diff options
Diffstat (limited to 'lldb/source/Symbol/Symbol.cpp')
| -rw-r--r-- | lldb/source/Symbol/Symbol.cpp | 463 |
1 files changed, 463 insertions, 0 deletions
diff --git a/lldb/source/Symbol/Symbol.cpp b/lldb/source/Symbol/Symbol.cpp new file mode 100644 index 00000000000..fb01fc176bd --- /dev/null +++ b/lldb/source/Symbol/Symbol.cpp @@ -0,0 +1,463 @@ +//===-- 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" + +using namespace lldb; +using namespace lldb_private; + + +Symbol::Symbol() : + UserID (), + 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), + 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), + 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), + 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) + { + 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::GetAddressRangeRef() +{ + return m_addr_range; +} + +const AddressRange & +Symbol::GetAddressRangeRef() const +{ + return m_addr_range; +} + +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; +} + +bool +Symbol::GetSizeIsSibling() const +{ + return m_size_is_sibling; +} + +bool +Symbol::GetSizeIsSynthesized() const +{ + return m_size_is_synthesized; +} + +uint32_t +Symbol::GetSiblingIndex() const +{ + return m_size_is_sibling ? m_addr_range.GetByteSize() : 0; +} + +uint32_t +Symbol::GetFlags() const +{ + return m_flags; +} + +void +Symbol::SetFlags (uint32_t flags) +{ + m_flags = flags; +} + +SymbolType +Symbol::GetType() const +{ + return m_type; +} + +void +Symbol::SetType(SymbolType type) +{ + m_type = type; +} + +bool +Symbol::IsSynthetic () const +{ + return m_is_synthetic; +} + +void +Symbol::SetIsSynthetic (bool b) +{ + m_is_synthetic = b; +} + +void +Symbol::SetSizeIsSynthesized(bool b) +{ + m_size_is_synthesized = b; +} + + +bool +Symbol::IsDebug() const +{ + return m_is_debug; +} + +void +Symbol::SetDebug (bool b) +{ + m_is_debug = b; +} + +bool +Symbol::IsExternal() const +{ + return m_is_external; +} + +void +Symbol::SetExternal(bool b) +{ + m_is_external = b; +} + +bool +Symbol::IsTrampoline () const +{ + return m_type == eSymbolTypeTrampoline; +} + +uint32_t +Symbol::GetByteSize() const +{ + return m_addr_range.GetByteSize(); +} + +void +Symbol::SetByteSize (uint32_t size) +{ + m_addr_range.SetByteSize(size); +} + +void +Symbol::SetSizeIsSibling (bool b) +{ + m_size_is_sibling = b; +} + +void +Symbol::Dump(Stream *s, Process *process, 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()); + + 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(' '); + + if (!m_addr_range.GetBaseAddress().Dump(s, process, Address::DumpStyleLoadAddress)) + 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("")); + } +} + +const Mangled& +Symbol::GetMangled() const +{ + return m_mangled; +} + +Mangled& +Symbol::GetMangled() +{ + return m_mangled; +} + +Address & +Symbol::GetValue() +{ + return m_addr_range.GetBaseAddress(); +} + +const Address & +Symbol::GetValue() const +{ + return m_addr_range.GetBaseAddress(); +} + +void +Symbol::SetValue (Address &value) +{ + m_addr_range.GetBaseAddress() = value; +} + +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 () +{ + if (m_type == eSymbolTypeCode || m_type == eSymbolTypeFunction) + { + 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 (const AddressRange &range) +{ + m_addr_range = range; +} + + +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(Function); + ENUM_TO_CSTRING(FunctionEnd); + ENUM_TO_CSTRING(CommonBlock); + ENUM_TO_CSTRING(Block); + ENUM_TO_CSTRING(Static); + ENUM_TO_CSTRING(Global); + 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>"; +} + |
