[ELF][X86] Support R_X86_64_PLTOFF64

[MaskRay]

Summary

For a function call (using the default -fplt), GCC -mcmodel=large generates an assembly modifier which
leads to an R_X86_64_PLTOFF64 relocation. In real world,
http://git.ageinghacker.net/jitter (used by GNU poke) uses -mcmodel=large.

R_X86_64_PLTOFF64's formula is (if preemptible) L - GOT + A or (if non-preemptible) S - GOT + A
where GOT is (confusingly) the address of .got.plt

[MaskRay]

adjust RelExpr member order

[peter.smith]

FWIW this looks like it matches the description in https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf . Would be good to get this checked over by someone that knows x86_64 better than me. If there's no-one left I can approve.

This may be a naive question, just thinking of Arm/AArch64 where the code often loads the base of the GOT with the GLOBAL_OFFSET_TABLE symbol. It may be worth checking on GOT being .got.plt. I'm guessing that in the large-code model some bit of code loads the base of the .got.plt. Is that done via the GLOBAL_OFFSET_TABLE symbol or some other more direct method? Just thinking of the case where GLOBAL_OFFSET_TABLE is not placed in between .got or .got.plt, this wouldn't be a problem if LLD always placed GLOBAL_OFFSET_TABLE at the base of the .got.plt if it existed. No problems if there is a more direct method for the code to get the base of the .got.plt.

lld/ELF/Relocations.cpp

1398–1399

// The 5 types ?

[MaskRay]

In D112386#3084962, @peter.smith wrote:

FWIW this looks like it matches the description in https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf . Would be good to get this checked over by someone that knows x86_64 better than me.

// a.c
void bar();
int main() { bar(); }

// b.c
#include <stdio.h>
void foo() { puts("foo"); }
void bar() { foo(); }

.MAKE.MODE = meta curDirOk=true

all: a b.so

a: a.c b.so
        $(CC) a.c ./b.so -ldl -o $@ -g

# Add or omit -Wl,-Bsymbolic
# Create a symlink /usr/local/bin/ld pointing to the newly built lld
b.so: b.c
        $(CC) -shared -fpic -mcmodel=large -O2 -g $> -o $@

I have verified that bmake; ./a works. (With an incorrect computation for R_X86_64_PLTOFF64 ./a would segfault.)

Clang -mcmodel=large always uses -fno-plt like code generation with R_X86_64_GOTOFF64 instead of R_X86_64_PLTOFF64, so GCC must be used for verification.

If there's no-one left I can approve.

It's more or less the case now but fortunately not many changes are needed...

This may be a naive question, just thinking of Arm/AArch64 where the code often loads the base of the GOT with the GLOBAL_OFFSET_TABLE symbol. It may be worth checking on GOT being .got.plt. I'm guessing that in the large-code model some bit of code loads the base of the .got.plt. Is that done via the GLOBAL_OFFSET_TABLE symbol or some other more direct method? Just thinking of the case where GLOBAL_OFFSET_TABLE is not placed in between .got or .got.plt, this wouldn't be a problem if LLD always placed GLOBAL_OFFSET_TABLE at the base of the .got.plt if it existed. No problems if there is a more direct method for the code to get the base of the .got.plt.

LLD defines __GLOBAL_OFFSET_TABLE__ only when it is referenced. R_X86_64_PLTOFF64 does not force creation of the symbol (LLD matches GNU ld).

global-offset-table-position.s checks that __GLOBAL_OFFSET_TABLE__ is placed at .got.plt for x86-64.
__GLOBAL_OFFSET_TABLE__ is either at start(.got) or start(.got.plt). All our RelExpr formulae use either start(.got) or start(.got.plt), not __GLOBAL_OFFSET_TABLE__.

So I think it is fine not to check the symbol in the new test.

[MaskRay]

update a stale comment

[peter.smith]

Thanks for confirming the placement of GLOBAL_OFFSET_TABLE. I've set approved.

lld/ELF/Arch/X86_64.cpp

case R_X86_64_GOTPC32_TLSDESC:
     return R_TLSDESC_PC;
   case R_X86_64_GOTPCREL:
   case R_X86_64_GOTPCRELX:
   case R_X86_64_REX_GOTPCRELX:
   case R_X86_64_GOTTPOFF:
     return R_GOT_PC;
   case R_X86_64_GOTOFF64:
     return R_GOTPLTREL;
+  case R_X86_64_PLTOFF64:
+    return R_PLT_GOTPLT;
   case R_X86_64_GOTPC32:
   case R_X86_64_GOTPC64:
     return R_GOTPLTONLY_PC;
   case R_X86_64_NONE:
     return R_NONE;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
