Move non-DWARF code: `DWARFUnit` -> `SymbolFileDWARF`

[jankratochvil]

Summary

This patchset is removing non-DWARF code from DWARFUnit as discussed with @labath.
@labath, maybe this is the only patch you did mean?
I do not need this patch myself but I am fine checking it in if you want it.

[labath]

@labath, maybe this is the only patch you did mean?

This is (more or less -- I can't say I had a really exact picture in my head) what I had in mind, when I said that moving the high-level code out of the DWARFUnit class would be useful for the llvm<->lldb dwarf parser convergence. I am aware that you need more for the DWZ stuff -- that is fine, and I like that you have split that into a separate patch.

Anyway, I think this is a good direction to move in. When the time comes, I'd like to get some of clang ast folks to give this a look too, but maybe that's not needed yet...

[labath]

This moves a lot of lldb-specific stuff out of low-level dwarf code, and as such, I think this is a great step towards the parser unification.

I'd just like to squeeze one interface tweak to function we are moving around, but otherwise, I think this is fine.

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

4011

please return the DWARFDeclContext by value here

[jankratochvil]

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

4011

I did the same also for DWARFDebugInfoEntry::GetDWARFDeclContext. It is a part of the updated patch but you can see it separately.

[labath]

Looks great, modulo the inline comment.

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

3986–4007

Don't use else after return. In fact, you might as well fold the GetDWARFParser call into the if condition (if (DWARFASTParser *parser = ...) parser->...)

[jankratochvil]

Checked in, thanks for the review.

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

3986–4007

This was only moving the code, I did not expect to also refactor it. But I have thus made these code cleanups which I found.

[jankratochvil]

This commit broke: http://lab.llvm.org:8080/green/view/LLDB/job/lldb-cmake/7400/
Going to revert the return value refactorization.
That DWARFDebugInfoEntry::GetDWARFDeclContext() refactorization for return value was non-trivial and I see I did screw it up I think despite I did not want to. It is now adding it in opposite order.

[jankratochvil]

Reverted the refactorization by: https://github.com/llvm/llvm-project/commit/6dd0163502ff8c48195643b2b08a123c495743a0

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

TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
   // 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(die.GetCU()->GetLanguageType());
+  languages.Insert(SymbolFileDWARF::GetLanguage(*die.GetCU()));
   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.

 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();
   const dw_tag_t tag = die.Tag();
-  LanguageType cu_language = die.GetLanguage();
+  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
   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 && attrs.type.IsValid()) {
     // Try to parse a typedef from the (DWARF embedded in the) Clang
     // module file first as modules can contain typedef'ed
TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
   TypeSP type_sp;
 
   if (attrs.is_forward_declaration) {
     type_sp = ParseTypeFromClangModule(sc, die, log);
     if (type_sp)
       return type_sp;
 
     DWARFDeclContext die_decl_ctx;
-    die.GetDWARFDeclContext(die_decl_ctx);
+    SymbolFileDWARF::GetDWARFDeclContext(die, 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,
         // see if we have a declaration anywhere else...

 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 = die.GetLanguage();
+  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
   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;
-    die.GetDWARFDeclContext(die_decl_ctx);
+    SymbolFileDWARF::GetDWARFDeclContext(die, 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) {
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(die.GetLanguage()) &&
-               !Language::LanguageIsObjC(die.GetLanguage()) && name &&
-               strcmp(name, "main") != 0) {
+               Language::LanguageIsCPlusPlus(
+                   SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
+               !Language::LanguageIsObjC(
+                   SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
+               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;
 
-        die.GetDWARFDeclContext(decl_ctx);
+        SymbolFileDWARF::GetDWARFDeclContext(die, 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 (dwarf && type) {
           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 = imported_uid.GetDecl();
+      CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid);
       if (imported_decl) {
         clang::DeclContext *decl_context =
             ClangASTContext::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
         if (clang::NamedDecl *clang_imported_decl =
                 llvm::dyn_cast<clang::NamedDecl>(
                     (clang::Decl *)imported_decl.GetOpaqueDecl()))
           decl =
               m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
       }
     }
     break;
   }
   case DW_TAG_imported_module: {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
 
     if (imported_uid) {
-      CompilerDeclContext imported_decl_ctx = imported_uid.GetDeclContext();
+      CompilerDeclContext imported_decl_ctx =
+          SymbolFileDWARF::GetDeclContext(imported_uid);
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
             ClangASTContext::DeclContextGetAsDeclContext(
                 dwarf->GetDeclContextContainingUID(die.GetID()));
         if (clang::NamespaceDecl *ns_decl =
                 ClangASTContext::DeclContextGetAsNamespaceDecl(
                     imported_decl_ctx))
           decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl);
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 =
-      (DWARFASTParserClang *)src_die.GetDWARFParser();
+      (DWARFASTParserClang *)SymbolFileDWARF::GetDWARFParser(*src_die.GetCU());
   DWARFASTParserClang *dst_dwarf_ast_parser =
-      (DWARFASTParserClang *)dst_die.GetDWARFParser();
+      (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/DWARFBaseDIE.h

public:
   SymbolFileDWARF *GetDWARF() const;
 
   DWARFUnit *GetCU() const { return m_cu; }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
   llvm::Optional<DIERef> GetDIERef() const;
 
-  llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem() const;
-
-  DWARFASTParser *GetDWARFParser() const;
-
   void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
     if (cu && die) {
       m_cu = cu;
       m_die = die;
     } else {
       Clear();
     }
   }
public:
   // 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;
 
   const char *GetName() const;
 
-  lldb::LanguageType GetLanguage() const;
-
   lldb::ModuleSP GetModule() const;
 
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   const char *GetAttributeValueAsString(const dw_attr_t attr,

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

 
 const char *DWARFBaseDIE::GetName() const {
   if (IsValid())
     return m_die->GetName(m_cu);
   else
     return nullptr;
 }
 
-lldb::LanguageType DWARFBaseDIE::GetLanguage() const {
-  if (IsValid())
-    return m_cu->GetLanguageType();
-  else
-    return lldb::eLanguageTypeUnknown;
-}
-
 lldb::ModuleSP DWARFBaseDIE::GetModule() const {
   SymbolFileDWARF *dwarf = GetDWARF();
   if (dwarf)
     return dwarf->GetObjectFile()->GetModule();
   else
     return lldb::ModuleSP();
 }
 
 dw_offset_t DWARFBaseDIE::GetOffset() const {
   if (IsValid())
     return m_die->GetOffset();
   else
     return DW_INVALID_OFFSET;
 }
 
 SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
   if (m_cu)
     return &m_cu->GetSymbolFileDWARF();
   else
     return nullptr;
 }
 
-llvm::Expected<lldb_private::TypeSystem &> DWARFBaseDIE::GetTypeSystem() const {
-  if (!m_cu)
-    return llvm::make_error<llvm::StringError>(
-        "Unable to get TypeSystem, no compilation unit available",
-        llvm::inconvertibleErrorCode());
-  return m_cu->GetTypeSystem();
-}
-
-DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const {
-  auto type_system_or_err = GetTypeSystem();
-  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();
-}
-
 bool DWARFBaseDIE::HasChildren() const {
   return m_die && m_die->HasChildren();
 }
 
 bool DWARFBaseDIE::Supports_DW_AT_APPLE_objc_complete_type() const {
   return IsValid() && GetDWARF()->Supports_DW_AT_APPLE_objc_complete_type(m_cu);
 }
 

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

public:
   LookupDeepestBlock(lldb::addr_t file_addr) const;
 
   DWARFDIE
   GetParentDeclContextDIE() const;
 
   // DeclContext related functions
   std::vector<DWARFDIE> GetDeclContextDIEs() const;
 
-  void GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const;
-
   /// Return this DIE's decl context as it is needed to look up types
   /// in Clang's -gmodules debug info format.
   void GetDeclContext(
       llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const;
 
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   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;
-
-  // CompilerDecl related functions
-
-  lldb_private::CompilerDecl GetDecl() const;
-
-  lldb_private::CompilerDeclContext GetDeclContext() const;
-
-  lldb_private::CompilerDeclContext GetContainingDeclContext() const;
 };
 
 #endif // SymbolFileDWARF_DWARFDIE_h_

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

std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
   while (parent.IsValid() && parent.GetDIE() != GetDIE()) {
     result.push_back(std::move(parent));
     parent = parent.GetParentDeclContextDIE();
   }
 
   return result;
 }
 
-void DWARFDIE::GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const {
-  if (IsValid()) {
-    dwarf_decl_ctx.SetLanguage(GetLanguage());
-    m_die->GetDWARFDeclContext(GetCU(), dwarf_decl_ctx);
-  } else {
-    dwarf_decl_ctx.Clear();
-  }
-}
-
 void DWARFDIE::GetDeclContext(
     llvm::SmallVectorImpl<lldb_private::CompilerContext> &context) const {
   const dw_tag_t tag = Tag();
   if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
     return;
   DWARFDIE parent = GetParent();
   if (parent)
     parent.GetDeclContext(context);
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;
 }
-
-CompilerDecl DWARFDIE::GetDecl() const {
-  DWARFASTParser *dwarf_ast = GetDWARFParser();
-  if (dwarf_ast)
-    return dwarf_ast->GetDeclForUIDFromDWARF(*this);
-  else
-    return CompilerDecl();
-}
-
-CompilerDeclContext DWARFDIE::GetDeclContext() const {
-  DWARFASTParser *dwarf_ast = GetDWARFParser();
-  if (dwarf_ast)
-    return dwarf_ast->GetDeclContextForUIDFromDWARF(*this);
-  else
-    return CompilerDeclContext();
-}
-
-CompilerDeclContext DWARFDIE::GetContainingDeclContext() const {
-  DWARFASTParser *dwarf_ast = GetDWARFParser();
-  if (dwarf_ast)
-    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(*this);
-  else
-    return CompilerDeclContext();
-}

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

public:
   void SetAddrBase(dw_addr_t addr_base);
   void SetLoclistsBase(dw_addr_t loclists_base);
   void SetRangesBase(dw_addr_t ranges_base);
   void SetStrOffsetsBase(dw_offset_t str_offsets_base);
   virtual void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) = 0;
 
   lldb::ByteOrder GetByteOrder() const;
 
-  llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem();
-
   const DWARFDebugAranges &GetFunctionAranges();
 
   void SetBaseAddress(dw_addr_t base_addr);
 
   DWARFBaseDIE GetUnitDIEOnly() { return DWARFDIE(this, GetUnitDIEPtrOnly()); }
 
   DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); }
 
public:
   DWARFProducer GetProducer();
 
   uint32_t GetProducerVersionMajor();
 
   uint32_t GetProducerVersionMinor();
 
   uint32_t GetProducerVersionUpdate();
 
-  static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
-
-  lldb::LanguageType GetLanguageType();
+  uint64_t GetDWARFLanguageType();
 
   bool GetIsOptimized();
 
   const lldb_private::FileSpec &GetCompilationDirectory();
   const lldb_private::FileSpec &GetAbsolutePath();
   lldb_private::FileSpec GetFile(size_t file_idx);
   lldb_private::FileSpec::Style GetPathStyle();
 
protected:
   // A table similar to the .debug_aranges table, but this one points to the
   // exact DW_TAG_subprogram DIEs
   std::unique_ptr<DWARFDebugAranges> m_func_aranges_up;
   dw_addr_t m_base_addr = 0;
   DWARFProducer m_producer = eProducerInvalid;
   uint32_t m_producer_version_major = 0;
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
-  lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
+  llvm::Optional<uint64_t> m_language_type;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   llvm::Optional<lldb_private::FileSpec> m_comp_dir;
   llvm::Optional<lldb_private::FileSpec> m_file_spec;
   dw_addr_t m_addr_base = 0;     ///< Value of DW_AT_addr_base.
   dw_addr_t m_loclists_base = 0; ///< Value of DW_AT_loclists_base.
   dw_addr_t m_ranges_base = 0;   ///< Value of DW_AT_rnglists_base.
 
   /// Value of DW_AT_stmt_list.

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

void DWARFUnit::ClearDIEsRWLocked() {
   if (m_dwo_symbol_file)
     m_dwo_symbol_file->GetCompileUnit()->ClearDIEsRWLocked();
 }
 
 lldb::ByteOrder DWARFUnit::GetByteOrder() const {
   return m_dwarf.GetObjectFile()->GetByteOrder();
 }
 
-llvm::Expected<TypeSystem &> DWARFUnit::GetTypeSystem() {
-  return m_dwarf.GetTypeSystemForLanguage(GetLanguageType());
-}
-
 void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) { m_base_addr = base_addr; }
 
 // Compare function DWARFDebugAranges::Range structures
 static bool CompareDIEOffset(const DWARFDebugInfoEntry &die,
                              const dw_offset_t die_offset) {
   return die.GetOffset() < die_offset;
 }
 
uint32_t DWARFUnit::GetProducerVersionMinor() {
   return m_producer_version_minor;
 }
 
 uint32_t DWARFUnit::GetProducerVersionUpdate() {
   if (m_producer_version_update == 0)
     ParseProducerInfo();
   return m_producer_version_update;
 }
-LanguageType DWARFUnit::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 DWARFUnit::GetLanguageType() {
-  if (m_language_type != eLanguageTypeUnknown)
-    return m_language_type;
+uint64_t DWARFUnit::GetDWARFLanguageType() {
+  if (m_language_type)
+    return *m_language_type;
 
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
-  if (die)
-    m_language_type = LanguageTypeFromDWARF(
-        die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0));
-  return m_language_type;
+  if (!die)
+    m_language_type = 0;
+  else
+    m_language_type = die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0);
+  return *m_language_type;
 }
 
 bool DWARFUnit::GetIsOptimized() {
   if (m_is_optimized == eLazyBoolCalculate) {
     const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
     if (die) {
       m_is_optimized = eLazyBoolNo;
       if (die->GetAttributeValueAsUnsigned(this, DW_AT_APPLE_optimized, 0) ==

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 = unit.GetLanguageType();
+  const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
 
   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);
   }

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

public:
   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);
+
+  static DWARFASTParser *GetDWARFParser(DWARFUnit &unit);
+
+  // CompilerDecl related functions
+
+  static lldb_private::CompilerDecl GetDecl(const DWARFDIE &die);
+
+  static lldb_private::CompilerDeclContext GetDeclContext(const DWARFDIE &die);
+
+  static lldb_private::CompilerDeclContext
+  GetContainingDeclContext(const DWARFDIE &die);
+
+  static void GetDWARFDeclContext(const DWARFDIE &die,
+                                  DWARFDeclContext &dwarf_decl_ctx);
+
+  static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
+
+  static lldb::LanguageType GetLanguage(DWARFUnit &unit);
+
 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>
       DIEToClangType;

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

if (&dwarf_cu.GetSymbolFileDWARF() != this) {
             cu_file_spec.MakeAbsolute(dwarf_cu.GetCompilationDirectory());
 
             std::string remapped_file;
             if (module_sp->RemapSourceFile(cu_file_spec.GetPath(),
                                            remapped_file))
               cu_file_spec.SetFile(remapped_file, FileSpec::Style::native);
           }
 
-          LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(
+          LanguageType cu_language = SymbolFileDWARF::LanguageTypeFromDWARF(
               cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 
           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);

 }
 
 Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
                                          const DWARFDIE &die) {
   ASSERT_MODULE_LOCK(this);
   if (!die.IsValid())
     return nullptr;
 
-  auto type_system_or_err =
-      GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
+  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to parse function");
     return nullptr;
   }
   DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
   if (!dwarf_ast)
     return nullptr;
