[lldb] DWZ 13/17: Main functionality

[jankratochvil]

My question about upstreaming of this patchset.

[jankratochvil]

I will be no longer involved with this patchset.

lldb/include/lldb/Utility/ConstString.h

public:
   /// Reports the size in bytes of all shared C string values, containers and
   /// any other values as a byte size for the entire string pool.
   ///
   /// \return
   ///     The number of bytes that the global string pool occupies
   ///     in memory.
   static size_t StaticMemorySize();
 
+  class Hasher {
+  public:
+    size_t operator()(const ConstString &key) const {
+      // https://stackoverflow.com/questions/7666509/hash-function-for-string
+      size_t hash = 5381;
+      for (const char *p = key.m_string; *p; ++p)
+        hash = hash * 33 + static_cast<uint8_t>(*p);
+      return hash;
+    }
+  };
+
 protected:
   template <typename T> friend struct ::llvm::DenseMapInfo;
   /// Only used by DenseMapInfo.
   static ConstString FromStringPoolPointer(const char *ptr) {
     ConstString s;
     s.m_string = ptr;
     return s;
   };

lldb/include/lldb/Utility/FileSpec.h

public:
   /// parent. When the current path has no parent, this is a no-op.
   ///
   /// \return
   ///     A boolean value indicating whether the path was updated.
   bool RemoveLastPathComponent();
 
   ConstString GetLastPathComponent() const;
 
+  class Hasher {
+  public:
+    size_t operator()(const FileSpec &key) const {
+      return (ConstString::Hasher()(key.m_directory) << 16) ^
+             ConstString::Hasher()(key.m_filename) ^ key.m_is_resolved;
+    }
+  };
+
 protected:
   friend struct llvm::yaml::MappingTraits<FileSpec>;
 
   // Convenience method for setting the file without changing the style.
   void SetFile(llvm::StringRef path);
 
   // Member variables
   ConstString m_directory;            ///< The uniqued directory path

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

add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   DWARFUnit.cpp
   DWARFUnitPair.cpp
   HashedNameToDIE.cpp
   LogChannelDWARF.cpp
   ManualDWARFIndex.cpp
   NameToDIE.cpp
   SymbolFileDWARF.cpp
   SymbolFileDWARFDwo.cpp
+  SymbolFileDWARFDwz.cpp
   SymbolFileDWARFDebugMap.cpp
   UniqueDWARFASTType.cpp
 
   LINK_LIBS
     lldbCore
     lldbExpression
     lldbHost
     lldbInterpreter

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

llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef() const {
   if (GetCU()->GetSymbolFileDWARF().GetDwoNum().hasValue())
     main_unit = nullptr;
   if (GetCU().GetCU() == main_unit)
     main_unit = nullptr;
 
   return DIERef(
       m_cu->GetSymbolFileDWARF().GetDwoNum(),
       (!main_unit ? llvm::None : llvm::Optional<uint32_t>(main_unit->GetID())),
-      DIERef::MainDwz, m_cu->GetDebugSection(), m_die->GetOffset());
+      GetCU()->GetSymbolFileDWARF().GetIsDwz() ? DIERef::CommonDwz
+                                               : DIERef::MainDwz,
+      m_cu->GetDebugSection(), m_die->GetOffset());
 }
 
 dw_tag_t DWARFBaseDIE::Tag() const {
   if (m_die)
     return m_die->Tag();
   else
     return llvm::dwarf::DW_TAG_null;
 }

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

public:
   DWARFDIE GetDIE(dw_offset_t die_offset) {
     return DWARFUnit::GetDIE(this, die_offset);
   }
 
   DWARFBaseDIE GetUnitDIEOnly() { return {DWARFUnitPair(this), DIEPtr()}; }
 
   DWARFDIE DIE() { return {DWARFUnitPair(this), DIEPtr()}; }
 
+  static DWARFCompileUnit *GetMainUnit(const lldb_private::SymbolContext &sc,
+                                       SymbolFileDWARF **dwarf_return);
+  static DWARFCompileUnit *GetMainUnit(lldb_private::CompileUnit &comp_unit,
+                                       SymbolFileDWARF **dwarf_return);
+
 private:
   DWARFCompileUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
                    const DWARFUnitHeader &header,
                    const DWARFAbbreviationDeclarationSet &abbrevs,
                    DIERef::Section section, bool is_dwo)
       : DWARFUnit(dwarf, uid, header, abbrevs, section, is_dwo) {}
 
   DWARFCompileUnit(const DWARFCompileUnit &) = delete;
   const DWARFCompileUnit &operator=(const DWARFCompileUnit &) = delete;
 
+  static DWARFCompileUnit *GetMainUnit(lldb_private::Module &module,
+                                       lldb_private::CompileUnit *comp_unit,
+                                       SymbolFileDWARF **dwarf_return);
+
   friend class DWARFUnit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFCOMPILEUNIT_H

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

 //===-- DWARFCompileUnit.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAranges.h"
 #include "SymbolFileDWARFDebugMap.h"
 
