[lld][WebAssembly] Generate TLS relocation code also when linking statically

[sbc100]

Summary

Previously relocations were only generated for PIC output, but
relocations for TLS GOT entries are always needed when shared
memory is enabled, not just in PIC mode.

This means that the __wasm_apply_global_tls_relocs is now
generated even for statically linked (non-PIC) output. Without
this the globals that hold the addresses of TLS symbols are
not set correctly.

[sbc100]

• rebase

[sbc100]

• revert part

[dschuff]

lld/wasm/SyntheticSections.cpp

460

lld/test/wasm/pie.ll

 ; to be generated along with __wasm_start as the start
 ; function.
 
 ; RUN: llc -relocation-model=pic -mattr=+mutable-globals,+atomics,+bulk-memory -filetype=obj %s -o %t.shmem.o
 ; RUN: wasm-ld --no-gc-sections --shared-memory --allow-undefined --experimental-pic -pie -o %t.shmem.wasm %t.shmem.o
 ; RUN: obj2yaml %t.shmem.wasm | FileCheck %s --check-prefix=SHMEM
 
 ; SHMEM:         - Type:            CODE
-; SHMEM:           - Index:           7
+; SHMEM:           - Index:           6
 ; SHMEM-NEXT:        Locals:          []
 ; SHMEM-NEXT:        Body:            100310050B
 
 ; SHMEM:         FunctionNames:
 ; SHMEM-NEXT:      - Index:           0
 ; SHMEM-NEXT:        Name:            external_func
 ; SHMEM-NEXT:      - Index:           1
 ; SHMEM-NEXT:        Name:            __wasm_call_ctors
 ; SHMEM-NEXT:      - Index:           2
 ; SHMEM-NEXT:        Name:            __wasm_init_tls
 ; SHMEM-NEXT:      - Index:           3
 ; SHMEM-NEXT:        Name:            __wasm_init_memory
 ; SHMEM-NEXT:      - Index:           4
 ; SHMEM-NEXT:        Name:            __wasm_apply_data_relocs
 ; SHMEM-NEXT:      - Index:           5
 ; SHMEM-NEXT:        Name:            __wasm_apply_global_relocs
 ; SHMEM-NEXT:      - Index:           6
-; SHMEM-NEXT:        Name:            __wasm_apply_global_tls_relocs
-; SHMEM-NEXT:      - Index:           7
 ; SHMEM-NEXT:        Name:            __wasm_start
-; SHMEM-NEXT:      - Index:           8
+; SHMEM-NEXT:      - Index:           7
 ; SHMEM-NEXT:        Name:            foo
-; SHMEM-NEXT:      - Index:           9
+; SHMEM-NEXT:      - Index:           8
 ; SHMEM-NEXT:        Name:            get_data_address
-; SHMEM-NEXT:      - Index:           10
+; SHMEM-NEXT:      - Index:           9
 ; SHMEM-NEXT:        Name:            _start
 

lld/test/wasm/tls-non-shared-memory.s

.section  .custom_section.target_features,"",@
   .ascii  "bulk-memory"
 
 # RUN: wasm-ld --no-gc-sections --no-entry -o %t.wasm %t.o
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # RUN: wasm-ld --experimental-pic -shared -o %t.so %t.o
 # RUN: obj2yaml %t.so | FileCheck %s --check-prefix=PIC
 
+# RUN: wasm-ld --experimental-pic --no-gc-sections --no-entry -pie -o %t-pie.wasm %t.o
+# RUN: obj2yaml %t.so | FileCheck %s --check-prefix=PIC
+
 #      CHECK:   - Type:            GLOBAL
 # __stack_pointer
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         true
 # CHECK-NEXT:         InitExpr:
 # CHECK-NEXT:           Opcode:          I32_CONST

lld/test/wasm/tls.s

tls3_addr:
   end_function
 
 .globl tls_align
 tls_align:
   .functype tls_align () -> (i32)
   global.get __tls_align
   end_function
 
+# TLS symbols can also be accessed by `global.get tls1@GOT@TLS`
+# which is the pattern emitted for non-DSO-local symbols.
+# In this case the global that holds that address must be
+# initialized by `__wasm_apply_global_tls_relocs` which is
+# called by `__wasm_init_tls`.
+.globl tls1_got_addr
+tls1_got_addr:
+  .functype tls1_got_addr () -> (i32)
+  global.get tls1@GOT@TLS
+  end_function
+
 .section  .bss.no_tls,"",@
 .globl  no_tls
 .p2align  2
 no_tls:
   .int32  0
   .size no_tls, 4
 
 // Older versions of LLVM did not use the "T" flag so we need to support

 # CHECK-NEXT:     - Index:           3
 # CHECK-NEXT:       Type:            I32
 # CHECK-NEXT:       Mutable:         false
 # CHECK-NEXT:       InitExpr:
 # CHECK-NEXT:         Opcode:          I32_CONST
 # CHECK-NEXT:         Value:           4
 
 
