Emit DW_LLE_base_address + DW_LLE_offset_pairs instead of DW_LLE_start_length in debug_loclists section

[rastogishubham]

Summary

This patch tries to reduce the size of the debug_loclist section by replacing the DW_LLE_start_length opcodes currently emitted by dsymutil in favor of using DW_LLE_base_address + DW_LLE_offset_pair instead.

The DW_LLE_start_length is one AddressSize followed by a ULEB per entry, whereas, the DW_LLE_base_address + DW_LLE_offset_pair will use one AddressSize for the base address, and then the DW_LLE_offset_pair is a pair of ULEBs. This will be more efficient where a loclist fragment has many entries.

I tried to see the size of the clang.dSYM and it went from 12.23 MB to 10.46 MB in size.

[aprantl]

Nice!

I tried to see the size of the clang.dSYM and it went from 12.23 MB to 10.46 MB in size.

Is that the size of the loclists section inside clang.dSYM?

llvm/lib/DWARFLinker/DWARFStreamer.cpp

644

Don't we need to subtract the base address here?

[aprantl]

llvm/include/llvm/DebugInfo/DWARF/DWARFLocationExpression.h

48

Maybe add an initializer here?

uint64_t BaseAddress = 0;

llvm/lib/DWARFLinker/DWARFLinker.cpp

1975

and then convert this to an if (Unit.getOrigUnit().getVersion() >= 5 && FirstLocation.Range)

[rastogishubham]

Addressed Adrians comments:

1. Added a default initializer for the BaseAddress in DWARFLocationExpressionsFragment

2. Changed the ternery to an if statement when calculating the BaseAddress for a loclist fragment

llvm/lib/DWARFLinker/DWARFStreamer.cpp

644

No, we already adjusted the address on line 1984 - line 1989, in DWARFLinker.cpp

uint64_t LowPCVal = CurExpression.Range->LowPC +
                    CurLocAttr.RelocAdjustment -
                    LinkedLocationExpressionsFrag.BaseAddress;
assert(LowPCVal >= 0 && "Low PC value should not be negative!");
LinkedExpression.Range = {
    LowPCVal, CurExpression.Range->HighPC + CurLocAttr.RelocAdjustment -
                  LinkedLocationExpressionsFrag.BaseAddress};

[JDevlieghere]

llvm/lib/DWARFLinker/DWARFLinker.cpp

1974

Is OriginalLocations guaranteed to be non empty? Also I would use OriginalLocations->front() here.

1988

nit: Let's drop the exclamation mark: other asserts in this file either use a period or no punctuation at all.

[avl]

llvm/include/llvm/DebugInfo/DWARF/DWARFLocationExpression.h

47

probably not name it "LinkedLocationExpression" as linked is dsymutil term. DebugInfo/DWARF does not name addresses linked or relocated. maybe LinkedLocationExpression -> LocationExpressions or LinkedLocationExpression -> LocationExpressionsVector.

llvm/lib/DWARFLinker/DWARFLinker.cpp

1988

uint64_t could not be negative. probably:

uint64_t LowPCVal = CurExpression.Range->LowPC + CurLocAttr.RelocAdjustment - LinkedLocationExpressionsFrag.BaseAddress;
assert(LowPCVal <= CurExpression.Range->LowPC + CurLocAttr.RelocAdjustment && "Address overflow");

llvm/lib/DWARFLinker/DWARFStreamer.cpp

614

may be we can do all calculations inside DwarfStreamer::emitDwarfDebugLocListsTableFragment ? i.e. do not create new structure DWARFLocationExpressionsFragment, do not change DWARFLinker::generateUnitLocations, calculate and apply BaseAddress inside DwarfStreamer::emitDwarfDebugLocListsTableFragment ? Such approach allows to change output format not changing high level structures and makes overall patch smaller.

648

it looks like it should be emit_U_LEB128IntValue.

DW_LLE_offset_pair
This is a form of bounded location description entry that has two unsigned
LEB128 operands.

I think SLEB came from my original patch.

[rastogishubham]

Moved code to DWARFStreamer.cpp, makes the patch a lot smaller as calculated values do not have to be passed through

llvm/include/llvm/DebugInfo/DWARF/DWARFLocationExpression.h

47

We don't need this anymore, because your other comment about moving the calculations to DWARFStreamer makes sense

llvm/lib/DWARFLinker/DWARFStreamer.cpp

614

Yes, this is a fantastic observation, and I don't know why I didn't think of it!

[avl]

LGTM. Though, wait a couple of days for other reviewers, please.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

620

not necessary to do that way, but if you found this useful: It might be a bit simpler if BaseAddress would be std::optional<uint64_t>. Then we do not need BaseAddressEmitted flag. A bit shorter and no connected variables.

std::optional<uint64_t> BaseAddress;

