[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/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.h

 //===-- AppleDWARFIndex.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_APPLEDWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_APPLEDWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/HashedNameToDIE.h"
 
 namespace lldb_private {
 class AppleDWARFIndex : public DWARFIndex {
 public:
   static std::unique_ptr<AppleDWARFIndex>
   Create(Module &module, DWARFDataExtractor apple_names,
          DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
          DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str);
 
   AppleDWARFIndex(
       Module &module, std::unique_ptr<DWARFMappedHash::MemoryTable> apple_names,
       std::unique_ptr<DWARFMappedHash::MemoryTable> apple_namespaces,
       std::unique_ptr<DWARFMappedHash::MemoryTable> apple_types,
       std::unique_ptr<DWARFMappedHash::MemoryTable> apple_objc)
       : DWARFIndex(module), m_apple_names_up(std::move(apple_names)),
         m_apple_namespaces_up(std::move(apple_namespaces)),
         m_apple_types_up(std::move(apple_types)),
         m_apple_objc_up(std::move(apple_objc)) {}
 
   void Preload() override {}
 
+  void GetGlobalVariables(
+      ConstString basename,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
+  void GetGlobalVariables(
+      const RegularExpression &regex,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
+  void GetGlobalVariables(
+      const DWARFUnit &main_unit,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
   void
-  GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void
-  GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void
-  GetGlobalVariables(const DWARFUnit &cu,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetObjCMethods(ConstString class_name,
-                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+  GetObjCMethods(ConstString class_name,
+                 llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                     callback) override;
   void GetCompleteObjCClass(
       ConstString class_name, bool must_be_implementation,
-      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
   void GetTypes(ConstString name,
-                llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
   void GetTypes(const DWARFDeclContext &context,
-                llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetNamespaces(ConstString name,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
+  void
+  GetNamespaces(ConstString name,
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                        callback) override;
   void GetFunctions(const RegularExpression &regex,
-                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                        callback) override;
 
   void Dump(Stream &s) override;
 
 private:
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_names_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_namespaces_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_types_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_objc_up;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_APPLEDWARFINDEX_H

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

 //===-- AppleDWARFIndex.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/AppleDWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 
 using namespace lldb_private;
return std::make_unique<AppleDWARFIndex>(
         module, std::move(apple_names_table_up),
         std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
         std::move(apple_objc_table_up));
 
   return nullptr;
 }
 
 void AppleDWARFIndex::GetGlobalVariables(
-    ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString basename,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
   m_apple_names_up->FindByName(
       basename.GetStringRef(),
       DIERefCallback(callback, basename.GetStringRef()));
 }
 
 void AppleDWARFIndex::GetGlobalVariables(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
   m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data);
   // This is not really the DIE name.
   DWARFMappedHash::ExtractDIEArray(hash_data,
                                    DIERefCallback(callback, regex.GetText()));
 }
 
 void AppleDWARFIndex::GetGlobalVariables(
-    const DWARFUnit &cu, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    const DWARFUnit &main_unit,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
-  m_apple_names_up->AppendAllDIEsInRange(cu.GetOffset(), cu.GetNextUnitOffset(),
-                                         hash_data);
+  m_apple_names_up->AppendAllDIEsInRange(
+      main_unit.GetOffset(), main_unit.GetNextUnitOffset(), hash_data);
   DWARFMappedHash::ExtractDIEArray(hash_data, DIERefCallback(callback));
 }
 
 void AppleDWARFIndex::GetObjCMethods(
-    ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString class_name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_objc_up)
     return;
   m_apple_objc_up->FindByName(
       class_name.GetStringRef(),
       DIERefCallback(callback, class_name.GetStringRef()));
 }
 
 void AppleDWARFIndex::GetCompleteObjCClass(
     ConstString class_name, bool must_be_implementation,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_types_up)
     return;
   m_apple_types_up->FindCompleteObjCClassByName(
       class_name.GetStringRef(),
       DIERefCallback(callback, class_name.GetStringRef()),
       must_be_implementation);
 }
 
 void AppleDWARFIndex::GetTypes(
-    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_types_up)
     return;
   m_apple_types_up->FindByName(name.GetStringRef(),
                                DIERefCallback(callback, name.GetStringRef()));
 }
 
 void AppleDWARFIndex::GetTypes(
     const DWARFDeclContext &context,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_types_up)
     return;
 
   Log *log = LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                           DWARF_LOG_LOOKUPS);
   const bool has_tag = m_apple_types_up->GetHeader().header_data.ContainsAtom(
       DWARFMappedHash::eAtomTypeTag);
   const bool has_qualified_name_hash =
void AppleDWARFIndex::GetTypes(
   }
 
   m_apple_types_up->FindByName(
       type_name.GetStringRef(),
       DIERefCallback(callback, type_name.GetStringRef()));
 }
 
 void AppleDWARFIndex::GetNamespaces(
-    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_namespaces_up)
     return;
   m_apple_namespaces_up->FindByName(
       name.GetStringRef(), DIERefCallback(callback, name.GetStringRef()));
 }
 
 void AppleDWARFIndex::GetFunctions(
     ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   m_apple_names_up->FindByName(name.GetStringRef(), [&](DIERef die_ref) {
-    return ProcessFunctionDIE(name.GetStringRef(), die_ref, dwarf,
-                              parent_decl_ctx, name_type_mask, callback);
+    return ProcessFunctionDIE(name.GetStringRef(), nullptr /* main_unit */,
+                              die_ref, dwarf, parent_decl_ctx, name_type_mask,
+                              callback);
   });
 }
 
 void AppleDWARFIndex::GetFunctions(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
   m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data);
   DWARFMappedHash::ExtractDIEArray(hash_data,
                                    DIERefCallback(callback, regex.GetText()));
 }

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

 //===-- DIERef.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_DIEREF_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DIEREF_H
 
 #include "lldb/Core/dwarf.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FormatProviders.h"
 #include <cassert>
 #include <vector>
 
 /// Identifies a DWARF debug info entry within a given Module. It contains three
 /// "coordinates":
 /// - dwo_num: identifies the dwo file in the Module. If this field is not set,
if (m_dwo_num_valid != other.m_dwo_num_valid)
       return m_dwo_num_valid < other.m_dwo_num_valid;
     if (m_dwo_num_valid && (m_dwo_num != other.m_dwo_num))
       return m_dwo_num < other.m_dwo_num;
     if (m_section != other.m_section)
       return m_section < other.m_section;
     return m_die_offset < other.m_die_offset;
   }
 
+  bool operator==(DIERef other) const {
+    if (m_dwo_num_valid != other.m_dwo_num_valid ||
+        m_section != other.m_section || m_die_offset != other.m_die_offset)
+      return false;
+    if (m_dwo_num_valid && m_dwo_num != other.m_dwo_num)
+      return false;
+    return true;
+  }
+
 private:
   uint32_t m_dwo_num : 30;
   uint32_t m_dwo_num_valid : 1;
   uint32_t m_section : 1;
   dw_offset_t m_die_offset;
 };
 static_assert(sizeof(DIERef) == 8, "");
 

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

virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                           const DWARFDIE &die,
                                           bool *type_is_new_ptr) = 0;
 
   virtual lldb_private::Function *
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) = 0;
 
   virtual bool
-  CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
+  CompleteTypeFromDWARF(DWARFUnit *main_unit, const DWARFDIE &die,
+                        lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) = 0;
 
   virtual lldb_private::CompilerDecl
-  GetDeclForUIDFromDWARF(const DWARFDIE &die) = 0;
+  GetDeclForUIDFromDWARF(DWARFUnit *main_unit, const DWARFDIE &die) = 0;
 
   virtual lldb_private::CompilerDeclContext
-  GetDeclContextForUIDFromDWARF(const DWARFDIE &die) = 0;
+  GetDeclContextForUIDFromDWARF(DWARFUnit *main_unit, const DWARFDIE &die) = 0;
 
   virtual lldb_private::CompilerDeclContext
-  GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) = 0;
+  GetDeclContextContainingUIDFromDWARF(DWARFUnit *main_unit,
+                                       const DWARFDIE &die) = 0;
 
   virtual void EnsureAllDIEsInDeclContextHaveBeenParsed(
       lldb_private::CompilerDeclContext decl_context) = 0;
 
   static llvm::Optional<lldb_private::SymbolFile::ArrayInfo>
   ParseChildArrayInfo(const DWARFDIE &parent_die,
                       const lldb_private::ExecutionContext *exe_ctx = nullptr);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSER_H

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

 //===-- DWARFASTParserClang.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_DWARFASTPARSERCLANG_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H
 
 #include "clang/AST/CharUnits.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFDIE.h"
 #include "DWARFDefines.h"
 #include "DWARFFormValue.h"
lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                   const DWARFDIE &die,
                                   bool *type_is_new_ptr) override;
 
   lldb_private::Function *
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) override;
 
   bool
-  CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
+  CompleteTypeFromDWARF(DWARFUnit *main_unit, const DWARFDIE &die,
+                        lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) override;
 
   lldb_private::CompilerDecl
-  GetDeclForUIDFromDWARF(const DWARFDIE &die) override;
+  GetDeclForUIDFromDWARF(DWARFUnit *main_unit, const DWARFDIE &die) override;
 
   void EnsureAllDIEsInDeclContextHaveBeenParsed(
       lldb_private::CompilerDeclContext decl_context) override;
 
   lldb_private::CompilerDeclContext
-  GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override;
+  GetDeclContextForUIDFromDWARF(DWARFUnit *main_unit,
+                                const DWARFDIE &die) override;
 
   lldb_private::CompilerDeclContext
-  GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) override;
+  GetDeclContextContainingUIDFromDWARF(DWARFUnit *main_unit,
+                                       const DWARFDIE &die) override;
 
   lldb_private::ClangASTImporter &GetClangASTImporter();
 
 protected:
   /// Protected typedefs and members.
   /// @{
   class DelayedAddObjCClassProperty;
   typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
 
-  typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
+  typedef llvm::SmallSet<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>, 4>
+      DIEPointerSet;
+  typedef llvm::DenseMap<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>,
+                         clang::DeclContext *>
       DIEToDeclContextMap;
-  typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
+  typedef std::multimap<const clang::DeclContext *,
+                        std::pair<DWARFUnit *, const DWARFDIE>>
       DeclContextToDIEMap;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
-                         lldb_private::OptionalClangModuleID>
+  typedef llvm::DenseMap<
+      std::pair<const DWARFUnit *, const DWARFDebugInfoEntry *>,
       DIEToModuleMap;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
+  typedef llvm::DenseMap<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>,
+                         clang::Decl *>
       DIEToDeclMap;
   typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
   lldb_private::TypeSystemClang &m_ast;
   DIEToDeclMap m_die_to_decl;
   DeclToDIEMap m_decl_to_die;
   DIEToDeclContextMap m_die_to_decl_ctx;
   DeclContextToDIEMap m_decl_ctx_to_die;
   DIEToModuleMap m_die_to_module;
   std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
   /// @}
 
-  clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
+  clang::DeclContext *GetDeclContextForBlock(DWARFUnit *main_unit,
+                                             const DWARFDIE &die);
 
-  clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);
+  clang::BlockDecl *ResolveBlockDIE(DWARFUnit *main_unit, const DWARFDIE &die);
 
-  clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die);
+  clang::NamespaceDecl *ResolveNamespaceDIE(DWARFUnit *main_unit,
+                                            const DWARFDIE &die);
 
-  bool ParseTemplateDIE(const DWARFDIE &die,
+  bool ParseTemplateDIE(DWARFUnit *main_unit, const DWARFDIE &die,
                         lldb_private::TypeSystemClang::TemplateParameterInfos
                             &template_param_infos);
   bool ParseTemplateParameterInfos(
-      const DWARFDIE &parent_die,
+      DWARFUnit *main_unit, const DWARFDIE &parent_die,
       lldb_private::TypeSystemClang::TemplateParameterInfos
           &template_param_infos);
 
   bool ParseChildMembers(
+      lldb_private::CompileUnit *comp_unit, DWARFUnit *main_unit,
       const DWARFDIE &die, lldb_private::CompilerType &class_compiler_type,
       std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
       std::vector<int> &member_accessibilities,
       std::vector<DWARFDIE> &member_function_dies,
       DelayedPropertyList &delayed_properties,
       lldb::AccessType &default_accessibility, bool &is_a_class,
       lldb_private::ClangASTImporter::LayoutInfo &layout_info);
 
   size_t
-  ParseChildParameters(clang::DeclContext *containing_decl_ctx,
-                       const DWARFDIE &parent_die, bool skip_artificial,
-                       bool &is_static, bool &is_variadic,
+  ParseChildParameters(lldb_private::CompileUnit *comp_unit,
+                       clang::DeclContext *containing_decl_ctx,
+                       DWARFUnit *main_unit, const DWARFDIE &parent_die,
+                       bool skip_artificial, bool &is_static, bool &is_variadic,
                        bool &has_template_params,
                        std::vector<lldb_private::CompilerType> &function_args,
                        std::vector<clang::ParmVarDecl *> &function_param_decls,
                        unsigned &type_quals);
 
   size_t ParseChildEnumerators(lldb_private::CompilerType &compiler_type,
                                bool is_signed, uint32_t enumerator_byte_size,
                                const DWARFDIE &parent_die);
 
   /// Parse a structure, class, or union type DIE.
   lldb::TypeSP ParseStructureLikeDIE(const lldb_private::SymbolContext &sc,
                                      const DWARFDIE &die,
                                      ParsedDWARFTypeAttributes &attrs);
 
-  lldb_private::Type *GetTypeForDIE(const DWARFDIE &die);
+  lldb_private::Type *GetTypeForDIE(DWARFUnit *main_unit, const DWARFDIE &die);
 
-  clang::Decl *GetClangDeclForDIE(const DWARFDIE &die);
+  clang::Decl *GetClangDeclForDIE(DWARFUnit *main_unit, const DWARFDIE &die);
 
-  clang::DeclContext *GetClangDeclContextForDIE(const DWARFDIE &die);
+  clang::DeclContext *GetClangDeclContextForDIE(DWARFUnit *main_unit,
+                                                const DWARFDIE &die);
 
-  clang::DeclContext *GetClangDeclContextContainingDIE(const DWARFDIE &die,
+  clang::DeclContext *GetClangDeclContextContainingDIE(DWARFUnit *main_unit,
+                                                       const DWARFDIE &die,
                                                        DWARFDIE *decl_ctx_die);
-  lldb_private::OptionalClangModuleID GetOwningClangModule(const DWARFDIE &die);
+  lldb_private::OptionalClangModuleID GetOwningClangModule(DWARFUnit *main_unit,
+                                                           const DWARFDIE &die);
 
-  bool CopyUniqueClassMethodTypes(const DWARFDIE &src_class_die,
+  bool CopyUniqueClassMethodTypes(DWARFUnit *main_unit,
+                                  const DWARFDIE &src_class_die,
                                   const DWARFDIE &dst_class_die,
                                   lldb_private::Type *class_type,
                                   std::vector<DWARFDIE> &failures);
 
-  clang::DeclContext *GetCachedClangDeclContextForDIE(const DWARFDIE &die);
+  clang::DeclContext *GetCachedClangDeclContextForDIE(DWARFUnit *main_unit,
+                                                      const DWARFDIE &die);
 
-  void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, const DWARFDIE &die);
+  void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, DWARFUnit *main_unit,
+                            const DWARFDIE &die);
 
   void LinkDeclToDIE(clang::Decl *decl, const DWARFDIE &die);
 
   /// If \p type_sp is valid, calculate and set its symbol context scope, and
   /// update the type list for its backing symbol file.
   ///
   /// Returns \p type_sp.
   lldb::TypeSP
struct FieldInfo {
     bool NextBitfieldOffsetIsValid(const uint64_t next_bit_offset) const {
       // Any subsequent bitfields must not overlap and must be at a higher
       // bit offset than any previous bitfield + size.
       return (bit_size + bit_offset) <= next_bit_offset;
     }
   };
 
   void
-  ParseSingleMember(const DWARFDIE &die, const DWARFDIE &parent_die,
+  ParseSingleMember(lldb_private::CompileUnit *comp_unit, DWARFUnit *main_unit,
+                    const DWARFDIE &die, const DWARFDIE &parent_die,
                     const lldb_private::CompilerType &class_clang_type,
                     std::vector<int> &member_accessibilities,
                     lldb::AccessType default_accessibility,
                     DelayedPropertyList &delayed_properties,
                     lldb_private::ClangASTImporter::LayoutInfo &layout_info,
                     FieldInfo &last_field_info);
 
-  bool CompleteRecordType(const DWARFDIE &die, lldb_private::Type *type,
+  bool CompleteRecordType(DWARFUnit *main_unit, const DWARFDIE &die,
+                          lldb_private::Type *type,
                           lldb_private::CompilerType &clang_type);
   bool CompleteEnumType(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &clang_type);
 
   lldb::TypeSP ParseTypeModifier(const lldb_private::SymbolContext &sc,
                                  const DWARFDIE &die,
                                  ParsedDWARFTypeAttributes &attrs);
   lldb::TypeSP ParseEnum(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die, ParsedDWARFTypeAttributes &attrs);
-  lldb::TypeSP ParseSubroutine(const DWARFDIE &die,
+  lldb::TypeSP ParseSubroutine(const lldb_private::SymbolContext &sc,
+                               const DWARFDIE &die,
                                ParsedDWARFTypeAttributes &attrs);
   // FIXME: attrs should be passed as a const reference.
-  lldb::TypeSP ParseArrayType(const DWARFDIE &die,
+  lldb::TypeSP ParseArrayType(const lldb_private::SymbolContext &sc,
+                              const DWARFDIE &die,
                               ParsedDWARFTypeAttributes &attrs);
-  lldb::TypeSP ParsePointerToMemberType(const DWARFDIE &die,
+  lldb::TypeSP ParsePointerToMemberType(const lldb_private::SymbolContext &sc,
+                                        const DWARFDIE &die,
                                         const ParsedDWARFTypeAttributes &attrs);
 };
 
 /// Parsed form of all attributes that are relevant for type reconstruction.
 /// Some attributes are relevant for all kinds of types (declaration), while
 /// others are only meaningful to a specific type (is_virtual)
 struct ParsedDWARFTypeAttributes {
   explicit ParsedDWARFTypeAttributes(const DWARFDIE &die);

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 <stdlib.h>
 
 #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"
 

 
 TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
                                                      const DWARFDIE &die,
                                                      Log *log) {
   ModuleSP clang_module_sp = GetContainingClangModule(die);
   if (!clang_module_sp)
     return TypeSP();
 
+  SymbolFileDWARF *dwarf;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
+
   // 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::GetLanguage(*die.GetCU()));
+  languages.Insert(
+      SymbolFileDWARF::GetLanguage(*die.GetMainDWARFUnit(main_unit)));
   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.
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();
-  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))));
+  TypeSP type_sp(new Type(
+      die.GetID(main_unit), dwarf, pcm_type_sp->GetName(),
+      pcm_type_sp->GetByteSize(nullptr), sc.comp_unit, LLDB_INVALID_UID,
+      Type::eEncodingInvalid, &pcm_type_sp->GetDeclaration(), type,
+      TypePayloadClang(GetOwningClangModule(main_unit, die))));
 
   dwarf->GetTypeList().Insert(type_sp);
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = type_sp.get();
   clang::TagDecl *tag_decl = TypeSystemClang::GetAsTagDecl(type);
   if (tag_decl) {
-    LinkDeclContextToDIE(tag_decl, die);
+    LinkDeclContextToDIE(tag_decl, main_unit, die);
   } else {
-    clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
+    clang::DeclContext *defn_decl_ctx =
+        GetCachedClangDeclContextForDIE(main_unit, die);
     if (defn_decl_ctx)
-      LinkDeclContextToDIE(defn_decl_ctx, die);
+      LinkDeclContextToDIE(defn_decl_ctx, main_unit, die);
   }
 
   return type_sp;
 }
 
 static void ForcefullyCompleteType(CompilerType type) {
   bool started = TypeSystemClang::StartTagDeclarationDefinition(type);
   lldbassert(started && "Unable to start a class type definition.");
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;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
   if (log) {
     DWARFDIE context_die;
     clang::DeclContext *context =
-        GetClangDeclContextContainingDIE(die, &context_die);
+        GetClangDeclContextContainingDIE(main_unit, 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());
   }
 
-  Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE());
+  Type *type_ptr =
+      dwarf->GetDIEToType().lookup(die.MainUnitToDIEPair(main_unit));
   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->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = DIE_IS_BEING_PARSED;
 
   ParsedDWARFTypeAttributes attrs(die);
 
   if (DWARFDIE signature_die = attrs.signature.Reference()) {
     if (TypeSP type_sp =
             ParseTypeFromDWARF(sc, signature_die, type_is_new_ptr)) {
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+      dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = type_sp.get();
       if (clang::DeclContext *decl_ctx =
-              GetCachedClangDeclContextForDIE(signature_die))
-        LinkDeclContextToDIE(decl_ctx, die);
+              GetCachedClangDeclContextForDIE(main_unit, signature_die))
+        LinkDeclContextToDIE(decl_ctx, main_unit, die);
       return type_sp;
     }
     return nullptr;
   }
 
   if (type_is_new_ptr)
     *type_is_new_ptr = true;
 
TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
   case DW_TAG_enumeration_type: {
     type_sp = ParseEnum(sc, die, attrs);
     break;
   }
 
   case DW_TAG_inlined_subroutine:
   case DW_TAG_subprogram:
   case DW_TAG_subroutine_type: {
-    type_sp = ParseSubroutine(die, attrs);
+    type_sp = ParseSubroutine(sc, die, attrs);
     break;
   }
   case DW_TAG_array_type: {
-    type_sp = ParseArrayType(die, attrs);
+    type_sp = ParseArrayType(sc, die, attrs);
     break;
   }
   case DW_TAG_ptr_to_member_type: {
-    type_sp = ParsePointerToMemberType(die, attrs);
+    type_sp = ParsePointerToMemberType(sc, die, attrs);
     break;
   }
   default:
     dwarf->GetObjectFile()->GetModule()->ReportError(
         "{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and "
         "attach the file at the start of this error message",
         die.GetOffset(), tag, DW_TAG_value_to_name(tag));
     break;
   }
 
   // TODO: We should consider making the switch above exhaustive to simplify
   // control flow in ParseTypeFromDWARF. Then, we could simply replace this
   // return statement with a call to llvm_unreachable.
   return UpdateSymbolContextScopeForType(sc, die, 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;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
   const dw_tag_t tag = die.Tag();
-  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
+  LanguageType cu_language =
+      SymbolFileDWARF::GetLanguage(*die.GetMainDWARFUnit(main_unit));
   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.
     PrepareContextToReceiveMembers(
         m_ast, GetClangASTImporter(),
-        GetClangDeclContextContainingDIE(die, nullptr), die,
+        GetClangDeclContextContainingDIE(main_unit, die, nullptr), die,
         attrs.name.GetCString());
 
     if (attrs.type.IsValid()) {
       // Try to parse a typedef from the (DWARF embedded in the) Clang
       // module file first as modules can contain typedef'ed
       // structures that have no names like:
       //
       //  typedef struct { int a; } Foo;
if (cu_language == eLanguageTypeObjC ||
             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)));
+      die.GetID(main_unit), dwarf, attrs.name, attrs.byte_size, sc.comp_unit,
+      dwarf->GetUID(main_unit, attrs.type.Reference()), encoding_data_type,
+      &attrs.decl, clang_type, resolve_state,
+      TypePayloadClang(GetOwningClangModule(main_unit, die)));
 
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = 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();
   const dw_tag_t tag = die.Tag();
   TypeSP type_sp;
 
