[DWARF] Store compile unit IDs in the DIERef class

[labath]

Summary

The offset of a compile unit is enough to identify in a section, but
things start to get a lot more complicated when you have multiple object
files, each with potentially several debug-info-carrying sections
floating around.

We were already pushing this concept to its limits split-dwarf, which
required juggling offsets of several units to get things to work.
However, this really become a problem when we tried to introduce
debug_types support, which resulted in a long series of attempts to
"concatenate" various debug info sections so that the unit offset
remains a valid identifier.

Instead of attempting to assign unique offsets to all units that we care
about, this patch does something more fundamental. We just admit that
using offsets as unique identifiers does not scale to all debug info
formats we want to support, and uses a different ID instead.

Decoupling the ID from the offset means the offset can be free to point
to the actual offset of the compile unit in the relevant section,
without any changes to low-level parsing code needed. And using a
surrogate ID means its much easier to map the compile units into a
single address space. At least two strategies are possible after this
patch:
a) map all relevant units into a single continuous sequence of integers
(as if the were all stored in one vector)
b) steal some bits from the cu_idx field and use it as some sort of a
discriminator (essentially creating multiple address spaces)

Additionally, this makes us better prepared for the future, where the
total size of debug info exceeds 4GB. It also simplifies code, as we can
treat different debug info flavours more uniformly.

This patch:

• renames the cu_offset field of DIERef to cu_idx and fixes all uses to treat it as such
• removes DWARFUnit::GetBaseObjOffset as it no longer serves any useful purpose. Instead the DWO unit is made to share the ID of the "base" unit, as they logically represent a single compilation.
• changes SymbolFileDWARFDwo to use the index of the contained unit as its ID (this is the same approach taken by SymbolFileDWARFDebugMap).
• has a longer commit message than the code it changes. :)

[labath]

Fix two more things I noticed when looking at the patch in phab:

• incorrect use of unit offset in DIERef constructor in the DebugMap case (I'm guessing this didn't cause any test failures because both offsets and IDs are generally zero there).
• incorrect local variable name in ManualDWARFIndex (NFC)

[labath]

Hm... looking at @jankratochvil's patches, I realized that I completely omitted HashedNameToDIE from this patch (it used emplace_back to construct DIERefs, so it snuck past me). Thinking about it, I guess the best way to handle that would be to set the cu_idx to the invalid value for DIERefs created there, as the offset is sufficient to identify the die in those cases (which I guess is also the reason why all tests passed). That shouldn't impact the performance in any way as one way or the other one has to do a binary search to convert the offset into a DWARFUnit*. I'll try to update that on monday...

[labath]

My understanding of the DIERef class has evolved. I'm going to revise this approach a bit.

[labath]

Obsoleted by D61908.

source/Plugins/SymbolFile/DWARF/DIERef.h

 #include "lldb/lldb-defines.h"
 
 class DWARFFormValue;
 class SymbolFileDWARF;
 
 struct DIERef {
   DIERef() = default;
 
-  DIERef(dw_offset_t c, dw_offset_t d) : cu_offset(c), die_offset(d) {}
+  DIERef(dw_offset_t c, dw_offset_t d) : cu_idx(c), die_offset(d) {}
 
   // In order to properly decode a lldb::user_id_t back into a DIERef we
   // need the DWARF file since it knows if DWARF in .o files is being used
   // (MacOSX) or if DWO files are being used. The encoding of the user ID
   // differs between the two types of DWARF.
   explicit DIERef(lldb::user_id_t uid, SymbolFileDWARF *dwarf);
 
   explicit DIERef(const DWARFFormValue &form_value);
 
   // In order to properly encode a DIERef unto a lldb::user_id_t we need
   // the DWARF file since it knows if DWARF in .o files is being used
   // (MacOSX) or if DWO files are being used. The encoding of the user ID
   // differs between the two types of DWARF.
   lldb::user_id_t GetUID(SymbolFileDWARF *dwarf) const;
 
   bool operator<(const DIERef &ref) const {
     return die_offset < ref.die_offset;
   }
 
   bool operator<(const DIERef &ref) { return die_offset < ref.die_offset; }
 
   explicit operator bool() const {
-    return cu_offset != DW_INVALID_OFFSET || die_offset != DW_INVALID_OFFSET;
+    return cu_idx != DW_INVALID_OFFSET || die_offset != DW_INVALID_OFFSET;
   }
 
-  dw_offset_t cu_offset = DW_INVALID_OFFSET;
+  dw_offset_t cu_idx = DW_INVALID_OFFSET;
   dw_offset_t die_offset = DW_INVALID_OFFSET;
 };
 
 typedef std::vector<DIERef> DIEArray;
 
 #endif // SymbolFileDWARF_DIERef_h_