bool SymbolFileDWARF::FixupAddress(Address &addr) {
   }
   // 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 dwarf_cu->GetLanguageType();
+    return GetLanguage(*dwarf_cu);
   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());

 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 die.GetDecl();
+    return GetDecl(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 die.GetDeclContext();
+    return GetDeclContext(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 die.GetContainingDeclContext();
+    return GetContainingDeclContext(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 (dwarf_die) {
     Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO |
                                           DWARF_LOG_TYPE_COMPLETION));
     if (log)
       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
           log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
           dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
     assert(compiler_type);
-    DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
+    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,
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 = die.GetDWARFParser();
+            DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
             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;
             }
           }
bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext *decl_ctx,
                                        const DWARFDIE &die) {
   // If we have no parent decl context to match this DIE matches, and if the
   // parent decl context isn't valid, we aren't trying to look for any
   // particular decl context so any die matches.
   if (decl_ctx == nullptr || !decl_ctx->IsValid())
     return true;
 
   if (die) {
-    DWARFASTParser *dwarf_ast = die.GetDWARFParser();
+    DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
     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(
   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[die.GetCU()->GetLanguageType()])
+    if (!languages[GetLanguage(*die.GetCU())])
       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 (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))
             continue; // The containing decl contexts don't match
 
-          DWARFASTParser *dwarf_ast = die.GetDWARFParser();
+          DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
           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(type_die.GetLanguage()))
