[DWARF v5] Supporting verbose dumping of .dbg_rnglist entries

[wolfgangp]

Summary

Adding verbose dumping to the recent implementation of dumping of v5 range list entries. We're capturing the entries as is as they come in during extraction, including their file offset, so we can dump them in more detail.
The offset table entries which are table-relative are shown as is (as in non-verbose mode) and with the actual file offset they map to.

Adding support for RLE_base_address will come in a separate patch.

[dblaikie]

Seems awkward/not ideal to compute the start/end, then reverse those computations to compute the values appropriate to print in verbose mode - probably better to keep the original values & compute the final values when needed/printing?

Also I think there's probably some similar printing logic, maybe for the debug_loc.dwo section? Maybe check that to see how the different kinds of address range specifications (start+length, start+end, base address specifier, etc) are printed there & whether there's some uniformity that can be applied/reused/improved here?

[wolfgangp]

Revised the code to take advantage of DWARFAddressRange::dump(), which simplified both non-verbose and verbose dumping. I reduced the range list entries to just raw fields of uint64_t which seems less awkward than using a union with one of the fields an AddressRange. After that there was enough commonality between verbose and non-verbose dumping that it could be handled in one function instead of two.

Added a flag to DWARFAddressRange::dump() to make the printing of interval brackets optional. This makes it a bit more flexible when dumping the raw contents of a range entry that is not a start/end pair. This change could be separated out into its own patch if needed.

I didn't see anything usable in DWARFLocLists, but it appears that DWARFLocLists could make use of DWARFAddressRange. This is probably best addressed in a different patch.

[wolfgangp]

In D43366#1009611, @dblaikie wrote:

Seems awkward/not ideal to compute the start/end, then reverse those computations to compute the values appropriate to print in verbose mode - probably better to keep the original values & compute the final values when needed/printing?

Also I think there's probably some similar printing logic, maybe for the debug_loc.dwo section? Maybe check that to see how the different kinds of address range specifications (start+length, start+end, base address specifier, etc) are printed there & whether there's some uniformity that can be applied/reused/improved here?

As I pointed out in the revision comment, I didn't see much in the loclist code, but it seems that the loclist code could take advantage of DWARFAddressRange. It handles printing of an interval.

[jhenderson]

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

51 ↗

