[lld][WebAssembly] Apply relocations to TLS data

[sbc100]

Summary

This is only needed in the case of dynamic linking and pthreads.
Previously these relocations were simply not be applied.

Also verified that this works using a more real world emscripten test:
https://github.com/emscripten-core/emscripten/pull/18641

[sbc100]

lld/wasm/Symbols.cpp

312

This is perhaps a concerning change. The original line here was added without any test changes in: https://reviews.llvm.org/D112831. Its seems to lack test coverage although the new test I've add here adds coverage.

I also ran the entire emscripten test suite with this change to ensure this change doesn't break anything.

[dschuff]

lld/wasm/Symbols.cpp

312

oh yeah I was going to ask, is that value getting moved to somewhere else. So this is used in exactly the case your new test covers, right? I guess it's no surprise that it was wrong, if the use case was also wrong in a different way, and nobody noticed before.

lld/test/wasm/tls-relocations.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
+
+.section data,"",@
+  .int32 41
+data_sym:
+  .int32 42
+  .size data_sym, 4
+
+# TLS data section of size 16 with as relocations at offset 8 and 12
+.section tls_sec,"T",@
+.globl  tls_sym
+.p2align  2
+  .int32 0x50
+tls_sym:
+  .int32 0x51
+  .int32 data_sym
+  .int32 tls_sym
+  .size tls_sym, 4
+
+.section  .custom_section.target_features,"",@
+  .int8 2
+  .int8 43
+  .int8 7
+  .ascii  "atomics"
+  .int8 43
+  .int8 11
+  .ascii  "bulk-memory"
+
+# RUN: wasm-ld --experimental-pic -pie -no-gc-sections --shared-memory --no-entry -o %t.wasm %t.o
+# RUN: obj2yaml %t.wasm | FileCheck %s
+# RUN: llvm-objdump -d --no-show-raw-insn --no-leading-addr %t.wasm | FileCheck --check-prefix=ASM %s --
+
+# CHECK:       - Type:            GLOBAL
+
+# __tls_base
+# CHECK-NEXT:    Globals:
+# CHECK-NEXT:      - Index:           3
+# CHECK-NEXT:        Type:            I32
+# CHECK-NEXT:        Mutable:         true
+# CHECK-NEXT:        InitExpr:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           0
+
+# __tls_size
+# CHECK-NEXT:      - Index:           4
+# CHECK-NEXT:        Type:            I32
+# CHECK-NEXT:        Mutable:         false
+# CHECK-NEXT:        InitExpr:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           16
+
+# __tls_align
+# CHECK-NEXT:      - Index:           5
+# 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-EMPTY:
+# ASM-NEXT:                 local.get 0
+# ASM-NEXT:                 global.set  3
+# ASM-NEXT:                 local.get 0
+# ASM-NEXT:                 i32.const 0
+# ASM-NEXT:                 i32.const 16
+# ASM-NEXT:                 memory.init 0, 0
+# call to __wasm_apply_tls_relocs
+# ASM-NEXT:                 call  4
+# ASM-NEXT:                 end
+
+# ASM: <__wasm_apply_tls_relocs>:
+# ASM-EMPTY:
+# ASM-NEXT:                 i32.const 8
+# ASM-NEXT:                 global.get  3
+# ASM-NEXT:                 i32.add
+# ASM-NEXT:                 global.get  1
+# ASM-NEXT:                 i32.const 20
+# ASM-NEXT:                 i32.add
+# ASM-NEXT:                 i32.store 0
+# ASM-NEXT:                 i32.const 12
+# ASM-NEXT:                 global.get  3
+# ASM-NEXT:                 i32.add
+# ASM-NEXT:                 global.get  3
+# ASM-NEXT:                 i32.const 4
+# ASM-NEXT:                 i32.add
+# ASM-NEXT:                 i32.store 0
+# ASM-NEXT:                 end

lld/test/wasm/tls.s

 # 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>
+# 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

lld/wasm/InputChunks.cpp

