[ELF] - Set DF_STATIC_TLS flag for x86_64 target.

[grimar]

Summary

DF_STATIC_TLS
If set in a shared object or executable, this flag instructs the dynamic linker to reject attempts to load this file dynamically. It indicates that the shared object or executable contains code using a static thread-local storage scheme. Implementations need not support any form of thread-local storage.

The is same as D32354, but for x86_64 target.

[ruiu]

Can you verify that you actually cannot dlopen() an .so file if the file has the DF_STATIC_TLS flag? I want to make sure that glibc actually uses the flag.

[joerg]

It's actually more a diagnostic hint. Due to things like Nvidia's binary-only libGL, this is actually supported by most TLS implementations as long as no initializers are needed.

[grimar]

In D33041#751238, @ruiu wrote:

Can you verify that you actually cannot dlopen() an .so file if the file has the DF_STATIC_TLS flag? I want to make sure that glibc actually uses the flag.

Flag does not seem to have effect for me on Ubuntu 16.04.1 LTS.

Used code:

#include <iostream>
#include <dlfcn.h>

int main() {
    std::cout << "Opening test_flag.so...\n";
    void* handle = dlopen("./test_flag.so", RTLD_NOW);
    if (!handle) {
      std::cout << "Cannot open library: " << dlerror() << std::endl;
      return 0;
   }

  std::cout << "OK" << std::endl;
  dlclose(handle);
  return 0;
}

umb@umb-virtual-machine:~/tests/311$ g++ test.cpp -o temp -ldl
umb@umb-virtual-machine:~/tests/311$ ./temp
Opening test_flag.so...
OK
umb@umb-virtual-machine:~/tests/311$ readelf --dynamic test_flag.so

Dynamic section at offset 0x228 contains 10 entries:
  Tag        Type                         Name/Value
 0x0000000000000004 (HASH)               0x120
 0x0000000000000005 (STRTAB)             0x1e0
 0x0000000000000006 (SYMTAB)             0x150
 0x000000000000000a (STRSZ)              29 (bytes)
 0x000000000000000b (SYMENT)             24 (bytes)
 0x0000000000000007 (RELA)               0x200
 0x0000000000000008 (RELASZ)             24 (bytes)
 0x0000000000000009 (RELAENT)            24 (bytes)
 0x000000000000001e (FLAGS)              STATIC_TLS
 0x0000000000000000 (NULL)               0x0

[grimar]

Abandoning since we decided to remove support of STATIC_TLS flag.

[emaste]

FreeBSD patch adding initial exec TLS mode for dynamically loaded shared objects: https://reviews.freebsd.org/D19072. Can we revisit this lld patch?

[grimar]

In D33041#1382592, @emaste wrote:

FreeBSD patch adding initial exec TLS mode for dynamically loaded shared objects: https://reviews.freebsd.org/D19072. Can we revisit this lld patch?

I'll take a look tomorrow. Seems FreeBSD is going to use it for both x86_64 and i386 targets for start? That means we also might want to revisit D32354.
It was reverted.

FTR and to answer the comment from freebsd.org page above, which was
"They did not stated why DF_STATIC_TLS was considered as 'not needed'.":

Rafael's answer in the mail list that time was:

I just cloned musl and DF_STATIC_TLS is not used anywhere.

glibc used to use it, but doesn't since 2002
(2430d57a13f4f10312e13c58962cd9104e6428fd).

It is also not used by the freebsd one.

[emaste]

In D33041#1382751, @grimar wrote:

In D33041#1382592, @emaste wrote:

FreeBSD patch adding initial exec TLS mode for dynamically loaded shared objects: https://reviews.freebsd.org/D19072. Can we revisit this lld patch?

I'll take a look tomorrow.

Great, thank you.

Seems FreeBSD is going to use it for both x86_64 and i386 targets for start? That means we also might want to revisit D32354.
It was reverted.

Yes, we were still shipping GNU ld.bfd 2.17.50 as /usr/bin/ld on i386 until just recently because of trouble in the ports tree (although the kernel and base system userland has been linked with lld for quite some time).

Now that lld is fully enabled on amd64, i386, arm64 and armv7 we'll start making use of these features across platforms, i386 included.

FTR and to answer the comment from freebsd.org page above, which was
"They did not stated why DF_STATIC_TLS was considered as 'not needed'.":

Rafael's answer in the mail list that time was:

I just cloned musl and DF_STATIC_TLS is not used anywhere.

glibc used to use it, but doesn't since 2002
(2430d57a13f4f10312e13c58962cd9104e6428fd).

It is also not used by the freebsd one.

Thank you for the archaeology; looking into what we'll do in FreeBSD.

[grimar]

Updated version is D57821.

ELF/Target.cpp

