[BOLT][DWARF] Change loclist encoding to use base_addrx

[ayermolo]

Summary

Doing the same thing as for rangelists. Changing loclists to use base_addrx, it
slightly increases .debug_loclists, but reduces .debug_addr section.

section	clang-16.bolt.base	clang-16.bolt	raw	%
debug_loclists	198208	203398	5190	102%
.debug_addr	14415808	14351448	-64360	99.5%

[maksfb]

s/[bolt]/[BOLT]/

LGTM with nits.

bolt/lib/Core/DebugData.cpp

215

s/ListEntries/ListEntry/ ?

219

[ayermolo]

fixed nits

bolt/lib/Core/DebugData.cpp

 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/SHA1.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
+#include <functional>
 #include <limits>
 #include <unordered_map>
 #include <vector>
 
 #define DEBUG_TYPE "bolt-debug-info"
 
 namespace opts {
 extern llvm::cl::opt<unsigned> Verbosity;
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;
 }
 
-static bool emitWithBase(raw_ostream &OS,
-                         const DebugAddressRangesVector &Ranges,
+struct OffsetEntry {
+  uint32_t Index;
+  uint32_t StartOffset;
+  uint32_t EndOffset;
+};
+template <typename DebugVector, typename ListEntry, typename DebugAddressEntry>
+static bool emitWithBase(raw_ostream &OS, const DebugVector &Entries,
                          DebugAddrWriter &AddrWriter, DWARFUnit &CU,
-                         uint32_t &Index) {
-  if (Ranges.size() < 2)
+                         uint32_t &Index, const ListEntry BaseAddressx,
+                         const ListEntry OffsetPair, const ListEntry EndOfList,
+                         const std::function<void(uint32_t)> &Func) {
+  if (Entries.size() < 2)
     return false;
-  uint64_t Base = Ranges[Index].LowPC;
-  std::vector<std::pair<uint16_t, uint16_t>> RangeOffsets;
+  uint64_t Base = Entries[Index].LowPC;
+  std::vector<OffsetEntry> Offsets;
   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;
+  while (Index < Entries.size()) {
+    const DebugAddressEntry &Entry = Entries[Index];
+    if (Entry.LowPC == 0)
+      break;
+    assert(Base <= Entry.LowPC && "Entry base is higher than low PC");
+    uint32_t StartOffset = Entry.LowPC - Base;
+    uint32_t EndOffset = Entry.HighPC - Base;
     if (encodeULEB128(EndOffset, TempBuffer) > 2)
       break;
-    RangeOffsets.emplace_back(StartOffset, EndOffset);
+    Offsets.push_back({Index, StartOffset, EndOffset});
     ++Index;
   }
 
-  if (RangeOffsets.size() < 2) {
-    Index -= RangeOffsets.size();
+  if (Offsets.size() < 2) {
+    Index -= Offsets.size();
     return false;
   }
 
-  support::endian::write(OS, static_cast<uint8_t>(dwarf::DW_RLE_base_addressx),
+  support::endian::write(OS, static_cast<uint8_t>(BaseAddressx),
                          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),
+  for (auto &OffsetEntry : Offsets) {
+    support::endian::write(OS, static_cast<uint8_t>(OffsetPair),
                            support::little);
-    encodeULEB128(Offset.first, OS);
-    encodeULEB128(Offset.second, OS);
+    encodeULEB128(OffsetEntry.StartOffset, OS);
+    encodeULEB128(OffsetEntry.EndOffset, OS);
+    Func(OffsetEntry.Index);
   }
-  support::endian::write(OS, static_cast<uint8_t>(dwarf::DW_RLE_end_of_list),
-                         support::little);
+  support::endian::write(OS, static_cast<uint8_t>(EndOfList), support::little);
   return true;
 }
 
 uint64_t
 DebugRangeListsSectionWriter::addRanges(DebugAddressRangesVector &Ranges) {
   std::lock_guard<std::mutex> Lock(WriterMutex);
 
   RangeEntries.push_back(CurrentOffset);
   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))
+    if (emitWithBase<DebugAddressRangesVector, dwarf::RnglistEntries,
+                     DebugAddressRange>(
+            *CUBodyStream, Ranges, *AddrWriter, *CU, I,
+            dwarf::DW_RLE_base_addressx, dwarf::DW_RLE_offset_pair,
+            dwarf::DW_RLE_end_of_list, [](uint32_t Index) -> void {}))
       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;
static void writeDWARF5LocList(
   RelativeLocListOffsets.push_back(LocBodyBuffer.size());
   ++NumberOfEntries;
   if (LocList.empty()) {
     writeEmptyListDwarf5(LocBodyStream);
     return;
   }
 
   std::vector<uint64_t> OffsetsArray;
-  for (const DebugLocationEntry &Entry : LocList) {
+  bool WrittenStartxLength = false;
+  auto writeExpression = [&](uint32_t Index) -> void {
+    const DebugLocationEntry &Entry = LocList[Index];
+    encodeULEB128(Entry.Expr.size(), LocBodyStream);
+    LocBodyStream << StringRef(
+        reinterpret_cast<const char *>(Entry.Expr.data()), Entry.Expr.size());
+  };
+  for (unsigned I = 0; I < LocList.size();) {
+    WrittenStartxLength = false;
+    if (emitWithBase<DebugLocationsVector, dwarf::LoclistEntries,
+                     DebugLocationEntry>(
+            LocBodyStream, LocList, AddrWriter, CU, I,
+            dwarf::DW_LLE_base_addressx, dwarf::DW_LLE_offset_pair,
+            dwarf::DW_LLE_end_of_list, writeExpression))
+      continue;
+
+    const DebugLocationEntry &Entry = LocList[I];
     support::endian::write(LocBodyStream,
                            static_cast<uint8_t>(dwarf::DW_LLE_startx_length),
                            support::little);
     const uint32_t Index = AddrWriter.getIndexFromAddress(Entry.LowPC, CU);
     encodeULEB128(Index, LocBodyStream);
     encodeULEB128(Entry.HighPC - Entry.LowPC, LocBodyStream);
-    encodeULEB128(Entry.Expr.size(), LocBodyStream);
-    LocBodyStream << StringRef(
-        reinterpret_cast<const char *>(Entry.Expr.data()), Entry.Expr.size());
+    writeExpression(I);
+    ++I;
+    WrittenStartxLength = true;
   }
+
+  if (WrittenStartxLength)
     support::endian::write(LocBodyStream,
                            static_cast<uint8_t>(dwarf::DW_LLE_end_of_list),
                            support::little);
 }
 
 void DebugLoclistWriter::addList(AttrInfo &AttrVal,
                                  DebugLocationsVector &LocList,
                                  DebugInfoBinaryPatcher &DebugInfoPatcher,
                                  DebugAbbrevWriter &AbbrevWriter) {
   if (DwarfVersion < 5)
     writeLegacyLocList(AttrVal, LocList, DebugInfoPatcher, *AddrWriter,

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

 # PRECHECK: DW_AT_location [DW_FORM_loclistx]
 # PRECHECK-SAME: indexed (0x0)
 # PRECHECK-SAME: loclist = 0x00000010
 
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x
 # 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
 # POSTCHECK-NEXT: [0x[[#ADDR]]
-# POSTCHECK-SAME: 0x[[#ADDR + 3]]
-# POSTCHECK-NEXT: [0x[[#ADDR2]]
-# POSTCHECK-SAME: 0x[[#ADDR2 + 1]]
+# POSTCHECK-SAME: 0x[[#ADDR + 0x3]]
+# POSTCHECK-NEXT: [0x[[#ADDR + 0x3]]
+# POSTCHECK-SAME: 0x[[#ADDR + 0x4]]
 
 # clang++ main.cpp -g -O2 -S
 # void use(int * x) {
 #   *x += 4;
 # }
 #
 # int  main(int argc, char *argv[]) {
 #   int x = argc;

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

 ; PRE-BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000024:
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_base_addressx   (0x0000000000000002)
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000010, 0x000000000000001c)
 ; PRE-BOLT-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x000000000000001c, 0x0000000000000029)
 
 ; BOLT-DWO-MAIN: version = 0x0005
 ; BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]
 ; BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0) loclist = 0x00000014:
-; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length     (0x0000000000000004, 0x0000000000000014)
-; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length     (0x0000000000000005, 0x0000000000000005)
+; BOLT-DWO-MAIN-NEXT: DW_LLE_base_addressx   (0x0000000000000004)
+; BOLT-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000014)
+; BOLT-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000014, 0x0000000000000019)
 ; BOLT-DWO-MAIN: DW_TAG_formal_parameter [10]
-; BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000022:
-; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length     (0x0000000000000004, 0x000000000000000c)
-; BOLT-DWO-MAIN-NEXT: DW_LLE_startx_length     (0x0000000000000006, 0x000000000000000d)
+; BOLT-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000024:
+; BOLT-DWO-MAIN-NEXT: DW_LLE_base_addressx   (0x0000000000000004)
+; BOLT-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x000000000000000c)
+; BOLT-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x000000000000000c, 0x0000000000000019)
 
 
 ; PRE-BOLT-DWO-HELPER: version = 0x0005
 ; PRE-BOLT-DWO-HELPER: DW_TAG_formal_parameter [5]
 ; PRE-BOLT-DWO-HELPER-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0) loclist = 0x00000010:
 ; PRE-BOLT-DWO-HELPER-NEXT: DW_LLE_base_addressx   (0x0000000000000002)
 ; PRE-BOLT-DWO-HELPER-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000008)
 ; PRE-BOLT-DWO-HELPER-NEXT: DW_LLE_offset_pair     (0x0000000000000008, 0x000000000000001e)
 
 ; BOLT-DWO-HELPER: version = 0x0005
 ; BOLT-DWO-HELPER: DW_TAG_formal_parameter [5]
 ; BOLT-DWO-HELPER-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0) loclist = 0x00000010:
-; BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length   (0x0000000000000002, 0x0000000000000008)
-; BOLT-DWO-HELPER-NEXT: DW_LLE_startx_length   (0x0000000000000004, 0x0000000000000016)
+; BOLT-DWO-HELPER-NEXT: DW_LLE_base_addressx   (0x0000000000000002)
+; BOLT-DWO-HELPER-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000008)
+; BOLT-DWO-HELPER-NEXT: DW_LLE_offset_pair     (0x0000000000000008, 0x000000000000001e)

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

 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR1:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR3:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR4:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR5:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR6:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR7:]]
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDR8:]]
 
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDRB:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDRB1:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDRB2:]]
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDRB3:]]
 
 
 # main.cpp
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_TAG_compile_unit [1] *
 # POSTCHECK-NEXT: DW_AT_producer [DW_FORM_strx1]  (indexed (00000000)
 # POSTCHECK-NEXT: DW_AT_language
 # POSTCHECK-NEXT: DW_AT_name

 # POSTCHECK-NEXT: [0x[[#ADDR]], 0x[[#ADDR + 0x7]]
 # POSTCHECK: DW_TAG_subprogram [8]
 # 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[[#ADDR2]], 0x[[#ADDR2 + 0x22]]
-# POSTCHECK-NEXT: [0x[[#ADDR3]], 0x[[#ADDR3 + 0x2f]]
+# POSTCHECK-NEXT: [0x[[#ADDR2 + 0x22]], 0x[[#ADDR2 + 0x51]]
 # POSTCHECK: DW_TAG_formal_parameter [9]
-# POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000026
+# POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000028
 # POSTCHECK-NEXT: [0x[[#ADDR2]], 0x[[#ADDR2 + 0x27]]
-# POSTCHECK-NEXT: [0x[[#ADDR4]], 0x[[#ADDR4 + 0x2a]]
+# POSTCHECK-NEXT: [0x[[#ADDR2 + 0x27]], 0x[[#ADDR2 + 0x51]]
 # POSTCHECK: DW_TAG_variable
-# POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x2) loclist = 0x00000034
-# POSTCHECK-NEXT: [0x[[#ADDR5]], 0x[[#ADDR5 + 0x6]]
-# POSTCHECK-NEXT: [0x[[#ADDR6]], 0x[[#ADDR6 + 0x40]]
+# POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x2) loclist = 0x00000038
+# POSTCHECK-NEXT: [0x[[#ADDR3]], 0x[[#ADDR3 + 0x6]]
+# POSTCHECK-NEXT: [0x[[#ADDR3 + 0x6]], 0x[[#ADDR3 + 0x46]]
 # POSTCHECK: DW_TAG_inlined_subroutine [12]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # 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]]