+#include "lldb/Core/Module.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 void DWARFCompileUnit::Dump(Stream *s) const {
void DWARFCompileUnit::BuildAddressRangeTable(
   // order to produce a compile unit level set of address ranges that is
   // accurate.
 
   size_t num_debug_aranges = debug_aranges->GetNumRanges();
 
   // First get the compile unit DIE only and check contains ranges information.
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
 
+  // DWZ partial units never contain any PC.
+  if (die && die->Tag() == DW_TAG_partial_unit)
+    return;
+
   const dw_offset_t cu_offset = GetOffset();
   if (die) {
     DWARFRangeList ranges;
     // It does not make sense to build address table for DW_TAG_partial_unit as
     // those never contain any addresses.
     const size_t num_ranges =
         die->GetAttributeAddressRanges(this, ranges, /*check_hi_lo_pc=*/true);
     if (num_ranges > 0) {
if (DIE()) {
     const DWARFDebugAranges &func_aranges = GetFunctionAranges();
 
     // Re-check the aranges auto pointer contents in case it was created above
     if (!func_aranges.IsEmpty())
       return GetDIE(func_aranges.FindAddress(address));
   }
   return DWARFDIE();
 }
+
+DWARFCompileUnit *
+DWARFCompileUnit::GetMainUnit(Module &module, CompileUnit *comp_unit,
+                              SymbolFileDWARF **dwarf_return) {
+  SymbolFile *symfile = module.GetSymbolFile();
+  SymbolFileDWARF *dwarf;
+  if (auto *debug_map_symfile =
+          llvm::dyn_cast<SymbolFileDWARFDebugMap>(symfile)) {
+    lldbassert(comp_unit);
+    dwarf = debug_map_symfile->GetSymbolFile(*comp_unit);
+  } else {
+    dwarf = llvm::dyn_cast<SymbolFileDWARF>(symfile);
+    lldbassert(dwarf);
+  }
+  if (dwarf_return)
+    *dwarf_return = dwarf;
+  if (!comp_unit) {
+    lldbassert(dwarf_return);
+    return nullptr;
+  }
+  return dwarf->GetDWARFCompileUnit(comp_unit);
+}
+
+DWARFCompileUnit *
+DWARFCompileUnit::GetMainUnit(CompileUnit &comp_unit,
+                              SymbolFileDWARF **dwarf_return) {
+  ModuleSP module_sp = comp_unit.CalculateSymbolContextModule();
+  lldbassert(module_sp);
+  return GetMainUnit(*module_sp, &comp_unit, dwarf_return);
+}
+
+DWARFCompileUnit *
+DWARFCompileUnit::GetMainUnit(const SymbolContext &sc,
+                              SymbolFileDWARF **dwarf_return) {
+  lldbassert(sc.module_sp);
+  return GetMainUnit(*sc.module_sp, sc.comp_unit, dwarf_return);
+}

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

 
 #include "DWARFCompileUnit.h"
 #include "DWARFContext.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFFormValue.h"
 #include "DWARFTypeUnit.h"
+#include "SymbolFileDWARFDwz.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 // Constructor
 DWARFDebugInfo::DWARFDebugInfo(SymbolFileDWARF &dwarf,
                                lldb_private::DWARFContext &context)
     : m_dwarf(dwarf), m_context(context), m_units(), m_cu_aranges_up() {}
 
 const DWARFDebugAranges &DWARFDebugInfo::GetCompileUnitAranges() {
   if (m_cu_aranges_up)
     return *m_cu_aranges_up;
 
+  lldbassert(!m_dwarf.GetIsDwz());
+
   m_cu_aranges_up = std::make_unique<DWARFDebugAranges>();
   const DWARFDataExtractor &debug_aranges_data =
       m_context.getOrLoadArangesData();
 
   // Extract what we can from the .debug_aranges first.
   m_cu_aranges_up->extract(debug_aranges_data);
 
   // Make a list of all CUs represented by the .debug_aranges data.
if (result && result->GetOffset() != cu_offset) {
     idx = DW_INVALID_INDEX;
   }
   if (idx_ptr)
     *idx_ptr = idx;
   return result;
 }
 
 DWARFUnit *DWARFDebugInfo::GetUnit(const DIERef &die_ref) {
+  bool dwz_common =
+      die_ref.main_cu() && die_ref.dwz_common() == DIERef::CommonDwz;
+  if (dwz_common && !m_dwarf.GetIsDwz()) {
+    lldbassert(m_dwarf.GetDwzSymbolFile());
+    return m_dwarf.GetDwzSymbolFile()->DebugInfo().GetUnit(die_ref);
+  }
+  lldbassert(dwz_common == m_dwarf.GetIsDwz());
   return GetUnitContainingDIEOffset(die_ref.section(), die_ref.die_offset());
 }
 
 DWARFUnit *DWARFDebugInfo::GetMainUnit(const DIERef &die_ref) {
-  return GetUnit(die_ref);
+  DWARFUnit *main_unit;
+  if (!die_ref.main_cu())
+    main_unit = GetUnit(die_ref);
+  else
+    main_unit = GetUnitAtIndex(*m_dwarf.GetDWARFUnitIndex(*die_ref.main_cu()));
+  lldbassert(!main_unit->GetSymbolFileDWARF().GetIsDwz());
+  return main_unit;
 }
 
 DWARFUnit *
 DWARFDebugInfo::GetUnitContainingDIEOffset(DIERef::Section section,
                                            dw_offset_t die_offset) {
   uint32_t idx = FindUnitIndex(section, die_offset);
   DWARFUnit *result = GetUnitAtIndex(idx);
   if (result && !result->ContainsDIEOffset(die_offset))

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

else {
           form_size = cu->GetAddressByteSize();
           break;
         case DW_FORM_ref_addr:
           if (cu->GetVersion() <= 2)
             form_size = cu->GetAddressByteSize();
           else
             form_size = 4;
           break;
+        case DW_FORM_GNU_ref_alt:
+          form_size = 4;
+          break;
 
         // 0 sized form
         case DW_FORM_flag_present:
           form_size = 0;
           break;
 
         // 1 byte values
         case DW_FORM_addrx1:
else {
 
         case DW_FORM_indirect:
           form_is_indirect = true;
           form = data.GetULEB128(&offset);
           break;
 
         case DW_FORM_strp:
         case DW_FORM_line_strp:
+        case DW_FORM_GNU_strp_alt:
         case DW_FORM_sec_offset:
           data.GetU32(&offset);
           break;
 
         case DW_FORM_implicit_const:
           form_size = 0;
           break;
 

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

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
 #include "DWARFSimpleDIE.h"
 #include "DWARFUnit.h"
+#include "SymbolFileDWARFDwz.h"
 
 class DWARFUnit;
 
 using namespace lldb_private;
 
 void DWARFFormValue::Clear() {
   m_unit = nullptr;
   m_form = 0;
case DW_FORM_string:
       m_value.value.cstr = data.GetCStr(offset_ptr);
       break;
     case DW_FORM_sdata:
       m_value.value.sval = data.GetSLEB128(offset_ptr);
       break;
     case DW_FORM_strp:
     case DW_FORM_line_strp:
     case DW_FORM_sec_offset:
+    case DW_FORM_GNU_strp_alt:
       m_value.value.uval = data.GetMaxU64(offset_ptr, 4);
       break;
     case DW_FORM_addrx1:
     case DW_FORM_strx1:
     case DW_FORM_ref1:
     case DW_FORM_data1:
     case DW_FORM_flag:
       m_value.value.uval = data.GetU8(offset_ptr);
do {
     case DW_FORM_ref_addr:
       assert(m_unit);
       if (m_unit->GetVersion() <= 2)
         ref_addr_size = m_unit->GetAddressByteSize();
       else
         ref_addr_size = 4;
       m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
       break;
+    case DW_FORM_GNU_ref_alt:
+      assert(m_unit);
+      ref_addr_size = 4;
+      m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
+      break;
     case DW_FORM_indirect:
       m_form = data.GetULEB128(offset_ptr);
       indirect = true;
       break;
     case DW_FORM_flag_present:
       m_value.value.uval = 1;
       break;
     default:
assert(unit); // Unit must be valid for DW_FORM_ref_addr objects or we will
                   // get this wrong
     if (unit->GetVersion() <= 2)
       ref_addr_size = unit->GetAddressByteSize();
     else
       ref_addr_size = 4;
     *offset_ptr += ref_addr_size;
     return true;
 
+  case DW_FORM_GNU_ref_alt:
+    ref_addr_size = 4;
+    *offset_ptr += ref_addr_size;
+    return true;
+
   // 0 bytes values (implied from DW_FORM)
   case DW_FORM_flag_present:
   case DW_FORM_implicit_const:
     return true;
 
     // 1 byte values
     case DW_FORM_addrx1:
     case DW_FORM_data1:
case DW_FORM_implicit_const:
     case DW_FORM_strx3:
       *offset_ptr += 3;
       return true;
 
     // 32 bit for DWARF 32, 64 for DWARF 64
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
     case DW_FORM_line_strp:
+    case DW_FORM_GNU_strp_alt:
       *offset_ptr += 4;
       return true;
 
     // 4 byte values
     case DW_FORM_addrx4:
     case DW_FORM_data4:
     case DW_FORM_ref4:
     case DW_FORM_strx4:
case DW_FORM_ref4:
     unit_relative_offset = true;
     break;
   case DW_FORM_ref8:
     unit_relative_offset = true;
     break;
   case DW_FORM_ref_udata:
     unit_relative_offset = true;
     break;
+  case DW_FORM_GNU_ref_alt:
+    DumpAddress(s.AsRawOstream(), uvalue, 4 * 2);
+    break;
 
   // All DW_FORM_indirect attributes should be resolved prior to calling this
   // function
   case DW_FORM_indirect:
     s.PutCString("DW_FORM_indirect");
     break;
   case DW_FORM_flag_present:
     break;
if (m_form == DW_FORM_GNU_str_index || m_form == DW_FORM_strx ||
     if (!offset)
       return nullptr;
     return context.getOrLoadStrData().PeekCStr(*offset);
   }
 
   if (m_form == DW_FORM_line_strp)
     return context.getOrLoadLineStrData().PeekCStr(m_value.value.uval);
 
+  if (m_form == DW_FORM_GNU_strp_alt) {
+    SymbolFileDWARFDwz *dwz_symbol_file =
+        m_unit->GetSymbolFileDWARF().GetDwzSymbolFile();
+    if (!dwz_symbol_file) {
+      m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
+          "String reference to DWZ offset 0x%8.8" PRIx64
+          " is in a file without associated DWZ common file",
+          m_value.value.uval);
+      return nullptr;
+    }
+    return dwz_symbol_file->GetDWARFContext().getOrLoadStrData().PeekCStr(
+        m_value.value.uval);
+  }
+
   return nullptr;
 }
 
 dw_addr_t DWARFFormValue::Address() const {
   SymbolFileDWARF &symbol_file = m_unit->GetSymbolFileDWARF();
 
   if (m_form == DW_FORM_addr)
     return Unsigned();
DWARFSimpleDIE DWARFFormValue::Reference() const {
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata: {
     assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
                     // unit relative or we will get this wrong
+    // The offset adjustment is already appropriate inside this CU.
     value += m_unit->GetOffset();
     if (!m_unit->ContainsDIEOffset(value)) {
       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
           "DW_FORM_ref* DIE reference 0x%" PRIx64 " is outside of its CU",
           value);
       return {};
     }
     DWARFUnit *cu = const_cast<DWARFUnit *>(m_unit);
     return {cu, cu->GetDIEPtr(value)};
   }
 
+  case DW_FORM_GNU_ref_alt: {
+    assert(m_unit);
+    SymbolFileDWARF &symbol_file = m_unit->GetSymbolFileDWARF();
+    if (symbol_file.GetIsDwz())
+      symbol_file.GetObjectFile()->GetModule()->ReportError(
+          "DW_FORM_GNU_ref_alt to DWZ offset 0x%8.8" PRIx64
+          " is in a DWZ common file itself",
+          value);
+    else if (!symbol_file.GetDwzSymbolFile()) {
+      symbol_file.GetObjectFile()->GetModule()->ReportError(
+          "DW_FORM_GNU_ref_alt to DWZ offset 0x%8.8" PRIx64
+          " has no DWZ common file",
+          value);
+      return {};
+    }
+    SymbolFileDWARF *target_symbol_file = &symbol_file;
+    if (!target_symbol_file->GetIsDwz()) {
+      target_symbol_file = symbol_file.GetDwzSymbolFile();
+      if (!target_symbol_file) {
+        symbol_file.GetObjectFile()->GetModule()->ReportError(
+            "There is Reference to DWZ offset 0x%8.8" PRIx64
+            " but the DWZ common file is missing",
+            value);
+        return {};
+      }
+    }
+    lldbassert(target_symbol_file->GetIsDwz());
+    DWARFDebugInfo &target_debuginfo = target_symbol_file->DebugInfo();
+    DWARFUnit *target_cu = target_debuginfo.GetUnitContainingDIEOffset(
+        DIERef::Section::DebugInfo, value);
+    if (!target_cu) {
+      symbol_file.GetObjectFile()->GetModule()->ReportError(
+          "There is Reference to DWZ offset 0x%8.8" PRIx64
+          " but the DWZ common file does not contain a unit for that offset",
+          value);
+      return {};
+    }
+    return target_cu->GetDIE(const_cast<DWARFUnit *>(m_unit), value);
+  }
+
   case DW_FORM_ref_addr: {
+    assert(m_unit);
     DWARFUnit *ref_cu =
         m_unit->GetSymbolFileDWARF().DebugInfo().GetUnitContainingDIEOffset(
             DIERef::Section::DebugInfo, value);
     if (!ref_cu) {
       m_unit->GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
           "DW_FORM_ref_addr DIE reference 0x%" PRIx64 " has no matching CU",
           value);
       return {};
switch (form) {
     case DW_FORM_indirect:
     case DW_FORM_sec_offset:
     case DW_FORM_exprloc:
     case DW_FORM_flag_present:
     case DW_FORM_ref_sig8:
     case DW_FORM_GNU_str_index:
     case DW_FORM_GNU_addr_index:
     case DW_FORM_implicit_const:
+    case DW_FORM_GNU_ref_alt:
+    case DW_FORM_GNU_strp_alt:
       return true;
     default:
       break;
   }
   return false;
 }

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

public:
 
   static bool classof(const DWARFUnit *unit) { return unit->IsTypeUnit(); }
 
 private:
   DWARFTypeUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
                 const DWARFUnitHeader &header,
                 const DWARFAbbreviationDeclarationSet &abbrevs,
                 DIERef::Section section, bool is_dwo)
-      : DWARFUnit(dwarf, uid, header, abbrevs, section, is_dwo) {}
+      : DWARFUnit(dwarf, uid, header, abbrevs, section, is_dwo) {
+    assert(!dwarf.GetIsDwz());
+  }
 
   friend class DWARFUnit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFTYPEUNIT_H

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

 
 uint32_t DWARFUnit::GetProducerVersionUpdate() {
   if (m_producer_version_update == 0)
     ParseProducerInfo();
   return m_producer_version_update;
 }
 
 uint64_t DWARFUnit::GetDWARFLanguageType() {
+  lldbassert(!GetSymbolFileDWARF().GetIsDwz());
+
   if (m_language_type)
     return *m_language_type;
 
   const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
   if (!die)
     m_language_type = 0;
   else
     m_language_type = die->GetAttributeValueAsUnsigned(this, DW_AT_language, 0);

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

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

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

 }
 
 llvm::Optional<DIERef>
 DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
   llvm::Optional<uint64_t> cu_offset = entry.getCUOffset();
   if (!cu_offset)
     return llvm::None;
 
+  // FIXME: .debug_names have no DWZ support yet.
   DWARFUnit *cu = m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, *cu_offset);
   if (!cu)
     return llvm::None;
 
   cu = &cu->GetNonSkeletonUnit();
   if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
     // FIXME: .debug_names have no DWZ support yet.
     return DIERef(cu->GetSymbolFileDWARF().GetDwoNum(), llvm::None,
for (const DebugNames::Entry &entry :
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
     llvm::Optional<DIERef> ref = ToDIERef(entry);
     if (!ref)
       continue;
 
+    // FIXME: .debug_names have no DWZ support yet.
     DWARFUnit *cu = m_debug_info.GetUnit(*ref);
     if (!cu || !cu->Supports_DW_AT_APPLE_objc_complete_type()) {
       incomplete_types.push_back(*ref);
       continue;
     }
 
     DWARFDIE die = m_debug_info.GetDIE(*ref);
     if (!die) {

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

 //===-- ManualDWARFIndex.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/ManualDWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
+#include "Plugins/SymbolFile/DWARF/DWARFSimpleDIE.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Progress.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 #include "llvm/Support/FormatVariadic.h"
void ManualDWARFIndex::Index() {
   pool.wait();
 }
 
 void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp,
                                  IndexSet &set) {
   // DWZ DW_TAG_partial_unit will get indexed by DW_AT_import
   // from its DW_TAG_compile_unit (possibly transitively).
   // Try to prevent GetUnitDIEOnly() which is expensive.
+  if (unit.GetSymbolFileDWARF().GetIsDwz())
+    return;
   if (unit.GetUnitDIEOnly().Tag() == DW_TAG_partial_unit)
     return;
   IndexUnit(&unit, dwp, set);
 }
 
 void ManualDWARFIndex::IndexUnit(DWARFUnitPair unit, SymbolFileDWARFDwo *dwp,
                                  IndexSet &set) {
   // Are we called for DW_TAG_compile_unit (contrary to DW_TAG_partial_unit)?
   if (unit.GetMainCU() == unit.GetCU()) {
     // DWZ DW_TAG_partial_unit will get indexed by DW_AT_import
     // from its DW_TAG_compile_unit (possibly transitively).
     // GetUnitDIEPtrOnly() is too expensive.
+    if (unit->GetSymbolFileDWARF().GetIsDwz())
+      return;
     if (unit->GetUnitDIEOnly().Tag() == DW_TAG_partial_unit)
       return;
   }
 
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS);
 
   if (log) {
     m_module.LogMessage(log,
                         "ManualDWARFIndex::IndexUnit for unit at "
                         ".debug_info[0x%8.8x] from .debug_info[0x%8.8x]",
                         unit->GetOffset(), unit.GetMainCU()->GetOffset());
   }
 
+  // DWZ DW_TAG_partial_unit will get indexed through DW_TAG_imported_unit from
+  // its main DW_TAG_compile_unit (possibly transitively). Indexing it
+  // standalone is not possible as we would not have its main CU. Also try to
+  // prevent calling GetUnitDIEOnly() which may be expensive.
+  if (unit->GetSymbolFileDWARF().GetIsDwz())
+    return;
+  if (unit->GetUnitDIEOnly().Tag() == DW_TAG_partial_unit)
+    return;
+
   IndexUnitImpl(unit, set);
 
   if (SymbolFileDWARFDwo *dwo_symbol_file = unit->GetDwoSymbolFile()) {
     // Type units in a dwp file are indexed separately, so we just need to
     // process the split unit here. However, if the split unit is in a dwo file,
     // then we need to process type units here.
     if (dwo_symbol_file == dwp) {
       IndexUnitImpl(&unit->GetNonSkeletonUnit(), set);
for (const DWARFDebugInfoEntry &die : unit.dies()) {
     case DW_TAG_string_type:
     case DW_TAG_structure_type:
     case DW_TAG_subprogram:
     case DW_TAG_subroutine_type:
     case DW_TAG_typedef:
     case DW_TAG_union_type:
     case DW_TAG_unspecified_type:
     case DW_TAG_variable:
+    case DW_TAG_imported_unit:
       break;
 
     default:
       continue;
     }
 
     DWARFAttributes attributes;
     const char *name = nullptr;
     const char *mangled_cstr = nullptr;
     bool is_declaration = false;
     // bool is_artificial = false;
     bool has_address = false;
     bool has_location_or_const_value = false;
     bool is_global_or_static_variable = false;
 
-    DWARFFormValue specification_die_form;
+    DWARFFormValue specification_die_form, import_die_form;
     const size_t num_attributes = die.GetAttributes(&unit, attributes);
     if (num_attributes > 0) {
       for (uint32_t i = 0; i < num_attributes; ++i) {
         dw_attr_t attr = attributes.AttributeAtIndex(i);
         DWARFFormValue form_value;
         switch (attr) {
         case DW_AT_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
if (num_attributes > 0) {
           is_global_or_static_variable = die.IsGlobalOrStaticScopeVariable();
 
           break;
 
         case DW_AT_specification:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             specification_die_form = form_value;
           break;
+
+        case DW_AT_import:
+          if (attributes.ExtractFormValueAtIndex(i, form_value))
+            import_die_form = form_value;
+          break;
         }
       }
     }
 
     DIERef ref = *DWARFDIE(unitpair, &die).GetDIERef();
     switch (tag) {
     case DW_TAG_inlined_subroutine:
     case DW_TAG_subprogram:
case DW_TAG_variable:
         // entries
         if (mangled_cstr && name != mangled_cstr &&
             ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) {
           set.globals.Insert(ConstString(mangled_cstr), ref);
         }
       }
       break;
 
+    case DW_TAG_imported_unit:
+      if (import_die_form.IsValid()) {
+        // DWZ is using DW_TAG_imported_unit only at the top level of CUs.
+        // Therefore GetParent() of any top level DIE in partial unit is always
+        // DW_TAG_compile_unit (possibly after multiple import levels).
+        const DWARFDebugInfoEntry *parent_die = die.GetParent();
+        if (!parent_die || (parent_die->Tag() != DW_TAG_compile_unit &&
+                            parent_die->Tag() != DW_TAG_partial_unit)) {
+          unit.GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
+              "CU 0x%8.8" PRIx32 " DIE 0x%8.8" PRIx32
+              " DW_TAG_imported_unit does not have DW_TAG_compile_unit"
+              " as its parent",
+              unit.GetOffset(), die.GetOffset());
+          break;
+        }
+        DWARFSimpleDIE import_die = import_die_form.Reference();
+        if (!import_die.IsValid())
+          break;
+        DWARFUnit *import_cu = import_die.GetCU();
+        dw_offset_t import_cu_firstdie_offset = import_cu->GetFirstDIEOffset();
+        if (import_die.GetOffset() != import_cu_firstdie_offset) {
+          unit.GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
+              "CU 0x%8.8" PRIx32 " DIE 0x%8.8" PRIx32
+              " DW_TAG_imported_unit of DIE 0x%16.16" PRIx32
+              " is not the target CU first DIE 0x%8.8" PRIx32,
+              unit.GetOffset(), die.GetOffset(), import_die.GetOffset(),
+              import_cu_firstdie_offset);
+          break;
+        }
+        IndexUnitImpl({import_cu, unitpair.GetMainCU()}, set);
+      }
+      break;
+
     default:
       continue;
     }
   }
 }
 
 void ManualDWARFIndex::GetGlobalVariables(
     ConstString basename, llvm::function_ref<bool(DWARFDIE die)> callback) {

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

 //===-- NameToDIE.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "NameToDIE.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFUnit.h"
+#include "SymbolFileDWARFDwz.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
bool NameToDIE::Find(const RegularExpression &regex,
   return true;
 }
 
 void NameToDIE::FindAllEntriesForUnit(
     DWARFUnit &s_unit, llvm::function_ref<bool(DIERef ref)> callback) const {
   lldbassert(!s_unit.GetSymbolFileDWARF().GetDwoNum());
   const DWARFUnit &ns_unit = s_unit.GetNonSkeletonUnit();
   SymbolFileDWARF *ns_symfile = &ns_unit.GetSymbolFileDWARF();
+  lldbassert(!ns_symfile->GetIsDwz());
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     const DIERef &die_ref = m_map.GetValueAtIndexUnchecked(i);
     if (ns_unit.GetDebugSection() != die_ref.section())
       continue;
     if (die_ref.main_cu()) {
       DWARFDebugInfo &ns_info = ns_symfile->DebugInfo();
       DWARFUnit *die_main_unit = ns_info.GetUnitAtIndex(

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

 class DWARFDebugLine;
 class DWARFDebugRanges;
 class DWARFDeclContext;
 class DWARFFormValue;
 class DWARFTypeUnit;
 class SymbolFileDWARFDebugMap;
 class SymbolFileDWARFDwo;
 class SymbolFileDWARFDwp;
+class SymbolFileDWARFDwz;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type *)1)
 
 class SymbolFileDWARF : public lldb_private::SymbolFile,
                         public lldb_private::UserID {
   /// LLVM RTTI support.
   static char ID;
 
 public:
   /// LLVM RTTI support.
   /// \{
   bool isA(const void *ClassID) const override {
     return ClassID == &ID || SymbolFile::isA(ClassID);
   }
   static bool classof(const SymbolFile *obj) { return obj->isA(&ID); }
   /// \}
 
   friend class SymbolFileDWARFDebugMap;
   friend class SymbolFileDWARFDwo;
   friend class DebugMapModule;
   friend class DWARFCompileUnit;
   friend class DWARFDIE;
   friend class DWARFASTParserClang;
+  friend class SymbolFileDWARFDwz;
 
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static void DebuggerInitialize(lldb_private::Debugger &debugger);
 
public:
   static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die);
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   static lldb::LanguageType GetLanguage(DWARFUnit &unit);
   /// Same as GetLanguage() but reports all C++ versions as C++ (no version).
   static lldb::LanguageType GetLanguageFamily(DWARFUnit &unit);
 
+  SymbolFileDWARFDwz *GetDwzSymbolFile() const { return m_dwz_symfile; }
+  virtual bool GetIsDwz() const { return false; }
+
   llvm::Optional<uint32_t> GetDWARFUnitIndex(uint32_t cu_idx);
 
 protected:
   typedef llvm::DenseMap<DIERef, lldb_private::Type *> DIERefToTypePtr;
   typedef llvm::DenseMap<DIERef, lldb::VariableSP> DIERefToVariableSP;
   typedef llvm::DenseMap<DIERef, lldb::opaque_compiler_type_t>
       DIERefToClangType;
   typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
struct DecodedUID {
     DIERef ref;
   };
   llvm::Optional<DecodedUID> DecodeUID(lldb::user_id_t uid);
 
   void FindDwpSymbolFile();
 
   const lldb_private::FileSpecList &GetSharedUnitSupportFiles(DWARFUnit &tu);
 
+  SymbolFileDWARFDwz *m_dwz_symfile = nullptr;
+
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;
 
   llvm::once_flag m_dwp_symfile_once_flag;
   std::shared_ptr<SymbolFileDWARFDwo> m_dwp_symfile;
 
   lldb_private::DWARFContext m_context;
 

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

 #include "DWARFFormValue.h"
 #include "DWARFTypeUnit.h"
 #include "DWARFUnit.h"
 #include "DebugNamesDWARFIndex.h"
 #include "LogChannelDWARF.h"
 #include "ManualDWARFIndex.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
+#include "SymbolFileDWARFDwz.h"
 
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
: SymbolFile(std::move(objfile_sp)),
       UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
                                   // when this class parses .o files to
                                   // contain the .o file index/ID
       m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
       m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
       m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
-SymbolFileDWARF::~SymbolFileDWARF() = default;
+SymbolFileDWARF::~SymbolFileDWARF() {
+  if (m_dwz_symfile)
+    m_dwz_symfile->ClearForDWARF(*this);
+}
 
 static ConstString GetDWARFMachOSegmentName() {
   static ConstString g_dwarf_section_name("__DWARF");
   return g_dwarf_section_name;
 }
 
 UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile)
     return debug_map_symfile->GetUniqueDWARFASTTypeMap();
   else
     return m_unique_ast_type_map;
 }
 
 llvm::Expected<TypeSystem &>
 SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
+  lldbassert(!GetIsDwz());
+
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeSystemForLanguage(language);
 
   auto type_system_or_err =
       m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
   if (type_system_or_err) {
     type_system_or_err->SetSymbolFile(this);
   }
   return type_system_or_err;
 }
 
 void SymbolFileDWARF::InitializeObject() {
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
 
+  // DWZ needs to be already prepared for indexing below.
+  SymbolFileDWARFDwz::InitializeForDWARF(*this);
+
   if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
     StreamString module_desc;
     GetObjectFile()->GetModule()->GetDescription(module_desc.AsRawOstream(),
                                                  lldb::eDescriptionLevelBrief);
     DWARFDataExtractor apple_names, apple_namespaces, apple_types, apple_objc;
     LoadSectionData(eSectionTypeDWARFAppleNames, apple_names);
     LoadSectionData(eSectionTypeDWARFAppleNamespaces, apple_namespaces);
     LoadSectionData(eSectionTypeDWARFAppleTypes, apple_types);
const char *dwo_name =
       cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
   if (!dwo_name)
     dwo_name =
         cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_dwo_name, nullptr);
   return dwo_name;
 }
 
 lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) {
+  lldbassert(!GetIsDwz());
   CompUnitSP cu_sp;
   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.GetOffset() == 0 && GetDebugMapSymfile()) {
       // Let the debug map create the compile unit
support_files = ParseSupportFilesFromPrologue(
       module, prologue, dwarf_cu.GetPathStyle(),
       dwarf_cu.GetCompilationDirectory().GetCString());
 
   return true;
 }
 
 FileSpec SymbolFileDWARF::GetFile(DWARFUnit &unit, size_t file_idx) {
   if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
+    // Try to prevent GetUnitDIEOnly() which may be expensive.
+    if (!unit.GetSymbolFileDWARF().GetIsDwz() &&
+        unit.GetUnitDIEOnly().Tag() == DW_TAG_compile_unit) {
       if (CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(*dwarf_cu))
         return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
       return FileSpec();
     }
+  }
 
   return GetSharedUnitSupportFiles(unit).GetFileSpecAtIndex(file_idx);
 }
 
 const FileSpecList &
 SymbolFileDWARF::GetSharedUnitSupportFiles(DWARFUnit &unit) {
   static FileSpecList empty_list;
 
if (type_system != nullptr)
     type_system->GetDWARFParser()->EnsureAllDIEsInDeclContextHaveBeenParsed(
         decl_ctx);
 }
 
 user_id_t SymbolFileDWARF::GetUID(DIERef ref) {
   if (GetDebugMapSymfile())
     return GetID() | ref.die_offset();
 
+  lldbassert(!GetIsDwz());
+
 #ifndef NDEBUG
   DWARFDIE dwarfdie_check = GetDIE(ref);
   lldbassert(dwarfdie_check.IsValid());
   lldbassert(*dwarfdie_check.GetDIERef() == ref);
 #endif
 
   // WARNING: Use ref.dwo_num() as GetDwoNum() may not be valid in 'this'.
   static_assert(sizeof(ref.die_offset()) * 8 == 32, "");
DIERef::Section section =
       uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
 
   DIERef::Kind kind = DIERef::Kind(uid >> 61 & 3);
 
   llvm::Optional<uint32_t> dwo_num;
   if (kind == DIERef::Kind::DwoKind)
     dwo_num = uid >> 32 & 0x1fffffff;
 
-  return DecodedUID{
-      *this, {dwo_num, llvm::None, DIERef::MainDwz, section, die_offset}};
+  llvm::Optional<uint32_t> main_cu = uid >> 32 & 0x1fffffff;
+  if (kind != DIERef::Kind::MainDwzKind && kind != DIERef::Kind::DwzCommonKind)
+    main_cu = llvm::None;
+
+  return DecodedUID{*this,
+                    {dwo_num, main_cu,
+                     kind == DIERef::Kind::DwzCommonKind ? DIERef::CommonDwz
+                                                         : DIERef::MainDwz,
+                     section, die_offset}};
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIE(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
if (pos != m_external_type_modules.end())
     return pos->second;
   else
     return lldb::ModuleSP();
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
   if (die_ref.dwo_num()) {
+    lldbassert(!GetIsDwz());
+    lldbassert(!GetDwzSymbolFile());
     SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x1fffffff
                                  ? m_dwp_symfile.get()
                                  : this->DebugInfo()
                                        .GetUnitAtIndex(*die_ref.dwo_num())
                                        ->GetDwoSymbolFile();
     return dwarf->DebugInfo().GetDIE(die_ref);
   }
 
LanguageType SymbolFileDWARF::LanguageTypeFromDWARF(uint64_t val) {
   case DW_LANG_GOOGLE_RenderScript:
     return eLanguageTypeExtRenderScript;
   default:
     return static_cast<LanguageType>(val);
   }
 }
 
 LanguageType SymbolFileDWARF::GetLanguage(DWARFUnit &unit) {
+  // Caller should have called GetMainCU().
+  lldbassert(unit.GetUnitDIEOnly().Tag() != DW_TAG_partial_unit);
   return LanguageTypeFromDWARF(unit.GetDWARFLanguageType());
 }
 
 LanguageType SymbolFileDWARF::GetLanguageFamily(DWARFUnit &unit) {
   auto lang = (llvm::dwarf::SourceLanguage)unit.GetDWARFLanguageType();
   if (llvm::dwarf::isCPlusPlus(lang))
     lang = DW_LANG_C_plus_plus;
   return LanguageTypeFromDWARF(lang);
 }

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

+//===-- SymbolFileDWARFDwz.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 SymbolFileDWARFDwz_SymbolFileDWARFDwz_h_
+#define SymbolFileDWARFDwz_SymbolFileDWARFDwz_h_
+
+#include "SymbolFileDWARF.h"
+
+typedef std::unique_ptr<SymbolFileDWARFDwz> SymbolFileDWARFDwzUP;
+
+class SymbolFileDWARFDwz : public SymbolFileDWARF {
+public:
+  SymbolFileDWARFDwz(lldb::ObjectFileSP objfile, lldb::ModuleSP m_module);
+
+  bool GetIsDwz() const override { return true; }
+
+  static void InitializeForDWARF(SymbolFileDWARF &dwarf);
+
+  void ClearForDWARF(SymbolFileDWARF &dwarf);
+
+private:
+  void SetForDWARF(SymbolFileDWARF &dwarf);
+
+  size_t m_use_count = 0;
+  lldb::ModuleSP m_module;
+
+  SymbolFileDWARFDwz(const SymbolFileDWARFDwz &) = delete;
+  const SymbolFileDWARFDwz &operator=(const SymbolFileDWARFDwz &) = delete;
+};
+
+#endif // SymbolFileDWARFDwz_SymbolFileDWARFDwz_h_

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

+//===-- SymbolFileDWARFDwz.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 "SymbolFileDWARFDwz.h"
+#include "DWARFDebugInfo.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Utility/FileSpec.h"
+#include "llvm/ADT/PointerUnion.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SymbolFileDWARFDwz::SymbolFileDWARFDwz(ObjectFileSP objfile, ModuleSP module)
+    : SymbolFileDWARF(std::move(objfile), /*dwo_section_list*/ nullptr),
+      m_module(std::move(module)) {
+  InitializeObject();
+  // Call private DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded() as
+  // otherwise DWARFCompileUnit::GetAbbreviations() would have no data.
+  DebugInfo().GetNumUnits();
+}
+
+// C++20: Use heterogeneous lookup for unordered container instead.
+class DwzAsKey {
+public:
+  DwzAsKey(SymbolFileDWARFDwz &dwz) : ptr(&dwz) {}
+  DwzAsKey(FileSpec &fspec) : ptr(&fspec) {}
+  DwzAsKey() {}
+  SymbolFileDWARFDwz &GetDwz() const {
+    return *ptr.get<SymbolFileDWARFDwz *>();
+  }
+  FileSpec &GetFileSpec() const {
+    if (ptr.is<FileSpec *>())
+      return *ptr.get<FileSpec *>();
+    return GetDwz().GetObjectFile()->GetFileSpec();
+  }
+  bool operator==(const DwzAsKey &rhs) const {
+    return GetFileSpec() == rhs.GetFileSpec();
+  }
+  bool operator!=(const DwzAsKey &rhs) const { return !(*this == rhs); }
+  class Hasher {
+  public:
+    size_t operator()(const DwzAsKey &key) const {
+      return FileSpec::Hasher()(key.GetFileSpec());
+    }
+  };
+
+private:
+  llvm::PointerUnion<SymbolFileDWARFDwz *, FileSpec *> ptr;
+};
+
+static std::unordered_map<DwzAsKey, SymbolFileDWARFDwzUP, DwzAsKey::Hasher>
+    dwz_map;
+static llvm::sys::RWMutex dwz_map_mutex;
+
+void SymbolFileDWARFDwz::InitializeForDWARF(SymbolFileDWARF &dwarf) {
+  const DWARFDataExtractor &section_extractor(
+      dwarf.GetDWARFContext().getOrLoadGNUDebugAltLink());
+  if (section_extractor.GetByteSize() == 0)
+    return; // .gnu_debugaltlink does not exist
+  if (dwarf.GetIsDwz()) {
+    dwarf.GetObjectFile()->GetModule()->ReportWarning(
+        "Error reading DWZ common file - it does contain .gnu_debugaltlink");
+    return;
+  }
+  lldb::offset_t offset = 0;
+  const char *link_cstr(section_extractor.GetCStr(&offset));
+  if (!link_cstr) {
+    dwarf.GetObjectFile()->GetModule()->ReportWarning(
+        "Cannot get DWZ common file - missing section .gnu_debugaltlink");
+    return;
+  }
+  lldb::offset_t uuid_bytes_size = section_extractor.BytesLeft(offset);
+  const void *uuid_bytes(section_extractor.GetData(&offset, uuid_bytes_size));
+  if (!uuid_bytes) {
+    dwarf.GetObjectFile()->GetModule()->ReportWarning(
+        "Cannot get DWZ common file - missing build-id"
+        " in section .gnu_debugaltlink with string \"%s\"",
+        link_cstr);
+    return;
+  }
+  UUID link_uuid = UUID::fromOptionalData(uuid_bytes, uuid_bytes_size);
+  if (!link_uuid.IsValid()) {
+    dwarf.GetObjectFile()->GetModule()->ReportWarning(
+        "Cannot get DWZ common file - invalid build-id size %" PRIu64
+        " in section .gnu_debugaltlink with string \"%s\"",
+        uuid_bytes_size, link_cstr);
+    return;
+  }
+  // For objfile "/usr/lib/debug/usr/bin/true.debug"
+  // link_cstr is "../../.dwz/coreutils-8.25-17.fc25.x86_64".
+  ModuleSpec dwz_module_spec;
+  FileSpec &dwz_fspec = dwz_module_spec.GetFileSpec();
+  dwz_fspec = FileSpec(link_cstr);
+  dwz_fspec.PrependPathComponent(
+      dwarf.GetObjectFile()->GetFileSpec().CopyByRemovingLastPathComponent());
+  DwzAsKey dwz_fspec_lookup(dwz_fspec);
+  {
+    llvm::sys::ScopedReader lock(dwz_map_mutex);
+    const auto it = dwz_map.find(dwz_fspec_lookup);
+    if (it != dwz_map.end()) {
+      it->second->SetForDWARF(dwarf);
+      return;
+    }
+  }
+  dwz_module_spec.GetArchitecture() =
+      dwarf.GetObjectFile()->GetModule()->GetArchitecture();
+  ModuleSP dwz_module = std::make_shared<Module>(dwz_module_spec);
+  DataBufferSP dwz_file_data_sp;
+  lldb::offset_t dwz_file_data_offset = 0;
+  lldb::ObjectFileSP dwz_obj_file = ObjectFile::FindPlugin(
+      dwz_module, &dwz_fspec, 0, FileSystem::Instance().GetByteSize(dwz_fspec),
+      dwz_file_data_sp, dwz_file_data_offset);
+  if (!dwz_obj_file) {
+    dwarf.GetObjectFile()->GetModule()->ReportWarning(
+        "Cannot get DWZ common file - file \"%s\" cannot be opened",
+        dwz_fspec.GetCString());
+    return;
+  }
+  lldbassert(dwz_obj_file->GetFileSpec() == dwz_fspec);
+  UUID dwz_uuid = dwz_obj_file->GetUUID();
+  if (!dwz_uuid) {
+    dwarf.GetObjectFile()->GetModule()->ReportWarning(
+        "Cannot get DWZ common file - file \"%s\" does not have build-id",
+        dwz_fspec.GetCString());
+    return;
+  }
+  if (link_uuid != dwz_uuid) {
+    dwarf.GetObjectFile()->GetModule()->ReportWarning(
+        "Cannot get DWZ common file - expected build-id %s but file \"%s\""
+        " has build-id %s",
+        link_uuid.GetAsString().c_str(), dwz_fspec.GetCString(),
+        dwz_uuid.GetAsString().c_str());
+    return;
+  }
+  auto dwz_symbol_file =
+      std::make_unique<SymbolFileDWARFDwz>(dwz_obj_file, std::move(dwz_module));
+  assert(DwzAsKey(*dwz_symbol_file) == dwz_fspec_lookup);
+  {
+    llvm::sys::ScopedWriter lock(dwz_map_mutex);
+    const auto it = dwz_map.find(dwz_fspec_lookup);
+    if (it != dwz_map.end())
+      it->second->SetForDWARF(dwarf);
+    else {
+      dwz_symbol_file->SetForDWARF(dwarf);
+      const auto insertpair = dwz_map.emplace(DwzAsKey(*dwz_symbol_file),
+                                              std::move(dwz_symbol_file));
+      lldbassert(insertpair.second);
+    }
+  }
+}
+
+void SymbolFileDWARFDwz::SetForDWARF(SymbolFileDWARF &dwarf) {
+  lldbassert(&dwarf != this);
+  lldbassert(!dwarf.m_dwz_symfile);
+  dwarf.m_dwz_symfile = this;
+  ++m_use_count;
+}
+
+void SymbolFileDWARFDwz::ClearForDWARF(SymbolFileDWARF &main_dwarf) {
+  lldbassert(main_dwarf.m_dwz_symfile == this);
+  llvm::sys::ScopedWriter lock(dwz_map_mutex);
+  lldbassert(m_use_count);
+  if (--m_use_count)
+    return;
+  size_t erased = dwz_map.erase(DwzAsKey(*this));
+  lldbassert(erased == 1);
+}