DWARF: Add ability to reference debug info coming from multiple sections

[labath]

Summary

This patch adds the ability to precisely address debug info in
situations when a single file can have more than one debug-info-bearing
sections (as is the case with type units in DWARF v4).

The changes here can be classified into roughly three categories:

• the code which addresses a debug info by offset gets an additional argument, which specifies the section one should look into.
• the DIERef class also gets an additional member variable specifying the section. This way, code dealing with DIERefs can know which section is the object referring to.
• the user_id_t encoding steals one bit from the dwarf_id field to store the section. This means the total number of separate object files (apple .o, or normal .dwo) is limited to 2 billion, but that is fine as it's not possible to hit that number without switching to DWARF64 anyway.

This patch is functionally equivalent to (and inspired by) the two
patches (D61503 and D61504) by Jan Kratochvil, but there are differences
in the implementation:

• it uses an enum instead of a bool flag to differentiate the sections
• it increases the size of DIERef struct instead of reducing the amount of addressable debug info
• it sets up DWARFDebugInfo to store the units in a single vector instead of two. This sets us up for the future in which type units can also live in the debug_info section, and I believe it's cleaner because there's no need for unit index remapping

There are no tests with this patch as this is essentially NFC until
we start parsing type units from the debug_types section.

[clayborg]

See inline comments. Nice patch overall though, real close.

source/Plugins/SymbolFile/DWARF/DIERef.cpp

18 ↗

