540 lines · cpp
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-exception6//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 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,26 std::make_shared<SupportFile>(FileSpec(pathname)), cu_sym_id,27 language, is_optimized) {}28 29CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,30 SupportFileNSP support_file_nsp,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_nsp(support_file_nsp),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 44void CompileUnit::CalculateSymbolContext(SymbolContext *sc) {45 sc->comp_unit = this;46 GetModule()->CalculateSymbolContext(sc);47}48 49ModuleSP CompileUnit::CalculateSymbolContextModule() { return GetModule(); }50 51CompileUnit *CompileUnit::CalculateSymbolContextCompileUnit() { return this; }52 53void CompileUnit::DumpSymbolContext(Stream *s) {54 GetModule()->DumpSymbolContext(s);55 s->Printf(", CompileUnit{0x%8.8" PRIx64 "}", GetID());56}57 58void 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 65void 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 81lldb::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 105const 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 demand112// parsing of functions, globals, statics are called, so this is a good113// function to call to get an idea of the current contents of the CompileUnit114// object.115void 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 unit144void CompileUnit::AddFunction(FunctionSP &funcSP) {145 m_functions_by_uid[funcSP->GetID()] = funcSP;146}147 148FunctionSP 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 155lldb::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 166LineTable *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 177void CompileUnit::SetLineTable(LineTable *line_table) {178 if (line_table == nullptr)179 m_flags.Clear(flagsParsedLineTable);180 else181 m_flags.Set(flagsParsedLineTable);182 m_line_table_up.reset(line_table);183}184 185DebugMacros *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 197void CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp) {198 if (debug_macros_sp.get() == nullptr)199 m_flags.Clear(flagsParsedDebugMacros);200 else201 m_flags.Set(flagsParsedDebugMacros);202 m_debug_macros_sp = debug_macros_sp;203}204 205VariableListSP 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 216std::vector<uint32_t>217FindFileIndexes(const SupportFileList &files, const FileSpec &file,218 RealpathPrefixes *realpath_prefixes = nullptr) {219 std::vector<uint32_t> result;220 uint32_t idx = -1;221 while ((idx = files.FindCompatibleIndex(idx + 1, file, realpath_prefixes)) !=222 UINT32_MAX)223 result.push_back(idx);224 return result;225}226 227uint32_t CompileUnit::FindLineEntry(uint32_t start_idx, uint32_t line,228 const FileSpec *file_spec_ptr, bool exact,229 LineEntry *line_entry_ptr) {230 if (!file_spec_ptr)231 file_spec_ptr = &GetPrimaryFile();232 std::vector<uint32_t> file_indexes = FindFileIndexes(GetSupportFiles(),233 *file_spec_ptr);234 if (file_indexes.empty())235 return UINT32_MAX;236 237 // TODO: Handle SourceLocationSpec column information238 SourceLocationSpec location_spec(*file_spec_ptr, line,239 /*column=*/std::nullopt,240 /*check_inlines=*/false, exact);241 242 LineTable *line_table = GetLineTable();243 if (line_table)244 return line_table->FindLineEntryIndexByFileIndex(245 start_idx, file_indexes, location_spec, line_entry_ptr);246 return UINT32_MAX;247}248 249void CompileUnit::ResolveSymbolContext(250 const SourceLocationSpec &src_location_spec,251 SymbolContextItem resolve_scope, SymbolContextList &sc_list,252 RealpathPrefixes *realpath_prefixes) {253 const FileSpec file_spec = src_location_spec.GetFileSpec();254 const uint32_t line =255 src_location_spec.GetLine().value_or(LLDB_INVALID_LINE_NUMBER);256 const uint32_t column_num =257 src_location_spec.GetColumn().value_or(LLDB_INVALID_COLUMN_NUMBER);258 const bool check_inlines = src_location_spec.GetCheckInlines();259 260 // First find all of the file indexes that match our "file_spec". If261 // "file_spec" has an empty directory, then only compare the basenames when262 // finding file indexes263 bool file_spec_matches_cu_file_spec =264 FileSpec::Match(file_spec, this->GetPrimaryFile());265 266 // If we are not looking for inlined functions and our file spec doesn't267 // match then we are done...268 if (!file_spec_matches_cu_file_spec && !check_inlines)269 return;270 271 SymbolContext sc(GetModule());272 sc.comp_unit = this;273 274 if (line == LLDB_INVALID_LINE_NUMBER) {275 if (file_spec_matches_cu_file_spec && !check_inlines) {276 // only append the context if we aren't looking for inline call sites by277 // file and line and if the file spec matches that of the compile unit278 sc_list.Append(sc);279 }280 return;281 }282 283 std::vector<uint32_t> file_indexes =284 FindFileIndexes(GetSupportFiles(), file_spec, realpath_prefixes);285 const size_t num_file_indexes = file_indexes.size();286 if (num_file_indexes == 0)287 return;288 289 // Found a matching source file in this compile unit load its debug info.290 GetModule()->GetSymbolFile()->SetLoadDebugInfoEnabled();291 292 LineTable *line_table = sc.comp_unit->GetLineTable();293 294 if (line_table == nullptr) {295 if (file_spec_matches_cu_file_spec && !check_inlines) {296 sc_list.Append(sc);297 }298 return;299 }300 301 uint32_t line_idx;302 LineEntry line_entry;303 304 if (num_file_indexes == 1) {305 // We only have a single support file that matches, so use the line306 // table function that searches for a line entries that match a single307 // support file index308 line_idx = line_table->FindLineEntryIndexByFileIndex(309 0, file_indexes.front(), src_location_spec, &line_entry);310 } else {311 // We found multiple support files that match "file_spec" so use the312 // line table function that searches for a line entries that match a313 // multiple support file indexes.314 line_idx = line_table->FindLineEntryIndexByFileIndex(315 0, file_indexes, src_location_spec, &line_entry);316 }317 318 // If we didn't manage to find a breakpoint that matched the line number319 // requested, that might be because it is only an inline call site, and320 // doesn't have a line entry in the line table. Scan for that here.321 //322 // We are making the assumption that if there was an inlined function it will323 // contribute at least 1 non-call-site entry to the line table. That's handy324 // because we don't move line breakpoints over function boundaries, so if we325 // found a hit, and there were also a call site entry, it would have to be in326 // the function containing the PC of the line table match. That way we can327 // limit the call site search to that function.328 // We will miss functions that ONLY exist as a call site entry.329 330 if (line_entry.IsValid() &&331 (line_entry.line != line ||332 (column_num != 0 && line_entry.column != column_num)) &&333 (resolve_scope & eSymbolContextLineEntry) && check_inlines) {334 // We don't move lines over function boundaries, so the address in the335 // line entry will be the in function that contained the line that might336 // be a CallSite, and we can just iterate over that function to find any337 // inline records, and dig up their call sites.338 Address start_addr = line_entry.range.GetBaseAddress();339 Function *function = start_addr.CalculateSymbolContextFunction();340 // Record the size of the list to see if we added to it:341 size_t old_sc_list_size = sc_list.GetSize();342 343 Declaration sought_decl(file_spec, line, column_num);344 // We use this recursive function to descend the block structure looking345 // for a block that has this Declaration as in it's CallSite info.346 // This function recursively scans the sibling blocks of the incoming347 // block parameter.348 std::function<void(Block &)> examine_block =349 [&sought_decl, &sc_list, &src_location_spec, resolve_scope,350 &examine_block](Block &block) -> void {351 // Iterate over the sibling child blocks of the incoming block.352 Block *sibling_block = block.GetFirstChild();353 while (sibling_block) {354 // We only have to descend through the regular blocks, looking for355 // immediate inlines, since those are the only ones that will have this356 // callsite.357 const InlineFunctionInfo *inline_info =358 sibling_block->GetInlinedFunctionInfo();359 if (inline_info) {360 // If this is the call-site we are looking for, record that:361 // We need to be careful because the call site from the debug info362 // will generally have a column, but the user might not have specified363 // it.364 Declaration found_decl = inline_info->GetCallSite();365 uint32_t sought_column = sought_decl.GetColumn();366 if (found_decl.FileAndLineEqual(sought_decl, false) &&367 (sought_column == LLDB_INVALID_COLUMN_NUMBER ||368 sought_column == found_decl.GetColumn())) {369 // If we found a call site, it belongs not in this inlined block,370 // but in the parent block that inlined it.371 Address parent_start_addr;372 if (sibling_block->GetParent()->GetStartAddress(373 parent_start_addr)) {374 SymbolContext sc;375 parent_start_addr.CalculateSymbolContext(&sc, resolve_scope);376 // Now swap out the line entry for the one we found.377 LineEntry call_site_line = sc.line_entry;378 call_site_line.line = found_decl.GetLine();379 call_site_line.column = found_decl.GetColumn();380 bool matches_spec = true;381 // If the user asked for an exact match, we need to make sure the382 // call site we found actually matches the location.383 if (src_location_spec.GetExactMatch()) {384 matches_spec = false;385 if ((src_location_spec.GetFileSpec() ==386 sc.line_entry.GetFile()) &&387 (src_location_spec.GetLine() &&388 *src_location_spec.GetLine() == call_site_line.line) &&389 (src_location_spec.GetColumn() &&390 *src_location_spec.GetColumn() == call_site_line.column))391 matches_spec = true;392 }393 if (matches_spec &&394 sibling_block->GetRangeAtIndex(0, call_site_line.range)) {395 SymbolContext call_site_sc(sc.target_sp, sc.module_sp,396 sc.comp_unit, sc.function, sc.block,397 &call_site_line, sc.symbol);398 sc_list.Append(call_site_sc);399 }400 }401 }402 }403 404 // Descend into the child blocks:405 examine_block(*sibling_block);406 // Now go to the next sibling:407 sibling_block = sibling_block->GetSibling();408 }409 };410 411 if (function) {412 // We don't need to examine the function block, it can't be inlined.413 Block &func_block = function->GetBlock(true);414 examine_block(func_block);415 }416 // If we found entries here, we are done. We only get here because we417 // didn't find an exact line entry for this line & column, but if we found418 // an exact match from the call site info that's strictly better than419 // continuing to look for matches further on in the file.420 // FIXME: Should I also do this for "call site line exists between the421 // given line number and the later line we found in the line table"? That's422 // a closer approximation to our general sliding algorithm.423 if (sc_list.GetSize() > old_sc_list_size)424 return;425 }426 427 // If "exact == true", then "found_line" will be the same as "line". If428 // "exact == false", the "found_line" will be the closest line entry429 // with a line number greater than "line" and we will use this for our430 // subsequent line exact matches below.431 const bool inlines = false;432 const bool exact = true;433 const std::optional<uint16_t> column =434 src_location_spec.GetColumn() ? std::optional<uint16_t>(line_entry.column)435 : std::nullopt;436 437 SourceLocationSpec found_entry(line_entry.GetFile(), line_entry.line, column,438 inlines, exact);439 440 while (line_idx != UINT32_MAX) {441 // If they only asked for the line entry, then we're done, we can442 // just copy that over. But if they wanted more than just the line443 // number, fill it in.444 SymbolContext resolved_sc;445 sc.line_entry = line_entry;446 if (resolve_scope == eSymbolContextLineEntry) {447 sc_list.Append(sc);448 } else {449 line_entry.range.GetBaseAddress().CalculateSymbolContext(&resolved_sc,450 resolve_scope);451 // Sometimes debug info is bad and isn't able to resolve the line entry's452 // address back to the same compile unit and/or line entry. If the compile453 // unit changed, then revert back to just the compile unit and line entry.454 // Prior to this fix, the above code might end up not being able to lookup455 // the address, and then it would clear compile unit and the line entry in456 // the symbol context and the breakpoint would fail to get set even though457 // we have a valid line table entry in this compile unit. The address458 // lookup can also end up finding another function in another compiler459 // unit if the DWARF has overlappging address ranges. So if we end up with460 // no compile unit or a different one after the above function call,461 // revert back to the same results as if resolve_scope was set exactly to462 // eSymbolContextLineEntry.463 if (resolved_sc.comp_unit == this) {464 sc_list.Append(resolved_sc);465 } else {466 if (resolved_sc.comp_unit == nullptr && resolved_sc.module_sp) {467 // Only report an error if we don't map back to any compile unit. With468 // link time optimizations, the debug info might have many compile469 // units that have the same address range due to function outlining470 // or other link time optimizations. If the compile unit is NULL, then471 // address resolving is completely failing and more deserving of an472 // error message the user can see.473 resolved_sc.module_sp->ReportError(474 "unable to resolve a line table file address {0:x16} back "475 "to a compile unit, please file a bug and attach the address "476 "and file.",477 line_entry.range.GetBaseAddress().GetFileAddress());478 }479 sc_list.Append(sc);480 }481 }482 483 if (num_file_indexes == 1)484 line_idx = line_table->FindLineEntryIndexByFileIndex(485 line_idx + 1, file_indexes.front(), found_entry, &line_entry);486 else487 line_idx = line_table->FindLineEntryIndexByFileIndex(488 line_idx + 1, file_indexes, found_entry, &line_entry);489 }490}491 492bool CompileUnit::GetIsOptimized() {493 if (m_is_optimized == eLazyBoolCalculate) {494 m_is_optimized = eLazyBoolNo;495 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {496 if (symfile->ParseIsOptimized(*this))497 m_is_optimized = eLazyBoolYes;498 }499 }500 return m_is_optimized;501}502 503void CompileUnit::SetVariableList(VariableListSP &variables) {504 m_variables = variables;505}506 507const std::vector<SourceModule> &CompileUnit::GetImportedModules() {508 if (m_imported_modules.empty() &&509 m_flags.IsClear(flagsParsedImportedModules)) {510 m_flags.Set(flagsParsedImportedModules);511 if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {512 SymbolContext sc;513 CalculateSymbolContext(&sc);514 symfile->ParseImportedModules(sc, m_imported_modules);515 }516 }517 return m_imported_modules;518}519 520bool CompileUnit::ForEachExternalModule(521 llvm::DenseSet<SymbolFile *> &visited_symbol_files,522 llvm::function_ref<bool(Module &)> lambda) {523 if (SymbolFile *symfile = GetModule()->GetSymbolFile())524 return symfile->ForEachExternalModule(*this, visited_symbol_files, lambda);525 return false;526}527 528const SupportFileList &CompileUnit::GetSupportFiles() {529 if (m_support_files.GetSize() == 0) {530 if (m_flags.IsClear(flagsParsedSupportFiles)) {531 m_flags.Set(flagsParsedSupportFiles);532 if (SymbolFile *symfile = GetModule()->GetSymbolFile())533 symfile->ParseSupportFiles(*this, m_support_files);534 }535 }536 return m_support_files;537}538 539void *CompileUnit::GetUserData() const { return m_user_data; }540