+  SymbolFileDWARF *dwarf;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
   if (attrs.is_forward_declaration) {
     type_sp = ParseTypeFromClangModule(sc, die, log);
     if (type_sp)
       return type_sp;
 
-    DWARFDeclContext die_decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
+    DWARFDeclContext die_decl_ctx =
+        SymbolFileDWARF::GetDWARFDeclContext(main_unit, die);
 
     type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
 
     if (!type_sp) {
       SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile();
       if (debug_map_symfile) {
         // We weren't able to find a full declaration in this DWARF,
         // see if we have a declaration anywhere else...
if (type_sp) {
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             type_sp->GetID());
       }
 
       // We found a real definition for this type elsewhere so lets use
       // it and cache the fact that we found a complete type for this
       // die
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
-      clang::DeclContext *defn_decl_ctx =
-          GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
+      dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = type_sp.get();
+      clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(
+          main_unit, dwarf->GetDIE(type_sp->GetID()));
       if (defn_decl_ctx)
-        LinkDeclContextToDIE(defn_decl_ctx, die);
+        LinkDeclContextToDIE(defn_decl_ctx, main_unit, die);
       return type_sp;
     }
   }
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
   CompilerType enumerator_clang_type;
   CompilerType clang_type;
-  clang_type.SetCompilerType(
-      &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
+  clang_type.SetCompilerType(&m_ast,
+                             dwarf->GetForwardDeclDieToClangType().lookup(
+                                 die.MainUnitToDIEPair(main_unit)));
   if (!clang_type) {
     if (attrs.type.IsValid()) {
       Type *enumerator_type =
-          dwarf->ResolveTypeUID(attrs.type.Reference(), true);
+          dwarf->ResolveTypeUID(main_unit, attrs.type.Reference(), 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);
       } else {
         enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt);
       }
     }
 
     clang_type = m_ast.CreateEnumerationType(
-        attrs.name.GetCString(), GetClangDeclContextContainingDIE(die, nullptr),
-        GetOwningClangModule(die), attrs.decl, enumerator_clang_type,
+        attrs.name.GetCString(),
+        GetClangDeclContextContainingDIE(main_unit, die, nullptr),
+        GetOwningClangModule(main_unit, die), attrs.decl, enumerator_clang_type,
         attrs.is_scoped_enum);
   } else {
     enumerator_clang_type = m_ast.GetEnumerationIntegerType(clang_type);
   }
 
-  LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type), die);
+  LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type),
+                       main_unit, 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)));
+      die.GetID(main_unit), dwarf, attrs.name, attrs.byte_size, sc.comp_unit,
+      dwarf->GetUID(main_unit, attrs.type.Reference()), Type::eEncodingIsUID,
+      &attrs.decl, clang_type, Type::ResolveState::Forward,
+      TypePayloadClang(GetOwningClangModule(main_unit, 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,
+TypeSP DWARFASTParserClang::ParseSubroutine(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;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
   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(main_unit, attrs.type.Reference(), 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;
 
   // Parse the function children for the parameters
 
   DWARFDIE decl_ctx_die;
   clang::DeclContext *containing_decl_ctx =
-      GetClangDeclContextContainingDIE(die, &decl_ctx_die);
+      GetClangDeclContextContainingDIE(main_unit, die, &decl_ctx_die);
   const clang::Decl::Kind containing_decl_kind =
       containing_decl_ctx->getDeclKind();
 
   bool is_cxx_method = DeclKindIsCXXClass(containing_decl_kind);
   // Start off static. This will be set to false in
   // ParseChildParameters(...) if we find a "this" parameters as the
   // first parameter
   if (is_cxx_method) {
     is_static = true;
   }
 
   if (die.HasChildren()) {
     bool skip_artificial = true;
-    ParseChildParameters(containing_decl_ctx, die, skip_artificial, is_static,
-                         is_variadic, has_template_params,
-                         function_param_types, function_param_decls,
-                         type_quals);
+    ParseChildParameters(sc.comp_unit, containing_decl_ctx, main_unit, die,
+                         skip_artificial, is_static, is_variadic,
+                         has_template_params, function_param_types,
+                         function_param_decls, type_quals);
   }
 
   bool ignore_containing_context = false;
   // Check for templatized class member functions. If we had any
   // DW_TAG_template_type_parameter or DW_TAG_template_value_parameter
   // the DW_TAG_subprogram DIE, then we can't let this become a method in
   // a class. Why? Because templatized functions are only emitted if one
   // of the templatized methods is used in the current compile unit and
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
 
           clang::ObjCMethodDecl *objc_method_decl =
               m_ast.AddMethodToObjCObjectType(
                   class_opaque_type, attrs.name.GetCString(), clang_type,
                   attrs.accessibility, attrs.is_artificial, is_variadic,
                   attrs.is_objc_direct_call);
           type_handled = objc_method_decl != NULL;
           if (type_handled) {
-            LinkDeclContextToDIE(objc_method_decl, die);
-            m_ast.SetMetadataAsUserID(objc_method_decl, die.GetID());
+            LinkDeclContextToDIE(objc_method_decl, main_unit, die);
+            m_ast.SetMetadataAsUserID(objc_method_decl, die.GetID(main_unit));
           } else {
             dwarf->GetObjectFile()->GetModule()->ReportError(
                 "{0x%8.8x}: invalid Objective-C method 0x%4.4x (%s), "
                 "please file a bug and attach the file at the start of "
                 "this error message",
                 die.GetOffset(), tag, DW_TAG_value_to_name(tag));
           }
         }
       } else if (is_cxx_method) {
         // Look at the parent of this DIE and see if is is a class or
         // struct and see if this is actually a C++ method
-        Type *class_type = dwarf->ResolveType(decl_ctx_die);
+        Type *class_type = dwarf->ResolveType(main_unit, decl_ctx_die);
         if (class_type) {
           bool alternate_defn = false;
-          if (class_type->GetID() != decl_ctx_die.GetID() ||
+          if (class_type->GetID() != decl_ctx_die.GetID(main_unit) ||
               IsClangModuleFwdDecl(decl_ctx_die)) {
             alternate_defn = true;
 
             // We uniqued the parent class of this function to another
             // class so we now need to associate all dies under
             // "decl_ctx_die" to DIEs in the DIE for "class_type"...
             DWARFDIE class_type_die = dwarf->GetDIE(class_type->GetID());
 
             if (class_type_die) {
               std::vector<DWARFDIE> failures;
 
-              CopyUniqueClassMethodTypes(decl_ctx_die, class_type_die,
-                                         class_type, failures);
+              CopyUniqueClassMethodTypes(main_unit, decl_ctx_die,
+                                         class_type_die, class_type, failures);
 
               // FIXME do something with these failures that's
               // smarter than just dropping them on the ground.
               // Unfortunately classes don't like having stuff added
               // to them after their definitions are complete...
 
-              Type *type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+              Type *type_ptr =
+                  dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)];
               if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                 return type_ptr->shared_from_this();
               }
             }
           }
 
           if (attrs.specification.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_die_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();
             clang::DeclContext *spec_clang_decl_ctx =
-                GetClangDeclContextForDIE(spec_die);
+                GetClangDeclContextForDIE(main_unit, spec_die);
             if (spec_clang_decl_ctx) {
-              LinkDeclContextToDIE(spec_clang_decl_ctx, die);
+              LinkDeclContextToDIE(spec_clang_decl_ctx, main_unit, 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());
+                  die.GetID(main_unit), 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_die_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();
             clang::DeclContext *abs_clang_decl_ctx =
-                GetClangDeclContextForDIE(abs_die);
+                GetClangDeclContextForDIE(main_unit, abs_die);
             if (abs_clang_decl_ctx) {
-              LinkDeclContextToDIE(abs_clang_decl_ctx, die);
+              LinkDeclContextToDIE(abs_clang_decl_ctx, main_unit, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x"
                   ") has no decl\n",
-                  die.GetID(), abs_die.GetOffset());
+                  die.GetID(main_unit), abs_die.GetOffset());
             }
             type_handled = true;
           } else {
             CompilerType class_opaque_type =
                 class_type->GetForwardCompilerType();
             if (TypeSystemClang::IsCXXClassType(class_opaque_type)) {
               if (class_opaque_type.IsBeingDefined() || alternate_defn) {
                 if (!is_static && !die.HasChildren()) {
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                            method_iter != record_decl->method_end();
                            method_iter++) {
                         clang::CXXMethodDecl *method_decl = *method_iter;
                         if (method_decl->getNameInfo().getAsString() ==
                             attrs.name.GetStringRef()) {
                           if (method_decl->getType() ==
                               ClangUtil::GetQualType(clang_type)) {
                             add_method = false;
-                            LinkDeclContextToDIE(method_decl, die);
+                            LinkDeclContextToDIE(method_decl, main_unit, die);
                             type_handled = true;
 
                             break;
                           }
                         }
                       }
                     }
                   }
 
                   if (add_method) {
                     llvm::PrettyStackTraceFormat stack_trace(
                         "SymbolFileDWARF::ParseType() is adding a method "
                         "%s to class %s in DIE 0x%8.8" PRIx64 " from %s",
                         attrs.name.GetCString(),
-                        class_type->GetName().GetCString(), die.GetID(),
+                        class_type->GetName().GetCString(),
+                        die.GetID(main_unit),
                         dwarf->GetObjectFile()
                             ->GetFileSpec()
                             .GetPath()
                             .c_str());
 
                     const bool is_attr_used = false;
                     // Neither GCC 4.2 nor clang++ currently set a valid
                     // accessibility in the DWARF for C++ methods...
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                             is_attr_used, attrs.is_artificial);
 
                     type_handled = cxx_method_decl != NULL;
                     // Artificial methods are always handled even when we
                     // don't create a new declaration for them.
                     type_handled |= attrs.is_artificial;
 
                     if (cxx_method_decl) {
-                      LinkDeclContextToDIE(cxx_method_decl, die);
+                      LinkDeclContextToDIE(cxx_method_decl, main_unit, die);
 
                       ClangASTMetadata metadata;
-                      metadata.SetUserID(die.GetID());
+                      metadata.SetUserID(die.GetID(main_unit));
 
                       if (!object_pointer_name.empty()) {
                         metadata.SetObjectPtrName(
                             object_pointer_name.c_str());
                         LLDB_LOGF(log,
                                   "Setting object pointer name: %s on method "
                                   "object %p.\n",
                                   object_pointer_name.c_str(),
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                 // itself through the clang::ExternalASTSource protocol,
                 // so we need to just have the class complete itself and
                 // do things the right way, then our
                 // DIE should then have an entry in the
                 // dwarf->GetDIEToType() map. First
                 // we need to modify the dwarf->GetDIEToType() so it
                 // doesn't think we are trying to parse this DIE
                 // anymore...
-                dwarf->GetDIEToType()[die.GetDIE()] = NULL;
+                dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = NULL;
 
                 // Now we get the full type to force our class type to
                 // complete itself using the clang::ExternalASTSource
                 // protocol which will parse all base classes and all
                 // methods (including the method for this DIE).
                 class_type->GetFullCompilerType();
 
                 // The type for this DIE should have been filled in the
                 // function call above
-                Type *type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+                Type *type_ptr =
+                    dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)];
                 if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                   return type_ptr->shared_from_this();
                 }
 
                 // FIXME This is fixing some even uglier behavior but we
                 // really need to
                 // uniq the methods of each class as well as the class
                 // itself. <rdar://problem/11240464>
                 type_handled = true;
               }
             }
           }
         }
       }
     }
 
     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();
 
-        if (dwarf->ResolveType(abs_die)) {
+        if (dwarf->ResolveType(main_unit, abs_die)) {
           function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(
-              GetCachedClangDeclContextForDIE(abs_die));
+              GetCachedClangDeclContextForDIE(main_unit, abs_die));
 
           if (function_decl) {
-            LinkDeclContextToDIE(function_decl, die);
+            LinkDeclContextToDIE(function_decl, main_unit, die);
           }
         }
       }
 
       if (!function_decl) {
         llvm::StringRef name = attrs.name.GetStringRef();
 
         // We currently generate function templates with template parameters in
         // their name. In order to get closer to the AST that clang generates
         // we want to strip these from the name when creating the AST.
         if (attrs.mangled_name) {
           llvm::ItaniumPartialDemangler D;
           if (!D.partialDemangle(attrs.mangled_name))
             name = D.getFunctionBaseName(nullptr, nullptr);
         }
 
         // We just have a function that isn't part of a class
         function_decl = m_ast.CreateFunctionDeclaration(
             ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                       : containing_decl_ctx,
-            GetOwningClangModule(die), name, clang_type, attrs.storage,
-            attrs.is_inline);
+            GetOwningClangModule(main_unit, die), name, clang_type,
+            attrs.storage, attrs.is_inline);
 
         if (has_template_params) {
           TypeSystemClang::TemplateParameterInfos template_param_infos;
-          ParseTemplateParameterInfos(die, template_param_infos);
+          ParseTemplateParameterInfos(main_unit, die, template_param_infos);
           template_function_decl = m_ast.CreateFunctionDeclaration(
               ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                         : containing_decl_ctx,
-              GetOwningClangModule(die), attrs.name.GetStringRef(), clang_type,
-              attrs.storage, attrs.is_inline);
+              GetOwningClangModule(main_unit, die), attrs.name.GetStringRef(),
+              clang_type, attrs.storage, attrs.is_inline);
           clang::FunctionTemplateDecl *func_template_decl =
               m_ast.CreateFunctionTemplateDecl(
-                  containing_decl_ctx, GetOwningClangModule(die),
+                  containing_decl_ctx, GetOwningClangModule(main_unit, die),
                   template_function_decl, template_param_infos);
           m_ast.CreateFunctionTemplateSpecializationInfo(
               template_function_decl, func_template_decl, template_param_infos);
         }
 
         lldbassert(function_decl);
 
         if (function_decl) {
-          LinkDeclContextToDIE(function_decl, die);
+          LinkDeclContextToDIE(function_decl, main_unit, die);
 
           if (!function_param_decls.empty()) {
             m_ast.SetFunctionParameters(function_decl,
                                         &function_param_decls.front(),
                                         function_param_decls.size());
             if (template_function_decl)
               m_ast.SetFunctionParameters(template_function_decl,
                                           &function_param_decls.front(),
                                           function_param_decls.size());
           }
 
           ClangASTMetadata metadata;
-          metadata.SetUserID(die.GetID());
+          metadata.SetUserID(die.GetID(main_unit));
 
           if (!object_pointer_name.empty()) {
             metadata.SetObjectPtrName(object_pointer_name.c_str());
             LLDB_LOGF(log,
                       "Setting object pointer name: %s on function "
                       "object %p.",
                       object_pointer_name.c_str(),
                       static_cast<void *>(function_decl));
           }
           m_ast.SetMetadata(function_decl, metadata);
         }
       }
     }
   }
-  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);
+  return std::make_shared<Type>(die.GetID(main_unit), dwarf, attrs.name,
+                                llvm::None, sc.comp_unit, LLDB_INVALID_UID,
+                                Type::eEncodingIsUID, &attrs.decl, clang_type,
+                                Type::ResolveState::Full);
 }
 
-TypeSP DWARFASTParserClang::ParseArrayType(const DWARFDIE &die,
+TypeSP DWARFASTParserClang::ParseArrayType(const SymbolContext &sc,
+                                           const DWARFDIE &die,
                                            ParsedDWARFTypeAttributes &attrs) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
-
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
+  SymbolFileDWARF *dwarf;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
   DWARFDIE type_die = attrs.type.Reference();
-  Type *element_type = dwarf->ResolveTypeUID(type_die, true);
+  Type *element_type = dwarf->ResolveTypeUID(main_unit, 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;
     attrs.bit_stride = array_info->bit_stride;
for (auto pos = array_info->element_orders.rbegin(); pos != end; ++pos) {
                                      : array_element_bit_stride;
     }
   } else {
     clang_type =
         m_ast.CreateArrayType(array_element_type, 0, attrs.is_vector);
   }
   ConstString empty_name;
   TypeSP type_sp = std::make_shared<Type>(
-      die.GetID(), dwarf, empty_name, array_element_bit_stride / 8, nullptr,
-      dwarf->GetUID(type_die), Type::eEncodingIsUID, &attrs.decl, clang_type,
-      Type::ResolveState::Full);
+      die.GetID(main_unit), dwarf, empty_name, array_element_bit_stride / 8,
+      sc.comp_unit, dwarf->GetUID(main_unit, type_die), Type::eEncodingIsUID,
+      &attrs.decl, clang_type, Type::ResolveState::Full);
   type_sp->SetEncodingType(element_type);
   const clang::Type *type = ClangUtil::GetQualType(clang_type).getTypePtr();
-  m_ast.SetMetadataAsUserID(type, die.GetID());
+  m_ast.SetMetadataAsUserID(type, die.GetID(main_unit));
   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);
+    const SymbolContext &sc, const DWARFDIE &die,
+    const ParsedDWARFTypeAttributes &attrs) {
+  SymbolFileDWARF *dwarf;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
+  Type *pointee_type =
+      dwarf->ResolveTypeUID(main_unit, attrs.type.Reference(), true);
   Type *class_type =
-      dwarf->ResolveTypeUID(attrs.containing_type.Reference(), true);
+      dwarf->ResolveTypeUID(main_unit, attrs.containing_type.Reference(), true);
 
   CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType();
   CompilerType class_clang_type = class_type->GetLayoutCompilerType();
 
   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);
-  }
+          clang_type.GetByteSize(nullptr))
+    return std::make_shared<Type>(
+        die.GetID(main_unit), dwarf, attrs.name, *clang_type_size, sc.comp_unit,
+        LLDB_INVALID_UID, Type::eEncodingIsUID, nullptr, clang_type,
   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;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
   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;
   } else if (sc.function != nullptr && sc_parent_die) {
-    symbol_context_scope =
-        sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
+    symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(
+        sc_parent_die.GetID(main_unit));
     if (symbol_context_scope == nullptr)
       symbol_context_scope = sc.function;
+  } else if (sc.comp_unit) {
+    symbol_context_scope = sc.comp_unit;
   } else {
     symbol_context_scope = sc.module_sp.get();
   }
+  lldbassert(symbol_context_scope);
 
   if (symbol_context_scope != nullptr)
     type_sp->SetSymbolContextScope(symbol_context_scope);
 
   // We are ready to put this type into the uniqued list up at the module
   // level.
   type_list.Insert(type_sp);
 
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = type_sp.get();
   return type_sp;
 }
 
 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;
+  DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(sc, &dwarf);
+  LanguageType cu_language =
+      SymbolFileDWARF::GetLanguage(*die.GetMainDWARFUnit(main_unit));
   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>();
 
   ConstString unique_typename(attrs.name);
   Declaration unique_decl(attrs.decl);
 
   if (attrs.name) {
     if (Language::LanguageIsCPlusPlus(cu_language)) {
       // For C++, we rely solely upon the one definition rule that says
       // only one thing can exist at a given decl context. We ignore the
       // file and line that things are declared on.
       std::string qualified_name;
       if (die.GetQualifiedName(qualified_name))
         unique_typename = ConstString(qualified_name);
       unique_decl.Clear();
     }
 
     if (dwarf->GetUniqueDWARFASTTypeMap().Find(
-            unique_typename, die, unique_decl, attrs.byte_size.getValueOr(-1),
-            *unique_ast_entry_up)) {
+            unique_typename, main_unit, die, unique_decl,
+            attrs.byte_size.getValueOr(-1), *unique_ast_entry_up)) {
       type_sp = unique_ast_entry_up->m_type_sp;
       if (type_sp) {
-        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
-        LinkDeclContextToDIE(
-            GetCachedClangDeclContextForDIE(unique_ast_entry_up->m_die), die);
+        dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = type_sp.get();
+        LinkDeclContextToDIE(GetCachedClangDeclContextForDIE(
+                                 main_unit, unique_ast_entry_up->m_die),
+                             main_unit, die);
         return type_sp;
       }
     }
   }
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
if (!attrs.is_complete_objc_class &&
               static_cast<void *>(this), die.GetOffset(),
               DW_TAG_value_to_name(tag), attrs.name.GetCString(),
               type_sp->GetID());
         }
 
         // We found a real definition for this type elsewhere so lets use
         // it and cache the fact that we found a complete type for this
         // die
-        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+        dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = type_sp.get();
         return type_sp;
       }
     }
   }
 
   if (attrs.is_forward_declaration) {
     // We have a forward declaration to a type and we need to try and
     // find a full declaration. We look in the current type index just in
if (attrs.is_forward_declaration) {
     }
 
     // See if the type comes from a Clang module and if so, track down
     // that type.
     type_sp = ParseTypeFromClangModule(sc, die, log);
     if (type_sp)
       return type_sp;
 
-    DWARFDeclContext die_decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
+    DWARFDeclContext die_decl_ctx =
+        SymbolFileDWARF::GetDWARFDeclContext(main_unit, die);
 
     // type_sp = FindDefinitionTypeForDIE (dwarf_cu, die,
     // type_name_const_str);
     type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
 
     if (!type_sp) {
       SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile();
       if (debug_map_symfile) {
if (type_sp) {
             "forward declaration, complete type is 0x%8.8" PRIx64,
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             type_sp->GetID());
       }
 
       // We found a real definition for this type elsewhere so lets use
       // it and cache the fact that we found a complete type for this die
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+      dwarf->GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = type_sp.get();
+      DWARFUnit *type_main_unit;
+      DWARFDIE type_die = dwarf->GetDIE(type_sp->GetID(), &type_main_unit);
       clang::DeclContext *defn_decl_ctx =
-          GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
+          GetCachedClangDeclContextForDIE(type_main_unit, type_die);
       if (defn_decl_ctx)
-        LinkDeclContextToDIE(defn_decl_ctx, die);
+        LinkDeclContextToDIE(defn_decl_ctx, main_unit, die);
       return type_sp;
     }
   }
   assert(tag_decl_kind != -1);
   bool clang_type_was_created = false;
-  clang_type.SetCompilerType(
-      &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
+  clang_type.SetCompilerType(&m_ast,
+                             dwarf->GetForwardDeclDieToClangType().lookup(
+                                 die.MainUnitToDIEPair(main_unit)));
   if (!clang_type) {
     clang::DeclContext *decl_ctx =
-        GetClangDeclContextContainingDIE(die, nullptr);
+        GetClangDeclContextContainingDIE(main_unit, die, nullptr);
 
     PrepareContextToReceiveMembers(m_ast, GetClangASTImporter(), decl_ctx, die,
                                    attrs.name.GetCString());
 
     if (attrs.accessibility == eAccessNone && decl_ctx) {
       // Check the decl context that contains this class/struct/union. If
       // it is a class we must give it an accessibility.
       const clang::Decl::Kind containing_decl_kind = decl_ctx->getDeclKind();
       if (DeclKindIsCXXClass(containing_decl_kind))
         attrs.accessibility = default_accessibility;
     }
 
     ClangASTMetadata metadata;
-    metadata.SetUserID(die.GetID());
+    metadata.SetUserID(die.GetID(main_unit));
     metadata.SetIsDynamicCXXType(dwarf->ClassOrStructIsVirtual(die));
 
     if (attrs.name.GetStringRef().contains('<')) {
       TypeSystemClang::TemplateParameterInfos template_param_infos;
-      if (ParseTemplateParameterInfos(die, template_param_infos)) {
+      if (ParseTemplateParameterInfos(main_unit, die, template_param_infos)) {
         clang::ClassTemplateDecl *class_template_decl =
             m_ast.ParseClassTemplateDecl(
-                decl_ctx, GetOwningClangModule(die), attrs.accessibility,
-                attrs.name.GetCString(), tag_decl_kind, template_param_infos);
+                decl_ctx, GetOwningClangModule(main_unit, die),
+                attrs.accessibility, attrs.name.GetCString(), tag_decl_kind,
+                template_param_infos);
         if (!class_template_decl) {
           if (log) {
             dwarf->GetObjectFile()->GetModule()->LogMessage(
                 log,
                 "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" "
                 "clang::ClassTemplateDecl failed to return a decl.",
                 static_cast<void *>(this), die.GetOffset(),
                 DW_TAG_value_to_name(tag), attrs.name.GetCString());
           }
           return TypeSP();
         }
 
         clang::ClassTemplateSpecializationDecl *class_specialization_decl =
             m_ast.CreateClassTemplateSpecializationDecl(
-                decl_ctx, GetOwningClangModule(die), class_template_decl,
-                tag_decl_kind, template_param_infos);
+                decl_ctx, GetOwningClangModule(main_unit, die),
+                class_template_decl, tag_decl_kind, template_param_infos);
         clang_type = m_ast.CreateClassTemplateSpecializationType(
             class_specialization_decl);
         clang_type_was_created = true;
 
         m_ast.SetMetadata(class_template_decl, metadata);
         m_ast.SetMetadata(class_specialization_decl, metadata);
       }
     }
 
     if (!clang_type_was_created) {
       clang_type_was_created = true;
       clang_type = m_ast.CreateRecordType(
-          decl_ctx, GetOwningClangModule(die), attrs.accessibility,
+          decl_ctx, GetOwningClangModule(main_unit, die), attrs.accessibility,
           attrs.name.GetCString(), tag_decl_kind, attrs.class_language,
           &metadata, attrs.exports_symbols);
     }
   }
 
   // Store a forward declaration to this class type in case any
   // parameters in any class methods need it for the clang types for
   // function prototypes.
