[DWARF] Improved error reporting for range lists

[wolfgangp]

Summary

This is a primarily a refactor of the routines that are used to find individual range lists based on offsets or indices found as values of the DW_AT_ranges attribute.
Particularly DWARFUnit::findRnglistFromOffset() and DWARFUnit::findRnglistFromIndex() now return an Expected<> instead of a plain DWARFAddressRangesVector. This allows propagation of errors that occur during handling of the attribute, in particular invalid offsets and indices that are values of the DW_AT_ranges attribute. We did not report errors for this prior to this change.
As a result, a few routines that use the 2 mentioned above also return an Expected<>, which in turn means that their callers have to handle an error in some way if it occurs, e.g. DWARFDie::getAddressRanges() returns an Expected<> which means that their callers have to report the error, or ignore them.

This patch reports the error in the following contexts:

dumpAttribute() in DWARFDie.cpp
DWARFDie::collectAddressRanges()

In the following contexts it's ignored (for now):

DWARFDie::collectChildrenAddressRanges()
DWARFUnit::updateAddressDieMap()
DWARFVerifier::verifyDieRanges()
getLowPC() in llvm-dwarfdump/Statistics.cpp
DWARFDie::addressRangeContainsAddress()

In these contexts I added FIXME comments, because we want to eventually report the error, but they either require support for .debug_aranges or more complex tests with child DIEs. I'd like to add them in a follow-on patch.

In the case of the verifier, it needs to handle DWARF v5 rnglists before we can report errors meaningfully.

The extraction of v4 range lists (DebugRangeLists.extract()) now also returns an Error instead of a boolean, which is reported in DWARFContext::dump().

[JDevlieghere]

Thanks Wolfgang, I'm always excited to see improved error handling! LGTM modulo inline comment.

lib/DebugInfo/DWARF/DWARFUnit.cpp

417

Did you capitalize this on purpose or should it be lowercase like the other error messages? Same question below.

[wolfgangp]

lib/DebugInfo/DWARF/DWARFUnit.cpp

417

Thanks for finding this. Should have all been lowercase.

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

private:
   uint8_t AddressSize;
   std::vector<RangeListEntry> Entries;
 
 public:
   DWARFDebugRangeList() { clear(); }
 
   void clear();
   void dump(raw_ostream &OS) const;
-  bool extract(const DWARFDataExtractor &data, uint32_t *offset_ptr);
+  Error extract(const DWARFDataExtractor &data, uint32_t *offset_ptr);
   const std::vector<RangeListEntry> &getEntries() { return Entries; }
 
   /// getAbsoluteRanges - Returns absolute address ranges defined by this range
   /// list. Has to be passed base address of the compile unit referencing this
   /// range list.
   DWARFAddressRangesVector
   getAbsoluteRanges(llvm::Optional<BaseAddress> BaseAddr) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

 public:
   void clear();
   /// Extract the table header and the array of offsets.
   Error extractHeaderAndOffsets(DWARFDataExtractor Data, uint32_t *OffsetPtr);
   /// Extract an entire table, including all rangelists.
   Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
   /// Look up a rangelist based on a given offset. Extract it and enter it into
   /// the ranges map if necessary.
