WIP: Dont vend lldb_private::CompileUnits for DWARFTypeUnits

[labath]

Summary

This patch isn't meant to be committed, but it is here to demostrate
what it would take to implement the idea proposed by Greg in
D62073#1507063.

The background here is that a type unit build will have substantially
more "units" than a regular one (e.g., a type unit build of lldb will
have about 1k compile units, but almost 400k type units). Vending them
all as lldb_private::CompileUnits is a bit wasteful. It can be made less
wasteful by making sure the CompileUnits share line tables and stuff
(just like DWARF units do), but it's not clear to me whether this is
really useful/needed. For instance, lldb CompileUnits expect to have a
"name" (a file path), but type units don't have that as they're supposed
to be independent/shared between real compile units.

The majority of changes here just deal with the remapping of dwarf vs.
lldb unit indexes, as now we can now no longer use a 1:1 mapping.
However, there are a couple of things that are worth calling out
explicitly:

• DWARFASTParserClang goes through the lldb CompileUnits in order to fetch file names. Right now I've just deleted that code. In a proper solution, we'd need to find a way to get this information strictly through DWARF structures.
• The main visible side effect I can see from this is that we will stop filling out the SymbolContextScope field https://lldb.llvm.org/cpp_reference/classlldb__private_1_1Type.html#aea1b2a6336880f67455036803bf42ea1 of the Type objects that we hand about. More precisely, we can still fill out the "module" part, but not the "compile unit". I'm not sure what are the implications of that, but maybe that is even more correct as the type unit does not really belong to any single compilation. This patch breaks just three tests, and all of them seem related to me stopping to parse the file names, and not this...

So, does anyone see why (a cleaned up version of) this would be a bad
idea?

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

318–319

We should still be able to fill this in. We just need to unique all of the DWARF line tables internally and then access the line table using the DWARF compile/type unit, and not the lldb_private::CompileUnit

470–471

Cache this in local. Kind of expensive to get twice from the DIE since it will have to grab the DW_AT_language attribute from the DIE and not just use a cached version? Unless this just grabs it from the DWARFUnit underneath? And actually a DIE's language could differ from the CU/TU language. We might have a C type in C++, so it is theoretically possible to have a die with a DW_AT_language attribute? If "die.GetLanguage()" is just using the language of the DWARFUnit, then this is fine, otherwise we should explicitly use the DWARFUnit language.

567–568

Again, we can still fill this in correctly, just don't use the lldb_private::CompileUnit, grab the uniqued line table from DWARFContext or SymbolFileDWARF. We need to cache line tables anyway because many type units re-use existing compile unit line tables and we don't want to re-parse line table for each TU.

667

Again, do we want CU/TU language or DIE language?

998–999

fill in using uniqued DWARF line tables

1169–1170

fill in using uniqued DWARF line tables

1677–1678

fill in using uniqued DWARF line tables

2471–2472

fill in using uniqued DWARF line tables

2720–2721

fill in using uniqued DWARF line tables

3188–3189

fill in using uniqued DWARF line tables

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

22

What about DW_UT_split_type?

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

715

BuildCUTranslationTable? Not sure we need the "Lldb" in the name?

[labath]

Thanks for looking at this. I'm not going to respond to the individual comments here, as this patch is not is not intended to be submitted like this. I just posted it here to get some high level feedback about the overall direction. Instead, I'm going to split off smaller patches from here, and we can discuss the details there.

[labath]

Obsoleted by https://reviews.llvm.org/D63005.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

case DW_TAG_unspecified_type: {
 
     if (num_attributes > 0) {
       uint32_t i;
       for (i = 0; i < num_attributes; ++i) {
         attr = attributes.AttributeAtIndex(i);
         if (attributes.ExtractFormValueAtIndex(i, form_value)) {
           switch (attr) {
           case DW_AT_decl_file:
-            decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                form_value.Unsigned()));
             break;
           case DW_AT_decl_line:
             decl.SetLine(form_value.Unsigned());
             break;
           case DW_AT_decl_column:
             decl.SetColumn(form_value.Unsigned());
             break;
           case DW_AT_name:
if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID ||
 
               break;
             }
           }
         }
       }
 
       bool translation_unit_is_objc =
