[ELF][X86] Support TLS GD/LD relaxation for gcc -fno-plt

[MaskRay]

Summary

gcc -fno-plt uses call *___tls_get_addr@GOT(%reg) instead of call ___tls_get_addr@PLT.
GD to IE/LE relaxations need to shift the offset by one while LD to LE relaxation needs to use a different code sequence.

lld/ELF/Arch/X86.cpp

case R_386_TLS_DESC:
     break;
   default:
     llvm_unreachable("unknown relocation");
   }
 }
 
 static void relaxTlsGdToLe(uint8_t *loc, const Relocation &rel, uint64_t val) {
   if (rel.type == R_386_TLS_GD) {
-    // Convert
+    // Convert (loc[-2] == 0x04)
     //   leal x@tlsgd(, %ebx, 1), %eax
     //   call __tls_get_addr@plt
+    // or
+    //   leal x@tlsgd(%reg), %eax
+    //   call *__tls_get_addr@GOT(%reg)
     // to
-    //   movl %gs:0, %eax
-    //   subl $x@tpoff, %eax
     const uint8_t inst[] = {
         0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0, %eax
-        0x81, 0xe8, 0,    0,    0,    0,    // subl val(%ebx), %eax
+        0x81, 0xe8, 0,    0,    0,    0,    // subl x@tpoff(%ebx), %eax
     };
-    memcpy(loc - 3, inst, sizeof(inst));
-    write32le(loc + 5, val);
+    uint8_t *w = loc[-2] == 0x04 ? loc - 3 : loc - 2;
+    memcpy(w, inst, sizeof(inst));
+    write32le(w + 8, val);
   } else if (rel.type == R_386_TLS_GOTDESC) {
     // Convert leal x@tlsdesc(%ebx), %eax to leal x@ntpoff, %eax.
     //
     // Note: call *x@tlsdesc(%eax) may not immediately follow this instruction.
     if (memcmp(loc - 2, "\x8d\x83", 2)) {
       error(getErrorLocation(loc - 2) +
             "R_386_TLS_GOTDESC must be used in leal x@tlsdesc(%ebx), %eax");
       return;
     }
     loc[-1] = 0x05;
     write32le(loc, val);
   } else {
     // Convert call *x@tlsdesc(%eax) to xchg ax, ax.
     assert(rel.type == R_386_TLS_DESC_CALL);
     loc[0] = 0x66;
     loc[1] = 0x90;
   }
 }
 
 static void relaxTlsGdToIe(uint8_t *loc, const Relocation &rel, uint64_t val) {
   if (rel.type == R_386_TLS_GD) {
-    // Convert
+    // Convert (loc[-2] == 0x04)
     //   leal x@tlsgd(, %ebx, 1), %eax
     //   call __tls_get_addr@plt
-    // to
-    //   movl %gs:0, %eax
-    //   addl x@gotntpoff(%ebx), %eax
+    // or
+    //   leal x@tlsgd(%reg), %eax
+    //   call *__tls_get_addr@GOT(%reg)
     const uint8_t inst[] = {
         0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0, %eax
-        0x03, 0x83, 0,    0,    0,    0,    // addl val(%ebx), %eax
+        0x03, 0x83, 0,    0,    0,    0,    // addl x@gotntpoff(%ebx), %eax
     };
-    memcpy(loc - 3, inst, sizeof(inst));
-    write32le(loc + 5, val);
+    uint8_t *w = loc[-2] == 0x04 ? loc - 3 : loc - 2;
+    memcpy(w, inst, sizeof(inst));
+    write32le(w + 8, val);
   } else if (rel.type == R_386_TLS_GOTDESC) {
     // Convert leal x@tlsdesc(%ebx), %eax to movl x@gotntpoff(%ebx), %eax.
     if (memcmp(loc - 2, "\x8d\x83", 2)) {
       error(getErrorLocation(loc - 2) +
             "R_386_TLS_GOTDESC must be used in leal x@tlsdesc(%ebx), %eax");
       return;
     }
     loc[-2] = 0x8b;

 }
 
 static void relaxTlsLdToLe(uint8_t *loc, const Relocation &rel, uint64_t val) {
   if (rel.type == R_386_TLS_LDO_32) {
     write32le(loc, val);
     return;
   }
 
+  if (loc[4] == 0xe8) {
     // Convert
-  //   leal foo(%reg),%eax
+    //   leal x(%reg),%eax
     //   call ___tls_get_addr
     // to
-  //   movl %gs:0,%eax
-  //   nop
-  //   leal 0(%esi,1),%esi
     const uint8_t inst[] = {
         0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0,%eax
         0x90,                               // nop
         0x8d, 0x74, 0x26, 0x00,             // leal 0(%esi,1),%esi
     };
     memcpy(loc - 2, inst, sizeof(inst));
+    return;
+  }
+
+  // Convert
+  //   leal x(%reg),%eax
+  //   call *___tls_get_addr@GOT(%reg)
+  // to
+  const uint8_t inst[] = {
+      0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0,%eax
+      0x8d, 0xb6, 0x00, 0x00, 0x00, 0x00, // leal (%esi),%esi
+  };
+  memcpy(loc - 2, inst, sizeof(inst));
 }
 
 void X86::relocateAlloc(InputSectionBase &sec, uint8_t *buf) const {
   uint64_t secAddr = sec.getOutputSection()->addr;
   if (auto *s = dyn_cast<InputSection>(&sec))
     secAddr += s->outSecOff;
   for (const Relocation &rel : sec.relocs()) {
     uint8_t *loc = buf + rel.offset;

lld/test/ELF/i386-tls-gdiele.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686 %p/Inputs/tls-opt-gdiele-i686.s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=i686 %s -o %t1.o
 // RUN: ld.lld -shared %t.o -soname=t.so -o %t.so
 // RUN: ld.lld --hash-style=sysv %t1.o %t.so -o %tout
 // RUN: llvm-readobj -r %tout | FileCheck --check-prefix=NORELOC %s
 // RUN: llvm-objdump --no-print-imm-hex -d --no-show-raw-insn %tout | FileCheck --check-prefix=DISASM %s
 
 // NORELOC:      Relocations [
 // NORELOC-NEXT: Section ({{.*}}) .rel.dyn {
-// NORELOC-NEXT:   0x402258 R_386_TLS_TPOFF tlsshared0
-// NORELOC-NEXT:   0x40225C R_386_TLS_TPOFF tlsshared1
+// NORELOC-NEXT:   0x402270 R_386_TLS_TPOFF tlsshared0
+// NORELOC-NEXT:   0x402274 R_386_TLS_TPOFF tlsshared1
 // NORELOC-NEXT:   }
 // NORELOC-NEXT: ]
 
 // DISASM:      Disassembly of section .text:
 // DISASM-EMPTY:
 // DISASM-NEXT: <_start>:
 // DISASM-NEXT: 4011d0:       movl %gs:0, %eax
 // DISASM-NEXT:               addl -4104(%ebx), %eax
 // DISASM-NEXT:               movl %gs:0, %eax
 // DISASM-NEXT:               addl -4100(%ebx), %eax
 // DISASM-NEXT:               movl %gs:0, %eax
 // DISASM-NEXT:               subl $8, %eax
 // DISASM-NEXT:               movl %gs:0, %eax
 // DISASM-NEXT:               subl $4, %eax
+// DISASM-NEXT:               movl %gs:0, %eax
+// DISASM-NEXT:               addl -4100(%ebx), %eax
+// DISASM-NEXT:               movl %gs:0, %eax
+// DISASM-NEXT:               subl $4, %eax
 
 .type tlsexe1,@object
 .section .tbss,"awT",@nobits
 .globl tlsexe1
 .align 4
 tlsexe1:
  .long 0
  .size tlsexe1, 4

 call ___tls_get_addr@plt
 leal tlsshared1@tlsgd(,%ebx,1),%eax
 call ___tls_get_addr@plt
 //GD->LE
 leal tlsexe1@tlsgd(,%ebx,1),%eax
 call ___tls_get_addr@plt
 leal tlsexe2@tlsgd(,%ebx,1),%eax
 call ___tls_get_addr@plt
+
+// -fno-plt GD->IE and GD->LE
+leal tlsshared1@tlsgd(%edx),%eax
+call *___tls_get_addr@GOT(%edx)
+leal tlsexe2@tlsgd(%edx),%eax
+call *___tls_get_addr@GOT(%edx)

lld/test/ELF/i386-tls-opt.s

 // DISASM-NEXT:   movl %gs:0, %eax
 // DISASM-NEXT:   nop
 // DISASM-NEXT:   leal (%esi,%eiz), %esi
 // DISASM-NEXT:   leal -8(%eax), %edx
 // DISASM-NEXT:   movl %gs:0, %eax
 // DISASM-NEXT:   nop
 // DISASM-NEXT:   leal (%esi,%eiz), %esi
 // DISASM-NEXT:   leal -4(%eax), %edx
+// DISASM-NEXT:   movl %gs:0, %eax
+// DISASM-NEXT:   leal (%esi), %esi
+// DISASM-NEXT:   movl -4(%eax), %edx
 // IE -> LE:
 // 4294967288 == 0xFFFFFFF8
 // 4294967292 == 0xFFFFFFFC
 // DISASM-NEXT:   movl %gs:0, %eax
 // DISASM-NEXT:   movl $4294967288, %eax
 // DISASM-NEXT:   movl %gs:0, %eax
 // DISASM-NEXT:   movl $4294967292, %eax
 // DISASM-NEXT:   movl %gs:0, %eax

 _start:
 //LD -> LE:
 leal tls0@tlsldm(%ebx),%eax
 call ___tls_get_addr@plt
 leal tls0@dtpoff(%eax),%edx
 leal tls1@tlsldm(%ebx),%eax
 call ___tls_get_addr@plt
 leal tls1@dtpoff(%eax),%edx
+// -fno-plt LD -> LE
+leal tls1@tlsldm(%edx),%eax
+call *___tls_get_addr@GOT(%edx)
+movl tls1@dtpoff(%eax), %edx
 //IE -> LE:
 movl %gs:0,%eax
 movl tls0@gotntpoff(%ebx),%eax
 movl %gs:0,%eax
 movl tls1@gotntpoff(%ebx),%eax
 movl %gs:0,%eax
 addl tls0@gotntpoff(%ebx),%eax
 movl %gs:0,%eax
 addl tls1@gotntpoff(%ebx),%eax