DWARFDebugLoclists: Make it possible to read relocated addresses

[labath]

Summary

Handling relocations was not needed when the loclists section was a
DWO-only thing. But since DWARF5, it is possible to use it in regular
objects too, and the standard permits embedding addresses into the
section directly. These addresses need to be relocated in unlinked
files.

[dblaikie]

Looks good - thanks! Yeah, I had a few pieces somewhat like this in half-completed states along with the DWARFv4 loclist base address specifier change I committed recently (which I guess might've been related to your motivation here, or not)

[labath]

Rebase and make independent of D68270 (that is going to take a while).

[JDevlieghere]

LGTM

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

124–127

Is this written with a lambda because DWARFDataExtractor isn't assignable? Perhaps it should/could be made assignable?

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

12–13

Could you include the source & commands used to build this assembly for reference?

[labath]

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

124–127

It's not default-constructible (which I normally consider to be a good thing) so I had to initialize it in a single statement. That said, I have no idea why I ended up with a lambda here -- a plain ternary operator would work just fine. Using ?: now.

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

12–13

There isn't a "source", really. I was just adding a bunch of interesting location list entries by hand. (TBE, I did use some source to produce the minimal debug_info blurb needed to be able to print out, but I don't know what it was, and it has been mangled/reduced beyond recognition anyway.)

[labath]

Use ternary expression.

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

private:
 
   LocationLists Locations;
 
   unsigned AddressSize;
 
   bool IsLittleEndian;
 
 public:
-  void parse(DataExtractor data, uint64_t Offset, uint64_t EndOffset, uint16_t Version);
+  void parse(const DWARFDataExtractor &data, uint64_t Offset,
+             uint64_t EndOffset, uint16_t Version);
   void dump(raw_ostream &OS, uint64_t BaseAddr, const MCRegisterInfo *RegInfo,
             DIDumpOptions DumpOpts, Optional<uint64_t> Offset) const;
 
   /// Return the location list at the given offset or nullptr.
   LocationList const *getLocationListAtOffset(uint64_t Offset) const;
 
