[wasm] more cases when looking up unmanaged delegates

src/mono/browser/runtime/pinvoke.c

@@ -23,39 +23,71 @@ mono_wasm_pinvoke_vararg_stub (void)
 	/* This is just a stub used to mark vararg pinvokes */
 }
 
+int
+table_compare_name (const void *t1, const void *t2)
+{
+	return strcmp (((PinvokeTable*)t1)->name, ((PinvokeTable*)t2)->name);
+}
+
 void*
 wasm_dl_lookup_pinvoke_table (const char *name)
 {
-	for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (void*); ++i) {
-		if (!strcmp (name, pinvoke_names [i]))
-			return pinvoke_tables [i];
-	}
-	return NULL;
+	PinvokeImport needle = { name, NULL };
+	return bsearch (&needle, pinvoke_tables, (sizeof (pinvoke_tables) / sizeof (PinvokeTable)), sizeof (PinvokeTable), table_compare_name);
 }
 
 int
 wasm_dl_is_pinvoke_table (void *handle)
 {
-	for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (void*); ++i) {
-		if (pinvoke_tables [i] == handle) {
+	for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (PinvokeTable); ++i) {
+		if (&pinvoke_tables[i] == handle) {
 			return 1;
 		}
 	}
 	return 0;
 }
 
+static int
+export_compare_key (const void *k1, const void *k2)
+{
+	return strcmp (((UnmanagedExport*)k1)->key, ((UnmanagedExport*)k2)->key);
+}
+
+static int
+export_compare_key_and_token (const void *k1, const void *k2)
+{
+	UnmanagedExport *e1 = (UnmanagedExport*)k1;
+	UnmanagedExport *e2 = (UnmanagedExport*)k2;
+
+	// first compare by key
+	int compare = strcmp (e1->key, e2->key);
+	if (compare)
+		return compare;
+
+	// then by token
+	return (int)(e1->token - e2->token);
+}
+
 void*
