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 CompileUnit(const lldb::ModuleSP & module_sp,void * user_data,const char * pathname,const lldb::user_id_t cu_sym_id,lldb::LanguageType language,lldb_private::LazyBool is_optimized)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, 26 std::make_shared<SupportFile>(FileSpec(pathname)), cu_sym_id, 27 language, is_optimized) {} 28 CompileUnit(const lldb::ModuleSP & module_sp,void * user_data,lldb::SupportFileSP support_file_sp,const lldb::user_id_t cu_sym_id,lldb::LanguageType language,lldb_private::LazyBool is_optimized,SupportFileList && support_files)29 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data, 30 lldb::SupportFileSP support_file_sp, 31 const lldb::user_id_t cu_sym_id, 32 lldb::LanguageType language, 33 lldb_private::LazyBool is_optimized, 34 SupportFileList &&support_files) 35 : ModuleChild(module_sp), UserID(cu_sym_id), m_user_data(user_data), 36 m_language(language), m_flags(0), 37 m_primary_support_file_sp(support_file_sp), 38 m_support_files(std::move(support_files)), m_is_optimized(is_optimized) { 39 if (language != eLanguageTypeUnknown) 40 m_flags.Set(flagsParsedLanguage); 41 assert(module_sp); 42 } 43 CalculateSymbolContext(SymbolContext * sc)44 void CompileUnit::CalculateSymbolContext(SymbolContext *sc) { 45 sc->comp_unit = this; 46 GetModule()->CalculateSymbolContext(sc); 47 } 48 CalculateSymbolContextModule()49 ModuleSP CompileUnit::CalculateSymbolContextModule() { return GetModule(); } 50 CalculateSymbolContextCompileUnit()51 CompileUnit *CompileUnit::CalculateSymbolContextCompileUnit() { return this; } 52 DumpSymbolContext(Stream * s)53 void CompileUnit::DumpSymbolContext(Stream *s) { 54 GetModule()->DumpSymbolContext(s); 55 s->Printf(", CompileUnit{0x%8.8" PRIx64 "}", GetID()); 56 } 57 GetDescription(Stream * s,lldb::DescriptionLevel level) const58 void CompileUnit::GetDescription(Stream *s, 59 lldb::DescriptionLevel level) const { 60 const char *language = GetCachedLanguage(); 61 *s << "id = " << (const UserID &)*this << ", file = \"" 62 << this->GetPrimaryFile() << "\", language = \"" << language << '"'; 63 } 64 ForeachFunction(llvm::function_ref<bool (const FunctionSP &)> lambda) const65 void CompileUnit::ForeachFunction( 66 llvm::function_ref<bool(const FunctionSP &)> lambda) const { 67 std::vector<lldb::FunctionSP> sorted_functions; 68 sorted_functions.reserve(m_functions_by_uid.size()); 69 for (auto &p : m_functions_by_uid) 70 sorted_functions.push_back(p.second); 71 llvm::sort(sorted_functions, 72 [](const lldb::FunctionSP &a, const lldb::FunctionSP &b) { 73 return a->GetID() < b->GetID(); 74 }); 75 76 for (auto &f : sorted_functions) 77 if (lambda(f)) 78 return; 79 } 80 FindFunction(llvm::function_ref<bool (const FunctionSP &)> matching_lambda)81 lldb::FunctionSP CompileUnit::FindFunction( 82 llvm::function_ref<bool(const FunctionSP &)> matching_lambda) { 83 LLDB_SCOPED_TIMER(); 84 85 lldb::ModuleSP module = CalculateSymbolContextModule(); 86 87 if (!module) 88 return {}; 89 90 SymbolFile *symbol_file = module->GetSymbolFile(); 91 92 if (!symbol_file) 93 return {}; 94 95 // m_functions_by_uid is filled in lazily but we need all the entries. 96 symbol_file->ParseFunctions(*this); 97 98 for (auto &p : m_functions_by_uid) { 99 if (matching_lambda(p.second)) 100 return p.second; 101 } 102 return {}; 103 } 104 GetCachedLanguage() const105 const char *CompileUnit::GetCachedLanguage() const { 106 if (m_flags.IsClear(flagsParsedLanguage)) 107 return "<not loaded>"; 108 return Language::GetNameForLanguageType(m_language); 109 } 110 111 // Dump the current contents of this object. No functions that cause on demand 112 // parsing of functions, globals, statics are called, so this is a good 113 // function to call to get an idea of the current contents of the CompileUnit 114 // object. Dump(Stream * s,bool show_context) const115 void CompileUnit::Dump(Stream *s, bool show_context) const { 116 const char *language = GetCachedLanguage(); 117 118 s->Printf("%p: ", static_cast<const void *>(this)); 119 s->Indent(); 120 *s << "CompileUnit" << static_cast<const UserID &>(*this) << ", language = \"" 121 << language << "\", file = '" << GetPrimaryFile() << "'\n"; 122 123 // m_types.Dump(s); 124 125 if (m_variables.get()) { 126 s->IndentMore(); 127 m_variables->Dump(s, show_context); 128 s->IndentLess(); 129 } 130 131 if (!m_functions_by_uid.empty()) { 132 s->IndentMore(); 133 ForeachFunction([&s, show_context](const FunctionSP &f) { 134 f->Dump(s, show_context); 135 return false; 136 }); 137 138 s->IndentLess(); 139 s->EOL(); 140 } 141 } 142 143 // Add a function to this compile unit AddFunction(FunctionSP & funcSP)144 void CompileUnit::AddFunction(FunctionSP &funcSP) { 145 m_functions_by_uid[funcSP->GetID()] = funcSP; 146 } 147 FindFunctionByUID(lldb::user_id_t func_uid)148 FunctionSP CompileUnit::FindFunctionByUID(lldb::user_id_t func_uid) { 149 auto it = m_functions_by_uid.find(func_uid); 150 if (it == m_functions_by_uid.end()) 151 return FunctionSP(); 152 return it->second; 153 } 154 GetLanguage()155 lldb::LanguageType CompileUnit::GetLanguage() { 156 if (m_language == eLanguageTypeUnknown) { 157 if (m_flags.IsClear(flagsParsedLanguage)) { 158 m_flags.Set(flagsParsedLanguage); 159 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) 160 m_language = symfile->ParseLanguage(*this); 161 } 162 } 163 return m_language; 164 } 165 GetLineTable()166 LineTable *CompileUnit::GetLineTable() { 167 if (m_line_table_up == nullptr) { 168 if (m_flags.IsClear(flagsParsedLineTable)) { 169 m_flags.Set(flagsParsedLineTable); 170 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) 171 symfile->ParseLineTable(*this); 172 } 173 } 174 return m_line_table_up.get(); 175 } 176 SetLineTable(LineTable * line_table)177 void CompileUnit::SetLineTable(LineTable *line_table) { 178 if (line_table == nullptr) 179 m_flags.Clear(flagsParsedLineTable); 180 else 181 m_flags.Set(flagsParsedLineTable); 182 m_line_table_up.reset(line_table); 183 } 184 GetDebugMacros()185 DebugMacros *CompileUnit::GetDebugMacros() { 186 if (m_debug_macros_sp.get() == nullptr) { 187 if (m_flags.IsClear(flagsParsedDebugMacros)) { 188 m_flags.Set(flagsParsedDebugMacros); 189 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) 190 symfile->ParseDebugMacros(*this); 191 } 192 } 193 194 return m_debug_macros_sp.get(); 195 } 196 SetDebugMacros(const DebugMacrosSP & debug_macros_sp)197 void CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp) { 198 if (debug_macros_sp.get() == nullptr) 199 m_flags.Clear(flagsParsedDebugMacros); 200 else 201 m_flags.Set(flagsParsedDebugMacros); 202 m_debug_macros_sp = debug_macros_sp; 203 } 204 GetVariableList(bool can_create)205 VariableListSP CompileUnit::GetVariableList(bool can_create) { 206 if (m_variables.get() == nullptr && can_create) { 207 SymbolContext sc; 208 CalculateSymbolContext(&sc); 209 assert(sc.module_sp); 210 sc.module_sp->GetSymbolFile()->ParseVariablesForContext(sc); 211 } 212 213 return m_variables; 214 } 215 FindFileIndexes(const SupportFileList & files,const FileSpec & file)216 std::vector<uint32_t> FindFileIndexes(const SupportFileList &files, 217 const FileSpec &file) { 218 std::vector<uint32_t> result; 219 uint32_t idx = -1; 220 while ((idx = files.FindCompatibleIndex(idx + 1, file)) != 221 UINT32_MAX) 222 result.push_back(idx); 223 return result; 224 } 225 FindLineEntry(uint32_t start_idx,uint32_t line,const FileSpec * file_spec_ptr,bool exact,LineEntry * line_entry_ptr)226 uint32_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 ResolveSymbolContext(const SourceLocationSpec & src_location_spec,SymbolContextItem resolve_scope,SymbolContextList & sc_list)248 void CompileUnit::ResolveSymbolContext( 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 266 SymbolContext sc(GetModule()); 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.GetFile(), 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 GetIsOptimized()378 bool CompileUnit::GetIsOptimized() { 379 if (m_is_optimized == eLazyBoolCalculate) { 380 m_is_optimized = eLazyBoolNo; 381 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) { 382 if (symfile->ParseIsOptimized(*this)) 383 m_is_optimized = eLazyBoolYes; 384 } 385 } 386 return m_is_optimized; 387 } 388 SetVariableList(VariableListSP & variables)389 void CompileUnit::SetVariableList(VariableListSP &variables) { 390 m_variables = variables; 391 } 392 GetImportedModules()393 const std::vector<SourceModule> &CompileUnit::GetImportedModules() { 394 if (m_imported_modules.empty() && 395 m_flags.IsClear(flagsParsedImportedModules)) { 396 m_flags.Set(flagsParsedImportedModules); 397 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) { 398 SymbolContext sc; 399 CalculateSymbolContext(&sc); 400 symfile->ParseImportedModules(sc, m_imported_modules); 401 } 402 } 403 return m_imported_modules; 404 } 405 ForEachExternalModule(llvm::DenseSet<SymbolFile * > & visited_symbol_files,llvm::function_ref<bool (Module &)> lambda)406 bool CompileUnit::ForEachExternalModule( 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 GetSupportFiles()414 const SupportFileList &CompileUnit::GetSupportFiles() { 415 if (m_support_files.GetSize() == 0) { 416 if (m_flags.IsClear(flagsParsedSupportFiles)) { 417 m_flags.Set(flagsParsedSupportFiles); 418 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) 419 symfile->ParseSupportFiles(*this, m_support_files); 420 } 421 } 422 return m_support_files; 423 } 424 GetUserData() const425 void *CompileUnit::GetUserData() const { return m_user_data; } 426