-  Optional<DWARFDebugRnglist> findRangeList(DWARFDataExtractor Data,
+  Expected<DWARFDebugRnglist> findRangeList(DWARFDataExtractor Data,
                                             uint32_t Offset);
   uint32_t getHeaderOffset() const { return HeaderOffset; }
   uint8_t getAddrSize() const { return HeaderData.AddrSize; }
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const;
   /// Return the contents of the offset entry designated by a given index.
   Optional<uint32_t> getOffsetEntry(uint32_t Index) const {
     if (Index < Offsets.size())
       return Offsets[Index];

include/llvm/DebugInfo/DWARF/DWARFDie.h

public:
   /// Get the hi/low PC range if both attributes are available or exrtracts the
   /// non-contiguous address ranges from the DW_AT_ranges attribute.
   ///
   /// Extracts the range information from this DIE only. This call doesn't look
   /// for the range in any DW_AT_specification or DW_AT_abstract_origin DIEs.
   ///
   /// \returns a address range vector that might be empty if no address range
   /// information is available.
-  DWARFAddressRangesVector getAddressRanges() const;
+  Expected<DWARFAddressRangesVector> getAddressRanges() const;
 
   /// Get all address ranges for any DW_TAG_subprogram DIEs in this DIE or any
   /// of its children.
   ///
   /// Get the hi/low PC range if both attributes are available or exrtracts the
   /// non-contiguous address ranges from the DW_AT_ranges attribute for this DIE
   /// and all children.
   ///

include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
   bool getStringOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
 
   DWARFDataExtractor getDebugInfoExtractor() const;
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
-  /// extractRangeList - extracts the range list referenced by this compile
-  /// unit from .debug_ranges section. Returns true on success.
-  /// Requires that compile unit is already extracted.
-  bool extractRangeList(uint32_t RangeListOffset,
+  /// Extract the range list referenced by this compile unit from the
+  /// .debug_ranges section. If the extraction is unsuccessful, an error
+  /// is returned. Successful extraction requires that the compile unit
+  /// has already been extracted.
+  Error extractRangeList(uint32_t RangeListOffset,
                          DWARFDebugRangeList &RangeList) const;
   void clear();
 
   const Optional<StrOffsetsContributionDescriptor> &
   getStringOffsetsTableContribution() const {
     return StringOffsetsTableContribution;
   }
 
   uint8_t getDwarfStringOffsetsByteSize() const {
public:
   Optional<uint64_t> getDWOId() {
     extractDIEsIfNeeded(/*CUDieOnly*/ true);
     return getHeader().getDWOId();
   }
   void setDWOId(uint64_t NewID) { Header.setDWOId(NewID); }
 
   /// Return a vector of address ranges resulting from a (possibly encoded)
   /// range list starting at a given offset in the appropriate ranges section.
-  DWARFAddressRangesVector findRnglistFromOffset(uint32_t Offset);
+  Expected<DWARFAddressRangesVector> findRnglistFromOffset(uint32_t Offset);
 
   /// Return a vector of address ranges retrieved from an encoded range
   /// list whose offset is found via a table lookup given an index (DWARF v5
   /// and later).
-  DWARFAddressRangesVector findRnglistFromIndex(uint32_t Index);
+  Expected<DWARFAddressRangesVector> findRnglistFromIndex(uint32_t Index);
 
   /// Return a rangelist's offset based on an index. The index designates
   /// an entry in the rangelist table's offset array and is supplied by
   /// DW_FORM_rnglistx.
   Optional<uint32_t> getRnglistOffset(uint32_t Index) {
     if (RngListTable)
       return RngListTable->getOffsetEntry(Index);
     return None;

lib/DebugInfo/DWARF/DWARFContext.cpp

if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
     for (const auto &CU : compile_units()) {
       savedAddressByteSize = CU->getAddressByteSize();
       break;
     }
     DWARFDataExtractor rangesData(*DObj, DObj->getRangeSection(),
                                   isLittleEndian(), savedAddressByteSize);
     uint32_t offset = 0;
     DWARFDebugRangeList rangeList;
-    while (rangeList.extract(rangesData, &offset))
+    while (rangesData.isValidOffset(offset)) {
+      if (Error E = rangeList.extract(rangesData, &offset)) {
+        WithColor::error() << toString(std::move(E)) << '\n';
+        break;  
+      }
       rangeList.dump(OS);
     }
+  }
 
   if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
                  DObj->getRnglistsSection().Data)) {
     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(),
                                    isLittleEndian(), 0);
     dumpRnglistsSection(OS, RnglistData, DumpOpts);
   }
 

lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp

 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdint>
 
 using namespace llvm;
 
+// FIXME: There are several versions of this. Consolidate them.
+template <typename... Ts>
+static Error createError(char const *Fmt, const Ts &... Vals) {
+  std::string Buffer;
+  raw_string_ostream Stream(Buffer);
+  Stream << format(Fmt, Vals...);
+  return make_error<StringError>(Stream.str(), inconvertibleErrorCode());
+}
+
 void DWARFDebugRangeList::clear() {
   Offset = -1U;
   AddressSize = 0;
   Entries.clear();
 }
 
-bool DWARFDebugRangeList::extract(const DWARFDataExtractor &data,
+Error DWARFDebugRangeList::extract(const DWARFDataExtractor &data,
                                    uint32_t *offset_ptr) {
   clear();
   if (!data.isValidOffset(*offset_ptr))
-    return false;
+    return createError("invalid range list offset 0x%" PRIx32, *offset_ptr);
+
   AddressSize = data.getAddressSize();
   if (AddressSize != 4 && AddressSize != 8)
-    return false;
+    return createError("invalid address size: %d", AddressSize);
   Offset = *offset_ptr;
   while (true) {
     RangeListEntry Entry;
     Entry.SectionIndex = -1ULL;
 
     uint32_t prev_offset = *offset_ptr;
     Entry.StartAddress = data.getRelocatedAddress(offset_ptr);
     Entry.EndAddress =
         data.getRelocatedAddress(offset_ptr, &Entry.SectionIndex);
 
     // Check that both values were extracted correctly.
     if (*offset_ptr != prev_offset + 2 * AddressSize) {
       clear();
-      return false;
+      return createError("invalid range list entry at offset 0x%" PRIx32,
+                         prev_offset);
     }
     if (Entry.isEndOfListEntry())
       break;
     Entries.push_back(Entry);
   }
-  return true;
+  return Error::success();
 }
 
 void DWARFDebugRangeList::dump(raw_ostream &OS) const {
   for (const RangeListEntry &RLE : Entries) {
     const char *format_str = (AddressSize == 4
                               ? "%08x %08"  PRIx64 " %08"  PRIx64 "\n"
                               : "%08x %016" PRIx64 " %016" PRIx64 "\n");
     OS << format(format_str, Offset, RLE.StartAddress, RLE.EndAddress);

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

for (const RangeListEntry &RLE : Entries) {
     }
     Res.push_back(E);
   }
   return Res;
 }
 
 Error DWARFDebugRnglist::extract(DWARFDataExtractor Data, uint32_t HeaderOffset,
                                  uint32_t End, uint32_t *OffsetPtr) {
+  if (*OffsetPtr < HeaderOffset || *OffsetPtr >= End)
+    return createError("Invalid range list offset 0x%" PRIx32, *OffsetPtr);
   Entries.clear();
   while (*OffsetPtr < End) {
     RangeListEntry Entry{0, 0, 0, 0, 0};
     if (Error E = Entry.extract(Data, End, OffsetPtr))
       return E;
     Entries.push_back(Entry);
     if (Entry.EntryKind == dwarf::DW_RLE_end_of_list)
       return Error::success();

 
 uint32_t DWARFDebugRnglistTable::length() const {
   if (HeaderData.Length == 0)
     return 0;
   // TODO: DWARF64 support.
   return HeaderData.Length + sizeof(uint32_t);
 }
 
-Optional<DWARFDebugRnglist>
+Expected<DWARFDebugRnglist>
 DWARFDebugRnglistTable::findRangeList(DWARFDataExtractor Data,
                                       uint32_t Offset) {
   auto Entry = Ranges.find(Offset);
   if (Entry != Ranges.end())
     return Entry->second;
 
   // Extract the rangelist from the section and enter it into the ranges map.
   DWARFDebugRnglist RngList;
   uint32_t End = HeaderOffset + length();
   uint32_t StartingOffset = Offset;
-  if (Error E = RngList.extract(Data, HeaderOffset, End, &Offset)) {
-    llvm::consumeError(std::move(E));
-    return None;
-  }
+  if (Error E = RngList.extract(Data, HeaderOffset, End, &Offset))
+    return std::move(E);
   Ranges[StartingOffset] = RngList;
   return RngList;
 }

lib/DebugInfo/DWARF/DWARFDie.cpp

if (Attr == DW_AT_specification || Attr == DW_AT_abstract_origin) {
     Optional<DWARFFormValue> Value = Die.find(DW_AT_ranges);
     if (Value && Value->getForm() == DW_FORM_rnglistx)
       if (auto RangeListOffset =
               U->getRnglistOffset(*Value->getAsSectionOffset())) {
         DWARFFormValue FV(dwarf::DW_FORM_sec_offset);
         FV.setUValue(*RangeListOffset);
         FV.dump(OS, DumpOpts);
       }
-    dumpRanges(Obj, OS, Die.getAddressRanges(), U->getAddressByteSize(),
+    if (auto RangesOrError = Die.getAddressRanges())
+      dumpRanges(Obj, OS, RangesOrError.get(), U->getAddressByteSize(),
                  sizeof(BaseIndent) + Indent + 4, DumpOpts);
+    else
+      WithColor::error() << "decoding address ranges: "
+                         << toString(RangesOrError.takeError()) << '\n';
   }
 
   OS << ")\n";
 }
 
 bool DWARFDie::isSubprogramDIE() const { return getTag() == DW_TAG_subprogram; }
 
 bool DWARFDie::isSubroutineDIE() const {
if (auto HighPcAddr = getHighPC(*LowPcAddr)) {
     LowPC = *LowPcAddr;
     HighPC = *HighPcAddr;
     SectionIndex = F->getSectionIndex();
     return true;
   }
   return false;
 }
 
-DWARFAddressRangesVector DWARFDie::getAddressRanges() const {
+Expected<DWARFAddressRangesVector> DWARFDie::getAddressRanges() const {
   if (isNULL())
     return DWARFAddressRangesVector();
   // Single range specified by low/high PC.
   uint64_t LowPC, HighPC, Index;
   if (getLowAndHighPC(LowPC, HighPC, Index))
-    return {{LowPC, HighPC, Index}};
+    return DWARFAddressRangesVector{{LowPC, HighPC, Index}};
 
   Optional<DWARFFormValue> Value = find(DW_AT_ranges);
   if (Value) {
     if (Value->getForm() == DW_FORM_rnglistx)
       return U->findRnglistFromIndex(*Value->getAsSectionOffset());
     return U->findRnglistFromOffset(*Value->getAsSectionOffset());
   }
   return DWARFAddressRangesVector();
 }
 
 void DWARFDie::collectChildrenAddressRanges(
     DWARFAddressRangesVector &Ranges) const {
   if (isNULL())
     return;
   if (isSubprogramDIE()) {
-    const auto &DIERanges = getAddressRanges();
-    Ranges.insert(Ranges.end(), DIERanges.begin(), DIERanges.end());
+    if (auto DIERangesOrError = getAddressRanges())
+      Ranges.insert(Ranges.end(), DIERangesOrError.get().begin(),
+                    DIERangesOrError.get().end());
+    else
+      llvm::consumeError(DIERangesOrError.takeError());
   }
 
   for (auto Child : children())
     Child.collectChildrenAddressRanges(Ranges);
 }
 
 bool DWARFDie::addressRangeContainsAddress(const uint64_t Address) const {
-  for (const auto &R : getAddressRanges()) {
+  auto RangesOrError = getAddressRanges();
+  if (!RangesOrError) {
+    llvm::consumeError(RangesOrError.takeError());
+    return false;
+  }
+
+  for (const auto &R : RangesOrError.get())
     if (R.LowPC <= Address && Address < R.HighPC)
       return true;
-  }
   return false;
 }
 
 const char *DWARFDie::getSubroutineName(DINameKind Kind) const {
   if (!isSubroutineDIE())
     return nullptr;
   return getName(Kind);
 }

lib/DebugInfo/DWARF/DWARFUnit.cpp

if (Offset > 0) {
     Offset -= 12U;
   }
   llvm::DWARFDebugRnglistTable Table;
   if (Error E = Table.extractHeaderAndOffsets(DA, &Offset))
     return std::move(E);
   return Table;
 }
 
-bool DWARFUnit::extractRangeList(uint32_t RangeListOffset,
+Error DWARFUnit::extractRangeList(uint32_t RangeListOffset,
                                   DWARFDebugRangeList &RangeList) const {
   // Require that compile unit is extracted.
   assert(!DieArray.empty());
   DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
                                 isLittleEndian, getAddressByteSize());
   uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
   return RangeList.extract(RangesData, &ActualRangeListOffset);
 }
 

 
 void DWARFUnit::clearDIEs(bool KeepCUDie) {
   if (DieArray.size() > (unsigned)KeepCUDie) {
     DieArray.resize((unsigned)KeepCUDie);
     DieArray.shrink_to_fit();
   }
 }
 
-DWARFAddressRangesVector DWARFUnit::findRnglistFromOffset(uint32_t Offset) {
+Expected<DWARFAddressRangesVector>
+DWARFUnit::findRnglistFromOffset(uint32_t Offset) {
   if (getVersion() <= 4) {
     DWARFDebugRangeList RangeList;
-    if (extractRangeList(Offset, RangeList))
-      return RangeList.getAbsoluteRanges(getBaseAddress());
-    return DWARFAddressRangesVector();
+    if (Error E = extractRangeList(Offset, RangeList))
+      return std::move(E);
   }
   if (RngListTable) {
     DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
                                   isLittleEndian, RngListTable->getAddrSize());
-    if (auto RangeList = RngListTable->findRangeList(RangesData, Offset))
-      return RangeList->getAbsoluteRanges(getBaseAddress());
+    auto RangeListOrError = RngListTable->findRangeList(RangesData, Offset);
+    if (RangeListOrError)
+      return RangeListOrError.get().getAbsoluteRanges(getBaseAddress());
+    return RangeListOrError.takeError();
   }
-  return DWARFAddressRangesVector();
+
+  return make_error<StringError>("Missing or invalid range list table",
+                                 inconvertibleErrorCode());
 }
 
-DWARFAddressRangesVector DWARFUnit::findRnglistFromIndex(uint32_t Index) {
+Expected<DWARFAddressRangesVector>
+DWARFUnit::findRnglistFromIndex(uint32_t Index) {
   if (auto Offset = getRnglistOffset(Index))
     return findRnglistFromOffset(*Offset + RangeSectionBase);
-  return DWARFAddressRangesVector();
+
+  std::string Buffer;
+  raw_string_ostream Stream(Buffer);
+  if (RngListTable)
+    Stream << format("Invalid range list table index %d", Index);
+  else
+    Stream << "Missing or invalid range list table";
+  return make_error<StringError>(Stream.str(), inconvertibleErrorCode());
 }
 
 void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
   DWARFDie UnitDie = getUnitDIE();
   if (!UnitDie)
     return;
   // First, check if unit DIE describes address ranges for the whole unit.
-  const auto &CUDIERanges = UnitDie.getAddressRanges();
-  if (!CUDIERanges.empty()) {
-    CURanges.insert(CURanges.end(), CUDIERanges.begin(), CUDIERanges.end());
+  auto CUDIERangesOrError = UnitDie.getAddressRanges();
+  if (CUDIERangesOrError) {
+    if (!CUDIERangesOrError.get().empty()) {
+      CURanges.insert(CURanges.end(), CUDIERangesOrError.get().begin(),
+                      CUDIERangesOrError.get().end());
       return;
     }
+  } else
+    WithColor::error() << "decoding address ranges: "
+                       << toString(CUDIERangesOrError.takeError()) << '\n';
 
   // This function is usually called if there in no .debug_aranges section
   // in order to produce a compile unit level set of address ranges that
   // is accurate. If the DIEs weren't parsed, then we don't want all dies for
   // all compile units to stay loaded when they weren't needed. So we can end
   // up parsing the DWARF and then throwing them all away to keep memory usage
   // down.
   const bool ClearDIEs = extractDIEsIfNeeded(false) > 1;
void DWARFUnit::collectAddressRanges(DWARFAddressRangesVector &CURanges) {
   // Keep memory down by clearing DIEs if this generate function
   // caused them to be parsed.
   if (ClearDIEs)
     clearDIEs(true);
 }
 
 void DWARFUnit::updateAddressDieMap(DWARFDie Die) {
   if (Die.isSubroutineDIE()) {
-    for (const auto &R : Die.getAddressRanges()) {
+    auto DIERangesOrError = Die.getAddressRanges();
+    if (DIERangesOrError) {
+      for (const auto &R : DIERangesOrError.get()) {
         // Ignore 0-sized ranges.
         if (R.LowPC == R.HighPC)
           continue;
         auto B = AddrDieMap.upper_bound(R.LowPC);
         if (B != AddrDieMap.begin() && R.LowPC < (--B)->second.first) {
           // The range is a sub-range of existing ranges, we need to split the
           // existing range.
           if (R.HighPC < B->second.first)
             AddrDieMap[R.HighPC] = B->second;
           if (R.LowPC > B->first)
             AddrDieMap[B->first].first = R.LowPC;
         }
         AddrDieMap[R.LowPC] = std::make_pair(R.HighPC, Die);
       }
+    } else
+      llvm::consumeError(DIERangesOrError.takeError());
   }
   // Parent DIEs are added to the AddrDieMap prior to the Children DIEs to
   // simplify the logic to update AddrDieMap. The child's range will always
   // be equal or smaller than the parent's range. With this assumption, when
   // adding one range into the map, it will at most split a range into 3
   // sub-ranges.
   for (DWARFDie Child = Die.getFirstChild(); Child; Child = Child.getSibling())
     updateAddressDieMap(Child);

lib/DebugInfo/DWARF/DWARFVerifier.cpp

 
 unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
                                         DieRangeInfo &ParentRI) {
   unsigned NumErrors = 0;
 
   if (!Die.isValid())
     return NumErrors;
 
-  DWARFAddressRangesVector Ranges = Die.getAddressRanges();
+  auto RangesOrError = Die.getAddressRanges();
+  if (!RangesOrError) {
+    // FIXME: Report the error.
+    ++NumErrors;
+    llvm::consumeError(RangesOrError.takeError());
+    return NumErrors;
+  }
 
+  DWARFAddressRangesVector Ranges = RangesOrError.get();
   // Build RI for this DIE and check that ranges within this DIE do not
   // overlap.
   DieRangeInfo RI(Die);
   for (auto Range : Ranges) {
     if (!Range.valid()) {
       ++NumErrors;
       error() << "Invalid address range " << Range << "\n";
       continue;

test/DebugInfo/X86/dwarfdump-ranges-baseaddr.s

 # RUN: llvm-mc -triple x86_64-pc-linux -filetype=obj %s -o %t
-# RUN: llvm-dwarfdump -v %t | FileCheck %s
+# RUN: llvm-dwarfdump -v %t 2>%t.err | FileCheck %s
+# RUN: FileCheck %s <%t.err -check-prefix=ERR
 
 # CHECK: .debug_info contents:
 # CHECK: 0x0000000b: DW_TAG_compile_unit [1]
 # CHECK:             DW_AT_low_pc [DW_FORM_addr]       (0x0000000000000000)
 # CHECK-NEXT:        DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
 # CHECK-NEXT:    [0x0000000000000000, 0x0000000000000001) ".text"
 # CHECK-NEXT:    [0x0000000000000003, 0x0000000000000006) ".text"
 # CHECK-NEXT:    [0x0000000000000001, 0x0000000000000002) ".text.foo1")

 .long 0                       # DW_AT_producer
 .short 4                      # DW_AT_language
 .long 0                       # DW_AT_name
 .long 0                       # DW_AT_stmt_list
 .long 0                       # DW_AT_comp_dir
 .quad .Lfunc_begin0           # DW_AT_low_pc
 .long .Ldebug_ranges0         # DW_AT_ranges
 
+# A CU with an invalid DW_AT_ranges attribute
+.Lcu_begin1:
+.long 38                      # Length of Unit
+.short 4                      # DWARF version number
+.long .debug_abbrev           # Offset Into Abbrev. Section
+.byte 8                       # Address Size (in bytes)
+.byte 1                       # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+.long 0                       # DW_AT_producer
+.short 4                      # DW_AT_language
+.long 0                       # DW_AT_name
+.long 0                       # DW_AT_stmt_list
+.long 0                       # DW_AT_comp_dir
+.quad .Lfunc_begin0           # DW_AT_low_pc
+.long 0x4000                  # DW_AT_ranges
+
+# ERR: error: decoding address ranges: invalid range list offset 0x4000
+
+# A CU where the DW_AT_ranges attribute points to an invalid range list.
+.Lcu_begin2:
+.long 38                      # Length of Unit
+.short 4                      # DWARF version number
+.long .debug_abbrev           # Offset Into Abbrev. Section
+.byte 8                       # Address Size (in bytes)
+.byte 1                       # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+.long 0                       # DW_AT_producer
+.short 4                      # DW_AT_language
+.long 0                       # DW_AT_name
+.long 0                       # DW_AT_stmt_list
+.long 0                       # DW_AT_comp_dir
+.quad .Lfunc_begin0           # DW_AT_low_pc
+.long .Ldebug_ranges1         # DW_AT_ranges
+
 .section .debug_ranges,"",@progbits
 .Ldebug_ranges0:
  .quad .Lfunc_begin0-.Lfunc_begin0
  .quad .Ltmp0-.Lfunc_begin0
  .quad .Ltmp1-.Lfunc_begin0
  .quad .Ltmp2-.Lfunc_begin0
  .quad 0xFFFFFFFFFFFFFFFF
  .quad .text.foo1
  .quad .Ltmp4-.text.foo1
  .quad .Ltmp5-.text.foo1
  .quad 0
  .quad 0
+.Ldebug_ranges1:
+ .quad 0
+
+# ERR: error: decoding address ranges: invalid range list entry at offset 0x50

test/DebugInfo/X86/dwarfdump-rnglists.s

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o
 # RUN: llvm-dwarfdump -v -debug-info %t.o 2> %t.err | FileCheck %s
 # RUN: FileCheck %s --input-file %t.err --check-prefix=ERR
+# RUN: llvm-dwarfdump -lookup 10 %t.o 2> %t2.err
+# RUN: FileCheck %s --input-file %t2.err --check-prefix=ERR
 
 # Test object to verify dwarfdump handles v5 range lists.
 # We use very simplified compile unit dies.
 # There are 2 full CUs with DW_AT_rnglists_base, one with a DW_AT_ranges
 # attribute using DW_FORM_sec_offset, the other with DW_AT_ranges using
 # DW_FORM_rnglistx.
 
         .section .debug_abbrev,"",@progbits
# There is no DW_AT_rnglists_base in split units.
         .byte 0x00  # DW_CHILDREN_no
         .byte 0x55  # DW_AT_ranges
         .byte 0x23  # DW_FORM_rnglistx
         .byte 0x00  # EOM(1)
         .byte 0x00  # EOM(2)
         .byte 0x00  # EOM(3)
         
         .section .debug_info,"",@progbits
-# DWARF v5 CU header.
         .long  CU1_5_end-CU1_5_version  # Length of Unit
 CU1_5_version:
         .short 5               # DWARF version number
         .byte 1                # DWARF Unit Type
         .byte 4                # Address Size (in bytes)
         .long .debug_abbrev    # Offset Into Abbrev. Section
 # The compile-unit DIE, which has DW_AT_rnglists_base and DW_AT_ranges.
         .byte 1                # Abbreviation code
         .long Rnglist_Table0_base     # DW_AT_rnglists_base
         .long Rnglist_Table0_Rnglist0 # DW_AT_ranges
         .byte 0 # NULL
         .byte 0 # NULL
 CU1_5_end:
 
-# DWARF v5 CU header
         .long  CU2_5_end-CU2_5_version  # Length of Unit
 CU2_5_version:
         .short 5               # DWARF version number
         .byte 1                # DWARF Unit Type
         .byte 4                # Address Size (in bytes)
         .long .debug_abbrev    # Offset Into Abbrev. Section
 # The compile-unit DIE, which has DW_AT_rnglists_base and DW_AT_ranges.
         .byte 2                # Abbreviation code
CU3_5_version:
         .byte 4                # Address Size (in bytes)
         .long .debug_abbrev    # Offset Into Abbrev. Section
 # The compile-unit DIE, which has DW_AT_rnglists_base and DW_AT_ranges.
         .byte 2                # Abbreviation code
         .long 0x8              # DW_AT_rnglists_base
         .long 0                # DW_AT_ranges
         .byte 0                # NULL
 CU3_5_end:
+# A CU DIE with an incorrect DW_AT_ranges attribute
+        .long  CU4_5_end-CU4_5_version  # Length of Unit
+CU4_5_version:
+        .short 5               # DWARF version number
+        .byte 1                # DWARF Unit Type
+        .byte 4                # Address Size (in bytes)
+        .long .debug_abbrev    # Offset Into Abbrev. Section
+# The compile-unit DIE, which has DW_AT_rnglists_base and DW_AT_ranges.
+        .byte 1                # Abbreviation code
+        .long Rnglist_Table0_base   # DW_AT_rnglists_base
+        .long 4000             # DW_AT_ranges
+        .byte 0                # NULL
+CU4_5_end:
 
         .section .debug_info.dwo,"",@progbits
 
 # DWARF v5 split CU header.
         .long  CU_split_5_end-CU_split_5_version  # Length of Unit
 CU_split_5_version:
         .short 5               # DWARF version number
         .byte 5                # DWARF Unit Type

 # CHECK:      .debug_info.dwo contents:
 # CHECK:      Compile Unit:
 # CHECK-NOT:  contents:
 # CHECK:      DW_TAG_compile_unit
 # CHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1) rangelist = 0x00000009
 # CHECK-NEXT: [0x0000002a, 0x00000034))
 
 #ERR: error: parsing a range list table: Did not detect a valid range list table with base = 0x8
+#ERR: error: decoding address ranges: Missing or invalid range list table
+#ERR: error: decoding address ranges: Invalid range list offset 0xfa0

tools/dsymutil/DwarfLinker.cpp

void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
   // 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();
     RangeAttribute.set(Streamer->getRangesSectionSize());
-    RangeList.extract(RangeExtractor, &Offset);
+    if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
+      llvm::consumeError(std::move(E));
+      reportWarning("invalid range list ignored.", DMO);
+      RangeList.clear();
+    }
     const auto &Entries = RangeList.getEntries();
     if (!Entries.empty()) {
       const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
 
       if (CurrRange == InvalidRange ||
           First.StartAddress + OrigLowPc < CurrRange.start() ||
           First.StartAddress + OrigLowPc >= CurrRange.stop()) {
         CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);

tools/llvm-dwarfdump/Statistics.cpp

struct GlobalStats {
   unsigned ScopeBytesCovered = 0;
   /// Total number of PC range bytes in each variable's enclosing scope,
   /// starting from the first definition of the variable.
   unsigned ScopeBytesFromFirstDefinition = 0;
 };
 
 /// Extract the low pc from a Die.
 static uint64_t getLowPC(DWARFDie Die) {
-  if (Die.getAddressRanges().size())
-    return Die.getAddressRanges()[0].LowPC;
+  auto RangesOrError = Die.getAddressRanges();
+  DWARFAddressRangesVector Ranges;
+  if (RangesOrError)
+    Ranges = RangesOrError.get();
+  else
+    llvm::consumeError(RangesOrError.takeError());
+  if (Ranges.size())
+    return Ranges[0].LowPC;
   return dwarf::toAddress(Die.find(dwarf::DW_AT_low_pc), 0);
 }
 
 /// Collect debug info quality metrics for one DIE.
 static void collectStatsForDie(DWARFDie Die, std::string Prefix,
                                uint64_t ScopeLowPC, uint64_t BytesInScope,
                                StringMap<PerFunctionStats> &FnStatMap,
                                GlobalStats &GlobalStats) {
if (Die.getTag() != dwarf::DW_TAG_lexical_block) {
         return;
       // We've seen an (inlined) instance of this function.
       auto &FnStats = FnStatMap[Name];
       FnStats.NumFnInlined++;
       FnStats.IsFunction = true;
     }
 
     // PC Ranges.
-    auto Ranges = Die.getAddressRanges();
+    auto RangesOrError = Die.getAddressRanges();
+    if (!RangesOrError) {
+      llvm::consumeError(RangesOrError.takeError());
+      return;
+    }
+       
+    auto Ranges = RangesOrError.get();
     uint64_t BytesInThisScope = 0;
     for (auto Range : Ranges)
       BytesInThisScope += Range.HighPC - Range.LowPC;
     ScopeLowPC = getLowPC(Die);
 
     if (BytesInThisScope)
       BytesInScope = BytesInThisScope;
   } else {