-wasm_dl_get_native_to_interp (const char *key, void *extra_arg)
+wasm_dl_get_native_to_interp (uint32_t token, const char *key, void *extra_arg)
 {
 #ifdef GEN_PINVOKE
-	for (int i = 0; i < sizeof (wasm_native_to_interp_map) / sizeof (void*); ++i) {
-		if (!strcmp (wasm_native_to_interp_map [i], key)) {
-			void *addr = wasm_native_to_interp_funcs [i];
-			wasm_native_to_interp_ftndescs [i] = *(InterpFtnDesc*)extra_arg;
-			return addr;
-		}
+	UnmanagedExport needle = { key, token, NULL };
+	int count = (sizeof (wasm_native_to_interp_table) / sizeof (UnmanagedExport));
+
+	// comparison must match the one used in the PInvokeTableGenerator to ensure the same order
+	UnmanagedExport *result = bsearch (&needle, wasm_native_to_interp_table, count, sizeof (UnmanagedExport), export_compare_key_and_token);
+	if (!result) {
+		// assembly may have been trimmed / modified, try to find by key only
+		result = bsearch (&needle, wasm_native_to_interp_table, count, sizeof (UnmanagedExport), export_compare_key);
 	}
-	return NULL;
+
+	if (!result)
+		return NULL;
+
+	void *addr = result->func;
+	wasm_native_to_interp_ftndescs [result - wasm_native_to_interp_table] = *(InterpFtnDesc*)extra_arg;
+	return addr;
 #else
 	return NULL;
 #endif

src/mono/browser/runtime/pinvoke.h

@@ -8,6 +8,18 @@ typedef struct {
 	void *func;
 } PinvokeImport;
 
+typedef struct {
+	const char *name;
+	PinvokeImport *imports;
+	int count;
+} PinvokeTable;
+
+typedef struct {
+	const char *key;
+	uint32_t token;
+	void *func;
+} UnmanagedExport;
+
 typedef struct {
 	void *func;
 	void *arg;
@@ -20,7 +32,7 @@ int
 wasm_dl_is_pinvoke_table (void *handle);
 
 void*
-wasm_dl_get_native_to_interp (const char *key, void *extra_arg);
+wasm_dl_get_native_to_interp (uint32_t token, const char *key, void *extra_arg);
 
 void
 mono_wasm_pinvoke_vararg_stub (void);
@@ -45,6 +57,6 @@ double
 mono_wasm_interp_method_args_get_darg (MonoInterpMethodArguments *margs, int i);
 
 void*
-mono_wasm_interp_method_args_get_retval  (MonoInterpMethodArguments *margs);
+mono_wasm_interp_method_args_get_retval (MonoInterpMethodArguments *margs);
 
 #endif

src/mono/browser/runtime/runtime.c

@@ -199,29 +199,43 @@ init_icall_table (void)
 static void*
 get_native_to_interp (MonoMethod *method, void *extra_arg)
 {
-	void *addr;
-
+	void *addr = NULL;
 	MONO_ENTER_GC_UNSAFE;
 	MonoClass *klass = mono_method_get_class (method);
 	MonoImage *image = mono_class_get_image (klass);
 	MonoAssembly *assembly = mono_image_get_assembly (image);
 	MonoAssemblyName *aname = mono_assembly_get_name (assembly);
 	const char *name = mono_assembly_name_get_name (aname);
+	const char *namespace = mono_class_get_namespace (klass);
 	const char *class_name = mono_class_get_name (klass);
 	const char *method_name = mono_method_get_name (method);
-	char key [128];
+	MonoMethodSignature *sig = mono_method_signature (method);
+	uint32_t param_count = mono_signature_get_param_count (sig);
+	uint32_t token = mono_method_get_token (method);
+
+	char buf [128];
+	char *key = buf;
 	int len;
+	if (name != NULL) {
+		// the key must match the one used in PInvokeTableGenerator
+		len = snprintf (key, sizeof(buf), "%s#%d:%s:%s:%s", method_name, param_count, name, namespace, class_name);
+
+		if (len >= sizeof (buf)) {
+			// The key is too long, try again with a larger buffer
+			key = g_new (char, len + 1);
+			snprintf (key, len + 1, "%s#%d:%s:%s:%s", method_name, param_count, name, namespace, class_name);
+		}
 
-	assert (strlen (name) < 100);
-	snprintf (key, sizeof(key), "%s_%s_%s", name, class_name, method_name);
-	char *fixedName = mono_fixup_symbol_name ("", key, "");
-	addr = wasm_dl_get_native_to_interp (fixedName, extra_arg);
-	free (fixedName);
+		addr = wasm_dl_get_native_to_interp (token, key, extra_arg);
+
+		if (key != buf)
+			free (key);
+	}
 	MONO_EXIT_GC_UNSAFE;
 	return addr;
 }
 
-static void *sysglobal_native_handle;
+static void *sysglobal_native_handle = (void *)0xDeadBeef;
 
 static void*
 wasm_dl_load (const char *name, int flags, char **err, void *user_data)
@@ -248,24 +262,33 @@ wasm_dl_load (const char *name, int flags, char **err, void *user_data)
 	return NULL;
 }
 
+int
+import_compare_name (const void *k1, const void *k2)
+{
+	const PinvokeImport *e1 = (const PinvokeImport*)k1;
+	const PinvokeImport *e2 = (const PinvokeImport*)k2;
+
+	return strcmp (e1->name, e2->name);
+}
+
 static void*
 wasm_dl_symbol (void *handle, const char *name, char **err, void *user_data)
 {
-	if (handle == sysglobal_native_handle)
-		assert (0);
+	assert (handle != sysglobal_native_handle);
 
 #if WASM_SUPPORTS_DLOPEN
 	if (!wasm_dl_is_pinvoke_tables (handle)) {
 		return dlsym (handle, name);
 	}
 #endif
-
-	PinvokeImport *table = (PinvokeImport*)handle;
-	for (int i = 0; table [i].name; ++i) {
-		if (!strcmp (table [i].name, name))
-			return table [i].func;
-	}
-	return NULL;
+	PinvokeTable* index = (PinvokeTable*)handle;
+	PinvokeImport key = { name, NULL };
+    PinvokeImport* result = (PinvokeImport *)bsearch(&key, index->imports, index->count, sizeof(PinvokeImport), import_compare_name);
+    if (!result) {
+        // *err = g_strdup_printf ("Symbol not found: %s", name);
+        return NULL;
+    }
+    return result->func;
 }
 
 MonoDomain *
@@ -363,24 +386,50 @@ mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int argument
 	return result;
 }
 
+MonoMethod*
+mono_wasm_get_method_matching (MonoImage *image, uint32_t token, MonoClass *klass, const char* name, int param_count)
+{
+	MonoMethod *result = NULL;
+	MONO_ENTER_GC_UNSAFE;
+	MonoMethod *method = mono_get_method (image, token, klass);
+	MonoMethodSignature *sig = mono_method_signature (method);
+	// Lookp by token but verify the name and param count in case assembly was trimmed
+	if (mono_signature_get_param_count (sig) == param_count) {
+		const char *method_name = mono_method_get_name (method);
+		if (!strcmp (method_name, name)) {
+			result = method;
+		}
+	}
+	// If the token lookup failed, try to find the method by name and param count
+	if (!result) {
+		result = mono_class_get_method_from_name (klass, name, param_count);
+	}
+	MONO_EXIT_GC_UNSAFE;
+	return result;
+}
+
 /*
  * mono_wasm_marshal_get_managed_wrapper:
  * Creates a wrapper for a function pointer to a method marked with
  * UnamangedCallersOnlyAttribute.
  * This wrapper ensures that the interpreter initializes the pointers.
  */
 void
-mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, int num_params)
+mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, uint32_t token, int param_count)
 {
 	MonoError error;
 	mono_error_init (&error);
+	MONO_ENTER_GC_UNSAFE;
 	MonoAssembly* assembly = mono_wasm_assembly_load (assemblyName);
 	assert (assembly);
-	MonoClass* class = mono_wasm_assembly_find_class (assembly, namespaceName, typeName);
-	assert (class);
-	MonoMethod* method = mono_wasm_assembly_find_method (class, methodName, num_params);
+	MonoImage *image = mono_assembly_get_image (assembly);
+	assert (image);
+	MonoClass* klass = mono_class_from_name (image, namespaceName, typeName);
+	assert (klass);
+	MonoMethod *method = mono_wasm_get_method_matching (image, token, klass, methodName, param_count);
 	assert (method);
 	MonoMethod *managedWrapper = mono_marshal_get_managed_wrapper (method, NULL, 0, &error);
 	assert (managedWrapper);
 	mono_compile_method (managedWrapper);
-}
+	MONO_EXIT_GC_UNSAFE;
+}

