[DWARF v5] Refactoring range list dumping to fold DWARF v4 functionality into v5 handling (almost NFC).

[wolfgangp]

Summary

This patch is motivated by the following observations:

• DWARF 4 rangelists are essentially a subset of DWARF 5 rangelists.
• We implemented DWARF5 largely independently (the consumer side, i.e. mostly llvm-dwarfdump). The DWARF 5 implementations are in DWARFDebugRnglists.*, the DWARF 4 implementations in DWARFDebugRangelists.* with a fair amount of duplication.

So I thought it should be possible to fold the DWARF 4 functionality into the newly implemented DWARF 5 functionality so that, at the expense of a bit more version-dependent code in dump and extract routines, we should be able to eliminate the DWARF4-only code (i.e. DWARFDebugRangeList.*) entirely.

This patch does attempt this in the following way:

• DWARF5 has range list tables, which of course don't exist in DWARF4, so for DWARF 4 (i.e. when we are extracting range lists from the .debug_ranges section) we create a fake table so we can use the same mechanisms as in DWARF 5.

• The extract and dump routines become version-aware so they can do what's expected both for DWARF4 and DWARF5.

The code in DWARFContext.cpp, DWARFUnit.cpp that arbiters between the different versions now just needs to set up the extractors correctly, set the correct section and pass the DWARF version, and should otherwise be version-oblivious to deal with ranges.

This is also prep for location list dumping, where it's possible to do the same thing, i.e. express DWARF4 functionality as a special case of DWARF5. This is why two routines in DWARFUnit.cpp that deal with the setup of range list tables are now templatized, so they can be used for location list tables as well.

One thing to note is that this change is almost, but not quite NFC. The difference is the following: In DWARF4 the range list table in .debug_ranges is dumped with the list offset preceding the entries:

00000000 00000000 0000abcd
00000000 ffffffff 0000deaf
00000000 00000010 00000020

etc. with the leading '00000000' being the list's section offset, which is repeated for every entry.
I didn't find this particularly useful, so the refactor now displays the list with the correct section offset for each entry, with the list offset simply being the first entry's offset.

00000000 00000000 0000abcd
00000008 ffffffff 0000deaf
00000010 00000010 00000020

Apologies for the size of the patch, but this will make the changes for location list dumping smaller.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFListTable.h

52

Why this new special case - when would the range list contain an empty range?

71

This appears to be unused in this patch? (I see no other mention of 'addEntry') - delete it as dead code?

72–77

This seems to be dead in this patch - maybe remove it from here and add it in whichever patch adds its use?

87–88

That sounds like in all cases we know the version from the input, right? So when/why would this assumption be needed?

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

30–33

Would it be simpler to model DWARFv4 range list entries as RLE_offset_pair, rather than as start_end with an offset? It looks like then it'd fall out without a special case in getAbsoluteRanges (& that function may not need to be touched at all - it wouldn't need to change behavior based on version & maybe the assertions aren't worth the extra API change?)

99–107

Suspect it might be fine to rephrase the DWARFv5 message ("start/end encoding" (or "offset pair at offset ..." ) - so it applies to the 4 and 5 case equally) to be more general & avoid the 4/5 special casing here. (or in offset_pair if the code moves there based on the previous comment)

126–136

Perhaps this logic should move into the relevant (start_end or offset_pair) case above rather than here - since it doesn't/can't apply to other cases in the switch?

lib/DebugInfo/DWARF/DWARFUnit.cpp

318–319

Maybe rather than propagating DWO information here, the Base could be set to Table.getHeaderSize() if there is no Base specified? (using Base == 0 or Base == -1 or something as a flagging value to communicate "no Base has been specified, fill one in")?

(though side rant: I don't understand why these offsets ever point past the header - that seems like it breaks the purpose of the header to provide section versioning, etc - it means the header format can never change and the parser would have to walk backwards from the base offset to parse the version to know how to parse the rest of the section anyway... @probinson @aprantl - though perhaps I've ranted sufficiently about this before)

493

I think the ">= 5" phrasing might make more sense to readers "supported since 5" is sort of what I'm thinking when I read it.

test/DebugInfo/dwarfdump-ranges.test

18–36

If you're updating all these test cases anyway - is it worth revisiting what the best format for dumping debug_ranges is? I'm not sure printing those offsets is especially meaningful (either in the old behavior or the new behavior) rather than just printing the starting offset, then printing the pairs.

& printing it in a way that's more similar between ranges and rnglistsn wouldn't hurt either - not sure if there's something in common that'd suit everyone though.

[probinson]

include/llvm/DebugInfo/DWARF/DWARFListTable.h

52

It's explicitly legal to have a list that consists solely of the end-of-list marker. Not saying any producer would actually emit it this way, but it's one way to describe an empty range. The parser should handle this case smoothly.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFListTable.h

52

Good point - I guess I could narrow/clarify my comment somewhat: Why is the emptiness of a range list important? I'd figure the printing algorithm would work the same either way.

[vleschuk]

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

69

I suggest that DWARFListType::extract() saves Version in class data, and thus we don't need to specify it here explicitly. Same suggestion regarding RangeListEntry and other classes.

include/llvm/DebugInfo/DWARF/DWARFListTable.h

68

Why does dump() method need Version argument? We set the version when we are extracting the data. Maybe save it somewhere during extraction?

237

To make naming consistent maybe we should rename it to getLength()?

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

101

Maybe illegal_byte_sequence would be more suitable here?

[wolfgangp]

Addressed David's review comments:

• Changed the dumping of DWARF v4 range lists to resemble the new format and updated the tests. More detailed comments are inline.
• Use DW_RLE_offset_pair to model the DWARF 4 range list entries.
• Removed some dead code that will not be used for this patch.
• Answered other miscellaneous comments.

Addressed Victor's comments:

• renamed length() to getLength() for consistency.
• not sure if I want to store the DWARF version in the list entries.

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

69

I was trying to avoid having to store the version in each list and entry, since it's always available from the context (i.e. the table during dumping and extracting). Based on David's suggestion I eliminated it from this function. It would remove a parameter from the extract and dump routines, however. I'm not sure. I guess I can see it stored in the list, but perhaps not in each individual entry.

include/llvm/DebugInfo/DWARF/DWARFListTable.h

52

Also , the DWARF5 rnglist implementation keeps the end-of-list entry in the list (unlike the DWARF4 implementation), which makes display a bit more straightforward.

52

Good point - I guess I could narrow/clarify my comment somewhat: Why is the emptiness of a > range list important? I'd figure the printing algorithm would work the same either way.

This was motivated by the code in DwarfLinker.cpp (dsymutil) that needs to check for the emptiness of a list during range patching. With the end-of-list entry as part of the Entries vector it seemed prudent to provide this method.

68

See my comment above. I'm not sure if I want the version to be stored in each individual entry, given that they are usually processed altogether and not passed around individually anyway. I could be persuaded, though. It would make the interface simpler.

71

I will be using this with location lists in an upcoming patch. Ah, I see, it's bad form to add it before it's actually used. OK I'll delete it.

72–77

Actually, it's used further down in DWARFListTableBase<DWARFListType>::dump

87–88

During extraction we're using getTableLength() (I've renamed it from just 'length()' in the first version of this review) for validation and also to determine if we can recover from an error and keep parsing the section. With the creation of an artificial table for DWARF 4 range lists the calculation of the table length is now dependent on the version, since for DWARF 5 we need to add the size of the length field to the length we extracted. In DWARF 4 the length is simply the size of the section as is.
If we find an error in the table header before we get to extract the version, the version would obviously not be set to anything meaningful and would confuse our recovery in DWARFContext.cpp. Also, presetting the version allows us to use getTableLength() before we actually extract the version for validation.
But it's perhaps more appropriate to preset the version during extraction, so I'm doing it there now.

237

I've renamed the DWARFListTableBase::length() to getLength() and
DWARFListTableHeader::length() to getTableLength().
DWARFListTableHeader::getLength() simply extracts the length field from the header data.

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

30–33

I tried this and it seems it would leave getAbsoluteRanges unchanged. The only negative IMO is that offset_pair does not expect relocated addresses but only the extractor has to worry about that.

99–107

The error handling in offset_pair is different b/c DWARF 4 range lists take relocated addresses, whereas DWARF 5 offset_pair takes ULEBs. We have to validate after extracting in the DWARF 5 case. This makes the code for the 2 versions fairly different anyway. Is is still worth reconciling the error messages?

lib/DebugInfo/DWARF/DWARFUnit.cpp

318–319

We're going to need DWO information later anyway during extraction of the (range or location) lists to decide which entries are valid, e.g. start_end, start_length, base_address are only valid in non-split CUs.

test/DebugInfo/dwarfdump-ranges.test

18–36

If we're not too worried about anybody depending on the existing format, we could make the same distinction in the old mode between verbose and terse mode:

Verbose mode: section offsets + raw values of entries + final values of ranges (i.e. adjusted by base) displayed as intervals (between '[' and ')').

Terse mode: just the final ranges displayed as intervals.

The only difference between old and new would be no encoding strings in the old verbose mode.

18–36

I changed the formatting to roughly what we do in the new version, so the table looks like this in verbose mode:

.debug_ranges contents:
0x00000000: 0x0000000000000000, 0x0000000000000001 => [0x0000000000000000, 0x0000000000000001)
0x00000010: 0x0000000000000003, 0x0000000000000006 => [0x0000000000000003,  0x0000000000000006)
0x00000020: 0xffffffffffffffff, 0x0000000000000000
0x00000030: 0x0000000000000001, 0x0000000000000002 => [0x0000000000000001, 0x0000000000000002)
0x00000040: 0x0000000000000000, 0x0000000000000000

and like this in terse mode:

.debug_ranges contents:
[0x0000000000000000, 0x0000000000000001)
[0x0000000000000003, 0x0000000000000006)
[0x0000000000000001, 0x0000000000000002)
<End of list>

Does this make sense?

[vleschuk]

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

69

Agree, I think every entry would be overkill.

[vleschuk]

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

101

Why is this marked as done?

[wolfgangp]

lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp

101

It's because the relevant code was moved to the RLE_offset_pair clause. I made the change there Sorry I should have pointed this out.

[vleschuk]

LGTM

[JDevlieghere]

A few nits, but otherwise this LGTM

include/llvm/DebugInfo/DWARF/DWARFListTable.h

175

Spurious /// or missing comment?

305

nit: no braces

lib/DebugInfo/DWARF/DWARFContext.cpp

337

Maybe we can just refactor getMaxVersion to take an optional default version?

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFListTable.h

52

Could this be addressed by keeping the DWARF4 end-of-list entry too, for consistency?

Though I'm still a bit confused - I'm not sure why DwarfLinker.cpp would need to worry about whether the list is empty or not? Maybe as an optimization, but otherwise I'd figure it would just iterate over the list & if it's empty, it would iterate over zero things.

& why does this change you're making cause this extra case to be added - I thought this code (DWARFListtype) was for DWARF5 rnglists already & now it was getting DWARF4 support - but it sounds like you had to add a case that is for the DWARF5 case... so I'm a bit confused?

