[ELF] Reject local-exec TLS relocations for -shared

[MaskRay]

Summary

For x86-64, D33100 added a diagnostic for local-exec TLS relocations referencing a preemptible symbol.

This patch generalizes it to non-preemptible symbols (see -Bsymbolic in tls.s)
on all targets.

Local-exec TLS relocations resolve to offsets relative to a fixed point within
the static TLS block, which are only meaningful for the executable.

With this change, clang -fpic -shared -fuse-ld=bfd a.c on the following example will be flagged for AArch64/ARM/i386/x86-64/PowerPC/RISC-V

static __attribute__((tls_model("local-exec"))) __thread long TlsVar = 42;
long bump() { return ++TlsVar; }

Note, in GNU ld, at least arm, riscv and x86's ports have the similar
diagnostics, but aarch64 and ppc64 do not error.

[MaskRay]

Improve i386-tls-le.s

lld/test/ELF/ppc64-local-exec-tls.s

17

Note this test is not well organized. All the relocation types have been checked so I'll not add --implicit-check-not=error:

[rprichard]

It looks OK to me.

lld/ELF/Relocations.cpp

1401

I think this should also check for R_NEG_TLS. AFAIK R_NEG_TLS/R_386_TLS_LE_32 is only used on 32-bit x86, and compilers usually prefer R_TLS/R_386_TLS_LE, but it's possible to bypass the new error with assembly:

movl %gs:TlsVar@NTPOFF, %eax ==> R_TLS
movl %gs:TlsVar@TPOFF, %eax ==> R_NEG_TLS

[MaskRay]

Reject R_NEG_TLS

[MaskRay]

lld/ELF/Relocations.cpp

1401

Thanks. R_386_TLS_LE_32 is an obsoleted Solaris TLS relocation type.

[jhenderson]

lld/ELF/Relocations.cpp

1408

handleTlsRelocation has a number of config->shared checks. Can these be dropped given this new diagnostic?

[MaskRay]

lld/ELF/Relocations.cpp

1408

No. The config->shared checks in handleTlsRelocation are about whether GD/LD/IE can be relaxed to IE/LE.

This check is about LE in -shared.

Actually, R_TLS should really be renamed to R_TPOFFSET to be less confusing and I am going to send such a patch.

[MaskRay]

-> R_TPREL/R_TPREL_NEG

[grimar]

X86 part looks good to me.

lld/ELF/Relocations.cpp

