04/06: Track .debug_types vs. .debug_info difference

[jankratochvil]

Summary

Steal one bit from DIERef's die_offset. That will make DWO's maximum CU size 4GB->2GB which should be OK. It will unfortunately also limit non-DWO DWARF size 4GB->2GB. That should be fixed by D61482 (then this patch will to steal the bit from cu_index/cu_offset).

The whole patchset available for testing as: git clone -b debugtypes git://git.jankratochvil.net/lldb

[jankratochvil]

Obsoleted by: D61908

lldb/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, bool t) : cu_offset(c), die_offset(d, t)
+      {}
 
   // 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);
struct DIERef {
   }
 
   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;
   }
 
-  dw_offset_t cu_offset = DW_INVALID_OFFSET;
-  dw_offset_t die_offset = DW_INVALID_OFFSET;
+  dw_offset_t cu_offset;
+  class DIEOffset {
+  public:
+    operator dw_offset_t() const {
+      if (m_val == (DW_INVALID_OFFSET & 0x7fffffff))
+        return DW_INVALID_OFFSET;
+      return m_val;
+    }
+    DIEOffset() : m_val(DW_INVALID_OFFSET & 0x7fffffff),
+        m_is_types_section(false) {}
+    DIEOffset(dw_offset_t o, bool t) {
+      (*this) = o;
+      m_is_types_section = t;
+    }
+    DIEOffset &operator =(dw_offset_t val) {
+      m_val = val;
+      assert(val == *this);
+      return *this;
+    }
+  private:
+    dw_offset_t m_val : 31;
+  public:
+    bool m_is_types_section : 1;
+  } die_offset;
+  bool IsTypesSection() const { return die_offset.m_is_types_section; }
+  void IsTypesSection_set(bool val) { die_offset.m_is_types_section = val; }
+
+  // It is 64-bit so that &=~UID_IS_TYPES_SECTION works.
+  static const uint64_t UID_IS_TYPES_SECTION = (1ULL << 31);
 };
 
 typedef std::vector<DIERef> DIEArray;
 
 #endif // SymbolFileDWARF_DIERef_h_

lldb/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) {
+    : cu_offset(DW_INVALID_OFFSET),
+    die_offset(
+        (uid & 0xffffffff) == DW_INVALID_OFFSET
+            ? DW_INVALID_OFFSET : uid & 0x7fffffff,
+        (uid & 0xffffffff) == DW_INVALID_OFFSET
+            ? false : (uid & UID_IS_TYPES_SECTION) != 0) {
   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->GetUnitContainingDIEOffset(die_offset);
         if (dwarf_cu) {
           cu_offset = dwarf_cu->GetOffset();
           return;
         }
       }
     }
     die_offset = DW_INVALID_OFFSET;
   } else {
     cu_offset = uid >> 32;
   }
 }
 
 DIERef::DIERef(const DWARFFormValue &form_value)
-    : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {
+    : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET, false) {
   if (form_value.IsValid()) {
     DWARFFormValue::CUDIERef cudieref = form_value.Reference();
     die_offset = cudieref.DIEOffset();
     if (cudieref.CU()) {
       if (cudieref.CU()->GetBaseObjOffset() != DW_INVALID_OFFSET)
         cu_offset = cudieref.CU()->GetBaseObjOffset();
       else
         cu_offset = cudieref.CU()->GetOffset();
+      IsTypesSection_set(cudieref.CU()->IsTypesSection());
     }
   }
 }
 
 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;