for (const WasmRelocation &rel : relocations) {
     Symbol *sym = file->getSymbol(rel);
     if (!config->isPic && sym->isDefined())
       continue;
 
     LLVM_DEBUG(dbgs() << "gen reloc: type=" << relocTypeToString(rel.Type)
                       << " addend=" << rel.Addend << " index=" << rel.Index
                       << " output offset=" << offset << "\n");
 
-    // Calculate the address at which to apply the relocations
+    // Calculate the address at which to apply the relocation
     writeU8(os, opcode_ptr_const, "CONST");
     writeSleb128(os, offset, "offset");
 
     // In PIC mode we need to add the __memory_base
     if (config->isPic) {
       writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
+      if (isTLS())
+        writeUleb128(os, WasmSym::tlsBase->getGlobalIndex(), "tls_base");
+      else
         writeUleb128(os, WasmSym::memoryBase->getGlobalIndex(), "memory_base");
       writeU8(os, opcode_ptr_add, "ADD");
     }
 
     // Now figure out what we want to store at this location
     bool is64 = relocIs64(rel.Type);
     unsigned opcode_reloc_const =
         is64 ? WASM_OPCODE_I64_CONST : WASM_OPCODE_I32_CONST;
     unsigned opcode_reloc_add =
if (sym->hasGOTIndex()) {
         writeU8(os, opcode_reloc_add, "ADD");
       }
     } else {
       assert(config->isPic);
       const GlobalSymbol* baseSymbol = WasmSym::memoryBase;
       if (rel.Type == R_WASM_TABLE_INDEX_I32 ||
           rel.Type == R_WASM_TABLE_INDEX_I64)
         baseSymbol = WasmSym::tableBase;
+      else if (sym->isTLS())
+        baseSymbol = WasmSym::tlsBase;
       writeU8(os, WASM_OPCODE_GLOBAL_GET, "GLOBAL_GET");
       writeUleb128(os, baseSymbol->getGlobalIndex(), "base");
       writeU8(os, opcode_reloc_const, "CONST");
       writeSleb128(os, file->calcNewValue(rel, tombstone, this), "offset");
       writeU8(os, opcode_reloc_add, "ADD");
     }
 
     // Store that value at the virtual address

lld/wasm/Symbols.h

struct WasmSym {
   // Function that applies relocations to data segment post-instantiation.
   static DefinedFunction *applyDataRelocs;
 
   // __wasm_apply_global_relocs
   // Function that applies relocations to wasm globals post-instantiation.
   // Unlike __wasm_apply_data_relocs this needs to run on every thread.
   static DefinedFunction *applyGlobalRelocs;
 
+  // __wasm_apply_tls_relocs
+  // Like applyDataRelocs but for TLS section.  These must be delayed until
+  // __wasm_init_tls.
+  static DefinedFunction *applyTLSRelocs;
+
   // __wasm_apply_global_tls_relocs
   // Like applyGlobalRelocs but for globals that hold TLS addresses.  These
   // must be delayed until __wasm_init_tls.
   static DefinedFunction *applyGlobalTLSRelocs;
 