if (!BaseAddress) {
  BaseAddress = LocExpression.Range->LowPC;
  ...
  MS->emitIntValue(*BaseAddress, AddressSize);
  ...
}

[rastogishubham]

Changed from using a bool flag to a std::optional

[JDevlieghere]

LGTM

llvm/include/llvm/DWARFLinker/DWARFLinker.h

virtual void emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
                                              MCSymbol *EndLabel) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) header.
   virtual MCSymbol *emitDwarfDebugLocListHeader(const CompileUnit &Unit) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) fragment.
   virtual void emitDwarfDebugLocListFragment(
       const CompileUnit &Unit,
-      const DWARFLocationExpressionsVector &LinkedLocationExpression,
+      const DWARFLocationExpressionsFragment &LinkedLocationExpressionsFrag,
       PatchLocation Patch) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) footer.
   virtual void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                            MCSymbol *EndLabel) = 0;
 
   /// Emit .debug_aranges entries for \p Unit
   virtual void

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

void emitDwarfDebugRangeListFooter(const CompileUnit &Unit,
                                      MCSymbol *EndLabel) override;
 
   /// Emit debug locations(.debug_loc, .debug_loclists) header.
   MCSymbol *emitDwarfDebugLocListHeader(const CompileUnit &Unit) override;
 
   /// Emit debug ranges(.debug_loc, .debug_loclists) fragment.
   void emitDwarfDebugLocListFragment(
       const CompileUnit &Unit,
-      const DWARFLocationExpressionsVector &LinkedLocationExpression,
+      const DWARFLocationExpressionsFragment &LinkedLocationExpressionsFrag,
       PatchLocation Patch) override;
 
   /// Emit debug ranges(.debug_loc, .debug_loclists) footer.
   void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                    MCSymbol *EndLabel) override;
 
   /// Emit .debug_aranges entries for \p Unit
   void emitDwarfDebugArangesTable(const CompileUnit &Unit,
private:
   void emitDwarfDebugLocTableFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
       PatchLocation Patch);
 
   /// Emit piece of .debug_loclists for \p LinkedRanges.
   void emitDwarfDebugLocListsTableFragment(
       const CompileUnit &Unit,
-      const DWARFLocationExpressionsVector &LinkedLocationExpression,
+      const DWARFLocationExpressionsFragment &LinkedLocationExpressionsFrag,
       PatchLocation Patch);
 
   /// \defgroup Line table emission
   /// @{
   void emitLineTablePrologue(const DWARFDebugLine::Prologue &P,
                              OffsetsStringPool &DebugStrPool,
                              OffsetsStringPool &DebugLineStrPool);
   void emitLineTableString(const DWARFDebugLine::Prologue &P,

llvm/include/llvm/DebugInfo/DWARF/DWARFLocationExpression.h

inline bool operator!=(const DWARFLocationExpression &L,
   return !(L == R);
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const DWARFLocationExpression &Loc);
 
 /// Represents a set of absolute location expressions.
 using DWARFLocationExpressionsVector = std::vector<DWARFLocationExpression>;
 
+struct DWARFLocationExpressionsFragment {
+  DWARFLocationExpressionsVector LinkedLocationExpression;
+  uint64_t BaseAddress = 0;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFLOCATIONEXPRESSION_H

llvm/lib/DWARFLinker/DWARFLinker.cpp

         Unit.getOrigUnit().findLoclistFromOffset(CurLocAttr.get());
 
     if (!OriginalLocations) {
       llvm::consumeError(OriginalLocations.takeError());
       reportWarning("Invalid location attribute ignored.", File);
       continue;
     }
 
-    DWARFLocationExpressionsVector LinkedLocationExpressions;
+    DWARFLocationExpressionsFragment LinkedLocationExpressionsFrag;
+    // Calculate value of the DW_LLE_base_address.
+    auto FirstLocation = (*OriginalLocations)[0];
+
+    if (Unit.getOrigUnit().getVersion() >= 5 && FirstLocation.Range)
+      LinkedLocationExpressionsFrag.BaseAddress =
+          FirstLocation.Range->LowPC + CurLocAttr.RelocAdjustment;
+
     for (DWARFLocationExpression &CurExpression : *OriginalLocations) {
       DWARFLocationExpression LinkedExpression;
 
       if (CurExpression.Range) {
         // Relocate address range.
+        uint64_t LowPCVal = CurExpression.Range->LowPC +
+                            CurLocAttr.RelocAdjustment -
+                            LinkedLocationExpressionsFrag.BaseAddress;
+        assert(LowPCVal >= 0 && "Low PC value should not be negative!");
         LinkedExpression.Range = {
-            CurExpression.Range->LowPC + CurLocAttr.RelocAdjustment,
-            CurExpression.Range->HighPC + CurLocAttr.RelocAdjustment};
+            LowPCVal, CurExpression.Range->HighPC + CurLocAttr.RelocAdjustment -
+                          LinkedLocationExpressionsFrag.BaseAddress};
       }
 
       // Clone expression.
       LinkedExpression.Expr.reserve(CurExpression.Expr.size());
       ExprHandler(CurExpression.Expr, LinkedExpression.Expr,
                   CurLocAttr.RelocAdjustment);
 
-      LinkedLocationExpressions.push_back(LinkedExpression);
+      LinkedLocationExpressionsFrag.LinkedLocationExpression.push_back(
+          LinkedExpression);
     }
 
     // Emit locations list table fragment corresponding to the CurLocAttr.
     TheDwarfEmitter->emitDwarfDebugLocListFragment(
-        Unit, LinkedLocationExpressions, CurLocAttr);
+        Unit, LinkedLocationExpressionsFrag, CurLocAttr);
   }
 
   // Emit locations list table footer.
   TheDwarfEmitter->emitDwarfDebugLocListFooter(Unit, EndLabel);
 }
 
 /// Insert the new line info sequence \p Seq into the current
 /// set of already linked line info \p Rows.