+  if (dwarf && die_offset != DW_INVALID_OFFSET) {
+    lldb::user_id_t uid = dwarf->GetID();
+    lldbassert((uid & 0x7fffffff) == 0);
+    lldbassert((uid & UID_IS_TYPES_SECTION) == 0);
+    if (IsTypesSection())
+      uid |= UID_IS_TYPES_SECTION;
     else
+      lldbassert((uid & UID_IS_TYPES_SECTION) == 0);
+    uid |= die_offset & 0x7fffffff;
+    return uid;
+  } else
     return LLDB_INVALID_UID;
 }

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

               if (module_sp) {
                 if (die.GetCU()->GetProducer() == eProducerClang)
                   module_sp->ReportError(
                       "DWARF DW_TAG_array_type DIE at 0x%8.8x has a "
                       "class/union/struct element type DIE 0x%8.8x that is a "
                       "forward declaration, not a complete definition.\nTry "
                       "compiling the source file with -fstandalone-debug or "
                       "disable -gmodules",
-                      die.GetOffset(), type_die_ref.die_offset);
+                      die.GetOffset(), dw_offset_t(type_die_ref.die_offset));
                 else
                   module_sp->ReportError(
                       "DWARF DW_TAG_array_type DIE at 0x%8.8x has a "
                       "class/union/struct element type DIE 0x%8.8x that is a "
                       "forward declaration, not a complete definition.\nPlease "
                       "file a bug against the compiler and include the "
                       "preprocessed output for %s",
-                      die.GetOffset(), type_die_ref.die_offset,
+                      die.GetOffset(), dw_offset_t(type_die_ref.die_offset),
                       die.GetLLDBCompileUnit()
                           ? die.GetLLDBCompileUnit()->GetPath().c_str()
                           : "the source file");
               }
 
               // We have no choice other than to pretend that the element class
               // type is complete. If we don't do this, clang will crash when
               // trying to layout the class. Since we provide layout
               // assistance, all ivars in this class and other classes will be
               // fine, this is the best we can do short of crashing.
               if (ClangASTContext::StartTagDeclarationDefinition(
                       array_element_type)) {
                 ClangASTContext::CompleteTagDeclarationDefinition(
                     array_element_type);
               } else {
                 module_sp->ReportError("DWARF DIE at 0x%8.8x was not able to "
                                        "start its definition.\nPlease file a "
                                        "bug and attach the file at the start "
                                        "of this error message",
-                                       type_die_ref.die_offset);
+                                       dw_offset_t(type_die_ref.die_offset));
               }
             }
 
             uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride;
             if (array_info && array_info->element_orders.size() > 0) {
               uint64_t num_elements = 0;
               auto end = array_info->element_orders.rend();
               for (auto pos = array_info->element_orders.rbegin(); pos != end;

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

lldb/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;
 
+  bool IsTypesSection() const override { return false; }
+
 private:
   DWARFCompileUnit(SymbolFileDWARF *dwarf2Data);
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFCompileUnit_h_

lldb/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->GetOffset(), block_die->GetOffset(),
+                                  cu->IsTypesSection())),
                           block_die);
       }
     }
   }
   return DWARFDIE();
 }
 
 const char *DWARFDIE::GetMangledName() const {

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

 
 class DWARFUnit {
   using die_iterator_range =
       llvm::iterator_range<DWARFDebugInfoEntry::collection::iterator>;
 
 public:
   virtual ~DWARFUnit();
 
+  virtual bool IsTypesSection() const = 0;
   void ExtractUnitDIEIfNeeded();
   void ExtractDIEsIfNeeded();
 
   class ScopedExtractDIEs {
     DWARFUnit *m_cu;
   public:
     bool m_clear_dies = false;
     ScopedExtractDIEs(DWARFUnit *cu);

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

size_t DWARFUnit::AppendDIEsWithTag(const dw_tag_t tag,
 
   // Return the number of DIEs added to the collection
   return dies.size() - old_size;
 }
 
 lldb::user_id_t DWARFUnit::GetID() const {
   dw_offset_t local_id =
       m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset;
+  lldbassert((local_id & DIERef::UID_IS_TYPES_SECTION) == 0);
+  bool is_types_section = IsTypesSection();
   if (m_dwarf)
-    return DIERef(local_id, local_id).GetUID(m_dwarf);
+    return DIERef(local_id, local_id, is_types_section).GetUID(m_dwarf);
   else
-    return local_id;
+    return local_id | (is_types_section ? DIERef::UID_IS_TYPES_SECTION : 0);
 }
 
 dw_offset_t DWARFUnit::GetNextUnitOffset() const {
   return m_offset + GetLengthByteSize() + GetLength();
 }
 
 size_t DWARFUnit::GetDebugInfoSize() const {
   return GetLengthByteSize() + GetLength() - GetHeaderByteSize();

lldb/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_offset, die_bias + *die_offset, cu->IsTypesSection());
 
   return DIERef();
 }
 
 void DebugNamesDWARFIndex::Append(const DebugNames::Entry &entry,
                                   DIEArray &offsets) {
   if (DIERef ref = ToDIERef(entry))
     offsets.push_back(ref);

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

public:
   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::DIEOffset offset; // The DIE offset
+    bool IsTypesSection() const { return offset.m_is_types_section; }
+    void IsTypesSection_set(bool val) { offset.m_is_types_section = val; }
     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);
+    DIEInfo(dw_offset_t c, dw_offset_t o, bool it, dw_tag_t t, uint32_t f,
+        uint32_t h);
   };
 
   struct Atom {
     AtomType type;
     dw_form_t form;
   };
 
   typedef std::vector<DIEInfo> DIEInfoArray;

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

 //===-- HashedNameToDIE.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 "HashedNameToDIE.h"
 #include "llvm/ADT/StringRef.h"
 
 void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
                                       DIEArray &die_offsets) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i)
     die_offsets.emplace_back(die_info_array[i].cu_offset,
-                             die_info_array[i].offset);
+                             die_info_array[i].offset,
+                             die_info_array[i].IsTypesSection());
 }
 
 void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
                                       const dw_tag_t tag,
                                       DIEArray &die_offsets) {
   if (tag == 0) {
     ExtractDIEArray(die_info_array, die_offsets);
   } else {
     const size_t count = die_info_array.size();
     for (size_t i = 0; i < count; ++i) {
       const dw_tag_t die_tag = die_info_array[i].tag;
       bool tag_matches = die_tag == 0 || tag == die_tag;
       if (!tag_matches) {
         if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
           tag_matches =
               tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
       }
       if (tag_matches)
         die_offsets.emplace_back(die_info_array[i].cu_offset,
-                                 die_info_array[i].offset);
+                                 die_info_array[i].offset,
+                                 die_info_array[i].IsTypesSection());
     }
   }
 }
 
 void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
                                       const dw_tag_t tag,
                                       const uint32_t qualified_name_hash,
                                       DIEArray &die_offsets) {
   if (tag == 0) {
     ExtractDIEArray(die_info_array, die_offsets);
   } else {
     const size_t count = die_info_array.size();
     for (size_t i = 0; i < count; ++i) {
       if (qualified_name_hash != die_info_array[i].qualified_name_hash)
         continue;
       const dw_tag_t die_tag = die_info_array[i].tag;
       bool tag_matches = die_tag == 0 || tag == die_tag;
       if (!tag_matches) {
         if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
           tag_matches =
               tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
       }
       if (tag_matches)
         die_offsets.emplace_back(die_info_array[i].cu_offset,
-                                 die_info_array[i].offset);
+                                 die_info_array[i].offset,
+                                 die_info_array[i].IsTypesSection());
     }
   }
 }
 
 void DWARFMappedHash::ExtractClassOrStructDIEArray(
     const DIEInfoArray &die_info_array,
     bool return_implementation_only_if_available, DIEArray &die_offsets) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
     const dw_tag_t die_tag = die_info_array[i].tag;
     if (die_tag == 0 || die_tag == DW_TAG_class_type ||
         die_tag == DW_TAG_structure_type) {
       if (die_info_array[i].type_flags & eTypeFlagClassIsImplementation) {
         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].cu_offset,
-                                   die_info_array[i].offset);
+                                   die_info_array[i].offset,
+                                   die_info_array[i].IsTypesSection());
           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_info_array[i].offset,
