RFC 3/3: Remove DWARFDIE dependency from functions moved by D70646

[jankratochvil]

Summary

This patchset is removing dependency on DWARFDIE's DWARFUnit *m_cu for stuff which is unavailable in DW_TAG_partial_unit without accessing its parent DW_TAG_compile_unit (which includes DW_TAG_partial_unit by DW_AT_import).
This patch has no regressions but to really make it usable for DWZ one still needs to adjust DWARFBaseDIE::GetDIERef() as one cannot generate DIERef (containing main unit idenitifier for DWZ) purely from DWARFDIE (not containing DWARFUnit *main_cu).
Refactored DWARFBaseDIE::GetDIERef() (adding some parameter) would then need adjustment also of functions calling it directly - DWARFBaseDIE::GetID() and SymbolFileDWARF::GetUID(const DWARFBaseDIE &die) (and many functions calling these).
I do not plan to check it in yet. I plan to finish it for use by DWZ patchset first (D40474 et al.). Asking whether this is a good way forward.

[labath]

lldb/include/lldb/Symbol/TypeSystem.h

108–110

This part looks pretty dodgy. I'd like to avoid introducing plugin references in non-plugin code. It looks like this class isn't particularly clean already (DWARFDIE forward decl), but this seems to make the problem much worse.

Since this class already contains a SymbolFile pointer, maybe we could create some kind of a ast-parser constructing method on the SymbolFile class to avoid mentioning the SymbolFileDWARF directly.

If I was doing this, I'd probably try to take this one step further and merge the GetDWARFParser/GetPDBParser methods (whose only calls are in the relevant symbol file plugins) into a single GetASTParser method and do appropriate casts in the plugins themselves.

[jankratochvil]

Remove that dodgy new parameter SymbolFileDWARF &dwarf.

[jankratochvil]

lldb/include/lldb/Symbol/TypeSystem.h

108–110

TBH I did not do the described refactoring, I just used the existing m_sym_file.

[jankratochvil]

I tried to use DIERef instead of DWARFDIE everywhere as @labath does not like to increase DWARFDIE size from 16 bytes to 24 bytes. But that is not really feasible. For DIERef one needs to also carry SymbolFileDWARF * along and also resolving DIERef into DWARFDIE is slow as it has to bisect CUs from the DIE offset. I will post a different proposal how to implement DWZ.

lldb/include/lldb/Symbol/ClangASTContext.h

 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-enumerations.h"
 
 class DWARFASTParserClang;
 class PDBASTParser;
+class SymbolFileDWARF;
 
 namespace lldb_private {
 
 class Declaration;
 
 class ClangASTContext : public TypeSystem {
 public:
   typedef void (*CompleteTagDeclCallback)(void *baton, clang::TagDecl *);
static CompilerType GetPointerSizedIntType(clang::ASTContext *ast,
                                              bool is_signed);
 
   // Floating point functions
 
   static CompilerType GetFloatTypeFromBitSize(clang::ASTContext *ast,
                                               size_t bit_size);
 
   // TypeSystem methods
-  DWARFASTParser *GetDWARFParser() override;
+  DWARFASTParser *GetDWARFParser(SymbolFileDWARF &dwarf) override;
   PDBASTParser *GetPDBParser() override;
 
   // ClangASTContext callbacks for external source lookups.
   static void CompleteTagDecl(void *baton, clang::TagDecl *);
 
   static void CompleteObjCInterfaceDecl(void *baton,
                                         clang::ObjCInterfaceDecl *);
 

lldb/include/lldb/Symbol/TypeSystem.h

 #include "lldb/Expression/Expression.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-private.h"
 
 class DWARFDIE;
 class DWARFASTParser;
 class PDBASTParser;
+class SymbolFileDWARF;
 
 namespace lldb_private {
 
 /// A SmallBitVector that represents a set of source languages (\p
 /// lldb::LanguageType).  Each lldb::LanguageType is represented by
 /// the bit with the position of its enumerator. The largest
 /// LanguageType is < 64, so this is space-efficient and on 64-bit
 /// architectures a LanguageSet can be completely stack-allocated.
public:
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Target *target);
 
   // Free up any resources associated with this TypeSystem.  Done before
   // removing all the TypeSystems from the TypeSystemMap.
   virtual void Finalize() {}
 
-  virtual DWARFASTParser *GetDWARFParser() { return nullptr; }
+  virtual DWARFASTParser *GetDWARFParser(SymbolFileDWARF &dwarf) {
+    return nullptr;
+  }
   virtual PDBASTParser *GetPDBParser() { return nullptr; }
 
   virtual SymbolFile *GetSymbolFile() const { return m_sym_file; }
 
   // Returns true if the symbol file changed during the set accessor.
   virtual void SetSymbolFile(SymbolFile *sym_file) { m_sym_file = sym_file; }
 
   // CompilerDecl functions

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

 //===-- DWARFASTParser.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 SymbolFileDWARF_DWARFASTParser_h_
 #define SymbolFileDWARF_DWARFASTParser_h_
 
+#include "DIERef.h"
 #include "DWARFDefines.h"
 #include "lldb/Core/PluginInterface.h"
-#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
+#include "lldb/Symbol/SymbolFile.h"
 
 class DWARFDIE;
 namespace lldb_private {
 class CompileUnit;
 class ExecutionContext;
 }
 class SymbolFileDWARF;
 
public:
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) = 0;
 
   virtual bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) = 0;
 
   virtual lldb_private::CompilerDecl