72–77

I guess perhaps I was thinking: this function seems to be a no-op & should be removed from this patch - and added back in when it's used/needed?

87–88

I'm pretty confused by this - how does having a hardcoded (possibly incorrect) version help with error recovery? I guess it's correct based on the section being extracted from (though in the future it could be incorrect when we get to DWARFv6)?

What sort of recovery would be done when the version couldn't be read from the input?

[wolfgangp]

Addressed review comments:

• refactored getMaxVersion() in DWARFUnit.h to take an optional default argument.
• Removed some code that is a noop for this patch
• Extracting the initial length field of a list table to a local instead of straight into the header data. This aids error recovery when we find an unsupported DWARF64 length field.
• added a missing comment
• corrected one coding guides violation.

include/llvm/DebugInfo/DWARF/DWARFListTable.h

52

Could this be addressed by keeping the DWARF4 end-of-list entry too, for consistency?

Actually, that is what's happening with this change. I should have said "unlike the original DWARF4 implementation" in my previous comment.

Though I'm still a bit confused - I'm not sure why DwarfLinker.cpp would need to worry
about whether the list is empty or not? Maybe as an optimization, but otherwise I'd figure it
would just iterate over the list & if it's empty, it would iterate over zero things.

Looking at the code it seems that in the context in question it performs a remapping of ranges and only seems to look at the first entry of a range list to determine whether it can validly remap the entire range list. It is not iterating over the entries, so I guess it just wants to check whether there is a valid first entry in the first place.

& why does this change you're making cause this extra case to be added - I thought this
code (DWARFListtype) was for DWARF5 rnglists already & now it was getting DWARF4
support - but it sounds like you had to add a case that is for the DWARF5 case

Actually, this is dsymutil handling the .debug_ranges section, so basically DWARF 4 rangelists.
With this patch DWARFDebugRnglist is now handling both DWARF 4 and DWARF 5 ranges, and since we're keeping the end-of-list entry in the list the extra case had to be added, since we didn't do this previously in the DWARF4 code.

As for dsymutil handling DWARF5 rnglists (i.e. the .debug_rnglists section), that is not supported at this point.

72–77

OK. It will be added back in later, because the corresponding function for the location lists will do something more meaningful.

87–88

Error recovery (in dumpListSection() in DWARFContext.cpp) relies on the correct interpretation of the length field in the header. In DWARF 5 we need to add sizeof(uint32_t) to the extracted length, in DWARF 4 the length field has simply been set to the section size and already represents the length.

If we find errors before we extract the version, e.g. while validating the extracted length against section size etc., we return without knowing the version, and getLength( ) doesn't know what to do. Hence I wanted to preset the version until we extract it from the data.

The other relevant scenario is when we extract an invalid version from the data. In that case we report the error but need to set the version to something valid in order to have the length interpreted correctly.

I suppose we could handle this differently by providing a different interface to get the table length for recovery purposes. We always know the version in the context, so we would never have to preset the table version during extraction. Do you have any other suggestions?

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFListTable.h

87–88

I think I'm just generally confused about this still.

(looks like, for now, the Version field is no longer preset? So maybe what I'm asking about has already been addressed? (I Was concerned the default value in the Version field might be misleading or otherwise cause problems later))

Why does the error recovery in dumpListSection only apply to DWARF4 and earlier?

It seems like the contract for "extract" is a bit subtle if you can still access some fields(like length) but not others. Maybe it'd be better to have extract modify an in/out parameter of the offset - rather than relying on reading the length after extract fails? Not sure - and that doesn't address the issue of printing partially extracted lists... - maybe that's not worth supporting?

[wolfgangp]

include/llvm/DebugInfo/DWARF/DWARFListTable.h

87–88

Why does the error recovery in dumpListSection only apply to DWARF4 and earlier?

Actually, error recovery really only affects DWARF5. In DWARF4 we just have one large array of entries without table headers etc. so reading more tables after an error is not an issue. Printing partially extracted lists in DWARF4 was just me being paranoid about preserving existing behavior, but perhaps that's not necessary, as you say.

It seems like the contract for "extract" is a bit subtle if you can still access some fields(like length) but not others. Maybe it'd be better to have extract modify an in/out parameter of the offset - rather than relying on reading the length after extract fails?

That's a good point. After an error the entire table should be considered invalid, and accessing the length field is inconsistent with that. I'll look into that.

[vleschuk]

include/llvm/DebugInfo/DWARF/DWARFListTable.h

87–88

For DebugAddr I have added two methods: bool hasValidLength() and void invalidateLength(). If an unrecoverable error occurs extract() calls invalidateLength() method and calling code checks hasValidLength(). This hides the implementation details from calling code (e.g. we don't need to compare Length to zero directly). I think we can go this way here too. (Actually I was going to suggest a patch for this after this revision is landed in order not to mix everything, as this patch already has a lot of changes).

[wolfgangp]

When we find an error during table extraction, ListTableBase::extract is expected to set Offset to either 0 if the error is not recoverable, or to past the end of the table if it is. This removes the need to access the extracted length in the caller in the error case and simplifies recovery.

@vleschuk: Let me know what you think about this. I understand your suggestion but this seems a bit simpler to me.

[wolfgangp]

lib/DebugInfo/DWARF/DWARFContext.cpp

296

Here we're no longer accessing the table length.

lib/DebugInfo/DWARF/DWARFListTable.cpp

49

This indicates a recoverable error and the caller can continue with a presumably correct Offset.

[vleschuk]

@vleschuk: Let me know what you think about this. I understand your suggestion but this seems a bit simpler to me.

Looks good and consistent with other code in this area.

[dblaikie]

test/DebugInfo/Generic/cu-ranges.ll

17–22

Not sure if this is necessary/improving the check, perhaps? (if this test was going to check for the address ranges - it could've been doing that already, I'm not sure the recent changes to dumping make this more viable/appropriate? Not sure though)

[wolfgangp]

Added some checks to cu-ranges.ll to capture the intent of the test better.

test/DebugInfo/Generic/cu-ranges.ll

17–22

Perhaps this change would capture the intent of the test better, if we want to verify that ranges for 2 different sections are created, i.e. more relying on the ability to display the section.

[dblaikie]

test/DebugInfo/Generic/cu-ranges.ll

17–22

At that point, we can probably drop the .debug_ranges part of this test entirely.

And the range checking in the debug_info section can probably skip the address ranges and just be:

CHECK:  DW_AT_ranges
CHECK-NEXT: "__TEXT,__foo"
CHECK-NEXT: ".text")+

Since the addresses aren't checked and this isn't a test for llvm-dwarfdump's syntactic output, but a test for LLVM's ranegs output, assuming dwarfdump's output is as expected.

But up to you what you reckon's more readable there.

[vleschuk]

@wolfgangp do you need any help with this revision before you commit it?

[wolfgangp]

In D51081#1230989, @vleschuk wrote:

@wolfgangp do you need any help with this revision before you commit it?

Sorry for the delay. Other work got in the way a bit. I'll commit shortly.

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 <cassert>
-#include <cstdint>
-#include <vector>
-
-namespace llvm {
-
-struct BaseAddress;
-class raw_ostream;
-
-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;
-    /// An ending address offset. This address offset again 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 first
-    /// address past the end of the address range. The ending address must
-    /// be greater than or equal to the beginning address.
-    uint64_t EndAddress;
-    /// A section index this range belongs to.
-    uint64_t SectionIndex;
-
-    /// The end of any given range list is marked by an end of list entry,
-    /// which consists of a 0 for the beginning address offset
-    /// and a 0 for the ending address offset.
-    bool isEndOfListEntry() const {
-      return (StartAddress == 0) && (EndAddress == 0);
-    }
-
-    /// A base address selection entry consists of:
-    /// 1. The value of the largest representable address offset
-    /// (for example, 0xffffffff when the size of an address is 32 bits).
-    /// 2. An address, which defines the appropriate base address for
-    /// use in interpreting the beginning and ending address offsets of
-    /// subsequent entries of the location list.
-    bool isBaseAddressSelectionEntry(uint8_t AddressSize) const {
-      assert(AddressSize == 4 || AddressSize == 8);
-      if (AddressSize == 4)
-        return StartAddress == -1U;
-      else
-        return StartAddress == -1ULL;
-    }
-  };
-
-private:
-  /// Offset in .debug_ranges section.
-  uint32_t Offset;
-  uint8_t AddressSize;
-  std::vector<RangeListEntry> Entries;
-
-public:
-  DWARFDebugRangeList() { clear(); }
-
-  void clear();
-  void dump(raw_ostream &OS) const;
-  Error extract(const DWARFDataExtractor &data, uint32_t *offset_ptr);
-  const std::vector<RangeListEntry> &getEntries() { return Entries; }
-
-  /// getAbsoluteRanges - Returns absolute address ranges defined by this range
-  /// list. Has to be passed base address of the compile unit referencing this
-  /// range list.
-  DWARFAddressRangesVector
-  getAbsoluteRanges(llvm::Optional<BaseAddress> BaseAddr) const;
-};
-
-} // end namespace llvm
-
-#endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGRANGELIST_H

include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h

 //===- 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/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DIContext.h"
