DWARFDebugLoclists: stricter base address handling

[labath]

Summary

This removes the use of zero as a base address in section-based dumping.
Although this will often be true for (unlinked) object files with a
single compile unit, it is not true in general. This means that
section-based dumping will not be able to resolve entries referencing
the base address (DW_LLE_offset_pair) -- it wasn't able to do that
correctly before either, but now it will be more explicit about it. One
exception to that is if the location list contains an explicit
DW_LLE_base_address entry -- in this case the dumper will pick it up,
and resolve subsequent entries normally.

The patch also removes the fallback to zero in the "inline" dumping in
case the compile unit does not contain a base address.

[JDevlieghere]

LGTM!

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

public:
   virtual Error
   visitLocationList(uint64_t *Offset,
                     function_ref<bool(const DWARFLocationEntry &)> F) const = 0;
 
   /// Dump the location list at the given \p Offset. The function returns true
   /// iff it has successfully reched the end of the list. This means that one
   /// can attempt to parse another list after the current one (\p Offset will be
   /// updated to point past the end of the current list).
-  bool dumpLocationList(uint64_t *Offset, raw_ostream &OS, uint64_t BaseAddr,
+  bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,
+                        Optional<object::SectionedAddress> BaseAddr,
                         const MCRegisterInfo *MRI, DWARFUnit *U,
                         DIDumpOptions DumpOpts, unsigned Indent) const;
 
 protected:
   DWARFDataExtractor Data;
 
   virtual void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                             unsigned Indent) const = 0;
DWARFDebugLoclists(DWARFDataExtractor Data, uint16_t Version)
       : DWARFLocationTable(std::move(Data)), Version(Version) {}
 
   Error visitLocationList(
       uint64_t *Offset,
       function_ref<bool(const DWARFLocationEntry &)> F) const override;
 
   /// Dump all location lists within the given range.
   void dumpRange(uint64_t StartOffset, uint64_t Size, raw_ostream &OS,
-                 uint64_t BaseAddr, const MCRegisterInfo *MRI,
-                 DIDumpOptions DumpOpts);
+                 const MCRegisterInfo *MRI, DIDumpOptions DumpOpts);
 
 protected:
   void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                     unsigned Indent) const override;
 
 private:
   uint16_t Version;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

while (Data.isValidOffset(Offset)) {
     Header.dump(OS, DumpOpts);
 
     uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
     Data.setAddressSize(Header.getAddrSize());
     DWARFDebugLoclists Loc(Data, Header.getVersion());
     if (DumpOffset) {
       if (DumpOffset >= Offset && DumpOffset < EndOffset) {
         Offset = *DumpOffset;
-        Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/0, MRI, nullptr,
+        Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, nullptr,
                              DumpOpts, /*Indent=*/0);
         OS << "\n";
         return;
       }
     } else {
-      Loc.dumpRange(Offset, EndOffset - Offset, OS, /*BaseAddr=*/0, MRI,
-                    DumpOpts);
+      Loc.dumpRange(Offset, EndOffset - Offset, OS, MRI, DumpOpts);
     }
     Offset = EndOffset;
   }
 }
 
 void DWARFContext::dump(
     raw_ostream &OS, DIDumpOptions DumpOpts,
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
if (const auto *Off =
           shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                      DObj->getLocDWOSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
                             4);
     DWARFDebugLoclists Loc(Data, /*Version=*/4);
     if (*Off) {
       uint64_t Offset = **Off;
       Loc.dumpLocationList(&Offset, OS,
-                           /*BaseAddr=*/0, getRegisterInfo(), nullptr, DumpOpts,
-                           /*Indent=*/0);
+                           /*BaseAddr=*/None, getRegisterInfo(), nullptr,
+                           DumpOpts, /*Indent=*/0);
       OS << "\n";
     } else {
-      Loc.dumpRange(0, Data.getData().size(), OS, /*BaseAddr=*/0,
-                    getRegisterInfo(), DumpOpts);
+      Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(), DumpOpts);
     }
   }
 
   if (const auto *Off = shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
                                    DObj->getFrameSection().Data))
     getDebugFrame()->dump(OS, getRegisterInfo(), *Off);
 
   if (const auto *Off = shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

 static void dumpExpression(raw_ostream &OS, ArrayRef<uint8_t> Data,
                            bool IsLittleEndian, unsigned AddressSize,
                            const MCRegisterInfo *MRI, DWARFUnit *U) {
   DWARFDataExtractor Extractor(toStringRef(Data), IsLittleEndian, AddressSize);
   DWARFExpression(Extractor, dwarf::DWARF_VERSION, AddressSize).print(OS, MRI, U);
 }
 
 bool DWARFLocationTable::dumpLocationList(uint64_t *Offset, raw_ostream &OS,
-                                          uint64_t BaseAddr,
+                                          Optional<SectionedAddress> BaseAddr,
                                           const MCRegisterInfo *MRI,
                                           DWARFUnit *U, DIDumpOptions DumpOpts,
                                           unsigned Indent) const {
   DWARFLocationInterpreter Interp(
-      SectionedAddress{BaseAddr, SectionedAddress::UndefSection},
-      [U](uint32_t Index) -> Optional<SectionedAddress> {
+      BaseAddr, [U](uint32_t Index) -> Optional<SectionedAddress> {
         if (U)
           return U->getAddrOffsetSectionItem(Index);
         return None;
       });
   OS << format("0x%8.8" PRIx64 ": ", *Offset);
   Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
     Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E);
     if (!Loc || DumpOpts.Verbose)
case dwarf::DW_LLE_base_address:
     break;
   case dwarf::DW_LLE_end_of_list:
     break;
   }
   OS << ')';
 }
 
 void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size,
