1 //===-- SymbolFile.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 "lldb/Symbol/SymbolFile.h" 10 11 #include "lldb/Core/Module.h" 12 #include "lldb/Core/PluginManager.h" 13 #include "lldb/Symbol/CompileUnit.h" 14 #include "lldb/Symbol/ObjectFile.h" 15 #include "lldb/Symbol/SymbolFileOnDemand.h" 16 #include "lldb/Symbol/TypeMap.h" 17 #include "lldb/Symbol/TypeSystem.h" 18 #include "lldb/Symbol/VariableList.h" 19 #include "lldb/Utility/Log.h" 20 #include "lldb/Utility/StreamString.h" 21 #include "lldb/lldb-private.h" 22 23 #include <future> 24 25 using namespace lldb_private; 26 using namespace lldb; 27 28 char SymbolFile::ID; 29 char SymbolFileCommon::ID; 30 31 void SymbolFile::PreloadSymbols() { 32 // No-op for most implementations. 33 } 34 35 std::recursive_mutex &SymbolFile::GetModuleMutex() const { 36 return GetObjectFile()->GetModule()->GetMutex(); 37 } 38 39 SymbolFile *SymbolFile::FindPlugin(ObjectFileSP objfile_sp) { 40 std::unique_ptr<SymbolFile> best_symfile_up; 41 if (objfile_sp != nullptr) { 42 43 // We need to test the abilities of this section list. So create what it 44 // would be with this new objfile_sp. 45 lldb::ModuleSP module_sp(objfile_sp->GetModule()); 46 if (module_sp) { 47 // Default to the main module section list. 48 ObjectFile *module_obj_file = module_sp->GetObjectFile(); 49 if (module_obj_file != objfile_sp.get()) { 50 // Make sure the main object file's sections are created 51 module_obj_file->GetSectionList(); 52 objfile_sp->CreateSections(*module_sp->GetUnifiedSectionList()); 53 } 54 } 55 56 // TODO: Load any plug-ins in the appropriate plug-in search paths and 57 // iterate over all of them to find the best one for the job. 58 59 uint32_t best_symfile_abilities = 0; 60 61 SymbolFileCreateInstance create_callback; 62 for (uint32_t idx = 0; 63 (create_callback = PluginManager::GetSymbolFileCreateCallbackAtIndex( 64 idx)) != nullptr; 65 ++idx) { 66 std::unique_ptr<SymbolFile> curr_symfile_up(create_callback(objfile_sp)); 67 68 if (curr_symfile_up) { 69 const uint32_t sym_file_abilities = curr_symfile_up->GetAbilities(); 70 if (sym_file_abilities > best_symfile_abilities) { 71 best_symfile_abilities = sym_file_abilities; 72 best_symfile_up.reset(curr_symfile_up.release()); 73 // If any symbol file parser has all of the abilities, then we should 74 // just stop looking. 75 if ((kAllAbilities & sym_file_abilities) == kAllAbilities) 76 break; 77 } 78 } 79 } 80 if (best_symfile_up) { 81 // If symbol on-demand is enabled the winning symbol file parser is 82 // wrapped with SymbolFileOnDemand so that hydration of the debug info 83 // can be controlled to improve performance. 84 // 85 // Currently the supported on-demand symbol files include: 86 // executables, shared libraries and debug info files. 87 // 88 // To reduce unnecessary wrapping files with zero debug abilities are 89 // skipped. 90 ObjectFile::Type obj_file_type = objfile_sp->CalculateType(); 91 if (ModuleList::GetGlobalModuleListProperties().GetLoadSymbolOnDemand() && 92 best_symfile_abilities > 0 && 93 (obj_file_type == ObjectFile::eTypeExecutable || 94 obj_file_type == ObjectFile::eTypeSharedLibrary || 95 obj_file_type == ObjectFile::eTypeDebugInfo)) { 96 best_symfile_up = 97 std::make_unique<SymbolFileOnDemand>(std::move(best_symfile_up)); 98 } 99 // Let the winning symbol file parser initialize itself more completely 100 // now that it has been chosen 101 best_symfile_up->InitializeObject(); 102 } 103 } 104 return best_symfile_up.release(); 105 } 106 107 uint32_t 108 SymbolFile::ResolveSymbolContext(const SourceLocationSpec &src_location_spec, 109 lldb::SymbolContextItem resolve_scope, 110 SymbolContextList &sc_list) { 111 return 0; 112 } 113 114 void SymbolFile::FindGlobalVariables(ConstString name, 115 const CompilerDeclContext &parent_decl_ctx, 116 uint32_t max_matches, 117 VariableList &variables) {} 118 119 void SymbolFile::FindGlobalVariables(const RegularExpression ®ex, 120 uint32_t max_matches, 121 VariableList &variables) {} 122 123 void SymbolFile::FindFunctions(const Module::LookupInfo &lookup_info, 124 const CompilerDeclContext &parent_decl_ctx, 125 bool include_inlines, 126 SymbolContextList &sc_list) {} 127 128 void SymbolFile::FindFunctions(const RegularExpression ®ex, 129 bool include_inlines, 130 SymbolContextList &sc_list) {} 131 132 void SymbolFile::GetMangledNamesForFunction( 133 const std::string &scope_qualified_name, 134 std::vector<ConstString> &mangled_names) {} 135 136 void SymbolFile::FindTypes( 137 ConstString name, const CompilerDeclContext &parent_decl_ctx, 138 uint32_t max_matches, 139 llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, 140 TypeMap &types) {} 141 142 void SymbolFile::FindTypes(llvm::ArrayRef<CompilerContext> pattern, 143 LanguageSet languages, 144 llvm::DenseSet<SymbolFile *> &searched_symbol_files, 145 TypeMap &types) {} 146 147 void SymbolFile::AssertModuleLock() { 148 // The code below is too expensive to leave enabled in release builds. It's 149 // enabled in debug builds or when the correct macro is set. 150 #if defined(LLDB_CONFIGURATION_DEBUG) 151 // We assert that we have to module lock by trying to acquire the lock from a 152 // different thread. Note that we must abort if the result is true to 153 // guarantee correctness. 154 assert(std::async( 155 std::launch::async, 156 [this] { 157 return this->GetModuleMutex().try_lock(); 158 }).get() == false && 159 "Module is not locked"); 160 #endif 161 } 162 163 SymbolFile::RegisterInfoResolver::~RegisterInfoResolver() = default; 164 165 Symtab *SymbolFileCommon::GetSymtab() { 166 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); 167 // Fetch the symtab from the main object file. 168 auto *symtab = GetMainObjectFile()->GetSymtab(); 169 if (m_symtab != symtab) { 170 m_symtab = symtab; 171 172 // Then add our symbols to it. 173 if (m_symtab) 174 AddSymbols(*m_symtab); 175 } 176 return m_symtab; 177 } 178 179 ObjectFile *SymbolFileCommon::GetMainObjectFile() { 180 return m_objfile_sp->GetModule()->GetObjectFile(); 181 } 182 183 void SymbolFileCommon::SectionFileAddressesChanged() { 184 ObjectFile *module_objfile = GetMainObjectFile(); 185 ObjectFile *symfile_objfile = GetObjectFile(); 186 if (symfile_objfile != module_objfile) 187 symfile_objfile->SectionFileAddressesChanged(); 188 if (auto *symtab = GetSymtab()) 189 symtab->SectionFileAddressesChanged(); 190 } 191 192 uint32_t SymbolFileCommon::GetNumCompileUnits() { 193 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); 194 if (!m_compile_units) { 195 // Create an array of compile unit shared pointers -- which will each 196 // remain NULL until someone asks for the actual compile unit information. 197 m_compile_units.emplace(CalculateNumCompileUnits()); 198 } 199 return m_compile_units->size(); 200 } 201 202 CompUnitSP SymbolFileCommon::GetCompileUnitAtIndex(uint32_t idx) { 203 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); 204 uint32_t num = GetNumCompileUnits(); 205 if (idx >= num) 206 return nullptr; 207 lldb::CompUnitSP &cu_sp = (*m_compile_units)[idx]; 208 if (!cu_sp) 209 cu_sp = ParseCompileUnitAtIndex(idx); 210 return cu_sp; 211 } 212 213 void SymbolFileCommon::SetCompileUnitAtIndex(uint32_t idx, 214 const CompUnitSP &cu_sp) { 215 std::lock_guard<std::recursive_mutex> guard(GetModuleMutex()); 216 const size_t num_compile_units = GetNumCompileUnits(); 217 assert(idx < num_compile_units); 218 (void)num_compile_units; 219 220 // Fire off an assertion if this compile unit already exists for now. The 221 // partial parsing should take care of only setting the compile unit 222 // once, so if this assertion fails, we need to make sure that we don't 223 // have a race condition, or have a second parse of the same compile 224 // unit. 225 assert((*m_compile_units)[idx] == nullptr); 226 (*m_compile_units)[idx] = cu_sp; 227 } 228 229 llvm::Expected<TypeSystemSP> 230 SymbolFileCommon::GetTypeSystemForLanguage(lldb::LanguageType language) { 231 auto type_system_or_err = 232 m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language); 233 if (type_system_or_err) { 234 if (auto ts = *type_system_or_err) 235 ts->SetSymbolFile(this); 236 } 237 return type_system_or_err; 238 } 239 240 uint64_t SymbolFileCommon::GetDebugInfoSize() { 241 if (!m_objfile_sp) 242 return 0; 243 ModuleSP module_sp(m_objfile_sp->GetModule()); 244 if (!module_sp) 245 return 0; 246 const SectionList *section_list = module_sp->GetSectionList(); 247 if (section_list) 248 return section_list->GetDebugInfoSize(); 249 return 0; 250 } 251 252 void SymbolFileCommon::Dump(Stream &s) { 253 s.Format("SymbolFile {0} ({1})\n", GetPluginName(), 254 GetMainObjectFile()->GetFileSpec()); 255 s.PutCString("Types:\n"); 256 m_type_list.Dump(&s, /*show_context*/ false); 257 s.PutChar('\n'); 258 259 s.PutCString("Compile units:\n"); 260 if (m_compile_units) { 261 for (const CompUnitSP &cu_sp : *m_compile_units) { 262 // We currently only dump the compile units that have been parsed 263 if (cu_sp) 264 cu_sp->Dump(&s, /*show_context*/ false); 265 } 266 } 267 s.PutChar('\n'); 268 269 if (Symtab *symtab = GetSymtab()) 270 symtab->Dump(&s, nullptr, eSortOrderNone); 271 } 272