[lldb][ObjectFileELF] Support AArch32 in ApplyRelocations

[sgraenitz]

Summary

Allow the ObjectFileELF plugin to resolve R_ARM_ABS32 relocations from AArch32 object files. This fixes https://github.com/llvm/llvm-project/issues/61948

The existing architectures work with RELA-type relocation records that read addend from the relocation entry. REL-type relocations in AArch32 store addend in-place.
The new function doesn't re-use ELFRelocation::RelocAddend32(), because the interface doesn't match: in addition to the relocation entry we need the actual target section memory.

[sgraenitz]

Adding an abstraction for reading implicit addend or somehow integrate it into ELFRelocation::RelocAddend32() might be more confusing for the reader than keeping it in the function inline. What do you think?

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2660

IIUC we'd want to account for an endianness difference between debugger and target (in theory). However, non of the other cases seems to do it, so I didn't start with it either.

2712

In think debug info relocations have been R_ARM_ABS32 in all ARM/Thumb, pic/non-pic variations I tried. @peter.smith Does that hold in general? Otherwise, I'd like to report errors for the other cases and not let them run into the assert(false) below.

[sgraenitz]

Add the missing 5th relocation to the test that exercises the out-of-range case

[sgraenitz]

Second try for the out-of-range test

[peter.smith]

From the Arm side this looks good. Strictly speaking R_ARM_ABS32 doesn't require overflow checking, but in this context adding it makes sense. It is definitely the case that addends are signed in Arm, I guess there may be a 32-bit ABI that has unsigned REL addends, but I guess support can be added for that when needed.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2640

IIUC the largest difference between this and ApplyELF64ABS32Relocation is the use of REL rather than RELA relocations. Perhaps worth naming it as ApplyELF32ABS32RelRelocation

[sgraenitz]

Rename new function to ApplyELF32ABS32RelRelocation()

[sgraenitz]

Add error reporting for R_ARM_REL32 relocations

[sgraenitz]

Addressed feedback and added handling for R_ARM_REL32. I didn't see a real-world case for it yet. Hope it's ok to have the error reported for the time being.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2640

Thanks, very good point. Done.

[sgraenitz]

Double-checked and found source locations on Raspberry Pi 3b with this patch applied https://github.com/llvm/llvm-project/issues/61948#issuecomment-1508305542
Is there more feedback on this? It would be nice to land it soon, i.e. before EuroLLVM =)

[sgraenitz]

Ping

[labath]

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

2660

We probably should.
What we also should do (and what other cases seem to get mostly right) is avoid dereferencing type-punned pointers (use memcpy to read).

2663

[sgraenitz]

Address feedback and rebase

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

WritableDataBuffer *data_buffer =
         llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
     uint32_t *dst = reinterpret_cast<uint32_t *>(
         data_buffer->GetBytes() + rel_section->GetFileOffset() +
         ELFRelocation::RelocOffset32(rel));
     memcpy(dst, &truncated_addr, sizeof(uint32_t));
   }
 }
 