-  LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
+  LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), main_unit, die);
   type_sp = std::make_shared<Type>(
-      die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
+      die.GetID(main_unit), dwarf, attrs.name, attrs.byte_size, sc.comp_unit,
       LLDB_INVALID_UID, Type::eEncodingIsUID, &attrs.decl, clang_type,
       Type::ResolveState::Forward,
       TypePayloadClang(OptionalClangModuleID(), attrs.is_complete_objc_class));
 
   // Add our type to the unique type map so we don't end up creating many
   // copies of the same type over and over in the ASTContext for our
   // module
   unique_ast_entry_up->m_type_sp = type_sp;
+  unique_ast_entry_up->m_main_unit = main_unit;
   unique_ast_entry_up->m_die = die;
   unique_ast_entry_up->m_declaration = unique_decl;
   unique_ast_entry_up->m_byte_size = attrs.byte_size.getValueOr(0);
   dwarf->GetUniqueDWARFASTTypeMap().Insert(unique_typename,
                                            *unique_ast_entry_up);
 
   if (!attrs.is_forward_declaration) {
     // Always start the definition for a class type so that if the class
if (!die.HasChildren()) {
       // needs to be defined.
       assert(!dwarf->GetForwardDeclClangTypeToDie().count(
                  ClangUtil::RemoveFastQualifiers(clang_type)
                      .GetOpaqueQualType()) &&
              "Type already in the forward declaration map!");
       // Can't assume m_ast.GetSymbolFile() is actually a
       // SymbolFileDWARF, it can be a SymbolFileDWARFDebugMap for Apple
       // binaries.
-      dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
+      dwarf->GetForwardDeclDieToClangType()[die.MainUnitToDIEPair(main_unit)] =
           clang_type.GetOpaqueQualType();
       dwarf->GetForwardDeclClangTypeToDie().try_emplace(
           ClangUtil::RemoveFastQualifiers(clang_type).GetOpaqueQualType(),
-          *die.GetDIERef());
+          die.GetID(main_unit));
       m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), true);
     }
   }
 
   // If we made a clang type, set the trivial abi if applicable: We only
   // do this for pass by value - which implies the Trivial ABI. There
   // isn't a way to assert that something that would normally be pass by
   // value is pass by reference, so we ignore that attribute if set.
private:
   clang::ObjCIvarDecl *m_ivar_decl;
   const char *m_property_setter_name;
   const char *m_property_getter_name;
   uint32_t m_property_attributes;
   std::unique_ptr<ClangASTMetadata> m_metadata_up;
 };
 
 bool DWARFASTParserClang::ParseTemplateDIE(
-    const DWARFDIE &die,
+    DWARFUnit *main_unit, const DWARFDIE &die,
     TypeSystemClang::TemplateParameterInfos &template_param_infos) {
   const dw_tag_t tag = die.Tag();
   bool is_template_template_argument = false;
 
   switch (tag) {
   case DW_TAG_GNU_template_parameter_pack: {
     template_param_infos.packed_args =
         std::make_unique<TypeSystemClang::TemplateParameterInfos>();
     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
          child_die = child_die.GetSibling()) {
-      if (!ParseTemplateDIE(child_die, *template_param_infos.packed_args))
+      if (!ParseTemplateDIE(main_unit, child_die,
+                            *template_param_infos.packed_args))
         return false;
     }
     if (const char *name = die.GetName()) {
       template_param_infos.pack_name = name;
     }
     return true;
   }
   case DW_TAG_GNU_template_template_param:
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(main_unit, form_value.Reference());
             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::ParseTemplateDIE(
 
   default:
     break;
   }
   return false;
 }
 
 bool DWARFASTParserClang::ParseTemplateParameterInfos(
-    const DWARFDIE &parent_die,
+    DWARFUnit *main_unit, const DWARFDIE &parent_die,
     TypeSystemClang::TemplateParameterInfos &template_param_infos) {
 
   if (!parent_die)
     return false;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     const dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_template_type_parameter:
     case DW_TAG_template_value_parameter:
     case DW_TAG_GNU_template_parameter_pack:
     case DW_TAG_GNU_template_template_param:
-      ParseTemplateDIE(die, template_param_infos);
+      ParseTemplateDIE(main_unit, die, template_param_infos);
       break;
 
     default:
       break;
     }
   }
   return template_param_infos.args.size() == template_param_infos.names.size();
 }
 
-bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
+bool DWARFASTParserClang::CompleteRecordType(DWARFUnit *main_unit,
+                                             const DWARFDIE &die,
                                              lldb_private::Type *type,
                                              CompilerType &clang_type) {
   const dw_tag_t tag = die.Tag();
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = &main_unit->GetSymbolFileDWARF();
+  CompileUnit *comp_unit =
+      type->GetSymbolContextScope()->CalculateSymbolContextCompileUnit();
+  // comp_unit may be a CU with DIE being only a declaration.
+  // Then 'die' will be a definition in a different CU with different
+  // 'main_unit'. This assertion therefore would not work:
+  // lldbassert(&sc.GetDWARFCompileUnit(&dwarf)->GetNonSkeletonUnit() ==
+  // sc.GetDWARFCompileUnit(&dwarf));
 
   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()) {
 
     std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
     std::vector<int> member_accessibilities;
     bool is_a_class = false;
     // Parse members and base classes first
     std::vector<DWARFDIE> member_function_dies;
 
     DelayedPropertyList delayed_properties;
-    ParseChildMembers(die, clang_type, bases, member_accessibilities,
-                      member_function_dies, delayed_properties,
-                      default_accessibility, is_a_class, layout_info);
+    ParseChildMembers(comp_unit, main_unit, die, clang_type, bases,
+                      member_accessibilities, member_function_dies,
+                      delayed_properties, default_accessibility, is_a_class,
+                      layout_info);
 
     // Now parse any methods if there were any...
     for (const DWARFDIE &die : member_function_dies)
-      dwarf->ResolveType(die);
+      dwarf->ResolveType(main_unit, 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();
+        dwarf->GetObjCMethods(class_name,
+                              [&](DWARFUnit *main_unit, DWARFDIE method_die) {
+                                method_die.ResolveType(main_unit);
                                 return true;
                               });
 
         for (DelayedPropertyList::iterator pi = delayed_properties.begin(),
                                            pe = delayed_properties.end();
              pi != pe; ++pi)
           pi->Finalize();
       }
     }
 
if (die.HasChildren()) {
       ParseChildEnumerators(clang_type, is_signed,
                             type->GetByteSize(nullptr).getValueOr(0), die);
     }
     TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   }
   return (bool)clang_type;
 }
 
-bool DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die,
+bool DWARFASTParserClang::CompleteTypeFromDWARF(DWARFUnit *main_unit,
+                                                const DWARFDIE &die,
                                                 lldb_private::Type *type,
                                                 CompilerType &clang_type) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = &main_unit->GetSymbolFileDWARF();
 
   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)
     return false;
 
   const dw_tag_t tag = die.Tag();
 
   Log *log =
       nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
   if (log)
     dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
         log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
-        die.GetID(), die.GetTagAsCString(), type->GetName().AsCString());
+        die.GetID(main_unit), die.GetTagAsCString(),
+        type->GetName().AsCString());
   assert(clang_type);
   DWARFAttributes attributes;
   switch (tag) {
   case DW_TAG_structure_type:
   case DW_TAG_union_type:
   case DW_TAG_class_type:
-    return CompleteRecordType(die, type, clang_type);
+    return CompleteRecordType(main_unit, die, type, clang_type);
   case DW_TAG_enumeration_type:
     return CompleteEnumType(die, type, clang_type);
   default:
     assert(false && "not a forward clang type decl!");
     break;
   }
 
   return false;
 }
 
 void DWARFASTParserClang::EnsureAllDIEsInDeclContextHaveBeenParsed(
     lldb_private::CompilerDeclContext decl_context) {
   auto opaque_decl_ctx =
       (clang::DeclContext *)decl_context.GetOpaqueDeclContext();
   for (auto it = m_decl_ctx_to_die.find(opaque_decl_ctx);
        it != m_decl_ctx_to_die.end() && it->first == opaque_decl_ctx;
-       it = m_decl_ctx_to_die.erase(it))
-    for (DWARFDIE decl = it->second.GetFirstChild(); decl;
+       it = m_decl_ctx_to_die.erase(it)) {
+    DWARFUnit *main_unit = it->second.first;
+    for (DWARFDIE decl = it->second.second.GetFirstChild(); decl;
          decl = decl.GetSibling())
-      GetClangDeclForDIE(decl);
+      GetClangDeclForDIE(main_unit, decl);
+  }
 }
 
-CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(const DWARFDIE &die) {
-  clang::Decl *clang_decl = GetClangDeclForDIE(die);
+CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(DWARFUnit *main_unit,
+                                                         const DWARFDIE &die) {
+  clang::Decl *clang_decl = GetClangDeclForDIE(main_unit, die);
   if (clang_decl != nullptr)
     return m_ast.GetCompilerDecl(clang_decl);
   return CompilerDecl();
 }
 
 CompilerDeclContext
-DWARFASTParserClang::GetDeclContextForUIDFromDWARF(const DWARFDIE &die) {
-  clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE(die);
+DWARFASTParserClang::GetDeclContextForUIDFromDWARF(DWARFUnit *main_unit,
+                                                   const DWARFDIE &die) {
+  clang::DeclContext *clang_decl_ctx =
+      GetClangDeclContextForDIE(main_unit, die);
   if (clang_decl_ctx)
     return m_ast.CreateDeclContext(clang_decl_ctx);
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
-DWARFASTParserClang::GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) {
+DWARFASTParserClang::GetDeclContextContainingUIDFromDWARF(DWARFUnit *main_unit,
+                                                          const DWARFDIE &die) {
   clang::DeclContext *clang_decl_ctx =
-      GetClangDeclContextContainingDIE(die, nullptr);
+      GetClangDeclContextContainingDIE(main_unit, die, nullptr);
   if (clang_decl_ctx)
     return m_ast.CreateDeclContext(clang_decl_ctx);
   return CompilerDeclContext();
 }
 
 size_t DWARFASTParserClang::ParseChildEnumerators(
     lldb_private::CompilerType &clang_type, bool is_signed,
     uint32_t enumerator_byte_size, const DWARFDIE &parent_die) {
if (lowest_func_addr != LLDB_INVALID_ADDRESS &&
       ModuleSP module_sp(die.GetModule());
       func_range.GetBaseAddress().ResolveAddressUsingFileSections(
           lowest_func_addr, module_sp->GetSectionList());
       if (func_range.GetBaseAddress().IsValid())
         func_range.SetByteSize(highest_func_addr - lowest_func_addr);
     }
 
     if (func_range.GetBaseAddress().IsValid()) {
+      SymbolFileDWARF *dwarf;
+      DWARFUnit *main_unit = DWARFCompileUnit::GetMainUnit(comp_unit, &dwarf);
       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())) &&
-               !Language::LanguageIsObjC(
-                   SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
+               Language::LanguageIsCPlusPlus(SymbolFileDWARF::GetLanguage(
+                   *die.GetMainDWARFUnit(main_unit))) &&
+               !Language::LanguageIsObjC(SymbolFileDWARF::GetLanguage(
+                   *die.GetMainDWARFUnit(main_unit))) &&
                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;
         std::vector<CompilerType> param_types;
         std::vector<clang::ParmVarDecl *> param_decls;
         StreamString sstr;
 
-        DWARFDeclContext decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
+        DWARFDeclContext decl_ctx =
+            SymbolFileDWARF::GetDWARFDeclContext(main_unit, die);
         sstr << decl_ctx.GetQualifiedName();
 
         clang::DeclContext *containing_decl_ctx =
-            GetClangDeclContextContainingDIE(die, nullptr);
-        ParseChildParameters(containing_decl_ctx, die, true, is_static,
-                             is_variadic, has_template_params, param_types,
-                             param_decls, type_quals);
+            GetClangDeclContextContainingDIE(main_unit, die, nullptr);
+        ParseChildParameters(&comp_unit, containing_decl_ctx, main_unit, die,
+                             true, is_static, is_variadic, has_template_params,
+                             param_types, param_decls, type_quals);
         sstr << "(";
         for (size_t i = 0; i < param_types.size(); i++) {
           if (i > 0)
             sstr << ", ";
           sstr << param_types[i].GetTypeName();
         }
         if (is_variadic)
           sstr << ", ...";
         sstr << ")";
         if (type_quals & clang::Qualifiers::Const)
           sstr << " const";
 
         func_name.SetValue(ConstString(sstr.GetString()), false);
       } else
         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();
       // Supply the type _only_ if it has already been parsed
-      Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
+      Type *func_type =
+          dwarf->GetDIEToType().lookup(die.MainUnitToDIEPair(main_unit));
 
       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();
+        const user_id_t func_user_id = die.GetID(main_unit);
         func_sp =
             std::make_shared<Function>(&comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,
                                        func_range); // first address range
 
         if (func_sp.get() != nullptr) {
           if (frame_base.IsValid())
             func_sp->GetFrameBaseExpression() = frame_base;
           comp_unit.AddFunction(func_sp);
           return func_sp.get();
         }
       }
     }
   }
   return nullptr;
 }
 
 void DWARFASTParserClang::ParseSingleMember(
+    lldb_private::CompileUnit *comp_unit, DWARFUnit *main_unit,
     const DWARFDIE &die, const DWARFDIE &parent_die,
     const lldb_private::CompilerType &class_clang_type,
     std::vector<int> &member_accessibilities,
     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();
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(main_unit, encoding_form.Reference());
 
     if (var_type) {
       if (accessibility == eAccessNone)
         accessibility = eAccessPublic;
       TypeSystemClang::AddVariableToRecordType(
           class_clang_type, name, var_type->GetLayoutCompilerType(),
           accessibility);
     }
     return;
   }
 
   if (!is_artificial) {
-    Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
+    Type *member_type =
+        die.ResolveTypeUID(main_unit, encoding_form.Reference());
 
     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) {
                 !last_field_info.NextBitfieldOffsetIsValid(
                     this_field_info.bit_offset)))) {
             ObjectFile *objfile = die.GetDWARF()->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,
+                die.GetID(main_unit), DW_TAG_value_to_name(tag), name,
                 this_field_info.bit_offset, GetUnitName(parent_die).c_str());
             return;
           }
 
           // Update the field bit offset we will report for layout
           field_bit_offset = this_field_info.bit_offset;
 
           // Objective-C has invalid DW_AT_bit_offset values in older
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(),
-                    parent_die.GetID());
+                    die.GetID(main_unit), name,
+                    encoding_form.Reference().GetOffset(),
+                    parent_die.GetID(main_unit));
               }
 
               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());
+        m_ast.SetMetadataAsUserID(field_decl, die.GetID(main_unit));
 
         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"
+          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(main_unit), name,
+                                 encoding_form.Reference().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(main_unit), encoding_form.Reference().GetOffset());
       }
     }
 
     if (prop_name != nullptr && member_type) {
       clang::ObjCIvarDecl *ivar_decl = nullptr;
 
       if (field_decl) {
         ivar_decl = clang::dyn_cast<clang::ObjCIvarDecl>(field_decl);
         assert(ivar_decl != nullptr);
       }
 
       ClangASTMetadata metadata;
-      metadata.SetUserID(die.GetID());
+      metadata.SetUserID(die.GetID(main_unit));
       delayed_properties.push_back(DelayedAddObjCClassProperty(
           class_clang_type, prop_name, member_type->GetLayoutCompilerType(),
           ivar_decl, prop_setter_name, prop_getter_name, prop_attributes,
           &metadata));
 
       if (ivar_decl)
-        m_ast.SetMetadataAsUserID(ivar_decl, die.GetID());
+        m_ast.SetMetadataAsUserID(ivar_decl, die.GetID(main_unit));
     }
   }
 }
 
 bool DWARFASTParserClang::ParseChildMembers(
-    const DWARFDIE &parent_die, CompilerType &class_clang_type,
+    CompileUnit *comp_unit, DWARFUnit *main_unit, const DWARFDIE &parent_die,
+    CompilerType &class_clang_type,
     std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
     std::vector<int> &member_accessibilities,
     std::vector<DWARFDIE> &member_function_dies,
     DelayedPropertyList &delayed_properties, AccessType &default_accessibility,
     bool &is_a_class, ClangASTImporter::LayoutInfo &layout_info) {
   if (!parent_die)
     return false;
 
   FieldInfo last_field_info;
 
   ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
   TypeSystemClang *ast =
       llvm::dyn_cast_or_null<TypeSystemClang>(class_clang_type.GetTypeSystem());
   if (ast == nullptr)
     return false;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_member:
     case DW_TAG_APPLE_property:
-      ParseSingleMember(die, parent_die, class_clang_type,
+      ParseSingleMember(comp_unit, main_unit, die, parent_die, class_clang_type,
                         member_accessibilities, default_accessibility,
                         delayed_properties, layout_info, last_field_info);
       break;
 
     case DW_TAG_subprogram:
       // Let the type parsing code handle this one for us.
       member_function_dies.push_back(die);
       break;
case DW_TAG_inheritance: {
               break;
 
             default:
               break;
             }
           }
         }
 
-        Type *base_class_type = die.ResolveTypeUID(encoding_form.Reference());
+        Type *base_class_type =
+            die.ResolveTypeUID(main_unit, encoding_form.Reference());
         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(),
default:
       break;
     }
   }
 
   return true;
 }
 
 size_t DWARFASTParserClang::ParseChildParameters(
-    clang::DeclContext *containing_decl_ctx, const DWARFDIE &parent_die,
-    bool skip_artificial, bool &is_static, bool &is_variadic,
-    bool &has_template_params, std::vector<CompilerType> &function_param_types,
+    CompileUnit *comp_unit, clang::DeclContext *containing_decl_ctx,
+    DWARFUnit *main_unit, const DWARFDIE &parent_die, bool skip_artificial,
+    bool &is_static, bool &is_variadic, bool &has_template_params,
+    std::vector<CompilerType> &function_param_types,
     std::vector<clang::ParmVarDecl *> &function_param_decls,
     unsigned &type_quals) {
   if (!parent_die)
     return 0;
 
   size_t arg_idx = 0;
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
case DW_TAG_formal_parameter: {
           // 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());
+                die.ResolveTypeUID(main_unit, param_type_die_form.Reference());
             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(main_unit, param_type_die_form.Reference());
           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);
+                    containing_decl_ctx, GetOwningClangModule(main_unit, die),
+                    name, type->GetForwardCompilerType(), storage);
             assert(param_var_decl);
             function_param_decls.push_back(param_var_decl);
 
-            m_ast.SetMetadataAsUserID(param_var_decl, die.GetID());
+            m_ast.SetMetadataAsUserID(param_var_decl, die.GetID(main_unit));
           }
         }
       }
       arg_idx++;
     } break;
 
     case DW_TAG_unspecified_parameters:
       is_variadic = true;
if (num_child_attributes > 0) {
       }
 
       array_info.element_orders.push_back(num_elements);
     }
   }
   return array_info;
 }
 
-Type *DWARFASTParserClang::GetTypeForDIE(const DWARFDIE &die) {
+Type *DWARFASTParserClang::GetTypeForDIE(DWARFUnit *main_unit,
+                                         const DWARFDIE &die) {
   if (die) {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    SymbolFileDWARF *dwarf =
+        &die.GetMainDWARFUnit(main_unit)->GetSymbolFileDWARF();
     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(main_unit, form_value.Reference(), true);
       }
     }
   }
 
   return nullptr;
 }
 
-clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
+clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(DWARFUnit *main_unit,
+                                                     const DWARFDIE &die) {
   if (!die)
     return nullptr;
 
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   case DW_TAG_formal_parameter:
   case DW_TAG_imported_declaration:
   case DW_TAG_imported_module:
     break;
   default:
     return nullptr;
   }
 
-  DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(die.GetDIE());
+  auto diepair = die.MainUnitToDIEPair(main_unit);
+  DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(diepair);
   if (cache_pos != m_die_to_decl.end())
     return cache_pos->second;
 
   if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification)) {
-    clang::Decl *decl = GetClangDeclForDIE(spec_die);
-    m_die_to_decl[die.GetDIE()] = decl;
-    m_decl_to_die[decl].insert(die.GetDIE());
+    clang::Decl *decl = GetClangDeclForDIE(main_unit, spec_die);
+    m_die_to_decl[diepair] = decl;
+    m_decl_to_die[decl].insert(diepair);
     return decl;
   }
 
   if (DWARFDIE abstract_origin_die =
           die.GetReferencedDIE(DW_AT_abstract_origin)) {
-    clang::Decl *decl = GetClangDeclForDIE(abstract_origin_die);
-    m_die_to_decl[die.GetDIE()] = decl;
-    m_decl_to_die[decl].insert(die.GetDIE());
+    clang::Decl *decl = GetClangDeclForDIE(main_unit, abstract_origin_die);
+    m_die_to_decl[diepair] = decl;
+    m_decl_to_die[decl].insert(diepair);
     return decl;
   }
 
+  SymbolFileDWARF *dwarf =
+      &die.GetMainDWARFUnit(main_unit)->GetSymbolFileDWARF();
+
   clang::Decl *decl = nullptr;
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   case DW_TAG_formal_parameter: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
-    Type *type = GetTypeForDIE(die);
+    Type *type = GetTypeForDIE(main_unit, die);
     if (dwarf && type) {
       const char *name = die.GetName();
       clang::DeclContext *decl_context =
           TypeSystemClang::DeclContextGetAsDeclContext(
-              dwarf->GetDeclContextContainingUID(die.GetID()));
+              dwarf->GetDeclContextContainingUID(die.GetID(main_unit)));
       decl = m_ast.CreateVariableDeclaration(
-          decl_context, GetOwningClangModule(die), name,
+          decl_context, GetOwningClangModule(main_unit, die), name,
           ClangUtil::GetQualType(type->GetForwardCompilerType()));
     }
     break;
   }
   case DW_TAG_imported_declaration: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
     if (imported_uid) {
-      CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid);
+      CompilerDecl imported_decl =
+          SymbolFileDWARF::GetDecl(main_unit, imported_uid);
       if (imported_decl) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(
-                dwarf->GetDeclContextContainingUID(die.GetID()));
+                dwarf->GetDeclContextContainingUID(die.GetID(main_unit)));
         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();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
 
     if (imported_uid) {
       CompilerDeclContext imported_decl_ctx =
-          SymbolFileDWARF::GetDeclContext(imported_uid);
+          SymbolFileDWARF::GetDeclContext(main_unit, imported_uid);
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(
-                dwarf->GetDeclContextContainingUID(die.GetID()));
+                dwarf->GetDeclContextContainingUID(die.GetID(main_unit)));
         if (clang::NamespaceDecl *ns_decl =
                 TypeSystemClang::DeclContextGetAsNamespaceDecl(
                     imported_decl_ctx))
           decl = m_ast.CreateUsingDirectiveDeclaration(
               decl_context, OptionalClangModuleID(), ns_decl);
       }
     }
     break;
   }
   default:
     break;
   }
 
