[BOLT][DWARF] Change rangelists to use DW_RLE_offset_pair

[ayermolo]

Summary

Before we always used DW_RLE_startx_length. This is not very efficient and leads
to bigger .debug_addr section. Changed it to use
DW_RLE_base_addressx/DW_RLE_offset_pair.

clang-16 build in debug mode
llvm-bolt ran on it with --update-debug-sections

section	before	after	diff	% decrease
.debug_rnglists	32732292	31986051	-746241	2.3%
.debug_addr	14415808	14184128	-231680	1.6%

[ayermolo]

clang-format

[maksfb]

Could you add to the summary the decrease in binary/DWARF size you see with this change?

bolt/lib/Core/DebugData.cpp

215

238

bolt/include/bolt/Core/DebugData.h

public:
   virtual ~DebugRangesSectionWriter(){};
 
   /// Add ranges with caching.
   virtual uint64_t
   addRanges(DebugAddressRangesVector &&Ranges,
             std::map<DebugAddressRangesVector, uint64_t> &CachedRanges);
 
   /// Add ranges and return offset into section.
-  virtual uint64_t addRanges(const DebugAddressRangesVector &Ranges);
+  virtual uint64_t addRanges(DebugAddressRangesVector &Ranges);
 
   /// Returns an offset of an empty address ranges list that is always written
   /// to .debug_ranges
   uint64_t getEmptyRangesOffset() const { return EmptyRangesOffset; }
 
   /// Returns the SectionOffset.
   uint64_t getSectionOffset();
 
public:
   static void setAddressWriter(DebugAddrWriter *AddrW) { AddrWriter = AddrW; }
 
   /// Add ranges with caching.
   uint64_t addRanges(
       DebugAddressRangesVector &&Ranges,
       std::map<DebugAddressRangesVector, uint64_t> &CachedRanges) override;
 
   /// Add ranges and return offset into section.
-  uint64_t addRanges(const DebugAddressRangesVector &Ranges) override;
+  uint64_t addRanges(DebugAddressRangesVector &Ranges) override;
 
   std::unique_ptr<DebugBufferVector> releaseBuffer() override {
     return std::move(RangesBuffer);
   }
 
   /// Needs to be invoked before each \p CU is processed.
   void initSection(DWARFUnit &CU) override;
 

bolt/lib/Core/DebugData.cpp

if (RI != CachedRanges.end())
     return RI->second;
 
   const uint64_t EntryOffset = addRanges(Ranges);
   CachedRanges.emplace(std::move(Ranges), EntryOffset);
 
   return EntryOffset;
 }
 
