return GPOINTER_TO_UINT (info->m) ^ GPOINTER_TO_UINT (info->addr);
}
-/*
+/**
* mono_create_static_rgctx_trampoline:
+ * @m: the mono method to create a trampoline for
+ * @addr: the address to jump to (where the compiled code for M lives)
*
- * Return a static rgctx trampoline for M which branches to ADDR which should
+ * Creates a static rgctx trampoline for M which branches to ADDR which should
* point to the compiled code of M.
*
- * Static rgctx trampolines are used when a shared generic method which doesn't
+ * Static rgctx trampolines are used when a shared generic method which doesn't
* have a this argument is called indirectly, ie. from code which can't pass in
* the rgctx argument. The trampoline sets the rgctx argument and jumps to the
* methods code. These trampolines are similar to the unbox trampolines, they
* perform the same task as the static rgctx wrappers, but they are smaller/faster,
* and can be made to work with full AOT.
+ *
* On PPC addr should be an ftnptr and the return value is an ftnptr too.
+ *
+ * Returns the generated static rgctx trampoline.
*/
gpointer
mono_create_static_rgctx_trampoline (MonoMethod *m, gpointer addr)
return FALSE;
}
-/*
+/**
* mini_add_method_trampoline:
+ * @orig_method: the method the caller originally called i.e. an iface method, or NULL.
+ * @m:
+ * @compiled_method:
+ * @add_static_rgctx_tramp: adds a static rgctx trampoline
+ * @add_unbox_tramp: adds an unboxing trampoline
+ *
+ * Add static rgctx/gsharedvt_in/unbox trampolines to
+ * M/COMPILED_METHOD if needed.
*
- * Add static rgctx/gsharedvt_in/unbox trampolines to M/COMPILED_METHOD if needed. Return the trampoline address, or
- * COMPILED_METHOD if no trampoline is needed.
- * ORIG_METHOD is the method the caller originally called i.e. an iface method, or NULL.
+ * Returns the trampoline address, or COMPILED_METHOD if no trampoline
+ * is needed.
*/
gpointer
mini_add_method_trampoline (MonoMethod *orig_method, MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp)
} else {
gboolean lookup_aot;
+ mono_class_interface_offset_with_variance (vt->klass, m->klass, &variance_used);
+
if (m->is_inflated && ((MonoMethodInflated*)m)->context.method_inst) {
/* Generic virtual method */
generic_virtual = m;
}
}
if (!no_patch)
- mono_aot_patch_plt_entry (plt_entry, NULL, regs, addr);
+ mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, addr);
} else {
if (generic_shared) {
if (m->wrapper_type != MONO_WRAPPER_NONE)
/**
* mono_magic_trampoline:
*
- * This trampoline handles normal calls from JITted code.
+ * This trampoline handles normal calls from JITted code.
*/
gpointer
mono_magic_trampoline (mgreg_t *regs, guint8 *code, gpointer arg, guint8* tramp)
return common_call_trampoline (regs, code, arg, tramp, NULL, NULL, FALSE);
}
-/*
+/**
* mono_vcall_trampoline:
*
- * This trampoline handles virtual calls.
+ * This trampoline handles virtual calls.
*/
static gpointer
mono_vcall_trampoline (mgreg_t *regs, guint8 *code, int slot, guint8 *tramp)
}
#endif
-/*
+/**
* mono_aot_trampoline:
*
- * This trampoline handles calls made from AOT code. We try to bypass the
+ * This trampoline handles calls made from AOT code. We try to bypass the
* normal JIT compilation logic to avoid loading the metadata for the method.
*/
#ifdef MONO_ARCH_AOT_SUPPORTED
plt_entry = mono_aot_get_plt_entry (code);
g_assert (plt_entry);
- mono_aot_patch_plt_entry (plt_entry, NULL, regs, addr);
+ mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, addr);
return addr;
}
if (vtable->initialized) {
if (plt_entry)
- mono_arch_nullify_plt_entry (plt_entry, regs);
+ mono_aot_patch_plt_entry (code, plt_entry, NULL, regs, mini_get_nullified_class_init_trampoline ());
else
mono_arch_nullify_class_init_trampoline (code, regs);
}
#ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
+typedef struct {
+ MonoMethod *invoke;
+ gpointer impl_this;
+ gpointer impl_nothis;
+ MonoMethod *method;
+ MonoMethodSignature *invoke_sig;
+ MonoMethodSignature *sig;
+ gboolean need_rgctx_tramp;
+} DelegateTrampInfo;
+
+/*
+ * Precompute data to speed up mono_delegate_trampoline ().
+ * METHOD might be NULL.
+ */
+static gpointer
+create_delegate_trampoline_data (MonoDomain *domain, MonoClass *klass, MonoMethod *method)
+{
+ DelegateTrampInfo *tramp_data;
+ MonoMethod *invoke;
+ MonoError err;
+
+ // Precompute the delegate invoke impl and pass it to the delegate trampoline
+ invoke = mono_get_delegate_invoke (klass);
+ g_assert (invoke);
+
+ tramp_data = mono_domain_alloc (domain, sizeof (DelegateTrampInfo));
+ tramp_data->invoke = invoke;
+ tramp_data->invoke_sig = mono_method_signature (invoke);
+ tramp_data->impl_this = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), TRUE);
+ tramp_data->impl_nothis = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), FALSE);
+ tramp_data->method = method;
+ if (method) {
+ mono_error_init (&err);
+ tramp_data->sig = mono_method_signature_checked (method, &err);
+ tramp_data->need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (method, FALSE);
+ }
+
+ return tramp_data;
+}
+
/**
* mono_delegate_trampoline:
*
* This is called once the first time a delegate is invoked, so it must be fast.
*/
gpointer
-mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
+mono_delegate_trampoline (mgreg_t *regs, guint8 *code, gpointer *arg, guint8* tramp)
{
MonoDomain *domain = mono_domain_get ();
MonoDelegate *delegate;
MonoJitInfo *ji;
MonoMethod *m;
MonoMethod *method = NULL;
- gboolean multicast, callvirt = FALSE;
+ gboolean multicast, callvirt = FALSE, closed_over_null = FALSE;
gboolean need_rgctx_tramp = FALSE;
gboolean need_unbox_tramp = FALSE;
gboolean enable_caching = TRUE;
- MonoMethod *invoke = tramp_data [0];
- guint8 *impl_this = tramp_data [1];
- guint8 *impl_nothis = tramp_data [2];
+ DelegateTrampInfo *tramp_info = (DelegateTrampInfo*)arg;
+ MonoMethod *invoke = tramp_info->invoke;
+ guint8 *impl_this = tramp_info->impl_this;
+ guint8 *impl_nothis = tramp_info->impl_nothis;
MonoError err;
MonoMethodSignature *sig;
gpointer addr, compiled_method;
} else
#endif
{
- mono_error_init (&err);
- sig = mono_method_signature_checked (method, &err);
- if (!sig)
- mono_error_raise_exception (&err);
-
+ sig = tramp_info->sig;
+ if (!(sig && method == tramp_info->method)) {
+ mono_error_init (&err);
+ sig = mono_method_signature_checked (method, &err);
+ if (!sig)
+ mono_error_raise_exception (&err);
+ }
+
if (sig->hasthis && method->klass->valuetype) {
if (mono_aot_only)
need_unbox_tramp = TRUE;
}
if (method) {
- mono_error_init (&err);
- sig = mono_method_signature_checked (method, &err);
- if (!sig)
- mono_error_raise_exception (&err);
+ sig = tramp_info->sig;
+ if (!(sig && method == tramp_info->method)) {
+ mono_error_init (&err);
+ sig = mono_method_signature_checked (method, &err);
+ if (!sig)
+ mono_error_raise_exception (&err);
+ }
callvirt = !delegate->target && sig->hasthis;
+ if (callvirt)
+ closed_over_null = tramp_info->invoke_sig->param_count == sig->param_count;
+
+ if (callvirt && !closed_over_null) {
+ /*
+ * The delegate needs to make a virtual call to the target method using its
+ * first argument as the receiver. This is hard to support in full-aot, so
+ * optimize it in some cases if possible.
+ * If the target method is not virtual or is in a sealed class,
+ * the vcall will call it directly.
+ * If the call doesn't return a valuetype, then the vcall uses the same calling
+ * convention as a normal call.
+ */
+ if (((method->klass->flags & TYPE_ATTRIBUTE_SEALED) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) && !MONO_TYPE_ISSTRUCT (sig->ret)) {
+ callvirt = FALSE;
+ enable_caching = FALSE;
+ }
+ }
+
if (delegate->target &&
method->flags & METHOD_ATTRIBUTE_VIRTUAL &&
method->flags & METHOD_ATTRIBUTE_ABSTRACT &&
method = mono_object_get_virtual_method (delegate->target, method);
enable_caching = FALSE;
}
- }
- if (method && method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
- method = mono_marshal_get_synchronized_wrapper (method);
+ if (method->iflags & METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED)
+ method = mono_marshal_get_synchronized_wrapper (method);
- if (method && mono_method_needs_static_rgctx_invoke (method, FALSE))
- need_rgctx_tramp = TRUE;
+ if (method == tramp_info->method)
+ need_rgctx_tramp = tramp_info->need_rgctx_tramp;
+ else if (mono_method_needs_static_rgctx_invoke (method, FALSE))
+ need_rgctx_tramp = TRUE;
+ }
/*
* If the called address is a trampoline, replace it with the compiled method so
#ifdef MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD
static gpointer
-mono_handler_block_guard_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_data, guint8* tramp)
+mono_handler_block_guard_trampoline (mgreg_t *regs, guint8 *code, gpointer *tramp_info, guint8* tramp)
{
MonoContext ctx;
MonoException *exc;
return tramp;
}
+
+/*
+ * mono_create_delegate_trampoline_with_method:
+ *
+ * Create a delegate trampoline for the KLASS+METHOD pair.
+ */
gpointer
-mono_create_delegate_trampoline (MonoDomain *domain, MonoClass *klass)
+mono_create_delegate_trampoline_with_method (MonoDomain *domain, MonoClass *klass, MonoMethod *method)
{
#ifdef MONO_ARCH_HAVE_CREATE_DELEGATE_TRAMPOLINE
gpointer ptr;
guint32 code_size = 0;
- gpointer *tramp_data;
- MonoMethod *invoke;
+ gpointer tramp_info;
+ MonoClassMethodPair pair, *dpair;
+ pair.klass = klass;
+ pair.method = method;
mono_domain_lock (domain);
- ptr = g_hash_table_lookup (domain_jit_info (domain)->delegate_trampoline_hash, klass);
+ ptr = g_hash_table_lookup (domain_jit_info (domain)->delegate_trampoline_hash, &pair);
mono_domain_unlock (domain);
if (ptr)
return ptr;
- // Precompute the delegate invoke impl and pass it to the delegate trampoline
- invoke = mono_get_delegate_invoke (klass);
- g_assert (invoke);
-
- tramp_data = mono_domain_alloc (domain, sizeof (gpointer) * 3);
- tramp_data [0] = invoke;
- tramp_data [1] = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), TRUE);
- tramp_data [2] = mono_arch_get_delegate_invoke_impl (mono_method_signature (invoke), FALSE);
+ tramp_info = create_delegate_trampoline_data (domain, klass, method);
- ptr = mono_create_specific_trampoline (tramp_data, MONO_TRAMPOLINE_DELEGATE, domain, &code_size);
+ ptr = mono_create_specific_trampoline (tramp_info, MONO_TRAMPOLINE_DELEGATE, domain, &code_size);
g_assert (code_size);
+ dpair = mono_domain_alloc0 (domain, sizeof (MonoClassMethodPair));
+ memcpy (dpair, &pair, sizeof (MonoClassMethodPair));
+
/* store trampoline address */
mono_domain_lock (domain);
- g_hash_table_insert (domain_jit_info (domain)->delegate_trampoline_hash,
- klass, ptr);
+ g_hash_table_insert (domain_jit_info (domain)->delegate_trampoline_hash, dpair, ptr);
mono_domain_unlock (domain);
return ptr;
#endif
}
+gpointer
+mono_create_delegate_trampoline (MonoDomain *domain, MonoClass *klass)
+{
+ return mono_create_delegate_trampoline_with_method (domain, klass, NULL);
+}
+
gpointer
mono_create_rgctx_lazy_fetch_trampoline (guint32 offset)
{