llvm/lib/DWARFLinker/DWARFStreamer.cpp

MCSymbol *DwarfStreamer::emitDwarfDebugLocListHeader(const CompileUnit &Unit) {
   LocListsSectionSize += sizeof(uint32_t);
 
   return EndLabel;
 }
 
 /// Emit debug locations(.debug_loc, .debug_loclists) fragment.
 void DwarfStreamer::emitDwarfDebugLocListFragment(
     const CompileUnit &Unit,
-    const DWARFLocationExpressionsVector &LinkedLocationExpression,
+    const DWARFLocationExpressionsFragment &LinkedLocationExpressionsFrag,
     PatchLocation Patch) {
   if (Unit.getOrigUnit().getVersion() < 5) {
-    emitDwarfDebugLocTableFragment(Unit, LinkedLocationExpression, Patch);
+    emitDwarfDebugLocTableFragment(
+        Unit, LinkedLocationExpressionsFrag.LinkedLocationExpression, Patch);
     return;
   }
 
-  emitDwarfDebugLocListsTableFragment(Unit, LinkedLocationExpression, Patch);
+  emitDwarfDebugLocListsTableFragment(Unit, LinkedLocationExpressionsFrag,
+                                      Patch);
 }
 
 /// Emit debug locations(.debug_loc, .debug_loclists) footer.
 void DwarfStreamer::emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                                 MCSymbol *EndLabel) {
   if (Unit.getOrigUnit().getVersion() < 5)
     return;
 
void DwarfStreamer::emitDwarfDebugLocTableFragment(
   // Add the terminator entry.
   MS->emitIntValue(0, AddressSize);
   MS->emitIntValue(0, AddressSize);
 
   LocSectionSize += AddressSize;
   LocSectionSize += AddressSize;
 }
 
-/// Emit piece of .debug_loclists for \p LinkedLocationExpression.
+/// Emit piece of .debug_loclists for \p LinkedLocationExpressionsFrag.
 void DwarfStreamer::emitDwarfDebugLocListsTableFragment(
     const CompileUnit &Unit,
-    const DWARFLocationExpressionsVector &LinkedLocationExpression,
+    const DWARFLocationExpressionsFragment &LinkedLocationExpressionsFrag,
     PatchLocation Patch) {
   Patch.set(LocListsSectionSize);
 
   // Make .debug_loclists the current section.
   MS->switchSection(MC->getObjectFileInfo()->getDwarfLoclistsSection());
 
-  unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
+  bool BaseAddressEmitted = false;
 
   for (const DWARFLocationExpression &LocExpression :
-       LinkedLocationExpression) {
+       LinkedLocationExpressionsFrag.LinkedLocationExpression) {
     if (LocExpression.Range) {
-      // Emit type of entry.
-      MS->emitInt8(dwarf::DW_LLE_start_length);
-      LocListsSectionSize += 1;
 
-      // Emit start address.
-      MS->emitIntValue(LocExpression.Range->LowPC, AddressSize);
+      if (!BaseAddressEmitted) {
+        // Emit base address.
+        MS->emitInt8(dwarf::DW_LLE_base_address);
+        LocListsSectionSize += 1;
+        unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
+        MS->emitIntValue(LinkedLocationExpressionsFrag.BaseAddress,
+                         AddressSize);
         LocListsSectionSize += AddressSize;
+        BaseAddressEmitted = true;
+      }
 
-      // Emit length of the range.
-      LocListsSectionSize += MS->emitSLEB128IntValue(
-          LocExpression.Range->HighPC - LocExpression.Range->LowPC);
+      // Emit type of entry.
+      MS->emitInt8(dwarf::DW_LLE_offset_pair);
+      LocListsSectionSize += 1;
+
+      // Emit start offset relative to base address.
+      LocListsSectionSize +=
+          MS->emitULEB128IntValue(LocExpression.Range->LowPC);
+
+      // Emit end offset relative to base address.
+      LocListsSectionSize +=
+          MS->emitSLEB128IntValue(LocExpression.Range->HighPC);
     } else {
       // Emit type of entry.
       MS->emitInt8(dwarf::DW_LLE_default_location);
       LocListsSectionSize += 1;
     }
 
     LocListsSectionSize += MS->emitULEB128IntValue(LocExpression.Expr.size());
     Asm->OutStreamer->emitBytes(StringRef(

llvm/lib/DWARFLinkerParallel/DWARFEmitterImpl.h

private:
   void emitDwarfDebugLocTableFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
       LocAttrPatch &Patch) {}
 
   /// Emit piece of .debug_loclists for \p LinkedRanges.
   void emitDwarfDebugLocListsTableFragment(
       const CompileUnit &Unit,
-      const DWARFLocationExpressionsVector &LinkedLocationExpression,
+      const DWARFLocationExpressionsFragment &LinkedLocationExpressionsFrag,
       LocAttrPatch &Patch) {}
 
   /// \defgroup MCObjects MC layer objects constructed by the streamer
   /// @{
   std::unique_ptr<MCRegisterInfo> MRI;
   std::unique_ptr<MCAsmInfo> MAI;
   std::unique_ptr<MCObjectFileInfo> MOFI;
   std::unique_ptr<MCContext> MC;

llvm/test/tools/dsymutil/ARM/dwarf5-dwarf4-combination-macho.test

 
 CHECK:.debug_abbrev contents:
 CHECK-NEXT: Abbrev table for offset: 0x00000000
 
 CHECK: .debug_info contents:
 CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000007d, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000081)
 CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x[[RANGELIST_OFFSET:[0-9a-f]+]]
 CHECK-NEXT:                  [0x[[RANGELIST_OFFSET_START:[0-9a-f]+]], 0x[[RANGELIST_OFFSET_END:[0-9a-f]+]]))
+CHECK: 0x00000033:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addr]     (0x[[#%.16x,LOCLIST_LOWPC:]])
 CHECK: 0x00000050:     DW_TAG_formal_parameter [3]   (0x00000033)
 CHECK-NEXT:                   DW_AT_location [DW_FORM_sec_offset]   (0x[[LOCLIST_OFFSET:[0-9a-f]+]]: 
-CHECK-NEXT:                      [0x[[LOCLIST_OFFSET_START:[0-9a-f]+]], 0x[[LOCLIST_OFFSET_END:[0-9a-f]+]]): [[LOCLIST_EXPR:.*]]
-CHECK-NEXT:                      [0x[[LOCLIST_OFFSET_START2:[0-9a-f]+]], 0x[[LOCLIST_OFFSET_END2:[0-9a-f]+]]): [[LOCLIST_EXPR2:.*]])
+CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START:]], 0x[[#%.16x,LOCLIST_PAIR_END:]]): [[LOCLIST_EXPR:.*]]
+CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START2:]], 0x[[#%.16x,LOCLIST_PAIR_END2:]]): [[LOCLIST_EXPR2:.*]])
 
 CHECK: 0x00000081: Compile Unit: length = 0x00000072, format = DWARF32, version = 0x0004, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x000000f7)
-CHECK:              DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
-CHECK-NEXT:                 [0x00000000000200[[RANGE_OFFSET_START:[0-9a-f][0-9a-f]]], 0x00000000000200[[RANGE_OFFSET_END:[0-9a-f][0-9a-f]]]))
+CHECK:              DW_AT_low_pc [DW_FORM_addr]       (0x[[#%.16x,RANGE_LOWPC:]])
+CHECK-NEXT:              DW_AT_ranges [DW_FORM_sec_offset] (0x00000000
+CHECK-NEXT:                 [0x[[#%.16x,RANGE_START:]], 0x[[#%.16x,RANGE_END:]]))
+CHECK:0x000000b3:   DW_TAG_subprogram [2] * (0x0000008c)
+CHECK-NEXT:                DW_AT_low_pc [DW_FORM_addr]     (0x[[#%.16x,LOC_LOWPC:]])
 CHECK:0x000000d0:     DW_TAG_formal_parameter [3]   (0x000000b3)
 CHECK-NEXT:                  DW_AT_location [DW_FORM_sec_offset]   (0x[[LOC_OFFSET:[0-9a-f]+]]: 
-CHECK-NEXT:                     [0x00000000000200[[LOC_OFFSET_START:[0-9a-f][0-9a-f]]], 0x00000000000200[[LOC_OFFSET_END:[0-9a-f][0-9a-f]]]): [[LOC_EXPR:.*]]
-CHECK-NEXT:                     [0x00000000000200[[LOC_OFFSET_START2:[0-9a-f][0-9a-f]]], 0x00000000000200[[LOC_OFFSET_END2:[0-9a-f][0-9a-f]]]): [[LOC_EXPR2:.*]])
+CHECK-NEXT:                     [0x[[#%.16x,LOC_PAIR_START:]], 0x[[#%.16x,LOC_PAIR_END:]]): [[LOC_EXPR:.*]]
+CHECK-NEXT:                     [0x[[#%.16x,LOC_PAIR_START2:]], 0x[[#%.16x,LOC_PAIR_END2:]]): [[LOC_EXPR2:.*]])
 
 CHECK: .debug_loc contents:
 CHECK-NEXT: 0x[[LOC_OFFSET]]:
-CHECK-NEXT:            (0x0000000000000000, 0x0000000000000004): [[LOC_EXPR:.*]]
-CHECK-NEXT:            (0x0000000000000004, 0x0000000000000008): [[LOC_EXPR2:.*]]
+CHECK-NEXT:            (0x[[#sub(LOC_PAIR_START,LOC_LOWPC)]], 0x[[#sub(LOC_PAIR_END,LOC_LOWPC)]]): [[LOC_EXPR:.*]]
+CHECK-NEXT:            (0x[[#sub(LOC_PAIR_START2,LOC_LOWPC)]], 0x[[#sub(LOC_PAIR_END2,LOC_LOWPC)]]): [[LOC_EXPR2:.*]]
 
 CHECK: .debug_loclists contents:
-CHECK-NEXT: 0x00000000: locations list header: length = 0x00000024, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+CHECK-NEXT: 0x00000000: locations list header: length = 0x0000001f, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: 0x[[LOCLIST_OFFSET]]: 
-CHECK-NEXT:             DW_LLE_start_length    {{.*}}
-CHECK-NEXT:                       => [0x[[LOCLIST_OFFSET_START]], 0x[[LOCLIST_OFFSET_END]]): [[LOCLIST_EXPR]]
-CHECK-NEXT:             DW_LLE_start_length    {{.*}}
-CHECK-NEXT:                       => [0x[[LOCLIST_OFFSET_START2]], 0x[[LOCLIST_OFFSET_END2]]): [[LOCLIST_EXPR2]]
-CHECK-NEXT:             DW_LLE_end_of_list     ()
+CHECK-NEXT:            DW_LLE_base_address    (0x[[#LOCLIST_LOWPC]])
+CHECK-NEXT:            DW_LLE_offset_pair     (0x[[#sub(LOCLIST_PAIR_START,LOCLIST_LOWPC)]], 0x[[#sub(LOCLIST_PAIR_END,LOCLIST_LOWPC)]])
+CHECK-NEXT:                      => [0x[[#LOCLIST_PAIR_START]], 0x[[#LOCLIST_PAIR_END]]): [[LOCLIST_EXPR]]
+CHECK-NEXT:            DW_LLE_offset_pair     (0x[[#sub(LOCLIST_PAIR_START2,LOCLIST_LOWPC)]], 0x[[#sub(LOCLIST_PAIR_END2,LOCLIST_LOWPC)]])
+CHECK-NEXT:                      => [0x[[#LOCLIST_PAIR_START2]], 0x[[#LOCLIST_PAIR_END2]]): [[LOCLIST_EXPR2]]
+CHECK-NEXT:            DW_LLE_end_of_list     ()
 
 CHECK: .debug_line contents:
 CHECK-NEXT: debug_line[0x00000000]
 CHECK-NEXT: Line table prologue:
 CHECK-NEXT:     total_length: 0x00000050
 CHECK-NEXT:           format: DWARF32
 CHECK-NEXT:          version: 5
 CHECK-NEXT:     address_size: 8

 
 CHECK: .debug_str contents:
 
 CHECK: .debug_line_str contents:
 CHECK-NEXT: 0x00000000: "/Users/shubham/Development/test109275485"
 CHECK-NEXT: 0x00000029: "a.cpp"
 
 CHECK: .debug_ranges contents:
-CHECK-NEXT: 00000000 00000000000000[[RANGE_OFFSET_START]] 00000000000000[[RANGE_OFFSET_END]]
+CHECK-NEXT: 00000000 [[#sub(RANGE_START,RANGE_LOWPC)]] [[#sub(RANGE_END,RANGE_LOWPC)]]
 
 CHECK: .debug_rnglists contents:
 CHECK-NEXT: 0x00000000: range list header: length = 0x00000013, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: ranges:
 CHECK-NEXT: [[RANGELIST_OFFSET]]: [DW_RLE_start_length]: {{.*}}[0x[[RANGELIST_OFFSET_START]], 0x[[RANGELIST_OFFSET_END]])
 
 CHECK: .debug_names contents:
 CHECK-NEXT: Name Index @ 0x0 {

llvm/test/tools/dsymutil/ARM/dwarf5-macho.test

 RUN: dsymutil -y %p/dummy-debug-map-amr64.map -oso-prepend-path=%p/../Inputs/DWARF5 -o %t.dir/dwarf5-macho.dSYM
 RUN: llvm-dwarfdump %t.dir/dwarf5-macho.dSYM -a --verbose | FileCheck %s
 
 CHECK:.debug_abbrev contents:
 CHECK-NEXT: Abbrev table for offset: 0x00000000
 
 CHECK: .debug_info contents:
 CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000007d, format = DWARF32, version = 0x0005, unit_type = DW_UT_compile, abbr_offset = 0x0000, addr_size = 0x08 (next unit at 0x00000081)
-CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x[[RANGE_OFFSET:[0-9a-f]+]]
-CHECK-NEXT:                  [0x[[RANGE_OFFSET_START:[0-9a-f]+]], 0x[[RANGE_OFFSET_END:[0-9a-f]+]]))
+CHECK: DW_AT_ranges [DW_FORM_sec_offset] (0x[[RANGELIST_OFFSET:[0-9a-f]+]]
+CHECK-NEXT:                  [0x[[RANGELIST_OFFSET_START:[0-9a-f]+]], 0x[[RANGELIST_OFFSET_END:[0-9a-f]+]]))
+CHECK: 0x00000033:   DW_TAG_subprogram [2] * (0x0000000c)
+CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addr]     (0x[[#%.16x,LOCLIST_LOWPC:]])
 CHECK: 0x00000050:     DW_TAG_formal_parameter [3]   (0x00000033)
 CHECK-NEXT:                   DW_AT_location [DW_FORM_sec_offset]   (0x[[LOC_OFFSET:[0-9a-f]+]]: 
-CHECK-NEXT:                      [0x[[LOC_OFFSET_START:[0-9a-f]+]], 0x[[LOC_OFFSET_END:[0-9a-f]+]]): [[LOC_EXPR:.*]]
-CHECK-NEXT:                      [0x[[LOC_OFFSET_START2:[0-9a-f]+]], 0x[[LOC_OFFSET_END2:[0-9a-f]+]]): [[LOC_EXPR2:.*]])
+CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START:]], 0x[[#%.16x,LOCLIST_PAIR_END:]]): [[LOCLIST_EXPR:.*]]
+CHECK-NEXT:                      [0x[[#%.16x,LOCLIST_PAIR_START2:]], 0x[[#%.16x,LOCLIST_PAIR_END2:]]): [[LOCLIST_EXPR2:.*]])
 
 CHECK: .debug_loclists contents:
-CHECK-NEXT: 0x00000000: locations list header: length = 0x00000024, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+CHECK-NEXT: locations list header: length = 0x0000001f, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: 0x[[LOC_OFFSET]]: 
-CHECK-NEXT:             DW_LLE_start_length    {{.*}}
-CHECK-NEXT:                       => [0x[[LOC_OFFSET_START]], 0x[[LOC_OFFSET_END]]): [[LOC_EXPR]]
-CHECK-NEXT:             DW_LLE_start_length    {{.*}}
-CHECK-NEXT:                       => [0x[[LOC_OFFSET_START2]], 0x[[LOC_OFFSET_END2]]): [[LOC_EXPR2]]
-CHECK-NEXT:             DW_LLE_end_of_list     ()
+CHECK-NEXT:            DW_LLE_base_address    (0x[[#LOCLIST_LOWPC]])
+CHECK-NEXT:            DW_LLE_offset_pair     (0x[[#sub(LOCLIST_PAIR_START,LOCLIST_LOWPC)]], 0x[[#sub(LOCLIST_PAIR_END,LOCLIST_LOWPC)]])
+CHECK-NEXT:                      => [0x[[#LOCLIST_PAIR_START]], 0x[[#LOCLIST_PAIR_END]]): [[LOCLIST_EXPR]]
+CHECK-NEXT:            DW_LLE_offset_pair     (0x[[#sub(LOCLIST_PAIR_START2,LOCLIST_LOWPC)]], 0x[[#sub(LOCLIST_PAIR_END2,LOCLIST_LOWPC)]])
+CHECK-NEXT:                      => [0x[[#LOCLIST_PAIR_START2]], 0x[[#LOCLIST_PAIR_END2]]): [[LOCLIST_EXPR2]]
+CHECK-NEXT:            DW_LLE_end_of_list     ()
 
 CHECK: .debug_line contents:
 CHECK-NEXT: debug_line[0x00000000]
 CHECK-NEXT: Line table prologue:
 CHECK-NEXT:     total_length: 0x00000050
 CHECK-NEXT:           format: DWARF32
 CHECK-NEXT:          version: 5
 CHECK-NEXT:     address_size: 8

 
 CHECK: .debug_line_str contents:
 CHECK-NEXT: 0x00000000: "/Users/shubham/Development/test109275485"
 CHECK-NEXT: 0x00000029: "a.cpp"
 
 CHECK: .debug_rnglists contents:
 CHECK-NEXT: 0x00000000: range list header: length = 0x00000013, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: ranges:
-CHECK-NEXT: [[RANGE_OFFSET]]: [DW_RLE_start_length]: {{.*}}[0x[[RANGE_OFFSET_START]], 0x[[RANGE_OFFSET_END]])
+CHECK-NEXT: [[RANGELIST_OFFSET]]: [DW_RLE_start_length]: {{.*}}[0x[[RANGELIST_OFFSET_START]], 0x[[RANGELIST_OFFSET_END]])
 
 CHECK: .debug_names contents:
 CHECK-NEXT: Name Index @ 0x0 {
 CHECK-NEXT:   Header {
 CHECK-NEXT:     Length: 0x94
 CHECK-NEXT:     Format: DWARF32
 CHECK-NEXT:     Version: 5
 CHECK-NEXT:     CU count: 1
 CHECK-NEXT:     Local TU count: 0
 CHECK-NEXT:     Foreign TU count: 0
 CHECK-NEXT:     Bucket count: 4
 CHECK-NEXT:     Name count: 4
 CHECK-NEXT:     Abbreviations table size: 0xD
 CHECK-NEXT:     Augmentation: 'LLVM0700'
 CHECK-NEXT:   }
 

llvm/test/tools/dsymutil/X86/dwarf5-loclists.test

 #DWARF-CHECK:   DW_AT_location [DW_FORM_sec_offset]   (0x0000000c:
 #DWARF-CHECK:     [0x0000000100000f70, 0x0000000100000f87): DW_OP_reg5 RDI
 #DWARF-CHECK:     [0x0000000100000f87, 0x0000000100000f93): DW_OP_reg3 RBX
 #DWARF-CHECK:     [0x0000000100000f93, 0x0000000100000f9d): DW_OP_reg4 RSI
 #DWARF-CHECK:     [0x0000000100000fa0, 0x0000000100000fa3): DW_OP_reg3 RBX
 #DWARF-CHECK:     [0x0000000100000fa3, 0x0000000100000fbc): DW_OP_breg6 RBP-20)
 #DWARF-CHECK:   DW_AT_name {{.*}} "argv"
 #DWARF-CHECK: DW_TAG_formal_parameter
-#DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]   (0x0000004a:
+#DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]   (0x00000031:
 #DWARF-CHECK:     [0x0000000100000f70, 0x0000000100000f89): DW_OP_reg4 RSI
 #DWARF-CHECK:     [0x0000000100000f89, 0x0000000100000fbc): DW_OP_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value)
 #DWARF-CHECK:   DW_AT_name {{.*}} "argc"
 #DWARF-CHECK: .debug_loclists contents:
-#DWARF-CHECK: 0x00000000: locations list header: length = 0x00000062, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+#DWARF-CHECK: 0x00000000: locations list header: length = 0x00000045, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 #DWARF-CHECK: 0x0000000c:
-#DWARF-CHECK:     DW_LLE_start_length    (0x0000000100000f70, 0x0000000000000017)
-#DWARF-CHECK:                => [0x0000000100000f70, 0x0000000100000f87): DW_OP_reg5 RDI
-#DWARF-CHECK:     DW_LLE_start_length    (0x0000000100000f87, 0x000000000000000c)
-#DWARF-CHECK:                => [0x0000000100000f87, 0x0000000100000f93): DW_OP_reg3 RBX
-#DWARF-CHECK:     DW_LLE_start_length    (0x0000000100000f93, 0x000000000000000a)
-#DWARF-CHECK:                => [0x0000000100000f93, 0x0000000100000f9d): DW_OP_reg4 RSI
-#DWARF-CHECK:     DW_LLE_start_length    (0x0000000100000fa0, 0x0000000000000003)
-#DWARF-CHECK:                => [0x0000000100000fa0, 0x0000000100000fa3): DW_OP_reg3 RBX
-#DWARF-CHECK:     DW_LLE_start_length    (0x0000000100000fa3, 0x0000000000000019)
-#DWARF-CHECK:                => [0x0000000100000fa3, 0x0000000100000fbc): DW_OP_breg6 RBP-20
-#DWARF-CHECK:     DW_LLE_end_of_list     ()
-#DWARF-CHECK: 0x0000004a:
-#DWARF-CHECK:     DW_LLE_start_length    (0x0000000100000f70, 0x0000000000000019)
-#DWARF-CHECK:                => [0x0000000100000f70, 0x0000000100000f89): DW_OP_reg4 RSI
-#DWARF-CHECK:     DW_LLE_start_length    (0x0000000100000f89, 0x0000000000000033)
-#DWARF-CHECK:                => [0x0000000100000f89, 0x0000000100000fbc): DW_OP_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value
-#DWARF-CHECK:     DW_LLE_end_of_list     ()
+#DWARF-CHECK:            DW_LLE_base_address    (0x0000000100000f70)
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000017)
+#DWARF-CHECK:                      => [0x0000000100000f70, 0x0000000100000f87): DW_OP_reg5 RDI
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000017, 0x0000000000000023)
+#DWARF-CHECK:                      => [0x0000000100000f87, 0x0000000100000f93): DW_OP_reg3 RBX
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000023, 0x000000000000002d)
+#DWARF-CHECK:                      => [0x0000000100000f93, 0x0000000100000f9d): DW_OP_reg4 RSI
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000030, 0x0000000000000033)
+#DWARF-CHECK:                      => [0x0000000100000fa0, 0x0000000100000fa3): DW_OP_reg3 RBX
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000033, 0x000000000000004c)
+#DWARF-CHECK:                      => [0x0000000100000fa3, 0x0000000100000fbc): DW_OP_breg6 RBP-20
+#DWARF-CHECK:            DW_LLE_end_of_list     ()
+#DWARF-CHECK: 0x00000031:
+#DWARF-CHECK:            DW_LLE_base_address    (0x0000000100000f70)
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000019)
+#DWARF-CHECK:                      => [0x0000000100000f70, 0x0000000100000f89): DW_OP_reg4 RSI
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000019, 0x000000000000004c)
+#DWARF-CHECK:                      => [0x0000000100000f89, 0x0000000100000fbc): DW_OP_entry_value(DW_OP_reg4 RSI), DW_OP_stack_value
+#DWARF-CHECK:            DW_LLE_end_of_list     ()
 
+
+
+
+
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
 #UPD-DWARF-CHECK: DW_AT_name {{.*}} "dwarf5-loclists.c"
 #UPD-DWARF-CHECK: DW_AT_loclists_base [DW_FORM_sec_offset]  (0x0000000c)
 #UPD-DWARF-CHECK: DW_TAG_formal_parameter [8]   (0x00000058)
 #UPD-DWARF-CHECK:   DW_AT_location [DW_FORM_loclistx]     (indexed (0x0) loclist = 0x00000014:
 #UPD-DWARF-CHECK:    [0x0000000000000000, 0x0000000000000017): DW_OP_reg5 RDI
 #UPD-DWARF-CHECK:    [0x0000000000000017, 0x0000000000000023): DW_OP_reg3 RBX
 #UPD-DWARF-CHECK:    [0x0000000000000023, 0x000000000000002d): DW_OP_reg4 RSI

llvm/test/tools/llvm-dwarfutil/ELF/X86/dwarf5-loclists.test

 #DWARF-CHECK: DW_TAG_compile_unit
 #DWARF-CHECK: DW_AT_name {{.*}}"CU1"
 #DWARF-CHECK-NOT: DW_AT_loclists_base
 #DWARF-CHECK: DW_TAG_variable
 #DWARF-CHECK: DW_AT_name {{.*}}"var1"
 #DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]      (0x0000000c:
 #DWARF-CHECK: [0x0000000000001130, 0x0000000000001140): DW_OP_reg5 RDI)
 #DWARF-CHECK: DW_AT_name {{.*}}"var2"
-#DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]     (0x00000019:
+#DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]     (0x0000001b:
 #DWARF-CHECK: <default>: DW_OP_reg5 RDI)
 #DWARF-CHECK: DW_TAG_variable
 #DWARF-CHECK: DW_AT_name {{.*}}"var3"
-#DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]     (0x0000001d:
+#DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]     (0x0000001f:
 #DWARF-CHECK: [0x0000000000001140, 0x0000000000001150): DW_OP_reg5 RDI
 #DWARF-CHECK: [0x0000000000001160, 0x0000000000001170): DW_OP_reg6 RBP)
 
 #UPD-DWARF-CHECK: DW_TAG_compile_unit
 #UPD-DWARF-CHECK:   DW_AT_name {{.*}}"CU1"
 #UPD-DWARF-CHECK:              DW_AT_loclists_base [DW_FORM_sec_offset]  (0x0000000c)
 #UPD-DWARF-CHECK:   DW_TAG_variable
 #UPD-DWARF-CHECK:     DW_AT_name {{.*}}"var1"