-uint64_t
-DebugRangesSectionWriter::addRanges(const DebugAddressRangesVector &Ranges) {
+uint64_t DebugRangesSectionWriter::addRanges(DebugAddressRangesVector &Ranges) {
   if (Ranges.empty())
     return getEmptyRangesOffset();
 
   // Reading the SectionOffset and updating it should be atomic to guarantee
   // unique and correct offsets in patches.
   std::lock_guard<std::mutex> Lock(WriterMutex);
   const uint32_t EntryOffset = SectionOffset;
   SectionOffset += writeAddressRanges(*RangesStream.get(), Ranges);
getDWARF5Header(const LocListsRangelistsHeader &Header) {
   support::endian::write(*HeaderStream, Header.AddressSize, support::little);
   support::endian::write(*HeaderStream, Header.SegmentSelector,
                          support::little);
   support::endian::write(*HeaderStream, Header.OffsetEntryCount,
                          support::little);
   return HeaderBuffer;
 }
 
-uint64_t DebugRangeListsSectionWriter::addRanges(
-    const DebugAddressRangesVector &Ranges) {
+static bool emitWithBase(raw_ostream &OS,
+                         const DebugAddressRangesVector &Ranges,
+                         DebugAddrWriter &AddrWriter, DWARFUnit &CU,
+                         uint32_t &Index) {
+  if (Ranges.size() < 2)
+    return false;
+  uint64_t Base = Ranges[Index].LowPC;
+  std::vector<std::pair<uint16_t, uint16_t>> RangeOffsets;
+  uint8_t TempBuffer[64];
+  while (Index < Ranges.size()) {
+    const DebugAddressRange &Range = Ranges[Index];
+    if (Range.LowPC == 0)
+      break;
+    assert(Base <= Range.LowPC && "Range base is higher than low PC");
+    uint32_t StartOffset = Range.LowPC - Base;
+    uint32_t EndOffset = Range.HighPC - Base;
+    if (encodeULEB128(EndOffset, TempBuffer) > 2)
+      break;
+    RangeOffsets.emplace_back(StartOffset, EndOffset);
+    ++Index;
+  }
+
+  if (RangeOffsets.size() < 2) {
+    Index -= RangeOffsets.size();
+    return false;
+  }
+
+  support::endian::write(OS, static_cast<uint8_t>(dwarf::DW_RLE_base_addressx),
+                         support::little);
+  uint32_t BaseIndex = AddrWriter.getIndexFromAddress(Base, CU);
+  encodeULEB128(BaseIndex, OS);
+  for (auto &Offset : RangeOffsets) {
+    support::endian::write(OS, static_cast<uint8_t>(dwarf::DW_RLE_offset_pair),
+                           support::little);
+    encodeULEB128(Offset.first, OS);
+    encodeULEB128(Offset.second, OS);
+  }
+  support::endian::write(OS, static_cast<uint8_t>(dwarf::DW_RLE_end_of_list),
+                         support::little);
+  return true;
+}
+
+uint64_t
+DebugRangeListsSectionWriter::addRanges(DebugAddressRangesVector &Ranges) {
   std::lock_guard<std::mutex> Lock(WriterMutex);
 
   RangeEntries.push_back(CurrentOffset);
-  for (const DebugAddressRange &Range : Ranges) {
+  bool WrittenStartxLength = false;
+  std::sort(
+      Ranges.begin(), Ranges.end(),
+      [](const DebugAddressRange &R1, const DebugAddressRange &R2) -> bool {
+        return R1.LowPC < R2.LowPC;
+      });
+  for (unsigned I = 0; I < Ranges.size();) {
+    WrittenStartxLength = false;
+    if (emitWithBase(*CUBodyStream, Ranges, *AddrWriter, *CU, I))
+      continue;
+    const DebugAddressRange &Range = Ranges[I];
     support::endian::write(*CUBodyStream,
                            static_cast<uint8_t>(dwarf::DW_RLE_startx_length),
                            support::little);
     uint32_t Index = AddrWriter->getIndexFromAddress(Range.LowPC, *CU);
     encodeULEB128(Index, *CUBodyStream);
     encodeULEB128(Range.HighPC - Range.LowPC, *CUBodyStream);
+    ++I;
+    WrittenStartxLength = true;
   }
+  if (WrittenStartxLength)
     support::endian::write(*CUBodyStream,
                            static_cast<uint8_t>(dwarf::DW_RLE_end_of_list),
                            support::little);
   CurrentOffset = CUBodyBuffer->size();
   return RangeEntries.size() - 1;
 }
 
 void DebugRangeListsSectionWriter::finalizeSection() {
   std::unique_ptr<DebugBufferVector> CUArrayBuffer =
       std::make_unique<DebugBufferVector>();
   std::unique_ptr<raw_svector_ostream> CUArrayStream =

bolt/test/X86/dwarf5-debug-loclists.s

 # PRECHECK-EMPTY:
 # PRECHECK: DW_TAG_variable
 # PRECHECK: DW_AT_location [DW_FORM_loclistx]
 # PRECHECK-SAME: indexed (0x0)
 # PRECHECK-SAME: loclist = 0x00000010
 
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
 # POSTCHECK-NEXT: 0x
+# POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset] (0x0000000c)
 # POSTCHECK: DW_AT_rnglists_base [DW_FORM_sec_offset] (0x0000000c)
 # POSTCHECK: DW_TAG_variable
 # POSTCHECK: DW_AT_location [DW_FORM_loclistx]
 # POSTCHECK-SAME: indexed (0x0)
 # POSTCHECK-SAME: loclist = 0x00000010

bolt/test/X86/dwarf5-df-dualcu.test

 ; BOLT-SAME: 0x[[#ADDR + 0x24]]
 ; BOLT-NEXT: [0x[[#ADDR2]]
 ; BOLT-SAME: 0x[[#ADDR2 + 0x59]]
 ; BOLT-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]  (0x00000008)
 ; BOLT-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000c)
 ; BOLT: DW_TAG_skeleton_unit
 ; BOLT: DW_AT_dwo_name [DW_FORM_strx1]  (indexed (00000001) string = "helper.dwo.dwo")
 ; BOLT-NEXT: DW_AT_low_pc [DW_FORM_addrx] (indexed (00000003) address = 0x0000000000000000)
-; BOLT-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0) rangelist = 0x00000027
+; BOLT-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0) rangelist = 0x0000002a
 ; BOLT-NEXT: [0x[[#ADDR3]]
 ; BOLT-SAME: 0x[[#ADDR3 + 0x3D]]
 ; BOLT-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]  (0x00000038)
-; BOLT-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000023)
+; BOLT-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000026)
 
 ; PRE-BOLT-DWO-MAIN: version = 0x0005
 ; PRE-BOLT-DWO-MAIN: DW_TAG_compile_unit
 ; PRE-BOLT-DWO-MAIN: DW_TAG_variable [2]
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_name [DW_FORM_strx1]  (indexed (00000000) string = "x")
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_type
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_external
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_decl_file

bolt/test/X86/dwarf5-df-mono-dualcu.test

 ; BOLT-SAME: 0x[[#ADDR + 0x24]]
 ; BOLT-NEXT: [0x[[#ADDR2]]
 ; BOLT-SAME: 0x[[#ADDR2 + 0x59]]
 ; BOLT-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]  (0x00000008)
 ; BOLT-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000c)
 ; BOLT: DW_TAG_compile_unit
 ; BOLT: DW_AT_name [DW_FORM_strx1]  (indexed (00000001) string = "helper.cpp")
 ; BOLT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001) address = 0x0000000000000000)
-; BOLT-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0) rangelist = 0x0000002b
+; BOLT-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0) rangelist = 0x0000002e
 ; BOLT-NEXT: [0x[[#ADDR3]]
 ; BOLT-SAME: 0x[[#ADDR3 + 0x3D]]
 ; BOLT-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]  (0x00000038)
-; BOLT-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000023)
+; BOLT-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000026)
 ; BOLT: DW_TAG_variable
 ; BOLT-NEXT: DW_AT_name [DW_FORM_strx1]  (indexed (00000003) string = "z")
 ; BOLT-NEXT: DW_AT_type
 ; BOLT-NEXT: DW_AT_external
 ; BOLT-NEXT: DW_AT_decl_file
 ; BOLT-NEXT: DW_AT_decl_line
 ; BOLT-NEXT: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x2)
 ; BOLT: DW_TAG_variable
 ; BOLT-NEXT: DW_AT_name [DW_FORM_strx1]  (indexed (00000005) string = "d")
 ; BOLT-NEXT: DW_AT_type
 ; BOLT-NEXT: DW_AT_external
 ; BOLT-NEXT: DW_AT_decl_file
 ; BOLT-NEXT: DW_AT_decl_line
 ; BOLT-NEXT: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x3)
 ; BOLT: DW_TAG_subprogram
 ; BOLT-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001) address = 0x0000000000000000)
-; BOLT-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1) rangelist = 0x0000002f
+; BOLT-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1) rangelist = 0x00000032
 ; BOLT-NEXT: [0x[[#ADDR3]]
 ; BOLT-SAME: 0x[[#ADDR3 + 0x3D]]
 
 ; PRE-BOLT-DWO-MAIN: version = 0x0005
 ; PRE-BOLT-DWO-MAIN: DW_TAG_compile_unit
 ; PRE-BOLT-DWO-MAIN: DW_TAG_variable [2]
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_name [DW_FORM_strx1]  (indexed (00000000) string = "x")
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_type

bolt/test/X86/dwarf5-dwarf4-monolithic.test

 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
 # POSTCHECK-NEXT: DW_AT_stmt_list [DW_FORM_sec_offset]  (0x00000000)
 # POSTCHECK-NEXT: DW_AT_comp_dir
 # POSTCHECK-NEXT: DW_AT_low_pc
 # POSTCHECK: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0)
 # POSTCHECK-NEXT: [0x[[#ADDR]], 0x[[#ADDR + 0x7]]
-# POSTCHECK-NEXT: [0x[[#ADDR1]], 0x[[#ADDR1 + 0x51]]
+# POSTCHECK-NEXT: [0x[[#ADDR2]], 0x[[#ADDR2 + 0x51]]
 # POSTCHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]  (0x00000008)
 # POSTCHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000c)
 # POSTCHECK-NEXT: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x0000000c)
 # POSTCHECK: DW_TAG_subprogram [2]
-# POSTCHECK: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000002) address = 0x0000000000000000)
+# POSTCHECK: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001) address = 0x0000000000000000)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1) rangelist
 # POSTCHECK-NEXT: [0x[[#ADDR]], 0x[[#ADDR + 0x7]]
 # POSTCHECK: DW_TAG_subprogram [8]
-# POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000002) address = 0x0000000000000000)
-# POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x2) rangelist = 0x00000027
-# POSTCHECK-NEXT: [0x[[#ADDR1]], 0x[[#ADDR1 + 0x51]]
+# POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001) address = 0x0000000000000000)
+# POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x2) rangelist = 0x00000029
+# POSTCHECK-NEXT: [0x[[#ADDR2]], 0x[[#ADDR2 + 0x51]]
 # POSTCHECK: DW_TAG_formal_parameter [9]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0) loclist = 0x00000018
-# POSTCHECK-NEXT: [0x[[#ADDR1]], 0x[[#ADDR3]]
+# POSTCHECK-NEXT: [0x[[#ADDR2]], 0x[[#ADDR2 + 0x22]]
 # POSTCHECK-NEXT: [0x[[#ADDR3]], 0x[[#ADDR3 + 0x2f]]
 # POSTCHECK: DW_TAG_formal_parameter [9]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000026
-# POSTCHECK-NEXT: [0x[[#ADDR1]], 0x[[#ADDR4]]
+# POSTCHECK-NEXT: [0x[[#ADDR2]], 0x[[#ADDR2 + 0x27]]
 # POSTCHECK-NEXT: [0x[[#ADDR4]], 0x[[#ADDR4 + 0x2a]]
 # POSTCHECK: DW_TAG_variable
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x2) loclist = 0x00000034
-# POSTCHECK-NEXT: [0x[[#ADDR5]], 0x[[#ADDR6]]
+# POSTCHECK-NEXT: [0x[[#ADDR5]], 0x[[#ADDR5 + 0x6]]
 # POSTCHECK-NEXT: [0x[[#ADDR6]], 0x[[#ADDR6 + 0x40]]
 # POSTCHECK: DW_TAG_inlined_subroutine [12]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
-# POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x3) rangelist =  0x0000002b
-# POSTCHECK-NEXT: [0x[[#ADDR7]], 0x[[#ADDR6]]
-# POSTCHECK-NEXT: [0x[[#ADDR8]], 0x[[#ADDR8 + 0x6]]
+# POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x3) rangelist =  0x0000002d
+# POSTCHECK-NEXT: [0x[[#ADDR7]], 0x[[#ADDR7 + 0x4]]
+# POSTCHECK-NEXT: [0x[[#ADDR7 + 0x10]], 0x[[#ADDR7 + 0x16]]
 
 # helper0.cpp
 # POSTCHECK: version = 0x0004
 # POSTCHECK: DW_TAG_compile_unit
 # POSTCHECK-NEXT: DW_AT_producer
 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name
 # POSTCHECK-NEXT: DW_AT_stmt_list

bolt/test/X86/dwarf5-locexpr-addrx.s

 # PRECHECK: DW_TAG_variable
 # PRECHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x0)
 # PRECHECK: DW_TAG_variable
 # PRECHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x1)
 # PRECHECK-EMPTY:
 
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_TAG_variable
-# POSTCHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x3)
+# POSTCHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x2)
 # POSTCHECK-EMPTY:
 # POSTCHECK: DW_TAG_variable
-# POSTCHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x4)
+# POSTCHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x3)
 # POSTCHECK-EMPTY:
 
 # clang++ main.cpp -g -O2
 # void use(int * x, int * y) {
 # *x += 4;
 # *y -= 2;
 # }
 #

bolt/test/X86/dwarf5-loclist-offset-form.test

 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR6:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR7:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR8:]]
 
 # POSTCHECK: DW_TAG_compile_unit
 # POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x0000000c)
 # POSTCHECK: DW_TAG_variable [5]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
-# POSTCHECK-NEXT: [0x[[#ADDR1]]
-# POSTCHECK-SAME: 0x[[#ADDR1 + 9]]
+# POSTCHECK-NEXT: [0x[[#ADDR2]]
+# POSTCHECK-SAME: 0x[[#ADDR2 + 9]]
 # POSTCHECK-NEXT: [0x[[#ADDR3]]
 # POSTCHECK-SAME: 0x[[#ADDR3 + 6]]
 # POSTCHECK: DW_TAG_variable [5]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1)
 # POSTCHECK-NEXT: [0x[[#ADDR3]]
 # POSTCHECK-SAME: 0x[[#ADDR3 + 2]]
 
 # POSTCHECK: DW_TAG_compile_unit
 # POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x00000043)
 # POSTCHECK: DW_TAG_variable [11]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
-# POSTCHECK-NEXT: [0x[[#ADDR5]]
-# POSTCHECK-SAME: 0x[[#ADDR5 + 3]]
+# POSTCHECK-NEXT: [0x[[#ADDR7]]
+# POSTCHECK-SAME: 0x[[#ADDR7 + 3]]
 # POSTCHECK-NEXT: [0x[[#ADDR8]]
 # POSTCHECK-SAME: 0x[[#ADDR8 + 1]]

bolt/test/X86/dwarf5-multiple-dw-op-addrx-locexpr.s

 # PRECHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x0, DW_OP_piece 0x4, DW_OP_addrx 0x1, DW_OP_piece 0x4)
 
 
 # CHECK: DW_TAG_variable
 # CHECK: DW_AT_name [DW_FORM_strx1]
 # CHECK: DW_AT_type [DW_FORM_ref4]
 # CHECK: DW_AT_decl_file [DW_FORM_data1]
 # CHECK: DW_AT_decl_line [DW_FORM_data1]
-# CHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x4, DW_OP_piece 0x4, DW_OP_addrx 0x5, DW_OP_piece 0x4)
+# CHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x2, DW_OP_piece 0x4, DW_OP_addrx 0x3, DW_OP_piece 0x4)
 
 # This test checks that we update DW_AT_location [DW_FORM_exprloc] with multiple DW_OP_addrx.
 
 # struct pair {int i; int j; };
 # static pair p;
 # int load() {
 #     return p.i + p.j;
 # }

bolt/test/X86/dwarf5-split-dwarf4-monolithic.test

 # POSTCHECK-DWO-MAIN-NEXT: DW_LLE_startx_length   (0x0000000000000004, 0x000000000000002a): DW_OP_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value)
 # POSTCHECK-DWO-MAIN: DW_TAG_variable [10]
 # POSTCHECK-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x2) loclist = 0x00000034:
 # POSTCHECK-DWO-MAIN-NEXT: DW_LLE_startx_length   (0x0000000000000005, 0x0000000000000006): DW_OP_reg5 RDI
 # POSTCHECK-DWO-MAIN-NEXT: DW_LLE_startx_length   (0x0000000000000006, 0x0000000000000040): DW_OP_reg14 R14)
 # POSTCHECK-DWO-MAIN: DW_TAG_inlined_subroutine [12]
 # POSTCHECK-DWO-MAIN-NEXT: DW_AT_abstract_origin [DW_FORM_ref4]
 # POSTCHECK-DWO-MAIN-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x2) rangelist = 0x00000020
-# BOLT uses DW_RLE_startx_length encoding. Wit this encoding llvm-dwarfdump tries to lookup the actual address.
-# Since .debug_addr is in the binary low_pc is set to 0.
-# POSTCHECK-DWO-MAIN-NEXT: [0x0000000000000000, 0x0000000000000004)
-# POSTCHECK-DWO-MAIN-NEXT: [0x0000000000000000, 0x0000000000000006))
+# Encded as a pair. So it's offset from base address.
+# POSTCHECK-DWO-MAIN-NEXT: [0x0000000000000007, 0x000000000000000b)
+# POSTCHECK-DWO-MAIN-NEXT: [0x0000000000000017, 0x000000000000001d))
 
 # POSTCHECK-DWO-HELPER1: version = 0x0005
 # POSTCHECK-DWO-HELPER1: DW_TAG_subprogram [7]
 # POSTCHECK-DWO-HELPER1-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000002) address
 # POSTCHECK-DWO-HELPER1-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0) rangelist = 0x00000014
 # POSTCHECK-DWO-HELPER1-NEXT: [0x0000000000000000, 0x0000000000000004))
 # POSTCHECK-DWO-HELPER1: DW_TAG_variable [9]
 # POSTCHECK-DWO-HELPER1-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0) loclist = 0x00000010:

bolt/test/X86/dwarf5-two-loclists.test

 # PRECHECK: DW_TAG_variable
 # PRECHECK: DW_TAG_variable
 # PRECHECK: DW_AT_location [DW_FORM_loclistx]
 # PRECHECK-SAME: indexed (0x0)
 # PRECHECK-SAME: loclist = 0x00000047
 
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
 # POSTCHECK-NEXT: 0x
+# POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
 # For second CU.
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDR3:]]
 # POSTCHECK-NEXT: 0x
 # POSTCHECK-NEXT: 0x
+# POSTCHECK-NEXT: 0x[[#%.16x,ADDR3:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR4:]]
 
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset] (0x0000000c)
 # POSTCHECK: DW_AT_rnglists_base [DW_FORM_sec_offset] (0x0000000c)
 # POSTCHECK-EMPTY
 # POSTCHECK: DW_TAG_variable
 # POSTCHECK: DW_AT_location [DW_FORM_loclistx]
 # POSTCHECK-SAME: indexed (0x0)
 # POSTCHECK-SAME: loclist = 0x00000014
 # POSTCHECK-NEXT: [0x[[#ADDR]]
 # POSTCHECK-SAME: 0x[[#ADDR + 6]]
 # POSTCHECK-NEXT: [0x[[#ADDR2]]
 # POSTCHECK-SAME: 0x[[#ADDR2 + 6]]
 # POSTCHECK: DW_TAG_variable
 # POSTCHECK: DW_AT_location [DW_FORM_loclistx]
 # POSTCHECK-SAME: indexed (0x1)
 # POSTCHECK-SAME: loclist = 0x00000028
 # POSTCHECK-NEXT: [0x[[#ADDR2]]
 # POSTCHECK-SAME: 0x[[#ADDR2 + 2]]
 
 # Checking second CU
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset] (0x00000043)
-# POSTCHECK: DW_AT_rnglists_base [DW_FORM_sec_offset] (0x00000033)
+# POSTCHECK: DW_AT_rnglists_base [DW_FORM_sec_offset] (0x00000035)
 # POSTCHECK-EMPTY:
 # POSTCHECK: DW_TAG_variable
 # POSTCHECK: DW_TAG_variable
 # POSTCHECK: DW_AT_location [DW_FORM_loclistx]
 # POSTCHECK-SAME: indexed (0x0)
 # POSTCHECK-SAME: loclist = 0x00000047
 # POSTCHECK-NEXT: [0x[[#ADDR3]]
 # POSTCHECK-SAME: 0x[[#ADDR3 + 3]]
 # POSTCHECK-NEXT: [0x[[#ADDR4]]
 # POSTCHECK-SAME: 0x[[#ADDR4 + 1]]

bolt/test/X86/dwarf5-two-rnglists.test

 
 # PRECHECK: DW_TAG_inlined_subroutine
 # PRECHECK-NEXT: DW_AT_abstract_origin
 # PRECHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]
 # PRECHECK-NEXT: DW_AT_high_pc [DW_FORM_data4] (0x00000003)
 
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDR1:]]
 # POSTCHECK-NEXT: 0x
+# POSTCHECK-NEXT: 0x[[#%.16x,ADDR1:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
 # For second CU.
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR3:]]
+# POSTCHECK-NEXT: 0x
+# POSTCHECK-NEXT: 0x
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR4:]]
 
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: (indexed (0x0)
 # POSTCHECK-SAME: rangelist = 0x00000018
 # POSTCHECK-NEXT: [
 # POSTCHECK-SAME: 0x[[#ADDR]]
 # POSTCHECK-SAME: 0x[[#ADDR + 7]]
 # POSTCHECK-NEXT: [
 # POSTCHECK-SAME: 0x[[#ADDR1]]
 # POSTCHECK-SAME: 0x[[#ADDR1 + 12]]
 # POSTCHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]  (0x00000008)
 # POSTCHECK-NEXT: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x0000000c)
 # POSTCHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x0000000c)
 # POSTCHECK-EMPTY
 # POSTCHECK: DW_TAG_subprogram
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]
-# POSTCHECK-SAME: indexed (00000002)
+# POSTCHECK-SAME: indexed (00000001)
 # POSTCHECK-SAME: address = 0x0000000000000000
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: indexed (0x1)
-# POSTCHECK-SAME: rangelist = 0x0000001f
+# POSTCHECK-SAME: rangelist = 0x00000021
 # POSTCHECK-NEXT: [0x[[#ADDR]], 0x[[#ADDR + 7]])
 
 # POSTCHECK: DW_TAG_subprogram
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]
-# POSTCHECK-SAME: indexed (00000002)
+# POSTCHECK-SAME: indexed (00000001)
 # POSTCHECK-SAME: address = 0x0000000000000000
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: indexed (0x2)
-# POSTCHECK-SAME: rangelist = 0x00000023
+# POSTCHECK-SAME: rangelist = 0x00000025
 # POSTCHECK-NEXT: [0x[[#ADDR1]], 0x[[#ADDR1 + 12]])
 
 # Checking second CU
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: (indexed (0x0)
-# POSTCHECK-SAME: rangelist = 0x00000043
+# POSTCHECK-SAME: rangelist = 0x00000045
 # POSTCHECK-NEXT: [0x[[#ADDR3]], 0x[[#ADDR3 + 4]])
 # POSTCHECK-NEXT: [0x[[#ADDR4]], 0x[[#ADDR4 + 4]])
 # POSTCHECK-NEXT: DW_AT_addr_base [DW_FORM_sec_offset]  (0x00000030)
 # POSTCHECK-NEXT: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x00000043)
-# POSTCHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000033)
+# POSTCHECK-NEXT: DW_AT_rnglists_base [DW_FORM_sec_offset]  (0x00000035)
 # POSTCHECK-EMPTY
 
 # POSTCHECK: DW_TAG_subprogram
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]
-# POSTCHECK-SAME: indexed (00000002)
+# POSTCHECK-SAME: indexed (00000001)
 # POSTCHECK-SAME: address = 0x0000000000000000
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: indexed (0x1)
-# POSTCHECK-SAME: rangelist = 0x0000004a
+# POSTCHECK-SAME: rangelist = 0x0000004e
 # POSTCHECK-NEXT: [0x[[#ADDR3]], 0x[[#ADDR3 + 4]])
 # POSTCHECK: DW_TAG_subprogram
 # POSTCHECK: DW_TAG_subprogram
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]
-# POSTCHECK-SAME: indexed (00000002)
+# POSTCHECK-SAME: indexed (00000001)
 # POSTCHECK-SAME: address = 0x0000000000000000
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: indexed (0x2)
-# POSTCHECK-SAME: rangelist = 0x0000004e
+# POSTCHECK-SAME: rangelist = 0x00000052
 # POSTCHECK-NEXT: [0x[[#ADDR4]], 0x[[#ADDR4 + 4]])
 
 # POSTCHECK: DW_TAG_inlined_subroutine
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]
-# POSTCHECK-SAME: indexed (00000002)
+# POSTCHECK-SAME: indexed (00000001)
 # POSTCHECK-SAME: address = 0x0000000000000000
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: indexed (0x3)
-# POSTCHECK-SAME: rangelist = 0x00000052
+# POSTCHECK-SAME: rangelist = 0x00000056
 # POSTCHECK-NEXT: [0x[[#ADDR4]], 0x[[#ADDR4 + 3]])