-# ASM:      <__wasm_init_tls>:
+# ASM-LABEL: <__wasm_init_tls>:
 # ASM-EMPTY:
 # ASM-NEXT:   local.get 0
 # ASM-NEXT:   global.set 1
 # ASM-NEXT:   local.get 0
 # ASM-NEXT:   i32.const 0
 # ASM-NEXT:   i32.const 12
 # ASM-NEXT:   memory.init 0, 0
+# call to __wasm_apply_global_tls_relocs>
+# ASM-NEXT:   call 3
+# ASM-NEXT:   end
+
+# ASM-LABEL: <__wasm_apply_global_tls_relocs>:
+# ASM-EMPTY:
+# ASM-NEXT:   global.get      1
+# ASM-NEXT:   i32.const       0
+# ASM-NEXT:   i32.add
+# ASM-NEXT:   global.set      4
 # ASM-NEXT:   end
 
-# ASM:      <tls1_addr>:
+# ASM-LABEL: <tls1_addr>:
 # ASM-EMPTY:
 # ASM-NEXT:   global.get 1
 # ASM-NEXT:   i32.const 0
 # ASM-NEXT:   i32.add
 # ASM-NEXT:   end
 
-# ASM:      <tls2_addr>:
+# ASM-LABEL: <tls2_addr>:
 # ASM-EMPTY:
 # ASM-NEXT:   global.get 1
 # ASM-NEXT:   i32.const 4
 # ASM-NEXT:   i32.add
 # ASM-NEXT:   end
 
-# ASM:      <tls3_addr>:
+# ASM-LABEL: <tls3_addr>:
 # ASM-EMPTY:
 # ASM-NEXT:   global.get 1
 # ASM-NEXT:   i32.const 8
 # ASM-NEXT:   i32.add
 # ASM-NEXT:   end
 
-# ASM:      <tls_align>:
+# ASM-LABEL: <tls_align>:
 # ASM-EMPTY:
-# ASM-NEXT:  global.get 3
-# ASM-NEXT:  end
+# ASM-NEXT:   global.get 3
+# ASM-NEXT:   end
 
 # Also verify TLS usage with --relocatable
 # RUN: wasm-ld --relocatable -o %t3.wasm %t.o
 # RUN: obj2yaml %t3.wasm | FileCheck %s --check-prefix=RELOC
 
 # RELOC:       - Type:            IMPORT
 # RELOC-NEXT:    Imports:
 # RELOC-NEXT:      - Module:          env
 # RELOC-NEXT:        Field:           __tls_base
 # RELOC-NEXT:        Kind:            GLOBAL
 # RELOC-NEXT:        GlobalType:      I32
 # RELOC-NEXT:        GlobalMutable:   true
 # RELOC-NEXT:      - Module:          env
 # RELOC-NEXT:        Field:           __tls_align
 # RELOC-NEXT:        Kind:            GLOBAL
 # RELOC-NEXT:        GlobalType:      I32
 # RELOC-NEXT:        GlobalMutable:   false
 
 # RELOC:         GlobalNames:
 # RELOC-NEXT:      - Index:           0
 # RELOC-NEXT:        Name:            __tls_base
 # RELOC-NEXT:      - Index:           1
 # RELOC-NEXT:        Name:            __tls_align
+# RELOC-NEXT:      - Index:           2
+# RELOC-NEXT:        Name:            GOT.data.internal.tls1
 # RELOC-NEXT:    DataSegmentNames:
 # RELOC-NEXT:      - Index:           0
 # RELOC-NEXT:        Name:            .tdata
 # RELOC-NEXT:      - Index:           1
 # RELOC-NEXT:        Name:            .bss.no_tls

lld/wasm/SyntheticSections.h

public:
   //
   // For the static linking case these internal globals can be completely
   // eliminated by a post-link optimizer such as wasm-opt.
   //
   // TODO(sbc): Another approach to optimizing these away could be to use
   // specific relocation types combined with linker relaxation which could
   // transform a `global.get` to an `i32.const`.
   void addInternalGOTEntry(Symbol *sym);
-  bool needsRelocations() { return internalGotSymbols.size(); }
+  bool needsRelocations() {
+    return llvm::find_if(internalGotSymbols, [=](Symbol *sym) {
+             return !sym->isTLS();
+           }) != internalGotSymbols.end();
+  }
+  bool needsTLSRelocations() {
+    return llvm::find_if(internalGotSymbols, [=](Symbol *sym) {
+             return sym->isTLS();
+           }) != internalGotSymbols.end();
+  }
   void generateRelocationCode(raw_ostream &os, bool TLS) const;
 
   std::vector<DefinedData *> dataAddressGlobals;
   std::vector<InputGlobal *> inputGlobals;
   std::vector<Symbol *> internalGotSymbols;
 
 protected:
   bool isSealed = false;

