DWARF: Make DIERefs always valid

[labath]

Summary

This patch makes the DIERef class always valid by default constructor
and operator bool. This allows one to express the validity of a DIERef
in the type system. Places which are working with potentially-invalid
DIERefs have been updated to use Optional<DIERef> instead.

The constructor taking a DWARFFormValue was not needed, as all places
which were constructing a DIERef this way were immediately converting it
into a DWARFDIE or a user_id. This can be done without constructing an
intermediate DIERef.

[labath]

source/Plugins/SymbolFile/DWARF/DIERef.cpp

1 ↗

(On Diff #205002)

I'm not deleting this file, because I'm going to add some stuff to it in the next patch in this series.

[clayborg]

I am concerned that our mapping from DIERef to lldb::user_id_t won't work for all cases now that we are/have expanded the DIERef class (including as we add the DWO field). I voiced this concern in https://reviews.llvm.org/D63428. Let me know what you think.

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

59 ↗

(On Diff #205002)

Shouldn't we be using the section from the DIERef in "entry" instead of hard coding to "DIERef::Section::DebugInfo" here? If so we need a test to cover this case so we don't regress

70 ↗

(On Diff #205002)

Shouldn't we be using the section from the DIERef in "entry" instead of hard coding to "DIERef::Section::DebugInfo" here?

source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

64 ↗

(On Diff #205002)

DIEInfo objects are only ever used in .debug_info?

[labath]

In D63399#1546330, @clayborg wrote:

I am concerned that our mapping from DIERef to lldb::user_id_t won't work for all cases now that we are/have expanded the DIERef class (including as we add the DWO field). I voiced this concern in https://reviews.llvm.org/D63428. Let me know what you think.

I'll reply to that review tomorrow, for now here's a quick reply to the comments in this review.

source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

59 ↗

(On Diff #205002)

debug_names is DWARF5 only, which has moved back type units into the debug_info section. So entry does not contain the section, nor does it need to because we can always assume all units will be in the debug_info section.

source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

64 ↗

(On Diff #205002)

Yes. They are only used with apple indexes, and those only work with debug_info sections. -fdebug-types-section is hard-disabled on apple targets nowadays (it used to crash the compiler before that).

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

 //===-- DIERef.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 SymbolFileDWARF_DIERef_h_
 #define SymbolFileDWARF_DIERef_h_
 
 #include "lldb/Core/dwarf.h"
-#include "lldb/lldb-defines.h"
-
-class DWARFFormValue;
-class SymbolFileDWARF;
+#include <vector>
 
 struct DIERef {
   enum Section : uint8_t { DebugInfo, DebugTypes };
 
-  DIERef() = default;
-
   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);
-
-  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;
+  Section section;
+  dw_offset_t cu_offset;
+  dw_offset_t die_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) {
-  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/DWARFASTParserClang.cpp

if (!clang_type && (encoding_data_type == Type::eEncodingIsPointerUID ||
             }
           }
         }
       }
     }
 
     type_sp = std::make_shared<Type>(
         die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
-        dwarf->GetUID(DIERef(attrs.type)), encoding_data_type, &attrs.decl,
+        dwarf->GetUID(attrs.type.Reference()), encoding_data_type, &attrs.decl,
         clang_type, resolve_state);
 
     dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
   } break;
 
   case DW_TAG_structure_type:
   case DW_TAG_union_type:
   case DW_TAG_class_type: {
case DW_TAG_enumeration_type: {
     DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                  DW_TAG_value_to_name(tag), type_name_cstr);
 
     CompilerType enumerator_clang_type;
     clang_type.SetCompilerType(
         &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
     if (!clang_type) {
       if (attrs.type.IsValid()) {
-        Type *enumerator_type = dwarf->ResolveTypeUID(DIERef(attrs.type));
+        Type *enumerator_type =
+            dwarf->ResolveTypeUID(attrs.type.Reference(), true);
         if (enumerator_type)
           enumerator_clang_type = enumerator_type->GetFullCompilerType();
       }
 
       if (!enumerator_clang_type) {
         if (attrs.byte_size) {
           enumerator_clang_type =
               m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize(
if (!clang_type) {
           m_ast.GetEnumerationIntegerType(clang_type.GetOpaqueQualType());
     }
 
     LinkDeclContextToDIE(ClangASTContext::GetDeclContextForType(clang_type),
                          die);
 
     type_sp = std::make_shared<Type>(
         die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
-        dwarf->GetUID(DIERef(attrs.type)), Type::eEncodingIsUID, &attrs.decl,
-        clang_type, Type::eResolveStateForward);
+        dwarf->GetUID(attrs.type.Reference()), Type::eEncodingIsUID,
+        &attrs.decl, clang_type, Type::eResolveStateForward);
 
     if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
       if (die.HasChildren()) {
         bool is_signed = false;
         enumerator_clang_type.IsIntegerType(is_signed);
         ParseChildEnumerators(clang_type, is_signed,
                               type_sp->GetByteSize().getValueOr(0), die);
       }
case DW_TAG_subroutine_type: {
 
     DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                  DW_TAG_value_to_name(tag), type_name_cstr);
 
     CompilerType return_clang_type;
     Type *func_type = NULL;
 
     if (attrs.type.IsValid())
-      func_type = dwarf->ResolveTypeUID(DIERef(attrs.type));
+      func_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true);
 
     if (func_type)
       return_clang_type = func_type->GetForwardCompilerType();
     else
       return_clang_type = m_ast.GetBasicType(eBasicTypeVoid);
 
     std::vector<CompilerType> function_param_types;
     std::vector<clang::ParmVarDecl *> function_param_decls;
if (attrs.name) {
               // We have a specification which we are going to base our
               // function prototype off of, so we need this type to be
               // completed so that the m_die_to_decl_ctx for the method in
               // the specification has a valid clang decl context.
               class_type->GetForwardCompilerType();
               // If we have a specification, then the function type should
               // have been made with the specification and not with this
               // die.
-              DWARFDIE spec_die =
-                  dwarf->DebugInfo()->GetDIE(DIERef(attrs.specification));
+              DWARFDIE spec_die = attrs.specification.Reference();
               clang::DeclContext *spec_clang_decl_ctx =
                   GetClangDeclContextForDIE(spec_die);
               if (spec_clang_decl_ctx) {
                 LinkDeclContextToDIE(spec_clang_decl_ctx, die);
               } else {
                 dwarf->GetObjectFile()->GetModule()->ReportWarning(
                     "0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x"
                     ") has no decl\n",
-                    die.GetID(), attrs.specification.Reference().GetOffset());
+                    die.GetID(), spec_die.GetOffset());
               }
               type_handled = true;
             } else if (attrs.abstract_origin.IsValid()) {
               // We have a specification which we are going to base our
               // function prototype off of, so we need this type to be
               // completed so that the m_die_to_decl_ctx for the method in
               // the abstract origin has a valid clang decl context.
               class_type->GetForwardCompilerType();
 
-              DWARFDIE abs_die =
-                  dwarf->DebugInfo()->GetDIE(DIERef(attrs.abstract_origin));
+              DWARFDIE abs_die = attrs.abstract_origin.Reference();
               clang::DeclContext *abs_clang_decl_ctx =
                   GetClangDeclContextForDIE(abs_die);
               if (abs_clang_decl_ctx) {
                 LinkDeclContextToDIE(abs_clang_decl_ctx, die);
               } else {
                 dwarf->GetObjectFile()->GetModule()->ReportWarning(
                     "0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x"
                     ") has no decl\n",
-                    die.GetID(), attrs.abstract_origin.Reference().GetOffset());
+                    die.GetID(), abs_die.GetOffset());
               }
               type_handled = true;
             } else {
               CompilerType class_opaque_type =
                   class_type->GetForwardCompilerType();
               if (ClangASTContext::IsCXXClassType(class_opaque_type)) {
                 if (class_opaque_type.IsBeingDefined() || alternate_defn) {
                   if (!is_static && !die.HasChildren()) {
type_sp = std::make_shared<Type>(
         Type::eEncodingIsUID, &attrs.decl, clang_type, Type::eResolveStateFull);
     assert(type_sp.get());
   } break;
 
   case DW_TAG_array_type: {
     DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                  DW_TAG_value_to_name(tag), type_name_cstr);
 
-    DIERef type_die_ref(attrs.type);
-    Type *element_type = dwarf->ResolveTypeUID(type_die_ref);
+    DWARFDIE type_die = attrs.type.Reference();
+    Type *element_type = dwarf->ResolveTypeUID(type_die, true);
 
     if (element_type) {
       auto array_info = ParseChildArrayInfo(die);
       if (array_info) {
         attrs.byte_stride = array_info->byte_stride;
         attrs.bit_stride = array_info->bit_stride;
       }
       if (attrs.byte_stride == 0 && attrs.bit_stride == 0)
         attrs.byte_stride = element_type->GetByteSize().getValueOr(0);
       CompilerType array_element_type = element_type->GetForwardCompilerType();
 
       if (ClangASTContext::IsCXXClassType(array_element_type) &&
           !array_element_type.GetCompleteType()) {
         ModuleSP module_sp = die.GetModule();
         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(), type_die.GetOffset());
           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(), type_die.GetOffset(),
                 GetUnitName(die).c_str());
         }
 
         // 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);
+                                 type_die.GetOffset());
         }
       }
 
       uint64_t array_element_bit_stride =
           attrs.byte_stride * 8 + attrs.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;
              ++pos) {
           num_elements = *pos;
           clang_type = m_ast.CreateArrayType(array_element_type, num_elements,
                                              attrs.is_vector);
           array_element_type = clang_type;
           array_element_bit_stride =
               num_elements ? array_element_bit_stride * num_elements
                            : array_element_bit_stride;
         }
       } else {
         clang_type = m_ast.CreateArrayType(array_element_type, 0, attrs.is_vector);
       }
       ConstString empty_name;
       type_sp = std::make_shared<Type>(
           die.GetID(), dwarf, empty_name, array_element_bit_stride / 8, nullptr,
-          dwarf->GetUID(type_die_ref), Type::eEncodingIsUID, &attrs.decl,
+          dwarf->GetUID(type_die), Type::eEncodingIsUID, &attrs.decl,
           clang_type, Type::eResolveStateFull);
       type_sp->SetEncodingType(element_type);
       m_ast.SetMetadataAsUserID(clang_type.GetOpaqueQualType(), die.GetID());
     }
   } break;
 
   case DW_TAG_ptr_to_member_type: {
-    Type *pointee_type = dwarf->ResolveTypeUID(DIERef(attrs.type));
-    Type *class_type = dwarf->ResolveTypeUID(DIERef(attrs.containing_type));
+    Type *pointee_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true);
+    Type *class_type =
+        dwarf->ResolveTypeUID(attrs.containing_type.Reference(), true);
 
     CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType();
     CompilerType class_clang_type = class_type->GetLayoutCompilerType();
 
     clang_type = ClangASTContext::CreateMemberPointerType(class_clang_type,
                                                           pointee_clang_type);
 
     if (llvm::Optional<uint64_t> clang_type_size =
if (num_attributes > 0) {
 
         case DW_AT_GNU_template_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             template_name = form_value.AsCString();
           break;
 
         case DW_AT_type:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
-            Type *lldb_type = die.ResolveTypeUID(DIERef(form_value));
+            Type *lldb_type = die.ResolveTypeUID(form_value.Reference());
             if (lldb_type)
               clang_type = lldb_type->GetForwardCompilerType();
           }
           break;
 
         case DW_AT_const_value:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             uval64_valid = true;
case DW_TAG_APPLE_property: {
 
         // FIXME: Make Clang ignore Objective-C accessibility for expressions
         if (class_language == eLanguageTypeObjC ||
             class_language == eLanguageTypeObjC_plus_plus)
           accessibility = eAccessNone;
 
         // Handle static members
         if (is_external && member_byte_offset == UINT32_MAX) {
-          Type *var_type = die.ResolveTypeUID(DIERef(encoding_form));
+          Type *var_type = die.ResolveTypeUID(encoding_form.Reference());
 
           if (var_type) {
             if (accessibility == eAccessNone)
               accessibility = eAccessPublic;
             ClangASTContext::AddVariableToRecordType(
                 class_clang_type, name, var_type->GetLayoutCompilerType(),
                 accessibility);
           }
           break;
         }
 
         if (!is_artificial) {
-          Type *member_type = die.ResolveTypeUID(DIERef(encoding_form));
+          Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
 
           clang::FieldDecl *field_decl = nullptr;
           if (tag == DW_TAG_member) {
             if (member_type) {
               if (accessibility == eAccessNone)
                 accessibility = default_accessibility;
               member_accessibilities.push_back(accessibility);
 
case DW_TAG_inheritance: {
               break;
 
             default:
               break;
             }
           }
         }
 
-        Type *base_class_type = die.ResolveTypeUID(DIERef(encoding_form));
+        Type *base_class_type = die.ResolveTypeUID(encoding_form.Reference());
         if (base_class_type == nullptr) {
           module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to "
                                  "resolve the base class at 0x%8.8x"
                                  " from enclosing type 0x%8.8x. \nPlease file "
                                  "a bug and attach the file at the start of "
                                  "this error message",
                                  die.GetOffset(),
                                  encoding_form.Reference().GetOffset(),
case DW_TAG_formal_parameter: {
           // In order to determine if a C++ member function is "const" we
           // have to look at the const-ness of "this"...
           if (arg_idx == 0 &&
               DeclKindIsCXXClass(containing_decl_ctx->getDeclKind()) &&
               // Often times compilers omit the "this" name for the
               // specification DIEs, so we can't rely upon the name being in
               // the formal parameter DIE...
               (name == nullptr || ::strcmp(name, "this") == 0)) {
-            Type *this_type = die.ResolveTypeUID(DIERef(param_type_die_form));
+            Type *this_type =
+                die.ResolveTypeUID(param_type_die_form.Reference());
             if (this_type) {
               uint32_t encoding_mask = this_type->GetEncodingMask();
               if (encoding_mask & Type::eEncodingIsPointerUID) {
                 is_static = false;
 
                 if (encoding_mask & (1u << Type::eEncodingIsConstUID))
                   type_quals |= clang::Qualifiers::Const;
                 if (encoding_mask & (1u << Type::eEncodingIsVolatileUID))
                   type_quals |= clang::Qualifiers::Volatile;
               }
             }
           }
           skip = true;
         }
 
         if (!skip) {
-          Type *type = die.ResolveTypeUID(DIERef(param_type_die_form));
+          Type *type = die.ResolveTypeUID(param_type_die_form.Reference());
           if (type) {
             function_param_types.push_back(type->GetForwardCompilerType());
 
             clang::ParmVarDecl *param_var_decl =
                 m_ast.CreateParameterDeclaration(containing_decl_ctx, name,
                                                  type->GetForwardCompilerType(),
                                                  storage);
             assert(param_var_decl);

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

public:
 
   // Accessors
   SymbolFileDWARF *GetDWARF() const;
 
   DWARFUnit *GetCU() const { return m_cu; }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
-  DIERef GetDIERef() const;
+  llvm::Optional<DIERef> GetDIERef() const;
 
   lldb_private::TypeSystem *GetTypeSystem() const;
 
   DWARFASTParser *GetDWARFParser() const;
 
   void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
     if (cu && die) {
       m_cu = cu;

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

 #include "DWARFDebugInfoEntry.h"
 #include "SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 using namespace lldb_private;
 
-DIERef DWARFBaseDIE::GetDIERef() const {
+llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef() const {
   if (!IsValid())
-    return DIERef();
+    return llvm::None;
 
   dw_offset_t cu_offset = m_cu->GetOffset();
   if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
     cu_offset = m_cu->GetBaseObjOffset();
   return DIERef(m_cu->GetDebugSection(), cu_offset, m_die->GetOffset());
 }
 
 dw_tag_t DWARFBaseDIE::Tag() const {

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

public:
   using DWARFBaseDIE::GetName;
   void GetName(lldb_private::Stream &s) const;
 
   void AppendTypeName(lldb_private::Stream &s) const;
 
   lldb_private::Type *ResolveType() const;
 
   // Resolve a type by UID using this DIE's DWARF file
-  lldb_private::Type *ResolveTypeUID(const DIERef &die_ref) const;
+  lldb_private::Type *ResolveTypeUID(const DWARFDIE &die) const;
 
   // Functions for obtaining DIE relations and references
 
   DWARFDIE
   GetParent() const;
 
   DWARFDIE
   GetFirstChild() const;

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

 
 lldb_private::Type *DWARFDIE::ResolveType() const {
   if (IsValid())
     return GetDWARF()->ResolveType(*this, true);
   else
     return nullptr;
 }
 
-lldb_private::Type *DWARFDIE::ResolveTypeUID(const DIERef &die_ref) const {
-  SymbolFileDWARF *dwarf = GetDWARF();
-  if (dwarf)
-    return dwarf->ResolveTypeUID(dwarf->GetDIE(die_ref), true);
-  else
-    return nullptr;
+lldb_private::Type *DWARFDIE::ResolveTypeUID(const DWARFDIE &die) const {
+  if (SymbolFileDWARF *dwarf = GetDWARF())
+    return dwarf->ResolveTypeUID(die, true);
 }
 
 std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
   if (!IsValid())
     return {};
 
   std::vector<DWARFDIE> result;
   DWARFDIE parent = GetParentDeclContextDIE();

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

bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
   SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
   if (dwo_symbol_file)
     return GetDIENamesAndRanges(
         dwo_symbol_file->GetCompileUnit(), name, mangled, ranges, decl_file,
         decl_line, decl_column, call_file, call_line, call_column, frame_base);
 
   dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
   dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
-  std::vector<DIERef> die_refs;
+  std::vector<DWARFDIE> dies;
   bool set_frame_base_loclist_addr = false;
 
   auto abbrevDecl = GetAbbreviationDeclarationPtr(cu);
 
   SymbolFileDWARF &dwarf = cu->GetSymbolFileDWARF();
   lldb::ModuleSP module = dwarf.GetObjectFile()->GetModule();
 
   if (abbrevDecl) {
for (uint32_t i = 0; i < numAttributes; ++i) {
 
         case DW_AT_MIPS_linkage_name:
         case DW_AT_linkage_name:
           if (mangled == nullptr)
             mangled = form_value.AsCString();
           break;
 
         case DW_AT_abstract_origin:
-          die_refs.emplace_back(form_value);
+          dies.push_back(form_value.Reference());
           break;
 
         case DW_AT_specification:
-          die_refs.emplace_back(form_value);
+          dies.push_back(form_value.Reference());
           break;
 
         case DW_AT_decl_file:
           if (decl_file == 0)
             decl_file = form_value.Unsigned();
           break;
 
         case DW_AT_decl_line:
bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
 
   if (set_frame_base_loclist_addr) {
     dw_addr_t lowest_range_pc = ranges.GetMinRangeBase(0);
     assert(lowest_range_pc >= cu->GetBaseAddress());
     frame_base->SetLocationListSlide(lowest_range_pc - cu->GetBaseAddress());
   }
 
   if (ranges.IsEmpty() || name == nullptr || mangled == nullptr) {
-    for (const DIERef &die_ref : die_refs) {
-      if (die_ref.die_offset != DW_INVALID_OFFSET) {
-        DWARFDIE die = dwarf.GetDIE(die_ref);
-        if (die)
-          die.GetDIE()->GetDIENamesAndRanges(die.GetCU(), name, mangled, ranges,
-                                             decl_file, decl_line, decl_column,
-                                             call_file, call_line, call_column);
+    for (const DWARFDIE &die : dies) {
+      if (die) {
       }
     }
   }
   return !ranges.IsEmpty();
 }
 
 // Dump
 //

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

private:
   // track of the ownership here.
   DWARFDataExtractor m_debug_names_data;
   DWARFDataExtractor m_debug_str_data;
 
   using DebugNames = llvm::DWARFDebugNames;
   std::unique_ptr<DebugNames> m_debug_names_up;
   ManualDWARFIndex m_fallback;
 
-  DIERef ToDIERef(const DebugNames::Entry &entry);
+  llvm::Optional<DIERef> ToDIERef(const DebugNames::Entry &entry);
   void Append(const DebugNames::Entry &entry, DIEArray &offsets);
 
   static void MaybeLogLookupError(llvm::Error error,
                                   const DebugNames::NameIndex &ni,
                                   llvm::StringRef name);
 
   static llvm::DenseSet<dw_offset_t> GetUnits(const DebugNames &debug_names);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_DEBUGNAMESDWARFINDEX_H

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

DebugNamesDWARFIndex::GetUnits(const DebugNames &debug_names) {
   llvm::DenseSet<dw_offset_t> result;
   for (const DebugNames::NameIndex &ni : debug_names) {
     for (uint32_t cu = 0; cu < ni.getCUCount(); ++cu)
       result.insert(ni.getCUOffset(cu));
   }
   return result;
 }
 
-DIERef DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
+llvm::Optional<DIERef>
+DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
   llvm::Optional<uint64_t> cu_offset = entry.getCUOffset();
   if (!cu_offset)
-    return DIERef();
+    return llvm::None;
 
   DWARFUnit *cu = m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, *cu_offset);
   if (!cu)
-    return DIERef();
+    return llvm::None;
 
   // 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(DIERef::Section::DebugInfo, *cu_offset, die_bias + *die_offset);
 
-  return DIERef();
+  return llvm::None;
 }
 
 void DebugNamesDWARFIndex::Append(const DebugNames::Entry &entry,
                                   DIEArray &offsets) {
-  if (DIERef ref = ToDIERef(entry))
-    offsets.push_back(ref);
+  if (llvm::Optional<DIERef> ref = ToDIERef(entry))
+    offsets.push_back(*ref);
 }
 
 void DebugNamesDWARFIndex::MaybeLogLookupError(llvm::Error error,
                                                const DebugNames::NameIndex &ni,
                                                llvm::StringRef name) {
   // Ignore SentinelErrors, log everything else.
   LLDB_LOG_ERROR(
       LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS),
void DebugNamesDWARFIndex::GetCompleteObjCClass(ConstString class_name,
   DIEArray incomplete_types;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(class_name.GetStringRef())) {
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
-    DIERef ref = ToDIERef(entry);
+    llvm::Optional<DIERef> ref = ToDIERef(entry);
     if (!ref)
       continue;
 
-    DWARFUnit *cu =
-        m_debug_info.GetUnitAtOffset(DIERef::Section::DebugInfo, 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);
+      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);
+    DWARFDIE die = m_debug_info.GetDIE(*ref);
     if (!die)
       continue;
 
     if (die.GetAttributeValueAsUnsigned(DW_AT_APPLE_objc_complete_type, 0)) {
       // If we find the complete version we're done.
-      offsets.push_back(ref);
+      offsets.push_back(*ref);
       return;
     } else {
-      incomplete_types.push_back(ref);
+      incomplete_types.push_back(*ref);
     }
   }
 
   offsets.insert(offsets.end(), incomplete_types.begin(),
                  incomplete_types.end());
 }
 
 void DebugNamesDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
void DebugNamesDWARFIndex::GetFunctions(
   m_fallback.GetFunctions(name, info, parent_decl_ctx, name_type_mask, v);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     Tag tag = entry.tag();
     if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
       continue;
 
-    if (DIERef ref = ToDIERef(entry))
-      ProcessFunctionDIE(name.GetStringRef(), ref, info, parent_decl_ctx,
+    if (llvm::Optional<DIERef> ref = ToDIERef(entry))
+      ProcessFunctionDIE(name.GetStringRef(), *ref, info, parent_decl_ctx,
                          name_type_mask, v);
   }
 
   std::set<DWARFDebugInfoEntry *> seen;
   for (DWARFDIE die : v)
     if (seen.insert(die.GetDIE()).second)
       dies.push_back(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 {
-    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
+    dw_offset_t die_offset = DW_INVALID_OFFSET;
+    dw_tag_t tag = 0;
 
-    DIEInfo();
-    DIEInfo(dw_offset_t c, dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
+    /// Any flags for this DIEInfo
+    uint32_t type_flags = 0;
 
-    explicit operator DIERef() const { return die_ref; }
+    /// A 32 bit hash of the fully qualified name
+    uint32_t qualified_name_hash = 0;
+
+    DIEInfo() = default;
+    DIEInfo(dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
+
+    explicit operator DIERef() const {
+      return DIERef(DIERef::Section::DebugInfo, DW_INVALID_OFFSET, die_offset);
+    }
   };
 
   struct Atom {
     AtomType type;
     dw_form_t form;
   };
 
   typedef std::vector<DIEInfo> DIEInfoArray;

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

const char *DWARFMappedHash::GetAtomTypeName(uint16_t atom) {
   case eAtomTypeTypeFlags:
     return "type-flags";
   case eAtomTypeQualNameHash:
     return "qualified-name-hash";
   }
   return "<invalid>";
 }
 
-DWARFMappedHash::DIEInfo::DIEInfo()
-    : 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)
-    : die_ref(DIERef::Section::DebugInfo, c, o), tag(t), type_flags(f),
-      qualified_name_hash(h) {}
+DWARFMappedHash::DIEInfo::DIEInfo(dw_offset_t o, dw_tag_t t, uint32_t f,
+                                  uint32_t h)
+    : die_offset(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(nullptr, 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.die_ref.die_offset =
+      hash_data.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;
 
     case eAtomTypeTypeFlags: // Flags from enum TypeFlags
       hash_data.type_flags = (uint32_t)form_value.Unsigned();
       break;
 
     case eAtomTypeQualNameHash: // Flags from enum TypeFlags
       hash_data.qualified_name_hash = form_value.Unsigned();
       break;
 
     default:
       // We can always skip atoms we don't know about
       break;
     }
   }
-  return true;
+  return hash_data.die_offset != DW_INVALID_OFFSET;
 }
 
 DWARFMappedHash::MemoryTable::MemoryTable(
     lldb_private::DWARFDataExtractor &table_data,
     const lldb_private::DWARFDataExtractor &string_table, const char *name)
     : MappedHash::MemoryTable<uint32_t, Header, DIEInfoArray>(table_data),
       m_data(table_data), m_string_table(string_table), m_name(name) {}
 
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.die_ref.die_offset == 0)
+          if (die_info.die_offset == 0)
             done = true;
-          if (die_offset_start <= die_info.die_ref.die_offset &&
-              die_info.die_ref.die_offset < die_offset_end)
+          if (die_offset_start <= die_info.die_offset &&
+              die_info.die_offset < die_offset_end)
             die_info_array.push_back(die_info);
         }
       }
     }
   }
   return die_info_array.size();
 }
 

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

public:
   virtual DWARFDIE GetDIE(const DIERef &die_ref);
 
   DWARFDIE GetDIE(lldb::user_id_t uid);
 
   lldb::user_id_t GetUID(const DWARFBaseDIE &die) {
     return GetUID(die.GetDIERef());
   }
 
+  lldb::user_id_t GetUID(const llvm::Optional<DIERef> &ref) {
+    return ref ? GetUID(*ref) : LLDB_INVALID_UID;
+  }
+
   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);
protected:
   virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() {
     return m_forward_decl_clang_type_to_die;
   }
 
   void BuildCuTranslationTable();
   llvm::Optional<uint32_t> GetDWARFUnitIndex(uint32_t cu_idx);
 
   struct DecodedUID {
-    SymbolFileDWARF *dwarf;
+    SymbolFileDWARF &dwarf;
     DIERef ref;
   };
-  DecodedUID DecodeUID(lldb::user_id_t uid);
+  llvm::Optional<DecodedUID> DecodeUID(lldb::user_id_t uid);
 
   SymbolFileDWARFDwp *GetDwpSymbolFile();
 
   const lldb_private::FileSpecList &GetTypeUnitSupportFiles(DWARFTypeUnit &tu);
 
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;
 

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

std::vector<DWARFDIE> decl_ctx_die_list =
       ast_parser->GetDIEForDeclContext(decl_ctx);
 
   for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
     for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl;
          decl = decl.GetSibling())
       ast_parser->GetDeclForUIDFromDWARF(decl);
 }
 
-SymbolFileDWARF::DecodedUID SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
+llvm::Optional<SymbolFileDWARF::DecodedUID>
+SymbolFileDWARF::DecodeUID(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());
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
   // must make sure we use the correct DWARF file when resolving things. On
   // 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, {DIERef::Section::DebugInfo, DW_INVALID_OFFSET, dw_offset_t(uid)}};
+    return DecodedUID{
+        *dwarf,
+        {DIERef::Section::DebugInfo, DW_INVALID_OFFSET, dw_offset_t(uid)}};
   }
   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()};
