RuntimeDyldELF: add support for R_AARCH64_ADD_ABS_LO12_NC

[davide]

The code looks correct, but I left a comment inline.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

460–464 ↗

(On Diff #82496)

This is correct, but while you're here, I'd rather see if you can have a common helper for all the relocations updating immediates in AArch64 instructions (e.g., ldr, str) as we do in lld (see or32AArch64Imm).

[evgeny777]

Addressed review comments.
Now lld and RuntimeDyldELF uses two identical sets of helper functions, so it probably makes sense to move them to header file and provide patch for lld.

[davide]

This looks much better now. Please split in two patches. The first one which does the refactoring, the second one which adds the new functionality. @lhames , what do you think?

[davide]

Minor comment inline.

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

42–45 ↗

(On Diff #82510)

Prefer the ternary operator here:
return (isBE) ? write<T, support::big>(...) : write<T, support:little>(...);

[davide]

In D28115#631088, @evgeny777 wrote:

Addressed review comments.
Now lld and RuntimeDyldELF uses two identical sets of helper functions, so it probably makes sense to move them to header file and provide patch for lld.

Maybe. I have no opinions on the topic (bluntly, I don't care), but there have been discussions recently about sharing code between the JIT and the static linker. You may want to check with the involved parties before going on, but I think it makes sense to do this as a follow-up.

[evgeny777]

So, can it be pushed as is?

[davide]

In D28115#631099, @evgeny777 wrote:

So, can it be pushed as is?

Yes, but please split the NFC changes from the functionality changes first.

[evgeny777]

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

42–45 ↗

(On Diff #82510)

Ok, but it's actually void.

[evgeny777]

Do you propose to push extra reloc first and than refactoring as a subsequent patch?

[davide]

In D28115#631102, @evgeny777 wrote:

Do you propose to push extra reloc first and than refactoring as a subsequent patch?

Either way.

llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

case ELF::R_AARCH64_ADR_PREL_PG_HI21: {
     TargetValue &= 0x9f00001fU;
     // Immediate goes in bits 30:29 + 5:23 of ADRP instruction, taken
     // from bits 32:12 of X.
     TargetValue |= ((Result & 0x3000U) << (29 - 12));
     TargetValue |= ((Result & 0x1ffffc000ULL) >> (14 - 5));
     support::ulittle32_t::ref{TargetPtr} = TargetValue;
     break;
   }
+  case ELF::R_AARCH64_ADD_ABS_LO12_NC: {
+    // Operation: S + A
+    uint64_t Result = Value + Addend;
+
+    // Immediate goes in bits 21:10 of LD/ST instruction, taken
+    // from bits 11:0 of X
+    *TargetPtr |= ((Result & 0xfff) << 10);
+    break;
+  }
   case ELF::R_AARCH64_LDST32_ABS_LO12_NC: {
     // Operation: S + A
     uint64_t Result = Value + Addend;
     uint32_t TargetValue = support::ulittle32_t::ref{TargetPtr};
 
     // AArch64 code is emitted with .rela relocations. The data already in any
     // bits affected by the relocation on entry is garbage.
     TargetValue &= 0xffc003ffU;

llvm/trunk/test/ExecutionEngine/RuntimeDyld/AArch64/ELF_ARM64_relocations.s

 # RUN: llvm-mc -triple=arm64-none-linux-gnu -filetype=obj -o %T/reloc.o %s
 # RUN: llvm-rtdyld -triple=arm64-none-linux-gnu -verify -dummy-extern f=0x0123456789abcdef -check=%s %T/reloc.o
 
         .text
         .globl  g
         .p2align        2
         .type   g,@function
 g:
 # R_AARCH64_MOVW_UABS_G3
         movz    x0, #:abs_g3:f
 # R_AARCH64_MOVW_UABS_G2_NC
         movk    x0, #:abs_g2_nc:f
 # R_AARCH64_MOVW_UABS_G1_NC
         movk    x0, #:abs_g1_nc:f
 # R_AARCH64_MOVW_UABS_G0_NC
         movk    x0, #:abs_g0_nc:f
+a:
+# R_AARCH64_ADD_ABS_LO12_NC
+        add x0, x0, :lo12:f
         ret
         .Lfunc_end0:
         .size   g, .Lfunc_end0-g
 
         .type   k,@object
         .data
         .globl  k
         .p2align        3
 k:
         .xword  f
         .size   k, 8
 
 # rtdyld-check: *{4}(g) = 0xd2e02460
 # rtdyld-check: *{4}(g + 4) = 0xf2c8ace0
 # rtdyld-check: *{4}(g + 8) = 0xf2b13560
 # rtdyld-check: *{4}(g + 12) = 0xf299bde0
 # rtdyld-check: *{8}k = f
+
+## f & 0xFFF = 0xdef (bits 11:0 of f)
+## 0xdef << 10 = 0x37bc00
+# rtdyld-check: *{4}(a) = 0x9137bc00