[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

24

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

498

Set?

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

24

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

110

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

118

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

24

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

498

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

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

24

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

118

There are two lines in the outer loop!

[dblaikie]

lib/DebugInfo/DWARF/DWARFContext.cpp

498

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

10–28

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

24

Sounds like a good idea!

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

118

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(DebugInfo, ".debug_info", "debug-info")
 HANDLE_DWARF_SECTION(DebugTypes, ".debug_types", "debug-types")
 HANDLE_DWARF_SECTION(DebugLine, ".debug_line", "debug-line")
 HANDLE_DWARF_SECTION(DebugLineStr, ".debug_line_str", "debug-line-str")
 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/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 <cstdint>
+#include <tuple>
+#include <vector>
+
+namespace llvm {
+
+class raw_ostream;
+
+struct DWARFAddressRange {
+  uint64_t LowPC;
+  uint64_t HighPC;
+  uint64_t SectionIndex;
+
+  DWARFAddressRange() = default;
+
+  /// Used for unit testing.
+  DWARFAddressRange(uint64_t LowPC, uint64_t HighPC, uint64_t SectionIndex = 0)
+      : 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) intersects with [RHS.LowPC, RHS.HighPC).
+  bool intersects(const DWARFAddressRange &RHS) const {
+    // Empty ranges can't intersect.
+    if (LowPC == HighPC || RHS.LowPC == RHS.HighPC)
+      return false;
+    return (LowPC < RHS.HighPC) && (HighPC > RHS.LowPC);
+  }
+
+  /// 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;
+};
+
+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

include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h

 //===- DWARFDebugRangeList.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_DWARFDEBUGRANGELIST_H
 #define LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H
 
+#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
-#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 namespace llvm {
 
 struct BaseAddress;
 class raw_ostream;
 
-struct DWARFAddressRange {
-  uint64_t LowPC;
-  uint64_t HighPC;
-  uint64_t SectionIndex;
-
-  DWARFAddressRange() = default;
-
-  /// Used for unit testing.
-  DWARFAddressRange(uint64_t LowPC, uint64_t HighPC, uint64_t SectionIndex = 0)
-      : 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) intersects with [RHS.LowPC, RHS.HighPC).
-  bool intersects(const DWARFAddressRange &RHS) const {
-    // Empty ranges can't intersect.
-    if (LowPC == HighPC || RHS.LowPC == RHS.HighPC)
-      return false;
-    return (LowPC < RHS.HighPC) && (HighPC > RHS.LowPC);
-  }
-
-  /// 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;
-};
-
-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>;
-
 class DWARFDebugRangeList {
 public:
   struct RangeListEntry {
     /// A beginning address offset. This address offset has the size of an
     /// address and is relative to the applicable base address of the
     /// compilation unit referencing this range list. It marks the beginning
     /// of an address range.
     uint64_t StartAddress;

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 "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+
+class Error;
+class raw_ostream;
+
+class DWARFDebugRnglists {
+private:
+  struct Header {
+    /// The total length of the entries for this table, not including the length
+    /// field itself.
+    uint32_t Length = 0;
+    /// 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<DWARFAddressRangesVector> Ranges;
+
+public:
+  void clear();
+  Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
+  void dump(raw_ostream &OS) 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).
+  uint64_t length() const;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_DWARFDEBUGRNGLISTS_H

include/llvm/DebugInfo/DWARF/DWARFDie.h

 #define LLVM_DEBUGINFO_DWARFDIE_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFAttribute.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include <cassert>
 #include <cstdint>
 #include <iterator>
 
 namespace llvm {
 
 class DWARFUnit;
 class raw_ostream;

include/llvm/DebugInfo/DWARF/DWARFObject.h

public:
   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 getLineStringSection() const { return ""; }
   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

include/llvm/DebugInfo/DWARF/DWARFVerifier.h

 //===- DWARFVerifier.h ----------------------------------------------------===//
 //
 //                     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_DWARFVERIFIER_H
 #define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
 
 #include "llvm/DebugInfo/DIContext.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 
 #include <cstdint>
 #include <map>
 #include <set>
 
 namespace llvm {
 class raw_ostream;

lib/DebugInfo/DWARF/CMakeLists.txt

 add_llvm_library(LLVMDebugInfoDWARF
   DWARFAbbreviationDeclaration.cpp
+  DWARFAddressRange.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/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 {
+
+  OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, LowPC)
+     << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2, HighPC);
+}
+
+raw_ostream &llvm::operator<<(raw_ostream &OS, const DWARFAddressRange &R) {
+  R.dump(OS, /* AddressSize */ 8);
+  return OS;
+}

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);
+    uint32_t Offset = 0;
+    while (rnglistData.isValidOffset(Offset)) {
+      DWARFDebugRnglists Rnglists;
+      uint32_t TableOffset = 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);
+    }
+  }
+
   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 DebugNamesSection;
 
   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_names", &DebugNamesSection)
         .Case("debug_str_offsets.dwo", &StringOffsetDWOSection)
         .Case("debug_addr", &AddrSection)
         .Case("apple_names", &AppleNamesSection)
         .Case("apple_types", &AppleTypesSection)
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/DWARFDebugRangeList.cpp

 //===- DWARFDebugRangesList.cpp -------------------------------------------===//
 //
 //                     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/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cinttypes>
 #include <cstdint>
-#include <utility>
 
 using namespace llvm;
 
-void DWARFAddressRange::dump(raw_ostream &OS, uint32_t AddressSize) const {
-
-  OS << format("[0x%*.*" PRIx64 ", ", AddressSize * 2, AddressSize * 2, LowPC)
-     << format(" 0x%*.*" PRIx64 ")", AddressSize * 2, AddressSize * 2, HighPC);
-}
-
-raw_ostream &llvm::operator<<(raw_ostream &OS, const DWARFAddressRange &R) {
-  R.dump(OS, /* AddressSize */ 8);
-  return OS;
-}
-
 void DWARFDebugRangeList::clear() {
   Offset = -1U;
   AddressSize = 0;
   Entries.clear();
 }
 
 bool DWARFDebugRangeList::extract(const DWARFDataExtractor &data,
                                   uint32_t *offset_ptr) {

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/DebugInfo/DWARF/DWARFDebugRnglists.h"
+
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+void DWARFDebugRnglists::clear() {
+  HeaderData = {};
+  Offsets.clear();
+  Ranges.clear();
+}
+
+template <typename... Ts>
+static Error createError(char const *Fmt, const Ts &... Vals) {
+  std::string Buffer;
+  raw_string_ostream Stream(Buffer);
+  Stream << format(Fmt, Vals...);
+  return make_error<StringError>(Stream.str(), inconvertibleErrorCode());
+}
+
+Error DWARFDebugRnglists::extract(DWARFDataExtractor Data,
+                                  uint32_t *OffsetPtr) {
+  clear();
+  uint32_t TableOffset = *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 + 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());
+  uint64_t End = TableOffset + length();
+  if (!Data.isValidOffsetForDataOfSize(TableOffset, End - TableOffset))
+    return createError(
+        "section is not large enough to contain a .debug_rnglists table "
+        "of length 0x%" PRIx32 " at offset 0x%" PRIx32,
+        length(), TableOffset);
+
+  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);
+  if (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)
+    return createError(".debug_rnglists table at offset 0x%" PRIx32
+                       " has unsupported address size %hhu",
+                       TableOffset, 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) +
+                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);
+
+  Data.setAddressSize(HeaderData.AddrSize);
+
+  for (uint32_t I = 0; I < HeaderData.OffsetEntryCount; ++I)
+    Offsets.push_back(Data.getU32(OffsetPtr));
+
+  DWARFAddressRangesVector CurrentRanges;
+  while (*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:
+      return createError("unsupported rnglists encoding DW_RLE_base_addressx "
+                         "at offset 0x%" PRIx32,
+                         *OffsetPtr - 1);
+    case dwarf::DW_RLE_startx_endx:
+      return createError("unsupported rnglists encoding DW_RLE_startx_endx at "
+                         "offset 0x%" PRIx32,
+                         *OffsetPtr - 1);
+    case dwarf::DW_RLE_startx_length:
+      return createError("unsupported rnglists encoding DW_RLE_startx_length "
+                         "at offset 0x%" PRIx32,
+                         *OffsetPtr - 1);
+    case dwarf::DW_RLE_offset_pair:
+      return createError("unsupported rnglists encoding DW_RLE_offset_pair at "
+                         "offset 0x%" PRIx32,
+                         *OffsetPtr - 1);
+    case dwarf::DW_RLE_base_address:
+      return createError("unsupported rnglists encoding DW_RLE_base_address at "
+                         "offset 0x%" PRIx32,
+                         *OffsetPtr - 1);
+    case dwarf::DW_RLE_start_end: {
+      if (End - *OffsetPtr < 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);
+      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);
+      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);
+  return Error::success();
+}
+
+void DWARFDebugRnglists::dump(raw_ostream &OS) const {
+  // TODO: Add verbose printing of the raw encodings.
+  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.LowPC, HexWidth, HexWidth, Entry.HighPC);
+    OS << "<End of list>\n";
+  }
+}
+
+uint64_t DWARFDebugRnglists::length() const {
+  if (HeaderData.Length == 0)
+    return 0;
+  // TODO: DWARF64 support.
+  return HeaderData.Length + sizeof(uint32_t);
+}

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

