Block in dlopen until all threads have loaded the module

Fixes: #18345

Author: sbc100

emcc.py

@@ -1634,7 +1634,12 @@ def setup_pthreads(target):
   ]
 
   if settings.MAIN_MODULE:
-    settings.REQUIRED_EXPORTS += ['_emscripten_thread_sync_code', '__dl_seterr']
+    settings.REQUIRED_EXPORTS += [
+      '_emscripten_thread_sync_code',
+      '_emscripten_thread_sync_code_async',
+      '_emscripten_proxy_sync_code',
+      '__dl_seterr',
+    ]
 
   settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += [
     '$exitOnMainThread',

src/library_pthread.js

@@ -1069,6 +1069,83 @@ var LibraryPThread = {
 #endif
   },
 
+#if MAIN_MODULE
+  $promiseMap: "new Map();",
+  $nextPromiseId: 1,
+
+  // Create a new promise that can be resolved or rejected by passing
+  // a unique ID to emscripten_promise_resolve/emscripten_promise_reject
+  $newNativePromise__deps: ['$promiseMap', '$nextPromiseId'],
+  $newNativePromise: function(func, args) {
+    return new Promise((resolve, reject) => {
+      var promiseId = nextPromiseId;
+      nextPromiseId += 1;
+      promiseMap.set(promiseId, {resolve, reject});
+      // Native promise function take promise ID as last argument
+      args.push(promiseId);
+      func.apply(null, args);
+    });
+  },
+
+  emscripten_promise_resolve__deps: ['$promiseMap'],
+  emscripten_promise_resolve__sig: 'vip',
+  emscripten_promise_resolve: function(id, value) {
+#if RUNTIME_DEBUG
+    err('emscripten_resolve_promise: ' + id);
+#endif
+    assert(promiseMap.has(id));
+    promiseMap.get(id).resolve(value);
+    promiseMap.delete(id);
+  },
+
+  emscripten_promise_reject__deps: ['$promiseMap'],
+  emscripten_promise_reject__sig: 'vip',
+  emscripten_promise_reject: function(id) {
+#if RUNTIME_DEBUG
+    dbg('emscripten_promise_reject: ' + id);
+#endif
+    assert(promiseMap.has(id));
+    promiseMap.get(id).reject();
+  },
+
+  // Called on the main thread to syncronize the code loaded on all threads.
+  // This work happens asyncronously. The `callback` is called once this work
+  // is completely, passing the ctx.
+  _emscripten_sync_all_threads__sig: 'viii',
+  _emscripten_sync_all_threads__deps: ['_emscripten_proxy_sync_code', '$newNativePromise'],
+  _emscripten_sync_all_threads: function(caller, callback, ctx) {
+#if PTHREADS_DEBUG
+    dbg("_emscripten_sync_all_threads caller=" + ptrToString(caller));
+#endif
+#if ASSERTIONS
+    assert(!ENVIRONMENT_IS_PTHREAD, 'Internal Error! _emscripten_sync_all_threads() can only ever be called from main thread');
+#endif
+
+    let promises = [];
+
+    // This first promise resolves once the main thread has loaded all module
+    promises.push(newNativePromise(__emscripten_thread_sync_code_async, [0]));
+
+    // We then create a sequence of promises, one per thread, that resolve once
+    // each thread has performed its sync using _emscripten_proxy_sync_code.
+    for (const ptr of Object.keys(PThread.pthreads)) {
+      const pthread_ptr = Number(ptr);
+      if (pthread_ptr !== caller) {
+        promises.push(newNativePromise(__emscripten_proxy_sync_code, [pthread_ptr]));
+      }
+    }
+
+    // Once all promises are resolved then we we know all threads are in
+    // sync and we can call the callback.
+    Promise.all(promises).then(() => {
+#if PTHREADS_DEBUG
+      dbg("_emscripten_sync_all_threads done: calling callback");
+#endif
+      {{{ makeDynCall('vp', 'callback') }}}(ctx);
+    });
+  },
+#endif
+
   $executeNotifiedProxyingQueue: function(queue) {
     // Set the notification state to processing.
     Atomics.store(HEAP32, queue >> 2, {{{ cDefine('NOTIFICATION_RECEIVED') }}});

system/include/emscripten/threading.h

@@ -286,9 +286,6 @@ int emscripten_pthread_attr_settransferredcanvases(pthread_attr_t *a, const char
 // blocking is not enabled, see ALLOW_BLOCKING_ON_MAIN_THREAD.
 void emscripten_check_blocking_allowed(void);
 
-// Experimental API for syncing loaded code between pthreads.
-void _emscripten_thread_sync_code();
-
 void _emscripten_yield();
 
 #ifdef __cplusplus