Alternative proposal to https://reviews.llvm.org/D28581 where we return a DWARFormValue from DWARFDie::find*() functions

[clayborg]

Summary

This code seems to be more natural as it keeps things cleaner and more readable. I prefer this option over the one in https://reviews.llvm.org/D28581.

Did this to allow us to compare the two approaches to see which one we like better.

[clayborg]

Whoops I accidentally added "aam" as a reviewer instead of Adrian...

[aprantl]

When comparing with https://reviews.llvm.org/D28581 I think this variant is much more readable.

lib/DebugInfo/DWARF/DWARFDie.cpp

217

if (auto RangeOffset = ...)

[clayborg]

After speaking with Adrian who had spoken with Dave Blaike, we settled on using the other proposal.

include/llvm/DebugInfo/DWARF/DWARFDie.h

public:
   ///
   /// Extract an attribute value from this DIE only. This call doesn't look
   /// for the attribute value in any DW_AT_specification or
   /// DW_AT_abstract_origin referenced DIEs.
   ///
   /// \param Attr the attribute to extract.
   /// \returns an optional DWARFFormValue that will have the form value if the
   /// attribute was successfully extracted.
-  Optional<DWARFFormValue> getAttributeValue(dwarf::Attribute Attr) const;
-  
-  /// Extract the specified attribute from this DIE as a C string.
-  ///
-  /// Extract an attribute value from this DIE only. This call doesn't look
-  /// for the attribute value in any DW_AT_specification or
-  /// DW_AT_abstract_origin referenced DIEs.
-  ///
-  /// \param Attr the attribute to extract.
-  /// \param FailValue the value to return if this DIE doesn't have this
-  /// attribute.
-  /// \returns the NULL terminated C string value owned by the DWARF section
-  /// that contains the string or FailValue if the attribute doesn't exist or
-  /// if the attribute's form isn't a form that describes an string.
-  const char *getAttributeValueAsString(dwarf::Attribute Attr,
-                                        const char *FailValue) const;
-  
-  /// Extract the specified attribute from this DIE as an address.
-  ///
-  /// Extract an attribute value from this DIE only. This call doesn't look
-  /// for the attribute value in any DW_AT_specification or
-  /// DW_AT_abstract_origin referenced DIEs.
-  ///
-  /// \param Attr the attribute to extract.
-  /// \returns an optional value for the attribute.
-  Optional<uint64_t> getAttributeValueAsAddress(dwarf::Attribute Attr) const;
-  
-  /// Extract the specified attribute from this DIE as a signed integer.
-  ///
-  /// Extract an attribute value from this DIE only. This call doesn't look
-  /// for the attribute value in any DW_AT_specification or
-  /// DW_AT_abstract_origin referenced DIEs.
-  ///
-  /// \param Attr the attribute to extract.
-  /// \returns an optional value for the attribute.
-  Optional<int64_t>
-  getAttributeValueAsSignedConstant(dwarf::Attribute Attr) const;
-  
-  /// Extract the specified attribute from this DIE as an unsigned integer.
-  ///
-  /// Extract an attribute value from this DIE only. This call doesn't look
-  /// for the attribute value in any DW_AT_specification or
-  /// DW_AT_abstract_origin referenced DIEs.
-  ///
-  /// \param Attr the attribute to extract.
-  /// \returns an optional value for the attribute.
-  Optional<uint64_t>
-  getAttributeValueAsUnsignedConstant(dwarf::Attribute Attr) const;
-
-  /// Extract the specified attribute from this DIE as absolute DIE Offset.
-  ///
-  /// Extract an attribute value from this DIE only. This call doesn't look
-  /// for the attribute value in any DW_AT_specification or
-  /// DW_AT_abstract_origin referenced DIEs.
-  ///
-  /// \param Attr the attribute to extract.
-  /// \returns an optional value for the attribute.
-  Optional<uint64_t> getAttributeValueAsReference(dwarf::Attribute Attr) const;
-  
-  /// Extract the specified attribute from this DIE as absolute section offset.
-  ///
-  /// Extract an attribute value from this DIE only. This call doesn't look
-  /// for the attribute value in any DW_AT_specification or
-  /// DW_AT_abstract_origin referenced DIEs.
-  ///
-  /// \param Attr the attribute to extract.
-  /// \returns an optional value for the attribute.
-  Optional<uint64_t>
-  getAttributeValueAsSectionOffset(dwarf::Attribute Attr) const;
-  
+  DWARFFormValue find(dwarf::Attribute Attr) const;
+  DWARFFormValue findRecursively(dwarf::Attribute Attr) const;
   /// Extract the specified attribute from this DIE as the referenced DIE.
   ///
   /// Regardless of the reference type, return the correct DWARFDie instance if
   /// the attribute exists. The returned DWARFDie object might be from another
   /// DWARFUnit, but that is all encapsulated in the new DWARFDie object.
   ///
   /// Extract an attribute value from this DIE only. This call doesn't look
   /// for the attribute value in any DW_AT_specification or
   /// DW_AT_abstract_origin referenced DIEs.
   ///
   /// \param Attr the attribute to extract.
   /// \returns a valid DWARFDie instance if the attribute exists, or an invalid
   /// DWARFDie object if it doesn't.
   DWARFDie getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const;
   
+
   /// Extract the range base attribute from this DIE as absolute section offset.
   ///
   /// This is a utility function that checks for either the DW_AT_rnglists_base
   /// or DW_AT_GNU_ranges_base attribute.
   ///
   /// \returns anm optional absolute section offset value for the attribute.
   Optional<uint64_t> getRangesBaseAttribute() const;
   

include/llvm/DebugInfo/DWARF/DWARFFormValue.h

union {
       uint64_t uval;
       int64_t sval;
       const char* cstr;
     };
     const uint8_t* data;
   };
 
   dwarf::Form Form; // Form for this value.
+  bool Valid;
   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), U(nullptr) {}
+  DWARFFormValue(dwarf::Form F = dwarf::Form(0)) : Form(F), Valid(false), U(nullptr) {}
+  bool isValid() const { return Valid; }
+  operator bool() const { return Valid; }
   dwarf::Form getForm() const { return Form; }
-  void setForm(dwarf::Form F) { Form = F; }
-  void setUValue(uint64_t V) { Value.uval = V; }
-  void setSValue(int64_t V) { Value.sval = V; }
-  void setPValue(const char *V) { Value.cstr = V; }
+  void setForm(dwarf::Form F) { Valid = Form == F; Form = F;}
+  void setUValue(uint64_t V) { Value.uval = V; Valid = true; }
+  void setSValue(int64_t V) { Value.sval = V; Valid = true; }
+  void setPValue(const char *V) { Value.cstr = V; Valid = true; }
   bool isFormClass(FormClass FC) 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

lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(raw_ostream &OS, DIDumpType DumpType, bool DumpEH,
   uint8_t savedAddressByteSize = 0;
   if (DumpType == DIDT_All || DumpType == DIDT_Line) {
     OS << "\n.debug_line contents:\n";
     for (const auto &CU : compile_units()) {
       savedAddressByteSize = CU->getAddressByteSize();
       auto CUDIE = CU->getUnitDIE();
       if (!CUDIE)
         continue;
-      if (auto StmtOffset =
-              CUDIE.getAttributeValueAsSectionOffset(DW_AT_stmt_list)) {
+      if (auto StmtOffset = CUDIE.find(DW_AT_stmt_list).getAsSectionOffset()) {
         DataExtractor lineData(getLineSection().Data, isLittleEndian(),
                                savedAddressByteSize);
         DWARFDebugLine::LineTable LineTable;
         uint32_t Offset = *StmtOffset;
         LineTable.parse(lineData, &getLineSection().Relocs, &Offset);
         LineTable.dump(OS);
       }
     }

 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   if (!Line)
     Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
 
   auto UnitDIE = U->getUnitDIE();
   if (!UnitDIE)
     return nullptr;
 
-  auto Offset = UnitDIE.getAttributeValueAsSectionOffset(DW_AT_stmt_list);
+  auto Offset = UnitDIE.find(DW_AT_stmt_list).getAsSectionOffset();
   if (!Offset)
     return nullptr; // No line table for this compile unit.
 
   uint32_t stmtOffset = *Offset + U->getLineTableOffset();
   // See if the line table is cached.
   if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
     return lt;
 

lib/DebugInfo/DWARF/DWARFDie.cpp

bool DWARFDie::isSubprogramDIE() const {
   return getTag() == DW_TAG_subprogram;
 }
 
 bool DWARFDie::isSubroutineDIE() const {
   auto Tag = getTag();
   return Tag == DW_TAG_subprogram || Tag == DW_TAG_inlined_subroutine;
 }
 
-Optional<DWARFFormValue>
-DWARFDie::getAttributeValue(dwarf::Attribute Attr) const {
+DWARFFormValue
+DWARFDie::find(dwarf::Attribute Attr) const {
   if (!isValid())
-    return None;
+    return DWARFFormValue();
   auto AbbrevDecl = getAbbreviationDeclarationPtr();
   if (AbbrevDecl)
-    return AbbrevDecl->getAttributeValue(getOffset(), Attr, *U);
-  return None;
-}
-
-const char *DWARFDie::getAttributeValueAsString(dwarf::Attribute Attr,
-                                                const char *FailValue) const {
-  auto FormValue = getAttributeValue(Attr);
-  if (!FormValue)
-    return FailValue;
-  Optional<const char *> Result = FormValue->getAsCString();
-  return Result.hasValue() ? Result.getValue() : FailValue;
-}
-
-Optional<uint64_t>
-DWARFDie::getAttributeValueAsAddress(dwarf::Attribute Attr) const {
-  if (auto FormValue = getAttributeValue(Attr))
-    return FormValue->getAsAddress();
-  return None;
-}
-
-Optional<int64_t>
-DWARFDie::getAttributeValueAsSignedConstant(dwarf::Attribute Attr) const {
-  if (auto FormValue = getAttributeValue(Attr))
-    return FormValue->getAsSignedConstant();
-  return None;
-}
-
-Optional<uint64_t>
-DWARFDie::getAttributeValueAsUnsignedConstant(dwarf::Attribute Attr) const {
-  if (auto FormValue = getAttributeValue(Attr))
-    return FormValue->getAsUnsignedConstant();
-  return None;
-}
-
-Optional<uint64_t>
-DWARFDie::getAttributeValueAsReference(dwarf::Attribute Attr) const {
-  if (auto FormValue = getAttributeValue(Attr))
-    return FormValue->getAsReference();
-  return None;
+    if (auto FormValueOpt = AbbrevDecl->getAttributeValue(getOffset(), Attr, *U))
+      return *FormValueOpt;
+  return DWARFFormValue();
 }
 
-Optional<uint64_t>
-DWARFDie::getAttributeValueAsSectionOffset(dwarf::Attribute Attr) const {
-  if (auto FormValue = getAttributeValue(Attr))
-    return FormValue->getAsSectionOffset();
-  return None;
+DWARFFormValue
+DWARFDie::findRecursively(dwarf::Attribute Attr) const {
+  if (!isValid())
+    return DWARFFormValue();
+  if (auto Value = find(Attr))
+    return Value;
+  if (auto Die = getAttributeValueAsReferencedDie(DW_AT_abstract_origin))
+    if (auto Value = Die.find(Attr))
+      return Value;
+  if (auto Die = getAttributeValueAsReferencedDie(DW_AT_specification))
+    if (auto Value = Die.find(Attr))
+      return Value;
+  return DWARFFormValue();
 }
 
-
 DWARFDie
 DWARFDie::getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const {
-  auto SpecRef = getAttributeValueAsReference(Attr);
+  auto SpecRef = find(Attr).getAsReference();
   if (SpecRef) {
     auto SpecUnit = U->getUnitSection().getUnitForOffset(*SpecRef);
     if (SpecUnit)
       return SpecUnit->getDIEForOffset(*SpecRef);
   }
   return DWARFDie();
 }
 
 Optional<uint64_t>
 DWARFDie::getRangesBaseAttribute() const {
-  auto Result = getAttributeValueAsSectionOffset(DW_AT_rnglists_base);
+  auto Result = find(DW_AT_rnglists_base).getAsSectionOffset();
   if (Result)
     return Result;
-  return getAttributeValueAsSectionOffset(DW_AT_GNU_ranges_base);
+  return find(DW_AT_GNU_ranges_base).getAsSectionOffset();
 }
 
 Optional<uint64_t> DWARFDie::getHighPC(uint64_t LowPC) const {
-  if (auto FormValue = getAttributeValue(DW_AT_high_pc)) {
-    if (auto Address = FormValue->getAsAddress()) {
+  if (auto FormValue = find(DW_AT_high_pc)) {
+    if (auto Address = FormValue.getAsAddress()) {
       // High PC is an address.
       return Address;
     }
-    if (auto Offset = FormValue->getAsUnsignedConstant()) {
+    if (auto Offset = FormValue.getAsUnsignedConstant()) {
       // High PC is an offset from LowPC.
       return LowPC + *Offset;
     }
   }
   return None;
 }
 
 bool DWARFDie::getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC) const {
-  auto LowPcAddr = getAttributeValueAsAddress(DW_AT_low_pc);
+  auto LowPcAddr = find(DW_AT_low_pc).getAsAddress();
   if (!LowPcAddr)
     return false;
   if (auto HighPcAddr = getHighPC(*LowPcAddr)) {
     LowPC = *LowPcAddr;
     HighPC = *HighPcAddr;
     return true;
   }
   return false;
 }
 
 DWARFAddressRangesVector
 DWARFDie::getAddressRanges() const {
   if (isNULL())
     return DWARFAddressRangesVector();
   // Single range specified by low/high PC.
   uint64_t LowPC, HighPC;
   if (getLowAndHighPC(LowPC, HighPC)) {
     return DWARFAddressRangesVector(1, std::make_pair(LowPC, HighPC));
   }
   // Multiple ranges from .debug_ranges section.
-  auto RangesOffset = getAttributeValueAsSectionOffset(DW_AT_ranges);
+  auto RangesOffset = find(DW_AT_ranges).getAsSectionOffset();
   if (RangesOffset) {
     DWARFDebugRangeList RangeList;
     if (U->extractRangeList(*RangesOffset, RangeList))
       return RangeList.getAbsoluteRanges(U->getBaseAddress());
   }
   return DWARFAddressRangesVector();
 }
 
if (!isSubroutineDIE())
     return nullptr;
   return getName(Kind);
 }
 
 const char *
 DWARFDie::getName(DINameKind Kind) const {
   if (!isValid() || Kind == DINameKind::None)
     return nullptr;
-  const char *name = nullptr;
+  Optional<const char *> Name;
   // Try to get mangled name only if it was asked for.
   if (Kind == DINameKind::LinkageName) {
-    if ((name = getAttributeValueAsString(DW_AT_MIPS_linkage_name, nullptr)))
-      return name;
-    if ((name = getAttributeValueAsString(DW_AT_linkage_name, nullptr)))
-      return name;
-  }
-  if ((name = getAttributeValueAsString(DW_AT_name, nullptr)))
-    return name;
-  // Try to get name from specification DIE.
-  DWARFDie SpecDie = getAttributeValueAsReferencedDie(DW_AT_specification);
-  if (SpecDie && (name = SpecDie.getName(Kind)))
-    return name;
-  // Try to get name from abstract origin DIE.
-  DWARFDie AbsDie = getAttributeValueAsReferencedDie(DW_AT_abstract_origin);
-  if (AbsDie && (name = AbsDie.getName(Kind)))
-    return name;
+    if ((Name = findRecursively(DW_AT_MIPS_linkage_name).getAsCString()))
+      return *Name;
+    if ((Name = findRecursively(DW_AT_linkage_name).getAsCString()))
+      return *Name;
+  }
+  if ((Name = findRecursively(DW_AT_name).getAsCString()))
+    return *Name;
   return nullptr;
 }
 
 void DWARFDie::getCallerFrame(uint32_t &CallFile, uint32_t &CallLine,
                               uint32_t &CallColumn) const {
-  CallFile = getAttributeValueAsUnsignedConstant(DW_AT_call_file).getValueOr(0);
-  CallLine = getAttributeValueAsUnsignedConstant(DW_AT_call_line).getValueOr(0);
-  CallColumn =
-      getAttributeValueAsUnsignedConstant(DW_AT_call_column).getValueOr(0);
+  CallFile = find(DW_AT_call_file).getAsUnsignedConstant().getValueOr(0);
+  CallLine = find(DW_AT_call_line).getAsUnsignedConstant().getValueOr(0);
+  CallColumn = find(DW_AT_call_column).getAsUnsignedConstant().getValueOr(0);
 }
 
 void DWARFDie::dump(raw_ostream &OS, unsigned RecurseDepth,
                     unsigned Indent) const {
   if (!isValid())
     return;
   DataExtractor debug_info_data = U->getDebugInfoExtractor();
   const uint32_t Offset = getOffset();

lib/DebugInfo/DWARF/DWARFFormValue.cpp

 
 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;
+  Valid = false;
   // 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 (!U)
bool DWARFFormValue::extractValue(const DataExtractor &data,
   if (is_block) {
     StringRef str = data.getData().substr(*offset_ptr, Value.uval);
     Value.data = nullptr;
     if (!str.empty()) {
       Value.data = reinterpret_cast<const uint8_t *>(str.data());
       *offset_ptr += Value.uval;
     }
   }
-
+  Valid = true;
   return true;
 }
 
 bool DWARFFormValue::skipValue(DataExtractor DebugInfoData,
                                uint32_t *offset_ptr, const DWARFUnit *U) const {
   return DWARFFormValue::skipValue(Form, DebugInfoData, offset_ptr, U);
 }
 
if (DbgStr.hasValue()) {
     raw_ostream &COS = WithColor(OS, syntax::String);
     COS << '"';
     COS.write_escaped(DbgStr.getValue());
     COS << '"';
   }
 }
 
 Optional<const char *> DWARFFormValue::getAsCString() const {
-  if (!isFormClass(FC_String))
+  if (!isValid() || !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 {
-  if (!isFormClass(FC_Address))
+  if (!isValid() || !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 {
-  if (!isFormClass(FC_Reference))
+  if (!isValid() || !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:
     if (!U)
       return None;
     return Value.uval + U->getOffset();
   case DW_FORM_ref_addr:
   case DW_FORM_ref_sig8:
   case DW_FORM_GNU_ref_alt:
     return Value.uval;
   default:
     return None;
   }
 }
 
 Optional<uint64_t> DWARFFormValue::getAsSectionOffset() const {
-  if (!isFormClass(FC_SectionOffset))
+  if (!isValid() || !isFormClass(FC_SectionOffset))
     return None;
   return Value.uval;
 }
 
 Optional<uint64_t> DWARFFormValue::getAsUnsignedConstant() const {
-  if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag))
+  if (!isValid() || (!isFormClass(FC_Constant) && !isFormClass(FC_Flag))
       || Form == DW_FORM_sdata)
     return None;
   return Value.uval;
 }
 
 Optional<int64_t> DWARFFormValue::getAsSignedConstant() const {
-  if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
+  if (!isValid() || (!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
       (Form == DW_FORM_udata && uint64_t(std::numeric_limits<int64_t>::max()) < Value.uval))
     return None;
   switch (Form) {
   case DW_FORM_data4:
     return int32_t(Value.uval);
   case DW_FORM_data2:
     return int16_t(Value.uval);
   case DW_FORM_data1:
     return int8_t(Value.uval);
   case DW_FORM_sdata:
   case DW_FORM_data8:
   default:
     return Value.sval;
   }
 }
 
 Optional<ArrayRef<uint8_t>> DWARFFormValue::getAsBlock() const {
-  if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc))
+  if (!isValid() || !isFormClass(FC_Block) && !isFormClass(FC_Exprloc))
     return None;
   return makeArrayRef(Value.data, Value.uval);
 }
 
 Optional<uint64_t> DWARFFormValue::getAsCStringOffset() const {
-  if (!isFormClass(FC_String) && Form == DW_FORM_string)
+  if (!isValid() || !isFormClass(FC_String) && Form == DW_FORM_string)
     return None;
   return Value.uval;
 }
 
 Optional<uint64_t> DWARFFormValue::getAsReferenceUVal() const {
-  if (!isFormClass(FC_Reference))
+  if (!isValid() || !isFormClass(FC_Reference))
     return None;
   return Value.uval;
 }
 

lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

if (!DWARFUnit::extractImpl(debug_info, offset_ptr))
     return false;
   TypeHash = debug_info.getU64(offset_ptr);
   TypeOffset = debug_info.getU32(offset_ptr);
   return TypeOffset < getLength();
 }
 
 void DWARFTypeUnit::dump(raw_ostream &OS, bool SummarizeTypes) {
   DWARFDie TD = getDIEForOffset(TypeOffset + getOffset());
-  const char *Name = TD.getAttributeValueAsString(llvm::dwarf::DW_AT_name, "");
+  const char *Name = TD.find(llvm::dwarf::DW_AT_name).getAsCString().getValueOr("");
 
   if (SummarizeTypes) {
     OS << "name = '" << Name << "'"
        << " type_signature = " << format("0x%16" PRIx64, TypeHash)
        << " length = " << format("0x%08x", getLength()) << '\n';
     return;
   }
 

lib/DebugInfo/DWARF/DWARFUnit.cpp

 //===-- DWARFUnit.cpp -----------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Path.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
void DWARFUnit::clear() {
   BaseAddr = 0;
   RangeSectionBase = 0;
   AddrOffsetSectionBase = 0;
   clearDIEs(false);
   DWO.reset();
 }
 
 const char *DWARFUnit::getCompilationDir() {
-  return getUnitDIE().getAttributeValueAsString(DW_AT_comp_dir, nullptr);
+  return getUnitDIE().find(DW_AT_comp_dir).getAsCString().getValueOr(nullptr);
 }
 
 Optional<uint64_t> DWARFUnit::getDWOId() {
-  return getUnitDIE().getAttributeValueAsUnsignedConstant(DW_AT_GNU_dwo_id);
+  return getUnitDIE().find(DW_AT_GNU_dwo_id).getAsUnsignedConstant();
 }
 
 void DWARFUnit::extractDIEsToVector(
     bool AppendCUDie, bool AppendNonCUDies,
     std::vector<DWARFDebugInfoEntry> &Dies) const {
   if (!AppendCUDie && !AppendNonCUDies)
     return;
 
size_t DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
   extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
 
   if (DieArray.empty())
     return 0;
 
   // If CU DIE was just parsed, copy several attribute values from it.
   if (!HasCUDie) {
     DWARFDie UnitDie = getUnitDIE();
-    auto BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_low_pc);
+    auto BaseAddr = UnitDie.find(DW_AT_low_pc).getAsAddress();
     if (!BaseAddr)
-      BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_entry_pc);
+      BaseAddr = UnitDie.find(DW_AT_entry_pc).getAsAddress();
     if (BaseAddr)
       setBaseAddress(*BaseAddr);
     AddrOffsetSectionBase =
-        UnitDie.getAttributeValueAsSectionOffset(DW_AT_GNU_addr_base)
-            .getValueOr(0);
+        UnitDie.find(DW_AT_GNU_addr_base).getAsSectionOffset().getValueOr(0);
     RangeSectionBase =
-        UnitDie.getAttributeValueAsSectionOffset(DW_AT_rnglists_base)
-            .getValueOr(0);
+        UnitDie.find(DW_AT_rnglists_base).getAsSectionOffset().getValueOr(0);
     // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
     // skeleton CU DIE, so that DWARF users not aware of it are not broken.
   }
 
   return DieArray.size();
 }
 
 DWARFUnit::DWOHolder::DWOHolder(StringRef DWOPath)
bool DWARFUnit::parseDWO() {
   if (isDWO)
     return false;
   if (DWO.get())
     return false;
   DWARFDie UnitDie = getUnitDIE();
   if (!UnitDie)
     return false;
   const char *DWOFileName =
-      UnitDie.getAttributeValueAsString(DW_AT_GNU_dwo_name, nullptr);
+      UnitDie.find(DW_AT_GNU_dwo_name).getAsCString().getValueOr(nullptr);
   if (!DWOFileName)
     return false;
   const char *CompilationDir =
-      UnitDie.getAttributeValueAsString(DW_AT_comp_dir, nullptr);
+      UnitDie.find(DW_AT_comp_dir).getAsCString().getValueOr(nullptr);
   SmallString<16> AbsolutePath;
   if (sys::path::is_relative(DWOFileName) && CompilationDir != nullptr) {
     sys::path::append(AbsolutePath, CompilationDir);
   }
   sys::path::append(AbsolutePath, DWOFileName);
   DWO = llvm::make_unique<DWOHolder>(AbsolutePath);
   DWARFUnit *DWOCU = DWO->getUnit();
   // Verify that compile unit in .dwo file is valid.

tools/dsymutil/DwarfLinker.cpp

CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,
                                             OrigUnit.getAddressByteSize(),
                                             OrigUnit.getUnitDIE().getTag()),
           LowPc(UINT64_MAX), HighPc(0), RangeAlloc(), Ranges(RangeAlloc),
           ClangModuleName(ClangModuleName) {
     Info.resize(OrigUnit.getNumDIEs());
 
     auto CUDie = OrigUnit.getUnitDIE(false);
     unsigned Lang =
-        CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_language)
-            .getValueOr(0);
+        CUDie.find(dwarf::DW_AT_language).getAsUnsignedConstant().getValueOr(0);
     HasODR = CanUseODR && (Lang == dwarf::DW_LANG_C_plus_plus ||
                            Lang == dwarf::DW_LANG_C_plus_plus_03 ||
                            Lang == dwarf::DW_LANG_C_plus_plus_11 ||
                            Lang == dwarf::DW_LANG_C_plus_plus_14 ||
                            Lang == dwarf::DW_LANG_ObjC_plus_plus);
   }
 
   DWARFUnit &getOrigUnit() const { return OrigUnit; }
void DwarfStreamer::emitLocationsForUnit(const CompileUnit &Unit,
   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfLocSection());
 
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
   const DWARFSection &InputSec = Dwarf.getLocSection();
   DataExtractor Data(InputSec.Data, Dwarf.isLittleEndian(), AddressSize);
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
   int64_t UnitPcOffset = 0;
-  auto OrigLowPc = OrigUnitDie.getAttributeValueAsAddress(dwarf::DW_AT_low_pc);
+  auto OrigLowPc = OrigUnitDie.find(dwarf::DW_AT_low_pc).getAsAddress();
   if (OrigLowPc)
     UnitPcOffset = int64_t(*OrigLowPc) - Unit.getLowPc();
 
   for (const auto &Attr : Attributes) {
     uint32_t Offset = Attr.first.get();
     Attr.first.set(LocSectionSize);
     // This is the quantity to add to the old location address to get
     // the correct address for the new one.
PointerIntPair<DeclContext *, 1> DeclContextTree::getChildDeclContext(
   case dwarf::DW_TAG_module:
     break;
   case dwarf::DW_TAG_compile_unit:
     return PointerIntPair<DeclContext *, 1>(&Context);
   case dwarf::DW_TAG_subprogram:
     // Do not unique anything inside CU local functions.
     if ((Context.getTag() == dwarf::DW_TAG_namespace ||
          Context.getTag() == dwarf::DW_TAG_compile_unit) &&
-        !DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_external)
-             .getValueOr(0))
+        !DIE.find(dwarf::DW_AT_external).getAsUnsignedConstant().getValueOr(0))
       return PointerIntPair<DeclContext *, 1>(nullptr);
     LLVM_FALLTHROUGH;
   case dwarf::DW_TAG_member:
   case dwarf::DW_TAG_namespace:
   case dwarf::DW_TAG_structure_type:
   case dwarf::DW_TAG_class_type:
   case dwarf::DW_TAG_union_type:
   case dwarf::DW_TAG_enumeration_type:
   case dwarf::DW_TAG_typedef:
     // Artificial things might be ambiguous, because they might be
     // created on demand. For example implicitely defined constructors
     // are ambiguous because of the way we identify contexts, and they
     // won't be generated everytime everywhere.
-    if (DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_artificial)
-            .getValueOr(0))
+    if (DIE.find(dwarf::DW_AT_artificial).getAsUnsignedConstant().getValueOr(0))
       return PointerIntPair<DeclContext *, 1>(nullptr);
     break;
   }
 
   const char *Name = DIE.getName(DINameKind::LinkageName);
   const char *ShortName = DIE.getName(DINameKind::ShortName);
   StringRef NameRef;
   StringRef ShortNameRef;
PointerIntPair<DeclContext *, 1> DeclContextTree::getChildDeclContext(
   if (!InClangModule) {
     // Gather some discriminating data about the DeclContext we will be
     // creating: File, line number and byte size. This shouldn't be
     // necessary, because the ODR is just about names, but given that we
     // do some approximations with overloaded functions and anonymous
     // namespaces, use these additional data points to make the process
     // safer.  This is disabled for clang modules, because forward
     // declarations of module-defined types do not have a file and line.
-    ByteSize = DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_byte_size)
+    ByteSize = DIE.find(dwarf::DW_AT_byte_size).getAsUnsignedConstant()
                    .getValueOr(UINT64_MAX);
     if (Tag != dwarf::DW_TAG_namespace || !Name) {
       if (unsigned FileNum =
-              DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_decl_file)
+              DIE.find(dwarf::DW_AT_decl_file).getAsUnsignedConstant()
                   .getValueOr(0)) {
         if (const auto *LT = U.getOrigUnit().getContext().getLineTableForUnit(
                 &U.getOrigUnit())) {
           // FIXME: dsymutil-classic compatibility. I'd rather not
           // unique anything in anonymous namespaces, but if we do, then
           // verify that the file and line correspond.
           if (!Name && Tag == dwarf::DW_TAG_namespace)
             FileNum = 1;
 
           // FIXME: Passing U.getOrigUnit().getCompilationDir()
           // instead of "" would allow more uniquing, but for now, do
           // it this way to match dsymutil-classic.
           if (LT->hasFileAtIndex(FileNum)) {
             Line =
-                DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_decl_line)
+                DIE.find(dwarf::DW_AT_decl_line).getAsUnsignedConstant()
                     .getValueOr(0);
             // Cache the resolved paths, because calling realpath is expansive.
             StringRef ResolvedPath = U.getResolvedPath(FileNum);
             if (!ResolvedPath.empty()) {
               FileRef = ResolvedPath;
             } else {
               std::string File;
               bool gotFileName =
static bool analyzeContextInfo(const DWARFDie &DIE,
   // This does not extend to the types inside the modules:
   //  "[I]n C, this implies that if two structs are defined in
   //   different submodules with the same name, those two types are
   //   distinct types (but may be compatible types if their
   //   definitions match)."
   //
   // We treat non-C++ modules like namespaces for this reason.
   if (DIE.getTag() == dwarf::DW_TAG_module && ParentIdx == 0 &&
-      DIE.getAttributeValueAsString(dwarf::DW_AT_name,
-                                    "") != CU.getClangModuleName()) {
+      DIE.find(dwarf::DW_AT_name).getAsCString().getValueOr("") !=
+          CU.getClangModuleName()) {
     InImportedModule = true;
   }
 
   Info.ParentIdx = ParentIdx;
   bool InClangModule = CU.isClangModule() || InImportedModule;
   if (CU.hasODR() || InClangModule) {
     if (CurrentDeclContext) {
       auto PtrInvalidPair = Contexts.getChildDeclContext(
for (auto Child: DIE.children())
       Info.Prune &= analyzeContextInfo(Child, MyIdx, CU, CurrentDeclContext,
                                        StringPool, Contexts, InImportedModule);
 
   // Prune this DIE if it is either a forward declaration inside a
   // DW_TAG_module or a DW_TAG_module that contains nothing but
   // forward declarations.
   Info.Prune &=
       (DIE.getTag() == dwarf::DW_TAG_module) ||
-      DIE.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_declaration)
-          .getValueOr(0);
+      DIE.find(dwarf::DW_AT_declaration).getAsUnsignedConstant().getValueOr(0);
 
   // Don't prune it if there is no definition for the DIE.
   Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset();
 
   return Info.Prune;
 }
 
 static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag) {
if (!LowPcIdx)
     return Flags;
 
   uint32_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
   const DWARFUnit &OrigUnit = Unit.getOrigUnit();
   uint32_t LowPcOffset, LowPcEndOffset;
   std::tie(LowPcOffset, LowPcEndOffset) =
       getAttributeOffsets(Abbrev, *LowPcIdx, Offset, OrigUnit);
 
-  auto LowPc = DIE.getAttributeValueAsAddress(dwarf::DW_AT_low_pc);
+  auto LowPc = DIE.find(dwarf::DW_AT_low_pc).getAsAddress();
   assert(LowPc.hasValue() && "low_pc attribute is not an address.");
   if (!LowPc ||
       !RelocMgr.hasValidRelocation(LowPcOffset, LowPcEndOffset, MyInfo))
     return Flags;
 
   if (Options.Verbose)
     DIE.dump(outs(), 0, 8 /* Indent */);
 
if (RelocMgr.applyValidRelocs(DIECopy, Offset, Data.isLittleEndian())) {
     // If we applied relocations, we store the value of high_pc that was
     // potentially stored in the input DIE. If high_pc is an address
     // (Dwarf version == 2), then it might have been relocated to a
     // totally unrelated value (because the end address in the object
     // file might be start address of another function which got moved
     // independantly by the linker). The computation of the actual
     // high_pc value is done in cloneAddressAttribute().
     AttrInfo.OrigHighPc =
-        InputDIE.getAttributeValueAsAddress(dwarf::DW_AT_high_pc).getValueOr(0);
+        InputDIE.find(dwarf::DW_AT_high_pc).getAsAddress().getValueOr(0);
     // Also store the low_pc. It might get relocated in an
     // inline_subprogram that happens at the beginning of its
     // inlining function.
     AttrInfo.OrigLowPc =
-        InputDIE.getAttributeValueAsAddress(dwarf::DW_AT_low_pc)
-            .getValueOr(UINT64_MAX);
+        InputDIE.find(dwarf::DW_AT_low_pc).getAsAddress().getValueOr(UINT64_MAX);
   }
 
   // Reset the Offset to 0 as we will be working on the local copy of
   // the data.
   Offset = 0;
 
   const auto *Abbrev = InputDIE.getAbbreviationDeclarationPtr();
   Offset += getULEB128Size(Abbrev->getCode());
void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
   const auto &FunctionRanges = Unit.getFunctionRanges();
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
   DataExtractor RangeExtractor(OrigDwarf.getRangeSection(),
                                OrigDwarf.isLittleEndian(), AddressSize);
   auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
   uint64_t OrigLowPc =
-      OrigUnitDie.getAttributeValueAsAddress(dwarf::DW_AT_low_pc)
-          .getValueOr(-1ULL);
+      OrigUnitDie.find(dwarf::DW_AT_low_pc).getAsAddress().getValueOr(-1ULL);
   // Ranges addresses are based on the unit's low_pc. Compute the
   // offset we need to apply to adapt to the new unit's low_pc.
   int64_t UnitPcOffset = 0;
   if (OrigLowPc != -1ULL)
     UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
 
   for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
     uint32_t Offset = RangeAttribute.get();

 }
 
 /// \brief Extract the line table for \p Unit from \p OrigDwarf, and
 /// recreate a relocated version of these for the address ranges that
 /// are present in the binary.
 void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
                                         DWARFContext &OrigDwarf) {
   DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
-  auto StmtList = CUDie.getAttributeValueAsSectionOffset(dwarf::DW_AT_stmt_list);
+  auto StmtList = CUDie.find(dwarf::DW_AT_stmt_list).getAsSectionOffset();
   if (!StmtList)
     return;
 
   // Update the cloned DW_AT_stmt_list with the correct debug_line offset.
   if (auto *OutputDIE = Unit.getOutputUnitDIE())
     patchStmtList(*OutputDIE, DIEInteger(Streamer->getLineSectionSize()));
 
   // Parse the original line info for the unit.
for (const auto &Attr : Abbrev.attributes()) {
     Copy.AddAttribute(dwarf::Attribute(Attr.Attr), dwarf::Form(Form));
   }
 
   Linker.AssignAbbrev(Copy);
 }
 
 static uint64_t getDwoId(const DWARFDie &CUDie,
                          const DWARFUnit &Unit) {
-  auto DwoId = CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_dwo_id);
+  auto DwoId = CUDie.find(dwarf::DW_AT_dwo_id).getAsUnsignedConstant();
   if (DwoId)
     return *DwoId;
-  DwoId = CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_GNU_dwo_id);
+  DwoId = CUDie.find(dwarf::DW_AT_GNU_dwo_id).getAsUnsignedConstant();
   if (DwoId)
     return *DwoId;
   return 0;
 }
 
 bool DwarfLinker::registerModuleReference(
     const DWARFDie &CUDie, const DWARFUnit &Unit,
     DebugMap &ModuleMap, unsigned Indent) {
   std::string PCMfile =
-      CUDie.getAttributeValueAsString(dwarf::DW_AT_dwo_name, "");
+      CUDie.find(dwarf::DW_AT_dwo_name).getAsCString().getValueOr("");
   if (PCMfile.empty())
     PCMfile =
-        CUDie.getAttributeValueAsString(dwarf::DW_AT_GNU_dwo_name, "");
+        CUDie.find(dwarf::DW_AT_GNU_dwo_name).getAsCString().getValueOr("");
   if (PCMfile.empty())
     return false;
 
   // Clang module DWARF skeleton CUs abuse this for the path to the module.
   std::string PCMpath =
-      CUDie.getAttributeValueAsString(dwarf::DW_AT_comp_dir, "");
+      CUDie.find(dwarf::DW_AT_comp_dir).getAsCString().getValueOr("");
   uint64_t DwoId = getDwoId(CUDie, Unit);
 
   std::string Name =
-      CUDie.getAttributeValueAsString(dwarf::DW_AT_name, "");
+      CUDie.find(dwarf::DW_AT_name).getAsCString().getValueOr("");
   if (Name.empty()) {
     reportWarning("Anonymous module skeleton CU for " + PCMfile);
     return true;
   }
 
   if (Options.Verbose) {
     outs().indent(Indent);
     outs() << "Found clang module reference " << PCMfile;

tools/obj2yaml/dwarf2yaml.cpp

for (auto DIE : CU->dies()) {
       NewEntry.AbbrCode = EntryData.getULEB128(&offset);
 
       auto AbbrevDecl = DIE.getAbbreviationDeclarationPtr();
       if (AbbrevDecl) {
         for (const auto &AttrSpec : AbbrevDecl->attributes()) {
           DWARFYAML::FormValue NewValue;
           NewValue.Value = 0xDEADBEEFDEADBEEF;
           DWARFDie DIEWrapper(CU.get(), &DIE);
-          auto FormValue = DIEWrapper.getAttributeValue(AttrSpec.Attr);
+          auto FormValue = DIEWrapper.find(AttrSpec.Attr);
           if (!FormValue)
             return;
-          auto Form = FormValue.getValue().getForm();
+          auto Form = FormValue.getForm();
           bool indirect = false;
           do {
             indirect = false;
             switch (Form) {
             case dwarf::DW_FORM_addr:
             case dwarf::DW_FORM_GNU_addr_index:
-              if (auto Val = FormValue.getValue().getAsAddress())
+              if (auto Val = FormValue.getAsAddress())
                 NewValue.Value = Val.getValue();
               break;
             case dwarf::DW_FORM_ref_addr:
             case dwarf::DW_FORM_ref1:
             case dwarf::DW_FORM_ref2:
             case dwarf::DW_FORM_ref4:
             case dwarf::DW_FORM_ref8:
             case dwarf::DW_FORM_ref_udata:
             case dwarf::DW_FORM_ref_sig8:
-              if (auto Val = FormValue.getValue().getAsReferenceUVal())
+              if (auto Val = FormValue.getAsReferenceUVal())
                 NewValue.Value = Val.getValue();
               break;
             case dwarf::DW_FORM_exprloc:
             case dwarf::DW_FORM_block:
             case dwarf::DW_FORM_block1:
             case dwarf::DW_FORM_block2:
             case dwarf::DW_FORM_block4:
-              if (auto Val = FormValue.getValue().getAsBlock()) {
+              if (auto Val = FormValue.getAsBlock()) {
                 auto BlockData = Val.getValue();
                 std::copy(BlockData.begin(), BlockData.end(),
                           std::back_inserter(NewValue.BlockData));
               }
               NewValue.Value = NewValue.BlockData.size();
               break;
             case dwarf::DW_FORM_data1:
             case dwarf::DW_FORM_flag:
             case dwarf::DW_FORM_data2:
             case dwarf::DW_FORM_data4:
             case dwarf::DW_FORM_data8:
             case dwarf::DW_FORM_sdata:
             case dwarf::DW_FORM_udata:
-              if (auto Val = FormValue.getValue().getAsUnsignedConstant())
+              if (auto Val = FormValue.getAsUnsignedConstant())
                 NewValue.Value = Val.getValue();
               break;
             case dwarf::DW_FORM_string:
-              if (auto Val = FormValue.getValue().getAsCString())
+              if (auto Val = FormValue.getAsCString())
                 NewValue.CStr = Val.getValue();
               break;
             case dwarf::DW_FORM_indirect:
               indirect = true;
-              if (auto Val = FormValue.getValue().getAsUnsignedConstant()) {
+              if (auto Val = FormValue.getAsUnsignedConstant()) {
                 NewValue.Value = Val.getValue();
                 NewEntry.Values.push_back(NewValue);
                 Form = static_cast<dwarf::Form>(Val.getValue());
               }
               break;
             case dwarf::DW_FORM_strp:
             case dwarf::DW_FORM_sec_offset:
             case dwarf::DW_FORM_GNU_ref_alt:
             case dwarf::DW_FORM_GNU_strp_alt:
             case dwarf::DW_FORM_line_strp:
             case dwarf::DW_FORM_strp_sup:
             case dwarf::DW_FORM_ref_sup:
             case dwarf::DW_FORM_GNU_str_index:
-              if (auto Val = FormValue.getValue().getAsCStringOffset())
+              if (auto Val = FormValue.getAsCStringOffset())
                 NewValue.Value = Val.getValue();
               break;
             case dwarf::DW_FORM_flag_present:
               NewValue.Value = 1;
               break;
             default:
               break;
             }

 }
 
 void dumpDebugLines(DWARFContextInMemory &DCtx, DWARFYAML::Data &Y) {
   for (const auto &CU : DCtx.compile_units()) {
     auto CUDIE = CU->getUnitDIE();
     if (!CUDIE)
       continue;
     if (auto StmtOffset =
-            CUDIE.getAttributeValueAsSectionOffset(dwarf::DW_AT_stmt_list)) {
+            CUDIE.find(dwarf::DW_AT_stmt_list).getAsSectionOffset()) {
       DWARFYAML::LineTable DebugLines;
       DataExtractor LineData(DCtx.getLineSection().Data, DCtx.isLittleEndian(),
                              CU->getAddressByteSize());
       uint32_t Offset = *StmtOffset;
       uint64_t SizeOfPrologueLength = 4;
       DebugLines.TotalLength = LineData.getU32(&Offset);
       uint64_t LineTableLength = DebugLines.TotalLength;
       if (DebugLines.TotalLength == UINT32_MAX) {

unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

#define UDATA_1 18446744073709551614ULL
   EXPECT_EQ(NumCUs, 1u);
   DWARFCompileUnit *U = DwarfContext.getCompileUnitAtIndex(0);
   auto DieDG = U->getUnitDIE(false);
   EXPECT_TRUE(DieDG.isValid());
 
   //----------------------------------------------------------------------
   // Test address forms
   //----------------------------------------------------------------------
-  EXPECT_EQ(DieDG.getAttributeValueAsAddress(Attr_DW_FORM_addr).getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_addr).getAsAddress().getValueOr(0),
             AddrValue);
 
   //----------------------------------------------------------------------
   // Test block forms
   //----------------------------------------------------------------------
   Optional<DWARFFormValue> FormValue;
   ArrayRef<uint8_t> ExtractedBlockData;
   Optional<ArrayRef<uint8_t>> BlockDataOpt;
 
-  FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block);
+  FormValue = DieDG.find(Attr_DW_FORM_block);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
   EXPECT_TRUE(BlockDataOpt.hasValue());
   ExtractedBlockData = BlockDataOpt.getValue();
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
-  FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block1);
+  FormValue = DieDG.find(Attr_DW_FORM_block1);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
   EXPECT_TRUE(BlockDataOpt.hasValue());
   ExtractedBlockData = BlockDataOpt.getValue();
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
-  FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block2);
+  FormValue = DieDG.find(Attr_DW_FORM_block2);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
   EXPECT_TRUE(BlockDataOpt.hasValue());
   ExtractedBlockData = BlockDataOpt.getValue();
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
-  FormValue = DieDG.getAttributeValue(Attr_DW_FORM_block4);
+  FormValue = DieDG.find(Attr_DW_FORM_block4);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
   EXPECT_TRUE(BlockDataOpt.hasValue());
   ExtractedBlockData = BlockDataOpt.getValue();
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
   //----------------------------------------------------------------------
   // Test data forms
   //----------------------------------------------------------------------
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data1)
-                .getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_data1).getAsUnsignedConstant().getValueOr(0),
             Data1);
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data2)
-                .getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_data2).getAsUnsignedConstant().getValueOr(0),
             Data2);
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data4)
-                .getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_data4).getAsUnsignedConstant().getValueOr(0),
             Data4);
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_data8)
-                .getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_data8).getAsUnsignedConstant().getValueOr(0),
             Data8);
 
   //----------------------------------------------------------------------
   // Test string forms
   //----------------------------------------------------------------------
   const char *ExtractedStringValue =