(On Diff #199462)

We should maybe rename DWARFFormValue::GetCompileUnit() to DWARFFormValue::GetUnit()? Also we might use "unit" instead of "dwarf_cu" here?

source/Plugins/SymbolFile/DWARF/DIERef.h

19 ↗

(On Diff #199462)

Use enum class?

enum class Section : uint8_t { DebugInfo, DebugTypes };

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

141 ↗

(On Diff #199462)

Does the "GetUnitAtIndex" call need to take "section" to get the right unit?

162 ↗

(On Diff #199462)

Does the "GetUnitAtIndex" call need to take "section" to get the right unit?

source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

51–52 ↗

(On Diff #199462)

Should we use a DIERef here instead of these two members?

61 ↗

(On Diff #199462)

just return the DIERef member variable if we switch according to above inline comment

[labath]

source/Plugins/SymbolFile/DWARF/DIERef.cpp

18 ↗

(On Diff #199462)

Done in r360754.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

141 ↗

(On Diff #199462)

No, the idea is that the unit index will still uniquely determine the DWARFUnit, regardless of the section it is in (so the sections will still be kind of concatenated, but only at the index level). This makes it easy to convert back and forth between DWARFUnits and lldb_private::CompileUnits.

162 ↗

(On Diff #199462)

Same comment as above.

source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

51–52 ↗

(On Diff #199462)

Sounds like a good idea. I'll update the patch accordingly.

61 ↗

(On Diff #199462)

Done. I'm not sure the operator makes that much sense now as one can just access the contained DIERef directly. I've kept it for now to avoid needing to update all callsites, but I can also delete it if you prefer.

[labath]

• use enum class for the section type
• put DIERef as a member of HashedNameToDie::DIEInfo

lldb/trunk/lit/SymbolFile/DWARF/array-sizes.s

 # This tests a bug where we would incorrectly parse the size of an array if that
 # size happened to match an existing DIE offset. This happened because we
 # misinterpreted that value as a reference to a DIE specifying the VLA size even
 # though the form was a data form (as it should be).
 
 # REQUIRES: lld
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: lldb-test symbols %t | FileCheck %s
 
-# CHECK: Variable{0xffffffff0000001e}, name = "X"
-# CHECK-SAME: type = {ffffffff00000033} 0x{{[0-9a-f]*}} (char [56])
+# CHECK: Variable{0x7fffffff0000001e}, name = "X"
+# CHECK-SAME: type = {7fffffff00000033} 0x{{[0-9a-f]*}} (char [56])
 
 
 # Generated from "char X[47];"
 # The array size was modified by hand.
 
   .text
   .file "-"
   .file 1 "/tmp" "<stdin>"

lldb/trunk/lit/SymbolFile/DWARF/dwarf5_locations.s

 # This tests that lldb is able to process DW_OP_addrx tags introduced in dwarf5.
 # REQUIRES: lld
 # RUN: llvm-mc -g -dwarf-version=5 -triple x86_64-unknown-linux-gnu %s -filetype=obj > %t.o
 # RUN: ld.lld -m elf_x86_64 %t.o -o %t 
 # RUN: lldb-test symbols %t | FileCheck %s
 
-# CHECK: Variable{0xffffffff00000011}, name = "color"
+# CHECK: Variable{0x7fffffff00000011}, name = "color"
 # CHECK-SAME: location = DW_OP_addrx(0x0)
 
         .text
         .section        .debug_str,"MS",@progbits,1
 .Lstr_offsets_base0:
         .asciz  "color"
 
         .section        .debug_str_offsets,"",@progbits

lldb/trunk/source/Plugins/SymbolFile/DWARF/DIERef.h

 
 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-defines.h"
 
 class DWARFFormValue;
 class SymbolFileDWARF;
 
 struct DIERef {
+  enum Section : uint8_t { DebugInfo, DebugTypes };
+
   DIERef() = default;
 
-  DIERef(dw_offset_t c, dw_offset_t d) : cu_offset(c), die_offset(d) {}
+  DIERef(Section s, dw_offset_t c, dw_offset_t d)
+      : section(s), cu_offset(c), die_offset(d) {}
 
   explicit DIERef(const DWARFFormValue &form_value);
 
   bool operator<(const DIERef &ref) const {
     return die_offset < ref.die_offset;
   }
 
   explicit operator bool() const {
     return cu_offset != DW_INVALID_OFFSET || die_offset != DW_INVALID_OFFSET;
   }
 
+  Section section = Section::DebugInfo;
   dw_offset_t cu_offset = DW_INVALID_OFFSET;
   dw_offset_t die_offset = DW_INVALID_OFFSET;
 };
 
 typedef std::vector<DIERef> DIEArray;
 
 #endif // SymbolFileDWARF_DIERef_h_

lldb/trunk/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(const DWARFFormValue &form_value)
-    : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {
+DIERef::DIERef(const DWARFFormValue &form_value) {
   if (form_value.IsValid()) {
     DWARFDIE die = form_value.Reference();
     die_offset = die.GetOffset();
     if (die) {
+      section = die.GetCU()->GetDebugSection();
       if (die.GetCU()->GetBaseObjOffset() != DW_INVALID_OFFSET)
         cu_offset = die.GetCU()->GetBaseObjOffset();
       else
         cu_offset = die.GetCU()->GetOffset();
     }
   }
 }

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

 
 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->GetDebugSection(), cu_offset, m_die->GetOffset());
 }
 
 dw_tag_t DWARFBaseDIE::Tag() const {
   if (m_die)
     return m_die->Tag();
   else
     return 0;
 }

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

public:
   const lldb_private::DWARFDataExtractor &GetData() const override;
 
   /// Get the size in bytes of the header.
   ///
   /// \return
   ///     Byte size of the compile unit header
   uint32_t GetHeaderByteSize() const override;
 
+  DIERef::Section GetDebugSection() const override {
+    return DIERef::Section::DebugInfo;
+  }
+
 private:
   DWARFCompileUnit(SymbolFileDWARF *dwarf2Data, lldb::user_id_t uid);
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

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

if (IsValid()) {
     DWARFDebugInfoEntry *function_die = nullptr;
     DWARFDebugInfoEntry *block_die = nullptr;
     if (m_die->LookupAddress(file_addr, dwarf, cu, &function_die, &block_die)) {
       if (block_die && block_die != function_die) {
         if (cu->ContainsDIEOffset(block_die->GetOffset()))
           return DWARFDIE(cu, block_die);
         else
           return DWARFDIE(dwarf->DebugInfo()->GetUnit(
-                              DIERef(cu->GetOffset(), block_die->GetOffset())),
+                              DIERef(cu->GetDebugSection(), cu->GetOffset(),
+                                     block_die->GetOffset())),
                           block_die);
       }
     }
   }
   return DWARFDIE();
 }
 
 const char *DWARFDIE::GetMangledName() const {

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

typedef dw_offset_t (*Callback)(SymbolFileDWARF *dwarf2Data,
                                   const dw_offset_t next_offset,
                                   const uint32_t depth, void *userData);
 
   explicit DWARFDebugInfo(lldb_private::DWARFContext &context);
   void SetDwarfData(SymbolFileDWARF *dwarf2Data);
 
   size_t GetNumUnits();
   DWARFUnit *GetUnitAtIndex(lldb::user_id_t idx);
-  DWARFUnit *GetUnitAtOffset(dw_offset_t cu_offset, uint32_t *idx_ptr = NULL);
-  DWARFUnit *GetUnitContainingDIEOffset(dw_offset_t die_offset);
+  DWARFUnit *GetUnitAtOffset(DIERef::Section section,
+                             dw_offset_t cu_offset, uint32_t *idx_ptr = NULL);
+  DWARFUnit *GetUnitContainingDIEOffset(DIERef::Section section,
+                                        dw_offset_t die_offset);
   DWARFUnit *GetUnit(const DIERef &die_ref);
-  DWARFDIE GetDIEForDIEOffset(dw_offset_t die_offset);
+  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 =
         (1 << 2) // Show all parent DIEs when dumping single DIEs
   };
 
   llvm::Expected<DWARFDebugAranges &> GetCompileUnitAranges();
 
 protected:
-  static bool OffsetLessThanUnitOffset(dw_offset_t offset,
-                                       const DWARFUnitSP &cu_sp);
-
   typedef std::vector<DWARFUnitSP> UnitColl;
 
   // Member variables
   SymbolFileDWARF *m_dwarf2Data;
   lldb_private::DWARFContext &m_context;
   UnitColl m_units;
   std::unique_ptr<DWARFDebugAranges>
       m_cu_aranges_up; // A quick address to compile unit table
 
 private:
   // All parsing needs to be done partially any managed by this class as
   // accessors are called.
   void ParseUnitHeadersIfNeeded();
 
-  uint32_t FindUnitIndex(dw_offset_t offset);
+  uint32_t FindUnitIndex(DIERef::Section section, dw_offset_t offset);
 
   DISALLOW_COPY_AND_ASSIGN(DWARFDebugInfo);
 };
 
 #endif // SymbolFileDWARF_DWARFDebugInfo_h_

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

 
 DWARFUnit *DWARFDebugInfo::GetUnitAtIndex(user_id_t idx) {
   DWARFUnit *cu = NULL;
   if (idx < GetNumUnits())
     cu = m_units[idx].get();
   return cu;
 }
 
-bool DWARFDebugInfo::OffsetLessThanUnitOffset(dw_offset_t offset,
-                                              const DWARFUnitSP &cu_sp) {
-  return offset < cu_sp->GetOffset();
-}
-
-uint32_t DWARFDebugInfo::FindUnitIndex(dw_offset_t offset) {
+uint32_t DWARFDebugInfo::FindUnitIndex(DIERef::Section section,
+                                       dw_offset_t offset) {
   ParseUnitHeadersIfNeeded();
 
   // llvm::lower_bound is not used as for DIE offsets it would still return
   // index +1 and GetOffset() returning index itself would be a special case.
-  auto pos = llvm::upper_bound(m_units, offset, OffsetLessThanUnitOffset);
+  auto pos = llvm::upper_bound(
+      m_units, std::make_pair(section, offset),
+      [](const std::pair<DIERef::Section, dw_offset_t> &lhs,
+         const DWARFUnitSP &rhs) {
+        return lhs < std::make_pair(rhs->GetDebugSection(), rhs->GetOffset());
+      });
   uint32_t idx = std::distance(m_units.begin(), pos);
   if (idx == 0)
     return DW_INVALID_OFFSET;
   return idx - 1;
 }
 
-DWARFUnit *DWARFDebugInfo::GetUnitAtOffset(dw_offset_t cu_offset,
+DWARFUnit *DWARFDebugInfo::GetUnitAtOffset(DIERef::Section section,
+                                           dw_offset_t cu_offset,
                                            uint32_t *idx_ptr) {
-  uint32_t idx = FindUnitIndex(cu_offset);
+  uint32_t idx = FindUnitIndex(section, cu_offset);
   DWARFUnit *result = GetUnitAtIndex(idx);
   if (result && result->GetOffset() != cu_offset) {
     result = nullptr;
     idx = DW_INVALID_INDEX;
   }
   if (idx_ptr)
     *idx_ptr = idx;
   return result;
 }
 
 DWARFUnit *DWARFDebugInfo::GetUnit(const DIERef &die_ref) {
   if (die_ref.cu_offset == DW_INVALID_OFFSET)
-    return GetUnitContainingDIEOffset(die_ref.die_offset);
+    return GetUnitContainingDIEOffset(die_ref.section, die_ref.die_offset);
   else
-    return GetUnitAtOffset(die_ref.cu_offset);
+    return GetUnitAtOffset(die_ref.section, die_ref.cu_offset);
 }
 
-DWARFUnit *DWARFDebugInfo::GetUnitContainingDIEOffset(dw_offset_t die_offset) {
-  uint32_t idx = FindUnitIndex(die_offset);
+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))
     return nullptr;
   return result;
 }
 
 DWARFDIE
-DWARFDebugInfo::GetDIEForDIEOffset(dw_offset_t die_offset) {
-  DWARFUnit *cu = GetUnitContainingDIEOffset(die_offset);
+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();
 }
 
 // GetDIE()
 //
 // Get the DIE (Debug Information Entry) with the specified offset.
 DWARFDIE
 DWARFDebugInfo::GetDIE(const DIERef &die_ref) {
   DWARFUnit *cu = GetUnit(die_ref);
   if (cu)
     return cu->GetDIE(die_ref.die_offset);
   return DWARFDIE(); // Not found
 }
 

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

if (!m_unit->ContainsDIEOffset(value)) {
           value);
       return {};
     }
     return const_cast<DWARFUnit *>(m_unit)->GetDIE(value);
 
   case DW_FORM_ref_addr: {
     DWARFUnit *ref_cu =
         m_unit->GetSymbolFileDWARF()->DebugInfo()->GetUnitContainingDIEOffset(
-            value);
+            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 {};
     }
     return ref_cu->GetDIE(value);
   }

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

public:
 
   dw_offset_t GetBaseObjOffset() const;
 
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
 
+  virtual DIERef::Section GetDebugSection() const = 0;
+
 protected:
   DWARFUnit(SymbolFileDWARF *dwarf, lldb::user_id_t uid);
 
   SymbolFileDWARF *m_dwarf = nullptr;
   std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
   const DWARFAbbreviationDeclarationSet *m_abbrevs = nullptr;
   void *m_user_data = nullptr;
   // The compile unit debug information entry item

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

DebugNamesDWARFIndex::GetUnits(const DebugNames &debug_names) {
   return result;
 }
 
 DIERef DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
   llvm::Optional<uint64_t> cu_offset = entry.getCUOffset();
   if (!cu_offset)
     return DIERef();
 
-  DWARFUnit *cu = m_debug_info.GetUnitAtOffset(*cu_offset);
+  DWARFUnit *cu = m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, *cu_offset);
   if (!cu)
     return DIERef();
 
   // 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(DIERef::Section::DebugInfo, *cu_offset, 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.GetUnitAtOffset(ref.cu_offset);
+    DWARFUnit *cu =
+        m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, ref.cu_offset);
     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)

lldb/trunk/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

public:
   // Bit definitions for the eAtomTypeTypeFlags flags
   enum TypeFlags {
     // Always set for C++, only set for ObjC if this is the
     // @implementation for class
     eTypeFlagClassIsImplementation = (1u << 1)
   };
 
   struct DIEInfo {
-    dw_offset_t cu_offset;
-    dw_offset_t offset; // The DIE offset
+    DIERef die_ref;
     dw_tag_t tag;
     uint32_t type_flags;          // Any flags for this DIEInfo
     uint32_t qualified_name_hash; // A 32 bit hash of the fully qualified name
 
     DIEInfo();
     DIEInfo(dw_offset_t c, dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
 
-    explicit operator DIERef() const { return {cu_offset, offset}; }
+    explicit operator DIERef() const { return die_ref; }
   };
 
   struct Atom {
     AtomType type;
     dw_form_t form;
   };
 
   typedef std::vector<DIEInfo> DIEInfoArray;

lldb/trunk/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.cpp

if (die_tag == 0 || die_tag == DW_TAG_class_type ||
         if (return_implementation_only_if_available) {
           // We found the one true definition for this class, so only return
           // that
           die_offsets.clear();
           die_offsets.emplace_back(die_info_array[i]);
           return;
         } else {
           // Put the one true definition as the first entry so it matches first
-          die_offsets.emplace(die_offsets.begin(), die_info_array[i].cu_offset,
-                              die_info_array[i].offset);
+          die_offsets.emplace(die_offsets.begin(), die_info_array[i]);
         }
       } else {
         die_offsets.emplace_back(die_info_array[i]);
       }
     }
   }
 }
 
