Initialize all embind bindings on all threads (#17499)

This change replaces `__embind_register_native_and_builtin_types` with
`_embind_register_bindings` which calls all `EMSCRIPTEN_BINDINGS`
functions.

Fixes: #17372

Author: sbc100

src/worker.js

@@ -213,9 +213,12 @@ self.onmessage = (e) => {
 
       if (!initializedJS) {
 #if EMBIND
+#if ASSERTIONS
+        err('Pthread 0x' + Module['_pthread_self']().toString(16) + ' initializing embind.');
+#endif
         // Embind must initialize itself on all threads, as it generates support JS.
         // We only do this once per worker since they get reused
-        Module['___embind_register_native_and_builtin_types']();
+        Module['__embind_initialize_bindings']();
 #endif // EMBIND
 
         // Execute any proxied work that came in before the thread was

system/include/emscripten/bind.h

@@ -246,6 +246,23 @@ void _embind_register_constant(
     TYPEID constantType,
     double value);
 
+// Register an InitFunc in the global linked list of init functions.
+void _embind_register_bindings(struct InitFunc* f);
+
+// Binding initialization functions registerd by EMSCRIPTEN_BINDINGS macro
+// below.  Stored as linked list of static data object avoiding std containers
+// to avoid static contructor ordering issues.
+struct InitFunc {
+  InitFunc(void (*init_func)()) : init_func(init_func) {
+    // This the function immediately upon constructions, and also register
+    // it so that it can be called again on each worker that starts.
+    init_func();
+    _embind_register_bindings(this);
+  }
+  void (*init_func)();
+  InitFunc* next = nullptr;
+};
+
 } // end extern "C"
 
 } // end namespace internal
@@ -1920,15 +1937,15 @@ class enum_ {
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace internal {
-    template<typename T>
-    double asGenericValue(T t) {
-        return static_cast<double>(t);
-    }
 
-    template<typename T>
-    uintptr_t asGenericValue(T* p) {
-        return reinterpret_cast<uintptr_t>(p);
-    }
+template<typename T> double asGenericValue(T t) {
+    return static_cast<double>(t);
+}
+
+template<typename T> uintptr_t asGenericValue(T* p) {
+    return reinterpret_cast<uintptr_t>(p);
+}
+
 }
 
 template<typename ConstantType>
@@ -1941,19 +1958,17 @@ void constant(const char* name, const ConstantType& v) {
         static_cast<double>(asGenericValue(BT::toWireType(v))));
 }
 
-
-
-
 // EMSCRIPTEN_BINDINGS creates a static struct to initialize the binding which
 // will get included in the program if the translation unit in which it is
 // defined gets linked into the program. Using a C++ constructor here ensures it
 // occurs after any other C++ constructors in this file, which is not true for
 // __attribute__((constructor)) (they run before C++ constructors in the same
 // file).
 #define EMSCRIPTEN_BINDINGS(name)                                              \
-  static struct EmBindInit_##name {                                            \
-    EmBindInit_##name();                                                       \
+  static void embind_init_##name();                                            \
+  static struct EmBindInit_##name : emscripten::internal::InitFunc {           \
+    EmBindInit_##name() : InitFunc(embind_init_##name) {}                      \
   } EmBindInit_##name##_instance;                                              \
-  EmBindInit_##name::EmBindInit_##name()
+  static void embind_init_##name()
 
 } // end namespace emscripten

system/lib/embind/bind.cpp

@@ -17,6 +17,7 @@
 #include <vector>
 
 using namespace emscripten;
+using namespace internal;
 
 extern "C" {
 const char* EMSCRIPTEN_KEEPALIVE __getTypeName(const std::type_info* ti) {
@@ -47,6 +48,20 @@ const char* EMSCRIPTEN_KEEPALIVE __getTypeName(const std::type_info* ti) {
     return strdup(str);
   }
 }
+
+static InitFunc* init_funcs = nullptr;
+
+EMSCRIPTEN_KEEPALIVE void _embind_initialize_bindings() {
+  for (auto* f = init_funcs; f; f = f->next) {
+    f->init_func();
+  }
+}
+
+void _embind_register_bindings(InitFunc* f) {
+  f->next = init_funcs;
+  init_funcs = f;
+}
+
 }
 
 namespace {
@@ -99,13 +114,7 @@ template <typename T> static void register_memory_view(const char* name) {
 }
 } // namespace
 
-extern "C" {
-
-// Normal initialization, executed through a global constructor. This
-// happens on the main thread; pthreads will call it manually, so make
-// sure we also export it (via EMSCRIPTEN_KEEPALIVE).
-EMSCRIPTEN_KEEPALIVE __attribute__((constructor))
-void __embind_register_native_and_builtin_types() {
+EMSCRIPTEN_BINDINGS(builtin) {
   using namespace emscripten::internal;
 
   _embind_register_void(TypeID<void>::get(), "void");
@@ -171,5 +180,3 @@ void __embind_register_native_and_builtin_types() {
   register_memory_view<long double>("emscripten::memory_view<long double>");
 #endif
 }
-
-} // extern "C"

tests/other/metadce/test_metadce_minimal_pthreads.jssize

@@ -1 +1 @@
-15892
+15885

tests/test_core.py

@@ -7363,8 +7363,13 @@ def test_embind(self):
       ''')
       self.do_runf('test_embind.cpp', 'abs(-10): 10\nabs(-11): 11', emcc_args=args)
 
-  def test_embind_2(self):
-    self.emcc_args += ['-lembind', '--post-js', 'post.js']
+  @parameterized({
+    '': ([],),
+    'pthreads': (['-pthread', '-sPROXY_TO_PTHREAD', '-sEXIT_RUNTIME'],),
+  })
+  @node_pthreads
+  def test_embind_2(self, args):
+    self.emcc_args += ['-lembind', '--post-js', 'post.js'] + args
     create_file('post.js', '''
       function printLerp() {
         out('lerp ' + Module.lerp(100, 200, 66) + '.');
@@ -7374,11 +7379,13 @@ def test_embind_2(self):
       #include <stdio.h>
       #include <emscripten.h>
       #include <emscripten/bind.h>
+      #include <emscripten/console.h>
       using namespace emscripten;
       int lerp(int a, int b, int t) {
         return (100 - t) * a + t * b;
       }
       EMSCRIPTEN_BINDINGS(my_module) {
+        _emscripten_err("test bindings");
         function("lerp", &lerp);
       }
       int main(int argc, char **argv) {