10#include "clang/Basic/ABI.h"
11#include "llvm/ADT/STLExtras.h"
12#include "llvm/ADT/SmallPtrSet.h"
13#include "llvm/ADT/StringExtras.h"
14#include "llvm/ADT/StringRef.h"
15#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
16#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
17#include "llvm/Support/Casting.h"
18#include "llvm/Support/Error.h"
19#include "llvm/Support/ErrorExtras.h"
20#include "llvm/Support/FileUtilities.h"
21#include "llvm/Support/FormatAdapters.h"
22#include "llvm/Support/Threading.h"
43#include "lldb/Host/Config.h"
87#include "llvm/DebugInfo/DWARF/DWARFContext.h"
88#include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
89#include "llvm/Demangle/Demangle.h"
90#include "llvm/Support/FileSystem.h"
91#include "llvm/Support/FormatVariadic.h"
103#ifdef ENABLE_DEBUG_PRINTF
105#define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
107#define DEBUG_PRINTF(fmt, ...)
113using namespace llvm::dwarf;
121#define LLDB_PROPERTIES_symbolfiledwarf
122#include "SymbolFileDWARFProperties.inc"
125#define LLDB_PROPERTIES_symbolfiledwarf
126#include "SymbolFileDWARFPropertiesEnum.inc"
131 static llvm::StringRef GetSettingName() {
136 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
137 m_collection_sp->Initialize(g_symbolfiledwarf_properties_def);
140 bool IgnoreFileIndexes()
const {
141 return GetPropertyAtIndexAs<bool>(ePropertyIgnoreIndexes,
false);
148 return Tag == llvm::dwarf::Tag::DW_TAG_class_type ||
149 Tag == llvm::dwarf::Tag::DW_TAG_structure_type;
153 static PluginProperties g_settings;
157static const llvm::DWARFDebugLine::LineTable *
163 llvm::DWARFContext &ctx = context.
GetAsLLVM();
164 llvm::Expected<const llvm::DWARFDebugLine::LineTable *> line_table =
165 line.getOrParseLineTable(
166 data, line_offset, ctx,
nullptr, [&](llvm::Error e) {
169 "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
174 "SymbolFileDWARF::ParseLineTable failed to parse: {0}");
181 llvm::DWARFDebugLine::Prologue &prologue,
187 llvm::DWARFContext &ctx = context.
GetAsLLVM();
188 uint64_t offset = line_offset;
189 llvm::Error
error = prologue.parse(
194 "SymbolFileDWARF::ParseSupportFiles failed to parse "
195 "line table prologue: {0}");
200 "SymbolFileDWARF::ParseSupportFiles failed to parse line "
201 "table prologue: {0}");
207static std::optional<std::string>
211 std::string abs_path;
212 auto absolute = llvm::DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath;
213 if (prologue.getFileNameByIndex(idx, compile_dir, absolute, abs_path, style))
214 return std::move(abs_path);
217 std::string rel_path;
218 auto relative = llvm::DILineInfoSpecifier::FileLineInfoKind::RawValue;
219 if (!prologue.getFileNameByIndex(idx, compile_dir, relative, rel_path, style))
221 return std::move(rel_path);
227 llvm::StringRef compile_dir = {}) {
230 if (prologue.FileNames.empty())
234 const bool is_one_based = prologue.getVersion() < 5;
235 const size_t file_names = prologue.FileNames.size();
236 const size_t first_file_idx = is_one_based ? 1 : 0;
237 const size_t last_file_idx = is_one_based ? file_names : file_names - 1;
244 for (
size_t idx = first_file_idx; idx <= last_file_idx; ++idx) {
245 std::string remapped_file;
246 if (
auto file_path =
GetFileByIndex(prologue, idx, compile_dir, style)) {
247 auto entry = prologue.getFileNameEntry(idx);
248 auto source = entry.Source.getAsCString();
250 consumeError(source.takeError());
252 llvm::StringRef source_ref(*source);
253 if (!source_ref.empty()) {
257 LazyDWARFSourceFile(
const FileSpec &fs, llvm::StringRef source,
259 : SupportFile(fs), source(source), style(style) {}
262 llvm::StringRef source;
264 std::unique_ptr<llvm::FileRemover> remover;
271 llvm::SmallString<0> name;
274 auto ec = llvm::sys::fs::createTemporaryFile(
275 "", llvm::sys::path::filename(orig_name, style), fd, name);
278 "Could not create temporary file");
281 remover = std::make_unique<llvm::FileRemover>(name);
283 size_t num_bytes = source.size();
284 file.Write(source.data(), num_bytes);
289 support_files.
Append(std::make_unique<LazyDWARFSourceFile>(
290 FileSpec(*file_path), *source, style));
294 if (
auto remapped = module->RemapSourceFile(llvm::StringRef(*file_path)))
295 remapped_file = *remapped;
297 remapped_file = std::move(*file_path);
301 if (prologue.ContentTypes.HasMD5) {
302 const llvm::DWARFDebugLine::FileNameEntry &file_name_entry =
303 prologue.getFileNameEntry(idx);
304 checksum = file_name_entry.
Checksum;
318 llvm::Expected<llvm::DWARFDebugLine::LineTable>
line_table)
335 SymbolContextItem resolve_scope,
338 const llvm::DWARFDebugLine::LineTable *
GetLineTable(uint32_t cu_idx);
339 const llvm::DWARFDebugLine::Prologue *
GetPrologue(uint32_t cu_idx);
347static std::unique_ptr<LineTable>
349 const llvm::DWARFDebugLine::LineTable &line_table,
351 std::vector<LineTable::Sequence> sequences;
354 for (
const llvm::DWARFDebugLine::Sequence &seq : line_table.Sequences) {
358 if (seq.LowPC < first_code_address)
361 for (
unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
362 const llvm::DWARFDebugLine::Row &row = line_table.Rows[idx];
364 sequence, row.Address.Address, row.Line, row.Column, row.File,
365 row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
368 sequences.push_back(std::move(sequence));
371 return std::make_unique<LineTable>(&comp_unit, std::move(sequences));
377 llvm::DWARFDataExtractor line_data =
378 m_symfile.m_context.getOrLoadLineData().GetAsLLVMDWARF();
379 if (line_data.getData().empty())
382 llvm::DWARFContext &context =
m_symfile.m_context.GetAsLLVM();
383 llvm::DWARFDebugLine::SectionParser parser(line_data, context,
384 context.normal_units());
386 auto recoverable = [&](llvm::Error
error) {
388 "SymbolFileDWARF failed to parse standalone line "
391 auto append_error = [&](llvm::Error
error) {
392 LLDB_LOG(log,
"SymbolFileDWARF failed to parse standalone line table: {0}",
393 llvm::toStringWithoutConsuming(
error));
395 llvm::Expected<llvm::DWARFDebugLine::LineTable>(std::move(
error)));
398 while (!parser.done()) {
399 llvm::Error parse_error = llvm::Error::success();
400 auto unrecoverable = [&](llvm::Error error) {
401 parse_error = llvm::joinErrors(std::move(parse_error), std::move(error));
403 llvm::DWARFDebugLine::LineTable line_table =
404 parser.parseNext(recoverable, unrecoverable);
407 append_error(std::move(parse_error));
409 line_table.Prologue.getVersion())) {
410 append_error(llvm::createStringError(
411 llvm::inconvertibleErrorCode(),
412 "unsupported standalone line table version %u",
413 line_table.Prologue.getVersion()));
414 }
else if (line_table.Prologue.FileNames.empty()) {
416 llvm::createStringError(llvm::inconvertibleErrorCode(),
417 "standalone line table has no files"));
419 line_tables.emplace_back(llvm::Expected<llvm::DWARFDebugLine::LineTable>(
420 std::move(line_table)));
427 llvm::consumeError(entry.line_table.takeError());
436const llvm::DWARFDebugLine::Prologue *
444const llvm::DWARFDebugLine::LineTable *
455 for (uint32_t cu_idx = 0; cu_idx <
line_tables.size(); ++cu_idx) {
456 const llvm::DWARFDebugLine::LineTable *line_table =
GetLineTable(cu_idx);
459 for (
const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
460 if (seq.isValid() && seq.LowPC >= first_code_address)
461 aranges.AppendRange(cu_idx, seq.LowPC, seq.HighPC);
475 const llvm::DWARFDebugLine::Prologue *prologue =
GetPrologue(cu_idx);
481 support_files,
m_symfile.m_objfile_sp->GetModule(), *prologue,
482 m_symfile.m_objfile_sp->GetFileSpec().GetPathStyle());
487 const size_t primary_file_idx = prologue->getVersion() < 5 ? 1 : 0;
494 CompUnitSP cu_sp = std::make_shared<CompileUnit>(
495 module_sp,
nullptr, primary_file, cu_idx,
497 m_symfile.SetCompileUnitAtIndex(cu_idx, cu_sp);
502 const llvm::DWARFDebugLine::LineTable *line_table =
515 const Address &so_addr, SymbolContextItem resolve_scope,
528 uint32_t resolved = eSymbolContextCompUnit;
530 if (resolve_scope & eSymbolContextLineEntry) {
533 if (
m_symfile.FixupAddress(exe_so_addr) &&
534 line_table->FindLineEntryByAddress(exe_so_addr, sc.
line_entry))
535 resolved |= eSymbolContextLineEntry;
551 debugger, PluginProperties::GetSettingName())) {
552 const bool is_global_setting =
true;
555 "Properties for the dwarf symbol-file plug-in.", is_global_setting);
566 return "DWARF and DWARF3 debug symbol file reader.";
570 return LLDB_DWO_DIAGNOSTIC_SUFFIX;
574 if (objfile_sp->GetArchitecture().GetTriple().isWasm())
584 return debug_map_symfile->GetTypeList();
593 if (die_offset >= max_die_offset)
596 if (die_offset >= min_die_offset) {
599 bool add_type =
false;
602 case DW_TAG_array_type:
603 add_type = (type_mask & eTypeClassArray) != 0;
605 case DW_TAG_unspecified_type:
606 case DW_TAG_base_type:
607 add_type = (type_mask & eTypeClassBuiltin) != 0;
609 case DW_TAG_class_type:
610 add_type = (type_mask & eTypeClassClass) != 0;
612 case DW_TAG_structure_type:
613 add_type = (type_mask & eTypeClassStruct) != 0;
615 case DW_TAG_union_type:
616 add_type = (type_mask & eTypeClassUnion) != 0;
618 case DW_TAG_enumeration_type:
619 add_type = (type_mask & eTypeClassEnumeration) != 0;
621 case DW_TAG_subroutine_type:
622 case DW_TAG_subprogram:
623 case DW_TAG_inlined_subroutine:
624 add_type = (type_mask & eTypeClassFunction) != 0;
626 case DW_TAG_pointer_type:
627 add_type = (type_mask & eTypeClassPointer) != 0;
629 case DW_TAG_rvalue_reference_type:
630 case DW_TAG_reference_type:
631 add_type = (type_mask & eTypeClassReference) != 0;
634 add_type = (type_mask & eTypeClassTypedef) != 0;
636 case DW_TAG_ptr_to_member_type:
637 add_type = (type_mask & eTypeClassMemberPointer) != 0;
644 const bool assert_not_being_parsed =
true;
647 type_set.insert(type);
652 GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
658 TypeClass type_mask,
TypeList &type_list)
671 unit = &unit->GetNonSkeletonUnit();
672 GetTypes(unit->DIE(), unit->GetOffset(), unit->GetNextUnitOffset(),
673 type_mask, type_set);
680 for (
size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx)
684 std::set<CompilerType> compiler_type_set;
685 for (
Type *type : type_set) {
686 CompilerType compiler_type = type->GetForwardCompilerType();
687 if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) {
688 compiler_type_set.insert(compiler_type);
689 type_list.
Insert(type->shared_from_this());
703 case DW_TAG_compile_unit:
704 case DW_TAG_partial_unit:
705 case DW_TAG_subprogram:
706 case DW_TAG_inlined_subroutine:
707 case DW_TAG_lexical_block:
726 static ConstString g_dwarf_section_name(
"__DWARF");
727 return g_dwarf_section_name;
730llvm::DenseMap<const DWARFDebugInfoEntry *, Type *> &
733 return debug_map_symfile->GetDIEToType();
737llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> &
740 return debug_map_symfile->GetForwardDeclCompilerTypeToDIE();
746 if (debug_map_symfile)
752llvm::Expected<lldb::TypeSystemSP>
755 return debug_map_symfile->GetTypeSystemForLanguage(language);
778 *
GetObjectFile()->GetModule(), apple_names, apple_namespaces,
779 apple_types, apple_objc,
m_context.getOrLoadStrData());
789 llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>> index_or =
794 m_index = std::move(*index_or);
798 "Unable to read .debug_names data: {0}");
803 std::make_unique<ManualDWARFIndex>(*
GetObjectFile()->GetModule(), *
this);
815 for (
SectionSP section_sp : section_list) {
816 if (section_sp->GetChildren().GetSize() > 0) {
826 return version >= 2 && version <= 5;
829static std::set<dw_form_t>
834 std::set<dw_form_t> unsupported_forms;
835 for (
const auto &[_, decl_set] : *debug_abbrev)
836 for (
const auto &decl : decl_set)
837 for (
const auto &attr : decl.attributes())
839 unsupported_forms.insert(attr.Form);
841 return unsupported_forms;
845 uint32_t abilities = 0;
847 const Section *section =
nullptr;
849 if (section_list ==
nullptr)
852 uint64_t debug_abbrev_file_size = 0;
853 uint64_t debug_info_file_size = 0;
854 uint64_t debug_line_file_size = 0;
863 if (section !=
nullptr) {
874 if (!unsupported_forms.empty()) {
876 error.Printf(
"unsupported DW_FORM value%s:",
877 unsupported_forms.size() > 1 ?
"s" :
"");
878 for (
auto form : unsupported_forms)
879 error.Printf(
" %#x", form);
885 llvm::StringRef symfile_dir =
m_objfile_sp->GetFileSpec().GetDirectory();
886 if (symfile_dir.contains_insensitive(
".dsym")) {
897 "empty dSYM file detected, dSYM was created with an "
898 "executable with no debug info");
911 if (debug_info_file_size >= MaxDebugInfoSize) {
913 "SymbolFileDWARF can't load this DWARF. It's larger then {0:x+16}",
918 if (debug_abbrev_file_size > 0 && debug_info_file_size > 0) {
922 if (debug_line_file_size > 0)
924 }
else if (debug_line_file_size > 0) {
939 const SectionList *section_list = module_sp->GetSectionList();
961 std::make_unique<llvm::DWARFDebugAbbrev>(debug_abbrev_data.
GetAsLLVM());
962 llvm::Error
error = abbr->parse();
966 "Unable to read .debug_abbrev section: {0}");
984 return m_context.getOrLoadDebugInfoData().GetByteSize() == 0;
992 auto info = std::make_unique<StandaloneDWARFLineTableInfo>(*
this);
993 if (info->HasLineTables())
1015 return llvm::cast_or_null<DWARFCompileUnit>(dwarf_cu);
1029 if (
auto remapped_file = module_sp->RemapSourceFile(file_spec.
GetPath()))
1030 file_spec.
SetFile(*remapped_file, FileSpec::Style::native);
1036 const char *dwo_name =
1049 cu_sp = comp_unit->shared_from_this();
1062 cu_sp = std::make_shared<CompileUnit>(
1063 module_sp, &dwarf_cu, support_file_nsp,
1072 auto lazy_initialize_cu = [&]() {
1094 if (support_files.
GetSize() == 0)
1101 if (!lazy_initialize_cu()) {
1115 initialize_cu(std::make_shared<SupportFile>(cu_file_spec),
1134 for (uint32_t i = 0, num = info.
GetNumUnits(); i < num; ++i) {
1135 if (
auto *cu = llvm::dyn_cast<DWARFCompileUnit>(info.
GetUnitAtIndex(i))) {
1147 return std::nullopt;
1153 return info->CalculateNumCompileUnits();
1163 return info->ParseCompileUnitAtIndex(cu_idx);
1166 if (
auto *dwarf_cu = llvm::cast_or_null<DWARFCompileUnit>(
1167 DebugInfo().GetUnitAtIndex(*dwarf_idx)))
1181 if (
auto err = type_system_or_err.takeError()) {
1182 LLDB_LOG_ERROR(log, std::move(err),
"Unable to parse function: {0}");
1185 auto ts = *type_system_or_err;
1194 if (llvm::Expected<llvm::DWARFAddressRangesVector> die_ranges =
1195 die.
GetDIE()->GetAttributeAddressRanges(die.
GetCU(),
1197 for (
const auto &range : *die_ranges) {
1203 if (
Address base_addr(range.LowPC, module_sp->GetSectionList());
1205 ranges.emplace_back(std::move(base_addr), range.HighPC - range.LowPC);
1225 if (
auto err = type_system_or_err.takeError()) {
1227 "Unable to construct demangled name for function: {0}");
1231 auto ts = *type_system_or_err;
1245 if (debug_map_symfile)
1252 if (debug_map_symfile) {
1278 llvm::StringRef sysroot =
1283 if (!sysroot.starts_with(
"/Library/Developer/CommandLineTools/SDKs")) {
1290 module_sp->RegisterXcodeSDK(sdk, sysroot);
1293 if (local_module_sp && local_module_sp != module_sp)
1294 local_module_sp->RegisterXcodeSDK(sdk, sysroot);
1307 size_t functions_added = 0;
1310 if (entry.Tag() != DW_TAG_subprogram)
1320 return functions_added;
1325 llvm::DenseSet<lldb_private::SymbolFile *> &visited_symbol_files,
1326 llvm::function_ref<
bool(
Module &)> lambda) {
1328 if (!visited_symbol_files.insert(
this).second)
1338 if (lambda(*module))
1341 for (std::size_t i = 0; i < module->GetNumCompileUnits(); ++i) {
1342 auto cu =
module->GetCompileUnitAtIndex(i);
1343 bool early_exit = cu->ForEachExternalModule(visited_symbol_files, lambda);
1373 llvm::DWARFDebugLine::Prologue prologue;
1385 if (
auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
1387 return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
1391 auto &tu = llvm::cast<DWARFTypeUnit>(unit);
1408 std::unique_ptr<SupportFileList> &list = iter_bool.first->second;
1409 if (iter_bool.second) {
1410 list = std::make_unique<SupportFileList>();
1411 uint64_t line_table_offset = offset;
1412 llvm::DWARFDataExtractor data =
1413 m_context.getOrLoadLineData().GetAsLLVMDWARF();
1414 llvm::DWARFContext &ctx =
m_context.GetAsLLVM();
1415 llvm::DWARFDebugLine::Prologue prologue;
1416 auto report = [](llvm::Error
error) {
1419 "SymbolFileDWARF::GetTypeUnitSupportFiles failed to parse "
1420 "the line table prologue: {0}");
1423 llvm::Error
error = prologue.parse(data, &line_table_offset, report, ctx);
1425 report(std::move(
error));
1443 std::vector<SourceModule> &imported_modules) {
1459 if (child_die.Tag() != DW_TAG_imported_declaration)
1462 DWARFDIE module_die = child_die.GetReferencedDIE(DW_AT_import);
1463 if (module_die.
Tag() != DW_TAG_module)
1466 if (
const char *name =
1469 module.path.push_back(ConstString(name));
1472 DW_AT_LLVM_include_path,
nullptr);
1474 while ((parent_die = parent_die.
GetParent())) {
1475 if (parent_die.
Tag() != DW_TAG_module)
1477 if (
const char *name =
1479 module.path.push_back(ConstString(name));
1486 DW_AT_LLVM_include_path,
nullptr);
1488 std::reverse(module.
path.begin(), module.
path.end());
1493 module.search_path = ConstString(include_spec.GetPath());
1496 DW_AT_LLVM_sysroot,
nullptr))
1497 module.sysroot = ConstString(sysroot);
1498 imported_modules.push_back(module);
1510 return info->ParseLineTable(comp_unit);
1521 llvm::DWARFDebugLine line;
1522 const llvm::DWARFDebugLine::LineTable *line_table =
1528 std::unique_ptr<LineTable> line_table_up =
1536 debug_map_symfile->LinkOSOLineTable(
this, line_table_up.get()));
1548 return iter->second;
1562 offset,
this, debug_macros_sp);
1564 return debug_macros_sp;
1571 if (dwarf_cu ==
nullptr)
1593 addr_t function_file_addr) {
1594 size_t blocks_added = 0;
1598 if (tag != DW_TAG_inlined_subroutine && tag != DW_TAG_lexical_block)
1602 llvm::DWARFAddressRangesVector ranges;
1603 const char *name =
nullptr;
1604 const char *mangled_name =
nullptr;
1606 std::optional<int> decl_file;
1607 std::optional<int> decl_line;
1608 std::optional<int> decl_column;
1609 std::optional<int> call_file;
1610 std::optional<int> call_line;
1611 std::optional<int> call_column;
1613 decl_line, decl_column, call_file, call_line,
1614 call_column,
nullptr)) {
1615 for (
const llvm::DWARFAddressRange &range : ranges) {
1618 range.HighPC - range.LowPC));
1622 if (tag != DW_TAG_subprogram &&
1623 (name !=
nullptr || mangled_name !=
nullptr)) {
1624 std::unique_ptr<Declaration> decl_up;
1625 if (decl_file || decl_line || decl_column)
1626 decl_up = std::make_unique<Declaration>(
1628 decl_file.value_or(0)),
1629 decl_line.value_or(0), decl_column.value_or(0));
1631 std::unique_ptr<Declaration> call_up;
1632 if (call_file || call_line || call_column)
1633 call_up = std::make_unique<Declaration>(
1635 call_file.value_or(0)),
1636 call_line.value_or(0), call_column.value_or(0));
1650 return blocks_added;
1657 bool check_virtuality =
false;
1659 case DW_TAG_inheritance:
1660 case DW_TAG_subprogram:
1661 check_virtuality =
true;
1666 if (check_virtuality) {
1667 if (die.GetAttributeValueAsUnsigned(DW_AT_virtuality, 0) != 0)
1677 if (type_system !=
nullptr)
1721std::vector<CompilerContext>
1728 return die.GetDeclContext();
1738 return type_die.ResolveType();
1749 return std::nullopt;
1757 bool assert_not_being_parsed) {
1763 "SymbolFileDWARF::ResolveTypeUID (die = {0:x16}) {1} ({2}) '{3}'",
1773 switch (decl_ctx_die.
Tag()) {
1774 case DW_TAG_structure_type:
1775 case DW_TAG_union_type:
1776 case DW_TAG_class_type: {
1781 "SymbolFileDWARF::ResolveTypeUID (die = {0:x16}) {1} ({2}) "
1782 "'{3}' resolve parent forward type for {4:x16})",
1809 if (!clang_type_system)
1812 llvm::cast<DWARFASTParserClang>(clang_type_system->GetDWARFParser());
1813 return ast_parser->GetClangASTImporter().CanImport(compiler_type);
1819 if (clang_type_system) {
1821 llvm::cast<DWARFASTParserClang>(clang_type_system->GetDWARFParser());
1823 ast_parser->GetClangASTImporter().CanImport(compiler_type))
1824 return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
1845 if (debug_map_symfile) {
1863 if (decl_die != def_die) {
1865 auto *ast_parser = llvm::cast<DWARFASTParserClang>(dwarf_ast);
1866 ast_parser->MapDeclDIEToDefDIE(decl_die, def_die);
1872 log,
"{0:x8}: {1} ({2}) '{3}' resolving forward declaration...",
1875 assert(compiler_type);
1880 bool assert_not_being_parsed,
1881 bool resolve_function_context) {
1885 if (assert_not_being_parsed) {
1890 "Parsing a die that is being parsed die: {0:x16}: {1} ({2}) {3}",
1921 m_index->GetObjCMethods(class_name, callback);
1927 if (die && llvm::isa<DWARFCompileUnit>(die.
GetCU())) {
1962 std::optional<uint32_t> file_index = die_ref.
file_index();
1973 return debug_map->GetSymbolFileByOSOIndex(*file_index);
2004 std::optional<uint64_t> dwo_id =
2016 return ::GetDWOId(*cu, *cu_die);
2025std::shared_ptr<SymbolFileDWARFDwo>
2039 if (!dwarf_cu || !dwarf_cu->
GetDWOId().has_value())
2042 const char *dwo_name =
GetDWOName(*dwarf_cu, cu_die);
2045 "missing DWO name in skeleton DIE {0:x16}", cu_die.
GetOffset()));
2058 size_t num_search_paths = debug_file_search_paths.
GetSize();
2064 const char *comp_dir =
2069 dwo_file.
SetFile(comp_dir, FileSpec::Style::native);
2080 FileSpec relative_to_binary = dwo_file;
2085 dwo_paths.
Append(relative_to_binary);
2088 for (
size_t idx = 0; idx < num_search_paths; ++idx) {
2096 dwo_paths.
Append(dirspec);
2099 size_t num_possible = dwo_paths.
GetSize();
2100 for (
size_t idx = 0; idx < num_possible && !found; ++idx) {
2103 dwo_file = dwo_spec;
2111 "unable to locate relative .dwo debug file \"%s\" for "
2112 "skeleton DIE 0x%016" PRIx64
" without valid DW_AT_comp_dir "
2123 llvm::StringRef filename_only = dwo_name_spec.
GetFilename();
2129 FileSpec dwo_name_binary_directory(binary_directory);
2131 dwo_paths.
Append(dwo_name_binary_directory);
2134 FileSpec filename_binary_directory(binary_directory);
2136 dwo_paths.
Append(filename_binary_directory);
2138 for (
size_t idx = 0; idx < num_search_paths; ++idx) {
2144 FileSpec dwo_name_dirspec(dirspec);
2146 dwo_paths.
Append(dwo_name_dirspec);
2148 FileSpec filename_dirspec(dirspec);
2150 dwo_paths.
Append(filename_dirspec);
2153 size_t num_possible = dwo_paths.
GetSize();
2154 for (
size_t idx = 0; idx < num_possible && !found; ++idx) {
2157 dwo_file = dwo_spec;
2166 if (error_dwo_path.
IsRelative() && comp_dir !=
nullptr) {
2171 "unable to locate .dwo debug file \"{0}\" for skeleton DIE "
2178 "unable to locate separate debug file (dwo, dwp). {0}",
2190 dwo_file_data_offset);
2191 if (dwo_obj_file ==
nullptr) {
2193 "unable to load object file for .dwo debug file \"{0}\" for "
2199 return std::make_shared<SymbolFileDWARFDwo>(*
this, dwo_obj_file,
2211 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
2213 llvm::dyn_cast<DWARFCompileUnit>(debug_info.
GetUnitAtIndex(cu_idx));
2237 const char *comp_dir =
2241 FileSpec::Style::native);
2261 if (
m_objfile_sp->GetFileSpec().GetFileNameExtension() ==
".dwo" &&
2274 "{0}",
error.AsCString(
"unknown error"));
2276 "unable to locate module needed for external types.\n"
2277 "Debugging will be degraded due to missing types. Rebuilding the "
2278 "project will regenerate the needed module files");
2289 llvm::dyn_cast_or_null<SymbolFileDWARF>(module_sp->GetSymbolFile());
2292 std::optional<uint64_t> dwo_dwo_id = dwo_symfile->GetDWOId();
2296 if (dwo_id != dwo_dwo_id) {
2298 "module {0} is out-of-date (hash mismatch).\n"
2299 "Type information from this module may be incomplete or inconsistent "
2300 "with the rest of the program. Rebuilding the project will "
2301 "regenerate the needed module files",
2313 const size_t num_cus = module_sp->GetNumCompileUnits();
2314 for (
size_t i = 0; i < num_cus; ++i) {
2315 CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
2319 const size_t num_globals = globals_sp->GetSize();
2320 for (
size_t g = 0; g < num_globals; ++g) {
2321 VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
2322 if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
2324 var_sp->LocationExpressionList();
2326 llvm::Expected<Value> location_result = location.
Evaluate(
2328 if (location_result) {
2329 if (location_result->GetValueType() ==
2332 location_result->GetScalar().ULongLong();
2334 if (var_sp->GetType())
2335 byte_size = llvm::expectedToOptional(
2336 var_sp->GetType()->GetByteSize(
nullptr))
2339 file_addr, byte_size, var_sp.get()));
2343 location_result.takeError(),
2344 "location expression failed to execute: {0}");
2385 SymbolContextItem resolve_scope,
2389 "ResolveSymbolContext (so_addr = { "
2390 "section = %p, offset = 0x%" PRIx64
2391 " }, resolve_scope = 0x%8.8x)",
2392 static_cast<void *
>(so_addr.
GetSection().get()),
2394 uint32_t resolved = 0;
2396 (eSymbolContextCompUnit | eSymbolContextFunction | eSymbolContextBlock |
2397 eSymbolContextLineEntry | eSymbolContextVariable)) {
2399 return standalone->ResolveSymbolContext(so_addr, resolve_scope, sc);
2411 if (resolve_scope & eSymbolContextVariable) {
2414 map.FindEntryThatContains(file_vm_addr);
2415 if (entry && entry->data) {
2427 if (
auto *dwarf_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(
2432 resolved |= eSymbolContextCompUnit;
2434 bool force_check_line_table =
false;
2435 if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
2437 resolve_scope & eSymbolContextBlock, sc);
2439 resolved |= eSymbolContextFunction;
2447 force_check_line_table =
true;
2450 resolved |= eSymbolContextBlock;
2453 if ((resolve_scope & eSymbolContextLineEntry) ||
2454 force_check_line_table) {
2456 if (line_table !=
nullptr) {
2462 Address exe_so_addr(so_addr);
2466 resolved |= eSymbolContextLineEntry;
2472 if (force_check_line_table && !(resolved & eSymbolContextLineEntry)) {
2479 resolved &= ~eSymbolContextCompUnit;
2483 "{0:x16}: compile unit {1} failed to create a valid "
2484 "lldb_private::CompileUnit class",
2494 const SourceLocationSpec &src_location_spec,
2495 SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
2498 const uint32_t prev_size = sc_list.
GetSize();
2499 if (resolve_scope & eSymbolContextCompUnit) {
2508 if (check_inlines || file_spec_matches_cu_file_spec) {
2515 return sc_list.
GetSize() - prev_size;
2533 return module_sp->GetMutex();
2549 if (
auto err = type_system_or_err.takeError()) {
2551 "Unable to match namespace decl using TypeSystem: {0}");
2555 if (decl_ctx_type_system == type_system_or_err->get())
2563 log,
"Valid namespace does not match symbol file");
2577 "SymbolFileDWARF::FindGlobalVariables (name=\"{0}\", "
2578 "parent_decl_ctx={1:p}, max_matches={2}, variables)",
2579 name.
GetCString(),
static_cast<const void *
>(&parent_decl_ctx),
2586 const uint32_t original_size = variables.
GetSize();
2588 llvm::StringRef basename;
2589 llvm::StringRef context;
2597 if (name ==
"__clang_vtable")
2598 name_is_mangled =
true;
2606 uint32_t pruned_idx = original_size;
2614 if (die.
Tag() != DW_TAG_variable && die.
Tag() != DW_TAG_member)
2617 auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.
GetCU());
2622 if (parent_decl_ctx) {
2625 dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
2631 if (!actual_parent_decl_ctx ||
2632 (actual_parent_decl_ctx != parent_decl_ctx &&
2639 while (pruned_idx < variables.
GetSize()) {
2641 if (name_is_mangled ||
2642 var_sp->GetName().GetStringRef().contains(name.
GetStringRef()))
2648 if (variables.
GetSize() - original_size < max_matches)
2655 const uint32_t num_matches = variables.
GetSize() - original_size;
2656 if (log && num_matches > 0) {
2659 "SymbolFileDWARF::FindGlobalVariables (name=\"{0}\", "
2660 "parent_decl_ctx={1:p}, max_matches={2}, variables) => {3}",
2661 name.
GetCString(),
static_cast<const void *
>(&parent_decl_ctx),
2662 max_matches, num_matches);
2667 uint32_t max_matches,
2675 "SymbolFileDWARF::FindGlobalVariables (regex=\"{0}\", "
2676 "max_matches={1}, variables)",
2677 regex.
GetText().str().c_str(), max_matches);
2681 const uint32_t original_size = variables.
GetSize();
2696 if (variables.
GetSize() - original_size < max_matches)
2704 bool include_inlines,
2712 if (!(orig_die.
Tag() == DW_TAG_subprogram ||
2713 (include_inlines && orig_die.
Tag() == DW_TAG_inlined_subroutine)))
2718 if (die.
Tag() == DW_TAG_inlined_subroutine) {
2725 if (die.
Tag() == DW_TAG_subprogram)
2731 assert(die && die.
Tag() == DW_TAG_subprogram);
2737 if (sc.
block ==
nullptr)
2750 case clang::CXXCtorType::Ctor_Complete:
2752 case clang::CXXCtorType::Ctor_Base:
2754 case clang::CXXCtorType::Ctor_Unified:
2756 case clang::CXXCtorType::Ctor_CopyingClosure:
2757 case clang::CXXCtorType::Ctor_DefaultClosure:
2758 case clang::CXXCtorType::Ctor_Comdat:
2759 llvm_unreachable(
"Unexpected constructor kind.");
2761 llvm_unreachable(
"Fully covered switch above");
2766 case clang::CXXDtorType::Dtor_Deleting:
2768 case clang::CXXDtorType::Dtor_Complete:
2770 case clang::CXXDtorType::Dtor_Base:
2772 case clang::CXXDtorType::Dtor_Unified:
2774 case clang::CXXDtorType::Dtor_Comdat:
2775 case clang::CXXDtorType::Dtor_VectorDeleting:
2776 llvm_unreachable(
"Unexpected destructor kind.");
2778 llvm_unreachable(
"Fully covered switch above");
2781static llvm::StringRef
2783 const bool is_ctor = discriminator.consume_front(
"C");
2784 if (!is_ctor && !discriminator.consume_front(
"D"))
2787 uint64_t structor_kind;
2788 if (!llvm::to_integer(discriminator, structor_kind))
2792 if (structor_kind > clang::CXXCtorType::Ctor_Unified)
2796 static_cast<clang::CXXCtorType
>(structor_kind));
2799 if (structor_kind > clang::CXXDtorType::Dtor_Unified)
2805llvm::Expected<DWARFDIE>
2808 auto do_lookup = [
this](llvm::StringRef lookup_name) ->
DWARFDIE {
2811 ConstString(lookup_name), lldb::eFunctionNameTypeFull,
2815 if (entry.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0))
2831 return llvm::createStringError(
2832 "no definition DIE found in this SymbolFile");
2845 return subst_or_err.takeError();
2847 definition = do_lookup(*subst_or_err);
2850 return llvm::createStringError(
2851 "failed to find definition DIE for structor alias in fallback lookup");
2856llvm::Expected<SymbolContext>
2861 llvm::StringRef from = label.
discriminator[0] ==
'C' ?
"C4" :
"D4";
2864 if (variant.empty())
2865 return llvm::createStringError(
2866 "failed to get Itanium variant for discriminator");
2868 if (from == variant)
2869 return llvm::createStringError(
2870 "tried substituting unified structor variant into label");
2878 return llvm::joinErrors(
2879 llvm::createStringErrorV(
2880 "failed to substitute {0} for {1} in mangled name {2}:", from,
2882 subst_or_err.takeError());
2885 return llvm::createStringErrorV(
2886 "got invalid substituted mangled named (substituted "
2887 "{0} for {1} in mangled name {2})",
2895 return llvm::createStringErrorV(
"invalid DIE ID in {0}", label);
2902 return llvm::joinErrors(
2903 llvm::createStringError(
"failed to find definition DIE:"),
2904 die_or_err.takeError());
2906 die = std::move(*die_or_err);
2911 return llvm::createStringError(
"failed to resolve function");
2914 return llvm::createStringError(
"failed to find function");
2916 assert(sc_list.
GetSize() == 1);
2923 bool only_root_namespaces) {
2930 if (only_root_namespaces)
2931 return die.
GetParent().
Tag() == llvm::dwarf::DW_TAG_compile_unit;
2939 dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
2948 bool include_inlines,
2956 assert((name_type_mask & eFunctionNameTypeAuto) == 0);
2963 "SymbolFileDWARF::FindFunctions (name=\"{0}\", name_type_mask={1:x}, "
2978 const uint32_t original_size = sc_list.
GetSize();
2980 llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
2982 m_index->GetFunctions(lookup_info, *
this, parent_decl_ctx, [&](
DWARFDIE die) {
2983 if (resolved_dies.insert(die.
GetDIE()).second)
2992 auto it = name_ref.find(
'<');
2993 if (it != llvm::StringRef::npos) {
2994 const llvm::StringRef name_no_template_params = name_ref.slice(0, it);
2997 lookup_info,
ConstString(name_no_template_params));
2998 m_index->GetFunctions(no_tp_lookup_info, *
this, parent_decl_ctx,
3000 if (resolved_dies.insert(die.
GetDIE()).second)
3008 const uint32_t num_matches = sc_list.
GetSize() - original_size;
3010 if (log && num_matches > 0) {
3013 "SymbolFileDWARF::FindFunctions (name=\"{0}\", "
3014 "name_type_mask={1:x}, include_inlines={2:d}, sc_list) => {3}",
3015 name.
GetCString(), name_type_mask, include_inlines, num_matches);
3020 bool include_inlines,
3024 regex.
GetText().str().c_str());
3030 log,
"SymbolFileDWARF::FindFunctions (regex=\"{0}\", sc_list)",
3031 regex.
GetText().str().c_str());
3034 llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
3036 if (resolved_dies.insert(die.
GetDIE()).second)
3043 const std::string &scope_qualified_name,
3044 std::vector<ConstString> &mangled_names) {
3047 for (uint32_t i = 0; i < num_comp_units; i++) {
3066 llvm::StringRef &basename,
3067 llvm::StringRef &template_params) {
3068 auto it = fullname.find(
'<');
3069 if (it == llvm::StringRef::npos) {
3070 basename = fullname;
3071 template_params = llvm::StringRef();
3074 basename = fullname.slice(0, it);
3075 template_params = fullname.slice(it, fullname.size());
3083 bool any_context_updated =
false;
3085 llvm::StringRef basename, params;
3088 any_context_updated =
true;
3091 return any_context_updated;
3101 return debug_info_size + dwp_sp->GetDebugInfoSize();
3104 for (uint32_t i = 0; i < num_comp_units; i++) {
3113 return debug_info_size;
3127 log,
"SymbolFileDWARF::FindTypes(type_basename=\"{0}\")",
3134 bool have_index_match =
false;
3146 auto CompilerTypeBasename =
3147 matching_type->GetForwardCompilerType().GetTypeName(
true);
3151 have_index_match =
true;
3152 results.
InsertUnique(matching_type->shared_from_this());
3154 if (!results.
Done(query))
3160 if (results.
Done(query)) {
3163 log,
"SymbolFileDWARF::FindTypes(type_basename=\"{0}\") => {1}",
3186 std::vector<CompilerContext> qualified_context =
3192 results.
InsertUnique(matching_type->shared_from_this());
3193 if (!results.
Done(query))
3198 if (results.
Done(query)) {
3202 "SymbolFileDWARF::FindTypes(type_basename=\"{0}\") => {1} "
3203 "(simplified as \"{2}\")",
3205 type_basename_simple);
3218 if (
ModuleSP external_module_sp = pair.second) {
3219 external_module_sp->FindTypes(query, results);
3220 if (results.
Done(query)) {
3232 bool only_root_namespaces) {
3238 log,
"SymbolFileDWARF::FindNamespace (sc, name=\"{0}\")",
3245 return namespace_decl_ctx;
3247 m_index->GetNamespacesWithParents(name, parent_decl_ctx, [&](
DWARFDIE die) {
3256 if (namespace_decl_ctx.
IsValid())
3262 if (log && namespace_decl_ctx) {
3265 "SymbolFileDWARF::FindNamespace (sc, name=\"{0}\") => "
3266 "CompilerDeclContext({1:p}/{2:p}) \"{3}\"",
3268 static_cast<const void *
>(namespace_decl_ctx.
GetTypeSystem()),
3273 return namespace_decl_ctx;
3277 bool resolve_function_context) {
3281 if (type_ptr ==
nullptr) {
3283 if (
auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.
GetCU()))
3290 while (parent_die !=
nullptr) {
3291 if (parent_die->
Tag() == DW_TAG_subprogram)
3296 if (resolve_function_context && parent_die !=
nullptr &&
3303 type_sp = type_ptr->shared_from_this();
3312 llvm::SmallVector<std::pair<DWARFDIE, bool>, 4> worklist;
3314 worklist.emplace_back(orig_die,
true);
3317 llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> seen;
3319 while (!worklist.empty()) {
3320 auto [die, is_elaboration] = worklist.pop_back_val();
3322 if (is_elaboration) {
3323 if (!seen.insert(die.GetDIE()).second)
3326 switch (die.Tag()) {
3327 case DW_TAG_compile_unit:
3328 case DW_TAG_partial_unit:
3329 case DW_TAG_namespace:
3330 case DW_TAG_structure_type:
3331 case DW_TAG_union_type:
3332 case DW_TAG_class_type:
3333 case DW_TAG_lexical_block:
3334 case DW_TAG_subprogram:
3336 case DW_TAG_inlined_subroutine:
3337 if (
DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin))
3346 if (
DWARFDIE parent = die.GetParent())
3347 worklist.emplace_back(parent,
false);
3348 if (
DWARFDIE abs_die = die.GetReferencedDIE(DW_AT_abstract_origin))
3349 worklist.emplace_back(abs_die,
true);
3350 if (
DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification))
3351 worklist.emplace_back(spec_die,
true);
3358 Symbol *objc_class_symbol =
nullptr;
3367 return objc_class_symbol;
3380 m_index->GetCompleteObjCClass(
3381 type_name, must_be_implementation, [&](
DWARFDIE type_die) {
3387 if (must_be_implementation) {
3389 DW_AT_APPLE_objc_complete_type, 0);
3390 if (!try_resolving_type)
3399 "resolved 0x%8.8" PRIx64
" from %s to 0x%8.8" PRIx64
3400 " (cu 0x%8.8" PRIx64
")\n",
3402 m_objfile_sp->GetFileSpec().GetFilename().AsCString(
"<Unknown>"),
3403 type_die.
GetID(), type_cu->GetID());
3407 type_sp = resolved_type->shared_from_this();
3415 const char *name = die.
GetName();
3421 Progress progress(llvm::formatv(
"Searching definition DIE in {0}: '{1}'",
3431 "SymbolFileDWARF::FindDefinitionDIE(tag={0} "
3432 "({1}), name='{2}')",
3443 if (
auto err = type_system_or_err.takeError()) {
3445 "Cannot get TypeSystem for language {1}: {0}",
3448 type_system = *type_system_or_err;
3454 std::vector<std::string> template_params;
3457 type_system ? type_system->GetDWARFParser() :
nullptr;
3458 for (
DWARFDIE ctx_die = die; ctx_die && !isUnitType(ctx_die.Tag());
3459 ctx_die = ctx_die.GetParentDeclContextDIE()) {
3461 template_params.push_back(
3462 (ctx_die.IsStructUnionOrClass() && dwarf_ast)
3466 const bool any_template_params = llvm::any_of(
3467 template_params, [](llvm::StringRef p) {
return !p.empty(); });
3469 auto die_matches = [&](
DWARFDIE type_die) {
3471 const bool tag_matches =
3472 type_die.Tag() == tag ||
3476 if (any_template_params) {
3478 for (
DWARFDIE ctx_die = type_die; ctx_die && !isUnitType(ctx_die.Tag()) &&
3479 pos < template_params.size();
3480 ctx_die = ctx_die.GetParentDeclContextDIE(), ++pos) {
3481 if (template_params[pos].empty())
3483 if (template_params[pos] !=
3487 if (pos != template_params.size())
3493 m_index->GetFullyQualifiedType(die_dwarf_decl_ctx, [&](
DWARFDIE type_die) {
3501 if (!die_matches(type_die)) {
3505 "SymbolFileDWARF::FindDefinitionDIE(tag={0} ({1}), "
3506 "name='{2}') ignoring die={3:x16} ({4})",
3517 "SymbolFileDWARF::FindDefinitionTypeDIE(tag={0} ({1}), name='{2}') "
3518 "trying die={3:x16} ({4})",
3530 bool *type_is_new_ptr) {
3535 if (
auto err = type_system_or_err.takeError()) {
3537 "Unable to parse type: {0}");
3540 auto ts = *type_system_or_err;
3550 if (die.
Tag() == DW_TAG_subprogram) {
3554 if (scope_qualified_name.size()) {
3566 bool parse_siblings,
bool parse_children) {
3567 size_t types_added = 0;
3572 bool type_is_new =
false;
3574 Tag dwarf_tag =
static_cast<Tag
>(tag);
3579 if (isType(dwarf_tag) && tag != DW_TAG_subrange_type)
3586 if (die.
Tag() == DW_TAG_subprogram) {
3611 size_t functions_added = 0;
3618 if (llvm::Expected<llvm::DWARFAddressRangesVector> ranges =
3619 function_die.
GetDIE()->GetAttributeAddressRanges(
3620 function_die.
GetCU(),
3622 if (ranges->empty())
3624 dw_addr_t function_file_addr = ranges->begin()->LowPC;
3634 return functions_added;
3639 size_t types_added = 0;
3660 if (llvm::Expected<llvm::DWARFAddressRangesVector> ranges =
3661 function_die.
GetDIE()->GetAttributeAddressRanges(
3662 function_die.
GetCU(),
true)) {
3663 if (!ranges->empty())
3664 func_lo_pc = ranges->begin()->LowPC;
3667 "DIE({1:x}): {0}", function_die.
GetID());
3670 const size_t num_variables =
3675 return num_variables;
3680 if (dwarf_cu ==
nullptr)
3683 uint32_t vars_added = 0;
3686 if (variables.get() ==
nullptr) {
3687 variables = std::make_shared<VariableList>();
3693 variables->AddVariableIfUnique(var_sp);
3718 die_to_variable[die.
GetDIE()] = var_sp;
3720 die_to_variable[spec_die.GetDIE()] = var_sp;
3728 unsigned max_depth = 64) {
3730 if (!die || !max_depth)
3731 return std::nullopt;
3733 if (std::optional<uint64_t> byte_size =
3737 switch (die.
Tag()) {
3738 case DW_TAG_const_type:
3739 case DW_TAG_volatile_type:
3740 case DW_TAG_restrict_type:
3741 case DW_TAG_atomic_type:
3742 case DW_TAG_typedef:
3749 return std::nullopt;
3756 const addr_t func_low_pc) {
3761 uint64_t block_length = form_value.
Unsigned();
3769 if (form_value.
Form() == DW_FORM_loclistx)
3778 return location_list;
3784static DWARFExpressionList
3790 uint64_t block_offset =
3792 uint64_t block_length = form_value.
Unsigned();
3794 module,
DataExtractor(debug_info_data, block_offset, block_length),
3797 if (
const char *str = form_value.
AsCString())
3817 if (!debug_map_objfile)
3821 if (!debug_map_symtab)
3850 if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
3851 tag != DW_TAG_member && (tag != DW_TAG_formal_parameter || !sc.
function))
3855 const char *name =
nullptr;
3856 const char *mangled =
nullptr;
3859 bool is_external =
false;
3860 bool is_artificial =
false;
3861 std::optional<uint64_t> tag_offset = std::nullopt;
3865 for (
size_t i = 0; i < attributes.
Size(); ++i) {
3872 case DW_AT_LLVM_tag_offset:
3873 tag_offset = form_value.
Unsigned();
3875 case DW_AT_decl_file:
3879 case DW_AT_decl_line:
3882 case DW_AT_decl_column:
3888 case DW_AT_linkage_name:
3889 case DW_AT_MIPS_linkage_name:
3896 type_die_form = form_value;
3898 case DW_AT_external:
3899 is_external = form_value.
Boolean();
3901 case DW_AT_const_value:
3902 const_value_form = form_value;
3904 case DW_AT_location:
3905 location_form = form_value;
3907 case DW_AT_start_scope:
3910 case DW_AT_artificial:
3911 is_artificial = form_value.
Boolean();
3913 case DW_AT_declaration:
3914 case DW_AT_description:
3915 case DW_AT_endianity:
3917 case DW_AT_specification:
3918 case DW_AT_visibility:
3920 case DW_AT_abstract_origin:
3929 bool location_is_const_value_data =
3935 if (const_value_form.
IsValid())
3943 bool is_static_member = (parent_tag == DW_TAG_compile_unit ||
3944 parent_tag == DW_TAG_partial_unit) &&
3945 (parent_context_die.
Tag() == DW_TAG_class_type ||
3946 parent_context_die.
Tag() == DW_TAG_structure_type);
3951 bool has_explicit_mangled = mangled !=
nullptr;
3963 if ((parent_tag == DW_TAG_compile_unit ||
3964 parent_tag == DW_TAG_partial_unit) &&
3971 if (tag == DW_TAG_formal_parameter)
3982 bool has_explicit_location = location_form.
IsValid();
3983 bool is_static_lifetime =
3984 has_explicit_mangled ||
3985 (has_explicit_location && !location_list.
IsValid());
3988 if (!location_is_const_value_data) {
3991 if (
auto maybe_location_DW_OP_addr =
3992 location->GetLocation_DW_OP_addr(location_form.
GetUnit())) {
3993 location_DW_OP_addr = *maybe_location_DW_OP_addr;
3998 "{0:x16}: {1} ({2}) has an invalid location: {3}: {4}",
4000 llvm::fmt_consume(maybe_location_DW_OP_addr.takeError()),
4005 is_static_lifetime =
true;
4008 if (debug_map_symfile)
4014 if (is_static_lifetime) {
4020 if (debug_map_symfile) {
4021 bool linked_oso_file_addr =
false;
4023 if (is_external && location_DW_OP_addr == 0) {
4025 *debug_map_symfile, mangled ? mangled : name, location_list,
4027 linked_oso_file_addr =
true;
4028 symbol_context_scope = exe_symbol;
4032 if (!linked_oso_file_addr) {
4049 if (location_is_const_value_data &&
4050 die.
GetDIE()->IsGlobalOrStaticScopeVariable())
4054 if (debug_map_symfile) {
4059 [
this, debug_map_symfile](
4061 return debug_map_symfile->LinkOSOFileAddress(
4062 this, unlinked_file_addr);
4071 if (symbol_context_scope ==
nullptr) {
4072 switch (parent_tag) {
4073 case DW_TAG_subprogram:
4074 case DW_TAG_inlined_subroutine:
4075 case DW_TAG_lexical_block:
4077 symbol_context_scope =
4079 if (symbol_context_scope ==
nullptr)
4080 symbol_context_scope = sc.
function;
4090 if (!symbol_context_scope) {
4097 auto type_sp = std::make_shared<SymbolFileType>(
4100 bool use_type_size_for_value =
4101 location_is_const_value_data &&
4103 if (use_type_size_for_value) {
4104 std::optional<uint64_t> byte_size;
4105 if (
Type *t = type_sp->GetType())
4106 byte_size = llvm::expectedToOptional(t->GetByteSize(
nullptr));
4123 return std::make_shared<Variable>(
4124 die.
GetID(), name, mangled, type_sp, scope, symbol_context_scope,
4125 scope_ranges, &decl, location_list, is_external, is_artificial,
4126 location_is_const_value_data, is_static_member, tag_offset);
4136 spec_block_die_offset);
4143 switch (die.
Tag()) {
4144 case DW_TAG_subprogram:
4145 case DW_TAG_inlined_subroutine:
4146 case DW_TAG_lexical_block: {
4148 spec_block_die_offset)
4152 spec_block_die_offset)
4180 if (tag != DW_TAG_variable && tag != DW_TAG_constant && tag != DW_TAG_member)
4196 switch (parent_tag) {
4197 case DW_TAG_compile_unit:
4198 case DW_TAG_partial_unit:
4203 "parent {0:x8} {1} ({2}) with no valid compile unit in "
4204 "symbol context for {3:x8} {4} ({5}).\n",
4214 "{0} '{1}' ({2:x8}) is not a global variable - ignoring", tag,
4224 if (variable_list_sp)
4225 variable_list_sp->AddVariableIfUnique(var_sp);
4241 if (block_die.
Tag() != DW_TAG_inlined_subroutine) {
4242 return std::move(variable_dies);
4247 if (!abs_die || abs_die.
Tag() != DW_TAG_subprogram ||
4249 return std::move(variable_dies);
4254 DIEArray::iterator concrete_it = variable_dies.
begin();
4257 bool did_merge_abstract =
false;
4258 for (; abstract_child; abstract_child = abstract_child.
GetSibling()) {
4259 if (abstract_child.
Tag() == DW_TAG_formal_parameter) {
4260 if (concrete_it == variable_dies.end() ||
4261 GetDIE(*concrete_it).Tag() != DW_TAG_formal_parameter) {
4265 merged.push_back(*abstract_child.
GetDIERef());
4266 did_merge_abstract =
true;
4272 if (origin_of_concrete == abstract_child) {
4275 merged.push_back(*concrete_it);
4280 merged.push_back(*abstract_child.
GetDIERef());
4281 did_merge_abstract =
true;
4287 if (!did_merge_abstract)
4288 return std::move(variable_dies);
4295 for (; concrete_it != variable_dies.end(); ++concrete_it) {
4296 if (
GetDIE(*concrete_it).
Tag() == DW_TAG_formal_parameter) {
4297 return std::move(variable_dies);
4299 merged.push_back(*concrete_it);
4315 dummy_block_variables);
4325 size_t vars_added = 0;
4328 if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
4329 (tag == DW_TAG_formal_parameter)) {
4330 accumulator.push_back(*die.
GetDIERef());
4334 case DW_TAG_subprogram:
4335 case DW_TAG_inlined_subroutine:
4336 case DW_TAG_lexical_block: {
4340 if (block ==
nullptr) {
4347 if (concrete_block_die)
4352 if (block ==
nullptr)
4355 const bool can_create =
false;
4358 if (block_variable_list_sp.get() ==
nullptr) {
4359 block_variable_list_sp = std::make_shared<VariableList>();
4367 sc, child, func_low_pc, block_variables);
4372 block_variables, func_low_pc);
4381 sc, child, func_low_pc, accumulator);
4391 llvm::ArrayRef<DIERef> variable_dies,
lldb::addr_t func_low_pc) {
4393 for (
auto &die : variable_dies) {
4398 return variable_dies.size();
4406 if (child.Tag() != DW_TAG_call_site_parameter &&
4407 child.Tag() != DW_TAG_GNU_call_site_parameter)
4410 std::optional<DWARFExpressionList> LocationInCallee;
4411 std::optional<DWARFExpressionList> LocationInCaller;
4417 auto parse_simple_location =
4418 [&](
int attr_index) -> std::optional<DWARFExpressionList> {
4424 auto data = child.GetData();
4425 uint64_t block_offset = form_value.
BlockData() - data.GetDataStart();
4426 uint64_t block_length = form_value.
Unsigned();
4432 for (
size_t i = 0; i < attributes.
Size(); ++i) {
4434 if (attr == DW_AT_location)
4435 LocationInCallee = parse_simple_location(i);
4436 if (attr == DW_AT_call_value || attr == DW_AT_GNU_call_site_value)
4437 LocationInCaller = parse_simple_location(i);
4440 if (LocationInCallee && LocationInCaller) {
4442 parameters.push_back(param);
4449std::vector<std::unique_ptr<lldb_private::CallEdge>>
4453 bool has_call_edges =
4456 if (!has_call_edges)
4460 LLDB_LOG(log,
"CollectCallEdges: Found call site info in {0}",
4468 std::vector<std::unique_ptr<CallEdge>> call_edges;
4470 if (child.Tag() != DW_TAG_call_site && child.Tag() != DW_TAG_GNU_call_site)
4473 std::optional<DWARFDIE> call_origin;
4474 std::optional<DWARFExpressionList> call_target;
4478 bool tail_call =
false;
4484 for (
size_t i = 0; i < attributes.
Size(); ++i) {
4487 LLDB_LOG(log,
"CollectCallEdges: Could not extract TAG_call_site form");
4493 if (attr == DW_AT_call_tail_call || attr == DW_AT_GNU_tail_call)
4494 tail_call = form_value.
Boolean();
4497 if (attr == DW_AT_call_origin || attr == DW_AT_abstract_origin) {
4499 if (!call_origin->IsValid()) {
4500 LLDB_LOG(log,
"CollectCallEdges: Invalid call origin in {0}",
4506 if (attr == DW_AT_low_pc)
4507 low_pc = form_value.
Address();
4512 if (attr == DW_AT_call_return_pc)
4513 return_pc = form_value.
Address();
4518 if (attr == DW_AT_call_pc)
4519 call_inst_pc = form_value.
Address();
4523 if (attr == DW_AT_call_target || attr == DW_AT_GNU_call_site_target) {
4526 "CollectCallEdges: AT_call_target does not have block form");
4530 auto data = child.GetData();
4531 uint64_t block_offset = form_value.
BlockData() - data.GetDataStart();
4532 uint64_t block_length = form_value.
Unsigned();
4538 if (!call_origin && !call_target) {
4539 LLDB_LOG(log,
"CollectCallEdges: call site without any call target");
4546 caller_address = return_pc;
4549 caller_address = low_pc;
4552 caller_address = call_inst_pc;
4555 LLDB_LOG(log,
"CollectCallEdges: No caller address");
4567 std::unique_ptr<CallEdge> edge;
4570 "CollectCallEdges: Found call origin: {0} (retn-PC: {1:x}) "
4572 call_origin->GetPubname(), return_pc, call_inst_pc);
4573 edge = std::make_unique<DirectCallEdge>(
4574 call_origin->GetMangledName(), caller_address_type, caller_address,
4575 tail_call, std::move(parameters));
4581 LLDB_LOG(log,
"CollectCallEdges: Found indirect call target: {0}",
4584 edge = std::make_unique<IndirectCallEdge>(
4585 *call_target, caller_address_type, caller_address, tail_call,
4586 std::move(parameters));
4589 if (log && parameters.size()) {
4592 param.LocationInCallee.GetDescription(&callee_loc_desc,
4594 param.LocationInCaller.GetDescription(&caller_loc_desc,
4596 LLDB_LOG(log,
"CollectCallEdges: \tparam: {0} => {1}",
4601 call_edges.push_back(std::move(edge));
4606std::vector<std::unique_ptr<lldb_private::CallEdge>>
4629 auto ts = *ts_or_err;
4642 if (
ObjectFile *dwp_obj = dwp_sp->GetObjectFile()) {
4649 for (uint32_t cu_idx = 0; cu_idx < num_cus; ++cu_idx) {
4652 if (dwarf_cu ==
nullptr || !dwarf_cu->
GetDWOId().has_value())
4666 dwarf_cu, DW_AT_comp_dir,
nullptr);
4677 bool load_all_debug_info) {
4681 for (
size_t cu_idx = 0; cu_idx < num_cus; cu_idx++) {
4684 if (dwarf_cu ==
nullptr)
4689 if (!dwarf_cu->
GetDWOId().has_value())
4693 std::make_shared<StructuredData::Dictionary>();
4694 const uint64_t dwo_id = dwarf_cu->
GetDWOId().value();
4695 dwo_data->AddIntegerItem(
"dwo_id", dwo_id);
4700 dwo_data->AddStringItem(
"dwo_name", dwo_name);
4702 dwo_data->AddStringItem(
"error",
"missing dwo name");
4705 const char *comp_dir = die.GetDIE()->GetAttributeValueAsString(
4706 dwarf_cu, DW_AT_comp_dir,
nullptr);
4708 dwo_data->AddStringItem(
"comp_dir", comp_dir);
4711 dwo_data->AddStringItem(
4713 llvm::formatv(
"unable to get unit DIE for DWARFUnit at {0:x}",
4722 dwo_data->AddStringItem(
4723 "resolved_dwo_path",
4726 dwo_data->AddStringItem(
"error",
4729 dwo_data->AddBooleanItem(
"loaded", dwo_symfile !=
nullptr);
4730 if (!errors_only || dwo_data->HasKey(
"error"))
4731 separate_debug_info_files.
AddItem(dwo_data);
4736 d.
AddItem(
"separate-debug-info-files",
4737 std::make_shared<StructuredData::Array>(
4738 std::move(separate_debug_info_files)));
4747 module_sp->GetSymbolFile()->GetBackingSymbolFile());
4755 if (
m_objfile_sp->GetArchitecture().GetTriple().isAppleMachO())
4762 symfiles.
Append(module_fspec);
4768 if (symfile_fspec != module_fspec) {
4769 symfiles.
Append(symfile_fspec);
4774 llvm::StringRef filename_no_ext =
4776 if (filename_no_ext != module_fspec.
GetFilename()) {
4777 FileSpec module_spec_no_ext(module_fspec);
4779 symfiles.
Append(module_spec_no_ext);
4787 for (
const auto &symfile : symfiles.
files()) {
4789 FileSpec(symfile.GetPath() +
".dwp", symfile.GetPathStyle());
4790 LLDB_LOG(log,
"Searching for DWP using: \"{0}\"",
4793 module_spec, search_paths,
4794 m_objfile_sp->GetModule()->GetSymbolLocatorStatistics());
4800 LLDB_LOG(log,
"No DWP file found locally");
4806 module_spec, search_paths,
4807 m_objfile_sp->GetModule()->GetSymbolLocatorStatistics());
4810 LLDB_LOG(log,
"Found DWP file: \"{0}\"", dwp_filespec);
4816 dwp_file_extractor_sp, dwp_file_data_offset);
4823 LLDB_LOG(log,
"Unable to locate for DWP file for: \"{0}\"",
4830llvm::Expected<lldb::TypeSystemSP>
4837 if (
auto err = type_system_or_err.takeError()) {
4839 "Unable to get DWARFASTParser: {0}");
4842 if (
auto ts = *type_system_or_err)
4843 return ts->GetDWARFParser();
4849 return dwarf_ast->GetDeclForUIDFromDWARF(die);
4855 return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
4862 return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
4873 case DW_LANG_Mips_Assembler:
4886 if (llvm::dwarf::isCPlusPlus(lang))
4887 lang = DW_LANG_C_plus_plus;
4893 return m_index->GetIndexTime();
4900 return m_index->ResetStatistics();
4918 if (dwo_error.
Fail())
4919 return dwo_error.
Clone();
4928 if (dwarf_cu->
HasAny({DW_TAG_variable, DW_TAG_formal_parameter}))
4932 "no variable information is available in debug info for this "
4937 std::unordered_map<lldb::CompUnitSP, lldb_private::Args> &args) {
4941 for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
4958 args.insert({comp_unit,
Args(flags)});
4967 for (
size_t cu_idx = 0; cu_idx < num_cus; cu_idx++) {
4969 if (dwarf_cu ==
nullptr)
4973 if (!dwarf_cu->
GetDWOId().has_value())
4988 if (dwo_error.
Fail())
4998 if (die.
Tag() != DW_TAG_variable)
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_LOG_ERRORV(log, error,...)
#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 llvm::StringRef ClangToItaniumCtorKind(clang::CXXCtorType kind)
static void ParseSupportFilesFromPrologue(SupportFileList &support_files, const lldb::ModuleSP &module, const llvm::DWARFDebugLine::Prologue &prologue, FileSpec::Style style, llvm::StringRef compile_dir={})
static std::optional< uint64_t > GetByteSizeFromTypeDIE(DWARFDIE die, unsigned max_depth=64)
Walks transparent type wrappers following DW_AT_type and returns the first DW_AT_byte_size encountere...
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 llvm::StringRef GetItaniumCtorDtorVariant(llvm::StringRef discriminator)
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 std::unique_ptr< LineTable > ConvertLineTable(CompileUnit &comp_unit, const llvm::DWARFDebugLine::LineTable &line_table, lldb::addr_t first_code_address)
static llvm::StringRef ClangToItaniumDtorKind(clang::CXXDtorType kind)
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(...)
A section + offset based address class.
lldb::SectionSP GetSection() const
Get const accessor for the section.
lldb::addr_t GetFileAddress() const
Get the file address.
lldb::addr_t GetOffset() const
Get the section relative offset value.
bool IsSectionOffset() const
Check if an address is section offset.
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.
lldb::BlockSP CreateChild(lldb::user_id_t uid)
Creates a block with the specified UID uid.
Block * FindBlockByID(lldb::user_id_t block_id)
void SetVariableList(lldb::VariableListSP &variable_list_sp)
Set accessor for the variable list.
void SetDidParseVariables(bool b, bool set_children)
void AddRange(const Range &range)
Add a new offset range to this block.
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(llvm::StringRef name, llvm::StringRef &context, llvm::StringRef &identifier)
static llvm::Expected< ConstString > SubstituteStructor_ItaniumMangle(llvm::StringRef mangled_name, llvm::StringRef subst_from, llvm::StringRef subst_to)
Substitutes Itanium structor encoding substrings given by subst_from in mangled_name with subst_to.
static llvm::Expected< ConstString > SubstituteStructorAliases_ItaniumMangle(llvm::StringRef mangled_name)
Tries replacing Itanium structor encoding substrings in mangled_name with potential aliases....
Checksum(llvm::MD5::MD5Result md5=g_sentinel)
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.
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.
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.
const char * AsCString(const char *value_if_empty) 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 UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size, uint8_t addr_byte_size)
bool Update_DW_OP_addr(const Delegate *dwarf_cu, lldb::addr_t file_addr)
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.
llvm::StringRef GetFileNameStrippingExtension() const
Return the filename without the extension part.
void SetFilename(llvm::StringRef filename)
Filename string set 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.
llvm::StringRef GetFilename() const
Filename string const get accessor.
bool IsAbsolute() const
Returns true if the filespec represents an absolute path.
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
bool Exists(const FileSpec &file_spec) const
Returns whether the given file exists.
static FileSystem & Instance()
void Resolve(llvm::SmallVectorImpl< char > &path, bool force_make_absolute=false)
Resolve path to make it canonical.
A class that describes a function.
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)
Returns the internal LLDB name for the specified language.
static bool LanguageIsCPlusPlus(lldb::LanguageType language)
static void AppendLineEntryToSequence(Sequence &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)
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 Mangled::ManglingScheme GetManglingScheme(llvm::StringRef 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, llvm::SmallVectorImpl< lldb::ModuleSP > *old_modules, bool *did_create_ptr, bool invoke_locate_callback=true, bool invoke_symbol_locators=true)
void Append(const ModuleSpec &spec)
ArchSpec & GetArchitecture()
FileSpec & GetSymbolFileSpec()
A class that encapsulates name lookup information.
lldb::FunctionNameType GetNameTypeMask() const
ConstString GetLookupName() const
static std::vector< LookupInfo > MakeLookupInfos(ConstString name, lldb::FunctionNameType name_type_mask, lldb::LanguageType lang_type, ConstString lookup_name_override={})
Creates a vector of lookup infos for function name resolution.
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::DataExtractorSP extractor_sp, lldb::offset_t &data_offset)
Find a ObjectFile plug-in that can parse file_spec.
Symtab * GetSymtab(bool can_create=true)
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 FileSpec LocateExecutableSymbolFile(const ModuleSpec &module_spec, const FileSpecList &default_search_paths, StatisticsMap &map)
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 bool UnregisterPlugin(ABICreateInstance create_callback)
A Progress indicator helper class.
RangeData< lldb::addr_t, lldb::addr_t, Variable * > Entry
llvm::StringRef GetText() const
Access the regular expression text.
lldb::SectionSP FindSectionByName(llvm::StringRef section_name) const
lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, bool check_children, size_t start_idx=0) const
SectionList & GetChildren()
lldb::offset_t GetFileSize() const
bool GetCheckInlines() const
FileSpec GetFileSpec() const
This base class provides an interface to stack frames.
virtual const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
std::chrono::duration< double > Duration
Status Clone() const
Don't call this function in new code.
static Status FromErrorString(const char *str)
bool Fail() const
Test for error condition.
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
static Status static Status FromErrorStringWithFormatv(const char *format, Args &&...args)
const char * GetData() const
llvm::StringRef GetString() const
A stream class that can stream formatted output to a file.
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
void AddItem(const ObjectSP &item)
void AddStringItem(llvm::StringRef key, llvm::StringRef value)
void AddItem(llvm::StringRef key, ObjectSP value_sp)
std::shared_ptr< Dictionary > DictionarySP
A list of support files for a CompileUnit.
const FileSpec & GetFileSpecAtIndex(size_t idx) const
void Append(const FileSpec &file)
SupportFileNSP GetSupportFileAtIndex(size_t idx) const
void EmplaceBack(Args &&...args)
Wraps a FileSpec and an optional Checksum.
virtual const FileSpec & Materialize()
Materialize the file to disk and return the path to that temporary file.
Defines a list of symbol context objects.
uint32_t GetSize() const
Get accessor for a symbol context list size.
bool AppendIfUnique(const SymbolContext &sc, bool merge_symbol_into_function)
"lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is part of a symbol context and c...
virtual CompileUnit * CalculateSymbolContextCompileUnit()
virtual void CalculateSymbolContext(SymbolContext *sc)=0
Reconstruct the object's symbol context into sc.
Defines a symbol context baton that can be handed other debug core functions.
Function * function
The Function for a given query.
Block * block
The Block for a given query.
lldb::ModuleSP module_sp
The Module for a given query.
CompileUnit * comp_unit
The CompileUnit for a given query.
uint32_t GetResolvedMask() const
void Clear(bool clear_target)
Clear the object's state.
Variable * variable
The global variable matching the given query.
LineEntry line_entry
The LineEntry for a given query.
lldb::CompUnitSP GetCompileUnitAtIndex(uint32_t idx) override
ObjectFile * GetObjectFile() override
virtual TypeList & GetTypeList()
lldb::ObjectFileSP m_objfile_sp
ObjectFile * GetMainObjectFile() override
void SetCompileUnitAtIndex(uint32_t idx, const lldb::CompUnitSP &cu_sp)
SymbolFileCommon(lldb::ObjectFileSP objfile_sp)
Symtab * GetSymtab(bool can_create=true) override
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language) override
uint32_t GetNumCompileUnits() override
void Dump(Stream &s) override
uint64_t GetDebugInfoSize(bool load_all_debug_info=false) override
Metrics gathering functions.
std::unordered_map< lldb::CompUnitSP, Args > GetCompileOptions()
Returns a map of compilation unit to the compile option arguments associated with that compilation un...
virtual ObjectFile * GetObjectFile()=0
bool ValueIsAddress() const
Address & GetAddressRef()
Symbol * FindFirstSymbolWithNameAndType(ConstString name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
static FileSpecList GetDefaultDebugFileSearchPaths()
void Insert(const lldb::TypeSP &type)
A class that contains all state required for type lookups.
bool GetModuleSearch() const
The m_context can be used in two ways: normal types searching with the context containing a stanadard...
std::vector< lldb_private::CompilerContext > & GetContextRef()
Access the internal compiler context array.
ConstString GetTypeBasename() const
Get the type basename to use when searching the type indexes in each SymbolFile object.
bool ContextMatches(llvm::ArrayRef< lldb_private::CompilerContext > context) const
Check of a CompilerContext array from matching type from a symbol file matches the m_context.
bool GetSearchByMangledName() const
Returns true if the type query is supposed to treat the name to be searched as a mangled name.
This class tracks the state and results of a TypeQuery.
bool InsertUnique(const lldb::TypeSP &type_sp)
When types that match a TypeQuery are found, this API is used to insert the matching types.
bool Done(const TypeQuery &query) const
Check if the type matching has found all of the matches that it needs.
bool AlreadySearched(lldb_private::SymbolFile *sym_file)
Check if a SymbolFile object has already been searched by this type match object.
A TypeSystem implementation based on Clang.
Interface for representing a type system.
virtual lldb::LanguageType GetMinimumLanguage(lldb::opaque_compiler_type_t type)=0
virtual plugin::dwarf::DWARFASTParser * GetDWARFParser()
@ FileAddress
A file address value.
bool AddVariableIfUnique(const lldb::VariableSP &var_sp)
lldb::VariableSP GetVariableAtIndex(size_t idx) const
lldb::VariableSP RemoveVariableAtIndex(size_t idx)
SymbolContextScope * GetSymbolContextScope() const
RangeVector< lldb::addr_t, lldb::addr_t > RangeList
An abstraction which groups an XcodeSDK with the sysroot it was used from.
static std::unique_ptr< AppleDWARFIndex > Create(Module &module, DWARFDataExtractor apple_names, DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types, DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str)
Identifies a DWARF debug info entry within a given Module.
std::optional< uint32_t > file_index() const
static constexpr uint64_t k_file_index_mask
dw_offset_t die_offset() const
virtual void EnsureAllDIEsInDeclContextHaveBeenParsed(CompilerDeclContext decl_context)=0
virtual bool CompleteTypeFromDWARF(const DWARFDIE &die, Type *type, const CompilerType &compiler_type)=0
virtual std::string GetDIEClassTemplateParams(DWARFDIE die)=0
virtual Function * ParseFunctionFromDWARF(CompileUnit &comp_unit, const DWARFDIE &die, AddressRanges ranges)=0
virtual ConstString ConstructDemangledNameFromDWARF(const DWARFDIE &die)=0
virtual lldb::TypeSP ParseTypeFromDWARF(const SymbolContext &sc, const DWARFDIE &die, bool *type_is_new_ptr)=0
static std::optional< SymbolFile::ArrayInfo > ParseChildArrayInfo(const DWARFDIE &parent_die, const ExecutionContext *exe_ctx=nullptr)
virtual CompilerDeclContext GetDeclContextForUIDFromDWARF(const DWARFDIE &die)=0
DWARFUnit * CompileUnitAtIndex(uint32_t i) const
dw_attr_t AttributeAtIndex(uint32_t i) const
bool ExtractFormValueAtIndex(uint32_t i, DWARFFormValue &form_value) const
DWARFAttributes GetAttributes(Recurse recurse=Recurse::yes) const
std::optional< uint64_t > GetAttributeValueAsOptionalUnsigned(const dw_attr_t attr) const
const DWARFDataExtractor & GetData() const
const char * GetAttributeValueAsString(const dw_attr_t attr, const char *fail_value) const
std::optional< DIERef > GetDIERef() const
lldb::ModuleSP GetModule() const
SymbolFileDWARF * GetDWARF() const
DWARFDebugInfoEntry * GetDIE() const
DWARFUnit * GetCU() const
const char * GetName() const
uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr, uint64_t fail_value) const
dw_offset_t GetOffset() const
lldb::user_id_t GetID() const
DWARFDIE LookupAddress(const dw_addr_t address)
DWARFCompileUnit & GetNonSkeletonUnit()
const DWARFDataExtractor & getOrLoadLineData()
llvm::DWARFContext & GetAsLLVM()
void GetName(Stream &s) const
const char * GetMangledName(bool substitute_name_allowed=true) const
DWARFDIE GetFirstChild() const
DWARFDIE GetParent() const
bool GetDIENamesAndRanges(const char *&name, const char *&mangled, llvm::DWARFAddressRangesVector &ranges, std::optional< int > &decl_file, std::optional< int > &decl_line, std::optional< int > &decl_column, std::optional< int > &call_file, std::optional< int > &call_line, std::optional< int > &call_column, DWARFExpressionList *frame_base) const
DWARFDIE GetDIE(dw_offset_t die_offset) const
llvm::iterator_range< child_iterator > children() const
The range of all the children of this DIE.
DWARFDIE GetParentDeclContextDIE() const
std::vector< CompilerContext > GetDeclContext(bool derive_template_names=false) const
Return this DIE's decl context as it is needed to look up types in Clang modules.
DWARFDIE LookupDeepestBlock(lldb::addr_t file_addr) const
DWARFDIE GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const
DWARFDeclContext GetDWARFDeclContext() const
child_iterator begin() const
DWARFDIE GetReferencedDIE(const dw_attr_t attr) const
std::vector< CompilerContext > GetTypeLookupContext(bool derive_template_names=false) const
Get a context to a type so it can be looked up.
const char * GetPubname() const
DWARFDIE GetSibling() const
dw_offset_t FindAddress(dw_addr_t address) const
DWARFDebugInfoEntry objects assume that they are living in one big vector and do pointer arithmetic o...
dw_offset_t GetOffset() const
std::optional< uint64_t > GetAttributeValueAsOptionalUnsigned(const DWARFUnit *cu, const dw_attr_t attr, bool check_elaborating_dies=false) const
DWARFDebugInfoEntry * GetParent()
const char * GetAttributeValueAsString(const DWARFUnit *cu, const dw_attr_t attr, const char *fail_value, bool check_elaborating_dies=false) const
DWARFUnit * GetSkeletonUnit(DWARFUnit *dwo_unit)
DWARFUnit * GetUnitAtOffset(DIERef::Section section, dw_offset_t cu_offset, uint32_t *idx_ptr=nullptr)
const DWARFDebugAranges & GetCompileUnitAranges()
DWARFDIE GetDIE(DIERef::Section section, dw_offset_t die_offset)
DWARFUnit * GetUnitAtIndex(size_t idx)
static void ReadMacroEntries(const DWARFDataExtractor &debug_macro_data, const DWARFDataExtractor &debug_str_data, const bool offset_is_64_bit, lldb::offset_t *sect_offset, SymbolFileDWARF *sym_file_dwarf, DebugMacrosSP &debug_macros_sp)
const char * GetQualifiedName() const
ConstString GetQualifiedNameAsConstString() const
void AppendDeclContext(dw_tag_t tag, const char *name)
FileSpec::Style GetPathStyle()
DWARFBaseDIE GetUnitDIEOnly()
void ExtractUnitDIEIfNeeded()
SymbolFileDWARF & GetSymbolFileDWARF() const
dw_offset_t GetLineTableOffset()
DWARFCompileUnit * GetSkeletonUnit()
Get the skeleton compile unit for a DWO file.
const Status & GetDwoError() const
Get the fission .dwo file specific error for this compile unit.
void SetLLDBCompUnit(lldb_private::CompileUnit *cu)
lldb_private::CompileUnit * GetLLDBCompUnit() const
dw_offset_t GetOffset() const
uint8_t GetAddressByteSize() const override
DWARFDataExtractor GetLocationData() const
die_iterator_range dies()
std::optional< uint64_t > GetLoclistOffset(uint32_t Index)
bool ParseDWARFLocationList(const DataExtractor &data, DWARFExpressionList &loc_list) const
void SetDwoError(Status &&error)
Set the fission .dwo file specific error for this compile unit.
uint64_t GetDWARFLanguageType()
DWARFUnit & GetNonSkeletonUnit()
DWARFDIE GetDIE(dw_offset_t die_offset)
lldb::ByteOrder GetByteOrder() const
SymbolFileDWARFDwo * GetDwoSymbolFile(bool load_all_debug_info=true)
uint16_t GetVersion() const override
const FileSpec & GetCompilationDirectory()
std::optional< uint64_t > GetDWOId()
Get the DWO ID from the DWARFUnitHeader for DWARF5, or from the unit DIE's DW_AT_dwo_id or DW_AT_GNU_...
bool HasAny(llvm::ArrayRef< dw_tag_t > tags)
Returns true if any DIEs in the unit match any DW_TAG values in tags.
FileSpec GetFile(size_t file_idx)
static llvm::Expected< std::unique_ptr< DebugNamesDWARFIndex > > Create(Module &module, DWARFDataExtractor debug_names, DWARFDataExtractor debug_str, SymbolFileDWARF &dwarf)
lldb::addr_t LinkOSOFileAddress(SymbolFileDWARF *oso_symfile, lldb::addr_t oso_file_addr)
Convert a .o file "file address" to an executable "file address".
bool LinkOSOAddress(Address &addr)
Convert addr from a .o file address, to an executable address.
UniqueDWARFASTTypeMap & GetUniqueDWARFASTTypeMap()
DWARFDIE FindDefinitionDIE(const DWARFDIE &die)
uint64_t GetDebugInfoSize(bool load_all_debug_info=false) override
Metrics gathering functions.
CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) override
static CompilerDeclContext GetContainingDeclContext(const DWARFDIE &die)
static bool SupportedVersion(uint16_t version)
std::optional< uint32_t > GetDWARFUnitIndex(uint32_t cu_idx)
CompileUnit * GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu)
lldb::ModuleSP GetExternalModule(ConstString name)
void BuildCuTranslationTable()
friend class DWARFASTParser
void FindGlobalVariables(ConstString name, const CompilerDeclContext &parent_decl_ctx, uint32_t max_matches, VariableList &variables) override
virtual DWARFDIE FindDefinitionDIE(const DWARFDIE &die)
DWARFDIE FindBlockContainingSpecification(const DIERef &func_die_ref, dw_offset_t spec_block_die_offset)
lldb::VariableSP ParseVariableDIE(const SymbolContext &sc, const DWARFDIE &die, const lldb::addr_t func_low_pc)
void UpdateExternalModuleListIfNeeded()
static DWARFASTParser * GetDWARFParser(DWARFUnit &unit)
static lldb::LanguageType GetLanguageFamily(DWARFUnit &unit)
Same as GetLanguage() but reports all C++ versions as C++ (no version).
bool ForEachExternalModule(CompileUnit &, llvm::DenseSet< SymbolFile * > &, llvm::function_ref< bool(Module &)>) override
static llvm::StringRef GetDwoDiagnosticSuffix()
static char ID
LLVM RTTI support.
std::unique_ptr< DWARFDebugInfo > m_info
bool DeclContextMatchesThisSymbolFile(const CompilerDeclContext &decl_ctx)
void GetMangledNamesForFunction(const std::string &scope_qualified_name, std::vector< ConstString > &mangled_names) override
size_t PopulateBlockVariableList(VariableList &variable_list, const SymbolContext &sc, llvm::ArrayRef< DIERef > variable_dies, lldb::addr_t func_low_pc)
Type * ResolveType(const DWARFDIE &die, bool assert_not_being_parsed=true, bool resolve_function_context=false)
DWOStats GetDwoStats() override
Gets statistics about dwo files associated with this symbol file.
virtual llvm::DenseMap< lldb::opaque_compiler_type_t, DIERef > & GetForwardDeclCompilerTypeToDIE()
llvm::DenseMap< const DWARFDebugInfoEntry *, lldb::VariableSP > DIEToVariableSP
friend class SymbolFileDWARFDwo
friend struct StandaloneDWARFLineTableInfo
size_t ParseVariablesInFunctionContextRecursive(const SymbolContext &sc, const DWARFDIE &die, lldb::addr_t func_low_pc, DIEArray &accumulator)
std::unique_ptr< StandaloneDWARFLineTableInfo > m_standalone_line_table_info
virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(const DWARFDIE &die, ConstString type_name, bool must_be_implementation)
const std::shared_ptr< SymbolFileDWARFDwo > & GetDwpSymbolFile()
StandaloneDWARFLineTableInfo * GetStandaloneLineTableInfo()
Return standalone line-table information when there is a .debug_line section without a ....
std::recursive_mutex & GetModuleMutex() const override
Symbols file subclasses should override this to return the Module that owns the TypeSystem that this ...
bool GetSeparateDebugInfo(StructuredData::Dictionary &d, bool errors_only, bool load_all_debug_info=false) override
List separate dwo files.
UniqueDWARFASTTypeMap m_unique_ast_type_map
llvm::Expected< DWARFDIE > FindFunctionDefinition(const FunctionCallLabel &label, const DWARFDIE &declaration)
Find the definition DIE for the specified label in this SymbolFile.
bool m_fetched_external_modules
virtual llvm::DenseMap< const DWARFDebugInfoEntry *, Type * > & GetDIEToType()
GlobalVariableMap & GetGlobalAranges()
virtual DWARFCompileUnit * GetDWARFCompileUnit(CompileUnit *comp_unit)
llvm::SetVector< Type * > TypeSet
Function * ParseFunction(CompileUnit &comp_unit, const DWARFDIE &die)
friend class SymbolFileDWARFDebugMap
lldb::TypeSP GetTypeForDIE(const DWARFDIE &die, bool resolve_function_context=false)
friend class DWARFCompileUnit
llvm::Expected< SymbolContext > ResolveFunctionCallLabel(FunctionCallLabel &label) override
Resolves the function corresponding to the specified LLDB function call label.
lldb::addr_t m_first_code_address
DWARF does not provide a good way for traditional (concatenating) linkers to invalidate debug info de...
ConstString ConstructFunctionDemangledName(const DWARFDIE &die)
lldb::ModuleWP m_debug_map_module_wp
DWARFUnit * GetSkeletonUnit(DWARFUnit *dwo_unit)
Given a DWO DWARFUnit, find the corresponding skeleton DWARFUnit in the main symbol file.
FileSpec GetFile(DWARFUnit &unit, size_t file_idx)
std::shared_ptr< SymbolFileDWARFDwo > m_dwp_symfile
void DumpClangAST(Stream &s, llvm::StringRef filter, bool show_colors) override
void InitializeFirstCodeAddressRecursive(const SectionList §ion_list)
std::unique_ptr< llvm::DWARFDebugAbbrev > m_abbr
llvm::DenseMap< lldb::opaque_compiler_type_t, DIERef > m_forward_decl_compiler_type_to_die
std::vector< CompilerContext > GetCompilerContextForUID(lldb::user_id_t uid) override
virtual DWARFDIE GetDIE(const DIERef &die_ref)
static llvm::StringRef GetPluginNameStatic()
void InitializeFirstCodeAddress()
std::unique_ptr< GlobalVariableMap > m_global_aranges_up
llvm::once_flag m_info_once_flag
uint64_t GetDebugInfoSize(bool load_all_debug_info=false) override
Metrics gathering functions.
void FindTypes(const lldb_private::TypeQuery &match, lldb_private::TypeResults &results) override
Find types using a type-matching object that contains all search parameters.
static CompilerDecl GetDecl(const DWARFDIE &die)
void ResolveFunctionAndBlock(lldb::addr_t file_vm_addr, bool lookup_block, SymbolContext &sc)
Resolve functions and (possibly) blocks for the given file address and a compile unit.
void ResetStatistics() override
Reset the statistics for the symbol file.
size_t ParseVariablesForContext(const SymbolContext &sc) override
uint32_t CalculateNumCompileUnits() override
std::optional< ArrayInfo > GetDynamicArrayInfoForUID(lldb::user_id_t type_uid, const ExecutionContext *exe_ctx) override
If type_uid points to an array type, return its characteristics.
size_t ParseBlocksRecursive(Function &func) override
ExternalTypeModuleMap m_external_type_modules
Type * ResolveTypeUID(lldb::user_id_t type_uid) override
static lldb::LanguageType GetLanguage(DWARFUnit &unit)
bool ClassOrStructIsVirtual(const DWARFDIE &die)
llvm::DenseMap< dw_offset_t, std::unique_ptr< SupportFileList > > m_type_unit_support_files
size_t ParseFunctions(CompileUnit &comp_unit) override
bool ParseDebugMacros(CompileUnit &comp_unit) override
NameToOffsetMap m_function_scope_qualified_name_map
static SymbolFile * CreateInstance(lldb::ObjectFileSP objfile_sp)
std::atomic_flag m_dwo_warning_issued
bool ParseSupportFiles(CompileUnit &comp_unit, SupportFileList &support_files) override
bool ParseImportedModules(const SymbolContext &sc, std::vector< SourceModule > &imported_modules) override
std::optional< uint64_t > GetDWOId()
If this is a DWARF object with a single CU, return its DW_AT_dwo_id.
uint32_t CalculateAbilities() override
void GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask, TypeList &type_list) override
SymbolFileDWARFDebugMap * GetDebugMapSymfile()
void ParseDeclsForContext(CompilerDeclContext decl_ctx) override
size_t ParseTypes(CompileUnit &comp_unit) override
std::shared_ptr< SymbolFileDWARFDwo > GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
SymbolFileDWARF(lldb::ObjectFileSP objfile_sp, SectionList *dwo_section_list)
~SymbolFileDWARF() override
lldb::VariableSP ParseVariableDIECached(const SymbolContext &sc, const DWARFDIE &die)
lldb_private::ModuleSpecList GetSeparateDebugInfoFiles() override
Return a map of separate debug info files that are loaded.
StatsDuration::Duration GetDebugInfoIndexTime() override
Return the time it took to index the debug information in the object file.
bool CompleteType(CompilerType &compiler_type) override
DWARFDebugInfo & DebugInfo()
bool ParseLineTable(CompileUnit &comp_unit) override
lldb::TypeSP GetTypeEnclosingVariableUID(lldb::user_id_t uid) override
Get the semantically innermost non-function type that encloses the provided variable.
bool ResolveFunction(const DWARFDIE &die, bool include_inlines, SymbolContextList &sc_list)
bool ParseIsOptimized(CompileUnit &comp_unit) override
static llvm::StringRef GetPluginDescriptionStatic()
std::vector< std::unique_ptr< CallEdge > > CollectCallEdges(lldb::ModuleSP module, DWARFDIE function_die)
Parse call site entries (DW_TAG_call_site), including any nested call site parameters (DW_TAG_call_si...
void Dump(Stream &s) override
DIEArray MergeBlockAbstractParameters(const DWARFDIE &block_die, DIEArray &&variable_dies)
DWARFDIE GetDeclContextDIEContainingDIE(const DWARFDIE &die)
SymbolFileDWARFDebugMap * m_debug_map_symfile
llvm::once_flag m_standalone_line_table_once_flag
void InitializeObject() override
Initialize the SymbolFile object.
void ParseAndAppendGlobalVariable(const SymbolContext &sc, const DWARFDIE &die, VariableList &cc_variable_list)
static llvm::Expected< lldb::TypeSystemSP > GetTypeSystem(DWARFUnit &unit)
std::vector< uint32_t > m_lldb_cu_to_dwarf_unit
XcodeSDKAndSysroot ParseXcodeSDK(CompileUnit &comp_unit) override
Return the Xcode SDK comp_unit was compiled against.
void FindFunctions(const Module::LookupInfo &lookup_info, const CompilerDeclContext &parent_decl_ctx, bool include_inlines, SymbolContextList &sc_list) override
static bool DIEInDeclContext(const CompilerDeclContext &parent_decl_ctx, const DWARFDIE &die, bool only_root_namespaces=false)
uint32_t ResolveSymbolContext(const Address &so_addr, lldb::SymbolContextItem resolve_scope, SymbolContext &sc) override
std::unique_ptr< DWARFIndex > m_index
bool HasForwardDeclForCompilerType(const CompilerType &compiler_type)
void PreloadSymbols() override
TypeList & GetTypeList() override
lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit &dwarf_cu)
CompilerDeclContext FindNamespace(ConstString name, const CompilerDeclContext &parent_decl_ctx, bool only_root_namespaces) override
Finds a namespace of name name and whose parent context is parent_decl_ctx.
lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override
static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val)
lldb::TypeSP ParseType(const SymbolContext &sc, const DWARFDIE &die, bool *type_is_new)
static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die)
std::vector< std::unique_ptr< CallEdge > > ParseCallEdgesInFunction(UserID func_id) override
lldb::addr_t FixupAddress(lldb::addr_t file_addr)
If this symbol file is linked to by a debug map (see SymbolFileDWARFDebugMap), and file_addr is a fil...
virtual void GetObjCMethods(ConstString class_name, llvm::function_ref< IterationAction(DWARFDIE die)> callback)
llvm::Expected< lldb::TypeSystemSP > GetTypeSystemForLanguage(lldb::LanguageType language) override
CompilerDecl GetDeclForUID(lldb::user_id_t uid) override
virtual SymbolFileDWARF * GetDIERefSymbolFile(const DIERef &die_ref)
Given a DIERef, find the correct SymbolFileDWARF.
lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) override
StatsDuration m_parse_time
llvm::once_flag m_dwp_symfile_once_flag
CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) override
static void DebuggerInitialize(Debugger &debugger)
RangeDataVector< lldb::addr_t, lldb::addr_t, Variable * > GlobalVariableMap
size_t ParseVariablesInFunctionContext(const SymbolContext &sc, const DWARFDIE &die, const lldb::addr_t func_low_pc)
DebugMacrosMap m_debug_macros_map
llvm::DWARFDebugAbbrev * DebugAbbrev()
llvm::DenseMap< const DWARFDebugInfoEntry *, Type * > m_die_to_type
bool GetFunction(const DWARFDIE &die, SymbolContext &sc)
const SupportFileList * GetTypeUnitSupportFiles(DWARFTypeUnit &tu)
virtual DIEToVariableSP & GetDIEToVariable()
std::optional< uint64_t > GetFileIndex() const
Symbol * GetObjCClassSymbol(ConstString objc_class_name)
static CompilerDeclContext GetDeclContext(const DWARFDIE &die)
virtual UniqueDWARFASTTypeMap & GetUniqueDWARFASTTypeMap()
virtual void LoadSectionData(lldb::SectionType sect_type, DWARFDataExtractor &data)
Status CalculateFrameVariableError(StackFrame &frame) override
Subclasses will override this function to for GetFrameVariableError().
#define DW_INVALID_OFFSET
llvm::dwarf::Tag dw_tag_t
#define DW_DIE_OFFSET_MAX_BITSIZE
llvm::dwarf::Attribute dw_attr_t
#define LLDB_INVALID_ADDRESS
llvm::StringRef DW_TAG_value_to_name(dw_tag_t tag)
std::vector< DIERef > DIEArray
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
NonNullSharedPtr< lldb_private::SupportFile > SupportFileNSP
NativeFilePosix NativeFile
std::shared_ptr< DebugMacros > DebugMacrosSP
llvm::SmallVector< CallSiteParameter, 0 > CallSiteParameterArray
A vector of CallSiteParameter.
IterationAction
Useful for callbacks whose return type indicates whether to continue iteration or short-circuit.
std::shared_ptr< lldb_private::TypeSystem > TypeSystemSP
std::shared_ptr< lldb_private::ObjectFile > ObjectFileSP
LanguageType
Programming language type.
@ eLanguageTypeMipsAssembler
Mips_Assembler.
@ eLanguageTypeUnknown
Unknown or invalid language value.
@ eLanguageTypeC_plus_plus
ISO C++:1998.
@ eLanguageTypeLastStandardLanguage
std::shared_ptr< lldb_private::Type > TypeSP
std::shared_ptr< lldb_private::VariableList > VariableListSP
std::shared_ptr< lldb_private::Variable > VariableSP
@ eValueTypeVariableGlobal
globals variable
@ eValueTypeVariableLocal
function local variables
@ eValueTypeVariableArgument
function argument variables
@ eValueTypeVariableStatic
static variable
@ eValueTypeVariableThreadLocal
thread local storage variable
std::shared_ptr< lldb_private::Section > SectionSP
@ eSectionTypeDWARFAppleNamespaces
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
@ eSectionTypeDWARFAppleTypes
@ eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFAppleNames
@ eSectionTypeDWARFAppleObjC
@ eSectionTypeDWARFDebugAbbrev
std::shared_ptr< lldb_private::DataExtractor > DataExtractorSP
std::shared_ptr< lldb_private::Module > ModuleSP
std::shared_ptr< lldb_private::CompileUnit > CompUnitSP
Represent the locations of a parameter at a call site, both in the caller and in the callee.
static CompilerType RemoveFastQualifiers(const CompilerType &ct)
Holds statistics about DWO (Debug With Object) files.
uint32_t loaded_dwo_file_count
Holds parsed information about a function call label that LLDB attaches as an AsmLabel to function AS...
lldb::user_id_t symbol_id
Unique identifier of the function symbol on which to perform the function call.
llvm::StringRef discriminator
Arbitrary string which language plugins can interpret for their own needs.
llvm::StringRef lookup_name
Name to use when searching for the function symbol in module_id.
Information needed to import a source-language module.
std::vector< ConstString > path
Something like "Module.Submodule".
A mix in class that contains a generic user ID.
lldb::user_id_t GetID() const
Get accessor for the user ID.
LineTableEntry(llvm::Expected< llvm::DWARFDebugLine::LineTable > line_table)
llvm::Expected< llvm::DWARFDebugLine::LineTable > line_table
const llvm::DWARFDebugLine::Prologue * GetPrologue(uint32_t cu_idx)
~StandaloneDWARFLineTableInfo()
llvm::once_flag aranges_once_flag
CompUnitSP ParseCompileUnitAtIndex(uint32_t cu_idx)
const llvm::DWARFDebugLine::LineTable * GetLineTable(uint32_t cu_idx)
uint32_t ResolveSymbolContext(const Address &so_addr, SymbolContextItem resolve_scope, SymbolContext &sc)
StandaloneDWARFLineTableInfo(SymbolFileDWARF &symfile)
const DWARFDebugAranges & GetAranges(lldb::addr_t first_code_address)
std::vector< LineTableEntry > line_tables
SymbolFileDWARF & m_symfile
bool ParseLineTable(CompileUnit &comp_unit)
uint32_t CalculateNumCompileUnits() const
DWARFDebugAranges aranges