case eAtomTypeTypeFlags:
     return "type-flags";
   case eAtomTypeQualNameHash:
     return "qualified-name-hash";
   }
   return "<invalid>";
 }
 
 DWARFMappedHash::DIEInfo::DIEInfo()
-    : cu_offset(DW_INVALID_OFFSET), offset(DW_INVALID_OFFSET), tag(0),
-      type_flags(0), qualified_name_hash(0) {}
+    : tag(0), type_flags(0), qualified_name_hash(0) {}
 
 DWARFMappedHash::DIEInfo::DIEInfo(dw_offset_t c, dw_offset_t o, dw_tag_t t,
                                   uint32_t f, uint32_t h)
-    : cu_offset(c), offset(o), tag(t), type_flags(f), qualified_name_hash(h) {}
+    : die_ref(DIERef::Section::DebugInfo, c, o), tag(t), type_flags(f),
+      qualified_name_hash(h) {}
 
 DWARFMappedHash::Prologue::Prologue(dw_offset_t _die_base_offset)
     : die_base_offset(_die_base_offset), atoms(), atom_mask(0),
       min_hash_data_byte_size(0), hash_data_has_fixed_byte_size(true) {
   // Define an array of DIE offsets by first defining an array, and then define
   // the atom type for the array, in this case we have an array of DIE offsets
   AppendAtom(eAtomTypeDIEOffset, DW_FORM_data4);
 }