-  GetDeclForUIDFromDWARF(const DWARFDIE &die) = 0;
+  GetDeclForUIDFromDWARF(SymbolFileDWARF &dwarf, DIERef die_ref) = 0;
 
   virtual lldb_private::CompilerDeclContext
   GetDeclContextForUIDFromDWARF(const DWARFDIE &die) = 0;
 
   virtual lldb_private::CompilerDeclContext
   GetDeclContextContainingUIDFromDWARF(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 // SymbolFileDWARF_DWARFASTParser_h_

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

 }
 class DWARFDebugInfoEntry;
 class SymbolFileDWARF;
 
 struct ParsedDWARFTypeAttributes;
 
 class DWARFASTParserClang : public DWARFASTParser {
 public:
-  DWARFASTParserClang(lldb_private::ClangASTContext &ast);
+  DWARFASTParserClang(lldb_private::ClangASTContext &ast,
+                      SymbolFileDWARF &dwarf);
 
   ~DWARFASTParserClang() override;
 
   // DWARFASTParser interface.
   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,
                         lldb_private::CompilerType &compiler_type) override;
 
-  lldb_private::CompilerDecl
-  GetDeclForUIDFromDWARF(const DWARFDIE &die) override;
+  lldb_private::CompilerDecl GetDeclForUIDFromDWARF(SymbolFileDWARF &dwarf,
+                                                    DIERef die_ref) override;
 
   void EnsureAllDIEsInDeclContextHaveBeenParsed(
       lldb_private::CompilerDeclContext decl_context) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override;
 
   lldb_private::CompilerDeclContext
typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
       DIEToDeclContextMap;
   typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
       DeclContextToDIEMap;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
       DIEToDeclMap;
   typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
   lldb_private::ClangASTContext &m_ast;
+  SymbolFileDWARF &m_dwarf;
   DIEToDeclMap m_die_to_decl;
   DeclToDIEMap m_decl_to_die;
   DIEToDeclContextMap m_die_to_decl_ctx;
   DeclContextToDIEMap m_decl_ctx_to_die;
   std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_up;
   /// @}
 
   clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
protected:
 
   /// 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);
 
