[DebugInfo] Add basic support for DWARF 5 .debug_rnglists dumping

[jhenderson]

Summary

This change adds support to llvm-dwarfdump for dumping a DWARF5 .debug_rnglists section in a regular ELF file. It is not complete, in that several DW_RLE_* encodings are not currently supported, but does dump the header and the basic ranges for DW_RLE_start_length and DW_RLE_start_end encodings.

Obvious next steps are to add verbose dumping that dumps the raw encodings, rather than the interpreted contents, to add -verify support of the section (e.g. to show that the correct number of offsets is included), add dumping of .debug_rnglists.dwo, and to add support for other encodings.

[dblaikie]

I'm guessing several of these invalid tests could be in one file - only the "length too long" should need to be last in the list, right? ("length too short" is undetectable, isn't it? it'd just appear as though the remaining bytes outside the length were the next entry and that entry would be incorrect in some way (its length, version, etc))

Also, it might be that we want more fidelity in the dumping, so that we can test the differences in encoding between start+length, start+end, offset+offset, etc?

More or less like I was dabbling with for loc lists here: https://reviews.llvm.org/D36300 you can see how different loc list ranges are dumped differently, explaining how the loc list is structured not just what it means semantically.

[jhenderson]

In D42481#986902, @dblaikie wrote:

I'm guessing several of these invalid tests could be in one file - only the "length too long" should need to be last in the list, right? ("length too short" is undetectable, isn't it? it'd just appear as though the remaining bytes outside the length were the next entry and that entry would be incorrect in some way (its length, version, etc))

The "length too short" test is not undetectable in this instance, because it leaves the .debug_rnglists without an end of list marker, which is invalid. In other cases, you are right, a short length may be undetectable e.g. if the length missed out an entire list of ranges, or the entire payload. The invalid_offset_entries test can't be combined with the too long test, because both effectively result in trying to read more than there is available, in the current code (we don't bother to validate the number of offset entries against the section size, although that is something that could be done - I considered this unnecessary because the DataExtractor class will simply read 0s if it runs off the end of the section). I could combine the invalid header case, the short case, and one of the long length or invalid offset cases, but as that leaves one separate case, I feel like the clarity of distinct test cases is better at that point.

Also, it might be that we want more fidelity in the dumping, so that we can test the differences in encoding between start+length, start+end, offset+offset, etc?

More or less like I was dabbling with for loc lists here: https://reviews.llvm.org/D36300 you can see how different loc list ranges are dumped differently, explaining how the loc list is structured not just what it means semantically.

I agree that this would be useful to have, but I felt like this belonged under the "verbose" switch in llvm-dwarfdump. This would be similar to .debug_line, where -debug-line dumps just the interpreted line table, whilst -debug-line -verbose dumps the encoding as well as the interpretation of it.

[JDevlieghere]

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

23

As this is so similar to DWARFAddressRange it would be nice if we could reuse that in some way. We already have infrastructure to verify these entries for things like overlap that we might want to reuse in the verifier.

lib/DebugInfo/DWARF/DWARFContext.cpp

488

Set?

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

23

Let's return an LLVM error instead of a bool so we can convey a useful error message to the caller.

109

LLVM Coding standard says no braces around single line if/for

117

Same here and on the next line.

[dblaikie]

In D42481#987601, @jhenderson wrote:

In D42481#986902, @dblaikie wrote:

I'm guessing several of these invalid tests could be in one file - only the "length too long" should need to be last in the list, right? ("length too short" is undetectable, isn't it? it'd just appear as though the remaining bytes outside the length were the next entry and that entry would be incorrect in some way (its length, version, etc))

The "length too short" test is not undetectable in this instance, because it leaves the .debug_rnglists without an end of list marker, which is invalid.

Sure, but it would be detected as "missing end of list marker" rather than "length too short". I would think we should probably be respecting the length to find the boundaries - rather than assuming the length is wrong and walking further to find the beginning of the next contribution.