+.section .debug_rnglists,"",@progbits
+.byte 3, 0, 0 # Short section

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 = 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:
+
+.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 27 # Table length
+.short 5 # Version
+.byte 4  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# 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
+
+# Third (empty) table
+.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_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-NOT: Range List Header:
+# CHECK-NOT: error:
+
+.section .debug_rnglists,"",@progbits

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

+# RUN: llvm-mc %S/Inputs/debug_rnglists_short_section.s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - 2>&1 | FileCheck %s --check-prefix=SHORT
+# SHORT-NOT: error:
+# SHORT-NOT: Range List Header
+# SHORT: error: section is not large enough to contain a .debug_rnglists table length at offset 0
+# SHORT-NOT: Range List Header
+# SHORT-NOT: error:
+
+# RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o - | \
+# RUN: llvm-dwarfdump --debug-rnglists - 2> %t.err | FileCheck %s --check-prefix=GOOD
+# RUN: FileCheck %s --input-file %t.err
+
+# GOOD: .debug_rnglists contents:
+# GOOD-NEXT: Range List Header: length = 0x0000001e, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
+# GOOD-NEXT: Offsets: [
+# GOOD-NEXT:    0x00000004
+# GOOD-NEXT: ]
+# GOOD-NEXT: Ranges:
+# GOOD-NEXT: [0x0000000000000010, 0x0000000000000020)
+# GOOD-NEXT: <End of list>
+# GOOD-NEXT: Range List Header: length = 0x0000001a, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+# GOOD-NEXT: Ranges:
+# GOOD-NEXT: [0x0000000000000030, 0x0000000000000040)
+# GOOD-NEXT: <End of list>
+# GOOD-NOT:  Range List Header
+
+# CHECK-NOT: error:
+# CHECK: error: .debug_rnglists table at offset 0x22 has too small length (0xb) to contain a complete header
+# CHECK-NEXT: error: unrecognised .debug_rnglists table version 4 in table at offset 0x2d
+# CHECK-NEXT: error: .debug_rnglists table at offset 0x39 has unsupported address size 2
+# CHECK-NEXT: error: .debug_rnglists table at offset 0x45 has unsupported segment selector size 4
+# 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:
+
+.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
+
+# Offsets
+.long 4
+
+# First range list
+.byte 6         # DW_RLE_start_length
+.quad 0x10, 0x20   # Encoding payload
+.byte 0         # DW_RLE_end_of_list
+
+# Table 2 (length too small for header)
+.long 7  # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.byte 0, 0, 0  # Truncated offset entry count
+
+# Table 3 (unknown version)
+.long 8  # Table length
+.short 4 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# Table 4 (unsupported address size)
+.long 8  # Table length
+.short 5 # Version
+.byte 2  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# Table 5 (unsupported segment selector size)
+.long 8  # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 4  # Segment selector size
+.long 0  # Offset entry count
+
+# Table 6 (bad offset entry count)
+.long 8  # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 12345678  # Offset entry count
+
+# Table 7 (malformed DW_RLE_start_end)
+.long 21 # 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 1            # Start address
+.long 4            # Truncated end address
+
+# Table 8 (malformed DW_RLE_start_length)
+.long 18 # Table length
+.short 5 # Version
+.byte 8  # Address size
+.byte 0  # Segment selector size
+.long 0  # Offset entry count
+
+# First range list
+.byte 7          # DW_RLE_start_length
+.quad 1            # Start address
+.byte 0xFF         # Length - invalid ULEB, so will continue reading past the end
+
+# Table 9 (unknown encoding)
+.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
+
+# Table 10 (missing end of list marker)
+.long 25 # 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_length
+.quad 0x10, 0x20   # Encoding payload
+
+# Table 11 (good)
+.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 6         # DW_RLE_start_length
+.quad 0x30, 0x40   # Encoding payload
+.byte 0         # DW_RLE_end_of_list
+
+# Table 12 (length too long)
+.long 27 # Table length - 1 greater than actual 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