Parse section ranges when verifying DWARF so we can exclude addresses that should have been stripped from DWARF.

[clayborg]

Summary

This change gets all of the section address ranges with executable permissions and registers these valid .text ranges with the verifier. This allows the verifier to ignore any address ranges that should have been stripped so they don't cause false overlapping errors. This is meant as a starting point to a solution for https://bugs.llvm.org/show_bug.cgi?id=46453. Hopefully we can discuss the pros and cons of this approach and see if this approach is worth persuing.

[clayborg]

This approach is very verbose at the moment so we can see each time an address range is ignored. The idea would be to omit the messages unless "--verbose" is supplied, but for now a warning message is emitted each time a DIE has one or more invalid ranges just so we can see everything that happens. If this approach works, I will make a full set of tests.

[jhenderson]

I'm probably not best-placed to review this, as I haven't really used the verifier in practice, partly because of the exact problem this is trying to solve. In principle, I quite like not needing to use specific tombstone values here, but I wonder whether a "dead" range that isn't a tombstone value should itself be a verification failure, regardless of where it ends up?

Another point: there can be dead data too, and this approach shouldn't be text specific. After all, you can have -fdata-sections leading to discarded data via --gc-sections just as easily as dead text sections from -ffunction-sections.

[clayborg]

In D82838#2122054, @jhenderson wrote:

I'm probably not best-placed to review this, as I haven't really used the verifier in practice, partly because of the exact problem this is trying to solve. In principle, I quite like not needing to use specific tombstone values here, but I wonder whether a "dead" range that isn't a tombstone value should itself be a verification failure, regardless of where it ends up?

Can you give an example of what you are saying above? We can easily ignore tombstone values (-1, -2) in addition to what we are doing here. Zero is more problematic and more common from what I have seen, and that is what this patch really helps weed out. At address zero in a ELF file is right at the ELF header, so not many shared libraries actually have functions with a virtual address of zero from what I have seen.

Another point: there can be dead data too, and this approach shouldn't be text specific. After all, you can have -fdata-sections leading to discarded data via --gc-sections just as easily as dead text sections from -ffunction-sections.

This is definitely possible. I don't think we do any verification on data right now since there isn't much we can do other than emit a warning that the DIE should have been stripped.

[clayborg]

I added the extra "ObjectFile *Obj" argument to the DIContext::verify(...) function currently, though I wonder if the DwarfContext should get this information when it is constructed. It might be handy to have the text ranges available so that standard DWARF queries on the DWARFContext could filter out stripped information when the user looks up information in the DWARF. This could be extended to data sections as well. Thoughts?

[jhenderson]

In D82838#2123649, @clayborg wrote:

In D82838#2122054, @jhenderson wrote:

I'm probably not best-placed to review this, as I haven't really used the verifier in practice, partly because of the exact problem this is trying to solve. In principle, I quite like not needing to use specific tombstone values here, but I wonder whether a "dead" range that isn't a tombstone value should itself be a verification failure, regardless of where it ends up?

Can you give an example of what you are saying above? We can easily ignore tombstone values (-1, -2) in addition to what we are doing here. Zero is more problematic and more common from what I have seen, and that is what this patch really helps weed out. At address zero in a ELF file is right at the ELF header, so not many shared libraries actually have functions with a virtual address of zero from what I have seen.

I mean a range that isn't referenced by any function/data in the final output. For example, if I had the range [0x20, 0x30) in my .debug_ranges, but that range is outside the assigned addresses for the program (which might be, say [0x4000, 0x5000) and [0x10000, 0x20000), could it be a failure? There's no overlapping involved, but the range isn't useful and indicates something might have gone wrong.

[aprantl]

llvm/include/llvm/DebugInfo/DIContext.h

233

Perhaps add a Doxygen comment that explains what the extra argument is for?

[clayborg]

How does everyone feel about using this approach? If this looks good to people, I will add doxygen comments and then add tests. But I wanted to get some feedback prior to proceeding.

[dblaikie]

I think maybe this is sort of orthogonal to 46453... maybe not, but kind of.

Seems like we should filter out known-tombstoned ranges (the only ones we can know for sure are the new -1/-2 tombstones - all the others have ambiguities). Then we should maybe flag maybe-tombstones with a little "eh, maybe?". Then we should warn for anything left that's even partially outside the .text range (this patch), then we should warn for overlaps/etc on the remaining ones?

