1 //===-- SymbolFileSymtab.cpp ----------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "SymbolFileSymtab.h" 10 11 #include "lldb/Core/Module.h" 12 #include "lldb/Core/PluginManager.h" 13 #include "lldb/Symbol/CompileUnit.h" 14 #include "lldb/Symbol/Function.h" 15 #include "lldb/Symbol/ObjectFile.h" 16 #include "lldb/Symbol/Symbol.h" 17 #include "lldb/Symbol/SymbolContext.h" 18 #include "lldb/Symbol/Symtab.h" 19 #include "lldb/Symbol/TypeList.h" 20 #include "lldb/Utility/RegularExpression.h" 21 #include "lldb/Utility/Timer.h" 22 23 #include <memory> 24 25 using namespace lldb; 26 using namespace lldb_private; 27 28 LLDB_PLUGIN_DEFINE(SymbolFileSymtab) 29 30 char SymbolFileSymtab::ID; 31 32 void SymbolFileSymtab::Initialize() { 33 PluginManager::RegisterPlugin(GetPluginNameStatic(), 34 GetPluginDescriptionStatic(), CreateInstance); 35 } 36 37 void SymbolFileSymtab::Terminate() { 38 PluginManager::UnregisterPlugin(CreateInstance); 39 } 40 41 lldb_private::ConstString SymbolFileSymtab::GetPluginNameStatic() { 42 static ConstString g_name("symtab"); 43 return g_name; 44 } 45 46 const char *SymbolFileSymtab::GetPluginDescriptionStatic() { 47 return "Reads debug symbols from an object file's symbol table."; 48 } 49 50 SymbolFile *SymbolFileSymtab::CreateInstance(ObjectFileSP objfile_sp) { 51 return new SymbolFileSymtab(std::move(objfile_sp)); 52 } 53 54 void SymbolFileSymtab::GetTypes(SymbolContextScope *sc_scope, 55 TypeClass type_mask, 56 lldb_private::TypeList &type_list) {} 57 58 SymbolFileSymtab::SymbolFileSymtab(ObjectFileSP objfile_sp) 59 : SymbolFile(std::move(objfile_sp)), m_source_indexes(), m_func_indexes(), 60 m_code_indexes(), m_objc_class_name_to_index() {} 61 62 uint32_t SymbolFileSymtab::CalculateAbilities() { 63 uint32_t abilities = 0; 64 if (m_objfile_sp) { 65 const Symtab *symtab = m_objfile_sp->GetSymtab(); 66 if (symtab) { 67 // The snippet of code below will get the indexes the module symbol table 68 // entries that are code, data, or function related (debug info), sort 69 // them by value (address) and dump the sorted symbols. 70 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeSourceFile, 71 m_source_indexes)) { 72 abilities |= CompileUnits; 73 } 74 75 if (symtab->AppendSymbolIndexesWithType( 76 eSymbolTypeCode, Symtab::eDebugYes, Symtab::eVisibilityAny, 77 m_func_indexes)) { 78 symtab->SortSymbolIndexesByValue(m_func_indexes, true); 79 abilities |= Functions; 80 } 81 82 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo, 83 Symtab::eVisibilityAny, 84 m_code_indexes)) { 85 symtab->SortSymbolIndexesByValue(m_code_indexes, true); 86 abilities |= Functions; 87 } 88 89 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeData, 90 m_data_indexes)) { 91 symtab->SortSymbolIndexesByValue(m_data_indexes, true); 92 abilities |= GlobalVariables; 93 } 94 95 lldb_private::Symtab::IndexCollection objc_class_indexes; 96 if (symtab->AppendSymbolIndexesWithType(eSymbolTypeObjCClass, 97 objc_class_indexes)) { 98 symtab->AppendSymbolNamesToMap(objc_class_indexes, true, true, 99 m_objc_class_name_to_index); 100 m_objc_class_name_to_index.Sort(); 101 } 102 } 103 } 104 return abilities; 105 } 106 107 uint32_t SymbolFileSymtab::CalculateNumCompileUnits() { 108 // If we don't have any source file symbols we will just have one compile 109 // unit for the entire object file 110 if (m_source_indexes.empty()) 111 return 0; 112 113 // If we have any source file symbols we will logically organize the object 114 // symbols using these. 115 return m_source_indexes.size(); 116 } 117 118 CompUnitSP SymbolFileSymtab::ParseCompileUnitAtIndex(uint32_t idx) { 119 CompUnitSP cu_sp; 120 121 // If we don't have any source file symbols we will just have one compile 122 // unit for the entire object file 123 if (idx < m_source_indexes.size()) { 124 const Symbol *cu_symbol = 125 m_objfile_sp->GetSymtab()->SymbolAtIndex(m_source_indexes[idx]); 126 if (cu_symbol) 127 cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr, 128 cu_symbol->GetName().AsCString(), 0, 129 eLanguageTypeUnknown, eLazyBoolNo); 130 } 131 return cu_sp; 132 } 133 134 lldb::LanguageType SymbolFileSymtab::ParseLanguage(CompileUnit &comp_unit) { 135 return eLanguageTypeUnknown; 136 } 137 138 size_t SymbolFileSymtab::ParseFunctions(CompileUnit &comp_unit) { 139 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); 140 size_t num_added = 0; 141 // We must at least have a valid compile unit 142 const Symtab *symtab = m_objfile_sp->GetSymtab(); 143 const Symbol *curr_symbol = nullptr; 144 const Symbol *next_symbol = nullptr; 145 // const char *prefix = m_objfile_sp->SymbolPrefix(); 146 // if (prefix == NULL) 147 // prefix == ""; 148 // 149 // const uint32_t prefix_len = strlen(prefix); 150 151 // If we don't have any source file symbols we will just have one compile 152 // unit for the entire object file 153 if (m_source_indexes.empty()) { 154 // The only time we will have a user ID of zero is when we don't have and 155 // source file symbols and we declare one compile unit for the entire 156 // object file 157 if (!m_func_indexes.empty()) { 158 } 159 160 if (!m_code_indexes.empty()) { 161 // StreamFile s(stdout); 162 // symtab->Dump(&s, m_code_indexes); 163 164 uint32_t idx = 0; // Index into the indexes 165 const uint32_t num_indexes = m_code_indexes.size(); 166 for (idx = 0; idx < num_indexes; ++idx) { 167 uint32_t symbol_idx = m_code_indexes[idx]; 168 curr_symbol = symtab->SymbolAtIndex(symbol_idx); 169 if (curr_symbol) { 170 // Union of all ranges in the function DIE (if the function is 171 // discontiguous) 172 AddressRange func_range(curr_symbol->GetAddress(), 0); 173 if (func_range.GetBaseAddress().IsSectionOffset()) { 174 uint32_t symbol_size = curr_symbol->GetByteSize(); 175 if (symbol_size != 0 && !curr_symbol->GetSizeIsSibling()) 176 func_range.SetByteSize(symbol_size); 177 else if (idx + 1 < num_indexes) { 178 next_symbol = symtab->SymbolAtIndex(m_code_indexes[idx + 1]); 179 if (next_symbol) { 180 func_range.SetByteSize( 181 next_symbol->GetAddressRef().GetOffset() - 182 curr_symbol->GetAddressRef().GetOffset()); 183 } 184 } 185 186 FunctionSP func_sp( 187 new Function(&comp_unit, 188 symbol_idx, // UserID is the DIE offset 189 LLDB_INVALID_UID, // We don't have any type info 190 // for this function 191 curr_symbol->GetMangled(), // Linker/mangled name 192 nullptr, // no return type for a code symbol... 193 func_range)); // first address range 194 195 if (func_sp.get() != nullptr) { 196 comp_unit.AddFunction(func_sp); 197 ++num_added; 198 } 199 } 200 } 201 } 202 } 203 } else { 204 // We assume we 205 } 206 return num_added; 207 } 208 209 size_t SymbolFileSymtab::ParseTypes(CompileUnit &comp_unit) { return 0; } 210 211 bool SymbolFileSymtab::ParseLineTable(CompileUnit &comp_unit) { return false; } 212 213 bool SymbolFileSymtab::ParseDebugMacros(CompileUnit &comp_unit) { 214 return false; 215 } 216 217 bool SymbolFileSymtab::ParseSupportFiles(CompileUnit &comp_unit, 218 FileSpecList &support_files) { 219 return false; 220 } 221 222 bool SymbolFileSymtab::ParseImportedModules( 223 const SymbolContext &sc, std::vector<SourceModule> &imported_modules) { 224 return false; 225 } 226 227 size_t SymbolFileSymtab::ParseBlocksRecursive(Function &func) { return 0; } 228 229 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) { 230 return 0; 231 } 232 233 Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) { 234 return nullptr; 235 } 236 237 llvm::Optional<SymbolFile::ArrayInfo> 238 SymbolFileSymtab::GetDynamicArrayInfoForUID( 239 lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) { 240 return llvm::None; 241 } 242 243 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) { 244 return false; 245 } 246 247 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr, 248 SymbolContextItem resolve_scope, 249 SymbolContext &sc) { 250 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); 251 if (m_objfile_sp->GetSymtab() == nullptr) 252 return 0; 253 254 uint32_t resolved_flags = 0; 255 if (resolve_scope & eSymbolContextSymbol) { 256 sc.symbol = m_objfile_sp->GetSymtab()->FindSymbolContainingFileAddress( 257 so_addr.GetFileAddress()); 258 if (sc.symbol) 259 resolved_flags |= eSymbolContextSymbol; 260 } 261 return resolved_flags; 262 } 263 264 // PluginInterface protocol 265 lldb_private::ConstString SymbolFileSymtab::GetPluginName() { 266 return GetPluginNameStatic(); 267 } 268 269 uint32_t SymbolFileSymtab::GetPluginVersion() { return 1; } 270