Permit cross-CU references

[jankratochvil]

Summary

So far dw_offset_t was global for the whole SymbolFileDWARF but with .debug_types the same dw_offset_t may mean two different things depending on its section (=CU). So references now return whole new referenced DWARFDIE instead of just dw_offset_t.

This means that some functions have to now handle 16 bytes instead of 8 bytes but I do not see that anywhere performance critical.

[labath]

I like this patch in a lot of ways, because it makes the code cleaner, and prepares us for DWARF5, which can reference entries in other files in a lot of interesting ways.

The part I am not totally sure if is the alignment of lldb's DWARFFormValue with it's llvm counterpart. The llvm version does not have this fancy cross-unit resolution capability, but it just returns the raw value and leaves it up to the user to make sense of it (much like our class does now). However, it's possible that the llvm version does not have this functionality because there wasn't need for it, and it already has access to the DWARFContext, so it is certainly prepared to do more complex lookups, so it's possible it could be extended similarly once we go around to merging the two. And even if we go back to the world where form.Reference() returns a raw value, this may serve as a good intermediate step, because otherwise we'd have a hard time catching all the cases where someone calls Reference, and expects it to return an simple section offset.

So, overall, I'm inclined to accept this patch, but I'd like to hear what @JDevlieghere and @clayborg think.

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

114–115

It looks like these two functions are equivalent now and we can remove one of them (I vote to keep this one).

[clayborg]

Just a few simplifications to GetName() and AppendTypeName() are in question and can optionally be done if needed.

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

699

Should we make GetName() just take a DWARFDIE now?:

GetName(abstract_die, s);

705

Should we make AppendTypeName() just take a DWARFDIE now?:

AppendTypeName(type_die, s);

1199–1200

Should we make AppendTypeName() just take a DWARFDIE now?:

AppendTypeName(next_die, s);

[jankratochvil]

In D61502#1503247, @clayborg wrote:

Just a few simplifications to GetName() and AppendTypeName() are in question and can optionally be done if needed.

I will do that in a different patch as its removal of the SymbolFileDWARF *dwarf2Data parameter goes outside of scope of this patch.

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

 #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()) {
-    const DWARFUnit *dwarf_cu = form_value.GetCompileUnit();
-    if (dwarf_cu) {
-      section = dwarf_cu->GetDebugSection();
-      if (dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
-        cu_offset = dwarf_cu->GetBaseObjOffset();
+    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 = dwarf_cu->GetOffset();
+        cu_offset = die.GetCU()->GetOffset();
     }
-    die_offset = form_value.Reference();
   }
 }

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