src/mono/browser/runtime/runtime.h

@@ -19,7 +19,7 @@ MonoDomain *mono_wasm_load_runtime_common (int debug_level, MonoLogCallback log_
 MonoAssembly *mono_wasm_assembly_load (const char *name);
 MonoClass *mono_wasm_assembly_find_class (MonoAssembly *assembly, const char *namespace, const char *name);
 MonoMethod *mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int arguments);
-void mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, int num_params);
+void mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, uint32_t token, int param_count);
 int initialize_runtime ();
 
 #endif

src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs

@@ -437,6 +437,71 @@ file class Foo
             Assert.Contains("Main running", output);
         }
 
+        [Theory]
+        [BuildAndRun(host: RunHost.Chrome)]
+        public void UnmanagedCallersOnly_Namespaced(BuildArgs buildArgs, RunHost host, string id)
+        {
+            string code =
+                """
+                    using System;
+                    using System.Runtime.InteropServices;
+
+                    public class Test
+                    {
+                        public unsafe static int Main()
+                        {
+                            ((delegate* unmanaged<void>)&A.Conflict.C)();
+                            ((delegate* unmanaged<void>)&B.Conflict.C)();
+                            ((delegate* unmanaged<void>)&A.Conflict.C\u733f)();
+                            ((delegate* unmanaged<void>)&B.Conflict.C\u733f)();
+                            return 42;
+                        }
+                    }
+
+                    namespace A {
+                        public class Conflict {
+                            [UnmanagedCallersOnly(EntryPoint = "A_Conflict_C")]
+                            public static void C() {
+                                Console.WriteLine("A.Conflict.C");
+                            }
+
+                            [UnmanagedCallersOnly(EntryPoint = "A_Conflict_C\u733f")]
+                            public static void C\u733f() {
+                                Console.WriteLine("A.Conflict.C\U0001F412");
+                            }
+                        }
+                    }
+
+                    namespace B {
+                        public class Conflict {
+                            [UnmanagedCallersOnly(EntryPoint = "B_Conflict_C")]
+                            public static void C() {
+                                Console.WriteLine("B.Conflict.C");
+                            }
+
+                            [UnmanagedCallersOnly(EntryPoint = "B_Conflict_C\u733f")]
+                            public static void C\u733f() {
+                                Console.WriteLine("B.Conflict.C\U0001F412");
+                            }
+                        }
+                    }
+                """;
+
+            (buildArgs, string output) = BuildForVariadicFunctionTests(
+                code,
+                buildArgs with { ProjectName = $"cb_namespace_{buildArgs.Config}" },
+                id
+            );
+
+            Assert.DoesNotMatch(".*(warning|error).*>[A-Z0-9]+__Foo", output);
+
+            output = RunAndTestWasmApp(buildArgs, buildDir: _projectDir, expectedExitCode: 42, host: host, id: id);
+            Assert.Contains("A.Conflict.C", output);
+            Assert.Contains("B.Conflict.C", output);
+            Assert.Contains("A.Conflict.C\U0001F412", output);
+            Assert.Contains("B.Conflict.C\U0001F412", output);
+        }
+
         [Theory]
         [BuildAndRun(host: RunHost.None)]
         public void IcallWithOverloadedParametersAndEnum(BuildArgs buildArgs, string id)