source/Plugins/SymbolFile/DWARF/DIERef.cpp

 //===-- DIERef.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 "DIERef.h"
 #include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 
 DIERef::DIERef(lldb::user_id_t uid, SymbolFileDWARF *dwarf)
-    : cu_offset(DW_INVALID_OFFSET), die_offset(uid & 0xffffffff) {
+    : die_offset(uid & 0xffffffff) {
   SymbolFileDWARFDebugMap *debug_map = dwarf->GetDebugMapSymfile();
   if (debug_map) {
     const uint32_t oso_idx = debug_map->GetOSOIndexFromUserID(uid);
     SymbolFileDWARF *actual_dwarf = debug_map->GetSymbolFileByOSOIndex(oso_idx);
     if (actual_dwarf) {
       DWARFDebugInfo *debug_info = actual_dwarf->DebugInfo();
       if (debug_info) {
         DWARFUnit *dwarf_cu =
             debug_info->GetCompileUnitContainingDIEOffset(die_offset);
         if (dwarf_cu) {
-          cu_offset = dwarf_cu->GetOffset();
+          cu_idx = dwarf_cu->GetID();
           return;
         }
       }
     }
     die_offset = DW_INVALID_OFFSET;
   } else {
-    cu_offset = uid >> 32;
+    cu_idx = uid >> 32;
   }
 }
 
-DIERef::DIERef(const DWARFFormValue &form_value)
-    : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {
+DIERef::DIERef(const DWARFFormValue &form_value) {
   if (form_value.IsValid()) {
     const DWARFUnit *dwarf_cu = form_value.GetCompileUnit();
-    if (dwarf_cu) {
-      if (dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
-        cu_offset = dwarf_cu->GetBaseObjOffset();
-      else
-        cu_offset = dwarf_cu->GetOffset();
-    }
+    if (dwarf_cu)
+      cu_idx = dwarf_cu->GetID();
     die_offset = form_value.Reference();
   }
 }
 
 lldb::user_id_t DIERef::GetUID(SymbolFileDWARF *dwarf) const {
   // Each SymbolFileDWARF will set its ID to what is expected.
   //
   // SymbolFileDWARF, when used for DWARF with .o files on MacOSX, has the
   // ID set to the compile unit index.
   //
   // SymbolFileDWARFDwo sets the ID to the compile unit offset.
   if (dwarf && die_offset != DW_INVALID_OFFSET)
     return dwarf->GetID() | die_offset;
   else
     return LLDB_INVALID_UID;
 }

source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

 #include "lldb/Symbol/ObjectFile.h"
 
 using namespace lldb_private;
 
 DIERef DWARFBaseDIE::GetDIERef() const {
   if (!IsValid())
     return DIERef();
 
-  dw_offset_t cu_offset = m_cu->GetOffset();
-  if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
-    cu_offset = m_cu->GetBaseObjOffset();
-  return DIERef(cu_offset, m_die->GetOffset());
+  return DIERef(m_cu->GetID(), m_die->GetOffset());
 }
 
 dw_tag_t DWARFBaseDIE::Tag() const {
   if (m_die)
     return m_die->Tag();
   else
     return 0;
 }

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

if (cu_offset != DW_INVALID_OFFSET) {
     }
   }
   if (idx_ptr)
     *idx_ptr = cu_idx;
   return cu_sp.get();
 }
 
 DWARFUnit *DWARFDebugInfo::GetCompileUnit(const DIERef &die_ref) {
-  if (die_ref.cu_offset == DW_INVALID_OFFSET)
+  if (die_ref.cu_idx == DW_INVALID_OFFSET)
     return GetCompileUnitContainingDIEOffset(die_ref.die_offset);
   else
-    return GetCompileUnitAtOffset(die_ref.cu_offset);
+    return GetCompileUnitAtIndex(die_ref.cu_idx);
 }
 
 DWARFUnit *
 DWARFDebugInfo::GetCompileUnitContainingDIEOffset(dw_offset_t die_offset) {
   ParseCompileUnitHeadersIfNeeded();
 
   DWARFUnitSP cu_sp;
 

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   dw_offset_t GetAbbrevOffset() const;
   uint8_t GetAddressByteSize() const { return m_addr_size; }
   dw_addr_t GetBaseAddress() const { return m_base_addr; }
   dw_addr_t GetAddrBase() const { return m_addr_base; }
   dw_addr_t GetRangesBase() const { return m_ranges_base; }
   dw_addr_t GetStrOffsetsBase() const { return m_str_offsets_base; }
   void SetAddrBase(dw_addr_t addr_base);
   void SetRangesBase(dw_addr_t ranges_base);
-  void SetBaseObjOffset(dw_offset_t base_obj_offset);
   void SetStrOffsetsBase(dw_offset_t str_offsets_base);
   void BuildAddressRangeTable(SymbolFileDWARF *dwarf,
                               DWARFDebugAranges *debug_aranges);
 
   lldb::ByteOrder GetByteOrder() const;
 
   lldb_private::TypeSystem *GetTypeSystem();
 
public:
 
   bool GetIsOptimized();
 
   const lldb_private::FileSpec &GetCompilationDirectory();
   lldb_private::FileSpec::Style GetPathStyle();
 
   SymbolFileDWARFDwo *GetDwoSymbolFile() const;
 
-  dw_offset_t GetBaseObjOffset() const;
-
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
 protected:
   DWARFUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid);
 
protected:
   uint32_t m_producer_version_update = 0;
   lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   llvm::Optional<lldb_private::FileSpec> m_comp_dir;
   dw_addr_t m_addr_base = 0;   // Value of DW_AT_addr_base
   dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
   // If this is a dwo compile unit this is the offset of the base compile unit
   // in the main object file
-  dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;
   dw_offset_t m_str_offsets_base = 0; // Value of DW_AT_str_offsets_base.
   // Offset of the initial length field.
   dw_offset_t m_offset;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

addr_base = cu_die.GetAttributeValueAsUnsigned(m_dwarf, this,
                                                    DW_AT_GNU_addr_base, 0);
   dwo_cu->SetAddrBase(addr_base);
 
   if (ranges_base == LLDB_INVALID_ADDRESS)
     ranges_base = cu_die.GetAttributeValueAsUnsigned(m_dwarf, this,
                                                      DW_AT_GNU_ranges_base, 0);
   dwo_cu->SetRangesBase(ranges_base);
 
-  dwo_cu->SetBaseObjOffset(m_offset);
+  dwo_cu->SetID(GetID());
 
   SetDwoStrOffsetsBase(dwo_cu);
 }
 
 DWARFDIE DWARFUnit::LookupAddress(const dw_addr_t address) {
   if (DIE()) {
     const DWARFDebugAranges &func_aranges = GetFunctionAranges();
 

 }
 
 void DWARFUnit::SetAddrBase(dw_addr_t addr_base) { m_addr_base = addr_base; }
 
 void DWARFUnit::SetRangesBase(dw_addr_t ranges_base) {
   m_ranges_base = ranges_base;
 }
 
-void DWARFUnit::SetBaseObjOffset(dw_offset_t base_obj_offset) {
-  m_base_obj_offset = base_obj_offset;
-}
-
 void DWARFUnit::SetStrOffsetsBase(dw_offset_t str_offsets_base) {
   m_str_offsets_base = str_offsets_base;
 }
 
 // It may be called only with m_die_array_mutex held R/W.
 void DWARFUnit::ClearDIEsRWLocked() {
   m_die_array.clear();
   m_die_array.shrink_to_fit();
m_comp_dir = FileSpec(
         "", FileSpec::GuessPathStyle(name).getValueOr(FileSpec::Style::native));
   }
 }
 
 SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const {
   return m_dwo_symbol_file.get();
 }
 