-  clang::Decl *GetClangDeclForDIE(const DWARFDIE &die);
+  clang::Decl *GetClangDeclForDIE(SymbolFileDWARF &dwarf, DIERef die_ref);
 
   clang::DeclContext *GetClangDeclContextForDIE(const DWARFDIE &die);
 
   clang::DeclContext *GetClangDeclContextContainingDIE(const DWARFDIE &die,
                                                        DWARFDIE *decl_ctx_die);
 
   bool CopyUniqueClassMethodTypes(const DWARFDIE &src_class_die,
                                   const DWARFDIE &dst_class_die,
                                   lldb_private::Type *class_type,
+                                  DWARFASTParserClang *dwarf_ast_parser,
                                   std::vector<DWARFDIE> &failures);
 
   clang::DeclContext *GetCachedClangDeclContextForDIE(const DWARFDIE &die);
 
   void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, const DWARFDIE &die);
 
   void LinkDeclToDIE(clang::Decl *decl, const DWARFDIE &die);
 

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

 #include <stdio.h>
 #define DEBUG_PRINTF(fmt, ...) printf(fmt, __VA_ARGS__)
 #else
 #define DEBUG_PRINTF(fmt, ...)
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
-DWARFASTParserClang::DWARFASTParserClang(ClangASTContext &ast)
-    : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
+DWARFASTParserClang::DWARFASTParserClang(ClangASTContext &ast,
+                                         SymbolFileDWARF &dwarf)
+    : m_ast(ast), m_dwarf(dwarf), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
 
 DWARFASTParserClang::~DWARFASTParserClang() {}
 
 static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
   switch (dwarf_accessibility) {
   case DW_ACCESS_public:
     return eAccessPublic;
   case DW_ACCESS_private:
static bool IsClangModuleFwdDecl(const DWARFDIE &Die) {
   while (Parent.IsValid()) {
     if (Parent.Tag() == DW_TAG_module)
       return true;
     Parent = Parent.GetParent();
   }
   return false;
 }
 
-static DWARFDIE GetContainingClangModuleDIE(const DWARFDIE &die) {
-  if (die.IsValid()) {
-    DWARFDIE top_module_die;
-    // Now make sure this DIE is scoped in a DW_TAG_module tag and return true
-    // if so
-    for (DWARFDIE parent = die.GetParent(); parent.IsValid();
-         parent = parent.GetParent()) {
-      const dw_tag_t tag = parent.Tag();
-      if (tag == DW_TAG_module)
-        top_module_die = parent;
-      else if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
-        break;
-    }
-
-    return top_module_die;
-  }
-  return DWARFDIE();
-}
-
-static lldb::ModuleSP GetContainingClangModule(const DWARFDIE &die) {
-  if (die.IsValid()) {
-    DWARFDIE clang_module_die = GetContainingClangModuleDIE(die);
-
-    if (clang_module_die) {
-      const char *module_name = clang_module_die.GetName();
-      if (module_name)
-        return die.GetDWARF()->GetExternalModule(
-            lldb_private::ConstString(module_name));
-    }
-  }
-  return lldb::ModuleSP();
-}
-
 TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
                                                      const DWARFDIE &die,
                                                      Log *log) {
-  ModuleSP clang_module_sp = GetContainingClangModule(die);
+  const ModuleSP &clang_module_sp = sc.module_sp;
   if (!clang_module_sp)
     return TypeSP();
 
   // If this type comes from a Clang module, recursively look in the
   // DWARF section of the .pcm file in the module cache. Clang
   // generates DWO skeleton units as breadcrumbs to find them.
   llvm::SmallVector<CompilerContext, 4> decl_context;
   die.GetDeclContext(decl_context);
   TypeMap pcm_types;
 
   // The type in the Clang module must have the same language as the current CU.
   LanguageSet languages;
-  languages.Insert(SymbolFileDWARF::GetLanguage(*die.GetCU()));
+  languages.Insert(!sc.comp_unit ? eLanguageTypeUnknown
+                                 : sc.comp_unit->GetLanguage());
   llvm::DenseSet<SymbolFile *> searched_symbol_files;
   clang_module_sp->GetSymbolFile()->FindTypes(decl_context, languages,
                                               searched_symbol_files, pcm_types);
   if (pcm_types.Empty()) {
     // Since this type is defined in one of the Clang modules imported
     // by this symbol file, search all of them. Instead of calling
     // sym_file->FindTypes(), which would return this again, go straight
     // to the imported modules.
-    auto &sym_file = die.GetCU()->GetSymbolFileDWARF();
+    auto &sym_file =
+        static_cast<SymbolFileDWARF &>(*sc.module_sp->GetSymbolFile());
 
     // Well-formed clang modules never form cycles; guard against corrupted
     // ones by inserting the current file.
     searched_symbol_files.insert(&sym_file);
     sym_file.ForEachExternalModule(
         *sc.comp_unit, searched_symbol_files, [&](Module &module) {
           module.GetSymbolFile()->FindTypes(decl_context, languages,
                                             searched_symbol_files, pcm_types);
TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
   const dw_tag_t tag = die.Tag();
 
   Type::ResolveState resolve_state = Type::ResolveState::Unresolved;
 
   Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
   CompilerType clang_type;
 
   TypeSP type_sp;
-  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
+  LanguageType cu_language =
+      !sc.comp_unit ? eLanguageTypeUnknown : sc.comp_unit->GetLanguage();
   switch (tag) {
   case DW_TAG_typedef:
   case DW_TAG_base_type:
   case DW_TAG_pointer_type:
   case DW_TAG_reference_type:
   case DW_TAG_rvalue_reference_type:
   case DW_TAG_const_type:
   case DW_TAG_restrict_type:
TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
 
   case DW_TAG_enumeration_type: {
     if (attrs.is_forward_declaration) {
       type_sp = ParseTypeFromClangModule(sc, die, log);
       if (type_sp)
         return type_sp;
 
       DWARFDeclContext die_decl_ctx;
-      SymbolFileDWARF::GetDWARFDeclContext(die, die_decl_ctx);
+      die_decl_ctx.SetLanguage(cu_language);
+      die.GetDIE()->GetDWARFDeclContext(die.GetCU(), die_decl_ctx);
 
       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,
if (attrs.name) {
               // 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(
+                    decl_ctx_die, class_type_die, class_type,
+                    (DWARFASTParserClang *)dwarf->GetDWARFParser(cu_language),
+                    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_ptr = dwarf->GetDIEToType()[die.GetDIE()];
                 if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {

 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());
+  LanguageType cu_language =
+      !sc.comp_unit ? eLanguageTypeUnknown : sc.comp_unit->GetLanguage();
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_TYPE_COMPLETION |
                                           DWARF_LOG_LOOKUPS);
 
   // UniqueDWARFASTType is large, so don't create a local variables on the
   // stack, put it on the heap. This function is often called recursively and
   // clang isn't good at sharing the stack space for variables in different
   // blocks.
   auto unique_ast_entry_up = std::make_unique<UniqueDWARFASTType>();
if (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, die_decl_ctx);
+    die_decl_ctx.SetLanguage(cu_language);
+    die.GetDIE()->GetDWARFDeclContext(die.GetCU(), die_decl_ctx);
 
     // 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) {

 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;
-         decl = decl.GetSibling())
-      GetClangDeclForDIE(decl);
+         decl = decl.GetSibling()) {
+      llvm::Optional<DIERef> decl_ref = decl.GetDIERef();
+      if (!decl_ref)
+        continue;
+      GetClangDeclForDIE(m_dwarf, *decl_ref);
+    }
 }
 
-CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(const DWARFDIE &die) {
-  clang::Decl *clang_decl = GetClangDeclForDIE(die);
+CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(SymbolFileDWARF &dwarf,
+                                                         DIERef die_ref) {
+  clang::Decl *clang_decl = GetClangDeclForDIE(dwarf, die_ref);
   if (clang_decl != nullptr)
     return CompilerDecl(&m_ast, clang_decl);
   return CompilerDecl();
 }
 
 CompilerDeclContext
 DWARFASTParserClang::GetDeclContextForUIDFromDWARF(const DWARFDIE &die) {
   clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE(die);
if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
     }
 
     if (func_range.GetBaseAddress().IsValid()) {
       Mangled func_name;
       if (mangled)
         func_name.SetValue(ConstString(mangled), true);
       else if ((die.GetParent().Tag() == DW_TAG_compile_unit ||
                 die.GetParent().Tag() == DW_TAG_partial_unit) &&
-               Language::LanguageIsCPlusPlus(
-                   SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
-               !Language::LanguageIsObjC(
-                   SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
-               name && strcmp(name, "main") != 0) {
+               Language::LanguageIsCPlusPlus(comp_unit.GetLanguage()) &&
+               !Language::LanguageIsObjC(comp_unit.GetLanguage()) && 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;
         DWARFDeclContext decl_ctx;
         StreamString sstr;
 
-        SymbolFileDWARF::GetDWARFDeclContext(die, decl_ctx);
+        decl_ctx.SetLanguage(comp_unit.GetLanguage());
+        die.GetDIE()->GetDWARFDeclContext(die.GetCU(), decl_ctx);
         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);
         sstr << "(";
if (num_attributes > 0) {
           return dwarf->ResolveTypeUID(form_value.Reference(), true);
       }
     }
   }
 
   return nullptr;
 }
 
-clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
+clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(SymbolFileDWARF &dwarf,
+                                                     DIERef die_ref) {
+  DWARFDIE die = dwarf.GetDIE(die_ref);
   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());
   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);
+    llvm::Optional<DIERef> spec_die_ref = spec_die.GetDIERef();
+    if (!spec_die_ref)
+      return nullptr;
+    clang::Decl *decl = GetClangDeclForDIE(dwarf, *spec_die_ref);
     m_die_to_decl[die.GetDIE()] = decl;
     m_decl_to_die[decl].insert(die.GetDIE());
     return decl;
   }
 
   if (DWARFDIE abstract_origin_die =
           die.GetReferencedDIE(DW_AT_abstract_origin)) {
-    clang::Decl *decl = GetClangDeclForDIE(abstract_origin_die);
+    llvm::Optional<DIERef> abstract_origin_die_ref =
+        abstract_origin_die.GetDIERef();
+    if (!abstract_origin_die_ref)
+      return nullptr;
+    clang::Decl *decl = GetClangDeclForDIE(dwarf, *abstract_origin_die_ref);
     m_die_to_decl[die.GetDIE()] = decl;
     m_decl_to_die[decl].insert(die.GetDIE());
     return decl;
   }
 
   clang::Decl *decl = nullptr;
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   case DW_TAG_formal_parameter: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
     Type *type = GetTypeForDIE(die);
-    if (dwarf && type) {
+    if (type) {
       const char *name = die.GetName();
       clang::DeclContext *decl_context =
           ClangASTContext::DeclContextGetAsDeclContext(
-              dwarf->GetDeclContextContainingUID(die.GetID()));
+              dwarf.GetDeclContextContainingUID(die.GetID()));
       decl = m_ast.CreateVariableDeclaration(
           decl_context, name,
           ClangUtil::GetQualType(type->GetForwardCompilerType()));
     }
     break;
   }
   case DW_TAG_imported_declaration: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
-    DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
-    if (imported_uid) {
-      CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid);
+    DWARFDIE imported_die = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
+    if (imported_die) {
+      llvm::Optional<DIERef> imported_die_ref = imported_die.GetDIERef();
+      if (!imported_die_ref)
+        return nullptr;
+      CompilerDecl imported_decl = dwarf.GetDecl(*imported_die_ref);
       if (imported_decl) {
         clang::DeclContext *decl_context =
             ClangASTContext::DeclContextGetAsDeclContext(
-                dwarf->GetDeclContextContainingUID(die.GetID()));
+                dwarf.GetDeclContextContainingUID(die.GetID()));
         if (clang::NamedDecl *clang_imported_decl =
                 llvm::dyn_cast<clang::NamedDecl>(
                     (clang::Decl *)imported_decl.GetOpaqueDecl()))
           decl =
               m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
       }
     }
     break;
   }
   case DW_TAG_imported_module: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
