goto exception_exit; \
} while (0)
#define GENERIC_SHARING_FAILURE do { \
- if (cfg->generic_shared) { \
+ if (cfg->generic_sharing_context) { \
/* g_print ("sharing failed for method %s.%s in %s:%d\n", method->klass->name, method->name, __FILE__, __LINE__); */ \
cfg->exception_type = MONO_EXCEPTION_GENERIC_SHARING_FAILED; \
goto exception_exit; \
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->ssa_op = MONO_SSA_LOAD; \
(dest)->inst_i0 = arg_array [(num)]; \
- (dest)->opcode = mono_type_to_ldind ((dest)->inst_i0->inst_vtype); \
- type_to_eval_stack_type (param_types [(num)], (dest)); \
+ (dest)->opcode = mini_type_to_ldind ((cfg), (dest)->inst_i0->inst_vtype); \
+ type_to_eval_stack_type ((cfg), param_types [(num)], (dest)); \
(dest)->klass = (dest)->inst_i0->klass; \
}} while (0)
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->ssa_op = MONO_SSA_LOAD; \
(dest)->inst_i0 = (cfg)->varinfo [locals_offset + (num)]; \
- (dest)->opcode = mono_type_to_ldind ((dest)->inst_i0->inst_vtype); \
- type_to_eval_stack_type (header->locals [(num)], (dest)); \
+ (dest)->opcode = mini_type_to_ldind ((cfg), (dest)->inst_i0->inst_vtype); \
+ type_to_eval_stack_type ((cfg), header->locals [(num)], (dest)); \
(dest)->klass = (dest)->inst_i0->klass; \
} while (0)
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->ssa_op = MONO_SSA_LOAD; \
(dest)->inst_i0 = (cfg)->varinfo [(num)]; \
- (dest)->opcode = mono_type_to_ldind ((dest)->inst_i0->inst_vtype); \
- type_to_eval_stack_type ((dest)->inst_i0->inst_vtype, (dest)); \
+ (dest)->opcode = mini_type_to_ldind ((cfg), (dest)->inst_i0->inst_vtype); \
+ type_to_eval_stack_type ((cfg), (dest)->inst_i0->inst_vtype, (dest)); \
(dest)->klass = (dest)->inst_i0->klass; \
} while (0)
#define NEW_INDLOAD(cfg,dest,addr,vtype) do { \
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->inst_left = addr; \
- (dest)->opcode = mono_type_to_ldind (vtype); \
- type_to_eval_stack_type (vtype, (dest)); \
+ (dest)->opcode = mini_type_to_ldind ((cfg), vtype); \
+ type_to_eval_stack_type ((cfg), vtype, (dest)); \
/* FIXME: (dest)->klass = (dest)->inst_i0->klass;*/ \
} while (0)
#define NEW_INDSTORE(cfg,dest,addr,value,vtype) do { \
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->inst_i0 = addr; \
- (dest)->opcode = mono_type_to_stind (vtype); \
+ (dest)->opcode = mini_type_to_stind ((cfg), vtype); \
(dest)->inst_i1 = (value); \
/* FIXME: (dest)->klass = (dest)->inst_i0->klass;*/ \
} while (0)
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
(dest)->ssa_op = MONO_SSA_STORE; \
(dest)->inst_i0 = (cfg)->varinfo [(num)]; \
- (dest)->opcode = mono_type_to_stind ((dest)->inst_i0->inst_vtype); \
+ (dest)->opcode = mini_type_to_stind ((cfg), (dest)->inst_i0->inst_vtype); \
(dest)->inst_i1 = (inst); \
(dest)->klass = (dest)->inst_i0->klass; \
} while (0)
#define NEW_LOCSTORE(cfg,dest,num,inst) do { \
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
- (dest)->opcode = mono_type_to_stind (header->locals [(num)]); \
+ (dest)->opcode = mini_type_to_stind ((cfg), header->locals [(num)]); \
(dest)->ssa_op = MONO_SSA_STORE; \
(dest)->inst_i0 = (cfg)->varinfo [locals_offset + (num)]; \
(dest)->inst_i1 = (inst); \
#define NEW_ARGSTORE(cfg,dest,num,inst) do { \
if (arg_array [(num)]->opcode == OP_ICONST) goto inline_failure; \
(dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
- (dest)->opcode = mono_type_to_stind (param_types [(num)]); \
+ (dest)->opcode = mini_type_to_stind ((cfg), param_types [(num)]); \
(dest)->ssa_op = MONO_SSA_STORE; \
(dest)->inst_i0 = arg_array [(num)]; \
(dest)->inst_i1 = (inst); \
* FIXME: return a MonoType/MonoClass for the byref and VALUETYPE cases.
*/
static void
-type_to_eval_stack_type (MonoType *type, MonoInst *inst)
+type_to_eval_stack_type (MonoCompile *cfg, MonoType *type, MonoInst *inst)
{
MonoClass *klass;
case MONO_TYPE_GENERICINST:
type = &type->data.generic_class->container_class->byval_arg;
goto handle_enum;
+ case MONO_TYPE_VAR :
+ case MONO_TYPE_MVAR :
+ /* FIXME: all the arguments must be references for now,
+ * later look inside cfg and see if the arg num is
+ * really a reference
+ */
+ g_assert (cfg->generic_sharing_context);
+ inst->type = STACK_OBJ;
+ return;
default:
g_error ("unknown type 0x%02x in eval stack type", type->type);
}
}
#endif
+static guint
+mini_type_to_ldind (MonoCompile* cfg, MonoType *type)
+{
+ if (cfg->generic_sharing_context && !type->byref) {
+ /* FIXME: all the arguments must be references for now,
+ * later look inside cfg and see if the arg num is
+ * really a reference
+ */
+ if (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR)
+ return CEE_LDIND_REF;
+ }
+ return mono_type_to_ldind (type);
+}
+
+static guint
+mini_type_to_stind (MonoCompile* cfg, MonoType *type)
+{
+ if (cfg->generic_sharing_context && !type->byref) {
+ /* FIXME: all the arguments must be references for now,
+ * later look inside cfg and see if the arg num is
+ * really a reference
+ */
+ if (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR)
+ return CEE_STIND_REF;
+ }
+ return mono_type_to_stind (type);
+}
+
/*
* When we need a pointer to the current domain many times in a method, we
* call mono_domain_get() once and we store the result in a local variable.
memset (dest, 0, sizeof (MonoInst));
dest->ssa_op = MONO_SSA_LOAD;
dest->inst_i0 = cfg->varinfo [var_index];
- dest->opcode = mono_type_to_ldind (dest->inst_i0->inst_vtype);
- type_to_eval_stack_type (dest->inst_i0->inst_vtype, dest);
+ dest->opcode = mini_type_to_ldind (cfg, dest->inst_i0->inst_vtype);
+ type_to_eval_stack_type (cfg, dest->inst_i0->inst_vtype, dest);
dest->klass = dest->inst_i0->klass;
}
/* FIXME: check type compatibility */
return 0;
}
+ case MONO_TYPE_VAR:
+ case MONO_TYPE_MVAR:
+ /* FIXME: all the arguments must be references for now,
+ * later look inside cfg and see if the arg num is
+ * really a reference
+ */
+ g_assert (cfg->generic_sharing_context);
+ if (arg->type != STACK_OBJ)
+ return 1;
+ return 0;
default:
g_error ("unknown type 0x%02x in target_type_is_incompatible", simple_type->type);
}
call->inst.opcode = CEE_CALL;
temp = mono_compile_create_var (cfg, &mono_defaults.string_class->byval_arg, OP_LOCAL);
} else {
- type_to_eval_stack_type (ret, ins);
+ type_to_eval_stack_type (cfg, ret, ins);
temp = mono_compile_create_var (cfg, ret, OP_LOCAL);
}
call->args = args;
call->signature = sig;
call = mono_arch_call_opcode (cfg, bblock, call, virtual);
- type_to_eval_stack_type (sig->ret, &call->inst);
+ type_to_eval_stack_type (cfg, sig->ret, &call->inst);
for (arg = call->out_args; arg;) {
MonoInst *narg = arg->next;
add->cil_code = ip;
add->klass = klass;
MONO_INST_NEW (cfg, vstore, CEE_STIND_I);
- vstore->opcode = mono_type_to_stind (&klass->byval_arg);
+ vstore->opcode = mini_type_to_stind (cfg, &klass->byval_arg);
vstore->cil_code = ip;
vstore->inst_left = add;
vstore->inst_right = val;
MonoInst *ldelem, *store, *load;
MonoClass *eklass = mono_class_from_mono_type (fsig->params [1]);
int n;
- n = mono_type_to_stind (&eklass->byval_arg);
+ n = mini_type_to_stind (cfg, &eklass->byval_arg);
if (n == CEE_STOBJ)
return NULL;
sp [0] = args [0];
NEW_LDELEMA (cfg, ldelem, sp, eklass);
ldelem->flags |= MONO_INST_NORANGECHECK;
MONO_INST_NEW (cfg, store, n);
- n = mono_type_to_ldind (&eklass->byval_arg);
- MONO_INST_NEW (cfg, load, mono_type_to_ldind (&eklass->byval_arg));
- type_to_eval_stack_type (&eklass->byval_arg, load);
+ MONO_INST_NEW (cfg, load, mini_type_to_ldind (cfg, &eklass->byval_arg));
+ type_to_eval_stack_type (cfg, &eklass->byval_arg, load);
load->inst_left = ldelem;
store->inst_left = args [2];
store->inst_right = load;
end = ip + header->code_size;
mono_jit_stats.cil_code_size += header->code_size;
- if (cfg->generic_shared) {
+ if (cfg->generic_sharing_context) {
g_assert (shared_context);
generic_context = shared_context;
} else if (sig->is_inflated)
if (!cmethod)
goto load_error;
- if (cfg->generic_shared && mono_method_check_context_used (cmethod, generic_context))
+ if (cfg->generic_sharing_context && mono_method_check_context_used (cmethod, generic_context))
GENERIC_SHARING_FAILURE;
if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
if (cmethod && cmethod->klass->generic_container)
UNVERIFIED;
- if (cfg->generic_shared && cmethod && mono_method_check_context_used (cmethod, generic_context))
+ if (cfg->generic_sharing_context && cmethod && mono_method_check_context_used (cmethod, generic_context))
GENERIC_SHARING_FAILURE;
CHECK_STACK (n);
* sp [0] is a pointer to the data: we need the value
* in handle_box (), so load it here.
*/
- MONO_INST_NEW (cfg, load, mono_type_to_ldind (&constrained_call->byval_arg));
- type_to_eval_stack_type (&constrained_call->byval_arg, load);
+ MONO_INST_NEW (cfg, load, mini_type_to_ldind (cfg, &constrained_call->byval_arg));
+ type_to_eval_stack_type (cfg, &constrained_call->byval_arg, load);
load->cil_code = ip;
load->inst_left = sp [0];
sp [0] = handle_box (cfg, bblock, load, ip, constrained_call);
if (MONO_TYPE_IS_VOID (fsig->ret)) {
MONO_ADD_INS (bblock, ins);
} else {
- type_to_eval_stack_type (fsig->ret, ins);
+ type_to_eval_stack_type (cfg, fsig->ret, ins);
*sp = ins;
sp++;
}
CHECK_STACK (1);
--sp;
MONO_INST_NEW (cfg, ins, OP_NOP);
- ins->opcode = mono_type_to_stind (mono_method_signature (method)->ret);
+ ins->opcode = mini_type_to_stind (cfg, mono_method_signature (method)->ret);
if (ins->opcode == CEE_STOBJ) {
NEW_RETLOADA (cfg, ins);
/* FIXME: it is possible some optimization will pass the a heap pointer for the struct address, so we'll need the write barrier */
if (!mono_class_init (cmethod->klass))
goto load_error;
- if (cfg->generic_shared && mono_method_check_context_used (cmethod, generic_context))
+ if (cfg->generic_sharing_context && mono_method_check_context_used (cmethod, generic_context))
GENERIC_SHARING_FAILURE;
if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
if (sp [0]->type != STACK_OBJ)
UNVERIFIED;
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
/* Needed by the code generated in inssel.brg */
klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) {
klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
if (mono_class_is_nullable (klass)) {
if (sp [0]->type != STACK_OBJ)
UNVERIFIED;
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
/* Needed by the code generated in inssel.brg */
mono_emit_method_call_spilled (cfg, bblock, stfld_wrapper, mono_method_signature (stfld_wrapper), iargs, ip, NULL);
}
#if HAVE_WRITE_BARRIERS
- } else if (mono_type_to_stind (field->type) == CEE_STIND_REF) {
+ } else if (mini_type_to_stind (cfg, field->type) == CEE_STIND_REF) {
/* insert call to write barrier */
MonoMethod *write_barrier = mono_marshal_get_write_barrier ();
MonoInst *iargs [2];
mono_emit_method_call_spilled (cfg, bblock, write_barrier, mono_method_signature (write_barrier), iargs, ip, NULL);
#endif
#ifdef MONO_ARCH_SOFT_FLOAT
- } else if (mono_type_to_stind (field->type) == CEE_STIND_R4) {
+ } else if (mini_type_to_stind (cfg, field->type) == CEE_STIND_R4) {
NEW_ICONST (cfg, offset_ins, foffset);
MONO_INST_NEW (cfg, ins, OP_PADD);
ins->cil_code = ip;
ins->inst_right = offset_ins;
ins->type = STACK_MP;
- MONO_INST_NEW (cfg, store, mono_type_to_stind (field->type));
+ MONO_INST_NEW (cfg, store, mini_type_to_stind (cfg, field->type));
store->cil_code = ip;
store->inst_left = ins;
store->inst_right = sp [1];
*sp++ = ins;
} else {
MonoInst *load;
- MONO_INST_NEW (cfg, load, mono_type_to_ldind (field->type));
- type_to_eval_stack_type (field->type, load);
+ MONO_INST_NEW (cfg, load, mini_type_to_ldind (cfg, field->type));
+ type_to_eval_stack_type (cfg, field->type, load);
load->cil_code = ip;
load->inst_left = ins;
load->flags |= ins_flag;
ins_flag = 0;
#ifdef MONO_ARCH_SOFT_FLOAT
- if (mono_type_to_ldind (field->type) == CEE_LDIND_R4) {
+ if (mini_type_to_ldind (cfg, field->type) == CEE_LDIND_R4) {
int temp;
temp = handle_load_float (cfg, bblock, ins, ip);
NEW_TEMPLOAD (cfg, *sp, temp);
if (!dont_verify && !cfg->skip_visibility && !mono_method_can_access_field (method, field))
FIELD_ACCESS_FAILURE;
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
g_assert (!(field->type->attrs & FIELD_ATTRIBUTE_LITERAL));
MonoInst *store;
CHECK_STACK (1);
sp--;
- MONO_INST_NEW (cfg, store, mono_type_to_stind (field->type));
+ MONO_INST_NEW (cfg, store, mini_type_to_stind (cfg, field->type));
store->cil_code = ip;
store->inst_left = ins;
store->inst_right = sp [0];
case MONO_TYPE_FNPTR:
case MONO_TYPE_ARRAY:
NEW_PCONST (cfg, *sp, *((gpointer *)addr));
- type_to_eval_stack_type (field->type, *sp);
+ type_to_eval_stack_type (cfg, field->type, *sp);
sp++;
break;
#endif
if (!is_const) {
MonoInst *load;
CHECK_STACK_OVF (1);
- MONO_INST_NEW (cfg, load, mono_type_to_ldind (field->type));
- type_to_eval_stack_type (field->type, load);
+ MONO_INST_NEW (cfg, load, mini_type_to_ldind (cfg, field->type));
+ type_to_eval_stack_type (cfg, field->type, load);
load->cil_code = ip;
load->inst_left = ins;
*sp++ = load;
token = read32 (ip + 1);
klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
- n = mono_type_to_stind (&klass->byval_arg);
+ n = mini_type_to_stind (cfg, &klass->byval_arg);
/* FIXME: handle CEE_STIND_R4 */
if (n == CEE_STOBJ) {
handle_stobj (cfg, bblock, sp [0], sp [1], ip, klass, FALSE, FALSE, TRUE);
klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) {
klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
- if (cfg->generic_shared)
+ if (cfg->generic_sharing_context)
context_used = mono_class_check_context_used (klass, generic_context);
else
context_used = 0;
UNVERIFIED;
CHECK_OPSIZE (5);
token = read32 (ip + 1);
- klass = mono_class_get_full (image, token, generic_context);
+ klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
mono_class_init (klass);
NEW_LDELEMA (cfg, load, sp, klass);
load->cil_code = ip;
- MONO_INST_NEW (cfg, ins, mono_type_to_ldind (&klass->byval_arg));
+ MONO_INST_NEW (cfg, ins, mini_type_to_ldind (cfg, &klass->byval_arg));
ins->cil_code = ip;
ins->inst_left = load;
*sp++ = ins;
- type_to_eval_stack_type (&klass->byval_arg, ins);
+ type_to_eval_stack_type (cfg, &klass->byval_arg, ins);
ip += 5;
break;
}
UNVERIFIED;
CHECK_OPSIZE (5);
token = read32 (ip + 1);
- klass = mono_class_get_full (image, token, generic_context);
+ klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
mono_class_init (klass);
if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) {
NEW_LDELEMA (cfg, load, sp, klass);
load->cil_code = ip;
- n = mono_type_to_stind (&klass->byval_arg);
+ n = mini_type_to_stind (cfg, &klass->byval_arg);
/* FIXME: CEE_STIND_R4 */
if (n == CEE_STOBJ)
handle_stobj (cfg, bblock, load, sp [2], ip, klass, FALSE, FALSE, TRUE);
mono_class_init (klass);
ins->cil_code = ip;
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
loc = mono_compile_create_var (cfg, &mono_defaults.typed_reference_class->byval_arg, OP_LOCAL);
}
else {
handle = mono_ldtoken (image, n, &handle_class, generic_context);
- if (cfg->generic_shared &&
+ if (cfg->generic_sharing_context &&
mono_class_check_context_used (handle_class, generic_context))
GENERIC_SHARING_FAILURE;
}
goto load_error;
mono_class_init (cmethod->klass);
- if (cfg->generic_shared && mono_method_check_context_used (cmethod, generic_context))
+ if (cfg->generic_sharing_context && mono_method_check_context_used (cmethod, generic_context))
GENERIC_SHARING_FAILURE;
cil_method = cmethod;
goto load_error;
mono_class_init (cmethod->klass);
- if (cfg->generic_shared && mono_method_check_context_used (cmethod, generic_context))
+ if (cfg->generic_sharing_context && mono_method_check_context_used (cmethod, generic_context))
GENERIC_SHARING_FAILURE;
if (mono_security_get_mode () == MONO_SECURITY_MODE_CAS) {
klass = mini_get_class (method, token, generic_context);
CHECK_TYPELOAD (klass);
- if (cfg->generic_shared && mono_class_check_context_used (klass, generic_context))
+ if (cfg->generic_sharing_context && mono_class_check_context_used (klass, generic_context))
GENERIC_SHARING_FAILURE;
if (MONO_TYPE_IS_REFERENCE (&klass->byval_arg)) {
cfg->verbose_level = mini_verbose;
cfg->compile_aot = compile_aot;
cfg->skip_visibility = method->skip_visibility;
- cfg->generic_shared = try_generic_shared;
+ if (try_generic_shared)
+ cfg->generic_sharing_context = (MonoGenericSharingContext*)&cfg->generic_sharing_context;
cfg->token_info_hash = g_hash_table_new (NULL, NULL);
if (!header) {
cfg->exception_type = MONO_EXCEPTION_INVALID_PROGRAM;
jinfo->used_regs = cfg->used_int_regs;
jinfo->domain_neutral = (cfg->opt & MONO_OPT_SHARED) != 0;
jinfo->cas_inited = FALSE; /* initialization delayed at the first stalk walk using this method */
- jinfo->generic_shared = cfg->generic_shared;
+ jinfo->generic_shared = cfg->generic_sharing_context ? 1 : 0;
if (header->num_clauses) {
int i;
mono_internal_hash_table_insert (&target_domain->jit_code_hash, method, cfg->jit_info);
code = cfg->native_code;
- if (cfg->generic_shared && mono_method_is_generic_sharable_impl (method)) {
+ if (cfg->generic_sharing_context && mono_method_is_generic_sharable_impl (method)) {
/* g_print ("inserting method %s.%s.%s\n", method->klass->name_space, method->klass->name, method->name); */
mono_domain_register_shared_generic (target_domain,
method_get_declaring_generic_method (method), cfg->jit_info);
return mono_get_addr_from_ftnptr (addr);
}
+#ifdef MONO_ARCH_HAVE_IMT
+static gpointer
+mini_get_imt_trampoline (void)
+{
+ static gpointer tramp = NULL;
+ if (!tramp)
+ tramp = mono_arch_create_specific_trampoline (MONO_FAKE_IMT_METHOD, MONO_TRAMPOLINE_GENERIC, mono_get_root_domain (), NULL);
+ return tramp;
+}
+#endif
+
+#ifdef MONO_ARCH_COMMON_VTABLE_TRAMPOLINE
+static gpointer
+mini_get_vtable_trampoline (void)
+{
+ static gpointer tramp = NULL;
+ if (!tramp)
+ tramp = mono_arch_create_specific_trampoline (MONO_FAKE_VTABLE_METHOD, MONO_TRAMPOLINE_GENERIC, mono_get_root_domain (), NULL);
+ return tramp;
+}
+#endif
+
static void
mini_parse_debug_options (void)
{
mono_install_get_class_from_name (mono_aot_get_class_from_name);
mono_install_jit_info_find_in_aot (mono_aot_find_jit_info);
-#ifdef MONO_ARCH_HAVE_IMT
- mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
-#endif
if (debug_options.collect_pagefault_stats) {
mono_raw_buffer_set_make_unreadable (TRUE);
mono_aot_set_make_unreadable (TRUE);
domain = mono_init_version (filename, runtime_version);
else
domain = mono_init_from_assembly (filename, filename);
+#ifdef MONO_ARCH_HAVE_IMT
+ mono_install_imt_thunk_builder (mono_arch_build_imt_thunk);
+ mono_install_imt_trampoline (mini_get_imt_trampoline ());
+#if MONO_ARCH_COMMON_VTABLE_TRAMPOLINE
+ mono_install_vtable_trampoline (mini_get_vtable_trampoline ());
+#endif
+#endif
mono_icall_init ();
mono_add_internal_call ("System.Diagnostics.StackFrame::get_frame_info",
g_print ("Locals stack size: %ld\n", mono_jit_stats.locals_stack_size);
g_print ("\nCreated object count: %ld\n", mono_stats.new_object_count);
+ g_print ("Delegates created: %ld\n", mono_stats.delegate_creations);
g_print ("Initialized classes: %ld\n", mono_stats.initialized_class_count);
g_print ("Used classes: %ld\n", mono_stats.used_class_count);
g_print ("Generic vtables: %ld\n", mono_stats.generic_vtable_count);