-dw_offset_t DWARFUnit::GetBaseObjOffset() const { return m_base_obj_offset; }
-
 const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() {
   if (m_func_aranges_up == NULL) {
     m_func_aranges_up.reset(new DWARFDebugAranges());
     const DWARFDebugInfoEntry *die = DIEPtr();
     if (die)
       die->BuildFunctionAddressRangeTable(m_dwarf, this,
                                           m_func_aranges_up.get());
 

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

DIERef DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
 
   // This initializes the DWO symbol file. It's not possible for
   // GetDwoSymbolFile to call this automatically because of mutual recursion
   // between this and DWARFDebugInfoEntry::GetAttributeValue.
   cu->ExtractUnitDIEIfNeeded();
   uint64_t die_bias = cu->GetDwoSymbolFile() ? 0 : *cu_offset;
 
   if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
-    return DIERef(*cu_offset, die_bias + *die_offset);
+    return DIERef(cu->GetID(), die_bias + *die_offset);
 
   return DIERef();
 }
 
 void DebugNamesDWARFIndex::Append(const DebugNames::Entry &entry,
                                   DIEArray &offsets) {
   if (DIERef ref = ToDIERef(entry))
     offsets.push_back(ref);
for (const DebugNames::Entry &entry :
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
     DIERef ref = ToDIERef(entry);
     if (!ref)
       continue;
 
-    DWARFUnit *cu = m_debug_info.GetCompileUnitAtOffset(ref.cu_offset);
+    DWARFUnit *cu = m_debug_info.GetCompileUnitAtIndex(ref.cu_idx);
     if (!cu || !cu->Supports_DW_AT_APPLE_objc_complete_type()) {
       incomplete_types.push_back(ref);
       continue;
     }
 
     // FIXME: We should return DWARFDIEs so we don't have to resolve it twice.
     DWARFDIE die = m_debug_info.GetDIE(ref);
     if (!die)

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h

struct IndexSet {
     NameToDIE namespaces;
   };
   void Index();
   void IndexUnit(DWARFUnit &unit, IndexSet &set);
 
   static void
   IndexUnitImpl(DWARFUnit &unit, const lldb::LanguageType cu_language,
                 const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
-                const dw_offset_t cu_offset, IndexSet &set);
+                IndexSet &set);
 
   /// Non-null value means we haven't built the index yet.
   DWARFDebugInfo *m_debug_info;
   /// Which dwarf units should we skip while building the index.
   llvm::DenseSet<dw_offset_t> m_units_to_avoid;
 
   IndexSet m_set;
 };
 } // namespace lldb_private
 
 #endif // LLDB_MANUALDWARFINDEX_H

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

