maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Added function name types to allow us to set breakpoints by name more 

intelligently. The four name types we currently have are:

eFunctionNameTypeFull       = (1 << 1), // The function name.
                                        // For C this is the same as just the name of the function
                                        // For C++ this is the demangled version of the mangled name.
                                        // For ObjC this is the full function signature with the + or
                                        // - and the square brackets and the class and selector
eFunctionNameTypeBase       = (1 << 2), // The function name only, no namespaces or arguments and no class 
                                        // methods or selectors will be searched.
eFunctionNameTypeMethod     = (1 << 3), // Find function by method name (C++) with no namespace or arguments
eFunctionNameTypeSelector   = (1 << 4)  // Find function by selector name (ObjC) names


this allows much more flexibility when setting breakoints:

(lldb) breakpoint set --name main --basename
(lldb) breakpoint set --name main --fullname
(lldb) breakpoint set --name main --method
(lldb) breakpoint set --name main --selector

The default:

(lldb) breakpoint set --name main

will inspect the name "main" and look for any parens, or if the name starts
with "-[" or "+[" and if any are found then a full name search will happen.
Else a basename search will be the default.

Fixed some command option structures so not all options are required when they
shouldn't be.

Cleaned up the breakpoint output summary.

Made the "image lookup --address <addr>" output much more verbose so it shows
all the important symbol context results. Added a GetDescription method to 
many of the SymbolContext objects for the more verbose output.

llvm-svn: 107075
This commit is contained in:
Greg Clayton 2010-06-28 21:30:43 +00:00
parent e697a6f24f
commit 0c5cd90d63
54 changed files with 718 additions and 270 deletions

14
lldb/include/lldb/Breakpoint/BreakpointResolverName.h
View File

@ -30,17 +30,18 @@ class BreakpointResolverName:
public:
BreakpointResolverName (Breakpoint *bkpt,
const char *func_name,
Breakpoint::MatchType type = Breakpoint::Exact);
const char *name,
uint32_t name_type_mask,
Breakpoint::MatchType type);
// Creates a function breakpoint by regular expression. Takes over control of the lifespan of func_regex.
BreakpointResolverName (Breakpoint *bkpt,
RegularExpression &func_regex);
RegularExpression &func_regex);
BreakpointResolverName (Breakpoint *bkpt,
const char *class_name,
const char *method,
Breakpoint::MatchType type);
const char *class_name,
const char *method,
Breakpoint::MatchType type);
virtual
~BreakpointResolverName ();
@ -62,6 +63,7 @@ public:
protected:
ConstString m_func_name;
uint32_t m_func_name_type_mask; // See FunctionNameType
ConstString m_class_name; // FIXME: Not used yet. The idea would be to stop on methods of this class.
RegularExpression m_regex;
Breakpoint::MatchType m_match_type;

8
lldb/include/lldb/Core/Module.h
View File

@ -157,6 +157,12 @@ public:
/// @param[in] name
/// The name of the function we are looking for.
///
/// @param[in] name_type_mask
/// A bit mask of bits that indicate what kind of names should
/// be used when doing the lookup. Bits include fully qualified
/// names, base names, C++ methods, or ObjC selectors.
/// See FunctionNameType for more details.
///
/// @param[in] append
/// If \b true, any matches will be appended to \a
/// variable_list, else matches replace the contents of
@ -170,7 +176,7 @@ public:
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
uint32_t
FindFunctions (const ConstString &name, bool append, SymbolContextList& sc_list);
FindFunctions (const ConstString &name, uint32_t name_type_mask, bool append, SymbolContextList& sc_list);
//------------------------------------------------------------------
/// Find functions by name.

7
lldb/include/lldb/Core/ModuleList.h
View File

@ -144,6 +144,12 @@ public:
/// @param[in] name
/// The name of the function we are looking for.
///
/// @param[in] name_type_mask
/// A bit mask of bits that indicate what kind of names should
/// be used when doing the lookup. Bits include fully qualified
/// names, base names, C++ methods, or ObjC selectors.
/// See FunctionNameType for more details.
///
/// @param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
@ -153,6 +159,7 @@ public:
//------------------------------------------------------------------
size_t
FindFunctions (const ConstString &name,
uint32_t name_type_mask,
SymbolContextList &sc_list);
//------------------------------------------------------------------

2
lldb/include/lldb/Core/VMRange.h
View File

@ -112,7 +112,7 @@ public:
}
void
Dump(Stream *s, lldb::addr_t base_addr = 0) const;
Dump (Stream *s, lldb::addr_t base_addr = 0, uint32_t addr_width = 8) const;
class ValueInRangeUnaryPredicate
{

36
lldb/include/lldb/Symbol/Block.h
View File

@ -213,6 +213,11 @@ public:
virtual void
DumpSymbolContext(Stream *s);
void
GetDescription (Stream *s,
lldb::DescriptionLevel level,
Process *process) const;
//------------------------------------------------------------------
/// Get the parent block's UID.
///
@ -243,6 +248,37 @@ public:
lldb::user_id_t
GetFirstChildUID () const;
//------------------------------------------------------------------
/// Get the parent block.
///
/// @return
/// The parent block pointer, or NULL if this block has no
/// parent.
//------------------------------------------------------------------
Block *
GetParent () const;
//------------------------------------------------------------------
/// Get the sibling block.
///
/// @return
/// The sibling block pointer, or NULL if this block has no
/// sibling.
//------------------------------------------------------------------
Block *
GetSibling () const;
//------------------------------------------------------------------
/// Get the first child block.
///
/// @return
/// The first child block pointer, or NULL if this block has no
/// children.
//------------------------------------------------------------------
Block *
GetFirstChild () const;
//------------------------------------------------------------------
/// Get the variable list for this block and optionally all child
/// blocks if \a get_child_variables is \b true.

4
lldb/include/lldb/Symbol/CompileUnit.h
View File

@ -135,6 +135,10 @@ public:
virtual void
DumpSymbolContext(Stream *s);
void
GetDescription(Stream *s, lldb::DescriptionLevel level) const;
//------------------------------------------------------------------
/// Get a shared pointer to a function in this compile unit by
/// index.

3
lldb/include/lldb/Symbol/Function.h
View File

@ -451,6 +451,9 @@ public:
const CompileUnit*
GetCompileUnit() const;
void
GetDescription(Stream *s, lldb::DescriptionLevel level, Process *process);
//------------------------------------------------------------------
/// Get accessor for the frame base location.
///

8
lldb/include/lldb/Symbol/LineEntry.h
View File

@ -87,8 +87,12 @@ struct LineEntry
Dump (Stream *s, Process *process, bool show_file, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_range) const;
bool
GetDescription (Stream *s, lldb::DescriptionLevel level, CompileUnit* cu, Process *process) const;
GetDescription (Stream *s,
lldb::DescriptionLevel level,
CompileUnit* cu,
Process *process,
bool show_address_only) const;
//------------------------------------------------------------------
/// Dumps information specific to a process that stops at this
/// line entry to the supplied stream \a s.

3
lldb/include/lldb/Symbol/Symbol.h
View File

@ -106,6 +106,9 @@ public:
void
SetFlags (uint32_t flags) { m_flags = flags; }
void
GetDescription (Stream *s, lldb::DescriptionLevel level, Process *process) const;
Function *
GetFunction ();

6
lldb/include/lldb/Symbol/SymbolContext.h
View File

@ -184,6 +184,12 @@ public:
bool
GetAddressRange (uint32_t scope, AddressRange &range) const;
void
GetDescription(Stream *s,
lldb::DescriptionLevel level,
Process *process) const;
//------------------------------------------------------------------
/// Find a function matching the given name, working out from this
/// symbol context.

2
lldb/include/lldb/Symbol/SymbolFile.h
View File

@ -75,7 +75,7 @@ public:
virtual uint32_t ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) = 0;
virtual uint32_t FindGlobalVariables (const ConstString &name, bool append, uint32_t max_matches, VariableList& variables) = 0;
virtual uint32_t FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables) = 0;
virtual uint32_t FindFunctions (const ConstString &name, bool append, SymbolContextList& sc_list) = 0;
virtual uint32_t FindFunctions (const ConstString &name, uint32_t name_type_mask, bool append, SymbolContextList& sc_list) = 0;
virtual uint32_t FindFunctions (const RegularExpression& regex, bool append, SymbolContextList& sc_list) = 0;
// virtual uint32_t FindTypes (const SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types) = 0;
// virtual uint32_t FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types) = 0;

1
lldb/include/lldb/Symbol/SymbolVendor.h
View File

@ -110,6 +110,7 @@ public:
virtual uint32_t
FindFunctions(const ConstString &name,
uint32_t name_type_mask,
bool append,
SymbolContextList& sc_list);

4
lldb/include/lldb/Symbol/Type.h
View File

