forked from OSchip/llvm-project
463 lines
14 KiB
C++
463 lines
14 KiB
C++
//===-- 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/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/Symtab.h"
|
|
#include "lldb/Symbol/Function.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Symbol/SymbolVendor.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
|
|
Symbol::Symbol() :
|
|
SymbolContextScope (),
|
|
m_uid (UINT32_MAX),
|
|
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_size_is_valid (false),
|
|
m_demangled_is_synthesized (false),
|
|
m_type (eSymbolTypeInvalid),
|
|
m_mangled (),
|
|
m_addr_range (),
|
|
m_flags ()
|
|
{
|
|
}
|
|
|
|
Symbol::Symbol
|
|
(
|
|
uint32_t symID,
|
|
const char *name,
|
|
bool name_is_mangled,
|
|
SymbolType type,
|
|
bool external,
|
|
bool is_debug,
|
|
bool is_trampoline,
|
|
bool is_artificial,
|
|
const lldb::SectionSP §ion_sp,
|
|
addr_t offset,
|
|
addr_t size,
|
|
bool size_is_valid,
|
|
uint32_t flags
|
|
) :
|
|
SymbolContextScope (),
|
|
m_uid (symID),
|
|
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_size_is_valid (size_is_valid || size > 0),
|
|
m_demangled_is_synthesized (false),
|
|
m_type (type),
|
|
m_mangled (ConstString(name), name_is_mangled),
|
|
m_addr_range (section_sp, offset, size),
|
|
m_flags (flags)
|
|
{
|
|
}
|
|
|
|
Symbol::Symbol
|
|
(
|
|
uint32_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,
|
|
bool size_is_valid,
|
|
uint32_t flags
|
|
) :
|
|
SymbolContextScope (),
|
|
m_uid (symID),
|
|
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_size_is_valid (size_is_valid || range.GetByteSize() > 0),
|
|
m_demangled_is_synthesized (false),
|
|
m_type (type),
|
|
m_mangled (ConstString(name), name_is_mangled),
|
|
m_addr_range (range),
|
|
m_flags (flags)
|
|
{
|
|
}
|
|
|
|
Symbol::Symbol(const Symbol& rhs):
|
|
SymbolContextScope (rhs),
|
|
m_uid (rhs.m_uid),
|
|
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_size_is_valid (rhs.m_size_is_valid),
|
|
m_demangled_is_synthesized (rhs.m_demangled_is_synthesized),
|
|
m_type (rhs.m_type),
|
|
m_mangled (rhs.m_mangled),
|
|
m_addr_range (rhs.m_addr_range),
|
|
m_flags (rhs.m_flags)
|
|
{
|
|
}
|
|
|
|
const Symbol&
|
|
Symbol::operator= (const Symbol& rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
SymbolContextScope::operator= (rhs);
|
|
m_uid = rhs.m_uid;
|
|
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_size_is_valid = rhs.m_size_is_valid;
|
|
m_demangled_is_synthesized = rhs.m_demangled_is_synthesized;
|
|
m_type = rhs.m_type;
|
|
m_mangled = rhs.m_mangled;
|
|
m_addr_range = rhs.m_addr_range;
|
|
m_flags = rhs.m_flags;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
void
|
|
Symbol::Clear()
|
|
{
|
|
m_uid = UINT32_MAX;
|
|
m_mangled.Clear();
|
|
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_size_is_valid = false;
|
|
m_demangled_is_synthesized = false;
|
|
m_type = eSymbolTypeInvalid;
|
|
m_flags = 0;
|
|
m_addr_range.Clear();
|
|
}
|
|
|
|
bool
|
|
Symbol::ValueIsAddress() const
|
|
{
|
|
return m_addr_range.GetBaseAddress().GetSection().get() != NULL;
|
|
}
|
|
|
|
uint32_t
|
|
Symbol::GetSiblingIndex() const
|
|
{
|
|
return m_size_is_sibling ? m_addr_range.GetByteSize() : 0;
|
|
}
|
|
|
|
bool
|
|
Symbol::IsTrampoline () const
|
|
{
|
|
return m_type == eSymbolTypeTrampoline;
|
|
}
|
|
|
|
bool
|
|
Symbol::IsIndirect () const
|
|
{
|
|
return m_type == eSymbolTypeResolver;
|
|
}
|
|
|
|
void
|
|
Symbol::GetDescription (Stream *s, lldb::DescriptionLevel level, Target *target) const
|
|
{
|
|
s->Printf("id = {0x%8.8x}", m_uid);
|
|
|
|
if (m_addr_range.GetBaseAddress().GetSection())
|
|
{
|
|
if (ValueIsAddress())
|
|
{
|
|
const lldb::addr_t byte_size = GetByteSize();
|
|
if (byte_size > 0)
|
|
{
|
|
s->PutCString (", range = ");
|
|
m_addr_range.Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
|
|
}
|
|
else
|
|
{
|
|
s->PutCString (", address = ");
|
|
m_addr_range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
|
|
}
|
|
}
|
|
else
|
|
s->Printf (", value = 0x%16.16" PRIx64, m_addr_range.GetBaseAddress().GetOffset());
|
|
}
|
|
else
|
|
{
|
|
if (m_size_is_sibling)
|
|
s->Printf (", sibling = %5" PRIu64, m_addr_range.GetBaseAddress().GetOffset());
|
|
else
|
|
s->Printf (", value = 0x%16.16" PRIx64, m_addr_range.GetBaseAddress().GetOffset());
|
|
}
|
|
if (m_mangled.GetDemangledName())
|
|
s->Printf(", name=\"%s\"", m_mangled.GetDemangledName().AsCString());
|
|
if (m_mangled.GetMangledName())
|
|
s->Printf(", mangled=\"%s\"", m_mangled.GetMangledName().AsCString());
|
|
|
|
}
|
|
|
|
void
|
|
Symbol::Dump(Stream *s, Target *target, uint32_t index) const
|
|
{
|
|
// 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());
|
|
|
|
// Make sure the size of the symbol is up to date before dumping
|
|
GetByteSize();
|
|
|
|
if (ValueIsAddress())
|
|
{
|
|
if (!m_addr_range.GetBaseAddress().Dump(s, NULL, Address::DumpStyleFileAddress))
|
|
s->Printf("%*s", 18, "");
|
|
|
|
s->PutChar(' ');
|
|
|
|
if (!m_addr_range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress))
|
|
s->Printf("%*s", 18, "");
|
|
|
|
const char *format = m_size_is_sibling ?
|
|
" Sibling -> [%5llu] 0x%8.8x %s\n":
|
|
" 0x%16.16" PRIx64 " 0x%8.8x %s\n";
|
|
s->Printf( format,
|
|
GetByteSize(),
|
|
m_flags,
|
|
m_mangled.GetName().AsCString(""));
|
|
}
|
|
else
|
|
{
|
|
const char *format = m_size_is_sibling ?
|
|
"0x%16.16" PRIx64 " Sibling -> [%5llu] 0x%8.8x %s\n":
|
|
"0x%16.16" PRIx64 " 0x%16.16" PRIx64 " 0x%8.8x %s\n";
|
|
s->Printf( format,
|
|
m_addr_range.GetBaseAddress().GetOffset(),
|
|
GetByteSize(),
|
|
m_flags,
|
|
m_mangled.GetName().AsCString(""));
|
|
}
|
|
}
|
|
|
|
uint32_t
|
|
Symbol::GetPrologueByteSize ()
|
|
{
|
|
if (m_type == eSymbolTypeCode || m_type == eSymbolTypeResolver)
|
|
{
|
|
if (!m_type_data_resolved)
|
|
{
|
|
m_type_data_resolved = true;
|
|
|
|
const Address &base_address = m_addr_range.GetBaseAddress();
|
|
Function *function = base_address.CalculateSymbolContextFunction();
|
|
if (function)
|
|
{
|
|
// Functions have line entries which can also potentially have end of prologue information.
|
|
// So if this symbol points to a function, use the prologue information from there.
|
|
m_type_data = function->GetPrologueByteSize();
|
|
}
|
|
else
|
|
{
|
|
ModuleSP module_sp (base_address.GetModule());
|
|
SymbolContext sc;
|
|
if (module_sp)
|
|
{
|
|
uint32_t resolved_flags = module_sp->ResolveSymbolContextForAddress (base_address,
|
|
eSymbolContextLineEntry,
|
|
sc);
|
|
if (resolved_flags & eSymbolContextLineEntry)
|
|
{
|
|
// Default to the end of the first line entry.
|
|
m_type_data = sc.line_entry.range.GetByteSize();
|
|
|
|
// Set address for next line.
|
|
Address addr (base_address);
|
|
addr.Slide (m_type_data);
|
|
|
|
// Check the first few instructions and look for one that has a line number that is
|
|
// different than the first entry. This is also done in Function::GetPrologueByteSize().
|
|
uint16_t total_offset = m_type_data;
|
|
for (int idx = 0; idx < 6; ++idx)
|
|
{
|
|
SymbolContext sc_temp;
|
|
resolved_flags = module_sp->ResolveSymbolContextForAddress (addr, eSymbolContextLineEntry, sc_temp);
|
|
// Make sure we got line number information...
|
|
if (!(resolved_flags & eSymbolContextLineEntry))
|
|
break;
|
|
|
|
// If this line number is different than our first one, use it and we're done.
|
|
if (sc_temp.line_entry.line != sc.line_entry.line)
|
|
{
|
|
m_type_data = total_offset;
|
|
break;
|
|
}
|
|
|
|
// Slide addr up to the next line address.
|
|
addr.Slide (sc_temp.line_entry.range.GetByteSize());
|
|
total_offset += sc_temp.line_entry.range.GetByteSize();
|
|
// If we've gone too far, bail out.
|
|
if (total_offset >= m_addr_range.GetByteSize())
|
|
break;
|
|
}
|
|
|
|
// Sanity check - this may be a function in the middle of code that has debug information, but
|
|
// not for this symbol. So the line entries surrounding us won't lie inside our function.
|
|
// In that case, the line entry will be bigger than we are, so we do that quick check and
|
|
// if that is true, we just return 0.
|
|
if (m_type_data >= m_addr_range.GetByteSize())
|
|
m_type_data = 0;
|
|
}
|
|
else
|
|
{
|
|
// TODO: expose something in Process to figure out the
|
|
// size of a function prologue.
|
|
m_type_data = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return m_type_data;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
Symbol::Compare(const ConstString& name, SymbolType type) const
|
|
{
|
|
if (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(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);
|
|
ENUM_TO_CSTRING(ObjCClass);
|
|
ENUM_TO_CSTRING(ObjCMetaClass);
|
|
ENUM_TO_CSTRING(ObjCIVar);
|
|
default:
|
|
break;
|
|
}
|
|
return "<unknown SymbolType>";
|
|
}
|
|
|
|
void
|
|
Symbol::CalculateSymbolContext (SymbolContext *sc)
|
|
{
|
|
// Symbols can reconstruct the symbol and the module in the symbol context
|
|
sc->symbol = this;
|
|
if (ValueIsAddress())
|
|
sc->module_sp = GetAddress().GetModule();
|
|
else
|
|
sc->module_sp.reset();
|
|
}
|
|
|
|
ModuleSP
|
|
Symbol::CalculateSymbolContextModule ()
|
|
{
|
|
if (ValueIsAddress())
|
|
return GetAddress().GetModule();
|
|
return ModuleSP();
|
|
}
|
|
|
|
Symbol *
|
|
Symbol::CalculateSymbolContextSymbol ()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
void
|
|
Symbol::DumpSymbolContext (Stream *s)
|
|
{
|
|
bool dumped_module = false;
|
|
if (ValueIsAddress())
|
|
{
|
|
ModuleSP module_sp (GetAddress().GetModule());
|
|
if (module_sp)
|
|
{
|
|
dumped_module = true;
|
|
module_sp->DumpSymbolContext(s);
|
|
}
|
|
}
|
|
if (dumped_module)
|
|
s->PutCString(", ");
|
|
|
|
s->Printf("Symbol{0x%8.8x}", GetID());
|
|
}
|
|
|
|
lldb::addr_t
|
|
Symbol::GetByteSize () const
|
|
{
|
|
return m_addr_range.GetByteSize();
|
|
}
|
|
|