if (log) {
     m_module.LogMessage(
         log, "ManualDWARFIndex::IndexUnit for compile unit at .debug_info[0x%8.8x]",
         unit.GetOffset());
   }
 
   const LanguageType cu_language = unit.GetLanguageType();
   DWARFFormValue::FixedFormSizes fixed_form_sizes = unit.GetFixedFormSizes();
 
-  IndexUnitImpl(unit, cu_language, fixed_form_sizes, unit.GetOffset(), set);
+  IndexUnitImpl(unit, cu_language, fixed_form_sizes, set);
 
   SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile();
   if (dwo_symbol_file && dwo_symbol_file->GetCompileUnit()) {
     IndexUnitImpl(*dwo_symbol_file->GetCompileUnit(), cu_language,
-                  fixed_form_sizes, unit.GetOffset(), set);
+                  fixed_form_sizes, set);
   }
 }
 
 void ManualDWARFIndex::IndexUnitImpl(
     DWARFUnit &unit, const LanguageType cu_language,
-    const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
-    const dw_offset_t cu_offset, IndexSet &set) {
+    const DWARFFormValue::FixedFormSizes &fixed_form_sizes, IndexSet &set) {
+  user_id_t unit_id = unit.GetID();
   for (const DWARFDebugInfoEntry &die : unit.dies()) {
     const dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_array_type:
     case DW_TAG_base_type:
     case DW_TAG_class_type:
     case DW_TAG_constant:
case DW_TAG_subprogram:
           if (objc_method.IsValid(true)) {
             ConstString objc_class_name_with_category(
                 objc_method.GetClassNameWithCategory());
             ConstString objc_selector_name(objc_method.GetSelector());
             ConstString objc_fullname_no_category_name(
                 objc_method.GetFullNameWithoutCategory(true));
             ConstString objc_class_name_no_category(objc_method.GetClassName());
             set.function_fullnames.Insert(ConstString(name),
-                                          DIERef(cu_offset, die.GetOffset()));
+                                          DIERef(unit_id, die.GetOffset()));
             if (objc_class_name_with_category)
-              set.objc_class_selectors.Insert(
-                  objc_class_name_with_category,
-                  DIERef(cu_offset, die.GetOffset()));
+              set.objc_class_selectors.Insert(objc_class_name_with_category,
+                                              DIERef(unit_id, die.GetOffset()));
             if (objc_class_name_no_category &&
                 objc_class_name_no_category != objc_class_name_with_category)
-              set.objc_class_selectors.Insert(
-                  objc_class_name_no_category,
-                  DIERef(cu_offset, die.GetOffset()));
+              set.objc_class_selectors.Insert(objc_class_name_no_category,
+                                              DIERef(unit_id, die.GetOffset()));
             if (objc_selector_name)
               set.function_selectors.Insert(objc_selector_name,
-                                            DIERef(cu_offset, die.GetOffset()));
+                                            DIERef(unit_id, die.GetOffset()));
             if (objc_fullname_no_category_name)
               set.function_fullnames.Insert(objc_fullname_no_category_name,
-                                            DIERef(cu_offset, die.GetOffset()));
+                                            DIERef(unit_id, die.GetOffset()));
           }
           // If we have a mangled name, then the DW_AT_name attribute is
           // usually the method name without the class or any parameters
           bool is_method = DWARFDIE(&unit, &die).IsMethod();
 
           if (is_method)
             set.function_methods.Insert(ConstString(name),
-                                        DIERef(cu_offset, die.GetOffset()));
+                                        DIERef(unit_id, die.GetOffset()));
           else
             set.function_basenames.Insert(ConstString(name),
-                                          DIERef(cu_offset, die.GetOffset()));
+                                          DIERef(unit_id, die.GetOffset()));
 
           if (!is_method && !mangled_cstr && !objc_method.IsValid(true))
             set.function_fullnames.Insert(ConstString(name),
-                                          DIERef(cu_offset, die.GetOffset()));
+                                          DIERef(unit_id, die.GetOffset()));
         }
         if (mangled_cstr) {
           // Make sure our mangled name isn't the same string table entry as
           // our name. If it starts with '_', then it is ok, else compare the
           // string to make sure it isn't the same and we don't end up with
           // duplicate entries
           if (name && name != mangled_cstr &&
               ((mangled_cstr[0] == '_') ||
                (::strcmp(name, mangled_cstr) != 0))) {
             set.function_fullnames.Insert(ConstString(mangled_cstr),
-                                          DIERef(cu_offset, die.GetOffset()));
+                                          DIERef(unit_id, die.GetOffset()));
           }
         }
       }
       break;
 
     case DW_TAG_array_type:
     case DW_TAG_base_type:
     case DW_TAG_class_type:
     case DW_TAG_constant:
     case DW_TAG_enumeration_type:
     case DW_TAG_string_type:
     case DW_TAG_structure_type:
     case DW_TAG_subroutine_type:
     case DW_TAG_typedef:
     case DW_TAG_union_type:
     case DW_TAG_unspecified_type:
       if (name && !is_declaration)
