Auto-generate signatures for pthread-related functions. NFC (#19112)

- Enable threading in tools/gen_sig_info.py
- Ensure all thread-related JS functions are declared in header files
- Prefix JS-only functions with `$` so that are not native accessible
- Run `tools/gen_sig_info.py --remove`

Author: sbc100

src/jsifier.js

@@ -168,7 +168,7 @@ function ${name}(${args}) {
           snippet = modifyFunction(snippet, (name, args, body) => `
 function ${name}(${args}) {
 if (ENVIRONMENT_IS_PTHREAD)
-  return _emscripten_proxy_to_main_thread_js(${proxiedFunctionTable.length}, ${+sync}${args ? ', ' : ''}${args});
+  return proxyToMainThread(${proxiedFunctionTable.length}, ${+sync}${args ? ', ' : ''}${args});
 ${body}
 }\n`);
         } else if (WASM_WORKERS && ASSERTIONS) {

src/library.js

@@ -3001,7 +3001,11 @@ mergeInto(LibraryManager.library, {
     return runEmAsmFunction(code, sigPtr, argbuf);
   },
 
-  $runMainThreadEmAsm__deps: ['$readEmAsmArgs'],
+  $runMainThreadEmAsm__deps: ['$readEmAsmArgs',
+#if PTHREADS
+    '$proxyToMainThread'
+#endif
+  ],
   $runMainThreadEmAsm: function(code, sigPtr, argbuf, sync) {
     var args = readEmAsmArgs(sigPtr, argbuf);
 #if PTHREADS
@@ -3017,7 +3021,7 @@ mergeInto(LibraryManager.library, {
       // code paths as similar as possible on both sides.)
       // -1 - code is the encoding of a proxied EM_ASM, as a negative number
       // (positive numbers are non-EM_ASM calls).
-      return _emscripten_proxy_to_main_thread_js.apply(null, [-1 - code, sync].concat(args));
+      return proxyToMainThread.apply(null, [-1 - code, sync].concat(args));
     }
 #endif
 #if ASSERTIONS

src/library_html5.js

@@ -2393,7 +2393,6 @@ var LibraryHTML5 = {
     return {{{ cDefs.EMSCRIPTEN_RESULT_SUCCESS }}};
   },
 
-  _emscripten_set_offscreencanvas_size__sig: 'iiii',
 #if OFFSCREENCANVAS_SUPPORT
   _emscripten_set_offscreencanvas_size: 'emscripten_set_canvas_element_size',
 
@@ -2479,8 +2478,8 @@ var LibraryHTML5 = {
   },
 
 #if PTHREADS
-  emscripten_get_canvas_element_size_calling_thread__deps: ['$JSEvents', '$findCanvasEventTarget'],
-  emscripten_get_canvas_element_size_calling_thread: function(target, width, height) {
+  $getCanvasSizeCallingThread__deps: ['$JSEvents', '$findCanvasEventTarget'],
+  $getCanvasSizeCallingThread: function(target, width, height) {
     var canvas = findCanvasEventTarget(target);
     if (!canvas) return {{{ cDefs.EMSCRIPTEN_RESULT_UNKNOWN_TARGET }}};
 
@@ -2510,18 +2509,19 @@ var LibraryHTML5 = {
     return {{{ cDefs.EMSCRIPTEN_RESULT_SUCCESS }}};
   },
 
-  emscripten_get_canvas_element_size_main_thread__proxy: 'sync',
-  emscripten_get_canvas_element_size_main_thread__sig: 'iiii',
-  emscripten_get_canvas_element_size_main_thread__deps: ['emscripten_get_canvas_element_size_calling_thread'],
-  emscripten_get_canvas_element_size_main_thread: function(target, width, height) { return _emscripten_get_canvas_element_size_calling_thread(target, width, height); },
+  $getCanvasSizeMainThread__proxy: 'sync',
+  $getCanvasSizeMainThread__deps: ['$getCanvasSizeCallingThread'],
+  $getCanvasSizeMainThread: function(target, width, height) {
+    return getCanvasSizeCallingThread(target, width, height);
+  },
 
-  emscripten_get_canvas_element_size__deps: ['$JSEvents', 'emscripten_get_canvas_element_size_calling_thread', 'emscripten_get_canvas_element_size_main_thread', '$findCanvasEventTarget'],
+  emscripten_get_canvas_element_size__deps: ['$JSEvents', '$getCanvasSizeCallingThread', '$getCanvasSizeMainThread', '$findCanvasEventTarget'],
   emscripten_get_canvas_element_size: function(target, width, height) {
     var canvas = findCanvasEventTarget(target);
     if (canvas) {
-      return _emscripten_get_canvas_element_size_calling_thread(target, width, height);
+      return getCanvasSizeCallingThread(target, width, height);
     }
-    return _emscripten_get_canvas_element_size_main_thread(target, width, height);
+    return getCanvasSizeMainThread(target, width, height);
   },
 #else
   emscripten_get_canvas_element_size__deps: ['$JSEvents', '$findCanvasEventTarget'],

src/library_html5_webgl.js

@@ -321,8 +321,8 @@ var LibraryHtml5WebGL = {
 #if PTHREADS
   // Special function that will be invoked on the thread calling emscripten_webgl_destroy_context(), before routing
   // the call over to the target thread.
-  emscripten_webgl_destroy_context_before_on_calling_thread__deps: ['emscripten_webgl_get_current_context', 'emscripten_webgl_make_context_current'],
-  emscripten_webgl_destroy_context_before_on_calling_thread: function(contextHandle) {
+  $emscripten_webgl_destroy_context_before_on_calling_thread__deps: ['emscripten_webgl_get_current_context', 'emscripten_webgl_make_context_current'],
+  $emscripten_webgl_destroy_context_before_on_calling_thread: function(contextHandle) {
     if (_emscripten_webgl_get_current_context() == contextHandle) _emscripten_webgl_make_context_current(0);
   },
 #endif
@@ -592,8 +592,8 @@ function handleWebGLProxying(funcs) {
       var contextCheck = proxyContextHandle ? 'GL.contexts[p0]' : 'GLctx';
       var funcBody = `${retStatement} ${contextCheck} ? _${i}_calling_thread(${funcArgsString}) : _${i}_main_thread(${funcArgsString});`;
       if (funcs[i + '_before_on_calling_thread']) {
-        funcs[i + '__deps'].push(i + '_before_on_calling_thread');
-        funcBody = `_${i}_before_on_calling_thread(${funcArgsString}); ` + funcBody;
+        funcs[i + '__deps'].push('$' + i + '_before_on_calling_thread');
+        funcBody = `${i}_before_on_calling_thread(${funcArgsString}); ` + funcBody;
       }
       funcArgs.push(funcBody);
       funcs[i] = new (Function.prototype.bind.apply(Function, [Function].concat(funcArgs)));

src/library_pthread.js

@@ -562,7 +562,6 @@ var LibraryPThread = {
     worker.pthread_ptr = 0;
   },
 
-  __emscripten_thread_cleanup__sig: 'vp',
   __emscripten_thread_cleanup: function(thread) {
     // Called when a thread needs to be cleaned up so it can be reused.
     // A thread is considered reusable when it either returns from its
@@ -735,7 +734,6 @@ var LibraryPThread = {
   // allocations from __pthread_create_js we could also remove this.
   __pthread_create_js__noleakcheck: true,
 #endif
-  __pthread_create_js__sig: 'ipppp',
   __pthread_create_js__deps: ['$spawnThread', 'pthread_self', '$pthreadCreateProxied',
 #if OFFSCREENCANVAS_SUPPORT
     'malloc',
@@ -947,9 +945,9 @@ var LibraryPThread = {
     _exit(returnCode);
   },
 
-  emscripten_proxy_to_main_thread_js__deps: ['$withStackSave', '_emscripten_run_in_main_runtime_thread_js'],
-  emscripten_proxy_to_main_thread_js__docs: '/** @type{function(number, (number|boolean), ...(number|boolean))} */',
-  emscripten_proxy_to_main_thread_js: function(index, sync) {
+  $proxyToMainThread__deps: ['$withStackSave', '_emscripten_run_in_main_runtime_thread_js'],
+  $proxyToMainThread__docs: '/** @type{function(number, (number|boolean), ...(number|boolean))} */',
+  $proxyToMainThread: function(index, sync) {
     // Additional arguments are passed after those two, which are the actual
     // function arguments.
     // The serialization buffer contains the number of call params, and then
@@ -960,7 +958,7 @@ var LibraryPThread = {
 #if ASSERTIONS
     var maxArgs = {{{ cDefs.EM_QUEUED_JS_CALL_MAX_ARGS - 1 }}};
     if (numCallArgs > maxArgs) {
-      throw 'emscripten_proxy_to_main_thread_js: Too many arguments ' + numCallArgs + ' to proxied function idx=' + index + ', maximum supported is ' + maxArgs;
+      throw 'proxyToMainThread: Too many arguments ' + numCallArgs + ' to proxied function idx=' + index + ', maximum supported is ' + maxArgs;
     }
 #endif
     // Allocate a buffer, which will be copied by the C code.
@@ -994,29 +992,28 @@ var LibraryPThread = {
     });
   },
 
-  emscripten_receive_on_main_thread_js_callArgs: '=[]',
+  $emscripten_receive_on_main_thread_js_callArgs: '=[]',
 
-  emscripten_receive_on_main_thread_js__sig: 'diip',
   emscripten_receive_on_main_thread_js__deps: [
-    'emscripten_proxy_to_main_thread_js',
-    'emscripten_receive_on_main_thread_js_callArgs'],
+    '$proxyToMainThread',
+    '$emscripten_receive_on_main_thread_js_callArgs'],
   emscripten_receive_on_main_thread_js: function(index, numCallArgs, args) {
 #if WASM_BIGINT
     numCallArgs /= 2;
 #endif
-    _emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs;
+    emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs;
     var b = args >> 3;
     for (var i = 0; i < numCallArgs; i++) {
 #if WASM_BIGINT
       if (HEAP64[b + 2*i]) {
         // It's a BigInt.
-        _emscripten_receive_on_main_thread_js_callArgs[i] = HEAP64[b + 2*i + 1];
+        emscripten_receive_on_main_thread_js_callArgs[i] = HEAP64[b + 2*i + 1];
       } else {
         // It's a Number.
-        _emscripten_receive_on_main_thread_js_callArgs[i] = HEAPF64[b + 2*i + 1];
+        emscripten_receive_on_main_thread_js_callArgs[i] = HEAPF64[b + 2*i + 1];
       }
 #else
-      _emscripten_receive_on_main_thread_js_callArgs[i] = HEAPF64[b + i];
+      emscripten_receive_on_main_thread_js_callArgs[i] = HEAPF64[b + i];
 #endif
     }
     // Proxied JS library funcs are encoded as positive values, and
@@ -1030,7 +1027,7 @@ var LibraryPThread = {
 #if ASSERTIONS
     assert(func.length == numCallArgs, 'Call args mismatch in emscripten_receive_on_main_thread_js');
 #endif
-    return func.apply(null, _emscripten_receive_on_main_thread_js_callArgs);
+    return func.apply(null, emscripten_receive_on_main_thread_js_callArgs);
   },
 
   // TODO(sbc): Do we really need this to be dynamically settable from JS like this?
@@ -1126,7 +1123,6 @@ var LibraryPThread = {
   },
 
 #if MAIN_MODULE
-  _emscripten_thread_exit_joinable__sig: 'vp',
   _emscripten_thread_exit_joinable: function(thread) {
     // Called when a thread exits and is joinable.  We mark these threads
     // as finished, which means that are in state where are no longer actually
@@ -1152,7 +1148,6 @@ var LibraryPThread = {
   // TODO(sbc): Should we make a new form of __proxy attribute for JS library
   // function that run asynchronously like but blocks the caller until they are
   // done.  Perhaps "sync_with_ctx"?
-  _emscripten_dlsync_threads_async__sig: 'vppp',
   _emscripten_dlsync_threads_async__deps: ['_emscripten_proxy_dlsync_async', 'emscripten_promise_create', '$getPromise'],
   _emscripten_dlsync_threads_async: function(caller, callback, ctx) {
 #if PTHREADS_DEBUG
@@ -1234,7 +1229,6 @@ var LibraryPThread = {
   },
 
   _emscripten_thread_mailbox_await__deps: ['$checkMailbox'],
-  _emscripten_thread_mailbox_await__sig: 'vp',
   _emscripten_thread_mailbox_await: function(pthread_ptr) {
     if (typeof Atomics.waitAsync === 'function') {
       // TODO: How to make this work with wasm64?
@@ -1249,7 +1243,6 @@ var LibraryPThread = {
   },
 
   _emscripten_notify_mailbox_postmessage__deps: ['$checkMailbox'],
-  _emscripten_notify_mailbox_postmessage__sig: 'vppp',
   _emscripten_notify_mailbox_postmessage: function(targetThreadId,
                                                    currThreadId,
                                                    mainThreadId) {

src/library_sigs.js

@@ -212,7 +212,11 @@ sigs = {
   __assert_fail__sig: 'vppip',
   __call_sighandler__sig: 'vpi',
   __dlsym__sig: 'pppp',
+  __emscripten_init_main_thread_js__sig: 'vp',
+  __emscripten_thread_cleanup__sig: 'vp',
   __handle_stack_overflow__sig: 'vp',
+  __pthread_create_js__sig: 'ipppp',
+  __pthread_kill_js__sig: 'ipi',
   __syscall__newselect__sig: 'iipppp',
   __syscall_accept4__sig: 'iippiii',
   __syscall_bind__sig: 'iippiii',
@@ -269,17 +273,24 @@ sigs = {
   _dlsym_catchup_js__sig: 'ppi',
   _dlsym_js__sig: 'pppp',
   _emscripten_dbg__sig: 'vp',
+  _emscripten_default_pthread_stack_size__sig: 'i',
   _emscripten_dlopen_js__sig: 'vpppp',
+  _emscripten_dlsync_threads__sig: 'v',
+  _emscripten_dlsync_threads_async__sig: 'vppp',
   _emscripten_err__sig: 'vp',
   _emscripten_fetch_free__sig: 'vi',
   _emscripten_fetch_get_response_headers__sig: 'pipp',
   _emscripten_fetch_get_response_headers_length__sig: 'pi',
   _emscripten_fs_load_embedded_files__sig: 'vp',
   _emscripten_get_now_is_monotonic__sig: 'i',
   _emscripten_get_progname__sig: 'vpi',
+  _emscripten_notify_mailbox_postmessage__sig: 'vppp',
   _emscripten_out__sig: 'vp',
   _emscripten_push_main_loop_blocker__sig: 'vppp',
   _emscripten_push_uncounted_main_loop_blocker__sig: 'vppp',
+  _emscripten_set_offscreencanvas_size__sig: 'ipii',
+  _emscripten_thread_exit_joinable__sig: 'vp',
+  _emscripten_thread_mailbox_await__sig: 'vp',
   _emscripten_throw_longjmp__sig: 'v',
   _gmtime_js__sig: 'vpp',
   _localtime_js__sig: 'vpp',
@@ -419,6 +430,7 @@ sigs = {
   emscripten_call_worker__sig: 'vippipp',
   emscripten_cancel_animation_frame__sig: 'vi',
   emscripten_cancel_main_loop__sig: 'v',
+  emscripten_check_blocking_allowed__sig: 'v',
   emscripten_clear_immediate__sig: 'vi',
   emscripten_clear_interval__sig: 'vi',
   emscripten_clear_timeout__sig: 'vi',
@@ -470,6 +482,7 @@ sigs = {
   emscripten_get_window_title__sig: 'p',
   emscripten_get_worker_queue_size__sig: 'ii',
   emscripten_has_asyncify__sig: 'i',
+  emscripten_has_threading_support__sig: 'i',
   emscripten_hide_mouse__sig: 'v',
   emscripten_html5_remove_all_event_listeners__sig: 'v',
   emscripten_idb_async_delete__sig: 'vppppp',
@@ -512,6 +525,7 @@ sigs = {
   emscripten_math_tanh__sig: 'dd',
   emscripten_memcpy_big__sig: 'vppp',
   emscripten_notify_memory_growth__sig: 'vp',
+  emscripten_num_logical_cores__sig: 'i',
   emscripten_pause_main_loop__sig: 'v',
   emscripten_pc_get_column__sig: 'ip',
   emscripten_pc_get_file__sig: 'pp',
@@ -525,6 +539,7 @@ sigs = {
   emscripten_promise_resolve__sig: 'vpip',
   emscripten_promise_then__sig: 'ppppp',
   emscripten_random__sig: 'f',
+  emscripten_receive_on_main_thread_js__sig: 'diip',
   emscripten_request_animation_frame__sig: 'ipp',
   emscripten_request_animation_frame_loop__sig: 'vpp',
   emscripten_request_fullscreen__sig: 'ipi',

system/lib/libc/dynlink.c

@@ -179,21 +179,6 @@ static struct dso* load_library_start(const char* name, int flags) {
 // the module.
 #define ABORT_ON_SYNC_FAILURE 1
 
-// These functions are defined in JS.
-
-// Synchronous version of "dlsync_threads".  Called only on the main thread.
-// Runs _emscripten_dlsync_self on each of the threads that are running at
-// the time of the call.
-void _emscripten_dlsync_threads();
-
-// Asynchronous version of "dlsync_threads".  Called only on the main thread.
-// Runs _emscripten_dlsync_self on each of the threads that are running at
-// the time of the call.  Once this is done the callback is called with the
-// given em_proxying_ctx.
-void _emscripten_dlsync_threads_async(pthread_t calling_thread,
-                                      void (*callback)(em_proxying_ctx*),
-                                      em_proxying_ctx* ctx);
-
 static void dlsync_next(struct dlevent* dlevent, em_promise_t promise);
 
 static void sync_one_onsuccess(struct dso* dso, void* user_data) {

system/lib/libc/emscripten_internal.h

@@ -12,6 +12,8 @@
  */
 
 #include <emscripten/em_macros.h>
+#include <emscripten/proxying.h>
+#include <emscripten/html5.h>
 
 #include <signal.h>    // for `sighandler_t`
 #include <stdbool.h>   // for `bool`
@@ -93,6 +95,19 @@ void* _dlsym_catchup_js(struct dso* handle, int sym_index);
 
 int _setitimer_js(int which, double timeout);
 
+// Synchronous version of "dlsync_threads".  Called only on the main thread.
+// Runs _emscripten_dlsync_self on each of the threads that are running at
+// the time of the call.
+void _emscripten_dlsync_threads();
+
+// Asynchronous version of "dlsync_threads".  Called only on the main thread.
+// Runs _emscripten_dlsync_self on each of the threads that are running at
+// the time of the call.  Once this is done the callback is called with the
+// given em_proxying_ctx.
+void _emscripten_dlsync_threads_async(pthread_t calling_thread,
+                                      void (*callback)(em_proxying_ctx*),
+                                      em_proxying_ctx* ctx);
+
 #ifdef _GNU_SOURCE
 void __call_sighandler(sighandler_t handler, int sig);
 #endif
@@ -114,6 +129,8 @@ size_t _emscripten_fetch_get_response_headers_length(int32_t fetchID);
 size_t _emscripten_fetch_get_response_headers(int32_t fetchID, char *dst, size_t dstSizeBytes);
 void _emscripten_fetch_free(unsigned int);
 
+EMSCRIPTEN_RESULT _emscripten_set_offscreencanvas_size(const char *target, int width, int height);
+
 #ifdef __cplusplus
 }
 #endif

system/lib/pthread/emscripten_thread_init.c

@@ -8,8 +8,6 @@
 #include "emscripten/threading.h"
 #include "threading_internal.h"
 
-void __set_thread_state(pthread_t ptr, int is_main, int is_runtime, int can_block);
-
 void _emscripten_thread_init(pthread_t ptr,
                              int is_main,
                              int is_runtime,

system/lib/pthread/library_pthread.c

@@ -36,6 +36,7 @@
 #include <emscripten/threading.h>
 
 #include "threading_internal.h"
+#include "emscripten_internal.h"
 
 int emscripten_pthread_attr_gettransferredcanvases(const pthread_attr_t* a, const char** str) {
   *str = a->_a_transferredcanvases;
@@ -176,9 +177,6 @@ void emscripten_async_waitable_close(em_queued_call* call) {
   em_queued_call_free(call);
 }
 
-extern EMSCRIPTEN_RESULT _emscripten_set_offscreencanvas_size(const char *target, int width, int height);
-extern double emscripten_receive_on_main_thread_js(int functionIndex, int numCallArgs, double* args);
-
 static void _do_call(void* arg) {
   em_queued_call* q = (em_queued_call*)arg;
   // C function pointer