@ -58,6 +58,10 @@ public:
void
DumpTypeName(Stream *s);
void
GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name);
SymbolFile *
GetSymbolFile()
{

1
lldb/include/lldb/Target/Target.h
View File

@ -138,6 +138,7 @@ public:
lldb::BreakpointSP
CreateBreakpoint (FileSpec *containingModule,
const char *func_name,
uint32_t func_name_type_mask,
bool internal = false);
// Use this to create a general breakpoint:

14
lldb/include/lldb/lldb-enumerations.h
View File

@ -390,6 +390,20 @@ typedef enum ArchitectureType
kNumArchTypes
} ArchitectureType;
typedef enum FunctionNameType
{
eFunctionNameTypeNone = 0,
eFunctionNameTypeFull = (1 << 1), // The function name.
// For C this is the same as just the name of the function
// For C++ this is the demangled version of the mangled name.
// For ObjC this is the full function signature with the + or
// - and the square brackets and the class and selector
eFunctionNameTypeBase = (1 << 2), // The function name only, no namespaces or arguments and no class
// methods or selectors will be searched.
eFunctionNameTypeMethod = (1 << 3), // Find function by method name (C++) with no namespace or arguments
eFunctionNameTypeSelector = (1 << 4) // Find function by selector name (ObjC) names
} FunctionNameType;
} // namespace lldb

8
lldb/lldb.xcodeproj/project.pbxproj
View File

@ -1621,6 +1621,8 @@
26BC7E9310F1B85900F91463 /* StreamString.cpp */,
9A35765E116E76A700E8ED2F /* StringList.h */,
9A35765F116E76B900E8ED2F /* StringList.cpp */,
26B167A41123BF5500DC7B4F /* ThreadSafeValue.h */,
263FEDA5112CC1DA00E4C208 /* ThreadSafeSTLMap.h */,
26BC7D7E10F1B77400F91463 /* Timer.h */,
26BC7E9610F1B85900F91463 /* Timer.cpp */,
26BC7D7F10F1B77400F91463 /* TTYState.h */,
@ -1628,6 +1630,8 @@
268A813F115B19D000F645B0 /* UniqueCStringMap.h */,
26BC7D8010F1B77400F91463 /* UserID.h */,
26BC7E9810F1B85900F91463 /* UserID.cpp */,
26C81CA411335651004BDC5A /* UUID.h */,
26C81CA511335651004BDC5A /* UUID.cpp */,
26BC7D8110F1B77400F91463 /* Value.h */,
26BC7E9910F1B85900F91463 /* Value.cpp */,
26BC7D8210F1B77400F91463 /* ValueObject.h */,
@ -1642,10 +1646,6 @@
26BC7E9D10F1B85900F91463 /* ValueObjectVariable.cpp */,
26BC7D8610F1B77400F91463 /* VMRange.h */,
26BC7E9E10F1B85900F91463 /* VMRange.cpp */,
26B167A41123BF5500DC7B4F /* ThreadSafeValue.h */,
263FEDA5112CC1DA00E4C208 /* ThreadSafeSTLMap.h */,
26C81CA411335651004BDC5A /* UUID.h */,
26C81CA511335651004BDC5A /* UUID.cpp */,
);
name = Core;
sourceTree = "<group>";

21
lldb/source/Breakpoint/Breakpoint.cpp
View File

@ -349,17 +349,9 @@ void
Breakpoint::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_locations)
{
assert (s != NULL);
StreamString filter_strm;
s->Printf("%i ", GetID());
s->Printf("%i: ", GetID());
GetResolverDescription (s);
GetFilterDescription (&filter_strm);
if (filter_strm.GetString().compare ("No Filter") != 0)
{
s->Printf (", ");
GetFilterDescription (s);
}
GetFilterDescription (s);
const uint32_t num_locations = GetNumLocations ();
const uint32_t num_resolved_locations = GetNumResolvedLocations ();
@ -370,14 +362,13 @@ Breakpoint::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_l
case lldb::eDescriptionLevelFull:
if (num_locations > 0)
{
s->Printf(" with %u location%s", num_locations, num_locations > 1 ? "s" : "");
s->Printf(", locations = %u", num_locations);
if (num_resolved_locations > 0)
s->Printf(" (%u resolved)", num_resolved_locations);
s->PutChar(';');
s->Printf(", resolved = %u", num_resolved_locations);
}
else
{
s->Printf(" with 0 locations (Pending Breakpoint).");
s->Printf(", locations = 0 (pending)");
}
GetOptions()->GetDescription(s, level);
@ -400,7 +391,6 @@ Breakpoint::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_l
if (show_locations)
{
s->EOL();
s->IndentMore();
for (int i = 0; i < GetNumLocations(); ++i)
{
@ -409,7 +399,6 @@ Breakpoint::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_l
s->EOL();
}
s->IndentLess();
}
}

10
lldb/source/Breakpoint/BreakpointOptions.cpp
View File