But as @jhenderson said, maybe those first ones come later & we use the .text range to determine which things to look at for overlap first, then add new verifier checks for "things outside .text that aren't clearly tombstoned" knowing that some of those are expected limitations of (at least gold's) previous tombstoning strategies.

(I'd sort of like to avoid actually looking at the object's executable sections - but I can't really fault the strategy & even if we added all the other verifier checks/warnings/etc, it'd still be super reasonable to warn about ranges that are otherwise totally valid, but extend beyond/are entirely outside the actual executable .text)

[clayborg]

In D82838#2134725, @dblaikie wrote:

I think maybe this is sort of orthogonal to 46453... maybe not, but kind of.

Seems like we should filter out known-tombstoned ranges (the only ones we can know for sure are the new -1/-2 tombstones - all the others have ambiguities). Then we should maybe flag maybe-tombstones with a little "eh, maybe?". Then we should warn for anything left that's even partially outside the .text range (this patch), then we should warn for overlaps/etc on the remaining ones?

So for this patch, anything that isn't in text becomes a warning and not an error? Or do we want to add an option to "llvm-dwarfdump --verify" to enforce the text ranges as feature that is disabled by default? --ignore-invalid-text-ranges?

But as @jhenderson said, maybe those first ones come later & we use the .text range to determine which things to look at for overlap first, then add new verifier checks for "things outside .text that aren't clearly tombstoned" knowing that some of those are expected limitations of (at least gold's) previous tombstoning strategies.

(I'd sort of like to avoid actually looking at the object's executable sections - but I can't really fault the strategy & even if we added all the other verifier checks/warnings/etc, it'd still be super reasonable to warn about ranges that are otherwise totally valid, but extend beyond/are entirely outside the actual executable .text)

Since zero is so prevalent, it is nice to get that noise out of the error checking since it creates so many false errors at the moment. It makes the --verify option less useful and way too noisy if we don't do something. We can also just not do the .text ranges for object files since they typically have relocations on each address. We already avoid looking at ranges in many cases for .o files.

[dblaikie]

In D82838#2135038, @clayborg wrote:

In D82838#2134725, @dblaikie wrote:

I think maybe this is sort of orthogonal to 46453... maybe not, but kind of.

Seems like we should filter out known-tombstoned ranges (the only ones we can know for sure are the new -1/-2 tombstones - all the others have ambiguities). Then we should maybe flag maybe-tombstones with a little "eh, maybe?". Then we should warn for anything left that's even partially outside the .text range (this patch), then we should warn for overlaps/etc on the remaining ones?

So for this patch, anything that isn't in text becomes a warning and not an error? Or do we want to add an option to "llvm-dwarfdump --verify" to enforce the text ranges as feature that is disabled by default? --ignore-invalid-text-ranges?

I think my goal was to suggest implementing filter known-tombstones first (now we have a good/known tombstone) so that "is not in .text" doesn't unduly warn on correctly tombstoned ranges/addresses (honestly bfd's tombstoning should be fairly good - since it creates empty ranges at least in debug_ranges that don't use base address selection entries - . Then we could maybe warn or error to varying degrees on the things in the middle (not certainly tombstoned, not entirely in .text... )

Sorry, didn't mean to muddy the waters with "warning V error" discussion or need to add more flags, etc - folks who implemented/have more ownership over "verify" should chime in on this, but for myself - yeah, I think I'm coming around to "let's just ignore anything that's even partially outside .text for now" & eventually maybe someone implements the specific tombstone support - and then we warn/error/something on "it's not tombstone, but it's outside .text" which would be a separate issue & a problem, even if it's non-overlapping. Then only the "is in .text" bits would be tested for overlapping.

But as @jhenderson said, maybe those first ones come later & we use the .text range to determine which things to look at for overlap first, then add new verifier checks for "things outside .text that aren't clearly tombstoned" knowing that some of those are expected limitations of (at least gold's) previous tombstoning strategies.

(I'd sort of like to avoid actually looking at the object's executable sections - but I can't really fault the strategy & even if we added all the other verifier checks/warnings/etc, it'd still be super reasonable to warn about ranges that are otherwise totally valid, but extend beyond/are entirely outside the actual executable .text)

Since zero is so prevalent, it is nice to get that noise out of the error checking since it creates so many false errors at the moment. It makes the --verify option less useful and way too noisy if we don't do something. We can also just not do the .text ranges for object files since they typically have relocations on each address. We already avoid looking at ranges in many cases for .o files.

Yup.

In theory all this stuff should be supported for object files too.

llvm/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

365

(non-member static shouldn't be used in headers - I fixed the op< to not do this)

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

743

Not sure why this uses UndefSection - be nice to support this in object files and track distinct .text sections. Might be that pre-building a table doesn't suit that strategy - not sure.

(& maybe even non-.text sections, in case someone decides to use attribute((section(".my_section"))) for their functions, for instance)

llvm/include/llvm/DebugInfo/DIContext.h

public:
 
   DIContext(DIContextKind K) : Kind(K) {}
   virtual ~DIContext() = default;
 
   DIContextKind getKind() const { return Kind; }
 
   virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0;
 
-  virtual bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) {
+  virtual bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {},
+                      const object::ObjectFile *Obj = nullptr) {
     // No verifier? Just say things went well.
     return true;
   }
 
   virtual DILineInfo getLineInfoForAddress(
       object::SectionedAddress Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) = 0;
   virtual DILineInfoTable getLineInfoForAddressRange(

llvm/include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

DWARFAddressRange(
       uint64_t LowPC, uint64_t HighPC,
       uint64_t SectionIndex = object::SectionedAddress::UndefSection)
       : LowPC(LowPC), HighPC(HighPC), SectionIndex(SectionIndex) {}
 
   /// Returns true if LowPC is smaller or equal to HighPC. This accounts for
   /// dead-stripped ranges.
   bool valid() const { return LowPC <= HighPC; }
 
+  /// Returns true if [LowPC, HighPC) fully contains the entire range
+  /// [RHS.LowPC, RHS.HighPC).
+  bool contains(const DWARFAddressRange &RHS) const {
+    if (!valid() || !RHS.valid() || SectionIndex != RHS.SectionIndex)
+      return false;
+    if (LowPC <= RHS.LowPC && RHS.LowPC < HighPC)
+      return RHS.HighPC <= HighPC;
+    return false;
+  }
+
   /// Returns true if [LowPC, HighPC) intersects with [RHS.LowPC, RHS.HighPC).
   bool intersects(const DWARFAddressRange &RHS) const {
     assert(valid() && RHS.valid());
     // Empty ranges can't intersect.
     if (LowPC == HighPC || RHS.LowPC == RHS.HighPC)
       return false;
     return LowPC < RHS.HighPC && RHS.LowPC < HighPC;
   }

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
             std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets);
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override {
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets;
     dump(OS, DumpOpts, DumpOffsets);
   }
 
-  bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
+  bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {},
+              const object::ObjectFile *Obj = nullptr) override;
 
   using unit_iterator_range = DWARFUnitVector::iterator_range;
 
   /// Get units from .debug_info in this context.
   unit_iterator_range info_section_units() {
     parseNormalUnits();
     return unit_iterator_range(NormalUnits.begin(),
                                NormalUnits.begin() +

llvm/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

 class DWARFDataExtractor;
 class DWARFDebugAbbrev;
 class DataExtractor;
 struct DWARFSection;
 
 /// A class that verifies DWARF debug information given a DWARF Context.
 class DWARFVerifier {
 public:
+  /// A class that keeps address ranges sorted for quick lookups.
+  struct SortedRanges {
+    /// Sorted DWARFAddressRanges.
+    DWARFAddressRangesVector Ranges;
+    typedef DWARFAddressRangesVector::const_iterator address_range_iterator;
+    SortedRanges() = default;
+    SortedRanges(const DWARFAddressRangesVector R);
+    /// Inserts the address range. If the range overlaps with an existing
+    /// range, the range that it overlaps with will be returned and the two
+    /// address ranges will be unioned together in "Ranges".
+    ///
+    /// This is used for finding overlapping ranges in the DW_AT_ranges
+    /// attribute of a DIE. It is also used as a set of address ranges that
+    /// children address ranges must all be contained in.
+    Optional<DWARFAddressRange> insert(const DWARFAddressRange &R);
+
+    /// Return true if ranges in this object contains the range within RHS.
+    bool contains(const DWARFAddressRange &Range) const;
+
+    /// Return true if ranges in this object contains all ranges within RHS.
+    bool contains(const SortedRanges &RHS) const;
+
+    /// Return true if any range in this object intersects with any range in
+    /// RHS.
+    bool intersects(const SortedRanges &RHS) const;
+
+    /// Returns true if there are no address ranges.
+    bool empty() const { return Ranges.empty(); }
+  };
+
   /// A class that keeps the address range information for a single DIE.
   struct DieRangeInfo {
     DWARFDie Die;
 
     /// Sorted DWARFAddressRanges.
-    std::vector<DWARFAddressRange> Ranges;
+    SortedRanges Ranges;
 
     /// Sorted DWARFAddressRangeInfo.
     std::set<DieRangeInfo> Children;
 
     DieRangeInfo() = default;
     DieRangeInfo(DWARFDie Die) : Die(Die) {}
 
     /// Used for unit testing.
-    DieRangeInfo(std::vector<DWARFAddressRange> Ranges)
-        : Ranges(std::move(Ranges)) {}
+    DieRangeInfo(DWARFAddressRangesVector R) : Ranges(R) {}
 
-    typedef std::vector<DWARFAddressRange>::const_iterator
-        address_range_iterator;
     typedef std::set<DieRangeInfo>::const_iterator die_range_info_iterator;
 
-    /// Inserts the address range. If the range overlaps with an existing
-    /// range, the range that it overlaps with will be returned and the two
-    /// address ranges will be unioned together in "Ranges".
-    ///
-    /// This is used for finding overlapping ranges in the DW_AT_ranges
-    /// attribute of a DIE. It is also used as a set of address ranges that
-    /// children address ranges must all be contained in.
-    Optional<DWARFAddressRange> insert(const DWARFAddressRange &R);
-
-    /// Finds an address range in the sorted vector of ranges.
-    address_range_iterator findRange(const DWARFAddressRange &R) const {
-      auto Begin = Ranges.begin();
-      auto End = Ranges.end();
-      auto Iter = std::upper_bound(Begin, End, R);
-      if (Iter != Begin)
-        --Iter;
-      return Iter;
-    }
-
     /// Inserts the address range info. If any of its ranges overlaps with a
     /// range in an existing range info, the range info is *not* added and an
     /// iterator to the overlapping range info.
     ///
     /// This is used for finding overlapping children of the same DIE.
     die_range_info_iterator insert(const DieRangeInfo &RI);
 
     /// Return true if ranges in this object contains all ranges within RHS.
     bool contains(const DieRangeInfo &RHS) const;
 
     /// Return true if any range in this object intersects with any range in
     /// RHS.
     bool intersects(const DieRangeInfo &RHS) const;
   };
 
 private:
   raw_ostream &OS;
   DWARFContext &DCtx;
   DIDumpOptions DumpOpts;
   /// A map that tracks all references (converted absolute references) so we
   /// can verify each reference points to a valid DIE and not an offset that
   /// lies between to valid DIEs.
   std::map<uint64_t, std::set<uint64_t>> ReferenceToDIEOffsets;
+  Optional<SortedRanges> ValidTextRanges;
   uint32_t NumDebugLineErrors = 0;
   // Used to relax some checks that do not currently work portably
   bool IsObjectFile;
   bool IsMachOObject;
 
   raw_ostream &error() const;
   raw_ostream &warn() const;
   raw_ostream &note() const;
   raw_ostream &dump(const DWARFDie &Die, unsigned indent = 0) const;
 
+  /// Detects if a DWARF address range is stripped.
+  ///
+  /// This function can check any DWARF address range to make sure it should be
+  /// checked. If the object file has executable sections, those address ranges
+  /// can be used to determine if an address range is stripped. This helps
+  /// catch addresses left in the DWARF whose low PC has been set to zero, -1
+  /// or -2. Typically those addresses won't be valid function addresses.
+  ///
+  /// \param R An address range from DWARF to check.
+  ///
+  /// \returns True if the text ranges have been set and if the address is not
+  /// contained in any of those ranges.
+  bool rangeIsStripped(const DWARFAddressRange R) const {
+    // If we have .text ranges, check to make sure the address range is not
+    // contained in any of them.
+    if (ValidTextRanges)
+      return !ValidTextRanges->contains(R);
+    // No .text ranges have been set we don't know if an address range
+    // should have been stripped, so we return false.
+    return false;
+  }
+
   /// Verifies the abbreviations section.
   ///
   /// This function currently checks that:
   /// --No abbreviation declaration has more than one attributes with the same
   /// name.
   ///
   /// \param Abbrev Pointer to the abbreviations section we are verifying
   /// Abbrev can be a pointer to either .debug_abbrev or debug_abbrev.dwo.
public:
   /// Verify the information in accelerator tables, if they exist.
   ///
   /// Any errors are reported to the stream that was this object was
   /// constructed with.
   ///
   /// \returns true if the existing Apple-style accelerator tables verify
   /// successfully, false otherwise.
   bool handleAccelTables();
+
+  void setValidTextRanges(const SortedRanges &R) { ValidTextRanges = R; }
 };
 
+static inline bool operator<(const DWARFVerifier::SortedRanges &LHS,
+                             const DWARFVerifier::SortedRanges &RHS) {
+  return LHS.Ranges < RHS.Ranges;
+}
+
 static inline bool operator<(const DWARFVerifier::DieRangeInfo &LHS,
                              const DWARFVerifier::DieRangeInfo &RHS) {
   return std::tie(LHS.Ranges, LHS.Die) < std::tie(RHS.Ranges, RHS.Die);
 }
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFCONTEXT_H

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

 //===- DWARFContext.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
+#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAddr.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"

 
 DWARFDie DWARFContext::getDIEForOffset(uint64_t Offset) {
   parseNormalUnits();
   if (auto *CU = NormalUnits.getUnitForOffset(Offset))
     return CU->getDIEForOffset(Offset);
   return DWARFDie();
 }
 
-bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
+bool DWARFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts,
+                          const object::ObjectFile *Obj) {
   bool Success = true;
   DWARFVerifier verifier(OS, *this, DumpOpts);
 
+  if (Obj) {
+    // We need to know where the valid sections are that contain instructions.
+    // See header documentation for DWARFTransformer::SetValidTextRanges() for
+    // defails.
+    DWARFAddressRangesVector TextRanges;
+    for (const object::SectionRef &Sect : Obj->sections()) {
+      if (!Sect.isText())
+        continue;
+      const uint64_t Size = Sect.getSize();
+      if (Size == 0)
+        continue;
+      const uint64_t StartAddr = Sect.getAddress();
+      TextRanges.emplace_back(DWARFAddressRange(
+          StartAddr, StartAddr + Size, SectionedAddress::UndefSection));
+    }
+    if (!TextRanges.empty())
+      verifier.setValidTextRanges(TextRanges);
+  }
+
   Success &= verifier.handleDebugAbbrev();
   if (DumpOpts.DumpType & DIDT_DebugInfo)
     Success &= verifier.handleDebugInfo();
   if (DumpOpts.DumpType & DIDT_DebugLine)
     Success &= verifier.handleDebugLine();
   Success &= verifier.handleAccelTables();
   return Success;
 }

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

 #include <map>
 #include <set>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 using namespace object;
 
+DWARFVerifier::SortedRanges::SortedRanges(const DWARFAddressRangesVector R) {
+  for (const auto Range : R)
+    insert(Range);
+}
+
 Optional<DWARFAddressRange>
-DWARFVerifier::DieRangeInfo::insert(const DWARFAddressRange &R) {
+DWARFVerifier::SortedRanges::insert(const DWARFAddressRange &R) {
   auto Begin = Ranges.begin();
   auto End = Ranges.end();
   auto Pos = std::lower_bound(Begin, End, R);
 
   if (Pos != End) {
     DWARFAddressRange Range(*Pos);
     if (Pos->merge(R))
       return Range;
   }
   if (Pos != Begin) {
     auto Iter = Pos - 1;
     DWARFAddressRange Range(*Iter);
     if (Iter->merge(R))
       return Range;
   }
 
   Ranges.insert(Pos, R);
   return None;
 }
 
-DWARFVerifier::DieRangeInfo::die_range_info_iterator
-DWARFVerifier::DieRangeInfo::insert(const DieRangeInfo &RI) {
-  auto End = Children.end();
-  auto Iter = Children.begin();
-  while (Iter != End) {
-    if (Iter->intersects(RI))
-      return Iter;
-    ++Iter;
+bool DWARFVerifier::SortedRanges::contains(const DWARFAddressRange &R) const {
+  auto Begin = Ranges.begin();
+  auto End = Ranges.end();
+  auto Pos = std::lower_bound(Begin, End, R);
+  if (Pos != End && Pos->contains(R))
+    return true;
+  if (Pos != Begin) {
+    auto Prev = Pos - 1;
+    return Prev->contains(R);
   }
-  Children.insert(RI);
-  return Children.end();
+  return false;
 }
 
-bool DWARFVerifier::DieRangeInfo::contains(const DieRangeInfo &RHS) const {
+bool DWARFVerifier::SortedRanges::contains(const SortedRanges &RHS) const {
   auto I1 = Ranges.begin(), E1 = Ranges.end();
   auto I2 = RHS.Ranges.begin(), E2 = RHS.Ranges.end();
   if (I2 == E2)
     return true;
 
   DWARFAddressRange R = *I2;
   while (I1 != E1) {
     bool Covered = I1->LowPC <= R.LowPC;
     if (R.LowPC == R.HighPC || (Covered && R.HighPC <= I1->HighPC)) {
       if (++I2 == E2)
         return true;
       R = *I2;
       continue;
     }
     if (!Covered)
       return false;
     if (R.LowPC < I1->HighPC)
       R.LowPC = I1->HighPC;
     ++I1;
   }
   return false;
 }
 
-bool DWARFVerifier::DieRangeInfo::intersects(const DieRangeInfo &RHS) const {
+bool DWARFVerifier::SortedRanges::intersects(const SortedRanges &RHS) const {
   auto I1 = Ranges.begin(), E1 = Ranges.end();
   auto I2 = RHS.Ranges.begin(), E2 = RHS.Ranges.end();
   while (I1 != E1 && I2 != E2) {
     if (I1->intersects(*I2))
       return true;
     if (I1->LowPC < I2->LowPC)
       ++I1;
     else
       ++I2;
   }
   return false;
 }
 
+DWARFVerifier::DieRangeInfo::die_range_info_iterator
+DWARFVerifier::DieRangeInfo::insert(const DieRangeInfo &RI) {
+  auto End = Children.end();
+  auto Iter = Children.begin();
+  while (Iter != End) {
+    if (Iter->intersects(RI))
+      return Iter;
+    ++Iter;
+  }
+  Children.insert(RI);
+  return Children.end();
+}
+
+bool DWARFVerifier::DieRangeInfo::contains(const DieRangeInfo &RHS) const {
+  return Ranges.contains(RHS.Ranges);
+}
+
+bool DWARFVerifier::DieRangeInfo::intersects(const DieRangeInfo &RHS) const {
+  return Ranges.intersects(RHS.Ranges);
+}
+
 bool DWARFVerifier::verifyUnitHeader(const DWARFDataExtractor DebugInfoData,
                                      uint64_t *Offset, unsigned UnitIndex,
                                      uint8_t &UnitType, bool &isUnitDWARF64) {
   uint64_t AbbrOffset, Length;
   uint8_t AddrSize = 0;
   uint16_t Version;
   bool Success = true;
 
unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
   // information for the associated section.
   //
   // For now, simply elide the range verification for the CU DIEs if we are
   // processing an object file.
 
   if (!IsObjectFile || IsMachOObject || Die.getTag() != DW_TAG_compile_unit) {
     bool DumpDieAfterError = false;
     for (auto Range : Ranges) {
+      if (rangeIsStripped(Range)) {
+        OS << "warning: ignoring stripped address range " << Range << "\n";
+        DumpDieAfterError = true;
+        continue;
+      }
       if (!Range.valid()) {
         ++NumErrors;
         error() << "Invalid address range " << Range << "\n";
         DumpDieAfterError = true;
         continue;
       }
 
       // Verify that ranges don't intersect and also build up the DieRangeInfo
       // address ranges. Don't break out of the loop below early, or we will
       // think this DIE doesn't have all of the address ranges it is supposed
       // to have. Compile units often have DW_AT_ranges that can contain one or
       // more dead stripped address ranges which tend to all be at the same
       // address: 0 or -1.
-      if (auto PrevRange = RI.insert(Range)) {
+      if (auto PrevRange = RI.Ranges.insert(Range)) {
         ++NumErrors;
         error() << "DIE has overlapping ranges in DW_AT_ranges attribute: "
                 << *PrevRange << " and " << Range << '\n';
         DumpDieAfterError = true;
       }
     }
     if (DumpDieAfterError)
       dump(Die, 2) << '\n';

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 
 static bool verifyObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                              const Twine &Filename, raw_ostream &OS) {
   // Verify the DWARF and exit with non-zero exit status if verification
   // fails.
   raw_ostream &stream = Quiet ? nulls() : OS;
   stream << "Verifying " << Filename.str() << ":\tfile format "
   << Obj.getFileFormatName() << "\n";
-  bool Result = DICtx.verify(stream, getDumpOpts(DICtx));
+
+  bool Result = DICtx.verify(stream, getDumpOpts(DICtx), &Obj);
   if (Result)
     stream << "No errors.\n";
   else
     stream << "Errors detected.\n";
   return Result;
 }
 
 static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,