remove unused arg from async wait semaphore

don't need both user data and a gchandle

src/mono/System.Private.CoreLib/src/System/Threading/LowLevelJSSemaphore.Browser.Mono.cs

@@ -48,9 +48,8 @@ private void CreateAsyncJS(int maximumSignalCount)
     [MethodImpl(MethodImplOptions.InternalCall)]
     private static extern unsafe void PrepareAsyncWaitInternal(IntPtr semaphore,
                                                                int timeoutMs,
-                                                               /*delegate* unmanaged<IntPtr, GCHandle, IntPtr, void> successCallback*/ void* successCallback,
-                                                               /*delegate* unmanaged<IntPtr, GCHandle, IntPtr, void> timeoutCallback*/ void* timeoutCallback,
-                                                               GCHandle handle,
+                                                               /*delegate* unmanaged<IntPtr, IntPtr, void> successCallback*/ void* successCallback,
+                                                               /*delegate* unmanaged<IntPtr, IntPtr, void> timeoutCallback*/ void* timeoutCallback,
                                                                IntPtr userData);
 
     private sealed record WaitEntry (LowLevelLifoSemaphore Semaphore, Action<LowLevelLifoSemaphore, object?> OnSuccess, Action<LowLevelLifoSemaphore, object?> OnTimeout, object? State);
@@ -201,23 +200,25 @@ internal void PrepareAsyncWaitCore(int timeout_ms, Action<LowLevelLifoSemaphore,
         WaitEntry entry = new (this, onSuccess, onTimeout, state);
         GCHandle gchandle = GCHandle.Alloc (entry);
         unsafe {
-            delegate* unmanaged<IntPtr, GCHandle, IntPtr, void> successCallback = &SuccessCallback;
-            delegate* unmanaged<IntPtr, GCHandle, IntPtr, void> timeoutCallback = &TimeoutCallback;
-            PrepareAsyncWaitInternal (lifo_semaphore, timeout_ms, successCallback, timeoutCallback, gchandle, IntPtr.Zero);
+            delegate* unmanaged<IntPtr, IntPtr, void> successCallback = &SuccessCallback;
+            delegate* unmanaged<IntPtr, IntPtr, void> timeoutCallback = &TimeoutCallback;
+            PrepareAsyncWaitInternal (lifo_semaphore, timeout_ms, successCallback, timeoutCallback, GCHandle.ToIntPtr(gchandle));
         }
     }
 
     [UnmanagedCallersOnly]
-    private static void SuccessCallback(IntPtr lifo_semaphore, GCHandle gchandle, IntPtr user_data)
+    private static void SuccessCallback(IntPtr lifoSemaphore, IntPtr userData)
     {
+        GCHandle gchandle = GCHandle.FromIntPtr(userData);
         WaitEntry entry = (WaitEntry)gchandle.Target!;
         gchandle.Free();
         entry.OnSuccess(entry.Semaphore, entry.State);
     }
 
     [UnmanagedCallersOnly]
-    private static void TimeoutCallback(IntPtr lifo_semaphore, GCHandle gchandle, IntPtr user_data)
+    private static void TimeoutCallback(IntPtr lifoSemaphore, IntPtr userData)
     {
+        GCHandle gchandle = GCHandle.FromIntPtr(userData);
         WaitEntry entry = (WaitEntry)gchandle.Target!;
         gchandle.Free();
         entry.OnTimeout(entry.Semaphore, entry.State);

src/mono/mono/metadata/icall-decl.h

@@ -186,7 +186,7 @@ ICALL_EXPORT void     ves_icall_System_Threading_LowLevelLifoSemaphore_ReleaseIn
 
 /* include these declarations if we're in the threaded wasm runtime, or if we're building a wasm-targeting cross compiler and we need to support --print-icall-table */
 #if (defined(HOST_BROWSER) && !defined(DISABLE_THREADS)) || (defined(TARGET_WASM) && defined(ENABLE_ICALL_SYMBOL_MAP))
-ICALL_EXPORT void   ves_icall_System_Threading_LowLevelLifoSemaphore_PrepareAsyncWaitInternal (gpointer sem_ptr, gint32 timeout_ms, gpointer success_cb, gpointer timeout_cb, gpointer gchandle, gpointer user_data);
+ICALL_EXPORT void   ves_icall_System_Threading_LowLevelLifoSemaphore_PrepareAsyncWaitInternal (gpointer sem_ptr, gint32 timeout_ms, gpointer success_cb, gpointer timeout_cb, intptr_t user_data);
 
 ICALL_EXPORT void ves_icall_System_Threading_WebWorkerEventLoop_KeepalivePushInternal (void);
 ICALL_EXPORT void ves_icall_System_Threading_WebWorkerEventLoop_KeepalivePopInternal (void);

src/mono/mono/metadata/threads.c

@@ -5060,11 +5060,11 @@ ves_icall_System_Threading_LowLevelLifoSemaphore_ReleaseInternal (gpointer sem_p
 
 #if defined(HOST_BROWSER) && !defined(DISABLE_THREADS)
 void
-ves_icall_System_Threading_LowLevelLifoSemaphore_PrepareAsyncWaitInternal (gpointer sem_ptr, gint32 timeout_ms, gpointer success_cb, gpointer timedout_cb, gpointer gchandle, gpointer user_data)
+ves_icall_System_Threading_LowLevelLifoSemaphore_PrepareAsyncWaitInternal (gpointer sem_ptr, gint32 timeout_ms, gpointer success_cb, gpointer timedout_cb, intptr_t user_data)
 {
 	LifoJSSemaphore *sem = (LifoJSSemaphore *)sem_ptr;
 	g_assert (sem->base.kind == LIFO_SEMAPHORE_ASYNC_JS);
-	mono_lifo_js_semaphore_prepare_wait (sem, timeout_ms, (LifoJSSemaphoreCallbackFn)success_cb, (LifoJSSemaphoreCallbackFn)timedout_cb, (uint32_t)(MonoGCHandle)gchandle, user_data);
+	mono_lifo_js_semaphore_prepare_wait (sem, timeout_ms, (LifoJSSemaphoreCallbackFn)success_cb, (LifoJSSemaphoreCallbackFn)timedout_cb, user_data);
 }
 
 void
@@ -5106,7 +5106,7 @@ ves_icall_System_Threading_WebWorkerEventLoop_KeepalivePopInternal (void)
  * need to be defined */
 #if defined(TARGET_WASM) && defined(ENABLE_ICALL_SYMBOL_MAP)
 void
-ves_icall_System_Threading_LowLevelLifoSemaphore_PrepareAsyncWaitInternal (gpointer sem_ptr, gint32 timeout_ms, gpointer success_cb, gpointer timedout_cb, gpointer gchandle, gpointer user_data)
+ves_icall_System_Threading_LowLevelLifoSemaphore_PrepareAsyncWaitInternal (gpointer sem_ptr, gint32 timeout_ms, gpointer success_cb, gpointer timedout_cb, intptr_t user_data)
 {
 	g_assert_not_reached();
 }

src/mono/mono/utils/lifo-semaphore.c

@@ -187,14 +187,13 @@ mono_lifo_js_semaphore_prepare_wait (LifoJSSemaphore *sem,
 				     int32_t timeout_ms,
 				     LifoJSSemaphoreCallbackFn success_cb,
 				     LifoJSSemaphoreCallbackFn timeout_cb,
-				     uint32_t gchandle,
-				     void *user_data)
+				     intptr_t user_data)
 {
 	mono_coop_mutex_lock (&sem->base.mutex);
 	if (sem->pending_signals > 0) {
 		sem->pending_signals--;
 		mono_coop_mutex_unlock (&sem->base.mutex);
-		success_cb (sem, gchandle, user_data); // FIXME: queue microtask
+		success_cb (sem, user_data); // FIXME: queue microtask
 		return;
 	}
 
@@ -210,7 +209,6 @@ mono_lifo_js_semaphore_prepare_wait (LifoJSSemaphore *sem,
 	wait_entry->success_cb = success_cb;
 	wait_entry->timeout_cb = timeout_cb;
 	wait_entry->sem = sem;
-	wait_entry->gchandle = gchandle;
 	wait_entry->user_data = user_data;
 	wait_entry->thread = pthread_self();
 	wait_entry->state = LIFO_JS_WAITING;
@@ -257,8 +255,7 @@ lifo_js_wait_entry_on_timeout (void *wait_entry_as_user_data)
 	LifoJSSemaphore *sem = wait_entry->sem;
 	gboolean call_timeout_cb = FALSE;
 	LifoJSSemaphoreCallbackFn timeout_cb = NULL;
-	uint32_t gchandle = 0;
-	void *user_data = NULL;
+	intptr_t user_data = 0;
 	mono_coop_mutex_lock (&sem->base.mutex);
 	switch (wait_entry->state) {
 	case LIFO_JS_WAITING:
@@ -267,7 +264,6 @@ lifo_js_wait_entry_on_timeout (void *wait_entry_as_user_data)
 		/* unlink and free the wait entry, run the user timeout_cb. */
 		lifo_js_wait_entry_unlink (&sem->head, wait_entry);
 		timeout_cb = wait_entry->timeout_cb;
-		gchandle = wait_entry->gchandle;
 		user_data = wait_entry->user_data;
 		g_free (wait_entry);
 		call_timeout_cb = TRUE;
@@ -285,7 +281,7 @@ lifo_js_wait_entry_on_timeout (void *wait_entry_as_user_data)
 	}
 	mono_coop_mutex_unlock (&sem->base.mutex);
 	if (call_timeout_cb) {
-		timeout_cb (sem, gchandle, user_data);
+		timeout_cb (sem, user_data);
 	}
 }
 
@@ -298,8 +294,7 @@ lifo_js_wait_entry_on_success (void *wait_entry_as_user_data)
 	LifoJSSemaphore *sem = wait_entry->sem;
 	gboolean call_success_cb = FALSE;
 	LifoJSSemaphoreCallbackFn success_cb = NULL;
-	uint32_t gchandle = 0;
-	void *user_data = NULL;
+	intptr_t user_data = 0;
 	mono_coop_mutex_lock (&sem->base.mutex);
 	switch (wait_entry->state) {
 	case LIFO_JS_SIGNALED:
@@ -314,7 +309,6 @@ lifo_js_wait_entry_on_success (void *wait_entry_as_user_data)
 		g_assert (wait_entry->refcount == 1);
 		lifo_js_wait_entry_unlink (&sem->head, wait_entry);
 		success_cb = wait_entry->success_cb;
-		gchandle = wait_entry->gchandle;
 		user_data = wait_entry->user_data;
 		g_free (wait_entry);
 		call_success_cb = TRUE;
@@ -325,7 +319,7 @@ lifo_js_wait_entry_on_success (void *wait_entry_as_user_data)
 	}
 	mono_coop_mutex_unlock (&sem->base.mutex);
 	g_assert (call_success_cb);
-	success_cb (sem, gchandle, user_data);
+	success_cb (sem, user_data);
 }
 
 #endif /* HOST_BROWSER && !DISABLE_THREADS */

src/mono/mono/utils/lifo-semaphore.h

@@ -61,17 +61,16 @@ typedef struct _LifoJSSemaphore LifoJSSemaphore;
  */
 typedef struct _LifoJSSemaphoreWaitEntry LifoJSSemaphoreWaitEntry;
 
-typedef void (*LifoJSSemaphoreCallbackFn)(LifoJSSemaphore *semaphore, uint32_t gch, void *user_data);
+typedef void (*LifoJSSemaphoreCallbackFn)(LifoJSSemaphore *semaphore, intptr_t user_data);
 
 struct _LifoJSSemaphoreWaitEntry {
 	LifoJSSemaphoreWaitEntry *previous;
 	LifoJSSemaphoreWaitEntry *next;
 	LifoJSSemaphoreCallbackFn success_cb;
 	LifoJSSemaphoreCallbackFn timeout_cb;
 	LifoJSSemaphore *sem;
-	void *user_data;
+	intptr_t user_data;
 	pthread_t thread;
-	uint32_t gchandle; // what do we want in here?
 	int32_t js_timeout_id; // only valid to access from the waiting thread
 	/* state and refcount are protected by the semaphore mutex */
 	uint16_t state; /* 0 waiting, 1 signaled, 2 signaled - timeout ignored */
@@ -131,8 +130,7 @@ void
 mono_lifo_js_semaphore_prepare_wait (LifoJSSemaphore *semaphore, int32_t timeout_ms,
 				     LifoJSSemaphoreCallbackFn success_cb,
 				     LifoJSSemaphoreCallbackFn timeout_cb,
-				     uint32_t gchandle,
-				     void *user_data);
+				     intptr_t user_data);
 
 void
 mono_lifo_js_semaphore_release (LifoJSSemaphore *semaphore, uint32_t count);