[Mono-dev] Patch review request -- generic changes to support MIPS conditional exceptions
mason
mason at broadcom.com
Mon Jan 15 16:02:01 EST 2007
Hello,
On Fri, Jan 12, 2007 at 03:44:15PM +0100, Paolo Molaro wrote:
> On 01/11/07 mason wrote:
> > Index: mono/mini/inssel.brg
> > ===================================================================
> > --- mono/mini/inssel.brg (revision 70746)
> > +++ mono/mini/inssel.brg (working copy)
> > @@ -278,8 +278,7 @@
> > if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \
> > int _length_reg = mono_regstate_next_int (cfg->rs); \
> > MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \
> > - MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, _length_reg, index_reg); \
> > - MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException"); \
> > + MONO_EMIT_NEW_COMPARE_EXC (cfe, LE_UN, _length_reg, index_reg, "IndexOutOfRangeException"); \
>
> There is a typo here: cfe -> cfg.
Sigh - finger macro. 'cfe' is the name of our firmware -- I type it a
lot.
> > +#ifndef MONO_EMIT_NEW_COMPARE_IMM_EXC
> > +#define MONO_EMIT_NEW_COMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \
> > + MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE, -1, sreg1, imm); \
>
> It should be OP_COMPARE_IMM.
Fixed. Is does bring up a pet peeve that regs are simply #defines of
integers - so there's no compile-time type checking to catch this sort
of thing. I've been bitten by this bug (mismatch of _IMM) a couple of
times.
> So this patch can't go in. Let me know if you want me to test compile a
> fixed patch.
Please do - attached is a fixed copy of the inssel.brg patch.
Thanks,
Mark
Index: inssel.brg
===================================================================
--- inssel.brg (revision 70746)
+++ inssel.brg (working copy)
@@ -278,8 +278,7 @@
if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \
int _length_reg = mono_regstate_next_int (cfg->rs); \
MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \
- MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, _length_reg, index_reg); \
- MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException"); \
+ MONO_EMIT_NEW_COMPARE_EXC (cfg, LE_UN, _length_reg, index_reg, "IndexOutOfRangeException"); \
} \
} while (0)
@@ -287,11 +286,31 @@
if (! (state->tree->flags & MONO_INST_NORANGECHECK)) { \
int _length_reg = mono_regstate_next_int (cfg->rs); \
MONO_EMIT_NEW_LOAD_MEMBASE_OP (cfg, OP_LOADI4_MEMBASE, _length_reg, array_reg, G_STRUCT_OFFSET (array_type, array_length_field)); \
- MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, _length_reg, index_imm); \
- MONO_EMIT_NEW_COND_EXC (cfg, LE_UN, "IndexOutOfRangeException"); \
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (cfg, LE_UN, _length_reg, index_imm, "IndexOutOfRangeException"); \
} \
} while (0)
+#ifndef MONO_EMIT_NEW_COMPARE_EXC
+#define MONO_EMIT_NEW_COMPARE_EXC(cfg, cmp_op, sreg1, sreg2, exc) do { \
+ MONO_EMIT_NEW_BIALU (cfg, OP_COMPARE, -1, sreg1, sreg2); \
+ MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \
+ } while (0)
+#endif
+
+#ifndef MONO_EMIT_NEW_COMPARE_IMM_EXC
+#define MONO_EMIT_NEW_COMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \
+ MONO_EMIT_NEW_BIALU_IMM (cfg, OP_COMPARE_IMM, -1, sreg1, imm); \
+ MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \
+ } while (0)
+#endif
+
+#ifndef MONO_EMIT_NEW_ICOMPARE_IMM_EXC
+#define MONO_EMIT_NEW_ICOMPARE_IMM_EXC(cfg, cmp_op, sreg1, imm, exc) do { \
+ MONO_EMIT_NEW_ICOMPARE_IMM(cfg, sreg1, imm); \
+ MONO_EMIT_NEW_COND_EXC (cfg, cmp_op, exc); \
+ } while (0)
+#endif
+
#ifndef MONO_EMIT_NEW_COMPARE_BRANCH_LABEL
#define MONO_EMIT_NEW_COMPARE_BRANCH_LABEL(cfg, cmp_op, sreg1, sreg2, label) \
do { \
@@ -629,16 +648,14 @@
MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx1_reg, index1, low1_reg);
MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high1_reg,
bounds_reg, G_STRUCT_OFFSET (MonoArrayBounds, length));
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, high1_reg, realidx1_reg);
- MONO_EMIT_NEW_COND_EXC (s, LE_UN, "IndexOutOfRangeException");
+ MONO_EMIT_NEW_COMPARE_EXC (s, LE_UN, high1_reg, realidx1_reg, "IndexOutOfRangeException");
MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, low2_reg,
bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, lower_bound));
MONO_EMIT_NEW_BIALU (s, CEE_SUB, realidx2_reg, index2, low2_reg);
MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, high2_reg,
bounds_reg, sizeof (MonoArrayBounds) + G_STRUCT_OFFSET (MonoArrayBounds, length));
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, high2_reg, realidx2_reg);
- MONO_EMIT_NEW_COND_EXC (s, LE_UN, "IndexOutOfRangeException");
+ MONO_EMIT_NEW_COMPARE_EXC (s, LE_UN, high2_reg, realidx2_reg, "IndexOutOfRangeException");
MONO_EMIT_NEW_BIALU (s, CEE_MUL, mult_reg, high2_reg, realidx1_reg);
MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, mult_reg, realidx2_reg);
@@ -683,56 +700,47 @@
if (sizeof (void *) == 8) {
MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
} else {
- MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0);
- MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT, state->left->reg1, 0, "OverflowException");
MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
}
}
reg: CEE_CONV_OVF_I1 (reg) {
- MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 127);
- MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
- MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, -128);
- MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
+ MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT, state->left->reg1, 127, "OverflowException");
+ MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, LT, state->left->reg1, -128, "OverflowException");
MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
}
reg: CEE_CONV_OVF_I1_UN (reg) {
/* probe values between 0 to 127 */
- MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 127);
- MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
+ MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 127, "OverflowException");
MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
}
reg: CEE_CONV_OVF_U1 (reg),
reg: CEE_CONV_OVF_U1_UN (reg) {
/* probe value to be within 0 to 255 */
- MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 255);
- MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 255, "OverflowException");
MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff);
}
reg: CEE_CONV_OVF_I2 (reg) {
/* Probe value to be within -32768 and 32767 */
- MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 32767);
- MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
- MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, -32768);
- MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
+ MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT, state->left->reg1, 32767, "OverflowException");
+ MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, LT, state->left->reg1, -32768, "OverflowException");
MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
}
reg: CEE_CONV_OVF_I2_UN (reg) {
/* Convert uint value into short, value within 0 and 32767 */
- MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 32767);
- MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
+ MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 32767, "OverflowException");
MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
}
reg: CEE_CONV_OVF_U2 (reg),
reg: CEE_CONV_OVF_U2_UN (reg) {
/* Probe value to be within 0 and 65535 */
- MONO_EMIT_NEW_ICOMPARE_IMM (s, state->left->reg1, 0xffff);
- MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
+ MONO_EMIT_NEW_ICOMPARE_IMM_EXC (s, GT_UN, state->left->reg1, 0xffff, "OverflowException");
MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff);
}
@@ -1208,8 +1216,7 @@
g_assert (klass->rank == 0);
// Check rank == 0
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, 0);
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, rank_reg, 0, "InvalidCastException");
MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, element_class));
@@ -1217,12 +1224,11 @@
if (s->compile_aot) {
int const_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass->element_class);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, klass->element_class);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, klass->element_class, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, obj_reg);
}
@@ -1249,8 +1255,7 @@
int eclass_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU1_MEMBASE, rank_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, rank));
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, rank_reg, klass->rank);
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, rank_reg, klass->rank, "InvalidCastException");
MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
if (klass->cast_class == mono_defaults.object_class) {
@@ -1267,11 +1272,10 @@
}
if (s->compile_aot) {
MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
} else if (klass->cast_class == mono_defaults.enum_class->parent) {
int const_reg = mono_regstate_next_int (s->rs);
if (s->compile_aot) {
@@ -1283,20 +1287,18 @@
}
if (s->compile_aot) {
MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
} else if (klass->cast_class == mono_defaults.enum_class) {
if (s->compile_aot) {
int const_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_CLASSCONST (s, const_reg, mono_defaults.enum_class);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, eclass_reg, const_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, eclass_reg, const_reg, "InvalidCastException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, eclass_reg, mono_defaults.enum_class);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, eclass_reg, mono_defaults.enum_class, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
} else if (klass->cast_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
mini_emit_castclass_iface_class (s, eclass_reg, klass->cast_class);
} else {
@@ -1307,20 +1309,18 @@
/* Check that the object is a vector too */
int bounds_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_LOAD_MEMBASE (s, bounds_reg, obj_reg, G_STRUCT_OFFSET (MonoArray, bounds));
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, bounds_reg, 0);
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, bounds_reg, 0, "InvalidCastException");
}
} else {
if (!s->compile_aot && !(s->opt & MONO_OPT_SHARED) && (klass->flags & TYPE_ATTRIBUTE_SEALED)) {
/* the remoting code is broken, access the class for now */
if (0) {
MonoVTable *vt = mono_class_vtable (s->domain, klass);
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, vt);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, vtable_reg, vt, "InvalidCastException");
} else {
MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, klass);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, klass, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
} else {
MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, vtable_reg, G_STRUCT_OFFSET (MonoVTable, klass));
mini_emit_castclass (s, klass_reg, klass);
@@ -1362,19 +1362,17 @@
if (s->compile_aot) {
int tproxy_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_CLASSCONST (s, tproxy_reg, mono_defaults.transparent_proxy_class);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, tproxy_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, klass_reg, tproxy_reg, "InvalidCastException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, mono_defaults.transparent_proxy_class);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, mono_defaults.transparent_proxy_class, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, remote_class));
MONO_EMIT_NEW_LOAD_MEMBASE (s, klass_reg, tmp_reg, G_STRUCT_OFFSET (MonoRemoteClass, proxy_class));
MONO_EMIT_NEW_LOAD_MEMBASE (s, tmp_reg, obj_reg, G_STRUCT_OFFSET (MonoTransparentProxy, custom_type_info));
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, tmp_reg, 0);
- MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, tmp_reg, 0, "InvalidCastException");
MONO_EMIT_NEW_ICONST (s, state->reg1, 1);
MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, end_label);
@@ -1520,21 +1518,20 @@
if (s->compile_aot) {
int klass_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_CLASSCONST (s, klass_reg, array_class);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, class_reg, klass_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, class_reg, klass_reg, "ArrayTypeMismatchException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, class_reg, array_class);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, class_reg, array_class, "ArrayTypeMismatchException");
}
} else {
if (s->compile_aot) {
int vt_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_VTABLECONST (s, vt_reg, mono_class_vtable (s->domain, array_class));
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, vtable_reg, vt_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, vtable_reg, vt_reg, "ArrayTypeMismatchException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, vtable_reg, mono_class_vtable (s->domain, array_class));
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, vtable_reg, mono_class_vtable (s->domain, array_class), "ArrayTypeMismatchException");
}
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "ArrayTypeMismatchException");
MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
}
@@ -1564,11 +1561,10 @@
if (s->compile_aot) {
int const_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_CLASSCONST (s, const_reg, tree->inst_newa_class);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, klass_reg, const_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, klass_reg, const_reg, "InvalidCastException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, klass_reg, tree->inst_newa_class);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, klass_reg, tree->inst_newa_class, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
MONO_EMIT_NEW_LOAD_MEMBASE (s, state->reg1, state->left->reg1, G_STRUCT_OFFSET (MonoTypedRef, value));
}
@@ -1612,15 +1608,13 @@
if (false_target)
MONO_EMIT_NEW_COMPARE_BRANCH_LABEL (s, CEE_BLT_UN, max_iid_reg, iid_reg, false_target);
else
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, max_iid_reg, iid_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, LT_UN, max_iid_reg, iid_reg, "InvalidCastException");
} else {
if (false_target)
MONO_EMIT_NEW_COMPARE_IMM_BRANCH_LABEL (s, CEE_BLT_UN, max_iid_reg, klass->interface_id, false_target);
else
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, max_iid_reg, klass->interface_id);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT_UN, max_iid_reg, klass->interface_id, "InvalidCastException");
}
- if (!false_target)
- MONO_EMIT_NEW_COND_EXC (s, LT_UN, "InvalidCastException");
}
/* Same as above, but obtains max_iid from a vtable */
@@ -1790,19 +1784,17 @@
if (klass->idepth > MONO_DEFAULT_SUPERTABLE_SIZE) {
MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADU2_MEMBASE, idepth_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, idepth));
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, idepth_reg, klass->idepth);
- MONO_EMIT_NEW_COND_EXC (s, LT_UN, "InvalidCastException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, LT_UN, idepth_reg, klass->idepth, "InvalidCastException");
}
MONO_EMIT_NEW_LOAD_MEMBASE (s, stypes_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, supertypes));
MONO_EMIT_NEW_LOAD_MEMBASE (s, stype, stypes_reg, ((klass->idepth - 1) * SIZEOF_VOID_P));
if (s->compile_aot) {
int const_reg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_CLASSCONST (s, const_reg, klass);
- MONO_EMIT_NEW_BIALU (s, OP_COMPARE, -1, stype, const_reg);
+ MONO_EMIT_NEW_COMPARE_EXC (s, NE_UN, stype, const_reg, "InvalidCastException");
} else {
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, stype, klass);
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, NE_UN, stype, klass, "InvalidCastException");
}
- MONO_EMIT_NEW_COND_EXC (s, NE_UN, "InvalidCastException");
}
static void
@@ -1812,8 +1804,7 @@
mini_emit_max_iid_check_vtable (s, vtable_reg, klass, NULL);
mini_emit_load_intf_reg_vtable (s, intf_reg, vtable_reg, klass);
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, 0);
- MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, intf_reg, 0, "InvalidCastException");
}
/*
@@ -1827,8 +1818,7 @@
mini_emit_max_iid_check_class (s, klass_reg, klass, NULL);
mini_emit_load_intf_reg_class (s, intf_reg, klass_reg, klass);
- MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, intf_reg, -1);
- MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException");
+ MONO_EMIT_NEW_COMPARE_IMM_EXC (s, EQ, intf_reg, -1, "InvalidCastException");
}
static void
More information about the Mono-devel-list
mailing list