-    DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
-
-    if (imported_uid) {
+    DWARFDIE imported_die = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
+    if (imported_die) {
+      llvm::Optional<DIERef> imported_die_ref = imported_die.GetDIERef();
+      if (!imported_die_ref)
+        return nullptr;
       CompilerDeclContext imported_decl_ctx =
-          SymbolFileDWARF::GetDeclContext(imported_uid);
+          dwarf.GetDeclContext(*imported_die_ref);
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
             ClangASTContext::DeclContextGetAsDeclContext(
-                dwarf->GetDeclContextContainingUID(die.GetID()));
+                dwarf.GetDeclContextContainingUID(die.GetID()));
         if (clang::NamespaceDecl *ns_decl =
                 ClangASTContext::DeclContextGetAsNamespaceDecl(
                     imported_decl_ctx))
           decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl);
       }
     }
     break;
   }
void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx,
   m_die_to_decl_ctx[die.GetDIE()] = 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));
 }
 
 bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
     const DWARFDIE &src_class_die, const DWARFDIE &dst_class_die,
-    lldb_private::Type *class_type, std::vector<DWARFDIE> &failures) {
+    lldb_private::Type *class_type, DWARFASTParserClang *dwarf_ast_parser,
+    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) {
                 "but 0x%8.8x (%s) names didn't match 0x%8.8x (%s)",
                 src_class_die.GetOffset(), dst_class_die.GetOffset(),
                 src_die.GetOffset(), src_name, dst_die.GetOffset(), dst_name);
 
       fast_path = false;
     }
   }
 
-  DWARFASTParserClang *dwarf_ast_parser =
-      (DWARFASTParserClang *)SymbolFileDWARF::GetDWARFParser(*src_die.GetCU());
-  lldbassert(dwarf_ast_parser == (DWARFASTParserClang *)SymbolFileDWARF::GetDWARFParser(*dst_die.GetCU());
-
   // 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);
 

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

void DWARFIndex::ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
   // 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;
 
   // 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 (!dwarf.DIEInDeclContext(&parent_decl_ctx, die, ref))
     return;
 
   // In case of a full match, we just insert everything we find.
   if (name_type_mask & eFunctionNameTypeFull) {
     dies.push_back(die);
     return;
   }
 

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

void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, IndexSet &set) {
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS);
 
   if (log) {
     m_module.LogMessage(
         log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
         unit.GetOffset());
   }
 