+                              die_info_array[i].IsTypesSection());
         }
       } else {
         die_offsets.emplace_back(die_info_array[i].cu_offset,
-                                 die_info_array[i].offset);
+                                 die_info_array[i].offset,
+                                 die_info_array[i].IsTypesSection());
       }
     }
   }
 }
 
 void DWARFMappedHash::ExtractTypesFromDIEArray(
     const DIEInfoArray &die_info_array, uint32_t type_flag_mask,
     uint32_t type_flag_value, DIEArray &die_offsets) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
     if ((die_info_array[i].type_flags & type_flag_mask) == type_flag_value)
       die_offsets.emplace_back(die_info_array[i].cu_offset,
-                               die_info_array[i].offset);
+                               die_info_array[i].offset,
+                               die_info_array[i].IsTypesSection());
   }
 }
 
 const char *DWARFMappedHash::GetAtomTypeName(uint16_t atom) {
   switch (atom) {
   case eAtomTypeNULL:
     return "NULL";
   case eAtomTypeDIEOffset:
     return "die-offset";
   case eAtomTypeCUOffset:
     return "cu-offset";
   case eAtomTypeTag:
     return "die-tag";
   case eAtomTypeNameFlags:
     return "name-flags";
   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) {}
+    : cu_offset(DW_INVALID_OFFSET), offset(DW_INVALID_OFFSET, false), tag(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) {}
+DWARFMappedHash::DIEInfo::DIEInfo(dw_offset_t c, dw_offset_t o, bool it,
+    dw_tag_t t, uint32_t f, uint32_t h)
+    : cu_offset(c), offset(o, it), 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);
 }

