LLDB mainline
SymbolFile.cpp
Go to the documentation of this file.
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
10
11#include "lldb/Core/Module.h"
16#include "lldb/Symbol/TypeMap.h"
19#include "lldb/Utility/Log.h"
21#include "lldb/lldb-private.h"
22
23#include <future>
24
25using namespace lldb_private;
26using namespace lldb;
27
30
32 // No-op for most implementations.
33}
34
35std::recursive_mutex &SymbolFile::GetModuleMutex() const {
36 return GetObjectFile()->GetModule()->GetMutex();
37}
38
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;
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
107uint32_t
109 lldb::SymbolContextItem resolve_scope,
110 SymbolContextList &sc_list) {
111 return 0;
112}
113
115 const CompilerDeclContext &parent_decl_ctx,
116 uint32_t max_matches,
117 VariableList &variables) {}
118
120 uint32_t max_matches,
121 VariableList &variables) {}
122
124 const CompilerDeclContext &parent_decl_ctx,
125 bool include_inlines,
126 SymbolContextList &sc_list) {}
127
129 bool include_inlines,
130 SymbolContextList &sc_list) {}
131
133 const std::string &scope_qualified_name,
134 std::vector<ConstString> &mangled_names) {}
135
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
142void SymbolFile::FindTypes(llvm::ArrayRef<CompilerContext> pattern,
143 LanguageSet languages,
144 llvm::DenseSet<SymbolFile *> &searched_symbol_files,
145 TypeMap &types) {}
146
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
164
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)
175 }
176 return m_symtab;
177}
178
180 return m_objfile_sp->GetModule()->GetObjectFile();
181}
182
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
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.
198 }
199 return m_compile_units->size();
200}
201
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
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
229llvm::Expected<TypeSystemSP>
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
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
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}
Represents a generic declaration context in a program.
A uniqued constant string class.
Definition: ConstString.h:40
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
static ModuleListProperties & GetGlobalModuleListProperties()
Definition: ModuleList.cpp:751
A class that encapsulates name lookup information.
Definition: Module.h:949
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
Symtab * GetSymtab()
Gets the symbol table for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:727
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:53
@ eTypeDebugInfo
An object file that contains only debug information.
Definition: ObjectFile.h:55
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition: ObjectFile.h:61
virtual void SectionFileAddressesChanged()
Notify the ObjectFile that the file addresses in the Sections for this module have been changed.
Definition: ObjectFile.h:304
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:590
virtual llvm::StringRef GetPluginName()=0
static SymbolFileCreateInstance GetSymbolFileCreateCallbackAtIndex(uint32_t idx)
uint64_t GetDebugInfoSize() const
Get the debug information size from all sections that contain debug information.
Definition: Section.cpp:671
"lldb/Core/SourceLocationSpec.h" A source location specifier class.
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
void Format(const char *format, Args &&... args)
Definition: Stream.h:309
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
size_t PutChar(char ch)
Definition: Stream.cpp:104
Defines a list of symbol context objects.
lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) override
Definition: SymbolFile.cpp:202
ObjectFile * GetObjectFile() override
Definition: SymbolFile.h:498
std::optional< std::vector< lldb::CompUnitSP > > m_compile_units
Definition: SymbolFile.h:578
uint64_t GetDebugInfoSize() override
Metrics gathering functions.
Definition: SymbolFile.cpp:240
lldb::ObjectFileSP m_objfile_sp
Definition: SymbolFile.h:574
Symtab * GetSymtab() override
Definition: SymbolFile.cpp:165
virtual lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t idx)=0
ObjectFile * GetMainObjectFile() override
Definition: SymbolFile.cpp:179
Symtab * m_symtab
Do not use m_symtab directly, as it may be freed.
Definition: SymbolFile.h:595
static char ID
LLVM RTTI support.
Definition: SymbolFile.h:471
void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp)
Definition: SymbolFile.cpp:213
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language) override
Definition: SymbolFile.cpp:230
uint32_t GetNumCompileUnits() override
Definition: SymbolFile.cpp:192
void SectionFileAddressesChanged() override
Notify the SymbolFile that the file addresses in the Sections for this module have been changed.
Definition: SymbolFile.cpp:183
virtual uint32_t CalculateNumCompileUnits()=0
void Dump(Stream &s) override
Definition: SymbolFile.cpp:252
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:49
virtual void PreloadSymbols()
Definition: SymbolFile.cpp:31
virtual void FindGlobalVariables(ConstString name, const CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, VariableList &variables)
Definition: SymbolFile.cpp:114
static SymbolFile * FindPlugin(lldb::ObjectFileSP objfile_sp)
Definition: SymbolFile.cpp:39
virtual std::recursive_mutex & GetModuleMutex() const
Symbols file subclasses should override this to return the Module that owns the TypeSystem that this ...
Definition: SymbolFile.cpp:35
virtual void FindTypes(ConstString name, const CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, llvm::DenseSet< lldb_private::SymbolFile * > &searched_symbol_files, TypeMap &types)
Definition: SymbolFile.cpp:136
virtual void AddSymbols(Symtab &symtab)
Definition: SymbolFile.h:353
static char ID
LLVM RTTI support.
Definition: SymbolFile.h:51
virtual void FindFunctions(const Module::LookupInfo &lookup_info, const CompilerDeclContext &parent_decl_ctx, bool include_inlines, SymbolContextList &sc_list)
Definition: SymbolFile.cpp:123
virtual ObjectFile * GetObjectFile()=0
virtual uint32_t ResolveSymbolContext(const Address &so_addr, lldb::SymbolContextItem resolve_scope, SymbolContext &sc)=0
virtual void GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector< ConstString > &mangled_names)
Definition: SymbolFile.cpp:132
void Dump(Stream *s, bool show_context)
Definition: TypeList.cpp:94
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
SymbolFile *(* SymbolFileCreateInstance)(lldb::ObjectFileSP objfile_sp)
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::ObjectFile > ObjectFileSP
Definition: lldb-forward.h:356
LanguageType
Programming language type.
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:354
std::shared_ptr< lldb_private::CompileUnit > CompUnitSP
Definition: lldb-forward.h:317
A SmallBitVector that represents a set of source languages (lldb::LanguageType).
Definition: TypeSystem.h:45