-  const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
+  const LanguageType cu_language =
+      SymbolFileDWARF::LanguageTypeFromDWARF(unit.GetDWARFLanguageType());
 
   IndexUnitImpl(unit, cu_language, set);
 
   if (SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile()) {
     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);
   }
if (name_type_mask & eFunctionNameTypeFull) {
     DIEArray offsets;
     m_set.function_basenames.Find(name, offsets);
     m_set.function_methods.Find(name, offsets);
     m_set.function_fullnames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
       DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
+      if (dwarf.DIEInDeclContext(&parent_decl_ctx, die, die_ref))
         dies.push_back(die);
     }
   }
   if (name_type_mask & eFunctionNameTypeBase) {
     DIEArray offsets;
     m_set.function_basenames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
       DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(&parent_decl_ctx, die))
+      if (dwarf.DIEInDeclContext(&parent_decl_ctx, die, die_ref))
         dies.push_back(die);
     }
     offsets.clear();
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
     DIEArray offsets;
     m_set.function_methods.Find(name, offsets);

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

public:
   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 DWARFUnit *GetUnit(DIERef die_ref);
+
+  DWARFDIE GetDIE(DIERef die_ref);
 
   DWARFDIE GetDIE(lldb::user_id_t uid);
 
   lldb::user_id_t GetUID(const DWARFBaseDIE &die) {
     return GetUID(die.GetDIERef());
   }
 
   lldb::user_id_t GetUID(const llvm::Optional<DIERef> &ref) {
public:
   // the method returns a pointer to the base compile unit.
   virtual DWARFCompileUnit *GetBaseCompileUnit() { return nullptr; }
 
   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
+  bool
   DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
-                   const DWARFDIE &die);
+                   const DWARFDIE &die, DIERef die_ref);
 
   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; }
 
   lldb_private::FileSpec GetFile(DWARFUnit &unit, size_t file_idx);
 
-  static llvm::Expected<lldb_private::TypeSystem &>
-  GetTypeSystem(DWARFUnit &unit);
+  lldb::LanguageType GetLanguage(DIERef die_ref);
+
+  DWARFASTParser *GetDWARFParser(lldb::LanguageType language);
 
-  static DWARFASTParser *GetDWARFParser(DWARFUnit &unit);
+  DWARFASTParser *GetDWARFParser(DIERef die_ref);
+
+  DWARFASTParser *GetDWARFParser(lldb::user_id_t die_uid,
+                                 DWARFDIE *die = nullptr);
 
   // CompilerDecl related functions
 
-  static lldb_private::CompilerDecl GetDecl(const DWARFDIE &die);
+  lldb_private::CompilerDecl GetDecl(lldb::user_id_t die_uid);
 
-  static lldb_private::CompilerDeclContext GetDeclContext(const DWARFDIE &die);
+  lldb_private::CompilerDecl GetDecl(DIERef die_ref);
 
-  static lldb_private::CompilerDeclContext
-  GetContainingDeclContext(const DWARFDIE &die);
+  lldb_private::CompilerDeclContext GetDeclContext(lldb::user_id_t die_uid);
 
-  static void GetDWARFDeclContext(const DWARFDIE &die,
-                                  DWARFDeclContext &dwarf_decl_ctx);
+  lldb_private::CompilerDeclContext GetDeclContext(DIERef die_ref);
 
-  static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
+  lldb_private::CompilerDeclContext
+  GetContainingDeclContext(lldb::user_id_t die_uid);
 
-  static lldb::LanguageType GetLanguage(DWARFUnit &unit);
+  static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
 protected:
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
       DIEToTypePtr;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
       DIEToVariableSP;
   typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
                          lldb::opaque_compiler_type_t>

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

 }
 
 Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
                                          const DWARFDIE &die) {
   ASSERT_MODULE_LOCK(this);
   if (!die.IsValid())
     return nullptr;
 
-  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
+  auto type_system_or_err = GetTypeSystemForLanguage(comp_unit.GetLanguage());
   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();
+  DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser(*this);
   if (!dwarf_ast)
     return nullptr;
 
   return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die);
 }
 
 bool SymbolFileDWARF::FixupAddress(Address &addr) {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile) {
     return debug_map_symfile->LinkOSOAddress(addr);
   }
   // This is a normal DWARF file, no address fixups need to happen
   return true;
 }
 lldb::LanguageType SymbolFileDWARF::ParseLanguage(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
-    return GetLanguage(*dwarf_cu);
+    return LanguageTypeFromDWARF(dwarf_cu->GetDWARFLanguageType());
   else
     return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "SymbolFileDWARF::ParseFunctions");
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (parent_die) {
     }
   }
   return false;
 }
 
 void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
   auto *type_system = decl_ctx.GetTypeSystem();
   if (type_system != nullptr)
-    type_system->GetDWARFParser()->EnsureAllDIEsInDeclContextHaveBeenParsed(
-        decl_ctx);
+    type_system->GetDWARFParser(*this)
+        ->EnsureAllDIEsInDeclContextHaveBeenParsed(decl_ctx);
 }
 
 user_id_t SymbolFileDWARF::GetUID(DIERef ref) {
   if (GetDebugMapSymfile())
     return GetID() | ref.die_offset();
 
   return user_id_t(GetDwoNum().getValueOr(0x7fffffff)) << 32 |
          ref.die_offset() |

 
 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);
