Change DW_LLE_baseaddr to DW_LLE_baseaddrx in .debug_loclist section

[rastogishubham]

Summary

With https://reviews.llvm.org/D154638, the ability to emit a .debug_addr section has been added to dsymutil. With this, instead of emitting a DW_LLE_baseaddr in the .debug_loclist section, a DW_LLE_baseaddrx can be emitted instead, which will allow for more indirection.

I opted for DW_LLE_baseaddrx + DW_LLE_offset_pair because using a DW_LLE_startx_length, because the latter would cause more entries to appear in the .debug_addr section which may lead to the size of the .debug_addr section blowing up considerably

[aprantl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

657

This hasn't been introduced by this patch, but I'm curious why we need to store the addresses twice? Would AddrIndexMap.insert(std::make_pair(Addr, AddrIndexMap.size())) work just as well?

llvm/lib/DWARFLinker/DWARFLinker.cpp

2002

should we assert(BaseAddress) here to make sure Index was initialized?

llvm/lib/DWARFLinker/DWARFStreamer.cpp

547

Should this be called BaseAddressIndex?

665

ditto

[rastogishubham]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

657

It is a matter of space vs size, if we get rid of SmallVector<uint64_t> Addrs; we will have to sort the AddrIndexMap by index and then output the .debug_addr section.

[aprantl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

657

Right. I forgot we need to write out the stuff, too ;-)

[rastogishubham]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

657

Space vs time*

Sorry about that

[avl]

llvm/include/llvm/DWARFLinker/DWARFLinker.h

832–833

probably we can make generateUnitLocations to be method of DIECloner as it looks compile unit local?

llvm/lib/DWARFLinker/DWARFLinker.cpp

1997

it looks like duplication of what is going on inside emitDwarfDebugLocListsTableFragment(). probably instead of passing Index into emitDwarfDebugLocListsTableFragment we would pass DebugAddrPool ?

LocListsSectionSize += MS->emitULEB128IntValue(AddrPool.getAddrIndex(*BaseAddress));

It makes unnecessary this additional index calculation and duplicating BaseAddress variable.

[rastogishubham]

Rebased on top of https://reviews.llvm.org/D154638

[rastogishubham]

rebase on top of https://reviews.llvm.org/D154638

[rastogishubham]

Moved generateUnitLocations into DIECloner

Pass AddrPool to DWARFStreamer::emitDwarfDebugLocListFragment` to calculate baseaddrx index there instead of passing index in

[rastogishubham]

Fix test failures in dwarf5-loclists.test

[avl]

LGTM, Thanks! Please, pay attention that patch application failed.

[rastogishubham]

Rebased on top of main

[rastogishubham]

@avl I imagine the patch application failed because this patch depends on https://reviews.llvm.org/D154638 going in?

[avl]

In D155724#4523017, @rastogishubham wrote:

@avl I imagine the patch application failed because this patch depends on https://reviews.llvm.org/D154638 going in?

yes, application failed because this patch depends on https://reviews.llvm.org/D154638 and one or both of these two patches probably need rebasing.

[rastogishubham]

Rebased on top of https://reviews.llvm.org/D155666 and https://reviews.llvm.org/D154638

[rastogishubham]

Landed with ab7874e945f0ecba4a62605950503b4c5d830c0b

llvm/include/llvm/DWARFLinker/DWARFLinker.h

virtual bool applyValidRelocs(MutableArrayRef<char> Data, uint64_t BaseOffset,
                                 bool IsLittleEndian) = 0;
 
   /// Erases all data.
   virtual void clear() = 0;
 };
 
 using Offset2UnitMap = DenseMap<uint64_t, CompileUnit *>;
 
+struct DebugAddrPool {
+  DenseMap<uint64_t, uint64_t> AddrIndexMap;
+  SmallVector<uint64_t> Addrs;
+
+  uint64_t getAddrIndex(uint64_t Addr) {
+    DenseMap<uint64_t, uint64_t>::iterator It = AddrIndexMap.find(Addr);
+    if (It == AddrIndexMap.end()) {
+      It = AddrIndexMap.insert(std::make_pair(Addr, Addrs.size())).first;
+      Addrs.push_back(Addr);
+    }
+    return It->second;
+  }
+
+  void clear() {
+    AddrIndexMap.clear();
+    Addrs.clear();
+  }
+};
+
 /// DwarfEmitter presents interface to generate all debug info tables.
 class DwarfEmitter {
 public:
   virtual ~DwarfEmitter();
 
   /// Emit DIE containing warnings.
   virtual void emitPaperTrailWarningsDie(DIE &Die) = 0;
 
public:
 
   /// 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,
-      PatchLocation Patch) = 0;
+      PatchLocation Patch, DebugAddrPool &AddrPool) = 0;
 
   /// Emit debug locations (.debug_loc, .debug_loclists) footer.
   virtual void emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                            MCSymbol *EndLabel) = 0;
 
   /// Emit .debug_addr header.
   virtual MCSymbol *emitDwarfDebugAddrsHeader(const CompileUnit &Unit) = 0;
 
private:
   /// \defgroup Methods used to link the debug information
   ///
   /// @{
 
   struct DWARFLinkerOptions;
 
   class DIECloner {
     DWARFLinker &Linker;
     DwarfEmitter *Emitter;
     DWARFFile &ObjFile;
     OffsetsStringPool &DebugStrPool;
     OffsetsStringPool &DebugLineStrPool;
-
-    struct DebugAddrPool {
-      DenseMap<uint64_t, uint64_t> AddrIndexMap;
-      SmallVector<uint64_t> Addrs;
-
-      uint64_t getAddrIndex(uint64_t Addr) {
-        DenseMap<uint64_t, uint64_t>::iterator It = AddrIndexMap.find(Addr);
-        if (It == AddrIndexMap.end()) {
-          It = AddrIndexMap.insert(std::make_pair(Addr, Addrs.size())).first;
-          Addrs.push_back(Addr);
-        }
-        return It->second;
-      }
-
-      void clear() {
-        AddrIndexMap.clear();
-        Addrs.clear();
-      }
-
-    };
-
     DebugAddrPool AddrPool;
 
     /// Allocator used for all the DIEValue objects.
     BumpPtrAllocator &DIEAlloc;
 
     std::vector<std::unique_ptr<CompileUnit>> &CompileUnits;
 
     /// Keeps mapping from offset of the macro table to corresponding
public:
     /// nothing to clone/emit.
     uint64_t cloneAllCompileUnits(DWARFContext &DwarfContext,
                                   const DWARFFile &File, bool IsLittleEndian);
 
     /// Emit the .debug_addr section for the \p Unit.
     void emitDebugAddrSection(CompileUnit &Unit,
                               const uint16_t DwarfVersion) const;
 
+    using ExpressionHandlerRef = function_ref<void(
+        SmallVectorImpl<uint8_t> &, SmallVectorImpl<uint8_t> &,
+        int64_t AddrRelocAdjustment)>;
+
+    /// Compute and emit debug locations (.debug_loc, .debug_loclists)
+    /// for \p Unit, patch the attributes referencing it.
+    void generateUnitLocations(CompileUnit &Unit, const DWARFFile &File,
+                               ExpressionHandlerRef ExprHandler);
+
   private:
     using AttributeSpec = DWARFAbbreviationDeclaration::AttributeSpec;
 
     /// Information gathered and exchanged between the various
     /// clone*Attributes helpers about the attributes of a particular DIE.
     struct AttributesInfo {
       /// Names.
       DwarfStringPoolEntryRef Name, MangledName, NameWithoutTemplate;
private:
   };
 
   /// Assign an abbreviation number to \p Abbrev
   void assignAbbrev(DIEAbbrev &Abbrev);
 
   /// Compute and emit debug ranges(.debug_aranges, .debug_ranges,
   /// .debug_rnglists) for \p Unit, patch the attributes referencing it.
   void generateUnitRanges(CompileUnit &Unit, const DWARFFile &File) const;
 
-  using ExpressionHandlerRef =
-      function_ref<void(SmallVectorImpl<uint8_t> &, SmallVectorImpl<uint8_t> &,
-                        int64_t AddrRelocAdjustment)>;
-
-  /// Compute and emit debug locations (.debug_loc, .debug_loclists)
-  /// for \p Unit, patch the attributes referencing it.
-  void generateUnitLocations(CompileUnit &Unit, const DWARFFile &File,
-                             ExpressionHandlerRef ExprHandler) const;
-
   /// Emit the accelerator entries for \p Unit.
   void emitAcceleratorEntriesForUnit(CompileUnit &Unit);
 
   /// Patch the frame info for an object file and emit it.
   void patchFrameInfoForObject(LinkContext &Context);
 
   /// FoldingSet that uniques the abbreviations.
   FoldingSet<DIEAbbrev> AbbreviationsSet;
 

llvm/include/llvm/DWARFLinker/DWARFStreamer.h

public:
   /// Emit .debug_addr footer.
   void emitDwarfDebugAddrsFooter(const CompileUnit &Unit,
                                  MCSymbol *EndLabel) override;
 
   /// Emit debug ranges(.debug_loc, .debug_loclists) fragment.
   void emitDwarfDebugLocListFragment(
       const CompileUnit &Unit,
       const DWARFLocationExpressionsVector &LinkedLocationExpression,
-      PatchLocation Patch) override;
+      PatchLocation Patch, DebugAddrPool &AddrPool) 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,
                                   const AddressRanges &LinkedRanges) override;
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,
-      PatchLocation Patch);
+      PatchLocation Patch, DebugAddrPool &AddrPool);
 
   /// \defgroup Line table emission
   /// @{
   void emitLineTablePrologue(const DWARFDebugLine::Prologue &P,
                              OffsetsStringPool &DebugStrPool,
                              OffsetsStringPool &DebugLineStrPool);
   void emitLineTableString(const DWARFDebugLine::Prologue &P,
                            const DWARFFormValue &String,

llvm/lib/DWARFLinker/DWARFLinker.cpp

       TheDwarfEmitter->emitDwarfDebugRangeListFragment(
           Unit, LinkedFunctionRanges, *UnitRngListAttribute);
 
     // Emit ranges footer.
     TheDwarfEmitter->emitDwarfDebugRangeListFooter(Unit, EndLabel);
   }
 }
 
-void DWARFLinker::generateUnitLocations(
+void DWARFLinker::DIECloner::generateUnitLocations(
     CompileUnit &Unit, const DWARFFile &File,
-    ExpressionHandlerRef ExprHandler) const {
-  if (LLVM_UNLIKELY(Options.Update))
+    ExpressionHandlerRef ExprHandler) {
+  if (LLVM_UNLIKELY(Linker.Options.Update))
     return;
 
   const LocListAttributesTy &AllLocListAttributes =
       Unit.getLocationAttributes();
 
   if (AllLocListAttributes.empty())
     return;
 
   // Emit locations list table header.
-  MCSymbol *EndLabel = TheDwarfEmitter->emitDwarfDebugLocListHeader(Unit);
+  MCSymbol *EndLabel = Emitter->emitDwarfDebugLocListHeader(Unit);
 
   for (auto &CurLocAttr : AllLocListAttributes) {
     // Get location expressions vector corresponding to the current attribute
     // from the source DWARF.
     Expected<DWARFLocationExpressionsVector> OriginalLocations =
         Unit.getOrigUnit().findLoclistFromOffset(CurLocAttr.get());
 
     if (!OriginalLocations) {
       llvm::consumeError(OriginalLocations.takeError());
-      reportWarning("Invalid location attribute ignored.", File);
+      Linker.reportWarning("Invalid location attribute ignored.", File);
       continue;
     }
 
     DWARFLocationExpressionsVector LinkedLocationExpressions;
     for (DWARFLocationExpression &CurExpression : *OriginalLocations) {
       DWARFLocationExpression LinkedExpression;
 
       if (CurExpression.Range) {
         // Relocate address range.
         LinkedExpression.Range = {
             CurExpression.Range->LowPC + CurLocAttr.RelocAdjustment,
             CurExpression.Range->HighPC + CurLocAttr.RelocAdjustment};
       }
 
       // Clone expression.
       LinkedExpression.Expr.reserve(CurExpression.Expr.size());
       ExprHandler(CurExpression.Expr, LinkedExpression.Expr,
                   CurLocAttr.RelocAdjustment);
 
       LinkedLocationExpressions.push_back(LinkedExpression);
     }
 
     // Emit locations list table fragment corresponding to the CurLocAttr.
-    TheDwarfEmitter->emitDwarfDebugLocListFragment(
-        Unit, LinkedLocationExpressions, CurLocAttr);
+    Emitter->emitDwarfDebugLocListFragment(Unit, LinkedLocationExpressions,
+                                           CurLocAttr, AddrPool);
   }
 
   // Emit locations list table footer.
-  TheDwarfEmitter->emitDwarfDebugLocListFooter(Unit, EndLabel);
+  Emitter->emitDwarfDebugLocListFooter(Unit, EndLabel);
 }
 
 static void patchAddrBase(DIE &Die, DIEInteger Offset) {
   for (auto &V : Die.values())
     if (V.getAttribute() == dwarf::DW_AT_addr_base) {
       V = DIEValue(V.getAttribute(), V.getForm(), Offset);
       return;
     }
 
   llvm_unreachable("Didn't find a DW_AT_addr_base in cloned DIE!");
 }
 
 void DWARFLinker::DIECloner::emitDebugAddrSection(

         DataExtractor Data(SrcBytes, IsLittleEndian,
                            OrigUnit.getAddressByteSize());
         cloneExpression(Data,
                         DWARFExpression(Data, OrigUnit.getAddressByteSize(),
                                         OrigUnit.getFormParams().Format),
                         File, *CurrentUnit, OutBytes, RelocAdjustment,
                         IsLittleEndian);
       };
-      Linker.generateUnitLocations(*CurrentUnit, File, ProcessExpr);
+      generateUnitLocations(*CurrentUnit, File, ProcessExpr);
       if (!AddrPool.Addrs.empty())
         emitDebugAddrSection(*CurrentUnit, DwarfVersion);
     }
     AddrPool.clear();
   }
 
   if (Emitter != nullptr) {
     assert(Emitter);

llvm/lib/DWARFLinker/DWARFStreamer.cpp

MCSymbol *DwarfStreamer::emitDwarfDebugLocListHeader(const CompileUnit &Unit) {
 
   return EndLabel;
 }
 
 /// Emit debug locations(.debug_loc, .debug_loclists) fragment.
 void DwarfStreamer::emitDwarfDebugLocListFragment(
     const CompileUnit &Unit,
     const DWARFLocationExpressionsVector &LinkedLocationExpression,
-    PatchLocation Patch) {
+    PatchLocation Patch, DebugAddrPool &AddrPool) {
   if (Unit.getOrigUnit().getVersion() < 5) {
     emitDwarfDebugLocTableFragment(Unit, LinkedLocationExpression, Patch);
     return;
   }
 
-  emitDwarfDebugLocListsTableFragment(Unit, LinkedLocationExpression, Patch);
+  emitDwarfDebugLocListsTableFragment(Unit, LinkedLocationExpression, Patch,
+                                      AddrPool);
 }
 
 /// Emit debug locations(.debug_loc, .debug_loclists) footer.
 void DwarfStreamer::emitDwarfDebugLocListFooter(const CompileUnit &Unit,
                                                 MCSymbol *EndLabel) {
   if (Unit.getOrigUnit().getVersion() < 5)
     return;
 
void DwarfStreamer::emitDwarfDebugAddrsFooter(const CompileUnit &Unit,
   if (EndLabel != nullptr)
     Asm->OutStreamer->emitLabel(EndLabel);
 }
 
 /// Emit piece of .debug_loclists for \p LinkedLocationExpression.
 void DwarfStreamer::emitDwarfDebugLocListsTableFragment(
     const CompileUnit &Unit,
     const DWARFLocationExpressionsVector &LinkedLocationExpression,
-    PatchLocation Patch) {
+    PatchLocation Patch, DebugAddrPool &AddrPool) {
   Patch.set(LocListsSectionSize);
 
   // Make .debug_loclists the current section.
   MS->switchSection(MC->getObjectFileInfo()->getDwarfLoclistsSection());
   std::optional<uint64_t> BaseAddress;
 
   for (const DWARFLocationExpression &LocExpression :
        LinkedLocationExpression) {
     if (LocExpression.Range) {
 
       if (!BaseAddress) {
 
         BaseAddress = LocExpression.Range->LowPC;
 
         // Emit base address.
-        MS->emitInt8(dwarf::DW_LLE_base_address);
+        MS->emitInt8(dwarf::DW_LLE_base_addressx);
         LocListsSectionSize += 1;
-        unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
-        MS->emitIntValue(*BaseAddress, AddressSize);
-        LocListsSectionSize += AddressSize;
+        LocListsSectionSize +=
+            MS->emitULEB128IntValue(AddrPool.getAddrIndex(*BaseAddress));
       }
 
       // Emit type of entry.
       MS->emitInt8(dwarf::DW_LLE_offset_pair);
       LocListsSectionSize += 1;
 
       // Emit start offset relative to base address.
       LocListsSectionSize +=

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

 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:            (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 = 0x0000001f, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+CHECK-NEXT: 0x00000000: locations list header: length = 0x00000018, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: 0x[[LOCLIST_OFFSET]]: 
-CHECK-NEXT:            DW_LLE_base_address    (0x[[#LOCLIST_LOWPC]])
+CHECK-NEXT:            DW_LLE_base_addressx   (0x0000000000000000)
 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: 0x00000048
 CHECK-NEXT:           format: DWARF32
 CHECK-NEXT:          version: 5

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

 CHECK: 0x00000037:   DW_TAG_subprogram [2] * (0x0000000c)
 CHECK-NEXT:  DW_AT_low_pc [DW_FORM_addrx]     (indexed (00000000) address = 0x[[#%.16x,LOCLIST_LOWPC:]])
 CHECK: 0x0000004d:     DW_TAG_formal_parameter [3]   (0x00000037)
 CHECK-NEXT:                   DW_AT_location [DW_FORM_sec_offset]   (0x[[LOC_OFFSET:[0-9a-f]+]]: 
 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: locations list header: length = 0x0000001f, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+CHECK-NEXT: 0x00000000: locations list header: length = 0x00000018, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 CHECK-NEXT: 0x[[LOC_OFFSET]]: 
-CHECK-NEXT:            DW_LLE_base_address    (0x[[#LOCLIST_LOWPC]])
+CHECK-NEXT:            DW_LLE_base_addressx   (0x0000000000000000)
 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: 0x00000048
 CHECK-NEXT:           format: DWARF32
 CHECK-NEXT:          version: 5

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]   (0x00000030:
+#DWARF-CHECK: DW_AT_location [DW_FORM_sec_offset]   (0x00000029:
 #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 = 0x00000043, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
+#DWARF-CHECK: 0x00000000: locations list header: length = 0x00000035, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 #DWARF-CHECK: 0x0000000c:
-#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_base_addressx   (0x0000000000000000)
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000017): DW_OP_reg5 RDI
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000017, 0x0000000000000023): DW_OP_reg3 RBX
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000023, 0x000000000000002d): DW_OP_reg4 RSI
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000030, 0x0000000000000033): DW_OP_reg3 RBX
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000033, 0x000000000000004c): DW_OP_breg6 RBP-20
 #DWARF-CHECK:            DW_LLE_end_of_list     ()
-#DWARF-CHECK: 0x00000030:
-#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: 0x00000029:
+#DWARF-CHECK:            DW_LLE_base_addressx   (0x0000000000000000)
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000019): DW_OP_reg4 RSI
+#DWARF-CHECK:            DW_LLE_offset_pair     (0x0000000000000019, 0x000000000000004c): 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"