-      DieDG.getAttributeValueAsString(Attr_DW_FORM_string, nullptr);
+      DieDG.find(Attr_DW_FORM_string).getAsCString().getValueOr(nullptr);
   EXPECT_TRUE(ExtractedStringValue != nullptr);
   EXPECT_TRUE(strcmp(StringValue, ExtractedStringValue) == 0);
 
   const char *ExtractedStrpValue =
-      DieDG.getAttributeValueAsString(Attr_DW_FORM_strp, nullptr);
+      DieDG.find(Attr_DW_FORM_strp).getAsCString().getValueOr(nullptr);
   EXPECT_TRUE(ExtractedStrpValue != nullptr);
   EXPECT_TRUE(strcmp(StrpValue, ExtractedStrpValue) == 0);
 
   //----------------------------------------------------------------------
   // Test reference forms
   //----------------------------------------------------------------------
   EXPECT_EQ(
-      DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_addr).getValueOr(0),
+      DieDG.find(Attr_DW_FORM_ref_addr).getAsReference().getValueOr(0),
       RefAddr);
-  EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref1).getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_ref1).getAsReference().getValueOr(0),
             Data1);
-  EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref2).getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_ref2).getAsReference().getValueOr(0),
             Data2);
-  EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref4).getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_ref4).getAsReference().getValueOr(0),
             Data4);