int64_t X86_64::getImplicitAddend(const uint8_t *buf, RelType type) const {
   case R_X86_64_DTPOFF64:
   case R_X86_64_DTPMOD64:
   case R_X86_64_PC64:
   case R_X86_64_SIZE64:
   case R_X86_64_GLOB_DAT:
   case R_X86_64_GOT64:
   case R_X86_64_GOTOFF64:
   case R_X86_64_GOTPC64:
+  case R_X86_64_PLTOFF64:
   case R_X86_64_IRELATIVE:
   case R_X86_64_RELATIVE:
     return read64le(buf);
   case R_X86_64_JUMP_SLOT:
   case R_X86_64_NONE:
     // These relocations are defined as not having an implicit addend.
     return 0;
   default:
case R_X86_64_SIZE32:
     break;
   case R_X86_64_64:
   case R_X86_64_DTPOFF64:
   case R_X86_64_PC64:
   case R_X86_64_SIZE64:
   case R_X86_64_GOT64:
   case R_X86_64_GOTOFF64:
   case R_X86_64_GOTPC64:
+  case R_X86_64_PLTOFF64:
     write64le(loc, val);
     break;
   default:
     llvm_unreachable("unknown relocation");
   }
 }
 
 RelExpr X86_64::adjustGotPcExpr(RelType type, int64_t addend,

lld/ELF/InputSection.cpp

case R_ARM_PCA: {
     }
     return dest - p;
   }
   case R_PLT:
     return sym.getPltVA() + a;
   case R_PLT_PC:
   case R_PPC64_CALL_PLT:
     return sym.getPltVA() + a - p;
