static gboolean
ji_is_gsharedvt (MonoJitInfo *ji)
{
if (ji && ji->has_generic_jit_info && (mono_jit_info_get_generic_sharing_context (ji)->var_is_vt ||
mono_jit_info_get_generic_sharing_context (ji)->mvar_is_vt))
return TRUE;
else
return FALSE;
}
void
mono_trace_enter_method (MonoMethod *method, char *ebp)
{
int i, j;
MonoClass *klass;
MonoObject *o;
MonoJitArgumentInfo *arg_info;
MonoMethodSignature *sig;
char *fname;
MonoGenericSharingContext *gsctx = NULL;
if (!trace_spec.enabled)
return;
while (output_lock != 0 || InterlockedCompareExchange (&output_lock, 1, 0) != 0)
mono_thread_info_yield ();
fname = mono_method_full_name (method, TRUE);
indent (1);
printf ("ENTER: %s(", fname);
g_free (fname);
if (!ebp) {
printf (") ip: %p\n", RETURN_ADDRESS_N (1));
goto unlock;
}
sig = mono_method_signature (method);
arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1));
if (method->is_inflated) {
/* FIXME: Might be better to pass the ji itself */
MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), RETURN_ADDRESS (), NULL);
if (ji) {
gsctx = mono_jit_info_get_generic_sharing_context (ji);
if (gsctx && gsctx->is_gsharedvt) {
/* Needs a ctx to get precise method */
printf (") <gsharedvt>\n");
goto unlock;
}
}
}
mono_arch_get_argument_info (sig, sig->param_count, arg_info);
if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret)) {
g_assert (!mono_method_signature (method)->ret->byref);
printf ("VALUERET:%p, ", *((gpointer *)(ebp + 8)));
}
if (mono_method_signature (method)->hasthis) {
gpointer *this = (gpointer *)(ebp + arg_info [0].offset);
if (method->klass->valuetype) {
printf ("value:%p, ", *arg_in_stack_slot(this, gpointer *));
} else {
/*
* mini_add_method_trampoline:
*
* Add static rgctx/gsharedvt_in trampoline 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.
*/
gpointer
mini_add_method_trampoline (MonoMethod *orig_method, MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp)
{
gpointer addr = compiled_method;
gboolean callee_gsharedvt, callee_array_helper;
MonoJitInfo *ji =
mini_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (compiled_method), NULL);
// FIXME: This loads information from AOT
callee_gsharedvt = ji_is_gsharedvt (ji);
callee_array_helper = FALSE;
if (m->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
WrapperInfo *info = mono_marshal_get_wrapper_info (m);
/*
* generic array helpers.
* Have to replace the wrappers with the original generic instances.
*/
if (info && info->subtype == WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER) {
callee_array_helper = TRUE;
m = info->d.generic_array_helper.method;
}
} else if (m->wrapper_type == MONO_WRAPPER_UNKNOWN) {
WrapperInfo *info = mono_marshal_get_wrapper_info (m);
/* Same for synchronized inner wrappers */
if (info && info->subtype == WRAPPER_SUBTYPE_SYNCHRONIZED_INNER) {
m = info->d.synchronized_inner.method;
}
}
if (!orig_method)
orig_method = m;
if (callee_gsharedvt)
g_assert (m->is_inflated);
addr = compiled_method;
if (callee_gsharedvt && mini_is_gsharedvt_variable_signature (mono_method_signature (ji->method))) {
MonoGenericSharingContext *gsctx;
MonoMethodSignature *sig, *gsig;
/* Here m is a generic instance, while ji->method is the gsharedvt method implementing it */
/* Call from normal/gshared code to gsharedvt code with variable signature */
gsctx = mono_jit_info_get_generic_sharing_context (ji);
sig = mono_method_signature (m);
gsig = mono_method_signature (ji->method);
addr = mini_get_gsharedvt_wrapper (TRUE, compiled_method, sig, gsig, gsctx, -1, FALSE);
//printf ("IN: %s\n", mono_method_full_name (m, TRUE));
}
if (add_static_rgctx_tramp && !callee_array_helper)
addr = mono_create_static_rgctx_trampoline (m, addr);
return addr;
}
