Modify DWARFFormValue to remember the DWARFUnit that it was decoded with.

[clayborg]

Summary

Modifying DWARFFormValue to remember the DWARFUnit that it was encoded with can simplify the usage of instances of this class. Previously users would have to try and pass in the same DWARFUnit that was used to decode the form value and there was a possibility that a different DWARFUnit might be supplied to the functions that extract values (strings, CU relative references, addresses) and cause problems. This fixes this potential issue by storing the DWARFUnit inside the DWARFFormValue so that this mistake can't be made. Instances of DWARFFormValue are not stored permanently and are used as temporary values, so the increase in size of an instance of DWARFFormValue isn't a big deal. This makes decoding form values more bullet proof and is a change that will be used by future modifications.

[aprantl]

Can you say anything about the impact this change has on the memory footprint? Do we typically keep many DWARFFormValues around?

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

52

You can doxygen'ify this by using

dwarf::Form Form; ///< Form for this value.

or

/// Form for this value.
dwarf::Form Form;

lib/DebugInfo/DWARF/DWARFFormValue.cpp

136

A DataExtractor is only a StringRef + 2x uint8_t. Are we saving anything by passing it by reference?

[clayborg]

All DWARFFormValue objects are temporaries. I mentioned in the original description that this won't affect memory because of this.

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

52

This is how it was, I didn't change it, but I can add the doxygen /// if desired.

lib/DebugInfo/DWARF/DWARFFormValue.cpp

136

It just avoids the copy. It passes one pointer for the reference versus 2 pointers + 2 uint8_t values.

[aprantl]

This is probably fine then. Fred, this touches a bunch of dsymutil code — any concerns?

[friss]

Looks globally good. Some nits:

include/llvm/DebugInfo/DWARF/DWARFUnit.h

198–201

llvm-dsymutil has a helper that does the same computation. Please add this helper and remove dsymutil's one in a preliminary commit.

tools/dsymutil/DwarfLinker.cpp

1487–1490

If the FormValue holds the Unit, let's stop passing it around in small helpers like this. RefValue->getUnit() can be used below.

2358

U is just unused here AFAICS, just remove it.

[aprantl]

LGTM (with feedback addressed).
Thanks!

[clayborg]

I will fix the one issue Fred Riss asked for and commit.

include/llvm/DebugInfo/DWARF/DWARFUnit.h

201

I will fix this.

tools/dsymutil/DwarfLinker.cpp

1490

I will fix this in a commit that is coming up soon. I am going to make a DWARFDIE class that encapsulates both the DwarfUnit and the DWARFDebugInfoEntryMinimal into one unit so all raw DWARFUnit objects will no longer be passed around. So I am going to defer fixing this until that patch since the new patch will take care of this.

[clayborg]

Committed with SVN revision 285594.

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

struct ValueType {
     union {
       uint64_t uval;
       int64_t sval;
       const char* cstr;
     };
     const uint8_t* data;
   };
 
-  dwarf::Form Form;   // Form for this value.
+  dwarf::Form Form; // Form for this value.
   ValueType Value; // Contains all data for the form.
+  const DWARFUnit *U; // Remember the DWARFUnit at extract time.
 
 public:
-  DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F) {}
+  DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F), U(nullptr) {}
   dwarf::Form getForm() const { return Form; }
   bool isFormClass(FormClass FC) const;
-
-  void dump(raw_ostream &OS, const DWARFUnit *U) const;
+  const DWARFUnit *getUnit() const { return U; }
+  void dump(raw_ostream &OS) const;
 
   /// \brief extracts a value in data at offset *offset_ptr.
   ///
   /// The passed DWARFUnit is allowed to be nullptr, in which
   /// case no relocation processing will be performed and some
   /// kind of forms that depend on Unit information are disallowed.
   /// \returns whether the extraction succeeded.