+  case R_PLT_GOTPLT:
+    return sym.getPltVA() + a - in.gotPlt->getVA();
   case R_PPC32_PLTREL:
     // R_PPC_PLTREL24 uses the addend (usually 0 or 0x8000) to indicate r30
     // stores _GLOBAL_OFFSET_TABLE_ or .got2+0x8000. The addend is ignored for
     // target VA computation.
     return sym.getPltVA() - p;
   case R_PPC64_CALL: {
     uint64_t symVA = sym.getVA(a);
     // If we have an undefined weak symbol, we might get here with a symbol

lld/ELF/Relocations.h

enum RelExpr {
   R_GOTPLTONLY_PC,
   R_GOTPLT,
   R_GOTPLTREL,
   R_GOTREL,
   R_NONE,
   R_PC,
   R_PLT,
   R_PLT_PC,
+  R_PLT_GOTPLT,
   R_RELAX_GOT_PC,
   R_RELAX_GOT_PC_NOPIC,
   R_RELAX_TLS_GD_TO_IE,
   R_RELAX_TLS_GD_TO_IE_ABS,
   R_RELAX_TLS_GD_TO_IE_GOT_OFF,
   R_RELAX_TLS_GD_TO_IE_GOTPLT,
   R_RELAX_TLS_GD_TO_LE,
   R_RELAX_TLS_GD_TO_LE_NEG,

lld/ELF/Relocations.cpp

 }
 
 static bool isAbsoluteValue(const Symbol &sym) {
   return isAbsolute(sym) || sym.isTls();
 }
 
 // Returns true if Expr refers a PLT entry.
 static bool needsPlt(RelExpr expr) {
-  return oneof<R_PLT_PC, R_PPC32_PLTREL, R_PPC64_CALL_PLT, R_PLT>(expr);
+  return oneof<R_PLT, R_PLT_PC, R_PLT_GOTPLT, R_PPC32_PLTREL, R_PPC64_CALL_PLT>(
+      expr);
 }
 
 // Returns true if Expr refers a GOT entry. Note that this function
 // returns false for TLS variables even though they need GOT, because
 // TLS variables uses GOT differently than the regular variables.
 static bool needsGot(RelExpr expr) {
   return oneof<R_GOT, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOT_OFF,
                R_MIPS_GOT_OFF32, R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTPLT,

 // dynamic relocation so that the relocation will be fixed at load-time.
 static bool isStaticLinkTimeConstant(RelExpr e, RelType type, const Symbol &sym,
                                      InputSectionBase &s, uint64_t relOff) {
   // These expressions always compute a constant
   if (oneof<R_DTPREL, R_GOTPLT, R_GOT_OFF, R_TLSLD_GOT_OFF,
             R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOTREL, R_MIPS_GOT_OFF,
             R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC, R_MIPS_TLSGD,
             R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, R_GOTPLTONLY_PC,
-            R_PLT_PC, R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC, R_PPC32_PLTREL,
-            R_PPC64_CALL_PLT, R_PPC64_RELAX_TOC, R_RISCV_ADD, R_TLSDESC_CALL,
-            R_TLSDESC_PC, R_AARCH64_TLSDESC_PAGE, R_TLSLD_HINT, R_TLSIE_HINT,
-            R_AARCH64_GOT_PAGE>(
-          e))
+            R_PLT_PC, R_PLT_GOTPLT, R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC,
+            R_PPC32_PLTREL, R_PPC64_CALL_PLT, R_PPC64_RELAX_TOC, R_RISCV_ADD,
+            R_TLSDESC_CALL, R_TLSDESC_PC, R_AARCH64_TLSDESC_PAGE, R_TLSLD_HINT,
+            R_TLSIE_HINT, R_AARCH64_GOT_PAGE>(e))
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (e == R_GOT || e == R_PLT || e == R_TLSDESC)
     return target->usesOnlyLowPageBits(type) || !config->isPic;
 
   if (sym.isPreemptible)
static RelExpr fromPlt(RelExpr expr) {
   switch (expr) {
   case R_PLT_PC:
   case R_PPC32_PLTREL:
     return R_PC;
   case R_PPC64_CALL_PLT:
     return R_PPC64_CALL;
   case R_PLT:
     return R_ABS;
+  case R_PLT_GOTPLT:
+    return R_GOTPLTREL;
   default:
     return expr;
   }
 }
 
 // Returns true if a given shared symbol is in a read-only segment in a DSO.
 template <class ELFT> static bool isReadOnly(SharedSymbol &ss) {
   using Elf_Phdr = typename ELFT::Phdr;
if (expr != R_GOT_PC) {
       expr = fromPlt(expr);
     } else if (!isAbsoluteValue(sym)) {
       expr = target->adjustGotPcExpr(type, addend, relocatedAddr);
     }
   }
 
   // If the relocation does not emit a GOT or GOTPLT entry but its computation
   // uses their addresses, we need GOT or GOTPLT to be created.
   //
-  // The 4 types that relative GOTPLT are all x86 and x86-64 specific.
-  if (oneof<R_GOTPLTONLY_PC, R_GOTPLTREL, R_GOTPLT, R_TLSGD_GOTPLT>(expr)) {
+  // The 5 types that relative GOTPLT are all x86 and x86-64 specific.
+  if (oneof<R_GOTPLTONLY_PC, R_GOTPLTREL, R_GOTPLT, R_PLT_GOTPLT,
+            R_TLSGD_GOTPLT>(expr)) {
     in.gotPlt->hasGotPltOffRel = true;
   } else if (oneof<R_GOTONLY_PC, R_GOTREL, R_PPC64_TOCBASE, R_PPC64_RELAX_TOC>(
                  expr)) {
     in.got->hasGotOffRel = true;
   }
 
   // Process TLS relocations, including relaxing TLS relocations. Note that
   // R_TPREL and R_TPREL_NEG relocations are resolved in processRelocAux.

lld/test/ELF/x86-64-reloc-pltoff64.s

+# REQUIRES: x86
+## Test R_X86_64_PLTOFF64 (preemptible: L - GOT + A; non-preemptible: S - GOT + A).
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: ld.lld %t.o -shared -o %t.so
+# RUN: llvm-readelf -S %t.so | FileCheck %s --check-prefix=SEC-SHARED
+# RUN: llvm-objdump -d --no-show-raw-insn %t.so | FileCheck %s --check-prefix=SHARED
+
+# RUN: ld.lld %t.o -o %t
+# RUN: llvm-readelf -S %t | FileCheck %s --check-prefix=SEC-PDE
+# RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s --check-prefix=PDE
+
+# SEC-SHARED: .got.plt PROGBITS 00000000000033c0 0003c0 000028
+
+## foo@plt - .got.plt = 0x12f0 - 0x33c0 = -8400
+## undefweak@plt - .got.plt = 0x1300 - 0x33c0 = -8384
+# SHARED-LABEL: <.text>:
+# SHARED-NEXT:          movabsq $-8400, %rdx
+# SHARED-NEXT:          movabsq $-8384, %rdx
+# SHARED-LABEL: <foo@plt>:
+# SHARED-NEXT:    12f0: jmpq {{.*}}(%rip)
+
+# SEC-PDE: .got.plt PROGBITS 0000000000202170 000170 000018
+
+## Avoid PLT since the referenced symbol is non-preemptible.
+## foo - .got.plt = 0x20116c - 0x202170 = -4100
+## 0 - .got.plt = 0 - 0x202168 = -2105712
+# PDE-LABEL: <.text>:
+# PDE-NEXT:            movabsq $-4100, %rdx
+# PDE-NEXT:            movabsq $-2105712, %rdx
+# PDE-LABEL: <foo>:
+# PDE-NEXT:    20116c: retq
+
+  movabsq $foo@PLTOFF, %rdx
+  movabsq $undefweak@PLTOFF, %rdx
+
+.globl foo
+foo:
+  ret
+
+.weak undefweak