-  m_die_to_decl[die.GetDIE()] = decl;
-  m_decl_to_die[decl].insert(die.GetDIE());
+  m_die_to_decl[diepair] = decl;
+  m_decl_to_die[decl].insert(diepair);
 
   return decl;
 }
 
 clang::DeclContext *
-DWARFASTParserClang::GetClangDeclContextForDIE(const DWARFDIE &die) {
+DWARFASTParserClang::GetClangDeclContextForDIE(DWARFUnit *main_unit,
+                                               const DWARFDIE &die) {
   if (die) {
-    clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(die);
+    clang::DeclContext *decl_ctx =
+        GetCachedClangDeclContextForDIE(main_unit, die);
     if (decl_ctx)
       return decl_ctx;
 
     bool try_parsing_type = true;
     switch (die.Tag()) {
     case DW_TAG_compile_unit:
     case DW_TAG_partial_unit:
       decl_ctx = m_ast.GetTranslationUnitDecl();
       try_parsing_type = false;
       break;
 
     case DW_TAG_namespace:
-      decl_ctx = ResolveNamespaceDIE(die);
+      decl_ctx = ResolveNamespaceDIE(main_unit, die);
       try_parsing_type = false;
       break;
 
     case DW_TAG_lexical_block:
-      decl_ctx = GetDeclContextForBlock(die);
+      decl_ctx = GetDeclContextForBlock(main_unit, die);
       try_parsing_type = false;
       break;
 
     default:
       break;
     }
 
     if (decl_ctx == nullptr && try_parsing_type) {
-      Type *type = die.GetDWARF()->ResolveType(die);
+      Type *type =
+          die.GetMainDWARFUnit(main_unit)->GetSymbolFileDWARF().ResolveType(
+              main_unit, die);
       if (type)
-        decl_ctx = GetCachedClangDeclContextForDIE(die);
+        decl_ctx = GetCachedClangDeclContextForDIE(main_unit, die);
     }
 
     if (decl_ctx) {
-      LinkDeclContextToDIE(decl_ctx, die);
+      LinkDeclContextToDIE(decl_ctx, main_unit, die);
       return decl_ctx;
     }
   }
   return nullptr;
 }
 
 OptionalClangModuleID
-DWARFASTParserClang::GetOwningClangModule(const DWARFDIE &die) {
+DWARFASTParserClang::GetOwningClangModule(DWARFUnit *main_unit,
+                                          const DWARFDIE &die) {
   if (!die.IsValid())
     return {};
 
   for (DWARFDIE parent = die.GetParent(); parent.IsValid();
        parent = parent.GetParent()) {
     const dw_tag_t tag = parent.Tag();
     if (tag == DW_TAG_module) {
       DWARFDIE module_die = parent;
-      auto it = m_die_to_module.find(module_die.GetDIE());
+      auto it = m_die_to_module.find(module_die.MainUnitToDIEPair(main_unit));
       if (it != m_die_to_module.end())
         return it->second;
       const char *name = module_die.GetAttributeValueAsString(DW_AT_name, 0);
       if (!name)
         return {};
 
-      OptionalClangModuleID id =
-          m_ast.GetOrCreateClangModule(name, GetOwningClangModule(module_die));
-      m_die_to_module.insert({module_die.GetDIE(), id});
+      OptionalClangModuleID id = m_ast.GetOrCreateClangModule(
+          name, GetOwningClangModule(main_unit, module_die));
+      m_die_to_module.insert({module_die.MainUnitToDIEPair(main_unit), id});
       return id;
     }
   }
   return {};
 }
 
 static bool IsSubroutine(const DWARFDIE &die) {
   switch (die.Tag()) {
for (DWARFDIE context = block; context != function.GetParent();
     if (DWARFDIE child = FindAnyChildWithAbstractOrigin(context)) {
       return child;
     }
   }
   return DWARFDIE();
 }
 
 clang::DeclContext *
-DWARFASTParserClang::GetDeclContextForBlock(const DWARFDIE &die) {
+DWARFASTParserClang::GetDeclContextForBlock(DWARFUnit *main_unit,
+                                            const DWARFDIE &die) {
   assert(die.Tag() == DW_TAG_lexical_block);
   DWARFDIE containing_function_with_abstract_origin =
       GetContainingFunctionWithAbstractOrigin(die);
   if (!containing_function_with_abstract_origin) {
-    return (clang::DeclContext *)ResolveBlockDIE(die);
+    return (clang::DeclContext *)ResolveBlockDIE(main_unit, die);
   }
   DWARFDIE child = FindFirstChildWithAbstractOrigin(
       die, containing_function_with_abstract_origin);
   CompilerDeclContext decl_context =
-      GetDeclContextContainingUIDFromDWARF(child);
+      GetDeclContextContainingUIDFromDWARF(main_unit, child);
   return (clang::DeclContext *)decl_context.GetOpaqueDeclContext();
 }
 
-clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) {
+clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(DWARFUnit *main_unit,
+                                                       const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_lexical_block) {
-    clang::BlockDecl *decl =
-        llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
+    clang::BlockDecl *decl = llvm::cast_or_null<clang::BlockDecl>(
+        m_die_to_decl_ctx[die.MainUnitToDIEPair(main_unit)]);
 
     if (!decl) {
       DWARFDIE decl_context_die;
       clang::DeclContext *decl_context =
-          GetClangDeclContextContainingDIE(die, &decl_context_die);
-      decl =
-          m_ast.CreateBlockDeclaration(decl_context, GetOwningClangModule(die));
+          GetClangDeclContextContainingDIE(main_unit, die, &decl_context_die);
+      decl = m_ast.CreateBlockDeclaration(decl_context,
+                                          GetOwningClangModule(main_unit, die));
 
       if (decl)
-        LinkDeclContextToDIE((clang::DeclContext *)decl, die);
+        LinkDeclContextToDIE((clang::DeclContext *)decl, main_unit, die);
     }
 
     return decl;
   }
   return nullptr;
 }
 
 clang::NamespaceDecl *
-DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) {
+DWARFASTParserClang::ResolveNamespaceDIE(DWARFUnit *main_unit,
+                                         const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_namespace) {
     // See if we already parsed this namespace DIE and associated it with a
     // uniqued namespace declaration
-    clang::NamespaceDecl *namespace_decl =
-        static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
+    clang::NamespaceDecl *namespace_decl = static_cast<clang::NamespaceDecl *>(
+        m_die_to_decl_ctx[die.MainUnitToDIEPair(main_unit)]);
     if (namespace_decl)
       return namespace_decl;
     else {
       const char *namespace_name = die.GetName();
       clang::DeclContext *containing_decl_ctx =
-          GetClangDeclContextContainingDIE(die, nullptr);
+          GetClangDeclContextContainingDIE(main_unit, die, nullptr);
       bool is_inline =
           die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0;
 
       namespace_decl = m_ast.GetUniqueNamespaceDeclaration(
-          namespace_name, containing_decl_ctx, GetOwningClangModule(die),
-          is_inline);
+          namespace_name, containing_decl_ctx,
+          GetOwningClangModule(main_unit, die), is_inline);
       Log *log =
           nullptr; // (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
       if (log) {
-        SymbolFileDWARF *dwarf = die.GetDWARF();
+        SymbolFileDWARF *dwarf =
+            &die.GetMainDWARFUnit(main_unit)->GetSymbolFileDWARF();
         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(),
+              static_cast<void *>(&m_ast.getASTContext()), die.GetID(main_unit),
               namespace_name, static_cast<void *>(namespace_decl),
               static_cast<void *>(namespace_decl->getOriginalNamespace()));
         } else {
           dwarf->GetObjectFile()->GetModule()->LogMessage(
               log,
               "ASTContext => %p: 0x%8.8" PRIx64
               ": DW_TAG_namespace (anonymous) => clang::NamespaceDecl *%p "
               "(original = %p)",
-              static_cast<void *>(&m_ast.getASTContext()), die.GetID(),
+              static_cast<void *>(&m_ast.getASTContext()), die.GetID(main_unit),
               static_cast<void *>(namespace_decl),
               static_cast<void *>(namespace_decl->getOriginalNamespace()));
         }
       }
 
       if (namespace_decl)
-        LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die);
+        LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, main_unit,
+                             die);
       return namespace_decl;
     }
   }
   return nullptr;
 }
 
 clang::DeclContext *DWARFASTParserClang::GetClangDeclContextContainingDIE(
-    const DWARFDIE &die, DWARFDIE *decl_ctx_die_copy) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+    DWARFUnit *main_unit, const DWARFDIE &die, DWARFDIE *decl_ctx_die_copy) {
+  SymbolFileDWARF *dwarf =
+      &die.GetMainDWARFUnit(main_unit)->GetSymbolFileDWARF();
 
   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 =
-        GetClangDeclContextForDIE(decl_ctx_die);
+        GetClangDeclContextForDIE(main_unit, decl_ctx_die);
     if (clang_decl_ctx)
       return clang_decl_ctx;
   }
   return m_ast.GetTranslationUnitDecl();
 }
 
 clang::DeclContext *
-DWARFASTParserClang::GetCachedClangDeclContextForDIE(const DWARFDIE &die) {
+DWARFASTParserClang::GetCachedClangDeclContextForDIE(DWARFUnit *main_unit,
+                                                     const DWARFDIE &die) {
   if (die) {
-    DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE());
+    DIEToDeclContextMap::iterator pos =
+        m_die_to_decl_ctx.find(die.MainUnitToDIEPair(main_unit));
     if (pos != m_die_to_decl_ctx.end())
       return pos->second;
   }
   return nullptr;
 }
 
 void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx,
+                                               DWARFUnit *main_unit,
                                                const DWARFDIE &die) {
-  m_die_to_decl_ctx[die.GetDIE()] = decl_ctx;
+  m_die_to_decl_ctx[die.MainUnitToDIEPair(main_unit)] = decl_ctx;
   // There can be many DIEs for a single decl context
   // m_decl_ctx_to_die[decl_ctx].insert(die.GetDIE());
-  m_decl_ctx_to_die.insert(std::make_pair(decl_ctx, die));
+  m_decl_ctx_to_die.insert(
+      std::make_pair(decl_ctx, die.MainUnitToDWARFDIEPair(main_unit)));
 }
 
 bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
-    const DWARFDIE &src_class_die, const DWARFDIE &dst_class_die,
-    lldb_private::Type *class_type, std::vector<DWARFDIE> &failures) {
+    DWARFUnit *main_unit, const DWARFDIE &src_class_die,
+    const DWARFDIE &dst_class_die, lldb_private::Type *class_type,
+    std::vector<DWARFDIE> &failures) {
   if (!class_type || !src_class_die || !dst_class_die)
     return false;
   if (src_class_die.Tag() != dst_class_die.Tag())
     return false;
 
   // We need to complete the class type so we can get all of the method types
   // parsed so we can then unique those types to their equivalent counterparts
   // in "dst_cu" and "dst_class_die"
for (idx = 0; idx < src_size; ++idx) {
                 src_class_die.GetOffset(), dst_class_die.GetOffset(),
                 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()));
+      static_cast<DWARFASTParserClang *>(SymbolFileDWARF::GetDWARFParser(
+          *src_class_die.GetMainDWARFUnit(main_unit)));
   DWARFASTParserClang *dst_dwarf_ast_parser =
-      static_cast<DWARFASTParserClang *>(
-          SymbolFileDWARF::GetDWARFParser(*dst_die.GetCU()));
+      static_cast<DWARFASTParserClang *>(SymbolFileDWARF::GetDWARFParser(
+          *dst_class_die.GetMainDWARFUnit(main_unit)));
 
   // 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_die_to_decl_ctx[src_die.GetDIE()];
+          src_dwarf_ast_parser
+              ->m_die_to_decl_ctx[src_die.MainUnitToDIEPair(main_unit)];
       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);
+        dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, main_unit,
+                                                   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()->GetDIEToType()[src_die.GetDIE()];
+          dst_die.GetDWARF()
+              ->GetDIEToType()[src_die.MainUnitToDIEPair(main_unit)];
       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()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