In other cases, you are right, a short length may be undetectable e.g. if the length missed out an entire list of ranges, or the entire payload. The invalid_offset_entries test can't be combined with the too long test, because both effectively result in trying to read more than there is available, in the current code (we don't bother to validate the number of offset entries against the section size, although that is something that could be done - I considered this unnecessary because the DataExtractor class will simply read 0s if it runs off the end of the section).

As developer tools, it might be good for llvm-dwarfdump to provide more precise error messages to ensure debugging is as easy as possible (if it says "hey, there's a zero here" and there's no zero - it just reached the end of the contribution - that could cause some painful mislead debugging)

I could combine the invalid header case, the short case, and one of the long length or invalid offset cases, but as that leaves one separate case, I feel like the clarity of distinct test cases is better at that point.

Also, it might be that we want more fidelity in the dumping, so that we can test the differences in encoding between start+length, start+end, offset+offset, etc?

More or less like I was dabbling with for loc lists here: https://reviews.llvm.org/D36300 you can see how different loc list ranges are dumped differently, explaining how the loc list is structured not just what it means semantically.

I agree that this would be useful to have, but I felt like this belonged under the "verbose" switch in llvm-dwarfdump. This would be similar to .debug_line, where -debug-line dumps just the interpreted line table, whilst -debug-line -verbose dumps the encoding as well as the interpretation of it.

Fair enough

[jhenderson]

Addressed review comments.

In switching to using Errors, I realised I could add several more errors producing finer grained error messages. To go along with that, I've also rewritten the tests quite a bit, mostly to combine the error message tests into a single test, and to test a couple of corner cases.

With this change, the behaviour is to try to keep going and parse other tables in the same section, as much as possible. In keeping with what happens with other debug sections, when there is an error with the .debug_rnglists parsing, llvm-dwarfdump still does not exit with a failure.

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

23

Good idea. I wonder if DWARFAddressRange should be moved into its own file, since it's not specific to the DWARFDebugRangeList class?

lib/DebugInfo/DWARF/DWARFContext.cpp

488

Oops, that was leftover from an earlier version when the class was called something to do with sets.

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

23

I like this idea. It allows for more fine-grained behaviour than simply not printing the section.

117

There are two lines in the outer loop!

[dblaikie]

lib/DebugInfo/DWARF/DWARFContext.cpp

488

Move this variable into the loop - since it's not intended to preserve state between iterations of the loop? I realize it means some memory reuse by keeping it outside the loop, but I'd probably classify that as premature optimization?

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

20

Could this be written as "HeaderData = {}" ?

25–37

These seem a bit weirdly special cased to handle certain string layouts.

Could you instead use the LLVM string format library as you've used elsewhere?

104

Probably more appropriate to use createError here - since it's certainly reachable by user-defined inputs. But up to you if you reckon this'll be around for a really short time.

test/tools/llvm-dwarfdump/X86/debug_rnglists_invalid.s

9–27 ↗

(On Diff #132142)

Looks like this should move to the some_invalid.s file? Alternatively, could that assembly be moved into this file?

[JDevlieghere]

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

23

Sounds like a good idea!

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

117

Right, missed the last OS << ... underneath :-)

[jhenderson]

Addressed review comments.

[dblaikie]

Looks good to me

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

104

Test cases for these, then? (the same test cases can be updated once there's better dumping support to test the behavior there)

include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DWARF_SECTION(DebugAranges, ".debug_aranges", "debug-aranges")
 HANDLE_DWARF_SECTION(DebugInfo, ".debug_info", "debug-info")
 HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types")
 HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line")
 HANDLE_DWARF_SECTION(DebugLoc, ".debug_loc", "debug-loc")
 HANDLE_DWARF_SECTION(DebugFrame, ".debug_frame", "debug-frame")
 HANDLE_DWARF_SECTION(DebugMacro, ".debug_macro", "debug-macro")
 HANDLE_DWARF_SECTION(DebugNames, ".debug_names", "debug-names")
-HANDLE_DWARF_SECTION(DebugRanges, ".debug_ranges", "debug-ranges")
 HANDLE_DWARF_SECTION(DebugPubnames, ".debug_pubnames", "debug-pubnames")
 HANDLE_DWARF_SECTION(DebugPubtypes, ".debug_pubtypes", "debug-pubtypes")
 HANDLE_DWARF_SECTION(DebugGnuPubnames, ".debug_gnu_pubnames", "debug-gnu-pubnames")
 HANDLE_DWARF_SECTION(DebugGnuPubtypes, ".debug_gnu_pubtypes", "debug-gnu-pubtypes")
+HANDLE_DWARF_SECTION(DebugRanges, ".debug_ranges", "debug-ranges")
+HANDLE_DWARF_SECTION(DebugRnglists, ".debug_rnglists", "debug-rnglists")
 HANDLE_DWARF_SECTION(DebugStr, ".debug_str", "debug-str")
 HANDLE_DWARF_SECTION(DebugStrOffsets, ".debug_str_offsets", "debug-str-offsets")
 HANDLE_DWARF_SECTION(DebugCUIndex, ".debug_cu_index", "debug-cu-index")
 HANDLE_DWARF_SECTION(DebugTUIndex, ".debug_tu_index", "debug-tu-index")
 // Vendor extensions.
 HANDLE_DWARF_SECTION(AppleNames, ".apple_names", "apple-names")
 HANDLE_DWARF_SECTION(AppleTypes, ".apple_types", "apple-types")
 HANDLE_DWARF_SECTION(AppleNamespaces, ".apple_namespaces", "apple-namespaces")

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

+//===- DWARFDebugRnglists.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_DEBUGINFO_DWARFDEBUGRNGLISTS_H
+#define LLVM_DEBUGINFO_DWARFDEBUGRNGLISTS_H
+
+#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+
+class raw_ostream;
+
+class DWARFDebugRnglists {
+public:
+  struct BoundedRange {
+    uint64_t Start;
+    uint64_t End;
+
+    BoundedRange(uint64_t S, uint64_t E) : Start(S), End(E) {}
+  };
+  using RangeList = std::vector<BoundedRange>;
+
+private:
+  struct Header {
+    /// The total length of the entries for this table, not including the length
+    /// field itself.
+    uint32_t Length;
+    /// The DWARF version number.
+    uint16_t Version;
+    /// The size in bytes of an address on the target architecture. For
+    /// segmented addressing, this is the size of the offset portion of the
+    /// address.
+    uint8_t AddrSize;
+    /// The size in bytes of a segment selector on the target architecture.
+    /// If the target system uses a flat address space, this value is 0.
+    uint8_t SegSize;
+    /// The number of offsets that follow the header before the range lists.
+    uint32_t OffsetEntryCount;
+  };
+
+  Header HeaderData;
+  std::vector<uint64_t> Offsets;
+  std::vector<RangeList> Ranges;
+
+public:
+  void clear();
+  bool extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
+  void dump(raw_ostream &OS) const;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_DWARFDEBUGRNGLISTS_H

include/llvm/DebugInfo/DWARF/DWARFObject.h

public:
   virtual StringRef getAbbrevSection() const { return ""; }
   virtual const DWARFSection &getLocSection() const { return Dummy; }
   virtual StringRef getARangeSection() const { return ""; }
   virtual StringRef getDebugFrameSection() const { return ""; }
   virtual StringRef getEHFrameSection() const { return ""; }
   virtual const DWARFSection &getLineSection() const { return Dummy; }
   virtual StringRef getStringSection() const { return ""; }
   virtual const DWARFSection &getRangeSection() const { return Dummy; }
+  virtual const DWARFSection &getRnglistsSection() const { return Dummy; }
   virtual StringRef getMacinfoSection() const { return ""; }
   virtual StringRef getPubNamesSection() const { return ""; }
   virtual StringRef getPubTypesSection() const { return ""; }
   virtual StringRef getGnuPubNamesSection() const { return ""; }
   virtual StringRef getGnuPubTypesSection() const { return ""; }
   virtual const DWARFSection &getStringOffsetSection() const { return Dummy; }
   virtual const DWARFSection &getInfoDWOSection() const { return Dummy; }
   virtual void

lib/DebugInfo/DWARF/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoDWARF
   DWARFAbbreviationDeclaration.cpp
   DWARFAcceleratorTable.cpp
   DWARFCompileUnit.cpp
   DWARFContext.cpp
   DWARFDataExtractor.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugAranges.cpp
   DWARFDebugFrame.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp
   DWARFDebugLoc.cpp
   DWARFDebugMacro.cpp
   DWARFDebugPubTable.cpp
   DWARFDebugRangeList.cpp
+  DWARFDebugRnglists.cpp
   DWARFDie.cpp
   DWARFExpression.cpp
   DWARFFormValue.cpp
   DWARFGdbIndex.cpp
   DWARFTypeUnit.cpp
   DWARFUnitIndex.cpp
   DWARFUnit.cpp
   DWARFVerifier.cpp
   SyntaxHighlighting.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/DWARF
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo
   )

lib/DebugInfo/DWARF/DWARFContext.cpp

 #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"
 #include "llvm/DebugInfo/DWARF/DWARFDebugMacro.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Object/Decompressor.h"
if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
     DWARFDataExtractor rangesData(*DObj, DObj->getRangeSection(),
                                   isLittleEndian(), savedAddressByteSize);
     uint32_t offset = 0;
     DWARFDebugRangeList rangeList;
     while (rangeList.extract(rangesData, &offset))
       rangeList.dump(OS);
   }
 
+  if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
+                 DObj->getRnglistsSection().Data)) {
+    DWARFDataExtractor rnglistData(*DObj, DObj->getRnglistsSection(),
+                                   isLittleEndian(), 0);
+    DWARFDebugRnglists Set;
+    uint32_t Offset = 0;
+    while (Set.extract(rnglistData, &Offset))
+      Set.dump(OS);
+  }
+
   if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames,
                  DObj->getPubNamesSection()))
     DWARFDebugPubTable(DObj->getPubNamesSection(), isLittleEndian(), false)
         .dump(OS);
 
   if (shouldDump(Explicit, ".debug_pubtypes", DIDT_ID_DebugPubtypes,
                  DObj->getPubTypesSection()))
     DWARFDebugPubTable(DObj->getPubTypesSection(), isLittleEndian(), false)