-                                   raw_ostream &OS, uint64_t BaseAddr,
-                                   const MCRegisterInfo *MRI,
+                                   raw_ostream &OS, const MCRegisterInfo *MRI,
                                    DIDumpOptions DumpOpts) {
   if (!Data.isValidOffsetForDataOfSize(StartOffset, Size))  {
     OS << "Invalid dump range\n";
     return;
   }
   uint64_t Offset = StartOffset;
   StringRef Separator;
   bool CanContinue = true;
   while (CanContinue && Offset < StartOffset + Size) {
     OS << Separator;
     Separator = "\n";
 
-    CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, nullptr,
+    CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/None, MRI, nullptr,
                                    DumpOpts, /*Indent=*/12);
     OS << '\n';
   }
 }

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
     return;
   }
 
   if (FormValue.isFormClass(DWARFFormValue::FC_SectionOffset)) {
     auto LLDumpOpts = DumpOpts;
     LLDumpOpts.Verbose = false;
 
     uint64_t Offset = *FormValue.getAsSectionOffset();
-    uint64_t BaseAddr = 0;
-    if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
-      BaseAddr = BA->Address;
 
     if (const DWARFLocationTable *LT = U->getLocationTable()) {
-      LT->dumpLocationList(&Offset, OS, BaseAddr, MRI, U, LLDumpOpts, Indent);
+      LT->dumpLocationList(&Offset, OS, U->getBaseAddress(), MRI, U, LLDumpOpts,
+                           Indent);
       return;
     }
 
     DWARFDebugLoc DebugLoc;
     DWARFDataExtractor Data(Obj, *U->getLocSection(), Ctx.isLittleEndian(),
                             Obj.getAddressSize());
 
     FormValue.dump(OS, DumpOpts);
     OS << ": ";
 
     if (Expected<DWARFDebugLoc::LocationList> LL =
             DebugLoc.parseOneLocationList(Data, &Offset)) {
+      uint64_t BaseAddr = 0;
+      if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
+        BaseAddr = BA->Address;
       LL->dump(OS, BaseAddr, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI, U,
                LLDumpOpts, Indent);
     } else {
       OS << '\n';
       OS.indent(Indent);
       OS << formatv("error extracting location list: {0}",
                     fmt_consume(LL.takeError()));
     }

llvm/test/DebugInfo/X86/dwarfdump-debug-loclists.test

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump -v %t.o | FileCheck %s
 
 # CHECK:      .debug_info
 # CHECK:       DW_AT_name{{.*}}"stub"
 # CHECK:       DW_AT_location [DW_FORM_sec_offset]   (0x0000000c
 # CHECK-NEXT:    [0x0000000000000010, 0x0000000000000020): DW_OP_breg5 RDI+0
 # CHECK-NEXT:    [0x0000000000000530, 0x0000000000000540): DW_OP_breg6 RBP-8, DW_OP_deref
 # CHECK-NEXT:    [0x0000000000000700, 0x0000000000000710): DW_OP_breg5 RDI+0
 
 # CHECK:      .debug_loclists contents:
 # CHECK-NEXT: 0x00000000: locations list header: length = 0x0000002c, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000000
 # CHECK-NEXT: 0x0000000c:
-# CHECK-NEXT:   DW_LLE_offset_pair  (0x0000000000000000, 0x0000000000000010)
-# CHECK-NEXT:                   => [0x0000000000000000, 0x0000000000000010): DW_OP_breg5 RDI+0
+# CHECK-NEXT:   DW_LLE_offset_pair  (0x0000000000000000, 0x0000000000000010): DW_OP_breg5 RDI+0
 # CHECK-NEXT:   DW_LLE_base_address (0x0000000000000500)
 # CHECK-NEXT:   DW_LLE_offset_pair  (0x0000000000000030, 0x0000000000000040)
 # CHECK-NEXT:                   => [0x0000000000000530, 0x0000000000000540): DW_OP_breg6 RBP-8, DW_OP_deref
 # CHECK-NEXT:   DW_LLE_start_length (0x0000000000000700, 0x0000000000000010)
 # CHECK-NEXT:                   => [0x0000000000000700, 0x0000000000000710): DW_OP_breg5 RDI+0
 # CHECK-NEXT:   DW_LLE_end_of_list  ()
 
 .section  .debug_str,"MS",@progbits,1

llvm/test/tools/llvm-dwarfdump/X86/debug_loclists.s

.Ldebug_loclist_table_end0:
         .section        .debug_abbrev,"",@progbits
         .byte   1                       # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit
         .byte   1                       # DW_CHILDREN_yes
         .byte   115                     # DW_AT_addr_base
         .byte   23                      # DW_FORM_sec_offset
         .ascii  "\214\001"              # DW_AT_loclists_base
         .byte   23                      # DW_FORM_sec_offset
+        .byte   17                      # DW_AT_low_pc
+        .byte   27                      # DW_FORM_addrx
+        .byte   18                      # DW_AT_high_pc
+        .byte   6                       # DW_FORM_data4
         .byte   0                       # EOM(1)
         .byte   0                       # EOM(2)
         .byte   2                       # Abbreviation Code
         .byte   46                      # DW_TAG_subprogram
         .byte   1                       # DW_CHILDREN_yes
         .byte   17                      # DW_AT_low_pc
         .byte   27                      # DW_FORM_addrx
         .byte   18                      # DW_AT_high_pc

 .Ldebug_info_start0:
         .short  5                       # DWARF version number
         .byte   1                       # DWARF Unit Type
         .byte   8                       # Address Size (in bytes)
         .long   .debug_abbrev           # Offset Into Abbrev. Section
         .byte   1                       # Abbrev [1] 0xc:0x3c DW_TAG_compile_unit
         .long   .Laddr_table_base0      # DW_AT_addr_base
         .long   .Lloclists_table_base0  # DW_AT_loclists_base
+        .byte   0                       # DW_AT_low_pc
+        .long   .Lfend-.Lf0             # DW_AT_high_pc
         .byte   2                       # Abbrev [2] 0x27:0x1c DW_TAG_subprogram
         .byte   0                       # DW_AT_low_pc
         .long   .Lfend-.Lf0             # DW_AT_high_pc
         .byte   3                       # Abbrev [3] 0x36:0xc DW_TAG_formal_parameter
         .long   .Ldebug_loc0            # DW_AT_location
         .byte   0                       # End Of Children Mark
         .byte   0                       # End Of Children Mark
 .Ldebug_info_end0:

llvm/test/tools/llvm-dwarfdump/X86/debug_loclists_multiple.s

 # RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t.o
 # RUN: llvm-dwarfdump -v %t.o | FileCheck %s
 
 # Test dumping of multiple separate debug_loclist contributions
 # CHECK: .debug_loclists contents:
 # CHECK: 0x00000000: locations list header:
 # CHECK: 0x0000000c:
-# CHECK:             [0x0000000000000001, 0x0000000000000002): DW_OP_consts +7, DW_OP_stack_value
+# CHECK:             DW_LLE_offset_pair (0x0000000000000001, 0x0000000000000002): DW_OP_consts +7, DW_OP_stack_value
 # CHECK: 0x00000014: locations list header:
-# CHECK:             [0x0000000000000005, 0x0000000000000007): DW_OP_consts +12, DW_OP_stack_value
+# CHECK:             DW_LLE_offset_pair (0x0000000000000005, 0x0000000000000007): DW_OP_consts +12, DW_OP_stack_value
 
   .section  .debug_loclists,"",@progbits
   .long .Ldebug_loclist_table_end0-.Ldebug_loclist_table_start0 # Length
 .Ldebug_loclist_table_start0:
   .short  5                       # Version
   .byte 8                       # Address size
   .byte 0                       # Segment selector size
   .long 0                       # Offset entry count