bool DWARFMappedHash::Header::Read(const lldb_private::DWARFDataExtractor &data,
   for (size_t i = 0; i < num_atoms; ++i) {
     DWARFFormValue form_value(NULL, header_data.atoms[i].form);
 
     if (!form_value.ExtractValue(data, offset_ptr))
       return false;
 
     switch (header_data.atoms[i].type) {
     case eAtomTypeDIEOffset: // DIE offset, check form for encoding
-      hash_data.offset =
+      hash_data.die_ref.die_offset =
           DWARFFormValue::IsDataForm(form_value.Form())
               ? form_value.Unsigned()
               : form_value.Reference(header_data.die_base_offset);
       break;
 
     case eAtomTypeTag: // DW_TAG value for the DIE
       hash_data.tag = (dw_tag_t)form_value.Unsigned();
       break;
while (!done && hash_data_offset != UINT32_MAX) {
       // this hash value.
       if (key == 0)
         break;
 
       const uint32_t count = m_data.GetU32(&hash_data_offset);
       for (uint32_t i = 0; i < count; ++i) {
         DIEInfo die_info;
         if (m_header.Read(m_data, &hash_data_offset, die_info)) {
-          if (die_info.offset == 0)
+          if (die_info.die_ref.die_offset == 0)
             done = true;
-          if (die_offset_start <= die_info.offset &&
-              die_info.offset < die_offset_end)
+          if (die_offset_start <= die_info.die_ref.die_offset &&
+              die_info.die_ref.die_offset < die_offset_end)
             die_info_array.push_back(die_info);
         }
       }
     }
   }
   return die_info_array.size();
 }
 

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

if (num_attributes > 0) {
         case DW_AT_specification:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             specification_die_form = form_value;
           break;
         }
       }
     }
 
