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 
9 #include "lldb/Symbol/CompileUnit.h"
10 #include "lldb/Core/Module.h"
11 #include "lldb/Symbol/LineTable.h"
12 #include "lldb/Symbol/SymbolFile.h"
13 #include "lldb/Symbol/VariableList.h"
14 #include "lldb/Target/Language.h"
15 #include "lldb/Utility/Timer.h"
16 #include <optional>
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 CompileUnit::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 
28 CompileUnit::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)
36     m_flags.Set(flagsParsedLanguage);
37   assert(module_sp);
38 }
39 
40 void CompileUnit::CalculateSymbolContext(SymbolContext *sc) {
41   sc->comp_unit = this;
42   GetModule()->CalculateSymbolContext(sc);
43 }
44 
45 ModuleSP CompileUnit::CalculateSymbolContextModule() { return GetModule(); }
46 
47 CompileUnit *CompileUnit::CalculateSymbolContextCompileUnit() { return this; }
48 
49 void CompileUnit::DumpSymbolContext(Stream *s) {
50   GetModule()->DumpSymbolContext(s);
51   s->Printf(", CompileUnit{0x%8.8" PRIx64 "}", GetID());
52 }
53 
54 void CompileUnit::GetDescription(Stream *s,
55                                  lldb::DescriptionLevel level) const {
56   const char *language = GetCachedLanguage();
57   *s << "id = " << (const UserID &)*this << ", file = \""
58      << this->GetPrimaryFile() << "\", language = \"" << language << '"';
59 }
60 
61 void CompileUnit::ForeachFunction(
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 
77 lldb::FunctionSP CompileUnit::FindFunction(
78     llvm::function_ref<bool(const FunctionSP &)> matching_lambda) {
79   LLDB_SCOPED_TIMER();
80 
81   lldb::ModuleSP module = CalculateSymbolContextModule();
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 
101 const char *CompileUnit::GetCachedLanguage() const {
102   if (m_flags.IsClear(flagsParsedLanguage))
103     return "<not loaded>";
104   return Language::GetNameForLanguageType(m_language);
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.
111 void 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
140 void CompileUnit::AddFunction(FunctionSP &funcSP) {
141   m_functions_by_uid[funcSP->GetID()] = funcSP;
142 }
143 
144 FunctionSP CompileUnit::FindFunctionByUID(lldb::user_id_t func_uid) {
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 
151 lldb::LanguageType CompileUnit::GetLanguage() {
152   if (m_language == eLanguageTypeUnknown) {
153     if (m_flags.IsClear(flagsParsedLanguage)) {
154       m_flags.Set(flagsParsedLanguage);
155       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
156         m_language = symfile->ParseLanguage(*this);
157     }
158   }
159   return m_language;
160 }
161 
162 LineTable *CompileUnit::GetLineTable() {
163   if (m_line_table_up == nullptr) {
164     if (m_flags.IsClear(flagsParsedLineTable)) {
165       m_flags.Set(flagsParsedLineTable);
166       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
167         symfile->ParseLineTable(*this);
168     }
169   }
170   return m_line_table_up.get();
171 }
172 
173 void CompileUnit::SetLineTable(LineTable *line_table) {
174   if (line_table == nullptr)
175     m_flags.Clear(flagsParsedLineTable);
176   else
177     m_flags.Set(flagsParsedLineTable);
178   m_line_table_up.reset(line_table);
179 }
180 
181 void CompileUnit::SetSupportFiles(const FileSpecList &support_files) {
182   m_support_files = support_files;
183 }
184 
185 void CompileUnit::SetSupportFiles(FileSpecList &&support_files) {
186   m_support_files = std::move(support_files);
187 }
188 
189 DebugMacros *CompileUnit::GetDebugMacros() {
190   if (m_debug_macros_sp.get() == nullptr) {
191     if (m_flags.IsClear(flagsParsedDebugMacros)) {
192       m_flags.Set(flagsParsedDebugMacros);
193       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
194         symfile->ParseDebugMacros(*this);
195     }
196   }
197 
198   return m_debug_macros_sp.get();
199 }
200 
201 void CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp) {
202   if (debug_macros_sp.get() == nullptr)
203     m_flags.Clear(flagsParsedDebugMacros);
204   else
205     m_flags.Set(flagsParsedDebugMacros);
206   m_debug_macros_sp = debug_macros_sp;
207 }
208 
209 VariableListSP CompileUnit::GetVariableList(bool can_create) {
210   if (m_variables.get() == nullptr && can_create) {
211     SymbolContext sc;
212     CalculateSymbolContext(&sc);
213     assert(sc.module_sp);
214     sc.module_sp->GetSymbolFile()->ParseVariablesForContext(sc);
215   }
216 
217   return m_variables;
218 }
219 
220 std::vector<uint32_t> FindFileIndexes(const FileSpecList &files,
221                                       const FileSpec &file) {
222   std::vector<uint32_t> result;
223   uint32_t idx = -1;
224   while ((idx = files.FindCompatibleIndex(idx + 1, file)) !=
225          UINT32_MAX)
226     result.push_back(idx);
227   return result;
228 }
229 
230 uint32_t CompileUnit::FindLineEntry(uint32_t start_idx, uint32_t line,
231                                     const FileSpec *file_spec_ptr, bool exact,
232                                     LineEntry *line_entry_ptr) {
233   if (!file_spec_ptr)
234     file_spec_ptr = &GetPrimaryFile();
235   std::vector<uint32_t> file_indexes = FindFileIndexes(GetSupportFiles(),
236                                                        *file_spec_ptr);
237   if (file_indexes.empty())
238     return UINT32_MAX;
239 
240   // TODO: Handle SourceLocationSpec column information
241   SourceLocationSpec location_spec(*file_spec_ptr, line,
242                                    /*column=*/std::nullopt,
243                                    /*check_inlines=*/false, exact);
244 
245   LineTable *line_table = GetLineTable();
246   if (line_table)
247     return line_table->FindLineEntryIndexByFileIndex(
248         start_idx, file_indexes, location_spec, line_entry_ptr);
249   return UINT32_MAX;
250 }
251 
252 void CompileUnit::ResolveSymbolContext(
253     const SourceLocationSpec &src_location_spec,
254     SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
255   const FileSpec file_spec = src_location_spec.GetFileSpec();
256   const uint32_t line = src_location_spec.GetLine().value_or(0);
257   const bool check_inlines = src_location_spec.GetCheckInlines();
258 
259   // First find all of the file indexes that match our "file_spec". If
260   // "file_spec" has an empty directory, then only compare the basenames when
261   // finding file indexes
262   bool file_spec_matches_cu_file_spec =
263       FileSpec::Match(file_spec, this->GetPrimaryFile());
264 
265   // If we are not looking for inlined functions and our file spec doesn't
266   // match then we are done...
267   if (!file_spec_matches_cu_file_spec && !check_inlines)
268     return;
269 
270   SymbolContext sc(GetModule());
271   sc.comp_unit = this;
272 
273   if (line == 0) {
274     if (file_spec_matches_cu_file_spec && !check_inlines) {
275       // only append the context if we aren't looking for inline call sites by
276       // file and line and if the file spec matches that of the compile unit
277       sc_list.Append(sc);
278     }
279     return;
280   }
281 
282   std::vector<uint32_t> file_indexes = FindFileIndexes(GetSupportFiles(),
283                                                        file_spec);
284   const size_t num_file_indexes = file_indexes.size();
285   if (num_file_indexes == 0)
286     return;
287 
288   // Found a matching source file in this compile unit load its debug info.
289   GetModule()->GetSymbolFile()->SetLoadDebugInfoEnabled();
290 
291   LineTable *line_table = sc.comp_unit->GetLineTable();
292 
293   if (line_table == nullptr) {
294     if (file_spec_matches_cu_file_spec && !check_inlines) {
295       sc_list.Append(sc);
296     }
297     return;
298   }
299 
300   uint32_t line_idx;
301   LineEntry line_entry;
302 
303   if (num_file_indexes == 1) {
304     // We only have a single support file that matches, so use the line
305     // table function that searches for a line entries that match a single
306     // support file index
307     line_idx = line_table->FindLineEntryIndexByFileIndex(
308         0, file_indexes.front(), src_location_spec, &line_entry);
309   } else {
310     // We found multiple support files that match "file_spec" so use the
311     // line table function that searches for a line entries that match a
312     // multiple support file indexes.
313     line_idx = line_table->FindLineEntryIndexByFileIndex(
314         0, file_indexes, src_location_spec, &line_entry);
315   }
316 
317   // If "exact == true", then "found_line" will be the same as "line". If
318   // "exact == false", the "found_line" will be the closest line entry
319   // with a line number greater than "line" and we will use this for our
320   // subsequent line exact matches below.
321   const bool inlines = false;
322   const bool exact = true;
323   const std::optional<uint16_t> column =
324       src_location_spec.GetColumn() ? std::optional<uint16_t>(line_entry.column)
325                                     : std::nullopt;
326 
327   SourceLocationSpec found_entry(line_entry.file, line_entry.line, column,
328                                  inlines, exact);
329 
330   while (line_idx != UINT32_MAX) {
331     // If they only asked for the line entry, then we're done, we can
332     // just copy that over. But if they wanted more than just the line
333     // number, fill it in.
334     SymbolContext resolved_sc;
335     sc.line_entry = line_entry;
336     if (resolve_scope == eSymbolContextLineEntry) {
337       sc_list.Append(sc);
338     } else {
339       line_entry.range.GetBaseAddress().CalculateSymbolContext(&resolved_sc,
340                                                                resolve_scope);
341       // Sometimes debug info is bad and isn't able to resolve the line entry's
342       // address back to the same compile unit and/or line entry. If the compile
343       // unit changed, then revert back to just the compile unit and line entry.
344       // Prior to this fix, the above code might end up not being able to lookup
345       // the address, and then it would clear compile unit and the line entry in
346       // the symbol context and the breakpoint would fail to get set even though
347       // we have a valid line table entry in this compile unit. The address
348       // lookup can also end up finding another function in another compiler
349       // unit if the DWARF has overlappging address ranges. So if we end up with
350       // no compile unit or a different one after the above function call,
351       // revert back to the same results as if resolve_scope was set exactly to
352       // eSymbolContextLineEntry.
353       if (resolved_sc.comp_unit == this) {
354         sc_list.Append(resolved_sc);
355       } else {
356         if (resolved_sc.comp_unit == nullptr && resolved_sc.module_sp) {
357           // Only report an error if we don't map back to any compile unit. With
358           // link time optimizations, the debug info might have many compile
359           // units that have the same address range due to function outlining
360           // or other link time optimizations. If the compile unit is NULL, then
361           // address resolving is completely failing and more deserving of an
362           // error message the user can see.
363           resolved_sc.module_sp->ReportError(
364               "unable to resolve a line table file address {0:x16} back "
365               "to a compile unit, please file a bug and attach the address "
366               "and file.",
367               line_entry.range.GetBaseAddress().GetFileAddress());
368         }
369         sc_list.Append(sc);
370       }
371     }
372 
373     if (num_file_indexes == 1)
374       line_idx = line_table->FindLineEntryIndexByFileIndex(
375           line_idx + 1, file_indexes.front(), found_entry, &line_entry);
376     else
377       line_idx = line_table->FindLineEntryIndexByFileIndex(
378           line_idx + 1, file_indexes, found_entry, &line_entry);
379   }
380 }
381 
382 bool CompileUnit::GetIsOptimized() {
383   if (m_is_optimized == eLazyBoolCalculate) {
384     m_is_optimized = eLazyBoolNo;
385     if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
386       if (symfile->ParseIsOptimized(*this))
387         m_is_optimized = eLazyBoolYes;
388     }
389   }
390   return m_is_optimized;
391 }
392 
393 void CompileUnit::SetVariableList(VariableListSP &variables) {
394   m_variables = variables;
395 }
396 
397 const std::vector<SourceModule> &CompileUnit::GetImportedModules() {
398   if (m_imported_modules.empty() &&
399       m_flags.IsClear(flagsParsedImportedModules)) {
400     m_flags.Set(flagsParsedImportedModules);
401     if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
402       SymbolContext sc;
403       CalculateSymbolContext(&sc);
404       symfile->ParseImportedModules(sc, m_imported_modules);
405     }
406   }
407   return m_imported_modules;
408 }
409 
410 bool CompileUnit::ForEachExternalModule(
411     llvm::DenseSet<SymbolFile *> &visited_symbol_files,
412     llvm::function_ref<bool(Module &)> lambda) {
413   if (SymbolFile *symfile = GetModule()->GetSymbolFile())
414     return symfile->ForEachExternalModule(*this, visited_symbol_files, lambda);
415   return false;
416 }
417 
418 const FileSpecList &CompileUnit::GetSupportFiles() {
419   if (m_support_files.GetSize() == 0) {
420     if (m_flags.IsClear(flagsParsedSupportFiles)) {
421       m_flags.Set(flagsParsedSupportFiles);
422       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
423         symfile->ParseSupportFiles(*this, m_support_files);
424     }
425   }
426   return m_support_files;
427 }
428 
429 void *CompileUnit::GetUserData() const { return m_user_data; }
430