+        dst_die.GetDWARF()
+            ->GetDIEToType()[dst_die.MainUnitToDIEPair(main_unit)] =
+            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 {
     // We must do this slowly.  For each member of the destination, look up a
     // member in the source with the same name, check its tag, and unique them
     // if everything matches up.  Report failures.
 
     if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty()) {
       src_name_to_die.Sort();
 
       for (idx = 0; idx < dst_size; ++idx) {
         ConstString dst_name = dst_name_to_die.GetCStringAtIndex(idx);
         dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
         src_die = src_name_to_die.Find(dst_name, DWARFDIE());
 
         if (src_die && (src_die.Tag() == dst_die.Tag())) {
           clang::DeclContext *src_decl_ctx =
-              src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+              src_dwarf_ast_parser
+                  ->m_die_to_decl_ctx[src_die.MainUnitToDIEPair(main_unit)];
           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);
+            dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, main_unit,
+                                                       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()->GetDIEToType()[src_die.GetDIE()];
+              dst_die.GetDWARF()
+                  ->GetDIEToType()[src_die.MainUnitToDIEPair(main_unit)];
           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()->GetDIEToType()[dst_die.GetDIE()] =
+            dst_die.GetDWARF()
+                ->GetDIEToType()[dst_die.MainUnitToDIEPair(main_unit)] =
                 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) {
           src_name_to_die_artificial.GetCStringAtIndex(idx);
       src_die = src_name_to_die_artificial.GetValueAtIndexUnchecked(idx);
       dst_die =
           dst_name_to_die_artificial.Find(src_name_artificial, DWARFDIE());
 
       if (dst_die) {
         // Both classes have the artificial types, link them
         clang::DeclContext *src_decl_ctx =
-            src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+            src_dwarf_ast_parser
+                ->m_die_to_decl_ctx[src_die.MainUnitToDIEPair(main_unit)];
         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);
+          dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, main_unit,
+                                                     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()->GetDIEToType()[src_die.GetDIE()];
+            dst_die.GetDWARF()
+                ->GetDIEToType()[src_die.MainUnitToDIEPair(main_unit)];
         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()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
+          dst_die.GetDWARF()
+              ->GetDIEToType()[dst_die.MainUnitToDIEPair(main_unit)] =
+              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/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 "lldb/Core/dwarf.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/Support/Error.h"
 
 class DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
 class DWARFUnit;
public:
 
   // Accessors
   SymbolFileDWARF *GetDWARF() const;
 
   DWARFUnit *GetCU() const { return m_cu; }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
-  llvm::Optional<DIERef> GetDIERef() const;
+  llvm::Optional<DIERef> GetDIERef(DWARFUnit *main_unit) const;
 
   void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
     if (cu && die) {
       m_cu = cu;
       m_die = die;
     } else {
       Clear();
     }
public:
   const char *GetTagAsCString() const;
 
   dw_offset_t GetOffset() const;
 
   // Get the LLDB user ID for this DIE. This is often just the DIE offset,
   // but it might have a SymbolFileDWARF::GetID() in the high 32 bits if
   // we are doing Darwin DWARF in .o file, or DWARF stand alone debug
   // info.
-  lldb::user_id_t GetID() const;
+  lldb::user_id_t GetID(DWARFUnit *main_unit) const;
 
   const char *GetName() const;
 
   lldb::ModuleSP GetModule() const;
 
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are

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

 #include "SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb_private;
 
-llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef() const {
+llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef(DWARFUnit *main_unit) const {
   if (!IsValid())
     return llvm::None;
 
+  if (m_cu->GetSymbolFileDWARF().GetDwoNum().hasValue())
+    main_unit = nullptr;
+  if (m_cu == main_unit)
+    main_unit = nullptr;
+
   return DIERef(m_cu->GetSymbolFileDWARF().GetDwoNum(), m_cu->GetDebugSection(),
                 m_die->GetOffset());
 }
 
 dw_tag_t DWARFBaseDIE::Tag() const {
   if (m_die)
     return m_die->Tag();
   else

 uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
                                               uint64_t fail_value) const {
   if (IsValid())
     return m_die->GetAttributeValueAsAddress(GetCU(), attr, fail_value);
   else
     return fail_value;
 }
 
-lldb::user_id_t DWARFBaseDIE::GetID() const {
+lldb::user_id_t DWARFBaseDIE::GetID(DWARFUnit *main_unit) const {
   if (IsValid())
-    return GetDWARF()->GetUID(*this);
+    return GetDWARF()->GetUID(main_unit, *this);
   return LLDB_INVALID_UID;
 }
 
 const char *DWARFBaseDIE::GetName() const {
   if (IsValid())
     return m_die->GetName(m_cu);
   else
     return nullptr;

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);
 
+  virtual DWARFUnit *GetMainDWARFUnit(DWARFUnit *main_unit) override;
+
+  DWARFDIE DIE() { return {this, DIEPtr()}; }
+
+  lldb_private::CompileUnit *GetCompUnit();
+
+  static DWARFCompileUnit *GetMainUnit(const lldb_private::SymbolContext &sc,
+                                       SymbolFileDWARF **dwarf_return);
+  static DWARFCompileUnit *GetMainUnit(lldb_private::CompileUnit &comp_unit,
+                                       SymbolFileDWARF **dwarf_return);
+
 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;
 
+  static DWARFCompileUnit *GetMainUnit(lldb_private::Module &module,
+                                       lldb_private::CompileUnit *comp_unit,
+                                       SymbolFileDWARF **dwarf_return);
+
   friend class DWARFUnit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFCOMPILEUNIT_H

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

 //===-- DWARFCompileUnit.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 "DWARFCompileUnit.h"
 #include "DWARFDebugAranges.h"
 #include "SymbolFileDWARFDebugMap.h"
 
+#include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void DWARFCompileUnit::Dump(Stream *s) const {
if (DIE()) {
     const DWARFDebugAranges &func_aranges = GetFunctionAranges();
 
     // Re-check the aranges auto pointer contents in case it was created above
     if (!func_aranges.IsEmpty())
       return GetDIE(func_aranges.FindAddress(address));
   }
   return DWARFDIE();
 }
+
+DWARFUnit *DWARFCompileUnit::GetMainDWARFUnit(DWARFUnit *main_unit) {
+  main_unit = &main_unit->GetNonSkeletonUnit();
+  return main_unit;
+}
+
+CompileUnit *DWARFCompileUnit::GetCompUnit() {
+  lldbassert(this);
+  CompileUnit *comp_unit =
+      GetNonSkeletonUnit().GetSymbolFileDWARF().GetCompUnitForDWARFCompUnit(
+          *this);
+  lldbassert(comp_unit);
+  return comp_unit;
+}
+
+DWARFCompileUnit *
+DWARFCompileUnit::GetMainUnit(Module &module, CompileUnit *comp_unit,
+                              SymbolFileDWARF **dwarf_return) {
+  SymbolFile *symfile = module.GetSymbolFile();
+  SymbolFileDWARF *dwarf;
+  if (auto *debug_map_symfile = llvm::dyn_cast<SymbolFileDWARFDebugMap>(symfile)) {
+    lldbassert(comp_unit);
+    dwarf = debug_map_symfile->GetSymbolFile(*comp_unit);
+  } else {
+    dwarf = llvm::dyn_cast<SymbolFileDWARF>(symfile);
+    lldbassert(dwarf);
+  }
+  if (dwarf_return)
+    *dwarf_return = dwarf;
+  if (!comp_unit) {
+    lldbassert(dwarf_return);
+    return nullptr;
+  }
+  return dwarf->GetDWARFCompileUnit(comp_unit);
+}
+
+DWARFCompileUnit *
+DWARFCompileUnit::GetMainUnit(CompileUnit &comp_unit,
+                              SymbolFileDWARF **dwarf_return) {
+  ModuleSP module_sp = comp_unit.CalculateSymbolContextModule();
+  lldbassert(module_sp);
+  return GetMainUnit(*module_sp, &comp_unit, dwarf_return);
+}
+
+DWARFCompileUnit *
+DWARFCompileUnit::GetMainUnit(const SymbolContext &sc,
+                              SymbolFileDWARF **dwarf_return) {
+  lldbassert(sc.module_sp);
+  return GetMainUnit(*sc.module_sp, sc.comp_unit, dwarf_return);
+}

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(DWARFUnit *main_unit) const;
 
   // Resolve a type by UID using this DIE's DWARF file
-  lldb_private::Type *ResolveTypeUID(const DWARFDIE &die) const;
+  lldb_private::Type *ResolveTypeUID(DWARFUnit *main_unit,
+                                     const DWARFDIE &die) const;
 
   // Functions for obtaining DIE relations and references
 
   DWARFDIE
   GetParent() const;
 
   DWARFDIE
   GetFirstChild() const;
public:
   DWARFDIE
   GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;
 
   bool GetDIENamesAndRanges(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,
                             lldb_private::DWARFExpression *frame_base) const;
+
+  DWARFUnit *GetMainDWARFUnit(DWARFUnit *main_unit) const;
+  std::pair<DWARFUnit *, DWARFDIE>
+  MainUnitToDWARFDIEPair(DWARFUnit *main_unit) const;
+  std::pair<DWARFUnit *, DWARFDebugInfoEntry *>
+  MainUnitToDIEPair(DWARFUnit *main_unit) const;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDIE_H

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

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(DWARFUnit *main_unit) const {
   if (IsValid())
-    return GetDWARF()->ResolveType(*this, true);
+    return GetMainDWARFUnit(main_unit)->GetSymbolFileDWARF().ResolveType(
+        main_unit, *this, true);
   else
     return nullptr;
 }
 
-lldb_private::Type *DWARFDIE::ResolveTypeUID(const DWARFDIE &die) const {
-  if (SymbolFileDWARF *dwarf = GetDWARF())
-    return dwarf->ResolveTypeUID(die, true);
+lldb_private::Type *DWARFDIE::ResolveTypeUID(DWARFUnit *main_unit,
+                                             const DWARFDIE &die) const {
+  if (SymbolFileDWARF *dwarf =
+          &GetMainDWARFUnit(main_unit)->GetSymbolFileDWARF())
+    return dwarf->ResolveTypeUID(main_unit, die, true);
   return nullptr;
 }
 
 std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
   if (!IsValid())
     return {};
 
   std::vector<DWARFDIE> result;
bool DWARFDIE::GetDIENamesAndRanges(
     lldb_private::DWARFExpression *frame_base) const {
   if (IsValid()) {
     return m_die->GetDIENamesAndRanges(
         GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
         call_file, call_line, call_column, frame_base);
   } else
     return false;
 }
+
+DWARFUnit *DWARFDIE::GetMainDWARFUnit(DWARFUnit *main_unit) const {
+  lldbassert(IsValid());
+  if (main_unit == nullptr)
+    main_unit = GetCU();
+  return GetCU()->GetMainDWARFUnit(main_unit);
+}
+
+std::pair<DWARFUnit *, DWARFDIE>
+DWARFDIE::MainUnitToDWARFDIEPair(DWARFUnit *main_unit) const {
+  return std::make_pair(GetMainDWARFUnit(main_unit), *this);
+}
+
+std::pair<DWARFUnit *, DWARFDebugInfoEntry *>
+DWARFDIE::MainUnitToDIEPair(DWARFUnit *main_unit) const {
+  return std::make_pair(GetMainDWARFUnit(main_unit), GetDIE());
+}

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 GetDIEForDIEOffset(DIERef::Section section,
                               dw_offset_t die_offset);
-  DWARFDIE GetDIE(const DIERef &die_ref);
+  DWARFDIE GetDIE(const DIERef &die_ref,
+                  DWARFUnit **main_unit_return = nullptr);
 
   enum {
     eDumpFlag_Verbose = (1 << 0),  // Verbose dumping
     eDumpFlag_ShowForm = (1 << 1), // Show the DW_form type
     eDumpFlag_ShowAncestors =
         (1 << 2) // Show all parent DIEs when dumping single DIEs
   };
 
   llvm::Expected<DWARFDebugAranges &> GetCompileUnitAranges();
 
+  lldb::user_id_t GetUID(DWARFUnit *main_unit, DIERef ref) const {
+    return m_dwarf.GetUID(main_unit, ref);
+  }
+
+  DWARFCompileUnit *GetDWARFCompileUnit(lldb_private::CompileUnit &comp_unit);
+
 protected:
   typedef std::vector<DWARFUnitSP> UnitColl;
 
   SymbolFileDWARF &m_dwarf;
   lldb_private::DWARFContext &m_context;
 
   llvm::once_flag m_units_once_flag;
   UnitColl m_units;

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

 //===-- DWARFDebugInfo.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 "SymbolFileDWARF.h"
 
 #include <algorithm>
 #include <set>
 
 #include "lldb/Host/PosixApi.h"
+#include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "llvm/Support/Casting.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFContext.h"
 #include "DWARFDebugAranges.h"
llvm::Expected<DWARFDebugAranges &> DWARFDebugInfo::GetCompileUnitAranges() {
   }
 
   // Manually build arange data for everything that wasn't in the
   // .debug_aranges table.
   const size_t num_units = GetNumUnits();
   for (size_t idx = 0; idx < num_units; ++idx) {
     DWARFUnit *cu = GetUnitAtIndex(idx);
 
+    if (cu->GetUnitDIEOnly().Tag() == DW_TAG_partial_unit)
+      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);
   return *m_cu_aranges_up;
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) {
+  // This function will be extended by a later DWZ patch.
+  DWARFUnit *main_unit = GetUnit(die_ref);
+  return main_unit;
+}
+
 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;
if (cu)
     return cu->GetDIE(die_offset);
   return DWARFDIE();
 }
 
 // GetDIE()
 //
 // Get the DIE (Debug Information Entry) with the specified offset.
 DWARFDIE
-DWARFDebugInfo::GetDIE(const DIERef &die_ref) {
+DWARFDebugInfo::GetDIE(const DIERef &die_ref, DWARFUnit **main_unit_return) {
   DWARFUnit *cu = GetUnit(die_ref);
-  if (cu)
-    return cu->GetNonSkeletonUnit().GetDIE(die_ref.die_offset());
+  if (cu) {
+    DWARFUnit *main_unit = GetMainUnit(die_ref);
+    if (main_unit == cu)
+      cu = main_unit = &main_unit->GetNonSkeletonUnit();
+    if (main_unit_return)
+      *main_unit_return = main_unit;
+    return cu->GetDIE(die_ref.die_offset());
+  }
   return DWARFDIE(); // Not found
 }
+
+DWARFCompileUnit *DWARFDebugInfo::GetDWARFCompileUnit(CompileUnit &comp_unit) {
+  // The compile unit ID is the index of the DWARF unit.
+  DWARFUnit *dwarf_cu = GetUnitAtIndex(comp_unit.GetID());
+  if (!dwarf_cu)
+    return nullptr;
+
+  if (dwarf_cu->GetUserData() == nullptr)
+    dwarf_cu->SetUserData(&comp_unit);
+  else
+    lldbassert(dwarf_cu->GetUserData() == &comp_unit);
+
+  // It must be DWARFCompileUnit when it created a CompileUnit.
+  return llvm::cast<DWARFCompileUnit>(dwarf_cu);
+}

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

for (;;) {
     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();
   }
 }
 
+// DIE.GetCU(), not main_unit.
 DWARFDeclContext DWARFDebugInfoEntry::GetDWARFDeclContext(DWARFUnit *cu) const {
   return GetDWARFDeclContextStatic(this, cu);
 }
 
 DWARFDIE
 DWARFDebugInfoEntry::GetParentDeclContextDIE(DWARFUnit *cu) const {
   DWARFAttributes attributes;
   GetAttributes(cu, attributes, Recurse::yes);

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

 //===-- DWARFIndex.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_DWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DIERef.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/DWARFFormValue.h"
 
 class DWARFDeclContext;
 class DWARFDIE;
 
 namespace lldb_private {
 class DWARFIndex {
 public:
   DWARFIndex(Module &module) : m_module(module) {}
   virtual ~DWARFIndex();
 
   virtual void Preload() = 0;
 
   /// Finds global variables with the given base name. Any additional filtering
   /// (e.g., to only retrieve variables from a given context) should be done by
   /// the consumer.
-  virtual void
-  GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
-
-  virtual void
-  GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
-  virtual void
-  GetGlobalVariables(const DWARFUnit &cu,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
+  virtual void GetGlobalVariables(
+      ConstString basename,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+          callback) = 0;
+
+  virtual void GetGlobalVariables(
+      const RegularExpression &regex,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+          callback) = 0;
+  virtual void GetGlobalVariables(
+      const DWARFUnit &main_unit,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+          callback) = 0;
   virtual void
   GetObjCMethods(ConstString class_name,
-                 llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
-  virtual void
-  GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                       llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
-  virtual void GetTypes(ConstString name,
-                        llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
-  virtual void GetTypes(const DWARFDeclContext &context,
-                        llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
+                 llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                     callback) = 0;
+  virtual void GetCompleteObjCClass(
+      ConstString class_name, bool must_be_implementation,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+          callback) = 0;
+  virtual void
+  GetTypes(ConstString name,
+           llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+               callback) = 0;
+  virtual void
+  GetTypes(const DWARFDeclContext &context,
+           llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+               callback) = 0;
   virtual void
   GetNamespaces(ConstString name,
-                llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) = 0;
   virtual void
   GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                const CompilerDeclContext &parent_decl_ctx,
                uint32_t name_type_mask,
-               llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
+               llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                   callback) = 0;
   virtual void
   GetFunctions(const RegularExpression &regex,
-               llvm::function_ref<bool(DWARFDIE die)> callback) = 0;
+               llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                   callback) = 0;
 
   virtual void Dump(Stream &s) = 0;
 
 protected:
   Module &m_module;
 
   /// Helper function implementing common logic for processing function dies. If
   /// the function given by "ref" matches search criteria given by
   /// "parent_decl_ctx" and "name_type_mask", it is inserted into the "dies"
   /// vector.
-  bool ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
-                          SymbolFileDWARF &dwarf,
-                          const CompilerDeclContext &parent_decl_ctx,
-                          uint32_t name_type_mask,
-                          llvm::function_ref<bool(DWARFDIE die)> callback);
+  bool ProcessFunctionDIE(
+      llvm::StringRef name, DWARFUnit *main_unit, DIERef ref,
+      SymbolFileDWARF &dwarf, const CompilerDeclContext &parent_decl_ctx,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback);
 
-  class DIERefCallbackImpl {
+  class DIECallbackImpl {
   public:
-    DIERefCallbackImpl(const DWARFIndex &index,
-                       llvm::function_ref<bool(DWARFDIE die)> callback,
-                       llvm::StringRef name);
-    bool operator()(DIERef ref) const;
+    DIECallbackImpl(
+        const DWARFIndex &index,
+        llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback,
 
-  private:
+  protected:
     const DWARFIndex &m_index;
     SymbolFileDWARF &m_dwarf;
-    const llvm::function_ref<bool(DWARFDIE die)> m_callback;
+    const llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+        m_callback;
     const llvm::StringRef m_name;
   };
-  DIERefCallbackImpl
-  DIERefCallback(llvm::function_ref<bool(DWARFDIE die)> callback,
-                 llvm::StringRef name = {}) const {
+  class DIERefCallbackImpl : protected DIECallbackImpl {
+  public:
+    using DIECallbackImpl::DIECallbackImpl;
+    bool operator()(DIERef ref) const;
+  };
+  class DIEUIDCallbackImpl : protected DIECallbackImpl {
+  public:
+    using DIECallbackImpl::DIECallbackImpl;
+    bool operator()(lldb::user_id_t uid) const;
+  };
+  DIERefCallbackImpl DIERefCallback(
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback,
     return DIERefCallbackImpl(*this, callback, name);
   }
+  DIEUIDCallbackImpl DIEUIDCallback(
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback,
+      llvm::StringRef name = {}) const {
+    return DIEUIDCallbackImpl(*this, callback, name);
+  }
 
   void ReportInvalidDIERef(DIERef ref, llvm::StringRef name) const;
+  void ReportInvalidDIEUID(lldb::user_id_t, llvm::StringRef name) const;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H

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

 //===-- DWARFIndex.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/DWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 DWARFIndex::~DWARFIndex() = default;
 
 bool DWARFIndex::ProcessFunctionDIE(
-    llvm::StringRef name, DIERef ref, SymbolFileDWARF &dwarf,
-    const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::StringRef name, DWARFUnit *main_unit, DIERef ref,
+    SymbolFileDWARF &dwarf, const CompilerDeclContext &parent_decl_ctx,
+    uint32_t name_type_mask,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   DWARFDIE die = dwarf.GetDIE(ref);
   if (!die) {
     ReportInvalidDIERef(ref, name);
     return true;
   }
+  main_unit = die.GetMainDWARFUnit(main_unit);
 
   // Exit early if we're searching exclusively for methods or selectors and
   // we have a context specified (no methods in namespaces).
   uint32_t looking_for_nonmethods =
       name_type_mask & ~(eFunctionNameTypeMethod | eFunctionNameTypeSelector);
   if (!looking_for_nonmethods && parent_decl_ctx.IsValid())
     return true;
 
   // Otherwise, we need to also check that the context matches. If it does not
   // match, we do nothing.
-  if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
+  if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, main_unit, die))
     return true;
 
   // In case of a full match, we just insert everything we find.
   if (name_type_mask & eFunctionNameTypeFull)
-    return callback(die);
+    return callback(main_unit, die);
 
   // If looking for ObjC selectors, we need to also check if the name is a
   // possible selector.
   if (name_type_mask & eFunctionNameTypeSelector &&
       ObjCLanguage::IsPossibleObjCMethodName(die.GetName()))
-    return callback(die);
+    return callback(main_unit, die);
 
   bool looking_for_methods = name_type_mask & lldb::eFunctionNameTypeMethod;
   bool looking_for_functions = name_type_mask & lldb::eFunctionNameTypeBase;
   if (looking_for_methods || looking_for_functions) {
     // If we're looking for either methods or functions, we definitely want this
     // die. Otherwise, only keep it if the die type matches what we are
     // searching for.
     if ((looking_for_methods && looking_for_functions) ||
         looking_for_methods == die.IsMethod())
-      return callback(die);
+      return callback(main_unit, die);
   }
 
   return true;
 }
 
-DWARFIndex::DIERefCallbackImpl::DIERefCallbackImpl(
-    const DWARFIndex &index, llvm::function_ref<bool(DWARFDIE die)> callback,
+DWARFIndex::DIECallbackImpl::DIECallbackImpl(
+    const DWARFIndex &index,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback,
     llvm::StringRef name)
     : m_index(index),
       m_dwarf(*llvm::cast<SymbolFileDWARF>(index.m_module.GetSymbolFile())),
       m_callback(callback), m_name(name) {}
 
 bool DWARFIndex::DIERefCallbackImpl::operator()(DIERef ref) const {
-  if (DWARFDIE die = m_dwarf.GetDIE(ref))
-    return m_callback(die);
+  DWARFUnit *main_unit;
+  if (DWARFDIE die = m_dwarf.GetDIE(ref, &main_unit))
+    return m_callback(main_unit, die);
   m_index.ReportInvalidDIERef(ref, m_name);
   return true;
 }
 
+bool DWARFIndex::DIEUIDCallbackImpl::operator()(user_id_t uid) const {
+  DWARFUnit *main_unit;
+  if (DWARFDIE die = m_dwarf.GetDIE(uid, &main_unit))
+    return m_callback(main_unit, die);
+  m_index.ReportInvalidDIEUID(uid, m_name);
+  return true;
+}
+
 void DWARFIndex::ReportInvalidDIERef(DIERef ref, llvm::StringRef name) const {
   m_module.ReportErrorIfModifyDetected(
       "the DWARF debug information has been modified (accelerator table had "
-      "bad die 0x%8.8x for '%s')\n",
+      "bad DIERef 0x%8.8x for '%s')\n",
       ref.die_offset(), name.str().c_str());
 }
+
+void DWARFIndex::ReportInvalidDIEUID(user_id_t uid,
+                                     llvm::StringRef name) const {
+  m_module.ReportErrorIfModifyDetected(
+      "the DWARF debug information has been modified (accelerator table had "
+      "bad user_id_t 0x%" PRIx64 " for '%s')\n",
+      uid, name.str().c_str());
+}

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

public:
   void Dump(lldb_private::Stream *s) const override;
 
   uint64_t GetTypeHash() { return m_header.GetTypeHash(); }
 
   dw_offset_t GetTypeOffset() { return GetOffset() + m_header.GetTypeOffset(); }
 
   static bool classof(const DWARFUnit *unit) { return unit->IsTypeUnit(); }
 
+  virtual DWARFUnit *GetMainDWARFUnit(DWARFUnit *main_unit) override;
+
 private:
   DWARFTypeUnit(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) {}
 
   friend class DWARFUnit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFTYPEUNIT_H

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

 
 void DWARFTypeUnit::Dump(Stream *s) const {
   s->Printf("0x%8.8x: Type Unit: length = 0x%8.8x, version = 0x%4.4x, "
             "abbr_offset = 0x%8.8x, addr_size = 0x%2.2x (next CU at "
             "{0x%8.8x})\n",
             GetOffset(), GetLength(), GetVersion(), GetAbbrevOffset(),
             GetAddressByteSize(), GetNextUnitOffset());
 }
+
+DWARFUnit *DWARFTypeUnit::GetMainDWARFUnit(DWARFUnit *main_unit) {
+  return &GetNonSkeletonUnit();
+}

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

public:
 
   /// Return the location table for parsing the given location list data. The
   /// format is chosen according to the unit type. Never returns null.
   std::unique_ptr<llvm::DWARFLocationTable>
   GetLocationTable(const lldb_private::DataExtractor &data) const;
 
   lldb_private::DWARFDataExtractor GetLocationData() const;
 
+  virtual DWARFUnit *GetMainDWARFUnit(DWARFUnit *main_unit) = 0;
+
 protected:
   DWARFUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
             const DWARFUnitHeader &header,
             const DWARFAbbreviationDeclarationSet &abbrevs,
             DIERef::Section section, bool is_dwo);
 
   llvm::Error ExtractHeader(SymbolFileDWARF &dwarf,
                             const lldb_private::DWARFDataExtractor &data,
protected:
   const DWARFDebugInfoEntry *DIEPtr() {
     ExtractDIEsIfNeeded();
     if (m_die_array.empty())
       return NULL;
     return &m_die_array[0];
   }
 
   SymbolFileDWARF &m_dwarf;
-  std::shared_ptr<DWARFUnit> m_dwo;
+  std::shared_ptr<DWARFCompileUnit> m_dwo;
   DWARFUnitHeader m_header;
   const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr;
   void *m_user_data = nullptr;
   // The compile unit debug information entry item
   DWARFDebugInfoEntry::collection m_die_array;
   mutable llvm::sys::RWMutex m_die_array_mutex;
   // It is used for tracking of ScopedExtractDIEs instances.
   mutable llvm::sys::RWMutex m_die_array_scoped_mutex;

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

if (m_is_dwo) {
     return;
   }
 
   std::shared_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf.GetDwoSymbolFileForCompileUnit(*this, cu_die);
   if (!dwo_symbol_file)
     return;
 
-  DWARFUnit *dwo_cu = dwo_symbol_file->GetDWOCompileUnitForHash(m_dwo_id);
+  DWARFCompileUnit *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())
     return; // Can't fetch the compile unit DIE from the dwo file.
else if (dwo_symbol_file->GetDWARFContext()
     dwo_cu->SetRangesBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
 
   if (GetVersion() >= 5 &&
       dwo_symbol_file->GetDWARFContext().getOrLoadLocListsData().GetByteSize() >
           0)
     dwo_cu->SetLoclistsBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
   dwo_cu->SetBaseAddress(GetBaseAddress());
 
-  m_dwo = std::shared_ptr<DWARFUnit>(std::move(dwo_symbol_file), dwo_cu);
+  m_dwo = std::shared_ptr<DWARFCompileUnit>(std::move(dwo_symbol_file), dwo_cu);
 }
 
 size_t DWARFUnit::GetDebugInfoSize() const {
   return GetLengthByteSize() + GetLength() - GetHeaderByteSize();
 }
 
 const DWARFAbbreviationDeclarationSet *DWARFUnit::GetAbbreviations() const {
   return m_abbrevs;

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

 //===-- DebugNamesDWARFIndex.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_DEBUGNAMESDWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DEBUGNAMESDWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 #include "Plugins/SymbolFile/DWARF/ManualDWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "lldb/Utility/ConstString.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 
 namespace lldb_private {
 class DebugNamesDWARFIndex : public DWARFIndex {
 public:
   static llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
   Create(Module &module, DWARFDataExtractor debug_names,
          DWARFDataExtractor debug_str, SymbolFileDWARF &dwarf);
 
   void Preload() override { m_fallback.Preload(); }
 
-  void
-  GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void
-  GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void
-  GetGlobalVariables(const DWARFUnit &cu,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
+  void GetGlobalVariables(
+      ConstString basename,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
+  void GetGlobalVariables(
+      const RegularExpression &regex,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
+  void GetGlobalVariables(
+      const DWARFUnit &main_unit,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
   void
   GetObjCMethods(ConstString class_name,
-                 llvm::function_ref<bool(DWARFDIE die)> callback) override {}
+                 llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                     callback) override {}
   void GetCompleteObjCClass(
       ConstString class_name, bool must_be_implementation,
-      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
   void GetTypes(ConstString name,
-                llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
   void GetTypes(const DWARFDeclContext &context,
-                llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetNamespaces(ConstString name,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
+  void
+  GetNamespaces(ConstString name,
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                        callback) override;
   void GetFunctions(const RegularExpression &regex,
-                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                        callback) override;
 
   void Dump(Stream &s) override;
 
 private:
   DebugNamesDWARFIndex(Module &module,
                        std::unique_ptr<llvm::DWARFDebugNames> debug_names_up,
                        DWARFDataExtractor debug_names_data,
                        DWARFDataExtractor debug_str_data,
private:
   DWARFDataExtractor m_debug_names_data;
   DWARFDataExtractor m_debug_str_data;
 
   using DebugNames = llvm::DWARFDebugNames;
   std::unique_ptr<DebugNames> m_debug_names_up;
   ManualDWARFIndex m_fallback;
 
   llvm::Optional<DIERef> ToDIERef(const DebugNames::Entry &entry);
-  bool ProcessEntry(const DebugNames::Entry &entry,
-                    llvm::function_ref<bool(DWARFDIE die)> callback,
-                    llvm::StringRef name);
+  bool ProcessEntry(
+      const DebugNames::Entry &entry,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback,
 
   static void MaybeLogLookupError(llvm::Error error,
                                   const DebugNames::NameIndex &ni,
                                   llvm::StringRef name);
 
   static llvm::DenseSet<dw_offset_t> GetUnits(const DebugNames &debug_names);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DEBUGNAMESDWARFINDEX_H

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

 //===-- DebugNamesDWARFIndex.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/DebugNamesDWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb_private;
if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
     return DIERef(cu->GetSymbolFileDWARF().GetDwoNum(),
                   DIERef::Section::DebugInfo, cu->GetOffset() + *die_offset);
 
   return llvm::None;
 }
 
 bool DebugNamesDWARFIndex::ProcessEntry(
     const DebugNames::Entry &entry,
-    llvm::function_ref<bool(DWARFDIE die)> callback, llvm::StringRef name) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback,
+    llvm::StringRef name) {
   llvm::Optional<DIERef> ref = ToDIERef(entry);
   if (!ref)
     return true;
   SymbolFileDWARF &dwarf =
       *llvm::cast<SymbolFileDWARF>(m_module.GetSymbolFile());
   DWARFDIE die = dwarf.GetDIE(*ref);
   if (!die)
     return true;
-  return callback(die);
+  // FIXME: .debug_names have no DWZ support yet.
+  DWARFUnit *main_unit = die.GetMainDWARFUnit(nullptr);
+  return callback(main_unit, die);
 }
 
 void DebugNamesDWARFIndex::MaybeLogLookupError(llvm::Error error,
                                                const DebugNames::NameIndex &ni,
                                                llvm::StringRef name) {
   // Ignore SentinelErrors, log everything else.
   LLDB_LOG_ERROR(
       LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS),
       handleErrors(std::move(error), [](const DebugNames::SentinelError &) {}),
       "Failed to parse index entries for index at {1:x}, name {2}: {0}",
       ni.getUnitOffset(), name);
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(
-    ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString basename,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(basename.GetStringRef())) {
     if (entry.tag() != DW_TAG_variable)
       continue;
 
     if (!ProcessEntry(entry, callback, basename.GetStringRef()))
       return;
   }
 
   m_fallback.GetGlobalVariables(basename, callback);
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       if (!regex.Execute(nte.getString()))
         continue;
 
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
         if (entry_or->tag() != DW_TAG_variable)
           continue;
 
         if (!ProcessEntry(*entry_or, callback,
                           llvm::StringRef(nte.getString())))
           return;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
 
   m_fallback.GetGlobalVariables(regex, callback);
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(
-    const DWARFUnit &cu, llvm::function_ref<bool(DWARFDIE die)> callback) {
-  uint64_t cu_offset = cu.GetOffset();
+    const DWARFUnit &main_unit,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
+  uint64_t cu_offset = main_unit.GetOffset();
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
         if (entry_or->tag() != DW_TAG_variable)
           continue;
         if (entry_or->getCUOffset() != cu_offset)
           continue;
 
         if (!ProcessEntry(*entry_or, callback,
                           llvm::StringRef(nte.getString())))
           return;
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
 
-  m_fallback.GetGlobalVariables(cu, callback);
+  m_fallback.GetGlobalVariables(main_unit, callback);
 }
 
 void DebugNamesDWARFIndex::GetCompleteObjCClass(
     ConstString class_name, bool must_be_implementation,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   // Keep a list of incomplete types as fallback for when we don't find the
   // complete type.
+  // FIXME: .debug_names have no DWZ support yet.
   DIEArray incomplete_types;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(class_name.GetStringRef())) {
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
for (const DebugNames::Entry &entry :
     DWARFDIE die = m_debug_info.GetDIE(*ref);
     if (!die) {
       ReportInvalidDIERef(*ref, class_name.GetStringRef());
       continue;
     }
 
     if (die.GetAttributeValueAsUnsigned(DW_AT_APPLE_objc_complete_type, 0)) {
       // If we find the complete version we're done.
-      callback(die);
+      // FIXME: .debug_names have no DWZ support yet.
+      callback(nullptr /* main_unit */, die);
       return;
     }
     incomplete_types.push_back(*ref);
   }
 
+  // FIXME: .debug_names have no DWZ support yet.
   auto dierefcallback = DIERefCallback(callback, class_name.GetStringRef());
   for (DIERef ref : incomplete_types)
     if (!dierefcallback(ref))
       return;
 
   m_fallback.GetCompleteObjCClass(class_name, must_be_implementation, callback);
 }
 
 void DebugNamesDWARFIndex::GetTypes(
-    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     if (isType(entry.tag())) {
       if (!ProcessEntry(entry, callback, name.GetStringRef()))
         return;
     }
   }
 
   m_fallback.GetTypes(name, callback);
 }
 
 void DebugNamesDWARFIndex::GetTypes(
     const DWARFDeclContext &context,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   auto name = context[0].name;
   for (const DebugNames::Entry &entry : m_debug_names_up->equal_range(name)) {
     if (entry.tag() == context[0].tag) {
       if (!ProcessEntry(entry, callback, name))
         return;
     }
   }
 
   m_fallback.GetTypes(context, callback);
 }
 
 void DebugNamesDWARFIndex::GetNamespaces(
-    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     if (entry.tag() == DW_TAG_namespace) {
       if (!ProcessEntry(entry, callback, name.GetStringRef()))
         return;
     }
   }
 
   m_fallback.GetNamespaces(name, callback);
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
     ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
 
+  // FIXME: .debug_names have no DWZ support yet.
   std::set<DWARFDebugInfoEntry *> seen;
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     Tag tag = entry.tag();
     if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
       continue;
 
     if (llvm::Optional<DIERef> ref = ToDIERef(entry)) {
-      if (!ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
-                              name_type_mask, [&](DWARFDIE die) {
+      // FIXME: .debug_names have no DWZ support yet.
+      DWARFUnit *main_unit = nullptr;
+      if (!ProcessFunctionDIE(name.GetStringRef(), main_unit, *ref, dwarf,
+                              parent_decl_ctx, name_type_mask,
+                              [&](DWARFUnit *main_unit_check, DWARFDIE die) {
+                                // FIXME: .debug_names have no DWZ support yet.
+                                // lldbassert(main_unit_check == main_unit);
                                 if (!seen.insert(die.GetDIE()).second)
                                   return true;
-                                return callback(die);
+                                // FIXME: .debug_names have no DWZ support yet.
+                                return callback(main_unit_check, die);
                               }))
         return;
     }
   }
 
   m_fallback.GetFunctions(name, dwarf, parent_decl_ctx, name_type_mask,
                           callback);
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       if (!regex.Execute(nte.getString()))
         continue;
 
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {

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/NameToDIE.h"
 #include "llvm/ADT/DenseSet.h"
 
 class DWARFDebugInfo;
 class SymbolFileDWARFDwo;
 
 namespace lldb_private {
 class ManualDWARFIndex : public DWARFIndex {
 public:
   ManualDWARFIndex(Module &module, SymbolFileDWARF &dwarf,
                    llvm::DenseSet<dw_offset_t> units_to_avoid = {})
       : DWARFIndex(module), m_dwarf(&dwarf),
         m_units_to_avoid(std::move(units_to_avoid)) {}
 
   void Preload() override { Index(); }
 
+  void GetGlobalVariables(
+      ConstString basename,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
+  void GetGlobalVariables(
+      const RegularExpression &regex,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
+  void GetGlobalVariables(
+      const DWARFUnit &main_unit,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
   void
-  GetGlobalVariables(ConstString basename,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void
-  GetGlobalVariables(const RegularExpression &regex,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void
-  GetGlobalVariables(const DWARFUnit &unit,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetObjCMethods(ConstString class_name,
-                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+  GetObjCMethods(ConstString class_name,
+                 llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                     callback) override;
   void GetCompleteObjCClass(
       ConstString class_name, bool must_be_implementation,
-      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback)
+      override;
   void GetTypes(ConstString name,
-                llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
   void GetTypes(const DWARFDeclContext &context,
-                llvm::function_ref<bool(DWARFDIE die)> callback) override;
-  void GetNamespaces(ConstString name,
-                     llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
+  void
+  GetNamespaces(ConstString name,
+                llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                    callback) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                        callback) override;
   void GetFunctions(const RegularExpression &regex,
-                    llvm::function_ref<bool(DWARFDIE die)> callback) override;
+                    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                        callback) override;
 
   void Dump(Stream &s) override;
 
 private:
   struct IndexSet {
     NameToDIE function_basenames;
     NameToDIE function_fullnames;
     NameToDIE function_methods;
     NameToDIE function_selectors;
     NameToDIE objc_class_selectors;
     NameToDIE globals;
     NameToDIE types;
     NameToDIE namespaces;
   };
   void Index();
   void IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp, IndexSet &set);
 
-  static void IndexUnitImpl(DWARFUnit &unit,
+  static void IndexUnitImpl(DWARFUnit &unit, DWARFUnit *main_unit,
                             const lldb::LanguageType cu_language,
                             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/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"
void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp,
   if (log) {
     m_module.LogMessage(
         log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
         unit.GetOffset());
   }
 
   const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
 
-  IndexUnitImpl(unit, cu_language, set);
+  IndexUnitImpl(unit, &unit, cu_language, set);
 
   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(), &unit, cu_language, set);
     } else {
       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);
+        IndexUnitImpl(*dwo_info.GetUnitAtIndex(i), &unit, cu_language, set);
     }
   }
 }
 
-void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit,
+void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit, DWARFUnit *main_unit,
                                      const LanguageType cu_language,
                                      IndexSet &set) {
   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:
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(&unit, &die).GetDIERef(main_unit);
     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) {
for (const DWARFDebugInfoEntry &die : unit.dies()) {
 
     default:
       continue;
     }
   }
 }
 
 void ManualDWARFIndex::GetGlobalVariables(
-    ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString basename,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
   m_set.globals.Find(basename,
                      DIERefCallback(callback, basename.GetStringRef()));
 }
 
 void ManualDWARFIndex::GetGlobalVariables(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
   m_set.globals.Find(regex, DIERefCallback(callback, regex.GetText()));
 }
 
 void ManualDWARFIndex::GetGlobalVariables(
-    const DWARFUnit &unit, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    const DWARFUnit &main_unit,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
-  m_set.globals.FindAllEntriesForUnit(unit, DIERefCallback(callback));
+  m_set.globals.FindAllEntriesForUnit(main_unit, DIERefCallback(callback));
 }
 
 void ManualDWARFIndex::GetObjCMethods(
-    ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString class_name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
   m_set.objc_class_selectors.Find(
       class_name, DIERefCallback(callback, class_name.GetStringRef()));
 }
 
 void ManualDWARFIndex::GetCompleteObjCClass(
     ConstString class_name, bool must_be_implementation,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
   m_set.types.Find(class_name,
                    DIERefCallback(callback, class_name.GetStringRef()));
 }
 
 void ManualDWARFIndex::GetTypes(
-    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
   m_set.types.Find(name, DIERefCallback(callback, name.GetStringRef()));
 }
 
 void ManualDWARFIndex::GetTypes(
     const DWARFDeclContext &context,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
   auto name = context[0].name;
   m_set.types.Find(ConstString(name),
                    DIERefCallback(callback, llvm::StringRef(name)));
 }
 
 void ManualDWARFIndex::GetNamespaces(
-    ConstString name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
   m_set.namespaces.Find(name, DIERefCallback(callback, name.GetStringRef()));
 }
 
 void ManualDWARFIndex::GetFunctions(
     ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
 
   if (name_type_mask & eFunctionNameTypeFull) {
     if (!m_set.function_fullnames.Find(
             name, DIERefCallback(
-                      [&](DWARFDIE die) {
+                      [&](DWARFUnit *main_unit, DWARFDIE die) {
                         if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx,
-                                                               die))
+                                                               main_unit, die))
                           return true;
-                        return callback(die);
+                        return callback(main_unit, die);
                       },
                       name.GetStringRef())))
       return;
   }
   if (name_type_mask & eFunctionNameTypeBase) {
     if (!m_set.function_basenames.Find(
             name, DIERefCallback(
-                      [&](DWARFDIE die) {
+                      [&](DWARFUnit *main_unit, DWARFDIE die) {
                         if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx,
-                                                               die))
+                                                               main_unit, die))
                           return true;
-                        return callback(die);
+                        return callback(main_unit, die);
                       },
                       name.GetStringRef())))
       return;
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
     if (!m_set.function_methods.Find(
             name, DIERefCallback(callback, name.GetStringRef())))
       return;
   }
 
   if (name_type_mask & eFunctionNameTypeSelector &&
       !parent_decl_ctx.IsValid()) {
     if (!m_set.function_selectors.Find(
             name, DIERefCallback(callback, name.GetStringRef())))
       return;
   }
 }
 
 void ManualDWARFIndex::GetFunctions(
     const RegularExpression &regex,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   Index();
 
   if (!m_set.function_basenames.Find(regex,
                                      DIERefCallback(callback, regex.GetText())))
     return;
   if (!m_set.function_fullnames.Find(regex,
                                      DIERefCallback(callback, regex.GetText())))
     return;

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

 #include <mutex>
 #include <unordered_map>
 #include <vector>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
public:
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
-  lldb_private::Type *ResolveType(const DWARFDIE &die,
+  lldb_private::Type *ResolveType(DWARFUnit *main_unit, const DWARFDIE &die,
                                   bool assert_not_being_parsed = true,
                                   bool resolve_function_context = false);
 
   lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextForUID(lldb::user_id_t uid) override;
 
public:
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 
   lldb_private::CompileUnit *
   GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu);
 
-  virtual void GetObjCMethods(lldb_private::ConstString class_name,
-                              llvm::function_ref<bool(DWARFDIE die)> callback);
+  virtual void GetObjCMethods(
+      lldb_private::ConstString class_name,
+      llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback);
 
   bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu);
 
   lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset);
 
   static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die);
 
   lldb::ModuleSP GetExternalModule(lldb_private::ConstString name);
 
   typedef std::map<lldb_private::ConstString, lldb::ModuleSP>
       ExternalTypeModuleMap;
 
   /// Return the list of Clang modules imported by this SymbolFile.
   const ExternalTypeModuleMap& getExternalTypeModules() const {
       return m_external_type_modules;
   }
 
-  virtual DWARFDIE GetDIE(const DIERef &die_ref);
+  virtual DWARFDIE GetDIE(const DIERef &die_ref,
+                          DWARFUnit **main_unit_return = nullptr);
 
-  DWARFDIE GetDIE(lldb::user_id_t uid);
+  DWARFDIE GetDIE(lldb::user_id_t uid, DWARFUnit **main_unit_return = nullptr);
 
-  lldb::user_id_t GetUID(const DWARFBaseDIE &die) {
-    return GetUID(die.GetDIERef());
-  }
+  lldb::user_id_t GetUID(DWARFUnit *main_unit, const DWARFBaseDIE &die);
 
-  lldb::user_id_t GetUID(const llvm::Optional<DIERef> &ref) {
-    return ref ? GetUID(*ref) : LLDB_INVALID_UID;
+  lldb::user_id_t GetUID(DWARFUnit *main_unit,
+                         const llvm::Optional<DIERef> &ref) {
+    return ref ? GetUID(main_unit, *ref) : LLDB_INVALID_UID;
   }
 
-  lldb::user_id_t GetUID(DIERef ref);
+  lldb::user_id_t GetUID(DWARFUnit *main_unit, DIERef ref);
 
   std::shared_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   virtual llvm::Optional<uint32_t> GetDwoNum() { return llvm::None; }
 
   /// If this is a DWARF object with a single CU, return its DW_AT_dwo_id.
   llvm::Optional<uint64_t> GetDWOId();
 
   static bool
   DIEInDeclContext(const lldb_private::CompilerDeclContext &parent_decl_ctx,
-                   const DWARFDIE &die);
+                   DWARFUnit *main_unit, const DWARFDIE &die);
 
   std::vector<std::unique_ptr<lldb_private::CallEdge>>
   ParseCallEdgesInFunction(UserID func_id) override;
 
   void Dump(lldb_private::Stream &s) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
   lldb_private::DWARFContext &GetDWARFContext() { return m_context; }
 
   const std::shared_ptr<SymbolFileDWARFDwo> &GetDwpSymbolFile();
 
   lldb_private::FileSpec GetFile(DWARFUnit &unit, size_t file_idx);
 
   static llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystem(DWARFUnit &unit);
 
   static DWARFASTParser *GetDWARFParser(DWARFUnit &unit);
 
   // CompilerDecl related functions
 
-  static lldb_private::CompilerDecl GetDecl(const DWARFDIE &die);
+  static lldb_private::CompilerDecl GetDecl(DWARFUnit *main_unit,
+                                            const DWARFDIE &die);
 
-  static lldb_private::CompilerDeclContext GetDeclContext(const DWARFDIE &die);
+  static lldb_private::CompilerDeclContext GetDeclContext(DWARFUnit *main_unit,
+                                                          const DWARFDIE &die);
 
   static lldb_private::CompilerDeclContext
-  GetContainingDeclContext(const DWARFDIE &die);
+  GetContainingDeclContext(DWARFUnit *main_unit, const DWARFDIE &die);
 
-  static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die);
+  static DWARFDeclContext GetDWARFDeclContext(DWARFUnit *main_unit,
+                                              const DWARFDIE &die);
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   static lldb::LanguageType GetLanguage(DWARFUnit &unit);
 
+  llvm::Optional<uint32_t> GetDWARFUnitIndex(uint32_t cu_idx);
+
+  virtual SymbolFileDWARF &GetBaseSymbolFile() { return *this; }
+
 protected:
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
+  typedef llvm::DenseMap<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>,
+                         lldb_private::Type *>
       DIEToTypePtr;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
+  typedef llvm::DenseMap<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>,
+                         lldb::VariableSP>
       DIEToVariableSP;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
+  typedef llvm::DenseMap<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
-  typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
+  typedef llvm::DenseMap<lldb::opaque_compiler_type_t, lldb::user_id_t>
+      ClangTypeToDIE;
 
   SymbolFileDWARF(const SymbolFileDWARF &) = delete;
   const SymbolFileDWARF &operator=(const SymbolFileDWARF &) = delete;
 
   virtual void LoadSectionData(lldb::SectionType sect_type,
                                lldb_private::DWARFDataExtractor &data);
 
   bool DeclContextMatchesThisSymbolFile(
       const lldb_private::CompilerDeclContext &decl_ctx);
 
   uint32_t CalculateNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   lldb_private::TypeList &GetTypeList() override;
 
   lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit &dwarf_cu);
 
-  virtual DWARFCompileUnit *
-  GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
+  DWARFCompileUnit *GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
 
   DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu);
 
-  bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc);
+  bool GetFunction(DWARFUnit *main_unit, const DWARFDIE &die,
+                   lldb_private::SymbolContext &sc);
 
   lldb_private::Function *ParseFunction(lldb_private::CompileUnit &comp_unit,
                                         const DWARFDIE &die);
 
   size_t ParseBlocksRecursive(lldb_private::CompileUnit &comp_unit,
                               lldb_private::Block *parent_block,
                               const DWARFDIE &die,
                               lldb::addr_t subprogram_low_pc, uint32_t depth);
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                     bool parse_siblings, bool parse_children);
 
   lldb::TypeSP ParseType(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die, bool *type_is_new);
 
-  lldb_private::Type *ResolveTypeUID(const DWARFDIE &die,
+  lldb_private::Type *ResolveTypeUID(DWARFUnit *main_unit, const DWARFDIE &die,
                                      bool assert_not_being_parsed);
 
-  lldb_private::Type *ResolveTypeUID(const DIERef &die_ref);
+  lldb_private::Type *ResolveTypeUID(DWARFUnit *main_unit,
+                                     const DIERef &die_ref);
 
   lldb::VariableSP ParseVariableDIE(const lldb_private::SymbolContext &sc,
                                     const DWARFDIE &die,
                                     const lldb::addr_t func_low_pc);
 
   size_t ParseVariables(const lldb_private::SymbolContext &sc,
                         const DWARFDIE &orig_die,
                         const lldb::addr_t func_low_pc, bool parse_siblings,
                         bool parse_children,
                         lldb_private::VariableList *cc_variable_list = nullptr);
 
   bool ClassOrStructIsVirtual(const DWARFDIE &die);
 
   // Given a die_offset, figure out the symbol context representing that die.
-  bool ResolveFunction(const DWARFDIE &die, bool include_inlines,
+  bool ResolveFunction(DWARFUnit *main_unit, const DWARFDIE &die,
+                       bool include_inlines,
                        lldb_private::SymbolContextList &sc_list);
 
   /// Resolve functions and (possibly) blocks for the given file address and a
   /// compile unit. The compile unit comes from the sc argument and it must be
   /// set. The results of the lookup (if any) are written back to the symbol
   /// context.
   void ResolveFunctionAndBlock(lldb::addr_t file_vm_addr, bool lookup_block,
                                lldb_private::SymbolContext &sc);
 
   virtual lldb::TypeSP
   FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx);
 
   virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, lldb_private::ConstString type_name,
       bool must_be_implementation);
 
   lldb_private::Symbol *
   GetObjCClassSymbol(lldb_private::ConstString objc_class_name);
 
-  lldb::TypeSP GetTypeForDIE(const DWARFDIE &die,
+  lldb::TypeSP GetTypeForDIE(DWARFUnit *main_unit, const DWARFDIE &die,
                              bool resolve_function_context = false);
 
   void SetDebugMapModule(const lldb::ModuleSP &module_sp) {
     m_debug_map_module_wp = module_sp;
   }
 
   SymbolFileDWARFDebugMap *GetDebugMapSymfile();
 
protected:
   /// binary. Returns the adjusted address, or \p file_addr if no adjustment is
   /// needed, on success and LLDB_INVALID_ADDRESS otherwise.
   lldb::addr_t FixupAddress(lldb::addr_t file_addr);
 
   bool FixupAddress(lldb_private::Address &addr);
 
   typedef llvm::SetVector<lldb_private::Type *> TypeSet;
 
-  void GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
-                dw_offset_t max_die_offset, uint32_t type_mask,
-                TypeSet &type_set);
+  void GetTypes(DWARFUnit *main_unit, const DWARFDIE &die,
+                dw_offset_t min_die_offset, dw_offset_t max_die_offset,
+                uint32_t type_mask, TypeSet &type_set);
 
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t,
                                         lldb_private::Variable *>
       GlobalVariableMap;
 
   GlobalVariableMap &GetGlobalAranges();
 
   void UpdateExternalModuleListIfNeeded();
 
   virtual DIEToTypePtr &GetDIEToType() { return m_die_to_type; }
 
   virtual DIEToVariableSP &GetDIEToVariable() { return m_die_to_variable_sp; }
 
   virtual DIEToClangType &GetForwardDeclDieToClangType() {
     return m_forward_decl_die_to_clang_type;
   }
 
   virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() {
     return m_forward_decl_clang_type_to_die;
   }
 
   void BuildCuTranslationTable();
-  llvm::Optional<uint32_t> GetDWARFUnitIndex(uint32_t cu_idx);
 
   struct DecodedUID {
     SymbolFileDWARF &dwarf;
     DIERef ref;
   };
   llvm::Optional<DecodedUID> DecodeUID(lldb::user_id_t uid);
 
   void FindDwpSymbolFile();

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

 }
 
 TypeList &SymbolFileDWARF::GetTypeList() {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeList();
   return SymbolFile::GetTypeList();
 }
-void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
+void SymbolFileDWARF::GetTypes(DWARFUnit *main_unit, const DWARFDIE &die,
+                               dw_offset_t min_die_offset,
                                dw_offset_t max_die_offset, uint32_t type_mask,
                                TypeSet &type_set) {
   if (die) {
     const dw_offset_t die_offset = die.GetOffset();
 
     if (die_offset >= max_die_offset)
       return;
 
if (die_offset >= min_die_offset) {
         add_type = (type_mask & eTypeClassMemberPointer) != 0;
         break;
       default:
         break;
       }
 
       if (add_type) {
         const bool assert_not_being_parsed = true;
-        Type *type = ResolveTypeUID(die, assert_not_being_parsed);
+        Type *type = ResolveTypeUID(main_unit, die, assert_not_being_parsed);
         if (type)
           type_set.insert(type);
       }
     }
 
     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
          child_die = child_die.GetSibling()) {
-      GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
+      GetTypes(main_unit, child_die, min_die_offset, max_die_offset, type_mask,
+               type_set);
     }
   }
 }
 
 void SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
                                TypeClass type_mask, TypeList &type_list)
 
 {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   TypeSet type_set;
 
   CompileUnit *comp_unit = nullptr;
   if (sc_scope)
     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 
   const auto &get = [&](DWARFUnit *unit) {
     if (!unit)
       return;
     unit = &unit->GetNonSkeletonUnit();
-    GetTypes(unit->DIE(), unit->GetOffset(), unit->GetNextUnitOffset(),
+    GetTypes(unit, unit->DIE(), 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)
DWARFDebugInfo &SymbolFileDWARF::DebugInfo() {
   });
   return *m_info;
 }
 
 DWARFCompileUnit *SymbolFileDWARF::GetDWARFCompileUnit(CompileUnit *comp_unit) {
   if (!comp_unit)
     return nullptr;
 
-  // The compile unit ID is the index of the DWARF unit.
-  DWARFUnit *dwarf_cu = DebugInfo().GetUnitAtIndex(comp_unit->GetID());
+  // Compile unit ID is index of the DWARF unit.
+  // GetBaseSymbolFile() is for the case we are called from SymbolFileDWARFDwo.
+  DWARFUnit *dwarf_cu =
+      GetBaseSymbolFile().DebugInfo().GetUnitAtIndex(comp_unit->GetID());
   if (dwarf_cu && dwarf_cu->GetUserData() == nullptr)
     dwarf_cu->SetUserData(comp_unit);
 
   // It must be DWARFCompileUnit when it created a CompileUnit.
   return llvm::cast_or_null<DWARFCompileUnit>(dwarf_cu);
 }
 
 DWARFDebugRanges *SymbolFileDWARF::GetDebugRanges() {
if (dwarf_cu.GetOffset() == 0 && GetDebugMapSymfile()) {
 
           bool is_optimized = dwarf_cu.GetNonSkeletonUnit().GetIsOptimized();
           BuildCuTranslationTable();
           cu_sp = std::make_shared<CompileUnit>(
               module_sp, &dwarf_cu, cu_file_spec,
               *GetDWARFUnitIndex(dwarf_cu.GetID()), cu_language,
               is_optimized ? eLazyBoolYes : eLazyBoolNo);
 
+          lldbassert(cu_sp->GetID() == *GetDWARFUnitIndex(dwarf_cu.GetID()));
           dwarf_cu.SetUserData(cu_sp.get());
 
           SetCompileUnitAtIndex(dwarf_cu.GetID(), cu_sp);
         }
       }
     }
   }
   return cu_sp;

 }
 
 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()));