-    DIERef ref(cu_offset, die.GetOffset());
+    DIERef ref(unit.GetDebugSection(), cu_offset, die.GetOffset());
     switch (tag) {
     case DW_TAG_inlined_subroutine:
     case DW_TAG_subprogram:
       if (has_address) {
         if (name) {
           ObjCLanguage::MethodName objc_method(name, true);
           if (objc_method.IsValid(true)) {
             ConstString objc_class_name_with_category(

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

const ExternalTypeModuleMap& getExternalTypeModules() const {
       return m_external_type_modules;
   }
 
   virtual DWARFDIE GetDIE(const DIERef &die_ref);
 
   DWARFDIE GetDIE(lldb::user_id_t uid);
 
   lldb::user_id_t GetUID(const DWARFBaseDIE &die) {
-    return GetID() | die.GetOffset();
+    return GetUID(die.GetDIERef());
   }
 
-  lldb::user_id_t GetUID(const DIERef &ref) { return GetID() | ref.die_offset; }
+  lldb::user_id_t GetUID(const DIERef &ref) {
+    return GetID() | ref.die_offset |
+           (lldb::user_id_t(ref.section == DIERef::Section::DebugTypes) << 63);
+  }
 
   virtual std::unique_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   // For regular SymbolFileDWARF instances the method returns nullptr,
   // for the instances of the subclass SymbolFileDWARFDwo
   // the method returns a pointer to the base compile unit.

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

for (die = child_die.GetParent(); die; die = die.GetParent()) {
     case DW_TAG_lexical_block:
       return die;
     }
   }
   return DWARFDIE();
 }
 
 SymbolFileDWARF::SymbolFileDWARF(ObjectFile *objfile)
-    : SymbolFile(objfile), UserID(uint64_t(DW_INVALID_OFFSET)
-                                  << 32), // Used by SymbolFileDWARFDebugMap to
-                                          // when this class parses .o files to
-                                          // contain the .o file index/ID
+    : SymbolFile(objfile),
+      UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
       m_debug_map_module_wp(), m_debug_map_symfile(NULL),
       m_context(*objfile->GetModule()), m_data_debug_abbrev(),
       m_data_debug_frame(), m_data_debug_info(), m_data_debug_line(),
       m_data_debug_macro(), m_data_debug_loc(), m_data_debug_ranges(),
       m_data_debug_rnglists(), m_data_debug_str(), m_data_apple_names(),
       m_data_apple_types(), m_data_apple_namespaces(), m_abbr(), m_info(),
       m_line(), m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate), m_ranges(),
SymbolFileDWARF::DecodedUID SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
   // SymbolFileDWARF classes, one for each .o file. We can often end up with
   // references to other DWARF objects and we must be ready to receive a
   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
   // instance.
   if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
     SymbolFileDWARF *dwarf = debug_map->GetSymbolFileByOSOIndex(
         debug_map->GetOSOIndexFromUserID(uid));
-    return {dwarf, {DW_INVALID_OFFSET, dw_offset_t(uid)}};
+    return {dwarf, {DIERef::Section::DebugInfo, DW_INVALID_OFFSET, dw_offset_t(uid)}};
   }
-  uint32_t dwarf_id = uid >> 32;
+  DIERef::Section section =
+      uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
+  uint32_t dwarf_id = uid >> 32 & 0x7fffffff;
   dw_offset_t die_offset = uid;
 
   if (die_offset == DW_INVALID_OFFSET)
     return {nullptr, DIERef()};
 
   SymbolFileDWARF *dwarf = this;
   if (DebugInfo()) {
     if (DWARFUnit *unit = DebugInfo()->GetUnitAtIndex(dwarf_id)) {
       if (unit->GetDwoSymbolFile())
         dwarf = unit->GetDwoSymbolFile();
     }
   }
-  return {dwarf, {DW_INVALID_OFFSET, die_offset}};
+  return {dwarf, {section, DW_INVALID_OFFSET, 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 (debug_info) {
               scc->CalculateSymbolContext(&sc);
               sc.variable = variable;
             }
             return sc.GetResolvedMask();
           }
         }
       } else {
         uint32_t cu_idx = DW_INVALID_INDEX;
-        DWARFUnit *dwarf_cu = debug_info->GetUnitAtOffset(cu_offset, &cu_idx);
+        DWARFUnit *dwarf_cu = debug_info->GetUnitAtOffset(DIERef::Section::DebugInfo,
+                                                          cu_offset, &cu_idx);
         if (dwarf_cu) {
           sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
           if (sc.comp_unit) {
             resolved |= eSymbolContextCompUnit;
 
             bool force_check_line_table = false;
             if (resolve_scope &
                 (eSymbolContextFunction | eSymbolContextBlock)) {

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

 SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
   return GetBaseSymbolFile()->GetTypeSystemForLanguage(language);
 }
 
 DWARFDIE
 SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
   lldbassert(die_ref.cu_offset == m_base_dwarf_cu->GetOffset() ||
              die_ref.cu_offset == DW_INVALID_OFFSET);
-  return DebugInfo()->GetDIEForDIEOffset(die_ref.die_offset);
+  return DebugInfo()->GetDIEForDIEOffset(die_ref.section, die_ref.die_offset);
 }