Add support for TLS imports/exports to/from DSOs

Author: sbc100

emcc.py

@@ -1623,7 +1623,15 @@ def default_setting(name, new_default):
     settings.EXPORT_ALL = 1
 
   if settings.MAIN_MODULE:
-    settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$getDylinkMetadata', '$mergeLibSymbols']
+    settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += [
+        '$getDylinkMetadata',
+        '$mergeLibSymbols',
+    ]
+
+  if settings.USE_PTHREADS:
+    settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += [
+        '$registerTlsInit',
+    ]
 
   if settings.RELOCATABLE:
     settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += [

src/library_dylink.js

@@ -68,7 +68,7 @@ var LibraryDylink = {
   },
 
   $updateGOT__deps: ['$GOT', '$isInternalSym'],
-  $updateGOT: function(exports) {
+  $updateGOT: function(exports, replace) {
 #if DYLINK_DEBUG
     err("updateGOT: " + Object.keys(exports).length);
 #endif
@@ -77,7 +77,6 @@ var LibraryDylink = {
         continue;
       }
 
-      var replace = false;
       var value = exports[symName];
 #if !WASM_BIGINT
       if (symName.startsWith('orig$')) {
@@ -117,7 +116,7 @@ var LibraryDylink = {
 
   // Applies relocations to exported things.
   $relocateExports__deps: ['$updateGOT'],
-  $relocateExports: function(exports, memoryBase) {
+  $relocateExports: function(exports, memoryBase, replace) {
     var relocated = {};
 
     for (var e in exports) {
@@ -139,7 +138,7 @@ var LibraryDylink = {
       }
       relocated[e] = value;
     }
-    updateGOT(relocated);
+    updateGOT(relocated, replace);
     return relocated;
   },
 
@@ -256,37 +255,46 @@ var LibraryDylink = {
   // returns the side module metadata as an object
   // { memorySize, memoryAlign, tableSize, tableAlign, neededDynlibs}
   $getDylinkMetadata: function(binary) {
-    var next = 0;
+    var offset = 0;
+    var end = 0;
+
+    function getU8() {
+      return binary[offset++];
+    }
+
     function getLEB() {
       var ret = 0;
       var mul = 1;
       while (1) {
-        var byte = binary[next++];
+        var byte = binary[offset++];
         ret += ((byte & 0x7f) * mul);
         mul *= 0x80;
         if (!(byte & 0x80)) break;
       }
       return ret;
     }
 
+    function getString() {
+      var len = getLEB();
+      offset += len;
+      return UTF8ArrayToString(binary, offset - len, len);
+    }
+
     if (binary instanceof WebAssembly.Module) {
       var dylinkSection = WebAssembly.Module.customSections(binary, "dylink");
       assert(dylinkSection.length != 0, 'need dylink section');
       binary = new Uint8Array(dylinkSection[0]);
+      end = binary.length
     } else {
       var int32View = new Uint32Array(new Uint8Array(binary.subarray(0, 24)).buffer);
       assert(int32View[0] == 0x6d736100, 'need to see wasm magic number'); // \0asm
       // we should see the dylink section right after the magic number and wasm version
       assert(binary[8] === 0, 'need the dylink section to be first')
-      next = 9;
-      getLEB(); //section size
-      assert(binary[next] === 6);                 next++; // size of "dylink" string
-      assert(binary[next] === 'd'.charCodeAt(0)); next++;
-      assert(binary[next] === 'y'.charCodeAt(0)); next++;
-      assert(binary[next] === 'l'.charCodeAt(0)); next++;
-      assert(binary[next] === 'i'.charCodeAt(0)); next++;
-      assert(binary[next] === 'n'.charCodeAt(0)); next++;
-      assert(binary[next] === 'k'.charCodeAt(0)); next++;
+      offset = 9;
+      var section_size = getLEB(); //section size
+      end = offset + section_size;
+      var name = getString();
+      assert(name == 'dylink');
     }
 
     var customSection = {};
@@ -304,12 +312,38 @@ var LibraryDylink = {
     var neededDynlibsCount = getLEB();
     customSection.neededDynlibs = [];
     for (var i = 0; i < neededDynlibsCount; ++i) {
-      var nameLen = getLEB();
-      var nameUTF8 = binary.subarray(next, next + nameLen);
-      next += nameLen;
-      var name = UTF8ArrayToString(nameUTF8, 0);
+      var name = getString();
       customSection.neededDynlibs.push(name);
     }
+
+#if DYLINK_DEBUG
+    err('dylink needed:' + customSection.neededDynlibs);
+#endif
+    customSection.tlsExports = {};
+
+    var WASM_DYLINK_EXPORT_INFO = 0x1;
+    var WASM_DYLINK_IMPORT_INFO = 0x2;
+    var WASM_SYMBOL_TLS = 0x100;
+
+    while (offset < end) {
+      var subsectionType = getU8();
+      var subsectionSize = getLEB();
+      if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
+        var count = getLEB();
+        while (count--) {
+          var name = getString();
+          var flags = getLEB();
+          if (flags & WASM_SYMBOL_TLS) {
+            customSection.tlsExports[name] = 1;
+          }
+        }
+      } else {
+        err('unknown subsection: ' + subsectionType)
+        // unknown subsection
+        offset += subsectionSize;
+      }
+    }
+    assert(offset == end);
     return customSection;
   },
 
@@ -485,17 +519,7 @@ var LibraryDylink = {
 #if USE_PTHREADS
         // Only one thread (currently The main thread) should call
         // __wasm_call_ctors, but all threads need to call emscripten_tls_init
-        var initTLS = moduleExports['emscripten_tls_init'];
-#if ASSERTIONS
-        assert(initTLS);
-#endif
-#if DYLINK_DEBUG
-        out("adding to tlsInitFunctions: " + initTLS);
-#endif
-        PThread.tlsInitFunctions.push(initTLS);
-        if (runtimeInitialized) {
-          initTLS();
-        }
+        registerTlsInit(instance.exports, metadata)
         if (!ENVIRONMENT_IS_PTHREAD) {
 #endif
           var init = moduleExports['__wasm_call_ctors'];

src/library_pthread.js

@@ -470,6 +470,33 @@ var LibraryPThread = {
     }
   },
 
+  $registerTlsInit: function(moduleExports, metadata) {
+    var emscripten_tls_init = moduleExports['emscripten_tls_init'];
+    assert(emscripten_tls_init);
+#if DYLINK_DEBUG
+    out("adding to tlsInitFunctions: " + emscripten_tls_init);
+#endif
+#if RELOCATABLE
+    function tlsInint() {
+      var __tls_base = emscripten_tls_init();
+#if DYLINK_DEBUG
+      err('tlsInint -> ' + __tls_base);
+#endif
+      for (var sym in metadata.tlsExports) {
+        metadata.tlsExports[sym] = moduleExports[sym];
+      }
+      relocateExports(metadata.tlsExports, __tls_base, true);
+    }
+
+    PThread.tlsInitFunctions.push(tlsInint);
+    if (runtimeInitialized) {
+      tlsInint();
+    }
+#else
+    PThread.tlsInitFunctions.push(emscripten_tls_init);
+#endif
+  },
+
   $cancelThread: function(pthread_ptr) {
     if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! cancelThread() can only ever be called from main application thread!';
     if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in cancelThread!';

src/preamble.js

@@ -970,15 +970,23 @@ function createWasm() {
     Module['asm'] = exports;
 
 #if MAIN_MODULE
-#if AUTOLOAD_DYLIBS
     var metadata = getDylinkMetadata(module);
+#if AUTOLOAD_DYLIBS
     if (metadata.neededDynlibs) {
       dynamicLibraries = metadata.neededDynlibs.concat(dynamicLibraries);
     }
 #endif
     mergeLibSymbols(exports, 'main')
 #endif
 
+#if USE_PTHREADS
+#if MAIN_MODULE
+    registerTlsInit(instance.exports, metadata);
+#else
+    registerTlsInit(instance.exports);
+#endif
+#endif
+
 #if !IMPORTED_MEMORY
     wasmMemory = Module['asm']['memory'];
 #if ASSERTIONS
@@ -1015,7 +1023,6 @@ function createWasm() {
     exportAsmFunctions(exports);
 #endif
 #if USE_PTHREADS
-    PThread.tlsInitFunctions.push(Module['asm']['emscripten_tls_init']);
     // We now have the Wasm module loaded up, keep a reference to the compiled module so we can post it to the workers.
     wasmModule = module;
     // Instantiation is synchronous in pthreads and we assert on run dependencies.

system/lib/pthread/emscripten_tls_init.c

@@ -28,15 +28,17 @@ static void free_tls(void* tls_block) {
   emscripten_builtin_free(tls_block);
 }
 
-void emscripten_tls_init(void) {
+void* emscripten_tls_init(void) {
   size_t tls_size = __builtin_wasm_tls_size();
   size_t tls_align = __builtin_wasm_tls_align();
-  if (tls_size) {
-    void *tls_block = emscripten_builtin_memalign(tls_align, tls_size);
+  if (!tls_size) {
+    return NULL;
+  }
+  void *tls_block = emscripten_builtin_memalign(tls_align, tls_size);
 #ifdef DEBUG_TLS
-    printf("tls init: thread[%p] dso[%p] -> %p\n", pthread_self(), &__dso_handle, tls_block);
+  printf("tls init: thread[%p] dso[%p] -> %p\n", pthread_self(), &__dso_handle, tls_block);
 #endif
-    __wasm_init_tls(tls_block);
-    __cxa_thread_atexit(free_tls, tls_block, &__dso_handle);
-  }
+  __wasm_init_tls(tls_block);
+  __cxa_thread_atexit(free_tls, tls_block, &__dso_handle);
+  return tls_block;
 }

tests/core/test_dylink_tls_export.c

@@ -0,0 +1,34 @@
+#include <threads.h>
+#include <stdio.h>
+
+thread_local int foo = 10;
+thread_local int bar = 11;
+extern thread_local int baz;
+extern thread_local int wiz;
+
+void sidey();
+
+int get_foo() {
+  return foo;
+}
+
+int get_bar() {
+  return bar;
+}
+
+int get_baz() {
+  return baz;
+}
+
+int get_wiz() {
+  return wiz;
+}
+
+int main(int argc, char const *argv[]) {
+  printf("main: foo=%d\n", get_foo());
+  printf("main: bar=%d\n", get_bar());
+  printf("side: baz=%d\n", get_baz());
+  printf("side: wiz=%d\n", get_wiz());
+  sidey();
+  return 0;
+}

tests/core/test_dylink_tls_export.out

@@ -0,0 +1,8 @@
+main: foo=10
+main: bar=11
+side: baz=42
+side: wiz=43
+side: foo=10
+side: bar=11
+side: baz=42
+side: wiz=43

tests/core/test_dylink_tls_export_side.c

@@ -0,0 +1,31 @@
+#include <threads.h>
+#include <stdio.h>
+#include <threads.h>
+
+thread_local int baz = 42;
+thread_local int wiz = 43;
+extern thread_local int foo;
+extern thread_local int bar;
+
+int get_foo() {
+  return foo;
+}
+
+int get_bar() {
+  return bar;
+}
+
+int get_baz() {
+  return baz;
+}
+
+int get_wiz() {
+  return wiz;
+}
+
+void sidey() {
+  printf("side: foo=%d\n", get_foo());
+  printf("side: bar=%d\n", get_bar());
+  printf("side: baz=%d\n", get_baz());
+  printf("side: wiz=%d\n", get_wiz());
+}

tests/test_core.py

@@ -4586,16 +4586,17 @@ def test_dylink_weak(self):
   @node_pthreads
   @needs_dylink
   def test_dylink_tls(self):
-    # We currently can't export TLS symbols from module since we don't have
-    # and ABI for signaling which exports are TLS and which are regular
-    # data exports.
-
-    # TODO(sbc): Add tests that depend on importing/exported TLS symbols
-    # once we figure out how to do that.
     self.emcc_args.append('-Wno-experimental')
     self.dylink_testf(test_file('core/test_dylink_tls.c'),
                       need_reverse=False)
 
+  @node_pthreads
+  @needs_dylink
+  def test_dylink_tls_export(self):
+    self.emcc_args.append('-Wno-experimental')
+    self.dylink_testf(test_file('core/test_dylink_tls_export.c'),
+                      need_reverse=False)
+
   def test_random(self):
     src = r'''#include <stdlib.h>
 #include <stdio.h>