-  bool extractValue(DataExtractor data, uint32_t *offset_ptr,
-                    const DWARFUnit *u);
+  bool extractValue(const DataExtractor &Data, uint32_t *OffsetPtr,
+                    const DWARFUnit *U);
   bool isInlinedCStr() const {
     return Value.data != nullptr && Value.data == (const uint8_t*)Value.cstr;
   }
 
   /// getAsFoo functions below return the extracted value as Foo if only
   /// DWARFFormValue has form class is suitable for representing Foo.
-  Optional<uint64_t> getAsReference(const DWARFUnit *U) const;
+  Optional<uint64_t> getAsReference() const;
   Optional<uint64_t> getAsUnsignedConstant() const;
   Optional<int64_t> getAsSignedConstant() const;
-  Optional<const char *> getAsCString(const DWARFUnit *U) const;
-  Optional<uint64_t> getAsAddress(const DWARFUnit *U) const;
+  Optional<const char *> getAsCString() const;
+  Optional<uint64_t> getAsAddress() const;
   Optional<uint64_t> getAsSectionOffset() const;
   Optional<ArrayRef<uint8_t>> getAsBlock() const;
 
   bool skipValue(DataExtractor debug_info_data, uint32_t *offset_ptr,
-                 const DWARFUnit *u) const;
+                 const DWARFUnit *U) const;
   static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
                         uint32_t *offset_ptr, const DWARFUnit *u);
   static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
                         uint32_t *offset_ptr, uint16_t Version,
                         uint8_t AddrSize);
 
   static ArrayRef<uint8_t> getFixedFormSizes(uint8_t AddrSize,
                                              uint16_t Version);
 private:
-  void dumpString(raw_ostream &OS, const DWARFUnit *U) const;
+  void dumpString(raw_ostream &OS) const;
 };
 
 }
 
 #endif

include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
   uint32_t getOffset() const { return Offset; }
   uint32_t getNextUnitOffset() const { return Offset + Length + 4; }
   uint32_t getLength() const { return Length; }
   uint16_t getVersion() const { return Version; }
   const DWARFAbbreviationDeclarationSet *getAbbreviations() const {
     return Abbrevs;
   }
   uint8_t getAddressByteSize() const { return AddrSize; }
+  uint8_t getRefAddrByteSize() const {
+    // FIXME: Support DWARF64.
+    return (Version == 2) ? AddrSize : 4;
+  }
   uint64_t getBaseAddress() const { return BaseAddr; }
 
   void setBaseAddress(uint64_t base_addr) {
     BaseAddr = base_addr;
   }
 
   const DWARFDebugInfoEntryMinimal *getUnitDIE(bool ExtractUnitDIEOnly = true) {
     extractDIEsIfNeeded(ExtractUnitDIEOnly);

lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp

for (unsigned HashIdx = Index; HashIdx < Hdr.NumHashes; ++HashIdx) {
                      StringSection.getCStr(&StringOffset));
         unsigned NumData = AccelSection.getU32(&DataOffset);
         for (unsigned Data = 0; Data < NumData; ++Data) {
           OS << format("    Data[%d] => ", Data);
           unsigned i = 0;
           for (auto &Atom : AtomForms) {
             OS << format("{Atom[%d]: ", i++);
             if (Atom.extractValue(AccelSection, &DataOffset, nullptr))
-              Atom.dump(OS, nullptr);
+              Atom.dump(OS);
             else
               OS << "Error extracting the value";
             OS << "} ";
           }
           OS << '\n';
         }
       }
     }
   }
 }
 }

lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
   } else if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
     Name = AttributeValueString(attr, *Val);
 
   if (!Name.empty())
     WithColor(OS, Color) << Name;
   else if (attr == DW_AT_decl_line || attr == DW_AT_call_line)
     OS << *formValue.getAsUnsignedConstant();
   else
