replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
hanchenye-llvm-project/lldb/source/Symbol/Symbol.cpp

390 lines
10 KiB
C++
Raw Normal View History

Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
//===-- Symbol.cpp ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "lldb/Symbol/Symbol.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Target/Process.h"
Moved the section load list up into the target so we can use the target to symbolicate things without the need for a valid process subclass. llvm-svn: 113895
2010-09-15 07:36:40 +08:00
#include "lldb/Target/Target.h"
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
using namespace lldb;
using namespace lldb_private;
Symbol::Symbol() :
UserID (),
Order of initialization lists. This patch fixes all of the warnings due to unordered initialization lists. Patch by Marco Minutoli. llvm-svn: 129290
2011-04-12 03:41:40 +08:00
SymbolContextScope (),
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
m_mangled (),
m_type (eSymbolTypeInvalid),
m_type_data (0),
m_type_data_resolved (false),
m_is_synthetic (false),
m_is_debug (false),
m_is_external (false),
m_size_is_sibling (false),
m_size_is_synthesized (false),
m_searched_for_function (false),
m_addr_range (),
m_flags (),
m_function (NULL)
{
}
Symbol::Symbol
(
user_id_t symID,
const char *name,
bool name_is_mangled,
SymbolType type,
bool external,
bool is_debug,
bool is_trampoline,
bool is_artificial,
const Section* section,
addr_t offset,
uint32_t size,
uint32_t flags
) :
UserID (symID),
Order of initialization lists. This patch fixes all of the warnings due to unordered initialization lists. Patch by Marco Minutoli. llvm-svn: 129290
2011-04-12 03:41:40 +08:00
SymbolContextScope (),
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
m_mangled (name, name_is_mangled),
m_type (type),
m_type_data (0),
m_type_data_resolved (false),
m_is_synthetic (is_artificial),
m_is_debug (is_debug),
m_is_external (external),
m_size_is_sibling (false),
m_size_is_synthesized (false),
m_searched_for_function (false),
m_addr_range (section, offset, size),
m_flags (flags),
m_function (NULL)
{
}
Symbol::Symbol
(
user_id_t symID,
const char *name,
bool name_is_mangled,
SymbolType type,
bool external,
bool is_debug,
bool is_trampoline,
bool is_artificial,
const AddressRange &range,
uint32_t flags
) :
UserID (symID),
Order of initialization lists. This patch fixes all of the warnings due to unordered initialization lists. Patch by Marco Minutoli. llvm-svn: 129290
2011-04-12 03:41:40 +08:00
SymbolContextScope (),
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
m_mangled (name, name_is_mangled),
m_type (type),
m_type_data (0),
m_type_data_resolved (false),
m_is_synthetic (is_artificial),
m_is_debug (is_debug),
m_is_external (external),
m_size_is_sibling (false),
m_size_is_synthesized (false),
m_searched_for_function (false),
m_addr_range (range),
m_flags (flags),
m_function (NULL)
{
}
Symbol::Symbol(const Symbol& rhs):
UserID (rhs),
Order of initialization lists. This patch fixes all of the warnings due to unordered initialization lists. Patch by Marco Minutoli. llvm-svn: 129290
2011-04-12 03:41:40 +08:00
SymbolContextScope (rhs),
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
m_mangled (rhs.m_mangled),
m_type (rhs.m_type),
m_type_data (rhs.m_type_data),
m_type_data_resolved (rhs.m_type_data_resolved),
m_is_synthetic (rhs.m_is_synthetic),
m_is_debug (rhs.m_is_debug),
m_is_external (rhs.m_is_external),
m_size_is_sibling (rhs.m_size_is_sibling),
m_size_is_synthesized (false),
m_searched_for_function (false),
m_addr_range (rhs.m_addr_range),
m_flags (rhs.m_flags),
m_function (NULL)
{
}
const Symbol&
Symbol::operator= (const Symbol& rhs)
{
if (this != &rhs)
{
Clarified the intent of the SymbolContextScope class in the header documentation. Symbol now inherits from the symbol context scope so that the StackID can use a "SymbolContextScope *" instead of a blockID (which could have been the same as some other blockID from another symbol file). Modified the stacks that are created on subsequent stops to reuse the previous stack frame objects which will allow for some internal optimization using pointer comparisons during stepping. llvm-svn: 112495
2010-08-31 02:11:35 +08:00
SymbolContextScope::operator= (rhs);
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
UserID::operator= (rhs);
m_mangled = rhs.m_mangled;
m_type = rhs.m_type;
m_type_data = rhs.m_type_data;
m_type_data_resolved = rhs.m_type_data_resolved;
m_is_synthetic = rhs.m_is_synthetic;
m_is_debug = rhs.m_is_debug;
m_is_external = rhs.m_is_external;
m_size_is_sibling = rhs.m_size_is_sibling;
m_size_is_synthesized = rhs.m_size_is_sibling;
m_searched_for_function = rhs.m_searched_for_function;
m_addr_range = rhs.m_addr_range;
m_flags = rhs.m_flags;
m_function = rhs.m_function;
}
return *this;
}
AddressRange *
Symbol::GetAddressRangePtr()
{
if (m_addr_range.GetBaseAddress().GetSection())
return &m_addr_range;
return NULL;
}
const AddressRange *
Symbol::GetAddressRangePtr() const
{
if (m_addr_range.GetBaseAddress().GetSection())
return &m_addr_range;
return NULL;
}
uint32_t
Symbol::GetSiblingIndex() const
{
return m_size_is_sibling ? m_addr_range.GetByteSize() : 0;
}
bool
Symbol::IsTrampoline () const
{
return m_type == eSymbolTypeTrampoline;
}
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
2010-06-29 05:30:43 +08:00
void
Moved the section load list up into the target so we can use the target to symbolicate things without the need for a valid process subclass. llvm-svn: 113895
2010-09-15 07:36:40 +08:00
Symbol::GetDescription (Stream *s, lldb::DescriptionLevel level, Target *target) const
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
2010-06-29 05:30:43 +08:00
{
Cleaned up the output of "image lookup --address <ADDR>" which involved cleaning up the output of many GetDescription objects that are part of a symbol context. This fixes an issue where no ranges were being printed out for functions, blocks and symbols. llvm-svn: 113571
2010-09-10 09:30:46 +08:00
*s << "id = " << (const UserID&)*this << ", name = \"" << m_mangled.GetName() << '"';
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
2010-06-29 05:30:43 +08:00
const Section *section = m_addr_range.GetBaseAddress().GetSection();
if (section != NULL)
{
Cleaned up the output of "image lookup --address <ADDR>" which involved cleaning up the output of many GetDescription objects that are part of a symbol context. This fixes an issue where no ranges were being printed out for functions, blocks and symbols. llvm-svn: 113571
2010-09-10 09:30:46 +08:00
if (m_addr_range.GetBaseAddress().IsSectionOffset())
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
2010-06-29 05:30:43 +08:00
{
Cleaned up the output of "image lookup --address <ADDR>" which involved cleaning up the output of many GetDescription objects that are part of a symbol context. This fixes an issue where no ranges were being printed out for functions, blocks and symbols. llvm-svn: 113571
2010-09-10 09:30:46 +08:00
if (m_addr_range.GetByteSize() > 0)
{
s->PutCString (", range = ");
Moved the section load list up into the target so we can use the target to symbolicate things without the need for a valid process subclass. llvm-svn: 113895
2010-09-15 07:36:40 +08:00
m_addr_range.Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
Cleaned up the output of "image lookup --address <ADDR>" which involved cleaning up the output of many GetDescription objects that are part of a symbol context. This fixes an issue where no ranges were being printed out for functions, blocks and symbols. llvm-svn: 113571
2010-09-10 09:30:46 +08:00
}
else
{
s->PutCString (", address = ");
Moved the section load list up into the target so we can use the target to symbolicate things without the need for a valid process subclass. llvm-svn: 113895
2010-09-15 07:36:40 +08:00
m_addr_range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
Cleaned up the output of "image lookup --address <ADDR>" which involved cleaning up the output of many GetDescription objects that are part of a symbol context. This fixes an issue where no ranges were being printed out for functions, blocks and symbols. llvm-svn: 113571
2010-09-10 09:30:46 +08:00
}
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
2010-06-29 05:30:43 +08:00
}
else
{
Cleaned up the output of "image lookup --address <ADDR>" which involved cleaning up the output of many GetDescription objects that are part of a symbol context. This fixes an issue where no ranges were being printed out for functions, blocks and symbols. llvm-svn: 113571
2010-09-10 09:30:46 +08:00
if (m_size_is_sibling)
s->Printf (", sibling = %5llu", m_addr_range.GetBaseAddress().GetOffset());
else
s->Printf (", value = 0x%16.16llx", m_addr_range.GetBaseAddress().GetOffset());
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
2010-06-29 05:30:43 +08:00
}
}
}
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
void
Moved the section load list up into the target so we can use the target to symbolicate things without the need for a valid process subclass. llvm-svn: 113895
2010-09-15 07:36:40 +08:00
Symbol::Dump(Stream *s, Target *target, uint32_t index) const
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
// s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
// s->Indent();
// s->Printf("Symbol[%5u] %6u %c%c %-12s ",
s->Printf("[%5u] %6u %c%c%c %-12s ",
index,
GetID(),
m_is_debug ? 'D' : ' ',
m_is_synthetic ? 'S' : ' ',
m_is_external ? 'X' : ' ',
GetTypeAsString());
const Section *section = m_addr_range.GetBaseAddress().GetSection();
if (section != NULL)
{
if (!m_addr_range.GetBaseAddress().Dump(s, NULL, Address::DumpStyleFileAddress))
s->Printf("%*s", 18, "");
s->PutChar(' ');
Moved the section load list up into the target so we can use the target to symbolicate things without the need for a valid process subclass. llvm-svn: 113895
2010-09-15 07:36:40 +08:00
if (!m_addr_range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress))
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
s->Printf("%*s", 18, "");
const char *format = m_size_is_sibling ?
" Sibling -> [%5llu] 0x%8.8x %s\n":
" 0x%16.16llx 0x%8.8x %s\n";
s->Printf( format,
m_addr_range.GetByteSize(),
m_flags,
m_mangled.GetName().AsCString(""));
}
else
{
const char *format = m_size_is_sibling ?
"0x%16.16llx Sibling -> [%5llu] 0x%8.8x %s\n":
"0x%16.16llx 0x%16.16llx 0x%8.8x %s\n";
s->Printf( format,
m_addr_range.GetBaseAddress().GetOffset(),
m_addr_range.GetByteSize(),
m_flags,
m_mangled.GetName().AsCString(""));
}
}
Function *
Symbol::GetFunction ()
{
if (m_function == NULL && !m_searched_for_function)
{
m_searched_for_function = true;
Module *module = m_addr_range.GetBaseAddress().GetModule();
if (module)
{
SymbolContext sc;
if (module->ResolveSymbolContextForAddress(m_addr_range.GetBaseAddress(), eSymbolContextFunction, sc))
m_function = sc.function;
}
}
return m_function;
}
uint32_t
Symbol::GetPrologueByteSize ()
{
Remove the eSymbolTypeFunction, eSymbolTypeGlobal, and eSymbolTypeStatic. They will now be represented as: eSymbolTypeFunction: eSymbolTypeCode with IsDebug() == true eSymbolTypeGlobal: eSymbolTypeData with IsDebug() == true and IsExternal() == true eSymbolTypeStatic: eSymbolTypeData with IsDebug() == true and IsExternal() == false This simplifies the logic when dealing with symbols and allows for symbols to be coalesced into a single symbol most of the time. Enabled the minimal symbol table for mach-o again after working out all the kinks. We now get nice concise symbol tables and debugging with DWARF in the .o files with a debug map in the binary works well again. There were issues where the SymbolFileDWARFDebugMap symbol file parser was using symbol IDs and symbol indexes interchangeably. Now that all those issues are resolved debugging is working nicely. llvm-svn: 113678
2010-09-11 11:13:28 +08:00
if (m_type == eSymbolTypeCode)
Initial checkin of lldb code from internal Apple repo. llvm-svn: 105619
2010-06-09 00:52:24 +08:00
{
if (!m_type_data_resolved)
{
m_type_data_resolved = true;
Module *module = m_addr_range.GetBaseAddress().GetModule();
SymbolContext sc;
if (module && module->ResolveSymbolContextForAddress (m_addr_range.GetBaseAddress(),
eSymbolContextLineEntry,
sc))
{
m_type_data = sc.line_entry.range.GetByteSize();
}
else
{
// TODO: expose something in Process to figure out the
// size of a function prologue.
}
}
return m_type_data;
}
return 0;
}
void
Symbol::SetValue(addr_t value)
{
m_addr_range.GetBaseAddress().SetSection(NULL);
m_addr_range.GetBaseAddress().SetOffset(value);
}
bool
Symbol::Compare(const ConstString& name, SymbolType type) const
{
if (m_type == eSymbolTypeAny || m_type == type)
return m_mangled.GetMangledName() == name || m_mangled.GetDemangledName() == name;
return false;
}
#define ENUM_TO_CSTRING(x) case eSymbolType##x: return #x;
const char *
Symbol::GetTypeAsString() const
{
switch (m_type)
{
ENUM_TO_CSTRING(Invalid);
ENUM_TO_CSTRING(Absolute);
ENUM_TO_CSTRING(Extern);
ENUM_TO_CSTRING(Code);
ENUM_TO_CSTRING(Data);
ENUM_TO_CSTRING(Trampoline);
ENUM_TO_CSTRING(Runtime);
ENUM_TO_CSTRING(Exception);
ENUM_TO_CSTRING(SourceFile);
ENUM_TO_CSTRING(HeaderFile);
ENUM_TO_CSTRING(ObjectFile);
ENUM_TO_CSTRING(CommonBlock);
ENUM_TO_CSTRING(Block);
ENUM_TO_CSTRING(Local);
ENUM_TO_CSTRING(Param);
ENUM_TO_CSTRING(Variable);
ENUM_TO_CSTRING(VariableType);
ENUM_TO_CSTRING(LineEntry);
ENUM_TO_CSTRING(LineHeader);
ENUM_TO_CSTRING(ScopeBegin);
ENUM_TO_CSTRING(ScopeEnd);
ENUM_TO_CSTRING(Additional);
ENUM_TO_CSTRING(Compiler);
ENUM_TO_CSTRING(Instrumentation);
ENUM_TO_CSTRING(Undefined);
default:
break;
}
return "<unknown SymbolType>";
}
Clarified the intent of the SymbolContextScope class in the header documentation. Symbol now inherits from the symbol context scope so that the StackID can use a "SymbolContextScope *" instead of a blockID (which could have been the same as some other blockID from another symbol file). Modified the stacks that are created on subsequent stops to reuse the previous stack frame objects which will allow for some internal optimization using pointer comparisons during stepping. llvm-svn: 112495
2010-08-31 02:11:35 +08:00
void
Symbol::CalculateSymbolContext (SymbolContext *sc)
{
// Symbols can reconstruct the symbol and the module in the symbol context
sc->symbol = this;
const AddressRange *range = GetAddressRangePtr();
if (range)
{
Module *module = range->GetBaseAddress().GetModule ();
if (module)
{
sc->module_sp = module->GetSP();
return;
}
}
sc->module_sp.reset();
}
void
Symbol::DumpSymbolContext (Stream *s)
{
bool dumped_module = false;
const AddressRange *range = GetAddressRangePtr();
if (range)
{
Module *module = range->GetBaseAddress().GetModule ();
if (module)
{
dumped_module = true;
module->DumpSymbolContext(s);
}
}
if (dumped_module)
s->PutCString(", ");
s->Printf("Symbol{0x%8.8x}", GetID());
}