-  return CompilerDecl();
+  return GetDecl(type_uid);
 }
 
 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);
-  return CompilerDeclContext();
+  return GetDeclContext(type_uid);
 }
 
 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);
-  return CompilerDeclContext();
+  return GetContainingDeclContext(type_uid);
 }
 
 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))
if (GetForwardDeclClangTypeToDie().count(
     return true;
   }
   TypeSystem *type_system = compiler_type.GetTypeSystem();
 
   ClangASTContext *clang_type_system =
       llvm::dyn_cast_or_null<ClangASTContext>(type_system);
   if (!clang_type_system)
     return false;
-  DWARFASTParserClang *ast_parser =
-      static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
+  DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(
+      clang_type_system->GetDWARFParser(*this));
   return ast_parser->GetClangASTImporter().CanImport(compiler_type);
 }
 
 bool SymbolFileDWARF::CompleteType(CompilerType &compiler_type) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
   ClangASTContext *clang_type_system =
       llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
   if (clang_type_system) {
-    DWARFASTParserClang *ast_parser =
-        static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
+    DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(
+        clang_type_system->GetDWARFParser(*this));
     if (ast_parser &&
         ast_parser->GetClangASTImporter().CanImport(compiler_type))
       return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
   }
 
   // We have a struct/union/class/enum that needs to be fully resolved.
   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());
-  if (dwarf_die) {
+  DWARFDIE dwarf_die;
+  DWARFASTParser *dwarf_ast = GetDWARFParser(die_it->getSecond(), &dwarf_die);
+  if (dwarf_ast) {
     // 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());
 
     Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO |
                                           DWARF_LOG_TYPE_COMPLETION));
     if (log)
       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
           log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
           dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
     assert(compiler_type);