-    formValue.dump(OS, u);
+    formValue.dump(OS);
 
   // We have dumped the attribute raw value. For some attributes
   // having both the raw value and the pretty-printed value is
   // interesting. These attributes are handled below.
   if (attr == DW_AT_specification || attr == DW_AT_abstract_origin) {
-    Optional<uint64_t> Ref = formValue.getAsReference(u);
+    Optional<uint64_t> Ref = formValue.getAsReference();
     if (Ref.hasValue()) {
       uint32_t RefOffset = Ref.getValue();
       DWARFDebugInfoEntryMinimal DIE;
       if (const DWARFUnit *RefU = findUnitAndExtractFast(DIE, u, &RefOffset))
         if (const char *Name = DIE.getName(RefU, DINameKind::LinkageName))
           OS << " \"" << Name << '\"';
     }
   } else if (attr == DW_AT_APPLE_property_attribute) {

 }
 
 const char *DWARFDebugInfoEntryMinimal::getAttributeValueAsString(
     const DWARFUnit *U, dwarf::Attribute Attr, 
     const char *FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
-  Optional<const char *> Result = FormValue.getAsCString(U);
+  Optional<const char *> Result = FormValue.getAsCString();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsAddress(
     const DWARFUnit *U, dwarf::Attribute Attr, 
     uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
-  Optional<uint64_t> Result = FormValue.getAsAddress(U);
+  Optional<uint64_t> Result = FormValue.getAsAddress();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsUnsignedConstant(
     const DWARFUnit *U, dwarf::Attribute Attr, 
     uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
   Optional<uint64_t> Result = FormValue.getAsUnsignedConstant();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsReference(
     const DWARFUnit *U, dwarf::Attribute Attr, 
     uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))
     return FailValue;
-  Optional<uint64_t> Result = FormValue.getAsReference(U);
+  Optional<uint64_t> Result = FormValue.getAsReference();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDebugInfoEntryMinimal::getAttributeValueAsSectionOffset(
     const DWARFUnit *U, dwarf::Attribute Attr, 
     uint64_t FailValue) const {
   DWARFFormValue FormValue;
   if (!getAttributeValue(U, Attr, FormValue))

lib/DebugInfo/DWARF/DWARFFormValue.cpp

bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
   }
   // In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
   // Don't check for DWARF version here, as some producers may still do this
   // by mistake.
   return (Form == DW_FORM_data4 || Form == DW_FORM_data8) &&
          FC == FC_SectionOffset;
 }
 
-bool DWARFFormValue::extractValue(DataExtractor data, uint32_t *offset_ptr,
+bool DWARFFormValue::extractValue(const DataExtractor &data, 
+                                  uint32_t *offset_ptr,
                                   const DWARFUnit *cu) {
+  U = cu;
   bool indirect = false;
   bool is_block = false;
   Value.data = nullptr;
   // Read the value for the form into value and follow and DW_FORM_indirect
   // instances we run into
   do {
     indirect = false;
     switch (Form) {
     case DW_FORM_addr:
     case DW_FORM_ref_addr: {
-      if (!cu)
+      if (!U)
         return false;
       uint16_t AddrSize =
           (Form == DW_FORM_addr)
-              ? cu->getAddressByteSize()
-              : getRefAddrSize(cu->getAddressByteSize(), cu->getVersion());
-      RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr);
-      if (AI != cu->getRelocMap()->end()) {
+              ? U->getAddressByteSize()
+              : U->getRefAddrByteSize();
+      RelocAddrMap::const_iterator AI = U->getRelocMap()->find(*offset_ptr);
+      if (AI != U->getRelocMap()->end()) {
         const std::pair<uint8_t, int64_t> &R = AI->second;
         Value.uval = data.getUnsigned(offset_ptr, AddrSize) + R.second;
       } else
         Value.uval = data.getUnsigned(offset_ptr, AddrSize);
       break;
     }
     case DW_FORM_exprloc:
     case DW_FORM_block:
case DW_FORM_flag:
       break;
     case DW_FORM_data2:
     case DW_FORM_ref2:
       Value.uval = data.getU16(offset_ptr);
       break;
     case DW_FORM_data4:
     case DW_FORM_ref4: {
       Value.uval = data.getU32(offset_ptr);
-      if (!cu)
+      if (!U)
         break;
-      RelocAddrMap::const_iterator AI = cu->getRelocMap()->find(*offset_ptr-4);
-      if (AI != cu->getRelocMap()->end())
+      RelocAddrMap::const_iterator AI = U->getRelocMap()->find(*offset_ptr-4);
+      if (AI != U->getRelocMap()->end())
         Value.uval += AI->second.second;
       break;
     }
     case DW_FORM_data8:
     case DW_FORM_ref8:
       Value.uval = data.getU64(offset_ptr);
       break;
     case DW_FORM_sdata:
case DW_FORM_indirect:
       indirect = true;
       break;
     case DW_FORM_sec_offset:
     case DW_FORM_strp:
     case DW_FORM_GNU_ref_alt:
     case DW_FORM_GNU_strp_alt: {
       // FIXME: This is 64-bit for DWARF64.
       Value.uval = data.getU32(offset_ptr);
-      if (!cu)
+      if (!U)
         break;
       RelocAddrMap::const_iterator AI =
-          cu->getRelocMap()->find(*offset_ptr - 4);
-      if (AI != cu->getRelocMap()->end())
+          U->getRelocMap()->find(*offset_ptr - 4);
+      if (AI != U->getRelocMap()->end())
         Value.uval += AI->second.second;
       break;
     }
     case DW_FORM_flag_present:
       Value.uval = 1;
       break;
     case DW_FORM_ref_sig8:
       Value.uval = data.getU64(offset_ptr);
if (is_block) {
     }
   }
 
   return true;
 }
 
 bool
 DWARFFormValue::skipValue(DataExtractor debug_info_data, uint32_t* offset_ptr,
-                          const DWARFUnit *cu) const {
-  return DWARFFormValue::skipValue(Form, debug_info_data, offset_ptr, cu);
+                          const DWARFUnit *U) const {
+  return DWARFFormValue::skipValue(Form, debug_info_data, offset_ptr, U);
 }
 
 bool
 DWARFFormValue::skipValue(dwarf::Form form, DataExtractor debug_info_data,
                           uint32_t *offset_ptr, const DWARFUnit *cu) {
   return skipValue(form, debug_info_data, offset_ptr, cu->getVersion(),
                    cu->getAddressByteSize());
 }
do {
     default:
       return false;
     }
   } while (indirect);
   return true;
 }
 
 void
-DWARFFormValue::dump(raw_ostream &OS, const DWARFUnit *cu) const {
+DWARFFormValue::dump(raw_ostream &OS) const {
   uint64_t uvalue = Value.uval;
   bool cu_relative_offset = false;
 
   switch (Form) {
   case DW_FORM_addr:      OS << format("0x%016" PRIx64, uvalue); break;
   case DW_FORM_GNU_addr_index: {
     OS << format(" indexed (%8.8x) address = ", (uint32_t)uvalue);
     uint64_t Address;
-    if (cu->getAddrOffsetSectionItem(uvalue, Address))
+    if (U == nullptr)
+      OS << "<invalid dwarf unit>";
+    else if (U->getAddrOffsetSectionItem(uvalue, Address))
       OS << format("0x%016" PRIx64, Address);
     else
       OS << "<no .debug_addr section>";
     break;
   }
   case DW_FORM_flag_present: OS << "true"; break;
   case DW_FORM_flag:
   case DW_FORM_data1:     OS << format("0x%02x", (uint8_t)uvalue); break;
if (uvalue > 0) {
         OS << "NULL";
     }
     break;
 
   case DW_FORM_sdata:     OS << Value.sval; break;
   case DW_FORM_udata:     OS << Value.uval; break;
   case DW_FORM_strp: {
     OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
-    dumpString(OS, cu);
+    dumpString(OS);
     break;
   }
   case DW_FORM_GNU_str_index: {
     OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);
-    dumpString(OS, cu);
+    dumpString(OS);
     break;
   }
   case DW_FORM_GNU_strp_alt: {
     OS << format("alt indirect string, offset: 0x%" PRIx64 "", uvalue);
-    dumpString(OS, cu);
+    dumpString(OS);
     break;
   }
   case DW_FORM_ref_addr:
     OS << format("0x%016" PRIx64, uvalue);
     break;
   case DW_FORM_ref1:
     cu_relative_offset = true;
     OS << format("cu + 0x%2.2x", (uint8_t)uvalue);
DWARFFormValue::dump(raw_ostream &OS) const {
   default:
     OS << format("DW_FORM(0x%4.4x)", Form);
     break;
   }
 
   if (cu_relative_offset) {
     OS << " => {";
     WithColor(OS, syntax::Address).get()
-      << format("0x%8.8" PRIx64, uvalue + (cu ? cu->getOffset() : 0));
+      << format("0x%8.8" PRIx64, uvalue + (U ? U->getOffset() : 0));
     OS << "}";
   }
 }
 
-void DWARFFormValue::dumpString(raw_ostream &OS, const DWARFUnit *U) const {
-  Optional<const char *> DbgStr = getAsCString(U);
+void DWARFFormValue::dumpString(raw_ostream &OS) const {
+  Optional<const char *> DbgStr = getAsCString();
   if (DbgStr.hasValue()) {
     raw_ostream &COS = WithColor(OS, syntax::String);
     COS << '"';
     COS.write_escaped(DbgStr.getValue());
     COS << '"';
   }
 }
 
-Optional<const char *> DWARFFormValue::getAsCString(const DWARFUnit *U) const {
+Optional<const char *> DWARFFormValue::getAsCString() const {
   if (!isFormClass(FC_String))
     return None;
   if (Form == DW_FORM_string)
     return Value.cstr;
   // FIXME: Add support for DW_FORM_GNU_strp_alt
   if (Form == DW_FORM_GNU_strp_alt || U == nullptr)
     return None;
   uint32_t Offset = Value.uval;
   if (Form == DW_FORM_GNU_str_index) {
     uint32_t StrOffset;
     if (!U->getStringOffsetSectionItem(Offset, StrOffset))
       return None;
     Offset = StrOffset;
   }
   if (const char *Str = U->getStringExtractor().getCStr(&Offset)) {
     return Str;
   }
   return None;
 }
 
-Optional<uint64_t> DWARFFormValue::getAsAddress(const DWARFUnit *U) const {
+Optional<uint64_t> DWARFFormValue::getAsAddress() const {
   if (!isFormClass(FC_Address))
     return None;
   if (Form == DW_FORM_GNU_addr_index) {
     uint32_t Index = Value.uval;
     uint64_t Result;
     if (!U || !U->getAddrOffsetSectionItem(Index, Result))
       return None;
     return Result;
   }
   return Value.uval;
 }
 
-Optional<uint64_t> DWARFFormValue::getAsReference(const DWARFUnit *U) const {
+Optional<uint64_t> DWARFFormValue::getAsReference() const {
   if (!isFormClass(FC_Reference))
     return None;
   switch (Form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

 }
 
 void DWARFTypeUnit::dump(raw_ostream &OS, bool SummarizeTypes) {
   const DWARFDebugInfoEntryMinimal *TD =
       getDIEForOffset(TypeOffset + getOffset());
   DWARFFormValue NameVal;
   const char *Name = "";
   if (TD->getAttributeValue(this, llvm::dwarf::DW_AT_name, NameVal))
-    if (auto ON = NameVal.getAsCString(this))
+    if (auto ON = NameVal.getAsCString())
       Name = *ON;
 
   if (SummarizeTypes) {
     OS << "name = '" << Name << "'"
        << " type_signature = " << format("0x%16" PRIx64, TypeHash)
        << " length = " << format("0x%08x", getLength()) << '\n';
     return;
   }

tools/dsymutil/DwarfLinker.cpp

 }
 
 /// Resolve the DIE attribute reference that has been
 /// extracted in \p RefValue. The resulting DIE migh be in another
 /// CompileUnit which is stored into \p ReferencedCU.
 /// \returns null if resolving fails for any reason.
 static const DWARFDebugInfoEntryMinimal *resolveDIEReference(
     const DwarfLinker &Linker, MutableArrayRef<CompileUnit> Units,
     const DWARFFormValue &RefValue, const DWARFUnit &Unit,
     const DWARFDebugInfoEntryMinimal &DIE, CompileUnit *&RefCU) {
   assert(RefValue.isFormClass(DWARFFormValue::FC_Reference));
-  uint64_t RefOffset = *RefValue.getAsReference(&Unit);
+  uint64_t RefOffset = *RefValue.getAsReference();
 
   if ((RefCU = getUnitForOffset(Units, RefOffset)))
     if (const auto *RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset))
       return RefDie;
 
   Linker.reportWarning("could not find referenced DIE", &Unit, &DIE);
   return nullptr;
 }
unsigned DwarfLinker::shouldKeepSubprogramDIE(
   if (!DIE.getAttributeValue(&OrigUnit, dwarf::DW_AT_high_pc, HighPcValue)) {
     reportWarning("Function without high_pc. Range will be discarded.\n",
                   &OrigUnit, &DIE);
     return Flags;
   }
 
   uint64_t HighPc;
   if (HighPcValue.isFormClass(DWARFFormValue::FC_Address)) {
-    HighPc = *HighPcValue.getAsAddress(&OrigUnit);
+    HighPc = *HighPcValue.getAsAddress();
   } else {
     assert(HighPcValue.isFormClass(DWARFFormValue::FC_Constant));
     HighPc = LowPc + *HighPcValue.getAsUnsignedConstant();
   }
 
   // Replace the debug map range with a more accurate one.
   Ranges[LowPc] = std::make_pair(HighPc, MyInfo.AddrAdjust);
   Unit.addFunctionRange(LowPc, HighPc, MyInfo.AddrAdjust);
if (InSet) {
     Abbrev.setNumber(Abbreviations.size());
     Abbreviations.back()->setNumber(Abbreviations.size());
   }
 }
 
 unsigned DwarfLinker::DIECloner::cloneStringAttribute(DIE &Die,
                                                       AttributeSpec AttrSpec,
                                                       const DWARFFormValue &Val,
                                                       const DWARFUnit &U) {
   // Switch everything to out of line strings.
-  const char *String = *Val.getAsCString(&U);
+  const char *String = *Val.getAsCString();
   unsigned Offset = Linker.StringPool.getStringOffset(String);
   Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp,
                DIEInteger(Offset));
   return 4;
 }
 
 unsigned DwarfLinker::DIECloner::cloneDieReferenceAttribute(
     DIE &Die, const DWARFDebugInfoEntryMinimal &InputDIE,
     AttributeSpec AttrSpec, unsigned AttrSize, const DWARFFormValue &Val,
     CompileUnit &Unit) {
   const DWARFUnit &U = Unit.getOrigUnit();
-  uint32_t Ref = *Val.getAsReference(&U);
+  uint32_t Ref = *Val.getAsReference();
   DIE *NewRefDie = nullptr;
   CompileUnit *RefUnit = nullptr;
   DeclContext *Ctxt = nullptr;
 
   const DWARFDebugInfoEntryMinimal *RefDie =
       resolveDIEReference(Linker, CompileUnits, Val, U, InputDIE, RefUnit);
 
   // If the referenced DIE is not found,  drop the attribute.
unsigned DwarfLinker::DIECloner::cloneBlockAttribute(DIE &Die,
   }
   Die.addValue(DIEAlloc, Value);
   return AttrSize;
 }
 
 unsigned DwarfLinker::DIECloner::cloneAddressAttribute(
     DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
     const CompileUnit &Unit, AttributesInfo &Info) {
-  uint64_t Addr = *Val.getAsAddress(&Unit.getOrigUnit());
+  uint64_t Addr = *Val.getAsAddress();
   if (AttrSpec.Attr == dwarf::DW_AT_low_pc) {
     if (Die.getTag() == dwarf::DW_TAG_inlined_subroutine ||
         Die.getTag() == dwarf::DW_TAG_lexical_block)
       // The low_pc of a block or inline subroutine might get
       // relocated because it happens to match the low_pc of the
       // enclosing subprogram. To prevent issues with that, always use
       // the low_pc from the input DIE if relocations have been applied.
       Addr = (Info.OrigLowPc != UINT64_MAX ? Info.OrigLowPc : Addr) +