Add the ability to get attribute values as Optional<T>

[clayborg]

Summary

When getting attributes it is sometimes nicer to use Optional<T> some of the time instead of magic values. I tried to cut over to only using the Optional values but it made many of the call sites very messy, so it makes sense the leave in the calls that can return a default value. Otherwise code that looks like this:

uint64_t CallColumn = Die.getAttributeValueAsAddress(DW_AT_call_line, 0);

Has to be turned into:

uint64_t CallColumn = 0;
if (auto CallColumnValue = Die.getAttributeValueAsAddress(DW_AT_call_line))
    CallColumn = *CallColumnValue;

The first snippet of code looks much better. But in cases where you want an offset that may or may not be there, the following code looks better:

if (auto StmtOffset = Die.getAttributeValueAsSectionOffset(DW_AT_stmt_list)) {
  // Use StmtOffset
}

[aprantl]

Thanks, this is much cleaner than using special ~1ULL return values!
LGTM, and if we can get the Optional-default-value patch in later, this will be even better.

lib/DebugInfo/DWARF/DWARFDie.cpp

255

formatting nit: Comment should go above the statement.

include/llvm/DebugInfo/DWARF/DWARFDie.h

public:
   /// \param Attr the attribute to extract.
   /// \param FailValue the value to return if this DIE doesn't have this
   /// attribute.
   /// \returns the address value of the attribute or FailValue if the
   /// attribute doesn't exist or if the attribute's form isn't a form that
   /// describes an address.
   uint64_t getAttributeValueAsAddress(dwarf::Attribute Attr,
                                       uint64_t 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.
   /// \param FailValue the value to return if this DIE doesn't have this
   /// attribute.
   /// \returns the signed integer constant value of the attribute or FailValue
   /// if the attribute doesn't exist or if the attribute's form isn't a form
   /// that describes a signed integer.
   int64_t getAttributeValueAsSignedConstant(dwarf::Attribute Attr,
                                             int64_t FailValue) 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.
   /// \param FailValue the value to return if this DIE doesn't have this
   /// attribute.
   /// \returns the unsigned integer constant value of the attribute or FailValue
   /// if the attribute doesn't exist or if the attribute's form isn't a form
   /// that describes an unsigned integer.
   uint64_t getAttributeValueAsUnsignedConstant(dwarf::Attribute Attr,
                                                uint64_t FailValue) 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.
   /// \param FailValue the value to return if this DIE doesn't have this
   /// attribute.
   /// \returns the unsigned integer constant value of the attribute or FailValue
   /// if the attribute doesn't exist or if the attribute's form isn't a form
   /// that describes a reference.
   uint64_t getAttributeValueAsReference(dwarf::Attribute Attr,
                                         uint64_t FailValue) 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.
   /// \param FailValue the value to return if this DIE doesn't have this
   /// attribute.
   /// \returns the unsigned integer constant value of the attribute or FailValue
   /// if the attribute doesn't exist or if the attribute's form isn't a form
   /// that describes a section offset.
   uint64_t getAttributeValueAsSectionOffset(dwarf::Attribute Attr,
                                             uint64_t FailValue) 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;
   
   /// 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 the absolute section offset value of the attribute or FailValue
-  /// if the attribute doesn't exist.
-  uint64_t getRangesBaseAttribute(uint64_t FailValue) const;
+  /// \returns anm optional absolute section offset value for the attribute.
+  Optional<uint64_t> getRangesBaseAttribute() const;
   
   /// Retrieves DW_AT_low_pc and DW_AT_high_pc from CU.
   /// Returns true if both attributes are present.
   bool getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC) const;
   
   /// Get the address ranges for this DIE.
   ///
   /// Get the hi/low PC range if both attributes are available or exrtracts the

include/llvm/DebugInfo/DWARF/DWARFUnit.h

 //===-- DWARFUnit.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFUNIT_H
 #define LLVM_LIB_DEBUGINFO_DWARFUNIT_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
public:
   DWARFDie getUnitDIE(bool ExtractUnitDIEOnly = true) {
     extractDIEsIfNeeded(ExtractUnitDIEOnly);
     if (DieArray.empty())
       return DWARFDie();
     return DWARFDie(this, &DieArray[0]);
   }
 
   const char *getCompilationDir();
