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