[LLD][ELF] - Set DF_STATIC_TLS flag for i386 target.

[grimar]

Summary

DF_STATIC_TLS flag indicates that the shared object or executable contains code using a static thread-local storage scheme.

Patch checks if IE/LE relocations were used to check if the code uses a static model. If so it sets the DF_STATIC_TLS flag.

It is based on D32354 which was reverted because we decided to not support the DF_STATIC_TLS at that time.
But now it will be used in FreeBSD.

[ruiu]

Could you give me a pointer to the FreeBSD change to support this feature?

ELF/Arch/X86.cpp

80 ↗

(On Diff #185294)

I don't remember if this function is called from a multi-threaded part of lld. If that's the case, mutating a variable is not considered thread-safe, even if you are just mutating a boolean variable and set it to the same value from everywhere.

[ruiu]

I found the thread: https://reviews.freebsd.org/D19072

[joerg]

The description is certainly not right. IE can be used from dlopen'd objects without problems as long as there is still reserved space around and the data is not initialized non-trivially or the dynamic linker is willing to fix up all threads. The point of the flag is to allow the dynamic linker to make a quick decision without having to scan the relocation table first. A classic user of this was libGL. It also applies to many platforms, not just i386. As such, please update the description before any commit.

[grimar]

In D57749#1385666, @joerg wrote:

The description is certainly not right. IE can be used from dlopen'd objects without problems as long as there is still reserved space around and the data is not initialized non-trivially or the dynamic linker is willing to fix up all threads. The point of the flag is to allow the dynamic linker to make a quick decision without having to scan the relocation table first. A classic user of this was libGL. It also applies to many platforms, not just i386. As such, please update the description before any commit.

I updated the description to say just "DF_STATIC_TLS flag indicates that the shared object or executable contains code using a static thread-local storage scheme."
i386 was mentioned only because this patch does that for this target only.

[emaste]

In D57749#1385666, @joerg wrote:

The description is certainly not right. IE can be used from dlopen'd objects without problems as long as there is still reserved space around and the data is not initialized non-trivially or the dynamic linker is willing to fix up all threads. The point of the flag is to allow the dynamic linker to make a quick decision without having to scan the relocation table first. A classic user of this was libGL. It also applies to many platforms, not just i386. As such, please update the description before any commit.

Indeed, it appears this was originally used to have the dlopen fail, but really it's just an indicator of the object's TLS use. Search for obj->static_tls in the FreeBSD review to see the proposed use.

[grimar]

ELF/Arch/X86.cpp

80 ↗

(On Diff #185294)

Yes, you're right. We call it for relocateNonAlloc, it should be multithreaded.

Actually, I do not really like to have such code here.

I am using it for the following place now:
https://github.com/llvm-mirror/lld/blob/master/ELF/Relocations.cpp#L997

And I thought about just doing a static helper right above scanReloc like

static bool isStaticTlsReloc(RelType Type) {
  switch (Target) {
   case TargetA:
   return Type == Reloc1 ...;
  ...
   }
}

Cons would be that we will have a switch for targets and target specific relocations there,
though we already have a helper for MIPS in that file:
https://github.com/llvm-mirror/lld/blob/master/ELF/Relocations.cpp#L298

An alternative can be adding a Target::isStaticTlsReloc(RelType Type) method,
what is probably better, though I am not sure it is not too much for this little feature.

What would you prefer?

[ruiu]

I think you can just use std::atomic_bool.

[grimar]

OK, used std::atomic<bool>. (Not the std::atomic_bool, because LLD already use std::atomic<bool> form in ICF).

[ruiu]

LGTM

lld/trunk/ELF/Arch/X86.cpp

 }
 
 int X86::getTlsGdRelaxSkip(RelType Type) const {
   return 2;
 }
 
 RelExpr X86::getRelExpr(RelType Type, const Symbol &S,
                         const uint8_t *Loc) const {
+  // There are 4 different TLS variable models with varying degrees of
+  // flexibility and performance. LocalExec and InitialExec models are fast but
+  // less-flexible models. They cannot be used for dlopen(). If they are in use,
+  // we set DF_STATIC_TLS in the ELF header so that the runtime can reject such
+  // DSOs.
+  if (Type == R_386_TLS_LE || Type == R_386_TLS_LE_32 || Type == R_386_TLS_IE ||
+      Type == R_386_TLS_GOTIE)
+    Config->HasStaticTlsModel = true;
+
   switch (Type) {
   case R_386_8:
   case R_386_16:
   case R_386_32:
   case R_386_TLS_LDO_32:
     return R_ABS;
   case R_386_TLS_GD:
     return R_TLSGD_GOT_FROM_END;

lld/trunk/ELF/Config.h

 #include "lld/Common/ErrorHandler.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Endian.h"
+#include <atomic>
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class InputFile;
 class InputSectionBase;
 
struct VersionDefinition {
   size_t NameOff = 0; // Offset in the string table
 };
 
 // This struct contains the global configuration for the linker.
 // Most fields are direct mapping from the command line options
 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
+  std::atomic<bool> HasStaticTlsModel = false;
   uint8_t OSABI = 0;
   llvm::CachePruningPolicy ThinLTOCachePolicy;
   llvm::StringMap<uint64_t> SectionStartMap;
   llvm::StringRef Chroot;
   llvm::StringRef DynamicLinker;
   llvm::StringRef DwoDir;
   llvm::StringRef Entry;
   llvm::StringRef Emulation;

lld/trunk/ELF/SyntheticSections.cpp

if (Config->ZNow) {
     DtFlags1 |= DF_1_NOW;
   }
   if (Config->ZOrigin) {
     DtFlags |= DF_ORIGIN;
     DtFlags1 |= DF_1_ORIGIN;
   }
   if (!Config->ZText)
     DtFlags |= DF_TEXTREL;
+  if (Config->HasStaticTlsModel)
+    DtFlags |= DF_STATIC_TLS;
 
   if (DtFlags)
     addInt(DT_FLAGS, DtFlags);
   if (DtFlags1)
     addInt(DT_FLAGS_1, DtFlags1);
 
   // DT_DEBUG is a pointer to debug informaion used by debuggers at runtime. We
   // need it for each process, so we don't write it for DSOs. The loader writes

lld/trunk/test/ELF/Inputs/i386-static-tls-model1.s

+.section ".tdata", "awT", @progbits
+.globl var
+var:
+
+.section .foo, "aw"
+.global _start
+_start:
+ movl $var@tpoff, %edx # R_386_TLS_LE_32
+ movl %gs:0, %ecx

lld/trunk/test/ELF/Inputs/i386-static-tls-model2.s

+.section ".tdata", "awT", @progbits
+.globl var
+var:
+
+.section .foo, "aw"
+.global _start
+_start: 
+ movl %gs:0, %eax
+ addl var@gotntpoff(%ebx), %eax # R_386_TLS_GOTIE

lld/trunk/test/ELF/Inputs/i386-static-tls-model3.s

+.section ".tdata", "awT", @progbits
+.globl var
+var:
+
+.section .foo, "aw"
+.global _start
+_start:
+ movl %gs:0, %eax
+ addl var@indntpoff, %eax # R_386_TLS_IE

lld/trunk/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/trunk/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/trunk/test/ELF/i386-tls-ie-shared.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %p/Inputs/tls-opt-iele-i686-nopic.s -o %tso.o
 // RUN: ld.lld -shared %tso.o -o %tso
 // RUN: ld.lld --hash-style=sysv -shared %t.o %tso -o %t1
 // RUN: llvm-readobj -s -r -d %t1 | FileCheck --check-prefix=GOTRELSHARED %s
 // RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASMSHARED %s
 
 // GOTRELSHARED:     Section {
 // GOTRELSHARED:      Index: 8
 // GOTRELSHARED:      Name: .got
 // GOTRELSHARED-NEXT:   Type: SHT_PROGBITS
 // GOTRELSHARED-NEXT:   Flags [
 // GOTRELSHARED-NEXT:     SHF_ALLOC
 // GOTRELSHARED-NEXT:     SHF_WRITE
 // GOTRELSHARED-NEXT:   ]
-// GOTRELSHARED-NEXT:   Address: 0x2058
-// GOTRELSHARED-NEXT:   Offset: 0x2058
+// GOTRELSHARED-NEXT:   Address: 0x2060
+// GOTRELSHARED-NEXT:   Offset: 0x2060
 // GOTRELSHARED-NEXT:   Size: 16
 // GOTRELSHARED-NEXT:   Link: 0
 // GOTRELSHARED-NEXT:   Info: 0
 // GOTRELSHARED-NEXT:   AddressAlignment: 4
 // GOTRELSHARED-NEXT:   EntrySize: 0
 // GOTRELSHARED-NEXT: }
 // GOTRELSHARED:      Relocations [
 // GOTRELSHARED-NEXT:   Section ({{.*}}) .rel.dyn {
 // GOTRELSHARED-NEXT:     0x1002 R_386_RELATIVE - 0x0
 // GOTRELSHARED-NEXT:     0x100A R_386_RELATIVE - 0x0
 // GOTRELSHARED-NEXT:     0x1013 R_386_RELATIVE - 0x0
 // GOTRELSHARED-NEXT:     0x101C R_386_RELATIVE - 0x0
 // GOTRELSHARED-NEXT:     0x1024 R_386_RELATIVE - 0x0
 // GOTRELSHARED-NEXT:     0x102D R_386_RELATIVE - 0x0
 // GOTRELSHARED-NEXT:     0x1036 R_386_RELATIVE - 0x0
 // GOTRELSHARED-NEXT:     0x103F R_386_RELATIVE - 0x0
-// GOTRELSHARED-NEXT:     0x2058 R_386_TLS_TPOFF tlslocal0 0x0
-// GOTRELSHARED-NEXT:     0x205C R_386_TLS_TPOFF tlslocal1 0x0
-// GOTRELSHARED-NEXT:     0x2060 R_386_TLS_TPOFF tlsshared0 0x0
-// GOTRELSHARED-NEXT:     0x2064 R_386_TLS_TPOFF tlsshared1 0x0
+// GOTRELSHARED-NEXT:     0x2060 R_386_TLS_TPOFF tlslocal0 0x0
+// GOTRELSHARED-NEXT:     0x2064 R_386_TLS_TPOFF tlslocal1 0x0
+// GOTRELSHARED-NEXT:     0x2068 R_386_TLS_TPOFF tlsshared0 0x0
+// GOTRELSHARED-NEXT:     0x206C R_386_TLS_TPOFF tlsshared1 0x0
 // GOTRELSHARED-NEXT:   }
 // GOTRELSHARED-NEXT: ]
 // GOTRELSHARED:      0x6FFFFFFA RELCOUNT             8
 
 // DISASMSHARED:       Disassembly of section test:
 // DISASMSHARED-NEXT:  _start:
-// (.got)[0] = 0x2058 = 8280
-// (.got)[1] = 0x205C = 8284
-// (.got)[2] = 0x2060 = 8288
-// (.got)[3] = 0x2064 = 8292
-// DISASMSHARED-NEXT:  1000: 8b 0d 58 20 00 00   movl  8280, %ecx
-// DISASMSHARED-NEXT:  1006: 65 8b 01  movl  %gs:(%ecx), %eax
-// DISASMSHARED-NEXT:  1009: a1 58 20 00 00  movl  8280, %eax
-// DISASMSHARED-NEXT:  100e: 65 8b 00  movl  %gs:(%eax), %eax
-// DISASMSHARED-NEXT:  1011: 03 0d 58 20 00 00   addl  8280, %ecx
-// DISASMSHARED-NEXT:  1017: 65 8b 01  movl  %gs:(%ecx), %eax
-// DISASMSHARED-NEXT:  101a: 8b 0d 5c 20 00 00   movl  8284, %ecx
-// DISASMSHARED-NEXT:  1020: 65 8b 01  movl  %gs:(%ecx), %eax
-// DISASMSHARED-NEXT:  1023: a1 5c 20 00 00  movl  8284, %eax
-// DISASMSHARED-NEXT:  1028: 65 8b 00  movl  %gs:(%eax), %eax
-// DISASMSHARED-NEXT:  102b: 03 0d 5c 20 00 00   addl  8284, %ecx
-// DISASMSHARED-NEXT:  1031: 65 8b 01  movl  %gs:(%ecx), %eax
-// DISASMSHARED-NEXT:  1034: 8b 0d 60 20 00 00   movl  8288, %ecx
-// DISASMSHARED-NEXT:  103a: 65 8b 01  movl  %gs:(%ecx), %eax
-// DISASMSHARED-NEXT:  103d: 03 0d 64 20 00 00   addl  8292, %ecx
-// DISASMSHARED-NEXT:  1043: 65 8b 01  movl  %gs:(%ecx), %eax
+// (.got)[0] = 0x2060 = 8288
+// (.got)[1] = 0x2064 = 8292
+// (.got)[2] = 0x2068 = 8296
+// (.got)[3] = 0x206C = 8300
+// DISASMSHARED-NEXT:  1000: {{.*}} movl  8288, %ecx
+// DISASMSHARED-NEXT:  1006: {{.*}} movl  %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  1009: {{.*}} movl  8288, %eax
+// DISASMSHARED-NEXT:  100e: {{.*}} movl  %gs:(%eax), %eax
+// DISASMSHARED-NEXT:  1011: {{.*}} addl  8288, %ecx
+// DISASMSHARED-NEXT:  1017: {{.*}} movl  %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  101a: {{.*}} movl  8292, %ecx
+// DISASMSHARED-NEXT:  1020: {{.*}} movl  %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  1023: {{.*}} movl  8292, %eax
+// DISASMSHARED-NEXT:  1028: {{.*}} movl  %gs:(%eax), %eax
+// DISASMSHARED-NEXT:  102b: {{.*}} addl  8292, %ecx
+// DISASMSHARED-NEXT:  1031: {{.*}} movl  %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  1034: {{.*}} movl  8296, %ecx
+// DISASMSHARED-NEXT:  103a: {{.*}} movl  %gs:(%ecx), %eax
+// DISASMSHARED-NEXT:  103d: {{.*}} addl  8300, %ecx
+// DISASMSHARED-NEXT:  1043: {{.*}} movl  %gs:(%ecx), %eax
 
 .type tlslocal0,@object
 .section .tbss,"awT",@nobits
 .globl tlslocal0
 .align 4
 tlslocal0:
  .long 0
  .size tlslocal0, 4

lld/trunk/test/ELF/tls-dynamic-i686.s

 addl tls1@gotntpoff(%ebx),%eax
 
 // CHECK:      Name: .got (
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x3068
-// CHECK-NEXT: Offset: 0x3068
+// CHECK-NEXT: Address: 0x3070
+// CHECK-NEXT: Offset: 0x3070
 // CHECK-NEXT: Size: 32
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 4
 // CHECK-NEXT: EntrySize: 0
 
 // CHECK: Relocations [
 // CHECK:      Section ({{.+}}) .rel.dyn {
-// CHECK-NEXT: 0x3078 R_386_TLS_DTPMOD32 - 0x0
-// CHECK-NEXT: 0x3068 R_386_TLS_DTPMOD32 tls0 0x0
-// CHECK-NEXT: 0x306C R_386_TLS_DTPOFF32 tls0 0x0
-// CHECK-NEXT: 0x3080 R_386_TLS_TPOFF tls0 0x0
-// CHECK-NEXT: 0x3070 R_386_TLS_DTPMOD32 tls1 0x0
-// CHECK-NEXT: 0x3074 R_386_TLS_DTPOFF32 tls1 0x0
-// CHECK-NEXT: 0x3084 R_386_TLS_TPOFF tls1 0x0
+// CHECK-NEXT: 0x3080 R_386_TLS_DTPMOD32 - 0x0
+// CHECK-NEXT: 0x3070 R_386_TLS_DTPMOD32 tls0 0x0
+// CHECK-NEXT: 0x3074 R_386_TLS_DTPOFF32 tls0 0x0
+// CHECK-NEXT: 0x3088 R_386_TLS_TPOFF tls0 0x0
+// CHECK-NEXT: 0x3078 R_386_TLS_DTPMOD32 tls1 0x0
+// CHECK-NEXT: 0x307C R_386_TLS_DTPOFF32 tls1 0x0
+// CHECK-NEXT: 0x308C R_386_TLS_TPOFF tls1 0x0
 // CHECK-NEXT: }
 
 // DIS:      Disassembly of section .text:
 // DIS-NEXT: _start:
 // General dynamic model:
 // -32 and -24 are first and second GOT entries offsets.
 // Each one is a pair of records.
-// DIS-NEXT: 1000: 8d 04 1d e0 ff ff ff  leal -32(,%ebx), %eax
-// DIS-NEXT: 1007: e8 64 00 00 00        calll 100
-// DIS-NEXT: 100c: 8d 04 1d e8 ff ff ff  leal -24(,%ebx), %eax
-// DIS-NEXT: 1013: e8 58 00 00 00        calll 88
+// DIS-NEXT: 1000: {{.*}} leal -32(,%ebx), %eax
+// DIS-NEXT: 1007: {{.*}} calll 100
+// DIS-NEXT: 100c: {{.*}} leal -24(,%ebx), %eax
+// DIS-NEXT: 1013: {{.*}} calll 88
 // Local dynamic model:
 // -16 is a local module tls index offset.
-// DIS-NEXT: 1018: 8d 83 f0 ff ff ff leal -16(%ebx), %eax
-// DIS-NEXT: 101e: e8 4d 00 00 00    calll 77
-// DIS-NEXT: 1023: 8d 90 08 00 00 00 leal 8(%eax), %edx
-// DIS-NEXT: 1029: 8d 83 f0 ff ff ff leal -16(%ebx), %eax
-// DIS-NEXT: 102f: e8 3c 00 00 00    calll 60
-// DIS-NEXT: 1034: 8d 90 0c 00 00 00 leal 12(%eax), %edx
+// DIS-NEXT: 1018: {{.*}} leal -16(%ebx), %eax
+// DIS-NEXT: 101e: {{.*}} calll 77
+// DIS-NEXT: 1023: {{.*}} leal 8(%eax), %edx
+// DIS-NEXT: 1029: {{.*}} leal -16(%ebx), %eax
+// DIS-NEXT: 102f: {{.*}} calll 60
+// DIS-NEXT: 1034: {{.*}} leal 12(%eax), %edx
 // Initial exec model:
-// DIS-NEXT: 103a: 65 a1 00 00 00 00 movl %gs:0, %eax
-// DIS-NEXT: 1040: 03 83 f8 ff ff ff addl -8(%ebx), %eax
-// DIS-NEXT: 1046: 65 a1 00 00 00 00 movl %gs:0, %eax
-// DIS-NEXT: 104c: 03 83 fc ff ff ff addl -4(%ebx), %eax
+// DIS-NEXT: 103a: {{.*}} movl %gs:0, %eax
+// DIS-NEXT: 1040: {{.*}} addl -8(%ebx), %eax
+// DIS-NEXT: 1046: {{.*}} movl %gs:0, %eax
+// DIS-NEXT: 104c: {{.*}} addl -4(%ebx), %eax

lld/trunk/test/ELF/tls-opt-iele-i686-nopic.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %p/Inputs/tls-opt-iele-i686-nopic.s -o %tso.o
 // RUN: ld.lld -shared %tso.o -o %tso
 // RUN: ld.lld --hash-style=sysv %t.o %tso -o %t1
 // RUN: llvm-readobj -s -r %t1 | FileCheck --check-prefix=GOTREL %s
 // RUN: llvm-objdump -d %t1 | FileCheck --check-prefix=DISASM %s
 
 // GOTREL:      Section {
 // GOTREL:        Index:
 // GOTREL:        Name: .got
 // GOTREL-NEXT:   Type: SHT_PROGBITS
 // GOTREL-NEXT:   Flags [
 // GOTREL-NEXT:     SHF_ALLOC
 // GOTREL-NEXT:     SHF_WRITE
 // GOTREL-NEXT:   ]
-// GOTREL-NEXT:   Address: 0x402058
-// GOTREL-NEXT:   Offset: 0x2058
+// GOTREL-NEXT:   Address:  0x402060
+// GOTREL-NEXT:   Offset: 0x2060
 // GOTREL-NEXT:   Size: 8
 // GOTREL-NEXT:   Link: 0
 // GOTREL-NEXT:   Info: 0
 // GOTREL-NEXT:   AddressAlignment: 4
 // GOTREL-NEXT:   EntrySize: 0
 // GOTREL-NEXT: }
 // GOTREL:      Relocations [
 // GOTREL-NEXT: Section ({{.*}}) .rel.dyn {
-// GOTREL-NEXT:   0x402058 R_386_TLS_TPOFF tlsshared0 0x0
-// GOTREL-NEXT:   0x40205C R_386_TLS_TPOFF tlsshared1 0x0
+// GOTREL-NEXT:   0x402060 R_386_TLS_TPOFF tlsshared0 0x0
+// GOTREL-NEXT:   0x402064 R_386_TLS_TPOFF tlsshared1 0x0
 // GOTREL-NEXT:  }
 // GOTREL-NEXT: ]
 
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: _start:
 // 4294967288 = 0xFFFFFFF8
 // 4294967292 = 0xFFFFFFFC
-// 4202584 = (.got)[0] = 0x402058
-// 4202588 = (.got)[1] = 0x40205C
-// DISASM-NEXT: 401000: c7 c1 f8 ff ff ff movl $4294967288, %ecx
-// DISASM-NEXT: 401006: 65 8b 01          movl %gs:(%ecx), %eax
-// DISASM-NEXT: 401009: b8 f8 ff ff ff    movl $4294967288, %eax
-// DISASM-NEXT: 40100e: 65 8b 00          movl %gs:(%eax), %eax
-// DISASM-NEXT: 401011: 81 c1 f8 ff ff ff addl $4294967288, %ecx
-// DISASM-NEXT: 401017: 65 8b 01          movl %gs:(%ecx), %eax
-// DISASM-NEXT: 40101a: c7 c1 fc ff ff ff movl $4294967292, %ecx
-// DISASM-NEXT: 401020: 65 8b 01          movl %gs:(%ecx), %eax
-// DISASM-NEXT: 401023: b8 fc ff ff ff    movl $4294967292, %eax
-// DISASM-NEXT: 401028: 65 8b 00          movl %gs:(%eax), %eax
-// DISASM-NEXT: 40102b: 81 c1 fc ff ff ff addl $4294967292, %ecx
-// DISASM-NEXT: 401031: 65 8b 01          movl %gs:(%ecx), %eax
-// DISASM-NEXT: 401034: 8b 0d 58 20 40 00 movl 4202584, %ecx
-// DISASM-NEXT: 40103a: 65 8b 01          movl %gs:(%ecx), %eax
-// DISASM-NEXT: 40103d: 03 0d 5c 20 40 00 addl 4202588, %ecx
-// DISASM-NEXT: 401043: 65 8b 01          movl %gs:(%ecx), %eax
+// 4202592 = (.got)[0] = 0x402060
+// 4202596 = (.got)[1] = 0x402064
+// DISASM-NEXT: 401000: {{.*}} movl $4294967288, %ecx
+// DISASM-NEXT: 401006: {{.*}} movl %gs:(%ecx), %eax
+// DISASM-NEXT: 401009: {{.*}} movl $4294967288, %eax
+// DISASM-NEXT: 40100e: {{.*}} movl %gs:(%eax), %eax
+// DISASM-NEXT: 401011: {{.*}} addl $4294967288, %ecx
+// DISASM-NEXT: 401017: {{.*}} movl %gs:(%ecx), %eax
+// DISASM-NEXT: 40101a: {{.*}} movl $4294967292, %ecx
+// DISASM-NEXT: 401020: {{.*}} movl %gs:(%ecx), %eax
+// DISASM-NEXT: 401023: {{.*}} movl $4294967292, %eax
+// DISASM-NEXT: 401028: {{.*}} movl %gs:(%eax), %eax
+// DISASM-NEXT: 40102b: {{.*}} addl $4294967292, %ecx
+// DISASM-NEXT: 401031: {{.*}} movl %gs:(%ecx), %eax
+// DISASM-NEXT: 401034: {{.*}} movl 4202592, %ecx
+// DISASM-NEXT: 40103a: {{.*}} movl %gs:(%ecx), %eax
+// DISASM-NEXT: 40103d: {{.*}} addl 4202596, %ecx
+// DISASM-NEXT: 401043: {{.*}} movl %gs:(%ecx), %eax
 
 .type tlslocal0,@object
 .section .tbss,"awT",@nobits
 .globl tlslocal0
 .align 4
 tlslocal0:
  .long 0
  .size tlslocal0, 4