#define is_complex_isinst(klass) ((klass->flags & TYPE_ATTRIBUTE_INTERFACE) || klass->rank || mono_class_is_nullable (klass) || mono_class_is_marshalbyref (klass) || (klass->flags & TYPE_ATTRIBUTE_SEALED) || klass->byval_arg.type == MONO_TYPE_VAR || klass->byval_arg.type == MONO_TYPE_MVAR)
+static MonoInst*
+emit_isinst_with_cache (MonoCompile *cfg, MonoClass *klass, MonoInst **args)
+{
+ MonoMethod *mono_isinst = mono_marshal_get_isinst_with_cache ();
+ return mono_emit_method_call (cfg, mono_isinst, args, NULL);
+}
+
static MonoInst*
emit_castclass_with_cache (MonoCompile *cfg, MonoClass *klass, MonoInst **args)
{
- MonoMethod *mono_castclass;
+ MonoMethod *mono_castclass = mono_marshal_get_castclass_with_cache ();
MonoInst *res;
- mono_castclass = mono_marshal_get_castclass_with_cache ();
-
save_cast_details (cfg, klass, args [0]->dreg, TRUE);
res = mono_emit_method_call (cfg, mono_castclass, args, NULL);
reset_cast_details (cfg);
return (cfg->method_index << 16) | cfg->castclass_cache_index;
}
+
+static MonoInst*
+emit_isinst_with_cache_nonshared (MonoCompile *cfg, MonoInst *obj, MonoClass *klass)
+{
+ MonoInst *args [3];
+ int idx;
+
+ args [0] = obj; /* obj */
+ EMIT_NEW_CLASSCONST (cfg, args [1], klass); /* klass */
+
+ idx = get_castclass_cache_idx (cfg); /* inline cache*/
+ args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
+
+ return emit_isinst_with_cache (cfg, klass, args);
+}
+
static MonoInst*
emit_castclass_with_cache_nonshared (MonoCompile *cfg, MonoInst *obj, MonoClass *klass)
{
* Returns NULL and set the cfg exception on error.
*/
static MonoInst*
-handle_castclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src, guint8 *ip, int *inline_costs)
+handle_castclass (MonoCompile *cfg, MonoClass *klass, MonoInst *src, int context_used)
{
MonoBasicBlock *is_null_bb;
int obj_reg = src->dreg;
int vtable_reg = alloc_preg (cfg);
- int context_used;
- MonoInst *klass_inst = NULL, *res;
+ MonoInst *klass_inst = NULL;
if (src->opcode == OP_PCONST && src->inst_p0 == 0)
return src;
- context_used = mini_class_check_context_used (cfg, klass);
-
- if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
- res = emit_castclass_with_cache_nonshared (cfg, src, klass);
- (*inline_costs) += 2;
- return res;
- } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
- MonoMethod *mono_castclass;
- MonoInst *iargs [1];
- int costs;
-
- mono_castclass = mono_marshal_get_castclass (klass);
- iargs [0] = src;
-
- save_cast_details (cfg, klass, src->dreg, TRUE);
- costs = inline_method (cfg, mono_castclass, mono_method_signature (mono_castclass),
- iargs, ip, cfg->real_offset, TRUE);
- reset_cast_details (cfg);
- CHECK_CFG_EXCEPTION;
- g_assert (costs > 0);
-
- cfg->real_offset += 5;
-
- (*inline_costs) += costs;
-
- return src;
- }
-
if (context_used) {
MonoInst *args [3];
reset_cast_details (cfg);
return src;
-
-exception_exit:
- return NULL;
}
/*
MonoInst *args [3];
if(mini_class_has_reference_variant_generic_argument (cfg, klass, context_used) || is_complex_isinst (klass)) {
- MonoMethod *mono_isinst = mono_marshal_get_isinst_with_cache ();
- MonoInst *cache_ins;
+ MonoInst *cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
- cache_ins = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_CAST_CACHE);
-
- /* obj */
- args [0] = src;
+ args [0] = src; /* obj */
/* klass - it's the second element of the cache entry*/
EMIT_NEW_LOAD_MEMBASE (cfg, args [1], OP_LOAD_MEMBASE, alloc_preg (cfg), cache_ins->dreg, sizeof (gpointer));
- /* cache */
- args [2] = cache_ins;
-
- return mono_emit_method_call (cfg, mono_isinst, args, NULL);
+ args [2] = cache_ins; /* cache */
+ return emit_isinst_with_cache (cfg, klass, args);
}
klass_inst = emit_get_rgctx_klass (cfg, context_used, klass, MONO_RGCTX_INFO_KLASS);
break;
}
case CEE_CASTCLASS:
- CHECK_STACK (1);
- --sp;
- CHECK_OPSIZE (5);
- token = read32 (ip + 1);
- klass = mini_get_class (method, token, generic_context);
- CHECK_TYPELOAD (klass);
- if (sp [0]->type != STACK_OBJ)
- UNVERIFIED;
-
- ins = handle_castclass (cfg, klass, *sp, ip, &inline_costs);
- CHECK_CFG_EXCEPTION;
-
- *sp ++ = ins;
- ip += 5;
- break;
case CEE_ISINST: {
CHECK_STACK (1);
--sp;
CHECK_TYPELOAD (klass);
if (sp [0]->type != STACK_OBJ)
UNVERIFIED;
-
- context_used = mini_class_check_context_used (cfg, klass);
-
- if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
- MonoMethod *mono_isinst = mono_marshal_get_isinst_with_cache ();
- MonoInst *args [3];
- int idx;
-
- /* obj */
- args [0] = *sp;
-
- /* klass */
- EMIT_NEW_CLASSCONST (cfg, args [1], klass);
-
- /* inline cache*/
- idx = get_castclass_cache_idx (cfg);
- args [2] = emit_runtime_constant (cfg, MONO_PATCH_INFO_CASTCLASS_CACHE, GINT_TO_POINTER (idx));
-
- *sp++ = mono_emit_method_call (cfg, mono_isinst, args, NULL);
- ip += 5;
- inline_costs += 2;
- } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
- MonoMethod *mono_isinst;
- MonoInst *iargs [1];
- int costs;
-
- mono_isinst = mono_marshal_get_isinst (klass);
- iargs [0] = sp [0];
- costs = inline_method (cfg, mono_isinst, mono_method_signature (mono_isinst),
- iargs, ip, cfg->real_offset, TRUE);
- CHECK_CFG_EXCEPTION;
- g_assert (costs > 0);
-
- ip += 5;
- cfg->real_offset += 5;
+ MONO_INST_NEW (cfg, ins, *ip == CEE_ISINST ? OP_ISINST : OP_CASTCLASS);
+ ins->dreg = alloc_preg (cfg);
+ ins->sreg1 = (*sp)->dreg;
+ ins->klass = klass;
+ ins->type = STACK_OBJ;
+ MONO_ADD_INS (cfg->cbb, ins);
- *sp++= iargs [0];
+ CHECK_CFG_EXCEPTION;
+ *sp++ = ins;
+ ip += 5;
- inline_costs += costs;
- }
- else {
- ins = handle_isinst (cfg, klass, *sp, context_used);
- CHECK_CFG_EXCEPTION;
- *sp ++ = ins;
- ip += 5;
- }
+ cfg->flags |= MONO_CFG_HAS_TYPE_CHECK;
break;
}
case CEE_UNBOX_ANY: {
res = handle_unbox_gsharedvt (cfg, klass, *sp);
inline_costs += 2;
} else if (generic_class_is_reference_type (cfg, klass)) {
- res = handle_castclass (cfg, klass, *sp, ip, &inline_costs);
- CHECK_CFG_EXCEPTION;
+ MONO_INST_NEW (cfg, res, OP_CASTCLASS);
+ res->dreg = alloc_preg (cfg);
+ res->sreg1 = (*sp)->dreg;
+ res->klass = klass;
+ res->type = STACK_OBJ;
+ MONO_ADD_INS (cfg->cbb, res);
+ cfg->flags |= MONO_CFG_HAS_TYPE_CHECK;
} else if (mono_class_is_nullable (klass)) {
res = handle_unbox_nullable (cfg, *sp, klass, context_used);
} else {
g_free (live_range_end_bb);
}
+static void mono_decompose_typecheck (MonoCompile *cfg, MonoBasicBlock *bb, MonoInst *ins)
+{
+ MonoInst *ret, *move, *source;
+ MonoClass *klass = ins->klass;
+ int context_used = mini_class_check_context_used (cfg, klass);
+ int is_isinst = ins->opcode == OP_ISINST;
+ g_assert (is_isinst || ins->opcode == OP_CASTCLASS);
+ source = get_vreg_to_inst (cfg, ins->sreg1);
+ if (!source || source == (MonoInst *) -1)
+ source = mono_compile_create_var_for_vreg (cfg, &mono_defaults.object_class->byval_arg, OP_LOCAL, ins->sreg1);
+ g_assert (source && source != (MonoInst *) -1);
+
+ MonoBasicBlock *first_bb;
+ NEW_BBLOCK (cfg, first_bb);
+ cfg->cbb = first_bb;
+
+ if (!context_used && mini_class_has_reference_variant_generic_argument (cfg, klass, context_used)) {
+ if (is_isinst)
+ ret = emit_isinst_with_cache_nonshared (cfg, source, klass);
+ else
+ ret = emit_castclass_with_cache_nonshared (cfg, source, klass);
+ } else if (!context_used && (mono_class_is_marshalbyref (klass) || klass->flags & TYPE_ATTRIBUTE_INTERFACE)) {
+ MonoInst *iargs [1];
+ int costs;
+
+ iargs [0] = source;
+ if (is_isinst) {
+ MonoMethod *wrapper = mono_marshal_get_isinst (klass);
+ costs = inline_method (cfg, wrapper, mono_method_signature (wrapper), iargs, 0, 0, TRUE);
+ } else {
+ MonoMethod *wrapper = mono_marshal_get_castclass (klass);
+ save_cast_details (cfg, klass, source->dreg, TRUE);
+ costs = inline_method (cfg, wrapper, mono_method_signature (wrapper), iargs, 0, 0, TRUE);
+ reset_cast_details (cfg);
+ }
+ g_assert (costs > 0);
+ ret = iargs [0];
+ } else {
+ if (is_isinst)
+ ret = handle_isinst (cfg, klass, source, context_used);
+ else
+ ret = handle_castclass (cfg, klass, source, context_used);
+ }
+ EMIT_NEW_UNALU (cfg, move, OP_MOVE, ins->dreg, ret->dreg);
+
+ g_assert (cfg->cbb->code || first_bb->code);
+ MonoInst *prev = ins->prev;
+ mono_replace_ins (cfg, bb, ins, &prev, first_bb, cfg->cbb);
+}
+
+void mono_decompose_typechecks (MonoCompile *cfg)
+{
+ for (MonoBasicBlock *bb = cfg->bb_entry; bb; bb = bb->next_bb) {
+ MonoInst *c;
+ MONO_BB_FOR_EACH_INS (bb, c) {
+ switch (c->opcode) {
+ case OP_ISINST:
+ case OP_CASTCLASS:
+ mono_decompose_typecheck (cfg, bb, c);
+ break;
+ }
+ }
+ }
+}
+
+
/**
* FIXME:
* - use 'iadd' instead of 'int_add'