if (type_ptr == NULL) {
           // a DWO file, so it is cheap to call this function just to check.
           //
           // If we don't do this we end up creating a TypeSP that says this is
           // a typedef to type 0x123 (the DW_AT_type value would be 0x123 in
           // the DW_TAG_typedef), and this is the unnamed structure type. We
           // will have a hard time tracking down an unnammed structure type in
           // the module DWO file, so we make sure we don't get into this
           // situation by always resolving typedefs from the DWO file.
-          const DWARFDIE encoding_die = dwarf->GetDIE(DIERef(encoding_uid));
+          const DWARFDIE encoding_die = encoding_uid.Reference();
 
           // First make sure that the die that this is typedef'ed to _is_ just
           // a declaration (DW_AT_declaration == 1), not a full definition
           // since template types can't be represented in modules since only
           // concrete instances of templates are ever emitted and modules won't
           // contain those
           if (encoding_die &&
               encoding_die.GetAttributeValueAsUnsigned(DW_AT_declaration, 0) ==
if (type_ptr == NULL) {
                 encoding_uid.Clear();
                 resolve_state = Type::eResolveStateFull;
               }
             } else if (encoding_data_type == Type::eEncodingIsPointerUID &&
                        encoding_uid.IsValid()) {
               // Clang sometimes erroneously emits id as objc_object*.  In that
               // case we fix up the type to "id".
 
-              const DWARFDIE encoding_die = dwarf->GetDIE(DIERef(encoding_uid));
+              const DWARFDIE encoding_die = encoding_uid.Reference();
 
               if (encoding_die && encoding_die.Tag() == DW_TAG_structure_type) {
                 if (const char *struct_name = encoding_die.GetName()) {
                   if (!strcmp(struct_name, "objc_object")) {
                     if (log)
                       dwarf->GetObjectFile()->GetModule()->LogMessage(
                           log, "SymbolFileDWARF::ParseType (die = 0x%8.8x) %s "
                                "'%s' is 'objc_object*', which we overrode to "
if (type_ptr == NULL) {
         bool is_inline = false;
         bool is_static = false;
         bool is_virtual = false;
         bool is_explicit = false;
         bool is_artificial = false;
         bool has_template_params = false;
         DWARFFormValue specification_die_form;
         DWARFFormValue abstract_origin_die_form;
-        dw_offset_t object_pointer_die_offset = DW_INVALID_OFFSET;
+        DWARFDIE object_pointer_die;
 
         unsigned type_quals = 0;
         clang::StorageClass storage =
             clang::SC_None; //, Extern, Static, PrivateExtern
 
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0) {
           uint32_t i;
if (type_ptr == NULL) {
                 specification_die_form = form_value;
                 break;
 
               case DW_AT_abstract_origin:
                 abstract_origin_die_form = form_value;
                 break;
 
               case DW_AT_object_pointer:
-                object_pointer_die_offset = form_value.Reference();
+                object_pointer_die = form_value.Reference();
                 break;
 
               case DW_AT_allocated:
               case DW_AT_associated:
               case DW_AT_address_class:
               case DW_AT_calling_convention:
               case DW_AT_data_location:
               case DW_AT_elemental:
if (type_ptr == NULL) {
               case DW_AT_sibling:
                 break;
               }
             }
           }
         }
 
         std::string object_pointer_name;
-        if (object_pointer_die_offset != DW_INVALID_OFFSET) {
-          DWARFDIE object_pointer_die = die.GetDIE(object_pointer_die_offset);
-          if (object_pointer_die) {
-            const char *object_pointer_name_cstr = object_pointer_die.GetName();
-            if (object_pointer_name_cstr)
-              object_pointer_name = object_pointer_name_cstr;
-          }
-        }
 
         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 (type_die_form.IsValid())

                   DWARFDIE spec_die = dwarf->DebugInfo()->GetDIE(
                       DIERef(specification_die_form));
                   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.8" PRIx64
+                        "0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x"
                         ") has no decl\n",
-                        die.GetID(), specification_die_form.Reference());
+                        die.GetID(),
+                        specification_die_form.Reference().GetOffset());
                   }
                   type_handled = true;
                 } else if (abstract_origin_die_form.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(abstract_origin_die_form));
                   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.8" PRIx64
+                        "0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x"
                         ") has no decl\n",
-                        die.GetID(), abstract_origin_die_form.Reference());
+                        die.GetID(),
+                        abstract_origin_die_form.Reference().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()) {

             }
           }
 
           if (!type_handled) {
             clang::FunctionDecl *function_decl = nullptr;
             clang::FunctionDecl *template_function_decl = nullptr;
 
             if (abstract_origin_die_form.IsValid()) {
-              DWARFDIE abs_die =
-                  dwarf->DebugInfo()->GetDIE(DIERef(abstract_origin_die_form));
+              DWARFDIE abs_die = abstract_origin_die_form.Reference();
 
               SymbolContext sc;
 
               if (dwarf->ResolveType(abs_die)) {
                 function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(
                     GetCachedClangDeclContextForDIE(abs_die));
 
                 if (function_decl) {
case DW_TAG_APPLE_property: {
                                                              UINT64_MAX);
 
                   if (member_byte_offset >= parent_byte_size) {
                     if (member_array_size != 1 &&
                         (member_array_size != 0 ||
                          member_byte_offset > parent_byte_size)) {
                       module_sp->ReportError(
                           "0x%8.8" PRIx64
-                          ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64
+                          ": DW_TAG_member '%s' refers to type 0x%8.8x"
                           " which extends beyond the bounds of 0x%8.8" PRIx64,
-                          die.GetID(), name, encoding_form.Reference(),
+                          die.GetID(), name,
+                          encoding_form.Reference().GetOffset(),
                           parent_die.GetID());
                     }
 
                     member_clang_type = m_ast.CreateArrayType(
                         member_array_element_type, 0, false);
                   }
                 }
               }
case DW_TAG_APPLE_property: {
               m_ast.SetMetadataAsUserID(field_decl, die.GetID());
 
               layout_info.field_offsets.insert(
                   std::make_pair(field_decl, field_bit_offset));
             } else {
               if (name)
                 module_sp->ReportError(
                     "0x%8.8" PRIx64
-                    ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64
+                    ": DW_TAG_member '%s' refers to type 0x%8.8x"
                     " which was unable to be parsed",
-                    die.GetID(), name, encoding_form.Reference());
+                    die.GetID(), name, encoding_form.Reference().GetOffset());
               else
                 module_sp->ReportError(
-                    "0x%8.8" PRIx64
-                    ": DW_TAG_member refers to type 0x%8.8" PRIx64
+                    "0x%8.8" PRIx64 ": DW_TAG_member refers to type 0x%8.8x"
                     " which was unable to be parsed",
-                    die.GetID(), encoding_form.Reference());
+                    die.GetID(), encoding_form.Reference().GetOffset());
             }
           }
 
           if (prop_name != NULL && member_type) {
             clang::ObjCIvarDecl *ivar_decl = NULL;
 
             if (field_decl) {
               ivar_decl = clang::dyn_cast<clang::ObjCIvarDecl>(field_decl);
case DW_TAG_inheritance: {
               break;
             }
           }
         }
 
         Type *base_class_type = die.ResolveTypeUID(DIERef(encoding_form));
         if (base_class_type == NULL) {
           module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to "
-                                 "resolve the base class at 0x%8.8" PRIx64
+                                 "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(),
+                                 die.GetOffset(),
+                                 encoding_form.Reference().GetOffset(),
                                  parent_die.GetOffset());
           break;
         }
 
         CompilerType base_class_clang_type =
             base_class_type->GetFullCompilerType();
         assert(base_class_clang_type);
         if (class_language == eLanguageTypeObjC) {
if (die) {
     if (num_attributes > 0) {
       DWARFFormValue type_die_form;
       for (size_t i = 0; i < num_attributes; ++i) {
         dw_attr_t attr = attributes.AttributeAtIndex(i);
         DWARFFormValue form_value;
 
         if (attr == DW_AT_type &&
             attributes.ExtractFormValueAtIndex(i, form_value))
-          return dwarf->ResolveTypeUID(dwarf->GetDIE(DIERef(form_value)), true);
+          return dwarf->ResolveTypeUID(form_value.Reference(), true);
       }
     }
   }
 
   return nullptr;
 }
 
 clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {

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

public:
   dw_offset_t DIEOffsetAtIndex(uint32_t i) const {
     return m_infos[i].die_offset;
   }
   dw_attr_t AttributeAtIndex(uint32_t i) const {
     return m_infos[i].attr.get_attr();
   }
   dw_attr_t FormAtIndex(uint32_t i) const { return m_infos[i].attr.get_form(); }
   bool ExtractFormValueAtIndex(uint32_t i, DWARFFormValue &form_value) const;
-  uint64_t FormValueAsUnsignedAtIndex(uint32_t i, uint64_t fail_value) const;
-  uint64_t FormValueAsUnsigned(dw_attr_t attr, uint64_t fail_value) const;
+  DWARFDIE FormValueAsReferenceAtIndex(uint32_t i) const;
+  DWARFDIE FormValueAsReference(dw_attr_t attr) const;
   uint32_t FindAttributeIndex(dw_attr_t attr) const;
   void Clear() { m_infos.clear(); }
   size_t Size() const { return m_infos.size(); }
 
 protected:
   struct AttributeValue {
     const DWARFUnit *cu;        // Keep the compile unit with each attribute in
                                 // case we have DW_FORM_ref_addr values
     dw_offset_t die_offset;
     DWARFAttribute attr;
   };
   typedef llvm::SmallVector<AttributeValue, 8> collection;
   collection m_infos;
 };
 
 #endif // SymbolFileDWARF_DWARFAttribute_h_

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

