+#define MONO_EMIT_NEW_LOAD_R8(cfg,dr,addr) do { \
+ MonoInst *inst; \
+ inst = mono_mempool_alloc0 ((cfg)->mempool, sizeof (MonoInst)); \
+ inst->opcode = OP_R8CONST; \
+ inst->dreg = dr; \
+ inst->inst_p0 = addr; \
+ mono_bblock_add_inst (cfg->cbb, inst); \
+ } while (0)
+
%%
#
mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_ENDFINALLY {
+stmt: OP_ENDFINALLY {
MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
tree->inst_left = spvar;
mono_bblock_add_inst (s->cbb, tree);
mono_bblock_add_inst (s->cbb, tree);
}
+reg: CEE_REM_UN (reg, reg),
+reg: CEE_REM (reg, reg) "0" {
+ int div_result = mono_regstate_next_int (s->rs);
+ int mul_result = mono_regstate_next_int (s->rs);
+ MONO_EMIT_NEW_BIALU (s, (tree->opcode == CEE_REM_UN?CEE_DIV_UN:CEE_DIV), div_result, state->left->reg1, state->right->reg1);
+ MONO_EMIT_NEW_BIALU (s, CEE_MUL, mul_result, div_result, state->right->reg1);
+ MONO_EMIT_NEW_BIALU (s, CEE_SUB, state->reg1, state->left->reg1, mul_result);
+}
+
+freg: OP_CKFINITE (freg) "0" {
+ int msw_reg = mono_regstate_next_int (s->rs);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ppc_sp, -8, state->left->reg1);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, msw_reg, ppc_sp, -8);
+ MONO_EMIT_NEW_UNALU (s, OP_CHECK_FINITE, -1, msw_reg);
+ MONO_EMIT_NEW_UNALU (s, OP_FMOVE, state->reg1, state->left->reg1);
+}
+
+lreg: OP_LADD_OVF (lreg, lreg) "0" {
+ /* ADC sets the condition code */
+ MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
+ MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
+lreg: OP_LADD_OVF_UN (lreg, lreg) "0" {
+ /* ADC sets the condition code */
+ MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
+ MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
+lreg: OP_LSUB_OVF (lreg, lreg) "0" {
+ /* SBB sets the condition code */
+ MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
+ MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
+lreg: OP_LSUB_OVF_UN (lreg, lreg) "0" {
+ /* SBB sets the condition code */
+ MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
+ MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
stmt: CEE_STIND_I8 (OP_REGVAR, lreg) {
/* this should only happen for methods returning a long */
MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r3, state->right->reg1);
}
freg: OP_LCONV_TO_R8 (lreg) {
+ tree->dreg = state->reg1;
+ tree->sreg1 = state->left->reg1;
+ tree->sreg2 = state->left->reg2;
mono_bblock_add_inst (s->cbb, tree);
}
freg: OP_LCONV_TO_R4 (lreg) {
+ tree->dreg = state->reg1;
+ tree->sreg1 = state->left->reg1;
+ tree->sreg2 = state->left->reg2;
mono_bblock_add_inst (s->cbb, tree);
}
-freg: CEE_CONV_R_UN (reg) {
- mono_bblock_add_inst (s->cbb, tree);
+freg: CEE_CONV_R_UN (reg) "1" {
+ static const guint64 adjust_val = 0x4330000000000000ULL;
+ int msw_reg = mono_regstate_next_int (s->rs);
+ int adj_reg = mono_regstate_next_float (s->rs);
+ int tmp_reg = mono_regstate_next_float (s->rs);
+ MONO_EMIT_NEW_ICONST (s, msw_reg, 0x43300000);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -8, msw_reg);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -4, state->left->reg1);
+ MONO_EMIT_NEW_LOAD_R8 (s, adj_reg, &adjust_val);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR8_MEMBASE, tmp_reg, ppc_sp, -8);
+ MONO_EMIT_BIALU (s, tree, OP_FSUB, state->reg1, tmp_reg, adj_reg);
+}
+
+freg: CEE_CONV_R8 (reg),
+freg: CEE_CONV_R4 (reg) "1" {
+ /* FIXME: change precision for CEE_CONV_R4 */
+ static const guint64 adjust_val = 0x4330000080000000ULL;
+ int msw_reg = mono_regstate_next_int (s->rs);
+ int xored = mono_regstate_next_int (s->rs);
+ int adj_reg = mono_regstate_next_float (s->rs);
+ int tmp_reg = mono_regstate_next_float (s->rs);
+ MONO_EMIT_NEW_ICONST (s, msw_reg, 0x43300000);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -8, msw_reg);
+ MONO_EMIT_NEW_BIALU_IMM (s, OP_XOR_IMM, xored, state->left->reg1, 0x80000000);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -4, xored);
+ MONO_EMIT_NEW_LOAD_R8 (s, adj_reg, &adjust_val);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR8_MEMBASE, tmp_reg, ppc_sp, -8);
+ MONO_EMIT_BIALU (s, tree, OP_FSUB, state->reg1, tmp_reg, adj_reg);
}
reg: OP_LOCALLOC (OP_ICONST) {
/* microcoded in mini-ppc.c */
tree->sreg1 = mono_regstate_next_int (s->rs);
+ tree->dreg = state->reg1;
MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
mono_bblock_add_inst (s->cbb, tree);
}
reg: OP_LOCALLOC (reg) {
+ tree->dreg = state->reg1;
+ tree->sreg1 = state->left->reg1;
mono_bblock_add_inst (s->cbb, tree);
}
tree->opcode = OP_SETLRET;
tree->sreg1 = state->left->reg1;
tree->sreg2 = state->left->reg2;
+ tree->dreg = ppc_r3;
mono_bblock_add_inst (s->cbb, tree);
}
mono_bblock_add_inst (s->cbb, tree);
}
+stmt: CEE_STIND_I (OP_REGVAR, CEE_SUB (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
+stmt: CEE_STIND_I4 (OP_REGVAR, CEE_SUB (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)),
+stmt: CEE_STIND_I (OP_REGVAR, CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
+stmt: CEE_STIND_I4 (OP_REGVAR, CEE_ADD (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)) {
+ int con = state->right->right->tree->inst_c0;
+ int dreg = state->left->tree->dreg;
+ int sreg = state->right->left->left->tree->dreg;
+
+ if (state->right->op == CEE_ADD)
+ tree->opcode = OP_ADD_IMM;
+ else if (state->right->op == CEE_SUB)
+ tree->opcode = OP_SUB_IMM;
+ else
+ g_assert_not_reached ();
+ tree->inst_imm = con;
+ tree->sreg1 = sreg;
+ tree->dreg = dreg;
+ mono_bblock_add_inst (s->cbb, tree);
+}
+
+stmt: OP_OUTARG_MEMBASE (reg) {
+ MonoPPCArgInfo *ai = tree->backend.data;
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg1);
+}
+
+stmt: OP_OUTARG_MEMBASE (OP_REGVAR) {
+ MonoPPCArgInfo *ai = tree->backend.data;
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->tree->dreg);
+}
+
+stmt: OP_OUTARG_MEMBASE (lreg) {
+ MonoPPCArgInfo *ai = tree->backend.data;
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg2);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset + 4, state->left->reg1);
+}
+
+stmt: OP_OUTARG_MEMBASE (OP_ICONST) {
+ MonoPPCArgInfo *ai = tree->backend.data;
+ MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, ppc_r1, ai->offset, state->left->tree->inst_c0);
+}
+
+stmt: OP_OUTARG_MEMBASE (CEE_LDIND_REF (OP_REGVAR)) {
+ MonoPPCArgInfo *ai = tree->backend.data;
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->left->tree->dreg);
+}
+
+stmt: OP_OUTARG_MEMBASE (freg) {
+ MonoPPCArgInfo *ai = tree->backend.data;
+ int opcode = ai->size == 4? OP_STORER4_MEMBASE_REG: OP_STORER8_MEMBASE_REG;
+ MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, ppc_r1, ai->offset, state->left->reg1);
+}
+
stmt: OP_OUTARG (reg) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg1);
- return;
- }
- tree->opcode = OP_SETREG;
- tree->dreg = tree->unused;
+ MonoCallInst *call = tree->inst_call;
+
+ tree->opcode = OP_MOVE;
+ tree->dreg = mono_regstate_next_int (s->rs);
tree->sreg1 = state->left->reg1;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
stmt: OP_OUTARG (OP_REGVAR) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->tree->dreg);
- return;
- }
- tree->opcode = OP_SETREG;
- tree->dreg = tree->unused;
+ MonoCallInst *call = tree->inst_call;
+
+ tree->opcode = OP_MOVE;
+ tree->dreg = mono_regstate_next_int (s->rs);
tree->sreg1 = state->left->tree->dreg;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
stmt: OP_OUTARG (lreg) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg2);
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm + 4, state->left->reg1);
- return;
- }
- MONO_EMIT_NEW_UNALU (s, OP_SETREG, tree->unused, state->left->reg2);
- tree->opcode = OP_SETREG;
- tree->dreg = tree->unused + 1;
+ MonoCallInst *call = tree->inst_call;
+ int tdreg = mono_regstate_next_int (s->rs);
+
+ MONO_EMIT_NEW_UNALU (s, OP_MOVE, tdreg, state->left->reg2);
+ mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
+ tree->opcode = OP_MOVE;
+ tree->dreg = mono_regstate_next_int (s->rs);
tree->sreg1 = state->left->reg1;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
}
stmt: OP_OUTARG (OP_ICONST) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, s->frame_reg, tree->inst_imm, state->left->tree->inst_c0);
- return;
- }
- tree->opcode = OP_SETREGIMM;
- tree->dreg = tree->unused;
+ MonoCallInst *call = tree->inst_call;
+
+ tree->opcode = OP_ICONST;
+ tree->dreg = mono_regstate_next_int (s->rs);
tree->inst_c0 = state->left->tree->inst_c0;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
-#stmt: OP_OUTARG (CEE_LDIND_I4 (base)) {
-# tree->opcode = OP_X86_PUSH_MEMBASE;
-# tree->inst_basereg = state->left->left->tree->inst_basereg;
-# tree->inst_offset = state->left->left->tree->inst_offset;
-# mono_bblock_add_inst (s->cbb, tree);
-#}
-
-#stmt: OP_OUTARG (CEE_LDIND_U4 (base)) {
-# tree->opcode = OP_X86_PUSH_MEMBASE;
-# tree->inst_basereg = state->left->left->tree->inst_basereg;
-# tree->inst_offset = state->left->left->tree->inst_offset;
-# mono_bblock_add_inst (s->cbb, tree);
-#}
-
-#stmt: OP_OUTARG (CEE_LDIND_I (base)) {
-# tree->opcode = OP_X86_PUSH_MEMBASE;
-# tree->inst_basereg = state->left->left->tree->inst_basereg;
-# tree->inst_offset = state->left->left->tree->inst_offset;
-# mono_bblock_add_inst (s->cbb, tree);
-#}
-
-#stmt: OP_OUTARG (CEE_LDIND_REF (base)) {
-# tree->opcode = OP_X86_PUSH_MEMBASE;
-# tree->inst_basereg = state->left->left->tree->inst_basereg;
-# tree->inst_offset = state->left->left->tree->inst_offset;
-# mono_bblock_add_inst (s->cbb, tree);
-#}
-
stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->left->tree->dreg);
- return;
- }
- tree->opcode = OP_SETREG;
+ MonoCallInst *call = tree->inst_call;
+
+ tree->opcode = OP_MOVE;
+ tree->dreg = mono_regstate_next_int (s->rs);
tree->sreg1 = state->left->left->tree->dreg;
- tree->dreg = tree->unused;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
#stmt: OP_OUTARG (CEE_LDOBJ (reg)) {
# mono_bblock_add_inst (s->cbb, tree);
#}
+stmt: OP_OUTARG_R8 (freg),
stmt: OP_OUTARG (freg) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg1);
- return;
- }
- tree->opcode = OP_SETFREG;
- tree->sreg1 = state->left->reg1;
- tree->dreg = tree->unused;
- mono_bblock_add_inst (s->cbb, tree);
-}
+ MonoCallInst *call = tree->inst_call;
-stmt: OP_OUTARG_R4 (freg) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg1);
- return;
- }
- tree->opcode = OP_SETFREG;
+ tree->opcode = OP_FMOVE;
+ tree->dreg = mono_regstate_next_float (s->rs);
tree->sreg1 = state->left->reg1;
- tree->dreg = tree->unused;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
}
-stmt: OP_OUTARG_R8 (freg) {
- if (tree->inst_imm) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, s->frame_reg, tree->inst_imm, state->left->reg1);
- return;
- }
- tree->opcode = OP_SETFREG;
- tree->sreg1 = state->left->reg1;
- tree->dreg = tree->unused;
- mono_bblock_add_inst (s->cbb, tree);
+stmt: OP_OUTARG_R8 (CEE_LDOBJ (base)) {
+ /* small struct with fp value goes in a fp register */
+ MonoInst *vt = state->left->left->tree;
+ int tmpr, soffset, dreg;
+ MonoCallInst *call = tree->inst_call;
+
+ soffset = vt->inst_offset;
+ tmpr = mono_regstate_next_float (s->rs);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR4_MEMBASE, tmpr, vt->inst_basereg, soffset);
+ dreg = mono_regstate_next_float (s->rs);
+ MONO_EMIT_NEW_UNALU (s, OP_FMOVE, dreg, tmpr);
+ mono_call_inst_add_outarg_reg (s, call, dreg, tree->backend.reg3, TRUE);
}
stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
+ MonoCallInst *call = tree->inst_call;
+ MonoPPCArgInfo *ai = tree->backend.data;
MonoInst *vt = state->left->left->tree;
- int start_reg = tree->unused & 0xff;
- int nregs = (tree->unused >> 8) & 0xff;
- int ovf_size = (tree->unused >> 16) & 0xffff;
- int i, tmpr, soffset;
+ int start_reg = ai->reg;
+ int nregs = ai->size;
+ int ovf_size = ai->vtsize;
+ int i, tmpr, soffset, dreg;
+ int size = 0;
soffset = vt->inst_offset;
+/*
+ Darwin needs some special handling for 1 and 2 byte arguments
+*/
+#ifdef __APPLE__
+ if (vt->inst_vtype && MONO_TYPE_ISSTRUCT (vt->inst_vtype) && vt->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
+ size = mono_class_native_size (mono_class_from_mono_type (vt->inst_vtype), NULL);
+ if (size == 2 || size == 1) {
+ tmpr = mono_regstate_next_int (s->rs);
+ if (size == 1)
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, tmpr, vt->inst_basereg, soffset);
+ else
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, tmpr, vt->inst_basereg, soffset);
+ dreg = mono_regstate_next_int (s->rs);
+ MONO_EMIT_NEW_UNALU (s, OP_MOVE, dreg, tmpr);
+ mono_call_inst_add_outarg_reg (s, call, dreg, start_reg, FALSE);
+ } else
+#endif
for (i = 0; i < nregs; ++i) {
tmpr = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
- MONO_EMIT_NEW_UNALU (s, OP_SETREG, start_reg + i, tmpr);
+ dreg = mono_regstate_next_int (s->rs);
+ MONO_EMIT_NEW_UNALU (s, OP_MOVE, dreg, tmpr);
+ mono_call_inst_add_outarg_reg (s, call, dreg, start_reg + i, FALSE);
soffset += sizeof (gpointer);
}
- //g_print ("vt size: %d at R%d + %d\n", tree->inst_imm, vt->inst_basereg, vt->inst_offset);
+ //g_print ("vt size: %d at R%d + %d\n", ai->offset, vt->inst_basereg, vt->inst_offset);
if (ovf_size != 0) {
- mini_emit_memcpy (s, s->frame_reg, tree->inst_imm + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
+ mini_emit_memcpy (s, ppc_r1, ai->offset + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
}
}
stmt: OP_OUTARG_VT (OP_ICONST) {
- int start_reg = tree->unused & 0xff;
- int nregs = (tree->unused >> 8) & 0xff;
- int ovf_size = (tree->unused >> 16) & 0xffff;
+ MonoCallInst *call = tree->inst_call;
+ MonoPPCArgInfo *ai = tree->backend.data;
+ int start_reg = ai->reg;
+ int nregs = ai->size;
if (nregs) {
- tree->opcode = OP_SETREGIMM;
- tree->dreg = start_reg;
+ tree->opcode = OP_ICONST;
+ tree->dreg = mono_regstate_next_int (s->rs);
tree->inst_c0 = state->left->tree->inst_c0;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
} else {
g_assert_not_reached ();
}
}
stmt: OP_OUTARG_VT (reg) {
- int start_reg = tree->unused & 0xff;
- int nregs = (tree->unused >> 8) & 0xff;
- int ovf_size = (tree->unused >> 16) & 0xffff;
+ MonoCallInst *call = tree->inst_call;
+ MonoPPCArgInfo *ai = tree->backend.data;
+ int start_reg = ai->reg;
+ int nregs = ai->size;
if (nregs) {
- tree->opcode = OP_SETREG;
- tree->dreg = start_reg;
- tree->sreg1 = state->left->tree->dreg;
+ tree->opcode = OP_MOVE;
+ tree->dreg = mono_regstate_next_int (s->rs);
+ tree->sreg1 = state->left->reg1;
mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
} else {
g_assert_not_reached ();
}
state->left->right->reg1);
}
+reg: CEE_ADD_OVF (reg, reg) "0" {
+ MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
+
+reg: CEE_ADD_OVF_UN (reg, reg) "0" {
+ MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
+
+reg: CEE_SUB_OVF (reg, reg) "0" {
+ MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
+
+reg: CEE_SUB_OVF_UN (reg, reg) "0" {
+ MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
%%
projects / mono.git / blobdiff