-  static Expected<LocationList> parseOneLocationList(const DataExtractor &Data,
-                                                     uint64_t *Offset,
-                                                     unsigned Version);
+  static Expected<LocationList>
+  parseOneLocationList(const DWARFDataExtractor &Data, uint64_t *Offset,
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFDEBUGLOC_H

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
   while (Data.isValidOffset(Offset)) {
     DWARFListTableHeader Header(".debug_loclists", "locations");
     if (Error E = Header.extract(Data, &Offset)) {
       WithColor::error() << toString(std::move(E)) << '\n';
       return;
     }
 
     Header.dump(OS, DumpOpts);
-    DataExtractor LocData(Data.getData(),
-                          Data.isLittleEndian(), Header.getAddrSize());
 
     DWARFDebugLoclists Loclists;
     uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
-    Loclists.parse(LocData, Offset, EndOffset, Header.getVersion());
+    Data.setAddressSize(Header.getAddrSize());
+    Loclists.parse(Data, Offset, EndOffset, Header.getVersion());
     Loclists.dump(OS, 0, MRI, DumpOpts, DumpOffset);
     Offset = EndOffset;
   }
 }
 
 void DWARFContext::dump(
     raw_ostream &OS, DIDumpOptions DumpOpts,
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {

 const DWARFDebugLoclists *DWARFContext::getDebugLocDWO() {
   if (LocDWO)
     return LocDWO.get();
 
   LocDWO.reset(new DWARFDebugLoclists());
   // Assume all compile units have the same address byte size.
   // FIXME: We don't need AddressSize for split DWARF since relocatable
   // addresses cannot appear there. At the moment DWARFExpression requires it.
-  DataExtractor LocData(DObj->getLocDWOSection().Data, isLittleEndian(), 4);
+  DWARFDataExtractor LocData(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
+                             4);
   // Use version 4. DWO does not support the DWARF v5 .debug_loclists yet and
   // that means we are parsing the new style .debug_loc (pre-standatized version
   // of the .debug_loclists).
   LocDWO->parse(LocData, 0, LocData.getData().size(), 4 /* Version */);
   return LocDWO.get();
 }
 
 const DWARFDebugAranges *DWARFContext::getDebugAranges() {

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

while (Offset < data.getData().size()) {
     else {
       logAllUnhandledErrors(LL.takeError(), WithColor::error());
       break;
     }
   }
 }
 
 Expected<DWARFDebugLoclists::LocationList>
-DWARFDebugLoclists::parseOneLocationList(const DataExtractor &Data,
+DWARFDebugLoclists::parseOneLocationList(const DWARFDataExtractor &Data,
                                          uint64_t *Offset, unsigned Version) {
   LocationList LL;
   LL.Offset = *Offset;
   DataExtractor::Cursor C(*Offset);
 
   // dwarf::DW_LLE_end_of_list_entry is 0 and indicates the end of the list.
   while (auto Kind = Data.getU8(C)) {
     Entry E;
     E.Kind = Kind;
     E.Offset = C.tell() - 1;
     switch (Kind) {
     case dwarf::DW_LLE_base_addressx:
       E.Value0 = Data.getULEB128(C);
       break;
     case dwarf::DW_LLE_startx_length:
       E.Value0 = Data.getULEB128(C);
       // Pre-DWARF 5 has different interpretation of the length field. We have
       // to support both pre- and standartized styles for the compatibility.
       if (Version < 5)
         E.Value1 = Data.getU32(C);
       else
         E.Value1 = Data.getULEB128(C);
       break;
     case dwarf::DW_LLE_start_length:
-      E.Value0 = Data.getAddress(C);
+      E.Value0 = Data.getRelocatedAddress(C);
       E.Value1 = Data.getULEB128(C);
       break;
     case dwarf::DW_LLE_offset_pair:
       E.Value0 = Data.getULEB128(C);
       E.Value1 = Data.getULEB128(C);
       break;
     case dwarf::DW_LLE_base_address:
-      E.Value0 = Data.getAddress(C);
+      E.Value0 = Data.getRelocatedAddress(C);
       break;
     default:
       cantFail(C.takeError());
       return createStringError(errc::illegal_byte_sequence,
                                "LLE of kind %x not supported", (int)Kind);
     }
 
     if (Kind != dwarf::DW_LLE_base_address &&
DWARFDebugLoclists::parseOneLocationList(const DWARFDataExtractor &Data,
   Entry E;
   E.Kind = dwarf::DW_LLE_end_of_list;
   E.Offset = C.tell() - 1;
   LL.Entries.push_back(E);
   *Offset = C.tell();
   return LL;
 }
 
-void DWARFDebugLoclists::parse(DataExtractor data, uint64_t Offset, uint64_t EndOffset, uint16_t Version) {
+void DWARFDebugLoclists::parse(const DWARFDataExtractor &data, uint64_t Offset,
+                               uint64_t EndOffset, uint16_t Version) {
   IsLittleEndian = data.isLittleEndian();
   AddressSize = data.getAddressSize();
 
   while (Offset < EndOffset) {
     if (auto LL = parseOneLocationList(data, &Offset, Version))
       Locations.push_back(std::move(*LL));
     else {
       logAllUnhandledErrors(LL.takeError(), WithColor::error());

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

if (!U->isDWOUnit() && !U->getLocSection()->Data.empty()) {
       DWARFDebugLoc DebugLoc;
       DWARFDataExtractor Data(Obj, *U->getLocSection(), Ctx.isLittleEndian(),
                               Obj.getAddressSize());
       DumpLL(DebugLoc.parseOneLocationList(Data, &Offset));
       return;
     }
 
     bool UseLocLists = !U->isDWOUnit();
-    StringRef LoclistsSectionData =
-        UseLocLists ? Obj.getLoclistsSection().Data : U->getLocSectionData();
-
-    if (!LoclistsSectionData.empty()) {
-      DataExtractor Data(LoclistsSectionData, Ctx.isLittleEndian(),
+    auto Data =
+        UseLocLists
+            ? DWARFDataExtractor(Obj, Obj.getLoclistsSection(),
+                                 Ctx.isLittleEndian(), Obj.getAddressSize())
+            : DWARFDataExtractor(U->getLocSectionData(), Ctx.isLittleEndian(),
                                  Obj.getAddressSize());
 
+    if (!Data.getData().empty()) {
       // Old-style location list were used in DWARF v4 (.debug_loc.dwo section).
       // Modern locations list (.debug_loclists) are used starting from v5.
       // Ideally we should take the version from the .debug_loclists section
       // header, but using CU's version for simplicity.
       DumpLL(DWARFDebugLoclists::parseOneLocationList(
           Data, &Offset, UseLocLists ? U->getVersion() : 4));
     }
   }

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

+# RUN: llvm-mc %s -filetype obj -triple x86_64-pc-linux -o %t
+# RUN: llvm-dwarfdump %t | FileCheck %s
+
+
+# CHECK:          DW_AT_location        (0x0000000c
+# CHECK-NEXT:        Addr idx 0 (w/ length 1): DW_OP_reg0 RAX
+# CHECK-NEXT:        [0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX
+# CHECK-NEXT:        [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
+# CHECK-NEXT:        [0x0000000000000003, 0x0000000000000004): DW_OP_reg3 RBX
+# CHECK-NEXT:        Addr idx 57005 (w/ length 1): DW_OP_reg4 RSI)
+
+
+        .text
+f:                                      # @f
+.Lf0:
+        nop
+.Lf1:
+        nop
+.Lf2:
+        nop
+.Lf3:
+        nop
+.Lf4:
+.Lfend:
+                                        # -- End function
+        .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
+.Lloclists_table_base0:
+.Ldebug_loc0:
+        .byte   3                       # DW_LLE_startx_length
+        .uleb128 0                      #   start idx
+        .uleb128 .Lf1-.Lf0              #   length
+        .byte   1                       # Loc expr size
+        .byte   80                      # super-register DW_OP_reg0
+        .byte   4                       # DW_LLE_offset_pair
+        .uleb128 .Lf1-.Lf0              #   starting offset
+        .uleb128 .Lf2-.Lf0              #   ending offset
+        .byte   1                       # Loc expr size
+        .byte   81                      # super-register DW_OP_reg1
+        .byte   8                       # DW_LLE_start_length
+        .quad   .Lf2                    #   starting offset
+        .uleb128 .Lf3-.Lf2              #   length
+        .byte   1                       # Loc expr size
+        .byte   82                      # super-register DW_OP_reg2
+        .byte   6                       # DW_LLE_base_address
+        .quad   .Lf3                    #   base address
+        .byte   4                       # DW_LLE_offset_pair
+        .uleb128 .Lf3-.Lf3              #   starting offset
+        .uleb128 .Lf4-.Lf3              #   ending offset
+        .byte   1                       # Loc expr size
+        .byte   83                      # super-register DW_OP_reg3
+        .byte   3                       # DW_LLE_startx_length
+        .uleb128 0xdead                 #   start idx
+        .uleb128 .Lf1-.Lf0              #   length
+        .byte   1                       # Loc expr size
+        .byte   84                      # super-register DW_OP_reg4
+        .byte   0                       # DW_LLE_end_of_list
+.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   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
+        .byte   6                       # DW_FORM_data4
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   3                       # Abbreviation Code
+        .byte   5                       # DW_TAG_formal_parameter
+        .byte   0                       # DW_CHILDREN_no
+        .byte   2                       # DW_AT_location
+        .byte   23                      # DW_FORM_sec_offset
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   0                       # EOM(3)
+        .section        .debug_info,"",@progbits
+.Lcu_begin0:
+        .long   .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.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   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:
+
+        .section        .debug_addr,"",@progbits
+        .long   .Ldebug_addr_end0-.Ldebug_addr_start0 # Length of contribution
+.Ldebug_addr_start0:
+        .short  5                       # DWARF version number
+        .byte   8                       # Address size
+        .byte   0                       # Segment selector size
+.Laddr_table_base0:
+        .quad   .Lf0
+.Ldebug_addr_end0: