diff options
Diffstat (limited to 'source/Symbol/Symbol.cpp')
| -rw-r--r-- | source/Symbol/Symbol.cpp | 462 |
1 files changed, 462 insertions, 0 deletions
diff --git a/source/Symbol/Symbol.cpp b/source/Symbol/Symbol.cpp new file mode 100644 index 000000000000..7f3543c3b232 --- /dev/null +++ b/source/Symbol/Symbol.cpp @@ -0,0 +1,462 @@ +//===-- 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(); +} + |