+#include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFListTable.h"
 #include <cstdint>
 #include <map>
 #include <vector>
 
 namespace llvm {
 
+struct BaseAddress;
+class DWARFContext;
 class Error;
 class raw_ostream;
 
 /// A class representing a single range list entry.
 struct RangeListEntry : public DWARFListEntryBase {
   /// 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.
   uint64_t Value0;
   uint64_t Value1;
 
-  Error extract(DWARFDataExtractor Data, uint32_t End, uint32_t *OffsetPtr);
-  void dump(raw_ostream &OS, uint8_t AddrSize, uint8_t MaxEncodingStringLength,
-            uint64_t &CurrentBase, DIDumpOptions DumpOpts) const;
-  bool isSentinel() const { return EntryKind == dwarf::DW_RLE_end_of_list; }
+  Error extract(DWARFDataExtractor Data, uint32_t End, uint16_t Version,
+                StringRef SectionName, uint32_t *OffsetPtr, bool isDWO = false);
+  bool isEndOfList() const { return EntryKind == dwarf::DW_RLE_end_of_list; }
+  bool isBaseAddressSelectionEntry() const {
+    return EntryKind == dwarf::DW_RLE_base_address;
+  }
+  uint64_t getStartAddress() const {
+    assert((EntryKind == dwarf::DW_RLE_start_end ||
+            EntryKind == dwarf::DW_RLE_offset_pair ||
+            EntryKind == dwarf::DW_RLE_startx_length) &&
+           "Unexpected range list entry kind");
+    return Value0;
+  }
+  uint64_t getEndAddress() const {
+    assert((EntryKind == dwarf::DW_RLE_start_end ||
+            EntryKind == dwarf::DW_RLE_offset_pair) &&
+           "Unexpected range list entry kind");
+    return Value1;
+  }
+  void dump(raw_ostream &OS, DWARFContext *C, uint8_t AddrSize,
+            uint64_t &CurrentBase, unsigned Indent, uint16_t Version,
+            uint8_t MaxEncodingStringLength = 0,
+            DIDumpOptions DumpOpts = {}) const;
 };
 
 /// A class representing a single rangelist.
 class DWARFDebugRnglist : public DWARFListType<RangeListEntry> {
 public:
   /// Build a DWARFAddressRangesVector from a rangelist.
   DWARFAddressRangesVector
   getAbsoluteRanges(llvm::Optional<BaseAddress> BaseAddr) const;
 };
 
 class DWARFDebugRnglistTable : public DWARFListTableBase<DWARFDebugRnglist> {
 public:
-  DWARFDebugRnglistTable()
-      : DWARFListTableBase(/* SectionName    = */ ".debug_rnglists",
+  DWARFDebugRnglistTable(DWARFContext *C, StringRef SectionName,
+                         bool isDWO = false)
+      : DWARFListTableBase(C, SectionName, isDWO,
                            /* HeaderString   = */ "ranges:",
-                           /* ListTypeString = */ "range") {}
+                           /* ListTypeString = */ "range",
+                           dwarf::RangeListEncodingString) {}
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFDEBUGRNGLISTS_H

include/llvm/DebugInfo/DWARF/DWARFListTable.h

 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 #include <map>
 #include <vector>
 
 namespace llvm {
 
+class DWARFContext;
+
 /// A base class for DWARF list entries, such as range or location list
 /// entries.
 struct DWARFListEntryBase {
   /// The offset at which the entry is located in the section.
   uint32_t Offset;
   /// The DWARF encoding (DW_RLE_* or DW_LLE_*).
   uint8_t EntryKind;
   /// The index of the section this entry belongs to.
   uint64_t SectionIndex;
 };
 
 /// A base class for lists of entries that are extracted from a particular
 /// section, such as range lists or location lists.
 template <typename ListEntryType> class DWARFListType {
+public:
   using EntryType = ListEntryType;
   using ListEntries = std::vector<EntryType>;
 
 protected:
   ListEntries Entries;
 
 public:
   const ListEntries &getEntries() const { return Entries; }
-  bool empty() const { return Entries.empty(); }
+  bool empty() const {
+    return Entries.empty() || Entries.begin()->isEndOfList();
+  }
   void clear() { Entries.clear(); }
+  uint32_t getOffset() const {
+    if (Entries.empty())
+      return 0;
+    return Entries.begin()->Offset;
+  }
+
+  /// Extract a list. The caller must pass the correct DWARF version.
+  /// The end-of-list entry is retained as the last element of the vector of
+  /// entries.
   Error extract(DWARFDataExtractor Data, uint32_t HeaderOffset, uint32_t End,
-                uint32_t *OffsetPtr, StringRef SectionName,
-                StringRef ListStringName);
+                uint16_t Version, uint32_t *OffsetPtr, StringRef SectionName,
+                StringRef ListStringName, bool isDWO = false);
+  void dump(raw_ostream &OS, DWARFContext *C, uint8_t AddressSize,
+            uint64_t BaseAddress, unsigned Indent, uint16_t Version,
+            size_t MaxEncodingStringLength = 0,
+            DIDumpOptions DumpOpts = {}) const;
+  /// Print a header for the list. Returns the indentation that is to be used
+  /// when subsequently dumping each list entry.
+  unsigned printListHeader(raw_ostream &OS, uint8_t AddrSize,
+                           DIDumpOptions DIDumpOpts) const {
+    return 0;
+  }
 };
 
 /// A class representing the header of a list table such as the range list
 /// table in the .debug_rnglists section.
 class DWARFListTableHeader {
   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;
+    uint8_t SegSize = 0;
     /// The number of offsets that follow the header before the range lists.
-    uint32_t OffsetEntryCount;
+    uint32_t OffsetEntryCount = 0;
   };
 
   Header HeaderData;
   /// The offset table, which contains offsets to the individual list entries.
   /// It is used by forms such as DW_FORM_rnglistx.
   /// FIXME: Generate the table and use the appropriate forms.
   std::vector<uint32_t> Offsets;
   /// The table's format, either DWARF32 or DWARF64.
-  dwarf::DwarfFormat Format;
+  dwarf::DwarfFormat Format = dwarf::DwarfFormat::DWARF32;
   /// The offset at which the header (and hence the table) is located within
   /// its section.
-  uint32_t HeaderOffset;
+  uint32_t HeaderOffset = 0;
   /// The name of the section the list is located in.
   StringRef SectionName;
   /// A characterization of the list for dumping purposes, e.g. "range" or
   /// "location".
   StringRef ListTypeString;
 
 public:
   DWARFListTableHeader(StringRef SectionName, StringRef ListTypeString)
       : SectionName(SectionName), ListTypeString(ListTypeString) {}
 
   void clear() {
     HeaderData = {};
     Offsets.clear();
   }
   uint32_t getHeaderOffset() const { return HeaderOffset; }
+
   uint8_t getAddrSize() const { return HeaderData.AddrSize; }
+  void setAddrSize(uint8_t AddrSize) { HeaderData.AddrSize = AddrSize; }
+
   uint32_t getLength() const { return HeaderData.Length; }
+  void setLength(uint32_t Length) { HeaderData.Length = Length; }
+
+  uint16_t getVersion() const { return HeaderData.Version; }
+  void setVersion(uint16_t Version) { HeaderData.Version = Version; }
+
+  uint8_t getSegSize() const { return HeaderData.SegSize; }
+  uint32_t getOffsetEntryCount() const { return HeaderData.OffsetEntryCount; }
+
   StringRef getSectionName() const { return SectionName; }
   StringRef getListTypeString() const { return ListTypeString; }
   dwarf::DwarfFormat getFormat() const { return Format; }
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {}) const;
   Optional<uint32_t> getOffsetEntry(uint32_t Index) const {
     if (Index < Offsets.size())
       return Offsets[Index];
     return None;
   }
 
   /// Extract the table header and the array of offsets.
   Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
 
   /// Returns the length of the 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;
+  /// parsed, or there was a problem in parsing). In fake tables, such as for
+  /// DWARF v4 and earlier, there is no header, so the length simply reflects
+  /// the size of the section.
+  uint32_t getTableLength() const;
 };
 
 /// A class representing a table of lists as specified in the DWARF v5
 /// standard for location lists and range lists. The table consists of a header
 /// followed by an array of offsets into a DWARF section, followed by zero or
 /// more list entries. The list entries are kept in a map where the keys are
 /// the lists' section offsets.
 template <typename DWARFListType> class DWARFListTableBase {
   DWARFListTableHeader Header;
   /// A mapping between file offsets and lists. It is used to find a particular
   /// list based on an offset (obtained from DW_AT_ranges, for example).
   std::map<uint32_t, DWARFListType> ListMap;
+  DWARFContext *C;
+  /// True if this list is located in a split-DWARF (dwo or dwp) file.
+  bool isDWO;
   /// This string is displayed as a heading before the list is dumped
   /// (e.g. "ranges:").
   StringRef HeaderString;
+  ///
+  std::function<StringRef(unsigned)> EncodingString;
 
 protected:
-  DWARFListTableBase(StringRef SectionName, StringRef HeaderString,
-                     StringRef ListTypeString)
-      : Header(SectionName, ListTypeString), HeaderString(HeaderString) {}
+  DWARFListTableBase(DWARFContext *C, StringRef SectionName, bool isDWO,
+                     StringRef HeaderString, StringRef ListTypeString,
+                     std::function<StringRef(unsigned)> EncodingString)
+      : Header(SectionName, ListTypeString), C(C), isDWO(isDWO),
+        HeaderString(HeaderString), EncodingString(EncodingString) {}
 
 public:
   void clear() {
     Header.clear();
     ListMap.clear();
   }
   /// Extract the table header and the array of offsets.
   Error extractHeaderAndOffsets(DWARFDataExtractor Data, uint32_t *OffsetPtr) {
     return Header.extract(Data, OffsetPtr);
   }
+
+  /// Initialize the table header to explicit values. This is used for DWARF v4
+  /// and earlier since there is no header that can be extracted from a section.
+  void setHeaderData(uint32_t Length, uint16_t Version, uint8_t AddrSize) {
+    assert(Header.getSegSize() == 0 &&
+           "Unexpected segsize in list table header.");
+    assert(Header.getOffsetEntryCount() == 0 &&
+           "Unexpected offset entry count in list table header.");
+    Header.setLength(Length);
+    Header.setVersion(Version);
+    Header.setAddrSize(AddrSize);
+  }
+
   /// Extract an entire table, including all list entries.
-  Error extract(DWARFDataExtractor Data, uint32_t *OffsetPtr);
+  Error extract(DWARFDataExtractor Data, uint16_t Version, uint32_t *OffsetPtr);
   /// Look up a list based on a given offset. Extract it and enter it into the
   /// list map if necessary.
   Expected<DWARFListType> findList(DWARFDataExtractor Data, uint32_t Offset);
 
   uint32_t getHeaderOffset() const { return Header.getHeaderOffset(); }
   uint8_t getAddrSize() const { return Header.getAddrSize(); }
+  StringRef getListTypeString() const { return Header.getListTypeString(); }
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {}) const;
 
   /// Return the contents of the offset entry designated by a given index.
   Optional<uint32_t> getOffsetEntry(uint32_t Index) const {
     return Header.getOffsetEntry(Index);
   }
   /// Return the size of the table header including the length but not including
   /// the offsets. This is dependent on the table format, which is unambiguously
   /// derived from parsing the table.
   uint8_t getHeaderSize() const {
     switch (Header.getFormat()) {
     case dwarf::DwarfFormat::DWARF32:
       return 12;
     case dwarf::DwarfFormat::DWARF64:
       return 20;
     }
     llvm_unreachable("Invalid DWARF format (expected DWARF32 or DWARF64");
   }
 
-  uint32_t length() { return Header.length(); }
+  uint16_t getVersion() const { return Header.getVersion(); }
+  uint32_t getLength() const { return Header.getTableLength(); }
 };
 
 template <typename DWARFListType>
 Error DWARFListTableBase<DWARFListType>::extract(DWARFDataExtractor Data,
+                                                 uint16_t Version,
                                                  uint32_t *OffsetPtr) {
+  assert(Version > 0 && "DWARF version required and not given.");
   clear();
-  if (Error E = extractHeaderAndOffsets(Data, OffsetPtr))
+  // For DWARF v4 and earlier, we cannot extract a table header, so we
+  // initialize it explicitly.
+  if (Version < 5)
+    setHeaderData(Data.size(), Version, Data.getAddressSize());
+  else if (Error E = extractHeaderAndOffsets(Data, OffsetPtr))
     return E;
 
   Data.setAddressSize(Header.getAddrSize());
-  uint32_t End = getHeaderOffset() + Header.length();
+  uint32_t End = getHeaderOffset() + getLength();
+  // Extract all lists.
   while (*OffsetPtr < End) {
     DWARFListType CurrentList;
     uint32_t Off = *OffsetPtr;
-    if (Error E = CurrentList.extract(Data, getHeaderOffset(), End, OffsetPtr,
-                                      Header.getSectionName(),
-                                      Header.getListTypeString()))
+    if (Error E = CurrentList.extract(
+            Data, getHeaderOffset(), End, Header.getVersion(), OffsetPtr,
+            Header.getSectionName(), Header.getListTypeString(), isDWO))
       return E;
     ListMap[Off] = CurrentList;
   }
 
   assert(*OffsetPtr == End &&
          "mismatch between expected length of table and length "
          "of extracted data");
   return Error::success();
 }
 
 template <typename ListEntryType>
