lldb/source/Symbol/CompileUnit.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-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
  17 using namespace lldb;
  18 using namespace lldb_private;
  19
  20 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
  21                          const char *pathname, const lldb::user_id_t cu_sym_id,
  22                          lldb::LanguageType language,
  23                          lldb_private::LazyBool is_optimized)
  24     : CompileUnit(module_sp, user_data, FileSpec(pathname), cu_sym_id, language,
  25                   is_optimized) {}
  26
  27 CompileUnit::CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
  28                          const FileSpec &fspec, const lldb::user_id_t cu_sym_id,
  29                          lldb::LanguageType language,
  30                          lldb_private::LazyBool is_optimized)
  31     : ModuleChild(module_sp), UserID(cu_sym_id), m_user_data(user_data),
  32       m_language(language), m_flags(0), m_file_spec(fspec),
  33       m_is_optimized(is_optimized) {
  34   if (language != eLanguageTypeUnknown)
  35     m_flags.Set(flagsParsedLanguage);
  36   assert(module_sp);
  37 }
  38
  39 void CompileUnit::CalculateSymbolContext(SymbolContext *sc) {
  40   sc->comp_unit = this;
  41   GetModule()->CalculateSymbolContext(sc);
  42 }
  43
  44 ModuleSP CompileUnit::CalculateSymbolContextModule() { return GetModule(); }
  45
  46 CompileUnit *CompileUnit::CalculateSymbolContextCompileUnit() { return this; }
  47
  48 void CompileUnit::DumpSymbolContext(Stream *s) {
  49   GetModule()->DumpSymbolContext(s);
  50   s->Printf(", CompileUnit{0x%8.8" PRIx64 "}", GetID());
  51 }
  52
  53 void CompileUnit::GetDescription(Stream *s,
  54                                  lldb::DescriptionLevel level) const {
  55   const char *language = GetCachedLanguage();
  56   *s << "id = " << (const UserID &)*this << ", file = \""
  57      << this->GetPrimaryFile() << "\", language = \"" << language << '"';
  58 }
  59
  60 void CompileUnit::ForeachFunction(
  61     llvm::function_ref<bool(const FunctionSP &)> lambda) const {
  62   std::vector<lldb::FunctionSP> sorted_functions;
  63   sorted_functions.reserve(m_functions_by_uid.size());
  64   for (auto &p : m_functions_by_uid)
  65     sorted_functions.push_back(p.second);
  66   llvm::sort(sorted_functions.begin(), sorted_functions.end(),
  67              [](const lldb::FunctionSP &a, const lldb::FunctionSP &b) {
  68                return a->GetID() < b->GetID();
  69              });
  70
  71   for (auto &f : sorted_functions)
  72     if (lambda(f))
  73       return;
  74 }
  75
  76 lldb::FunctionSP CompileUnit::FindFunction(
  77     llvm::function_ref<bool(const FunctionSP &)> matching_lambda) {
  78   LLDB_SCOPED_TIMER();
  79
  80   lldb::ModuleSP module = CalculateSymbolContextModule();
  81
  82   if (!module)
  83     return {};
  84
  85   SymbolFile *symbol_file = module->GetSymbolFile();
  86
  87   if (!symbol_file)
  88     return {};
  89
  90   // m_functions_by_uid is filled in lazily but we need all the entries.
  91   symbol_file->ParseFunctions(*this);
  92
  93   for (auto &p : m_functions_by_uid) {
  94     if (matching_lambda(p.second))
  95       return p.second;
  96   }
  97   return {};
  98 }
  99
 100 const char *CompileUnit::GetCachedLanguage() const {
 101   if (m_flags.IsClear(flagsParsedLanguage))
 102     return "<not loaded>";
 103   return Language::GetNameForLanguageType(m_language);
 104 }
 105
 106 // Dump the current contents of this object. No functions that cause on demand
 107 // parsing of functions, globals, statics are called, so this is a good
 108 // function to call to get an idea of the current contents of the CompileUnit
 109 // object.
 110 void CompileUnit::Dump(Stream *s, bool show_context) const {
 111   const char *language = GetCachedLanguage();
 112
 113   s->Printf("%p: ", static_cast<const void *>(this));
 114   s->Indent();
 115   *s << "CompileUnit" << static_cast<const UserID &>(*this) << ", language = \""
 116      << language << "\", file = '" << GetPrimaryFile() << "'\n";
 117
 118   //  m_types.Dump(s);
 119
 120   if (m_variables.get()) {
 121     s->IndentMore();
 122     m_variables->Dump(s, show_context);
 123     s->IndentLess();
 124   }
 125
 126   if (!m_functions_by_uid.empty()) {
 127     s->IndentMore();
 128     ForeachFunction([&s, show_context](const FunctionSP &f) {
 129       f->Dump(s, show_context);
 130       return false;
 131     });
 132
 133     s->IndentLess();
 134     s->EOL();
 135   }
 136 }
 137
 138 // Add a function to this compile unit
 139 void CompileUnit::AddFunction(FunctionSP &funcSP) {
 140   m_functions_by_uid[funcSP->GetID()] = funcSP;
 141 }
 142
 143 FunctionSP CompileUnit::FindFunctionByUID(lldb::user_id_t func_uid) {
 144   auto it = m_functions_by_uid.find(func_uid);
 145   if (it == m_functions_by_uid.end())
 146     return FunctionSP();
 147   return it->second;
 148 }
 149
 150 lldb::LanguageType CompileUnit::GetLanguage() {
 151   if (m_language == eLanguageTypeUnknown) {
 152     if (m_flags.IsClear(flagsParsedLanguage)) {
 153       m_flags.Set(flagsParsedLanguage);
 154       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
 155         m_language = symfile->ParseLanguage(*this);
 156     }
 157   }
 158   return m_language;
 159 }
 160
 161 LineTable *CompileUnit::GetLineTable() {
 162   if (m_line_table_up == nullptr) {
 163     if (m_flags.IsClear(flagsParsedLineTable)) {
 164       m_flags.Set(flagsParsedLineTable);
 165       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
 166         symfile->ParseLineTable(*this);
 167     }
 168   }
 169   return m_line_table_up.get();
 170 }
 171
 172 void CompileUnit::SetLineTable(LineTable *line_table) {
 173   if (line_table == nullptr)
 174     m_flags.Clear(flagsParsedLineTable);
 175   else
 176     m_flags.Set(flagsParsedLineTable);
 177   m_line_table_up.reset(line_table);
 178 }
 179
 180 void CompileUnit::SetSupportFiles(const FileSpecList &support_files) {
 181   m_support_files = support_files;
 182 }
 183
 184 void CompileUnit::SetSupportFiles(FileSpecList &&support_files) {
 185   m_support_files = std::move(support_files);
 186 }
 187
 188 DebugMacros *CompileUnit::GetDebugMacros() {
 189   if (m_debug_macros_sp.get() == nullptr) {
 190     if (m_flags.IsClear(flagsParsedDebugMacros)) {
 191       m_flags.Set(flagsParsedDebugMacros);
 192       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
 193         symfile->ParseDebugMacros(*this);
 194     }
 195   }
 196
 197   return m_debug_macros_sp.get();
 198 }
 199
 200 void CompileUnit::SetDebugMacros(const DebugMacrosSP &debug_macros_sp) {
 201   if (debug_macros_sp.get() == nullptr)
 202     m_flags.Clear(flagsParsedDebugMacros);
 203   else
 204     m_flags.Set(flagsParsedDebugMacros);
 205   m_debug_macros_sp = debug_macros_sp;
 206 }
 207
 208 VariableListSP CompileUnit::GetVariableList(bool can_create) {
 209   if (m_variables.get() == nullptr && can_create) {
 210     SymbolContext sc;
 211     CalculateSymbolContext(&sc);
 212     assert(sc.module_sp);
 213     sc.module_sp->GetSymbolFile()->ParseVariablesForContext(sc);
 214   }
 215
 216   return m_variables;
 217 }
 218
 219 std::vector<uint32_t> FindFileIndexes(const FileSpecList &files, const FileSpec &file) {
 220   std::vector<uint32_t> result;
 221   uint32_t idx = -1;
 222   while ((idx = files.FindFileIndex(idx + 1, file, /*full=*/true)) !=
 223          UINT32_MAX)
 224     result.push_back(idx);
 225   return result;
 226 }
 227
 228 uint32_t CompileUnit::FindLineEntry(uint32_t start_idx, uint32_t line,
 229                                     const FileSpec *file_spec_ptr, bool exact,
 230                                     LineEntry *line_entry_ptr) {
 231   if (!file_spec_ptr)
 232     file_spec_ptr = &GetPrimaryFile();
 233   std::vector<uint32_t> file_indexes = FindFileIndexes(GetSupportFiles(), *file_spec_ptr);
 234   if (file_indexes.empty())
 235     return UINT32_MAX;
 236
 237   // TODO: Handle SourceLocationSpec column information
 238   SourceLocationSpec location_spec(*file_spec_ptr, line, /*column=*/llvm::None,
 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
 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().getValueOr(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   std::vector<uint32_t> file_indexes;
 259   bool file_spec_matches_cu_file_spec =
 260       FileSpec::Match(file_spec, this->GetPrimaryFile());
 261
 262   // If we are not looking for inlined functions and our file spec doesn't
 263   // match then we are done...
 264   if (!file_spec_matches_cu_file_spec && !check_inlines)
 265     return;
 266
 267   SymbolContext sc(GetModule());
 268   sc.comp_unit = this;
 269
 270   if (line == 0) {
 271     if (file_spec_matches_cu_file_spec && !check_inlines) {
 272       // only append the context if we aren't looking for inline call sites by
 273       // file and line and if the file spec matches that of the compile unit
 274       sc_list.Append(sc);
 275     }
 276     return;
 277   }
 278
 279   uint32_t file_idx =
 280       GetSupportFiles().FindFileIndex(0, file_spec, true);
 281   while (file_idx != UINT32_MAX) {
 282     file_indexes.push_back(file_idx);
 283     file_idx = GetSupportFiles().FindFileIndex(file_idx + 1, file_spec, true);
 284   }
 285
 286   const size_t num_file_indexes = file_indexes.size();
 287   if (num_file_indexes == 0)
 288     return;
 289
 290   LineTable *line_table = sc.comp_unit->GetLineTable();
 291
 292   if (line_table == nullptr) {
 293     if (file_spec_matches_cu_file_spec && !check_inlines) {
 294       sc_list.Append(sc);
 295     }
 296     return;
 297   }
 298
 299   uint32_t line_idx;
 300   LineEntry line_entry;
 301
 302   if (num_file_indexes == 1) {
 303     // We only have a single support file that matches, so use the line
 304     // table function that searches for a line entries that match a single
 305     // support file index
 306     line_idx = line_table->FindLineEntryIndexByFileIndex(
 307         0, file_indexes.front(), src_location_spec, &line_entry);
 308   } else {
 309     // We found multiple support files that match "file_spec" so use the
 310     // line table function that searches for a line entries that match a
 311     // multiple support file indexes.
 312     line_idx = line_table->FindLineEntryIndexByFileIndex(
 313         0, file_indexes, src_location_spec, &line_entry);
 314   }
 315
 316   // If "exact == true", then "found_line" will be the same as "line". If
 317   // "exact == false", the "found_line" will be the closest line entry
 318   // with a line number greater than "line" and we will use this for our
 319   // subsequent line exact matches below.
 320   const bool inlines = false;
 321   const bool exact = true;
 322   const llvm::Optional<uint16_t> column =
 323       src_location_spec.GetColumn().hasValue()
 324           ? llvm::Optional<uint16_t>(line_entry.column)
 325           : llvm::None;
 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     if (resolve_scope == eSymbolContextLineEntry) {
 335       sc.line_entry = line_entry;
 336     } else {
 337       line_entry.range.GetBaseAddress().CalculateSymbolContext(&sc,
 338                                                                resolve_scope);
 339     }
 340
 341     sc_list.Append(sc);
 342     if (num_file_indexes == 1)
 343       line_idx = line_table->FindLineEntryIndexByFileIndex(
 344           line_idx + 1, file_indexes.front(), found_entry, &line_entry);
 345     else
 346       line_idx = line_table->FindLineEntryIndexByFileIndex(
 347           line_idx + 1, file_indexes, found_entry, &line_entry);
 348   }
 349 }
 350
 351 bool CompileUnit::GetIsOptimized() {
 352   if (m_is_optimized == eLazyBoolCalculate) {
 353     m_is_optimized = eLazyBoolNo;
 354     if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
 355       if (symfile->ParseIsOptimized(*this))
 356         m_is_optimized = eLazyBoolYes;
 357     }
 358   }
 359   return m_is_optimized;
 360 }
 361
 362 void CompileUnit::SetVariableList(VariableListSP &variables) {
 363   m_variables = variables;
 364 }
 365
 366 const std::vector<SourceModule> &CompileUnit::GetImportedModules() {
 367   if (m_imported_modules.empty() &&
 368       m_flags.IsClear(flagsParsedImportedModules)) {
 369     m_flags.Set(flagsParsedImportedModules);
 370     if (SymbolFile *symfile = GetModule()->GetSymbolFile()) {
 371       SymbolContext sc;
 372       CalculateSymbolContext(&sc);
 373       symfile->ParseImportedModules(sc, m_imported_modules);
 374     }
 375   }
 376   return m_imported_modules;
 377 }
 378
 379 bool CompileUnit::ForEachExternalModule(
 380     llvm::DenseSet<SymbolFile *> &visited_symbol_files,
 381     llvm::function_ref<bool(Module &)> lambda) {
 382   if (SymbolFile *symfile = GetModule()->GetSymbolFile())
 383     return symfile->ForEachExternalModule(*this, visited_symbol_files, lambda);
 384   return false;
 385 }
 386
 387 const FileSpecList &CompileUnit::GetSupportFiles() {
 388   if (m_support_files.GetSize() == 0) {
 389     if (m_flags.IsClear(flagsParsedSupportFiles)) {
 390       m_flags.Set(flagsParsedSupportFiles);
 391       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
 392         symfile->ParseSupportFiles(*this, m_support_files);
 393     }
 394   }
 395   return m_support_files;
 396 }
 397
 398 void *CompileUnit::GetUserData() const { return m_user_data; }