[mono][aot] Enabling AOT wrappers for virtual delegates

src/mono/mono/metadata/marshal-lightweight.c

@@ -1990,7 +1990,7 @@ emit_delegate_end_invoke_ilgen (MonoMethodBuilder *mb, MonoMethodSignature *sig)
 }
 
 static void
-emit_delegate_invoke_internal_ilgen (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodSignature *invoke_sig, MonoMethodSignature *target_method_sig, gboolean static_method_with_first_arg_bound, gboolean callvirt, gboolean closed_over_null, MonoMethod *method, MonoMethod *target_method, MonoClass *target_class, MonoGenericContext *ctx, MonoGenericContainer *container)
+emit_delegate_invoke_internal_ilgen (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodSignature *invoke_sig, MonoMethodSignature *target_method_sig, gboolean static_method_with_first_arg_bound, gboolean callvirt, gboolean closed_over_null, MonoMethod *method, MonoMethod *target_method, MonoGenericContext *ctx, MonoGenericContainer *container)
 {
 	int local_i, local_len, local_delegates, local_d, local_target, local_res = 0;
 	int pos0, pos1, pos2;
@@ -2088,9 +2088,15 @@ emit_delegate_invoke_internal_ilgen (MonoMethodBuilder *mb, MonoMethodSignature
 
 	if (callvirt) {
 		if (!closed_over_null) {
-			for (i = 1; i <= sig->param_count; ++i)
+			for (i = 1; i <= sig->param_count; ++i) {
 				mono_mb_emit_ldarg (mb, i);
-			mono_mb_emit_ldarg (mb, 1);
+				if (i == 1 && MONO_TYPE_ISSTRUCT (sig->params [0]))
+					mono_mb_emit_op (mb, CEE_BOX, mono_class_from_mono_type_internal (sig->params [0]));
+			}
+			if (MONO_TYPE_ISSTRUCT (sig->params [0]))
+				mono_mb_emit_ldarg_addr (mb, 1);
+			else
+				mono_mb_emit_ldarg (mb, 1);
 			mono_mb_emit_ldarg (mb, 0);
 			mono_mb_emit_icall (mb, mono_get_addr_compiled_method);
 			mono_mb_emit_op (mb, CEE_CALLI, target_method_sig);

src/mono/mono/metadata/marshal.c

@@ -2092,7 +2092,6 @@ mono_marshal_get_delegate_invoke_internal (MonoMethod *method, gboolean callvirt
 	GHashTable *cache;
 	gpointer cache_key = NULL;
 	char *name;
-	MonoClass *target_class = NULL;
 	gboolean closed_over_null = FALSE;
 	MonoGenericContext *ctx = NULL;
 	MonoGenericContainer *container = NULL;
@@ -2113,25 +2112,14 @@ mono_marshal_get_delegate_invoke_internal (MonoMethod *method, gboolean callvirt
 	 */
 	if (callvirt) {
 		subtype = WRAPPER_SUBTYPE_DELEGATE_INVOKE_VIRTUAL;
-		if (target_method->is_inflated) {
-			ERROR_DECL (error);
-			MonoType *target_type;
-
-			g_assert (method->signature->hasthis);
-			target_type = mono_class_inflate_generic_type_checked (method->signature->params [0],
-				mono_method_get_context (method), error);
-			mono_error_assert_ok (error); /* FIXME don't swallow the error */
-			target_class = mono_class_from_mono_type_internal (target_type);
-		} else {
-			target_class = target_method->klass;
-		}
-
-		closed_over_null = sig->param_count == mono_method_signature_internal (target_method)->param_count;
 
 		/*
 		 * We don't want to use target_method's signature because it can be freed early
 		 */
-		target_method_sig = mono_method_signature_internal (target_method);
+		target_method_sig = mono_metadata_signature_dup_delegate_invoke_to_target (invoke_sig);
+		// target_method_sig = mono_method_signature_internal (target_method);
+
+		closed_over_null = sig->param_count == target_method_sig->param_count;
 	}
 
 	if (static_method_with_first_arg_bound) {
@@ -2241,7 +2229,7 @@ mono_marshal_get_delegate_invoke_internal (MonoMethod *method, gboolean callvirt
 		/* FIXME: Other subtypes */
 		mb->mem_manager = m_method_get_mem_manager (method);
 
-	get_marshal_cb ()->emit_delegate_invoke_internal (mb, sig, invoke_sig, target_method_sig, static_method_with_first_arg_bound, callvirt, closed_over_null, method, target_method, target_class, ctx, container);
+	get_marshal_cb ()->emit_delegate_invoke_internal (mb, sig, invoke_sig, target_method_sig, static_method_with_first_arg_bound, callvirt, closed_over_null, method, target_method, ctx, container);
 
 	get_marshal_cb ()->mb_skip_visibility (mb);
 

src/mono/mono/metadata/marshal.h

@@ -328,7 +328,7 @@ typedef struct {
 	void (*emit_runtime_invoke_dynamic) (MonoMethodBuilder *mb);
 	void (*emit_delegate_begin_invoke) (MonoMethodBuilder *mb, MonoMethodSignature *sig);
 	void (*emit_delegate_end_invoke) (MonoMethodBuilder *mb, MonoMethodSignature *sig);
-	void (*emit_delegate_invoke_internal) (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodSignature *invoke_sig, MonoMethodSignature *target_method_sig, gboolean static_method_with_first_arg_bound, gboolean callvirt, gboolean closed_over_null, MonoMethod *method, MonoMethod *target_method, MonoClass *target_class, MonoGenericContext *ctx, MonoGenericContainer *container);
+	void (*emit_delegate_invoke_internal) (MonoMethodBuilder *mb, MonoMethodSignature *sig, MonoMethodSignature *invoke_sig, MonoMethodSignature *target_method_sig, gboolean static_method_with_first_arg_bound, gboolean callvirt, gboolean closed_over_null, MonoMethod *method, MonoMethod *target_method, MonoGenericContext *ctx, MonoGenericContainer *container);
 	void (*emit_synchronized_wrapper) (MonoMethodBuilder *mb, MonoMethod *method, MonoGenericContext *ctx, MonoGenericContainer *container, MonoMethod *enter_method, MonoMethod *exit_method, MonoMethod *gettypefromhandle_method);
 	void (*emit_unbox_wrapper) (MonoMethodBuilder *mb, MonoMethod *method);
 	void (*emit_array_accessor_wrapper) (MonoMethodBuilder *mb, MonoMethod *method, MonoMethodSignature *sig, MonoGenericContext *ctx);

src/mono/mono/metadata/metadata-internals.h

@@ -985,6 +985,7 @@ MonoMethodSignature  *mono_metadata_signature_dup_full (MonoImage *image,MonoMet
 MonoMethodSignature  *mono_metadata_signature_dup_mempool (MonoMemPool *mp, MonoMethodSignature *sig);
 MonoMethodSignature  *mono_metadata_signature_dup_mem_manager (MonoMemoryManager *mem_manager, MonoMethodSignature *sig);
 MonoMethodSignature  *mono_metadata_signature_dup_add_this (MonoImage *image, MonoMethodSignature *sig, MonoClass *klass);
+MonoMethodSignature  *mono_metadata_signature_dup_delegate_invoke_to_target (MonoMethodSignature *sig);
 
 MonoGenericInst *
 mono_get_shared_generic_inst (MonoGenericContainer *container);

src/mono/mono/metadata/metadata.c

@@ -2512,6 +2512,33 @@ mono_metadata_signature_dup (MonoMethodSignature *sig)
 	return mono_metadata_signature_dup_full (NULL, sig);
 }
 
+/**
+ * mono_metadata_signature_dup_delegate_invoke_to_target:
+ * \param sig method signature
+ *
+ * Duplicate an existing \c MonoMethodSignature but removes first param from it so it can
+ * be used as signature for a delegate target method.
+ * This is a Mono runtime internal function.
+ *
+ * \returns the new \c MonoMethodSignature structure.
+ */
+MonoMethodSignature*
+mono_metadata_signature_dup_delegate_invoke_to_target (MonoMethodSignature *sig)
+{
+	MonoMethodSignature *res = mono_metadata_signature_dup_full (NULL, sig);
+
+	for (int i = 0 ; i < sig->param_count - 1; i ++) {
+		res->params [i] = sig->params [i + 1];
+	}
+
+    res->param_count --;
+
+	// if (res->params [res->param_count - 1])
+	// mono_metadata_free_type (res->params [res->param_count --]);
+
+	return res;
+}
+
 /*
  * mono_metadata_signature_size:
  *

src/mono/mono/mini/aot-compiler.c

@@ -3778,6 +3778,8 @@ encode_method_ref (MonoAotCompile *acfg, MonoMethod *method, guint8 *buf, guint8
 	MonoJumpInfoToken *ji;
 	guint8 *p = buf;
 
+	printf("NAME = %s\n", method->name);
+
 	/*
 	 * The encoding for most methods is as follows:
 	 * - image index encoded as a leb128
@@ -3915,7 +3917,11 @@ encode_method_ref (MonoAotCompile *acfg, MonoMethod *method, guint8 *buf, guint8
 				encode_value (0, p, &p);
 				if (method->wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE)
 					encode_value (wrapper_info ? wrapper_info->subtype : 0, p, &p);
-				encode_signature (acfg, sig, p, &p);
+
+				if (wrapper_info && wrapper_info->subtype == WRAPPER_SUBTYPE_DELEGATE_INVOKE_VIRTUAL)
+					encode_klass_ref (acfg, method->klass, p, &p);
+				else
+					encode_signature (acfg, sig, p, &p);
 			}
 			break;
 		}
@@ -4949,6 +4955,12 @@ add_full_aot_wrappers (MonoAotCompile *acfg)
 
 			add_method (acfg, m);
 
+			sig = mono_method_signature_internal (method);
+			if (sig->param_count && !m_class_is_byreflike (mono_class_from_mono_type_internal (sig->params [0]))) {
+				m = mono_marshal_get_delegate_invoke_internal (method, TRUE, FALSE, NULL);
+				add_method (acfg, m);
+			}
+
 			method = try_get_method_nofail (klass, "BeginInvoke", -1, 0);
 			if (method)
 				add_method (acfg, mono_marshal_get_delegate_begin_invoke (method));

src/mono/mono/mini/aot-runtime.c

@@ -1273,11 +1273,20 @@ decode_method_ref_with_target (MonoAotModule *module, MethodRef *ref, MonoMethod
 				 * These wrappers are associated with a signature, not with a method.
 				 * Since we can't decode them into methods, they need a target method.
 				 */
-				if (!target)
-					return FALSE;
+				MonoClass *klass;
+				MonoMethod *invoke;
+				// if (!target)
+				// 	return FALSE;
+
 
 				if (wrapper_type == MONO_WRAPPER_DELEGATE_INVOKE) {
 					subtype = (WrapperSubtype)decode_value (p, &p);
+					if (subtype == WRAPPER_SUBTYPE_DELEGATE_INVOKE_VIRTUAL) {
+						klass = decode_klass_ref (module, p, &p, error);
+						invoke = mono_get_delegate_invoke_internal (klass);
+						ref->method = mono_marshal_get_delegate_invoke_internal(invoke, TRUE, FALSE, NULL);
+						break;
+					}
 					info = mono_marshal_get_wrapper_info (target);
 					if (info) {
 						if (info->subtype != subtype)

src/mono/sample/iOS/Makefile

@@ -1,10 +1,10 @@
 MONO_CONFIG?=Debug
-MONO_ARCH?=x64
+MONO_ARCH?=arm64
 DOTNET := ../../../../dotnet.sh
 USE_LLVM=true
-AOT?=false
-TARGET?=iossimulator
-DEPLOY_AND_RUN?=true
+AOT?=true
+TARGET?=ios
+DEPLOY_AND_RUN?=false
 APP_SANDBOX?=false
 STRIP_DEBUG_SYMBOLS?=false # only used when measuring SOD via build-appbundle make target
 

src/mono/sample/iOS/Program.cs

@@ -30,10 +30,16 @@ public static async Task<int> Main(string[] args)
     public static async Task Main(string[] args)
 #endif
     {
-        unsafe {
-            // Register a managed callback (will be called by UIButton, see main.m)
-            delegate* unmanaged<void> unmanagedPtr = &OnButtonClick;
-            ios_register_button_click(unmanagedPtr);
+        // unsafe {
+        //     // Register a managed callback (will be called by UIButton, see main.m)
+        //     delegate* unmanaged<void> unmanagedPtr = &OnButtonClick;
+        //     ios_register_button_click(unmanagedPtr);
+        // }
+        try {
+            var del = (Func<string, string>)Delegate.CreateDelegate (typeof (Func<string, string>), null, typeof (object).GetMethod ("ToString"));
+            del ("Foo");
+        } catch(Exception e) {
+            Console.WriteLine(e);
         }
         const string msg = "Hello World!\n.NET 8.0";
         for (int i = 0; i < msg.Length; i++)