lld/wasm/SyntheticSections.cpp

void GlobalSection::writeBody() {
   writeUleb128(os, numGlobals(), "global count");
   for (InputGlobal *g : inputGlobals) {
     writeGlobalType(os, g->getType());
     writeInitExpr(os, g->getInitExpr());
   }
   bool is64 = config->is64.getValueOr(false);
   uint8_t itype = is64 ? WASM_TYPE_I64 : WASM_TYPE_I32;
   for (const Symbol *sym : internalGotSymbols) {
-    // In the case of dynamic linking, internal GOT entries
-    // need to be mutable since they get updated to the correct
-    // runtime value during `__wasm_apply_global_relocs`.
-    bool mutable_ = config->isPic & !sym->isStub;
+    bool mutable_ = false;
+    if (!sym->isStub) {
+      // In the case of dynamic linking, these global must to be mutable since
+      // they get updated to the correct runtime value during
+      // `__wasm_apply_global_relocs`.
+      if (config->isPic && !sym->isTLS())
+        mutable_ = true;
+      // With multi-theadeding any TLS globals must be mutable since they get
+      // set during `__wasm_apply_global_tls_relocs`
+      if (config->sharedMemory && sym->isTLS())
+        mutable_ = true;
+    }
     WasmGlobalType type{itype, mutable_};
     WasmInitExpr initExpr;
     if (auto *d = dyn_cast<DefinedData>(sym))
       initExpr = intConst(d->getVA(), is64);
     else if (auto *f = dyn_cast<FunctionSymbol>(sym))
       initExpr = intConst(f->isStub ? 0 : f->getTableIndex(), is64);
     else {
       assert(isa<UndefinedData>(sym));

lld/wasm/Writer.cpp

void Writer::createSyntheticInitFunctions() {
   // function.
   if (hasPassiveInitializedSegments()) {
     WasmSym::initMemory = symtab->addSyntheticFunction(
         "__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
     WasmSym::initMemory->markLive();
   }
 
+  if (config->sharedMemory && out.globalSec->needsTLSRelocations()) {
+    WasmSym::applyGlobalTLSRelocs = symtab->addSyntheticFunction(
+        "__wasm_apply_global_tls_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
+        make<SyntheticFunction>(nullSignature,
+                                "__wasm_apply_global_tls_relocs"));
+    WasmSym::applyGlobalTLSRelocs->markLive();
+  }
+
   if (config->isPic) {
     // For PIC code we create synthetic functions that apply relocations.
     // These get called from __wasm_call_ctors before the user-level
     // constructors.
     WasmSym::applyDataRelocs = symtab->addSyntheticFunction(
         "__wasm_apply_data_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_apply_data_relocs"));
     WasmSym::applyDataRelocs->markLive();
 
     if (out.globalSec->needsRelocations()) {
       WasmSym::applyGlobalRelocs = symtab->addSyntheticFunction(
           "__wasm_apply_global_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
           make<SyntheticFunction>(nullSignature, "__wasm_apply_global_relocs"));
       WasmSym::applyGlobalRelocs->markLive();
-      if (config->sharedMemory) {
-        WasmSym::applyGlobalTLSRelocs = symtab->addSyntheticFunction(
-            "__wasm_apply_global_tls_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
-            make<SyntheticFunction>(nullSignature,
-                                    "__wasm_apply_global_tls_relocs"));
-        WasmSym::applyGlobalTLSRelocs->markLive();
-      }
     }
   }
 
   if (WasmSym::applyGlobalRelocs && WasmSym::initMemory) {
     WasmSym::startFunction = symtab->addSyntheticFunction(
         "__wasm_start", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(nullSignature, "__wasm_start"));
     WasmSym::startFunction->markLive();
void Writer::run() {
   populateTargetFeatures();
   log("-- createSyntheticInitFunctions");
   createSyntheticInitFunctions();
   log("-- assignIndexes");
   assignIndexes();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
 
+  if (WasmSym::applyGlobalTLSRelocs)
+    createApplyGlobalTLSRelocationsFunction();
+
   if (!config->relocatable) {
     // Create linker synthesized functions
     if (WasmSym::applyDataRelocs)
       createApplyDataRelocationsFunction();
     if (WasmSym::applyGlobalRelocs)
       createApplyGlobalRelocationsFunction();
-    if (WasmSym::applyGlobalTLSRelocs)
-      createApplyGlobalTLSRelocationsFunction();
     if (WasmSym::initMemory)
       createInitMemoryFunction();
     createStartFunction();
 
     createCallCtorsFunction();
 
     // Create export wrappers for commands if needed.
     //