+                !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
               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;
-              type_die.GetDWARFDeclContext(type_dwarf_decl_ctx);
+              GetDWARFDeclContext(type_die, 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(die.GetCU()->GetLanguageType());
+  auto type_system_or_err = GetTypeSystemForLanguage(GetLanguage(*die.GetCU()));
   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)
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(die.GetLanguage())) {
+            Language::LanguageIsCPlusPlus(GetLanguage(*die.GetCU()))) {
           DWARFDeclContext decl_ctx;
 
-          die.GetDWARFDeclContext(decl_ctx);
+          GetDWARFDeclContext(die, 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
FileSpec dwp_filespec =
         Symbols::LocateExecutableSymbolFile(module_spec, search_paths);
     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);
+  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) {
+  DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+  if (dwarf_ast)
+    return dwarf_ast->GetDeclForUIDFromDWARF(die);
+  else
+    return CompilerDecl();
+}
+
+CompilerDeclContext SymbolFileDWARF::GetDeclContext(const DWARFDIE &die) {
+  DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+  if (dwarf_ast)
+    return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
+  else
+    return CompilerDeclContext();
+}
+
+CompilerDeclContext
+SymbolFileDWARF::GetContainingDeclContext(const DWARFDIE &die) {
+  DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+  if (dwarf_ast)
+    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(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);
+}
+
+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());
+}