-        set.types.Insert(ConstString(name), DIERef(cu_offset, die.GetOffset()));
+        set.types.Insert(ConstString(name), DIERef(unit_id, die.GetOffset()));
       if (mangled_cstr && !is_declaration)
         set.types.Insert(ConstString(mangled_cstr),
-                         DIERef(cu_offset, die.GetOffset()));
+                         DIERef(unit_id, die.GetOffset()));
       break;
 
     case DW_TAG_namespace:
       if (name)
         set.namespaces.Insert(ConstString(name),
-                              DIERef(cu_offset, die.GetOffset()));
+                              DIERef(unit_id, die.GetOffset()));
       break;
 
     case DW_TAG_variable:
       if (name && has_location_or_const_value && is_global_or_static_variable) {
-        set.globals.Insert(ConstString(name),
-                           DIERef(cu_offset, die.GetOffset()));
+        set.globals.Insert(ConstString(name), DIERef(unit_id, die.GetOffset()));
         // Be sure to include variables by their mangled and demangled names if
         // they have any since a variable can have a basename "i", a mangled
         // named "_ZN12_GLOBAL__N_11iE" and a demangled mangled name
         // "(anonymous namespace)::i"...
 
         // Make sure our mangled name isn't the same string table entry as our
         // name. If it starts with '_', then it is ok, else compare the string
         // to make sure it isn't the same and we don't end up with duplicate
         // entries
         if (mangled_cstr && name != mangled_cstr &&
             ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) {
           set.globals.Insert(ConstString(mangled_cstr),
-                             DIERef(cu_offset, die.GetOffset()));
+                             DIERef(unit_id, die.GetOffset()));
         }
       }
       break;
 
     default:
       continue;
     }
   }
 }
 
 void ManualDWARFIndex::GetGlobalVariables(ConstString basename, DIEArray &offsets) {
   Index();
   m_set.globals.Find(basename, offsets);
 }
 
 void ManualDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
                                           DIEArray &offsets) {
   Index();
   m_set.globals.Find(regex, offsets);
 }
 
 void ManualDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
                                           DIEArray &offsets) {
   Index();
-  m_set.globals.FindAllEntriesForCompileUnit(cu.GetOffset(), offsets);
+  m_set.globals.FindAllEntriesForCompileUnit(cu.GetID(), offsets);
 }
 
 void ManualDWARFIndex::GetObjCMethods(ConstString class_name,
                                       DIEArray &offsets) {
   Index();
   m_set.objc_class_selectors.Find(class_name, offsets);
 }
 