-  EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref8).getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_ref8).getAsReference().getValueOr(0),
             Data8);
   EXPECT_EQ(
-      DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_sig8).getValueOr(0),
+      DieDG.find(Attr_DW_FORM_ref_sig8).getAsReference().getValueOr(0),
       Data8_2);
   EXPECT_EQ(
-      DieDG.getAttributeValueAsReference(Attr_DW_FORM_ref_udata).getValueOr(0),
+      DieDG.find(Attr_DW_FORM_ref_udata).getAsReference().getValueOr(0),
       UData[0]);
 
   //----------------------------------------------------------------------
   // Test flag forms
   //----------------------------------------------------------------------
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_flag_true)
-                .getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_flag_true).getAsUnsignedConstant().getValueOr(0),
             1ULL);
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_flag_false)
-                .getValueOr(1),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_flag_false).getAsUnsignedConstant().getValueOr(1),
             0ULL);
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_flag_present)
-                .getValueOr(0ULL),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_flag_present).getAsUnsignedConstant().getValueOr(0ULL),
             1ULL);
 
   //----------------------------------------------------------------------
   // Test SLEB128 based forms
   //----------------------------------------------------------------------
   EXPECT_EQ(
-      DieDG.getAttributeValueAsSignedConstant(Attr_DW_FORM_sdata).getValueOr(0),
+      DieDG.find(Attr_DW_FORM_sdata).getAsSignedConstant().getValueOr(0),
       SData);
   if (Version >= 5)
     EXPECT_EQ(
-        DieDG.getAttributeValueAsSignedConstant(Attr_DW_FORM_implicit_const)
+        DieDG.find(Attr_DW_FORM_implicit_const).getAsSignedConstant()
             .getValueOr(0),
         ICSData);
 
   //----------------------------------------------------------------------
   // Test ULEB128 based forms
   //----------------------------------------------------------------------
