11#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
12#include "llvm/Support/Casting.h"
13#include "llvm/Support/FileUtilities.h"
14#include "llvm/Support/Format.h"
15#include "llvm/Support/Threading.h"
77#include "llvm/DebugInfo/DWARF/DWARFContext.h"
78#include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
79#include "llvm/Support/FileSystem.h"
80#include "llvm/Support/FormatVariadic.h"
92#ifdef ENABLE_DEBUG_PRINTF
94#define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
96#define DEBUG_PRINTF(fmt, ...)
110#define LLDB_PROPERTIES_symbolfiledwarf
111#include "SymbolFileDWARFProperties.inc"
114#define LLDB_PROPERTIES_symbolfiledwarf
115#include "SymbolFileDWARFPropertiesEnum.inc"
120 static llvm::StringRef GetSettingName() {
125 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
126 m_collection_sp->Initialize(g_symbolfiledwarf_properties);
129 bool IgnoreFileIndexes()
const {
130 return GetPropertyAtIndexAs<bool>(ePropertyIgnoreIndexes,
false);
137 return Tag == llvm::dwarf::Tag::DW_TAG_class_type ||
138 Tag == llvm::dwarf::Tag::DW_TAG_structure_type;
142 static PluginProperties g_settings;
146static const llvm::DWARFDebugLine::LineTable *
152 llvm::DWARFContext &ctx = context.
GetAsLLVM();
153 llvm::Expected<const llvm::DWARFDebugLine::LineTable *> line_table =
154 line.getOrParseLineTable(
155 data, line_offset, ctx,
nullptr, [&](llvm::Error e) {
158 "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
163 "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
170 llvm::DWARFDebugLine::Prologue &prologue,
176 llvm::DWARFContext &ctx = context.
GetAsLLVM();
177 uint64_t offset = line_offset;
178 llvm::Error
error = prologue.parse(
183 "SymbolFileDWARF::ParseSupportFiles failed to parse "
184 "line table prologue: {0}");
189 "SymbolFileDWARF::ParseSupportFiles failed to parse line "
190 "table prologue: {0}");
196static std::optional<std::string>
200 std::string abs_path;
201 auto absolute = llvm::DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath;
202 if (prologue.getFileNameByIndex(idx, compile_dir, absolute, abs_path, style))
203 return std::move(abs_path);
206 std::string rel_path;
207 auto relative = llvm::DILineInfoSpecifier::FileLineInfoKind::RawValue;
208 if (!prologue.getFileNameByIndex(idx, compile_dir, relative, rel_path, style))
210 return std::move(rel_path);
216 llvm::StringRef compile_dir = {}) {
219 if (prologue.FileNames.empty())
223 const bool is_one_based = prologue.getVersion() < 5;
224 const size_t file_names = prologue.FileNames.size();
225 const size_t first_file_idx = is_one_based ? 1 : 0;
226 const size_t last_file_idx = is_one_based ? file_names : file_names - 1;
233 for (
size_t idx = first_file_idx; idx <= last_file_idx; ++idx) {
234 std::string remapped_file;
235 if (
auto file_path =
GetFileByIndex(prologue, idx, compile_dir, style)) {
236 auto entry = prologue.getFileNameEntry(idx);
237 auto source = entry.Source.getAsCString();
239 consumeError(source.takeError());
241 llvm::StringRef source_ref(*source);
242 if (!source_ref.empty()) {
246 LazyDWARFSourceFile(
const FileSpec &fs, llvm::StringRef source,
251 llvm::StringRef source;
253 std::unique_ptr<llvm::FileRemover> remover;
260 llvm::SmallString<0> name;
263 auto ec = llvm::sys::fs::createTemporaryFile(
264 "", llvm::sys::path::filename(orig_name, style), fd, name);
267 "Could not create temporary file");
270 remover = std::make_unique<llvm::FileRemover>(name);
272 size_t num_bytes = source.size();
273 file.Write(source.data(), num_bytes);
278 support_files.
Append(std::make_unique<LazyDWARFSourceFile>(
279 FileSpec(*file_path), *source, style));
283 if (
auto remapped = module->RemapSourceFile(llvm::StringRef(*file_path)))
284 remapped_file = *remapped;
286 remapped_file = std::move(*file_path);
290 if (prologue.ContentTypes.HasMD5) {
291 const llvm::DWARFDebugLine::FileNameEntry &file_name_entry =
292 prologue.getFileNameEntry(idx);
293 checksum = file_name_entry.
Checksum;
311 debugger, PluginProperties::GetSettingName())) {
312 const bool is_global_setting =
true;
315 "Properties for the dwarf symbol-file plug-in.", is_global_setting);
326 return "DWARF and DWARF3 debug symbol file reader.";
337 return debug_map_symfile->GetTypeList();
346 if (die_offset >= max_die_offset)
349 if (die_offset >= min_die_offset) {
352 bool add_type =
false;
355 case DW_TAG_array_type:
356 add_type = (type_mask & eTypeClassArray) != 0;
358 case DW_TAG_unspecified_type:
359 case DW_TAG_base_type:
360 add_type = (type_mask & eTypeClassBuiltin) != 0;
362 case DW_TAG_class_type:
363 add_type = (type_mask & eTypeClassClass) != 0;
365 case DW_TAG_structure_type:
366 add_type = (type_mask & eTypeClassStruct) != 0;
368 case DW_TAG_union_type:
369 add_type = (type_mask & eTypeClassUnion) != 0;
371 case DW_TAG_enumeration_type:
372 add_type = (type_mask & eTypeClassEnumeration) != 0;
374 case DW_TAG_subroutine_type:
375 case DW_TAG_subprogram:
376 case DW_TAG_inlined_subroutine:
377 add_type = (type_mask & eTypeClassFunction) != 0;
379 case DW_TAG_pointer_type:
380 add_type = (type_mask & eTypeClassPointer) != 0;
382 case DW_TAG_rvalue_reference_type:
383 case DW_TAG_reference_type:
384 add_type = (type_mask & eTypeClassReference) != 0;
387 add_type = (type_mask & eTypeClassTypedef) != 0;
389 case DW_TAG_ptr_to_member_type:
390 add_type = (type_mask & eTypeClassMemberPointer) != 0;
397 const bool assert_not_being_parsed =
true;
400 type_set.insert(type);
405 GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
411 TypeClass type_mask,
TypeList &type_list)
424 unit = &unit->GetNonSkeletonUnit();
425 GetTypes(unit->DIE(), unit->GetOffset(), unit->GetNextUnitOffset(),
426 type_mask, type_set);
433 for (
size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx)
437 std::set<CompilerType> compiler_type_set;
438 for (
Type *type : type_set) {
439 CompilerType compiler_type = type->GetForwardCompilerType();
440 if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) {
441 compiler_type_set.insert(compiler_type);
442 type_list.
Insert(type->shared_from_this());
456 case DW_TAG_compile_unit:
457 case DW_TAG_partial_unit:
458 case DW_TAG_subprogram:
459 case DW_TAG_inlined_subroutine:
460 case DW_TAG_lexical_block:
472 m_debug_map_symfile(nullptr),
473 m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
474 m_fetched_external_modules(false),
480 static ConstString g_dwarf_section_name(
"__DWARF");
481 return g_dwarf_section_name;
484llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> &
487 return debug_map_symfile->GetForwardDeclCompilerTypeToDIE();
493 if (debug_map_symfile)
499llvm::Expected<lldb::TypeSystemSP>
502 return debug_map_symfile->GetTypeSystemForLanguage(language);
504 auto type_system_or_err =
505 m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
506 if (type_system_or_err)
507 if (
auto ts = *type_system_or_err)
508 ts->SetSymbolFile(
this);
509 return type_system_or_err;
530 *
GetObjectFile()->GetModule(), apple_names, apple_namespaces,
541 llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>> index_or =
546 m_index = std::move(*index_or);
550 "Unable to read .debug_names data: {0}");
555 std::make_unique<ManualDWARFIndex>(*
GetObjectFile()->GetModule(), *
this);
567 for (
SectionSP section_sp : section_list) {
568 if (section_sp->GetChildren().GetSize() > 0) {
578 return version >= 2 && version <= 5;
581static std::set<dw_form_t>
586 std::set<dw_form_t> unsupported_forms;
587 for (
const auto &[_, decl_set] : *debug_abbrev)
588 for (
const auto &decl : decl_set)
589 for (
const auto &attr : decl.attributes())
591 unsupported_forms.insert(attr.Form);
593 return unsupported_forms;
597 uint32_t abilities = 0;
599 const Section *section =
nullptr;
601 if (section_list ==
nullptr)
604 uint64_t debug_abbrev_file_size = 0;
605 uint64_t debug_info_file_size = 0;
606 uint64_t debug_line_file_size = 0;
615 if (section !=
nullptr) {
626 if (!unsupported_forms.empty()) {
628 error.Printf(
"unsupported DW_FORM value%s:",
629 unsupported_forms.size() > 1 ?
"s" :
"");
630 for (
auto form : unsupported_forms)
631 error.Printf(
" %#x", form);
642 llvm::StringRef symfile_dir =
643 m_objfile_sp->GetFileSpec().GetDirectory().GetStringRef();
644 if (symfile_dir.contains_insensitive(
".dsym")) {
655 "empty dSYM file detected, dSYM was created with an "
656 "executable with no debug info.");
663 if (debug_info_file_size >= MaxDebugInfoSize) {
665 "SymbolFileDWARF can't load this DWARF. It's larger then {0:x+16}",
670 if (debug_abbrev_file_size > 0 && debug_info_file_size > 0)
674 if (debug_line_file_size > 0)
683 const SectionList *section_list = module_sp->GetSectionList();
705 std::make_unique<llvm::DWARFDebugAbbrev>(debug_abbrev_data.
GetAsLLVM());
706 llvm::Error
error = abbr->parse();
710 "Unable to read .debug_abbrev section: {0}");
737 return llvm::cast_or_null<DWARFCompileUnit>(dwarf_cu);
745 m_ranges = std::make_unique<DWARFDebugRanges>();
764 if (
auto remapped_file = module_sp->RemapSourceFile(file_spec.
GetPath()))
765 file_spec.
SetFile(*remapped_file, FileSpec::Style::native);
771 const char *dwo_name =
784 cu_sp = comp_unit->shared_from_this();
797 cu_sp = std::make_shared<CompileUnit>(
798 module_sp, &dwarf_cu, support_file_sp,
807 auto lazy_initialize_cu = [&]() {
829 if (support_files.
GetSize() == 0)
836 if (!lazy_initialize_cu()) {
850 initialize_cu(std::make_shared<SupportFile>(cu_file_spec),
869 for (uint32_t i = 0, num = info.
GetNumUnits(); i < num; ++i) {
870 if (
auto *cu = llvm::dyn_cast<DWARFCompileUnit>(info.
GetUnitAtIndex(i))) {
895 if (
auto *dwarf_cu = llvm::cast_or_null<DWARFCompileUnit>(
909 if (
auto err = type_system_or_err.takeError()) {
911 "Unable to parse function: {0}");
914 auto ts = *type_system_or_err;
931 lowest_func_addr >= highest_func_addr ||
938 lowest_func_addr, module_sp->GetSectionList());
942 func_range.
SetByteSize(highest_func_addr - lowest_func_addr);
957 if (
auto err = type_system_or_err.takeError()) {
959 "Unable to construct demangled name for function: {0}");
963 auto ts = *type_system_or_err;
977 if (debug_map_symfile)
984 if (debug_map_symfile) {
1010 const char *sysroot =
1018 module_sp->RegisterXcodeSDK(sdk, sysroot);
1021 if (local_module_sp && local_module_sp != module_sp)
1022 local_module_sp->RegisterXcodeSDK(sdk, sysroot);
1034 size_t functions_added = 0;
1037 if (entry.Tag() != DW_TAG_subprogram)
1047 return functions_added;
1052 llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
1053 llvm::function_ref<
bool(
Module &)> lambda) {
1055 if (!visited_symbol_files.insert(
this).second)
1065 if (lambda(*module))
1068 for (std::size_t i = 0; i < module->GetNumCompileUnits(); ++i) {
1069 auto cu = module->GetCompileUnitAtIndex(i);
1070 bool early_exit = cu->ForEachExternalModule(visited_symbol_files, lambda);
1100 llvm::DWARFDebugLine::Prologue prologue;
1112 if (
auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
1114 return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
1118 auto &tu = llvm::cast<DWARFTypeUnit>(unit);
1130 offset == llvm::DenseMapInfo<dw_offset_t>::getEmptyKey() ||
1131 offset == llvm::DenseMapInfo<dw_offset_t>::getTombstoneKey())
1137 std::unique_ptr<SupportFileList> &list = iter_bool.first->second;
1138 if (iter_bool.second) {
1139 list = std::make_unique<SupportFileList>();
1140 uint64_t line_table_offset = offset;
1141 llvm::DWARFDataExtractor data =
1144 llvm::DWARFDebugLine::Prologue prologue;
1145 auto report = [](llvm::Error
error) {
1148 "SymbolFileDWARF::GetTypeUnitSupportFiles failed to parse "
1149 "the line table prologue: {0}");
1152 llvm::Error
error = prologue.parse(data, &line_table_offset, report, ctx);
1154 report(std::move(
error));
1172 std::vector<SourceModule> &imported_modules) {
1188 if (child_die.Tag() != DW_TAG_imported_declaration)
1192 if (module_die.
Tag() != DW_TAG_module)
1195 if (
const char *name =
1201 while ((parent_die = parent_die.
GetParent())) {
1202 if (parent_die.
Tag() != DW_TAG_module)
1204 if (
const char *name =
1208 std::reverse(module.
path.begin(), module.
path.end());
1210 DW_AT_LLVM_include_path,
nullptr)) {
1217 DW_AT_LLVM_sysroot,
nullptr))
1219 imported_modules.push_back(module);
1239 llvm::DWARFDebugLine line;
1240 const llvm::DWARFDebugLine::LineTable *line_table =
1249 std::vector<std::unique_ptr<LineSequence>> sequences;
1252 for (
const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
1259 std::unique_ptr<LineSequence> sequence =
1261 for (
unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
1262 const llvm::DWARFDebugLine::Row &row = line_table->Rows[idx];
1264 sequence.get(), row.Address.Address, row.Line, row.Column, row.File,
1265 row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
1268 sequences.push_back(std::move(sequence));
1271 std::unique_ptr<LineTable> line_table_up =
1272 std::make_unique<LineTable>(&comp_unit, std::move(sequences));
1279 debug_map_symfile->LinkOSOLineTable(
this, line_table_up.get()));
1291 return iter->second;
1305 offset,
this, debug_macros_sp);
1307 return debug_macros_sp;
1314 if (dwarf_cu ==
nullptr)
1336 const DWARFDIE &orig_die,
addr_t subprogram_low_pc, uint32_t depth) {
1337 size_t blocks_added = 0;
1343 case DW_TAG_inlined_subroutine:
1344 case DW_TAG_subprogram:
1345 case DW_TAG_lexical_block: {
1346 Block *block =
nullptr;
1347 if (tag == DW_TAG_subprogram) {
1355 block = parent_block;
1359 block = block_sp.get();
1362 const char *name =
nullptr;
1363 const char *mangled_name =
nullptr;
1365 std::optional<int> decl_file;
1366 std::optional<int> decl_line;
1367 std::optional<int> decl_column;
1368 std::optional<int> call_file;
1369 std::optional<int> call_line;
1370 std::optional<int> call_column;
1372 decl_line, decl_column, call_file, call_line,
1373 call_column,
nullptr)) {
1374 if (tag == DW_TAG_subprogram) {
1377 }
else if (tag == DW_TAG_inlined_subroutine) {
1391 const size_t num_ranges = ranges.
GetSize();
1392 for (
size_t i = 0; i < num_ranges; ++i) {
1395 if (range_base >= subprogram_low_pc)
1400 "{0:x8}: adding range [{1:x16}-{2:x16}) which has a base "
1401 "that is less than the function's low PC {3:x16}. Please file "
1402 "a bug and attach the file at the "
1403 "start of this error message",
1410 if (tag != DW_TAG_subprogram &&
1411 (name !=
nullptr || mangled_name !=
nullptr)) {
1412 std::unique_ptr<Declaration> decl_up;
1413 if (decl_file || decl_line || decl_column)
1414 decl_up = std::make_unique<Declaration>(
1416 decl_file ? *decl_file : 0),
1417 decl_line ? *decl_line : 0, decl_column ? *decl_column : 0);
1419 std::unique_ptr<Declaration> call_up;
1420 if (call_file || call_line || call_column)
1421 call_up = std::make_unique<Declaration>(
1423 call_file ? *call_file : 0),
1424 call_line ? *call_line : 0, call_column ? *call_column : 0);
1435 subprogram_low_pc, depth + 1);
1452 return blocks_added;
1459 bool check_virtuality =
false;
1461 case DW_TAG_inheritance:
1462 case DW_TAG_subprogram:
1463 check_virtuality =
true;
1468 if (check_virtuality) {
1469 if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
1479 if (type_system !=
nullptr)
1523std::vector<CompilerContext>
1530 return die.GetDeclContext();
1540 return type_die.ResolveType();
1551 return std::nullopt;
1559 bool assert_not_being_parsed) {
1565 "SymbolFileDWARF::ResolveTypeUID (die = {0:x16}) {1} ({2}) '{3}'",
1575 switch (decl_ctx_die.
Tag()) {
1576 case DW_TAG_structure_type:
1577 case DW_TAG_union_type:
1578 case DW_TAG_class_type: {
1583 "SymbolFileDWARF::ResolveTypeUID (die = {0:x16}) {1} ({2}) "
1584 "'{3}' resolve parent forward type for {4:x16})",
1612 if (!clang_type_system)
1621 auto clang_type_system =
1623 if (clang_type_system) {
1649 if (debug_map_symfile) {
1665 if (decl_die != def_die) {
1675 log,
"{0:x8}: {1} ({2}) '{3}' resolving forward declaration...",
1678 assert(compiler_type);
1683 bool assert_not_being_parsed,
1684 bool resolve_function_context) {
1688 if (assert_not_being_parsed) {
1693 "Parsing a die that is being parsed die: {0:x16}: {1} ({2}) {3}",
1723 m_index->GetObjCMethods(class_name, callback);
1729 if (die && llvm::isa<DWARFCompileUnit>(die.
GetCU())) {
1764 std::optional<uint32_t> file_index = die_ref.
file_index();
1775 return debug_map->GetSymbolFileByOSOIndex(*file_index);
1806 std::optional<uint64_t> dwo_id =
1818 return ::GetDWOId(*cu, *cu_die);
1827std::shared_ptr<SymbolFileDWARFDwo>
1841 if (!dwarf_cu || !dwarf_cu->
GetDWOId().has_value())
1844 const char *dwo_name =
GetDWOName(*dwarf_cu, cu_die);
1847 "missing DWO name in skeleton DIE {0:x16}", cu_die.
GetOffset()));
1860 size_t num_search_paths = debug_file_search_paths.
GetSize();
1866 const char *comp_dir =
1871 dwo_file.
SetFile(comp_dir, FileSpec::Style::native);
1882 FileSpec relative_to_binary = dwo_file;
1884 m_objfile_sp->GetFileSpec().GetDirectory().GetStringRef());
1887 dwo_paths.
Append(relative_to_binary);
1890 for (
size_t idx = 0; idx < num_search_paths; ++idx) {
1898 dwo_paths.
Append(dirspec);
1901 size_t num_possible = dwo_paths.
GetSize();
1902 for (
size_t idx = 0; idx < num_possible && !found; ++idx) {
1905 dwo_file = dwo_spec;
1913 "unable to locate relative .dwo debug file \"%s\" for "
1914 "skeleton DIE 0x%016" PRIx64
" without valid DW_AT_comp_dir "
1925 llvm::StringRef filename_only = dwo_name_spec.
GetFilename();
1928 m_objfile_sp->GetFileSpec().GetDirectory().GetStringRef());
1932 FileSpec dwo_name_binary_directory(binary_directory);
1934 dwo_paths.
Append(dwo_name_binary_directory);
1937 FileSpec filename_binary_directory(binary_directory);
1939 dwo_paths.
Append(filename_binary_directory);
1941 for (
size_t idx = 0; idx < num_search_paths; ++idx) {
1947 FileSpec dwo_name_dirspec(dirspec);
1949 dwo_paths.
Append(dwo_name_dirspec);
1951 FileSpec filename_dirspec(dirspec);
1953 dwo_paths.
Append(filename_dirspec);
1956 size_t num_possible = dwo_paths.
GetSize();
1957 for (
size_t idx = 0; idx < num_possible && !found; ++idx) {
1960 dwo_file = dwo_spec;
1969 if (error_dwo_path.
IsRelative() && comp_dir !=
nullptr) {
1974 "unable to locate .dwo debug file \"{0}\" for skeleton DIE "
1980 "unable to locate separate debug file (dwo, dwp). Debugging will be "
1992 dwo_file_data_offset);
1993 if (dwo_obj_file ==
nullptr) {
1995 "unable to load object file for .dwo debug file \"{0}\" for "
2001 return std::make_shared<SymbolFileDWARFDwo>(*
this, dwo_obj_file,
2013 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
2015 llvm::dyn_cast<DWARFCompileUnit>(debug_info.
GetUnitAtIndex(cu_idx));
2039 const char *comp_dir =
2043 FileSpec::Style::native);
2063 if (
m_objfile_sp->GetFileSpec().GetFileNameExtension() ==
".dwo" &&
2070 nullptr,
nullptr,
nullptr);
2073 "{0:x16}: unable to locate module needed for external types: "
2074 "{1}\nerror: {2}\nDebugging will be degraded due to missing "
2075 "types. Rebuilding the project will regenerate the needed "
2078 error.AsCString(
"unknown error"));
2089 llvm::dyn_cast_or_null<SymbolFileDWARF>(module_sp->GetSymbolFile());
2092 std::optional<uint64_t> dwo_dwo_id = dwo_symfile->GetDWOId();
2096 if (dwo_id != dwo_dwo_id) {
2098 "{0:x16}: Module {1} is out-of-date (hash mismatch). Type "
2100 "from this module may be incomplete or inconsistent with the rest of "
2101 "the program. Rebuilding the project will regenerate the needed "
2114 const size_t num_cus = module_sp->GetNumCompileUnits();
2115 for (
size_t i = 0; i < num_cus; ++i) {
2116 CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
2120 const size_t num_globals = globals_sp->GetSize();
2121 for (
size_t g = 0; g < num_globals; ++g) {
2122 VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
2123 if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
2125 var_sp->LocationExpressionList();
2127 llvm::Expected<Value> location_result = location.
Evaluate(
2129 if (location_result) {
2130 if (location_result->GetValueType() ==
2133 location_result->GetScalar().ULongLong();
2135 if (var_sp->GetType())
2137 var_sp->GetType()->GetByteSize(
nullptr).value_or(0);
2139 file_addr, byte_size, var_sp.get()));
2143 location_result.takeError(),
2144 "location expression failed to execute: {0}");
2185 SymbolContextItem resolve_scope,
2189 "ResolveSymbolContext (so_addr = { "
2190 "section = %p, offset = 0x%" PRIx64
2191 " }, resolve_scope = 0x%8.8x)",
2192 static_cast<void *
>(so_addr.
GetSection().get()),
2194 uint32_t resolved = 0;
2196 (eSymbolContextCompUnit | eSymbolContextFunction | eSymbolContextBlock |
2197 eSymbolContextLineEntry | eSymbolContextVariable)) {
2209 if (resolve_scope & eSymbolContextVariable) {
2212 map.FindEntryThatContains(file_vm_addr);
2213 if (entry && entry->data) {
2225 if (
auto *dwarf_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(
2230 resolved |= eSymbolContextCompUnit;
2232 bool force_check_line_table =
false;
2233 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
2235 resolve_scope & eSymbolContextBlock, sc);
2237 resolved |= eSymbolContextFunction;
2245 force_check_line_table =
true;
2248 resolved |= eSymbolContextBlock;
2251 if ((resolve_scope & eSymbolContextLineEntry) ||
2252 force_check_line_table) {
2254 if (line_table !=
nullptr) {
2264 resolved |= eSymbolContextLineEntry;
2270 if (force_check_line_table && !(resolved & eSymbolContextLineEntry)) {
2277 resolved &= ~eSymbolContextCompUnit;
2281 "{0:x16}: compile unit {1} failed to create a valid "
2282 "lldb_private::CompileUnit class.",
2296 const uint32_t prev_size = sc_list.
GetSize();
2297 if (resolve_scope & eSymbolContextCompUnit) {
2306 if (check_inlines || file_spec_matches_cu_file_spec) {
2313 return sc_list.
GetSize() - prev_size;
2331 return module_sp->GetMutex();
2347 if (
auto err = type_system_or_err.takeError()) {
2349 "Unable to match namespace decl using TypeSystem: {0}");
2353 if (decl_ctx_type_system == type_system_or_err->get())
2361 log,
"Valid namespace does not match symbol file");
2375 "SymbolFileDWARF::FindGlobalVariables (name=\"{0}\", "
2376 "parent_decl_ctx={1:p}, max_matches={2}, variables)",
2377 name.
GetCString(),
static_cast<const void *
>(&parent_decl_ctx),
2384 const uint32_t original_size = variables.
GetSize();
2386 llvm::StringRef basename;
2387 llvm::StringRef context;
2397 uint32_t pruned_idx = original_size;
2405 if (die.
Tag() != DW_TAG_variable)
2408 auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.
GetCU());
2413 if (parent_decl_ctx) {
2416 dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
2422 if (!actual_parent_decl_ctx ||
2423 (actual_parent_decl_ctx != parent_decl_ctx &&
2430 while (pruned_idx < variables.
GetSize()) {
2432 if (name_is_mangled ||
2433 var_sp->GetName().GetStringRef().contains(name.
GetStringRef()))
2439 return variables.
GetSize() - original_size < max_matches;
2443 const uint32_t num_matches = variables.
GetSize() - original_size;
2444 if (log && num_matches > 0) {
2447 "SymbolFileDWARF::FindGlobalVariables (name=\"{0}\", "
2448 "parent_decl_ctx={1:p}, max_matches={2}, variables) => {3}",
2449 name.
GetCString(),
static_cast<const void *
>(&parent_decl_ctx),
2450 max_matches, num_matches);
2455 uint32_t max_matches,
2463 "SymbolFileDWARF::FindGlobalVariables (regex=\"{0}\", "
2464 "max_matches={1}, variables)",
2465 regex.
GetText().str().c_str(), max_matches);
2469 const uint32_t original_size = variables.
GetSize();
2484 return variables.
GetSize() - original_size < max_matches;
2489 bool include_inlines,
2497 if (!(orig_die.
Tag() == DW_TAG_subprogram ||
2498 (include_inlines && orig_die.
Tag() == DW_TAG_inlined_subroutine)))
2503 if (die.
Tag() == DW_TAG_inlined_subroutine) {
2510 if (die.
Tag() == DW_TAG_subprogram)
2516 assert(die && die.
Tag() == DW_TAG_subprogram);
2523 if (sc.
block ==
nullptr)
2541 bool only_root_namespaces) {
2548 if (only_root_namespaces)
2549 return die.
GetParent().
Tag() == llvm::dwarf::DW_TAG_compile_unit;
2557 dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
2566 bool include_inlines,
2574 assert((name_type_mask & eFunctionNameTypeAuto) == 0);
2581 "SymbolFileDWARF::FindFunctions (name=\"{0}\", name_type_mask={1:x}, "
2596 const uint32_t original_size = sc_list.
GetSize();
2598 llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
2600 m_index->GetFunctions(lookup_info, *
this, parent_decl_ctx, [&](
DWARFDIE die) {
2601 if (resolved_dies.insert(die.
GetDIE()).second)
2610 auto it = name_ref.find(
'<');
2611 if (it != llvm::StringRef::npos) {
2612 const llvm::StringRef name_no_template_params = name_ref.slice(0, it);
2616 m_index->GetFunctions(no_tp_lookup_info, *
this, parent_decl_ctx,
2618 if (resolved_dies.insert(die.
GetDIE()).second)
2626 const uint32_t num_matches = sc_list.
GetSize() - original_size;
2628 if (log && num_matches > 0) {
2631 "SymbolFileDWARF::FindFunctions (name=\"{0}\", "
2632 "name_type_mask={1:x}, include_inlines={2:d}, sc_list) => {3}",
2633 name.
GetCString(), name_type_mask, include_inlines, num_matches);
2638 bool include_inlines,
2642 regex.
GetText().str().c_str());
2648 log,
"SymbolFileDWARF::FindFunctions (regex=\"{0}\", sc_list)",
2649 regex.
GetText().str().c_str());
2652 llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
2654 if (resolved_dies.insert(die.
GetDIE()).second)
2661 const std::string &scope_qualified_name,
2662 std::vector<ConstString> &mangled_names) {
2665 for (uint32_t i = 0; i < num_comp_units; i++) {
2684 llvm::StringRef &basename,
2685 llvm::StringRef &template_params) {
2686 auto it = fullname.find(
'<');
2687 if (it == llvm::StringRef::npos) {
2688 basename = fullname;
2689 template_params = llvm::StringRef();
2692 basename = fullname.slice(0, it);
2693 template_params = fullname.slice(it, fullname.size());
2701 bool any_context_updated =
false;
2703 llvm::StringRef basename, params;
2706 any_context_updated =
true;
2709 return any_context_updated;
2719 return debug_info_size + dwp_sp->GetDebugInfoSize();
2722 for (uint32_t i = 0; i < num_comp_units; i++) {
2731 return debug_info_size;
2742 bool have_index_match =
false;
2745 if (query.HasLanguage()) {
2746 if (!query.LanguageMatches(GetLanguageFamily(*die.GetCU())))
2751 std::vector<lldb_private::CompilerContext> die_context;
2756 assert(!die_context.empty());
2762 if (matching_type->IsTemplateType()) {
2771 auto CompilerTypeBasename =
2772 matching_type->GetForwardCompilerType().GetTypeName(true);
2773 if (CompilerTypeBasename != query.GetTypeBasename())
2776 have_index_match =
true;
2777 results.
InsertUnique(matching_type->shared_from_this());
2779 return !results.
Done(query);
2782 if (results.Done(query))
2788 if (!have_index_match) {
2801 m_index->GetTypes(query_simple.GetTypeBasename(), [&](
DWARFDIE die) {
2803 if (query.HasLanguage()) {
2804 if (!query.LanguageMatches(GetLanguageFamily(*die.GetCU())))
2809 std::vector<lldb_private::CompilerContext> die_context;
2810 if (query.GetModuleSearch())
2814 assert(!die_context.empty());
2815 if (!query_simple.ContextMatches(die_context))
2819 if (
Type *matching_type = ResolveType(die,
true,
true)) {
2820 ConstString name = matching_type->GetQualifiedName();
2829 TypeQueryOptions::e_exact_match);
2830 if (!query.ContextMatches(die_query.GetContextRef()))
2833 results.InsertUnique(matching_type->shared_from_this());
2835 return !results.Done(query);
2837 if (results.Done(query))
2845 UpdateExternalModuleListIfNeeded();
2847 for (
const auto &pair : m_external_type_modules) {
2848 if (
ModuleSP external_module_sp = pair.second) {
2849 external_module_sp->FindTypes(query, results);
2850 if (results.Done(query))
2859 bool only_root_namespaces) {
2865 log,
"SymbolFileDWARF::FindNamespace (sc, name=\"{0}\")",
2872 return namespace_decl_ctx;
2883 return !namespace_decl_ctx.
IsValid();
2886 if (log && namespace_decl_ctx) {
2889 "SymbolFileDWARF::FindNamespace (sc, name=\"{0}\") => "
2890 "CompilerDeclContext({1:p}/{2:p}) \"{3}\"",
2892 static_cast<const void *
>(namespace_decl_ctx.
GetTypeSystem()),
2897 return namespace_decl_ctx;
2901 bool resolve_function_context) {
2905 if (type_ptr ==
nullptr) {
2907 if (
auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.
GetCU()))
2914 while (parent_die !=
nullptr) {
2915 if (parent_die->
Tag() == DW_TAG_subprogram)
2920 if (resolve_function_context && parent_die !=
nullptr &&
2927 type_sp = type_ptr->shared_from_this();
2942 if (orig_die != die) {
2943 switch (die.
Tag()) {
2944 case DW_TAG_compile_unit:
2945 case DW_TAG_partial_unit:
2946 case DW_TAG_namespace:
2947 case DW_TAG_structure_type:
2948 case DW_TAG_union_type:
2949 case DW_TAG_class_type:
2950 case DW_TAG_lexical_block:
2951 case DW_TAG_subprogram:
2953 case DW_TAG_inlined_subroutine: {
2969 return decl_ctx_die;
2976 return decl_ctx_die;
2986 Symbol *objc_class_symbol =
nullptr;
2995 return objc_class_symbol;
3013 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
3015 if (dwarf_cu != cu &&
3039 m_index->GetCompleteObjCClass(
3040 type_name, must_be_implementation, [&](
DWARFDIE type_die) {
3046 if (must_be_implementation &&
3048 const bool try_resolving_type = type_die.GetAttributeValueAsUnsigned(
3049 DW_AT_APPLE_objc_complete_type, 0);
3050 if (!try_resolving_type)
3059 "resolved 0x%8.8" PRIx64
" from %s to 0x%8.8" PRIx64
3060 " (cu 0x%8.8" PRIx64
")\n",
3062 m_objfile_sp->GetFileSpec().GetFilename().AsCString(
"<Unknown>"),
3063 type_die.
GetID(), type_cu->GetID());
3067 type_sp = resolved_type->shared_from_this();
3075 const char *name = die.
GetName();
3082 "Searching definition DIE in {0}: '{1}'",
3083 GetObjectFile()->GetFileSpec().GetFilename().GetString(), name));
3091 "SymbolFileDWARF::FindDefinitionDIE(tag={0} "
3092 "({1}), name='{2}')",
3103 if (
auto err = type_system_or_err.takeError()) {
3105 "Cannot get TypeSystem for language {1}: {0}",
3108 type_system = *type_system_or_err;
3114 std::vector<std::string> template_params;
3117 type_system ? type_system->GetDWARFParser() :
nullptr;
3118 for (
DWARFDIE ctx_die = die; ctx_die && !isUnitType(ctx_die.Tag());
3119 ctx_die = ctx_die.GetParentDeclContextDIE()) {
3121 template_params.push_back(
3122 (ctx_die.IsStructUnionOrClass() && dwarf_ast)
3126 const bool any_template_params = llvm::any_of(
3127 template_params, [](llvm::StringRef p) {
return !p.empty(); });
3129 auto die_matches = [&](
DWARFDIE type_die) {
3131 const bool tag_matches =
3132 type_die.Tag() == tag ||
3136 if (any_template_params) {
3138 for (
DWARFDIE ctx_die = type_die; ctx_die && !isUnitType(ctx_die.Tag()) &&
3139 pos < template_params.size();
3141 if (template_params[pos].empty())
3143 if (template_params[pos] !=
3147 if (pos != template_params.size())
3153 m_index->GetFullyQualifiedType(die_dwarf_decl_ctx, [&](
DWARFDIE type_die) {
3161 if (!die_matches(type_die)) {
3165 "SymbolFileDWARF::FindDefinitionDIE(tag={0} ({1}), "
3166 "name='{2}') ignoring die={3:x16} ({4})",
3177 "SymbolFileDWARF::FindDefinitionTypeDIE(tag={0} ({1}), name='{2}') "
3178 "trying die={3:x16} ({4})",
3190 bool *type_is_new_ptr) {
3195 if (
auto err = type_system_or_err.takeError()) {
3197 "Unable to parse type: {0}");
3200 auto ts = *type_system_or_err;
3210 if (die.
Tag() == DW_TAG_subprogram) {
3214 if (scope_qualified_name.size()) {
3226 bool parse_siblings,
bool parse_children) {
3227 size_t types_added = 0;
3232 bool type_is_new =
false;
3234 Tag dwarf_tag =
static_cast<Tag
>(tag);
3239 if (isType(dwarf_tag) && tag != DW_TAG_subrange_type)
3246 if (die.
Tag() == DW_TAG_subprogram) {
3271 size_t functions_added = 0;
3280 return functions_added;
3285 size_t types_added = 0;
3307 function_die.
GetCU(),
true);
3311 const size_t num_variables =
3316 return num_variables;
3321 if (dwarf_cu ==
nullptr)
3324 uint32_t vars_added = 0;
3327 if (variables.get() ==
nullptr) {
3328 variables = std::make_shared<VariableList>();
3334 variables->AddVariableIfUnique(var_sp);
3359 die_to_variable[die.
GetDIE()] = var_sp;
3361 die_to_variable[spec_die.GetDIE()] = var_sp;
3370 const addr_t func_low_pc) {
3375 uint64_t block_length = form_value.
Unsigned();
3383 if (form_value.
Form() == DW_FORM_loclistx)
3392 return location_list;
3404 uint64_t block_offset =
3406 uint64_t block_length = form_value.
Unsigned();
3408 module,
DataExtractor(debug_info_data, block_offset, block_length),
3411 if (
const char *str = form_value.
AsCString())
3431 if (!debug_map_objfile)
3435 if (!debug_map_symtab)
3464 if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
3465 (tag != DW_TAG_formal_parameter || !sc.
function))
3469 const char *name =
nullptr;
3470 const char *mangled =
nullptr;
3473 bool is_external =
false;
3474 bool is_artificial =
false;
3478 for (
size_t i = 0; i < attributes.
Size(); ++i) {
3485 case DW_AT_decl_file:
3489 case DW_AT_decl_line:
3492 case DW_AT_decl_column:
3498 case DW_AT_linkage_name:
3499 case DW_AT_MIPS_linkage_name:
3503 type_die_form = form_value;
3505 case DW_AT_external:
3506 is_external = form_value.
Boolean();
3508 case DW_AT_const_value:
3509 const_value_form = form_value;
3511 case DW_AT_location:
3512 location_form = form_value;
3514 case DW_AT_start_scope:
3517 case DW_AT_artificial:
3518 is_artificial = form_value.
Boolean();
3520 case DW_AT_declaration:
3521 case DW_AT_description:
3522 case DW_AT_endianity:
3524 case DW_AT_specification:
3525 case DW_AT_visibility:
3527 case DW_AT_abstract_origin:
3536 bool location_is_const_value_data =
3542 if (const_value_form.
IsValid())
3550 bool is_static_member = (parent_tag == DW_TAG_compile_unit ||
3551 parent_tag == DW_TAG_partial_unit) &&
3552 (parent_context_die.
Tag() == DW_TAG_class_type ||
3553 parent_context_die.
Tag() == DW_TAG_structure_type);
3558 bool has_explicit_mangled = mangled !=
nullptr;
3570 if ((parent_tag == DW_TAG_compile_unit ||
3571 parent_tag == DW_TAG_partial_unit) &&
3578 if (tag == DW_TAG_formal_parameter)
3589 bool has_explicit_location = location_form.
IsValid();
3590 bool is_static_lifetime =
3591 has_explicit_mangled ||
3592 (has_explicit_location && !location_list.
IsValid());
3595 if (!location_is_const_value_data) {
3596 bool op_error =
false;
3599 location_DW_OP_addr =
3605 "{0:x16}: {1} ({2}) has an invalid location: {3}", die.
GetOffset(),
3609 is_static_lifetime =
true;
3612 if (debug_map_symfile)
3618 if (is_static_lifetime) {
3624 if (debug_map_symfile) {
3625 bool linked_oso_file_addr =
false;
3627 if (is_external && location_DW_OP_addr == 0) {
3629 *debug_map_symfile, mangled ? mangled : name, location_list,
3631 linked_oso_file_addr =
true;
3632 symbol_context_scope = exe_symbol;
3636 if (!linked_oso_file_addr) {
3653 if (location_is_const_value_data &&
3654 die.
GetDIE()->IsGlobalOrStaticScopeVariable())
3658 if (debug_map_symfile) {
3663 [
this, debug_map_symfile](
3665 return debug_map_symfile->LinkOSOFileAddress(
3666 this, unlinked_file_addr);
3675 if (symbol_context_scope ==
nullptr) {
3676 switch (parent_tag) {
3677 case DW_TAG_subprogram:
3678 case DW_TAG_inlined_subroutine:
3679 case DW_TAG_lexical_block:
3681 symbol_context_scope =
3683 if (symbol_context_scope ==
nullptr)
3684 symbol_context_scope = sc.
function;
3694 if (!symbol_context_scope) {
3701 auto type_sp = std::make_shared<SymbolFileType>(
3704 bool use_type_size_for_value =
3705 location_is_const_value_data &&
3707 if (use_type_size_for_value && type_sp->GetType()) {
3710 type_sp->GetType()->GetByteSize(
nullptr).value_or(0),
3714 return std::make_shared<Variable>(
3715 die.
GetID(), name, mangled, type_sp, scope, symbol_context_scope,
3716 scope_ranges, &decl, location_list, is_external, is_artificial,
3717 location_is_const_value_data, is_static_member);
3727 spec_block_die_offset);
3734 switch (die.
Tag()) {
3735 case DW_TAG_subprogram:
3736 case DW_TAG_inlined_subroutine:
3737 case DW_TAG_lexical_block: {
3739 spec_block_die_offset)
3743 spec_block_die_offset)
3771 if (tag != DW_TAG_variable && tag != DW_TAG_constant)
3787 switch (parent_tag) {
3788 case DW_TAG_compile_unit:
3789 case DW_TAG_partial_unit:
3794 "parent {0:x8} {1} ({2}) with no valid compile unit in "
3795 "symbol context for {3:x8} {4} ({5}).\n",
3805 "didn't find appropriate parent DIE for variable list for {0:x8} "
3816 if (variable_list_sp)
3817 variable_list_sp->AddVariableIfUnique(var_sp);
3833 if (block_die.
Tag() != DW_TAG_inlined_subroutine) {
3834 return std::move(variable_dies);
3839 if (!abs_die || abs_die.
Tag() != DW_TAG_subprogram ||
3841 return std::move(variable_dies);
3846 DIEArray::iterator concrete_it = variable_dies.begin();
3849 bool did_merge_abstract =
false;
3850 for (; abstract_child; abstract_child = abstract_child.
GetSibling()) {
3851 if (abstract_child.
Tag() == DW_TAG_formal_parameter) {
3852 if (concrete_it == variable_dies.end() ||
3853 GetDIE(*concrete_it).
Tag() != DW_TAG_formal_parameter) {
3857 merged.push_back(*abstract_child.
GetDIERef());
3858 did_merge_abstract =
true;
3864 if (origin_of_concrete == abstract_child) {
3867 merged.push_back(*concrete_it);
3872 merged.push_back(*abstract_child.
GetDIERef());
3873 did_merge_abstract =
true;
3879 if (!did_merge_abstract)
3880 return std::move(variable_dies);
3887 for (; concrete_it != variable_dies.end(); ++concrete_it) {
3888 if (
GetDIE(*concrete_it).
Tag() == DW_TAG_formal_parameter) {
3889 return std::move(variable_dies);
3891 merged.push_back(*concrete_it);
3907 dummy_block_variables);
3917 size_t vars_added = 0;
3920 if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
3921 (tag == DW_TAG_formal_parameter)) {
3922 accumulator.push_back(*die.
GetDIERef());
3926 case DW_TAG_subprogram:
3927 case DW_TAG_inlined_subroutine:
3928 case DW_TAG_lexical_block: {
3932 if (block ==
nullptr) {
3939 if (concrete_block_die)
3944 if (block ==
nullptr)
3947 const bool can_create =
false;
3950 if (block_variable_list_sp.get() ==
nullptr) {
3951 block_variable_list_sp = std::make_shared<VariableList>();
3959 sc, child, func_low_pc, block_variables);
3964 block_variables, func_low_pc);
3973 sc, child, func_low_pc, accumulator);
3983 llvm::ArrayRef<DIERef> variable_dies,
lldb::addr_t func_low_pc) {
3985 for (
auto &die : variable_dies) {
3990 return variable_dies.size();
3998 if (child.Tag() != DW_TAG_call_site_parameter &&
3999 child.Tag() != DW_TAG_GNU_call_site_parameter)
4002 std::optional<DWARFExpressionList> LocationInCallee;
4003 std::optional<DWARFExpressionList> LocationInCaller;
4009 auto parse_simple_location =
4010 [&](
int attr_index) -> std::optional<DWARFExpressionList> {
4016 auto data = child.GetData();
4017 uint64_t block_offset = form_value.
BlockData() - data.GetDataStart();
4018 uint64_t block_length = form_value.
Unsigned();
4024 for (
size_t i = 0; i < attributes.
Size(); ++i) {
4026 if (attr == DW_AT_location)
4027 LocationInCallee = parse_simple_location(i);
4028 if (attr == DW_AT_call_value || attr == DW_AT_GNU_call_site_value)
4029 LocationInCaller = parse_simple_location(i);
4032 if (LocationInCallee && LocationInCaller) {
4034 parameters.push_back(param);
4041std::vector<std::unique_ptr<lldb_private::CallEdge>>
4045 bool has_call_edges =
4048 if (!has_call_edges)
4052 LLDB_LOG(log,
"CollectCallEdges: Found call site info in {0}",
4060 std::vector<std::unique_ptr<CallEdge>> call_edges;
4062 if (child.Tag() != DW_TAG_call_site && child.Tag() != DW_TAG_GNU_call_site)
4065 std::optional<DWARFDIE> call_origin;
4066 std::optional<DWARFExpressionList> call_target;
4070 bool tail_call =
false;
4076 for (
size_t i = 0; i < attributes.
Size(); ++i) {
4079 LLDB_LOG(log,
"CollectCallEdges: Could not extract TAG_call_site form");
4085 if (attr == DW_AT_call_tail_call || attr == DW_AT_GNU_tail_call)
4086 tail_call = form_value.
Boolean();
4089 if (attr == DW_AT_call_origin || attr == DW_AT_abstract_origin) {
4091 if (!call_origin->IsValid()) {
4092 LLDB_LOG(log,
"CollectCallEdges: Invalid call origin in {0}",
4098 if (attr == DW_AT_low_pc)
4099 low_pc = form_value.
Address();
4104 if (attr == DW_AT_call_return_pc)
4105 return_pc = form_value.
Address();
4110 if (attr == DW_AT_call_pc)
4111 call_inst_pc = form_value.
Address();
4115 if (attr == DW_AT_call_target || attr == DW_AT_GNU_call_site_target) {
4118 "CollectCallEdges: AT_call_target does not have block form");
4122 auto data = child.GetData();
4123 uint64_t block_offset = form_value.
BlockData() - data.GetDataStart();
4124 uint64_t block_length = form_value.
Unsigned();
4130 if (!call_origin && !call_target) {
4131 LLDB_LOG(log,
"CollectCallEdges: call site without any call target");
4138 caller_address = return_pc;
4141 caller_address = low_pc;
4144 caller_address = call_inst_pc;
4147 LLDB_LOG(log,
"CollectCallEdges: No caller address");
4159 std::unique_ptr<CallEdge> edge;
4162 "CollectCallEdges: Found call origin: {0} (retn-PC: {1:x}) "
4164 call_origin->GetPubname(), return_pc, call_inst_pc);
4165 edge = std::make_unique<DirectCallEdge>(
4166 call_origin->GetMangledName(), caller_address_type, caller_address,
4167 tail_call, std::move(parameters));
4173 LLDB_LOG(log,
"CollectCallEdges: Found indirect call target: {0}",
4176 edge = std::make_unique<IndirectCallEdge>(
4177 *call_target, caller_address_type, caller_address, tail_call,
4178 std::move(parameters));
4181 if (log && parameters.size()) {
4184 param.LocationInCallee.GetDescription(&callee_loc_desc,
4186 param.LocationInCaller.GetDescription(&caller_loc_desc,
4188 LLDB_LOG(log,
"CollectCallEdges: \tparam: {0} => {1}",
4193 call_edges.push_back(std::move(edge));
4198std::vector<std::unique_ptr<lldb_private::CallEdge>>
4220 auto ts = *ts_or_err;
4232 for (
size_t cu_idx = 0; cu_idx < num_cus; cu_idx++) {
4235 if (dwarf_cu ==
nullptr)
4240 if (!dwarf_cu->
GetDWOId().has_value())
4244 std::make_shared<StructuredData::Dictionary>();
4245 const uint64_t dwo_id = dwarf_cu->
GetDWOId().value();
4246 dwo_data->AddIntegerItem(
"dwo_id", dwo_id);
4251 dwo_data->AddStringItem(
"dwo_name", dwo_name);
4253 dwo_data->AddStringItem(
"error",
"missing dwo name");
4257 dwarf_cu, DW_AT_comp_dir,
nullptr);
4259 dwo_data->AddStringItem(
"comp_dir", comp_dir);
4262 dwo_data->AddStringItem(
4264 llvm::formatv(
"unable to get unit DIE for DWARFUnit at {0:x}",
4273 dwo_data->AddStringItem(
4274 "resolved_dwo_path",
4277 dwo_data->AddStringItem(
"error",
4280 dwo_data->AddBooleanItem(
"loaded", dwo_symfile !=
nullptr);
4281 if (!errors_only || dwo_data->HasKey(
"error"))
4282 separate_debug_info_files.
AddItem(dwo_data);
4287 d.
AddItem(
"separate-debug-info-files",
4288 std::make_shared<StructuredData::Array>(
4289 std::move(separate_debug_info_files)));
4298 module_sp->GetSymbolFile()->GetBackingSymbolFile());
4310 symfiles.
Append(module_fspec);
4316 if (symfile_fspec != module_fspec) {
4317 symfiles.
Append(symfile_fspec);
4324 if (filename_no_ext != module_fspec.
GetFilename()) {
4325 FileSpec module_spec_no_ext(module_fspec);
4327 symfiles.
Append(module_spec_no_ext);
4335 for (
const auto &symfile : symfiles.
files()) {
4337 FileSpec(symfile.GetPath() +
".dwp", symfile.GetPathStyle());
4338 LLDB_LOG(log,
"Searching for DWP using: \"{0}\"",
4347 LLDB_LOG(log,
"No DWP file found locally");
4356 LLDB_LOG(log,
"Found DWP file: \"{0}\"", dwp_filespec);
4362 dwp_file_data_offset);
4369 LLDB_LOG(log,
"Unable to locate for DWP file for: \"{0}\"",
4376llvm::Expected<lldb::TypeSystemSP>
4383 if (
auto err = type_system_or_err.takeError()) {
4385 "Unable to get DWARFASTParser: {0}");
4388 if (
auto ts = *type_system_or_err)
4389 return ts->GetDWARFParser();
4395 return dwarf_ast->GetDeclForUIDFromDWARF(die);
4401 return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
4408 return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
4416 case DW_LANG_Mips_Assembler:
4429 if (llvm::dwarf::isCPlusPlus(lang))
4430 lang = DW_LANG_C_plus_plus;
4436 return m_index->GetIndexTime();
4455 if (dwo_error.
Fail())
4465 if (dwarf_cu->
HasAny({DW_TAG_variable, DW_TAG_formal_parameter}))
4468 return Status(
"no variable information is available in debug info for this "
4473 std::unordered_map<lldb::CompUnitSP, lldb_private::Args> &args) {
4477 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
4494 args.insert({comp_unit,
Args(flags)});
static llvm::raw_ostream & error(Stream &strm)
#define DEBUG_PRINTF(fmt,...)
static PluginProperties & GetGlobalPluginProperties()
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
#define LLDB_LOG_ERROR(log, error,...)
#define LLDB_PLUGIN_DEFINE(PluginName)
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
static PluginProperties & GetGlobalPluginProperties()
static bool UpdateCompilerContextForSimpleTemplateNames(TypeQuery &match)
static ConstString GetDWARFMachOSegmentName()
static DWARFExpressionList GetExprListFromAtConstValue(DWARFFormValue form_value, ModuleSP module, const DWARFDIE &die)
Creates a DWARFExpressionList from an DW_AT_const_value.
static void ParseSupportFilesFromPrologue(SupportFileList &support_files, const lldb::ModuleSP &module, const llvm::DWARFDebugLine::Prologue &prologue, FileSpec::Style style, llvm::StringRef compile_dir={})
static CallSiteParameterArray CollectCallSiteParameters(ModuleSP module, DWARFDIE call_site_die)
Collect call site parameters in a DW_TAG_call_site DIE.
static void MakeAbsoluteAndRemap(FileSpec &file_spec, DWARFUnit &dwarf_cu, const ModuleSP &module_sp)
Make an absolute path out of file_spec and remap it using the module's source remapping dictionary.
static const llvm::DWARFDebugLine::LineTable * ParseLLVMLineTable(DWARFContext &context, llvm::DWARFDebugLine &line, dw_offset_t line_offset, dw_offset_t unit_offset)
bool IsStructOrClassTag(llvm::dwarf::Tag Tag)
static bool SplitTemplateParams(llvm::StringRef fullname, llvm::StringRef &basename, llvm::StringRef &template_params)
Split a name up into a basename and template parameters.
static Symbol * fixupExternalAddrZeroVariable(SymbolFileDWARFDebugMap &debug_map_symfile, llvm::StringRef name, DWARFExpressionList &expr_list, const DWARFDIE &die)
Global variables that are not initialized may have their address set to zero.
static std::optional< uint64_t > GetDWOId(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
Return the DW_AT_(GNU_)dwo_id.
static std::set< dw_form_t > GetUnsupportedForms(llvm::DWARFDebugAbbrev *debug_abbrev)
static std::optional< std::string > GetFileByIndex(const llvm::DWARFDebugLine::Prologue &prologue, size_t idx, llvm::StringRef compile_dir, FileSpec::Style style)
static DWARFExpressionList GetExprListFromAtLocation(DWARFFormValue form_value, ModuleSP module, const DWARFDIE &die, const addr_t func_low_pc)
Creates a DWARFExpressionList from an DW_AT_location form_value.
static bool ParseLLVMLineTablePrologue(DWARFContext &context, llvm::DWARFDebugLine::Prologue &prologue, dw_offset_t line_offset, dw_offset_t unit_offset)
static const char * GetDWOName(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
Return the DW_AT_(GNU_)dwo_name.
#define DIE_IS_BEING_PARSED
#define ASSERT_MODULE_LOCK(expr)
#define LLDB_SCOPED_TIMER()
#define LLDB_SCOPED_TIMERF(...)
lldb_private::ClangASTImporter & GetClangASTImporter()
void MapDeclDIEToDefDIE(const lldb_private::plugin::dwarf::DWARFDIE &decl_die, const lldb_private::plugin::dwarf::DWARFDIE &def_die)
A section + offset based address range class.
Address & GetBaseAddress()
Get accessor for the base address of the range.
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
A section + offset based address class.
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
lldb::SectionSP GetSection() const
Get const accessor for the section.
void Clear()
Clear the object's state.
lldb::addr_t GetFileAddress() const
Get the file address.
lldb::addr_t GetOffset() const
Get the section relative offset value.
bool IsValid() const
Check if the object state is valid.
A command line argument class.
A class that describes a single lexical block.
lldb::VariableListSP GetBlockVariableList(bool can_create)
Get the variable list for this block only.
Block * FindBlockByID(lldb::user_id_t block_id)
void SetVariableList(lldb::VariableListSP &variable_list_sp)
Set accessor for the variable list.
bool GetStartAddress(Address &addr)
void SetDidParseVariables(bool b, bool set_children)
void AddRange(const Range &range)
Add a new offset range to this block.
void AddChild(const lldb::BlockSP &child_block_sp)
Add a child to this object.
void SetInlinedFunctionInfo(const char *name, const char *mangled, const Declaration *decl_ptr, const Declaration *call_decl_ptr)
Set accessor for any inlined function information.
static bool ExtractContextAndIdentifier(const char *name, llvm::StringRef &context, llvm::StringRef &identifier)
Checksum(llvm::MD5::MD5Result md5=g_sentinel)
bool CanImport(const CompilerType &type)
Returns true iff the given type was copied from another TypeSystemClang and the original type in this...
bool CompleteType(const CompilerType &compiler_type)
static bool LanguageSupportsClangModules(lldb::LanguageType language)
Query whether Clang supports modules for a particular language.
A class that describes a compilation unit.
void SetVariableList(lldb::VariableListSP &variable_list_sp)
Set accessor for the variable list.
const SupportFileList & GetSupportFiles()
Get the compile unit's support file list.
lldb::VariableListSP GetVariableList(bool can_create)
Get the variable list for a compile unit.
void SetDebugMacros(const DebugMacrosSP &debug_macros)
const FileSpec & GetPrimaryFile() const
Return the primary source spec associated with this compile unit.
void ResolveSymbolContext(const SourceLocationSpec &src_location_spec, lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list, RealpathPrefixes *realpath_prefixes=nullptr)
Resolve symbol contexts by file and line.
void SetLineTable(LineTable *line_table)
Set the line table for the compile unit.
lldb::FunctionSP FindFunctionByUID(lldb::user_id_t uid)
Finds a function by user ID.
lldb::LanguageType GetLanguage()
LineTable * GetLineTable()
Get the line table for the compile unit.
Represents a generic declaration context in a program.
ConstString GetScopeQualifiedName() const
ConstString GetName() const
bool IsContainedInLookup(CompilerDeclContext other) const
Check if the given other decl context is contained in the lookup of this decl context (for example be...
TypeSystem * GetTypeSystem() const
void * GetOpaqueDeclContext() const
Represents a generic declaration such as a function declaration.
std::shared_ptr< TypeSystemType > dyn_cast_or_null()
Return a shared_ptr<TypeSystemType> if dyn_cast succeeds.
Generic representation of a type in a programming language.
TypeSystemSPWrapper GetTypeSystem() const
Accessors.
lldb::opaque_compiler_type_t GetOpaqueQualType() const
A uniqued constant string class.
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
bool IsEmpty() const
Test for empty string.
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
const char * GetCString() const
Get the string value as a C string.
"lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file address range to a single ...
llvm::Expected< Value > Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx, lldb::addr_t func_load_addr, const Value *initial_value_ptr, const Value *object_address_ptr) const
bool ContainsThreadLocalStorage() const
const DWARFExpression * GetAlwaysValidExpr() const
void SetModule(const lldb::ModuleSP &module)
bool IsValid() const
Return true if the location expression contains data.
void SetFuncFileAddress(lldb::addr_t func_file_addr)
bool LinkThreadLocalStorage(lldb::ModuleSP new_module_sp, std::function< lldb::addr_t(lldb::addr_t file_addr)> const &link_address_callback)
DWARFExpression * GetMutableExpressionAtAddress(lldb::addr_t func_load_addr=LLDB_INVALID_ADDRESS, lldb::addr_t load_addr=0)
"lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location expression and interprets it.
void DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const
lldb::addr_t GetLocation_DW_OP_addr(const plugin::dwarf::DWARFUnit *dwarf_cu, bool &error) const
Return the address specified by the first DW_OP_{addr, addrx, GNU_addr_index} in the operation stream...
bool Update_DW_OP_addr(const plugin::dwarf::DWARFUnit *dwarf_cu, lldb::addr_t file_addr)
void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size, uint8_t addr_byte_size)
static bool ParseDWARFLocationList(const plugin::dwarf::DWARFUnit *dwarf_cu, const DataExtractor &data, DWARFExpressionList *loc_list)
A class to manage flag bits.
A class that describes the declaration location of a lldb object.
void SetLine(uint32_t line)
Set accessor for the declaration line number.
void SetColumn(uint16_t column)
Set accessor for the declaration column number.
void SetFile(const FileSpec &file_spec)
Set accessor for the declaration file specification.
A class that measures elapsed time in an exception safe way.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
llvm::iterator_range< const_iterator > files() const
const FileSpec & GetFileSpecAtIndex(size_t idx) const
Get file at index.
void Append(const FileSpec &file)
Append a FileSpec object to the list.
size_t GetSize() const
Get the number of files in the file list.
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
void AppendPathComponent(llvm::StringRef component)
static bool Match(const FileSpec &pattern, const FileSpec &file)
Match FileSpec pattern against FileSpec file.
bool IsRelative() const
Returns true if the filespec represents a relative path.
const ConstString & GetFilename() const
Filename string const get accessor.
void MakeAbsolute(const FileSpec &dir)
Make the FileSpec absolute by treating it relative to dir.
void SetPath(llvm::StringRef p)
Temporary helper for FileSystem change.
ConstString GetFileNameStrippingExtension() const
Return the filename without the extension part.
void PrependPathComponent(llvm::StringRef component)
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
llvm::sys::path::Style Style
void SetFilename(ConstString filename)
Filename string set accessor.
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
bool Exists(const FileSpec &file_spec) const
Returns whether the given file exists.
static FileSystem & Instance()
A class that describes a function.
const AddressRange & GetAddressRange()
lldb::ModuleSP CalculateSymbolContextModule() override
CompileUnit * GetCompileUnit()
Get accessor for the compile unit that owns this function.
Block & GetBlock(bool can_create)
Get accessor for the block list.
static const char * GetNameForLanguageType(lldb::LanguageType language)
static bool LanguageIsCPlusPlus(lldb::LanguageType language)
static std::unique_ptr< LineSequence > CreateLineSequenceContainer()
bool FindLineEntryByAddress(const Address &so_addr, LineEntry &line_entry, uint32_t *index_ptr=nullptr)
Find a line entry that contains the section offset address so_addr.
static void AppendLineEntryToSequence(LineSequence *sequence, lldb::addr_t file_addr, uint32_t line, uint16_t column, uint16_t file_idx, bool is_start_of_statement, bool is_start_of_basic_block, bool is_prologue_end, bool is_epilogue_begin, bool is_terminal_entry)
static Mangled::ManglingScheme GetManglingScheme(llvm::StringRef const name)
Try to identify the mangling scheme used.
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
static Status GetSharedModule(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr, llvm::SmallVectorImpl< lldb::ModuleSP > *old_modules, bool *did_create_ptr, bool always_create=false)
ArchSpec & GetArchitecture()
FileSpec & GetSymbolFileSpec()
A class that encapsulates name lookup information.
lldb::FunctionNameType GetNameTypeMask() const
void SetLookupName(ConstString name)
ConstString GetLookupName() const
A class that describes an executable image and its associated object and symbol files.
A plug-in interface definition class for object file parsers.
static lldb::ObjectFileSP FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file_spec, lldb::offset_t file_offset, lldb::offset_t file_size, lldb::DataBufferSP &data_sp, lldb::offset_t &data_offset)
Find a ObjectFile plug-in that can parse file_spec.
Symtab * GetSymtab()
Gets the symbol table for the currently selected architecture (and object for archives).
@ eTypeDebugInfo
An object file that contains only debug information.
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool CreateSettingForSymbolFilePlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, llvm::StringRef description, bool is_global_property)
static lldb::OptionValuePropertiesSP GetSettingForSymbolFilePlugin(Debugger &debugger, llvm::StringRef setting_name)
static FileSpec LocateExecutableSymbolFile(const ModuleSpec &module_spec, const FileSpecList &default_search_paths)
static bool UnregisterPlugin(ABICreateInstance create_callback)
A Progress indicator helper class.
RangeData< B, S, T > Entry
BaseType GetMaxRangeEnd(BaseType fail_value) const
Entry & GetEntryRef(size_t i)
BaseType GetMinRangeBase(BaseType fail_value) const
llvm::StringRef GetText() const
Access the regular expression text.
lldb::SectionSP FindSectionByName(ConstString section_dstr) const