bool DWARFAttributes::ExtractFormValueAtIndex(
     uint32_t i, DWARFFormValue &form_value) const {
   const DWARFUnit *cu = CompileUnitAtIndex(i);
   form_value.SetCompileUnit(cu);
   form_value.SetForm(FormAtIndex(i));
   lldb::offset_t offset = DIEOffsetAtIndex(i);
   return form_value.ExtractValue(cu->GetData(), &offset);
 }
 
-uint64_t DWARFAttributes::FormValueAsUnsigned(dw_attr_t attr,
-                                              uint64_t fail_value) const {
+DWARFDIE
+DWARFAttributes::FormValueAsReference(dw_attr_t attr) const {
   const uint32_t attr_idx = FindAttributeIndex(attr);
   if (attr_idx != UINT32_MAX)
-    return FormValueAsUnsignedAtIndex(attr_idx, fail_value);
-  return fail_value;
+    return FormValueAsReferenceAtIndex(attr_idx);
+  return {};
 }
 
-uint64_t
-DWARFAttributes::FormValueAsUnsignedAtIndex(uint32_t i,
-                                            uint64_t fail_value) const {
+DWARFDIE
+DWARFAttributes::FormValueAsReferenceAtIndex(uint32_t i) const {
   DWARFFormValue form_value;
   if (ExtractFormValueAtIndex(i, form_value))
     return form_value.Reference();
-  return fail_value;
+  return {};
 }

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

 
 struct DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
 class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class SymbolFileDWARF;
+class DWARFDIE;
 
 class DWARFBaseDIE {
 public:
   DWARFBaseDIE() : m_cu(nullptr), m_die(nullptr) {}
 
   DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(die) {}
 
public:
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   const char *GetAttributeValueAsString(const dw_attr_t attr,
                                         const char *fail_value) const;
 
   uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr,
                                        uint64_t fail_value) const;
 
-  uint64_t GetAttributeValueAsReference(const dw_attr_t attr,
-                                        uint64_t fail_value) const;
+  DWARFDIE GetAttributeValueAsReference(const dw_attr_t attr) const;
 
   uint64_t GetAttributeValueAsAddress(const dw_attr_t attr,
                                       uint64_t fail_value) const;
 
   size_t GetAttributes(DWARFAttributes &attributes, uint32_t depth = 0) const;
 
 protected:
   DWARFUnit *m_cu;
   DWARFDebugInfoEntry *m_die;
 };
 
 bool operator==(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
 bool operator!=(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
 
 #endif // SymbolFileDWARF_DWARFBaseDIE_h_

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

uint64_t DWARFBaseDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr,
                                                uint64_t fail_value) const {
   if (IsValid())
     return m_die->GetAttributeValueAsUnsigned(GetDWARF(), GetCU(), attr,
                                               fail_value);
   else
     return fail_value;
 }
 
-uint64_t DWARFBaseDIE::GetAttributeValueAsReference(const dw_attr_t attr,
-                                                uint64_t fail_value) const {
+DWARFDIE
+DWARFBaseDIE::GetAttributeValueAsReference(const dw_attr_t attr) const {
   if (IsValid())
-    return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr,
-                                               fail_value);
+    return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr);
   else
-    return fail_value;
+    return {};
 }
 
 uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
                                               uint64_t fail_value) const {
   if (IsValid())
     return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr,
                                              fail_value);
   else

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

 DWARFDIE::GetSibling() const {
   if (IsValid())
     return DWARFDIE(m_cu, m_die->GetSibling());
   else
     return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::GetReferencedDIE(const dw_attr_t attr) const {
-  const dw_offset_t die_offset =
-      GetAttributeValueAsReference(attr, DW_INVALID_OFFSET);
-  if (die_offset != DW_INVALID_OFFSET)
-    return GetDIE(die_offset);
-  else
-    return DWARFDIE();
+  return GetAttributeValueAsReference(attr);
 }
 
 DWARFDIE
 DWARFDIE::GetDIE(dw_offset_t die_offset) const {
   if (IsValid())
     return m_cu->GetDIE(die_offset);
   else
     return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
   if (IsValid()) {
     DWARFUnit *cu = GetCU();
     SymbolFileDWARF *dwarf = cu->GetSymbolFileDWARF();
     const bool check_specification_or_abstract_origin = true;
     DWARFFormValue form_value;
     if (m_die->GetAttributeValue(dwarf, cu, attr, form_value, nullptr,
                                  check_specification_or_abstract_origin))
-      return dwarf->GetDIE(DIERef(form_value));
+      return form_value.Reference();
   }
   return DWARFDIE();
 }
 
 DWARFDIE
 DWARFDIE::LookupDeepestBlock(lldb::addr_t file_addr) const {
   if (IsValid()) {
     SymbolFileDWARF *dwarf = GetDWARF();

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

const char *GetAttributeValueAsString(
       const dw_attr_t attr, const char *fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsUnsigned(
       SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
-  uint64_t GetAttributeValueAsReference(
-      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-      const dw_attr_t attr, uint64_t fail_value,
+  DWARFDIE GetAttributeValueAsReference(
+      SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, const dw_attr_t attr,
       bool check_specification_or_abstract_origin = false) const;
 
   uint64_t GetAttributeValueAsAddress(
       SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
       const dw_attr_t attr, uint64_t fail_value,
       bool check_specification_or_abstract_origin = false) const;
 
   dw_addr_t

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

if (blockData) {
         DWARFExpression::PrintDWARFLocationList(
             s, cu, dwarf2Data->DebugLocData(), debug_loc_offset);
       }
     }
   } break;
 
   case DW_AT_abstract_origin:
   case DW_AT_specification: {
-    uint64_t abstract_die_offset = form_value.Reference();
+    DWARFDIE abstract_die = form_value.Reference();
     form_value.Dump(s);
-    //  *ostrm_ptr << HEX32 << abstract_die_offset << " ( ";
-    GetName(dwarf2Data, cu, abstract_die_offset, s);
+    //  *ostrm_ptr << HEX32 << abstract_die.GetOffset() << " ( ";
+    GetName(dwarf2Data, abstract_die.GetCU(), abstract_die.GetOffset(), s);
   } break;
 
   case DW_AT_type: {
-    uint64_t type_die_offset = form_value.Reference();
+    DWARFDIE type_die = form_value.Reference();
     s.PutCString(" ( ");
-    AppendTypeName(dwarf2Data, cu, type_die_offset, s);
+    AppendTypeName(dwarf2Data, type_die.GetCU(), type_die.GetOffset(), s);
     s.PutCString(" )");
   } break;
 
   case DW_AT_ranges: {
     if (!dwarf2Data)
       break;
     lldb::offset_t ranges_offset =
         GetRangesOffset(dwarf2Data->DebugRanges(), form_value);

 // precedence (this can happen for declaration attributes).
 size_t DWARFDebugInfoEntry::GetAttributes(
     const DWARFUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
     DWARFAttributes &attributes, uint32_t curr_depth) const {
   SymbolFileDWARF *dwarf2Data = nullptr;
   const DWARFAbbreviationDeclaration *abbrevDecl = nullptr;
   lldb::offset_t offset = 0;
   if (cu) {
-    if (m_tag != DW_TAG_compile_unit && m_tag != DW_TAG_partial_unit) {
-      SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
-      if (dwo_symbol_file)
-        return GetAttributes(dwo_symbol_file->GetCompileUnit(),
-                             fixed_form_sizes, attributes, curr_depth);
-    }
-
     dwarf2Data = cu->GetSymbolFileDWARF();
     abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
   }
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data = cu->GetData();
 
     if (fixed_form_sizes.Empty())
for (uint32_t i = 0; i < num_attributes; ++i) {
         LLVM_FALLTHROUGH;
       default:
         attributes.Append(cu, offset, attr, form);
         break;
       }
 
       if ((attr == DW_AT_specification) || (attr == DW_AT_abstract_origin)) {
         if (form_value.ExtractValue(debug_info_data, &offset)) {
-          dw_offset_t die_offset = form_value.Reference();
-          DWARFDIE spec_die =
-              const_cast<DWARFUnit *>(cu)->GetDIE(die_offset);
+          DWARFDIE spec_die = form_value.Reference();
           if (spec_die)
             spec_die.GetAttributes(attributes, curr_depth + 1);
         }
       } else {
         const uint8_t fixed_skip_size = fixed_form_sizes.GetSize(form);
         if (fixed_skip_size)
           offset += fixed_skip_size;
         else
if (attr_idx != DW_INVALID_INDEX) {
           *end_attr_offset_ptr = offset;
         return attr_offset;
       }
     }
   }
 
   if (check_specification_or_abstract_origin) {
     if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value)) {
-      DWARFDIE die =
-          const_cast<DWARFUnit *>(cu)->GetDIE(form_value.Reference());
+      DWARFDIE die = form_value.Reference();
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
             die.GetDWARF(), die.GetCU(), attr, form_value, end_attr_offset_ptr,
             false);
         if (die_offset)
           return die_offset;
       }
     }
 
     if (GetAttributeValue(dwarf2Data, cu, DW_AT_abstract_origin, form_value)) {
-      DWARFDIE die =
-          const_cast<DWARFUnit *>(cu)->GetDIE(form_value.Reference());
+      DWARFDIE die = form_value.Reference();
       if (die) {
         dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(
             die.GetDWARF(), die.GetCU(), attr, form_value, end_attr_offset_ptr,
             false);
         if (die_offset)
           return die_offset;
       }
     }
if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
     return form_value.Unsigned();
   return fail_value;
 }
 
 // GetAttributeValueAsReference
 //
 // Get the value of an attribute as reference and fix up and compile unit
 // relative offsets as needed.
-uint64_t DWARFDebugInfoEntry::GetAttributeValueAsReference(
-    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    const dw_attr_t attr, uint64_t fail_value,
+DWARFDIE DWARFDebugInfoEntry::GetAttributeValueAsReference(
+    SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu, const dw_attr_t attr,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
                         check_specification_or_abstract_origin))
     return form_value.Reference();
-  return fail_value;
+  return {};
 }
 
 uint64_t DWARFDebugInfoEntry::GetAttributeValueAsAddress(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, uint64_t fail_value,
     bool check_specification_or_abstract_origin) const {
   DWARFFormValue form_value;
   if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr,
if (die.IsNULL()) {
           break;
         default:
           return false;
         }
 
         // Follow the DW_AT_type if possible
         DWARFFormValue form_value;
         if (die.GetAttributeValue(dwarf2Data, cu, DW_AT_type, form_value)) {
-          uint64_t next_die_offset = form_value.Reference();
-          result = AppendTypeName(dwarf2Data, cu, next_die_offset, s);
+          DWARFDIE next_die = form_value.Reference();
+          result = AppendTypeName(dwarf2Data, next_die.GetCU(),
+                                  next_die.GetOffset(), s);
         }
 
         switch (abbrevDecl->Tag()) {
         case DW_TAG_array_type:
           s.PutCString("[]");
           break;
         case DW_TAG_pointer_type:
           s.PutChar('*');
if (die.GetDIE() != this) {
       case DW_TAG_class_type:
         return die;
 
       default:
         break;
       }
     }
 
-    dw_offset_t die_offset;
-
-    die_offset =
-        attributes.FormValueAsUnsigned(DW_AT_specification, DW_INVALID_OFFSET);
-    if (die_offset != DW_INVALID_OFFSET) {
-      DWARFDIE spec_die = cu->GetDIE(die_offset);
-      if (spec_die) {
-        DWARFDIE decl_ctx_die = spec_die.GetParentDeclContextDIE();
-        if (decl_ctx_die)
-          return decl_ctx_die;
-      }
-    }
+    DWARFDIE spec_die = attributes.FormValueAsReference(DW_AT_specification);
 
-    die_offset = attributes.FormValueAsUnsigned(DW_AT_abstract_origin,
-                                                DW_INVALID_OFFSET);
-    if (die_offset != DW_INVALID_OFFSET) {
-      DWARFDIE abs_die = cu->GetDIE(die_offset);
-      if (abs_die) {
-        DWARFDIE decl_ctx_die = abs_die.GetParentDeclContextDIE();
-        if (decl_ctx_die)
-          return decl_ctx_die;
-      }
-    }
+    DWARFDIE abs_die = attributes.FormValueAsReference(DW_AT_abstract_origin);
 
     die = die.GetParent();
   }
   return DWARFDIE();
 }
 
 const char *DWARFDebugInfoEntry::GetQualifiedName(SymbolFileDWARF *dwarf2Data,
                                                   DWARFUnit *cu,

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

 //===-- DWARFFormValue.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_DWARFFormValue_h_
 #define SymbolFileDWARF_DWARFFormValue_h_
 
 #include "DWARFDataExtractor.h"
 #include <stddef.h>
 
 class DWARFUnit;
 class SymbolFileDWARF;
+class DWARFDIE;
 
 class DWARFFormValue {
 public:
   typedef struct ValueTypeTag {
     ValueTypeTag() : value(), data(NULL) { value.uval = 0; }
 
     union {
       uint64_t uval;
enum {
     eValueTypeSigned,
     eValueTypeCStr,
     eValueTypeBlock
   };
 
   DWARFFormValue();
   DWARFFormValue(const DWARFUnit *cu);
   DWARFFormValue(const DWARFUnit *cu, dw_form_t form);
-  const DWARFUnit *GetCompileUnit() const { return m_cu; }
   void SetCompileUnit(const DWARFUnit *cu) { m_cu = cu; }
   dw_form_t Form() const { return m_form; }
   dw_form_t& FormRef() { return m_form; }
   void SetForm(dw_form_t form) { m_form = form; }
   const ValueType &Value() const { return m_value; }
   ValueType &ValueRef() { return m_value; }
   void SetValue(const ValueType &val) { m_value = val; }
 
   void Dump(lldb_private::Stream &s) const;
   bool ExtractValue(const lldb_private::DWARFDataExtractor &data,
                     lldb::offset_t *offset_ptr);
   const uint8_t *BlockData() const;
-  uint64_t Reference() const;
+  DWARFDIE Reference() const;
   uint64_t Reference(dw_offset_t offset) const;
   bool Boolean() const { return m_value.value.uval != 0; }
   uint64_t Unsigned() const { return m_value.value.uval; }
   void SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
   int64_t Signed() const { return m_value.value.sval; }
   void SetSigned(int64_t sval) { m_value.value.sval = sval; }
   const char *AsCString() const;
   dw_addr_t Address() const;
   bool IsValid() const { return m_form != 0; }
   bool SkipValue(const lldb_private::DWARFDataExtractor &debug_info_data,
                  lldb::offset_t *offset_ptr) const;
   static bool SkipValue(const dw_form_t form,
                         const lldb_private::DWARFDataExtractor &debug_info_data,
                         lldb::offset_t *offset_ptr, const DWARFUnit *cu);
   static bool IsBlockForm(const dw_form_t form);
   static bool IsDataForm(const dw_form_t form);
   static FixedFormSizes GetFixedFormSizesForAddressSize(uint8_t addr_size);
   static int Compare(const DWARFFormValue &a, const DWARFFormValue &b);
   void Clear();
   static bool FormIsSupported(dw_form_t form);
 
 protected:
-  const DWARFUnit *m_cu;        // Compile unit for this form
+  // Compile unit where m_value was located.
+  // It may be different from compile unit where m_value refers to.
+  const DWARFUnit *m_cu;
   dw_form_t m_form;             // Form for this value
   ValueType m_value;            // Contains all data for the form
 };
 
 #endif // SymbolFileDWARF_DWARFFormValue_h_

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

 //===-- DWARFFormValue.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 <assert.h>
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/Stream.h"
 
-#include "DWARFUnit.h"
+#include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
+#include "DWARFUnit.h"
 
 class DWARFUnit;
 
 using namespace lldb_private;
 
 static uint8_t g_form_sizes_addr4[] = {
     0, // 0x00 unused
     4, // 0x01 DW_FORM_addr
if (!symbol_file)
     return 0;
 
   uint32_t index_size = m_cu->GetAddressByteSize();
   dw_offset_t addr_base = m_cu->GetAddrBase();
   lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
   return symbol_file->get_debug_addr_data().GetMaxU64(&offset, index_size);
 }
 
-uint64_t DWARFFormValue::Reference() const {
+DWARFDIE DWARFFormValue::Reference() const {
   uint64_t value = m_value.value.uval;
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:
     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
                   // unit relative or we will get this wrong
-    return value + m_cu->GetOffset();
+    value += m_cu->GetOffset();
+    if (!m_cu->ContainsDIEOffset(value)) {
+      m_cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
+          "DW_FORM_ref* DIE reference 0x%" PRIx64 " is outside of its CU",
+          value);
+      return {};
+    }
+    return const_cast<DWARFUnit *>(m_cu)->GetDIE(value);
 
-  case DW_FORM_ref_addr:
-  case DW_FORM_ref_sig8:
-  case DW_FORM_GNU_ref_alt:
-    return value;
+  case DW_FORM_ref_addr: {
+    DWARFUnit *ref_cu =
+        m_cu->GetSymbolFileDWARF()->DebugInfo()->GetUnitContainingDIEOffset(
+            m_cu->GetDebugSection(), value);
+    if (!ref_cu) {
+      m_cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
+          "DW_FORM_ref_addr DIE reference 0x%" PRIx64 " has no matching CU",
+          value);
+      return {};
+    }
+    return ref_cu->GetDIE(value);
+  }
 
   default:
-    return DW_INVALID_OFFSET;
+    return {};
   }
 }
 
 uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
   uint64_t value = m_value.value.uval;
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
case DW_FORM_exprloc: {
     return memcmp(a_value.BlockData(), b_value.BlockData(), a_value.Unsigned());
   } break;
 
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata: {
-    uint64_t a = a_value.Reference();
-    uint64_t b = b_value.Reference();
+    uint64_t a = a_value.m_value.value.uval;
+    uint64_t b = b_value.m_value.value.uval;
     if (a < b)
       return -1;
     if (a > b)
       return 1;
     return 0;
   }
 
   case DW_FORM_indirect:

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

if (ContainsDIEOffset(die_offset)) {
       ExtractDIEsIfNeeded();
       DWARFDebugInfoEntry::const_iterator end = m_die_array.cend();
       DWARFDebugInfoEntry::const_iterator pos =
           lower_bound(m_die_array.cbegin(), end, die_offset, CompareDIEOffset);
       if (pos != end) {
         if (die_offset == (*pos).GetOffset())
           return DWARFDIE(this, &(*pos));
       }
-    } else {
-      // Don't specify the compile unit offset as we don't know it because the
-      // DIE belongs to
-      // a different compile unit in the same symbol file.
-      return m_dwarf->DebugInfo()->GetDIEForDIEOffset(GetDebugSection(),
-                                                      die_offset);
-    }
+    } else
+      GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
+          "GetDIE for DIE 0x%" PRIx32 " is outside of its CU 0x%" PRIx32,
+          die_offset, GetOffset());
   }
   return DWARFDIE(); // Not found
 }
 
 uint8_t DWARFUnit::GetAddressByteSize(const DWARFUnit *cu) {
   if (cu)
     return cu->GetAddressByteSize();
   return DWARFUnit::GetDefaultAddressSize();

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

if (num_attributes > 0) {
                 assert(func_low_pc != LLDB_INVALID_ADDRESS);
                 location.SetLocationListSlide(
                     func_low_pc -
                     attributes.CompileUnitAtIndex(i)->GetBaseAddress());
               }
             }
           } break;
           case DW_AT_specification:
