DWZ 01/06: Adjust existing code for the DWZ support

[jankratochvil]

Summary

New DWARFCompileUnit::GetMainCU() and DWARFDIE::GetMainDWARF() need to locate original symbol file when they are place in a DWZ common file. For example for UID context. One needs to access both symbol files as the one where the DIE really comes from still needs to be used for .debug_abbrev, .debug_str and .debug_line.

Probably more such cases need to be caught, they get indicated by later implemented DWARFDebugInfo::DWZRedirect:

"Internal LLDB error - unable to resolve offset 0x%8.8" PRIx32
" as DWZ common file has been passed, change the callers to use:"
" DWARFDIE::GetDWARF() -> DWARFDIE::GetMainDWARF()",

All DWZ patches are also applied in: git clone -b dwz git://git.jankratochvil.net/lldb

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

180–181

Just fix the DIERef constructor to not use 0 for the cu_offset?

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

388–390

This seems like the wrong place to do this call. We are asking all DWARF to index itself from DWARFDebugInfoEntry::GetDIENamesAndRanges()? Doesn't seem like the right place.

[jankratochvil]

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

180–181

This has been fixed in the meantime by @alexshap's D42563.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

388–390

Fortunately it is somehow no longer needed now, dropped it.

[jankratochvil]

bugfix

[jankratochvil]

It is now reworked without FileOffset and the remapping to unique DIE offsets for each DW_TAG_partial_unit inclusion by DW_TAG_imported_unit, as discussed in: https://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180409/040324.html

[jankratochvil]

Replaced by D96236.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
                                                bool *type_is_new_ptr) {
   TypeSP type_sp;
 
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   AccessType accessibility = eAccessNone;
   if (die) {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    SymbolFileDWARF *dwarf = die.GetMainDWARF();
     if (log) {
       DWARFDIE context_die;
       clang::DeclContext *context =
           GetClangDeclContextContainingDIE(die, &context_die);
 
       dwarf->GetObjectFile()->GetModule()->LogMessage(
           log, "SymbolFileDWARF::ParseType (die = 0x%8.8x, decl_ctx = %p (die "
                "0x%8.8x)) %s name = '%s')",
case DW_TAG_subrange_type: {
       }
     } break;
     }
   }
 }
 
 Type *DWARFASTParserClang::GetTypeForDIE(const DWARFDIE &die) {
   if (die) {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    SymbolFileDWARF *dwarf = die.GetMainDWARF();
     DWARFAttributes attributes;
     const size_t num_attributes = die.GetAttributes(attributes);
     if (num_attributes > 0) {
       DWARFFormValue type_die_form;
       for (size_t i = 0; i < num_attributes; ++i) {
         dw_attr_t attr = attributes.AttributeAtIndex(i);
         DWARFFormValue form_value;
 
if (DWARFDIE abstract_origin_die =
     return decl;
   }
 
   clang::Decl *decl = nullptr;
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   case DW_TAG_formal_parameter: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    SymbolFileDWARF *dwarf = die.GetMainDWARF();
     Type *type = GetTypeForDIE(die);
     if (dwarf && type) {
       const char *name = die.GetName();
       clang::DeclContext *decl_context =
           ClangASTContext::DeclContextGetAsDeclContext(
               dwarf->GetDeclContextContainingUID(die.GetID()));
       decl = m_ast.CreateVariableDeclaration(
           decl_context, name,
           ClangUtil::GetQualType(type->GetForwardCompilerType()));
     }
     break;
   }
   case DW_TAG_imported_declaration: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    SymbolFileDWARF *dwarf = die.GetMainDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
     if (imported_uid) {
       CompilerDecl imported_decl = imported_uid.GetDecl();
       if (imported_decl) {
         clang::DeclContext *decl_context =
             ClangASTContext::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
         if (clang::NamedDecl *clang_imported_decl =
                 llvm::dyn_cast<clang::NamedDecl>(
                     (clang::Decl *)imported_decl.GetOpaqueDecl()))
           decl =
               m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
       }
     }
     break;
   }
   case DW_TAG_imported_module: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    SymbolFileDWARF *dwarf = die.GetMainDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
 
     if (imported_uid) {
       CompilerDeclContext imported_decl_ctx = imported_uid.GetDeclContext();
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
             ClangASTContext::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
case DW_TAG_lexical_block:
       try_parsing_type = false;
       break;
 
     default:
       break;
     }
 
     if (decl_ctx == nullptr && try_parsing_type) {
-      Type *type = die.GetDWARF()->ResolveType(die);
+      Type *type = die.GetMainDWARF()->ResolveType(die);
       if (type)
         decl_ctx = GetCachedClangDeclContextForDIE(die);
     }
 
     if (decl_ctx) {
       LinkDeclContextToDIE(decl_ctx, die);
       return decl_ctx;
     }

source/Plugins/SymbolFile/DWARF/DWARFDIE.h

public:
 
   bool Supports_DW_AT_APPLE_objc_complete_type() const;
 
   //----------------------------------------------------------------------
   // Accessors
   //----------------------------------------------------------------------
   SymbolFileDWARF *GetDWARF() const;
 
+  // File which referenced DWZCommonFile (where this DIE may be located).
+  SymbolFileDWARF *GetMainDWARF() const;
+
   DWARFUnit *GetCU() const { return m_cu; }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
   DIERef GetDIERef() const;
 
   lldb_private::TypeSystem *GetTypeSystem() const;
 

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
   if (IsValid()) {
     DWARFUnit *cu = GetCU();
     SymbolFileDWARF *dwarf = cu->GetSymbolFileDWARF();
     const bool check_specification_or_abstract_origin = true;
     DWARFFormValue form_value;
     if (m_die->GetAttributeValue(dwarf, cu, attr, form_value, nullptr,
                                  check_specification_or_abstract_origin))
-      return dwarf->GetDIE(DIERef(form_value));
+      return cu->GetMainCU()->GetSymbolFileDWARF()
+          ->GetDIE(DIERef(form_value));
   }
   return DWARFDIE();
 }
 
 uint64_t DWARFDIE::GetAttributeValueAsReference(const dw_attr_t attr,
                                                 uint64_t fail_value) const {
   if (IsValid())
     return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr,
lldb_private::CompileUnit *DWARFDIE::GetLLDBCompileUnit() const {
   if (IsValid())
     return GetDWARF()->GetCompUnitForDWARFCompUnit(GetCU());
   else
     return nullptr;
 }
 
 lldb_private::Type *DWARFDIE::ResolveType() const {
   if (IsValid())
-    return GetDWARF()->ResolveType(*this, true);
+    return GetMainDWARF()->ResolveType(*this, true);
   else
     return nullptr;
 }
 
 lldb_private::Type *DWARFDIE::ResolveTypeUID(const DIERef &die_ref) const {
-  SymbolFileDWARF *dwarf = GetDWARF();
+  SymbolFileDWARF *dwarf = GetMainDWARF();
   if (dwarf)
     return dwarf->ResolveTypeUID(dwarf->GetDIE(die_ref), true);
   else
     return nullptr;
 }
 
 void DWARFDIE::GetDeclContextDIEs(DWARFDIECollection &decl_context_dies) const {
   if (IsValid()) {

 
 SymbolFileDWARF *DWARFDIE::GetDWARF() const {
   if (m_cu)
     return m_cu->GetSymbolFileDWARF();
   else
     return nullptr;
 }
 
+SymbolFileDWARF *DWARFDIE::GetMainDWARF() const {
+  if (m_cu)
+    return m_cu->GetMainCU()->GetSymbolFileDWARF();
+  else
+    return nullptr;
+}
+
 lldb_private::TypeSystem *DWARFDIE::GetTypeSystem() const {
   if (m_cu)
     return m_cu->GetTypeSystem();
   else
     return nullptr;
 }
 
 DWARFASTParser *DWARFDIE::GetDWARFParser() const {

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

if (m_cu_aranges_ap.get() == NULL && m_dwarf2Data) {
 
     // Manually build arange data for everything that wasn't in the
     // .debug_aranges table.
     bool printed = false;
     const size_t num_compile_units = GetNumCompileUnits();
     for (size_t idx = 0; idx < num_compile_units; ++idx) {
       DWARFUnit *cu = GetCompileUnitAtIndex(idx);
 
+      if (cu->GetMainCU() != cu)
+        continue;
       dw_offset_t offset = cu->GetOffset();
       if (cus_with_data.find(offset) == cus_with_data.end()) {
         if (log) {
           if (!printed)
             log->Printf(
                 "DWARFDebugInfo::GetCompileUnitAranges() for \"%s\" by parsing",
                 m_dwarf2Data->GetObjectFile()->GetFileSpec().GetPath().c_str());
           printed = true;
if (cu_idx == DW_INVALID_INDEX)
           "CU 0x%8.8" PRIx32 " cannot be found", cu_offset);
   }
   if (idx_ptr)
     *idx_ptr = cu_idx;
   return cu_sp.get();
 }
 
 DWARFUnit *DWARFDebugInfo::GetCompileUnit(const DIERef &die_ref) {
   if (die_ref.cu_offset == DW_INVALID_OFFSET)
     return GetCompileUnitContainingDIEOffset(die_ref.die_offset);
   else
     return GetCompileUnit(die_ref.cu_offset);
 }
 
 DWARFUnit *
 DWARFDebugInfo::GetCompileUnitContainingDIEOffset(dw_offset_t die_offset) {
   ParseCompileUnitHeadersIfNeeded();
 

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, const char *&name,
     const char *&mangled, DWARFRangeList &ranges, int &decl_file,
     int &decl_line, int &decl_column, int &call_file, int &call_line,
     int &call_column, DWARFExpression *frame_base) const {
   if (dwarf2Data == nullptr)
     return false;
 
   SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
   if (dwo_symbol_file)
     return GetDIENamesAndRanges(
         dwo_symbol_file, dwo_symbol_file->GetCompileUnit(), name, mangled,
         ranges, decl_file, decl_line, decl_column, call_file, call_line,
         call_column, frame_base);
 
   dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
   dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
   std::vector<DIERef> die_refs;
if (set_frame_base_loclist_addr) {
     dw_addr_t lowest_range_pc = ranges.GetMinRangeBase(0);
     assert(lowest_range_pc >= cu->GetBaseAddress());
     frame_base->SetLocationListSlide(lowest_range_pc - cu->GetBaseAddress());
   }
 
   if (ranges.IsEmpty() || name == NULL || mangled == NULL) {
     for (const DIERef &die_ref : die_refs) {
       if (die_ref.die_offset != DW_INVALID_OFFSET) {
-        DWARFDIE die = dwarf2Data->GetDIE(die_ref);
+        DWARFDIE die = cu->GetMainCU()->GetSymbolFileDWARF()
+            ->GetDIE(die_ref);
         if (die)
           die.GetDIE()->GetDIENamesAndRanges(
               die.GetDWARF(), die.GetCU(), name, mangled, ranges, decl_file,
               decl_line, decl_column, call_file, call_line, call_column);
       }
     }
   }
   return !ranges.IsEmpty();

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   bool IsDWARF64() const;
 
   bool GetIsOptimized();
 
   SymbolFileDWARFDwo *GetDwoSymbolFile() const;
 
   dw_offset_t GetBaseObjOffset() const;
 
+  // DW_TAG_compile_unit with DW_TAG_imported_unit for this DW_TAG_partial_unit.
+  DWARFUnit *GetMainCU() const {
+    return const_cast<DWARFUnit *>(this);
+  }
+
 protected:
   DWARFUnit(SymbolFileDWARF *dwarf);
 
   SymbolFileDWARF *m_dwarf = nullptr;
   std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
   const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr;
   void *m_user_data = nullptr;
   // The compile unit debug information entry item

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

if (clear_dies)
     ClearDIEs(true);
 }
 
 lldb::ByteOrder DWARFUnit::GetByteOrder() const {
   return m_dwarf->GetObjectFile()->GetByteOrder();
 }
 
 TypeSystem *DWARFUnit::GetTypeSystem() {
+  if (GetMainCU() != this)
+    return GetMainCU()->GetTypeSystem();
+
   if (m_dwarf)
     return m_dwarf->GetTypeSystemForLanguage(GetLanguageType());
   else
     return nullptr;
 }
 
 DWARFFormValue::FixedFormSizes DWARFUnit::GetFixedFormSizes() {
   return DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
if (ContainsDIEOffset(die_offset)) {
       if (pos != end) {
         if (die_offset == (*pos).GetOffset())
           return DWARFDIE(this, &(*pos));
       }
     } else {
       // Don't specify the compile unit offset as we don't know it because the
       // DIE belongs to
       // a different compile unit in the same symbol file.
-      return m_dwarf->DebugInfo()->GetDIEForDIEOffset(die_offset);
+      return GetMainCU()->m_dwarf->DebugInfo()->GetDIEForDIEOffset(die_offset);
     }
   }
   m_dwarf->GetObjectFile()->GetModule()->ReportError(
      "CU 0x%8.8" PRIx32 " does not contain DIE 0x%8.8" PRIx32,
      m_offset, die_offset);
   return DWARFDIE(); // Not found
 }
 
LanguageType DWARFUnit::LanguageTypeFromDWARF(uint64_t val) {
   case DW_LANG_GOOGLE_RenderScript:
     return eLanguageTypeExtRenderScript;
   default:
     return static_cast<LanguageType>(val);
   }
 }
 
 LanguageType DWARFUnit::GetLanguageType() {
+  if (GetMainCU() != this)
+    return GetMainCU()->GetLanguageType();
+
   if (m_language_type != eLanguageTypeUnknown)
     return m_language_type;
 
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
   if (die)
     m_language_type = LanguageTypeFromDWARF(
         die->GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_language, 0));
   return m_language_type;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
 
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
     // Just a normal DWARF file whose user ID for the compile unit is
     // the DWARF offset itself
 
     DWARFUnit *dwarf_cu =
         info->GetCompileUnit((dw_offset_t)comp_unit->GetID());
+    if (dwarf_cu)
+      dwarf_cu = dwarf_cu->GetMainCU();
     if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
       dwarf_cu->SetUserData(comp_unit);
     return dwarf_cu;
   }
   return NULL;
 }
 
 DWARFDebugRanges *SymbolFileDWARF::DebugRanges() {

 const DWARFDebugRanges *SymbolFileDWARF::DebugRanges() const {
   return m_ranges.get();
 }
 
 lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFUnit *dwarf_cu,
                                                    uint32_t cu_idx) {
   CompUnitSP cu_sp;
   if (dwarf_cu) {
+    dwarf_cu = dwarf_cu->GetMainCU();
     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
     if (comp_unit) {
       // We already parsed this compile unit, had out a shared pointer to it
       cu_sp = comp_unit->shared_from_this();
     } else {
       if (dwarf_cu->GetSymbolFileDWARF() != this) {
         return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu,
                                                                 cu_idx);

 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
   return ResolveType(GetDIE(die_ref), true);
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
                                       bool assert_not_being_parsed) {
+  // this can be neither die.GetDWARF() nor die.GetMainDWARF().
+  if (die.GetMainDWARF() != this)
+    return die.GetMainDWARF()->ResolveTypeUID(die, assert_not_being_parsed);
   if (die) {
     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
     if (log)
       GetObjectFile()->GetModule()->LogMessage(
           log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
 
     // We might be coming in in the middle of a type tree (a class
if (dwarf_ast)
       return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
   }
   return false;
 }
 
 Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
                                    bool assert_not_being_parsed,
                                    bool resolve_function_context) {
+  // this can be neither die.GetDWARF() nor die.GetMainDWARF().
+  if (die.GetMainDWARF() != this)
+    return die.GetMainDWARF()->ResolveType(
+        die, assert_not_being_parsed, resolve_function_context);
   if (die) {
     Type *type = GetTypeForDIE(die, resolve_function_context).get();
 
     if (assert_not_being_parsed) {
       if (type != DIE_IS_BEING_PARSED)
         return type;
 
       GetObjectFile()->GetModule()->ReportError(
           "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
 
     } else
       return type;
   }
   return nullptr;
 }
 
 CompileUnit *
 SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFUnit *dwarf_cu,
                                              uint32_t cu_idx) {
+  dwarf_cu = dwarf_cu->GetMainCU();
   // Check if the symbol vendor already knows about this compile unit?
   if (dwarf_cu->GetUserData() == NULL) {
     // The symbol vendor doesn't know about this compile unit, we
     // need to parse and add it to the symbol vendor object.
     return ParseCompileUnit(dwarf_cu, cu_idx).get();
   }
   return (CompileUnit *)dwarf_cu->GetUserData();
 }