+  DWARFUnit *main_unit = GetDWARFCompileUnit(&comp_unit);
+
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(GetLanguage(*die.GetMainDWARFUnit(main_unit)));
   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;
size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
 
   size_t functions_added = 0;
   dwarf_cu = &dwarf_cu->GetNonSkeletonUnit();
   for (DWARFDebugInfoEntry &entry : dwarf_cu->dies()) {
     if (entry.Tag() != DW_TAG_subprogram)
       continue;
 
     DWARFDIE die(dwarf_cu, &entry);
-    if (comp_unit.FindFunctionByUID(die.GetID()))
+    if (comp_unit.FindFunctionByUID(die.GetID(dwarf_cu)))
       continue;
     if (ParseFunction(comp_unit, die))
       ++functions_added;
   }
   // FixupTypes();
   return functions_added;
 }
 
case DW_TAG_lexical_block: {
         // inlined functions. These will be parsed on their own as separate
         // entities.
 
         if (depth > 0)
           break;
 
         block = parent_block;
       } else {
-        BlockSP block_sp(new Block(die.GetID()));
+        DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+        BlockSP block_sp(new Block(die.GetID(dwarf_cu)));
         parent_block->AddChild(block_sp);
         block = block_sp.get();
       }
       DWARFRangeList ranges;
       const char *name = nullptr;
       const char *mangled_name = nullptr;
 
       int decl_file = 0;

 
 void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
   auto *type_system = decl_ctx.GetTypeSystem();
   if (type_system != nullptr)
     type_system->GetDWARFParser()->EnsureAllDIEsInDeclContextHaveBeenParsed(
         decl_ctx);
 }
 