static void scanReloc(InputSectionBase &sec, OffsetGetter &getOffset, RelTy *&i,
   // 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)) {
     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 some TLS relocations, including relaxing TLS relocations.
-  // Note that this function does not handle all TLS relocations.
-  if (unsigned processed =
-          handleTlsRelocation<ELFT>(type, sym, sec, offset, addend, expr)) {
+  // Process TLS relocations, including relaxing TLS relocations. Note that
+  // R_TLS relocations are resolved in processRelocAux.
+  if (expr == R_TLS) {
+    if (config->shared) {
+      errorOrWarn("relocation " + toString(type) + " against " + toString(sym) +
+                  " cannot be used with -shared" +
+                  getLocation(sec, sym, offset));
+      return;
+    }
+  } else if (unsigned processed = handleTlsRelocation<ELFT>(
+                 type, sym, sec, offset, addend, expr)) {
     i += (processed - 1);
     return;
   }
 
   // We were asked not to generate PLT entries for ifuncs. Instead, pass the
   // direct relocation on through.
   if (sym.isGnuIFunc() && config->zIfuncNoplt) {
     sym.exportDynamic = true;

lld/test/ELF/Inputs/i386-static-tls-model4.s

-.section ".tdata", "awT", @progbits
-.globl var
-var:
-
-.section .foo, "aw"
-.global _start
-_start:
- movl %gs:0, %eax
- leal var@ntpoff(%eax), %eax # R_386_TLS_LE

lld/test/ELF/aarch64-tls-le.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-unknown-freebsd %s -o %tmain.o
 # RUN: ld.lld %tmain.o -o %tout
 # RUN: llvm-objdump -d %tout | FileCheck %s
 # RUN: llvm-readobj -S -r %tout | FileCheck -check-prefix=RELOC %s
 
 #Local-Dynamic to Local-Exec relax creates no
 #RELOC:      Relocations [
 #RELOC-NEXT: ]
 
+## Reject local-exec TLS relocations for -shared.
+# RUN: not ld.lld -shared %tmain.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR --implicit-check-not=error:
+
+# ERR: error: relocation R_AARCH64_TLSLE_ADD_TPREL_HI12 against v1 cannot be used with -shared
+# ERR: error: relocation R_AARCH64_TLSLE_ADD_TPREL_LO12_NC against v1 cannot be used with -shared
+# ERR: error: relocation R_AARCH64_TLSLE_ADD_TPREL_HI12 against v2 cannot be used with -shared
+# ERR: error: relocation R_AARCH64_TLSLE_ADD_TPREL_LO12_NC against v2 cannot be used with -shared
+
 .globl _start
 _start:
  mrs x0, TPIDR_EL0
  add x0, x0, :tprel_hi12:v1
  add x0, x0, :tprel_lo12_nc:v1
  mrs x0, TPIDR_EL0
  add x0, x0, :tprel_hi12:v2
  add x0, x0, :tprel_lo12_nc:v2

lld/test/ELF/arm-tls-le32.s

 // REQUIRES: arm
 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=armv7a-linux-gnueabi
 // RUN: ld.lld %t.o -o %t
 // RUN: llvm-readobj -S --dyn-relocations %t | FileCheck --check-prefix=SEC %s
 // RUN: llvm-objdump -d --triple=armv7a-linux-gnueabi %t | FileCheck %s
 
 /// Test the handling of the local exec TLS model. TLS can be resolved
 /// statically for an application. The code sequences assume a thread pointer
 /// in r9
 
+/// Reject local-exec TLS relocations for -shared.
+// RUN: not ld.lld -shared %t.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR --implicit-check-not=error:
+
+// ERR: error: relocation R_ARM_TLS_LE32 against x cannot be used with -shared
+// ERR: error: relocation R_ARM_TLS_LE32 against y cannot be used with -shared
+// ERR: error: relocation R_ARM_TLS_LE32 against z cannot be used with -shared
+
  .text
  .syntax unified
  .globl  _start
  .p2align        2
  .type   _start,%function
 _start:
  .p2align        2
 /// Generate R_ARM_TLS_LE32 relocations. These resolve statically to the offset

lld/test/ELF/i386-static-tls-model.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %S/Inputs/i386-static-tls-model1.s -o %t.o
 # RUN: ld.lld %t.o -o %t1 -shared
 # RUN: llvm-readobj --dynamic-table %t1 | FileCheck %s
 
 # RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %S/Inputs/i386-static-tls-model2.s -o %t.o
 # RUN: ld.lld %t.o -o %t2 -shared
 # RUN: llvm-readobj --dynamic-table %t2 | FileCheck %s
 
 # RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %S/Inputs/i386-static-tls-model3.s -o %t.o
 # RUN: ld.lld %t.o -o %t3 -shared
 # RUN: llvm-readobj --dynamic-table %t3 | FileCheck %s
 
-# RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %S/Inputs/i386-static-tls-model4.s -o %t.o
-# RUN: ld.lld %t.o -o %t4 -shared
-# RUN: llvm-readobj --dynamic-table %t4 | FileCheck %s
-
 # CHECK: DynamicSection [
 # CHECK: FLAGS STATIC_TLS

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

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i686 %s -o %t.o
 # RUN: ld.lld %t.o -o %t
-# RUN: ld.lld %t.o -shared -o %t.so
+# RUN: ld.lld %t.o -pie -o %t.pie
 # RUN: llvm-objdump -d --no-show-raw-insn %t | FileCheck %s --check-prefix=DIS
 # RUN: llvm-readobj -r %t | FileCheck %s --check-prefix=RELOC
-# RUN: llvm-objdump -d --no-show-raw-insn %t.so | FileCheck %s --check-prefix=DISSHARED
-# RUN: llvm-readobj -r %t.so | FileCheck %s --check-prefix=RELOCSHARED
+# RUN: llvm-objdump -d --no-show-raw-insn %t.so | FileCheck %s --check-prefix=DIS
+# RUN: llvm-readobj -r %t.pie | FileCheck %s --check-prefix=RELOC
+
+## Reject local-exec TLS relocations for -shared.
+# RUN: not ld.lld -shared %t.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR
+
+# ERR: error: relocation R_386_TLS_LE against var cannot be used with -shared
+# ERR: error: relocation R_386_TLS_LE against var1 cannot be used with -shared
 
 .section ".tdata", "awT", @progbits
 .globl var
 .globl var1
 var:
 .long 0
 var1:
 .long 1

  movl %gs:0, %ecx
  leal var@ntpoff(%ecx), %eax
  movl %gs:0, %ecx
  leal var1@ntpoff+123(%ecx), %eax
 
 # DIS:      Disassembly of section test:
 # DIS-EMPTY:
 # DIS-NEXT: <_start>:
-# DIS-NEXT: 402134:       movl    $8, %edx
-# DIS-NEXT: 402139:       movl    %gs:0, %ecx
-# DIS-NEXT: 402140:       subl    %edx, %eax
-# DIS-NEXT: 402142:       movl    $4, %edx
-# DIS-NEXT: 402147:       movl    %gs:0, %ecx
-# DIS-NEXT: 40214e:       subl    %edx, %eax
-# DIS-NEXT: 402150:       movl    %gs:0, %ecx
-# DIS-NEXT: 402157:       leal    -8(%ecx), %eax
-# DIS-NEXT: 40215d:       movl    %gs:0, %ecx
-# DIS-NEXT: 402164:       leal    119(%ecx), %eax
+# DIS-NEXT:   movl    $8, %edx
+# DIS-NEXT:   movl    %gs:0, %ecx
+# DIS-NEXT:   subl    %edx, %eax
+# DIS-NEXT:   movl    $4, %edx
+# DIS-NEXT:   movl    %gs:0, %ecx
+# DIS-NEXT:   subl    %edx, %eax
+# DIS-NEXT:   movl    %gs:0, %ecx
+# DIS-NEXT:   leal    -8(%ecx), %eax
+# DIS-NEXT:   movl    %gs:0, %ecx
+# DIS-NEXT:   leal    119(%ecx), %eax
 
 # RELOC: Relocations [
 # RELOC-NEXT: ]
 
 # DISSHARED: Disassembly of section test:
 # DISSHARED-EMPTY:
 # DISSHARED-NEXT: <_start>:
-# DISSHARED-NEXT: 2218:       movl    $0, %edx
-# DISSHARED-NEXT: 221d:       movl    %gs:0, %ecx
-# DISSHARED-NEXT: 2224:       subl    %edx, %eax
-# DISSHARED-NEXT: 2226:       movl    $0, %edx
-# DISSHARED-NEXT: 222b:       movl    %gs:0, %ecx
-# DISSHARED-NEXT: 2232:       subl    %edx, %eax
-# DISSHARED-NEXT: 2234:       movl    %gs:0, %ecx
-# DISSHARED-NEXT: 223b:       leal    (%ecx), %eax
-# DISSHARED-NEXT: 2241:       movl    %gs:0, %ecx
-# DISSHARED-NEXT: 2248:       leal    123(%ecx), %eax
+# DISSHARED-NEXT:   movl    $8, %edx
+# DISSHARED-NEXT:   movl    %gs:0, %ecx
+# DISSHARED-NEXT:   subl    %edx, %eax
+# DISSHARED-NEXT:   movl    $0, %edx
+# DISSHARED-NEXT:   movl    %gs:0, %ecx
+# DISSHARED-NEXT:   subl    %edx, %eax
+# DISSHARED-NEXT:   movl    %gs:0, %ecx
+# DISSHARED-NEXT:   leal    (%ecx), %eax
+# DISSHARED-NEXT:   movl    %gs:0, %ecx
+# DISSHARED-NEXT:   leal    123(%ecx), %eax
 
 # RELOCSHARED:      Relocations [
-# RELOCSHARED-NEXT: Section (5) .rel.dyn {
+# RELOCSHARED-NEXT: Section ({{.*}}) .rel.dyn {
 # RELOCSHARED-NEXT:   0x2219 R_386_TLS_TPOFF32 var
 # RELOCSHARED-NEXT:   0x223D R_386_TLS_TPOFF var
 # RELOCSHARED-NEXT:   0x2227 R_386_TLS_TPOFF32 var1
 # RELOCSHARED-NEXT:   0x224A R_386_TLS_TPOFF var1
 # RELOCSHARED-NEXT:  }
 # RELOCSHARED-NEXT: ]

lld/test/ELF/i386-zrel-zrela.s

 # REL-NEXT:   R_386_TLS_TPOFF tls
 # REL-NEXT:   R_386_32 _start
 # REL-NEXT: }
 # REL-NEXT: .rel.plt {
 # REL-NEXT:   R_386_JUMP_SLOT func
 # REL-NEXT: }
 
 # REL:      Hex dump of section '.data':
-# REL-NEXT: 0x000042cc cc420000 2a000000
+# REL-NEXT: 0x000042d0 d0420000 2a000000
 
 # RUN: ld.lld -shared -z rel -z rela %t.o -o %t2.so
 # RUN: llvm-readobj -d -r %t2.so | FileCheck --check-prefix=RELA %s
 
 # RELA:      RELA      {{.*}}
 # RELA-NEXT: RELASZ    48 (bytes)
 # RELA-NEXT: RELAENT   12 (bytes)
 # RELA-NEXT: RELACOUNT 1
 # RELA-NEXT: JMPREL    {{.*}}
 # RELA-NEXT: PLTRELSZ  12 (bytes)
 # RELA-NEXT: PLTGOT    {{.*}}
 # RELA-NEXT: PLTREL    RELA
 # RELA:      .rela.dyn {
-# RELA-NEXT:   R_386_RELATIVE - 0x42EC
+# RELA-NEXT:   R_386_RELATIVE - 0x42F0
 # RELA-NEXT:   R_386_GLOB_DAT func 0x0
-# RELA-NEXT:   R_386_TLS_TPOFF tls 0x2A
+# RELA-NEXT:   R_386_TLS_TPOFF tls 0x0
 # RELA-NEXT:   R_386_32 _start 0x2A
 # RELA-NEXT: }
 # RELA-NEXT: .rela.plt {
 # RELA-NEXT:   R_386_JUMP_SLOT func 0x0
 # RELA-NEXT: }
 
 .globl _start
 _start:
   call func@PLT
   movl func@GOT(%eax), %eax
 
 .section .text1,"awx"
-  movl %gs:tls@NTPOFF+42, %eax
+  movl tls@GOTNTPOFF(%eax), %eax
 
 .data
   .long .data
   .long _start+42

lld/test/ELF/mips-tls-hilo.s

 # REQUIRES: mips
 # Check MIPS R_MIPS_TLS_DTPREL_HI16/LO16 and R_MIPS_TLS_TPREL_HI16/LO16
 # relocations handling.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t.exe
 # RUN: llvm-objdump -d -t --no-show-raw-insn %t.exe | FileCheck --check-prefix=DIS %s
 # RUN: llvm-readobj -r -A %t.exe | FileCheck %s
 
-# RUN: ld.lld %t.o -shared -o %t.so
-# RUN: llvm-readobj -r -A %t.so | FileCheck -check-prefix=SO %s
+# RUN: not ld.lld %t.o -shared -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR --implicit-check-not=error:
+
+# ERR: error: relocation R_MIPS_TLS_TPREL_HI16 against loc0 cannot be used with -shared
+# ERR: error: relocation R_MIPS_TLS_TPREL_LO16 against loc0 cannot be used with -shared
 
 # DIS: 00000000 l    O .tdata          00000000 loc0
 
 # DIS:      <__start>:
 # DIS-NEXT:    addiu   $2, $3, 0
 #                              ^-- %hi(loc0 - .tdata - 0x8000)
 # DIS-NEXT:    addiu   $2, $3, -32768
 #                              ^-- %lo(loc0 - .tdata - 0x8000)

lld/test/ELF/ppc64-local-exec-tls.s

 // REQUIRES: ppc
 // RUN: llvm-mc -filetype=obj -triple=powerpc64le-unknown-linux %s -o %t.o
 // RUN: ld.lld  %t.o -o %t
 // RUN: llvm-readelf -r %t.o | FileCheck --check-prefix=InputRelocs %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=Dis %s
 
+// RUN: not ld.lld -shared %t.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR
+
+/// Reject local-exec TLS relocations for -shared.
+// ERR: error: relocation R_PPC64_TPREL16_HA against a cannot be used with -shared
+// ERR: error: relocation R_PPC64_TPREL16_LO against a cannot be used with -shared
+// ERR: error: relocation R_PPC64_TPREL16 against b cannot be used with -shared
+// ERR: error: relocation R_PPC64_TPREL16_HI against b cannot be used with -shared
+// ERR: error: relocation R_PPC64_TPREL16_DS against b cannot be used with -shared
+// ERR: error: relocation R_PPC64_TPREL16_LO_DS against b cannot be used with -shared
+// ERR: error: relocation R_PPC64_TPREL16_HIGHESTA against b cannot be used with -shared
+// ERR: error: relocation R_PPC64_TPREL16_HIGHERA against b cannot be used with -shared
+
   .text
   .abiversion 2
   .globl  test_local_exec                    # -- Begin function test_local_exec
   .p2align  4
   .type test_local_exec,@function
 test_local_exec:                                   # @test_local_exec
 .Lfunc_begin0:
 # %bb.0:                                # %entry

lld/test/ELF/riscv-tls-le.s

 # REQUIRES: riscv
 
 # RUN: llvm-mc -filetype=obj -triple=riscv32 %s -o %t.32.o
 # RUN: ld.lld %t.32.o -o %t.32
 # RUN: llvm-nm -p %t.32 | FileCheck --check-prefixes=NM %s
 # RUN: llvm-objdump -d --no-show-raw-insn %t.32 | FileCheck --check-prefixes=LE %s
 # RUN: ld.lld -pie %t.32.o -o %t.32
 # RUN: llvm-objdump -d --no-show-raw-insn %t.32 | FileCheck --check-prefixes=LE %s
 
 # RUN: llvm-mc -filetype=obj -triple=riscv64 %s -o %t.64.o
 # RUN: ld.lld %t.64.o -o %t.64
 # RUN: llvm-objdump -d --no-show-raw-insn %t.64 | FileCheck --check-prefixes=LE %s
 # RUN: ld.lld -pie %t.64.o -o %t.64
 # RUN: llvm-objdump -d --no-show-raw-insn %t.64 | FileCheck --check-prefixes=LE %s
 
+# RUN: not ld.lld -shared %t.32.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR --implicit-check-not=error:
+
+# ERR: error: relocation R_RISCV_TPREL_HI20 against .LANCHOR0 cannot be used with -shared
+# ERR: error: relocation R_RISCV_TPREL_LO12_I against .LANCHOR0 cannot be used with -shared
+# ERR: error: relocation R_RISCV_TPREL_HI20 against a cannot be used with -shared
+# ERR: error: relocation R_RISCV_TPREL_LO12_S against a cannot be used with -shared
+
 # NM: {{0*}}00000008 b .LANCHOR0
 # NM: {{0*}}0000000c B a
 
 ## .LANCHOR0@tprel = 8
 ## a@tprel = 12
 # LE:      lui a5, 0
 # LE-NEXT: add a5, a5, tp
 # LE-NEXT: addi a5, a5, 8

lld/test/ELF/tls.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 // RUN: ld.lld %t -o %tout
 // RUN: llvm-readobj -S -l --symbols %tout | FileCheck %s
 // RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DIS
 
+/// Reject local-exec TLS relocations for -shared, regardless of the preemptibility.
+// RUN: not ld.lld -shared %t -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR
+// RUN: not ld.lld -shared -Bsymbolic %t -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR
+
+// ERR:       error: relocation R_X86_64_TPOFF32 against a cannot be used with -shared
+// ERR-NEXT:  defined in {{.*}}
+// ERR-NEXT:  referenced by {{.*}}:(.text+0x4)
+// ERR-EMPTY:
+// ERR-NEXT:  error: relocation R_X86_64_TPOFF32 against b cannot be used with -shared
+// ERR-NEXT:  defined in {{.*}}
+// ERR-NEXT:  referenced by {{.*}}:(.text+0xC)
+// ERR-EMPTY:
+// ERR-NEXT:  error: relocation R_X86_64_TPOFF32 against c cannot be used with -shared
+// ERR-NEXT:  defined in {{.*}}
+// ERR-NEXT:  referenced by {{.*}}:(.text+0x14)
+// ERR-EMPTY:
+// ERR-NEXT:  error: relocation R_X86_64_TPOFF32 against d cannot be used with -shared
+// ERR-NEXT:  defined in {{.*}}
+// ERR-NEXT:  referenced by {{.*}}:(.text+0x1C)
+
 .global _start
 _start:
   movl %fs:a@tpoff, %eax
   movl %fs:b@tpoff, %eax
   movl %fs:c@tpoff, %eax
   movl %fs:d@tpoff, %eax
 
   .global a

lld/test/ELF/x86-64-reloc-tpoff32-fpic.s

-# REQUIRES: x86
-# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
-# RUN: not ld.lld %t.o -shared -o /dev/null 2>&1 | FileCheck %s
-
-# CHECK: relocation R_X86_64_TPOFF32 cannot be used against symbol var; recompile with -fPIC
-# CHECK: >>> defined in {{.*}}.o
-# CHECK: >>> referenced by {{.*}}.o:(.tdata+0xC)
-
-.section ".tdata", "awT", @progbits
-.globl var
-var:
-
-movq %fs:0, %rax
-leaq var@TPOFF(%rax),%rax