lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

   1 //===-- SymbolFileDWARFDwo.cpp --------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "SymbolFileDWARFDwo.h"
  10
  11 #include "lldb/Core/Section.h"
  12 #include "lldb/Expression/DWARFExpression.h"
  13 #include "lldb/Symbol/ObjectFile.h"
  14 #include "lldb/Utility/LLDBAssert.h"
  15 #include "llvm/Support/Casting.h"
  16
  17 #include "DWARFCompileUnit.h"
  18 #include "DWARFDebugInfo.h"
  19 #include "DWARFUnit.h"
  20 #include <optional>
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24 using namespace lldb_private::plugin::dwarf;
  25
  26 char SymbolFileDWARFDwo::ID;
  27
  28 SymbolFileDWARFDwo::SymbolFileDWARFDwo(SymbolFileDWARF &base_symbol_file,
  29                                        ObjectFileSP objfile, uint32_t id)
  30     : SymbolFileDWARF(objfile, objfile->GetSectionList(
  31                                    /*update_module_section_list*/ false)),
  32       m_base_symbol_file(base_symbol_file) {
  33   SetFileIndex(id);
  34
  35   // Parsing of the dwarf unit index is not thread-safe, so we need to prime it
  36   // to enable subsequent concurrent lookups.
  37   m_context.GetAsLLVM().getCUIndex();
  38 }
  39
  40 DWARFCompileUnit *SymbolFileDWARFDwo::GetDWOCompileUnitForHash(uint64_t hash) {
  41   if (const llvm::DWARFUnitIndex &index = m_context.GetAsLLVM().getCUIndex()) {
  42     if (const llvm::DWARFUnitIndex::Entry *entry = index.getFromHash(hash)) {
  43       if (auto *unit_contrib = entry->getContribution())
  44         return llvm::dyn_cast_or_null<DWARFCompileUnit>(
  45             DebugInfo().GetUnitAtOffset(DIERef::Section::DebugInfo,
  46                                         unit_contrib->getOffset()));
  47     }
  48     return nullptr;
  49   }
  50
  51   DWARFCompileUnit *cu = FindSingleCompileUnit();
  52   if (!cu)
  53     return nullptr;
  54   std::optional<uint64_t> dwo_id = cu->GetDWOId();
  55   if (!dwo_id || hash != *dwo_id)
  56     return nullptr;
  57   return cu;
  58 }
  59
  60 DWARFCompileUnit *SymbolFileDWARFDwo::FindSingleCompileUnit() {
  61   DWARFDebugInfo &debug_info = DebugInfo();
  62
  63   // Right now we only support dwo files with one compile unit. If we don't have
  64   // type units, we can just check for the unit count.
  65   if (!debug_info.ContainsTypeUnits() && debug_info.GetNumUnits() == 1)
  66     return llvm::cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(0));
  67
  68   // Otherwise, we have to run through all units, and find the compile unit that
  69   // way.
  70   DWARFCompileUnit *cu = nullptr;
  71   for (size_t i = 0; i < debug_info.GetNumUnits(); ++i) {
  72     if (auto *candidate =
  73             llvm::dyn_cast<DWARFCompileUnit>(debug_info.GetUnitAtIndex(i))) {
  74       if (cu)
  75         return nullptr; // More that one CU found.
  76       cu = candidate;
  77     }
  78   }
  79   return cu;
  80 }
  81
  82 lldb::offset_t SymbolFileDWARFDwo::GetVendorDWARFOpcodeSize(
  83     const lldb_private::DataExtractor &data, const lldb::offset_t data_offset,
  84     const uint8_t op) const {
  85   return GetBaseSymbolFile().GetVendorDWARFOpcodeSize(data, data_offset, op);
  86 }
  87
  88 uint64_t SymbolFileDWARFDwo::GetDebugInfoSize(bool load_all_debug_info) {
  89   // Directly get debug info from current dwo object file's section list
  90   // instead of asking SymbolFileCommon::GetDebugInfo() which parses from
  91   // owning module which is wrong.
  92   SectionList *section_list =
  93       m_objfile_sp->GetSectionList(/*update_module_section_list=*/false);
  94   if (section_list)
  95     return section_list->GetDebugInfoSize();
  96   return 0;
  97 }
  98
  99 bool SymbolFileDWARFDwo::ParseVendorDWARFOpcode(
 100     uint8_t op, const lldb_private::DataExtractor &opcodes,
 101     lldb::offset_t &offset, std::vector<lldb_private::Value> &stack) const {
 102   return GetBaseSymbolFile().ParseVendorDWARFOpcode(op, opcodes, offset, stack);
 103 }
 104
 105 SymbolFileDWARF::DIEToTypePtr &SymbolFileDWARFDwo::GetDIEToType() {
 106   return GetBaseSymbolFile().GetDIEToType();
 107 }
 108
 109 SymbolFileDWARF::DIEToVariableSP &SymbolFileDWARFDwo::GetDIEToVariable() {
 110   return GetBaseSymbolFile().GetDIEToVariable();
 111 }
 112
 113 llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> &
 114 SymbolFileDWARFDwo::GetForwardDeclCompilerTypeToDIE() {
 115   return GetBaseSymbolFile().GetForwardDeclCompilerTypeToDIE();
 116 }
 117
 118 void SymbolFileDWARFDwo::GetObjCMethods(
 119     lldb_private::ConstString class_name,
 120     llvm::function_ref<bool(DWARFDIE die)> callback) {
 121   GetBaseSymbolFile().GetObjCMethods(class_name, callback);
 122 }
 123
 124 UniqueDWARFASTTypeMap &SymbolFileDWARFDwo::GetUniqueDWARFASTTypeMap() {
 125   return GetBaseSymbolFile().GetUniqueDWARFASTTypeMap();
 126 }
 127
 128 DWARFDIE SymbolFileDWARFDwo::FindDefinitionDIE(const DWARFDIE &die) {
 129   return GetBaseSymbolFile().FindDefinitionDIE(die);
 130 }
 131
 132 lldb::TypeSP SymbolFileDWARFDwo::FindCompleteObjCDefinitionTypeForDIE(
 133     const DWARFDIE &die, lldb_private::ConstString type_name,
 134     bool must_be_implementation) {
 135   return GetBaseSymbolFile().FindCompleteObjCDefinitionTypeForDIE(
 136       die, type_name, must_be_implementation);
 137 }
 138
 139 llvm::Expected<lldb::TypeSystemSP>
 140 SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
 141   return GetBaseSymbolFile().GetTypeSystemForLanguage(language);
 142 }
 143
 144 DWARFDIE
 145 SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
 146   if (die_ref.file_index() == GetFileIndex())
 147     return DebugInfo().GetDIE(die_ref.section(), die_ref.die_offset());
 148   return GetBaseSymbolFile().GetDIE(die_ref);
 149 }
 150
 151 void SymbolFileDWARFDwo::FindGlobalVariables(
 152     ConstString name, const CompilerDeclContext &parent_decl_ctx,
 153     uint32_t max_matches, VariableList &variables) {
 154   GetBaseSymbolFile().FindGlobalVariables(name, parent_decl_ctx, max_matches,
 155                                           variables);
 156 }
 157
 158 bool SymbolFileDWARFDwo::GetDebugInfoIndexWasLoadedFromCache() const {
 159   return GetBaseSymbolFile().GetDebugInfoIndexWasLoadedFromCache();
 160 }
 161 void SymbolFileDWARFDwo::SetDebugInfoIndexWasLoadedFromCache() {
 162   GetBaseSymbolFile().SetDebugInfoIndexWasLoadedFromCache();
 163 }
 164 bool SymbolFileDWARFDwo::GetDebugInfoIndexWasSavedToCache() const {
 165   return GetBaseSymbolFile().GetDebugInfoIndexWasSavedToCache();
 166 }
 167 void SymbolFileDWARFDwo::SetDebugInfoIndexWasSavedToCache() {
 168   GetBaseSymbolFile().SetDebugInfoIndexWasSavedToCache();
 169 }
 170 bool SymbolFileDWARFDwo::GetDebugInfoHadFrameVariableErrors() const {
 171   return GetBaseSymbolFile().GetDebugInfoHadFrameVariableErrors();
 172 }
 173 void SymbolFileDWARFDwo::SetDebugInfoHadFrameVariableErrors() {
 174   return GetBaseSymbolFile().SetDebugInfoHadFrameVariableErrors();
 175 }
 176
 177 SymbolFileDWARF *
 178 SymbolFileDWARFDwo::GetDIERefSymbolFile(const DIERef &die_ref) {
 179   return GetBaseSymbolFile().GetDIERefSymbolFile(die_ref);
 180 }