[llvmonly] Optimize delegate invocation. (dotnet#60593)

* [llvmonly] Optimize delegate invocation.

* Unify the initialization of delegates in llvmonly mode in mini_llvmonly_init_delegate ().
* Pass a MonoDelegateTrampInfo structure to init_delegate (), use it to
  cache various data.
* Invoke delegates similarly to the non-llvmonly case, by making an indirect
  call through del->invoke_impl, which is initialized in init_delegate ().
  This also fixes some special cases like bound delegates, since init_delegate ()
  has access to the delegate instance, so it can use the appropriate wrapper.

* Compute a cached MonoDelegateTrampInfo for delegates created from the interpreter as well.

* Fix interp execution of delegate invokes, the invoke wrapper depends on the delegate instance, so it needs to be created in interp_entry () not in transform_method ().

Author: vargaz

src/mono/mono/metadata/icall.c

@@ -6137,7 +6137,7 @@ ves_icall_System_Delegate_AllocDelegateLike_internal (MonoDelegateHandle delegat
 	MonoMulticastDelegateHandle ret = MONO_HANDLE_CAST (MonoMulticastDelegate, mono_object_new_handle (klass, error));
 	return_val_if_nok (error, MONO_HANDLE_CAST (MonoMulticastDelegate, NULL_HANDLE));
 
-	MONO_HANDLE_SETVAL (MONO_HANDLE_CAST (MonoDelegate, ret), invoke_impl, gpointer, mono_runtime_create_delegate_trampoline (klass));
+	mono_get_runtime_callbacks ()->init_delegate (MONO_HANDLE_CAST (MonoDelegate, ret), NULL_HANDLE, NULL, NULL, error);
 
 	return ret;
 }

src/mono/mono/metadata/marshal.c

@@ -2198,6 +2198,29 @@ mono_marshal_get_delegate_invoke_internal (MonoMethod *method, gboolean callvirt
 	return res;
 }
 
+WrapperSubtype
+mono_marshal_get_delegate_invoke_subtype (MonoMethod *method, MonoDelegate *del)
+{
+	MonoMethodSignature *sig;
+
+	sig = mono_method_signature_internal (method);
+
+	if (!del || !del->method)
+		return WRAPPER_SUBTYPE_NONE;
+
+	if (!del->target && mono_method_signature_internal (del->method)->hasthis) {
+		if (!(del->method->flags & METHOD_ATTRIBUTE_VIRTUAL) && !m_class_is_valuetype (del->method->klass) && sig->param_count ==  mono_method_signature_internal (del->method)->param_count + 1)
+			return WRAPPER_SUBTYPE_NONE;
+		else
+			return WRAPPER_SUBTYPE_DELEGATE_INVOKE_VIRTUAL;
+	}
+
+	if (mono_method_signature_internal (del->method)->param_count == sig->param_count + 1 && (del->method->flags & METHOD_ATTRIBUTE_STATIC))
+		return WRAPPER_SUBTYPE_DELEGATE_INVOKE_BOUND;
+
+	return WRAPPER_SUBTYPE_NONE;
+}
+
 /**
  * mono_marshal_get_delegate_invoke:
  * The returned method invokes all methods in a multicast delegate.

src/mono/mono/metadata/marshal.h

@@ -428,6 +428,9 @@ mono_marshal_get_delegate_invoke (MonoMethod *method, MonoDelegate *del);
 MonoMethod *
 mono_marshal_get_delegate_invoke_internal (MonoMethod *method, gboolean callvirt, gboolean static_method_with_first_arg_bound, MonoMethod *target_method);
 
+WrapperSubtype
+mono_marshal_get_delegate_invoke_subtype (MonoMethod *method, MonoDelegate *del);
+
 MonoMethod *
 mono_marshal_get_runtime_invoke_full (MonoMethod *method, gboolean virtual_, gboolean need_direct_wrapper);
 

src/mono/mono/mini/calls.c

@@ -703,6 +703,21 @@ mini_emit_llvmonly_virtual_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMeth
 		helper_sig_llvmonly_imt_trampoline = tmp;
 	}
 
+	if (!cfg->gsharedvt && (m_class_get_parent (cmethod->klass) == mono_defaults.multicastdelegate_class) && !strcmp (cmethod->name, "Invoke")) {
+		/* Delegate invokes */
+		MONO_EMIT_NULL_CHECK (cfg, this_reg, FALSE);
+
+		/* Make a call to delegate->invoke_impl */
+		int invoke_reg = alloc_preg (cfg);
+		MONO_EMIT_NEW_LOAD_MEMBASE (cfg, invoke_reg, this_reg, MONO_STRUCT_OFFSET (MonoDelegate, invoke_impl));
+
+		int addr_reg = alloc_preg (cfg);
+		int arg_reg = alloc_preg (cfg);
+		EMIT_NEW_LOAD_MEMBASE (cfg, call_target, OP_LOAD_MEMBASE, addr_reg, invoke_reg, 0);
+		MONO_EMIT_NEW_LOAD_MEMBASE (cfg, arg_reg, invoke_reg, TARGET_SIZEOF_VOID_P);
+		return mini_emit_extra_arg_calli (cfg, fsig, sp, arg_reg, call_target);
+	}
+
 	if (!fsig->generic_param_count && !is_iface) {
 		/*
 		 * The simplest case, a normal virtual call.

src/mono/mono/mini/ee.h

@@ -14,7 +14,7 @@
 #ifndef __MONO_EE_H__
 #define __MONO_EE_H__
 
-#define MONO_EE_API_VERSION 0x12
+#define MONO_EE_API_VERSION 0x13
 
 typedef struct _MonoInterpStackIter MonoInterpStackIter;
 
@@ -32,7 +32,7 @@ typedef gpointer MonoInterpFrameHandle;
 	MONO_EE_CALLBACK (MonoFtnDesc*, create_method_pointer_llvmonly, (MonoMethod *method, gboolean unbox, MonoError *error)) \
 	MONO_EE_CALLBACK (void, free_method, (MonoMethod *method)) \
 	MONO_EE_CALLBACK (MonoObject*, runtime_invoke, (MonoMethod *method, void *obj, void **params, MonoObject **exc, MonoError *error)) \
-	MONO_EE_CALLBACK (void, init_delegate, (MonoDelegate *del, MonoError *error)) \
+	MONO_EE_CALLBACK (void, init_delegate, (MonoDelegate *del, MonoDelegateTrampInfo **out_info, MonoError *error)) \
 	MONO_EE_CALLBACK (void, delegate_ctor, (MonoObjectHandle this_obj, MonoObjectHandle target, gpointer addr, MonoError *error)) \
 	MONO_EE_CALLBACK (void, set_resume_state, (MonoJitTlsData *jit_tls, MonoObject *ex, MonoJitExceptionInfo *ei, MonoInterpFrameHandle interp_frame, gpointer handler_ip)) \
 	MONO_EE_CALLBACK (void, get_resume_state, (const MonoJitTlsData *jit_tls, gboolean *has_resume_state, MonoInterpFrameHandle *interp_frame, gpointer *handler_ip)) \

src/mono/mono/mini/interp-stubs.c

@@ -155,7 +155,7 @@ stub_runtime_invoke (MonoMethod *method, void *obj, void **params, MonoObject **
 }
 
 static void
-stub_init_delegate (MonoDelegate *del, MonoError *error)
+stub_init_delegate (MonoDelegate *del, MonoDelegateTrampInfo **info, MonoError *error)
 {
 	g_assert_not_reached ();
 }

src/mono/mono/mini/interp/interp-internals.h

@@ -130,6 +130,7 @@ struct InterpMethod {
 	MonoJitInfo *jinfo;
 	MonoFtnDesc *ftndesc;
 	MonoFtnDesc *ftndesc_unbox;
+	MonoDelegateTrampInfo *del_info;
 
 	guint32 locals_size;
 	guint32 alloca_size;

src/mono/mono/mini/interp/interp.c

@@ -1619,7 +1619,7 @@ ves_pinvoke_method (
  *   Initialize del->interp_method.
  */
 static void
-interp_init_delegate (MonoDelegate *del, MonoError *error)
+interp_init_delegate (MonoDelegate *del, MonoDelegateTrampInfo **out_info, MonoError *error)
 {
 	MonoMethod *method;
 
@@ -1669,6 +1669,25 @@ interp_init_delegate (MonoDelegate *del, MonoError *error)
 		mono_interp_transform_method ((InterpMethod *) del->interp_method, get_context (), error);
 		return_if_nok (error);
 	}
+
+	/*
+	 * Compute a MonoDelegateTrampInfo for this delegate if possible and pass it back to
+	 * the caller.
+	 * Keep a 1 element cache in imethod->del_info. This should be good enough since most methods
+	 * are only associated with one delegate type.
+	 */
+	if (out_info)
+		*out_info = NULL;
+	if (mono_llvm_only) {
+		InterpMethod *imethod = del->interp_method;
+		method = imethod->method;
+		if (imethod->del_info && imethod->del_info->klass == del->object.vtable->klass) {
+			*out_info = imethod->del_info;
+		} else if (!imethod->del_info) {
+			imethod->del_info = mono_create_delegate_trampoline_info (del->object.vtable->klass, method);
+			*out_info = imethod->del_info;
+		}
+	}
 }
 
 /* Convert a function pointer for a managed method to an InterpMethod* */