@@ -951,6 +1016,7 @@ public void UCOWithSpecialCharacters(BuildArgs buildArgs, RunHost host, string i
                                             DotnetWasmFromRuntimePack: false));
 
             var runOutput = RunAndTestWasmApp(buildArgs, buildDir: _projectDir, expectedExitCode: 42, host: host, id: id);
+            Assert.DoesNotContain("Conflict.A.Managed8\u4F60Func(123) -> 123", runOutput);
             Assert.Contains("ManagedFunc returned 42", runOutput);
         }
     }

src/mono/wasm/testassets/Wasm.Buid.Tests.Programs/UnmanagedCallback.cs

@@ -6,13 +6,24 @@ public unsafe partial class Test
     public unsafe static int Main(string[] args)
     {
         ((IntPtr)(delegate* unmanaged<int,int>)&Interop.Managed8\u4F60Func).ToString();
-
         Console.WriteLine($"main: {args.Length}");
         Interop.UnmanagedFunc();
+
         return 42;
     }
 }
 
+namespace Conflict.A {
+    file class Interop {
+        [UnmanagedCallersOnly(EntryPoint = "ConflictManagedFunc")]
+        public static int Managed8\u4F60Func(int number)
+        {
+            Console.WriteLine($"Conflict.A.Managed8\u4F60Func({number}) -> {number}");
+            return number;
+        }
+    }
+}
+
 file partial class Interop
 {
     [UnmanagedCallersOnly(EntryPoint = "ManagedFunc")]

src/mono/wasm/testassets/native-libs/local.c

@@ -7,4 +7,4 @@ void UnmanagedFunc()
     printf("UnmanagedFunc calling ManagedFunc\n");
     ret = ManagedFunc(123);
     printf("ManagedFunc returned %d\n", ret);
-}
+}