+static void ApplyELF32ABS32RelRelocation(Symtab *symtab, ELFRelocation &rel,
+                                         DataExtractor &debug_data,
+                                         Section *rel_section) {
+  Log *log = GetLog(LLDBLog::Modules);
+  Symbol *symbol = symtab->FindSymbolByID(ELFRelocation::RelocSymbol32(rel));
+  if (symbol) {
+    addr_t value = symbol->GetAddressRef().GetFileAddress();
+    if (value == LLDB_INVALID_ADDRESS) {
+      const char *name = symbol->GetName().GetCString();
+      LLDB_LOGF(log, "Debug info symbol invalid: %s", name);
+      return;
+    }
+    assert(llvm::isUInt<32>(value) && "Valid addresses are 32-bit");
+    DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
+    // ObjectFileELF creates a WritableDataBuffer in CreateInstance.
+    WritableDataBuffer *data_buffer =
+        llvm::cast<WritableDataBuffer>(data_buffer_sp.get());
+    uint8_t *dst = data_buffer->GetBytes() + rel_section->GetFileOffset() +
+                   ELFRelocation::RelocOffset32(rel);
+    // Implicit addend is stored inline as a signed value.
+    int32_t addend;
+    memcpy(&addend, dst, sizeof(int32_t));
+    // The sum must be positive. This extra check prevents UB from overflow in
+    // the actual range check below.
+    if (addend < 0 && static_cast<uint32_t>(-addend) > value) {
+      LLDB_LOGF(log, "Debug info relocation overflow: 0x%" PRIx64,
+                static_cast<int64_t>(value) + addend);
+      return;
+    }
+    if (!llvm::isUInt<32>(value + addend)) {
+      LLDB_LOGF(log, "Debug info relocation out of range: 0x%" PRIx64, value);
+      return;
+    }
+    uint32_t addr = value + addend;
+    memcpy(dst, &addr, sizeof(uint32_t));
+  }
+}
+
 unsigned ObjectFileELF::ApplyRelocations(
     Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
     const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr,
     DataExtractor &rel_data, DataExtractor &symtab_data,
     DataExtractor &debug_data, Section *rel_section) {
   ELFRelocation rel(rel_hdr->sh_type);
   lldb::addr_t offset = 0;
   const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
if (!rel.Parse(rel_data, &offset)) {
       GetModule()->ReportError(".rel{0}[{1:d}] failed to parse relocation",
                                rel_section->GetName().AsCString(), i);
       break;
     }
     Symbol *symbol = nullptr;
 
     if (hdr->Is32Bit()) {
       switch (hdr->e_machine) {
+      case llvm::ELF::EM_ARM:
+        switch (reloc_type(rel)) {
+        case R_ARM_ABS32:
+          ApplyELF32ABS32RelRelocation(symtab, rel, debug_data, rel_section);
+          break;
+        case R_ARM_REL32:
+          GetModule()->ReportError("unsupported AArch32 relocation:"
+                                   " .rel{0}[{1}], type {2}",
+                                   rel_section->GetName().AsCString(), i,
+                                   reloc_type(rel));
+          break;
+        default:
+          assert(false && "unexpected relocation type");
+        }
+        break;
       case llvm::ELF::EM_386:
         switch (reloc_type(rel)) {
         case R_386_32:
           symbol = symtab->FindSymbolByID(reloc_symbol(rel));
           if (symbol) {
             addr_t f_offset =
                 rel_section->GetFileOffset() + ELFRelocation::RelocOffset32(rel);
             DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();

lldb/test/Shell/ObjectFile/ELF/aarch32-relocations.yaml

+# RUN: yaml2obj %s -o %t
+# RUN: lldb-test object-file -contents %t | FileCheck %s
+
+## Test that R_ARM_ABS32 relocations are resolved in .debug_info sections on aarch32.
+## REL-type relocations store implicit addend as signed values inline.
+## We relocate the symbol foo with 4 different addends and bar once in the .debug_info section.
+## Results that exceed the 32-bit range or overflow are logged and ignored.
+
+# CHECK:      Name: .debug_info
+# CHECK:      Data:  (
+#
+#              Addends: Zero     Positive Negative Overflow Out-of-range
+#                       00000000 04030201 D6FFFFFF D5FFFFFF FFFFFF7F
+# CHECK-NEXT:     0000: 2A000000 2E030201 00000000 D5FFFFFF FFFFFF7F
+# CHECK-NEXT: )
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    Content:         0000000004030201D6FFFFFFD5FFFFFFFFFFFF7F
+  - Name:            .rel.debug_info
+    Type:            SHT_REL
+    Info:            .debug_info
+    Relocations:
+      - Offset:          0x0
+        Symbol:          foo
+        Type:            R_ARM_ABS32
+      - Offset:          0x4
+        Symbol:          foo
+        Type:            R_ARM_ABS32
+      - Offset:          0x8
+        Symbol:          foo
+        Type:            R_ARM_ABS32
+      - Offset:          0xC
+        Symbol:          foo
+        Type:            R_ARM_ABS32
+      - Offset:          0x10
+        Symbol:          bar
+        Type:            R_ARM_ABS32
+Symbols:
+  - Name:            .debug_info
+    Type:            STT_SECTION
+    Section:         .debug_info
+  - Name:            foo
+    Type:            STT_FUNC
+    Section:         .debug_info
+    Value:           0x0000002A
+  - Name:            bar
+    Type:            STT_FUNC
+    Section:         .debug_info
+    Value:           0xFF000000
+...