[lldb] DWZ 09/17: Include main unit DWARFUnit * inside DWARFDIEs

[jankratochvil]

Summary

DWZ needs to know origin CU from where are current DW_TAG_Partial_Unit DIEs for example for current language or to generate UID. 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.

[labath]

I stopped looking after the first file, as the introduction of DWARF-ness to the CompileUnit class is a show-stopper. These classes are supposed to be independent of the actual format used to represent the data, and having them know anything about DWARF breaks that.
What's the reason for that? We already have a way to obtain the DWARFCompileUnit given a (generic) CompileUnit from within DWARF code (SymbolFileDWARF::GetDWARFCompileUnit). Given that your changes are (should be?) inside DWARF code, it's not clear to me why is that not sufficient (?)

[jankratochvil]

I will try to update it, I agree with your comment, thanks for the review.
I agree this first patch needs to be decided first before looking at the other parts 02..08.

[jankratochvil]

It breaks testsuite if both dwz and libc++ are installed. That is a bug of dwz itself, not a problem of this dwz-support-for-LLDB: Multifile drops DW_TAG_namespace::DW_AT_export_symbols

[jankratochvil]

OSX compatibility: DWARFCompileUnit::GetMainUnit

[jankratochvil]

Ping, it would be nice to know if there is some plan/schedule for patch review of this series. I understand it is all voluntary, thanks.

[labath]

I would love to do something about this, but currently I have no idea when I would be able to take on a review of this size. I know it's not what you wanted to hear. Sorry. :(

[jankratochvil]

That's sure fine, thanks for the reply. Great there is at least the plan to review it in the future. I understand you are busy.

[dblaikie]

If this is going to be plumbed through everywhere (ie: a DWARFDIE is mostly useless without both its lexical DWARFUnit and its imported-into DWARFUnit) then maybe it makes more sense to add this DWARFUnit* to the DWARFBaseDie type alongside the lexical DWARFUnit?

[clayborg]

Much of this patch requires all places that took a DWARFDie object now also must take an extra parameter. Is there really no way to have DWARFDie be able to discover the main unit via its contained DWARFUnit? DWARFDie objects are transient, so they can contain more information that just what they currently contain:

class DWARFDie {
  DWARFUnit *U = nullptr;
  const DWARFDebugInfoEntry *Die = nullptr;
};

Can we add a new "DWARFUnit *MU;" to the DWARFDie class? Is there really not way to ask the contained "U" DWARFUnit member for the main unit?

[jankratochvil]

In D96236#2705715, @dblaikie wrote:

(similar idea)

In D96236#2705920, @clayborg wrote:

Is there really not way to ask the contained "U" DWARFUnit member for the main unit?

There is no such way because one DWARFUnit can be used by multiple (in practice by two - DW_AT_language C plus C++) main units. You did ask it in D73206#1837138.

Can we add a new "DWARFUnit *MU;" to the DWARFDie class?

Been there, done that. It is the option 1 from text below. It cannot be applied (it was against the DWZ patch that time), just for an idea how it did work: https://people.redhat.com/jkratoch/dwz-DWARFUnitPair-2019-10-30.patch

 class DWARFBaseDIE {
-  DWARFUnit *m_cu;
+  DWARFUnitPair m_cu;
   DWARFDebugInfoEntry *m_die;
 };
+class DWARFUnitPair {
...
+  DWARFUnit *m_cu;
+  // For non-DWZ setups it is either equal to 'm_cu' or nullptr if 'm_cu' is a DWARFTypeUnit.
+  DWARFCompileUnit *m_main_cu;
+};

It was discussed in D73206 where was originally a different initial comment:

---

[...] proposing multiple possibilities how to satisfy DWZ's need for DWARFDIE::m_main_cu, could you choose one?

1. DWARFDIE 16B->24B does not matter as DWARFDIE is not stored anywhere - maybe one could use this patch in such case.
2. PointerUnion for DWARFDIE::m_cu so that DWARFDIE remains 16B without DWZ.

class DWARFBaseDIE {
  llvm::PointerUnion<DWARFUnit *, DWARFUnitPair *> m_cu;
  DWARFDebugInfoEntry *m_die;
};
class DWARFUnitPair {`
  DWARFUnit *m_cu;
  DWARFCompileUnit *m_main_cu;
};

3. (removed as I do not find nowadays enough to store just DW_LANG_* instead of the main unit pointer.)

---

The option 2 is fine as the double dereference performance impact (if any) affects only LLDB run on DWZ systems. And still LLDB with this little performance hit is much faster than the only existing debugger GDB for DWZ systems.

@labath did disagree in D73206#1836018 regarding the merge with LLVM DWARF. I cannot much talk about the merge as I do not know much the LLVM counterpart and so I haven't yet made any plan in my mind how to merge it.

Thanks for the comments.

[jankratochvil]

Just a rebase on top of trunk.

[clayborg]

I would be fine with DWARFDie getting bigger to 24B. These objects are used temporarily and not used as part of the storage of all of a DWARFUnit's DIEs. DWARFUnit objects store an array of DWARFDebugInfoEntry objects and those are what we care about not getting bigger.

[jankratochvil]

In D96236#2710376, @clayborg wrote:

I would be fine with DWARFDie getting bigger to 24B.

Great, so I can return back to 2019.

These objects are used temporarily and not used as part of the storage of all of a DWARFUnit's DIEs.

This is what I also found in D73206. There was originally a different initial comment:

---

I have found DWARFDIE is mostly used only for parameters and autovariables. I found (by grep -r '<.*DWARF\(Base\|\)DIE' lldb) only two cases of DWARFDIE in permanent structures:

• DWARFASTParserClang::m_decl_ctx_to_die refactored in this patch
• ElaboratingDIEIterator::m_worklist but I think it will never grow to any more DWARFDIEs than a few so it is worse to refactor it to DIERef which is slower and due to few entries it does not save any memory space.

---

For the DWARFASTParserClang::m_decl_ctx_to_die refactoring I will make it a standalone patch in a new series.

DWARFUnit objects store an array of DWARFDebugInfoEntry objects and those are what we care about not getting bigger.

The problem is I still need to increase element size of various indexes, such as:

-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
+  typedef llvm::DenseMap<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>, clang::Decl *>
       DIEToDeclMap;

I was thinking I could templatize it so that there are two variants of the code and it would switch to the larger + (a bit) slower variant only when it detects DWZ file. I understand it is bad to affect LLDB performance by the marginally used DWZ feature.

[jankratochvil]

This comment was removed by mehdi_amini.

[jankratochvil]

I will be no longer involved with this patchset.

lldb/include/lldb/Expression/DWARFExpression.h

 //===-- DWARFExpression.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_EXPRESSION_DWARFEXPRESSION_H
 #define LLDB_EXPRESSION_DWARFEXPRESSION_H
 
+#include "Plugins/SymbolFile/DWARF/DWARFUnitPair.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 #include <functional>
 
public:
   DWARFExpression();
 
   /// Constructor
   ///
   /// \param[in] data
   ///     A data extractor configured to read the DWARF location expression's
   ///     bytecode.
   DWARFExpression(lldb::ModuleSP module, const DataExtractor &data,
-                  const DWARFUnit *dwarf_cu);
+                  DWARFUnitPair dwarf_cu);
 
   /// Destructor
   virtual ~DWARFExpression();
 
   /// Print the description of the expression to a stream
   ///
   /// \param[in] s
   ///     The stream to print to.
public:
   /// \param[in] error_ptr
   ///     If non-NULL, used to report errors in expression evaluation.
   ///
   /// \return
   ///     True on success; false otherwise.  If error_ptr is non-NULL,
   ///     details of the failure are provided through it.
   static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                        lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
-                       const DWARFUnit *dwarf_cu,
-                       const lldb::RegisterKind reg_set,
+                       DWARFUnitPair dwarf_cu, const lldb::RegisterKind reg_set,
                        const Value *initial_value_ptr,
                        const Value *object_address_ptr, Value &result,
                        Status *error_ptr);
 
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
     return data.GetByteSize() > 0;
   }
private:
   lldb::ModuleWP m_module_wp;
 
   /// A data extractor capable of reading opcode bytes
   DataExtractor m_data;
 
   /// The DWARF compile unit this expression belongs to. It is used to evaluate
   /// values indexing into the .debug_addr section (e.g. DW_OP_GNU_addr_index,
   /// DW_OP_GNU_const_index)
-  const DWARFUnit *m_dwarf_cu = nullptr;
+  DWARFUnitPair m_dwarf_cu;
 
   /// One of the defines that starts with LLDB_REGKIND_
   lldb::RegisterKind m_reg_kind = lldb::eRegisterKindDWARF;
 
   struct LoclistAddresses {
     lldb::addr_t cu_file_addr;
     lldb::addr_t func_file_addr;
   };
   llvm::Optional<LoclistAddresses> m_loclist_addresses;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_EXPRESSION_DWARFEXPRESSION_H

lldb/source/Expression/DWARFExpression.cpp

ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
   return LLDB_INVALID_ADDRESS;
 }
 
 // DWARFExpression constructor
 DWARFExpression::DWARFExpression() : m_module_wp(), m_data() {}
 
 DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                                  const DataExtractor &data,
-                                 const DWARFUnit *dwarf_cu)
+                                 DWARFUnitPair dwarf_cu)
     : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu),
       m_reg_kind(eRegisterKindDWARF) {
   if (module_sp)
     m_module_wp = module_sp;
 }
 
 // Destructor
 DWARFExpression::~DWARFExpression() = default;
if (dwarf_cu && dwarf_cu->GetVersion() >= 4) {
     }
   }
 }
 } // namespace
 
 bool DWARFExpression::Evaluate(
     ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
     lldb::ModuleSP module_sp, const DataExtractor &opcodes,
-    const DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_kind,
+    DWARFUnitPair dwarf_cu, const lldb::RegisterKind reg_kind,
     const Value *initial_value_ptr, const Value *object_address_ptr,
     Value &result, Status *error_ptr) {
 
   if (opcodes.GetByteSize() == 0) {
     if (error_ptr)
       error_ptr->SetErrorString(
           "no location, value may have been optimized out");
     return false;
case DW_OP_convert: {
         bit_size = module_sp->GetArchitecture().GetAddressByteSize() * 8;
         if (!bit_size) {
           if (error_ptr)
             error_ptr->SetErrorString("unspecified architecture");
           return false;
         }
       } else {
         // Retrieve the type DIE that the value is being converted to.
-        // FIXME: the constness has annoying ripple effects.
-        DWARFDIE die = const_cast<DWARFUnit *>(dwarf_cu)->GetDIE(die_offset);
+        DWARFDIE die =
+            dwarf_cu.GetCU()->GetDIE(dwarf_cu.GetMainCU(), die_offset);
         if (!die) {
           if (error_ptr)
             error_ptr->SetErrorString("Cannot resolve DW_OP_convert type DIE");
           return false;
         }
         uint64_t encoding =
             die.GetAttributeValueAsUnsigned(DW_AT_encoding, DW_ATE_hi_user);
         bit_size = die.GetAttributeValueAsUnsigned(DW_AT_byte_size, 0) * 8;

lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   DWARFDebugInfoEntry.cpp
   DWARFDebugMacro.cpp
   DWARFDebugRanges.cpp
   DWARFDeclContext.cpp
   DWARFDefines.cpp
   DWARFDIE.cpp
   DWARFFormValue.cpp
   DWARFIndex.cpp
+  DWARFSimpleDIE.cpp
   DWARFTypeUnit.cpp
   DWARFUnit.cpp
+  DWARFUnitPair.cpp
   HashedNameToDIE.cpp
   LogChannelDWARF.cpp
   ManualDWARFIndex.cpp
   NameToDIE.cpp
   SymbolFileDWARF.cpp
   SymbolFileDWARFDwo.cpp
   SymbolFileDWARFDebugMap.cpp
   UniqueDWARFASTType.cpp

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

 //===-- DWARFASTParserClang.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdlib>
 
 #include "DWARFASTParserClang.h"
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDeclContext.h"
 #include "DWARFDefines.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 #include "UniqueDWARFASTType.h"
 

 
 static lldb::ModuleSP GetContainingClangModule(const DWARFDIE &die) {
   if (die.IsValid()) {
     DWARFDIE clang_module_die = GetContainingClangModuleDIE(die);
 
     if (clang_module_die) {
       const char *module_name = clang_module_die.GetName();
       if (module_name)
-        return die.GetDWARF()->GetExternalModule(
+        return die.GetMainDWARF()->GetExternalModule(
             lldb_private::ConstString(module_name));
     }
   }
   return lldb::ModuleSP();
 }
 
 TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
                                                      const DWARFDIE &die,
                                                      Log *log) {
   ModuleSP clang_module_sp = GetContainingClangModule(die);
   if (!clang_module_sp)
     return TypeSP();
 
   // If this type comes from a Clang module, recursively look in the
   // DWARF section of the .pcm file in the module cache. Clang
   // generates DWO skeleton units as breadcrumbs to find them.
   llvm::SmallVector<CompilerContext, 4> decl_context;
   die.GetDeclContext(decl_context);
   TypeMap pcm_types;
 
   // The type in the Clang module must have the same language as the current CU.
   LanguageSet languages;
-  languages.Insert(SymbolFileDWARF::GetLanguageFamily(*die.GetCU()));
+  languages.Insert(SymbolFileDWARF::GetLanguageFamily(*die.GetMainCU()));
   llvm::DenseSet<SymbolFile *> searched_symbol_files;
   clang_module_sp->GetSymbolFile()->FindTypes(decl_context, languages,
                                               searched_symbol_files, pcm_types);
   if (pcm_types.Empty()) {
     // Since this type is defined in one of the Clang modules imported
     // by this symbol file, search all of them. Instead of calling
     // sym_file->FindTypes(), which would return this again, go straight
     // to the imported modules.
-    auto &sym_file = die.GetCU()->GetSymbolFileDWARF();
+    auto &sym_file = die.GetMainCU()->GetSymbolFileDWARF();
 
     // Well-formed clang modules never form cycles; guard against corrupted
     // ones by inserting the current file.
     searched_symbol_files.insert(&sym_file);
     sym_file.ForEachExternalModule(
         *sc.comp_unit, searched_symbol_files, [&](Module &module) {
           module.GetSymbolFile()->FindTypes(decl_context, languages,
                                             searched_symbol_files, pcm_types);
TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
   // Type::ResolveClangType() effectively ignores the ResolveState
   // inside type_sp and only looks at IsDefined(), so it never calls
   // ClangASTImporter::ASTImporterDelegate::ImportDefinitionTo(),
   // which does extra work for Objective-C classes. This would result
   // in only the forward declaration to be visible.
   if (pcm_type.IsDefined())
     GetClangASTImporter().RequireCompleteType(ClangUtil::GetQualType(type));
 
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
   TypeSP type_sp(new Type(die.GetID(), dwarf, pcm_type_sp->GetName(),
                           pcm_type_sp->GetByteSize(nullptr), nullptr,
                           LLDB_INVALID_UID, Type::eEncodingInvalid,
                           &pcm_type_sp->GetDeclaration(), type,
                           Type::ResolveState::Forward,
                           TypePayloadClang(GetOwningClangModule(die))));
 
   dwarf->GetTypeList().Insert(type_sp);
static void PrepareContextToReceiveMembers(TypeSystemClang &ast,
   // gmodules case), we can complete the type by doing a full import.
 
   // If this type was not imported from an external AST, there's nothing to do.
   CompilerType type = ast.GetTypeForDecl(tag_decl_ctx);
   if (type && ast_importer.CanImport(type)) {
     auto qual_type = ClangUtil::GetQualType(type);
     if (ast_importer.RequireCompleteType(qual_type))
       return;
-    die.GetDWARF()->GetObjectFile()->GetModule()->ReportError(
+    die.GetMainDWARF()->GetObjectFile()->GetModule()->ReportError(
         "Unable to complete the Decl context for DIE '%s' at offset "
         "0x%8.8x.\nPlease file a bug report.",
         type_name_cstr ? type_name_cstr : "", die.GetOffset());
   }
 
   // We don't have a type definition and/or the import failed. We must
   // forcefully complete the type to avoid crashes.
   ForcefullyCompleteType(type);
case DW_AT_MIPS_linkage_name:
       mangled_name = form_value.AsCString();
       break;
 
     case DW_AT_name:
       name.SetCString(form_value.AsCString());
       break;
 
     case DW_AT_object_pointer:
-      object_pointer = form_value.Reference();
+      object_pointer = form_value.Reference(die.GetMainCU());
       break;
 
     case DW_AT_signature:
       signature = form_value;
       break;
 
     case DW_AT_specification:
       specification = form_value;
for (size_t i = 0; i < num_attributes; ++i) {
     case DW_AT_export_symbols:
       exports_symbols = form_value.Boolean();
       break;
     }
   }
 }
 
 static std::string GetUnitName(const DWARFDIE &die) {
-  if (DWARFUnit *unit = die.GetCU())
+  if (DWARFUnit *unit = die.GetCU().GetCU())
     return unit->GetAbsolutePath().GetPath();
   return "<missing DWARF unit path>";
 }
 
 TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
                                                const DWARFDIE &die,
                                                bool *type_is_new_ptr) {
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (!die)
     return nullptr;
 
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
 
-  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,
         "DWARFASTParserClang::ParseTypeFromDWARF "
         "(die = 0x%8.8x, decl_ctx = %p (die 0x%8.8x)) %s name = '%s')",
         die.GetOffset(), static_cast<void *>(context), context_die.GetOffset(),
         die.GetTagAsCString(), die.GetName());
   }
 
   DIERef dieref = *die.GetDIERef();
   Type *type_ptr = dwarf->GetDIERefToType().lookup(dieref);
   if (type_ptr == DIE_IS_BEING_PARSED)
     return nullptr;
   if (type_ptr)
     return type_ptr->shared_from_this();
   // Set a bit that lets us know that we are currently parsing this
   dwarf->GetDIERefToType()[dieref] = DIE_IS_BEING_PARSED;
 
   ParsedDWARFTypeAttributes attrs(die);
 
-  if (DWARFDIE signature_die = attrs.signature.Reference()) {
+  if (DWARFDIE signature_die = attrs.signature.Reference(die.GetMainCU())) {
     if (TypeSP type_sp =
             ParseTypeFromDWARF(sc, signature_die, type_is_new_ptr)) {
       dwarf->GetDIERefToType()[dieref] = type_sp.get();
       if (clang::DeclContext *decl_ctx =
               GetCachedClangDeclContextForDIE(signature_die))
         LinkDeclContextToDIE(decl_ctx, die);
       return type_sp;
     }

 }
 
 lldb::TypeSP
 DWARFASTParserClang::ParseTypeModifier(const SymbolContext &sc,
                                        const DWARFDIE &die,
                                        ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
   const dw_tag_t tag = die.Tag();
-  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
+  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetMainCU());
   Type::ResolveState resolve_state = Type::ResolveState::Unresolved;
   Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
   TypeSP type_sp;
   CompilerType clang_type;
 
   if (tag == DW_TAG_typedef) {
     // DeclContext will be populated when the clang type is materialized in
     // Type::ResolveCompilerType.
if (attrs.type.IsValid()) {
       //
       // If we don't do this we end up creating a TypeSP that says
       // this is a typedef to type 0x123 (the DW_AT_type value would
       // be 0x123 in the DW_TAG_typedef), and this is the unnamed
       // structure type. We will have a hard time tracking down an
       // unnammed structure type in the module debug info, so we make
       // sure we don't get into this situation by always resolving
       // typedefs from the module.
-      const DWARFDIE encoding_die = attrs.type.Reference();
+      const DWARFDIE encoding_die = attrs.type.Reference(die.GetMainCU());
 
       // First make sure that the die that this is typedef'ed to _is_
       // just a declaration (DW_AT_declaration == 1), not a full
       // definition since template types can't be represented in
       // modules since only concrete instances of templates are ever
       // emitted and modules won't contain those
       if (encoding_die &&
           encoding_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) == 1) {
         type_sp = ParseTypeFromClangModule(sc, die, log);
         if (type_sp)
           return type_sp;
       }
     }
   }
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\") type => 0x%8.8lx\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr,
-               encoding_uid.Reference());
+               encoding_uid.Reference(die.GetMainCU()));
 
   switch (tag) {
   default:
     break;
 
   case DW_TAG_unspecified_type:
     if (attrs.name == "nullptr_t" || attrs.name == "decltype(nullptr)") {
       resolve_state = Type::ResolveState::Full;
if (cu_language == eLanguageTypeObjC ||
           attrs.type.Clear();
           resolve_state = Type::ResolveState::Full;
         }
       } else if (encoding_data_type == Type::eEncodingIsPointerUID &&
                  attrs.type.IsValid()) {
         // Clang sometimes erroneously emits id as objc_object*.  In that
         // case we fix up the type to "id".
 
-        const DWARFDIE encoding_die = attrs.type.Reference();
+        const DWARFDIE encoding_die = attrs.type.Reference(die.GetMainCU());
 
         if (encoding_die && encoding_die.Tag() == DW_TAG_structure_type) {
           llvm::StringRef struct_name = encoding_die.GetName();
           if (struct_name == "objc_object") {
             if (log)
               dwarf->GetObjectFile()->GetModule()->LogMessage(
                   log,
                   "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s "
                   "'%s' is 'objc_object*', which we overrode to "
                   "'id'.",
                   die.GetOffset(), die.GetTagAsCString(), die.GetName());
             clang_type = m_ast.GetBasicType(eBasicTypeObjCID);
             encoding_data_type = Type::eEncodingIsUID;
             attrs.type.Clear();
             resolve_state = Type::ResolveState::Full;
           }
         }
       }
     }
   }
 
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
-      dwarf->GetUID(attrs.type.Reference()), encoding_data_type, &attrs.decl,
-      clang_type, resolve_state, TypePayloadClang(GetOwningClangModule(die)));
+      dwarf->GetUID(attrs.type.Reference(die.GetMainCU())), encoding_data_type,
+      &attrs.decl, clang_type, resolve_state,
+      TypePayloadClang(GetOwningClangModule(die)));
 
   dwarf->GetDIERefToType()[*die.GetDIERef()] = type_sp.get();
   return type_sp;
 }
 
 TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
                                       const DWARFDIE &die,
                                       ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
   const dw_tag_t tag = die.Tag();
   TypeSP type_sp;
 
   if (attrs.is_forward_declaration) {
     type_sp = ParseTypeFromClangModule(sc, die, log);
     if (type_sp)
       return type_sp;
 
TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
   CompilerType enumerator_clang_type;
   CompilerType clang_type;
   clang_type.SetCompilerType(
       &m_ast,
       dwarf->GetForwardDeclDIERefToClangType().lookup(*die.GetDIERef()));
   if (!clang_type) {
     if (attrs.type.IsValid()) {
       Type *enumerator_type =
-          dwarf->ResolveTypeUID(attrs.type.Reference(), true);
+          dwarf->ResolveTypeUID(attrs.type.Reference(die.GetMainCU()), true);
       if (enumerator_type)
         enumerator_clang_type = enumerator_type->GetFullCompilerType();
     }
 
     if (!enumerator_clang_type) {
       if (attrs.byte_size) {
         enumerator_clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize(
             "", DW_ATE_signed, *attrs.byte_size * 8);
TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
   } else {
     enumerator_clang_type = m_ast.GetEnumerationIntegerType(clang_type);
   }
 
   LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type), die);
 
   type_sp = std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
-      dwarf->GetUID(attrs.type.Reference()), Type::eEncodingIsUID, &attrs.decl,
-      clang_type, Type::ResolveState::Forward,
-      TypePayloadClang(GetOwningClangModule(die)));
+      dwarf->GetUID(attrs.type.Reference(die.GetMainCU())),
+      Type::eEncodingIsUID, &attrs.decl, clang_type,
+      Type::ResolveState::Forward, TypePayloadClang(GetOwningClangModule(die)));
 
   if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     if (die.HasChildren()) {
       bool is_signed = false;
       enumerator_clang_type.IsIntegerType(is_signed);
       ParseChildEnumerators(clang_type, is_signed,
                             type_sp->GetByteSize(nullptr).getValueOr(0), die);
     }
     TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   } else {
     dwarf->GetObjectFile()->GetModule()->ReportError(
         "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
         "definition.\nPlease file a bug and attach the file at the "
         "start of this error message",
         die.GetOffset(), attrs.name.GetCString());
   }
   return type_sp;
 }
 
 TypeSP DWARFASTParserClang::ParseSubroutine(const DWARFDIE &die,
                            ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
 
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
   const dw_tag_t tag = die.Tag();
 
   bool is_variadic = false;
   bool is_static = false;
   bool has_template_params = false;
 
   unsigned type_quals = 0;
 
   std::string object_pointer_name;
   if (attrs.object_pointer) {
     const char *object_pointer_name_cstr = attrs.object_pointer.GetName();
     if (object_pointer_name_cstr)
       object_pointer_name = object_pointer_name_cstr;
   }
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
   CompilerType return_clang_type;
   Type *func_type = NULL;
 
   if (attrs.type.IsValid())
-    func_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true);
+    func_type =
+        dwarf->ResolveTypeUID(attrs.type.Reference(die.GetMainCU()), true);
 
   if (func_type)
     return_clang_type = func_type->GetForwardCompilerType();
   else
     return_clang_type = m_ast.GetBasicType(eBasicTypeVoid);
 
   std::vector<CompilerType> function_param_types;
   std::vector<clang::ParmVarDecl *> function_param_decls;
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
             // We have a specification which we are going to base our
             // function prototype off of, so we need this type to be
             // completed so that the m_dieref_to_decl_ctx for the method in
             // the specification has a valid clang decl context.
             class_type->GetForwardCompilerType();
             // If we have a specification, then the function type should
             // have been made with the specification and not with this
             // die.
-            DWARFDIE spec_die = attrs.specification.Reference();
+            DWARFDIE spec_die = attrs.specification.Reference(die.GetMainCU());
             clang::DeclContext *spec_clang_decl_ctx =
                 GetClangDeclContextForDIE(spec_die);
             if (spec_clang_decl_ctx) {
               LinkDeclContextToDIE(spec_clang_decl_ctx, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x"
                   ") has no decl\n",
                   die.GetID(), spec_die.GetOffset());
             }
             type_handled = true;
           } else if (attrs.abstract_origin.IsValid()) {
             // We have a specification which we are going to base our
             // function prototype off of, so we need this type to be
             // completed so that the m_dieref_to_decl_ctx for the method in
             // the abstract origin has a valid clang decl context.
             class_type->GetForwardCompilerType();
 
-            DWARFDIE abs_die = attrs.abstract_origin.Reference();
+            DWARFDIE abs_die = attrs.abstract_origin.Reference(die.GetMainCU());
             clang::DeclContext *abs_clang_decl_ctx =
                 GetClangDeclContextForDIE(abs_die);
             if (abs_clang_decl_ctx) {
               LinkDeclContextToDIE(abs_clang_decl_ctx, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x"
                   ") has no decl\n",
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
       }
     }
 
     if (!type_handled) {
       clang::FunctionDecl *function_decl = nullptr;
       clang::FunctionDecl *template_function_decl = nullptr;
 
       if (attrs.abstract_origin.IsValid()) {
-        DWARFDIE abs_die = attrs.abstract_origin.Reference();
+        DWARFDIE abs_die = attrs.abstract_origin.Reference(die.GetMainCU());
 
         if (dwarf->ResolveType(abs_die)) {
           function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(
               GetCachedClangDeclContextForDIE(abs_die));
 
           if (function_decl) {
             LinkDeclContextToDIE(function_decl, die);
           }
TypeSP DWARFASTParserClang::ParseSubroutine(const DWARFDIE &die,
   }
   return std::make_shared<Type>(
       die.GetID(), dwarf, attrs.name, llvm::None, nullptr, LLDB_INVALID_UID,
       Type::eEncodingIsUID, &attrs.decl, clang_type, Type::ResolveState::Full);
 }
 
 TypeSP DWARFASTParserClang::ParseArrayType(const DWARFDIE &die,
                                            ParsedDWARFTypeAttributes &attrs) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
-  DWARFDIE type_die = attrs.type.Reference();
+  DWARFDIE type_die = attrs.type.Reference(die.GetMainCU());
   Type *element_type = dwarf->ResolveTypeUID(type_die, true);
 
   if (!element_type)
     return nullptr;
 
   llvm::Optional<SymbolFile::ArrayInfo> array_info = ParseChildArrayInfo(die);
   if (array_info) {
     attrs.byte_stride = array_info->byte_stride;
TypeSP DWARFASTParserClang::ParseArrayType(const DWARFDIE &die,
   type_sp->SetEncodingType(element_type);
   const clang::Type *type = ClangUtil::GetQualType(clang_type).getTypePtr();
   m_ast.SetMetadataAsUserID(type, die.GetID());
   return type_sp;
 }
 
 TypeSP DWARFASTParserClang::ParsePointerToMemberType(
     const DWARFDIE &die, const ParsedDWARFTypeAttributes &attrs) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
-  Type *pointee_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true);
-  Type *class_type =
-      dwarf->ResolveTypeUID(attrs.containing_type.Reference(), true);
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
+  Type *pointee_type =
+      dwarf->ResolveTypeUID(attrs.type.Reference(die.GetMainCU()), true);
+  Type *class_type = dwarf->ResolveTypeUID(
+      attrs.containing_type.Reference(die.GetMainCU()), true);
 
   CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType();
   CompilerType class_clang_type = class_type->GetForwardCompilerType();
 
   CompilerType clang_type = TypeSystemClang::CreateMemberPointerType(
       class_clang_type, pointee_clang_type);
 
   if (llvm::Optional<uint64_t> clang_type_size =
           clang_type.GetByteSize(nullptr)) {
     return std::make_shared<Type>(die.GetID(), dwarf, attrs.name,
                                   *clang_type_size, nullptr, LLDB_INVALID_UID,
                                   Type::eEncodingIsUID, nullptr, clang_type,
                                   Type::ResolveState::Forward);
   }
   return nullptr;
 }
 
 TypeSP DWARFASTParserClang::UpdateSymbolContextScopeForType(
     const SymbolContext &sc, const DWARFDIE &die, TypeSP type_sp) {
   if (!type_sp)
     return type_sp;
 
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
   TypeList &type_list = dwarf->GetTypeList();
   DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
   dw_tag_t sc_parent_tag = sc_parent_die.Tag();
 
   SymbolContextScope *symbol_context_scope = nullptr;
   if (sc_parent_tag == DW_TAG_compile_unit ||
       sc_parent_tag == DW_TAG_partial_unit) {
     symbol_context_scope = sc.comp_unit;

 
 TypeSP
 DWARFASTParserClang::ParseStructureLikeDIE(const SymbolContext &sc,
                                            const DWARFDIE &die,
                                            ParsedDWARFTypeAttributes &attrs) {
   TypeSP type_sp;
   CompilerType clang_type;
   const dw_tag_t tag = die.Tag();
-  SymbolFileDWARF *dwarf = die.GetDWARF();
-  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
+  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetMainCU());
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_TYPE_COMPLETION |
                                           DWARF_LOG_LOOKUPS);
 
   // UniqueDWARFASTType is large, so don't create a local variables on the
   // stack, put it on the heap. This function is often called recursively and
   // clang isn't good at sharing the stack space for variables in different
   // blocks.
   auto unique_ast_entry_up = std::make_unique<UniqueDWARFASTType>();
if (num_attributes > 0) {
 
         case DW_AT_GNU_template_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             template_name = form_value.AsCString();
           break;
 
         case DW_AT_type:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
-            Type *lldb_type = die.ResolveTypeUID(form_value.Reference());
+            Type *lldb_type =
+                die.ResolveTypeUID(form_value.Reference(die.GetMainCU()));
             if (lldb_type)
               clang_type = lldb_type->GetForwardCompilerType();
           }
           break;
 
         case DW_AT_const_value:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             uval64_valid = true;
bool DWARFASTParserClang::ParseTemplateParameterInfos(
   }
   return template_param_infos.args.size() == template_param_infos.names.size();
 }
 
 bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
                                              lldb_private::Type *type,
                                              CompilerType &clang_type) {
   const dw_tag_t tag = die.Tag();
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
 
   ClangASTImporter::LayoutInfo layout_info;
 
   if (die.HasChildren()) {
     const bool type_is_objc_object_or_interface =
         TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type);
     if (type_is_objc_object_or_interface) {
       // For objective C we don't start the definition when the class is
if (die.HasChildren()) {
     // Now parse any methods if there were any...
     for (const DWARFDIE &die : member_function_dies)
       dwarf->ResolveType(die);
 
     if (type_is_objc_object_or_interface) {
       ConstString class_name(clang_type.GetTypeName());
       if (class_name) {
         dwarf->GetObjCMethods(class_name, [&](DWARFDIE method_die) {
-          method_die.ResolveType();
+          method_die.ResolveType(*dwarf);
           return true;
         });
 
         for (DelayedPropertyList::iterator pi = delayed_properties.begin(),
                                            pe = delayed_properties.end();
              pi != pe; ++pi)
           pi->Finalize();
       }
if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   }
   return (bool)clang_type;
 }
 
 bool DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die,
                                                 lldb_private::Type *type,
                                                 CompilerType &clang_type) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
 
   std::lock_guard<std::recursive_mutex> guard(
       dwarf->GetObjectFile()->GetModule()->GetMutex());
 
   // Disable external storage for this type so we don't get anymore
   // clang::ExternalASTSource queries for this type.
   m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), false);
 
if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
 
     if (func_range.GetBaseAddress().IsValid()) {
       Mangled func_name;
       if (mangled)
         func_name.SetValue(ConstString(mangled), true);
       else if ((die.GetParent().Tag() == DW_TAG_compile_unit ||
                 die.GetParent().Tag() == DW_TAG_partial_unit) &&
                Language::LanguageIsCPlusPlus(
-                   SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
+                   SymbolFileDWARF::GetLanguage(*die.GetMainCU())) &&
                !Language::LanguageIsObjC(
-                   SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
+                   SymbolFileDWARF::GetLanguage(*die.GetMainCU())) &&
                name && strcmp(name, "main") != 0) {
         // If the mangled name is not present in the DWARF, generate the
         // demangled name using the decl context. We skip if the function is
         // "main" as its name is never mangled.
         bool is_static = false;
         bool is_variadic = false;
         bool has_template_params = false;
         unsigned type_quals = 0;
if (func_range.GetBaseAddress().IsValid()) {
         func_name.SetValue(ConstString(name), false);
 
       FunctionSP func_sp;
       std::unique_ptr<Declaration> decl_up;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_up = std::make_unique<Declaration>(die.GetCU()->GetFile(decl_file),
                                                 decl_line, decl_column);
 
-      SymbolFileDWARF *dwarf = die.GetDWARF();
+      SymbolFileDWARF *dwarf = die.GetMainDWARF();
       // Supply the type _only_ if it has already been parsed
       Type *func_type = dwarf->GetDIERefToType().lookup(*die.GetDIERef());
 
       assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
         func_sp =

 
 void DWARFASTParserClang::ParseSingleMember(
     const DWARFDIE &die, const DWARFDIE &parent_die,
     const lldb_private::CompilerType &class_clang_type,
     lldb::AccessType default_accessibility,
     DelayedPropertyList &delayed_properties,
     lldb_private::ClangASTImporter::LayoutInfo &layout_info,
     FieldInfo &last_field_info) {
-  ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
+  ModuleSP module_sp = parent_die.GetMainDWARF()->GetObjectFile()->GetModule();
   const dw_tag_t tag = die.Tag();
   // Get the parent byte size so we can verify any members will fit
   const uint64_t parent_byte_size =
       parent_die.GetAttributeValueAsUnsigned(DW_AT_byte_size, UINT64_MAX);
   const uint64_t parent_bit_size =
       parent_byte_size == UINT64_MAX ? UINT64_MAX : parent_byte_size * 8;
 
   DWARFAttributes attributes;
const bool class_is_objc_object_or_interface =
       TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type);
 
   // FIXME: Make Clang ignore Objective-C accessibility for expressions
   if (class_is_objc_object_or_interface)
     accessibility = eAccessNone;
 
   // Handle static members
   if (is_external && member_byte_offset == UINT32_MAX) {
-    Type *var_type = die.ResolveTypeUID(encoding_form.Reference());
+    Type *var_type =
+        die.ResolveTypeUID(encoding_form.Reference(die.GetMainCU()));
 
     if (var_type) {
       if (accessibility == eAccessNone)
         accessibility = eAccessPublic;
       TypeSystemClang::AddVariableToRecordType(
           class_clang_type, name, var_type->GetForwardCompilerType(),
           accessibility);
     }
     return;
   }
 
   if (!is_artificial) {
-    Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
+    Type *member_type =
+        die.ResolveTypeUID(encoding_form.Reference(die.GetMainCU()));
 
     clang::FieldDecl *field_decl = nullptr;
     const uint64_t character_width = 8;
     const uint64_t word_width = 32;
     if (tag == DW_TAG_member) {
       if (member_type) {
         CompilerType member_clang_type = member_type->GetLayoutCompilerType();
 
if (tag == DW_TAG_member) {
           this_field_info.bit_size = bit_size;
 
           if (data_bit_offset != UINT64_MAX) {
             this_field_info.bit_offset = data_bit_offset;
           } else {
             if (!byte_size)
               byte_size = member_type->GetByteSize(nullptr);
 
-            ObjectFile *objfile = die.GetDWARF()->GetObjectFile();
+            ObjectFile *objfile = die.GetMainDWARF()->GetObjectFile();
             if (objfile->GetByteOrder() == eByteOrderLittle) {
               this_field_info.bit_offset += byte_size.getValueOr(0) * 8;
               this_field_info.bit_offset -= (bit_offset + bit_size);
             } else {
               this_field_info.bit_offset += bit_offset;
             }
           }
 
           // The ObjC runtime knows the byte offset but we still need to provide
           // the bit-offset in the layout. It just means something different then
           // what it does in C and C++. So we skip this check for ObjC types.
           //
           // We also skip this for fields of a union since they will all have a
           // zero offset.
           if (!TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type) &&
               !(parent_die.Tag() == DW_TAG_union_type && this_field_info.bit_offset == 0) &&
               ((this_field_info.bit_offset >= parent_bit_size) ||
                (last_field_info.IsBitfield() &&
                 !last_field_info.NextBitfieldOffsetIsValid(
                     this_field_info.bit_offset)))) {
-            ObjectFile *objfile = die.GetDWARF()->GetObjectFile();
+            ObjectFile *objfile = die.GetMainDWARF()->GetObjectFile();
             objfile->GetModule()->ReportWarning(
                 "0x%8.8" PRIx64 ": %s bitfield named \"%s\" has invalid "
                 "bit offset (0x%8.8" PRIx64
                 ") member will be ignored. Please file a bug against the "
                 "compiler and include the preprocessed output for %s\n",
                 die.GetID(), DW_TAG_value_to_name(tag), name,
                 this_field_info.bit_offset, GetUnitName(parent_die).c_str());
             return;
if (tag == DW_TAG_member) {
             if (member_byte_offset >= parent_byte_size) {
               if (member_array_size != 1 &&
                   (member_array_size != 0 ||
                    member_byte_offset > parent_byte_size)) {
                 module_sp->ReportError(
                     "0x%8.8" PRIx64
                     ": DW_TAG_member '%s' refers to type 0x%8.8x"
                     " which extends beyond the bounds of 0x%8.8" PRIx64,
-                    die.GetID(), name, encoding_form.Reference().GetOffset(),
+                    die.GetID(), name,
+                    encoding_form.Reference(die.GetMainCU()).GetOffset(),
                     parent_die.GetID());
               }
 
               member_clang_type =
                   m_ast.CreateArrayType(member_array_element_type, 0, false);
             }
           }
         }
 
         RequireCompleteType(member_clang_type);
 
         field_decl = TypeSystemClang::AddFieldToRecordType(
             class_clang_type, name, member_clang_type, accessibility,
             bit_size);
 
         m_ast.SetMetadataAsUserID(field_decl, die.GetID());
 
         layout_info.field_offsets.insert(
             std::make_pair(field_decl, field_bit_offset));
       } else {
         if (name)
           module_sp->ReportError(
               "0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8x"
               " which was unable to be parsed",
-              die.GetID(), name, encoding_form.Reference().GetOffset());
+              die.GetID(), name,
+              encoding_form.Reference(die.GetMainCU()).GetOffset());
         else
           module_sp->ReportError(
               "0x%8.8" PRIx64 ": DW_TAG_member refers to type 0x%8.8x"
               " which was unable to be parsed",
-              die.GetID(), encoding_form.Reference().GetOffset());
+              die.GetID(),
+              encoding_form.Reference(die.GetMainCU()).GetOffset());
       }
     }
 
     if (prop_name != nullptr && member_type) {
       clang::ObjCIvarDecl *ivar_decl = nullptr;
 
       if (field_decl) {
         ivar_decl = clang::dyn_cast<clang::ObjCIvarDecl>(field_decl);
bool DWARFASTParserClang::ParseChildMembers(
     std::vector<DWARFDIE> &member_function_dies,
     DelayedPropertyList &delayed_properties, AccessType &default_accessibility,
     ClangASTImporter::LayoutInfo &layout_info) {
   if (!parent_die)
     return false;
 
   FieldInfo last_field_info;
 
-  ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
+  ModuleSP module_sp = parent_die.GetMainDWARF()->GetObjectFile()->GetModule();
   TypeSystemClang *ast =
       llvm::dyn_cast_or_null<TypeSystemClang>(class_clang_type.GetTypeSystem());
   if (ast == nullptr)
     return false;
 
   for (DWARFDIE die : parent_die.children()) {
     dw_tag_t tag = die.Tag();
 
case DW_TAG_inheritance: {
               break;
 
             default:
               break;
             }
           }
         }
 
-        Type *base_class_type = die.ResolveTypeUID(encoding_form.Reference());
+        Type *base_class_type =
+            die.ResolveTypeUID(encoding_form.Reference(die.GetMainCU()));
         if (base_class_type == nullptr) {
-          module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to "
-                                 "resolve the base class at 0x%8.8x"
-                                 " from enclosing type 0x%8.8x. \nPlease file "
-                                 "a bug and attach the file at the start of "
-                                 "this error message",
-                                 die.GetOffset(),
-                                 encoding_form.Reference().GetOffset(),
-                                 parent_die.GetOffset());
+          module_sp->ReportError(
+              "0x%8.8x: DW_TAG_inheritance failed to "
+              encoding_form.Reference(die.GetMainCU()).GetOffset(),
           break;
         }
 
         CompilerType base_class_clang_type =
             base_class_type->GetFullCompilerType();
         assert(base_class_clang_type);
         if (TypeSystemClang::IsObjCObjectOrInterfaceType(class_clang_type)) {
           ast->SetObjCSuperClass(class_clang_type, base_class_clang_type);
case DW_TAG_formal_parameter: {
           // In order to determine if a C++ member function is "const" we
           // have to look at the const-ness of "this"...
           if (arg_idx == 0 &&
               DeclKindIsCXXClass(containing_decl_ctx->getDeclKind()) &&
               // Often times compilers omit the "this" name for the
               // specification DIEs, so we can't rely upon the name being in
               // the formal parameter DIE...
               (name == nullptr || ::strcmp(name, "this") == 0)) {
-            Type *this_type =
-                die.ResolveTypeUID(param_type_die_form.Reference());
+            Type *this_type = die.ResolveTypeUID(
+                param_type_die_form.Reference(die.GetMainCU()));
             if (this_type) {
               uint32_t encoding_mask = this_type->GetEncodingMask();
               if (encoding_mask & Type::eEncodingIsPointerUID) {
                 is_static = false;
 
                 if (encoding_mask & (1u << Type::eEncodingIsConstUID))
                   type_quals |= clang::Qualifiers::Const;
                 if (encoding_mask & (1u << Type::eEncodingIsVolatileUID))
                   type_quals |= clang::Qualifiers::Volatile;
               }
             }
           }
           skip = true;
         }
 
         if (!skip) {
-          Type *type = die.ResolveTypeUID(param_type_die_form.Reference());
+          Type *type = die.ResolveTypeUID(
+              param_type_die_form.Reference(die.GetMainCU()));
           if (type) {
             function_param_types.push_back(type->GetForwardCompilerType());
 
             clang::ParmVarDecl *param_var_decl =
                 m_ast.CreateParameterDeclaration(
                     containing_decl_ctx, GetOwningClangModule(die), name,
                     type->GetForwardCompilerType(), storage);
             assert(param_var_decl);
if (num_child_attributes > 0) {
       array_info.element_orders.push_back(num_elements);
     }
   }
   return array_info;
 }
 
 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 (attr == DW_AT_type &&
             attributes.ExtractFormValueAtIndex(i, form_value))
-          return dwarf->ResolveTypeUID(form_value.Reference(), true);
+          return dwarf->ResolveTypeUID(form_value.Reference(die.GetMainCU()),
+                                       true);
       }
     }
   }
 
   return nullptr;
 }
 
 clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
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 =
           TypeSystemClang::DeclContextGetAsDeclContext(
               dwarf->GetDeclContextContainingUID(die.GetID()));
       decl = m_ast.CreateVariableDeclaration(
           decl_context, GetOwningClangModule(die), 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 = SymbolFileDWARF::GetDecl(imported_uid);
       if (imported_decl) {
         clang::DeclContext *decl_context =
             TypeSystemClang::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, OptionalClangModuleID(), 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 =
           SymbolFileDWARF::GetDeclContext(imported_uid);
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(
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;
     }
else {
           die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0;
 
       namespace_decl = m_ast.GetUniqueNamespaceDeclaration(
           namespace_name, containing_decl_ctx, GetOwningClangModule(die),
           is_inline);
       Log *log =
           nullptr; // (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
       if (log) {
-        SymbolFileDWARF *dwarf = die.GetDWARF();
+        SymbolFileDWARF *dwarf = die.GetMainDWARF();
         if (namespace_name) {
           dwarf->GetObjectFile()->GetModule()->LogMessage(
               log,
               "ASTContext => %p: 0x%8.8" PRIx64
               ": DW_TAG_namespace with DW_AT_name(\"%s\") => "
               "clang::NamespaceDecl *%p (original = %p)",
               static_cast<void *>(&m_ast.getASTContext()), die.GetID(),
               namespace_name, static_cast<void *>(namespace_decl),
else {
       return namespace_decl;
     }
   }
   return nullptr;
 }
 
 clang::DeclContext *DWARFASTParserClang::GetClangDeclContextContainingDIE(
     const DWARFDIE &die, DWARFDIE *decl_ctx_die_copy) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = die.GetMainDWARF();
 
   DWARFDIE decl_ctx_die = dwarf->GetDeclContextDIEContainingDIE(die);
 
   if (decl_ctx_die_copy)
     *decl_ctx_die_copy = decl_ctx_die;
 
   if (decl_ctx_die) {
     clang::DeclContext *clang_decl_ctx =
DWARFASTParserClang::GetCachedClangDeclContextForDIE(const DWARFDIE &die) {
   }
   return nullptr;
 }
 
 void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx,
                                                const DWARFDIE &die) {
   DIERef ref = *die.GetDIERef();
   m_dieref_to_decl_ctx[ref] = decl_ctx;
-  SymbolFileDWARF *sym_file = &die.GetCU()->GetSymbolFileDWARF();
+  SymbolFileDWARF *sym_file = &die.GetMainCU()->GetSymbolFileDWARF();
   // There can be many DIEs for a single decl context
   // m_decl_ctx_to_filedieref[decl_ctx].insert(...);
   m_decl_ctx_to_filedieref.insert(
       std::make_pair(decl_ctx, std::make_pair(sym_file, ref)));
 }
 
 bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
     const DWARFDIE &src_class_die, const DWARFDIE &dst_class_die,
for (idx = 0; idx < src_size; ++idx) {
                 src_die.GetOffset(), src_name, dst_die.GetOffset(), dst_name);
 
       fast_path = false;
     }
   }
 
   DWARFASTParserClang *src_dwarf_ast_parser =
       static_cast<DWARFASTParserClang *>(
-          SymbolFileDWARF::GetDWARFParser(*src_die.GetCU()));
+          SymbolFileDWARF::GetDWARFParser(*src_die.GetMainCU()));
   DWARFASTParserClang *dst_dwarf_ast_parser =
       static_cast<DWARFASTParserClang *>(
-          SymbolFileDWARF::GetDWARFParser(*dst_die.GetCU()));
+          SymbolFileDWARF::GetDWARFParser(*dst_die.GetMainCU()));
 
   // Now do the work of linking the DeclContexts and Types.
   if (fast_path) {
     // We can do this quickly.  Just run across the tables index-for-index
     // since we know each node has matching names and tags.
     for (idx = 0; idx < src_size; ++idx) {
       src_die = src_name_to_die.GetValueAtIndexUnchecked(idx);
       dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
 
       clang::DeclContext *src_decl_ctx =
           src_dwarf_ast_parser->m_dieref_to_decl_ctx[*src_die.GetDIERef()];
       if (src_decl_ctx) {
         LLDB_LOGF(log, "uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                   static_cast<void *>(src_decl_ctx), src_die.GetOffset(),
                   dst_die.GetOffset());
         dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, dst_die);
       } else {
         LLDB_LOGF(log,
                   "warning: tried to unique decl context from 0x%8.8x for "
                   "0x%8.8x, but none was found",
                   src_die.GetOffset(), dst_die.GetOffset());
       }
 
       Type *src_child_type =
-          dst_die.GetDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
+          dst_die.GetMainDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
       if (src_child_type) {
         LLDB_LOGF(log,
                   "uniquing type %p (uid=0x%" PRIx64
                   ") from 0x%8.8x for 0x%8.8x",
                   static_cast<void *>(src_child_type), src_child_type->GetID(),
                   src_die.GetOffset(), dst_die.GetOffset());
-        dst_die.GetDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
+        dst_die.GetMainDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
             src_child_type;
       } else {
         LLDB_LOGF(log,
                   "warning: tried to unique lldb_private::Type from "
                   "0x%8.8x for 0x%8.8x, but none was found",
                   src_die.GetOffset(), dst_die.GetOffset());
       }
     }
if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty()) {
           } else {
             LLDB_LOGF(log,
                       "warning: tried to unique decl context from 0x%8.8x "
                       "for 0x%8.8x, but none was found",
                       src_die.GetOffset(), dst_die.GetOffset());
           }
 
           Type *src_child_type =
-              dst_die.GetDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
+              dst_die.GetMainDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
           if (src_child_type) {
             LLDB_LOGF(
                 log,
                 "uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
                 static_cast<void *>(src_child_type), src_child_type->GetID(),
                 src_die.GetOffset(), dst_die.GetOffset());
-            dst_die.GetDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
+            dst_die.GetMainDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
                 src_child_type;
           } else {
             LLDB_LOGF(log,
                       "warning: tried to unique lldb_private::Type from "
                       "0x%8.8x for 0x%8.8x, but none was found",
                       src_die.GetOffset(), dst_die.GetOffset());
           }
         } else {
for (idx = 0; idx < src_size_artificial; ++idx) {
         } else {
           LLDB_LOGF(log,
                     "warning: tried to unique decl context from 0x%8.8x "
                     "for 0x%8.8x, but none was found",
                     src_die.GetOffset(), dst_die.GetOffset());
         }
 
         Type *src_child_type =
-            dst_die.GetDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
+            dst_die.GetMainDWARF()->GetDIERefToType()[*src_die.GetDIERef()];
         if (src_child_type) {
           LLDB_LOGF(
               log,
               "uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
               static_cast<void *>(src_child_type), src_child_type->GetID(),
               src_die.GetOffset(), dst_die.GetOffset());
-          dst_die.GetDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
+          dst_die.GetMainDWARF()->GetDIERefToType()[*dst_die.GetDIERef()] =
               src_child_type;
         } else {
           LLDB_LOGF(log,
                     "warning: tried to unique lldb_private::Type from "
                     "0x%8.8x for 0x%8.8x, but none was found",
                     src_die.GetOffset(), dst_die.GetOffset());
         }
       }

lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h

public:
   dw_attr_t AttributeAtIndex(uint32_t i) const {
     return m_infos[i].attr.get_attr();
   }
   dw_attr_t FormAtIndex(uint32_t i) const { return m_infos[i].attr.get_form(); }
   DWARFFormValue::ValueType ValueAtIndex(uint32_t i) const {
     return m_infos[i].attr.get_value();
   }
   bool ExtractFormValueAtIndex(uint32_t i, DWARFFormValue &form_value) const;
-  DWARFDIE FormValueAsReferenceAtIndex(uint32_t i) const;
-  DWARFDIE FormValueAsReference(dw_attr_t attr) const;
+  DWARFDIE FormValueAsReferenceAtIndex(uint32_t i, DWARFUnit *main_unit) const;
+  DWARFDIE FormValueAsReference(dw_attr_t attr, DWARFUnit *main_unit) const;
   uint32_t FindAttributeIndex(dw_attr_t attr) const;
   void Clear() { m_infos.clear(); }
   size_t Size() const { return m_infos.size(); }
 
 protected:
   struct AttributeValue {
     DWARFUnit *cu; // Keep the compile unit with each attribute in
                    // case we have DW_FORM_ref_addr values
     dw_offset_t die_offset;
     DWARFAttribute attr;
   };
   typedef llvm::SmallVector<AttributeValue, 8> collection;
   collection m_infos;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFATTRIBUTE_H

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

if (form_value.Form() == DW_FORM_implicit_const) {
     form_value.SetValue(ValueAtIndex(i));
     return true;
   }
   lldb::offset_t offset = DIEOffsetAtIndex(i);
   return form_value.ExtractValue(cu->GetData(), &offset);
 }
 
 DWARFDIE
-DWARFAttributes::FormValueAsReference(dw_attr_t attr) const {
+DWARFAttributes::FormValueAsReference(dw_attr_t attr,
+                                      DWARFUnit *main_unit) const {
   const uint32_t attr_idx = FindAttributeIndex(attr);
   if (attr_idx != UINT32_MAX)
-    return FormValueAsReferenceAtIndex(attr_idx);
+    return FormValueAsReferenceAtIndex(attr_idx, main_unit);
   return {};
 }
 
 DWARFDIE
-DWARFAttributes::FormValueAsReferenceAtIndex(uint32_t i) const {
+DWARFAttributes::FormValueAsReferenceAtIndex(uint32_t i,
+                                             DWARFUnit *main_unit) const {
   DWARFFormValue form_value;
   if (ExtractFormValueAtIndex(i, form_value))
-    return form_value.Reference();
+    return form_value.Reference(main_unit);
   return {};
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h

 //===-- DWARFBaseDIE.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFBASEDIE_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFBASEDIE_H
 
+#include "Plugins/SymbolFile/DWARF/DWARFUnitPair.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/Support/Error.h"
 
 class DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
 class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class SymbolFileDWARF;
 
 class DWARFBaseDIE {
 public:
   DWARFBaseDIE() = default;
 
-  DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
+  DWARFBaseDIE(DWARFUnitPair cu, DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(die) {}
 
-  DWARFBaseDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die)
-      : m_cu(const_cast<DWARFUnit *>(cu)), m_die(die) {}
-
-  DWARFBaseDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die)
+  DWARFBaseDIE(DWARFUnitPair cu, const DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
 
-  DWARFBaseDIE(const DWARFUnit *cu, const DWARFDebugInfoEntry *die)
-      : m_cu(const_cast<DWARFUnit *>(cu)),
-        m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
-
   // Tests
   explicit operator bool() const { return IsValid(); }
 
   bool IsValid() const { return m_cu && m_die; }
 
   bool HasChildren() const;
 
   bool Supports_DW_AT_APPLE_objc_complete_type() const;
 
   // Accessors
   SymbolFileDWARF *GetDWARF() const;
+  SymbolFileDWARF *GetMainDWARF() const;
 
-  DWARFUnit *GetCU() const { return m_cu; }
+  DWARFUnitPair GetCU() const { return m_cu; }
+  DWARFUnit *GetMainCU() const { return m_cu.GetMainCU(); }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
   llvm::Optional<DIERef> GetDIERef() const;
 
-  void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
+  void Set(DWARFUnitPair cu, DWARFDebugInfoEntry *die) {
     if (cu && die) {
       m_cu = cu;
       m_die = die;
     } else {
       Clear();
     }
   }
 
   void Clear() {
-    m_cu = nullptr;
+    m_cu.Clear();
     m_die = nullptr;
   }
 
   // Get the data that contains the attribute values for this DIE. Support
   // for .debug_types means that any DIE can have its data either in the
   // .debug_info or the .debug_types section; this method will return the
   // correct section data.
   //
public:
   uint64_t GetAttributeValueAsAddress(const dw_attr_t attr,
                                       uint64_t fail_value) const;
 
   enum class Recurse : bool { no, yes };
   size_t GetAttributes(DWARFAttributes &attributes,
                        Recurse recurse = Recurse::yes) const;
 
 protected:
-  DWARFUnit *m_cu = nullptr;
-  DWARFDebugInfoEntry *m_die = nullptr;
+  DWARFUnitPair m_cu;
+  DWARFDebugInfoEntry *m_die;
 };
 
 bool operator==(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
 bool operator!=(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFBASEDIE_H

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

 //===-- DWARFBaseDIE.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFBaseDIE.h"
 
-#include "DWARFUnit.h"
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugInfoEntry.h"
+#include "DWARFSimpleDIE.h"
+#include "DWARFUnit.h"
 #include "SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb_private;
 
uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
   if (IsValid())
     return m_die->GetAttributeValueAsAddress(GetCU(), attr, fail_value);
   else
     return fail_value;
 }
 
 lldb::user_id_t DWARFBaseDIE::GetID() const {
   if (IsValid())
-    return GetDWARF()->GetUID(*this);
+    return GetMainDWARF()->GetUID(*this);
   return LLDB_INVALID_UID;
 }
 
 const char *DWARFBaseDIE::GetName() const {
   if (IsValid())
     return m_die->GetName(m_cu);
   else
     return nullptr;

 
 SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
   if (m_cu)
     return &m_cu->GetSymbolFileDWARF();
   else
     return nullptr;
 }
 
+SymbolFileDWARF *DWARFBaseDIE::GetMainDWARF() const {
+  if (m_cu.GetMainCU())
+    return &m_cu.GetMainCU()->GetSymbolFileDWARF();
+  return GetDWARF();
+}
+
 bool DWARFBaseDIE::HasChildren() const {
   return m_die && m_die->HasChildren();
 }
 
 bool DWARFBaseDIE::Supports_DW_AT_APPLE_objc_complete_type() const {
   return IsValid() && GetDWARF()->Supports_DW_AT_APPLE_objc_complete_type(m_cu);
 }
 
 size_t DWARFBaseDIE::GetAttributes(DWARFAttributes &attributes,
                                    Recurse recurse) const {
-  if (IsValid())
-    return m_die->GetAttributes(m_cu, attributes, recurse);
-  attributes.Clear();
-  return 0;
+  return DWARFSimpleDIE(*this).GetAttributes(attributes, recurse);
 }
 
 bool operator==(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs) {
-  return lhs.GetDIE() == rhs.GetDIE() && lhs.GetCU() == rhs.GetCU();
+  return lhs.GetDIE() == rhs.GetDIE() && lhs.GetCU() == rhs.GetCU() &&
+         lhs.GetMainCU() == rhs.GetMainCU();
 }
 
 bool operator!=(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs) {
   return !(lhs == rhs);
 }
 
 const DWARFDataExtractor &DWARFBaseDIE::GetData() const {
   // Clients must check if this DIE is valid before calling this function.
   assert(IsValid());
   return m_cu->GetData();
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

public:
   void Dump(lldb_private::Stream *s) const override;
 
   static bool classof(const DWARFUnit *unit) { return !unit->IsTypeUnit(); }
 
   DWARFCompileUnit &GetNonSkeletonUnit();
 
   DWARFDIE LookupAddress(const dw_addr_t address);
 
+  DWARFDIE GetDIE(dw_offset_t die_offset) {
+    return DWARFUnit::GetDIE(this, die_offset);
+  }
+
+  DWARFBaseDIE GetUnitDIEOnly() { return {DWARFUnitPair(this), DIEPtr()}; }
+
+  DWARFDIE DIE() { return {DWARFUnitPair(this), DIEPtr()}; }
+
 private:
   DWARFCompileUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
                    const DWARFUnitHeader &header,
                    const DWARFAbbreviationDeclarationSet &abbrevs,
                    DIERef::Section section, bool is_dwo)
       : DWARFUnit(dwarf, uid, header, abbrevs, section, is_dwo) {}
 
   DWARFCompileUnit(const DWARFCompileUnit &) = delete;
   const DWARFCompileUnit &operator=(const DWARFCompileUnit &) = delete;
 
   friend class DWARFUnit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFCOMPILEUNIT_H

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

void DWARFCompileUnit::BuildAddressRangeTable(
   size_t num_debug_aranges = debug_aranges->GetNumRanges();
 
   // First get the compile unit DIE only and check contains ranges information.
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
 
   const dw_offset_t cu_offset = GetOffset();
   if (die) {
     DWARFRangeList ranges;
+    // It does not make sense to build address table for DW_TAG_partial_unit as
+    // those never contain any addresses.
     const size_t num_ranges =
         die->GetAttributeAddressRanges(this, ranges, /*check_hi_lo_pc=*/true);
     if (num_ranges > 0) {
       for (size_t i = 0; i < num_ranges; ++i) {
         const DWARFRangeList::Entry &range = ranges.GetEntryRef(i);
         debug_aranges->AppendRange(cu_offset, range.GetRangeBase(),
                                    range.GetRangeEnd());
       }

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h

public:
 
   const char *GetQualifiedName(std::string &storage) const;
 
   using DWARFBaseDIE::GetName;
   void GetName(lldb_private::Stream &s) const;
 
   void AppendTypeName(lldb_private::Stream &s) const;
 
-  lldb_private::Type *ResolveType() const;
+  lldb_private::Type *ResolveType(SymbolFileDWARF &dwarf) const;
 
   // Resolve a type by UID using this DIE's DWARF file
   lldb_private::Type *ResolveTypeUID(const DWARFDIE &die) const;
 
   // Functions for obtaining DIE relations and references
 
   DWARFDIE
   GetParent() const;

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

 //===-- DWARFDIE.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDIE.h"
 
 #include "DWARFASTParser.h"
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDeclContext.h"
 #include "DWARFUnit.h"
 
 using namespace lldb_private;
 
 namespace {
if (IsValid())
     return m_die->GetAttributeValueAsReference(GetCU(), attr);
   else
     return {};
 }
 
 DWARFDIE
 DWARFDIE::GetDIE(dw_offset_t die_offset) const {
   if (IsValid())
-    return m_cu->GetDIE(die_offset);
+    return m_cu->GetDIE(GetMainCU(), die_offset);
   else
     return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
   if (IsValid()) {
-    DWARFUnit *cu = GetCU();
+    DWARFUnitPair cu = GetCU();
     const bool check_specification_or_abstract_origin = true;
     DWARFFormValue form_value;
     if (m_die->GetAttributeValue(cu, attr, form_value, nullptr,
                                  check_specification_or_abstract_origin))
-      return form_value.Reference();
+      return form_value.Reference(cu.GetMainCU());
   }
   return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::LookupDeepestBlock(lldb::addr_t address) const {
   if (!IsValid())
     return DWARFDIE();
void DWARFDIE::AppendTypeName(Stream &s) const {
   case DW_TAG_reference_type:
     s.PutChar('&');
     break;
   default:
     break;
   }
 }
 
-lldb_private::Type *DWARFDIE::ResolveType() const {
+lldb_private::Type *DWARFDIE::ResolveType(SymbolFileDWARF &dwarf) const {
   if (IsValid())
-    return GetDWARF()->ResolveType(*this, true);
+    return dwarf.ResolveType(*this, true);
   else
     return nullptr;
 }
 
 lldb_private::Type *DWARFDIE::ResolveTypeUID(const DWARFDIE &die) const {
-  if (SymbolFileDWARF *dwarf = GetDWARF())
+  if (SymbolFileDWARF *dwarf = GetMainDWARF())
     return dwarf->ResolveTypeUID(die, true);
   return nullptr;
 }
 
 std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
   if (!IsValid())
     return {};
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

public:
 
   size_t GetNumUnits();
   DWARFUnit *GetUnitAtIndex(size_t idx);
   DWARFUnit *GetUnitAtOffset(DIERef::Section section, dw_offset_t cu_offset,
                              uint32_t *idx_ptr = nullptr);
   DWARFUnit *GetUnitContainingDIEOffset(DIERef::Section section,
                                         dw_offset_t die_offset);
   DWARFUnit *GetUnit(const DIERef &die_ref);
+  DWARFUnit *GetMainUnit(const DIERef &die_ref);
   DWARFTypeUnit *GetTypeUnitForHash(uint64_t hash);
   bool ContainsTypeUnits();
   DWARFDIE GetDIE(const DIERef &die_ref);
 
   enum {
     eDumpFlag_Verbose = (1 << 0),  // Verbose dumping
     eDumpFlag_ShowForm = (1 << 1), // Show the DW_form type
     eDumpFlag_ShowAncestors =

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

for (size_t n = 0; n < m_cu_aranges_up->GetNumRanges(); n++) {
     if (offset != DW_INVALID_OFFSET)
       cus_with_data.insert(offset);
   }
 
   // Manually build arange data for everything that wasn't in .debug_aranges.
   const size_t num_units = GetNumUnits();
   for (size_t idx = 0; idx < num_units; ++idx) {
     DWARFUnit *cu = GetUnitAtIndex(idx);
+    if (!llvm::isa<DWARFCompileUnit>(cu))
+      continue;
 
     dw_offset_t offset = cu->GetOffset();
     if (cus_with_data.find(offset) == cus_with_data.end())
       cu->BuildAddressRangeTable(m_cu_aranges_up.get());
   }
 
   const bool minimize = true;
   m_cu_aranges_up->Sort(minimize);
if (idx_ptr)
     *idx_ptr = idx;
   return result;
 }
 
 DWARFUnit *DWARFDebugInfo::GetUnit(const DIERef &die_ref) {
   return GetUnitContainingDIEOffset(die_ref.section(), die_ref.die_offset());
 }
 
+DWARFUnit *DWARFDebugInfo::GetMainUnit(const DIERef &die_ref) {
+  return GetUnit(die_ref);
+}
+
 DWARFUnit *
 DWARFDebugInfo::GetUnitContainingDIEOffset(DIERef::Section section,
                                            dw_offset_t die_offset) {
   uint32_t idx = FindUnitIndex(section, die_offset);
   DWARFUnit *result = GetUnitAtIndex(idx);
   if (result && !result->ContainsDIEOffset(die_offset))
     return nullptr;
   return result;

 }
 
 // GetDIE()
 //
 // Get the DIE (Debug Information Entry) with the specified offset.
 DWARFDIE
 DWARFDebugInfo::GetDIE(const DIERef &die_ref) {
   DWARFUnit *cu = GetUnit(die_ref);
-  if (cu)
-    return cu->GetNonSkeletonUnit().GetDIE(die_ref.die_offset());
+  if (cu) {
+    DWARFUnit *main_cu = GetMainUnit(die_ref);
+    return cu->GetNonSkeletonUnit().GetDIE(main_cu, die_ref.die_offset());
+  }
   return DWARFDIE(); // Not found
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

public:
   const char *GetAttributeValueAsString(
       const DWARFUnit *cu, const dw_attr_t attr, const char *fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsUnsigned(
       const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
-  DWARFDIE GetAttributeValueAsReference(
+  DWARFSimpleDIE GetAttributeValueAsReference(
       const DWARFUnit *cu, const dw_attr_t attr,
       bool check_specification_or_abstract_origin = false) const;
 
+  DWARFDIE GetAttributeValueAsReference(
+      DWARFUnitPair cu, const dw_attr_t attr,
+      bool check_specification_or_abstract_origin = false) const;
+
   uint64_t GetAttributeValueAsAddress(
       const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   dw_addr_t
   GetAttributeHighPC(const DWARFUnit *cu, dw_addr_t lo_pc, uint64_t fail_value,
                      bool check_specification_or_abstract_origin = false) const;
 
   bool GetAttributeAddressRange(
       const DWARFUnit *cu, dw_addr_t &lo_pc, dw_addr_t &hi_pc,
       uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   size_t GetAttributeAddressRanges(
       DWARFUnit *cu, DWARFRangeList &ranges, bool check_hi_lo_pc,
       bool check_specification_or_abstract_origin = false) const;
-
+  const char *GetName(DWARFUnitPair cu) const;
   const char *GetName(const DWARFUnit *cu) const;
-
-  const char *GetMangledName(const DWARFUnit *cu,
+  const char *GetMangledName(DWARFUnitPair cu,
                              bool substitute_name_allowed = true) const;
-
+  const char *GetPubname(DWARFUnitPair cu) const;
   const char *GetPubname(const DWARFUnit *cu) const;
-
-  const char *GetQualifiedName(DWARFUnit *cu, std::string &storage) const;
-
-  const char *GetQualifiedName(DWARFUnit *cu, const DWARFAttributes &attributes,
+  const char *GetQualifiedName(DWARFUnitPair cu, std::string &storage) const;
+  const char *GetQualifiedName(DWARFUnitPair cu,
+                               const DWARFAttributes &attributes,
                                std::string &storage) const;
 
   bool GetDIENamesAndRanges(
-      DWARFUnit *cu, const char *&name, const char *&mangled,
+      DWARFUnitPair cu, const char *&name, const char *&mangled,
       DWARFRangeList &rangeList, int &decl_file, int &decl_line,
       int &decl_column, int &call_file, int &call_line, int &call_column,
       lldb_private::DWARFExpression *frame_base = nullptr) const;
 
   const DWARFAbbreviationDeclaration *
   GetAbbreviationDeclarationPtr(const DWARFUnit *cu) const;
 
   lldb::offset_t GetFirstAttributeOffset() const;
public:
   // be the next entry in the list...
   DWARFDebugInfoEntry *GetFirstChild() {
     return HasChildren() ? this + 1 : nullptr;
   }
   const DWARFDebugInfoEntry *GetFirstChild() const {
     return HasChildren() ? this + 1 : nullptr;
   }
 
-  DWARFDeclContext GetDWARFDeclContext(DWARFUnit *cu) const;
+  DWARFDeclContext GetDWARFDeclContext(DWARFUnitPair cu) const;
 
-  DWARFDIE GetParentDeclContextDIE(DWARFUnit *cu) const;
-  DWARFDIE GetParentDeclContextDIE(DWARFUnit *cu,
+  DWARFDIE GetParentDeclContextDIE(DWARFUnitPair cu) const;
+  DWARFDIE GetParentDeclContextDIE(DWARFUnitPair cu,
                                    const DWARFAttributes &attributes) const;
 
   void SetSiblingIndex(uint32_t idx) { m_sibling_idx = idx; }
   void SetParentIndex(uint32_t idx) { m_parent_idx = idx; }
 
   // This function returns true if the variable scope is either
   // global or (file-static). It will return false for static variables
   // that are local to a function, as they have local scope.
   bool IsGlobalOrStaticScopeVariable() const;
 
 protected:
   static DWARFDeclContext
-  GetDWARFDeclContextStatic(const DWARFDebugInfoEntry *die, DWARFUnit *cu);
+  GetDWARFDeclContextStatic(const DWARFDebugInfoEntry *die, DWARFUnitPair cu);
 
   dw_offset_t m_offset; // Offset within the .debug_info/.debug_types
   uint32_t m_parent_idx = 0;   // How many to subtract from "this" to get the
                                // parent. If zero this die has no parent
   uint32_t m_sibling_idx : 31, // How many to add to "this" to get the sibling.
       // If it is zero, then the DIE doesn't have children, or the
       // DWARF claimed it had children but the DIE only contained
       // a single NULL terminating child.

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

 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
+#include "DWARFSimpleDIE.h"
 #include "DWARFUnit.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
 using namespace std;
 extern int g_verbose;
 
static DWARFRangeList GetRangesOrReportError(DWARFUnit &unit,
   return DWARFRangeList();
 }
 
 // GetDIENamesAndRanges
 //
 // Gets the valid address ranges for a given DIE by looking for a
 // DW_AT_low_pc/DW_AT_high_pc pair, DW_AT_entry_pc, or DW_AT_ranges attributes.
 bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
-    DWARFUnit *cu, const char *&name, const char *&mangled,
+    DWARFUnitPair 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 {
   dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
   dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
   std::vector<DWARFDIE> dies;
   bool set_frame_base_loclist_addr = false;
 
for (uint32_t i = 0; i < numAttributes; ++i) {
 
         case DW_AT_MIPS_linkage_name:
         case DW_AT_linkage_name:
           if (mangled == nullptr)
             mangled = form_value.AsCString();
           break;
 
         case DW_AT_abstract_origin:
-          dies.push_back(form_value.Reference());
+          dies.push_back(form_value.Reference(cu.GetMainCU()));
           break;
 
         case DW_AT_specification:
-          dies.push_back(form_value.Reference());
+          dies.push_back(form_value.Reference(cu.GetMainCU()));
           break;
 
         case DW_AT_decl_file:
           if (decl_file == 0)
             decl_file = form_value.Unsigned();
           break;
 
         case DW_AT_decl_line:
for (uint32_t i = 0; i < num_attributes; ++i) {
       default:
         attributes.Append(form_value, offset, attr);
         break;
       }
 
       if (recurse == Recurse::yes &&
           ((attr == DW_AT_specification) || (attr == DW_AT_abstract_origin))) {
         if (form_value.ExtractValue(data, &offset)) {
-          DWARFDIE spec_die = form_value.Reference();
+          DWARFSimpleDIE spec_die = form_value.Reference();
           if (spec_die)
             spec_die.GetDIE()->GetAttributes(spec_die.GetCU(), attributes,
                                              recurse, curr_depth + 1);
         }
       } else {
         llvm::Optional<uint8_t> fixed_skip_size = DWARFFormValue::GetFixedSize(form, cu);
         if (fixed_skip_size)
           offset += *fixed_skip_size;
if (attr_idx != DW_INVALID_INDEX) {
           *end_attr_offset_ptr = offset;
         return attr_offset;
       }
     }
   }
 
   if (check_specification_or_abstract_origin) {
     if (GetAttributeValue(cu, DW_AT_specification, form_value)) {
-      DWARFDIE die = form_value.Reference();
+      DWARFSimpleDIE die = form_value.Reference();
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
             die.GetCU(), attr, form_value, end_attr_offset_ptr, false);
         if (die_offset)
           return die_offset;
       }
     }
 
     if (GetAttributeValue(cu, DW_AT_abstract_origin, form_value)) {
-      DWARFDIE die = form_value.Reference();
+      DWARFSimpleDIE die = form_value.Reference();
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
             die.GetCU(), attr, form_value, end_attr_offset_ptr, false);
         if (die_offset)
           return die_offset;
       }
     }
   }
if (GetAttributeValue(cu, attr, form_value, nullptr,
     return form_value.Unsigned();
   return fail_value;
 }
 
 // GetAttributeValueAsReference
 //
 // Get the value of an attribute as reference and fix up and compile unit
 // relative offsets as needed.
-DWARFDIE DWARFDebugInfoEntry::GetAttributeValueAsReference(
+DWARFSimpleDIE DWARFDebugInfoEntry::GetAttributeValueAsReference(
     const DWARFUnit *cu, const dw_attr_t attr,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Reference();
   return {};
 }
 
+DWARFDIE DWARFDebugInfoEntry::GetAttributeValueAsReference(
+    DWARFUnitPair cu, const dw_attr_t attr,
+    bool check_specification_or_abstract_origin) const {
+  DWARFSimpleDIE die = GetAttributeValueAsReference(
+      cu.GetCU(), attr, check_specification_or_abstract_origin);
+  if (!die.IsValid())
+    return {};
+  return {{die.GetCU(), cu.GetMainCU()}, die.GetDIE()};
+}
+
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsAddress(
     const DWARFUnit *cu, const dw_attr_t attr, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Address();
   return fail_value;
size_t DWARFDebugInfoEntry::GetAttributeAddressRanges(
   }
   return ranges.GetSize();
 }
 
 // GetName
 //
 // Get value of the DW_AT_name attribute and return it if one exists, else
 // return NULL.
-const char *DWARFDebugInfoEntry::GetName(const DWARFUnit *cu) const {
+const char *DWARFDebugInfoEntry::GetName(DWARFUnitPair cu) const {
   return GetAttributeValueAsString(cu, DW_AT_name, nullptr, true);
 }
 
 // GetMangledName
 //
 // Get value of the DW_AT_MIPS_linkage_name attribute and return it if one
 // exists, else return the value of the DW_AT_name attribute
 const char *
-DWARFDebugInfoEntry::GetMangledName(const DWARFUnit *cu,
+DWARFDebugInfoEntry::GetMangledName(DWARFUnitPair cu,
                                     bool substitute_name_allowed) const {
   const char *name = nullptr;
 
   name = GetAttributeValueAsString(cu, DW_AT_MIPS_linkage_name, nullptr, true);
   if (name)
     return name;
 
   name = GetAttributeValueAsString(cu, DW_AT_linkage_name, nullptr, true);
   if (name)
     return name;
 
   if (!substitute_name_allowed)
     return nullptr;
 
   name = GetAttributeValueAsString(cu, DW_AT_name, nullptr, true);
   return name;
 }
 
 // GetPubname
 //
 // Get value the name for a DIE as it should appear for a .debug_pubnames or
 // .debug_pubtypes section.
-const char *DWARFDebugInfoEntry::GetPubname(const DWARFUnit *cu) const {
+const char *DWARFDebugInfoEntry::GetPubname(DWARFUnitPair cu) const {
   const char *name = nullptr;
   if (!cu)
     return name;
 
   name = GetAttributeValueAsString(cu, DW_AT_MIPS_linkage_name, nullptr, true);
   if (name)
     return name;
 
while (child) {
       child->BuildFunctionAddressRangeTable(cu, debug_aranges);
       child = child->GetSibling();
     }
   }
 }
 
 DWARFDeclContext
 DWARFDebugInfoEntry::GetDWARFDeclContextStatic(const DWARFDebugInfoEntry *die,
-                                               DWARFUnit *cu) {
+                                               DWARFUnitPair cu) {
   DWARFDeclContext dwarf_decl_ctx;
   for (;;) {
     const dw_tag_t tag = die->Tag();
     if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
       return dwarf_decl_ctx;
     dwarf_decl_ctx.AppendDeclContext(tag, die->GetName(cu));
     DWARFDIE parent_decl_ctx_die = die->GetParentDeclContextDIE(cu);
     if (!parent_decl_ctx_die || parent_decl_ctx_die.GetDIE() == die)
       return dwarf_decl_ctx;
     if (parent_decl_ctx_die.Tag() == DW_TAG_compile_unit ||
         parent_decl_ctx_die.Tag() == DW_TAG_partial_unit)
       return dwarf_decl_ctx;
     die = parent_decl_ctx_die.GetDIE();
     cu = parent_decl_ctx_die.GetCU();
   }
 }
 
-DWARFDeclContext DWARFDebugInfoEntry::GetDWARFDeclContext(DWARFUnit *cu) const {
+DWARFDeclContext
+DWARFDebugInfoEntry::GetDWARFDeclContext(DWARFUnitPair cu) const {
   return GetDWARFDeclContextStatic(this, cu);
 }
 
 DWARFDIE
-DWARFDebugInfoEntry::GetParentDeclContextDIE(DWARFUnit *cu) const {
+DWARFDebugInfoEntry::GetParentDeclContextDIE(DWARFUnitPair cu) const {
   DWARFAttributes attributes;
   GetAttributes(cu, attributes, Recurse::yes);
   return GetParentDeclContextDIE(cu, attributes);
 }
 
 DWARFDIE
 DWARFDebugInfoEntry::GetParentDeclContextDIE(
-    DWARFUnit *cu, const DWARFAttributes &attributes) const {
+    DWARFUnitPair cu, const DWARFAttributes &attributes) const {
   DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
 
   while (die) {
     // If this is the original DIE that we are searching for a declaration for,
     // then don't look in the cache as we don't want our own decl context to be
     // our decl context...
     if (die.GetDIE() != this) {
       switch (die.Tag()) {
       case DW_TAG_compile_unit:
       case DW_TAG_partial_unit:
       case DW_TAG_namespace:
       case DW_TAG_structure_type:
       case DW_TAG_union_type:
       case DW_TAG_class_type:
         return die;
 
       default:
         break;
       }
     }
 
-    DWARFDIE spec_die = attributes.FormValueAsReference(DW_AT_specification);
+    DWARFDIE spec_die =
+        attributes.FormValueAsReference(DW_AT_specification, cu.GetMainCU());
     if (spec_die) {
       DWARFDIE decl_ctx_die = spec_die.GetParentDeclContextDIE();
       if (decl_ctx_die)
         return decl_ctx_die;
     }
 
-    DWARFDIE abs_die = attributes.FormValueAsReference(DW_AT_abstract_origin);
+    DWARFDIE abs_die =
+        attributes.FormValueAsReference(DW_AT_abstract_origin, cu.GetMainCU());
     if (abs_die) {
       DWARFDIE decl_ctx_die = abs_die.GetParentDeclContextDIE();
       if (decl_ctx_die)
         return decl_ctx_die;
     }
 
     die = die.GetParent();
   }
   return DWARFDIE();
 }
 
-const char *DWARFDebugInfoEntry::GetQualifiedName(DWARFUnit *cu,
+const char *DWARFDebugInfoEntry::GetQualifiedName(DWARFUnitPair cu,
                                                   std::string &storage) const {
   DWARFAttributes attributes;
   GetAttributes(cu, attributes, Recurse::yes);
   return GetQualifiedName(cu, attributes, storage);
 }
 
 const char *
-DWARFDebugInfoEntry::GetQualifiedName(DWARFUnit *cu,
+DWARFDebugInfoEntry::GetQualifiedName(DWARFUnitPair cu,
                                       const DWARFAttributes &attributes,
                                       std::string &storage) const {
 
   const char *name = GetName(cu);
 
   if (name) {
     DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(cu);
     storage.clear();

lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

 
 #include "DWARFDataExtractor.h"
 #include "llvm/ADT/Optional.h"
 #include <cstddef>
 
 class DWARFUnit;
 class SymbolFileDWARF;
 class DWARFDIE;
+class DWARFSimpleDIE;
 
 class DWARFFormValue {
 public:
   typedef struct ValueTypeTag {
     ValueTypeTag() : value() { value.uval = 0; }
 
     union {
       uint64_t uval;
public:
 
   void Dump(lldb_private::Stream &s) const;
   bool ExtractValue(const lldb_private::DWARFDataExtractor &data,
                     lldb::offset_t *offset_ptr);
   const uint8_t *BlockData() const;
   static llvm::Optional<uint8_t> GetFixedSize(dw_form_t form,
                                               const DWARFUnit *u);
   llvm::Optional<uint8_t> GetFixedSize() const;
-  DWARFDIE Reference() const;
+  DWARFSimpleDIE Reference() const;
+  DWARFDIE Reference(DWARFUnit *main_unit) const;
   uint64_t Reference(dw_offset_t offset) const;
   bool Boolean() const { return m_value.value.uval != 0; }
   uint64_t Unsigned() const { return m_value.value.uval; }
   void SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
   int64_t Signed() const { return m_value.value.sval; }
   void SetSigned(int64_t sval) { m_value.value.sval = sval; }
   const char *AsCString() const;
   dw_addr_t Address() const;

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

 //===-- DWARFFormValue.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
 
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
+#include "DWARFSimpleDIE.h"
 #include "DWARFUnit.h"
 
 class DWARFUnit;
 
 using namespace lldb_private;
 
 void DWARFFormValue::Clear() {
   m_unit = nullptr;
dw_addr_t DWARFFormValue::Address() const {
 
   uint32_t index_size = m_unit->GetAddressByteSize();
   dw_offset_t addr_base = m_unit->GetAddrBase();
   lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
   return symbol_file.GetDWARFContext().getOrLoadAddrData().GetMaxU64(
       &offset, index_size);
 }
 
-DWARFDIE DWARFFormValue::Reference() const {
+DWARFSimpleDIE DWARFFormValue::Reference() const {
   uint64_t value = m_value.value.uval;
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
-  case DW_FORM_ref_udata:
+  case DW_FORM_ref_udata: {
     assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
                     // unit relative or we will get this wrong
     value += m_unit->GetOffset();
     if (!m_unit->ContainsDIEOffset(value)) {
       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
           "DW_FORM_ref* DIE reference 0x%" PRIx64 " is outside of its CU",
           value);
       return {};
     }
-    return const_cast<DWARFUnit *>(m_unit)->GetDIE(value);
+    DWARFUnit *cu = const_cast<DWARFUnit *>(m_unit);
+    return {cu, cu->GetDIEPtr(value)};
+  }
 
   case DW_FORM_ref_addr: {
     DWARFUnit *ref_cu =
         m_unit->GetSymbolFileDWARF().DebugInfo().GetUnitContainingDIEOffset(
             DIERef::Section::DebugInfo, value);
     if (!ref_cu) {
       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
           "DW_FORM_ref_addr DIE reference 0x%" PRIx64 " has no matching CU",
           value);
       return {};
     }
-    return ref_cu->GetDIE(value);
+    return {ref_cu, ref_cu->GetDIEPtr(value)};
   }
 
   case DW_FORM_ref_sig8: {
     DWARFTypeUnit *tu =
         m_unit->GetSymbolFileDWARF().DebugInfo().GetTypeUnitForHash(value);
     if (!tu)
       return {};
-    return tu->GetDIE(tu->GetTypeOffset());
+    return {tu, tu->GetDIEPtr(tu->GetTypeOffset())};
   }
 
   default:
     return {};
   }
 }
 
+DWARFDIE DWARFFormValue::Reference(DWARFUnit *main_unit) const {
+  DWARFSimpleDIE die = Reference();
+  if (!die.IsValid())
+    return {};
+
+  // MainCU may differ from CU only for DW_TAG_partial_unit units.
+  if (die.GetCU()->GetUnitDIEOnly().Tag() != DW_TAG_partial_unit) {
+    main_unit = die.GetCU();
+    lldbassert(llvm::isa<DWARFCompileUnit>(main_unit) ||
+               llvm::isa<DWARFTypeUnit>(main_unit));
+  }
+  return {{die.GetCU(), main_unit}, die.GetDIE()};
+}
+
 uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
   uint64_t value = m_value.value.uval;
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:

lldb/source/Plugins/SymbolFile/DWARF/DWARFSimpleDIE.h

+//===-- DWARFSimpleDIE.h ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFSIMPLEDIE_H
+#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFSIMPLEDIE_H
+
+#include "DWARFBaseDIE.h"
+
+class DWARFSimpleDIE {
+public:
+  DWARFSimpleDIE() {}
+  DWARFSimpleDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die)
+      : m_cu(cu), m_die(die) {
+    assert(m_cu);
+    assert(m_die);
+  }
+  DWARFSimpleDIE(const DWARFBaseDIE &die)
+      : DWARFSimpleDIE(die.GetCU(), die.GetDIE()) {}
+  DWARFUnit *GetCU() const { return m_cu; }
+  const DWARFDebugInfoEntry *GetDIE() const { return m_die; }
+  dw_offset_t GetOffset() const;
+  size_t GetAttributes(DWARFAttributes &attributes,
+                       DWARFBaseDIE::Recurse recurse) const;
+  bool IsValid() const { return m_die != nullptr; }
+  explicit operator bool() const { return IsValid(); }
+
+private:
+  DWARFUnit *m_cu = nullptr;
+  const DWARFDebugInfoEntry *m_die = nullptr;
+};
+
+#endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFSIMPLEDIE_H

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

+//===-- DWARFSimpleDIE.cpp ------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "DWARFSimpleDIE.h"
+#include "DWARFDebugInfoEntry.h"
+
+dw_offset_t DWARFSimpleDIE::GetOffset() const {
+  return !m_die ? DW_INVALID_OFFSET : m_die->GetOffset();
+}
+
+size_t DWARFSimpleDIE::GetAttributes(DWARFAttributes &attributes,
+                                     DWARFBaseDIE::Recurse recurse) const {
+  if (IsValid())
+    return m_die->GetAttributes(m_cu, attributes, recurse);
+  attributes.Clear();
+  return 0;
+}

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   virtual void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) = 0;
 
   lldb::ByteOrder GetByteOrder() const;
 
   const DWARFDebugAranges &GetFunctionAranges();
 
   void SetBaseAddress(dw_addr_t base_addr);
 
-  DWARFBaseDIE GetUnitDIEOnly() { return {this, GetUnitDIEPtrOnly()}; }
+  DWARFDebugInfoEntry GetUnitDIEOnly() {
+    const DWARFDebugInfoEntry *dieptr = GetUnitDIEPtrOnly();
+    if (!dieptr)
+      return {};
+    return *dieptr;
+  }
+
+  DWARFBaseDIE GetUnitDIEOnly(DWARFUnit *main_cu) {
+    return {DWARFUnitPair(this, main_cu), DIEPtr()};
+  }
+
+  DWARFDIE DIE(DWARFUnit *main_cu) {
+    return {DWARFUnitPair(this, main_cu), DIEPtr()};
+  }
 
-  DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); }
+  const DWARFDebugInfoEntry *GetDIEPtr(dw_offset_t die_offset);
 
-  DWARFDIE GetDIE(dw_offset_t die_offset);
+  DWARFDIE GetDIE(DWARFUnit *main_cu, dw_offset_t die_offset);
 
   DWARFUnit &GetNonSkeletonUnit();
 
   static uint8_t GetAddressByteSize(const DWARFUnit *cu);
 
   static uint8_t GetDefaultAddressSize();
 
   void *GetUserData() const;

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

if (!dwo_symbol_file)
     return;
 
   DWARFUnit *dwo_cu = dwo_symbol_file->GetDWOCompileUnitForHash(m_dwo_id);
 
   if (!dwo_cu)
     return; // Can't fetch the compile unit from the dwo file.
   dwo_cu->SetUserData(this);
 
-  DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
-  if (!dwo_cu_die.IsValid())
+  // 'main_cu' is not used.
+  const DWARFDebugInfoEntry *dwo_cu_die = dwo_cu->GetUnitDIEPtrOnly();
+  if (!dwo_cu_die)
     return; // Can't fetch the compile unit DIE from the dwo file.
 
   // Here for DWO CU we want to use the address base set in the skeleton unit
   // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base
   // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_*
   // attributes which were applicable to the DWO units. The corresponding
   // DW_AT_* attributes standardized in DWARF v5 are also applicable to the
   // main unit in contrast.

 void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) { m_base_addr = base_addr; }
 
 // Compare function DWARFDebugAranges::Range structures
 static bool CompareDIEOffset(const DWARFDebugInfoEntry &die,
                              const dw_offset_t die_offset) {
   return die.GetOffset() < die_offset;
 }
 
-// GetDIE()
-//
-// Get the DIE (Debug Information Entry) with the specified offset by first
-// checking if the DIE is contained within this compile unit and grabbing the
-// DIE from this compile unit. Otherwise we grab the DIE from the DWARF file.
-DWARFDIE
-DWARFUnit::GetDIE(dw_offset_t die_offset) {
+const DWARFDebugInfoEntry *DWARFUnit::GetDIEPtr(dw_offset_t die_offset) {
   if (die_offset == DW_INVALID_OFFSET)
-    return DWARFDIE(); // Not found
+    return nullptr;
 
   if (!ContainsDIEOffset(die_offset)) {
     GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
         "GetDIE for DIE 0x%" PRIx32 " is outside of its CU 0x%" PRIx32,
         die_offset, GetOffset());
-    return DWARFDIE(); // Not found
+    return nullptr;
   }
 
   ExtractDIEsIfNeeded();
   DWARFDebugInfoEntry::const_iterator end = m_die_array.cend();
   DWARFDebugInfoEntry::const_iterator pos =
       lower_bound(m_die_array.cbegin(), end, die_offset, CompareDIEOffset);
+  if (pos != end) {
+    if (die_offset == (*pos).GetOffset())
+      return &(*pos);
+  }
+  return nullptr;
+}
 
-  if (pos != end && die_offset == (*pos).GetOffset())
-    return DWARFDIE(this, &(*pos));
-  return DWARFDIE(); // Not found
+// GetDIE()
+//
+// Get the DIE (Debug Information Entry) with the specified offset by first
+// checking if the DIE is contained within this compile unit and grabbing the
+// DIE from this compile unit. Otherwise we grab the DIE from the DWARF file.
+DWARFDIE
+DWARFUnit::GetDIE(DWARFUnit *main_cu, dw_offset_t die_offset) {
+  const DWARFDebugInfoEntry *die = GetDIEPtr(die_offset);
+  if (!die)
+    return DWARFDIE();
+  return DWARFDIE({this, main_cu}, die);
 }
 
 DWARFUnit &DWARFUnit::GetNonSkeletonUnit() {
   ExtractUnitDIEIfNeeded();
   if (m_dwo)
     return *m_dwo;
   return *this;
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnitPair.h

+//===-- DWARFUnitPair.h -----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_DWARFUnitPair_h_
+#define liblldb_DWARFUnitPair_h_
+
+#include "lldb/Symbol/TypeSystem.h"
+#include "lldb/lldb-enumerations.h"
+#include "llvm/Support/Error.h"
+
+class DWARFUnit;
+
+class DWARFUnitPair {
+public:
+  DWARFUnitPair();
+  DWARFUnitPair(DWARFUnit *cu, DWARFUnit *main_cu);
+  DWARFUnitPair(DWARFUnit *main_cu);
+  DWARFUnit *operator->() const;
+  DWARFUnit &operator*() const;
+  DWARFUnit *GetCU() const;
+  DWARFUnit *GetMainCU() const;
+  explicit operator bool() const;
+  operator DWARFUnit *() const;
+  operator DWARFUnit &() const;
+  bool operator==(const DWARFUnitPair &rhs) const;
+  void Clear();
+
+private:
+  DWARFUnit *m_cu;
+  // For non-DWZ setups it is equal to 'm_cu'.
+  DWARFUnit *m_main_cu;
+};
+
+#endif // liblldb_DWARFUnitPair_h_

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

+//===-- DWARFUnitPair.cpp ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Plugins/SymbolFile/DWARF/DWARFUnitPair.h"
+#include <assert.h>
+
+DWARFUnitPair::DWARFUnitPair() : m_cu(nullptr), m_main_cu(nullptr) {}
+DWARFUnitPair::DWARFUnitPair(DWARFUnit *cu, DWARFUnit *main_cu)
+    : m_cu(cu), m_main_cu(main_cu) {
+  assert(m_cu);
+  assert(m_main_cu);
+}
+DWARFUnitPair::DWARFUnitPair(DWARFUnit *main_cu)
+    : DWARFUnitPair(static_cast<DWARFUnit *>(main_cu), main_cu) {}
+DWARFUnit *DWARFUnitPair::operator->() const {
+  assert(m_cu);
+  return m_cu;
+}
+DWARFUnit &DWARFUnitPair::operator*() const {
+  assert(m_cu);
+  return *m_cu;
+}
+DWARFUnit *DWARFUnitPair::GetCU() const {
+  assert(m_cu);
+  return m_cu;
+}
+DWARFUnit *DWARFUnitPair::GetMainCU() const { return m_main_cu; }
+
+DWARFUnitPair::operator bool() const { return m_cu != nullptr; }
+DWARFUnitPair::operator DWARFUnit *() const { /*assert(m_cu);*/
+  return m_cu;
+}
+DWARFUnitPair::operator DWARFUnit &() const {
+  assert(m_cu);
+  return *m_cu;
+}
+bool DWARFUnitPair::operator==(const DWARFUnitPair &rhs) const {
+  return m_cu == rhs.m_cu && m_main_cu == rhs.m_main_cu;
+}
+void DWARFUnitPair::Clear() {
+  m_cu = nullptr;
+  m_main_cu = nullptr;
+}

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

if (!cu_offset)
     return llvm::None;
 
   DWARFUnit *cu = m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, *cu_offset);
   if (!cu)
     return llvm::None;
 
   cu = &cu->GetNonSkeletonUnit();
   if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
+    // FIXME: .debug_names have no DWZ support yet.
     return DIERef(cu->GetSymbolFileDWARF().GetDwoNum(),
                   DIERef::Section::DebugInfo, cu->GetOffset() + *die_offset);
 
   return llvm::None;
 }
 
 bool DebugNamesDWARFIndex::ProcessEntry(
     const DebugNames::Entry &entry,

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

 bool DWARFMappedHash::Header::Read(const lldb_private::DWARFDataExtractor &data,
                                    lldb::offset_t *offset_ptr,
                                    DIEInfo &hash_data) const {
   const size_t num_atoms = header_data.atoms.size();
   if (num_atoms == 0)
     return false;
 
   for (size_t i = 0; i < num_atoms; ++i) {
-    DWARFFormValue form_value(nullptr, header_data.atoms[i].form);
+    DWARFFormValue form_value({}, header_data.atoms[i].form);
 
     if (!form_value.ExtractValue(data, offset_ptr))
       return false;
 
     switch (header_data.atoms[i].type) {
     case eAtomTypeDIEOffset: // DIE offset, check form for encoding
       hash_data.die_offset =
           DWARFFormValue::IsDataForm(form_value.Form())

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h

 //===-- ManualDWARFIndex.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_MANUALDWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_MANUALDWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
+#include "Plugins/SymbolFile/DWARF/DWARFUnitPair.h"
 #include "Plugins/SymbolFile/DWARF/NameToDIE.h"
 #include "llvm/ADT/DenseSet.h"
 
 class DWARFDebugInfo;
 class SymbolFileDWARFDwo;
 
 namespace lldb_private {
 class ManualDWARFIndex : public DWARFIndex {
struct IndexSet {
     NameToDIE function_selectors;
     NameToDIE objc_class_selectors;
     NameToDIE globals;
     NameToDIE types;
     NameToDIE namespaces;
   };
   void Index();
   void IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp, IndexSet &set);
+  void IndexUnit(DWARFUnitPair unit, SymbolFileDWARFDwo *dwp, IndexSet &set);
 
-  static void IndexUnitImpl(DWARFUnit &unit,
-                            const lldb::LanguageType cu_language,
-                            IndexSet &set);
+  static void IndexUnitImpl(DWARFUnitPair unit, IndexSet &set);
 
   /// The DWARF file which we are indexing. Set to nullptr after the index is
   /// built.
   SymbolFileDWARF *m_dwarf;
   /// Which dwarf units should we skip while building the index.
   llvm::DenseSet<dw_offset_t> m_units_to_avoid;
 
   IndexSet m_set;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_MANUALDWARFINDEX_H

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

 //===-- ManualDWARFIndex.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/ManualDWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
+#include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Progress.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
void ManualDWARFIndex::Index() {
   pool.async(finalize_fn, &IndexSet::globals);
   pool.async(finalize_fn, &IndexSet::types);
   pool.async(finalize_fn, &IndexSet::namespaces);
   pool.wait();
 }
 
 void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp,
                                  IndexSet &set) {
+  // DWZ DW_TAG_partial_unit will get indexed by DW_AT_import
+  // from its DW_TAG_compile_unit (possibly transitively).
+  // Try to prevent GetUnitDIEOnly() which is expensive.
+  if (unit.GetUnitDIEOnly().Tag() == DW_TAG_partial_unit)
+    return;
+  IndexUnit(&unit, dwp, set);
+}
+
+void ManualDWARFIndex::IndexUnit(DWARFUnitPair unit, SymbolFileDWARFDwo *dwp,
+                                 IndexSet &set) {
+  // Are we called for DW_TAG_compile_unit (contrary to DW_TAG_partial_unit)?
+  if (unit.GetMainCU() == unit.GetCU()) {
+    // DWZ DW_TAG_partial_unit will get indexed by DW_AT_import
+    // from its DW_TAG_compile_unit (possibly transitively).
+    // GetUnitDIEPtrOnly() is too expensive.
+    if (unit->GetUnitDIEOnly().Tag() == DW_TAG_partial_unit)
+      return;
+  }
+
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS);
 
   if (log) {
-    m_module.LogMessage(
-        log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
-        unit.GetOffset());
+    m_module.LogMessage(log,
+                        "ManualDWARFIndex::IndexUnit for unit at "
+                        ".debug_info[0x%8.8x] from .debug_info[0x%8.8x]",
+                        unit->GetOffset(), unit.GetMainCU()->GetOffset());
   }
 
-  const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
-
-  IndexUnitImpl(unit, cu_language, set);
+  IndexUnitImpl(unit, set);
 
-  if (SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile()) {
+  if (SymbolFileDWARFDwo *dwo_symbol_file = unit->GetDwoSymbolFile()) {
     // Type units in a dwp file are indexed separately, so we just need to
     // process the split unit here. However, if the split unit is in a dwo file,
     // then we need to process type units here.
     if (dwo_symbol_file == dwp) {
-      IndexUnitImpl(unit.GetNonSkeletonUnit(), cu_language, set);
+      IndexUnitImpl(&unit->GetNonSkeletonUnit(), set);
     } else {
+      assert(unit.GetCU() == unit.GetMainCU());
       DWARFDebugInfo &dwo_info = dwo_symbol_file->DebugInfo();
-      for (size_t i = 0; i < dwo_info.GetNumUnits(); ++i)
-        IndexUnitImpl(*dwo_info.GetUnitAtIndex(i), cu_language, set);
+      for (size_t i = 0; i < dwo_info.GetNumUnits(); ++i) {
+        // Separate main CU is not used for DWO CUs.
+        DWARFUnit *dwo_cu = dwo_info.GetUnitAtIndex(i);
+        IndexUnitImpl(dwo_cu, set);
+      }
     }
   }
 }
 
-void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit,
-                                     const LanguageType cu_language,
-                                     IndexSet &set) {
+void ManualDWARFIndex::IndexUnitImpl(DWARFUnitPair unitpair, IndexSet &set) {
+
+  DWARFUnit &unit = unitpair;
+  const LanguageType cu_language =
+      SymbolFileDWARF::GetLanguage(*unitpair.GetMainCU());
+
   for (const DWARFDebugInfoEntry &die : unit.dies()) {
     const dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_array_type:
     case DW_TAG_base_type:
     case DW_TAG_class_type:
     case DW_TAG_constant:
if (num_attributes > 0) {
         case DW_AT_specification:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             specification_die_form = form_value;
           break;
         }
       }
     }
 
-    DIERef ref = *DWARFDIE(&unit, &die).GetDIERef();
+    DIERef ref = *DWARFDIE(unitpair, &die).GetDIERef();
     switch (tag) {
     case DW_TAG_inlined_subroutine:
     case DW_TAG_subprogram:
       if (has_address) {
         if (name) {
           bool is_objc_method = false;
           if (cu_language == eLanguageTypeObjC ||
               cu_language == eLanguageTypeObjC_plus_plus) {
case DW_TAG_subprogram:
                 set.function_selectors.Insert(objc_selector_name, ref);
               if (objc_fullname_no_category_name)
                 set.function_fullnames.Insert(objc_fullname_no_category_name,
                                               ref);
             }
           }
           // If we have a mangled name, then the DW_AT_name attribute is
           // usually the method name without the class or any parameters
-          bool is_method = DWARFDIE(&unit, &die).IsMethod();
+          bool is_method = DWARFDIE(unitpair, &die).IsMethod();
 
           if (is_method)
             set.function_methods.Insert(ConstString(name), ref);
           else
             set.function_basenames.Insert(ConstString(name), ref);
 
           if (!is_method && !mangled_cstr && !is_objc_method)
             set.function_fullnames.Insert(ConstString(name), ref);

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

void SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
 
   CompileUnit *comp_unit = nullptr;
   if (sc_scope)
     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 
   const auto &get = [&](DWARFUnit *unit) {
     if (!unit)
       return;
+    DWARFUnit *main_unit = unit;
     unit = &unit->GetNonSkeletonUnit();
-    GetTypes(unit->DIE(), unit->GetOffset(), unit->GetNextUnitOffset(),
+    GetTypes(unit->DIE(main_unit), unit->GetOffset(), unit->GetNextUnitOffset(),
              type_mask, type_set);
   };
   if (comp_unit) {
     get(GetDWARFCompileUnit(comp_unit));
   } else {
     DWARFDebugInfo &info = DebugInfo();
     const size_t num_cus = info.GetNumUnits();
     for (size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx)

 }
 
 Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
                                          const DWARFDIE &die) {
   ASSERT_MODULE_LOCK(this);
   if (!die.IsValid())
     return nullptr;
 
-  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(GetLanguage(*die.GetMainCU()));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to parse function");
     return nullptr;
   }
   DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
   if (!dwarf_ast)
     return nullptr;
bool SymbolFileDWARF::FixupAddress(Address &addr) {
   if (debug_map_symfile) {
     return debug_map_symfile->LinkOSOAddress(addr);
   }
   // This is a normal DWARF file, no address fixups need to happen
   return true;
 }
 lldb::LanguageType SymbolFileDWARF::ParseLanguage(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return GetLanguage(dwarf_cu->GetNonSkeletonUnit());
   else
     return eLanguageTypeUnknown;
 }
 
 XcodeSDK SymbolFileDWARF::ParseXcodeSDK(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return {};
   const DWARFBaseDIE cu_die = dwarf_cu->GetNonSkeletonUnit().GetUnitDIEOnly();
   if (!cu_die)
     return {};
   const char *sdk = cu_die.GetAttributeValueAsString(DW_AT_APPLE_sdk, nullptr);
   if (!sdk)
     return {};
if (local_module_sp && local_module_sp != module_sp)
     local_module_sp->RegisterXcodeSDK(sdk, sysroot);
 
   return {sdk};
 }
 
 size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
   LLDB_SCOPED_TIMER();
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return 0;
 
   size_t functions_added = 0;
   dwarf_cu = &dwarf_cu->GetNonSkeletonUnit();
   for (DWARFDebugInfoEntry &entry : dwarf_cu->dies()) {
     if (entry.Tag() != DW_TAG_subprogram)
       continue;
bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   return false;
 }
 
 bool SymbolFileDWARF::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<SourceModule> &imported_modules) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   assert(sc.comp_unit);
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (!dwarf_cu)
     return false;
   if (!ClangModulesDeclVendor::LanguageSupportsClangModules(
           sc.comp_unit->GetLanguage()))
     return false;
   UpdateExternalModuleListIfNeeded();
 
   const DWARFDIE die = dwarf_cu->DIE();
DWARFDebugMacroEntry::ReadMacroEntries(
       offset, this, debug_macros_sp);
 
   return debug_macros_sp;
 }
 
 bool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu == nullptr)
     return false;
 
   const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
   if (!dwarf_cu_die)
     return false;
 
   lldb::offset_t sect_offset =

 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIE(). See comments inside the
   // SymbolFileDWARF::GetDIE() for details.
   if (DWARFDIE type_die = GetDIE(type_uid))
-    return type_die.ResolveType();
+    return type_die.ResolveType(*this);
   else
     return nullptr;
 }
 
 llvm::Optional<SymbolFile::ArrayInfo>
 SymbolFileDWARF::GetDynamicArrayInfoForUID(
     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (dwarf_die) {
     Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO |
                                           DWARF_LOG_TYPE_COMPLETION));
     if (log)
       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
           log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
           dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
     assert(compiler_type);
-    if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetCU()))
+    if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetMainCU()))
       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) {

 void SymbolFileDWARF::GetObjCMethods(
     ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
   m_index->GetObjCMethods(class_name, callback);
 }
 
 bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
   sc.Clear(false);
 
-  if (die && llvm::isa<DWARFCompileUnit>(die.GetCU())) {
+  if (die && llvm::isa<DWARFCompileUnit>(die.GetCU().GetCU())) {
     // Check if the symbol vendor already knows about this compile unit?
     sc.comp_unit =
         GetCompUnitForDWARFCompUnit(llvm::cast<DWARFCompileUnit>(*die.GetCU()));
 
     sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
     if (sc.function == nullptr)
       sc.function = ParseFunction(*sc.comp_unit, die);
 
void SymbolFileDWARF::FindGlobalVariables(
   m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) {
     if (!sc.module_sp)
       sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
     if (die.Tag() != DW_TAG_variable)
       return true;
 
-    auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
+    auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetMainCU());
     if (!dwarf_cu)
       return true;
     sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
     if (parent_decl_ctx) {
-      if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
+      if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainCU())) {
         CompilerDeclContext actual_parent_decl_ctx =
             dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
         if (!actual_parent_decl_ctx ||
             actual_parent_decl_ctx != parent_decl_ctx)
           return true;
       }
     }
 
void SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
   const uint32_t original_size = variables.GetSize();
 
   SymbolContext sc;
   m_index->GetGlobalVariables(regex, [&](DWARFDIE die) {
     if (!sc.module_sp)
       sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
-    DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
+    DWARFCompileUnit *dwarf_cu =
+        llvm::dyn_cast<DWARFCompileUnit>(die.GetCU().GetMainCU());
     if (!dwarf_cu)
       return true;
     sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
     ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
     return variables.GetSize() - original_size < max_matches;
   });
bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext &decl_ctx,
                                        const DWARFDIE &die) {
   // If we have no parent decl context to match this DIE matches, and if the
   // parent decl context isn't valid, we aren't trying to look for any
   // particular decl context so any die matches.
   if (!decl_ctx.IsValid())
     return true;
 
   if (die) {
-    if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
+    if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainCU())) {
       if (CompilerDeclContext actual_decl_ctx =
               dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
         return decl_ctx.IsContainedInLookup(actual_decl_ctx);
     }
   }
   return false;
 }
 
if (pattern.empty())
     return;
 
   ConstString name = pattern.back().name;
 
   if (!name)
     return;
 
   m_index->GetTypes(name, [&](DWARFDIE die) {
-    if (!languages[GetLanguageFamily(*die.GetCU())])
+    if (!languages[GetLanguageFamily(*die.GetMainCU())])
       return true;
 
     llvm::SmallVector<CompilerContext, 4> die_context;
     die.GetDeclContext(die_context);
     if (!contextMatches(die_context, pattern))
       return true;
 
     if (Type *matching_type = ResolveType(die, true, true)) {
SymbolFileDWARF::FindNamespace(ConstString name,
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
   m_index->GetNamespaces(name, [&](DWARFDIE die) {
     if (!DIEInDeclContext(parent_decl_ctx, die))
       return true; // The containing decl contexts don't match
 
-    DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+    DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainCU());
     if (!dwarf_ast)
       return true;
 
     namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
     return !namespace_decl_ctx.IsValid();
   });
 
   if (log && namespace_decl_ctx) {

 
 TypeSP SymbolFileDWARF::GetTypeForDIE(const DWARFDIE &die,
                                       bool resolve_function_context) {
   TypeSP type_sp;
   if (die) {
     Type *type_ptr = GetDIERefToType().lookup(*die.GetDIERef());
     if (type_ptr == nullptr) {
       SymbolContextScope *scope;
-      if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()))
+      if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetMainCU()))
         scope = GetCompUnitForDWARFCompUnit(*dwarf_cu);
       else
         scope = GetObjectFile()->GetModule().get();
       assert(scope);
       SymbolContext sc(scope);
       const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
       while (parent_die != nullptr) {
         if (parent_die->Tag() == DW_TAG_subprogram)
if (type_name) {
         }
       }
 
       m_index->GetTypes(dwarf_decl_ctx, [&](DWARFDIE type_die) {
         // Make sure type_die's langauge matches the type system we are
         // looking for. We don't want to find a "Foo" type from Java if we
         // are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
         if (type_system &&
-            !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
+            !type_system->SupportsLanguage(GetLanguage(*type_die.GetMainCU())))
           return true;
         bool try_resolving_type = false;
 
         // Don't try and resolve the DIE we are looking for with the DIE
         // itself!
         const dw_tag_t type_tag = type_die.Tag();
         // Make sure the tags match
         if (type_tag == tag) {
TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
   return type_sp;
 }
 
 TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
                                   bool *type_is_new_ptr) {
   if (!die)
     return {};
 
-  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(GetLanguage(*die.GetMainCU()));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to parse type");
     return {};
   }
 
   DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
   if (!dwarf_ast)
size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc,
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseBlocksRecursive(Function &func) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompileUnit *comp_unit = func.GetCompileUnit();
   lldbassert(comp_unit);
 
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
   if (!dwarf_cu)
     return 0;
 
   size_t functions_added = 0;
   const dw_offset_t function_die_offset = func.GetID();
   DWARFDIE function_die =
       dwarf_cu->GetNonSkeletonUnit().GetDIE(function_die_offset);
   if (function_die) {
     ParseBlocksRecursive(*comp_unit, &func.GetBlock(false), function_die,
                          LLDB_INVALID_ADDRESS, 0);
   }
 
   return functions_added;
 }
 
 size_t SymbolFileDWARF::ParseTypes(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   size_t types_added = 0;
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
     if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
       SymbolContext sc;
       sc.comp_unit = &comp_unit;
       types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
     }
   }
if (sc.comp_unit != nullptr) {
     }
   }
   return 0;
 }
 
 VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
                                              const DWARFDIE &die,
                                              const lldb::addr_t func_low_pc) {
-  if (die.GetDWARF() != this)
-    return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
+  if (die.GetMainDWARF() != this)
+    return die.GetMainDWARF()->ParseVariableDIE(sc, die, func_low_pc);
 
   if (!die)
     return nullptr;
 
   if (VariableSP var_sp = GetDIERefToVariable()[*die.GetDIERef()])
     return var_sp; // Already been parsed!
 
   const dw_tag_t tag = die.Tag();
case DW_AT_external:
       break;
     case DW_AT_const_value:
       const_value_form = form_value;
       break;
     case DW_AT_location:
       location_form = form_value;
       break;
     case DW_AT_specification:
-      spec_die = form_value.Reference();
+      spec_die = form_value.Reference(die.GetMainCU());
       break;
     case DW_AT_start_scope:
       // TODO: Implement this.
       break;
     case DW_AT_artificial:
       is_artificial = form_value.Boolean();
       break;
     case DW_AT_declaration:
if (!mangled) {
     // declared in a namespace B which in turn is contained in a
     // namespace A, the command "frame var j" returns
     //   "(int) A::B::j = 4".
     // If the compiler does not emit a linkage name, we should be
     // able to generate a fully qualified name from the
     // declaration context.
     if ((parent_tag == DW_TAG_compile_unit ||
          parent_tag == DW_TAG_partial_unit) &&
-        Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU())))
+        Language::LanguageIsCPlusPlus(GetLanguage(*die.GetMainCU())))
       mangled =
           GetDWARFDeclContext(die).GetQualifiedNameAsConstString().GetCString();
   }
 
   if (tag == DW_TAG_formal_parameter)
     scope = eValueTypeVariableArgument;
   else {
     // DWARF doesn't specify if a DW_TAG_variable is a local, global
if (symbol_context_scope == nullptr) {
     default:
       symbol_context_scope = sc.comp_unit;
       break;
     }
   }
 
   if (symbol_context_scope) {
     auto type_sp = std::make_shared<SymbolFileType>(
-        *this, GetUID(type_die_form.Reference()));
+        *this, GetUID(type_die_form.Reference(die.GetMainCU())));
 
     if (use_type_size_for_value && type_sp->GetType())
       location.UpdateValue(
           const_value_form.Unsigned(),
           type_sp->GetType()->GetByteSize(nullptr).getValueOr(0),
           die.GetCU()->GetAddressByteSize());
 
     var_sp = std::make_shared<Variable>(
for (size_t i = 0; i < num_attributes; ++i) {
 
       dw_attr_t attr = attributes.AttributeAtIndex(i);
 
       if (attr == DW_AT_call_tail_call || attr == DW_AT_GNU_tail_call)
         tail_call = form_value.Boolean();
 
       // Extract DW_AT_call_origin (the call target's DIE).
       if (attr == DW_AT_call_origin || attr == DW_AT_abstract_origin) {
-        call_origin = form_value.Reference();
+        call_origin = form_value.Reference(function_die.GetMainCU());
         if (!call_origin->IsValid()) {
           LLDB_LOG(log, "CollectCallEdges: Invalid call origin in {0}",
                    function_die.GetPubname());
           break;
         }
       }
 
       if (attr == DW_AT_low_pc)
const std::shared_ptr<SymbolFileDWARFDwo> &SymbolFileDWARF::GetDwpSymbolFile() {
   return m_dwp_symfile;
 }
 
 llvm::Expected<TypeSystem &> SymbolFileDWARF::GetTypeSystem(DWARFUnit &unit) {
   return unit.GetSymbolFileDWARF().GetTypeSystemForLanguage(GetLanguage(unit));
 }
 
 DWARFASTParser *SymbolFileDWARF::GetDWARFParser(DWARFUnit &unit) {
+  // Caller should have called GetMainCU().
+  lldbassert(unit.GetUnitDIEOnly().Tag() != DW_TAG_partial_unit);
   auto type_system_or_err = GetTypeSystem(unit);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to get DWARFASTParser");
     return nullptr;
   }
   return type_system_or_err->GetDWARFParser();
 }
 
 CompilerDecl SymbolFileDWARF::GetDecl(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
+  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainCU()))
     return dwarf_ast->GetDeclForUIDFromDWARF(die);
   return CompilerDecl();
 }
 
 CompilerDeclContext SymbolFileDWARF::GetDeclContext(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
+  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainCU()))
     return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetContainingDeclContext(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
+  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetMainCU()))
     return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
   return CompilerDeclContext();
 }
 
 DWARFDeclContext SymbolFileDWARF::GetDWARFDeclContext(const DWARFDIE &die) {
   if (!die.IsValid())
     return {};
   DWARFDeclContext dwarf_decl_ctx =
       die.GetDIE()->GetDWARFDeclContext(die.GetCU());
-  dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetCU()));
+  dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetMainCU()));
   return dwarf_decl_ctx;
 }
 
 LanguageType SymbolFileDWARF::LanguageTypeFromDWARF(uint64_t val) {
   // Note: user languages between lo_user and hi_user must be handled
   // explicitly here.
   switch (val) {
   case DW_LANG_Mips_Assembler:

lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp

static DWARFExpression MakeLocationExpressionInternal(lldb::ModuleSP module,
   StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
 
   if (!writer(stream, register_kind))
     return DWARFExpression();
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
-  DWARFExpression result(module, extractor, nullptr);
+  DWARFExpression result(module, extractor, {});
   result.SetRegisterKind(register_kind);
 
   return result;
 }
 
 static DWARFExpression MakeRegisterBasedLocationExpressionInternal(
     llvm::codeview::RegisterId reg, llvm::Optional<int32_t> relative_offset,
     lldb::ModuleSP module) {
DWARFExpression lldb_private::npdb::MakeConstantLocationExpression(
   } else {
     Value.U = constant.getZExtValue();
   }
 
   bytes = llvm::makeArrayRef(reinterpret_cast<const uint8_t *>(&Value), 8)
               .take_front(size);
   buffer->CopyData(bytes.data(), size);
   DataExtractor extractor(buffer, lldb::eByteOrderLittle, address_size);
-  DWARFExpression result(nullptr, extractor, nullptr);
+  DWARFExpression result(nullptr, extractor, {});
   return result;
 }

lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp

DWARFExpression ConvertPDBLocationToDWARFExpression(
   }
   default:
     return DWARFExpression();
   }
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
-  DWARFExpression result(module, extractor, nullptr);
+  DWARFExpression result(module, extractor, {});
   result.SetRegisterKind(register_kind);
 
   return result;
 }

lldb/source/Target/RegisterContext.cpp

RegisterContext::UpdateDynamicRegisterSize(const lldb_private::ArchSpec &arch,
   int expr_result;
   uint32_t addr_size = arch.GetAddressByteSize();
   const uint8_t *dwarf_opcode_ptr = reg_info->dynamic_size_dwarf_expr_bytes;
   const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
 
   DataExtractor dwarf_data(dwarf_opcode_ptr, dwarf_opcode_len,
                            arch.GetByteOrder(), addr_size);
   ModuleSP opcode_ctx;
-  DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, nullptr);
+  DWARFExpression dwarf_expr(opcode_ctx, dwarf_data, {});
   Value result;
   Status error;
-  if (dwarf_expr.Evaluate(&exe_ctx, this, opcode_ctx, dwarf_data, nullptr,
+  if (dwarf_expr.Evaluate(&exe_ctx, this, opcode_ctx, dwarf_data, {},
                           eRegisterKindDWARF, nullptr, nullptr, result,
                           &error)) {
     expr_result = result.GetScalar().SInt(-1);
     switch (expr_result) {
     case 0:
       return 4;
     case 1:
       return 8;

lldb/source/Target/RegisterContextUnwind.cpp

RegisterContextUnwind::SavedLocationForRegister(
 
   if (unwindplan_regloc.IsDWARFExpression() ||
       unwindplan_regloc.IsAtDWARFExpression()) {
     DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
                             unwindplan_regloc.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
-    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
+    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, {});
     dwarfexpr.SetRegisterKind(unwindplan_registerkind);
     Value cfa_val = Scalar(m_cfa);
     cfa_val.SetValueType(Value::ValueType::LoadAddress);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
                            &error)) {
       addr_t val;
bool RegisterContextUnwind::ReadFrameAddress(
   case UnwindPlan::Row::FAValue::isDWARFExpression: {
     ExecutionContext exe_ctx(m_thread.shared_from_this());
     Process *process = exe_ctx.GetProcessPtr();
     DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(),
                             fa.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
-    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
+    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, {});
     dwarfexpr.SetRegisterKind(row_register_kind);
     Value result;
     Status error;
     if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
                            &error)) {
       address = result.GetScalar().ULongLong();
       if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
         address = abi_sp->FixCodeAddress(address);

lldb/unittests/Expression/DWARFExpressionTest.cpp

 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr,
                                        lldb::ModuleSP module_sp = {},
-                                       DWARFUnit *unit = nullptr,
+                                       DWARFUnitPair unit = {},
                                        ExecutionContext *exe_ctx = nullptr) {
   DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle,
                           /*addr_size*/ 4);
   Value result;
   Status status;
   if (!DWARFExpression::Evaluate(exe_ctx, /*reg_ctx*/ nullptr, module_sp,
                                  extractor, unit, lldb::eRegisterKindLLDB,
                                  /*initial_value_ptr*/ nullptr,

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

)";
 
   YAMLModuleTester t(yamldata);
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
   DWARFASTParserClangStub ast_parser(ast_ctx);
 
   DWARFUnit *unit = t.GetDwarfUnit();
-  const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
+  const DWARFDebugInfoEntry *die_first = unit->DIE(unit).GetDIE();
   const DWARFDebugInfoEntry *die_child0 = die_first->GetFirstChild();
   const DWARFDebugInfoEntry *die_child1 = die_child0->GetSibling();
   const DWARFDebugInfoEntry *die_child2 = die_child1->GetSibling();
   const DWARFDebugInfoEntry *die_child3 = die_child2->GetSibling();
   std::vector<DWARFDIE> dies = {
       DWARFDIE(unit, die_child0), DWARFDIE(unit, die_child1),
       DWARFDIE(unit, die_child2), DWARFDIE(unit, die_child3)};
   std::vector<clang::DeclContext *> decl_ctxs = {

lldb/unittests/SymbolFile/DWARF/DWARFDIETest.cpp

- Version:         4
             - Value:           0x0000000000000008
         - AbbrCode:        0x00000000
 )";
 
   YAMLModuleTester t(yamldata);
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   DWARFUnit *unit = t.GetDwarfUnit();
-  const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
+  const DWARFDebugInfoEntry *die_first = unit->DIE(unit).GetDIE();
 
   // Create a DWARFDIE that has three DW_TAG_base_type children.
   DWARFDIE top_die(unit, die_first);
 
   // Create the iterator range that has the three tags as elements.
   llvm::iterator_range<DWARFDIE::child_iterator> children = top_die.children();
 
   // Compare begin() to the first child DIE.

lldb/unittests/SymbolFile/DWARF/DWARFUnitTest.cpp

- Version:         4
       Entries:
         - AbbrCode:        0x00000000
 )";
 
   YAMLModuleTester t(yamldata);
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   DWARFUnit *unit = t.GetDwarfUnit();
-  const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
+  const DWARFDebugInfoEntry *die_first = unit->DIE(unit).GetDIE();
   ASSERT_NE(die_first, nullptr);
   EXPECT_TRUE(die_first->IsNULL());
 }
 
 TEST(DWARFUnitTest, MissingSentinel) {
   // Make sure we don't crash if the debug info is missing a null DIE sentinel.
   const char *yamldata = R"(
 --- !ELF
- Version:         4
           Values:
             - Value:           0x000000000000000C
 )";
 
   YAMLModuleTester t(yamldata);
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   DWARFUnit *unit = t.GetDwarfUnit();
-  const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
+  const DWARFDebugInfoEntry *die_first = unit->DIE(unit).GetDIE();
   ASSERT_NE(die_first, nullptr);
   EXPECT_EQ(die_first->GetFirstChild(), nullptr);
   EXPECT_EQ(die_first->GetSibling(), nullptr);
 }