-  EXPECT_EQ(DieDG.getAttributeValueAsUnsignedConstant(Attr_DW_FORM_udata)
-                .getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_udata).getAsUnsignedConstant().getValueOr(0),
             UData[0]);
 
   //----------------------------------------------------------------------
   // Test DWARF32/DWARF64 forms
   //----------------------------------------------------------------------
-  EXPECT_EQ(DieDG.getAttributeValueAsReference(Attr_DW_FORM_GNU_ref_alt)
-                .getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_GNU_ref_alt).getAsReference().getValueOr(0),
             Dwarf32Values[0]);
-  EXPECT_EQ(DieDG.getAttributeValueAsSectionOffset(Attr_DW_FORM_sec_offset)
+  EXPECT_EQ(DieDG.find(Attr_DW_FORM_sec_offset).getAsSectionOffset()
                 .getValueOr(0),
             Dwarf32Values[1]);
 
   //----------------------------------------------------------------------
   // Add an address at the end to make sure we can decode this value
   //----------------------------------------------------------------------
-  EXPECT_EQ(DieDG.getAttributeValueAsAddress(Attr_Last).getValueOr(0),
+  EXPECT_EQ(DieDG.find(Attr_Last).getAsAddress().getValueOr(0),
             AddrValue);
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4AllForms) {
   // Test that we can decode all forms for DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
   // DW_FORM_ref_addr are the same as the address type in DWARF32 version 2.
template <uint16_t Version, class AddrType> void TestReferences() {
   auto Unit2DieDG = U2->getUnitDIE(false);
   EXPECT_TRUE(Unit2DieDG.isValid());
   // Unit2DieDG.dump(llvm::outs(), UINT32_MAX);
 
   // Verify the first child of the compile unit 1 DIE is our int base type.
   auto CU1TypeDieDG = Unit1DieDG.getFirstChild();
   EXPECT_TRUE(CU1TypeDieDG.isValid());
   EXPECT_EQ(CU1TypeDieDG.getTag(), DW_TAG_base_type);
-  EXPECT_EQ(CU1TypeDieDG.getAttributeValueAsUnsignedConstant(DW_AT_encoding)
+  EXPECT_EQ(CU1TypeDieDG.find(DW_AT_encoding).getAsUnsignedConstant()
                 .getValueOr(0),
             DW_ATE_signed);
 
   // Verify the first child of the compile unit 2 DIE is our float base type.
   auto CU2TypeDieDG = Unit2DieDG.getFirstChild();
   EXPECT_TRUE(CU2TypeDieDG.isValid());
   EXPECT_EQ(CU2TypeDieDG.getTag(), DW_TAG_base_type);
-  EXPECT_EQ(CU2TypeDieDG.getAttributeValueAsUnsignedConstant(DW_AT_encoding)
+  EXPECT_EQ(CU2TypeDieDG.find(DW_AT_encoding).getAsUnsignedConstant()
                 .getValueOr(0),
             DW_ATE_float);
 
   // Verify the sibling of the base type DIE is our Ref1 DIE and that its
   // DW_AT_type points to our base type DIE.
   auto CU1Ref1DieDG = CU1TypeDieDG.getSibling();
   EXPECT_TRUE(CU1Ref1DieDG.isValid());
   EXPECT_EQ(CU1Ref1DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU1Ref1DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU1Ref1DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU1TypeDieDG.getOffset());
   // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
   // base type DIE in CU1.
   auto CU1Ref2DieDG = CU1Ref1DieDG.getSibling();
   EXPECT_TRUE(CU1Ref2DieDG.isValid());
   EXPECT_EQ(CU1Ref2DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU1Ref2DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU1Ref2DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU1TypeDieDG.getOffset());
 
   // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
   // base type DIE in CU1.
   auto CU1Ref4DieDG = CU1Ref2DieDG.getSibling();
   EXPECT_TRUE(CU1Ref4DieDG.isValid());
   EXPECT_EQ(CU1Ref4DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU1Ref4DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU1Ref4DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU1TypeDieDG.getOffset());
 
   // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
   // base type DIE in CU1.
   auto CU1Ref8DieDG = CU1Ref4DieDG.getSibling();
   EXPECT_TRUE(CU1Ref8DieDG.isValid());
   EXPECT_EQ(CU1Ref8DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU1Ref8DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU1Ref8DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU1TypeDieDG.getOffset());
 
   // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
   // base type DIE in CU1.
   auto CU1RefAddrDieDG = CU1Ref8DieDG.getSibling();
   EXPECT_TRUE(CU1RefAddrDieDG.isValid());
   EXPECT_EQ(CU1RefAddrDieDG.getTag(), DW_TAG_variable);
-  EXPECT_EQ(CU1RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
-                .getValueOr(-1ULL),
+  EXPECT_EQ(CU1RefAddrDieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
             CU1TypeDieDG.getOffset());
 
   // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
   // DW_AT_type points to our base type DIE.
   auto CU1ToCU2RefAddrDieDG = CU1RefAddrDieDG.getSibling();
   EXPECT_TRUE(CU1ToCU2RefAddrDieDG.isValid());
   EXPECT_EQ(CU1ToCU2RefAddrDieDG.getTag(), DW_TAG_variable);
-  EXPECT_EQ(CU1ToCU2RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
+  EXPECT_EQ(CU1ToCU2RefAddrDieDG.find(DW_AT_type).getAsReference()
                 .getValueOr(-1ULL),
             CU2TypeDieDG.getOffset());
 
   // Verify the sibling of the base type DIE is our Ref1 DIE and that its
   // DW_AT_type points to our base type DIE.
   auto CU2Ref1DieDG = CU2TypeDieDG.getSibling();
   EXPECT_TRUE(CU2Ref1DieDG.isValid());
   EXPECT_EQ(CU2Ref1DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU2Ref1DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU2Ref1DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU2TypeDieDG.getOffset());
   // Verify the sibling is our Ref2 DIE and that its DW_AT_type points to our
   // base type DIE in CU2.
   auto CU2Ref2DieDG = CU2Ref1DieDG.getSibling();
   EXPECT_TRUE(CU2Ref2DieDG.isValid());
   EXPECT_EQ(CU2Ref2DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU2Ref2DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU2Ref2DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU2TypeDieDG.getOffset());
 
   // Verify the sibling is our Ref4 DIE and that its DW_AT_type points to our
   // base type DIE in CU2.
   auto CU2Ref4DieDG = CU2Ref2DieDG.getSibling();
   EXPECT_TRUE(CU2Ref4DieDG.isValid());
   EXPECT_EQ(CU2Ref4DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU2Ref4DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU2Ref4DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU2TypeDieDG.getOffset());
 
   // Verify the sibling is our Ref8 DIE and that its DW_AT_type points to our
   // base type DIE in CU2.
   auto CU2Ref8DieDG = CU2Ref4DieDG.getSibling();
   EXPECT_TRUE(CU2Ref8DieDG.isValid());
   EXPECT_EQ(CU2Ref8DieDG.getTag(), DW_TAG_variable);
   EXPECT_EQ(
-      CU2Ref8DieDG.getAttributeValueAsReference(DW_AT_type).getValueOr(-1ULL),
+      CU2Ref8DieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
       CU2TypeDieDG.getOffset());
 
   // Verify the sibling is our RefAddr DIE and that its DW_AT_type points to our
   // base type DIE in CU2.
   auto CU2RefAddrDieDG = CU2Ref8DieDG.getSibling();
   EXPECT_TRUE(CU2RefAddrDieDG.isValid());
   EXPECT_EQ(CU2RefAddrDieDG.getTag(), DW_TAG_variable);
-  EXPECT_EQ(CU2RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
-                .getValueOr(-1ULL),
+  EXPECT_EQ(CU2RefAddrDieDG.find(DW_AT_type).getAsReference().getValueOr(-1ULL),
             CU2TypeDieDG.getOffset());
 
   // Verify the sibling of the Ref4 DIE is our RefAddr DIE and that its
   // DW_AT_type points to our base type DIE.
   auto CU2ToCU1RefAddrDieDG = CU2RefAddrDieDG.getSibling();
   EXPECT_TRUE(CU2ToCU1RefAddrDieDG.isValid());
   EXPECT_EQ(CU2ToCU1RefAddrDieDG.getTag(), DW_TAG_variable);
-  EXPECT_EQ(CU2ToCU1RefAddrDieDG.getAttributeValueAsReference(DW_AT_type)
+  EXPECT_EQ(CU2ToCU1RefAddrDieDG.find(DW_AT_type).getAsReference()
                 .getValueOr(-1ULL),
             CU1TypeDieDG.getOffset());
 }
 
 TEST(DWARFDebugInfo, TestDWARF32Version2Addr4References) {
   // Test that we can decode all forms for DWARF32, version 2, with 4 byte
   // addresses.
   typedef uint32_t AddrType;
template <uint16_t Version, class AddrType> void TestAddresses() {
   
   uint64_t LowPC, HighPC;
   Optional<uint64_t> OptU64;
   // Verify the that our subprogram with no PC value fails appropriately when
   // asked for any PC values.
   auto SubprogramDieNoPC = DieDG.getFirstChild();
   EXPECT_TRUE(SubprogramDieNoPC.isValid());
   EXPECT_EQ(SubprogramDieNoPC.getTag(), DW_TAG_subprogram);
-  OptU64 = SubprogramDieNoPC.getAttributeValueAsAddress(DW_AT_low_pc);
+  OptU64 = SubprogramDieNoPC.find(DW_AT_low_pc).getAsAddress();
   EXPECT_FALSE((bool)OptU64);
-  OptU64 = SubprogramDieNoPC.getAttributeValueAsAddress(DW_AT_high_pc);
+  OptU64 = SubprogramDieNoPC.find(DW_AT_high_pc).getAsAddress();
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC));
-  OptU64 = SubprogramDieNoPC.getAttributeValueAsAddress(DW_AT_high_pc);
+  OptU64 = SubprogramDieNoPC.find(DW_AT_high_pc).getAsAddress();
   EXPECT_FALSE((bool)OptU64);
-  OptU64 = SubprogramDieNoPC.getAttributeValueAsUnsignedConstant(DW_AT_high_pc);
+  OptU64 = SubprogramDieNoPC.find(DW_AT_high_pc).getAsUnsignedConstant();
   EXPECT_FALSE((bool)OptU64);
   OptU64 = SubprogramDieNoPC.getHighPC(ActualLowPC);
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieNoPC.getLowAndHighPC(LowPC, HighPC));
   
   
   // Verify the that our subprogram with only a low PC value succeeds when
   // we ask for the Low PC, but fails appropriately when asked for the high PC
   // or both low and high PC values.
   auto SubprogramDieLowPC = SubprogramDieNoPC.getSibling();
   EXPECT_TRUE(SubprogramDieLowPC.isValid());
   EXPECT_EQ(SubprogramDieLowPC.getTag(), DW_TAG_subprogram);
-  OptU64 = SubprogramDieLowPC.getAttributeValueAsAddress(DW_AT_low_pc);
+  OptU64 = SubprogramDieLowPC.find(DW_AT_low_pc).getAsAddress();
   EXPECT_TRUE((bool)OptU64);
   EXPECT_EQ(OptU64.getValue(), ActualLowPC);
-  OptU64 = SubprogramDieLowPC.getAttributeValueAsAddress(DW_AT_high_pc);
+  OptU64 = SubprogramDieLowPC.find(DW_AT_high_pc).getAsAddress();
   EXPECT_FALSE((bool)OptU64);
-  OptU64 = SubprogramDieLowPC.getAttributeValueAsUnsignedConstant(DW_AT_high_pc);
+  OptU64 = SubprogramDieLowPC.find(DW_AT_high_pc).getAsUnsignedConstant();
   EXPECT_FALSE((bool)OptU64);
   OptU64 = SubprogramDieLowPC.getHighPC(ActualLowPC);
   EXPECT_FALSE((bool)OptU64);
   EXPECT_FALSE(SubprogramDieLowPC.getLowAndHighPC(LowPC, HighPC));
 
   
   // Verify the that our subprogram with only a low PC value succeeds when
   // we ask for the Low PC, but fails appropriately when asked for the high PC
   // or both low and high PC values.
   auto SubprogramDieLowHighPC = SubprogramDieLowPC.getSibling();
   EXPECT_TRUE(SubprogramDieLowHighPC.isValid());
   EXPECT_EQ(SubprogramDieLowHighPC.getTag(), DW_TAG_subprogram);
-  OptU64 = SubprogramDieLowHighPC.getAttributeValueAsAddress(DW_AT_low_pc);
+  OptU64 = SubprogramDieLowHighPC.find(DW_AT_low_pc).getAsAddress();
   EXPECT_TRUE((bool)OptU64);
   EXPECT_EQ(OptU64.getValue(), ActualLowPC);
   // Get the high PC as an address. This should succeed if the high PC was
   // encoded as an address and fail if the high PC was encoded as an offset.
-  OptU64 = SubprogramDieLowHighPC.getAttributeValueAsAddress(DW_AT_high_pc);
+  OptU64 = SubprogramDieLowHighPC.find(DW_AT_high_pc).getAsAddress();
   if (SupportsHighPCAsOffset) {
     EXPECT_FALSE((bool)OptU64);
   } else {
     EXPECT_TRUE((bool)OptU64);
     EXPECT_EQ(OptU64.getValue(), ActualHighPC);
   }
   // Get the high PC as an unsigned constant. This should succeed if the high PC
   // was encoded as an offset and fail if the high PC was encoded as an address.
-  OptU64 = SubprogramDieLowHighPC.getAttributeValueAsUnsignedConstant(
-      DW_AT_high_pc);
+  OptU64 = SubprogramDieLowHighPC.find(DW_AT_high_pc).getAsUnsignedConstant();
   if (SupportsHighPCAsOffset) {
     EXPECT_TRUE((bool)OptU64);
     EXPECT_EQ(OptU64.getValue(), ActualHighPCOffset);
   } else {
     EXPECT_FALSE((bool)OptU64);
   }
 
   OptU64 = SubprogramDieLowHighPC.getHighPC(ActualLowPC);