[X86] Fix x86-64 call *foo@tlsdesc(reg) and support R_386_TLSGOTDESC R_386_TLS_DESC_CALL

[MaskRay]

Summary

D18885 emitted 5 bytes for call *foo@tlsdesc(%rax). It should use the
2-byte form instead and let R_X86_64_TLSDESC_CALL apply to the beginning
of the call instruction.

The 2-byte form was deliberately chosen to make ->LE and ->IE relaxation work:

0:   48 8d 05 00 00 00 00    lea    0x0(%rip),%rax        # 7 <.text+0x7>
                     3: R_X86_64_GOTPC32_TLSDESC     a-0x4
7:   ff 10                   callq  *(%rax)
                     7: R_X86_64_TLSDESC_CALL        a

>

0:   48 c7 c0 fc ff ff ff    mov    $0xfffffffffffffffc,%rax
7:   66 90                   xchg   %ax,%ax

[MaskRay]

Change symbol type

[compnerd]

This looks good

llvm/trunk/lib/MC/MCELFStreamer.cpp

case MCExpr::SymbolRef: {
     const MCSymbolRefExpr &symRef = *cast<MCSymbolRefExpr>(expr);
     switch (symRef.getKind()) {
     default:
       return;
     case MCSymbolRefExpr::VK_GOTTPOFF:
     case MCSymbolRefExpr::VK_INDNTPOFF:
     case MCSymbolRefExpr::VK_NTPOFF:
     case MCSymbolRefExpr::VK_GOTNTPOFF:
+    case MCSymbolRefExpr::VK_TLSCALL:
+    case MCSymbolRefExpr::VK_TLSDESC:
     case MCSymbolRefExpr::VK_TLSGD:
     case MCSymbolRefExpr::VK_TLSLD:
     case MCSymbolRefExpr::VK_TLSLDM:
     case MCSymbolRefExpr::VK_TPOFF:
     case MCSymbolRefExpr::VK_TPREL:
     case MCSymbolRefExpr::VK_DTPOFF:
     case MCSymbolRefExpr::VK_DTPREL:
     case MCSymbolRefExpr::VK_PPC_DTPMOD:

llvm/trunk/lib/Target/X86/MCTargetDesc/X86ELFObjectWriter.cpp

if (!Ctx.getAsmInfo()->canRelaxRelocations())
       return ELF::R_386_GOT32;
 
     return Kind == X86::reloc_signed_4byte_relax ? ELF::R_386_GOT32X
                                                  : ELF::R_386_GOT32;
   case MCSymbolRefExpr::VK_GOTOFF:
     assert(Type == RT32_32);
     assert(!IsPCRel);
     return ELF::R_386_GOTOFF;
+  case MCSymbolRefExpr::VK_TLSCALL:
+    return ELF::R_386_TLS_DESC_CALL;
+  case MCSymbolRefExpr::VK_TLSDESC:
+    return ELF::R_386_TLS_GOTDESC;
   case MCSymbolRefExpr::VK_TPOFF:
     assert(Type == RT32_32);
     assert(!IsPCRel);
     return ELF::R_386_TLS_LE_32;
   case MCSymbolRefExpr::VK_DTPOFF:
     assert(Type == RT32_32);
     assert(!IsPCRel);
     return ELF::R_386_TLS_LDO_32;

llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCCodeEmitter.cpp

if (BaseReg == 0) {          // [disp32]     in X86-32 mode
       EmitImmediate(Disp, MI.getLoc(), 4, FK_Data_4, CurByte, OS, Fixups);
       return;
     }
 
     // If the base is not EBP/ESP and there is no displacement, use simple
     // indirect register encoding, this handles addresses like [EAX].  The
     // encoding for [EBP] with no displacement means [disp32] so we handle it
     // by emitting a displacement of 0 below.
-    if (Disp.isImm() && Disp.getImm() == 0 && BaseRegNo != N86::EBP) {
+    if (BaseRegNo != N86::EBP) {
+      if (Disp.isImm() && Disp.getImm() == 0) {
         EmitByte(ModRMByte(0, RegOpcodeField, BaseRegNo), CurByte, OS);
         return;
       }
 
+      // If the displacement is @tlscall, treat it as a zero.
+      if (Disp.isExpr()) {
+        auto *Sym = dyn_cast<MCSymbolRefExpr>(Disp.getExpr());
+        if (Sym && Sym->getKind() == MCSymbolRefExpr::VK_TLSCALL) {
+          // This is exclusively used by call *a@tlscall(base). The relocation
+          // (R_386_TLSCALL or R_X86_64_TLSCALL) applies to the beginning.
+          Fixups.push_back(MCFixup::create(0, Sym, FK_NONE, MI.getLoc()));
+          EmitByte(ModRMByte(0, RegOpcodeField, BaseRegNo), CurByte, OS);
+          return;
+        }
+      }
+    }
+
     // Otherwise, if the displacement fits in a byte, encode as [REG+disp8].
     if (Disp.isImm()) {
       if (!HasEVEX && isDisp8(Disp.getImm())) {
         EmitByte(ModRMByte(1, RegOpcodeField, BaseRegNo), CurByte, OS);
         EmitImmediate(Disp, MI.getLoc(), 1, FK_Data_1, CurByte, OS, Fixups);
         return;
       }
       // Try EVEX compressed 8-bit displacement first; if failed, fall back to

llvm/trunk/test/MC/ELF/relocation-tls.s

-// RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o - | llvm-readobj -S --sr | FileCheck  %s
-
-// Test that we produce the correct relocation.
-
-        leaq    _ZL3ccc@TLSDESC(%rip), %rax
-        call    *_ZL3ccc@TLSCALL(%rax)
-        addq    %fs:0, %rax
-
-// CHECK: Section {
-// CHECK:   Index:
-// CHECK:   Name: .rela.text
-// CHECK-NEXT:   Type: SHT_RELA
-// CHECK-NEXT:   Flags [
-// CHECK-NEXT:   ]
-// CHECK-NEXT:   Address: 0x0
-// CHECK-NEXT:   Offset:
-// CHECK-NEXT:   Size:
-// CHECK-NEXT:   Link:
-// CHECK-NEXT:   Info:
-// CHECK-NEXT:   AddressAlignment: 8
-// CHECK-NEXT:   EntrySize: 24
-// CHECK-NEXT:   Relocations [
-// CHECK-NEXT:     0x3 R_X86_64_GOTPC32_TLSDESC _ZL3ccc 0xFFFFFFFFFFFFFFFC
-// CHECK-NEXT:     0x9 R_X86_64_TLSDESC_CALL _ZL3ccc 0x0
-// CHECK-NEXT:   ]
-// CHECK-NEXT: }

llvm/trunk/test/MC/X86/tlsdesc-32.s

+# RUN: llvm-mc -triple i386-pc-linux-musl %s | FileCheck --check-prefix=PRINT %s
+
+# RUN: llvm-mc -filetype=obj -triple i386-pc-linux-musl %s -o %t
+# RUN: llvm-readelf -s %t | FileCheck --check-prefix=SYM %s
+# RUN: llvm-objdump -dr --no-show-raw-insn %t | FileCheck %s
+
+# PRINT:      leal a@tlsdesc(%ebx), %eax
+# PRINT-NEXT: calll *a@tlscall(%eax)
+
+# SYM: TLS GLOBAL DEFAULT UND a
+
+# CHECK:      0: leal (%ebx), %eax
+# CHECK-NEXT:   00000002: R_386_TLS_GOTDESC a
+# CHECK-NEXT: 6: calll *(%eax)
+# CHECK-NEXT:   00000006: R_386_TLS_DESC_CALL a
+
+leal a@tlsdesc(%ebx), %eax
+call *a@tlscall(%eax)
+addl %gs:0, %eax

llvm/trunk/test/MC/X86/tlsdesc-64.s

+# RUN: llvm-mc -triple x86_64-pc-linux-musl %s | FileCheck --check-prefix=PRINT %s
+
+# RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-musl %s -o %t
+# RUN: llvm-readelf -s %t | FileCheck --check-prefix=SYM %s
+# RUN: llvm-objdump -dr --no-show-raw-insn %t | FileCheck --match-full-lines %s
+
+# PRINT:      leaq a@tlsdesc(%rip), %rax
+# PRINT-NEXT: callq *a@tlscall(%rax)
+
+# SYM: TLS GLOBAL DEFAULT UND a
+
+# CHECK:      0: leaq (%rip), %rax
+# CHECK-NEXT:   0000000000000003: R_X86_64_GOTPC32_TLSDESC a-4
+# CHECK-NEXT: 7: callq *(%rax)
+# CHECK-NEXT:   0000000000000007: R_X86_64_TLSDESC_CALL a
+
+leaq a@tlsdesc(%rip), %rax
+call *a@tlscall(%rax)
+addq %fs:0, %rax