(On Diff #135519)

Perhaps worth mentioning that in the other cases the Value(s) are undefined.

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

46 ↗

(On Diff #135519)

.dbg_rnglists -> .debug_rnglists

Let's not abbreviate things in error messages that look like section names! Also, use the createError() method, used elsewhere in this function, and it would be good if this error provides the offset of the offending table (again, see the use of createError elsewhere).

Also, test case for this error?

[wolfgangp]

Addressed James' review comments and gave default values to RangeListEntry's constructor parameters for better use. Added an error test for the currently unsupported DWARF64 format.

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

51 ↗

(On Diff #135519)

Gave default parameters to the constructor for the less-than-2-value cases.

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

46 ↗

(On Diff #135519)

createError() does not take just a string, but with the added table offset it works.

[JDevlieghere]

include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

51 ↗

(On Diff #135942)

Maybe this is an option we can store in the DIDumpOptions?

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

46 ↗

(On Diff #135942)

Can these members be const?

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

170 ↗

(On Diff #135942)

Personally I'd prefer reading the verbose flag from the DIDumpOptions.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

56 ↗

(On Diff #135942)

I think this is unnecessary - since there's a non-default ctor, so the default ctor wouldn't be provided by default?

58–61 ↗

(On Diff #135942)

maybe this ctor could be skipped and {} init could be used?

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

19–24 ↗

(On Diff #135942)

Probably worth making the prefix indentation consistent (ie: padding the [DW_RLE_...] with spaces on the right, so the DW_RLE_s line up, and the range lines up on the RHS too?

26 ↗

(On Diff #135942)

Maybe "TERSE" rather than "DEFAULT" to make it easy to see it's the comparison between verbose and not verbose?

[wolfgangp]

Addressing review comments: The dump routine(s) are using DIDumpOptions more consistently. Added a "DisplayRawContents" flag to DIDumpOptions and using it to inform DWARFAddressRange to either display a range as an interval or print its contents as is.

Removed the constructor for RangeListEntry and used brace-initializer syntax instead.

Aligned the printed range entries for better readability.

include/llvm/DebugInfo/DWARF/DWARFAddressRange.h

51 ↗

(On Diff #135942)

Decided on an option "DisplayRawContents" with the intent to tell anybody who looks at it to not semantically interpret the content. It's a bit awkward as it's not settable by a user, but it's perhaps closer to what you had in mind.

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

19–24 ↗

(On Diff #135942)

Collecting the length of the maximal DW_RLE* string and using it to align things. The output still doesn't seem to win any aesthetic awards, though.

[dblaikie]

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

45–49 ↗

(On Diff #136425)

Consider putting the spaces inside the ]? so the ']:' are aligned? (I think some parts of the line table printing have that kind of alignment?)

[wolfgangp]

Review comments: Aligning the closing brackets (']') of range list entries on the right, added a space to 'raw' content dumping of start/length pairs to align the contents with interval-style display.

[dblaikie]

Seems OK as an intermediate step - what's your end-goal/plan? I would think this would need to be merged in some way with existing range list support so that things like the symbolizer can work with DWARF 5? (see DWARFUnit::extractRangeList and DWARFDie::getAddressRanges for example)

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

100 ↗

(On Diff #137115)

It's probably better to use push_back rather than emplace_back, if both are valid. (they'll be both as efficient, but emplace_back can do explicit conversions where push_back can only do implicit conversions - so it's simpler, there's less "going on")

[wolfgangp]

In D43366#1028058, @dblaikie wrote:

Seems OK as an intermediate step - what's your end-goal/plan? I would think this would need to be merged in some way with existing range list support so that things like the symbolizer can work with DWARF 5? (see DWARFUnit::extractRangeList and DWARFDie::getAddressRanges for example)

Right, this was just the first step. Next is to support more DW_RLE_* kinds (at least base_address and offset_pair so we can use rnglists in split units) and to make DW_AT_ranges work with DWARF5 rangelists (including DW_FORM_rnglistx), i.e. distill DWARFDebugRngLists into a DWARFAddressRangesVector, or something along those lines.

[wolfgangp]

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

100 ↗

(On Diff #137115)

Didn't update the review but I'm making this change before I commit.

llvm/trunk/include/llvm/BinaryFormat/Dwarf.h

 StringRef LanguageString(unsigned Language);
 StringRef CaseString(unsigned Case);
 StringRef ConventionString(unsigned Convention);
 StringRef InlineCodeString(unsigned Code);
 StringRef ArrayOrderString(unsigned Order);
 StringRef LNStandardString(unsigned Standard);
 StringRef LNExtendedString(unsigned Encoding);
 StringRef MacinfoString(unsigned Encoding);
+StringRef RangeListEncodingString(unsigned Encoding);
 StringRef CallFrameString(unsigned Encoding);
 StringRef ApplePropertyString(unsigned);
 StringRef UnitTypeString(unsigned);
 StringRef AtomTypeString(unsigned Atom);
 StringRef GDBIndexEntryKindString(GDBIndexEntryKind Kind);
 StringRef GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage);
 StringRef IndexString(unsigned Idx);
 /// @}

llvm/trunk/include/llvm/DebugInfo/DIContext.h

struct DIDumpOptions {
   unsigned DumpType = DIDT_All;
   unsigned RecurseDepth = -1U;
   bool ShowAddresses = true;
   bool ShowChildren = false;
   bool ShowParents = false;
   bool ShowForm = false;
   bool SummarizeTypes = false;
   bool Verbose = false;
+  bool DisplayRawContents = false;
 
   /// Return default option set for printing a single DIE without children.
   static DIDumpOptions getForSingleDIE() {
     DIDumpOptions Opts;
     Opts.RecurseDepth = 0;
     return Opts;
   }
 

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

 //===- DWARFAddressRange.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_DWARF_DWARFADDRESSRANGE_H
 #define LLVM_DEBUGINFO_DWARF_DWARFADDRESSRANGE_H
 
+#include "llvm/DebugInfo/DIContext.h"
 #include <cstdint>
 #include <tuple>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
struct DWARFAddressRange {
 
   /// Returns true if [LowPC, HighPC) fully contains [RHS.LowPC, RHS.HighPC).
   bool contains(const DWARFAddressRange &RHS) const {
     if (LowPC <= RHS.LowPC && RHS.LowPC <= HighPC)
       return LowPC <= RHS.HighPC && RHS.HighPC <= HighPC;
     return false;
   }
 
-  void dump(raw_ostream &OS, uint32_t AddressSize) const;
+  void dump(raw_ostream &OS, uint32_t AddressSize,
+            DIDumpOptions DumpOpts = {}) const;
 };
 
 static inline bool operator<(const DWARFAddressRange &LHS,
                              const DWARFAddressRange &RHS) {
   return std::tie(LHS.LowPC, LHS.HighPC) < std::tie(RHS.LowPC, RHS.HighPC);
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const DWARFAddressRange &R);
 
 /// DWARFAddressRangesVector - represents a set of absolute address ranges.
 using DWARFAddressRangesVector = std::vector<DWARFAddressRange>;
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFADDRESSRANGE_H

llvm/trunk/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/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 
 class Error;
struct Header {
     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;
   };
 
+public:
+  struct RangeListEntry {
+    /// The offset at which the entry is located in the section.
+    const uint32_t Offset;
+    /// The DWARF encoding (DW_RLE_*).
+    const uint8_t EntryKind;
+    /// The values making up the range list entry. Most represent a range with
+    /// a start and end address or a start address and a length. Others are
+    /// single value base addresses or end-of-list with no values. The unneeded
+    /// values are semantically undefined, but initialized to 0.
+    const uint64_t Value0;
+    const uint64_t Value1;
+  };
+
+  using DWARFRangeList = std::vector<RangeListEntry>;
+
+private:
+  uint32_t HeaderOffset;
   Header HeaderData;
   std::vector<uint32_t> Offsets;
-  std::vector<DWARFAddressRangesVector> Ranges;
+  std::vector<DWARFRangeList> Ranges;
+  // The length of the longest encoding string we encountered during parsing.
+  uint8_t MaxEncodingStringLength = 0;
 
 public:
   void clear();
   Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
-  void dump(raw_ostream &OS) const;
+  uint32_t getHeaderOffset() const { return HeaderOffset; }
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const;
 
   /// Returns the length of this table, including the length field, or 0 if the
   /// length has not been determined (e.g. because the table has not yet been
   /// parsed, or there was a problem in parsing).
   uint32_t length() const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFDEBUGRNGLISTS_H

llvm/trunk/lib/BinaryFormat/Dwarf.cpp

return StringSwitch<unsigned>(MacinfoString)
       .Case("DW_MACINFO_define", DW_MACINFO_define)
       .Case("DW_MACINFO_undef", DW_MACINFO_undef)
       .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
       .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
       .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
       .Default(DW_MACINFO_invalid);
 }
 
+StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) {
+  switch (Encoding) {
+  default:
+    return StringRef();
+#define HANDLE_DW_RLE(ID, NAME)                                                \
+  case DW_RLE_##NAME:                                                          \
+    return "DW_RLE_" #NAME;
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+}
+
 StringRef llvm::dwarf::CallFrameString(unsigned Encoding) {
   switch (Encoding) {
   default:
     return StringRef();
 #define HANDLE_DW_CFA(ID, NAME)                                                \
   case DW_CFA_##NAME:                                                          \
     return "DW_CFA_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"

llvm/trunk/lib/DebugInfo/DWARF/DWARFAddressRange.cpp

 //===- DWARFDebugAranges.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
-void DWARFAddressRange::dump(raw_ostream &OS, uint32_t AddressSize) const {
+void DWARFAddressRange::dump(raw_ostream &OS, uint32_t AddressSize,
+                             DIDumpOptions DumpOpts) const {
 
-  OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, LowPC)
-     << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2, HighPC);
+  OS << (DumpOpts.DisplayRawContents ? " " : "[");
+  OS << format("0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, LowPC)
+     << format("0x%*.*" PRIx64, AddressSize * 2, AddressSize * 2, HighPC);
+  OS << (DumpOpts.DisplayRawContents ? "" : ")");
 }
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const DWARFAddressRange &R) {
   R.dump(OS, /* AddressSize */ 8);
   return OS;
 }

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

while (rnglistData.isValidOffset(Offset)) {
       if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
         errs() << "error: " + toString(std::move(Err)) << '\n';
         uint64_t Length = Rnglists.length();
         // Keep going after an error, if we can, assuming that the length field
         // could be read. If it couldn't, stop reading the section.
         if (Length == 0)
           break;
         Offset = TableOffset + Length;
-      } else
-        Rnglists.dump(OS);
+      } else {
+        Rnglists.dump(OS, DumpOpts);
+      }
     }
   }
 
   if (shouldDump(Explicit, ".debug_pubnames", DIDT_ID_DebugPubnames,
                  DObj->getPubNamesSection()))
     DWARFDebugPubTable(DObj->getPubNamesSection(), isLittleEndian(), false)
         .dump(OS);
 

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

static Error createError(char const *Fmt, const Ts &... Vals) {
   raw_string_ostream Stream(Buffer);
   Stream << format(Fmt, Vals...);
   return make_error<StringError>(Stream.str(), inconvertibleErrorCode());
 }
 
 Error DWARFDebugRnglists::extract(DWARFDataExtractor Data,
                                   uint32_t *OffsetPtr) {
   clear();
-  uint32_t TableOffset = *OffsetPtr;
+  HeaderOffset = *OffsetPtr;
 
   // Read and verify the length field.
   if (!Data.isValidOffsetForDataOfSize(*OffsetPtr, sizeof(uint32_t)))
     return createError("section is not large enough to contain a "
                        ".debug_rnglists table length at offset 0x%" PRIx32,
                        *OffsetPtr);
   // TODO: Add support for DWARF64.
   HeaderData.Length = Data.getU32(OffsetPtr);
+  if (HeaderData.Length == 0xffffffffu)
+    return createError(
+        "DWARF64 is not supported in .debug_rnglists at offset 0x%" PRIx32,
+        HeaderOffset);
   if (HeaderData.Length + sizeof(uint32_t) < sizeof(Header))
     return createError(".debug_rnglists table at offset 0x%" PRIx32
                        " has too small length (0x%" PRIx32
                        ") to contain a complete header",
-                       TableOffset, length());
-  uint32_t End = TableOffset + length();
-  if (!Data.isValidOffsetForDataOfSize(TableOffset, End - TableOffset))
+                       HeaderOffset, length());
+  uint32_t End = HeaderOffset + length();
+  if (!Data.isValidOffsetForDataOfSize(HeaderOffset, End - HeaderOffset))
     return createError(
         "section is not large enough to contain a .debug_rnglists table "
         "of length 0x%" PRIx32 " at offset 0x%" PRIx32,
-        length(), TableOffset);
+        length(), HeaderOffset);
 
   HeaderData.Version = Data.getU16(OffsetPtr);
   HeaderData.AddrSize = Data.getU8(OffsetPtr);
   HeaderData.SegSize = Data.getU8(OffsetPtr);
   HeaderData.OffsetEntryCount = Data.getU32(OffsetPtr);
 
   // Perform basic validation of the remaining header fields.
   if (HeaderData.Version != 5)
     return createError("unrecognised .debug_rnglists table version %" PRIu16
                        " in table at offset 0x%" PRIx32,
-                       HeaderData.Version, TableOffset);
+                       HeaderData.Version, HeaderOffset);
   if (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)
     return createError(".debug_rnglists table at offset 0x%" PRIx32
                        " has unsupported address size %hhu",
-                       TableOffset, HeaderData.AddrSize);
+                       HeaderOffset, HeaderData.AddrSize);
   if (HeaderData.SegSize != 0)
     return createError(".debug_rnglists table at offset 0x%" PRIx32
                        " has unsupported segment selector size %" PRIu8,
-                       TableOffset, HeaderData.SegSize);
-  if (End < TableOffset + sizeof(HeaderData) +
+                       HeaderOffset, HeaderData.SegSize);
+  if (End < HeaderOffset + sizeof(HeaderData) +
                 HeaderData.OffsetEntryCount * sizeof(uint32_t))
     return createError(".debug_rnglists table at offset 0x%" PRIx32
                        " has more offset entries (%" PRIu32
                        ") than there is space for",
-                       TableOffset, HeaderData.OffsetEntryCount);
+                       HeaderOffset, HeaderData.OffsetEntryCount);
 
   Data.setAddressSize(HeaderData.AddrSize);
 
   for (uint32_t I = 0; I < HeaderData.OffsetEntryCount; ++I)
     Offsets.push_back(Data.getU32(OffsetPtr));
 
-  DWARFAddressRangesVector CurrentRanges;
+  DWARFRangeList CurrentRanges;
   while (*OffsetPtr < End) {
+    uint32_t EntryOffset = *OffsetPtr;
     uint8_t Encoding = Data.getU8(OffsetPtr);
+    MaxEncodingStringLength =
+        std::max(MaxEncodingStringLength,
+                 (uint8_t)dwarf::RangeListEncodingString(Encoding).size());
     switch (Encoding) {
     case dwarf::DW_RLE_end_of_list:
+      CurrentRanges.push_back(RangeListEntry{EntryOffset, Encoding});
       Ranges.insert(Ranges.end(), CurrentRanges);
       CurrentRanges.clear();
       break;
     // TODO: Support other encodings.
     case dwarf::DW_RLE_base_addressx:
       return createError("unsupported rnglists encoding DW_RLE_base_addressx "
                          "at offset 0x%" PRIx32,
                          *OffsetPtr - 1);
while (*OffsetPtr < End) {
     case dwarf::DW_RLE_start_end: {
       if ((End - *OffsetPtr) < unsigned(HeaderData.AddrSize * 2))
         return createError("insufficient space remaining in table for "
                            "DW_RLE_start_end encoding "
                            "at offset 0x%" PRIx32,
                            *OffsetPtr - 1);
       uint64_t Start = Data.getAddress(OffsetPtr);
       uint64_t End = Data.getAddress(OffsetPtr);
-      CurrentRanges.emplace_back(Start, End);
+      CurrentRanges.push_back(
+          RangeListEntry{EntryOffset, Encoding, Start, End});
       break;
     }
     case dwarf::DW_RLE_start_length: {
       uint32_t PreviousOffset = *OffsetPtr - 1;
       uint64_t Start = Data.getAddress(OffsetPtr);
       uint64_t Length = Data.getULEB128(OffsetPtr);
       if (End < *OffsetPtr)
         return createError("read past end of table when reading "
                            "DW_RLE_start_length encoding at offset 0x%" PRIx32,
                            PreviousOffset);
-      CurrentRanges.emplace_back(Start, Start + Length);
+      CurrentRanges.push_back(
+          RangeListEntry{EntryOffset, Encoding, Start, Length});
       break;
     }
     default:
       Ranges.insert(Ranges.end(), CurrentRanges);
       return createError("unknown rnglists encoding 0x%" PRIx32
                          " at offset 0x%" PRIx32,
                          uint32_t(Encoding), *OffsetPtr - 1);
     }
   }
 
   // If OffsetPtr does not indicate the End offset, then either the above loop
   // terminated prematurely, or we encountered a malformed encoding, but did not
   // report an error when we should have done.
   assert(*OffsetPtr == End &&
          "did not detect malformed data or loop ended unexpectedly");
 
   // 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 (!CurrentRanges.empty())
     return createError(
         "no end of list marker detected at end of .debug_rnglists table "
         "starting at offset 0x%" PRIx32,
-        TableOffset);
+        HeaderOffset);
   return Error::success();
 }
 
-void DWARFDebugRnglists::dump(raw_ostream &OS) const {
-  // TODO: Add verbose printing of the raw encodings.
+static void dumpRangeEntry(raw_ostream &OS,
+                           DWARFDebugRnglists::RangeListEntry Entry,
+                           uint8_t AddrSize, uint8_t MaxEncodingStringLength,
+                           DIDumpOptions DumpOpts) {
+  if (DumpOpts.Verbose) {
+    // Print the section offset in verbose mode.
+    OS << format("0x%8.8" PRIx32 ":", Entry.Offset);
+    auto EncodingString = dwarf::RangeListEncodingString(Entry.EntryKind);
+    // Unsupported encodings should have been reported during parsing.
+    assert(!EncodingString.empty() && "Unknown range entry encoding");
+    OS << format(" [%s%*c", EncodingString.data(),
+                 MaxEncodingStringLength - EncodingString.size() + 1, ']');
+    if (Entry.EntryKind != dwarf::DW_RLE_end_of_list)
+      OS << ": ";
+  }
+
+  switch (Entry.EntryKind) {
+  case dwarf::DW_RLE_end_of_list:
+    OS << (DumpOpts.Verbose ? "" : "<End of list>");
+    break;
+  case dwarf::DW_RLE_start_length:
+    if (DumpOpts.Verbose) {
+      // Make the address range display its contents in raw form rather than
+      // as an interval (i.e. without brackets).
+      DumpOpts.DisplayRawContents = true;
+      DWARFAddressRange(Entry.Value0, Entry.Value1)
+          .dump(OS, AddrSize, DumpOpts);
+      OS << " => ";
+    }
+    DumpOpts.DisplayRawContents = false;
+    DWARFAddressRange(Entry.Value0, Entry.Value0 + Entry.Value1)
+        .dump(OS, AddrSize, DumpOpts);
+    break;
+  case dwarf::DW_RLE_start_end:
+    DWARFAddressRange(Entry.Value0, Entry.Value1).dump(OS, AddrSize, DumpOpts);
+    break;
+  default:
+    llvm_unreachable("Unsupported range list encoding");
+  }
+  OS << "\n";
+}
+
+void DWARFDebugRnglists::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
+  if (DumpOpts.Verbose)
+    OS << format("0x%8.8" PRIx32 ": ", HeaderOffset);
   OS << format("Range List Header: length = 0x%8.8" PRIx32
                ", version = 0x%4.4" PRIx16 ", "
                "addr_size = 0x%2.2" PRIx8 ", seg_size = 0x%2.2" PRIx8
                ", offset_entry_count = "
                "0x%8.8" PRIx32 "\n",
                HeaderData.Length, HeaderData.Version, HeaderData.AddrSize,
                HeaderData.SegSize, HeaderData.OffsetEntryCount);
 
   if (HeaderData.OffsetEntryCount > 0) {
     OS << "Offsets: [";
-    for (const auto &Off : Offsets)
+    for (const auto &Off : Offsets) {
       OS << format("\n0x%8.8" PRIx32, Off);
+      if (DumpOpts.Verbose)
+        OS << format(" => 0x%8.8" PRIx32,
+                     Off + HeaderOffset + sizeof(HeaderData));
+    }
     OS << "\n]\n";
   }
   OS << "Ranges:\n";
 
-  const uint32_t HexWidth = HeaderData.AddrSize * 2;
-  for (const auto &List : Ranges) {
+  for (const auto &List : Ranges)
     for (const auto &Entry : List)
-      OS << format("[0x%*.*" PRIx64 ", 0x%*.*" PRIx64 ")\n", HexWidth, HexWidth,
-                   Entry.LowPC, HexWidth, HexWidth, Entry.HighPC);
-    OS << "<End of list>\n";
-  }
+      dumpRangeEntry(OS, Entry, HeaderData.AddrSize, MaxEncodingStringLength,
+                     DumpOpts);
 }
 
 uint32_t DWARFDebugRnglists::length() const {
   if (HeaderData.Length == 0)
     return 0;
   // TODO: DWARF64 support.
   return HeaderData.Length + sizeof(uint32_t);
 }

llvm/trunk/test/tools/llvm-dwarfdump/X86/Inputs/debug_rnglists_DWARF64.s

+.section .debug_rnglists,"",@progbits
+.long 0xffffffff  # Unsupported DWARF64 format

llvm/trunk/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 - 2> %t.err | FileCheck %s
+# RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
+# RUN: llvm-dwarfdump --debug-rnglists %t.o 2> %t.err | FileCheck %s --check-prefixes=TERSE,BOTH
 # RUN: FileCheck %s --input-file %t.err --check-prefix=ERR
+# RUN: llvm-dwarfdump -v --debug-rnglists %t.o 2> %t.err | FileCheck %s --check-prefixes=VERBOSE,BOTH
 
-# 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 = 0x0000001b, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000000
-# CHECK-NEXT: Ranges:
-# CHECK-NEXT: [0x00000000, 0x00000000)
-# CHECK-NEXT: [0x00000002, 0x00000006)
-# CHECK-NEXT: <End of list>
-# 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:
+# BOTH:         .debug_rnglists contents:
+# TERSE-NEXT:     Range List Header: length = 0x00000037, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+
+# VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
+# VERBOSE-SAME: Range List Header: length = 0x00000037, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+
+# BOTH-NEXT:    Ranges:
+# TERSE-NEXT:   [0x0000000000000010, 0x0000000000000020)
+# TERSE-NEXT:   [0x0000000000000025, 0x00000000000000a5)
+# TERSE-NEXT:   <End of list>
+# TERSE-NEXT:   [0x0000000000000100, 0x0000000000000200)
+# TERSE-NEXT:   <End of list>
+
+# VERBOSE-NEXT: 0x0000000c: [DW_RLE_start_end   ]: [0x0000000000000010, 0x0000000000000020)
+# VERBOSE-NEXT: 0x0000001d: [DW_RLE_start_length]:  0x0000000000000025, 0x0000000000000080
+# VERBOSE-SAME: => [0x0000000000000025, 0x00000000000000a5)
+# VERBOSE-NEXT: 0x00000028: [DW_RLE_end_of_list ]
+# VERBOSE-NEXT: 0x00000029: [DW_RLE_start_end   ]: [0x0000000000000100, 0x0000000000000200)
+# VERBOSE-NEXT: 0x0000003a: [DW_RLE_end_of_list ]
+
+# TERSE-NEXT:   Range List Header: length = 0x0000002b, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000002
+
+# VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
+# VERBOSE-SAME: Range List Header: length = 0x0000002b, version = 0x0005, addr_size = 0x04, seg_size = 0x00, offset_entry_count = 0x00000002
+
+# BOTH-NEXT:    Offsets: [
+# BOTH-NEXT:      0x00000008
+# VERBOSE-SAME:   => 0x0000004f
+# BOTH-NEXT:      0x0000001b
+# VERBOSE-SAME:   => 0x00000062
+# BOTH-NEXT:    ]
+# BOTH-NEXT:    Ranges:
+
+# TERSE-NEXT:   [0x00000000, 0x00000000)
+# TERSE-NEXT:   [0x00000002, 0x00000006)
+# TERSE-NEXT:   <End of list>
+# TERSE-NEXT:   [0x00000036, 0x00000136)
+# TERSE-NEXT:   <End of list>
+
+# VERBOSE-NEXT: 0x0000004f: [DW_RLE_start_end   ]: [0x00000000, 0x00000000)
+# VERBOSE-NEXT: 0x00000058: [DW_RLE_start_end   ]: [0x00000002, 0x00000006)
+# VERBOSE-NEXT: 0x00000061: [DW_RLE_end_of_list ]
+# VERBOSE-NEXT: 0x00000062: [DW_RLE_start_length]:  0x00000036, 0x00000100 => [0x00000036, 0x00000136)
+# VERBOSE-NEXT: 0x00000069: [DW_RLE_end_of_list ]
+
+# TERSE-NEXT:   Range List Header: length = 0x00000008, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+
+# VERBOSE-NEXT: 0x{{[0-9a-f]*}}:
+# VERBOSE-SAME: Range List Header: length = 0x00000008, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+
+# BOTH-NOT:     Offsets:
+# BOTH:         Ranges:
+# BOTH-NOT:     [
+# BOTH-NOT:     Range List Header:
 
 # ERR-NOT:  error:
-# ERR:      error: unsupported rnglists encoding DW_RLE_base_addressx at offset 0x7a
-# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_startx_endx at offset 0x89
-# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_startx_length at offset 0x99
-# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_offset_pair at offset 0xa9
-# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_base_address at offset 0xb9
+# ERR:      error: unsupported rnglists encoding DW_RLE_base_addressx at offset 0x82
+# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_startx_endx at offset 0x91
+# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_startx_length at offset 0xa1
+# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_offset_pair at offset 0xb1
+# ERR-NEXT: error: unsupported rnglists encoding DW_RLE_base_address at offset 0xc
 # ERR-NOT:  error:
 
 .section .debug_rnglists,"",@progbits
 
 # First table (tests DW_RLE_end_of_list, start_end, and start_length encodings)
-.long 63 # Table length
+.long 55 # 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
+.long 0  # Offset entry count
 
 # 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 (shows support for size 4 addresses)
-.long 27 # Table length
+.long 43 # Table length
 .short 5 # Version
 .byte 4  # Address size
 .byte 0  # Segment selector size
-.long 0  # Offset entry count
+.long 2  # Offset entry count
+
+# Offset array
+.long 8  # Offset Entry 0
+.long 27 # Offset Entry 1
 
 # First range list
 .byte 6          # DW_RLE_start_end
 .long 0, 0         # Start, end address
 .byte 6          # DW_RLE_start_end
 .long 0x2, 0x6     # Start, end address
 .byte 0          # DW_RLE_end_of_list
 
+# Second range list
+.byte 7          # DW_RLE_start_length
+.long 0x36         # Start address
+.byte 0x80, 0x02   # Length
+.byte 0          # DW_RLE_end_of_list
+
 # Third (empty) table
 .long 8  # Table length
 .short 5 # Version
 .byte 8  # Address size
 .byte 0  # Segment selector size
 .long 0  # Offset entry count
 
 # The following entries are for encodings unsupported at the time of writing.

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

 # CHECK-NEXT: error: .debug_rnglists table at offset 0x51 has more offset entries (12345678) than there is space for
 # CHECK-NEXT: error: insufficient space remaining in table for DW_RLE_start_end encoding at offset 0x69
 # CHECK-NEXT: error: read past end of table when reading DW_RLE_start_length encoding at offset 0x82
 # CHECK-NEXT: error: unknown rnglists encoding 0x2a at offset 0x98
 # CHECK-NEXT: error: no end of list marker detected at end of .debug_rnglists table starting at offset 0xaa
 # CHECK-NEXT: error: section is not large enough to contain a .debug_rnglists table of length 0x1f at offset 0xe5
 # CHECK-NOT: error:
 
+# RUN: llvm-mc %S/Inputs/debug_rnglists_DWARF64.s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - 2>&1 | FileCheck %s --check-prefix=DWARF64
+
+# DWARF64: DWARF64 is not supported in .debug_rnglists at offset 0x0
+
 .section .debug_rnglists,"",@progbits
 
 # Table 1 (good)
 .long 30 # Table length
 .short 5 # Version
 .byte 8  # Address size
 .byte 0  # Segment selector size
 .long 1  # Offset entry count