   // __wasm_init_tls
   // Function that allocates thread-local storage and initializes it.
   static DefinedFunction *initTLS;

lld/wasm/Symbols.cpp

 }
 
 namespace wasm {
 DefinedFunction *WasmSym::callCtors;
 DefinedFunction *WasmSym::callDtors;
 DefinedFunction *WasmSym::initMemory;
 DefinedFunction *WasmSym::applyDataRelocs;
 DefinedFunction *WasmSym::applyGlobalRelocs;
+DefinedFunction *WasmSym::applyTLSRelocs;
 DefinedFunction *WasmSym::applyGlobalTLSRelocs;
 DefinedFunction *WasmSym::initTLS;
 DefinedFunction *WasmSym::startFunction;
 DefinedData *WasmSym::dsoHandle;
 DefinedData *WasmSym::dataEnd;
 DefinedData *WasmSym::globalBase;
 DefinedData *WasmSym::heapBase;
 DefinedData *WasmSym::heapEnd;

 }
 
 uint64_t DefinedData::getVA() const {
   LLVM_DEBUG(dbgs() << "getVA: " << getName() << "\n");
   // In the shared memory case, TLS symbols are relative to the start of the TLS
   // output segment (__tls_base).  When building without shared memory, TLS
   // symbols absolute, just like non-TLS.
   if (isTLS() && config->sharedMemory)
-    return getOutputSegmentOffset() + value;
+    return getOutputSegmentOffset();
   if (segment)
     return segment->getVA(value);
   return value;
 }
 
 void DefinedData::setVA(uint64_t value_) {
   LLVM_DEBUG(dbgs() << "setVA " << name << " -> " << value_ << "\n");
   assert(!segment);

lld/wasm/Writer.cpp

private:
   bool needsPassiveInitialization(const OutputSegment *segment);
   bool hasPassiveInitializedSegments();
 
   void createSyntheticInitFunctions();
   void createInitMemoryFunction();
   void createStartFunction();
   void createApplyDataRelocationsFunction();
   void createApplyGlobalRelocationsFunction();
+  void createApplyTLSRelocationsFunction();
   void createApplyGlobalTLSRelocationsFunction();
   void createCallCtorsFunction();
   void createInitTLSFunction();
   void createCommandExportWrappers();
   void createCommandExportWrapper(uint32_t functionIndex, DefinedFunction *f);
 
   void assignIndexes();
   void populateSymtab();
if (hasPassiveInitializedSegments()) {
     WasmSym::initMemory->markLive();
     if (config->sharedMemory) {
       // This global is assigned during  __wasm_init_memory in the shared memory
       // case.
       WasmSym::tlsBase->markLive();
     }
   }
 
-  if (config->sharedMemory && out.globalSec->needsTLSRelocations()) {
+  if (config->sharedMemory) {
+    if (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();
       // TLS relocations depend on  the __tls_base symbols
       WasmSym::tlsBase->markLive();
     }
 
+    auto hasTLSRelocs = [](const OutputSegment *segment) {
+      if (segment->isTLS())
+        for (const auto* is: segment->inputSegments)
+          if (is->getRelocations().size())
+            return true;
+      return false;
+    };
+    if (llvm::any_of(segments, hasTLSRelocs)) {
+      WasmSym::applyTLSRelocs = symtab->addSyntheticFunction(
+          "__wasm_apply_tls_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
+          make<SyntheticFunction>(nullSignature,
+                                  "__wasm_apply_tls_relocs"));
+      WasmSym::applyTLSRelocs->markLive();
+    }
+  }
+
   if (config->isPic && 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 there is only one start function we can just use that function

 void Writer::createApplyDataRelocationsFunction() {
   LLVM_DEBUG(dbgs() << "createApplyDataRelocationsFunction\n");
   // First write the body's contents to a string.
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
     writeUleb128(os, 0, "num locals");
     for (const OutputSegment *seg : segments)
+      if (!config->sharedMemory || !seg->isTLS())
         for (const InputChunk *inSeg : seg->inputSegments)
           inSeg->generateRelocationCode(os);
 
     writeU8(os, WASM_OPCODE_END, "END");
   }
 
   createFunction(WasmSym::applyDataRelocs, bodyContent);
 }
 
+void Writer::createApplyTLSRelocationsFunction() {
+  LLVM_DEBUG(dbgs() << "createApplyTLSRelocationsFunction\n");
+  std::string bodyContent;
+  {
+    raw_string_ostream os(bodyContent);
+    writeUleb128(os, 0, "num locals");
+    for (const OutputSegment *seg : segments)
+      if (seg->isTLS())
+        for (const InputChunk *inSeg : seg->inputSegments)
+          inSeg->generateRelocationCode(os);
+
+    writeU8(os, WASM_OPCODE_END, "END");
+  }
+
+  createFunction(WasmSym::applyTLSRelocs, bodyContent);
+}
+
 // Similar to createApplyDataRelocationsFunction but generates relocation code
 // for WebAssembly globals. Because these globals are not shared between threads
 // these relocation need to run on every thread.
 void Writer::createApplyGlobalRelocationsFunction() {
   // First write the body's contents to a string.
   std::string bodyContent;
   {
     raw_string_ostream os(bodyContent);
if (tlsSeg) {
       writeI32Const(os, tlsSeg->size, "memory region size");
 
       writeU8(os, WASM_OPCODE_MISC_PREFIX, "bulk-memory prefix");
       writeUleb128(os, WASM_OPCODE_MEMORY_INIT, "MEMORY.INIT");
       writeUleb128(os, tlsSeg->index, "segment index immediate");
       writeU8(os, 0, "memory index immediate");
     }
 
+    if (WasmSym::applyTLSRelocs) {
+      writeU8(os, WASM_OPCODE_CALL, "CALL");
+      writeUleb128(os, WasmSym::applyTLSRelocs->getFunctionIndex(),
+                   "function index");
+    }
+
     if (WasmSym::applyGlobalTLSRelocs) {
       writeU8(os, WASM_OPCODE_CALL, "CALL");
       writeUleb128(os, WasmSym::applyGlobalTLSRelocs->getFunctionIndex(),
                    "function index");
     }
     writeU8(os, WASM_OPCODE_END, "end function");
   }
 
void Writer::run() {
   calculateInitFunctions();
 
   if (!config->relocatable) {
     // Create linker synthesized functions
     if (WasmSym::applyDataRelocs)
       createApplyDataRelocationsFunction();
     if (WasmSym::applyGlobalRelocs)
       createApplyGlobalRelocationsFunction();
+    if (WasmSym::applyTLSRelocs)
+      createApplyTLSRelocationsFunction();
     if (WasmSym::applyGlobalTLSRelocs)
       createApplyGlobalTLSRelocationsFunction();
     if (WasmSym::initMemory)
       createInitMemoryFunction();
     createStartFunction();
 
     createCallCtorsFunction();