-user_id_t SymbolFileDWARF::GetUID(DIERef ref) {
+user_id_t SymbolFileDWARF::GetUID(DWARFUnit *main_unit,
+                                  const DWARFBaseDIE &die) {
+  if (!die.IsValid())
+    return LLDB_INVALID_UID;
+  // if (die.GetCU()->GetUnitDIEOnly().Tag() != DW_TAG_partial_unit)
+  main_unit = nullptr;
+  return GetUID(main_unit, die.GetDIERef(main_unit));
+}
+
+user_id_t SymbolFileDWARF::GetUID(DWARFUnit *main_unit, DIERef ref) {
   if (GetDebugMapSymfile())
     return GetID() | ref.die_offset();
 
-  lldbassert(GetDwoNum().getValueOr(0) <= 0x3fffffff);
-  return user_id_t(GetDwoNum().getValueOr(0)) << 32 | ref.die_offset() |
-         lldb::user_id_t(GetDwoNum().hasValue()) << 62 |
-         lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes) << 63;
+  if (main_unit)
+    main_unit = &main_unit->GetNonSkeletonUnit();
+  if (ref.dwo_num().hasValue())
+    lldbassert(main_unit == nullptr);
+
+#ifndef NDEBUG
+  DWARFDIE dwarfdie_check = GetDIE(ref);
+  lldbassert(dwarfdie_check.IsValid());
+  lldbassert(*dwarfdie_check.GetDIERef(main_unit) == ref);
+#endif
+
+  // WARNING: Use ref.dwo_num() as GetDwoNum() may not be valid in 'this'.
+  static_assert(sizeof(ref.die_offset()) * 8 == 32, "");
+  lldbassert(!ref.dwo_num().hasValue() || *ref.dwo_num() <= 0x3fffffff);
+  user_id_t retval =
+      user_id_t(ref.dwo_num().getValueOr(0)) << 32 | ref.die_offset() |
+      lldb::user_id_t(ref.dwo_num().hasValue()) << 62 |
+
+#ifndef NDEBUG
+  DWARFUnit *main_unit_check;
+  DWARFDIE dwarfdie_check2 = GetDIE(retval, &main_unit_check);
+  lldbassert(dwarfdie_check2 == dwarfdie_check);
+#endif
+
+  return retval;
 }
 
 llvm::Optional<SymbolFileDWARF::DecodedUID>
 SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
   bool dwo_valid = uid >> 62 & 1;
   if (dwo_valid)
     dwo_num = uid >> 32 & 0x3fffffff;
 
   return DecodedUID{*this, {dwo_num, section, die_offset}};
 }
 
 DWARFDIE
-SymbolFileDWARF::GetDIE(lldb::user_id_t uid) {
+SymbolFileDWARF::GetDIE(lldb::user_id_t uid, DWARFUnit **main_unit_return) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
   llvm::Optional<DecodedUID> decoded = DecodeUID(uid);
 
   if (decoded)
-    return decoded->dwarf.GetDIE(decoded->ref);
+    return decoded->dwarf.GetDIE(decoded->ref, main_unit_return);
 
   return DWARFDIE();
 }
 
 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   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 die = GetDIE(type_uid))
-    return GetDecl(die);
+  DWARFUnit *main_unit;
+  if (DWARFDIE die = GetDIE(type_uid, &main_unit))
+    return GetDecl(main_unit, die);
   return CompilerDecl();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   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 die = GetDIE(type_uid))
-    return GetDeclContext(die);
+  DWARFUnit *main_unit;
+  if (DWARFDIE die = GetDIE(type_uid, &main_unit))
+    return GetDeclContext(main_unit, die);
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextContainingUID(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 die = GetDIE(type_uid))
-    return GetContainingDeclContext(die);
+  DWARFUnit *main_unit;
+  if (DWARFDIE die = GetDIE(type_uid, &main_unit))
+    return GetContainingDeclContext(main_unit, die);
   return CompilerDeclContext();
 }
 
 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();
+  DWARFUnit *main_unit;
+  if (DWARFDIE type_die = GetDIE(type_uid, &main_unit))
+    return type_die.ResolveType(main_unit);
   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 (DWARFDIE type_die = GetDIE(type_uid))
     return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx);
   else
     return llvm::None;
 }
 
-Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
-  return ResolveType(GetDIE(die_ref), true);
+Type *SymbolFileDWARF::ResolveTypeUID(DWARFUnit *main_unit,
+                                      const DIERef &die_ref) {
+  return ResolveType(main_unit, GetDIE(die_ref), true);
 }
 
-Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
+Type *SymbolFileDWARF::ResolveTypeUID(DWARFUnit *main_unit, const DWARFDIE &die,
                                       bool assert_not_being_parsed) {
   if (die) {
     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
     if (log)
       GetObjectFile()->GetModule()->LogMessage(
           log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
 
if (decl_ctx_die) {
                 decl_ctx_die.GetOffset());
         } break;
 
         default:
           break;
         }
       }
     }
-    return ResolveType(die);
+    return ResolveType(main_unit, die);
   }
   return nullptr;
 }
 
 // This function is used when SymbolFileDWARFDebugMap owns a bunch of
 // SymbolFileDWARF objects to detect if this DWARF file is the one that can
 // resolve a compiler_type.
 bool SymbolFileDWARF::HasForwardDeclForClangType(
CompilerType compiler_type_no_qualifiers =
       ClangUtil::RemoveFastQualifiers(compiler_type);
   auto die_it = GetForwardDeclClangTypeToDie().find(
       compiler_type_no_qualifiers.GetOpaqueQualType());
   if (die_it == GetForwardDeclClangTypeToDie().end()) {
     // We have already resolved this type...
     return true;
   }
 
-  DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
+  DWARFUnit *main_unit;
+  DWARFDIE dwarf_die = GetDIE(die_it->getSecond(), &main_unit);
   if (dwarf_die) {
     // Once we start resolving this type, remove it from the forward
     // declaration map in case anyone child members or other types require this
     // type to get resolved. The type will get resolved when all of the calls
     // to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition are done.
     GetForwardDeclClangTypeToDie().erase(die_it);
 
-    Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
+    Type *type = GetDIEToType().lookup(dwarf_die.MainUnitToDIEPair(main_unit));
+    lldbassert(type);
 
     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(),
+          dwarf_die.GetID(main_unit), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
     assert(compiler_type);
-    if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetCU()))
-      return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
+    if (DWARFASTParser *dwarf_ast =
+            GetDWARFParser(*dwarf_die.GetMainDWARFUnit(main_unit)))
+      return dwarf_ast->CompleteTypeFromDWARF(main_unit, dwarf_die, type,
+                                              compiler_type);
   }
   return false;
 }
 
-Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
+Type *SymbolFileDWARF::ResolveType(DWARFUnit *main_unit, const DWARFDIE &die,
                                    bool assert_not_being_parsed,
                                    bool resolve_function_context) {
   if (die) {
-    Type *type = GetTypeForDIE(die, resolve_function_context).get();
+    Type *type = GetTypeForDIE(main_unit, die, resolve_function_context).get();
 
     if (assert_not_being_parsed) {
       if (type != DIE_IS_BEING_PARSED)
         return type;
 
       GetObjectFile()->GetModule()->ReportError(
           "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
if (dwarf_cu.GetUserData() == nullptr) {
     // The symbol vendor doesn't know about this compile unit, we need to parse
     // and add it to the symbol vendor object.
     return ParseCompileUnit(dwarf_cu).get();
   }
   return static_cast<CompileUnit *>(dwarf_cu.GetUserData());
 }
 
 void SymbolFileDWARF::GetObjCMethods(
-    ConstString class_name, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    ConstString class_name,
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   m_index->GetObjCMethods(class_name, callback);
 }
 
-bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
+bool SymbolFileDWARF::GetFunction(DWARFUnit *main_unit, const DWARFDIE &die,
+                                  SymbolContext &sc) {
   sc.Clear(false);
+  if (!die)
+    return false;
 
-  if (die && llvm::isa<DWARFCompileUnit>(die.GetCU())) {
-    // Check if the symbol vendor already knows about this compile unit?
-    sc.comp_unit =
-        GetCompUnitForDWARFCompUnit(llvm::cast<DWARFCompileUnit>(*die.GetCU()));
+  DWARFCompileUnit *main_cu =
+      llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
+  if (!main_cu)
+    return false;
+  sc.comp_unit = main_cu->GetCompUnit();
 
-    sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
-    if (sc.function == nullptr)
-      sc.function = ParseFunction(*sc.comp_unit, die);
+  sc.function = sc.comp_unit->FindFunctionByUID(die.GetID(main_unit)).get();
+  if (sc.function == nullptr)
+    return false;
 
-    if (sc.function) {
-      sc.module_sp = sc.function->CalculateSymbolContextModule();
-      return true;
-    }
-  }
-
-  return false;
-}
 
 lldb::ModuleSP SymbolFileDWARF::GetExternalModule(ConstString name) {
   UpdateExternalModuleListIfNeeded();
   const auto &pos = m_external_type_modules.find(name);
   if (pos != m_external_type_modules.end())
     return pos->second;
   else
     return lldb::ModuleSP();
 }
 
 DWARFDIE
-SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
+SymbolFileDWARF::GetDIE(const DIERef &die_ref, DWARFUnit **main_unit_return) {
   if (die_ref.dwo_num()) {
     SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x3fffffff
                                  ? m_dwp_symfile.get()
                                  : this->DebugInfo()
                                        .GetUnitAtIndex(*die_ref.dwo_num())
                                        ->GetDwoSymbolFile();
-    return dwarf->DebugInfo().GetDIE(die_ref);
+    return dwarf->DebugInfo().GetDIE(die_ref, main_unit_return);
   }
 
-  return DebugInfo().GetDIE(die_ref);
+  return DebugInfo().GetDIE(die_ref, main_unit_return);
 }
 
 /// Return the DW_AT_(GNU_)dwo_name.
 static const char *GetDWOName(DWARFCompileUnit &dwarf_cu,
                               const DWARFDebugInfoEntry &cu_die) {
   const char *dwo_name =
       cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
   if (!dwo_name)
if (!m_global_aranges_up) {
     m_global_aranges_up->Sort();
   }
   return *m_global_aranges_up;
 }
 
 void SymbolFileDWARF::ResolveFunctionAndBlock(lldb::addr_t file_vm_addr,
                                               bool lookup_block,
                                               SymbolContext &sc) {
-  assert(sc.comp_unit);
-  DWARFCompileUnit &cu =
-      GetDWARFCompileUnit(sc.comp_unit)->GetNonSkeletonUnit();
-  DWARFDIE function_die = cu.LookupAddress(file_vm_addr);
+  DWARFCompileUnit *cu = GetDWARFCompileUnit(sc.comp_unit);
+  lldbassert(cu);
+  cu = &cu->GetNonSkeletonUnit();
+  DWARFDIE function_die = cu->LookupAddress(file_vm_addr);
   DWARFDIE block_die;
   if (function_die) {
-    sc.function = sc.comp_unit->FindFunctionByUID(function_die.GetID()).get();
+    sc.function = sc.comp_unit->FindFunctionByUID(function_die.GetID(cu)).get();
     if (sc.function == nullptr)
       sc.function = ParseFunction(*sc.comp_unit, function_die);
 
     if (sc.function && lookup_block)
       block_die = function_die.LookupDeepestBlock(file_vm_addr);
   }
 
   if (!sc.function || ! lookup_block)
     return;
 
   Block &block = sc.function->GetBlock(true);
   if (block_die)
-    sc.block = block.FindBlockByID(block_die.GetID());
+    sc.block = block.FindBlockByID(block_die.GetID(cu));
   else
-    sc.block = block.FindBlockByID(function_die.GetID());
+    sc.block = block.FindBlockByID(function_die.GetID(cu));
 }
 
 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
                                                SymbolContextItem resolve_scope,
                                                SymbolContext &sc) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   LLDB_SCOPED_TIMERF("SymbolFileDWARF::"
                      "ResolveSymbolContext (so_addr = { "
if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
                                                       context, basename))
     basename = name.GetStringRef();
 
   // Loop invariant: Variables up to this index have been checked for context
   // matches.
   uint32_t pruned_idx = original_size;
 
   SymbolContext sc;
-  m_index->GetGlobalVariables(ConstString(basename), [&](DWARFDIE die) {
+  m_index->GetGlobalVariables(
+      ConstString(basename), [&](DWARFUnit *main_unit, 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());
-    if (!dwarf_cu)
-      return true;
-    sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
+        DWARFCompileUnit *main_cu =
+            llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
+        if (!main_cu)
+          return false;
+        sc.comp_unit = main_cu->GetCompUnit();
 
         if (parent_decl_ctx) {
-      if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
+          if (DWARFASTParser *dwarf_ast =
+                  GetDWARFParser(*die.GetMainDWARFUnit(main_unit))) {
             CompilerDeclContext actual_parent_decl_ctx =
-            dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
+                dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die);
             if (!actual_parent_decl_ctx ||
                 actual_parent_decl_ctx != parent_decl_ctx)
               return true;
           }
         }
 
         ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
         while (pruned_idx < variables.GetSize()) {
           VariableSP var_sp = variables.GetVariableAtIndex(pruned_idx);
           if (name_is_mangled ||
               var_sp->GetName().GetStringRef().contains(name.GetStringRef()))
             ++pruned_idx;
           else
             variables.RemoveVariableAtIndex(pruned_idx);
         }
 
         return variables.GetSize() - original_size < max_matches;
       });
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = variables.GetSize() - original_size;
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
         "parent_decl_ctx=%p, max_matches=%u, variables) => %u",
GetObjectFile()->GetModule()->LogMessage(
         "max_matches=%u, variables)",
         regex.GetText().str().c_str(), max_matches);
   }
 
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
   SymbolContext sc;
-  m_index->GetGlobalVariables(regex, [&](DWARFDIE die) {
+  m_index->GetGlobalVariables(regex, [&](DWARFUnit *main_unit, 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());
-    if (!dwarf_cu)
-      return true;
-    sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
+    DWARFCompileUnit *main_cu =
+        llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
+    if (!main_cu)
+      return false;
+    sc.comp_unit = main_cu->GetCompUnit();
 
     ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
     return variables.GetSize() - original_size < max_matches;
   });
 }
 
-bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
+bool SymbolFileDWARF::ResolveFunction(DWARFUnit *main_unit,
+                                      const DWARFDIE &orig_die,
                                       bool include_inlines,
                                       SymbolContextList &sc_list) {
   SymbolContext sc;
 
   if (!orig_die)
     return false;
 
   // If we were passed a die that is not a function, just return false...
while (true) {
       if (die) {
         if (die.Tag() == DW_TAG_subprogram)
           break;
       } else
         break;
     }
   }
   assert(die && die.Tag() == DW_TAG_subprogram);
-  if (GetFunction(die, sc)) {
+  if (GetFunction(main_unit, die, sc)) {
     Address addr;
     // Parse all blocks if needed
     if (inlined_die) {
       Block &function_block = sc.function->GetBlock(true);
-      sc.block = function_block.FindBlockByID(inlined_die.GetID());
+      sc.block = function_block.FindBlockByID(inlined_die.GetID(main_unit));
       if (sc.block == nullptr)
         sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
       if (sc.block == nullptr || !sc.block->GetStartAddress(addr))
         addr.Clear();
     } else {
       sc.block = nullptr;
       addr = sc.function->GetAddressRange().GetBaseAddress();
     }
 
 
     if (auto section_sp = addr.GetSection()) {
       if (section_sp->GetPermissions() & ePermissionsExecutable) {
         sc_list.Append(sc);
         return true;
       }
     }
   }
 
   return false;
 }
 
 bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext &decl_ctx,
+                                       DWARFUnit *main_unit,
                                        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.GetMainDWARFUnit(main_unit))) {
       if (CompilerDeclContext actual_decl_ctx =
-              dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
+              dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die))
         return decl_ctx.IsContainedInLookup(actual_decl_ctx);
     }
   }
   return false;
 }
 
 void SymbolFileDWARF::FindFunctions(ConstString name,
                                     const CompilerDeclContext &parent_decl_ctx,
void SymbolFileDWARF::FindFunctions(ConstString name,
   if (name.IsEmpty())
     return;
 
   // Remember how many sc_list are in the list before we search in case we are
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
-  llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
+  llvm::DenseSet<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>>
+      resolved_dies;
 
-  m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask,
-                        [&](DWARFDIE die) {
-                          if (resolved_dies.insert(die.GetDIE()).second)
-                            ResolveFunction(die, include_inlines, sc_list);
-                          return true;
-                        });
+  m_index->GetFunctions(
+      name, *this, parent_decl_ctx, name_type_mask,
+      [&](DWARFUnit *main_unit, DWARFDIE die) {
+        if (resolved_dies.insert(std::make_pair(main_unit, die.GetDIE()))
+                .second)
+          ResolveFunction(main_unit, die, include_inlines, sc_list);
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = sc_list.GetSize() - original_size;
 
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindFunctions (name=\"%s\", "
void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
         regex.GetText().str().c_str());
   }
 
-  llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
-  m_index->GetFunctions(regex, [&](DWARFDIE die) {
-    if (resolved_dies.insert(die.GetDIE()).second)
-      ResolveFunction(die, include_inlines, sc_list);
+  llvm::DenseSet<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>>
+      resolved_dies;
+  m_index->GetFunctions(regex, [&](DWARFUnit *main_unit, DWARFDIE die) {
+    if (resolved_dies.insert(std::make_pair(main_unit, die.GetDIE())).second)
+      ResolveFunction(main_unit, die, include_inlines, sc_list);
     return true;
   });
 }
 
 void SymbolFileDWARF::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
   DWARFDebugInfo &info = DebugInfo();
else
           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
           "NULL, max_matches=%u, type_list)",
           name.GetCString(), max_matches);
   }
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
 
-  m_index->GetTypes(name, [&](DWARFDIE die) {
-    if (!DIEInDeclContext(parent_decl_ctx, die))
+  m_index->GetTypes(name, [&](DWARFUnit *main_unit, DWARFDIE die) {
+    if (!DIEInDeclContext(parent_decl_ctx, main_unit, die))
       return true; // The containing decl contexts don't match
 
-    Type *matching_type = ResolveType(die, true, true);
+    Type *matching_type = ResolveType(main_unit, die, true, true);
     if (!matching_type)
       return true;
 
     // We found a type pointer, now find the shared pointer form our type
     // list
     types.InsertUnique(matching_type->shared_from_this());
     return types.GetSize() < max_matches;
   });
void SymbolFileDWARF::FindTypes(
   if (pattern.empty())
     return;
 
   ConstString name = pattern.back().name;
 
   if (!name)
     return;
 
-  m_index->GetTypes(name, [&](DWARFDIE die) {
-    if (!languages[GetLanguage(*die.GetCU())])
+  m_index->GetTypes(name, [&](DWARFUnit *main_unit, DWARFDIE die) {
+    if (!languages[GetLanguage(*die.GetMainDWARFUnit(main_unit))])
       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)) {
+    if (Type *matching_type = ResolveType(main_unit, die, true, true)) {
       // We found a type pointer, now find the shared pointer form our type
       // list.
       types.InsertUnique(matching_type->shared_from_this());
     }
     return true;
   });
 
   // Next search through the reachable Clang modules. This only applies for
GetObjectFile()->GetModule()->LogMessage(
         name.GetCString());
   }
 
   CompilerDeclContext namespace_decl_ctx;
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
-  m_index->GetNamespaces(name, [&](DWARFDIE die) {
-    if (!DIEInDeclContext(parent_decl_ctx, die))
+  m_index->GetNamespaces(name, [&](DWARFUnit *main_unit, DWARFDIE die) {
+    if (!DIEInDeclContext(parent_decl_ctx, main_unit, die))
       return true; // The containing decl contexts don't match
 
-    DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+    DWARFASTParser *dwarf_ast =
+        GetDWARFParser(*die.GetMainDWARFUnit(main_unit));
     if (!dwarf_ast)
       return true;
 
-    namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
+    namespace_decl_ctx =
+        dwarf_ast->GetDeclContextForUIDFromDWARF(main_unit, die);
     return !namespace_decl_ctx.IsValid();
   });
 
   if (log && namespace_decl_ctx) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
         "CompilerDeclContext(%p/%p) \"%s\"",
         name.GetCString(),
         static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
         static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
         namespace_decl_ctx.GetName().AsCString("<NULL>"));
   }
 
   return namespace_decl_ctx;
 }
 
-TypeSP SymbolFileDWARF::GetTypeForDIE(const DWARFDIE &die,
+TypeSP SymbolFileDWARF::GetTypeForDIE(DWARFUnit *main_unit, const DWARFDIE &die,
                                       bool resolve_function_context) {
   TypeSP type_sp;
   if (die) {
-    Type *type_ptr = GetDIEToType().lookup(die.GetDIE());
+    Type *type_ptr = GetDIEToType().lookup(die.MainUnitToDIEPair(main_unit));
     if (type_ptr == nullptr) {
       SymbolContextScope *scope;
-      if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()))
-        scope = GetCompUnitForDWARFCompUnit(*dwarf_cu);
+      DWARFCompileUnit *main_cu =
+          llvm::dyn_cast_or_null<DWARFCompileUnit>(main_unit);
+      if (main_cu)
+        scope = main_cu->GetCompUnit();
       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)
           break;
         parent_die = parent_die->GetParent();
       }
       SymbolContext sc_backup = sc;
       if (resolve_function_context && parent_die != nullptr &&
-          !GetFunction(DWARFDIE(die.GetCU(), parent_die), sc))
+          !GetFunction(main_unit, DWARFDIE(die.GetCU(), parent_die), sc))
         sc = sc_backup;
 
       type_sp = ParseType(sc, die, nullptr);
     } else if (type_ptr != DIE_IS_BEING_PARSED) {
       // Grab the existing type from the master types lists
       type_sp = type_ptr->shared_from_this();
     }
   }
TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
     const DWARFDIE &die, ConstString type_name, bool must_be_implementation) {
 
   TypeSP type_sp;
 
   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
     return type_sp;
 
   m_index->GetCompleteObjCClass(
-      type_name, must_be_implementation, [&](DWARFDIE type_die) {
+      type_name, must_be_implementation,
+      [&](DWARFUnit *main_unit, DWARFDIE type_die) {
         bool try_resolving_type = false;
 
         // Don't try and resolve the DIE we are looking for with the DIE
         // itself!
         if (type_die != die) {
           switch (type_die.Tag()) {
           case DW_TAG_class_type:
           case DW_TAG_structure_type:
             try_resolving_type = true;
             break;
           default:
             break;
           }
         }
         if (!try_resolving_type)
           return true;
 
         if (must_be_implementation &&
             type_die.Supports_DW_AT_APPLE_objc_complete_type())
           try_resolving_type = type_die.GetAttributeValueAsUnsigned(
               DW_AT_APPLE_objc_complete_type, 0);
         if (!try_resolving_type)
           return true;
 
-        Type *resolved_type = ResolveType(type_die, false, true);
+        Type *resolved_type = ResolveType(main_unit, type_die, false, true);
         if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
           return true;
 
         DEBUG_PRINTF(
             "resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
             " (cu 0x%8.8" PRIx64 ")\n",
             die.GetID(),
             m_objfile_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"),
             type_die.GetID(), type_cu->GetID());
 
         if (die)
-          GetDIEToType()[die.GetDIE()] = resolved_type;
+          GetDIEToType()[die.MainUnitToDIEPair(main_unit)] = resolved_type;
         type_sp = resolved_type->shared_from_this();
         return false;
       });
   return type_sp;
 }
 
 // This function helps to ensure that the declaration contexts match for two
 // different DIEs. Often times debug information will refer to a forward
if (type_name) {
               lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
               std::move(err), "Cannot get TypeSystem for language {}",
               Language::GetNameForLanguageType(language));
         } else {
           type_system = &type_system_or_err.get();
         }
       }
 
