[WASM_WORKERS] Use typedefs for async callback functions. NFC

Author: sbc100

system/include/emscripten/atomic.h

@@ -229,6 +229,7 @@ _EM_INLINE int64_t emscripten_atomic_notify(void *addr __attribute__((nonnull)),
 
 // Represents a pending 'Atomics.waitAsync' wait operation.
 #define ATOMICS_WAIT_TOKEN_T int32_t
+typedef void (*emscripten_async_wait_callback_t)(int32_t *address, uint32_t value, ATOMICS_WAIT_RESULT_T waitResult, void *userData);
 
 #define EMSCRIPTEN_IS_VALID_WAIT_TOKEN(token) ((token) <= 0)
 
@@ -254,7 +255,7 @@ _EM_INLINE int64_t emscripten_atomic_notify(void *addr __attribute__((nonnull)),
 //    this function returned a valid wait token.
 ATOMICS_WAIT_TOKEN_T emscripten_atomic_wait_async(void *addr __attribute__((nonnull)),
                                                   uint32_t value,
-                                                  void (*asyncWaitFinished)(int32_t *addr, uint32_t value, ATOMICS_WAIT_RESULT_T waitResult, void *userData) __attribute__((nonnull)),
+                                                  emscripten_async_wait_callback_t asyncWaitFinished __attribute__((nonnull)),
                                                   void *userData,
                                                   double maxWaitMilliseconds);
 

system/include/emscripten/wasm_worker.h

@@ -169,6 +169,11 @@ bool emscripten_lock_busyspin_wait_acquire(emscripten_lock_t *lock __attribute__
 //       acquire without contention from other threads.
 void emscripten_lock_busyspin_waitinf_acquire(emscripten_lock_t *lock __attribute__((nonnull)));
 
+// Callback used in emscripten_lock_async_acquire.
+// This currently differs from emscripten_async_wait_callback_t due to the
+// address being volatile.
+typedef void (*emscripten_async_lock_acquire_callback_t)(volatile void *address, uint32_t value, ATOMICS_WAIT_RESULT_T waitResult, void *userData);
+
 // Registers an *asynchronous* lock acquire operation. The calling thread will
 // asynchronously try to obtain the given lock after the calling thread yields
 // back to the event loop. If the attempt is successful within
@@ -184,7 +189,7 @@ void emscripten_lock_busyspin_waitinf_acquire(emscripten_lock_t *lock __attribut
 //       use this API in Worker, you cannot utilise an infinite loop programming
 //       model.
 void emscripten_lock_async_acquire(emscripten_lock_t *lock __attribute__((nonnull)),
-                                   void (*asyncWaitFinished)(volatile void *address, uint32_t value, ATOMICS_WAIT_RESULT_T waitResult, void *userData) __attribute__((nonnull)),
+                                   emscripten_async_lock_acquire_callback_t asyncWaitFinished __attribute__((nonnull)),
                                    void *userData,
                                    double maxWaitMilliseconds);
 
@@ -218,7 +223,7 @@ int emscripten_semaphore_try_acquire(emscripten_semaphore_t *sem __attribute__((
 // acquired. If you use this API in Worker, you cannot run an infinite loop.
 void emscripten_semaphore_async_acquire(emscripten_semaphore_t *sem __attribute__((nonnull)),
                                         int num,
-                                        void (*asyncWaitFinished)(volatile void *address, uint32_t idx, ATOMICS_WAIT_RESULT_T result, void *userData) __attribute__((nonnull)),
+                                        emscripten_async_wait_callback_t asyncWaitFinished __attribute__((nonnull)),
                                         void *userData,
                                         double maxWaitMilliseconds);
 
@@ -267,10 +272,11 @@ void emscripten_condvar_waitinf(emscripten_condvar_t *condvar __attribute__((non
 // the calling thread will not try to reacquire the lock.
 bool emscripten_condvar_wait(emscripten_condvar_t *condvar __attribute__((nonnull)), emscripten_lock_t *lock __attribute__((nonnull)), int64_t maxWaitNanoseconds);
 
+
 // Asynchronously wait for the given condition variable to signal.
 ATOMICS_WAIT_TOKEN_T emscripten_condvar_wait_async(emscripten_condvar_t *condvar __attribute__((nonnull)),
                                                   emscripten_lock_t *lock __attribute__((nonnull)),
-                                                  void (*asyncWaitFinished)(int32_t *address, uint32_t value, ATOMICS_WAIT_RESULT_T waitResult, void *userData) __attribute__((nonnull)),
+                                                  emscripten_async_wait_callback_t asyncWaitFinished __attribute__((nonnull)),
                                                   void *userData,
                                                   double maxWaitMilliseconds);
 

system/lib/wasm_worker/library_wasm_worker.c

@@ -231,10 +231,10 @@ bool emscripten_condvar_wait(emscripten_condvar_t *condvar, emscripten_lock_t *l
 }
 
 ATOMICS_WAIT_TOKEN_T emscripten_condvar_wait_async(emscripten_condvar_t *condvar,
-                                                  emscripten_lock_t *lock,
-                                                  void (*asyncWaitFinished)(int32_t *address, uint32_t value, ATOMICS_WAIT_RESULT_T waitResult, void *userData),
-                                                  void *userData,
-                                                  double maxWaitMilliseconds)
+                                                   emscripten_lock_t *lock,
+                                                   emscripten_async_wait_callback_t asyncWaitFinished,
+                                                   void *userData,
+                                                   double maxWaitMilliseconds)
 {
 	int val = emscripten_atomic_load_u32((void*)condvar);
 	emscripten_lock_release(lock);