-            spec_die = GetDIE(DIERef(form_value));
+            spec_die = form_value.Reference();
             break;
           case DW_AT_start_scope: {
             if (form_value.Form() == DW_FORM_sec_offset) {
               DWARFRangeList dwarf_scope_ranges;
               const DWARFDebugRangesBase *debug_ranges = DebugRanges();
               debug_ranges->FindRanges(die.GetCU(),
                                        form_value.Unsigned(),
                                        dwarf_scope_ranges);

 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification(
     const DWARFDIE &die, dw_offset_t spec_block_die_offset) {
   if (die) {
     switch (die.Tag()) {
     case DW_TAG_subprogram:
     case DW_TAG_inlined_subroutine:
     case DW_TAG_lexical_block: {
-      if (die.GetAttributeValueAsReference(
-              DW_AT_specification, DW_INVALID_OFFSET) == spec_block_die_offset)
+      if (die.GetAttributeValueAsReference(DW_AT_specification).GetOffset() ==
+          spec_block_die_offset)
         return die;
 
-      if (die.GetAttributeValueAsReference(DW_AT_abstract_origin,
-                                           DW_INVALID_OFFSET) ==
+      if (die.GetAttributeValueAsReference(DW_AT_abstract_origin).GetOffset() ==
           spec_block_die_offset)
         return die;
     } break;
     }
 
     // Give the concrete function die specified by "func_die_offset", find the
     // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
     // to "spec_block_die_offset"