-      m_index->GetTypes(dwarf_decl_ctx, [&](DWARFDIE type_die) {
+      m_index->GetTypes(dwarf_decl_ctx, [&](DWARFUnit *main_unit,
+                                            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())))
+        if (type_system && !type_system->SupportsLanguage(GetLanguage(
+                               *type_die.GetMainDWARFUnit(main_unit))))
           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) {
if (type_name) {
                 "qualified-name='%s') ignoring die=0x%8.8x (%s)",
                 DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
                 dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
                 qualified_name.c_str());
           }
           return true;
         }
 
-        DWARFDeclContext type_dwarf_decl_ctx = GetDWARFDeclContext(type_die);
+        DWARFDeclContext type_dwarf_decl_ctx =
+            GetDWARFDeclContext(main_unit, type_die);
 
         if (log) {
           GetObjectFile()->GetModule()->LogMessage(
               log,
               "SymbolFileDWARF::"
               "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
               "qualified-name='%s') trying die=0x%8.8x (%s)",
               DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
               dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
               type_dwarf_decl_ctx.GetQualifiedName());
         }
 
         // Make sure the decl contexts match all the way up
         if (dwarf_decl_ctx != type_dwarf_decl_ctx)
           return true;
 
-        Type *resolved_type = ResolveType(type_die, false);
+        Type *resolved_type = ResolveType(main_unit, type_die, false);
         if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
           return true;
 
         type_sp = resolved_type->shared_from_this();
         return false;
       });
     }
   }
   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()));
+  DWARFUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(GetLanguage(*die.GetMainDWARFUnit(main_unit)));
   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)
     return {};
 
   TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, type_is_new_ptr);
   if (type_sp) {
     GetTypeList().Insert(type_sp);
 
     if (die.Tag() == DW_TAG_subprogram) {
-      std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
-                                           .GetScopeQualifiedName()
-                                           .AsCString(""));
+      std::string scope_qualified_name(
+          GetDeclContextForUID(die.GetID(main_unit))
       if (scope_qualified_name.size()) {
         m_function_scope_qualified_name_map[scope_qualified_name].insert(
-            *die.GetDIERef());
+            *die.GetDIERef(main_unit));
       }
     }
   }
 
   return type_sp;
 }
 
 size_t SymbolFileDWARF::ParseTypes(const SymbolContext &sc,
while (die) {
     if (isType(dwarf_tag) && tag != DW_TAG_subrange_type)
       ParseType(sc, die, &type_is_new);
 
     if (type_is_new)
       ++types_added;
 
     if (parse_children && die.HasChildren()) {
       if (die.Tag() == DW_TAG_subprogram) {
+        DWARFUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
         SymbolContext child_sc(sc);
-        child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
+        child_sc.function =
+            sc.comp_unit->FindFunctionByUID(die.GetID(main_unit)).get();
         types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
       } else
         types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
     }
 
     if (parse_siblings)
       die = die.GetSibling();
     else
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);
   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;
+      sc.module_sp = sc.comp_unit->GetModule();
       types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
     }
   }
 
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
if (sc.function) {
         const size_t num_variables = ParseVariables(
             sc, function_die.GetFirstChild(), func_lo_pc, true, true);
 
         // Let all blocks know they have parse all their variables
         sc.function->GetBlock(false).SetDidParseVariables(true, true);
         return num_variables;
       }
     } else if (sc.comp_unit) {
-      DWARFUnit *dwarf_cu = DebugInfo().GetUnitAtIndex(sc.comp_unit->GetID());
-
-      if (dwarf_cu == nullptr)
+      DWARFUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
+      if (!main_unit)
         return 0;
+      main_unit = &main_unit->GetNonSkeletonUnit();
 
       uint32_t vars_added = 0;
       VariableListSP variables(sc.comp_unit->GetVariableList(false));
 
       if (variables.get() == nullptr) {
         variables = std::make_shared<VariableList>();
         sc.comp_unit->SetVariableList(variables);
 
         m_index->GetGlobalVariables(
-            dwarf_cu->GetNonSkeletonUnit(), [&](DWARFDIE die) {
+            *main_unit, [&](DWARFUnit *main_unit_check, DWARFDIE die) {
+              lldbassert(main_unit_check == main_unit ||
+                         main_unit_check == nullptr);
               VariableSP var_sp(
                   ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
               if (var_sp) {
                 variables->AddVariableIfUnique(var_sp);
                 ++vars_added;
               }
               return true;
             });
       }
       return vars_added;
     }
   }
   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)
     return nullptr;
 
-  if (VariableSP var_sp = GetDIEToVariable()[die.GetDIE()])
+  DWARFUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
+
+  if (VariableSP var_sp = GetDIEToVariable()[die.MainUnitToDIEPair(main_unit)])
     return var_sp; // Already been parsed!
 
   const dw_tag_t tag = die.Tag();
   ModuleSP module = GetObjectFile()->GetModule();
 
   if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
       (tag != DW_TAG_formal_parameter || !sc.function))
     return nullptr;
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())))
-      mangled =
-          GetDWARFDeclContext(die).GetQualifiedNameAsConstString().GetCString();
+        Language::LanguageIsCPlusPlus(
+            GetLanguage(*die.GetMainDWARFUnit(main_unit))))
+      mangled = GetDWARFDeclContext(main_unit, 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
     // or static variable, so we have to do a little digging:
     // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
   }
 
   if (symbol_context_scope == nullptr) {
     switch (parent_tag) {
     case DW_TAG_subprogram:
     case DW_TAG_inlined_subroutine:
     case DW_TAG_lexical_block:
       if (sc.function) {
-        symbol_context_scope =
-            sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
+        symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(
+            sc_parent_die.GetID(main_unit));
         if (symbol_context_scope == nullptr)
           symbol_context_scope = sc.function;
       }
       break;
 
     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(main_unit, type_die_form.Reference()));
 
     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>(
-        die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,
-        scope_ranges, &decl, location, is_external, is_artificial,
-        location_is_const_value_data, is_static_member);
+        die.GetID(main_unit), name, mangled, type_sp, scope,
+        symbol_context_scope, scope_ranges, &decl, location, is_external,
+        is_artificial, location_is_const_value_data, is_static_member);
   } else {
     // Not ready to parse this variable yet. It might be a global or static
     // variable that is in a function scope and the function in the symbol
     // context wasn't filled in yet
     return var_sp;
   }
   // Cache var_sp even if NULL (the variable was just a specification or was
   // missing vital information to be able to be displayed in the debugger
   // (missing location due to optimization, etc)) so we don't re-parse this
   // DIE over and over later...
-  GetDIEToVariable()[die.GetDIE()] = var_sp;
+  GetDIEToVariable()[die.MainUnitToDIEPair(main_unit)] = var_sp;
   if (spec_die)
-    GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
+    GetDIEToVariable()[spec_die.MainUnitToDIEPair(main_unit)] = var_sp;
 
   return var_sp;
 }
 
 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification(
     const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
   // Give the concrete function die specified by "func_die_offset", find the
size_t SymbolFileDWARF::ParseVariables(const SymbolContext &sc,
                                        const DWARFDIE &orig_die,
                                        const lldb::addr_t func_low_pc,
                                        bool parse_siblings, bool parse_children,
                                        VariableList *cc_variable_list) {
   if (!orig_die)
     return 0;
 
   VariableListSP variable_list_sp;
+  DWARFUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
 
   size_t vars_added = 0;
   DWARFDIE die = orig_die;
   while (die) {
     dw_tag_t tag = die.Tag();
 
     // Check to see if we have already parsed this variable or constant?
-    VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
+    VariableSP var_sp = GetDIEToVariable()[die.MainUnitToDIEPair(main_unit)];
     if (var_sp) {
       if (cc_variable_list)
         cc_variable_list->AddVariableIfUnique(var_sp);
     } else {
       // We haven't already parsed it, lets do that now.
       if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
           (tag == DW_TAG_formal_parameter && sc.function)) {
         if (variable_list_sp.get() == nullptr) {
           DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
           dw_tag_t parent_tag = sc_parent_die.Tag();
           switch (parent_tag) {
           case DW_TAG_compile_unit:
           case DW_TAG_partial_unit:
             if (sc.comp_unit != nullptr) {
               variable_list_sp = sc.comp_unit->GetVariableList(false);
               if (variable_list_sp.get() == nullptr) {
                 variable_list_sp = std::make_shared<VariableList>();
               }
             } else {
               GetObjectFile()->GetModule()->ReportError(
                   "parent 0x%8.8" PRIx64 " %s with no valid compile unit in "
                   "symbol context for 0x%8.8" PRIx64 " %s.\n",
-                  sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(),
-                  orig_die.GetID(), orig_die.GetTagAsCString());
+                  sc_parent_die.GetID(main_unit),
+                  sc_parent_die.GetTagAsCString(), orig_die.GetID(main_unit),
+                  orig_die.GetTagAsCString());
             }
             break;
 
           case DW_TAG_subprogram:
           case DW_TAG_inlined_subroutine:
           case DW_TAG_lexical_block:
             if (sc.function != nullptr) {
               // Check to see if we already have parsed the variables for the
               // given scope
 
               Block *block = sc.function->GetBlock(true).FindBlockByID(
-                  sc_parent_die.GetID());
+                  sc_parent_die.GetID(main_unit));
               if (block == nullptr) {
                 // This must be a specification or abstract origin with a
                 // concrete block counterpart in the current function. We need
                 // to find the concrete block so we can correctly add the
                 // variable to it
                 const DWARFDIE concrete_block_die =
                     FindBlockContainingSpecification(
                         GetDIE(sc.function->GetID()),
                         sc_parent_die.GetOffset());
                 if (concrete_block_die)
                   block = sc.function->GetBlock(true).FindBlockByID(
-                      concrete_block_die.GetID());
+                      concrete_block_die.GetID(main_unit));
               }
 
               if (block != nullptr) {
                 const bool can_create = false;
                 variable_list_sp = block->GetBlockVariableList(can_create);
                 if (variable_list_sp.get() == nullptr) {
                   variable_list_sp = std::make_shared<VariableList>();
                   block->SetVariableList(variable_list_sp);
                 }
               }
             }
             break;
 
           default:
             GetObjectFile()->GetModule()->ReportError(
                 "didn't find appropriate parent DIE for variable list for "
                 "0x%8.8" PRIx64 " %s.\n",
-                orig_die.GetID(), orig_die.GetTagAsCString());
+                orig_die.GetID(main_unit), orig_die.GetTagAsCString());
             break;
           }
         }
 
         if (variable_list_sp) {
           VariableSP var_sp(ParseVariableDIE(sc, die, func_low_pc));
           if (var_sp) {
             variable_list_sp->AddVariableIfUnique(var_sp);
DWARFASTParser *SymbolFileDWARF::GetDWARFParser(DWARFUnit &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()))
-    return dwarf_ast->GetDeclForUIDFromDWARF(die);
+CompilerDecl SymbolFileDWARF::GetDecl(DWARFUnit *main_unit,
+                                      const DWARFDIE &die) {
+  if (DWARFASTParser *dwarf_ast =
+          GetDWARFParser(*die.GetMainDWARFUnit(main_unit)))
+    return dwarf_ast->GetDeclForUIDFromDWARF(main_unit, die);
   return CompilerDecl();
 }
 
-CompilerDeclContext SymbolFileDWARF::GetDeclContext(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
-    return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
+CompilerDeclContext SymbolFileDWARF::GetDeclContext(DWARFUnit *main_unit,
+                                                    const DWARFDIE &die) {
+  if (DWARFASTParser *dwarf_ast =
+          GetDWARFParser(*die.GetMainDWARFUnit(main_unit)))
+    return dwarf_ast->GetDeclContextForUIDFromDWARF(main_unit, die);
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
-SymbolFileDWARF::GetContainingDeclContext(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
-    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
+SymbolFileDWARF::GetContainingDeclContext(DWARFUnit *main_unit,
+                                          const DWARFDIE &die) {
+  if (DWARFASTParser *dwarf_ast =
+          GetDWARFParser(*die.GetMainDWARFUnit(main_unit)))
+    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die);
   return CompilerDeclContext();
 }
 
-DWARFDeclContext SymbolFileDWARF::GetDWARFDeclContext(const DWARFDIE &die) {
+DWARFDeclContext SymbolFileDWARF::GetDWARFDeclContext(DWARFUnit *main_unit,
+                                                      const DWARFDIE &die) {
   if (!die.IsValid())
     return {};
-  DWARFDeclContext dwarf_decl_ctx =
-      die.GetDIE()->GetDWARFDeclContext(die.GetCU());
-  dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetCU()));
+  DWARFDeclContext dwarf_decl_ctx = die.GetDIE()->GetDWARFDeclContext(
+      die.GetCU()); // DIE.GetCU(), not main_unit.
+  dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetMainDWARFUnit(main_unit)));
   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/DWARF/SymbolFileDWARFDwo.h

public:
 
   SymbolFileDWARFDwo(SymbolFileDWARF &m_base_symbol_file,
                      lldb::ObjectFileSP objfile, uint32_t id);
 
   ~SymbolFileDWARFDwo() override = default;
 
   DWARFCompileUnit *GetDWOCompileUnitForHash(uint64_t hash);
 
-  void GetObjCMethods(lldb_private::ConstString class_name,
-                      llvm::function_ref<bool(DWARFDIE die)> callback) override;
+  void
+  GetObjCMethods(lldb_private::ConstString class_name,
+                 llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)>
+                     callback) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE
-  GetDIE(const DIERef &die_ref) override;
+  GetDIE(const DIERef &die_ref,
+         DWARFUnit **main_unit_return = nullptr) override;
 
   llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
 
+  SymbolFileDWARF &GetBaseSymbolFile() override { return m_base_symbol_file; }
+
 protected:
   DIEToTypePtr &GetDIEToType() override;
 
   DIEToVariableSP &GetDIEToVariable() override;
 
   DIEToClangType &GetForwardDeclDieToClangType() override;
 
   ClangTypeToDIE &GetForwardDeclClangTypeToDie() override;
 
   UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() override;
 
   lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(
       const DWARFDeclContext &die_decl_ctx) override;
 
   lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, lldb_private::ConstString type_name,
       bool must_be_implementation) override;
 
-  SymbolFileDWARF &GetBaseSymbolFile() { return m_base_symbol_file; }
-
   /// If this file contains exactly one compile unit, this function will return
   /// it. Otherwise it returns nullptr.
   DWARFCompileUnit *FindSingleCompileUnit();
 
   SymbolFileDWARF &m_base_symbol_file;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDWO_H

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

 
 SymbolFileDWARF::ClangTypeToDIE &
 SymbolFileDWARFDwo::GetForwardDeclClangTypeToDie() {
   return GetBaseSymbolFile().GetForwardDeclClangTypeToDie();
 }
 
 void SymbolFileDWARFDwo::GetObjCMethods(
     lldb_private::ConstString class_name,
-    llvm::function_ref<bool(DWARFDIE die)> callback) {
+    llvm::function_ref<bool(DWARFUnit *main_unit, DWARFDIE die)> callback) {
   GetBaseSymbolFile().GetObjCMethods(class_name, callback);
 }
 
 UniqueDWARFASTTypeMap &SymbolFileDWARFDwo::GetUniqueDWARFASTTypeMap() {
   return GetBaseSymbolFile().GetUniqueDWARFASTTypeMap();
 }
 
 lldb::TypeSP SymbolFileDWARFDwo::FindDefinitionTypeForDWARFDeclContext(

 }
 
 llvm::Expected<TypeSystem &>
 SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
   return GetBaseSymbolFile().GetTypeSystemForLanguage(language);
 }
 
 DWARFDIE
-SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
+SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref,
+                           DWARFUnit **main_unit_return) {
   if (die_ref.dwo_num() == GetDwoNum())
-    return DebugInfo().GetDIE(die_ref);
-  return GetBaseSymbolFile().GetDIE(die_ref);
+    return DebugInfo().GetDIE(die_ref, main_unit_return);
+  return GetBaseSymbolFile().GetDIE(die_ref, main_unit_return);
 }

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

 
 #include "DWARFDIE.h"
 #include "lldb/Symbol/Declaration.h"
 
 class UniqueDWARFASTType {
 public:
   // Constructors and Destructors
   UniqueDWARFASTType()
-      : m_type_sp(), m_die(), m_declaration(),
+      : m_type_sp(), m_main_unit(nullptr), m_die(), m_declaration(),
         m_byte_size(
             -1) // Set to negative value to make sure we have a valid value
   {}
 
-  UniqueDWARFASTType(lldb::TypeSP &type_sp, const DWARFDIE &die,
-                     const lldb_private::Declaration &decl, int32_t byte_size)
-      : m_type_sp(type_sp), m_die(die), m_declaration(decl),
-        m_byte_size(byte_size) {}
+  UniqueDWARFASTType(lldb::TypeSP &type_sp, DWARFUnit *main_unit,
+                     const DWARFDIE &die, const lldb_private::Declaration &decl,
+                     int32_t byte_size)
+      : m_type_sp(type_sp), m_main_unit(main_unit), m_die(die),
+        m_declaration(decl), m_byte_size(byte_size) {}
 
   UniqueDWARFASTType(const UniqueDWARFASTType &rhs)
-      : m_type_sp(rhs.m_type_sp), m_die(rhs.m_die),
-        m_declaration(rhs.m_declaration), m_byte_size(rhs.m_byte_size) {}
+      : m_type_sp(rhs.m_type_sp), m_main_unit(rhs.m_main_unit),
+        m_die(rhs.m_die), m_declaration(rhs.m_declaration),
+        m_byte_size(rhs.m_byte_size) {}
 
   ~UniqueDWARFASTType() {}
 
   UniqueDWARFASTType &operator=(const UniqueDWARFASTType &rhs) {
     if (this != &rhs) {
       m_type_sp = rhs.m_type_sp;
+      m_main_unit = rhs.m_main_unit;
       m_die = rhs.m_die;
       m_declaration = rhs.m_declaration;
       m_byte_size = rhs.m_byte_size;
     }
     return *this;
   }
 
   lldb::TypeSP m_type_sp;
+  DWARFUnit *m_main_unit;
   DWARFDIE m_die;
   lldb_private::Declaration m_declaration;
   int32_t m_byte_size;
 };
 
 class UniqueDWARFASTTypeList {
 public:
   UniqueDWARFASTTypeList() : m_collection() {}
 
   ~UniqueDWARFASTTypeList() {}
 
   uint32_t GetSize() { return (uint32_t)m_collection.size(); }
 
   void Append(const UniqueDWARFASTType &entry) {
     m_collection.push_back(entry);
   }
 
-  bool Find(const DWARFDIE &die, const lldb_private::Declaration &decl,
-            const int32_t byte_size, UniqueDWARFASTType &entry) const;
+  bool Find(DWARFUnit *main_unit, const DWARFDIE &die,
+            const lldb_private::Declaration &decl, const int32_t byte_size,
+            UniqueDWARFASTType &entry) const;
 
 protected:
   typedef std::vector<UniqueDWARFASTType> collection;
   collection m_collection;
 };
 
 class UniqueDWARFASTTypeMap {
 public:
   UniqueDWARFASTTypeMap() : m_collection() {}
 
   ~UniqueDWARFASTTypeMap() {}
 
   void Insert(lldb_private::ConstString name,
               const UniqueDWARFASTType &entry) {
     m_collection[name.GetCString()].Append(entry);
   }
 
-  bool Find(lldb_private::ConstString name, const DWARFDIE &die,
-            const lldb_private::Declaration &decl, const int32_t byte_size,
-            UniqueDWARFASTType &entry) const {
+  bool Find(lldb_private::ConstString name, DWARFUnit *main_unit,
+            const DWARFDIE &die, const lldb_private::Declaration &decl,
+            const int32_t byte_size, UniqueDWARFASTType &entry) const {
     const char *unique_name_cstr = name.GetCString();
     collection::const_iterator pos = m_collection.find(unique_name_cstr);
     if (pos != m_collection.end()) {
-      return pos->second.Find(die, decl, byte_size, entry);
+      return pos->second.Find(main_unit, die, decl, byte_size, entry);
     }
     return false;
   }
 
 protected:
   // A unique name string should be used
   typedef llvm::DenseMap<const char *, UniqueDWARFASTTypeList> collection;
   collection m_collection;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_UNIQUEDWARFASTTYPE_H

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

 //===-- UniqueDWARFASTType.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 "UniqueDWARFASTType.h"
 
 #include "lldb/Symbol/Declaration.h"
 
-bool UniqueDWARFASTTypeList::Find(const DWARFDIE &die,
+bool UniqueDWARFASTTypeList::Find(DWARFUnit *main_unit, const DWARFDIE &die,
                                   const lldb_private::Declaration &decl,
                                   const int32_t byte_size,
                                   UniqueDWARFASTType &entry) const {
   for (const UniqueDWARFASTType &udt : m_collection) {
     // Make sure the tags match
-    if (udt.m_die.Tag() == die.Tag()) {
+    if (udt.m_die.Tag() == die.Tag() && udt.m_main_unit == main_unit) {
       // Validate byte sizes of both types only if both are valid.
       if (udt.m_byte_size < 0 || byte_size < 0 ||
           udt.m_byte_size == byte_size) {
         // Make sure the file and line match
         if (udt.m_declaration == decl) {
           // The type has the same name, and was defined on the same file and
           // line. Now verify all of the parent DIEs match.
           DWARFDIE parent_arg_die = die.GetParent();

lldb/source/Symbol/Variable.cpp

 //===-- Variable.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 "lldb/Symbol/Variable.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"

 CompilerDeclContext Variable::GetDeclContext() {
   Type *type = GetType();
   if (type)
     return type->GetSymbolFile()->GetDeclContextContainingUID(GetID());
   return CompilerDeclContext();
 }
 
 CompilerDecl Variable::GetDecl() {
-  Type *type = GetType();
-  return type ? type->GetSymbolFile()->GetDeclForUID(GetID()) : CompilerDecl();
+  if (!m_symfile_type_sp)
+    return {};
+  // GetType()->GetSymbolFile() may be a different file - the file where type
+  // of this variable is defined but not the file of this variable definition.
+  return m_symfile_type_sp->GetSymbolFile().GetDeclForUID(GetID());
 }
 
 void Variable::CalculateSymbolContext(SymbolContext *sc) {
   if (m_owner_scope) {
     m_owner_scope->CalculateSymbolContext(sc);
     sc->variable = this;
   } else
     sc->Clear(false);

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 //===-- DWARFASTParserClangTests.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/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "TestingSupport/Symbol/YAMLModuleTester.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;

 )";
 
   YAMLModuleTester t(yamldata);
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
   DWARFASTParserClangStub ast_parser(ast_ctx);
 
-  DWARFUnit *unit = t.GetDwarfUnit();
+  DWARFCompileUnit *unit = llvm::cast<DWARFCompileUnit>(t.GetDwarfUnit());
   const DWARFDebugInfoEntry *die_first = unit->DIE().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 = {
       (clang::DeclContext *)1LL, (clang::DeclContext *)2LL,
       (clang::DeclContext *)2LL, (clang::DeclContext *)3LL};
   for (int i = 0; i < 4; ++i)
-    ast_parser.LinkDeclContextToDIE(decl_ctxs[i], dies[i]);
+    ast_parser.LinkDeclContextToDIE(decl_ctxs[i], unit, dies[i]);
   ast_parser.EnsureAllDIEsInDeclContextHaveBeenParsed(
       CompilerDeclContext(nullptr, decl_ctxs[1]));
 
   EXPECT_THAT(ast_parser.GetDeclContextToDIEMapKeys(),
               testing::UnorderedElementsAre(decl_ctxs[0], decl_ctxs[3]));
 }