LLDB mainline
CompileUnit.cpp
Go to the documentation of this file.
1//===-- CompileUnit.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#include "lldb/Core/Module.h"
15#include "lldb/Utility/Timer.h"
16#include <optional>
17
18using namespace lldb;
19using namespace lldb_private;
20
21CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
22 const char *pathname, const lldb::user_id_t cu_sym_id,
23 lldb::LanguageType language,
24 lldb_private::LazyBool is_optimized)
25 : CompileUnit(module_sp, user_data, FileSpec(pathname), cu_sym_id, language,
26 is_optimized) {}
27
28CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
29 const FileSpec &fspec, const lldb::user_id_t cu_sym_id,
30 lldb::LanguageType language,
31 lldb_private::LazyBool is_optimized)
32 : ModuleChild(module_sp), UserID(cu_sym_id), m_user_data(user_data),
33 m_language(language), m_flags(0), m_file_spec(fspec),
34 m_is_optimized(is_optimized) {
35 if (language != eLanguageTypeUnknown)
37 assert(module_sp);
38}
39
41 sc->comp_unit = this;
42 GetModule()->CalculateSymbolContext(sc);
43}
44
46
48
50 GetModule()->DumpSymbolContext(s);
51 s->Printf(", CompileUnit{0x%8.8" PRIx64 "}", GetID());
52}
53
55 lldb::DescriptionLevel level) const {
56 const char *language = GetCachedLanguage();
57 *s << "id = " << (const UserID &)*this << ", file = \""
58 << this->GetPrimaryFile() << "\", language = \"" << language << '"';
59}
60
62 llvm::function_ref<bool(const FunctionSP &)> lambda) const {
63 std::vector<lldb::FunctionSP> sorted_functions;
64 sorted_functions.reserve(m_functions_by_uid.size());
65 for (auto &p : m_functions_by_uid)
66 sorted_functions.push_back(p.second);
67 llvm::sort(sorted_functions,
68 [](const lldb::FunctionSP &a, const lldb::FunctionSP &b) {
69 return a->GetID() < b->GetID();
70 });
71
72 for (auto &f : sorted_functions)
73 if (lambda(f))
74 return;
75}
76
78 llvm::function_ref<bool(const FunctionSP &)> matching_lambda) {
80
82
83 if (!module)
84 return {};
85
86 SymbolFile *symbol_file = module->GetSymbolFile();
87
88 if (!symbol_file)
89 return {};
90
91 // m_functions_by_uid is filled in lazily but we need all the entries.
92 symbol_file->ParseFunctions(*this);
93
94 for (auto &p : m_functions_by_uid) {
95 if (matching_lambda(p.second))
96 return p.second;
97 }
98 return {};
99}
100
103 return "<not loaded>";
105}
106
107// Dump the current contents of this object. No functions that cause on demand
108// parsing of functions, globals, statics are called, so this is a good
109// function to call to get an idea of the current contents of the CompileUnit
110// object.
111void CompileUnit::Dump(Stream *s, bool show_context) const {
112 const char *language = GetCachedLanguage();
113
114 s->Printf("%p: ", static_cast<const void *>(this));
115 s->Indent();
116 *s << "CompileUnit" << static_cast<const UserID &>(*this) << ", language = \""
117 << language << "\", file = '" << GetPrimaryFile() << "'\n";
118
119 // m_types.Dump(s);
120
121 if (m_variables.get()) {
122 s->IndentMore();
123 m_variables->Dump(s, show_context);
124 s->IndentLess();
125 }
126
127 if (!m_functions_by_uid.empty()) {
128 s->IndentMore();
129 ForeachFunction([&s, show_context](const FunctionSP &f) {
130 f->Dump(s, show_context);
131 return false;
132 });
133
134 s->IndentLess();
135 s->EOL();
136 }
137}
138
139// Add a function to this compile unit
141 m_functions_by_uid[funcSP->GetID()] = funcSP;
142}
143
145 auto it = m_functions_by_uid.find(func_uid);
146 if (it == m_functions_by_uid.end())
147 return FunctionSP();
148 return it->second;
149}
150
155 if (SymbolFile *symfile = GetModule()->GetSymbolFile())
156 m_language = symfile->ParseLanguage(*this);
157 }
158 }
159 return m_language;
160}
161
163 if (m_line_table_up == nullptr) {
166 if (SymbolFile *symfile = GetModule()->GetSymbolFile())
167 symfile->ParseLineTable(*this);
168 }
169 }
170 return m_line_table_up.get();
171}
172
174 if (line_table == nullptr)
176 else
178 m_line_table_up.reset(line_table);
179}
180
182 m_support_files = std::move(support_files);
183}
184
186 if (m_debug_macros_sp.get() == nullptr) {
189 if (SymbolFile *symfile = GetModule()->GetSymbolFile())
190 symfile->ParseDebugMacros(*this);
191 }
192 }
193
194 return m_debug_macros_sp.get();
195}
196
197void CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp) {
198 if (debug_macros_sp.get() == nullptr)
200 else
202 m_debug_macros_sp = debug_macros_sp;
203}
204
206 if (m_variables.get() == nullptr && can_create) {
207 SymbolContext sc;
209 assert(sc.module_sp);
210 sc.module_sp->GetSymbolFile()->ParseVariablesForContext(sc);
211 }
212
213 return m_variables;
214}
215
216std::vector<uint32_t> FindFileIndexes(const FileSpecList &files,
217 const FileSpec &file) {
218 std::vector<uint32_t> result;
219 uint32_t idx = -1;
220 while ((idx = files.FindCompatibleIndex(idx + 1, file)) !=
222 result.push_back(idx);
223 return result;
224}
225
226uint32_t CompileUnit::FindLineEntry(uint32_t start_idx, uint32_t line,
227 const FileSpec *file_spec_ptr, bool exact,
228 LineEntry *line_entry_ptr) {
229 if (!file_spec_ptr)
230 file_spec_ptr = &GetPrimaryFile();
231 std::vector<uint32_t> file_indexes = FindFileIndexes(GetSupportFiles(),
232 *file_spec_ptr);
233 if (file_indexes.empty())
234 return UINT32_MAX;
235
236 // TODO: Handle SourceLocationSpec column information
237 SourceLocationSpec location_spec(*file_spec_ptr, line,
238 /*column=*/std::nullopt,
239 /*check_inlines=*/false, exact);
240
241 LineTable *line_table = GetLineTable();
242 if (line_table)
243 return line_table->FindLineEntryIndexByFileIndex(
244 start_idx, file_indexes, location_spec, line_entry_ptr);
245 return UINT32_MAX;
246}
247
249 const SourceLocationSpec &src_location_spec,
250 SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
251 const FileSpec file_spec = src_location_spec.GetFileSpec();
252 const uint32_t line = src_location_spec.GetLine().value_or(0);
253 const bool check_inlines = src_location_spec.GetCheckInlines();
254
255 // First find all of the file indexes that match our "file_spec". If
256 // "file_spec" has an empty directory, then only compare the basenames when
257 // finding file indexes
258 bool file_spec_matches_cu_file_spec =
259 FileSpec::Match(file_spec, this->GetPrimaryFile());
260
261 // If we are not looking for inlined functions and our file spec doesn't
262 // match then we are done...
263 if (!file_spec_matches_cu_file_spec && !check_inlines)
264 return;
265
267 sc.comp_unit = this;
268
269 if (line == 0) {
270 if (file_spec_matches_cu_file_spec && !check_inlines) {
271 // only append the context if we aren't looking for inline call sites by
272 // file and line and if the file spec matches that of the compile unit
273 sc_list.Append(sc);
274 }
275 return;
276 }
277
278 std::vector<uint32_t> file_indexes = FindFileIndexes(GetSupportFiles(),
279 file_spec);
280 const size_t num_file_indexes = file_indexes.size();
281 if (num_file_indexes == 0)
282 return;
283
284 // Found a matching source file in this compile unit load its debug info.
285 GetModule()->GetSymbolFile()->SetLoadDebugInfoEnabled();
286
287 LineTable *line_table = sc.comp_unit->GetLineTable();
288
289 if (line_table == nullptr) {
290 if (file_spec_matches_cu_file_spec && !check_inlines) {
291 sc_list.Append(sc);
292 }
293 return;
294 }
295
296 uint32_t line_idx;
297 LineEntry line_entry;
298
299 if (num_file_indexes == 1) {
300 // We only have a single support file that matches, so use the line
301 // table function that searches for a line entries that match a single
302 // support file index
303 line_idx = line_table->FindLineEntryIndexByFileIndex(
304 0, file_indexes.front(), src_location_spec, &line_entry);
305 } else {
306 // We found multiple support files that match "file_spec" so use the
307 // line table function that searches for a line entries that match a
308 // multiple support file indexes.
309 line_idx = line_table->FindLineEntryIndexByFileIndex(
310 0, file_indexes, src_location_spec, &line_entry);
311 }
312
313 // If "exact == true", then "found_line" will be the same as "line". If
314 // "exact == false", the "found_line" will be the closest line entry
315 // with a line number greater than "line" and we will use this for our
316 // subsequent line exact matches below.
317 const bool inlines = false;
318 const bool exact = true;
319 const std::optional<uint16_t> column =
320 src_location_spec.GetColumn() ? std::optional<uint16_t>(line_entry.column)
321 : std::nullopt;
322
323 SourceLocationSpec found_entry(line_entry.file, line_entry.line, column,
324 inlines, exact);
325
326 while (line_idx != UINT32_MAX) {
327 // If they only asked for the line entry, then we're done, we can
328 // just copy that over. But if they wanted more than just the line
329 // number, fill it in.
330 SymbolContext resolved_sc;
331 sc.line_entry = line_entry;
332 if (resolve_scope == eSymbolContextLineEntry) {
333 sc_list.Append(sc);
334 } else {
335 line_entry.range.GetBaseAddress().CalculateSymbolContext(&resolved_sc,
336 resolve_scope);
337 // Sometimes debug info is bad and isn't able to resolve the line entry's
338 // address back to the same compile unit and/or line entry. If the compile
339 // unit changed, then revert back to just the compile unit and line entry.
340 // Prior to this fix, the above code might end up not being able to lookup
341 // the address, and then it would clear compile unit and the line entry in
342 // the symbol context and the breakpoint would fail to get set even though
343 // we have a valid line table entry in this compile unit. The address
344 // lookup can also end up finding another function in another compiler
345 // unit if the DWARF has overlappging address ranges. So if we end up with
346 // no compile unit or a different one after the above function call,
347 // revert back to the same results as if resolve_scope was set exactly to
348 // eSymbolContextLineEntry.
349 if (resolved_sc.comp_unit == this) {
350 sc_list.Append(resolved_sc);
351 } else {
352 if (resolved_sc.comp_unit == nullptr && resolved_sc.module_sp) {
353 // Only report an error if we don't map back to any compile unit. With
354 // link time optimizations, the debug info might have many compile
355 // units that have the same address range due to function outlining
356 // or other link time optimizations. If the compile unit is NULL, then
357 // address resolving is completely failing and more deserving of an
358 // error message the user can see.
359 resolved_sc.module_sp->ReportError(
360 "unable to resolve a line table file address {0:x16} back "
361 "to a compile unit, please file a bug and attach the address "
362 "and file.",
363 line_entry.range.GetBaseAddress().GetFileAddress());
364 }
365 sc_list.Append(sc);
366 }
367 }
368
369 if (num_file_indexes == 1)
370 line_idx = line_table->FindLineEntryIndexByFileIndex(
371 line_idx + 1, file_indexes.front(), found_entry, &line_entry);
372 else
373 line_idx = line_table->FindLineEntryIndexByFileIndex(
374 line_idx + 1, file_indexes, found_entry, &line_entry);
375 }
376}
377
381 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
382 if (symfile->ParseIsOptimized(*this))
384 }
385 }
386 return m_is_optimized;
387}
388
390 m_variables = variables;
391}
392
393const std::vector<SourceModule> &CompileUnit::GetImportedModules() {
394 if (m_imported_modules.empty() &&
397 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
398 SymbolContext sc;
400 symfile->ParseImportedModules(sc, m_imported_modules);
401 }
402 }
403 return m_imported_modules;
404}
405
407 llvm::DenseSet<SymbolFile *> &visited_symbol_files,
408 llvm::function_ref<bool(Module &)> lambda) {
409 if (SymbolFile *symfile = GetModule()->GetSymbolFile())
410 return symfile->ForEachExternalModule(*this, visited_symbol_files, lambda);
411 return false;
412}
413
415 if (m_support_files.GetSize() == 0) {
418 if (SymbolFile *symfile = GetModule()->GetSymbolFile())
419 symfile->ParseSupportFiles(*this, m_support_files);
420 }
421 }
422 return m_support_files;
423}
424
425void *CompileUnit::GetUserData() const { return m_user_data; }
std::vector< uint32_t > FindFileIndexes(const FileSpecList &files, const FileSpec &file)
#define LLDB_SCOPED_TIMER()
Definition: Timer.h:83
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
uint32_t CalculateSymbolContext(SymbolContext *sc, lldb::SymbolContextItem resolve_scope=lldb::eSymbolContextEverything) const
Reconstruct a symbol context from an address.
Definition: Address.cpp:825
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
A class that describes a compilation unit.
Definition: CompileUnit.h:41
void SetVariableList(lldb::VariableListSP &variable_list_sp)
Set accessor for the variable list.
void Dump(Stream *s, bool show_context) const
Dump the compile unit contents to the stream s.
lldb::LanguageType m_language
The programming language enumeration value.
Definition: CompileUnit.h:403
const std::vector< SourceModule > & GetImportedModules()
Get the compile unit's imported module list.
lldb::VariableListSP GetVariableList(bool can_create)
Get the variable list for a compile unit.
lldb_private::LazyBool m_is_optimized
eLazyBoolYes if this compile unit was compiled with optimization.
Definition: CompileUnit.h:424
void SetDebugMacros(const DebugMacrosSP &debug_macros)
const FileSpec & GetPrimaryFile() const
Return the primary source file associated with this compile unit.
Definition: CompileUnit.h:227
void ResolveSymbolContext(const SourceLocationSpec &src_location_spec, lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list)
Resolve symbol contexts by file and line.
void ForeachFunction(llvm::function_ref< bool(const lldb::FunctionSP &)> lambda) const
Apply a lambda to each function in this compile unit.
Definition: CompileUnit.cpp:61
Flags m_flags
Compile unit flags that help with partial parsing.
Definition: CompileUnit.h:405
lldb::FunctionSP FindFunction(llvm::function_ref< bool(const lldb::FunctionSP &)> matching_lambda)
Find a function in the compile unit based on the predicate matching_lambda.
Definition: CompileUnit.cpp:77
void * GetUserData() const
Get the SymbolFile plug-in user data.
bool GetIsOptimized()
Get whether compiler optimizations were enabled for this compile unit.
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: CompileUnit.cpp:40
lldb::ModuleSP CalculateSymbolContextModule() override
Definition: CompileUnit.cpp:45
DebugMacros * GetDebugMacros()
void SetLineTable(LineTable *line_table)
Set the line table for the compile unit.
void SetSupportFiles(FileSpecList support_files)
virtual bool ForEachExternalModule(llvm::DenseSet< lldb_private::SymbolFile * > &visited_symbol_files, llvm::function_ref< bool(Module &)> lambda)
Apply a lambda to each external lldb::Module referenced by this compilation unit.
void DumpSymbolContext(Stream *s) override
Dump the object's symbol context to the stream s.
Definition: CompileUnit.cpp:49
void AddFunction(lldb::FunctionSP &function_sp)
Add a function to this compile unit.
lldb::FunctionSP FindFunctionByUID(lldb::user_id_t uid)
Finds a function by user ID.
DebugMacrosSP m_debug_macros_sp
Debug macros that will get parsed on demand.
Definition: CompileUnit.h:419
std::unique_ptr< LineTable > m_line_table_up
Line table that will get parsed on demand.
Definition: CompileUnit.h:417
const char * GetCachedLanguage() const
@ flagsParsedLanguage
Have we parsed the language already?
Definition: CompileUnit.h:436
@ flagsParsedSupportFiles
Have we already parsed the support files for this compile unit?
Definition: CompileUnit.h:432
@ flagsParsedImportedModules
Have we parsed the imported modules already?
Definition: CompileUnit.h:437
@ flagsParsedDebugMacros
Have we parsed the debug macros already?
Definition: CompileUnit.h:439
@ flagsParsedLineTable
Have we parsed the line table already?
Definition: CompileUnit.h:434
const FileSpecList & GetSupportFiles()
Get the compile unit's support file list.
CompileUnit * CalculateSymbolContextCompileUnit() override
Definition: CompileUnit.cpp:47
CompileUnit(const lldb::ModuleSP &module_sp, void *user_data, const char *pathname, lldb::user_id_t uid, lldb::LanguageType language, lldb_private::LazyBool is_optimized)
Construct with a module, path, UID and language.
Definition: CompileUnit.cpp:21
FileSpecList m_support_files
Files associated with this compile unit's line table and declarations.
Definition: CompileUnit.h:415
lldb::VariableListSP m_variables
Global and static variable list that will get parsed on demand.
Definition: CompileUnit.h:421
uint32_t FindLineEntry(uint32_t start_idx, uint32_t line, const FileSpec *file_spec_ptr, bool exact, LineEntry *line_entry)
Find the line entry by line and optional inlined file spec.
void GetDescription(Stream *s, lldb::DescriptionLevel level) const
Definition: CompileUnit.cpp:54
std::vector< SourceModule > m_imported_modules
All modules, including the current module, imported by this compile unit.
Definition: CompileUnit.h:410
lldb::LanguageType GetLanguage()
llvm::DenseMap< lldb::user_id_t, lldb::FunctionSP > m_functions_by_uid
Maps UIDs to functions.
Definition: CompileUnit.h:407
LineTable * GetLineTable()
Get the line table for the compile unit.
void * m_user_data
User data for the SymbolFile parser to store information into.
Definition: CompileUnit.h:401
A file collection class.
Definition: FileSpecList.h:24
size_t FindCompatibleIndex(size_t idx, const FileSpec &file) const
Find a compatible file index.
size_t GetSize() const
Get the number of files in the file list.
A file utility class.
Definition: FileSpec.h:57
static bool Match(const FileSpec &pattern, const FileSpec &file)
Match FileSpec pattern against FileSpec file.
Definition: FileSpec.cpp:304
bool IsClear(ValueType bit) const
Test a single flag bit to see if it is clear (zero).
Definition: Flags.h:111
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
Definition: Flags.h:61
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Definition: Flags.h:73
static const char * GetNameForLanguageType(lldb::LanguageType language)
Definition: Language.cpp:235
A line table class.
Definition: LineTable.h:40
uint32_t FindLineEntryIndexByFileIndex(uint32_t start_idx, uint32_t file_idx, const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr)
Find a line entry index that has a matching file index and source line number.
Definition: LineTable.cpp:305
A mix in class that contains a pointer back to the module that owns the object which inherits from it...
Definition: ModuleChild.h:19
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
"lldb/Core/SourceLocationSpec.h" A source location specifier class.
std::optional< uint32_t > GetLine() const
std::optional< uint16_t > GetColumn() const
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:171
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:168
Defines a list of symbol context objects.
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
lldb::ModuleSP module_sp
The Module for a given query.
CompileUnit * comp_unit
The CompileUnit for a given query.
LineEntry line_entry
The LineEntry for a given query.
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:50
virtual size_t ParseFunctions(CompileUnit &comp_unit)=0
#define UINT32_MAX
Definition: lldb-defines.h:19
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
std::shared_ptr< DebugMacros > DebugMacrosSP
Definition: DebugMacros.h:22
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Function > FunctionSP
Definition: lldb-forward.h:342
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
LanguageType
Programming language type.
@ eLanguageTypeUnknown
Unknown or invalid language value.
std::shared_ptr< lldb_private::VariableList > VariableListSP
Definition: lldb-forward.h:469
uint64_t user_id_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:360
A line table entry class.
Definition: LineEntry.h:20
uint16_t column
The column number of the source line, or zero if there is no column information.
Definition: LineEntry.h:146
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:140
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:139
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:143
A mix in class that contains a generic user ID.
Definition: UserID.h:31
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47