+    return llvm::None;
 
   SymbolFileDWARF *dwarf = this;
   if (DebugInfo()) {
     if (DWARFUnit *unit = DebugInfo()->GetUnitAtIndex(dwarf_id)) {
       if (unit->GetDwoSymbolFile())
         dwarf = unit->GetDwoSymbolFile();
     }
   }
-  return {dwarf, {section, DW_INVALID_OFFSET, die_offset}};
+  return DecodedUID{*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());
 
-  DecodedUID decoded = DecodeUID(uid);
+  llvm::Optional<DecodedUID> decoded = DecodeUID(uid);
 
-  if (decoded.dwarf)
-    return decoded.dwarf->GetDIE(decoded.ref);
+  if (decoded)
+    return decoded->dwarf.GetDIE(decoded->ref);
 
   return DWARFDIE();
 }
 
 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_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 (num_attributes > 0) {
         default:
           symbol_context_scope = sc.comp_unit;
           break;
         }
       }
 
       if (symbol_context_scope) {
         SymbolFileTypeSP type_sp(
-            new SymbolFileType(*this, GetUID(DIERef(type_die_form))));
+            new SymbolFileType(*this, GetUID(type_die_form.Reference())));
 
         if (const_value.Form() && type_sp && type_sp->GetType())
           location.UpdateValue(const_value.Unsigned(),
                                type_sp->GetType()->GetByteSize().getValueOr(0),
                                die.GetCU()->GetAddressByteSize());
 
         var_sp = std::make_shared<Variable>(
             die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,