[ELF] Implement General Dynamic style x86-64 TLSDESC

[MaskRay]

Summary

This handles two initial relocation types R_X86_64_GOTPC32_TLSDESC and
R_X86_64_TLSDESC_CALL, as well as the GD->LE and GD->IE relaxations.

[MaskRay]

drop an unrelated test change. fix a comment

[ruiu]

ELF/Arch/X86_64.cpp

203 ↗

(On Diff #201626)

missing comment?

210 ↗

(On Diff #201626)

Hm, it's not missing, but a sentence in a comment separated by code looks odd. I don't think we need to save a few lines. You can just repeat the same comments, one at the top of this block and the other inline.

[ruiu]

ELF/Arch/X86_64.cpp

210 ↗

(On Diff #201626)

Or, "convert ... to the following two instructions."

[MaskRay]

Improve the comments as ruiu suggested.

[ruiu]

LGTM

lld/trunk/ELF/Arch/X86_64.cpp

 
 X86_64::X86_64() {
   CopyRel = R_X86_64_COPY;
   GotRel = R_X86_64_GLOB_DAT;
   NoneRel = R_X86_64_NONE;
   PltRel = R_X86_64_JUMP_SLOT;
   RelativeRel = R_X86_64_RELATIVE;
   IRelativeRel = R_X86_64_IRELATIVE;
+  TlsDescRel = R_X86_64_TLSDESC;
   TlsGotRel = R_X86_64_TPOFF64;
   TlsModuleIndexRel = R_X86_64_DTPMOD64;
   TlsOffsetRel = R_X86_64_DTPOFF64;
   GotEntrySize = 8;
   GotPltEntrySize = 8;
   PltEntrySize = 16;
   PltHeaderSize = 16;
   TrapInstr = {0xcc, 0xcc, 0xcc, 0xcc}; // 0xcc = INT3
RelExpr X86_64::getRelExpr(RelType Type, const Symbol &S,
   case R_X86_64_32S:
   case R_X86_64_64:
     return R_ABS;
   case R_X86_64_DTPOFF32:
   case R_X86_64_DTPOFF64:
     return R_DTPREL;
   case R_X86_64_TPOFF32:
     return R_TLS;
+  case R_X86_64_TLSDESC_CALL:
+    return R_TLSDESC_CALL;
   case R_X86_64_TLSLD:
     return R_TLSLD_PC;
   case R_X86_64_TLSGD:
     return R_TLSGD_PC;
   case R_X86_64_SIZE32:
   case R_X86_64_SIZE64:
     return R_SIZE;
   case R_X86_64_PLT32:
     return R_PLT_PC;
   case R_X86_64_PC8:
   case R_X86_64_PC16:
   case R_X86_64_PC32:
   case R_X86_64_PC64:
     return R_PC;
   case R_X86_64_GOT32:
   case R_X86_64_GOT64:
     return R_GOTPLT;
+  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_GOTPC32:

 RelType X86_64::getDynRel(RelType Type) const {
   if (Type == R_X86_64_64 || Type == R_X86_64_PC64 || Type == R_X86_64_SIZE32 ||
       Type == R_X86_64_SIZE64)
     return Type;
   return R_X86_64_NONE;
 }
 
 void X86_64::relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
+  if (Type == R_X86_64_TLSGD) {
     // Convert
     //   .byte 0x66
     //   leaq x@tlsgd(%rip), %rdi
     //   .word 0x6666
     //   rex64
     //   call __tls_get_addr@plt
-  // to
-  //   mov %fs:0x0,%rax
-  //   lea x@tpoff,%rax
+    // to the following two instructions.
     const uint8_t Inst[] = {
-      0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:0x0,%rax
-      0x48, 0x8d, 0x80, 0, 0, 0, 0,                         // lea x@tpoff,%rax
+        0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00,
+        0x00, 0x00,                            // mov %fs:0x0,%rax
+        0x48, 0x8d, 0x80, 0,    0,    0,    0, // lea x@tpoff,%rax
     };
     memcpy(Loc - 4, Inst, sizeof(Inst));
 
     // The original code used a pc relative relocation and so we have to
     // compensate for the -4 in had in the addend.
     write32le(Loc + 8, Val + 4);
+  } else {
+    // Convert
+    //   lea x@tlsgd(%rip), %rax
+    //   call *(%rax)
+    // to the following two instructions.
+    assert(Type == R_X86_64_GOTPC32_TLSDESC);
+    if (memcmp(Loc - 3, "\x48\x8d\x05", 3)) {
+      error(getErrorLocation(Loc - 3) + "R_X86_64_GOTPC32_TLSDESC must be used "
+                                        "in callq *x@tlsdesc(%rip), %rax");
+      return;
+    }
+    // movq $x@tpoff(%rip),%rax
+    Loc[-2] = 0xc7;
+    Loc[-1] = 0xc0;
+    write32le(Loc, Val + 4);
+    // xchg ax,ax
+    Loc[4] = 0x66;
+    Loc[5] = 0x90;
+  }
 }
 
 void X86_64::relaxTlsGdToIe(uint8_t *Loc, RelType Type, uint64_t Val) const {
+  if (Type == R_X86_64_TLSGD) {
     // Convert
     //   .byte 0x66
     //   leaq x@tlsgd(%rip), %rdi
     //   .word 0x6666
     //   rex64
     //   call __tls_get_addr@plt
-  // to
-  //   mov %fs:0x0,%rax
-  //   addq x@tpoff,%rax
+    // to the following two instructions.
     const uint8_t Inst[] = {
-      0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:0x0,%rax
-      0x48, 0x03, 0x05, 0, 0, 0, 0,                         // addq x@tpoff,%rax
+        0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00,
+        0x00, 0x00,                            // mov %fs:0x0,%rax
+        0x48, 0x03, 0x05, 0,    0,    0,    0, // addq x@gottpoff(%rip),%rax
     };
     memcpy(Loc - 4, Inst, sizeof(Inst));
 
-  // Both code sequences are PC relatives, but since we are moving the constant
-  // forward by 8 bytes we have to subtract the value by 8.
+    // Both code sequences are PC relatives, but since we are moving the
+    // constant forward by 8 bytes we have to subtract the value by 8.
     write32le(Loc + 8, Val - 8);
+  } else {
+    // Convert
+    //   lea x@tlsgd(%rip), %rax
+    //   call *(%rax)
+    // to the following two instructions.
+    assert(Type == R_X86_64_GOTPC32_TLSDESC);
+    if (memcmp(Loc - 3, "\x48\x8d\x05", 3)) {
+      error(getErrorLocation(Loc - 3) + "R_X86_64_GOTPC32_TLSDESC must be used "
+                                        "in callq *x@tlsdesc(%rip), %rax");
+      return;
+    }
+    // movq x@gottpoff(%rip),%rax
+    Loc[-2] = 0x8b;
+    write32le(Loc, Val);
+    // xchg ax,ax
+    Loc[4] = 0x66;
+    Loc[5] = 0x90;
+  }
 }
 
 // In some conditions, R_X86_64_GOTTPOFF relocation can be optimized to
 // R_X86_64_TPOFF32 so that it does not use GOT.
 void X86_64::relaxTlsIeToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
   uint8_t *Inst = Loc - 3;
   uint8_t Reg = Loc[-1] >> 3;
   uint8_t *RegSlot = Loc - 1;
void X86_64::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   case R_X86_64_32:
     checkUInt(Loc, Val, 32, Type);
     write32le(Loc, Val);
     break;
   case R_X86_64_32S:
   case R_X86_64_TPOFF32:
   case R_X86_64_GOT32:
   case R_X86_64_GOTPC32:
+  case R_X86_64_GOTPC32_TLSDESC:
   case R_X86_64_GOTPCREL:
   case R_X86_64_GOTPCRELX:
   case R_X86_64_REX_GOTPCRELX:
   case R_X86_64_PC32:
   case R_X86_64_GOTTPOFF:
   case R_X86_64_PLT32:
   case R_X86_64_TLSGD:
   case R_X86_64_TLSLD:

lld/trunk/ELF/InputSection.cpp

static uint64_t getRelocTargetVA(const InputFile *File, RelType Type, int64_t A,
   case R_NEG_TLS:
     if (Sym.isUndefined())
       return A;
     return -Sym.getVA(0) - getTlsTpOffset() + A;
   case R_SIZE:
     return Sym.getSize() + A;
   case R_TLSDESC:
     return In.Got->getGlobalDynAddr(Sym) + A;
+  case R_TLSDESC_PC:
+    return In.Got->getGlobalDynAddr(Sym) + A - P;
   case R_AARCH64_TLSDESC_PAGE:
     return getAArch64Page(In.Got->getGlobalDynAddr(Sym) + A) -
            getAArch64Page(P);
   case R_TLSGD_GOT:
     return In.Got->getGlobalDynOffset(Sym) + A;
   case R_TLSGD_GOTPLT:
     return In.Got->getVA() + In.Got->getGlobalDynOffset(Sym) + A - In.GotPlt->getVA();
   case R_TLSGD_PC:

lld/trunk/ELF/Relocations.h

enum RelExpr {
   R_RELAX_TLS_GD_TO_LE_NEG,
   R_RELAX_TLS_IE_TO_LE,
   R_RELAX_TLS_LD_TO_LE,
   R_RELAX_TLS_LD_TO_LE_ABS,
   R_SIZE,
   R_TLS,
   R_TLSDESC,
   R_TLSDESC_CALL,
+  R_TLSDESC_PC,
   R_TLSGD_GOT,
   R_TLSGD_GOTPLT,
   R_TLSGD_PC,
   R_TLSIE_HINT,
   R_TLSLD_GOT,
   R_TLSLD_GOTPLT,
   R_TLSLD_GOT_OFF,
   R_TLSLD_HINT,

lld/trunk/ELF/Relocations.cpp

handleTlsRelocation(RelType Type, Symbol &Sym, InputSectionBase &C,
   if (!Sym.isTls())
     return 0;
 
   if (Config->EMachine == EM_ARM)
     return handleARMTlsRelocation(Type, Sym, C, Offset, Addend, Expr);
   if (Config->EMachine == EM_MIPS)
     return handleMipsTlsRelocation(Type, Sym, C, Offset, Addend, Expr);
 
-  if (oneof<R_TLSDESC, R_AARCH64_TLSDESC_PAGE, R_TLSDESC_CALL>(Expr) &&
+  if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC>(
+          Expr) &&
       Config->Shared) {
     if (In.Got->addDynTlsEntry(Sym)) {
       uint64_t Off = In.Got->getGlobalDynOffset(Sym);
       In.RelaDyn->addReloc(
           {Target->TlsDescRel, In.Got, Off, !Sym.IsPreemptible, &Sym, 0});
     }
     if (Expr != R_TLSDESC_CALL)
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
if (!Sym.isInGot()) {
       uint64_t Off = Sym.getGotOffset();
       In.Got->Relocations.push_back(
           {R_ABS, Target->TlsOffsetRel, Off, 0, &Sym});
     }
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return 1;
   }
 
-  if (oneof<R_TLSDESC, R_AARCH64_TLSDESC_PAGE, R_TLSDESC_CALL, R_TLSGD_GOT,
-            R_TLSGD_GOTPLT, R_TLSGD_PC>(Expr)) {
+  if (oneof<R_AARCH64_TLSDESC_PAGE, R_TLSDESC, R_TLSDESC_CALL, R_TLSDESC_PC,
+            R_TLSGD_GOT, R_TLSGD_GOTPLT, R_TLSGD_PC>(Expr)) {
     if (Config->Shared) {
       if (In.Got->addDynTlsEntry(Sym)) {
         uint64_t Off = In.Got->getGlobalDynOffset(Sym);
         In.RelaDyn->addReloc(Target->TlsModuleIndexRel, In.Got, Off, &Sym);
 
         // If the symbol is preemptible we need the dynamic linker to write
         // the offset too.
         uint64_t OffsetOff = Off + Config->Wordsize;

 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_HEXAGON_GOT, 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_PPC_CALL_PLT,
-            R_PPC64_RELAX_TOC, R_TLSDESC_CALL, R_AARCH64_TLSDESC_PAGE, R_HINT, R_TLSLD_HINT,
-            R_TLSIE_HINT>(E))
+            R_PPC64_RELAX_TOC, R_TLSDESC_CALL, R_TLSDESC_PC,
+            R_AARCH64_TLSDESC_PAGE, R_HINT, R_TLSLD_HINT, R_TLSIE_HINT>(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->Pic;
 
   if (Sym.IsPreemptible)

lld/trunk/test/ELF/invalid/x86-64-tlsdesc-gd.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: echo '.tbss; .globl a; a:' | llvm-mc -filetype=obj -triple=x86_64 - -o %t1.o
+# RUN: ld.lld -shared %t1.o -o %t1.so
+
+## GD to LE relaxation.
+# RUN: not ld.lld %t.o %t1.o -o /dev/null 2>&1 | FileCheck -DINPUT=%t.o %s
+## GD to IE relaxation.
+# RUN: not ld.lld %t.o %t1.so -o /dev/null 2>&1 | FileCheck -DINPUT=%t.o %s
+
+# CHECK: error: [[INPUT]]:(.text+0x0): R_X86_64_GOTPC32_TLSDESC must be used in callq *x@tlsdesc(%rip), %rax
+
+leaq a@tlsdesc(%rip), %rdx
+call *a@tlscall(%rdx)
+movl %fs:(%rax), %eax

lld/trunk/test/ELF/x86-64-tlsdesc-gd.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %s -o %t.o
+# RUN: echo '.tbss; .globl b; b:' | llvm-mc -filetype=obj -triple=x86_64 - -o %t1.o
+# RUN: ld.lld -shared -soname=t1.so %t1.o -o %t1.so
+
+# RUN: ld.lld -shared %t.o %t1.o -o %t.so
+# RUN: llvm-readobj -r %t.so | FileCheck --check-prefix=GD-REL %s
+# RUN: llvm-objdump -d --no-show-raw-insn %t.so | FileCheck --check-prefix=GD %s
+
+# RUN: ld.lld %t.o %t1.o -o %t
+# RUN: llvm-readelf -r %t | FileCheck --check-prefix=NOREL %s
+# RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=LE %s
+
+# RUN: ld.lld %t.o %t1.so -o %t
+# RUN: llvm-readobj -r %t | FileCheck --check-prefix=IE-REL %s
+# RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck --check-prefix=IE %s
+
+# GD-REL:      .rela.dyn {
+# GD-REL-NEXT:   0x20A0 R_X86_64_TLSDESC a 0x0
+# GD-REL-NEXT:   0x20B0 R_X86_64_TLSDESC b 0x0
+# GD-REL-NEXT: }
+
+# 0x20a0-0x1007 = 4249
+# GD:            leaq 4249(%rip), %rax
+# GD-NEXT: 1007: callq *(%rax)
+# GD-NEXT:       movl %fs:(%rax), %eax
+
+# 0x20b0-0x1013 = 4253
+# GD-NEXT:       leaq 4253(%rip), %rax
+# GD-NEXT: 1013: callq *(%rax)
+# GD-NEXT:       movl %fs:(%rax), %eax
+
+# NOREL: no relocations
+
+## offset(a) = -4
+# LE:      movq $-4, %rax
+# LE-NEXT: nop
+# LE-NEXT: movl %fs:(%rax), %eax
+## offset(b) = 0
+# LE:      movq $0, %rax
+# LE-NEXT: nop
+# LE-NEXT: movl %fs:(%rax), %eax
+
+# IE-REL:      .rela.dyn {
+# IE-REL-NEXT:   0x2020C0 R_X86_64_TPOFF64 b 0x0
+# IE-REL-NEXT: }
+
+## a is relaxed to use LE.
+# IE:              movq $-4, %rax
+# IE-NEXT:         nop
+# IE-NEXT:         movl %fs:(%rax), %eax
+## 0x2020C0 - 0x201013 = 4269
+# IE-NEXT:         movq 4269(%rip), %rax
+# IE-NEXT: 201013: nop
+# IE-NEXT:         movl %fs:(%rax), %eax
+
+leaq a@tlsdesc(%rip), %rax
+call *a@tlscall(%rax)
+movl %fs:(%rax), %eax
+
+leaq b@tlsdesc(%rip), %rax
+call *b@tlscall(%rax)
+movl %fs:(%rax), %eax
+
+.section .tbss
+.globl a
+.zero 8
+a:
+.zero 4