[wasm64] Add MAIN_THREAD_EM_ASM_PTR macro (#20261)

This compliments `MAIN_THREAD_EM_ASM_INT` in the same way that `EM_ASM_PTR`
was added to compliment `EM_ASM_INT`.

This is needed to fix the wasm64 SDL2 build. See
libsdl-org/SDL#8241.

Author: sbc100

src/library.js

@@ -2958,6 +2958,11 @@ addToLibrary({
     return runMainThreadEmAsm(code, sigPtr, argbuf, 1);
   },
 
+  emscripten_asm_const_ptr_sync_on_main_thread__deps: ['$runMainThreadEmAsm'],
+  emscripten_asm_const_ptr_sync_on_main_thread: (code, sigPtr, argbuf) => {
+    return runMainThreadEmAsm(code, sigPtr, argbuf, 1);
+  },
+
   emscripten_asm_const_double_sync_on_main_thread: 'emscripten_asm_const_int_sync_on_main_thread',
   emscripten_asm_const_async_on_main_thread__deps: ['$runMainThreadEmAsm'],
   emscripten_asm_const_async_on_main_thread: (code, sigPtr, argbuf) => runMainThreadEmAsm(code, sigPtr, argbuf, 0),

src/library_sigs.js

@@ -565,6 +565,7 @@ sigs = {
   emscripten_asm_const_int__sig: 'ippp',
   emscripten_asm_const_int_sync_on_main_thread__sig: 'ippp',
   emscripten_asm_const_ptr__sig: 'pppp',
+  emscripten_asm_const_ptr_sync_on_main_thread__sig: 'pppp',
   emscripten_async_call__sig: 'vppi',
   emscripten_async_load_script__sig: 'vppp',
   emscripten_async_run_script__sig: 'vpi',

system/include/emscripten/em_asm.h

@@ -11,8 +11,9 @@ extern "C" {
 #endif // __cplusplus
 
 // You can use these functions by passing format string to arg_sigs.
-// Note that `code` requires you to provide a const C string known at compile time,
-// otherwise the "unable to find data for ASM/EM_JS const" error will be thrown.
+// Note that `code` requires you to provide a const C string known at compile
+// time, otherwise the "unable to find data for ASM/EM_JS const" error will be
+// thrown.
 // https://github.com/WebAssembly/binaryen/blob/51c8f2469f8fd05197b7694c65041b1567f2c6b5/src/wasm/wasm-emscripten.cpp#L183
 
 // C++ needs the nothrow attribute so -O0 doesn't lower these calls as invokes.
@@ -27,6 +28,9 @@ __attribute__((nothrow))
 int emscripten_asm_const_int_sync_on_main_thread(
   const char* code, const char* arg_sigs, ...);
 __attribute__((nothrow))
+void* emscripten_asm_const_ptr_sync_on_main_thread(
+  const char* code, const char* arg_sigs, ...);
+__attribute__((nothrow))
 double emscripten_asm_const_double_sync_on_main_thread(
   const char* code, const char* arg_sigs, ...);
 
@@ -48,6 +52,7 @@ void emscripten_asm_const_async_on_main_thread(
 #define EM_ASM_DOUBLE(...) EM_ASM_ERROR
 #define MAIN_THREAD_EM_ASM(...) EM_ASM_ERROR
 #define MAIN_THREAD_EM_ASM_INT(...) EM_ASM_ERROR
+#define MAIN_THREAD_EM_ASM_PTR(...) EM_ASM_ERROR
 #define MAIN_THREAD_EM_ASM_DOUBLE(...) EM_ASM_ERROR
 #define MAIN_THREAD_ASYNC_EM_ASM(...) EM_ASM_ERROR
 #define EM_ASM_(...) EM_ASM_ERROR
@@ -201,52 +206,75 @@ const char __em_asm_sig_builder<__em_asm_type_tuple<Args...> >::buffer[] = { __e
     , __em_asm_sig_builder<__typeof__(__em_asm_make_type_tuple(__VA_ARGS__))>::buffer, ##__VA_ARGS__
 #endif // __cplusplus
 
-// Note: If the code block in the EM_ASM() family of functions below contains a comma,
-// then wrap the whole code block inside parentheses (). See test/core/test_em_asm_2.cpp
-// for example code snippets.
+// Note: If the code block in the EM_ASM() family of functions below contains a
+// comma, then wrap the whole code block inside parentheses (). See
+// test/core/test_em_asm_2.cpp for example code snippets.
 
 #define CODE_EXPR(code) (__extension__({           \
     __attribute__((section("em_asm"), aligned(1))) \
     static const char x[] = code;                  \
     x;                                             \
   }))
 
-// Runs the given JavaScript code on the calling thread (synchronously), and returns no value back.
+// Runs the given JavaScript code on the calling thread (synchronously), and
+// returns no value back.
 #define EM_ASM(code, ...) ((void)emscripten_asm_const_int(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__)))
 
-// Runs the given JavaScript code on the calling thread (synchronously), and returns an i32 back.
+// Runs the given JavaScript code on the calling thread (synchronously), and
+// returns an i32 back.
 #define EM_ASM_INT(code, ...) emscripten_asm_const_int(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__))
 
-// Runs the given JavaScript code on the calling thread (synchronously), and returns an pointer back.
-// On wasm32 this is the same as emscripten_asm_const_int but on wasm64 it returns an i64.
+// Runs the given JavaScript code on the calling thread (synchronously), and
+// returns an pointer back.
+// On wasm32 this is the same as emscripten_asm_const_int but on wasm64 it
+// returns an i64.
 #define EM_ASM_PTR(code, ...) emscripten_asm_const_ptr(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__))
 
-// Runs the given JavaScript code on the calling thread (synchronously), and returns a double back.
+// Runs the given JavaScript code on the calling thread (synchronously), and
+// returns a double back.
 #define EM_ASM_DOUBLE(code, ...) emscripten_asm_const_double(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__))
 
-// Runs the given JavaScript code synchronously on the main browser thread, and returns no value back.
-// Call this function for example to access DOM elements in a pthread when building with -pthread.
-// Avoid calling this function in performance sensitive code, because this will effectively sleep the
-// calling thread until the main browser thread is able to service the proxied function call. If you have
-// multiple MAIN_THREAD_EM_ASM() code blocks to call in succession, it will likely be much faster to
-// coalesce all the calls to a single MAIN_THREAD_EM_ASM() block. If you do not need synchronization nor
-// a return value back, consider using the function MAIN_THREAD_ASYNC_EM_ASM() instead, which will not block.
+// Runs the given JavaScript code synchronously on the main browser thread, and
+// returns no value back.
+// Call this function for example to access DOM elements in a pthread when
+// building with -pthread.
+// Avoid calling this function in performance sensitive code, because this will
+// effectively sleep the calling thread until the main browser thread is able to
+// service the proxied function call. If you have multiple MAIN_THREAD_EM_ASM()
+// code blocks to call in succession, it will likely be much faster to coalesce
+// all the calls to a single MAIN_THREAD_EM_ASM() block. If you do not need
+// synchronization nor a return value back, consider using the function
+// MAIN_THREAD_ASYNC_EM_ASM() instead, which will not block.
 // In single-threaded builds (including proxy-to-worker), MAIN_THREAD_EM_ASM*()
-// functions are direct aliases to the corresponding EM_ASM*() family of functions.
+// functions are direct aliases to the corresponding EM_ASM*() family of
+// functions.
 #define MAIN_THREAD_EM_ASM(code, ...) ((void)emscripten_asm_const_int_sync_on_main_thread(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__)))
 
-// Runs the given JavaScript code synchronously on the main browser thread, and returns an integer back.
+// Runs the given JavaScript code synchronously on the main browser thread, and
+// returns an integer back.
 // The same considerations apply as with MAIN_THREAD_EM_ASM().
 #define MAIN_THREAD_EM_ASM_INT(code, ...) emscripten_asm_const_int_sync_on_main_thread(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__))
 
-// Runs the given JavaScript code synchronously on the main browser thread, and returns a double back.
+// Runs the given JavaScript code synchronously on the main browser thread, and
+// returns an pointer back.
+// The same considerations apply as with MAIN_THREAD_EM_ASM().
+// On wasm32 this is the same as emscripten_asm_const_int but on wasm64 it
+// returns an i64.
+#define MAIN_THREAD_EM_ASM_PTR(code, ...) emscripten_asm_const_ptr_sync_on_main_thread(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__))
+
+// Runs the given JavaScript code synchronously on the main browser thread, and
+// returns a double back.
 // The same considerations apply as with MAIN_THREAD_EM_ASM().
 #define MAIN_THREAD_EM_ASM_DOUBLE(code, ...) emscripten_asm_const_double_sync_on_main_thread(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__))
 
-// Asynchronously dispatches the given JavaScript code to be run on the main browser thread.
-// If the calling thread is the main browser thread, then the specified JavaScript code is executed
-// synchronously. Otherwise an event will be queued on the main browser thread to execute the call
-// later (think postMessage()), and this call will immediately return without waiting. Be sure to guard any accesses to shared memory on the heap inside the JavaScript code with appropriate locking.
+// Asynchronously dispatches the given JavaScript code to be run on the main
+// browser thread.
+// If the calling thread is the main browser thread, then the specified
+// JavaScript code is executed synchronously. Otherwise an event will be queued
+// on the main browser thread to execute the call later (think postMessage()),
+// and this call will immediately return without waiting. Be sure to guard any
+// accesses to shared memory on the heap inside the JavaScript code with
+// appropriate locking.
 #define MAIN_THREAD_ASYNC_EM_ASM(code, ...) ((void)emscripten_asm_const_async_on_main_thread(CODE_EXPR(#code) _EM_ASM_PREP_ARGS(__VA_ARGS__)))
 
 // Old forms for compatibility, no need to use these.

test/core/test_em_asm_2.cpp

@@ -111,6 +111,15 @@ int main()
   // Note that expressions do not evaluate to return values, but the "return" keyword is needed. That is, the following line would return undefined and store i <- 0.
   // i = EM_ASM_INT(HEAP8.length); printf("returned statement %d\n", i);
 
+  void* p;
+
+  printf("\nEM_ASM_PTR: Return a pointer back.\n");
+  p = EM_ASM_PTR(out('1. got arg ' + $0); return 3;, 42); printf("1. returned ptr %p\n", p);
+  p = EM_ASM_PTR("out('2. got arg ' + $0); return 4;", 42); printf("2. returned ptr %p\n", p);
+  p = EM_ASM_PTR({"out('3. got arg ' + $0); return 5;"}, 42); printf("3. returned ptr %p\n", p);
+  p = EM_ASM_PTR({out('4. got arg ' + $0); return 6;}, 42); printf("4. returned ptr %p\n", p);
+  p = EM_ASM_PTR("{out('5. got arg ' + $0); return 7;}", 42); printf("5. returned ptr %p\n", p);
+
   double d;
 
   printf("\nEM_ASM_DOUBLE: Pass no parameters, return a double.\n");

test/core/test_em_asm_2.out

@@ -119,6 +119,18 @@ EM_ASM_INT: Return an integer in a single brief statement.
 4. returned statement 45
 5. returned statement 46
 
+EM_ASM_PTR: Return a pointer back.
+1. got arg 42
+1. returned ptr 0x3
+2. got arg 42
+2. returned ptr 0x4
+3. got arg 42
+3. returned ptr 0x5
+4. got arg 42
+4. returned ptr 0x6
+5. got arg 42
+5. returned ptr 0x7
+
 EM_ASM_DOUBLE: Pass no parameters, return a double.
 1. returning double
 1. got double 3.500000

test/test_core.py

@@ -2196,9 +2196,12 @@ def test_em_asm_2(self):
     self.emcc_args.append('-std=gnu89')
     self.do_core_test('test_em_asm_2.cpp', force_c=True)
 
-  # Tests various different ways to invoke the MAIN_THREAD_EM_ASM(), MAIN_THREAD_EM_ASM_INT() and MAIN_THREAD_EM_ASM_DOUBLE() macros.
-  # This test is identical to test_em_asm_2, just search-replaces EM_ASM to MAIN_THREAD_EM_ASM on the test file. That way if new
-  # test cases are added to test_em_asm_2.cpp for EM_ASM, they will also get tested in MAIN_THREAD_EM_ASM form.
+  # Tests various different ways to invoke the MAIN_THREAD_EM_ASM(),
+  # MAIN_THREAD_EM_ASM_INT(), MAIN_THREAD_EM_ASM_PTR, and
+  # MAIN_THREAD_EM_ASM_DOUBLE() macros.  This test is identical to
+  # test_em_asm_2, just search-replaces EM_ASM to MAIN_THREAD_EM_ASM on the test
+  # file. That way if new test cases are added to test_em_asm_2.cpp for EM_ASM,
+  # they will also get tested in MAIN_THREAD_EM_ASM form.
   def test_main_thread_em_asm(self):
     src = read_file(test_file('core/test_em_asm_2.cpp'))
     create_file('src.cpp', src.replace('EM_ASM', 'MAIN_THREAD_EM_ASM'))