@@ -2007,6 +2026,20 @@ interp_entry (InterpEntryData *data)
 	sp_args = sp = (stackval*)context->stack_pointer;
 
 	method = rmethod->method;
+
+	if (m_class_get_parent (method->klass) == mono_defaults.multicastdelegate_class && !strcmp (method->name, "Invoke")) {
+		/*
+		 * This happens when AOT code for the invoke wrapper is not found.
+		 * Have to replace the method with the wrapper here, since the wrapper depends on the delegate.
+		 */
+		ERROR_DECL (error);
+		MonoDelegate *del = (MonoDelegate*)data->this_arg;
+		// FIXME: This is slow
+		method = mono_marshal_get_delegate_invoke (method, del);
+		data->rmethod = mono_interp_get_imethod (method, error);
+		mono_error_assert_ok (error);
+	}
+
 	sig = mono_method_signature_internal (method);
 
 	// FIXME: Optimize this

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

@@ -651,24 +651,39 @@ mini_llvmonly_init_vtable_slot (MonoVTable *vtable, int slot)
  * Similar to mono_delegate_ctor ().
  */
 void
-mini_llvmonly_init_delegate (MonoDelegate *del)
+mini_llvmonly_init_delegate (MonoDelegate *del, MonoDelegateTrampInfo *info)
 {
 	ERROR_DECL (error);
-	MonoFtnDesc *ftndesc = *(MonoFtnDesc**)del->method_code;
+	MonoFtnDesc *ftndesc;
+
+	if (!info && !del->method) {
+		// Multicast delegate init
+		// Have to set the invoke_impl field
+		// FIXME: Cache
+		MonoMethod *invoke_impl = mono_marshal_get_delegate_invoke (mono_get_delegate_invoke_internal (del->object.vtable->klass), NULL);
+		gpointer arg = NULL;
+		gpointer addr = mini_llvmonly_load_method_delegate (invoke_impl, FALSE, FALSE, &arg, error);
+		mono_error_assert_ok (error);
+		del->invoke_impl = mini_llvmonly_create_ftndesc (invoke_impl, addr, arg);
+		return;
+	}
+
+	if (G_UNLIKELY (!info)) {
+		g_assert (del->method);
+		info = mono_create_delegate_trampoline_info (del->object.vtable->klass, del->method);
+	}
+
+	/* Cache the target method address in MonoDelegateTrampInfo */
+	ftndesc = (MonoFtnDesc*)info->method_ptr;
 
-	/*
-	 * We store a MonoFtnDesc in del->method_code.
-	 * It would be better to store an ftndesc in del->method_ptr too,
-	 * but we don't have a a structure which could own its memory.
-	 */
 	if (G_UNLIKELY (!ftndesc)) {
 		MonoMethod *m = del->method;
 		gboolean need_unbox = FALSE;
 
 		if (m->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
 			m = mono_marshal_get_synchronized_wrapper (m);
 
-		if (m_class_is_valuetype (m->klass) && mono_method_signature_internal (m)->hasthis)
+		if (m_class_is_valuetype (m->klass) && mono_method_signature_internal (m)->hasthis && !(info->invoke_sig->param_count > info->sig->param_count))
 			need_unbox = TRUE;
 
 		gpointer arg = NULL;
@@ -677,33 +692,40 @@ mini_llvmonly_init_delegate (MonoDelegate *del)
 			return;
 		ftndesc = mini_llvmonly_create_ftndesc (m, addr, arg);
 		mono_memory_barrier ();
-		*del->method_code = (guint8*)ftndesc;
+		//*del->method_code = (guint8*)ftndesc;
+		info->method_ptr = ftndesc;
 	}
 	del->method_ptr = ftndesc->addr;
 	del->extra_arg = ftndesc->arg;
+
+	WrapperSubtype subtype = mono_marshal_get_delegate_invoke_subtype (info->invoke, del);
+
+	ftndesc = info->invoke_impl;
+	if (G_UNLIKELY (!ftndesc) || subtype != WRAPPER_SUBTYPE_NONE) {
+		ERROR_DECL (error);
+		MonoMethod *invoke_impl = mono_marshal_get_delegate_invoke (info->invoke, del);
+		gpointer arg = NULL;
+		gpointer addr = mini_llvmonly_load_method_delegate (invoke_impl, FALSE, FALSE, &arg, error);
+		mono_error_assert_ok (error);
+		ftndesc = mini_llvmonly_create_ftndesc (invoke_impl, addr, arg);
+		if (subtype == WRAPPER_SUBTYPE_NONE) {
+			mono_memory_barrier ();
+			info->invoke_impl = ftndesc;
+		} else {
+			// FIXME: Cache
+		}
+	}
+	del->invoke_impl = ftndesc;
 }
 
 void
 mini_llvmonly_init_delegate_virtual (MonoDelegate *del, MonoObject *target, MonoMethod *method)
 {
-	ERROR_DECL (error);
-	gpointer addr, arg;
-	gboolean need_unbox;
-
 	g_assert (target);
 
-	method = mono_object_get_virtual_method_internal (target, method);
-
-	if (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
-		method = mono_marshal_get_synchronized_wrapper (method);
-	need_unbox = m_class_is_valuetype (method->klass);
+	del->method = mono_object_get_virtual_method_internal (target, method);
 
-	del->method = method;
-	addr = mini_llvmonly_load_method_delegate (method, FALSE, need_unbox, &arg, error);
-	if (mono_error_set_pending_exception (error))
-		return;
-	del->method_ptr = addr;
-	del->extra_arg = arg;
+	mini_llvmonly_init_delegate (del, NULL);
 }
 
 /*

src/mono/mono/mini/llvmonly-runtime.h

@@ -25,7 +25,7 @@ G_EXTERN_C gpointer mini_llvmonly_resolve_vcall_gsharedvt (MonoObject *this_obj,
 G_EXTERN_C gpointer mini_llvmonly_resolve_iface_call_gsharedvt (MonoObject *this_obj, int imt_slot, MonoMethod *imt_method, gpointer *out_arg);
 G_EXTERN_C MonoFtnDesc* mini_llvmonly_resolve_generic_virtual_call (MonoVTable *vt, int slot, MonoMethod *imt_method);
 G_EXTERN_C MonoFtnDesc* mini_llvmonly_resolve_generic_virtual_iface_call (MonoVTable *vt, int imt_slot, MonoMethod *imt_method);
-G_EXTERN_C void mini_llvmonly_init_delegate (MonoDelegate *del);
+G_EXTERN_C void mini_llvmonly_init_delegate (MonoDelegate *del, MonoDelegateTrampInfo *info);
 G_EXTERN_C void mini_llvmonly_init_delegate_virtual (MonoDelegate *del, MonoObject *target, MonoMethod *method);
 
 /* Used for regular llvm as well */