class DWARFObjInMemory final : public DWARFObject {
 
   TypeSectionMap TypesSections;
   TypeSectionMap TypesDWOSections;
 
   DWARFSectionMap InfoSection;
   DWARFSectionMap LocSection;
   DWARFSectionMap LineSection;
   DWARFSectionMap RangeSection;
+  DWARFSectionMap RnglistsSection;
   DWARFSectionMap StringOffsetSection;
   DWARFSectionMap InfoDWOSection;
   DWARFSectionMap LineDWOSection;
   DWARFSectionMap LocDWOSection;
   DWARFSectionMap StringOffsetDWOSection;
   DWARFSectionMap RangeDWOSection;
   DWARFSectionMap AddrSection;
   DWARFSectionMap AppleNamesSection;
   DWARFSectionMap AppleTypesSection;
   DWARFSectionMap AppleNamespacesSection;
   DWARFSectionMap AppleObjCSection;
 
   DWARFSectionMap *mapNameToDWARFSection(StringRef Name) {
     return StringSwitch<DWARFSectionMap *>(Name)
         .Case("debug_info", &InfoSection)
         .Case("debug_loc", &LocSection)
         .Case("debug_line", &LineSection)
         .Case("debug_str_offsets", &StringOffsetSection)
         .Case("debug_ranges", &RangeSection)
+        .Case("debug_rnglists", &RnglistsSection)
         .Case("debug_info.dwo", &InfoDWOSection)
         .Case("debug_loc.dwo", &LocDWOSection)
         .Case("debug_line.dwo", &LineDWOSection)
         .Case("debug_str_offsets.dwo", &StringOffsetDWOSection)
         .Case("debug_addr", &AddrSection)
         .Case("apple_names", &AppleNamesSection)
         .Case("apple_types", &AppleTypesSection)
         .Case("apple_namespaces", &AppleNamespacesSection)
public:
   StringRef getAbbrevSection() const override { return AbbrevSection; }
   const DWARFSection &getLocSection() const override { return LocSection; }
   StringRef getARangeSection() const override { return ARangeSection; }
   StringRef getDebugFrameSection() const override { return DebugFrameSection; }
   StringRef getEHFrameSection() const override { return EHFrameSection; }
   const DWARFSection &getLineSection() const override { return LineSection; }
   StringRef getStringSection() const override { return StringSection; }
   const DWARFSection &getRangeSection() const override { return RangeSection; }
+  const DWARFSection &getRnglistsSection() const override {
+    return RnglistsSection;
+  }
   StringRef getMacinfoSection() const override { return MacinfoSection; }
   StringRef getPubNamesSection() const override { return PubNamesSection; }
   StringRef getPubTypesSection() const override { return PubTypesSection; }
   StringRef getGnuPubNamesSection() const override {
     return GnuPubNamesSection;
   }
   StringRef getGnuPubTypesSection() const override {
     return GnuPubTypesSection;

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

+//===- DWARFDebugRnglists.cpp ---------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+void DWARFDebugRnglists::clear() {
+  std::memset(&HeaderData, 0, sizeof(Header));
+  Offsets.clear();
+  Ranges.clear();
+}
+
+bool DWARFDebugRnglists::extract(DWARFDataExtractor Data, uint32_t *OffsetPtr) {
+  clear();
+  if (!Data.isValidOffsetForDataOfSize(*OffsetPtr, sizeof(Header))) {
+    return false;
+  }
+
+  uint32_t TableOffset = *OffsetPtr;
+
+  // TODO: Add support for DWARF64.
+  HeaderData.Length = Data.getU32(OffsetPtr);
+  HeaderData.Version = Data.getU16(OffsetPtr);
+  HeaderData.AddrSize = Data.getU8(OffsetPtr);
+  HeaderData.SegSize = Data.getU8(OffsetPtr);
+  HeaderData.OffsetEntryCount = Data.getU32(OffsetPtr);
+
+  uint64_t End = TableOffset + HeaderData.Length + sizeof(uint32_t);
+
+  // Perform basic validation of the header fields.
+  if (!Data.isValidOffsetForDataOfSize(TableOffset, End - TableOffset) ||
+      (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)) {
+    clear();
+    return false;
+  }
+  if (End < TableOffset + sizeof(HeaderData) +
+                HeaderData.OffsetEntryCount * sizeof(uint32_t)) {
+    clear();
+    return false;
+  }
+
+  Data.setAddressSize(HeaderData.AddrSize);
+
+  for (uint32_t I = 0; I < HeaderData.OffsetEntryCount; ++I)
+    Offsets.push_back(Data.getU32(OffsetPtr));
+
+  std::vector<BoundedRange> CurrentRanges;
+  while (Data.isValidOffset(*OffsetPtr) && *OffsetPtr < End) {
+    uint8_t Encoding = Data.getU8(OffsetPtr);
+    switch (Encoding) {
+    case dwarf::DW_RLE_end_of_list:
+      Ranges.insert(Ranges.end(), CurrentRanges);
+      CurrentRanges.clear();
+      break;
+    // TODO: Support other encodings.
+    case dwarf::DW_RLE_base_addressx:
+    case dwarf::DW_RLE_startx_endx:
+    case dwarf::DW_RLE_startx_length:
+    case dwarf::DW_RLE_offset_pair:
+    case dwarf::DW_RLE_base_address:
+      llvm_unreachable("unimplemented rnglists encoding");
+      break;
+    case dwarf::DW_RLE_start_end: {
+      uint64_t Start = Data.getAddress(OffsetPtr);
+      uint64_t End = Data.getAddress(OffsetPtr);
+      CurrentRanges.emplace_back(Start, End);
+      break;
+    }
+    case dwarf::DW_RLE_start_length: {
+      uint64_t Start = Data.getAddress(OffsetPtr);
+      uint64_t Length = Data.getULEB128(OffsetPtr);
+      CurrentRanges.emplace_back(Start, Start + Length);
+      break;
+    }
+    default:
+      errs() << "Unknown rnglists encoding " << uint32_t(Encoding) << "\n";
+      Ranges.insert(Ranges.end(), CurrentRanges);
+      return false;
+    }
+  }
+
+  // If CurrentRanges is not empty, we have a malformed section, because we did
+  // not find a DW_RLE_end_of_list marker at the end of the last list.
+  // If OffsetPtr does not indicate the End offset, we must have reached the end
+  // of the buffer before we got to the end of the section, or read past the end
+  // of the section.
+  return CurrentRanges.empty() && *OffsetPtr == End;
+}
+
+void DWARFDebugRnglists::dump(raw_ostream &OS) const {
+  OS << format("Range List Header: length = 0x%8.8x, version = 0x%4.4x, "
+               "addr_size = 0x%2.2x, seg_size = 0x%2.2x, offset_entry_count = "
+               "0x%8.8x\n",
+               HeaderData.Length, HeaderData.Version, HeaderData.AddrSize,
+               HeaderData.SegSize, HeaderData.OffsetEntryCount);
+
+  if (HeaderData.OffsetEntryCount > 0) {
+    OS << "Offsets: [";
+    for (const auto &Off : Offsets) {
+      OS << format("\n0x%8.8x", Off);
+    }
+    OS << "\n]\n";
+  }
+  OS << "Ranges:\n";
+
+  const uint32_t HexWidth = HeaderData.AddrSize * 2;
+  for (const auto &List : Ranges) {
+    for (const auto &Entry : List) {
+      OS << format("[0x%*.*" PRIx64 ", 0x%*.*" PRIx64 ")\n", HexWidth, HexWidth,
+                   Entry.Start, HexWidth, HexWidth, Entry.End);
+    }
+    OS << "<End of list>\n";
+  }
+}

test/tools/llvm-dwarfdump/X86/Inputs/debug_rnglists_invalid_header.s

+.section .debug_rnglists,"",@progbits
+.long 7  # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.byte 0, 0, 0  # Offset entry count

test/tools/llvm-dwarfdump/X86/Inputs/debug_rnglists_invalid_offset_entries.s

+.section .debug_rnglists,"",@progbits
+.long 26 # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0x12345678  # Offset entry count
+
+# First range list
+.byte 6          # DW_RLE_start_end
+.quad 1, 2         # Start, end address
+.byte 0          # DW_RLE_end_of_list

test/tools/llvm-dwarfdump/X86/Inputs/debug_rnglists_long_length.s

+.section .debug_rnglists,"",@progbits
+.long 27 # Table length - 1 greater than actual section contents
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# First range list
+.byte 6          # DW_RLE_start_end
+.quad 1, 2         # Start, end address
+.byte 0          # DW_RLE_end_of_list

test/tools/llvm-dwarfdump/X86/Inputs/debug_rnglists_short_length.s

+.section .debug_rnglists,"",@progbits
+.long 25 # Table length - 1 smaller than actual section contents
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# First range list
+.byte 6          # DW_RLE_start_end
+.quad 1, 2         # Start, end address
+.byte 0          # DW_RLE_end_of_list

test/tools/llvm-dwarfdump/X86/debug_rnglists.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - | FileCheck %s
+
+# CHECK: .debug_rnglists contents:
+# CHECK-NEXT: Range List Header: length = 0x0000003f, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000002
+# CHECK-NEXT: Offsets: [
+# CHECK-NEXT:    0x00000008
+# CHECK-NEXT:    0x0000002b
+# CHECK-NEXT: ]
+# CHECK-NEXT: Ranges:
+# CHECK-NEXT: [0x0000000000000010, 0x0000000000000020)
+# CHECK-NEXT: [0x0000000000000025, 0x00000000000000a5)
+# CHECK-NEXT: <End of list>
+# CHECK-NEXT: [0x0000000000000100, 0x0000000000000200)
+# CHECK-NEXT: <End of list>
+# CHECK-NEXT: Range List Header: length = 0x0000002b, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# CHECK-NEXT: Ranges:
+# CHECK-NEXT: [0x0000000000000000, 0x0000000000000000)
+# CHECK-NEXT: [0x0000000000000002, 0x0000000000000006)
+# CHECK-NEXT: <End of list>
+
+.section .debug_rnglists,"",@progbits
+
+# First table
+.long 63 # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 2  # Offset entry count
+
+# Offset array
+.long 8  # Offset Entry 0
+.long 43 # Offset Entry 1
+
+# First range list
+.byte 6          # DW_RLE_start_end
+.quad 0x10, 0x20   # Start, end address
+.byte 7          # DW_RLE_start_length
+.quad 0x25         # Start address
+.byte 0x80, 0x01   # Length
+.byte 0          # DW_RLE_end_of_list
+
+# Second range list
+.byte 6          # DW_RLE_start_end
+.quad 0x100, 0x200 # Start, end address
+.byte 0          # DW_RLE_end_of_list
+
+# Second table
+.long 43 # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# First range list
+.byte 6          # DW_RLE_start_end
+.quad 0, 0         # Start, end address
+.byte 6          # DW_RLE_start_end
+.quad 0x2, 0x6     # Start, end address
+.byte 0          # DW_RLE_end_of_list

test/tools/llvm-dwarfdump/X86/debug_rnglists_empty.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - | FileCheck %s
+
+# CHECK: .debug_rnglists contents:
+# CHECK-NEXT: Range List Header: length = 0x00000008, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# CHECK-NOT: Offsets:
+# CHECK: Ranges:
+# CHECK-NOT: [
+# CHECK-NOT: Range List Header:
+
+.section .debug_rnglists,"",@progbits
+.long 8 # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count

test/tools/llvm-dwarfdump/X86/debug_rnglists_invalid.test

+# RUN: llvm-mc %S/Inputs/debug_rnglists_invalid_header.s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - | FileCheck %s
+# RUN: llvm-mc %S/Inputs/debug_rnglists_invalid_offset_entries.s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - | FileCheck %s
+# RUN: llvm-mc %S/Inputs/debug_rnglists_long_length.s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - | FileCheck %s
+# RUN: llvm-mc %S/Inputs/debug_rnglists_short_length.s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - | FileCheck %s
+
+# CHECK: .debug_rnglists contents:
+# CHECK-NOT: Range List Header

test/tools/llvm-dwarfdump/X86/debug_rnglists_unknown_encoding.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - 2> %t.err | FileCheck %s
+# RUN: FileCheck %s --input-file=%t.err --check-prefix=ERROR
+
+# CHECK: .debug_rnglists contents:
+# CHECK-NOT: Range List Header
+
+# ERROR: Unknown rnglists encoding 42
+
+.section .debug_rnglists,"",@progbits
+
+# First table
+.long 26 # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# First range list
+.byte 42         # Unknown encoding
+.quad 0x10, 0x20   # Encoding payload
+.byte 0          # DW_RLE_end_of_list