@ -234,10 +234,7 @@ BreakpointOptions::GetDescription (Stream *s, lldb::DescriptionLevel level) cons
if (level != eDescriptionLevelBrief)
s->EOL();
m_callback_baton_sp->GetDescription (s, level);
}
else if (level == eDescriptionLevelBrief)
s->PutCString ("commands: no ");
}
}
void
@ -247,10 +244,7 @@ BreakpointOptions::CommandBaton::GetDescription (Stream *s, lldb::DescriptionLev
if (level == eDescriptionLevelBrief)
{
if (data && data->user_source.GetSize() > 0)
s->PutCString("commands: yes ");
else
s->PutCString("commands: no ");
s->Printf (", commands = %s", (data && data->user_source.GetSize() > 0) ? "yes" : "no");
return;
}

2
lldb/source/Breakpoint/BreakpointResolverAddress.cpp
View File

@ -100,7 +100,7 @@ BreakpointResolverAddress::GetDepth()
void
BreakpointResolverAddress::GetDescription (Stream *s)
{
s->PutCString ("Address breakpoint: ");
s->PutCString ("address = ");
m_addr.Dump(s, m_breakpoint->GetTarget().GetProcessSP().get(), Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
}

2
lldb/source/Breakpoint/BreakpointResolverFileLine.cpp
View File

@ -111,7 +111,7 @@ BreakpointResolverFileLine::GetDepth()
void
BreakpointResolverFileLine::GetDescription (Stream *s)
{
s->Printf ("File and line breakpoint - file: \"%s\" line: %u", m_file_spec.GetFilename().AsCString(), m_line_number);
s->Printf ("file ='%s', line = %u", m_file_spec.GetFilename().AsCString(), m_line_number);
}
void

72
lldb/source/Breakpoint/BreakpointResolverName.cpp
View File

@ -25,11 +25,13 @@ BreakpointResolverName::BreakpointResolverName
(
Breakpoint *bkpt,
const char *func_name,
uint32_t func_name_type_mask,
Breakpoint::MatchType type
) :
BreakpointResolver (bkpt),
m_func_name (func_name),
m_class_name (NULL),
m_func_name_type_mask (func_name_type_mask),
m_class_name (),
m_regex (),
m_match_type (type)
{
@ -94,45 +96,47 @@ BreakpointResolverName::SearchCallback
{
SymbolContextList func_list;
SymbolContextList sym_list;
bool skip_prologue = true;
uint32_t i;
bool new_location;
SymbolContext sc;
Address break_addr;
assert (m_breakpoint != NULL);
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
if (m_class_name)
{
if (log)
log->Warning ("Class/method function specification not supported yet.\n");
return Searcher::eCallbackReturnStop;
}
switch (m_match_type)
{
case Breakpoint::Exact:
if (context.module_sp)
{
context.module_sp->FindSymbolsWithNameAndType (m_func_name, eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions (m_func_name, false, func_list);
}
break;
case Breakpoint::Regexp:
if (context.module_sp)
{
context.module_sp->FindSymbolsMatchingRegExAndType (m_regex, eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions (m_regex, true, func_list);
}
break;
case Breakpoint::Glob:
if (log)
log->Warning ("glob is not supported yet.");
break;
case Breakpoint::Exact:
if (context.module_sp)
{
if (m_func_name_type_mask & (eFunctionNameTypeBase | eFunctionNameTypeFull))
context.module_sp->FindSymbolsWithNameAndType (m_func_name, eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions (m_func_name, m_func_name_type_mask, false, func_list);
}
break;
case Breakpoint::Regexp:
if (context.module_sp)
{
if (m_func_name_type_mask & (eFunctionNameTypeBase | eFunctionNameTypeFull))
context.module_sp->FindSymbolsMatchingRegExAndType (m_regex, eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions (m_regex, true, func_list);
}
break;
case Breakpoint::Glob:
if (log)
log->Warning ("glob is not supported yet.");
break;
}
// Remove any duplicates between the funcion list and the symbol list
if (func_list.GetSize())
{
@ -140,7 +144,7 @@ BreakpointResolverName::SearchCallback
{
if (func_list.GetContextAtIndex(i, sc) == false)
continue;
if (sc.function == NULL)
continue;
uint32_t j = 0;
@ -158,11 +162,11 @@ BreakpointResolverName::SearchCallback
}
}
}
j++;
}
}
for (i = 0; i < func_list.GetSize(); i++)
{
if (func_list.GetContextAtIndex(i, sc))
@ -176,7 +180,7 @@ BreakpointResolverName::SearchCallback
if (prologue_byte_size)
break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
}
if (filter.AddressPasses(break_addr))
{
BreakpointLocationSP bp_loc_sp (m_breakpoint->AddLocation(break_addr, &new_location));
@ -194,7 +198,7 @@ BreakpointResolverName::SearchCallback
}
}
}
for (i = 0; i < sym_list.GetSize(); i++)
{
if (sym_list.GetContextAtIndex(i, sc))
@ -202,14 +206,14 @@ BreakpointResolverName::SearchCallback
if (sc.symbol && sc.symbol->GetAddressRangePtr())
{
break_addr = sc.symbol->GetAddressRangePtr()->GetBaseAddress();
if (skip_prologue)
{
const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize();
if (prologue_byte_size)
break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
}
if (filter.AddressPasses(break_addr))
{
BreakpointLocationSP bp_loc_sp (m_breakpoint->AddLocation(break_addr, &new_location));
@ -236,12 +240,10 @@ BreakpointResolverName::GetDepth()
void
BreakpointResolverName::GetDescription (Stream *s)
{
s->PutCString("Breakpoint by name: ");
if (m_match_type == Breakpoint::Regexp)
s->Printf("'%s' (regular expression)", m_regex.GetText());
s->Printf("regex = '%s'", m_regex.GetText());
else
s->Printf("'%s'", m_func_name.AsCString());
s->Printf("name = '%s'", m_func_name.AsCString());
}
void

115
lldb/source/Commands/CommandObjectBreakpoint.cpp
View File

@ -52,6 +52,7 @@ CommandObjectBreakpointSet::CommandOptions::CommandOptions() :
m_column (0),
m_ignore_inlines (false),
m_func_name (),
m_func_name_type_mask (0),
m_func_regexp (),
m_modules (),
m_load_addr(),
@ -70,31 +71,28 @@ CommandObjectBreakpointSet::CommandOptions::~CommandOptions ()
lldb::OptionDefinition
CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, false, "shlib", 's', required_argument, NULL, CommandCompletions::eModuleCompletion, "<shlib-name>",
{ LLDB_OPT_SET_ALL, false, "shlib", 's', required_argument, NULL, CommandCompletions::eModuleCompletion, "<shlib-name>",
"Set the breakpoint only in this shared library (can use this option multiple times for multiple shlibs)."},
{ LLDB_OPT_SET_ALL, false, "ignore_inlines", 'i', no_argument, NULL, 0, NULL,
"Ignore inlined subroutines when setting the breakppoint." },
{ LLDB_OPT_SET_ALL, false, "ignore_count", 'k', required_argument, NULL, 0, NULL,
{ LLDB_OPT_SET_ALL, false, "ignore_count", 'k', required_argument, NULL, 0, "<n>",
"Set the number of times this breakpoint is sKipped before stopping." },
{ LLDB_OPT_SET_ALL, false, "thread_index", 'x', required_argument, NULL, NULL, "<thread_index>",
{ LLDB_OPT_SET_ALL, false, "thread_index", 'x', required_argument, NULL, NULL, "<thread_index>",
"The breakpoint stops only for the thread whose indeX matches this argument."},
{ LLDB_OPT_SET_ALL, false, "thread_id", 't', required_argument, NULL, NULL, "<thread_id>",
{ LLDB_OPT_SET_ALL, false, "thread_id", 't', required_argument, NULL, NULL, "<thread_id>",
"The breakpoint stops only for the thread whose TID matches this argument."},
{ LLDB_OPT_SET_ALL, false, "thread_name", 'T', required_argument, NULL, NULL, "<thread_name>",
{ LLDB_OPT_SET_ALL, false, "thread_name", 'T', required_argument, NULL, NULL, "<thread_name>",
"The breakpoint stops only for the thread whose thread name matches this argument."},
{ LLDB_OPT_SET_ALL, false, "queue_name", 'q', required_argument, NULL, NULL, "<queue_name>",
{ LLDB_OPT_SET_ALL, false, "queue_name", 'q', required_argument, NULL, NULL, "<queue_name>",
"The breakpoint stops only for threads in the queue whose name is given by this argument."},
{ LLDB_OPT_SET_1, false, "file", 'f', required_argument, NULL, CommandCompletions::eSourceFileCompletion, "<filename>",
{ LLDB_OPT_SET_1, false, "file", 'f', required_argument, NULL, CommandCompletions::eSourceFileCompletion, "<filename>",
"Set the breakpoint by source location in this particular file."},
{ LLDB_OPT_SET_1, true, "line", 'l', required_argument, NULL, 0, "<linenum>",
{ LLDB_OPT_SET_1, true, "line", 'l', required_argument, NULL, 0, "<linenum>",
"Set the breakpoint by source location at this particular line."},
// Comment out this option for the moment, as we don't actually use it, but will in the future.
@ -102,12 +100,24 @@ CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
// { 0, false, "column", 'c', required_argument, NULL, "<column>",
// "Set the breakpoint by source location at this particular column."},
{ LLDB_OPT_SET_2, true, "address", 'a', required_argument, NULL, 0, "<address>",
{ LLDB_OPT_SET_2, true, "address", 'a', required_argument, NULL, 0, "<address>",
"Set the breakpoint by address, at the specified address."},
{ LLDB_OPT_SET_3, true, "name", 'n', required_argument, NULL, CommandCompletions::eSymbolCompletion, "<function-name>",
{ LLDB_OPT_SET_3, true, "name", 'n', required_argument, NULL, CommandCompletions::eSymbolCompletion, "<name>",
"Set the breakpoint by function name." },
{ LLDB_OPT_SET_3, false, "basename", 'b', no_argument, NULL, 0, NULL,
"Used in conjuction with --name <name> to search function basenames." },
{ LLDB_OPT_SET_3, false, "fullname", 'F', no_argument, NULL, 0, NULL,
"Used in conjuction with --name <name> to search fully qualified function names. For C++ this means namespaces and all arguemnts, and for Objective C this means a full function prototype with class and selector." },
{ LLDB_OPT_SET_3, false, "selector", 'S', no_argument, NULL, 0, NULL,
"Used in conjuction with --name <name> to search objective C selector names." },
{ LLDB_OPT_SET_3, false, "method", 'm', no_argument, NULL, 0, NULL,
"Used in conjuction with --name <name> to search objective C selector C++ method names." },
{ LLDB_OPT_SET_4, true, "func_regex", 'r', required_argument, NULL, 0, "<regular-expression>",
"Set the breakpoint by function name, evaluating a regular-expression to find the function name(s)." },
@ -140,21 +150,39 @@ CommandObjectBreakpointSet::CommandOptions::SetOptionValue (int option_idx, cons
case 'c':
m_column = Args::StringToUInt32 (option_arg, 0);
break;
case 'f':
m_filename = option_arg;
break;
case 'i':
m_ignore_inlines = true;
break;
case 'l':
m_line_num = Args::StringToUInt32 (option_arg, 0);
break;
case 'n':
m_func_name = option_arg;
break;
case 'b':
m_func_name_type_mask |= eFunctionNameTypeBase;
break;
case 'F':
m_func_name_type_mask |= eFunctionNameTypeFull;
break;
case 'S':
m_func_name_type_mask |= eFunctionNameTypeSelector;
break;
case 'm':
m_func_name_type_mask |= eFunctionNameTypeMethod;
break;
case 'r':
m_func_regexp = option_arg;
break;
case 's':
{
m_modules.push_back (std::string (option_arg));
@ -204,8 +232,8 @@ CommandObjectBreakpointSet::CommandOptions::ResetOptionValues ()
m_filename.clear();
m_line_num = 0;
m_column = 0;
m_ignore_inlines = false;
m_func_name.clear();
m_func_name_type_mask = 0;
m_func_regexp.clear();
m_load_addr = LLDB_INVALID_ADDRESS;
m_modules.clear();
@ -357,32 +385,50 @@ CommandObjectBreakpointSet::Execute
case eSetTypeAddress: // Breakpoint by address
bp = target->CreateBreakpoint (m_options.m_load_addr, false).get();
break;
case eSetTypeFunctionName: // Breakpoint by function name
if (use_module)
{
for (int i = 0; i < num_modules; ++i)
uint32_t name_type_mask = m_options.m_func_name_type_mask;
if (name_type_mask == 0)
{
module.SetFile(m_options.m_modules[i].c_str());
bp = target->CreateBreakpoint (&module, m_options.m_func_name.c_str()).get();
if (bp)
{
StreamString &output_stream = result.GetOutputStream();
output_stream.Printf ("Breakpoint created: ");
bp->GetDescription(&output_stream, lldb::eDescriptionLevelBrief);
output_stream.EOL();
result.SetStatus (eReturnStatusSuccessFinishResult);
}
if (m_options.m_func_name.find('(') != std::string::npos ||
m_options.m_func_name.find("-[") == 0 ||
m_options.m_func_name.find("+[") == 0)
name_type_mask |= eFunctionNameTypeFull;
else
name_type_mask |= eFunctionNameTypeBase;
}
if (use_module)
{
for (int i = 0; i < num_modules; ++i)
{
result.AppendErrorWithFormat("Breakpoint creation failed: No breakpoint created in module '%s'.\n",
m_options.m_modules[i].c_str());
result.SetStatus (eReturnStatusFailed);
module.SetFile(m_options.m_modules[i].c_str());
bp = target->CreateBreakpoint (&module, m_options.m_func_name.c_str(), name_type_mask, Breakpoint::Exact).get();
if (bp)
{
StreamString &output_stream = result.GetOutputStream();
output_stream.Printf ("Breakpoint created: ");
bp->GetDescription(&output_stream, lldb::eDescriptionLevelBrief);
output_stream.EOL();
result.SetStatus (eReturnStatusSuccessFinishResult);
}
else
{
result.AppendErrorWithFormat("Breakpoint creation failed: No breakpoint created in module '%s'.\n",
m_options.m_modules[i].c_str());
result.SetStatus (eReturnStatusFailed);
}
}
}
else
bp = target->CreateBreakpoint (NULL, m_options.m_func_name.c_str(), name_type_mask, Breakpoint::Exact).get();
}
else
bp = target->CreateBreakpoint (NULL, m_options.m_func_name.c_str()).get();
break;
case eSetTypeFunctionRegexp: // Breakpoint by regular expression function name
{
RegularExpression regexp(m_options.m_func_regexp.c_str());
@ -412,6 +458,7 @@ CommandObjectBreakpointSet::Execute
bp = target->CreateBreakpoint (NULL, regexp).get();
}
break;
default:
break;
}

5
lldb/source/Commands/CommandObjectBreakpoint.h
View File

@ -98,10 +98,11 @@ public:
// Instance variables to hold the values for command options.
std::string m_filename;
unsigned int m_line_num;
unsigned int m_column;
uint32_t m_line_num;
uint32_t m_column;
bool m_ignore_inlines;
std::string m_func_name;
uint32_t m_func_name_type_mask;
std::string m_func_regexp;
lldb::addr_t m_load_addr;
STLStringArray m_modules;

2
lldb/source/Commands/CommandObjectCall.cpp
View File

@ -295,7 +295,7 @@ CommandObjectCall::Execute
lldb::OptionDefinition
CommandObjectCall::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, true, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."},
{ LLDB_OPT_SET_1, false, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."},
{ LLDB_OPT_SET_1, false, "format", 'f', required_argument, NULL, 0, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]", "Specify the format that the expression output should use."},
{ LLDB_OPT_SET_1, false, "debug", 'g', no_argument, NULL, 0, NULL, "Enable verbose debug logging of the expression parsing and evaluation."},
{ LLDB_OPT_SET_1, false, "noexecute", 'n', no_argument, NULL, 0, "no execute", "Only JIT and copy the wrapper & arguments, but don't execute."},

4
lldb/source/Commands/CommandObjectDisassemble.cpp
View File

@ -389,7 +389,9 @@ CommandObjectDisassemble::Execute
{
SymbolContextList sc_list;
if (target->GetImages().FindFunctions(name, sc_list))
if (target->GetImages().FindFunctions(name,
eFunctionNameTypeBase | eFunctionNameTypeFull | eFunctionNameTypeMethod | eFunctionNameTypeSelector,
sc_list))
{
Disassemble (interpreter, result, disassembler, sc_list);
}

2
lldb/source/Commands/CommandObjectExpression.cpp
View File

@ -456,7 +456,7 @@ CommandObjectExpression::ExecuteRawCommandString
lldb::OptionDefinition
CommandObjectExpression::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_ALL, true, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."},
{ LLDB_OPT_SET_ALL, false, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."},
{ LLDB_OPT_SET_ALL, false, "format", 'f', required_argument, NULL, 0, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]", "Specify the format that the expression output should use."},
{ LLDB_OPT_SET_ALL, false, "debug", 'g', no_argument, NULL, 0, NULL, "Enable verbose debug logging of the expression parsing and evaluation."},
{ LLDB_OPT_SET_ALL, false, "use-ir", 'i', no_argument, NULL, 0, NULL, "[Temporary] Instructs the expression evaluator to use IR instead of ASTs."},

9
lldb/source/Commands/CommandObjectImage.cpp
View File

@ -227,9 +227,12 @@ LookupAddressInModule (CommandInterpreter &interpreter, Stream &strm, Module *mo
strm.Printf("0x%llx: ", addr);
ExecutionContextScope *exe_scope = interpreter.GetDebugger().GetExecutionContext().GetBestExecutionContextScope();
if (so_addr.Dump (&strm, exe_scope, Address::DumpStyleSectionNameOffset))
strm.PutCString(": ");
strm.IndentMore();
strm.Indent (" Address: ");
so_addr.Dump (&strm, exe_scope, Address::DumpStyleSectionNameOffset);
strm.EOL();
so_addr.Dump (&strm, exe_scope, Address::DumpStyleResolvedDescription);
strm.IndentLess();
return true;
}
@ -347,7 +350,7 @@ LookupFunctionInModule (CommandInterpreter &interpreter, Stream &strm, Module *m
else
{
ConstString function_name(name);
num_matches = symbol_vendor->FindFunctions(function_name, true, sc_list);
num_matches = symbol_vendor->FindFunctions(function_name, eFunctionNameTypeBase | eFunctionNameTypeFull | eFunctionNameTypeMethod | eFunctionNameTypeSelector, true, sc_list);
}
if (num_matches)

10
lldb/source/Commands/CommandObjectThread.cpp
View File

@ -619,8 +619,8 @@ g_duo_running_mode[] =
lldb::OptionDefinition
CommandObjectThreadStepWithTypeAndScope::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, true, "avoid_no_debug", 'a', required_argument, NULL, 0, "<avoid_no_debug>", "Should step-in step over functions with no debug information"},
{ LLDB_OPT_SET_1, true, "run_mode", 'm', required_argument, g_tri_running_mode, 0, "<run_mode>", "Determine how to run other threads while stepping this one"},
{ LLDB_OPT_SET_1, false, "avoid_no_debug", 'a', required_argument, NULL, 0, "<avoid_no_debug>", "Should step-in step over functions with no debug information"},
{ LLDB_OPT_SET_1, false, "run_mode", 'm', required_argument, g_tri_running_mode, 0, "<run_mode>", "Determine how to run other threads while stepping this one"},
{ 0, false, NULL, 0, 0, NULL, 0, NULL, NULL }
};
@ -1060,9 +1060,9 @@ protected:
lldb::OptionDefinition
CommandObjectThreadUntil::CommandOptions::g_option_table[] =
{
{ LLDB_OPT_SET_1, true, "frame", 'f', required_argument, NULL, 0, "<frame>", "Frame index for until operation - defaults to 0"},
{ LLDB_OPT_SET_1, true, "thread", 't', required_argument, NULL, 0, "<thread>", "Thread index for the thread for until operation"},
{ LLDB_OPT_SET_1, true, "run_mode", 'm', required_argument, g_duo_running_mode, 0, "<run_mode>", "Determine how to run other threads while stepping this one"},
{ LLDB_OPT_SET_1, false, "frame", 'f', required_argument, NULL, 0, "<frame>", "Frame index for until operation - defaults to 0"},
{ LLDB_OPT_SET_1, false, "thread", 't', required_argument, NULL, 0, "<thread>", "Thread index for the thread for until operation"},
{ LLDB_OPT_SET_1, false, "run_mode",'m', required_argument, g_duo_running_mode, 0, "<run_mode>","Determine how to run other threads while stepping this one"},
{ 0, false, NULL, 0, 0, NULL, 0, NULL, NULL }
};

3
lldb/source/Core/Address.cpp
View File

@ -629,7 +629,10 @@ Address::Dump (Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, Dum
{
// We have a function or a symbol from the same
// sections as this address.
s->Indent(" Summary: ");
sc.DumpStopContext(s, process, *this, false);
s->EOL();
sc.GetDescription(s, eDescriptionLevelBrief, process);
}
else
{

17
lldb/source/Core/AddressResolverName.cpp
View File

@ -107,15 +107,24 @@ AddressResolverName::SearchCallback
case AddressResolver::Exact:
if (context.module_sp)
{
context.module_sp->FindSymbolsWithNameAndType (m_func_name, eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions (m_func_name, false, func_list);
context.module_sp->FindSymbolsWithNameAndType (m_func_name,
eSymbolTypeCode,
sym_list);
context.module_sp->FindFunctions (m_func_name,
eFunctionNameTypeBase | eFunctionNameTypeFull | eFunctionNameTypeMethod | eFunctionNameTypeSelector,
false,
func_list);
}
break;
case AddressResolver::Regexp:
if (context.module_sp)
{
context.module_sp->FindSymbolsMatchingRegExAndType (m_regex, eSymbolTypeCode, sym_list);
context.module_sp->FindFunctions (m_regex, true, func_list);
context.module_sp->FindSymbolsMatchingRegExAndType (m_regex,
eSymbolTypeCode,
sym_list);
context.module_sp->FindFunctions (m_regex,
true,
func_list);
}
break;
case AddressResolver::Glob:

4
lldb/source/Core/Module.cpp
View File

@ -286,11 +286,11 @@ Module::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_
}
uint32_t
Module::FindFunctions(const ConstString &name, bool append, SymbolContextList& sc_list)
Module::FindFunctions(const ConstString &name, uint32_t name_type_mask, bool append, SymbolContextList& sc_list)
{
SymbolVendor *symbols = GetSymbolVendor ();
if (symbols)
return symbols->FindFunctions(name, append, sc_list);
return symbols->FindFunctions(name, name_type_mask, append, sc_list);
return 0;
}

4
lldb/source/Core/ModuleList.cpp
View File

@ -126,14 +126,14 @@ ModuleList::GetModuleAtIndex(uint32_t idx)
}
size_t
ModuleList::FindFunctions (const ConstString &name, SymbolContextList &sc_list)
ModuleList::FindFunctions (const ConstString &name, uint32_t name_type_mask, SymbolContextList &sc_list)
{
sc_list.Clear();
Mutex::Locker locker(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos)
{
(*pos)->FindFunctions (name, true, sc_list);
(*pos)->FindFunctions (name, name_type_mask, true, sc_list);
}
return sc_list.GetSize();
}

3
lldb/source/Core/SearchFilter.cpp
View File

@ -113,7 +113,6 @@ SearchFilter::CompUnitPasses (CompileUnit &compUnit)
void
SearchFilter::GetDescription (Stream *s)
{
s->PutCString("No Filter");
}
void
@ -415,7 +414,7 @@ SearchFilterByModule::Search (Searcher &searcher)
void
SearchFilterByModule::GetDescription (Stream *s)
{
s->PutCString("In module ");
s->PutCString(", module = ");
if (s->GetVerbose())
{
char buffer[2048];

4
lldb/source/Core/VMRange.cpp
View File

@ -42,9 +42,9 @@ VMRange::ContainsRange(const VMRange::collection& coll, const VMRange& range)
void
VMRange::Dump(Stream *s, lldb::addr_t offset) const
VMRange::Dump(Stream *s, lldb::addr_t offset, uint32_t addr_width) const
{
s->AddressRange(offset + GetBaseAddress(), offset + GetEndAddress(), sizeof (addr_t));
s->AddressRange(offset + GetBaseAddress(), offset + GetEndAddress(), addr_width);
}
bool

70
lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp
View File

@ -14,6 +14,7 @@
#include "DWARFDebugAbbrev.h"
#include "DWARFDebugAranges.h"
#include "DWARFDebugInfo.h"
#include "DWARFDIECollection.h"
#include "DWARFFormValue.h"
#include "LogChannelDWARF.h"
@ -549,13 +550,14 @@ DWARFCompileUnit::AddGlobal (const DWARFDebugInfoEntry* die)
void
DWARFCompileUnit::Index
(
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_inlined_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_global_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_type_die
lldb_private::UniqueCStringMap<dw_offset_t>& base_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& full_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& method_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& selector_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_type_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_global_die
)
{
const DataExtractor* debug_str = &m_dwarf2Data->get_debug_str_data();
DWARFDebugInfoEntry::const_iterator pos;
@ -597,6 +599,7 @@ DWARFCompileUnit::Index
bool has_address = false;
bool has_location = false;
bool is_global_or_static_variable = false;
dw_offset_t specification_die_offset = DW_INVALID_OFFSET;
const size_t num_attributes = die.GetAttributes(m_dwarf2Data, this, attributes);
if (num_attributes > 0)
{
@ -685,6 +688,11 @@ DWARFCompileUnit::Index
}
}
break;
case DW_AT_specification:
if (attributes.ExtractFormValueAtIndex(m_dwarf2Data, i, form_value))
specification_die_offset = form_value.Reference(this);
break;
}
}
}
@ -694,7 +702,7 @@ DWARFCompileUnit::Index
case DW_TAG_subprogram:
if (has_address)
{
if (name && name[0])
if (name)
{
if ((name[0] == '-' || name[0] == '+') && name[1] == '[')
{
@ -716,24 +724,58 @@ DWARFCompileUnit::Index
// accelerator tables
size_t method_name_len = name_len - (method_name - name) - 1;
ConstString method_const_str (method_name, method_name_len);
name_to_function_die.Append(method_const_str.AsCString(), die.GetOffset());
selector_name_to_function_die.Append(method_const_str.AsCString(), die.GetOffset());
}
}
}
name_to_function_die.Append(ConstString(name).AsCString(), die.GetOffset());
// If we have a mangled name, then the DW_AT_name attribute
// is usually the method name without the class or any parameters
const DWARFDebugInfoEntry *parent = die.GetParent();
bool is_method = false;
if (parent)
{
dw_tag_t tag = parent->Tag();
if (tag == DW_TAG_class_type || tag == DW_TAG_structure_type)
{
is_method = true;
}
else
{
if (mangled && specification_die_offset != DW_INVALID_OFFSET)
{
const DWARFDebugInfoEntry *specification_die = m_dwarf2Data->DebugInfo()->GetDIEPtr (specification_die_offset, NULL);
if (specification_die)
{
parent = specification_die->GetParent();
if (parent)
{
tag = parent->Tag();
if (tag == DW_TAG_class_type || tag == DW_TAG_structure_type)
is_method = true;
}
}
}
}
}
if (is_method)
method_name_to_function_die.Append(ConstString(name).AsCString(), die.GetOffset());
else
base_name_to_function_die.Append(ConstString(name).AsCString(), die.GetOffset());
}
if (mangled && mangled[0])
name_to_function_die.Append(ConstString(mangled).AsCString(), die.GetOffset());
if (mangled)
full_name_to_function_die.Append(ConstString(mangled).AsCString(), die.GetOffset());
}
break;
case DW_TAG_inlined_subroutine:
if (has_address)
{
if (name && name[0])
name_to_inlined_die.Append(ConstString(name).AsCString(), die.GetOffset());
if (mangled && mangled[0])
name_to_inlined_die.Append(ConstString(mangled).AsCString(), die.GetOffset());
if (name)
base_name_to_function_die.Append(ConstString(name).AsCString(), die.GetOffset());
if (mangled)
full_name_to_function_die.Append(ConstString(mangled).AsCString(), die.GetOffset());
}
break;

11
lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h
View File

@ -142,10 +142,13 @@ public:
}
void
Index (lldb_private::UniqueCStringMap<dw_offset_t>& name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_inlined_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_global_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_type_die);
Index (lldb_private::UniqueCStringMap<dw_offset_t>& base_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& full_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& method_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& selector_name_to_function_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_type_die,
lldb_private::UniqueCStringMap<dw_offset_t>& name_to_global_die);
protected:
SymbolFileDWARF* m_dwarf2Data;

96
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
View File

@ -229,8 +229,10 @@ SymbolFileDWARF::SymbolFileDWARF(ObjectFile* ofile) :
m_aranges(),
m_info(),
m_line(),
m_name_to_function_die(),
m_name_to_inlined_die(),
m_base_name_to_function_die(),
m_full_name_to_function_die(),
m_method_name_to_function_die(),
m_selector_name_to_function_die(),
m_name_to_global_die(),
m_name_to_type_die(),
m_indexed(false),
@ -1778,8 +1780,10 @@ SymbolFileDWARF::Index ()
bool clear_dies = cu->ExtractDIEsIfNeeded (false) > 1;
cu->Index (m_name_to_function_die,
m_name_to_inlined_die,
cu->Index (m_base_name_to_function_die,
m_full_name_to_function_die,
m_method_name_to_function_die,
m_selector_name_to_function_die,
m_name_to_global_die,
m_name_to_type_die);
@ -1789,8 +1793,10 @@ SymbolFileDWARF::Index ()
cu->ClearDIEs (true);
}
m_name_to_function_die.Sort();
m_name_to_inlined_die.Sort();
m_base_name_to_function_die.Sort();
m_full_name_to_function_die.Sort();
m_method_name_to_function_die.Sort();
m_selector_name_to_function_die.Sort();
m_name_to_global_die.Sort();
m_name_to_type_die.Sort();
}
@ -1893,33 +1899,20 @@ SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append
}
uint32_t
SymbolFileDWARF::FindFunctions(const ConstString &name, bool append, SymbolContextList& sc_list)
void
SymbolFileDWARF::FindFunctions
(
const ConstString &name,
UniqueCStringMap<dw_offset_t> &name_to_die,
SymbolContextList& sc_list
)
{
Timer scoped_timer (__PRETTY_FUNCTION__,
"SymbolFileDWARF::FindFunctions (name = '%s')",
name.AsCString());
std::vector<dw_offset_t> die_offsets;
// If we aren't appending the results to this list, then clear the list
if (!append)
sc_list.Clear();
// Remember how many sc_list are in the list before we search in case
// we are appending the results to a variable list.
uint32_t original_size = sc_list.GetSize();
// Index the DWARF if we haven't already
if (!m_indexed)
Index ();
const UniqueCStringMap<dw_offset_t>::Entry *entry;
SymbolContext sc;
for (entry = m_name_to_function_die.FindFirstValueForName (name.AsCString());
for (entry = name_to_die.FindFirstValueForName (name.AsCString());
entry != NULL;
entry = m_name_to_function_die.FindNextValueForName (name.AsCString(), entry))
entry = name_to_die.FindNextValueForName (name.AsCString(), entry))
{
DWARFCompileUnitSP cu_sp;
const DWARFDebugInfoEntry* die = DebugInfo()->GetDIEPtr (entry->value, &cu_sp);
@ -1943,6 +1936,47 @@ SymbolFileDWARF::FindFunctions(const ConstString &name, bool append, SymbolConte
}
}
}
uint32_t
SymbolFileDWARF::FindFunctions
(
const ConstString &name,
uint32_t name_type_mask,
bool append,
SymbolContextList& sc_list
)
{
Timer scoped_timer (__PRETTY_FUNCTION__,
"SymbolFileDWARF::FindFunctions (name = '%s')",
name.AsCString());
std::vector<dw_offset_t> die_offsets;
// If we aren't appending the results to this list, then clear the list
if (!append)
sc_list.Clear();
// Remember how many sc_list are in the list before we search in case
// we are appending the results to a variable list.
uint32_t original_size = sc_list.GetSize();
// Index the DWARF if we haven't already
if (!m_indexed)
Index ();
if (name_type_mask & eFunctionNameTypeBase)
FindFunctions (name, m_base_name_to_function_die, sc_list);
if (name_type_mask & eFunctionNameTypeFull)
FindFunctions (name, m_full_name_to_function_die, sc_list);
if (name_type_mask & eFunctionNameTypeMethod)
FindFunctions (name, m_method_name_to_function_die, sc_list);
if (name_type_mask & eFunctionNameTypeSelector)
FindFunctions (name, m_selector_name_to_function_die, sc_list);
// Return the number of variable that were appended to the list
return sc_list.GetSize() - original_size;
}
@ -1971,14 +2005,14 @@ SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool append, Symb
// Create the pubnames information so we can quickly lookup external symbols by name
// Create the pubnames information so we can quickly lookup external symbols by name
const size_t num_entries = m_name_to_function_die.GetSize();
const size_t num_entries = m_full_name_to_function_die.GetSize();
SymbolContext sc;
for (size_t i=0; i<num_entries; i++)
{
if (!regex.Execute(m_name_to_function_die.GetCStringAtIndex (i)))
if (!regex.Execute(m_full_name_to_function_die.GetCStringAtIndex (i)))
continue;
const dw_offset_t die_offset = *m_name_to_function_die.GetValueAtIndex (i);
const dw_offset_t die_offset = *m_full_name_to_function_die.GetValueAtIndex (i);
DWARFCompileUnitSP cu_sp;
const DWARFDebugInfoEntry* die = DebugInfo()->GetDIEPtr (die_offset, &cu_sp);

13
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
View File

@ -97,7 +97,7 @@ public:
virtual uint32_t ResolveSymbolContext (const lldb_private::FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, lldb_private::SymbolContextList& sc_list);
virtual uint32_t FindGlobalVariables(const lldb_private::ConstString &name, bool append, uint32_t max_matches, lldb_private::VariableList& variables);
virtual uint32_t FindGlobalVariables(const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb_private::VariableList& variables);
virtual uint32_t FindFunctions(const lldb_private::ConstString &name, bool append, lldb_private::SymbolContextList& sc_list);
virtual uint32_t FindFunctions(const lldb_private::ConstString &name, uint32_t name_type_mask, bool append, lldb_private::SymbolContextList& sc_list);
virtual uint32_t FindFunctions(const lldb_private::RegularExpression& regex, bool append, lldb_private::SymbolContextList& sc_list);
// virtual uint32_t FindTypes(const lldb_private::SymbolContext& sc, const lldb_private::ConstString &name, bool append, uint32_t max_matches, lldb::Type::Encoding encoding, lldb::user_id_t udt_uid, lldb_private::TypeList& types);
// virtual uint32_t FindTypes(const lldb_private::SymbolContext& sc, const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb::Type::Encoding encoding, lldb::user_id_t udt_uid, lldb_private::TypeList& types);
@ -277,6 +277,11 @@ protected:
uint32_t& byte_stride,
uint32_t& bit_stride);
void FindFunctions(
const lldb_private::ConstString &name,
lldb_private::UniqueCStringMap<dw_offset_t> &name_to_die,
lldb_private::SymbolContextList& sc_list);
lldb_private::Type* GetUniquedTypeForDIEOffset(dw_offset_t type_die_offset, lldb::TypeSP& owning_type_sp, int32_t child_type, uint32_t idx, bool safe);
lldb::TypeSP GetTypeForDIE(DWARFCompileUnit *cu, const DWARFDebugInfoEntry* die, lldb::TypeSP& owning_type_sp, int32_t child_type, uint32_t idx);
// uint32_t FindTypes(std::vector<dw_offset_t> die_offsets, uint32_t max_matches, Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types);
@ -303,8 +308,10 @@ protected:
std::auto_ptr<DWARFDebugAranges> m_aranges;
std::auto_ptr<DWARFDebugInfo> m_info;
std::auto_ptr<DWARFDebugLine> m_line;
lldb_private::UniqueCStringMap<dw_offset_t> m_name_to_function_die; // All concrete functions
lldb_private::UniqueCStringMap<dw_offset_t> m_name_to_inlined_die; // All inlined functions
lldb_private::UniqueCStringMap<dw_offset_t> m_base_name_to_function_die; // All concrete functions
lldb_private::UniqueCStringMap<dw_offset_t> m_full_name_to_function_die; // All concrete functions
lldb_private::UniqueCStringMap<dw_offset_t> m_method_name_to_function_die; // All inlined functions
lldb_private::UniqueCStringMap<dw_offset_t> m_selector_name_to_function_die; // All method names for functions of classes
lldb_private::UniqueCStringMap<dw_offset_t> m_name_to_global_die; // Global and static variables
lldb_private::UniqueCStringMap<dw_offset_t> m_name_to_type_die; // All type DIE offsets
bool m_indexed;

4
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
View File

@ -763,7 +763,7 @@ SymbolFileDWARFDebugMap::GetCompileUnitInfoForSymbolWithIndex (uint32_t symbol_i
}
uint32_t
SymbolFileDWARFDebugMap::FindFunctions(const ConstString &name, bool append, SymbolContextList& sc_list)
SymbolFileDWARFDebugMap::FindFunctions(const ConstString &name, uint32_t name_type_mask, bool append, SymbolContextList& sc_list)
{
Timer scoped_timer (__PRETTY_FUNCTION__,
"SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
@ -788,7 +788,7 @@ SymbolFileDWARFDebugMap::FindFunctions(const ConstString &name, bool append, Sym
{
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex (oso_idx);
if (oso_dwarf)
oso_dwarf->FindFunctions(name, true, sc_list);
oso_dwarf->FindFunctions(name, name_type_mask, true, sc_list);
}
}
// Stream s(stdout);

2
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
View File

@ -64,7 +64,7 @@ public:
virtual uint32_t ResolveSymbolContext (const lldb_private::FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, lldb_private::SymbolContextList& sc_list);
virtual uint32_t FindGlobalVariables (const lldb_private::ConstString &name, bool append, uint32_t max_matches, lldb_private::VariableList& variables);
virtual uint32_t FindGlobalVariables (const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb_private::VariableList& variables);
virtual uint32_t FindFunctions (const lldb_private::ConstString &name, bool append, lldb_private::SymbolContextList& sc_list);
virtual uint32_t FindFunctions (const lldb_private::ConstString &name, uint32_t name_type_mask, bool append, lldb_private::SymbolContextList& sc_list);
virtual uint32_t FindFunctions (const lldb_private::RegularExpression& regex, bool append, lldb_private::SymbolContextList& sc_list);
// virtual uint32_t FindTypes (const lldb_private::SymbolContext& sc, const ConstString &name, bool append, uint32_t max_matches, Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types);
// virtual uint32_t FindTypes (const lldb_private::SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, Type::Encoding encoding, lldb::user_id_t udt_uid, TypeList& types);

2
lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
View File

@ -308,7 +308,7 @@ SymbolFileSymtab::FindGlobalVariables(const RegularExpression& regex, bool appen
}
uint32_t
SymbolFileSymtab::FindFunctions(const ConstString &name, bool append, SymbolContextList& sc_list)
SymbolFileSymtab::FindFunctions(const ConstString &name, uint32_t name_type_mask, bool append, SymbolContextList& sc_list)
{
Timer scoped_timer (__PRETTY_FUNCTION__,
"SymbolFileSymtab::FindFunctions (name = '%s')",

2
lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h
View File

@ -87,7 +87,7 @@ public:
FindGlobalVariables(const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb_private::VariableList& variables);
virtual uint32_t
FindFunctions(const lldb_private::ConstString &name, bool append, lldb_private::SymbolContextList& sc_list);
FindFunctions(const lldb_private::ConstString &name, uint32_t name_type_mask, bool append, lldb_private::SymbolContextList& sc_list);
virtual uint32_t
FindFunctions(const lldb_private::RegularExpression& regex, bool append, lldb_private::SymbolContextList& sc_list);

78
lldb/source/Symbol/Block.cpp
View File

@ -56,6 +56,30 @@ Block::~Block ()
{
}
void
Block::GetDescription(Stream *s, lldb::DescriptionLevel level, Process *process) const
{
size_t num_ranges = m_ranges.size();
if (num_ranges)
{
addr_t base_addr = LLDB_INVALID_ADDRESS;
if (process)
base_addr = m_block_list->GetAddressRange().GetBaseAddress().GetLoadAddress(process);
if (base_addr == LLDB_INVALID_ADDRESS)
base_addr = m_block_list->GetAddressRange().GetBaseAddress().GetFileAddress();
s->Printf("range%s = ", num_ranges > 1 ? "s" : "");
std::vector<VMRange>::const_iterator pos, end = m_ranges.end();
for (pos = m_ranges.begin(); pos != end; ++pos)
pos->Dump(s, base_addr, 4);
}
*s << ", id = " << ((const UserID&)*this);
if (m_inlineInfoSP.get() != NULL)
m_inlineInfoSP->Dump(s);
}
void
Block::Dump(Stream *s, addr_t base_addr, int32_t depth, bool show_context) const
{
@ -69,12 +93,10 @@ Block::Dump(Stream *s, addr_t base_addr, int32_t depth, bool show_context) const
s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
s->Indent();
*s << "Block" << ((const UserID&)*this);
user_id_t parentID = GetParentUID();
const Block* parent_block = NULL;
if (parentID != Block::InvalidID)
const Block* parent_block = GetParent();
if (parent_block)
{
parent_block = m_block_list->GetBlockByID(parentID);
s->Printf(", parent = {0x%8.8x}", parentID);
s->Printf(", parent = {0x%8.8x}", parent_block->GetID());
}
if (m_inlineInfoSP.get() != NULL)
m_inlineInfoSP->Dump(s);
@ -128,10 +150,7 @@ Block::CalculateSymbolContext(SymbolContext* sc)
void
Block::DumpStopContext (Stream *s, const SymbolContext *sc)
{
user_id_t parentID = GetParentUID();
Block* parent_block = NULL;
if (parentID != Block::InvalidID)
parent_block = m_block_list->GetBlockByID(parentID);
Block* parent_block = GetParent();
InlineFunctionInfo* inline_info = InlinedFunctionInfo ();
if (inline_info)
@ -256,6 +275,24 @@ Block::MemorySize() const
}
Block *
Block::GetParent () const
{
return m_block_list->GetBlockByID (m_block_list->GetParent(GetID()));
}
Block *
Block::GetSibling () const
{
return m_block_list->GetBlockByID (m_block_list->GetSibling(GetID()));
}
Block *
Block::GetFirstChild () const
{
return m_block_list->GetBlockByID (m_block_list->GetFirstChild(GetID()));
}
user_id_t
Block::GetParentUID() const
{
@ -455,7 +492,7 @@ BlockList::AddChild (user_id_t parentID, user_id_t childID)
const Block *
BlockList::GetBlockByID(user_id_t blockID) const
{
if (m_blocks.empty())
if (m_blocks.empty() || blockID == Block::InvalidID)
return NULL;
if (blockID == Block::RootID)
@ -471,7 +508,7 @@ BlockList::GetBlockByID(user_id_t blockID) const
Block *
BlockList::GetBlockByID(user_id_t blockID)
{
if (m_blocks.empty())
if (m_blocks.empty() || blockID == Block::InvalidID)
return NULL;
if (blockID == Block::RootID)
@ -584,16 +621,13 @@ Block::GetVariableList (bool get_child_variables, bool can_create)
if (get_child_variables)
{
user_id_t block_id = GetFirstChildUID();
while (block_id != Block::InvalidID)
Block *child_block = GetFirstChild();
while (child_block)
{
Block *child_block = m_block_list->GetBlockByID(block_id);
assert(child_block);
VariableListSP child_block_variable_list(child_block->GetVariableList(get_child_variables, can_create));
if (child_block_variable_list.get())
variable_list_sp->AddVariables(child_block_variable_list.get());
block_id = child_block->GetSiblingUID();
child_block = child_block->GetSibling();
}
}
}
@ -615,13 +649,9 @@ Block::AppendVariables (bool can_create, bool get_parent_variables, VariableList
if (get_parent_variables)
{
user_id_t parentID = GetParentUID();
if (parentID != Block::InvalidID)
{
Block* parent_block = m_block_list->GetBlockByID(parentID);
if (parent_block)
num_variables_added += parent_block->AppendVariables (can_create, get_parent_variables, variable_list);
}
Block* parent_block = GetParent();
if (parent_block)
num_variables_added += parent_block->AppendVariables (can_create, get_parent_variables, variable_list);
}
return num_variables_added;
}

7
lldb/source/Symbol/CompileUnit.cpp
View File

@ -65,6 +65,13 @@ CompileUnit::DumpSymbolContext(Stream *s)
}
void
CompileUnit::GetDescription(Stream *s, lldb::DescriptionLevel level) const
{
*s << '"' << (const FileSpec&)*this << "\", id = " << (const UserID&)*this
<< ", language = " << (const Language&)*this;
}
//----------------------------------------------------------------------
// Dump the current contents of this object. No functions that cause on

3
lldb/source/Symbol/Declaration.cpp
View File

@ -61,12 +61,11 @@ Declaration::Dump(Stream *s) const
{
if (m_file)
{
*s << ", decl = '" << m_file;
*s << ", decl = " << m_file;
if (m_line > 0)
s->Printf(":%u", m_line);
if (m_column > 0)
s->Printf(":%u", m_column);
s->PutChar('\'');
}
else
{

10
lldb/source/Symbol/Function.cpp
View File

@ -261,6 +261,16 @@ Function::GetCompileUnit() const
return m_comp_unit;
}
void
Function::GetDescription(Stream *s, lldb::DescriptionLevel level, Process *process)
{
Type* func_type = GetType();
*s << '"' << func_type->GetName() << "\", id = " << (const UserID&)*this;
*s << ", range = ";
GetAddressRange().Dump(s, process, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
}
void
Function::Dump(Stream *s, bool show_context) const
{

19
lldb/source/Symbol/LineEntry.cpp
View File

@ -118,14 +118,12 @@ LineEntry::Dump
fallback_style))
return false;
}
if (show_file)
*s << ", file = " << file;
if (line)
s->Printf(", line = %u", line);
if (column)
s->Printf(", column = %u", column);
if (show_file)
{
*s << ", file = " << file;
}
if (is_start_of_statement)
*s << ", is_start_of_statement = TRUE";
@ -144,13 +142,22 @@ LineEntry::Dump
}
bool
LineEntry::GetDescription (Stream *s, lldb::DescriptionLevel level, CompileUnit* cu, Process *process) const
LineEntry::GetDescription (Stream *s, lldb::DescriptionLevel level, CompileUnit* cu, Process *process, bool show_address_only) const
{
if (level == lldb::eDescriptionLevelBrief || level == lldb::eDescriptionLevelFull)
{
// Show address only
range.GetBaseAddress().Dump(s, process, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
if (show_address_only)
{
s->PutCString ("address = ");
range.GetBaseAddress().Dump(s, process, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
}
else
{
s->PutCString ("range = ");
range.Dump(s, process, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
}
if (file)
*s << ' ' << file;

2
lldb/source/Symbol/LineTable.cpp
View File

@ -324,7 +324,7 @@ LineTable::GetDescription (Stream *s, Process *process, DescriptionLevel level)
for (size_t idx = 0; idx < count; ++idx)
{
ConvertEntryAtIndexToLineEntry (idx, line_entry);
line_entry.GetDescription (s, level, m_comp_unit, process);
line_entry.GetDescription (s, level, m_comp_unit, process, true);
s->EOL();
}
}

20
lldb/source/Symbol/Symbol.cpp
View File

@ -167,6 +167,26 @@ Symbol::IsTrampoline () const
return m_type == eSymbolTypeTrampoline;
}
void
Symbol::GetDescription (Stream *s, lldb::DescriptionLevel level, Process *process) const
{
*s << '"' << m_mangled.GetName() << "\", id = " << (const UserID&)*this;
const Section *section = m_addr_range.GetBaseAddress().GetSection();
if (section != NULL)
{
if (m_addr_range.GetByteSize() > 0)
{
s->PutCString(", range = ");
m_addr_range.Dump(s, process, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
}
else
{
s->PutCString(", address = ");
m_addr_range.GetBaseAddress().Dump(s, process, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
}
}
}
void
Symbol::Dump(Stream *s, Process *process, uint32_t index) const
{

121
lldb/source/Symbol/SymbolContext.cpp
View File

@ -8,12 +8,13 @@
//===----------------------------------------------------------------------===//
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/Target.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Target/Target.h"
using namespace lldb;
using namespace lldb_private;
@ -168,6 +169,81 @@ SymbolContext::DumpStopContext
}
}
void
SymbolContext::GetDescription(Stream *s, lldb::DescriptionLevel level, Process *process) const
{
if (module_sp)
{
s->Indent(" Module: \"");
module_sp->GetFileSpec().Dump(s);
s->PutChar('"');
s->EOL();
}
if (comp_unit != NULL)
{
s->Indent("CompileUnit: ");
comp_unit->GetDescription (s, level);
s->EOL();
}
if (function != NULL)
{
s->Indent(" Function: ");
function->GetDescription (s, level, process);
s->EOL();
Type *func_type = function->GetType();
if (func_type)
{
s->Indent(" FuncType: ");
func_type->GetDescription (s, level, false);
s->EOL();
}
}
if (block != NULL)
{
std::vector<Block *> blocks;
blocks.push_back (block);
Block *parent_block = block->GetParent();
while (parent_block)
{
blocks.push_back (parent_block);
parent_block = parent_block->GetParent();
}
std::vector<Block *>::reverse_iterator pos;
std::vector<Block *>::reverse_iterator begin = blocks.rbegin();
std::vector<Block *>::reverse_iterator end = blocks.rend();
for (pos = begin; pos != end; ++pos)
{
if (pos == begin)
s->Indent(" Blocks: ");
else
s->Indent(" ");
(*pos)->GetDescription(s, level, process);
s->EOL();
}
}
if (line_entry.IsValid())
{
s->Indent(" LineEntry: ");
line_entry.GetDescription (s, level, comp_unit, process, false);
s->EOL();
}
if (symbol != NULL)
{
s->Indent(" Symbol: ");
symbol->GetDescription(s, level, process);
s->EOL();
}
}
void
SymbolContext::Dump(Stream *s, Process *process) const
{
@ -178,48 +254,45 @@ SymbolContext::Dump(Stream *s, Process *process) const
s->EOL();
s->IndentMore();
s->Indent();
*s << "Module = " << (void *)module_sp.get() << ' ';
*s << "Module = " << (void *)module_sp.get() << ' ';
if (module_sp)
module_sp->GetFileSpec().Dump(s);
s->EOL();
s->Indent();
*s << "CompileUnit = " << (void *)comp_unit;
if (comp_unit != NULL)
*s << " {" << comp_unit->GetID() << "} " << *(dynamic_cast<FileSpec*> (comp_unit));
*s << " {0x" << comp_unit->GetID() << "} " << *(dynamic_cast<FileSpec*> (comp_unit));
s->EOL();
s->Indent();
*s << "Function = " << (void *)function;
*s << "Function = " << (void *)function;
if (function != NULL)
{
*s << " {" << function->GetID() << "} ";/// << function->GetType()->GetName();
// Type* func_type = function->Type();
// if (func_type)
// {
// s->EOL();
// const UserDefType* func_udt = func_type->GetUserDefinedType().get();
// if (func_udt)
// {
// s->IndentMore();
// func_udt->Dump(s, func_type);
// s->IndentLess();
// }
// }
*s << " {0x" << function->GetID() << "} " << function->GetType()->GetName() << ", address-range = ";
function->GetAddressRange().Dump(s, process, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
s->EOL();
s->Indent();
Type* func_type = function->GetType();
if (func_type)
{
*s << " Type = ";
func_type->Dump (s, false);
}
}
s->EOL();
s->Indent();
*s << "Block = " << (void *)block;
*s << "Block = " << (void *)block;
if (block != NULL)
*s << " {" << block->GetID() << '}';
*s << " {0x" << block->GetID() << '}';
// Dump the block and pass it a negative depth to we print all the parent blocks
//if (block != NULL)
// block->Dump(s, function->GetFileAddress(), INT_MIN);
s->EOL();
s->Indent();
*s << "LineEntry = ";
*s << "LineEntry = ";
line_entry.Dump (s, process, true, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress, true);
s->EOL();
s->Indent();
*s << "Symbol = " << (void *)symbol;
*s << "Symbol = " << (void *)symbol;
if (symbol != NULL && symbol->GetMangled())
*s << ' ' << symbol->GetMangled().GetName().AsCString();
s->EOL();
@ -313,7 +386,7 @@ SymbolContext::FindFunctionByName (const char *name) const
if (module_sp != NULL)
{
SymbolContextList sc_matches;
if (module_sp->FindFunctions (name_const_str, false, sc_matches) > 0)
if (module_sp->FindFunctions (name_const_str, eFunctionNameTypeBase | eFunctionNameTypeFull, false, sc_matches) > 0)
{
SymbolContext sc;
sc_matches.GetContextAtIndex (0, sc);
@ -324,7 +397,7 @@ SymbolContext::FindFunctionByName (const char *name) const
if (target_sp)
{
SymbolContextList sc_matches;
if (target_sp->GetImages().FindFunctions (name_const_str, sc_matches) > 0)
if (target_sp->GetImages().FindFunctions (name_const_str, eFunctionNameTypeBase | eFunctionNameTypeFull, sc_matches) > 0)
{
SymbolContext sc;
sc_matches.GetContextAtIndex (0, sc);

4
lldb/source/Symbol/SymbolVendor.cpp
View File

@ -234,11 +234,11 @@ SymbolVendor::FindGlobalVariables (const RegularExpression& regex, bool append,
}
uint32_t
SymbolVendor::FindFunctions(const ConstString &name, bool append, SymbolContextList& sc_list)
SymbolVendor::FindFunctions(const ConstString &name, uint32_t name_type_mask, bool append, SymbolContextList& sc_list)
{
Mutex::Locker locker(m_mutex);
if (m_sym_file_ap.get())
return m_sym_file_ap->FindFunctions(name, append, sc_list);
return m_sym_file_ap->FindFunctions(name, name_type_mask, append, sc_list);
return 0;
}

89
lldb/source/Symbol/Type.cpp
View File

@ -96,6 +96,81 @@ lldb_private::Type::operator= (const Type& rhs)
}
void
lldb_private::Type::GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name)
{
if (show_name)
{
if (m_name)
*s << '\"' << m_name << "\", ";
}
*s << "id = " << (const UserID&)*this;
if (m_byte_size != 0)
s->Printf(", byte-size = %zu", m_byte_size);
m_decl.Dump(s);
clang::QualType qual_type(clang::QualType::getFromOpaquePtr(m_clang_qual_type));
if (qual_type.getTypePtr())
{
*s << ", type = ";
clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
clang::TagDecl *tag_decl = NULL;
if (tag_type)
tag_decl = tag_type->getDecl();
if (tag_decl)
{
s->EOL();
s->EOL();
tag_decl->print(llvm::fouts(), 0);
s->EOL();
}
else
{
const clang::TypedefType *typedef_type = qual_type->getAs<clang::TypedefType>();
if (typedef_type)
{
const clang::TypedefDecl *typedef_decl = typedef_type->getDecl();
std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString());
if (!clang_typedef_name.empty())
*s << ' ' << clang_typedef_name.c_str();
}
else
{
// We have a clang type, lets show it
clang::ASTContext *ast_context = GetClangAST();
if (ast_context)
{
std::string clang_type_name(qual_type.getAsString());
if (!clang_type_name.empty())
*s << ' ' << clang_type_name.c_str();
}
}
}
}
else if (m_encoding_uid != LLDB_INVALID_UID)
{
*s << ", type_uid = " << m_encoding_uid;
switch (m_encoding_uid_type)
{
case eIsTypeWithUID: s->PutCString(" (unresolved type)"); break;
case eIsConstTypeWithUID: s->PutCString(" (unresolved const type)"); break;
case eIsRestrictTypeWithUID: s->PutCString(" (unresolved restrict type)"); break;
case eIsVolatileTypeWithUID: s->PutCString(" (unresolved volatile type)"); break;
case eTypedefToTypeWithUID: s->PutCString(" (unresolved typedef)"); break;
case ePointerToTypeWithUID: s->PutCString(" (unresolved pointer)"); break;
case eLValueReferenceToTypeWithUID: s->PutCString(" (unresolved L value reference)"); break;
case eRValueReferenceToTypeWithUID: s->PutCString(" (unresolved R value reference)"); break;
}
}
}
void
lldb_private::Type::Dump (Stream *s, bool show_context)
{
@ -148,16 +223,12 @@ lldb_private::Type::Dump (Stream *s, bool show_context)
else
{
// We have a clang type, lets show it
TypeList *type_list = GetTypeList();
if (type_list)
clang::ASTContext *ast_context = GetClangAST();
if (ast_context)
{
clang::ASTContext *ast_context = GetClangAST();
if (ast_context)
{
std::string clang_type_name(qual_type.getAsString());
if (!clang_type_name.empty())
*s << " (" << clang_type_name.c_str() << ')';
}
std::string clang_type_name(qual_type.getAsString());
if (!clang_type_name.empty())
*s << " (" << clang_type_name.c_str() << ')';
}
}
}

13
lldb/source/Target/Target.cpp
View File

@ -179,11 +179,16 @@ Target::CreateBreakpoint (Address &addr, bool internal)
}
BreakpointSP
Target::CreateBreakpoint (FileSpec *containingModule, const char *func_name, bool internal)
Target::CreateBreakpoint (FileSpec *containingModule, const char *func_name, uint32_t func_name_type_mask, bool internal)
{
SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule));
BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, func_name));
return CreateBreakpoint (filter_sp, resolver_sp, internal);
BreakpointSP bp_sp;
if (func_name)
{
SearchFilterSP filter_sp(GetSearchFilterForModule (containingModule));
BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL, func_name, func_name_type_mask, Breakpoint::Exact));
bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal);
}
return bp_sp;
}

12
lldb/tools/driver/Driver.cpp
View File

@ -49,13 +49,13 @@ reset_stdin_termios ()
static lldb::OptionDefinition g_options[] =
{
{ LLDB_OPT_SET_1, true, "help", 'h', no_argument, NULL, NULL, NULL,
{ LLDB_OPT_SET_1, true, "help", 'h', no_argument, NULL, NULL, NULL,
"Prints out the usage information for the LLDB debugger." },
{ LLDB_OPT_SET_2, true, "version", 'v', no_argument, NULL, NULL, NULL,
{ LLDB_OPT_SET_2, true, "version", 'v', no_argument, NULL, NULL, NULL,
"Prints out the current version number of the LLDB debugger." },
{ LLDB_OPT_SET_3, false, "arch", 'a', required_argument, NULL, NULL, "<architecture>",
{ LLDB_OPT_SET_3, true, "arch", 'a', required_argument, NULL, NULL, "<architecture>",
"Tells the debugger to use the specified architecture when starting and running the program. <architecture> must be one of the architectures for which the program was compiled." },
{ LLDB_OPT_SET_3 | LLDB_OPT_SET_4, false, "script-language",'l', required_argument, NULL, NULL, "<scripting-language>",
@ -67,11 +67,11 @@ static lldb::OptionDefinition g_options[] =
{ LLDB_OPT_SET_3 | LLDB_OPT_SET_4, false, "source", 's', required_argument, NULL, NULL, "<file>",
"Tells the debugger to read in and execute the file <file>, which should contain lldb commands." },
{ LLDB_OPT_SET_3, false, "file", 'f', required_argument, NULL, NULL, "<filename>",
{ LLDB_OPT_SET_3, true, "file", 'f', required_argument, NULL, NULL, "<filename>",
"Tells the debugger to use the file <filename> as the program to be debugged." },
{ LLDB_OPT_SET_4, false, "crash-log", 'c', required_argument, NULL, NULL, "<file>",
"Load executable images from a crash log for symbolication." },
// { LLDB_OPT_SET_4, true, "crash-log", 'c', required_argument, NULL, NULL, "<file>",
// "Load executable images from a crash log for symbolication." },
{ 0, false, NULL, 0, 0, NULL, NULL, NULL, NULL }
};