-    DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetCU());
-    if (dwarf_ast)
-      return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
   }
   return false;
 }
 
 Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
                                    bool assert_not_being_parsed,
                                    bool resolve_function_context) {
   if (die) {
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) {
+DWARFUnit *SymbolFileDWARF::GetUnit(DIERef die_ref) {
   if (die_ref.dwo_num()) {
     return DebugInfo()
         ->GetUnitAtIndex(*die_ref.dwo_num())
         ->GetDwoSymbolFile()
-        ->GetDIE(die_ref);
+        ->GetUnit(die_ref);
   }
 
   DWARFDebugInfo *debug_info = DebugInfo();
   if (debug_info)
-    return debug_info->GetDIE(die_ref);
+    return debug_info->GetUnit(die_ref);
   else
-    return DWARFDIE();
+    return nullptr;
+}
+
+DWARFDIE
+SymbolFileDWARF::GetDIE(DIERef die_ref) {
+  DWARFUnit *unit = GetUnit(die_ref);
+  if (!unit)
+    return {};
+  return unit->GetDIE(die_ref.die_offset());
 }
 
 /// 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)
for (size_t i = 0; i < num_die_matches && !done; ++i) {
 
         case DW_TAG_variable: {
           auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
           if (!dwarf_cu)
             continue;
           sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
           if (parent_decl_ctx) {
-            DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+            DWARFASTParser *dwarf_ast = GetDWARFParser(die_ref);
             if (dwarf_ast) {
               CompilerDeclContext actual_parent_decl_ctx =
                   dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
               if (!actual_parent_decl_ctx ||
                   actual_parent_decl_ctx != *parent_decl_ctx)
                 continue;
             }
           }
if (addr.IsValid()) {
       return true;
     }
   }
 
   return false;
 }
 
 bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
-                                       const DWARFDIE &die) {
+                                       const DWARFDIE &die, DIERef die_ref) {
+  assert(die.GetOffset() == die_ref.die_offset());
   // 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 == nullptr || !decl_ctx->IsValid())
     return true;
 
   if (die) {
-    DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+    DWARFASTParser *dwarf_ast = GetDWARFParser(die_ref);
     if (dwarf_ast) {
       CompilerDeclContext actual_decl_ctx =
           dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
       if (actual_decl_ctx)
         return decl_ctx->IsContainedInLookup(actual_decl_ctx);
     }
   }
   return false;
void SymbolFileDWARF::FindTypes(
   DIEArray die_offsets;
   m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   for (size_t i = 0; i < num_die_matches; ++i) {
     const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
     if (die) {
-      if (!DIEInDeclContext(parent_decl_ctx, die))
+      if (!DIEInDeclContext(parent_decl_ctx, die, die_ref))
         continue; // The containing decl contexts don't match
 
       Type *matching_type = ResolveType(die, true, true);
       if (matching_type) {
         // We found a type pointer, now find the shared pointer form our type
         // list
         types.InsertUnique(matching_type->shared_from_this());
         if (types.GetSize() >= max_matches)
void SymbolFileDWARF::FindTypes(
   for (size_t i = 0; i < num_die_matches; ++i) {
     const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
 
     if (!die) {
       m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
       continue;
     }
-    if (!languages[GetLanguage(*die.GetCU())])
+    if (!languages[GetLanguage(die_ref)])
       continue;
 
     llvm::SmallVector<CompilerContext, 4> die_context;
     die.GetDeclContext(die_context);
     if (!contextMatches(die_context, pattern))
       continue;
 
     if (Type *matching_type = ResolveType(die, true, true)) {
if (info) {
     m_index->GetNamespaces(name, die_offsets);
     const size_t num_matches = die_offsets.size();
     if (num_matches) {
       for (size_t i = 0; i < num_matches; ++i) {
         const DIERef &die_ref = die_offsets[i];
         DWARFDIE die = GetDIE(die_ref);
 
         if (die) {
-          if (!DIEInDeclContext(parent_decl_ctx, die))
+          if (!DIEInDeclContext(parent_decl_ctx, die, die_ref))
             continue; // The containing decl contexts don't match
 
-          DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+          DWARFASTParser *dwarf_ast = GetDWARFParser(die_ref);
           if (dwarf_ast) {
             namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
             if (namespace_decl_ctx)
               break;
           }
         } else {
           m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
         }
if (type_name) {
           const DIERef &die_ref = die_offsets[i];
           DWARFDIE type_die = GetDIE(die_ref);
 
           if (type_die) {
             // Make sure type_die's langauge matches the type system we are
             // looking for. We don't want to find a "Foo" type from Java if we
             // are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
             if (type_system &&
-                !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
+                !type_system->SupportsLanguage(GetLanguage(die_ref)))
               continue;
             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) {
                 // Tags don't match, don't event try to resolve using this type
                 // whose name matches....
                 break;
               }
             }
 
             if (try_resolving_type) {
               DWARFDeclContext type_dwarf_decl_ctx;
-              GetDWARFDeclContext(type_die, type_dwarf_decl_ctx);
+              type_dwarf_decl_ctx.SetLanguage(dwarf_decl_ctx.GetLanguage());
+              type_die.GetDIE()->GetDWARFDeclContext(type_die.GetCU(),
+                                                     type_dwarf_decl_ctx);
 
               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),
TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
   return type_sp;
 }
 
 TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
                                   bool *type_is_new_ptr) {
   if (!die)
     return {};
 
-  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
+  auto type_system_or_err = GetTypeSystemForLanguage(
+      !sc.comp_unit ? eLanguageTypeUnknown : sc.comp_unit->GetLanguage());
   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();
+  DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser(*this);
   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) {
if (num_attributes > 0) {
         // declared in a namespace B which in turn is contained in a
         // namespace A, the command "frame var j" returns
         //   "(int) A::B::j = 4".
         // If the compiler does not emit a linkage name, we should be
         // able to generate a fully qualified name from the
         // declaration context.
         if ((parent_tag == DW_TAG_compile_unit ||
              parent_tag == DW_TAG_partial_unit) &&
-            Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU()))) {
+            Language::LanguageIsCPlusPlus(!sc.comp_unit
+                                              ? eLanguageTypeUnknown
+                                              : sc.comp_unit->GetLanguage())) {
           DWARFDeclContext decl_ctx;
 
-          GetDWARFDeclContext(die, decl_ctx);
+          decl_ctx.SetLanguage(!sc.comp_unit ? eLanguageTypeUnknown
+                                             : sc.comp_unit->GetLanguage());
+          die.GetDIE()->GetDWARFDeclContext(die.GetCU(), decl_ctx);
           mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString();
         }
       }
 
       if (tag == DW_TAG_formal_parameter)
         scope = eValueTypeVariableArgument;
       else {
         // DWARF doesn't specify if a DW_TAG_variable is a local, global
llvm::call_once(m_dwp_symfile_once_flag, [this]() {
     if (FileSystem::Instance().Exists(dwp_filespec)) {
       m_dwp_symfile = SymbolFileDWARFDwp::Create(GetObjectFile()->GetModule(),
                                                  dwp_filespec);
     }
   });
   return m_dwp_symfile.get();
 }
 
-llvm::Expected<TypeSystem &> SymbolFileDWARF::GetTypeSystem(DWARFUnit &unit) {
-  return unit.GetSymbolFileDWARF().GetTypeSystemForLanguage(GetLanguage(unit));
-}
-
-DWARFASTParser *SymbolFileDWARF::GetDWARFParser(DWARFUnit &unit) {
-  auto type_system_or_err = GetTypeSystem(unit);
+DWARFASTParser *SymbolFileDWARF::GetDWARFParser(LanguageType language) {
+  auto type_system_or_err = GetTypeSystemForLanguage(language);
   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();
+  return type_system_or_err->GetDWARFParser(*this);
+}
+
+DWARFASTParser *SymbolFileDWARF::GetDWARFParser(DIERef die_ref) {
+  return GetDWARFParser(GetLanguage(die_ref));
 }
 
-CompilerDecl SymbolFileDWARF::GetDecl(const DWARFDIE &die) {
-  DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+DWARFASTParser *SymbolFileDWARF::GetDWARFParser(user_id_t die_uid,
+                                                DWARFDIE *die) {
+  llvm::Optional<SymbolFileDWARF::DecodedUID> decoded = DecodeUID(die_uid);
+  if (!decoded)
+    return nullptr;
+  if (die) {
+    *die = decoded->dwarf.GetDIE(decoded->ref);
+    if (!*die)
+      return nullptr;
+  }
+  return decoded->dwarf.GetDWARFParser(decoded->ref);
+}
+
+CompilerDecl SymbolFileDWARF::GetDecl(lldb::user_id_t die_uid) {
+  llvm::Optional<SymbolFileDWARF::DecodedUID> decoded = DecodeUID(die_uid);
+  if (!decoded)
+    return {};
+  DWARFASTParser *dwarf_ast = decoded->dwarf.GetDWARFParser(decoded->ref);
+  if (dwarf_ast)
+    return dwarf_ast->GetDeclForUIDFromDWARF(decoded->dwarf, decoded->ref);
+  else
+    return CompilerDecl();
+}
+
+CompilerDecl SymbolFileDWARF::GetDecl(DIERef die_ref) {
+  DWARFASTParser *dwarf_ast = GetDWARFParser(die_ref);
   if (dwarf_ast)
-    return dwarf_ast->GetDeclForUIDFromDWARF(die);
+    return dwarf_ast->GetDeclForUIDFromDWARF(*this, die_ref);
   else
     return CompilerDecl();
 }
 
-CompilerDeclContext SymbolFileDWARF::GetDeclContext(const DWARFDIE &die) {
-  DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+CompilerDeclContext SymbolFileDWARF::GetDeclContext(lldb::user_id_t die_uid) {
+  DWARFDIE die;
+  DWARFASTParser *dwarf_ast = GetDWARFParser(die_uid, &die);
   if (dwarf_ast)
     return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
   else
     return CompilerDeclContext();
 }
 
-CompilerDeclContext
-SymbolFileDWARF::GetContainingDeclContext(const DWARFDIE &die) {
-  DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+CompilerDeclContext SymbolFileDWARF::GetDeclContext(DIERef die_ref) {
+  DWARFDIE die = GetDIE(die_ref);
+  if (!die)
+    return {};
+  DWARFASTParser *dwarf_ast = GetDWARFParser(die_ref);
   if (dwarf_ast)
-    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
+    return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
   else
     return CompilerDeclContext();
 }
 
-void SymbolFileDWARF::GetDWARFDeclContext(const DWARFDIE &die,
-                                          DWARFDeclContext &dwarf_decl_ctx) {
-  if (!die.IsValid()) {
-    dwarf_decl_ctx.Clear();
-    return;
-  }
-  dwarf_decl_ctx.SetLanguage(GetLanguage(*die.GetCU()));
-  die.GetDIE()->GetDWARFDeclContext(die.GetCU(), dwarf_decl_ctx);
+CompilerDeclContext
+SymbolFileDWARF::GetContainingDeclContext(lldb::user_id_t die_uid) {
+  DWARFDIE die;
+  DWARFASTParser *dwarf_ast = GetDWARFParser(die_uid, &die);
+  if (dwarf_ast)
+    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
+  else
+    return CompilerDeclContext();
 }
 
 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:
     return eLanguageTypeMipsAssembler;
   case DW_LANG_GOOGLE_RenderScript:
     return eLanguageTypeExtRenderScript;
   default:
     return static_cast<LanguageType>(val);
   }
 }
 
-LanguageType SymbolFileDWARF::GetLanguage(DWARFUnit &unit) {
-  return LanguageTypeFromDWARF(unit.GetDWARFLanguageType());
+LanguageType SymbolFileDWARF::GetLanguage(DIERef die_ref) {
+  DWARFUnit *unit = GetUnit(die_ref);
+  if (!unit)
+    return eLanguageTypeUnknown;
+  return LanguageTypeFromDWARF(unit->GetDWARFLanguageType());
 }

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

public:
   GetLocationListFormat() const override;
 
   size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                  DIEArray &method_die_offsets) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
-  DWARFDIE
-  GetDIE(const DIERef &die_ref) override;
+  DWARFUnit *GetUnit(DIERef die_ref) override;
 
   std::unique_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die) override {
     return nullptr;
   }
 
   DWARFCompileUnit *GetBaseCompileUnit() override { return &m_base_dwarf_cu; }

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

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

lldb/source/Symbol/ClangASTContext.cpp

void ClangASTContext::CompleteObjCInterfaceDecl(
   SymbolFile *sym_file = ast->GetSymbolFile();
   if (sym_file) {
     CompilerType clang_type = GetTypeForDecl(decl);
     if (clang_type)
       sym_file->CompleteType(clang_type);
   }
 }
 
-DWARFASTParser *ClangASTContext::GetDWARFParser() {
+DWARFASTParser *ClangASTContext::GetDWARFParser(SymbolFileDWARF &dwarf) {
   if (!m_dwarf_ast_parser_up)
-    m_dwarf_ast_parser_up.reset(new DWARFASTParserClang(*this));
+    m_dwarf_ast_parser_up.reset(new DWARFASTParserClang(*this, dwarf));
   return m_dwarf_ast_parser_up.get();
 }
 
 PDBASTParser *ClangASTContext::GetPDBParser() {
   if (!m_pdb_ast_parser_up)
     m_pdb_ast_parser_up.reset(new PDBASTParser(*this));
   return m_pdb_ast_parser_up.get();
 }

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 };
 } // namespace
 
 // If your implementation needs to dereference the dummy pointers we are
 // defining here, causing this test to fail, feel free to delete it.
 TEST_F(DWARFASTParserClangTests,
        EnsureAllDIEsInDeclContextHaveBeenParsedParsesOnlyMatchingEntries) {
   ClangASTContext ast_ctx;
-  DWARFASTParserClangStub ast_parser(ast_ctx);
+  DWARFASTParserClangStub ast_parser(ast_ctx, *(SymbolFileDWARF *)1LL);
 
   DWARFUnit *unit = nullptr;
   std::vector<DWARFDIE> dies = {DWARFDIE(unit, (DWARFDebugInfoEntry *)1LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)2LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)3LL),
                                 DWARFDIE(unit, (DWARFDebugInfoEntry *)4LL)};
   std::vector<clang::DeclContext *> decl_ctxs = {
       (clang::DeclContext *)1LL, (clang::DeclContext *)2LL,