source/Plugins/SymbolFile/DWARF/NameToDIE.cpp

size_t NameToDIE::Find(ConstString name, DIEArray &info_array) const {
   return m_map.GetValues(name, info_array);
 }
 
 size_t NameToDIE::Find(const RegularExpression &regex,
                        DIEArray &info_array) const {
   return m_map.GetValues(regex, info_array);
 }
 
-size_t NameToDIE::FindAllEntriesForCompileUnit(dw_offset_t cu_offset,
+size_t NameToDIE::FindAllEntriesForCompileUnit(dw_offset_t cu_idx,
                                                DIEArray &info_array) const {
   const size_t initial_size = info_array.size();
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     const DIERef &die_ref = m_map.GetValueAtIndexUnchecked(i);
-    if (cu_offset == die_ref.cu_offset)
+    if (cu_idx == die_ref.cu_idx)
       info_array.push_back(die_ref);
   }
   return info_array.size() - initial_size;
 }
 
 void NameToDIE::Dump(Stream *s) {
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     ConstString cstr = m_map.GetCStringAtIndex(i);
     const DIERef &die_ref = m_map.GetValueAtIndexUnchecked(i);
     s->Printf("%p: {0x%8.8x/0x%8.8x} \"%s\"\n", (const void *)cstr.GetCString(),
-              die_ref.cu_offset, die_ref.die_offset, cstr.GetCString());
+              die_ref.cu_idx, die_ref.die_offset, cstr.GetCString());
   }
 }
 
 void NameToDIE::ForEach(
     std::function<bool(ConstString name, const DIERef &die_ref)> const
         &callback) const {
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 SymbolFileDWARFDwo::SymbolFileDWARFDwo(ObjectFileSP objfile,
                                        DWARFUnit *dwarf_cu)
     : SymbolFileDWARF(objfile.get()), m_obj_file_sp(objfile),
       m_base_dwarf_cu(dwarf_cu) {
-  SetID(((lldb::user_id_t)dwarf_cu->GetOffset()) << 32);
+  SetID(((lldb::user_id_t)dwarf_cu->GetID()) << 32);
 }
 
 void SymbolFileDWARFDwo::LoadSectionData(lldb::SectionType sect_type,
                                          DWARFDataExtractor &data) {
   const SectionList *section_list =
       m_obj_file->GetSectionList(false /* update_module_section_list */);
   if (section_list) {
     SectionSP section_sp(section_list->FindSectionByType(sect_type, true));

 
 TypeSystem *
 SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
   return GetBaseSymbolFile()->GetTypeSystemForLanguage(language);
 }
 
 DWARFDIE
 SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
-  lldbassert(m_base_dwarf_cu->GetOffset() == die_ref.cu_offset);
+  assert(m_base_dwarf_cu->GetID() == die_ref.cu_idx);
   return DebugInfo()->GetDIEForDIEOffset(die_ref.die_offset);
 }