lldb/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;
         }
       }
     }
 
+    bool is_types_section = unit.IsTypesSection();
     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(
                 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(cu_offset, die.GetOffset(),
+                                              is_types_section));
             if (objc_class_name_with_category)
               set.objc_class_selectors.Insert(
                   objc_class_name_with_category,
-                  DIERef(cu_offset, die.GetOffset()));
+                  DIERef(cu_offset, die.GetOffset(), is_types_section));
             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()));
+                  DIERef(cu_offset, die.GetOffset(), is_types_section));
             if (objc_selector_name)
               set.function_selectors.Insert(objc_selector_name,
-                                            DIERef(cu_offset, die.GetOffset()));
+                                            DIERef(cu_offset, die.GetOffset(),
+                                                is_types_section));
             if (objc_fullname_no_category_name)
               set.function_fullnames.Insert(objc_fullname_no_category_name,
-                                            DIERef(cu_offset, die.GetOffset()));
+                                            DIERef(cu_offset, die.GetOffset(),
+                                                is_types_section));
           }
           // 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(cu_offset, die.GetOffset(),
+                                            is_types_section));
           else
             set.function_basenames.Insert(ConstString(name),
-                                          DIERef(cu_offset, die.GetOffset()));
+                                          DIERef(cu_offset, die.GetOffset(),
+                                              is_types_section));
 
           if (!is_method && !mangled_cstr && !objc_method.IsValid(true))
             set.function_fullnames.Insert(ConstString(name),
-                                          DIERef(cu_offset, die.GetOffset()));
+                                          DIERef(cu_offset, die.GetOffset(),
+                                              is_types_section));
         }
         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(cu_offset, die.GetOffset(),
+                                              is_types_section));
           }
         }
       }
       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(cu_offset, die.GetOffset(),
+            is_types_section));
       if (mangled_cstr && !is_declaration)
         set.types.Insert(ConstString(mangled_cstr),
-                         DIERef(cu_offset, die.GetOffset()));
+                         DIERef(cu_offset, die.GetOffset(), is_types_section));
       break;
 
     case DW_TAG_namespace:
       if (name)
         set.namespaces.Insert(ConstString(name),
-                              DIERef(cu_offset, die.GetOffset()));
+                              DIERef(cu_offset, die.GetOffset(),
+                                  is_types_section));
       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()));
+                           DIERef(cu_offset, die.GetOffset(),
+                               is_types_section));
         // 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(cu_offset, die.GetOffset(),
+                                 is_types_section));
         }
       }
       break;
 
     default:
       continue;
     }
   }

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

 }
 
 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_offset, dw_offset_t(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) {

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

SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
   if (!comp_unit)
     return nullptr;
 
   DWARFDebugInfo *info = DebugInfo();
   if (info) {
     // Just a normal DWARF file whose user ID for the compile unit is the DWARF
     // offset itself
 
+    auto offset = comp_unit->GetID();
+    bool is_types_section = (offset & DIERef::UID_IS_TYPES_SECTION) != 0;
+    offset &= ~DIERef::UID_IS_TYPES_SECTION;
     DWARFUnit *dwarf_cu =
         info->GetUnit((dw_offset_t)comp_unit->GetID());
     if (dwarf_cu && dwarf_cu->GetUserData() == NULL)
       dwarf_cu->SetUserData(comp_unit);
     return dwarf_cu;
   }
   return NULL;
 }