+# POSTCHECK-NEXT: [0x[[#ADDR4]], 0x[[#ADDR4 + 0x4]]
+# POSTCHECK-NEXT: [0x[[#ADDR4 + 0x10]], 0x[[#ADDR4 + 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

 # POSTCHECK: DW_AT_location [DW_FORM_exprloc]  (DW_OP_addrx 0x2)
 # POSTCHECK: DW_TAG_subprogram [7]
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1)
 # POSTCHECK-NEXT: [0x[[#ADDRB]], 0x[[#ADDRB + 0x4]]
 # POSTCHECK: DW_TAG_variable [9]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
 # POSTCHECK-NEXT: [0x[[#ADDRB]], 0x[[#ADDRB + 0x3]]
-# POSTCHECK-NEXT: [0x[[#ADDRB3]], 0x[[#ADDRB3 + 0x1]]
+# POSTCHECK-NEXT: [0x[[#ADDRB + 0x3]], 0x[[#ADDRB + 0x4]]
 # POSTCHECK: DW_TAG_inlined_subroutine [10]
 # POSTCHECK-NEXT: DW_AT_abstract_origin
 # POSTCHECK-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001)
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x2) rangelist
 # POSTCHECK-NEXT: [0x[[#ADDRB]], 0x[[#ADDRB + 0x3]]
 
 # helper2.cpp
 # POSTCHECK: version = 0x0004

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

 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR3:]]
 # For second CU.
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR4:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR5:]]
 # 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[[#ADDR2]]
-# POSTCHECK-SAME: 0x[[#ADDR2 + 9]]
-# POSTCHECK-NEXT: [0x[[#ADDR3]]
-# POSTCHECK-SAME: 0x[[#ADDR3 + 6]]
+# POSTCHECK-SAME: 0x[[#ADDR2 + 0x9]]
+# POSTCHECK-NEXT: [0x[[#ADDR2 + 0x9]]
+# POSTCHECK-SAME: 0x[[#ADDR2 + 0xf]]
 # 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_AT_loclists_base [DW_FORM_sec_offset]  (0x00000045)
 # POSTCHECK: DW_TAG_variable [11]
 # POSTCHECK-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0)
 # POSTCHECK-NEXT: [0x[[#ADDR7]]
-# POSTCHECK-SAME: 0x[[#ADDR7 + 3]]
-# POSTCHECK-NEXT: [0x[[#ADDR8]]
-# POSTCHECK-SAME: 0x[[#ADDR8 + 1]]
+# POSTCHECK-SAME: 0x[[#ADDR7 + 0x3]]
+# POSTCHECK-NEXT: [0x[[#ADDR7 + 0x3]]
+# POSTCHECK-SAME: 0x[[#ADDR7 + 0x4]]

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

 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR1:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR3:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR4:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR5:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR6:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR7:]]
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDR8:]]
 
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDRB:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDRB1:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDRB2:]]
-# POSTCHECK-NEXT: 0x[[#%.16x,ADDRB3:]]
 
 
 # main.cpp
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_AT_stmt_list [DW_FORM_sec_offset]  (0x00000000)
 # POSTCHECK-NEXT: DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
 # POSTCHECK-NEXT: DW_AT_comp_dir [DW_FORM_strx1]  (indexed (00000000) string = ".")
 # POSTCHECK-NEXT: DW_AT_GNU_pubnames [DW_FORM_flag_present] (true)

 # POSTCHECK-DWO-MAIN-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x0) rangelist = 0x00000018
 # POSTCHECK-DWO-MAIN-NEXT: [0x0000000000000000, 0x0000000000000007))
 # POSTCHECK-DWO-MAIN: DW_TAG_subprogram [8]
 # POSTCHECK-DWO-MAIN-NEXT: DW_AT_low_pc [DW_FORM_addrx]  (indexed (00000001)
 # POSTCHECK-DWO-MAIN-NEXT: DW_AT_ranges [DW_FORM_rnglistx] (indexed (0x1) rangelist = 0x0000001c
 # POSTCHECK-DWO-MAIN-NEXT: [0x0000000000000000, 0x0000000000000051))
 # POSTCHECK-DWO-MAIN: DW_TAG_formal_parameter [9]
 # POSTCHECK-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x0) loclist = 0x00000018:
-# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_startx_length   (0x0000000000000002, 0x0000000000000022): DW_OP_reg5 RDI
-# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_startx_length   (0x0000000000000003, 0x000000000000002f): DW_OP_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value)
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_base_addressx   (0x0000000000000002)
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000022): DW_OP_reg5 RDI
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000022, 0x0000000000000051): DW_OP_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value)
 # POSTCHECK-DWO-MAIN: DW_TAG_formal_parameter [9]