-          (sc.comp_unit->GetLanguage() == eLanguageTypeObjC ||
-           sc.comp_unit->GetLanguage() == eLanguageTypeObjC_plus_plus);
+          (die.GetLanguage() == eLanguageTypeObjC ||
+           die.GetLanguage() == eLanguageTypeObjC_plus_plus);
 
       if (translation_unit_is_objc) {
         if (type_name_cstr != nullptr) {
           static ConstString g_objc_type_name_id("id");
           static ConstString g_objc_type_name_Class("Class");
           static ConstString g_objc_type_name_selector("SEL");
 
           if (type_name_const_str == g_objc_type_name_id) {
case DW_TAG_class_type: {
     const size_t num_attributes = die.GetAttributes(attributes);
     if (num_attributes > 0) {
       uint32_t i;
       for (i = 0; i < num_attributes; ++i) {
         attr = attributes.AttributeAtIndex(i);
         if (attributes.ExtractFormValueAtIndex(i, form_value)) {
           switch (attr) {
           case DW_AT_decl_file:
-            decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                form_value.Unsigned()));
             break;
 
           case DW_AT_decl_line:
             decl.SetLine(form_value.Unsigned());
             break;
 
           case DW_AT_decl_column:
             decl.SetColumn(form_value.Unsigned());
if (tag == DW_TAG_structure_type) {
       tag_decl_kind = clang::TTK_Union;
       default_accessibility = eAccessPublic;
     } else if (tag == DW_TAG_class_type) {
       tag_decl_kind = clang::TTK_Class;
       default_accessibility = eAccessPrivate;
     }
 
     if (byte_size && *byte_size == 0 && type_name_cstr && !die.HasChildren() &&
-        sc.comp_unit->GetLanguage() == eLanguageTypeObjC) {
+        die.GetLanguage() == eLanguageTypeObjC) {
       // Work around an issue with clang at the moment where forward
       // declarations for objective C classes are emitted as:
       //  DW_TAG_structure_type [2]
       //  DW_AT_name( "ForwardObjcClass" )
       //  DW_AT_byte_size( 0x00 )
       //  DW_AT_decl_file( "..." )
       //  DW_AT_decl_line( 1 )
       //
case DW_TAG_enumeration_type: {
     if (num_attributes > 0) {
       uint32_t i;
 
       for (i = 0; i < num_attributes; ++i) {
         attr = attributes.AttributeAtIndex(i);
         if (attributes.ExtractFormValueAtIndex(i, form_value)) {
           switch (attr) {
           case DW_AT_decl_file:
-            decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                form_value.Unsigned()));
             break;
           case DW_AT_decl_line:
             decl.SetLine(form_value.Unsigned());
             break;
           case DW_AT_decl_column:
             decl.SetColumn(form_value.Unsigned());
             break;
           case DW_AT_name:
if (num_attributes > 0) {
 
       type_sp = std::make_shared<Type>(
           die.GetID(), dwarf, type_name_const_str, byte_size, nullptr,
           dwarf->GetUID(DIERef(encoding_form)), Type::eEncodingIsUID, &decl,
           clang_type, Type::eResolveStateForward);
 
       if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
         if (die.HasChildren()) {
-          SymbolContext cu_sc(die.GetLLDBCompileUnit());
+          SymbolContext cu_sc;
           bool is_signed = false;
           enumerator_clang_type.IsIntegerType(is_signed);
           ParseChildEnumerators(cu_sc, clang_type, is_signed,
                                 type_sp->GetByteSize().getValueOr(0), die);
         }
         ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
       } else {
         dwarf->GetObjectFile()->GetModule()->ReportError(
case DW_TAG_subroutine_type: {
     const size_t num_attributes = die.GetAttributes(attributes);
     if (num_attributes > 0) {
       uint32_t i;
       for (i = 0; i < num_attributes; ++i) {
         attr = attributes.AttributeAtIndex(i);
         if (attributes.ExtractFormValueAtIndex(i, form_value)) {
           switch (attr) {
           case DW_AT_decl_file:
-            decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                form_value.Unsigned()));
             break;
           case DW_AT_decl_line:
             decl.SetLine(form_value.Unsigned());
             break;
           case DW_AT_decl_column:
             decl.SetColumn(form_value.Unsigned());
             break;
           case DW_AT_name:
case DW_TAG_array_type: {
 
     if (num_attributes > 0) {
       uint32_t i;
       for (i = 0; i < num_attributes; ++i) {
         attr = attributes.AttributeAtIndex(i);
         if (attributes.ExtractFormValueAtIndex(i, form_value)) {
           switch (attr) {
           case DW_AT_decl_file:
-            decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                form_value.Unsigned()));
             break;
           case DW_AT_decl_line:
             decl.SetLine(form_value.Unsigned());
             break;
           case DW_AT_decl_column:
             decl.SetColumn(form_value.Unsigned());
             break;
           case DW_AT_name:
ClangASTImporter::LayoutInfo layout_info;
         } else if (tag == DW_TAG_union_type) {
           tag_decl_kind = clang::TTK_Union;
           default_accessibility = eAccessPublic;
         } else if (tag == DW_TAG_class_type) {
           tag_decl_kind = clang::TTK_Class;
           default_accessibility = eAccessPrivate;
         }
 
-        SymbolContext sc(die.GetLLDBCompileUnit());
+        SymbolContext sc;
         std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
         std::vector<int> member_accessibilities;
         bool is_a_class = false;
         // Parse members and base classes first
         std::vector<DWARFDIE> member_function_dies;
 
         DelayedPropertyList delayed_properties;
         ParseChildMembers(sc, die, clang_type, class_language, bases,
case DW_TAG_class_type: {
     }
   }
 
     return (bool)clang_type;
 
   case DW_TAG_enumeration_type:
     if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
       if (die.HasChildren()) {
-        SymbolContext sc(die.GetLLDBCompileUnit());
+        SymbolContext sc;
         bool is_signed = false;
         clang_type.IsIntegerType(is_signed);
         ParseChildEnumerators(sc, clang_type, is_signed,
                               type->GetByteSize().getValueOr(0), die);
       }
       ClangASTContext::CompleteTagDeclarationDefinition(clang_type);
     }
     return (bool)clang_type;
if (tag == DW_TAG_enumerator) {
 
             case DW_AT_name:
               name = form_value.AsCString();
               break;
 
             case DW_AT_description:
             default:
             case DW_AT_decl_file:
-              decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                  form_value.Unsigned()));
               break;
             case DW_AT_decl_line:
               decl.SetLine(form_value.Unsigned());
               break;
             case DW_AT_decl_column:
               decl.SetColumn(form_value.Unsigned());
               break;
             case DW_AT_sibling:
case DW_TAG_APPLE_property: {
             false; // On DW_TAG_members, this means the member is static
         uint32_t i;
         for (i = 0; i < num_attributes && !is_artificial; ++i) {
           const dw_attr_t attr = attributes.AttributeAtIndex(i);
           DWARFFormValue form_value;
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             switch (attr) {
             case DW_AT_decl_file:
-              decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                  form_value.Unsigned()));
               break;
             case DW_AT_decl_line:
               decl.SetLine(form_value.Unsigned());
               break;
             case DW_AT_decl_column:
               decl.SetColumn(form_value.Unsigned());
               break;
             case DW_AT_name:
case DW_TAG_inheritance: {
         off_t member_byte_offset = 0;
         uint32_t i;
         for (i = 0; i < num_attributes; ++i) {
           const dw_attr_t attr = attributes.AttributeAtIndex(i);
           DWARFFormValue form_value;
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             switch (attr) {
             case DW_AT_decl_file:
-              decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(
-                  form_value.Unsigned()));
               break;
             case DW_AT_decl_line:
               decl.SetLine(form_value.Unsigned());
               break;
             case DW_AT_decl_column:
               decl.SetColumn(form_value.Unsigned());
               break;
             case DW_AT_type:

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 #include "llvm/Support/Error.h"
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
   void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) override;
 
   void Dump(lldb_private::Stream *s) const override;
 
+  static bool classof(const DWARFUnit *unit) {
+    return unit->GetUnitType() != DW_UT_type;
+  }
+
 private:
   DWARFCompileUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid,
                    const DWARFUnitHeader &header,
                    const DWARFAbbreviationDeclarationSet &abbrevs,
                    DIERef::Section section)
       : DWARFUnit(dwarf, uid, header, abbrevs, section) {}
 
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 
   friend class DWARFUnit;
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

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

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

 DWARFTypeUnit *DWARFDebugInfo::GetTypeUnitForHash(uint64_t hash) {
   auto pos = llvm::lower_bound(m_type_hash_to_unit_index,
                                std::make_pair(hash, 0u), llvm::less_first());
   if (pos == m_type_hash_to_unit_index.end() || pos->first != hash)
     return nullptr;
   return llvm::cast<DWARFTypeUnit>(GetUnitAtIndex(pos->second));
 }
 
+bool DWARFDebugInfo::ContainsTypeUnits() {
+  ParseUnitHeadersIfNeeded();
+  return !m_type_hash_to_unit_index.empty();
+}
+
 DWARFDIE
 DWARFDebugInfo::GetDIEForDIEOffset(DIERef::Section section,
                                    dw_offset_t die_offset) {
   DWARFUnit *cu = GetUnitContainingDIEOffset(section, die_offset);
   if (cu)
     return cu->GetDIE(die_offset);
   return DWARFDIE();
 }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 class DWARFDebugAbbrev;
 class DWARFDebugAranges;
 class DWARFDebugInfo;
 class DWARFDebugInfoEntry;
 class DWARFDebugLine;
 class DWARFDebugRangesBase;
 class DWARFDeclContext;
 class DWARFFormValue;
+class DWARFCompileUnit;
 class SymbolFileDWARFDebugMap;
 class SymbolFileDWARFDwo;
 class SymbolFileDWARFDwp;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type *)1)
 
 class SymbolFileDWARF : public lldb_private::SymbolFile,
                         public lldb_private::UserID {
virtual size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                          DIEArray &method_die_offsets);
 
   bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu);
 
   lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset);
 
   static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die);
 
-  virtual lldb::CompUnitSP ParseCompileUnit(DWARFUnit *dwarf_cu,
-                                            uint32_t cu_idx);
+  virtual lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit *dwarf_cu);
 
   virtual lldb_private::DWARFExpression::LocationListFormat
   GetLocationListFormat() const;
 
   lldb::ModuleSP GetDWOModule(lldb_private::ConstString name);
 
   typedef std::map<lldb_private::ConstString, lldb::ModuleSP>
       ExternalTypeModuleMap;
protected:
   virtual DIEToClangType &GetForwardDeclDieToClangType() {
     return m_forward_decl_die_to_clang_type;
   }
 
   virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() {
     return m_forward_decl_clang_type_to_die;
   }
 
+  void BuildLldbCuTranslationTable();
+
   struct DecodedUID {
     SymbolFileDWARF *dwarf;
     DIERef ref;
   };
   DecodedUID DecodeUID(lldb::user_id_t uid);
 
   SymbolFileDWARFDwp *GetDwpSymbolFile();
 
protected:
   typedef std::unordered_map<std::string, DIERefSetSP> NameToOffsetMap;
   NameToOffsetMap m_function_scope_qualified_name_map;
   std::unique_ptr<DWARFDebugRangesBase> m_ranges;
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   DIEToTypePtr m_die_to_type;
   DIEToVariableSP m_die_to_variable_sp;
   DIEToClangType m_forward_decl_die_to_clang_type;
   ClangTypeToDIE m_forward_decl_clang_type_to_die;
+  std::vector<uint32_t> m_lldb_cu_to_dwarf_unit;
 };
 
 #endif // SymbolFileDWARF_SymbolFileDWARF_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "lldb/Symbol/VariableList.h"
 
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Target.h"
 
 #include "AppleDWARFIndex.h"
 #include "DWARFASTParser.h"
 #include "DWARFASTParserClang.h"
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugLine.h"
 #include "DWARFDebugMacro.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() {
   }
   return m_ranges.get();
 }
 
 const DWARFDebugRangesBase *SymbolFileDWARF::DebugRanges() const {
   return m_ranges.get();
 }
 
-lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFUnit *dwarf_cu,
-                                                   uint32_t cu_idx) {
+lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit *dwarf_cu) {
   CompUnitSP cu_sp;
   if (dwarf_cu) {
     CompileUnit *comp_unit = (CompileUnit *)dwarf_cu->GetUserData();
     if (comp_unit) {
       // We already parsed this compile unit, had out a shared pointer to it
       cu_sp = comp_unit->shared_from_this();
     } else {
       if (dwarf_cu->GetSymbolFileDWARF() != this) {
-        return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu,
-                                                                cu_idx);
+        return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu);
       } else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {
         // Let the debug map create the compile unit
         cu_sp = m_debug_map_symfile->GetCompileUnit(this);
         dwarf_cu->SetUserData(cu_sp.get());
       } else {
         ModuleSP module_sp(m_obj_file->GetModule());
         if (module_sp) {
           const DWARFDIE cu_die = dwarf_cu->DIE();
if (comp_unit) {
                                              remapped_file))
                 cu_file_spec.SetFile(remapped_file, FileSpec::Style::native);
             }
 
             LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(
                 cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
 
             bool is_optimized = dwarf_cu->GetIsOptimized();
+            uint32_t dwarf_idx;
+            if (m_lldb_cu_to_dwarf_unit.empty())
+              dwarf_idx = dwarf_cu->GetID();
+            else
+              dwarf_idx = m_lldb_cu_to_dwarf_unit[dwarf_cu->GetID()];
             cu_sp = std::make_shared<CompileUnit>(
-                module_sp, dwarf_cu, cu_file_spec, dwarf_cu->GetID(),
+                module_sp, dwarf_cu, cu_file_spec, dwarf_idx,
                 cu_language, is_optimized ? eLazyBoolYes : eLazyBoolNo);
             if (cu_sp) {
               // If we just created a compile unit with an invalid file spec,
               // try and get the first entry in the supports files from the
               // line table as that should be the compile unit.
               if (!cu_file_spec) {
                 cu_file_spec = cu_sp->GetSupportFiles().GetFileSpecAtIndex(1);
                 if (cu_file_spec) {
                   (FileSpec &)(*cu_sp) = cu_file_spec;
                   // Also fix the invalid file spec which was copied from the
                   // compile unit.
                   cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
                 }
               }
 
               dwarf_cu->SetUserData(cu_sp.get());
 
-              // Figure out the compile unit index if we weren't given one
-              if (cu_idx == UINT32_MAX)
-                cu_idx = dwarf_cu->GetID();
-
               m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(
-                  cu_idx, cu_sp);
+                  dwarf_cu->GetID(), cu_sp);
             }
           }
         }
       }
     }
   }
   return cu_sp;
 }
 
+void SymbolFileDWARF::BuildLldbCuTranslationTable() {
+  if (!m_lldb_cu_to_dwarf_unit.empty())
+    return;
+
+  DWARFDebugInfo *info = DebugInfo();
+  if (!info)
+    return;
+  if (!info->ContainsTypeUnits()) {
+    // We can use a 1-to-1 mapping. No need to build a translation table.
+    return;
+  }
+  for (uint32_t i = 0, num = info->GetNumUnits(); i < num; ++i) {
+    if (auto *cu = llvm::dyn_cast<DWARFCompileUnit>(info->GetUnitAtIndex(i))) {
+      cu->SetID(m_lldb_cu_to_dwarf_unit.size());
+      m_lldb_cu_to_dwarf_unit.push_back(i);
+    }
+  }
+}
+
 uint32_t SymbolFileDWARF::GetNumCompileUnits() {
   DWARFDebugInfo *info = DebugInfo();
-  if (info)
-    return info->GetNumUnits();
+  if (!info)
     return 0;
+  BuildLldbCuTranslationTable();
+  return m_lldb_cu_to_dwarf_unit.empty() ? info->GetNumUnits() : m_lldb_cu_to_dwarf_unit.size();
 }
 
 CompUnitSP SymbolFileDWARF::ParseCompileUnitAtIndex(uint32_t cu_idx) {
   ASSERT_MODULE_LOCK(this);
   CompUnitSP cu_sp;
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
-    DWARFUnit *dwarf_cu = info->GetUnitAtIndex(cu_idx);
+    BuildLldbCuTranslationTable();
+    uint32_t dwarf_idx;
+    if (m_lldb_cu_to_dwarf_unit.empty())
+      dwarf_idx = cu_idx;
+    else {
+      if (cu_idx >= m_lldb_cu_to_dwarf_unit.size())
+        return nullptr;
+      dwarf_idx = m_lldb_cu_to_dwarf_unit[cu_idx];
+    }
+    DWARFUnit *dwarf_cu = info->GetUnitAtIndex(dwarf_idx);
     if (dwarf_cu)
-      cu_sp = ParseCompileUnit(dwarf_cu, cu_idx);
+      cu_sp = ParseCompileUnit(llvm::cast<DWARFCompileUnit>(dwarf_cu));
   }
   return cu_sp;
 }
 
 Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
                                          const DWARFDIE &die) {
   ASSERT_MODULE_LOCK(this);
   if (die.IsValid()) {
if (die) {
 
     } else
       return type;
   }
   return nullptr;
 }
 
 CompileUnit *
-SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFUnit *dwarf_cu,
+SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFUnit *unit,
                                              uint32_t cu_idx) {
+  BuildLldbCuTranslationTable();
   // Check if the symbol vendor already knows about this compile unit?
-  if (dwarf_cu->GetUserData() == nullptr) {
-    // The symbol vendor doesn't know about this compile unit, we need to parse
-    // and add it to the symbol vendor object.
-    return ParseCompileUnit(dwarf_cu, cu_idx).get();
+  if (unit->GetUserData() == nullptr) {
+    if (auto *cu = llvm::dyn_cast<DWARFCompileUnit>(unit)) {
+      // The symbol vendor doesn't know about this compile unit, we need to
+      // parse and add it to the symbol vendor object.
+      return ParseCompileUnit(cu).get();
     }
-  return (CompileUnit *)dwarf_cu->GetUserData();
+  }
+  return (CompileUnit *)unit->GetUserData();
 }
 
 size_t SymbolFileDWARF::GetObjCMethodDIEOffsets(ConstString class_name,
                                                 DIEArray &method_die_offsets) {
   method_die_offsets.clear();
   m_index->GetObjCMethods(class_name, method_die_offsets);
   return method_die_offsets.size();
 }

 
 void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
   if (m_fetched_external_modules)
     return;
   m_fetched_external_modules = true;
 
   DWARFDebugInfo *debug_info = DebugInfo();
 
-  const uint32_t num_compile_units = GetNumCompileUnits();
+  const uint32_t num_compile_units = debug_info->GetNumUnits();
   for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
     DWARFUnit *dwarf_cu = debug_info->GetUnitAtIndex(cu_idx);
 
     const DWARFBaseDIE die = dwarf_cu->GetUnitDIEOnly();
     if (die && !die.HasChildren()) {
       const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
 
       if (name) {

 }
 
 TypeSP SymbolFileDWARF::GetTypeForDIE(const DWARFDIE &die,
                                       bool resolve_function_context) {
   TypeSP type_sp;
   if (die) {
     Type *type_ptr = GetDIEToType().lookup(die.GetDIE());
     if (type_ptr == nullptr) {
-      CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
-      assert(lldb_cu);
-      SymbolContext sc(lldb_cu);
+      SymbolContextScope *scope = GetCompUnitForDWARFCompUnit(die.GetCU());
+      if (!scope)
+        scope = GetObjectFile()->GetModule().get();
+      SymbolContext sc(scope);
       const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
       while (parent_die != nullptr) {
         if (parent_die->Tag() == DW_TAG_subprogram)
           break;
         parent_die = parent_die->GetParent();
       }
       SymbolContext sc_backup = sc;
       if (resolve_function_context && parent_die != nullptr &&

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

 #include "SymbolFileDWARF.h"
 
 class SymbolFileDWARFDwo : public SymbolFileDWARF {
 public:
   SymbolFileDWARFDwo(lldb::ObjectFileSP objfile, DWARFUnit *dwarf_cu);
 
   ~SymbolFileDWARFDwo() override = default;
 
-  lldb::CompUnitSP ParseCompileUnit(DWARFUnit *dwarf_cu,
-                                    uint32_t cu_idx) override;
+  lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit *dwarf_cu) override;
 
   DWARFUnit *GetCompileUnit();
 
   DWARFUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) override;
 
   lldb_private::DWARFExpression::LocationListFormat
   GetLocationListFormat() const override;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 //===-- SymbolFileDWARFDwo.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARFDwo.h"
 
 #include "lldb/Core/Section.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "llvm/Support/Casting.h"
 
-#include "DWARFUnit.h"
+#include "DWARFCompileUnit.h"
 #include "DWARFDebugInfo.h"
+#include "DWARFUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SymbolFileDWARFDwo::SymbolFileDWARFDwo(ObjectFileSP objfile,
                                        DWARFUnit *dwarf_cu)
     : SymbolFileDWARF(objfile.get(), objfile->GetSectionList(
                                          /*update_module_section_list*/ false)),
if (section_sp) {
       data.Clear();
     }
   }
 
   SymbolFileDWARF::LoadSectionData(sect_type, data);
 }
 
 lldb::CompUnitSP
-SymbolFileDWARFDwo::ParseCompileUnit(DWARFUnit *dwarf_cu,
-                                     uint32_t cu_idx) {
+SymbolFileDWARFDwo::ParseCompileUnit(DWARFCompileUnit *dwarf_cu) {
   assert(GetCompileUnit() == dwarf_cu && "SymbolFileDWARFDwo::ParseCompileUnit "
                                          "called with incompatible compile "
                                          "unit");
-  return GetBaseSymbolFile()->ParseCompileUnit(m_base_dwarf_cu, UINT32_MAX);
+  return GetBaseSymbolFile()->ParseCompileUnit(
+      llvm::cast<DWARFCompileUnit>(m_base_dwarf_cu));
 }
 
 DWARFUnit *SymbolFileDWARFDwo::GetCompileUnit() {
   // Only dwo files with 1 compile unit is supported
   if (GetNumCompileUnits() == 1)
     return DebugInfo()->GetUnitAtIndex(0);
   else
     return nullptr;