| //===-- SymbolFileSymtab.cpp ------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "SymbolFileSymtab.h" |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/PluginManager.h" |
| #include "lldb/Symbol/CompileUnit.h" |
| #include "lldb/Symbol/Function.h" |
| #include "lldb/Symbol/ObjectFile.h" |
| #include "lldb/Symbol/Symbol.h" |
| #include "lldb/Symbol/SymbolContext.h" |
| #include "lldb/Symbol/Symtab.h" |
| #include "lldb/Symbol/TypeList.h" |
| #include "lldb/Utility/RegularExpression.h" |
| #include "lldb/Utility/Timer.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| void SymbolFileSymtab::Initialize() { |
| PluginManager::RegisterPlugin(GetPluginNameStatic(), |
| GetPluginDescriptionStatic(), CreateInstance); |
| } |
| |
| void SymbolFileSymtab::Terminate() { |
| PluginManager::UnregisterPlugin(CreateInstance); |
| } |
| |
| lldb_private::ConstString SymbolFileSymtab::GetPluginNameStatic() { |
| static ConstString g_name("symtab"); |
| return g_name; |
| } |
| |
| const char *SymbolFileSymtab::GetPluginDescriptionStatic() { |
| return "Reads debug symbols from an object file's symbol table."; |
| } |
| |
| SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFile *obj_file) { |
| return new SymbolFileSymtab(obj_file); |
| } |
| |
| size_t SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope, |
| uint32_t type_mask, |
| lldb_private::TypeList &type_list) { |
| return 0; |
| } |
| |
| SymbolFileSymtab::SymbolFileSymtab(ObjectFile *obj_file) |
| : SymbolFile(obj_file), m_source_indexes(), m_func_indexes(), |
| m_code_indexes(), m_objc_class_name_to_index() {} |
| |
| SymbolFileSymtab::~SymbolFileSymtab() {} |
| |
| uint32_t SymbolFileSymtab::CalculateAbilities() { |
| uint32_t abilities = 0; |
| if (m_obj_file) { |
| const Symtab *symtab = m_obj_file->GetSymtab(); |
| if (symtab) { |
| //---------------------------------------------------------------------- |
| // The snippet of code below will get the indexes the module symbol table |
| // entries that are code, data, or function related (debug info), sort |
| // them by value (address) and dump the sorted symbols. |
| //---------------------------------------------------------------------- |
| if (symtab->AppendSymbolIndexesWithType(eSymbolTypeSourceFile, |
| m_source_indexes)) { |
| abilities |= CompileUnits; |
| } |
| |
| if (symtab->AppendSymbolIndexesWithType( |
| eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny, |
| m_func_indexes)) { |
| symtab->SortSymbolIndexesByValue(m_func_indexes, true); |
| abilities |= Functions; |
| } |
| |
| if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo, |
| Symtab::eVisibilityAny, |
| m_code_indexes)) { |
| symtab->SortSymbolIndexesByValue(m_code_indexes, true); |
| abilities |= Functions; |
| } |
| |
| if (symtab->AppendSymbolIndexesWithType(eSymbolTypeData, |
| m_data_indexes)) { |
| symtab->SortSymbolIndexesByValue(m_data_indexes, true); |
| abilities |= GlobalVariables; |
| } |
| |
| lldb_private::Symtab::IndexCollection objc_class_indexes; |
| if (symtab->AppendSymbolIndexesWithType(eSymbolTypeObjCClass, |
| objc_class_indexes)) { |
| symtab->AppendSymbolNamesToMap(objc_class_indexes, true, true, |
| m_objc_class_name_to_index); |
| m_objc_class_name_to_index.Sort(); |
| } |
| } |
| } |
| return abilities; |
| } |
| |
| uint32_t SymbolFileSymtab::GetNumCompileUnits() { |
| // If we don't have any source file symbols we will just have one compile |
| // unit for the entire object file |
| if (m_source_indexes.empty()) |
| return 0; |
| |
| // If we have any source file symbols we will logically organize the object |
| // symbols using these. |
| return m_source_indexes.size(); |
| } |
| |
| CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) { |
| CompUnitSP cu_sp; |
| |
| // If we don't have any source file symbols we will just have one compile |
| // unit for the entire object file |
| if (idx < m_source_indexes.size()) { |
| const Symbol *cu_symbol = |
| m_obj_file->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]); |
| if (cu_symbol) |
| cu_sp.reset(new CompileUnit(m_obj_file->GetModule(), NULL, |
| cu_symbol->GetName().AsCString(), 0, |
| eLanguageTypeUnknown, eLazyBoolNo)); |
| } |
| return cu_sp; |
| } |
| |
| lldb::LanguageType |
| SymbolFileSymtab::ParseCompileUnitLanguage(const SymbolContext &sc) { |
| return eLanguageTypeUnknown; |
| } |
| |
| size_t SymbolFileSymtab::ParseCompileUnitFunctions(const SymbolContext &sc) { |
| size_t num_added = 0; |
| // We must at least have a valid compile unit |
| assert(sc.comp_unit != NULL); |
| const Symtab *symtab = m_obj_file->GetSymtab(); |
| const Symbol *curr_symbol = NULL; |
| const Symbol *next_symbol = NULL; |
| // const char *prefix = m_obj_file->SymbolPrefix(); |
| // if (prefix == NULL) |
| // prefix == ""; |
| // |
| // const uint32_t prefix_len = strlen(prefix); |
| |
| // If we don't have any source file symbols we will just have one compile |
| // unit for the entire object file |
| if (m_source_indexes.empty()) { |
| // The only time we will have a user ID of zero is when we don't have and |
| // source file symbols and we declare one compile unit for the entire |
| // object file |
| if (!m_func_indexes.empty()) { |
| } |
| |
| if (!m_code_indexes.empty()) { |
| // StreamFile s(stdout); |
| // symtab->Dump(&s, m_code_indexes); |
| |
| uint32_t idx = 0; // Index into the indexes |
| const uint32_t num_indexes = m_code_indexes.size(); |
| for (idx = 0; idx < num_indexes; ++idx) { |
| uint32_t symbol_idx = m_code_indexes[idx]; |
| curr_symbol = symtab->SymbolAtIndex(symbol_idx); |
| if (curr_symbol) { |
| // Union of all ranges in the function DIE (if the function is |
| // discontiguous) |
| AddressRange func_range(curr_symbol->GetAddress(), 0); |
| if (func_range.GetBaseAddress().IsSectionOffset()) { |
| uint32_t symbol_size = curr_symbol->GetByteSize(); |
| if (symbol_size != 0 && !curr_symbol->GetSizeIsSibling()) |
| func_range.SetByteSize(symbol_size); |
| else if (idx + 1 < num_indexes) { |
| next_symbol = symtab->SymbolAtIndex(m_code_indexes[idx + 1]); |
| if (next_symbol) { |
| func_range.SetByteSize( |
| next_symbol->GetAddressRef().GetOffset() - |
| curr_symbol->GetAddressRef().GetOffset()); |
| } |
| } |
| |
| FunctionSP func_sp( |
| new Function(sc.comp_unit, |
| symbol_idx, // UserID is the DIE offset |
| LLDB_INVALID_UID, // We don't have any type info |
| // for this function |
| curr_symbol->GetMangled(), // Linker/mangled name |
| NULL, // no return type for a code symbol... |
| func_range)); // first address range |
| |
| if (func_sp.get() != NULL) { |
| sc.comp_unit->AddFunction(func_sp); |
| ++num_added; |
| } |
| } |
| } |
| } |
| } |
| } else { |
| // We assume we |
| } |
| return num_added; |
| } |
| |
| bool SymbolFileSymtab::ParseCompileUnitLineTable(const SymbolContext &sc) { |
| return false; |
| } |
| |
| bool SymbolFileSymtab::ParseCompileUnitDebugMacros(const SymbolContext &sc) { |
| return false; |
| } |
| |
| bool SymbolFileSymtab::ParseCompileUnitSupportFiles( |
| const SymbolContext &sc, FileSpecList &support_files) { |
| return false; |
| } |
| |
| bool SymbolFileSymtab::ParseImportedModules( |
| const SymbolContext &sc, std::vector<ConstString> &imported_modules) { |
| return false; |
| } |
| |
| size_t SymbolFileSymtab::ParseFunctionBlocks(const SymbolContext &sc) { |
| return 0; |
| } |
| |
| size_t SymbolFileSymtab::ParseTypes(const SymbolContext &sc) { return 0; } |
| |
| size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) { |
| return 0; |
| } |
| |
| Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) { |
| return NULL; |
| } |
| |
| bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) { |
| return false; |
| } |
| |
| uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr, |
| uint32_t resolve_scope, |
| SymbolContext &sc) { |
| if (m_obj_file->GetSymtab() == NULL) |
| return 0; |
| |
| uint32_t resolved_flags = 0; |
| if (resolve_scope & eSymbolContextSymbol) { |
| sc.symbol = m_obj_file->GetSymtab()->FindSymbolContainingFileAddress( |
| so_addr.GetFileAddress()); |
| if (sc.symbol) |
| resolved_flags |= eSymbolContextSymbol; |
| } |
| return resolved_flags; |
| } |
| |
| //------------------------------------------------------------------ |
| // PluginInterface protocol |
| //------------------------------------------------------------------ |
| lldb_private::ConstString SymbolFileSymtab::GetPluginName() { |
| return GetPluginNameStatic(); |
| } |
| |
| uint32_t SymbolFileSymtab::GetPluginVersion() { return 1; } |