-  uint64_t getDWOId();
+  Optional<uint64_t> getDWOId();
 
   void collectAddressRanges(DWARFAddressRangesVector &CURanges);
 
   /// getInlinedChainForAddress - fetches inlined chain for a given address.
   /// Returns empty chain if there is no subprogram containing address. The
   /// chain is valid as long as parsed compile unit DIEs are not cleared.
   void getInlinedChainForAddress(uint64_t Address,
                                  SmallVectorImpl<DWARFDie> &InlinedChain);

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;
-      unsigned stmtOffset = CUDIE.getAttributeValueAsSectionOffset(
-          DW_AT_stmt_list, -1U);
-      if (stmtOffset != -1U) {
+      if (auto StmtOffset =
+              CUDIE.getAttributeValueAsSectionOffset(DW_AT_stmt_list)) {
         DataExtractor lineData(getLineSection().Data, isLittleEndian(),
                                savedAddressByteSize);
         DWARFDebugLine::LineTable LineTable;
-        LineTable.parse(lineData, &getLineSection().Relocs, &stmtOffset);
+        uint32_t Offset = *StmtOffset;
+        LineTable.parse(lineData, &getLineSection().Relocs, &Offset);
         LineTable.dump(OS);
       }
     }
   }
 
   if (DumpType == DIDT_All || DumpType == DIDT_CUIndex) {
     OS << "\n.debug_cu_index contents:\n";
     getCUIndex().dump(OS);

 DWARFContext::getLineTableForUnit(DWARFUnit *U) {
   if (!Line)
     Line.reset(new DWARFDebugLine(&getLineSection().Relocs));
 
   auto UnitDIE = U->getUnitDIE();
   if (!UnitDIE)
     return nullptr;
 
-  unsigned stmtOffset =
-      UnitDIE.getAttributeValueAsSectionOffset(DW_AT_stmt_list, -1U);
-  if (stmtOffset == -1U)
+  auto Offset = UnitDIE.getAttributeValueAsSectionOffset(DW_AT_stmt_list);
+  if (!Offset)
     return nullptr; // No line table for this compile unit.
 
-  stmtOffset += U->getLineTableOffset();
+  uint32_t stmtOffset = *Offset + U->getLineTableOffset();
   // See if the line table is cached.
   if (const DWARFLineTable *lt = Line->getLineTable(stmtOffset))
     return lt;
 
   // We have to parse it first.
   DataExtractor lineData(U->getLineSection(), isLittleEndian(),
                          U->getAddressByteSize());
   return Line->getOrParseLineTable(lineData, stmtOffset);

lib/DebugInfo/DWARF/DWARFDie.cpp

const char *DWARFDie::getAttributeValueAsString(dwarf::Attribute Attr,
   if (!FormValue)
     return FailValue;
   Optional<const char *> Result = FormValue->getAsCString();
   return Result.hasValue() ? Result.getValue() : FailValue;
 }
 
 uint64_t DWARFDie::getAttributeValueAsAddress(dwarf::Attribute Attr,
                                               uint64_t FailValue) const {
-  auto FormValue = getAttributeValue(Attr);
-  if (!FormValue)
-    return FailValue;
-  Optional<uint64_t> Result = FormValue->getAsAddress();
-  return Result.hasValue() ? Result.getValue() : FailValue;
+  if (auto Value = getAttributeValueAsAddress(Attr))
+    return *Value;
+}
+
+Optional<uint64_t>
+DWARFDie::getAttributeValueAsAddress(dwarf::Attribute Attr) const {
+  if (auto FormValue = getAttributeValue(Attr))
+    return FormValue->getAsAddress();
+  return None;
 }
 
 int64_t DWARFDie::getAttributeValueAsSignedConstant(dwarf::Attribute Attr,
                                                     int64_t FailValue) const {
-  auto FormValue = getAttributeValue(Attr);
-  if (!FormValue)
-    return FailValue;
-  Optional<int64_t> Result = FormValue->getAsSignedConstant();
-  return Result.hasValue() ? Result.getValue() : FailValue;
+  if (auto Value = getAttributeValueAsSignedConstant(Attr))
+    return *Value;
+}
+
+Optional<int64_t>
+DWARFDie::getAttributeValueAsSignedConstant(dwarf::Attribute Attr) const {
+  if (auto FormValue = getAttributeValue(Attr))
+    return FormValue->getAsSignedConstant();
+  return None;
 }
 
 uint64_t
 DWARFDie::getAttributeValueAsUnsignedConstant(dwarf::Attribute Attr,
                                               uint64_t FailValue) const {
-  auto FormValue = getAttributeValue(Attr);
-  if (!FormValue)
-    return FailValue;
-  Optional<uint64_t> Result = FormValue->getAsUnsignedConstant();
-  return Result.hasValue() ? Result.getValue() : FailValue;
+  if (auto Value = getAttributeValueAsUnsignedConstant(Attr))
+    return *Value;
+}
+
+
+Optional<uint64_t>
+DWARFDie::getAttributeValueAsUnsignedConstant(dwarf::Attribute Attr) const {
+  if (auto FormValue = getAttributeValue(Attr))
+    return FormValue->getAsUnsignedConstant();
+  return None;
 }
 
 uint64_t DWARFDie::getAttributeValueAsReference(dwarf::Attribute Attr,
                                                 uint64_t FailValue) const {
-  auto FormValue = getAttributeValue(Attr);
-  if (!FormValue)
-    return FailValue;
-  Optional<uint64_t> Result = FormValue->getAsReference();
-  return Result.hasValue() ? Result.getValue() : FailValue;
+  if (auto Value = getAttributeValueAsReference(Attr))
+    return *Value;
+}
+
+
+Optional<uint64_t>
+DWARFDie::getAttributeValueAsReference(dwarf::Attribute Attr) const {
+  if (auto FormValue = getAttributeValue(Attr))
+    return FormValue->getAsReference();
+  return None;
 }
 
 uint64_t DWARFDie::getAttributeValueAsSectionOffset(dwarf::Attribute Attr,
                                                     uint64_t FailValue) const {
-  auto FormValue = getAttributeValue(Attr);
-  if (!FormValue)
-    return FailValue;
-  Optional<uint64_t> Result = FormValue->getAsSectionOffset();
-  return Result.hasValue() ? Result.getValue() : FailValue;
+  if (auto Value = getAttributeValueAsSectionOffset(Attr))
+    return *Value;
 }
 
+Optional<uint64_t>
+DWARFDie::getAttributeValueAsSectionOffset(dwarf::Attribute Attr) const {
+  if (auto FormValue = getAttributeValue(Attr))
+    return FormValue->getAsSectionOffset();
+  return None;
+}
+
+
 DWARFDie
 DWARFDie::getAttributeValueAsReferencedDie(dwarf::Attribute Attr) const {
-  uint32_t SpecRef = getAttributeValueAsReference(Attr, -1U);
-  if (SpecRef != -1U) {
-    auto SpecUnit = U->getUnitSection().getUnitForOffset(SpecRef);
+  auto SpecRef = getAttributeValueAsReference(Attr);
+  if (SpecRef) {
+    auto SpecUnit = U->getUnitSection().getUnitForOffset(*SpecRef);
     if (SpecUnit)
-      return SpecUnit->getDIEForOffset(SpecRef);
+      return SpecUnit->getDIEForOffset(*SpecRef);
   }
   return DWARFDie();
 }
 
-uint64_t
-DWARFDie::getRangesBaseAttribute(uint64_t FailValue) const {
-  auto Result = getAttributeValueAsSectionOffset(DW_AT_rnglists_base, -1ULL);
-  if (Result != -1ULL)
+Optional<uint64_t>
+DWARFDie::getRangesBaseAttribute() const {
+  auto Result = getAttributeValueAsSectionOffset(DW_AT_rnglists_base);
+  if (Result)
     return Result;
-  return getAttributeValueAsSectionOffset(DW_AT_GNU_ranges_base, FailValue);
+  return getAttributeValueAsSectionOffset(DW_AT_GNU_ranges_base);
 }
 
 bool DWARFDie::getLowAndHighPC(uint64_t &LowPC, uint64_t &HighPC) const {
-  LowPC = getAttributeValueAsAddress(DW_AT_low_pc, -1ULL);
-  if (LowPC == -1ULL)
+  if (auto LowPCVal = getAttributeValueAsAddress(DW_AT_low_pc))
+    LowPC = *LowPCVal;
+  else
     return false;
-  HighPC = getAttributeValueAsAddress(DW_AT_high_pc, -1ULL);
-  if (HighPC == -1ULL) {
-    // Since DWARF4, DW_AT_high_pc may also be of class constant, in which case
-    // it represents function size.
-    HighPC = getAttributeValueAsUnsignedConstant(DW_AT_high_pc, -1ULL);
-    if (HighPC != -1ULL)
-      HighPC += LowPC;
-  }
-  return (HighPC != -1ULL);
+
+  if (auto HighPCVal = getAttributeValueAsAddress(DW_AT_high_pc))
+    HighPC = *HighPCVal; // High PC is an address.
+  else if (auto Offset = getAttributeValueAsUnsignedConstant(DW_AT_high_pc))
+    HighPC = LowPC + *Offset; // High PC is an offset from LowPC.
+  else
+    return false;
+  return true;
 }
 
 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.
-  uint32_t RangesOffset = getAttributeValueAsSectionOffset(DW_AT_ranges, -1U);
-  if (RangesOffset != -1U) {
+  auto RangesOffset = getAttributeValueAsSectionOffset(DW_AT_ranges);
+  if (RangesOffset) {
     DWARFDebugRangeList RangeList;
-    if (U->extractRangeList(RangesOffset, RangeList))
+    if (U->extractRangeList(*RangesOffset, RangeList))
       return RangeList.getAbsoluteRanges(U->getBaseAddress());
   }
   return DWARFAddressRangesVector();
 }
 
 void
 DWARFDie::collectChildrenAddressRanges(DWARFAddressRangesVector& Ranges) const {
   if (isNULL())

lib/DebugInfo/DWARF/DWARFUnit.cpp

void DWARFUnit::clear() {
   clearDIEs(false);
   DWO.reset();
 }
 
 const char *DWARFUnit::getCompilationDir() {
   return getUnitDIE().getAttributeValueAsString(DW_AT_comp_dir, nullptr);
 }
 
-uint64_t DWARFUnit::getDWOId() {
-  return getUnitDIE().getAttributeValueAsUnsignedConstant(DW_AT_GNU_dwo_id,
-                                                          -1ULL);
+Optional<uint64_t> DWARFUnit::getDWOId() {
+  return getUnitDIE().getAttributeValueAsUnsignedConstant(DW_AT_GNU_dwo_id);
 }
 
 void DWARFUnit::setDIERelations() {
   if (DieArray.size() <= 1)
     return;
 
   std::vector<DWARFDebugInfoEntry *> ParentChain;
   DWARFDebugInfoEntry *SiblingChain = nullptr;
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();
-    uint64_t BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_low_pc, -1ULL);
-    if (BaseAddr == -1ULL)
-      BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_entry_pc, 0);
-    setBaseAddress(BaseAddr);
+    auto BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_low_pc);
+    if (!BaseAddr)
+      BaseAddr = UnitDie.getAttributeValueAsAddress(DW_AT_entry_pc);
+    if (BaseAddr)
+      setBaseAddress(*BaseAddr);
     AddrOffsetSectionBase = UnitDie.getAttributeValueAsSectionOffset(
         DW_AT_GNU_addr_base, 0);
     RangeSectionBase = UnitDie.getAttributeValueAsSectionOffset(
         DW_AT_rnglists_base, 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.
   }
 
bool DWARFUnit::parseDWO() {
   DWARFUnit *DWOCU = DWO->getUnit();
   // Verify that compile unit in .dwo file is valid.
   if (!DWOCU || DWOCU->getDWOId() != getDWOId()) {
     DWO.reset();
     return false;
   }
   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
   DWOCU->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
-  uint32_t DWORangesBase = UnitDie.getRangesBaseAttribute(0);
-  DWOCU->setRangesSection(RangeSection, DWORangesBase);
+  auto DWORangesBase = UnitDie.getRangesBaseAttribute();
+  DWOCU->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);
   return true;
 }
 
 void DWARFUnit::clearDIEs(bool KeepCUDie) {
   if (DieArray.size() > (unsigned)KeepCUDie) {
     // std::vectors never get any smaller when resized to a smaller size,
     // or when clear() or erase() are called, the size will report that it
     // is smaller, but the memory allocated remains intact (call capacity()

tools/dsymutil/DwarfLinker.cpp

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;
-  uint64_t OrigLowPc = OrigUnitDie.getAttributeValueAsAddress(
-      dwarf::DW_AT_low_pc, -1ULL);
-  if (OrigLowPc != -1ULL)
-    UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
+  auto OrigLowPc = OrigUnitDie.getAttributeValueAsAddress(dwarf::DW_AT_low_pc);
+  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.
     int64_t LocPcOffset = Attr.second + UnitPcOffset;
     while (Data.isValidOffset(Offset)) {
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);
 
-  uint64_t LowPc =
-      DIE.getAttributeValueAsAddress(dwarf::DW_AT_low_pc, -1ULL);
-  assert(LowPc != -1ULL && "low_pc attribute is not an address.");
-  if (LowPc == -1ULL ||
+  auto LowPc = DIE.getAttributeValueAsAddress(dwarf::DW_AT_low_pc);
+  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 */);
 
   Flags |= TF_Keep;
 
   Optional<DWARFFormValue> HighPcValue;
   if (!(HighPcValue = DIE.getAttributeValue(dwarf::DW_AT_high_pc))) {
     reportWarning("Function without high_pc. Range will be discarded.\n",
                   &DIE);
     return Flags;
   }
 
   uint64_t HighPc;
   if (HighPcValue->isFormClass(DWARFFormValue::FC_Address)) {
     HighPc = *HighPcValue->getAsAddress();
   } else {
     assert(HighPcValue->isFormClass(DWARFFormValue::FC_Constant));
-    HighPc = LowPc + *HighPcValue->getAsUnsignedConstant();
+    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);
+  Ranges[*LowPc] = std::make_pair(HighPc, MyInfo.AddrAdjust);
+  Unit.addFunctionRange(*LowPc, HighPc, MyInfo.AddrAdjust);
   return Flags;
 }
 
 /// \brief Check if a DIE should be kept.
 /// \returns updated TraversalFlags.
 unsigned DwarfLinker::shouldKeepDIE(RelocationManager &RelocMgr,
                                     const DWARFDie &DIE,
                                     CompileUnit &Unit,

 }
 
 /// \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();
-  uint64_t StmtList = CUDie.getAttributeValueAsSectionOffset(
-      dwarf::DW_AT_stmt_list, -1ULL);
-  if (StmtList == -1ULL)
+  auto StmtList = CUDie.getAttributeValueAsSectionOffset(dwarf::DW_AT_stmt_list);
+  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.
   DWARFDebugLine::LineTable LineTable;
-  uint32_t StmtOffset = StmtList;
+  uint32_t StmtOffset = *StmtList;
   StringRef LineData = OrigDwarf.getLineSection().Data;
   DataExtractor LineExtractor(LineData, OrigDwarf.isLittleEndian(),
                               Unit.getOrigUnit().getAddressByteSize());
   LineTable.parse(LineExtractor, &OrigDwarf.getLineSection().Relocs,
                   &StmtOffset);
 
   // This vector is the output line table.
   std::vector<DWARFDebugLine::Row> NewRows;
for (auto &Row : LineTable.Rows) {
     Row.Address += CurrRange.value();
     Seq.emplace_back(Row);
 
     if (Row.EndSequence)
       insertLineSequence(Seq, NewRows);
   }
 
   // Finished extracting, now emit the line tables.
-  uint32_t PrologueEnd = StmtList + 10 + LineTable.Prologue.PrologueLength;
+  uint32_t PrologueEnd = *StmtList + 10 + LineTable.Prologue.PrologueLength;
   // FIXME: LLVM hardcodes it's prologue values. We just copy the
   // prologue over and that works because we act as both producer and
   // consumer. It would be nicer to have a real configurable line
   // table emitter.
   if (LineTable.Prologue.Version != 2 ||
       LineTable.Prologue.DefaultIsStmt != DWARF2_LINE_DEFAULT_IS_STMT ||
       LineTable.Prologue.OpcodeBase > 13)
     reportWarning("line table paramters mismatch. Cannot emit.");
   else {
     MCDwarfLineTableParams Params;
     Params.DWARF2LineOpcodeBase = LineTable.Prologue.OpcodeBase;
     Params.DWARF2LineBase = LineTable.Prologue.LineBase;
     Params.DWARF2LineRange = LineTable.Prologue.LineRange;
     Streamer->emitLineTableForUnit(Params,
-                                   LineData.slice(StmtList + 4, PrologueEnd),
+                                   LineData.slice(*StmtList + 4, PrologueEnd),
                                    LineTable.Prologue.MinInstLength, NewRows,
                                    Unit.getOrigUnit().getAddressByteSize());
   }
 }
 
 void DwarfLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
   Streamer->emitPubNamesForUnit(Unit);
   Streamer->emitPubTypesForUnit(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) {
-  uint64_t DwoId =
-      CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_dwo_id, 0);
-  if (!DwoId)
-    DwoId = CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_GNU_dwo_id,
-                                                      0);
-  return DwoId;
+  auto DwoId = CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_dwo_id);
+  if (DwoId)
+    return *DwoId;
+  DwoId = CUDie.getAttributeValueAsUnsignedConstant(dwarf::DW_AT_GNU_dwo_id);
+  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, "");
   if (PCMfile.empty())