1 //===-- SymbolVendor.cpp ----------------------------------------*- C++ -*-===//
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/SymbolVendor.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/SymbolFile.h"
16 #include "lldb/Utility/Stream.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 //----------------------------------------------------------------------
22 // FindPlugin
23 //
24 // Platforms can register a callback to use when creating symbol vendors to
25 // allow for complex debug information file setups, and to also allow for
26 // finding separate debug information files.
27 //----------------------------------------------------------------------
28 SymbolVendor *SymbolVendor::FindPlugin(const lldb::ModuleSP &module_sp,
29                                        lldb_private::Stream *feedback_strm) {
30   std::unique_ptr<SymbolVendor> instance_up;
31   SymbolVendorCreateInstance create_callback;
32 
33   for (size_t idx = 0;
34        (create_callback = PluginManager::GetSymbolVendorCreateCallbackAtIndex(
35             idx)) != nullptr;
36        ++idx) {
37     instance_up.reset(create_callback(module_sp, feedback_strm));
38 
39     if (instance_up) {
40       return instance_up.release();
41     }
42   }
43   // The default implementation just tries to create debug information using
44   // the file representation for the module.
45   ObjectFileSP sym_objfile_sp;
46   FileSpec sym_spec = module_sp->GetSymbolFileFileSpec();
47   if (sym_spec && sym_spec != module_sp->GetObjectFile()->GetFileSpec()) {
48     DataBufferSP data_sp;
49     offset_t data_offset = 0;
50     sym_objfile_sp = ObjectFile::FindPlugin(
51         module_sp, &sym_spec, 0, FileSystem::Instance().GetByteSize(sym_spec),
52         data_sp, data_offset);
53   }
54   if (!sym_objfile_sp)
55     sym_objfile_sp = module_sp->GetObjectFile()->shared_from_this();
56   instance_up.reset(new SymbolVendor(module_sp));
57   instance_up->AddSymbolFileRepresentation(sym_objfile_sp);
58   return instance_up.release();
59 }
60 
61 //----------------------------------------------------------------------
62 // SymbolVendor constructor
63 //----------------------------------------------------------------------
64 SymbolVendor::SymbolVendor(const lldb::ModuleSP &module_sp)
65     : ModuleChild(module_sp), m_type_list(), m_compile_units(), m_sym_file_up(),
66       m_symtab() {}
67 
68 //----------------------------------------------------------------------
69 // Destructor
70 //----------------------------------------------------------------------
71 SymbolVendor::~SymbolVendor() {}
72 
73 //----------------------------------------------------------------------
74 // Add a representation given an object file.
75 //----------------------------------------------------------------------
76 void SymbolVendor::AddSymbolFileRepresentation(const ObjectFileSP &objfile_sp) {
77   ModuleSP module_sp(GetModule());
78   if (module_sp) {
79     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
80     if (objfile_sp) {
81       m_objfile_sp = objfile_sp;
82       m_sym_file_up.reset(SymbolFile::FindPlugin(objfile_sp.get()));
83     }
84   }
85 }
86 
87 bool SymbolVendor::SetCompileUnitAtIndex(size_t idx, const CompUnitSP &cu_sp) {
88   ModuleSP module_sp(GetModule());
89   if (module_sp) {
90     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
91     const size_t num_compile_units = GetNumCompileUnits();
92     if (idx < num_compile_units) {
93       // Fire off an assertion if this compile unit already exists for now. The
94       // partial parsing should take care of only setting the compile unit
95       // once, so if this assertion fails, we need to make sure that we don't
96       // have a race condition, or have a second parse of the same compile
97       // unit.
98       assert(m_compile_units[idx].get() == nullptr);
99       m_compile_units[idx] = cu_sp;
100       return true;
101     } else {
102       // This should NOT happen, and if it does, we want to crash and know
103       // about it
104       assert(idx < num_compile_units);
105     }
106   }
107   return false;
108 }
109 
110 size_t SymbolVendor::GetNumCompileUnits() {
111   ModuleSP module_sp(GetModule());
112   if (module_sp) {
113     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
114     if (m_compile_units.empty()) {
115       if (m_sym_file_up) {
116         // Resize our array of compile unit shared pointers -- which will each
117         // remain NULL until someone asks for the actual compile unit
118         // information. When this happens, the symbol file will be asked to
119         // parse this compile unit information.
120         m_compile_units.resize(m_sym_file_up->GetNumCompileUnits());
121       }
122     }
123   }
124   return m_compile_units.size();
125 }
126 
127 lldb::LanguageType SymbolVendor::ParseLanguage(CompileUnit &comp_unit) {
128   ModuleSP module_sp(GetModule());
129   if (module_sp) {
130     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
131     if (m_sym_file_up)
132       return m_sym_file_up->ParseLanguage(comp_unit);
133   }
134   return eLanguageTypeUnknown;
135 }
136 
137 size_t SymbolVendor::ParseFunctions(CompileUnit &comp_unit) {
138   ModuleSP module_sp(GetModule());
139   if (module_sp) {
140     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
141     if (m_sym_file_up)
142       return m_sym_file_up->ParseFunctions(comp_unit);
143   }
144   return 0;
145 }
146 
147 bool SymbolVendor::ParseLineTable(CompileUnit &comp_unit) {
148   ModuleSP module_sp(GetModule());
149   if (module_sp) {
150     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
151     if (m_sym_file_up)
152       return m_sym_file_up->ParseLineTable(comp_unit);
153   }
154   return false;
155 }
156 
157 bool SymbolVendor::ParseDebugMacros(CompileUnit &comp_unit) {
158   ModuleSP module_sp(GetModule());
159   if (module_sp) {
160     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
161     if (m_sym_file_up)
162       return m_sym_file_up->ParseDebugMacros(comp_unit);
163   }
164   return false;
165 }
166 bool SymbolVendor::ParseSupportFiles(CompileUnit &comp_unit,
167                                      FileSpecList &support_files) {
168   ModuleSP module_sp(GetModule());
169   if (module_sp) {
170     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
171     if (m_sym_file_up)
172       return m_sym_file_up->ParseSupportFiles(comp_unit, support_files);
173   }
174   return false;
175 }
176 
177 bool SymbolVendor::ParseIsOptimized(CompileUnit &comp_unit) {
178   ModuleSP module_sp(GetModule());
179   if (module_sp) {
180     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
181     if (m_sym_file_up)
182       return m_sym_file_up->ParseIsOptimized(comp_unit);
183   }
184   return false;
185 }
186 
187 bool SymbolVendor::ParseImportedModules(
188     const SymbolContext &sc, std::vector<SourceModule> &imported_modules) {
189   ModuleSP module_sp(GetModule());
190   if (module_sp) {
191     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
192     if (m_sym_file_up)
193       return m_sym_file_up->ParseImportedModules(sc, imported_modules);
194   }
195   return false;
196 }
197 
198 size_t SymbolVendor::ParseBlocksRecursive(Function &func) {
199   ModuleSP module_sp(GetModule());
200   if (module_sp) {
201     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
202     if (m_sym_file_up)
203       return m_sym_file_up->ParseBlocksRecursive(func);
204   }
205   return 0;
206 }
207 
208 size_t SymbolVendor::ParseTypes(CompileUnit &comp_unit) {
209   ModuleSP module_sp(GetModule());
210   if (module_sp) {
211     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
212     if (m_sym_file_up)
213       return m_sym_file_up->ParseTypes(comp_unit);
214   }
215   return 0;
216 }
217 
218 size_t SymbolVendor::ParseVariablesForContext(const SymbolContext &sc) {
219   ModuleSP module_sp(GetModule());
220   if (module_sp) {
221     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
222     if (m_sym_file_up)
223       return m_sym_file_up->ParseVariablesForContext(sc);
224   }
225   return 0;
226 }
227 
228 Type *SymbolVendor::ResolveTypeUID(lldb::user_id_t type_uid) {
229   ModuleSP module_sp(GetModule());
230   if (module_sp) {
231     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
232     if (m_sym_file_up)
233       return m_sym_file_up->ResolveTypeUID(type_uid);
234   }
235   return nullptr;
236 }
237 
238 uint32_t SymbolVendor::ResolveSymbolContext(const Address &so_addr,
239                                             SymbolContextItem resolve_scope,
240                                             SymbolContext &sc) {
241   ModuleSP module_sp(GetModule());
242   if (module_sp) {
243     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
244     if (m_sym_file_up)
245       return m_sym_file_up->ResolveSymbolContext(so_addr, resolve_scope, sc);
246   }
247   return 0;
248 }
249 
250 uint32_t SymbolVendor::ResolveSymbolContext(const FileSpec &file_spec,
251                                             uint32_t line, bool check_inlines,
252                                             SymbolContextItem resolve_scope,
253                                             SymbolContextList &sc_list) {
254   ModuleSP module_sp(GetModule());
255   if (module_sp) {
256     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
257     if (m_sym_file_up)
258       return m_sym_file_up->ResolveSymbolContext(file_spec, line, check_inlines,
259                                                  resolve_scope, sc_list);
260   }
261   return 0;
262 }
263 
264 size_t
265 SymbolVendor::FindGlobalVariables(const ConstString &name,
266                                   const CompilerDeclContext *parent_decl_ctx,
267                                   size_t max_matches, VariableList &variables) {
268   ModuleSP module_sp(GetModule());
269   if (module_sp) {
270     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
271     if (m_sym_file_up)
272       return m_sym_file_up->FindGlobalVariables(name, parent_decl_ctx,
273                                                 max_matches, variables);
274   }
275   return 0;
276 }
277 
278 size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex,
279                                          size_t max_matches,
280                                          VariableList &variables) {
281   ModuleSP module_sp(GetModule());
282   if (module_sp) {
283     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
284     if (m_sym_file_up)
285       return m_sym_file_up->FindGlobalVariables(regex, max_matches, variables);
286   }
287   return 0;
288 }
289 
290 size_t SymbolVendor::FindFunctions(const ConstString &name,
291                                    const CompilerDeclContext *parent_decl_ctx,
292                                    FunctionNameType name_type_mask,
293                                    bool include_inlines, bool append,
294                                    SymbolContextList &sc_list) {
295   ModuleSP module_sp(GetModule());
296   if (module_sp) {
297     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
298     if (m_sym_file_up)
299       return m_sym_file_up->FindFunctions(name, parent_decl_ctx, name_type_mask,
300                                           include_inlines, append, sc_list);
301   }
302   return 0;
303 }
304 
305 size_t SymbolVendor::FindFunctions(const RegularExpression &regex,
306                                    bool include_inlines, bool append,
307                                    SymbolContextList &sc_list) {
308   ModuleSP module_sp(GetModule());
309   if (module_sp) {
310     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
311     if (m_sym_file_up)
312       return m_sym_file_up->FindFunctions(regex, include_inlines, append,
313                                           sc_list);
314   }
315   return 0;
316 }
317 
318 size_t SymbolVendor::FindTypes(
319     const ConstString &name, const CompilerDeclContext *parent_decl_ctx,
320     bool append, size_t max_matches,
321     llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
322     TypeMap &types) {
323   ModuleSP module_sp(GetModule());
324   if (module_sp) {
325     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
326     if (m_sym_file_up)
327       return m_sym_file_up->FindTypes(name, parent_decl_ctx, append,
328                                       max_matches, searched_symbol_files,
329                                       types);
330   }
331   if (!append)
332     types.Clear();
333   return 0;
334 }
335 
336 size_t SymbolVendor::FindTypes(const std::vector<CompilerContext> &context,
337                                bool append, TypeMap &types) {
338   ModuleSP module_sp(GetModule());
339   if (module_sp) {
340     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
341     if (m_sym_file_up)
342       return m_sym_file_up->FindTypes(context, append, types);
343   }
344   if (!append)
345     types.Clear();
346   return 0;
347 }
348 
349 size_t SymbolVendor::GetTypes(SymbolContextScope *sc_scope, TypeClass type_mask,
350                               lldb_private::TypeList &type_list) {
351   ModuleSP module_sp(GetModule());
352   if (module_sp) {
353     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
354     if (m_sym_file_up)
355       return m_sym_file_up->GetTypes(sc_scope, type_mask, type_list);
356   }
357   return 0;
358 }
359 
360 CompilerDeclContext
361 SymbolVendor::FindNamespace(const ConstString &name,
362                             const CompilerDeclContext *parent_decl_ctx) {
363   CompilerDeclContext namespace_decl_ctx;
364   ModuleSP module_sp(GetModule());
365   if (module_sp) {
366     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
367     if (m_sym_file_up)
368       namespace_decl_ctx = m_sym_file_up->FindNamespace(name, parent_decl_ctx);
369   }
370   return namespace_decl_ctx;
371 }
372 
373 void SymbolVendor::Dump(Stream *s) {
374   ModuleSP module_sp(GetModule());
375   if (module_sp) {
376     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
377 
378     bool show_context = false;
379 
380     s->Printf("%p: ", static_cast<void *>(this));
381     s->Indent();
382     s->PutCString("SymbolVendor");
383     if (m_sym_file_up) {
384       *s << " " << m_sym_file_up->GetPluginName();
385       ObjectFile *objfile = m_sym_file_up->GetObjectFile();
386       if (objfile) {
387         const FileSpec &objfile_file_spec = objfile->GetFileSpec();
388         if (objfile_file_spec) {
389           s->PutCString(" (");
390           objfile_file_spec.Dump(s);
391           s->PutChar(')');
392         }
393       }
394     }
395     s->EOL();
396     if (m_sym_file_up)
397       m_sym_file_up->Dump(*s);
398     s->IndentMore();
399     m_type_list.Dump(s, show_context);
400 
401     CompileUnitConstIter cu_pos, cu_end;
402     cu_end = m_compile_units.end();
403     for (cu_pos = m_compile_units.begin(); cu_pos != cu_end; ++cu_pos) {
404       // We currently only dump the compile units that have been parsed
405       if (*cu_pos)
406         (*cu_pos)->Dump(s, show_context);
407     }
408 
409     if (Symtab *symtab = GetSymtab())
410       symtab->Dump(s, nullptr, eSortOrderNone);
411 
412     s->IndentLess();
413   }
414 }
415 
416 CompUnitSP SymbolVendor::GetCompileUnitAtIndex(size_t idx) {
417   CompUnitSP cu_sp;
418   ModuleSP module_sp(GetModule());
419   if (module_sp) {
420     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
421     const size_t num_compile_units = GetNumCompileUnits();
422     if (idx < num_compile_units) {
423       cu_sp = m_compile_units[idx];
424       if (cu_sp.get() == nullptr) {
425         m_compile_units[idx] = m_sym_file_up->ParseCompileUnitAtIndex(idx);
426         cu_sp = m_compile_units[idx];
427       }
428     }
429   }
430   return cu_sp;
431 }
432 
433 FileSpec SymbolVendor::GetMainFileSpec() const {
434   if (m_sym_file_up) {
435     const ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
436     if (symfile_objfile)
437       return symfile_objfile->GetFileSpec();
438   }
439 
440   return FileSpec();
441 }
442 
443 Symtab *SymbolVendor::GetSymtab() {
444   ModuleSP module_sp(GetModule());
445   if (!module_sp)
446     return nullptr;
447 
448   std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
449 
450   if (m_symtab)
451     return m_symtab;
452 
453   ObjectFile *objfile = module_sp->GetObjectFile();
454   if (!objfile)
455     return nullptr;
456 
457   m_symtab = objfile->GetSymtab();
458   if (m_symtab && m_sym_file_up)
459     m_sym_file_up->AddSymbols(*m_symtab);
460 
461   return m_symtab;
462 }
463 
464 void SymbolVendor::ClearSymtab() {
465   ModuleSP module_sp(GetModule());
466   if (module_sp) {
467     ObjectFile *objfile = module_sp->GetObjectFile();
468     if (objfile) {
469       // Clear symbol table from unified section list.
470       objfile->ClearSymtab();
471     }
472   }
473 }
474 
475 void SymbolVendor::SectionFileAddressesChanged() {
476   ModuleSP module_sp(GetModule());
477   if (module_sp) {
478     ObjectFile *module_objfile = module_sp->GetObjectFile();
479     if (m_sym_file_up) {
480       ObjectFile *symfile_objfile = m_sym_file_up->GetObjectFile();
481       if (symfile_objfile != module_objfile)
482         symfile_objfile->SectionFileAddressesChanged();
483     }
484     Symtab *symtab = GetSymtab();
485     if (symtab) {
486       symtab->SectionFileAddressesChanged();
487     }
488   }
489 }
490 
491 //------------------------------------------------------------------
492 // PluginInterface protocol
493 //------------------------------------------------------------------
494 lldb_private::ConstString SymbolVendor::GetPluginName() {
495   static ConstString g_name("vendor-default");
496   return g_name;
497 }
498 
499 uint32_t SymbolVendor::GetPluginVersion() { return 1; }
500