diff options
Diffstat (limited to 'source/Symbol/Function.cpp')
| -rw-r--r-- | source/Symbol/Function.cpp | 572 |
1 files changed, 572 insertions, 0 deletions
diff --git a/source/Symbol/Function.cpp b/source/Symbol/Function.cpp new file mode 100644 index 000000000000..31334a6df8d7 --- /dev/null +++ b/source/Symbol/Function.cpp @@ -0,0 +1,572 @@ +//===-- Function.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/Function.h" +#include "lldb/Core/Module.h" +#include "lldb/Core/Section.h" +#include "lldb/Host/Host.h" +#include "lldb/Symbol/ClangASTType.h" +#include "lldb/Symbol/CompileUnit.h" +#include "lldb/Symbol/LineTable.h" +#include "lldb/Symbol/SymbolFile.h" +#include "lldb/Symbol/SymbolVendor.h" +#include "llvm/Support/Casting.h" + +using namespace lldb; +using namespace lldb_private; + +//---------------------------------------------------------------------- +// Basic function information is contained in the FunctionInfo class. +// It is designed to contain the name, linkage name, and declaration +// location. +//---------------------------------------------------------------------- +FunctionInfo::FunctionInfo (const char *name, const Declaration *decl_ptr) : + m_name(name), + m_declaration(decl_ptr) +{ +} + + +FunctionInfo::FunctionInfo (const ConstString& name, const Declaration *decl_ptr) : + m_name(name), + m_declaration(decl_ptr) +{ +} + + +FunctionInfo::~FunctionInfo() +{ +} + +void +FunctionInfo::Dump(Stream *s, bool show_fullpaths) const +{ + if (m_name) + *s << ", name = \"" << m_name << "\""; + m_declaration.Dump(s, show_fullpaths); +} + + +int +FunctionInfo::Compare(const FunctionInfo& a, const FunctionInfo& b) +{ + int result = ConstString::Compare(a.GetName(), b.GetName()); + if (result) + return result; + + return Declaration::Compare(a.m_declaration, b.m_declaration); +} + + +Declaration& +FunctionInfo::GetDeclaration() +{ + return m_declaration; +} + +const Declaration& +FunctionInfo::GetDeclaration() const +{ + return m_declaration; +} + +const ConstString& +FunctionInfo::GetName() const +{ + return m_name; +} + +size_t +FunctionInfo::MemorySize() const +{ + return m_name.MemorySize() + m_declaration.MemorySize(); +} + + +InlineFunctionInfo::InlineFunctionInfo +( + const char *name, + const char *mangled, + const Declaration *decl_ptr, + const Declaration *call_decl_ptr +) : + FunctionInfo(name, decl_ptr), + m_mangled(ConstString(mangled), true), + m_call_decl (call_decl_ptr) +{ +} + +InlineFunctionInfo::InlineFunctionInfo +( + const ConstString& name, + const Mangled &mangled, + const Declaration *decl_ptr, + const Declaration *call_decl_ptr +) : + FunctionInfo(name, decl_ptr), + m_mangled(mangled), + m_call_decl (call_decl_ptr) +{ +} + +InlineFunctionInfo::~InlineFunctionInfo() +{ +} + +int +InlineFunctionInfo::Compare(const InlineFunctionInfo& a, const InlineFunctionInfo& b) +{ + + int result = FunctionInfo::Compare(a, b); + if (result) + return result; + // only compare the mangled names if both have them + return Mangled::Compare(a.m_mangled, a.m_mangled); +} + +void +InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const +{ + FunctionInfo::Dump(s, show_fullpaths); + if (m_mangled) + m_mangled.Dump(s); +} + +void +InlineFunctionInfo::DumpStopContext (Stream *s) const +{ +// s->Indent("[inlined] "); + s->Indent(); + if (m_mangled) + s->PutCString (m_mangled.GetName().AsCString()); + else + s->PutCString (m_name.AsCString()); +} + + +const ConstString & +InlineFunctionInfo::GetName () const +{ + if (m_mangled) + return m_mangled.GetName(); + return m_name; +} + + +Declaration & +InlineFunctionInfo::GetCallSite () +{ + return m_call_decl; +} + +const Declaration & +InlineFunctionInfo::GetCallSite () const +{ + return m_call_decl; +} + + +Mangled& +InlineFunctionInfo::GetMangled() +{ + return m_mangled; +} + +const Mangled& +InlineFunctionInfo::GetMangled() const +{ + return m_mangled; +} + +size_t +InlineFunctionInfo::MemorySize() const +{ + return FunctionInfo::MemorySize() + m_mangled.MemorySize(); +} + +//---------------------------------------------------------------------- +// +//---------------------------------------------------------------------- +Function::Function +( + CompileUnit *comp_unit, + lldb::user_id_t func_uid, + lldb::user_id_t type_uid, + const Mangled &mangled, + Type * type, + const AddressRange& range +) : + UserID (func_uid), + m_comp_unit (comp_unit), + m_type_uid (type_uid), + m_type (type), + m_mangled (mangled), + m_block (func_uid), + m_range (range), + m_frame_base (), + m_flags (), + m_prologue_byte_size (0) +{ + m_block.SetParentScope(this); + assert(comp_unit != NULL); +} + +Function::Function +( + CompileUnit *comp_unit, + lldb::user_id_t func_uid, + lldb::user_id_t type_uid, + const char *mangled, + Type *type, + const AddressRange &range +) : + UserID (func_uid), + m_comp_unit (comp_unit), + m_type_uid (type_uid), + m_type (type), + m_mangled (ConstString(mangled), true), + m_block (func_uid), + m_range (range), + m_frame_base (), + m_flags (), + m_prologue_byte_size (0) +{ + m_block.SetParentScope(this); + assert(comp_unit != NULL); +} + + +Function::~Function() +{ +} + +void +Function::GetStartLineSourceInfo (FileSpec &source_file, uint32_t &line_no) +{ + line_no = 0; + source_file.Clear(); + + if (m_comp_unit == NULL) + return; + + if (m_type != NULL && m_type->GetDeclaration().GetLine() != 0) + { + source_file = m_type->GetDeclaration().GetFile(); + line_no = m_type->GetDeclaration().GetLine(); + } + else + { + LineTable *line_table = m_comp_unit->GetLineTable(); + if (line_table == NULL) + return; + + LineEntry line_entry; + if (line_table->FindLineEntryByAddress (GetAddressRange().GetBaseAddress(), line_entry, NULL)) + { + line_no = line_entry.line; + source_file = line_entry.file; + } + } +} + +void +Function::GetEndLineSourceInfo (FileSpec &source_file, uint32_t &line_no) +{ + line_no = 0; + source_file.Clear(); + + // The -1 is kind of cheesy, but I want to get the last line entry for the given function, not the + // first entry of the next. + Address scratch_addr(GetAddressRange().GetBaseAddress()); + scratch_addr.SetOffset (scratch_addr.GetOffset() + GetAddressRange().GetByteSize() - 1); + + LineTable *line_table = m_comp_unit->GetLineTable(); + if (line_table == NULL) + return; + + LineEntry line_entry; + if (line_table->FindLineEntryByAddress (scratch_addr, line_entry, NULL)) + { + line_no = line_entry.line; + source_file = line_entry.file; + } +} + +Block & +Function::GetBlock (bool can_create) +{ + if (!m_block.BlockInfoHasBeenParsed() && can_create) + { + SymbolContext sc; + CalculateSymbolContext(&sc); + if (sc.module_sp) + { + sc.module_sp->GetSymbolVendor()->ParseFunctionBlocks(sc); + } + else + { + Host::SystemLog (Host::eSystemLogError, + "error: unable to find module shared pointer for function '%s' in %s\n", + GetName().GetCString(), + m_comp_unit->GetPath().c_str()); + } + m_block.SetBlockInfoHasBeenParsed (true, true); + } + return m_block; +} + +CompileUnit* +Function::GetCompileUnit() +{ + return m_comp_unit; +} + +const CompileUnit* +Function::GetCompileUnit() const +{ + return m_comp_unit; +} + + +void +Function::GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) +{ + Type* func_type = GetType(); + const char *name = func_type ? func_type->GetName().AsCString() : "<unknown>"; + + *s << "id = " << (const UserID&)*this << ", name = \"" << name << "\", range = "; + + Address::DumpStyle fallback_style; + if (level == eDescriptionLevelVerbose) + fallback_style = Address::DumpStyleModuleWithFileAddress; + else + fallback_style = Address::DumpStyleFileAddress; + GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress, fallback_style); +} + +void +Function::Dump(Stream *s, bool show_context) const +{ + s->Printf("%p: ", this); + s->Indent(); + *s << "Function" << (const UserID&)*this; + + m_mangled.Dump(s); + + if (m_type) + { + s->Printf(", type = %p", m_type); + } + else if (m_type_uid != LLDB_INVALID_UID) + { + s->Printf(", type_uid = 0x%8.8" PRIx64, m_type_uid); + } + + s->EOL(); + // Dump the root object + if (m_block.BlockInfoHasBeenParsed ()) + m_block.Dump(s, m_range.GetBaseAddress().GetFileAddress(), INT_MAX, show_context); +} + + +void +Function::CalculateSymbolContext(SymbolContext* sc) +{ + sc->function = this; + m_comp_unit->CalculateSymbolContext(sc); +} + +ModuleSP +Function::CalculateSymbolContextModule () +{ + SectionSP section_sp (m_range.GetBaseAddress().GetSection()); + if (section_sp) + return section_sp->GetModule(); + + return this->GetCompileUnit()->GetModule(); +} + +CompileUnit * +Function::CalculateSymbolContextCompileUnit () +{ + return this->GetCompileUnit(); +} + +Function * +Function::CalculateSymbolContextFunction () +{ + return this; +} + +//Symbol * +//Function::CalculateSymbolContextSymbol () +//{ +// return // TODO: find the symbol for the function??? +//} + + +void +Function::DumpSymbolContext(Stream *s) +{ + m_comp_unit->DumpSymbolContext(s); + s->Printf(", Function{0x%8.8" PRIx64 "}", GetID()); +} + +size_t +Function::MemorySize () const +{ + size_t mem_size = sizeof(Function) + m_block.MemorySize(); + return mem_size; +} + +clang::DeclContext * +Function::GetClangDeclContext() +{ + SymbolContext sc; + + CalculateSymbolContext (&sc); + + if (!sc.module_sp) + return NULL; + + SymbolVendor *sym_vendor = sc.module_sp->GetSymbolVendor(); + + if (!sym_vendor) + return NULL; + + SymbolFile *sym_file = sym_vendor->GetSymbolFile(); + + if (!sym_file) + return NULL; + + return sym_file->GetClangDeclContextForTypeUID (sc, m_uid); +} + +Type* +Function::GetType() +{ + if (m_type == NULL) + { + SymbolContext sc; + + CalculateSymbolContext (&sc); + + if (!sc.module_sp) + return NULL; + + SymbolVendor *sym_vendor = sc.module_sp->GetSymbolVendor(); + + if (sym_vendor == NULL) + return NULL; + + SymbolFile *sym_file = sym_vendor->GetSymbolFile(); + + if (sym_file == NULL) + return NULL; + + m_type = sym_file->ResolveTypeUID(m_type_uid); + } + return m_type; +} + +const Type* +Function::GetType() const +{ + return m_type; +} + +ClangASTType +Function::GetClangType() +{ + Type *function_type = GetType(); + if (function_type) + return function_type->GetClangFullType(); + return ClangASTType(); +} + +uint32_t +Function::GetPrologueByteSize () +{ + if (m_prologue_byte_size == 0 && m_flags.IsClear(flagsCalculatedPrologueSize)) + { + m_flags.Set(flagsCalculatedPrologueSize); + LineTable* line_table = m_comp_unit->GetLineTable (); + if (line_table) + { + LineEntry first_line_entry; + uint32_t first_line_entry_idx = UINT32_MAX; + if (line_table->FindLineEntryByAddress(GetAddressRange().GetBaseAddress(), first_line_entry, &first_line_entry_idx)) + { + // Make sure the first line entry isn't already the end of the prologue + addr_t prologue_end_file_addr = LLDB_INVALID_ADDRESS; + if (first_line_entry.is_prologue_end) + { + prologue_end_file_addr = first_line_entry.range.GetBaseAddress().GetFileAddress(); + } + else + { + // Check the first few instructions and look for one that has + // is_prologue_end set to true. + const uint32_t last_line_entry_idx = first_line_entry_idx + 6; + for (uint32_t idx = first_line_entry_idx + 1; idx < last_line_entry_idx; ++idx) + { + LineEntry line_entry; + if (line_table->GetLineEntryAtIndex (idx, line_entry)) + { + if (line_entry.is_prologue_end) + { + prologue_end_file_addr = line_entry.range.GetBaseAddress().GetFileAddress(); + break; + } + } + } + } + + // If we didn't find the end of the prologue in the line tables, + // then just use the end address of the first line table entry + if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) + { + // Check the first few instructions and look for one that has + // a line number that's different than the first entry. + const uint32_t last_line_entry_idx = first_line_entry_idx + 6; + for (uint32_t idx = first_line_entry_idx + 1; idx < last_line_entry_idx; ++idx) + { + LineEntry line_entry; + if (line_table->GetLineEntryAtIndex (idx, line_entry)) + { + if (line_entry.line != first_line_entry.line) + { + prologue_end_file_addr = line_entry.range.GetBaseAddress().GetFileAddress(); + break; + } + } + } + + if (prologue_end_file_addr == LLDB_INVALID_ADDRESS) + { + prologue_end_file_addr = first_line_entry.range.GetBaseAddress().GetFileAddress() + first_line_entry.range.GetByteSize(); + } + } + const addr_t func_start_file_addr = m_range.GetBaseAddress().GetFileAddress(); + const addr_t func_end_file_addr = func_start_file_addr + m_range.GetByteSize(); + + // Verify that this prologue end file address in the function's + // address range just to be sure + if (func_start_file_addr < prologue_end_file_addr && prologue_end_file_addr < func_end_file_addr) + { + m_prologue_byte_size = prologue_end_file_addr - func_start_file_addr; + } + } + } + } + return m_prologue_byte_size; +} + + + |