template <class ELFT> X86_64TargetInfo<ELFT>::X86_64TargetInfo() {
   DefaultImageBase = 0x200000;
   // 0xCC is the "int3" (call debug exception handler) instruction.
   TrapInstr = 0xcccccccc;
 }
 
 template <class ELFT>
 RelExpr X86_64TargetInfo<ELFT>::getRelExpr(uint32_t Type, const SymbolBody &S,
                                            const uint8_t *Loc) const {
+  if (Type == R_X86_64_GOTTPOFF || Type == R_X86_64_TPOFF32)
+    Config->HasStaticTlsModel = true;
+
   switch (Type) {
   case R_X86_64_8:
   case R_X86_64_16:
   case R_X86_64_32:
   case R_X86_64_32S:
   case R_X86_64_64:
   case R_X86_64_DTPOFF32:
   case R_X86_64_DTPOFF64:

test/ELF/Inputs/x86-64-static-tls-model1.s

+.section ".tdata", "awT", @progbits
+.globl var
+var:
+
+movq var@GOTTPOFF(%rip), %rax
+movl %fs:0(%rax), %eax

test/ELF/Inputs/x86-64-static-tls-model2.s

+.section ".tdata", "awT", @progbits
+.globl var
+var:
+
+movq %fs:0, %rax
+leaq var@TPOFF(%rax),%rax

test/ELF/tls-dynamic.s

 
 // CHECK:      Sections [
 // CHECK:          Name: .got (
 // CHECK-NEXT:     Type: SHT_PROGBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
-// CHECK-NEXT:     Address: 0x30D0
+// CHECK-NEXT:     Address: 0x30E0
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size: 40
 
 // CHECK:      Relocations [
 // CHECK:        Section ({{.+}}) .rela.dyn {
-// CHECK-NEXT:     0x30D0 R_X86_64_DTPMOD64 - 0x0
-// CHECK-NEXT:     0x30E0 R_X86_64_DTPMOD64 c 0x0
-// CHECK-NEXT:     0x30E8 R_X86_64_DTPOFF64 c 0x0
-// CHECK-NEXT:     0x30F0 R_X86_64_TPOFF64 c 0x0
+// CHECK-NEXT:     0x30E0 R_X86_64_DTPMOD64 - 0x0
+// CHECK-NEXT:     0x30F0 R_X86_64_DTPMOD64 c 0x0
+// CHECK-NEXT:     0x30F8 R_X86_64_DTPOFF64 c 0x0
+// CHECK-NEXT:     0x3100 R_X86_64_TPOFF64 c 0x0
 // CHECK-NEXT:   }
 
-// 4297 = (0x20D0 + -4) - (0x1000 + 3) // PC relative offset to got entry.
-// 4285 = (0x20D0 + -4) - (0x100c + 3) // PC relative offset to got entry.
-// 4267 = (0x20E0 + -4) - (0x102e + 3) // PC relative offset to got entry.
-// 4263 = (0x20F0 + -4) - (0x1042 + 3) // PC relative offset to got entry.
+// 8409 = (0x30E0 + -4) - (0x1000 + 3) // PC relative offset to got entry.
+// 8397 = (0x30F0 + -4) - (0x100c + 3) // PC relative offset to got entry.
+// 8379 = (0x30F8 + -4) - (0x102e + 3) // PC relative offset to got entry.
+// 8375 = (0x3100 + -4) - (0x1042 + 3) // PC relative offset to got entry.
 
 // DIS:      Disassembly of section .text:
 // DIS-NEXT: .text:
-// DIS-NEXT:     1000: {{.+}} leaq    8393(%rip), %rdi
+// DIS-NEXT:     1000: {{.+}} leaq    8409(%rip), %rdi
 // DIS-NEXT:     1007: {{.+}} callq
-// DIS-NEXT:     100c: {{.+}} leaq    8381(%rip), %rdi
+// DIS-NEXT:     100c: {{.+}} leaq    8397(%rip), %rdi
 // DIS-NEXT:     1013: {{.+}} callq
 // DIS-NEXT:     1018: {{.+}} leaq    (%rax), %rcx
 // DIS-NEXT:     101f: {{.+}} leaq    4(%rax), %rcx
 // DIS-NEXT:     1026: 04 00
 // DIS-NEXT:     1028: 00 00
 // DIS-NEXT:     102a: 00 00
 // DIS-NEXT:     102c: 00 00
-// DIS-NEXT:     102e: {{.+}} leaq    8363(%rip), %rdi
+// DIS-NEXT:     102e: {{.+}} leaq    8379(%rip), %rdi
 // DIS-NEXT:     1035: {{.+}} callq
 // DIS-NEXT:     103b: {{.+}} leaq    (%rax), %rcx
-// DIS-NEXT:     1042: {{.+}} movq    8359(%rip), %rax
+// DIS-NEXT:     1042: {{.+}} movq    8375(%rip), %rax
 // DIS-NEXT:     1049: {{.+}} movq    %fs:(%rax), %rax
 // DIS-NEXT:     104d: {{.+}} movabsq $0, %rax
 // DIS-NEXT:     1057: {{.+}} movabsq $4, %rax
 // DIS-NEXT:     1061: {{.+}} movabsq $0, %rax

test/ELF/tls-got.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/tls-got.s -o %t2.o
 // RUN: ld.lld -shared %t2.o -o %t2.so
 // RUN: ld.lld -e main %t1.o %t2.so -o %t3
 // RUN: llvm-readobj -s -r %t3 | FileCheck %s
 // RUN: llvm-objdump -d %t3 | FileCheck --check-prefix=DISASM %s
 
 // CHECK:      Section {
 // CHECK:      Index: 8
 // CHECK-NEXT: Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: [[ADDR:.*]]
-// CHECK-NEXT: Offset: 0x20B0
+// CHECK-NEXT: Offset: 0x20C0
 // CHECK-NEXT: Size: 16
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: }
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section (4) .rela.dyn {
-// CHECK-NEXT:     0x2020B8 R_X86_64_TPOFF64 tls0 0x0
+// CHECK-NEXT:     0x2020C8 R_X86_64_TPOFF64 tls0 0x0
 // CHECK-NEXT:     [[ADDR]] R_X86_64_TPOFF64 tls1 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
-//0x201000 + 4249 + 7 = 0x2020B0
-//0x20100A + 4247 + 7 = 0x2020B8
-//0x201014 + 4237 + 7 = 0x2020B8
+//0x201000 + 4281 + 7 = 0x2020C0
+//0x20100A + 4279 + 7 = 0x2020C8
+//0x201014 + 4269 + 7 = 0x2020C8
 //DISASM:      Disassembly of section .text:
 //DISASM-NEXT: main:
-//DISASM-NEXT: 201000: 48 8b 05 a9 10 00 00 movq 4265(%rip), %rax
-//DISASM-NEXT: 201007: 64 8b 00 movl %fs:(%rax), %eax
-//DISASM-NEXT: 20100a: 48 8b 05 a7 10 00 00 movq 4263(%rip), %rax
-//DISASM-NEXT: 201011: 64 8b 00 movl %fs:(%rax), %eax
-//DISASM-NEXT: 201014: 48 8b 05 9d 10 00 00 movq 4253(%rip), %rax
-//DISASM-NEXT: 20101b: 64 8b 00 movl %fs:(%rax), %eax
+//DISASM-NEXT: 201000: {{.*}} movq 4281(%rip), %rax
+//DISASM-NEXT: 201007: {{.*}} movl %fs:(%rax), %eax
+//DISASM-NEXT: 20100a: {{.*}} movq 4279(%rip), %rax
+//DISASM-NEXT: 201011: {{.*}} movl %fs:(%rax), %eax
+//DISASM-NEXT: 201014: {{.*}} movq 4269(%rip), %rax
+//DISASM-NEXT: 20101b: {{.*}} movl %fs:(%rax), %eax
 //DISASM-NEXT: 20101e: c3 retq
 
 .section .tdata,"awT",@progbits
 
 .text
  .globl main
  .align 16, 0x90
  .type main,@function
 main:
  movq tls1@GOTTPOFF(%rip), %rax
  movl %fs:0(%rax), %eax
  movq tls0@GOTTPOFF(%rip), %rax
  movl %fs:0(%rax), %eax
  movq tls0@GOTTPOFF(%rip), %rax
  movl %fs:0(%rax), %eax
  ret

test/ELF/tls-initial-exec-local.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t
 // RUN: llvm-readobj -r -s %t | FileCheck %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC (0x2)
 // CHECK-NEXT:   SHF_WRITE (0x1)
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x2090
+// CHECK-NEXT: Address: 0x20A0
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x2090 R_X86_64_TPOFF64 - 0x0
-// CHECK-NEXT:     0x2098 R_X86_64_TPOFF64 - 0x4
+// CHECK-NEXT:     0x20A0 R_X86_64_TPOFF64 - 0x0
+// CHECK-NEXT:     0x20A8 R_X86_64_TPOFF64 - 0x4
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
-// 0x1007 + 4233 = 0x2090
-// 0x100e + 4234 = 0x2098
+// 0x1007 + 4249 = 0x20A0
+// 0x100e + 4250 = 0x20A8
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: .text:
-// DISASM-NEXT:  1000: {{.*}} addq      4233(%rip), %rax
-// DISASM-NEXT:  1007: {{.*}} addq      4234(%rip), %rax
+// DISASM-NEXT:  1000: {{.*}} addq      4249(%rip), %rax
+// DISASM-NEXT:  1007: {{.*}} addq      4250(%rip), %rax
 
         addq    foo@GOTTPOFF(%rip), %rax
         addq    bar@GOTTPOFF(%rip), %rax
 
         .section        .tbss,"awT",@nobits
 foo:
         .long 0
 bar:
         .long 0

test/ELF/x86_64-static-tls-model.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/x86-64-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=x86_64-unknown-linux %S/Inputs/x86-64-static-tls-model2.s -o %t.o
+# RUN: ld.lld %t.o -o %t2 -shared
+# RUN: llvm-readobj -dynamic-table %t2 | FileCheck %s
+
+# CHECK: DynamicSection [
+# CHECK: FLAGS STATIC_TLS