-# POSTCHECK-DWO-MAIN-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000026:
-# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_startx_length   (0x0000000000000002, 0x0000000000000027): DW_OP_reg4 RSI
-# 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-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x1) loclist = 0x00000028:
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_base_addressx   (0x0000000000000002)
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000027): DW_OP_reg4 RSI
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000027, 0x0000000000000051): 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-NEXT: DW_AT_location [DW_FORM_loclistx] (indexed (0x2) loclist = 0x00000038:
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_base_addressx   (0x0000000000000003)
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000006): DW_OP_reg5 RDI
+# POSTCHECK-DWO-MAIN-NEXT: DW_LLE_offset_pair     (0x0000000000000006, 0x0000000000000046): 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
 # 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-MAIN-NEXT: [0x0000000000000004, 0x0000000000000008)
+# POSTCHECK-DWO-MAIN-NEXT: [0x0000000000000014, 0x000000000000001a))
 
 # 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:
-# POSTCHECK-DWO-HELPER1-NEXT: DW_LLE_startx_length   (0x0000000000000001, 0x0000000000000003): DW_OP_reg5 RDI
-# POSTCHECK-DWO-HELPER1-NEXT: DW_LLE_startx_length   (0x0000000000000003, 0x0000000000000001): DW_OP_reg0 RAX)
+# POSTCHECK-DWO-HELPER1-NEXT: DW_LLE_base_addressx   (0x0000000000000001)
+# POSTCHECK-DWO-HELPER1-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000003): DW_OP_reg5 RDI
+# POSTCHECK-DWO-HELPER1-NEXT: DW_LLE_offset_pair     (0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX)
 # POSTCHECK-DWO-HELPER1: DW_TAG_inlined_subroutine [10]
 # POSTCHECK-DWO-HELPER1-NEXT: DW_AT_abstract_origin
 # 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 (0x1) rangelist = 0x00000018
 # POSTCHECK-DWO-HELPER1-NEXT: [0x0000000000000000, 0x0000000000000003))
 
 # Checking debug line.
 

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

 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR:]]
 # POSTCHECK-NEXT: 0x[[#%.16x,ADDR2:]]
 # For second CU.
 # POSTCHECK: Addrs: [
 # POSTCHECK-NEXT: 0x
 # 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-SAME: 0x[[#ADDR + 0x6]]
+# POSTCHECK-NEXT: [0x[[#ADDR + 0x6]]
+# POSTCHECK-SAME: 0x[[#ADDR + 0xc]]
 # POSTCHECK: DW_TAG_variable
 # POSTCHECK: DW_AT_location [DW_FORM_loclistx]
 # POSTCHECK-SAME: indexed (0x1)
-# POSTCHECK-SAME: loclist = 0x00000028
+# POSTCHECK-SAME: loclist = 0x0000002a
 # POSTCHECK-NEXT: [0x[[#ADDR2]]
-# POSTCHECK-SAME: 0x[[#ADDR2 + 2]]
+# POSTCHECK-SAME: 0x[[#ADDR2 + 0x2]]
 
 # Checking second CU
 # POSTCHECK: version = 0x0005
-# POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset] (0x00000043)
+# POSTCHECK: DW_AT_loclists_base [DW_FORM_sec_offset] (0x00000045)
 # 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-SAME: loclist = 0x00000049
 # POSTCHECK-NEXT: [0x[[#ADDR3]]
-# POSTCHECK-SAME: 0x[[#ADDR3 + 3]]
-# POSTCHECK-NEXT: [0x[[#ADDR4]]
-# POSTCHECK-SAME: 0x[[#ADDR4 + 1]]
+# POSTCHECK-SAME: 0x[[#ADDR3 + 0x3]]
+# POSTCHECK-NEXT: [0x[[#ADDR3 + 0x3]]
+# POSTCHECK-SAME: 0x[[#ADDR3  + 0x4]]

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

 # Checking second CU
 # POSTCHECK: version = 0x0005
 # POSTCHECK: DW_AT_ranges [DW_FORM_rnglistx]
 # POSTCHECK-SAME: (indexed (0x0)
 # 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_loclists_base [DW_FORM_sec_offset]  (0x00000045)
 # 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 (00000001)
 # POSTCHECK-SAME: address = 0x0000000000000000
 # POSTCHECK-NEXT: DW_AT_ranges [DW_FORM_rnglistx]