-Error DWARFListType<ListEntryType>::extract(DWARFDataExtractor Data,
-                                            uint32_t HeaderOffset, uint32_t End,
-                                            uint32_t *OffsetPtr,
-                                            StringRef SectionName,
-                                            StringRef ListTypeString) {
+Error DWARFListType<ListEntryType>::extract(
+    DWARFDataExtractor Data, uint32_t HeaderOffset, uint32_t End,
+    uint16_t Version, uint32_t *OffsetPtr, StringRef SectionName,
+    StringRef ListTypeString, bool isDWO) {
   if (*OffsetPtr < HeaderOffset || *OffsetPtr >= End)
     return createStringError(errc::invalid_argument,
                        "invalid %s list offset 0x%" PRIx32,
                        ListTypeString.data(), *OffsetPtr);
   Entries.clear();
   while (*OffsetPtr < End) {
     ListEntryType Entry;
-    if (Error E = Entry.extract(Data, End, OffsetPtr))
+    if (Error E =
+            Entry.extract(Data, End, Version, SectionName, OffsetPtr, isDWO))
       return E;
     Entries.push_back(Entry);
-    if (Entry.isSentinel())
+    if (Entry.isEndOfList())
       return Error::success();
   }
   return createStringError(errc::illegal_byte_sequence,
                      "no end of list marker detected at end of %s table "
                      "starting at offset 0x%" PRIx32,
                      SectionName.data(), HeaderOffset);
 }
 
+template <typename ListEntryType>
+void DWARFListType<ListEntryType>::dump(raw_ostream &OS, DWARFContext *C,
+                                        uint8_t AddressSize,
+                                        uint64_t BaseAddress, unsigned Indent,
+                                        uint16_t Version,
+                                        size_t MaxEncodingStringLength,
+                                        DIDumpOptions DumpOpts) const {
+  uint64_t CurrentBase = BaseAddress;
+  for (const auto &Entry : Entries) {
+    Entry.dump(OS, C, AddressSize, CurrentBase, Indent, Version,
+               MaxEncodingStringLength, DumpOpts);
+  }
+}
+
 template <typename DWARFListType>
 void DWARFListTableBase<DWARFListType>::dump(raw_ostream &OS,
                                              DIDumpOptions DumpOpts) const {
+  size_t MaxEncodingStringLength = 0;
+  // Don't dump the fake table header we create for DWARF v4 and earlier.
+  if (Header.getVersion() > 4) {
     Header.dump(OS, DumpOpts);
-  OS << HeaderString << "\n";
-
+    OS << HeaderString << '\n';
     // Determine the length of the longest encoding string we have in the table,
     // so we can align the output properly. We only need this in verbose mode.
-  size_t MaxEncodingStringLength = 0;
-  if (DumpOpts.Verbose) {
+    if (DumpOpts.Verbose)
       for (const auto &List : ListMap)
         for (const auto &Entry : List.second.getEntries())
-        MaxEncodingStringLength =
-            std::max(MaxEncodingStringLength,
-                     dwarf::RangeListEncodingString(Entry.EntryKind).size());
+          MaxEncodingStringLength = std::max(
+              MaxEncodingStringLength, EncodingString(Entry.EntryKind).size());
   }
 
   uint64_t CurrentBase = 0;
-  for (const auto &List : ListMap)
-    for (const auto &Entry : List.second.getEntries())
-      Entry.dump(OS, getAddrSize(), MaxEncodingStringLength, CurrentBase,
-                 DumpOpts);
+  for (const auto &List : ListMap) {
+    auto Indent = List.second.printListHeader(OS, getAddrSize(), DumpOpts);
+    List.second.dump(OS, C, getAddrSize(), CurrentBase, Indent,
+                     Header.getVersion(), MaxEncodingStringLength, DumpOpts);
+  }
 }
 
 template <typename DWARFListType>
 Expected<DWARFListType>
 DWARFListTableBase<DWARFListType>::findList(DWARFDataExtractor Data,
                                             uint32_t Offset) {
   auto Entry = ListMap.find(Offset);
   if (Entry != ListMap.end())
     return Entry->second;
 
   // Extract the list from the section and enter it into the list map.
   DWARFListType List;
-  uint32_t End = getHeaderOffset() + Header.length();
+  uint32_t End = getHeaderOffset() + getLength();
   uint32_t StartingOffset = Offset;
-  if (Error E =
-          List.extract(Data, getHeaderOffset(), End, &Offset,
-                       Header.getSectionName(), Header.getListTypeString()))
+  if (Error E = List.extract(Data, getHeaderOffset(), End, Header.getVersion(),
+                             &Offset, Header.getSectionName(),
+                             Header.getListTypeString(), isDWO))
     return std::move(E);
   ListMap[StartingOffset] = List;
   return List;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARFLISTTABLE_H

include/llvm/DebugInfo/DWARF/DWARFUnit.h

 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugInfoEntry.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/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/Support/DataExtractor.h"
 #include <algorithm>
public:
   bool getStringOffsetSectionItem(uint32_t Index, uint64_t &Result) const;
 
   DWARFDataExtractor getDebugInfoExtractor() const;
 
   DataExtractor getStringExtractor() const {
     return DataExtractor(StringSection, false, 0);
   }
 
-  /// Extract the range list referenced by this compile unit from the
-  /// .debug_ranges section. If the extraction is unsuccessful, an error
-  /// is returned. Successful extraction requires that the compile unit
-  /// has already been extracted.
-  Error extractRangeList(uint32_t RangeListOffset,
-                         DWARFDebugRangeList &RangeList) const;
   void clear();
 
   const Optional<StrOffsetsContributionDescriptor> &
   getStringOffsetsTableContribution() const {
     return StringOffsetsTableContribution;
   }
 
   uint8_t getDwarfStringOffsetsByteSize() const {

lib/DebugInfo/DWARF/CMakeLists.txt

add_llvm_library(LLVMDebugInfoDWARF
   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
   DWARFListTable.cpp
   DWARFTypeUnit.cpp
   DWARFUnitIndex.cpp
   DWARFUnit.cpp
   DWARFVerifier.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/DWARFDebugAddr.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugArangeSet.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAranges.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #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"
if (Error Err = AddrTable.extract(AddrData, &Offset, Version,
       uint64_t Length = AddrTable.getLength();
       Offset = TableOffset + Length;
     } else {
       AddrTable.dump(OS, DumpOpts);
     }
   }
 }
 
-// Dump the .debug_rnglists or .debug_rnglists.dwo section (DWARF v5).
-static void dumpRnglistsSection(raw_ostream &OS,
-                                DWARFDataExtractor &rnglistData,
-                                DIDumpOptions DumpOpts) {
+// Dump a section that contains a sequence of tables of lists, such as range
+// or location list tables. In DWARF v5 we expect to find properly formatted
+// tables with headers. In DWARF v4 and earlier we simply expect a sequence of
+// lists, which we treat, mutatis mutandis, like DWARF v5 tables.
+template <typename ListTable>
+static void dumpListSection(raw_ostream &OS, DWARFContext *C,
+                            StringRef SectionName, uint16_t MaxVersion,
+                            DWARFDataExtractor &ListData,
+                            DIDumpOptions DumpOpts, bool isDWO = false) {
   uint32_t Offset = 0;
-  while (rnglistData.isValidOffset(Offset)) {
-    llvm::DWARFDebugRnglistTable Rnglists;
+  while (ListData.isValidOffset(Offset)) {
+    ListTable Table(C, SectionName, isDWO);
     uint32_t TableOffset = Offset;
-    if (Error Err = Rnglists.extract(rnglistData, &Offset)) {
+    if (Error Err = Table.extract(ListData, MaxVersion, &Offset)) {
       WithColor::error() << toString(std::move(Err)) << '\n';
-      uint64_t Length = Rnglists.length();
+      uint64_t Length = Table.getLength();
       // 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;
+      // In DWARF v4 and earlier, dump as much of the lists as we can.
+      if (MaxVersion < 5)
+        Table.dump(OS, DumpOpts);
     } else {
-      Rnglists.dump(OS, DumpOpts);
+      Table.dump(OS, DumpOpts);
     }
   }
 }
 
 void DWARFContext::dump(
     raw_ostream &OS, DIDumpOptions DumpOpts,
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
 
auto shouldDump = [&](bool Explicit, const char *Name, unsigned ID,
     DumpOffset = DumpOffsets[ID];
     unsigned Mask = 1U << ID;
     bool Should = (DumpType & Mask) && (Explicit || !Section.empty());
     if (Should)
       OS << "\n" << Name << " contents:\n";
     return Should;
   };
 
+  auto maxVersion = [this](uint16_t DefaultVersion) {
+    uint16_t MaxV = getMaxVersion();
+    return MaxV ? MaxV : DefaultVersion;
+  };
+
   // Dump individual sections.
   if (shouldDump(Explicit, ".debug_abbrev", DIDT_ID_DebugAbbrev,
                  DObj->getAbbrevSection()))
     getDebugAbbrev()->dump(OS);
   if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev,
                  DObj->getAbbrevDWOSection()))
     getDebugAbbrevDWO()->dump(OS);
 
if (shouldDump(Explicit, ".debug_addr", DIDT_ID_DebugAddr,
     dumpAddrSection(OS, AddrData, DumpOpts, getMaxVersion(), getCUAddrSize());
   }
 
   if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
                  DObj->getRangeSection().Data)) {
     uint8_t savedAddressByteSize = getCUAddrSize();
     DWARFDataExtractor rangesData(*DObj, DObj->getRangeSection(),
                                   isLittleEndian(), savedAddressByteSize);
-    uint32_t offset = 0;
-    DWARFDebugRangeList rangeList;
-    while (rangesData.isValidOffset(offset)) {
-      if (Error E = rangeList.extract(rangesData, &offset)) {
-        WithColor::error() << toString(std::move(E)) << '\n';
-        break;
-      }
-      rangeList.dump(OS);
-    }
+    dumpListSection<DWARFDebugRnglistTable>(
+        OS, this, ".debug_ranges", /* MaxVersion = */ 4, rangesData, DumpOpts);
   }
 
   if (shouldDump(Explicit, ".debug_rnglists", DIDT_ID_DebugRnglists,
                  DObj->getRnglistsSection().Data)) {
     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsSection(),
-                                   isLittleEndian(), 0);
-    dumpRnglistsSection(OS, RnglistData, DumpOpts);
+                                   isLittleEndian(), getCUAddrSize());
+    dumpListSection<DWARFDebugRnglistTable>(
+        OS, this, ".debug_rnglists", maxVersion(5), RnglistData, DumpOpts);
   }
 
   if (shouldDump(ExplicitDWO, ".debug_rnglists.dwo", DIDT_ID_DebugRnglists,
                  DObj->getRnglistsDWOSection().Data)) {
     DWARFDataExtractor RnglistData(*DObj, DObj->getRnglistsDWOSection(),
-                                   isLittleEndian(), 0);
-    dumpRnglistsSection(OS, RnglistData, DumpOpts);
+                                   isLittleEndian(), getCUAddrSize());
+    dumpListSection<DWARFDebugRnglistTable>(
+        OS, this, ".debug_rnglists.dwo", maxVersion(5), RnglistData, DumpOpts);
   }
 
   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,

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/Errc.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/raw_ostream.h"
-#include <cinttypes>
-#include <cstdint>
-
-using namespace llvm;
-
-void DWARFDebugRangeList::clear() {
-  Offset = -1U;
-  AddressSize = 0;
-  Entries.clear();
-}
-
-Error DWARFDebugRangeList::extract(const DWARFDataExtractor &data,
-                                   uint32_t *offset_ptr) {
-  clear();
-  if (!data.isValidOffset(*offset_ptr))
-    return createStringError(errc::invalid_argument,
-                       "invalid range list offset 0x%" PRIx32, *offset_ptr);
-
-  AddressSize = data.getAddressSize();
-  if (AddressSize != 4 && AddressSize != 8)
-    return createStringError(errc::invalid_argument,
-                       "invalid address size: %" PRIu8, AddressSize);
-  Offset = *offset_ptr;
-  while (true) {
-    RangeListEntry Entry;
-    Entry.SectionIndex = -1ULL;
-
-    uint32_t prev_offset = *offset_ptr;
-    Entry.StartAddress = data.getRelocatedAddress(offset_ptr);
-    Entry.EndAddress =
-        data.getRelocatedAddress(offset_ptr, &Entry.SectionIndex);
-
-    // Check that both values were extracted correctly.
-    if (*offset_ptr != prev_offset + 2 * AddressSize) {
-      clear();
-      return createStringError(errc::invalid_argument,
-                         "invalid range list entry at offset 0x%" PRIx32,
-                         prev_offset);
-    }
-    if (Entry.isEndOfListEntry())
-      break;
-    Entries.push_back(Entry);
-  }
-  return Error::success();
-}
-
-void DWARFDebugRangeList::dump(raw_ostream &OS) const {
-  for (const RangeListEntry &RLE : Entries) {
-    const char *format_str = (AddressSize == 4
-                              ? "%08x %08"  PRIx64 " %08"  PRIx64 "\n"
-                              : "%08x %016" PRIx64 " %016" PRIx64 "\n");
-    OS << format(format_str, Offset, RLE.StartAddress, RLE.EndAddress);
-  }
-  OS << format("%08x <End of list>\n", Offset);
-}
-
-DWARFAddressRangesVector DWARFDebugRangeList::getAbsoluteRanges(
-    llvm::Optional<BaseAddress> BaseAddr) const {
-  DWARFAddressRangesVector Res;
-  for (const RangeListEntry &RLE : Entries) {
-    if (RLE.isBaseAddressSelectionEntry(AddressSize)) {
-      BaseAddr = {RLE.EndAddress, RLE.SectionIndex};
-      continue;
-    }
-
-    DWARFAddressRange E;
-    E.LowPC = RLE.StartAddress;
-    E.HighPC = RLE.EndAddress;
-    E.SectionIndex = RLE.SectionIndex;
-    // Base address of a range list entry is determined by the closest preceding
-    // base address selection entry in the same range list. It defaults to the
-    // base address of the compilation unit if there is no such entry.
-    if (BaseAddr) {
-      E.LowPC += BaseAddr->Address;
-      E.HighPC += BaseAddr->Address;
-      if (E.SectionIndex == -1ULL)
-        E.SectionIndex = BaseAddr->SectionIndex;
-    }
-    Res.push_back(E);
-  }
-  return Res;
-}

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/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 Error RangeListEntry::extract(DWARFDataExtractor Data, uint32_t End,
-                              uint32_t *OffsetPtr) {
+                              uint16_t Version, StringRef /* SectionName */,
+                              uint32_t *OffsetPtr, bool /* isDWO */) {
   Offset = *OffsetPtr;
   SectionIndex = -1ULL;
+
+  assert((Data.getAddressSize() == 4 || Data.getAddressSize() == 8) &&
+         "Unsupported address size");
+
+  // We model a DWARF v4 range list entry like DWARF v5 DW_RLE_offset_pair,
+  // since it is subject to base adjustment.
+  uint8_t Encoding = dwarf::DW_RLE_offset_pair;
+  if (Version > 4) {
     // The caller should guarantee that we have at least 1 byte available, so
     // we just assert instead of revalidate.
     assert(*OffsetPtr < End &&
            "not enough space to extract a rangelist encoding");
-  uint8_t Encoding = Data.getU8(OffsetPtr);
+    Encoding = Data.getU8(OffsetPtr);
+  }
 
   switch (Encoding) {
   case dwarf::DW_RLE_end_of_list:
     Value0 = Value1 = 0;
     break;
   // TODO: Support other encodings.
   case dwarf::DW_RLE_base_addressx:
     return createStringError(errc::not_supported,
                        "unsupported rnglists encoding DW_RLE_base_addressx "
                        "at offset 0x%" PRIx32,
                        *OffsetPtr - 1);
   case dwarf::DW_RLE_startx_endx:
     return createStringError(errc::not_supported,
                        "unsupported rnglists encoding DW_RLE_startx_endx at "
                        "offset 0x%" PRIx32,
                        *OffsetPtr - 1);
   case dwarf::DW_RLE_startx_length:
     return createStringError(errc::not_supported,
                        "unsupported rnglists encoding DW_RLE_startx_length "
                        "at offset 0x%" PRIx32,
                        *OffsetPtr - 1);
   case dwarf::DW_RLE_offset_pair: {
+    if (Version < 5) {
+      if ((End - *OffsetPtr) < unsigned(Data.getAddressSize() * 2))
+        return createStringError(
+            errc::illegal_byte_sequence,
+            "invalid range list entry at offset 0x%" PRIx32, *OffsetPtr);
+      Value0 = Data.getRelocatedAddress(OffsetPtr);
+      Value1 = Data.getRelocatedAddress(OffsetPtr, &SectionIndex);
+      // Adjust the EntryKind for end-of-list and base_address based on the
+      // contents.
+      if (Value0 == maxUIntN(Data.getAddressSize() * 8)) {
+        Encoding = dwarf::DW_RLE_base_address;
+        Value0 = Value1;
+        Value1 = 0;
+      } else if (Value0 == 0 && Value1 == 0)
+        Encoding = dwarf::DW_RLE_end_of_list;
+      break;
+    }
     uint32_t PreviousOffset = *OffsetPtr - 1;
     Value0 = Data.getULEB128(OffsetPtr);
     Value1 = Data.getULEB128(OffsetPtr);
     if (End < *OffsetPtr)
       return createStringError(errc::invalid_argument,
                          "read past end of table when reading "
                          "DW_RLE_offset_pair encoding at offset 0x%" PRIx32,
                          PreviousOffset);
     break;
   }
-  case dwarf::DW_RLE_base_address: {
+  case dwarf::DW_RLE_base_address:
     if ((End - *OffsetPtr) < Data.getAddressSize())
       return createStringError(errc::invalid_argument,
                          "insufficient space remaining in table for "
                          "DW_RLE_base_address encoding at offset 0x%" PRIx32,
                          *OffsetPtr - 1);
     Value0 = Data.getRelocatedAddress(OffsetPtr, &SectionIndex);
     break;
-  }
-  case dwarf::DW_RLE_start_end: {
+  case dwarf::DW_RLE_start_end:
     if ((End - *OffsetPtr) < unsigned(Data.getAddressSize() * 2))
       return createStringError(errc::invalid_argument,
                          "insufficient space remaining in table for "
                          "DW_RLE_start_end encoding "
                          "at offset 0x%" PRIx32,
                          *OffsetPtr - 1);
-    Value0 = Data.getRelocatedAddress(OffsetPtr, &SectionIndex);
-    Value1 = Data.getRelocatedAddress(OffsetPtr);
+    Value0 = Data.getRelocatedAddress(OffsetPtr);
+    Value1 = Data.getRelocatedAddress(OffsetPtr, &SectionIndex);
     break;
-  }
   case dwarf::DW_RLE_start_length: {
     uint32_t PreviousOffset = *OffsetPtr - 1;
     Value0 = Data.getRelocatedAddress(OffsetPtr, &SectionIndex);
     Value1 = Data.getULEB128(OffsetPtr);
     if (End < *OffsetPtr)
       return createStringError(errc::invalid_argument,
                          "read past end of table when reading "
                          "DW_RLE_start_length encoding at offset 0x%" PRIx32,
                          PreviousOffset);
     break;
   }
   default:
     return createStringError(errc::not_supported,
                        "unknown rnglists encoding 0x%" PRIx32
                        " at offset 0x%" PRIx32,
                        uint32_t(Encoding), *OffsetPtr - 1);
   }
 
   EntryKind = Encoding;
   return Error::success();
 }
 
 DWARFAddressRangesVector DWARFDebugRnglist::getAbsoluteRanges(
     llvm::Optional<BaseAddress> BaseAddr) const {
   DWARFAddressRangesVector Res;
   for (const RangeListEntry &RLE : Entries) {
     if (RLE.EntryKind == dwarf::DW_RLE_end_of_list)
       break;
     if (RLE.EntryKind == dwarf::DW_RLE_base_address) {
       BaseAddr = {RLE.Value0, RLE.SectionIndex};
       continue;
     }
 
     DWARFAddressRange E;
     E.SectionIndex = RLE.SectionIndex;
     if (BaseAddr && E.SectionIndex == -1ULL)
       E.SectionIndex = BaseAddr->SectionIndex;
 
default:
       // so we should not run into any here.
       llvm_unreachable("Unsupported range list encoding");
     }
     Res.push_back(E);
   }
   return Res;
 }
 
-void RangeListEntry::dump(raw_ostream &OS, uint8_t AddrSize,
-                          uint8_t MaxEncodingStringLength,
-                          uint64_t &CurrentBase, DIDumpOptions DumpOpts) const {
+void RangeListEntry::dump(raw_ostream &OS, DWARFContext *, uint8_t AddrSize,
+                          uint64_t &CurrentBase, unsigned Indent,
+                          uint16_t Version, uint8_t MaxEncodingStringLength,
+                          DIDumpOptions DumpOpts) const {
   auto PrintRawEntry = [](raw_ostream &OS, const RangeListEntry &Entry,
                           uint8_t AddrSize, DIDumpOptions DumpOpts) {
     if (DumpOpts.Verbose) {
       DumpOpts.DisplayRawContents = true;
       DWARFAddressRange(Entry.Value0, Entry.Value1)
           .dump(OS, AddrSize, DumpOpts);
       OS << " => ";
     }
   };
 
+  // Output indentations before we print the actual entry. We only print
+  // anything for DW_RLE_base_address when we are in verbose mode.
+  if (DumpOpts.Verbose || !isBaseAddressSelectionEntry())
+    OS.indent(Indent);
+
   if (DumpOpts.Verbose) {
     // Print the section offset in verbose mode.
     OS << format("0x%8.8" PRIx32 ":", Offset);
+    if (Version > 4) {
       auto EncodingString = dwarf::RangeListEncodingString(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 (EntryKind != dwarf::DW_RLE_end_of_list)
+      if (!isEndOfList())
         OS << ": ";
     }
+  }
 
   switch (EntryKind) {
   case dwarf::DW_RLE_end_of_list:
-    OS << (DumpOpts.Verbose ? "" : "<End of list>");
+    if (DumpOpts.Verbose) {
+      // For DWARF v4 and earlier, we print the raw entry, i.e. 2 zeros.
+      if (Version < 5) {
+        OS << format(" 0x%*.*" PRIx64, AddrSize * 2, AddrSize * 2, Value0);
+        OS << format(", 0x%*.*" PRIx64, AddrSize * 2, AddrSize * 2, Value1);
+      }
+      break;
+    }
+    OS << "<End of list>";
     break;
   case dwarf::DW_RLE_base_address:
-    // In non-verbose mode we do not print anything for this entry.
+    // In non-verbose mode, we do not print anything for this entry.
     CurrentBase = Value0;
     if (!DumpOpts.Verbose)
       return;
+    if (Version < 5) {
+      // Dump the entry in pre-DWARF v5 format, i.e. with a -1 as Value0.
+      uint64_t allOnes = maxUIntN(AddrSize * 8);
+      OS << format(" 0x%*.*" PRIx64, AddrSize * 2, AddrSize * 2, allOnes);
+      OS << format(", 0x%*.*" PRIx64, AddrSize * 2, AddrSize * 2, Value0);
+      break;
+    }
     OS << format(" 0x%*.*" PRIx64, AddrSize * 2, AddrSize * 2, Value0);
     break;
   case dwarf::DW_RLE_start_length:
     PrintRawEntry(OS, *this, AddrSize, DumpOpts);
     DWARFAddressRange(Value0, Value0 + Value1).dump(OS, AddrSize, DumpOpts);
     break;
   case dwarf::DW_RLE_offset_pair:
     PrintRawEntry(OS, *this, AddrSize, DumpOpts);

lib/DebugInfo/DWARF/DWARFDie.cpp

 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"

lib/DebugInfo/DWARF/DWARFListTable.cpp

Error DWARFListTableHeader::extract(DWARFDataExtractor Data,
   // Read and verify the length field.
   if (!Data.isValidOffsetForDataOfSize(*OffsetPtr, sizeof(uint32_t)))
     return createStringError(errc::invalid_argument,
                        "section is not large enough to contain a "
                        "%s table length at offset 0x%" PRIx32,
                        SectionName.data(), *OffsetPtr);
   // TODO: Add support for DWARF64.
   HeaderData.Length = Data.getU32(OffsetPtr);
+  // Preset the DWARF version before we extract the actual value. Both
+  // for validation purposes and in order to recover from errors found
+  // during extraction, getTableLength() needs to know the version, or at least
+  // whether it's 5 or less.
+  HeaderData.Version = 5;
   if (HeaderData.Length == 0xffffffffu)
     return createStringError(errc::not_supported,
                        "DWARF64 is not supported in %s at offset 0x%" PRIx32,
                        SectionName.data(), HeaderOffset);
   Format = dwarf::DwarfFormat::DWARF32;
-  if (HeaderData.Length + sizeof(uint32_t) < sizeof(Header))
-    return createStringError(errc::invalid_argument,
-                       "%s table at offset 0x%" PRIx32
-                       " has too small length (0x%" PRIx32
-                       ") to contain a complete header",
-                       SectionName.data(), HeaderOffset, length());
-  uint32_t End = HeaderOffset + length();
+  if (getTableLength() < sizeof(Header))
+    return createStringError(
+        errc::invalid_argument,
+        "%s table at offset 0x%" PRIx32 " has too small length (0x%" PRIx32
+        SectionName.data(), HeaderOffset, getTableLength());
+  uint32_t End = HeaderOffset + getTableLength();
   if (!Data.isValidOffsetForDataOfSize(HeaderOffset, End - HeaderOffset))
-    return createStringError(errc::invalid_argument,
-                       "section is not large enough to contain a %s table "
-                       "of length 0x%" PRIx32 " at offset 0x%" PRIx32,
-                       SectionName.data(), length(), HeaderOffset);
+    return createStringError(
+        errc::invalid_argument,
+        SectionName.data(), getTableLength(), 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)
+  if (HeaderData.Version != 5) {
+    uint16_t ExtractedVersion = HeaderData.Version;
+    // Set the version field to something valid so we can use getTableLength()
+    // safely.
+    HeaderData.Version = 5;
     return createStringError(errc::invalid_argument,
                              "unrecognised %s table version %" PRIu16
                              " in table at offset 0x%" PRIx32,
-                       SectionName.data(), HeaderData.Version, HeaderOffset);
+                             SectionName.data(), ExtractedVersion,
+                             HeaderOffset);
+  }
   if (HeaderData.AddrSize != 4 && HeaderData.AddrSize != 8)
     return createStringError(errc::not_supported,
                        "%s table at offset 0x%" PRIx32
                        " has unsupported address size %" PRIu8,
                        SectionName.data(), HeaderOffset, HeaderData.AddrSize);
   if (HeaderData.SegSize != 0)
     return createStringError(errc::not_supported,
                        "%s table at offset 0x%" PRIx32
for (const auto &Off : Offsets) {
       if (DumpOpts.Verbose)
         OS << format(" => 0x%8.8" PRIx32,
                      Off + HeaderOffset + sizeof(HeaderData));
     }
     OS << "\n]\n";
   }
 }
 
-uint32_t DWARFListTableHeader::length() const {
+uint32_t DWARFListTableHeader::getTableLength() const {
   if (HeaderData.Length == 0)
     return 0;
+  assert(HeaderData.Version > 0 &&
+         "No DWARF version in header when using getTableLength()");
   // TODO: DWARF64 support.
-  return HeaderData.Length + sizeof(uint32_t);
+  return HeaderData.Length + (HeaderData.Version > 4) * sizeof(uint32_t);
 }

lib/DebugInfo/DWARF/DWARFUnit.cpp

bool DWARFUnitHeader::extract(DWARFContext &Context,
   if (!LengthOK || !VersionOK || !AddrSizeOK || !TypeOffsetOK)
     return false;
 
   // Keep track of the highest DWARF version we encounter across all units.
   Context.setMaxVersionIfGreater(getVersion());
   return true;
 }
 
-// Parse the rangelist table header, including the optional array of offsets
+// Parse a list table header, including the optional array of offsets
 // following it (DWARF v5 and later).
-static Expected<DWARFDebugRnglistTable>
-parseRngListTableHeader(DWARFDataExtractor &DA, uint32_t Offset) {
+template <typename DWARFListTable>
+static Expected<DWARFListTable>
+parseListTableHeader(DWARFDataExtractor DA, DWARFContext *C,
+                     StringRef SectionName, uint32_t Offset, bool isDWO) {
   // TODO: Support DWARF64
   // We are expected to be called with Offset 0 or pointing just past the table
   // header, which is 12 bytes long for DWARF32.
+  DWARFListTable Table(C, SectionName, isDWO);
   if (Offset > 0) {
     if (Offset < 12U)
       return createStringError(errc::invalid_argument, "Did not detect a valid"
                                " range list table with base = 0x%" PRIu32,
                                Offset);
     Offset -= 12U;
   }
-  llvm::DWARFDebugRnglistTable Table;
   if (Error E = Table.extractHeaderAndOffsets(DA, &Offset))
     return std::move(E);
   return Table;
 }
 
-Error DWARFUnit::extractRangeList(uint32_t RangeListOffset,
-                                  DWARFDebugRangeList &RangeList) const {
-  // Require that compile unit is extracted.
-  assert(!DieArray.empty());
-  DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
-                                isLittleEndian, getAddressByteSize());
-  uint32_t ActualRangeListOffset = RangeSectionBase + RangeListOffset;
-  return RangeList.extract(RangesData, &ActualRangeListOffset);
+// Parse a DWARF v5 list table (e.g. either a rangelist table or a location
+// list table). For DWARF units with version 4 or earlier, we instead create
+// the table artifically by giving it a size that equals the section size.
+template <typename DWARFListTable>
+static Optional<DWARFListTable>
+setupListTable(DWARFUnit *U, const DWARFSection *Section, StringRef SectionName,
+               uint32_t &Base, bool isDWO, bool isLittleEndian) {
+  if (!Section->Data.size())
+    return None;
+  DWARFContext &Ctx = U->getContext();
+  DWARFListTable Table(&Ctx, SectionName, isDWO);
+  // Parse the list table header. Individual lists are extracted lazily.
+  DWARFDataExtractor DA(Ctx.getDWARFObj(), *Section, isLittleEndian,
+                        U->getAddressByteSize());
+  if (U->getVersion() < 5) {
+    Base = 0;
+    Table.setHeaderData(Section->Data.size(), U->getVersion(),
+                        DA.getAddressSize());
+    return Table;
+  }
+  if (auto TableOrError = parseListTableHeader<DWARFListTable>(
+          DA, &Ctx, SectionName, Base, isDWO))
+    Table = TableOrError.get();
+  else {
+    WithColor::error() << "parsing a " << Table.getListTypeString().data()
+                       << " list table: " << toString(TableOrError.takeError())
+                       << '\n';
+    return None;
+  }
+  // In a split dwarf unit, there are no attributes like DW_AT_rnglists_base or
+  // DW_AT_loclists_base that describe the table base. Adjust Base to point past
+  // the table header which is expected to start at offset 0.
+  if (isDWO)
+    Base = Table.getHeaderSize();
+  return Table;
 }
 
 void DWARFUnit::clear() {
   Abbrevs = nullptr;
   BaseAddr.reset();
   RangeSectionBase = 0;
   AddrOffsetSectionBase = 0;
   clearDIEs(false);
if (isDWO)
           determineStringOffsetsTableContributionDWO(
               DA, StringOffsetsContributionBase);
     else if (getVersion() >= 5)
       StringOffsetsTableContribution = determineStringOffsetsTableContribution(
           DA, StringOffsetsContributionBase);
 
     // DWARF v5 uses the .debug_rnglists and .debug_rnglists.dwo sections to
     // describe address ranges.
+    StringRef RangeSectionName = ".debug_ranges";
     if (getVersion() >= 5) {
-      if (isDWO)
+      if (isDWO) {
+        RangeSectionName = ".debug_rnglists.dwo";
         setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
-      else
+      } else {
+        RangeSectionName = ".debug_rnglists";
         setRangesSection(&Context.getDWARFObj().getRnglistsSection(),
                          toSectionOffset(UnitDie.find(DW_AT_rnglists_base), 0));
-      if (RangeSection->Data.size()) {
-        // Parse the range list table header. Individual range lists are
-        // extracted lazily.
-        DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
-                                    isLittleEndian, 0);
-        if (auto TableOrError =
-                parseRngListTableHeader(RangesDA, RangeSectionBase))
-          RngListTable = TableOrError.get();
-        else
-          WithColor::error() << "parsing a range list table: "
-                             << toString(TableOrError.takeError())
-                             << '\n';
-
-        // In a split dwarf unit, there is no DW_AT_rnglists_base attribute.
-        // Adjust RangeSectionBase to point past the table header.
-        if (isDWO && RngListTable)
-          RangeSectionBase = RngListTable->getHeaderSize();
       }
     }
+    RngListTable = setupListTable<DWARFDebugRnglistTable>(
+        this, RangeSection, RangeSectionName, RangeSectionBase, isDWO,
+        isLittleEndian);
 
     // Don't fall back to DW_AT_GNU_ranges_base: it should be ignored for
     // skeleton CU DIE, so that DWARF users not aware of it are not broken.
   }
 
   return DieArray.size();
 }
 
if (!DWOContext)
     return false;
 
   DWARFCompileUnit *DWOCU = DWOContext->getDWOCompileUnitForHash(*DWOId);
   if (!DWOCU)
     return false;
   DWO = std::shared_ptr<DWARFCompileUnit>(std::move(DWOContext), DWOCU);
   // Share .debug_addr and .debug_ranges section with compile unit in .dwo
   DWO->setAddrOffsetSection(AddrOffsetSection, AddrOffsetSectionBase);
   if (getVersion() >= 5) {
     DWO->setRangesSection(&Context.getDWARFObj().getRnglistsDWOSection(), 0);
-    DWARFDataExtractor RangesDA(Context.getDWARFObj(), *RangeSection,
-                                isLittleEndian, 0);
-    if (auto TableOrError = parseRngListTableHeader(RangesDA, RangeSectionBase))
-      DWO->RngListTable = TableOrError.get();
-    else
-      WithColor::error() << "parsing a range list table: "
-                         << toString(TableOrError.takeError())
-                         << '\n';
-    if (DWO->RngListTable)
-      DWO->RangeSectionBase = DWO->RngListTable->getHeaderSize();
+    DWO->RngListTable = setupListTable<DWARFDebugRnglistTable>(
+        DWOCU, DWO->RangeSection, ".debug_rnglists.dwo", DWO->RangeSectionBase,
+        /* isDWO =*/true, isLittleEndian);
   } else {
     auto DWORangesBase = UnitDie.getRangesBaseAttribute();
     DWO->setRangesSection(RangeSection, DWORangesBase ? *DWORangesBase : 0);
   }
 
   return true;
 }
 
 void DWARFUnit::clearDIEs(bool KeepCUDie) {
   if (DieArray.size() > (unsigned)KeepCUDie) {
     DieArray.resize((unsigned)KeepCUDie);
     DieArray.shrink_to_fit();
   }
 }
 
 Expected<DWARFAddressRangesVector>
 DWARFUnit::findRnglistFromOffset(uint32_t Offset) {
-  if (getVersion() <= 4) {
-    DWARFDebugRangeList RangeList;
-    if (Error E = extractRangeList(Offset, RangeList))
-      return std::move(E);
-    return RangeList.getAbsoluteRanges(getBaseAddress());
-  }
   if (RngListTable) {
     DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
                                   isLittleEndian, RngListTable->getAddrSize());
     auto RangeListOrError = RngListTable->findList(RangesData, Offset);
     if (RangeListOrError)
       return RangeListOrError.get().getAbsoluteRanges(getBaseAddress());
     return RangeListOrError.takeError();
   }

test/DebugInfo/Generic/cu-ranges.ll

 ; REQUIRES: object-emission
 ; RUN: %llc_dwarf -O0 -filetype=obj %s -o %t
 ; RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 ; Check that we emit ranges for this which has a non-traditional section and a normal section.
 
 ; CHECK: DW_TAG_compile_unit
 ; CHECK: DW_AT_ranges
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_low_pc
 ; CHECK: DW_AT_high_pc
 ; CHECK: DW_TAG_subprogram
 ; CHECK: DW_AT_low_pc
 ; CHECK: DW_AT_high_pc
 
 ; CHECK: .debug_ranges contents:
-; FIXME: When we get better dumping facilities we'll want to elaborate here.
-; CHECK: 00000000 <End of list>
+; CHECK-NEXT: 0x00000000: 0x0000000000000000, 0x0000000000000011 =>
+; CHECK-SAME: [0x0000000000000000, 0x0000000000000011)
+; CHECK-NEXT: 0x00000010: 0x0000000000000000, 0x0000000000000011 =>
+; CHECK-SAME: [0x0000000000000000, 0x0000000000000011)
+; CHECK-NEXT: 0x00000020: 0x0000000000000000, 0x0000000000000000
 
 ; Function Attrs: nounwind uwtable
 define i32 @foo(i32 %a) #0 section "__TEXT,__foo" !dbg !4 {
 entry:
   %a.addr = alloca i32, align 4
   store i32 %a, i32* %a.addr, align 4
   call void @llvm.dbg.declare(metadata i32* %a.addr, metadata !13, metadata !DIExpression()), !dbg !14
   %0 = load i32, i32* %a.addr, align 4, !dbg !15
   %add = add nsw i32 %0, 5, !dbg !15

test/DebugInfo/Inputs/gmlt.ll

 
 ; CHECK: .debug_ranges contents:
 
 ; ... some addresses (depends on platform (such as platforms with function
 ; reordering in the linker), and looks wonky on platforms with zero values
 ; written in relocation places (dumper needs to be fixed to read the
 ; relocations rather than interpret that as the end of a range list))
 
-; CHECK: 00000000 <End of list>
+; CHECK: 0x00000030: 0x0000000000000000, 0x0000000000000000
 
 
 ; Check that we don't emit any pubnames or pubtypes under -gmlt
 ; CHECK-NOT: .debug_pubnames contents:
 ; CHECK-NOT: .debug_pubtypes contents:
 
 ; Function Attrs: nounwind uwtable
 define void @_Z2f1v() #0 !dbg !4 {

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

 # RUN: llvm-mc -triple x86_64-pc-linux -filetype=obj %s -o %t
 # RUN: llvm-dwarfdump -v %t 2>%t.err | FileCheck %s
+# RUN: llvm-dwarfdump --debug-ranges %t | FileCheck --check-prefix=TERSE %s
 # RUN: FileCheck %s <%t.err -check-prefix=ERR
 
 # CHECK: .debug_info contents:
 # CHECK: 0x0000000b: DW_TAG_compile_unit [1]
 # CHECK:             DW_AT_low_pc [DW_FORM_addr]       (0x0000000000000000)
 # CHECK-NEXT:        DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
 # CHECK-NEXT:    [0x0000000000000000, 0x0000000000000001) ".text"
 # CHECK-NEXT:    [0x0000000000000003, 0x0000000000000006) ".text"
 # CHECK-NEXT:    [0x0000000000000001, 0x0000000000000002) ".text.foo1")
 
+# CHECK:      .debug_ranges contents:
+# CHECK-NEXT: 0x00000000: 0x0000000000000000, 0x0000000000000001 =>
+# CHECK-SAME: [0x0000000000000000, 0x0000000000000001)
+# CHECK-NEXT: 0x00000010: 0x0000000000000003, 0x0000000000000006 =>
+# CHECK-SAME: [0x0000000000000003, 0x0000000000000006)
+# CHECK-NEXT: 0x00000020: 0xffffffffffffffff, 0x0000000000000000
+# CHECK-NEXT: 0x00000030: 0x0000000000000001, 0x0000000000000002 =>
+# CHECK-SAME: [0x0000000000000001, 0x0000000000000002)
+# CHECK-NEXT: 0x00000040: 0x0000000000000000, 0x0000000000000000
+
+# TERSE:      .debug_ranges contents:
+# TERSE-NEXT: [0x0000000000000000, 0x0000000000000001)
+# TERSE-NEXT: [0x0000000000000003, 0x0000000000000006)
+# TERSE-NEXT: [0x0000000000000001, 0x0000000000000002)
+# TERSE-NEXT: <End of list>
+
+
+
 .text
 .globl foo
 .type foo,@function
 foo:
 .Lfunc_begin0:
   nop
 .Ltmp0:
   nop

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

 # RUN: llvm-mc -triple x86_64-pc-linux -filetype=obj %s -o %t
 # RUN: llvm-dwarfdump -v %t | FileCheck %s
 
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_compile_unit
 # CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
 # CHECK-NEXT:  [0x0000000000000000, 0x0000000000000001) ".text.foo1"
 # CHECK-NEXT:  [0x0000000000000000, 0x0000000000000002) ".text.foo2" [4]
 # CHECK-NEXT:  [0x0000000000000000, 0x0000000000000003) ".text.foo2" [5])
 
 # CHECK: .debug_ranges contents:
-# CHECK:   00000000 0000000000000000 0000000000000001
-# CHECK:   00000000 0000000000000000 0000000000000002
-# CHECK:   00000000 0000000000000000 0000000000000003
-# CHECK:   00000000 <End of list>
+# CHECK-NEXT: 0x00000000: 0x0000000000000000, 0x0000000000000001 =>
+# CHECK-SAME: [0x0000000000000000, 0x0000000000000001)
+# CHECK-NEXT: 0x00000010: 0x0000000000000000, 0x0000000000000002 =>
+# CHECK-SAME: [0x0000000000000000, 0x0000000000000002)
+# CHECK-NEXT: 0x00000020: 0x0000000000000000, 0x0000000000000003 =>
+# CHECK-SAME: [0x0000000000000000, 0x0000000000000003)
+# CHCKK-NEXT: 0x00000030: 0x0000000000000000, 0x0000000000000000
 
 # RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=BRIEF
 # BRIEF: DW_TAG_compile_unit
 # BRIEF: DW_AT_ranges         (0x00000000
 # BRIEF-NEXT:  [0x0000000000000000, 0x0000000000000001)
 # BRIEF-NEXT:  [0x0000000000000000, 0x0000000000000002)
 # BRIEF-NEXT:  [0x0000000000000000, 0x0000000000000003))
 

test/DebugInfo/dwarfdump-ranges.test

 RUN: llvm-dwarfdump -v %p/Inputs/dwarfdump-test4.elf-x86-64 | FileCheck %s
+RUN: llvm-dwarfdump --debug-ranges %p/Inputs/dwarfdump-test4.elf-x86-64 | FileCheck -check-prefix=TERSE %s
 
 CHECK: .debug_info contents:
 CHECK: DW_TAG_compile_unit
 CHECK-NOT: TAG
 CHECK:  DW_AT_ranges [DW_FORM_data4]      (0x00000000
 CHECK-NEXT:          [0x000000000000062c, 0x0000000000000637)
 CHECK-NEXT:          [0x0000000000000637, 0x000000000000063d))
 
 CHECK: DW_TAG_compile_unit
 CHECK-NOT: TAG
 CHECK:  DW_AT_ranges [DW_FORM_data4]      (0x00000030
 CHECK-NEXT:          [0x0000000000000640, 0x000000000000064b)
 CHECK-NEXT:          [0x0000000000000637, 0x000000000000063d))
 
 
 CHECK:      .debug_ranges contents:
-CHECK-NEXT: 00000000 000000000000062c 0000000000000637
-CHECK-NEXT: 00000000 0000000000000637 000000000000063d
-CHECK-NEXT: 00000000 <End of list>
-CHECK-NEXT: 00000030 0000000000000640 000000000000064b
-CHECK-NEXT: 00000030 0000000000000637 000000000000063d
-CHECK-NEXT: 00000030 <End of list>
+CHECK-NEXT: 0x00000000: 0x000000000000062c, 0x0000000000000637 =>
+CHECK-SAME: [0x000000000000062c, 0x0000000000000637)
+CHECK-NEXT: 0x00000010: 0x0000000000000637, 0x000000000000063d =>
+CHECK-SAME: [0x0000000000000637, 0x000000000000063d)
+CHECK-NEXT: 0x00000020: 0x0000000000000000, 0x0000000000000000
+CHECK-NEXT: 0x00000030: 0x0000000000000640, 0x000000000000064b =>
+CHECK-SAME: [0x0000000000000640, 0x000000000000064b)
+CHECK-NEXT: 0x00000040: 0x0000000000000637, 0x000000000000063d =>
+CHECK-SAME: [0x0000000000000637, 0x000000000000063d)
+CHECK-NEXT: 0x00000050: 0x0000000000000000, 0x0000000000000000
 
+TERSE:      .debug_ranges contents:
+TERSE-NEXT: [0x000000000000062c, 0x0000000000000637)
+TERSE-NEXT: [0x0000000000000637, 0x000000000000063d)
+TERSE-NEXT: <End of list>
+TERSE-NEXT: [0x0000000000000640, 0x000000000000064b)
+TERSE-NEXT: [0x0000000000000637, 0x000000000000063d)
+TERSE-NEXT: <End of list>

test/MC/ARM/dwarf-asm-multiple-sections.s

 // DWARF-DL:      name: "{{(<stdin>|-)}}"
 // DWARF-DL:      0x0000000000000000     17      0      1   0   0  is_stmt
 // DWARF-DL-NEXT: 0x0000000000000004     17      0      1   0   0  is_stmt end_sequence
 // DWARF-DL-NEXT: 0x0000000000000000     21      0      1   0   0  is_stmt
 // DWARF-DL-NEXT: 0x0000000000000004     21      0      1   0   0  is_stmt end_sequence
 
 
 // DWARF: .debug_ranges contents:
-// DWARF: 00000000 ffffffff 00000000
-// DWARF: 00000000 00000000 00000004
-// DWARF: 00000000 ffffffff 00000000
-// DWARF: 00000000 00000000 00000004
-// DWARF: 00000000 <End of list>
-
+// DWARF-NEXT: 0x00000000: 0xffffffff, 0x00000000
+// DWARF-NEXT: 0x00000008: 0x00000000, 0x00000004 => [0x00000000, 0x00000004)
+// DWARF-NEXT: 0x00000010: 0xffffffff, 0x00000000
+// DWARF-NEXT: 0x00000018: 0x00000000, 0x00000004 => [0x00000000, 0x00000004)
+// DWARF-NEXT: 0x00000020: 0x00000000, 0x00000000
 
 
 // Offsets are different in DWARF v5 due to different header layout.
 // RELOC: RELOCATION RECORDS FOR [.rel.debug_info]:
 // RELOC4-NEXT: 00000006 R_ARM_ABS32 .debug_abbrev
 // RELOC4-NEXT: 0000000c R_ARM_ABS32 .debug_line
 // RELOC4-NEXT: 00000010 R_ARM_ABS32 .debug_ranges
 // RELOC5-NEXT: 00000008 R_ARM_ABS32 .debug_abbrev

tools/dsymutil/DwarfLinker.cpp

 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/DIE.h"
 #include "llvm/Config/config.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"

 }
 
 /// Patch the input object file relevant debug_ranges entries
 /// and emit them in the output file. Update the relevant attributes
 /// to point at the new entries.
 void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
                                      DWARFContext &OrigDwarf,
                                      const DebugMapObject &DMO) const {
-  DWARFDebugRangeList RangeList;
+  DWARFDebugRnglist RangeList;
   const auto &FunctionRanges = Unit.getFunctionRanges();
   unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
   DWARFDataExtractor RangeExtractor(OrigDwarf.getDWARFObj(),
                                     OrigDwarf.getDWARFObj().getRangeSection(),
                                     OrigDwarf.isLittleEndian(), AddressSize);
   auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
   DWARFUnit &OrigUnit = Unit.getOrigUnit();
   auto OrigUnitDie = OrigUnit.getUnitDIE(false);
   uint64_t OrigLowPc =
       dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc), -1ULL);
   // Ranges addresses are based on the unit's low_pc. Compute the
   // offset we need to apply to adapt to the new unit's low_pc.
   int64_t UnitPcOffset = 0;
   if (OrigLowPc != -1ULL)
     UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();
 
   for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
     uint32_t Offset = RangeAttribute.get();
     RangeAttribute.set(Streamer->getRangesSectionSize());
-    if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
+    if (Error E = RangeList.extract(RangeExtractor, /* HeaderOffset = */0,
+                                    RangeExtractor.size(),
+                                    Unit.getOrigUnit().getVersion(), &Offset,
+                                    ".debug_ranges", "range")) {
       llvm::consumeError(std::move(E));
       reportWarning("invalid range list ignored.", DMO);
       RangeList.clear();
     }
     const auto &Entries = RangeList.getEntries();
-    if (!Entries.empty()) {
-      const DWARFDebugRangeList::RangeListEntry &First = Entries.front();
-
+    if (!RangeList.empty()) {
+      const auto &First = Entries.front();
       if (CurrRange == InvalidRange ||
-          First.StartAddress + OrigLowPc < CurrRange.start() ||
-          First.StartAddress + OrigLowPc >= CurrRange.stop()) {
-        CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);
+          First.getStartAddress() + OrigLowPc < CurrRange.start() ||
+          First.getStartAddress() + OrigLowPc >= CurrRange.stop()) {
+        CurrRange = FunctionRanges.find(First.getStartAddress() + OrigLowPc);
         if (CurrRange == InvalidRange ||
-            CurrRange.start() > First.StartAddress + OrigLowPc) {
+            CurrRange.start() > First.getStartAddress() + OrigLowPc) {
           reportWarning("no mapping for range.", DMO);
           continue;
         }
       }
     }
 
     Streamer->emitRangesEntries(UnitPcOffset, OrigLowPc, CurrRange, Entries,
                                 AddressSize);

tools/dsymutil/DwarfStreamer.h

 //===- tools/dsymutil/DwarfStreamer.h - Dwarf Streamer ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CompileUnit.h"
 #include "DebugMap.h"
 #include "LinkUtils.h"
 #include "NonRelocatableStringpool.h"
 #include "llvm/CodeGen/AccelTable.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
-#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugRnglists.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
public:
   /// Emit the swift_ast section stored in \p Buffer.
   void emitSwiftAST(StringRef Buffer);
 
   /// Emit debug_ranges for \p FuncRange by translating the
   /// original \p Entries.
   void emitRangesEntries(
       int64_t UnitPcOffset, uint64_t OrigLowPc,
       const FunctionIntervals::const_iterator &FuncRange,
-      const std::vector<DWARFDebugRangeList::RangeListEntry> &Entries,
+      const DWARFDebugRnglist::ListEntries &Entries,
       unsigned AddressSize);
 
   /// Emit debug_aranges entries for \p Unit and if \p DoRangesSection is true,
   /// also emit the debug_ranges entries for the DW_TAG_compile_unit's
   /// DW_AT_ranges attribute.
   void emitUnitRangesEntries(CompileUnit &Unit, bool DoRangesSection);
 
   uint32_t getRangesSectionSize() const { return RangesSectionSize; }

tools/dsymutil/DwarfStreamer.cpp

 
 /// Emit the debug_range section contents for \p FuncRange by
 /// translating the original \p Entries. The debug_range section
 /// format is totally trivial, consisting just of pairs of address
 /// sized addresses describing the ranges.
 void DwarfStreamer::emitRangesEntries(
     int64_t UnitPcOffset, uint64_t OrigLowPc,
     const FunctionIntervals::const_iterator &FuncRange,
-    const std::vector<DWARFDebugRangeList::RangeListEntry> &Entries,
-    unsigned AddressSize) {
+    const DWARFDebugRnglist::ListEntries &Entries, unsigned AddressSize) {
   MS->SwitchSection(MC->getObjectFileInfo()->getDwarfRangesSection());
 
   // Offset each range by the right amount.
   int64_t PcOffset = Entries.empty() ? 0 : FuncRange.value() + UnitPcOffset;
   for (const auto &Range : Entries) {
-    if (Range.isBaseAddressSelectionEntry(AddressSize)) {
+    if (Range.isBaseAddressSelectionEntry()) {
       warn("unsupported base address selection operation",
            "emitting debug_ranges");
       break;
     }
     // Do not emit empty ranges.
-    if (Range.StartAddress == Range.EndAddress)
+    if (Range.isEndOfList() || Range.getStartAddress() == Range.getEndAddress())
       continue;
 
     // All range entries should lie in the function range.
-    if (!(Range.StartAddress + OrigLowPc >= FuncRange.start() &&
-          Range.EndAddress + OrigLowPc <= FuncRange.stop()))
+    if (!(Range.getStartAddress() + OrigLowPc >= FuncRange.start() &&
+          Range.getEndAddress() + OrigLowPc <= FuncRange.stop()))
       warn("inconsistent range data.", "emitting debug_ranges");
-    MS->EmitIntValue(Range.StartAddress + PcOffset, AddressSize);
-    MS->EmitIntValue(Range.EndAddress + PcOffset, AddressSize);
+    MS->EmitIntValue(Range.getStartAddress() + PcOffset, AddressSize);
+    MS->EmitIntValue(Range.getEndAddress() + PcOffset, AddressSize);
     RangesSectionSize += 2 * AddressSize;
   }
 
   // Add the terminator entry.
   MS->EmitIntValue(0, AddressSize);
   MS->EmitIntValue(0, AddressSize);
   RangesSectionSize += 2 * AddressSize;
 }