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 &regex,
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 &regex,
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