mono/mini/inssel-ppc.brg

   1 #define MONO_EMIT_NEW_LOAD_R8(cfg,dr,addr) do { \
   2                 MonoInst *inst;                            \
   3                 MONO_INST_NEW ((cfg), (inst), OP_R8CONST); \
   4                 inst->type = STACK_R8;                     \
   5                 inst->dreg = (dr);                     \
   6                 inst->inst_p0 = (void*)(addr);         \
   7                 mono_bblock_add_inst (cfg->cbb, inst); \
   8         } while (0)
   9
  10 %%
  11
  12 #
  13 # inssel-ppc.brg: burg file for special ppc instructions
  14 #
  15 # Author:
  16 #   Dietmar Maurer (dietmar@ximian.com)
  17 #   Paolo Molaro (lupus@ximian.com)
  18 #
  19 # (C) 2002 Ximian, Inc.
  20 #
  21
  22 stmt: OP_START_HANDLER {
  23         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  24         /*MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, spvar->inst_basereg, spvar->inst_offset, ppc_sp);
  25         */
  26         tree->inst_left = spvar;
  27         mono_bblock_add_inst (s->cbb, tree);
  28 }
  29
  30 stmt: OP_ENDFINALLY {
  31         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  32         tree->inst_left = spvar;
  33         mono_bblock_add_inst (s->cbb, tree);
  34 }
  35
  36 stmt: OP_ENDFILTER (reg) {
  37         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  38         tree->inst_left = spvar;
  39         tree->sreg1 = state->left->reg1;
  40         mono_bblock_add_inst (s->cbb, tree);
  41 }
  42
  43 reg: CEE_REM_UN (reg, reg),
  44 reg: CEE_REM (reg, reg) "0" {
  45         int div_result = mono_regstate_next_int (s->rs);
  46         int mul_result = mono_regstate_next_int (s->rs);
  47         MONO_EMIT_NEW_BIALU (s, (tree->opcode == CEE_REM_UN?CEE_DIV_UN:CEE_DIV), div_result, state->left->reg1, state->right->reg1);
  48         MONO_EMIT_NEW_BIALU (s, CEE_MUL, mul_result, div_result, state->right->reg1);
  49         MONO_EMIT_NEW_BIALU (s, CEE_SUB, state->reg1, state->left->reg1, mul_result);
  50 }
  51
  52 freg: OP_CKFINITE (freg) "0" {
  53         int msw_reg = mono_regstate_next_int (s->rs);
  54         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ppc_sp, -8, state->left->reg1);
  55         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, msw_reg, ppc_sp, -8);
  56         MONO_EMIT_NEW_UNALU (s, OP_CHECK_FINITE, -1, msw_reg);
  57         MONO_EMIT_NEW_UNALU (s, OP_FMOVE, state->reg1, state->left->reg1);
  58 }
  59
  60 lreg: OP_LADD_OVF (lreg, lreg) "0" {
  61         /* ADC sets the condition code */
  62         MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
  63         MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  64 }
  65
  66 lreg: OP_LADD_OVF_UN (lreg, lreg) "0" {
  67         /* ADC sets the condition code */
  68         MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
  69         MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  70 }
  71
  72 lreg: OP_LSUB_OVF (lreg, lreg) "0" {
  73         /* SBB sets the condition code */
  74         MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
  75         MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  76 }
  77
  78 lreg: OP_LSUB_OVF_UN (lreg, lreg) "0" {
  79         /* SBB sets the condition code */
  80         MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
  81         MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  82 }
  83
  84 stmt: CEE_STIND_I8 (OP_REGVAR, lreg) {
  85         /* this should only happen for methods returning a long */
  86         MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r3, state->right->reg1);
  87         MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r4, state->right->reg2);
  88 }
  89
  90 lreg: OP_LNEG (lreg) "2" {
  91         MONO_EMIT_NEW_BIALU_IMM (s, OP_PPC_SUBFIC, state->reg1, state->left->reg1, 0);
  92         MONO_EMIT_UNALU (s, tree, OP_PPC_SUBFZE, state->reg2, state->left->reg2);
  93 }
  94
  95 freg: OP_LCONV_TO_R8 (lreg) {
  96         tree->dreg = state->reg1;
  97         tree->sreg1 = state->left->reg1;
  98         tree->sreg2 = state->left->reg2;
  99         mono_bblock_add_inst (s->cbb, tree);
 100 }
 101
 102 freg: OP_LCONV_TO_R4 (lreg) {
 103         tree->dreg = state->reg1;
 104         tree->sreg1 = state->left->reg1;
 105         tree->sreg2 = state->left->reg2;
 106         mono_bblock_add_inst (s->cbb, tree);
 107 }
 108
 109 freg: CEE_CONV_R_UN (reg) "1" {
 110         static const guint64 adjust_val = 0x4330000000000000ULL;
 111         int msw_reg = mono_regstate_next_int (s->rs);
 112         int adj_reg = mono_regstate_next_float (s->rs);
 113         int tmp_reg = mono_regstate_next_float (s->rs);
 114         MONO_EMIT_NEW_ICONST (s, msw_reg, 0x43300000);
 115         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -8, msw_reg);
 116         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -4, state->left->reg1);
 117         MONO_EMIT_NEW_LOAD_R8 (s, adj_reg, &adjust_val);
 118         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR8_MEMBASE, tmp_reg, ppc_sp, -8);
 119         MONO_EMIT_BIALU (s, tree, OP_FSUB, state->reg1, tmp_reg, adj_reg);
 120 }
 121
 122 freg: CEE_CONV_R8 (reg),
 123 freg: CEE_CONV_R4 (reg) "1" {
 124         /* FIXME: change precision for CEE_CONV_R4 */
 125         static const guint64 adjust_val = 0x4330000080000000ULL;
 126         int msw_reg = mono_regstate_next_int (s->rs);
 127         int xored = mono_regstate_next_int (s->rs);
 128         int adj_reg = mono_regstate_next_float (s->rs);
 129         int tmp_reg = mono_regstate_next_float (s->rs);
 130         MONO_EMIT_NEW_ICONST (s, msw_reg, 0x43300000);
 131         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -8, msw_reg);
 132         MONO_EMIT_NEW_BIALU_IMM (s, OP_XOR_IMM, xored, state->left->reg1, 0x80000000);
 133         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, ppc_sp, -4, xored);
 134         MONO_EMIT_NEW_LOAD_R8 (s, adj_reg, &adjust_val);
 135         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR8_MEMBASE, tmp_reg, ppc_sp, -8);
 136         MONO_EMIT_BIALU (s, tree, OP_FSUB, state->reg1, tmp_reg, adj_reg);
 137 }
 138
 139 reg: OP_LOCALLOC (OP_ICONST) {
 140         /* microcoded in mini-ppc.c */
 141         tree->sreg1 = mono_regstate_next_int (s->rs);
 142         tree->dreg = state->reg1;
 143         MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
 144         mono_bblock_add_inst (s->cbb, tree);
 145 }
 146
 147 reg: OP_LOCALLOC (reg) {
 148         tree->dreg = state->reg1;
 149         tree->sreg1 = state->left->reg1;
 150         mono_bblock_add_inst (s->cbb, tree);
 151 }
 152
 153 stmt: OP_SETRET (reg) {
 154         tree->opcode = OP_MOVE;
 155         tree->sreg1 = state->left->reg1;
 156         tree->dreg = ppc_r3;
 157         mono_bblock_add_inst (s->cbb, tree);
 158 }
 159
 160 stmt: OP_SETRET (lreg) {
 161         tree->opcode = OP_SETLRET;
 162         tree->sreg1 = state->left->reg1;
 163         tree->sreg2 = state->left->reg2;
 164         tree->dreg = ppc_r3;
 165         mono_bblock_add_inst (s->cbb, tree);
 166 }
 167
 168 stmt: OP_SETRET (freg) {
 169         tree->opcode = OP_FMOVE;
 170         tree->sreg1 = state->left->reg1;
 171         tree->dreg = ppc_f1;
 172         mono_bblock_add_inst (s->cbb, tree);
 173 }
 174
 175 stmt: OP_SETRET (OP_ICONST) {
 176         tree->opcode = OP_ICONST;
 177         tree->inst_c0 = state->left->tree->inst_c0;
 178         tree->dreg = ppc_r3;
 179         mono_bblock_add_inst (s->cbb, tree);
 180 }
 181
 182 stmt: CEE_STIND_I (OP_REGVAR, CEE_SUB (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
 183 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_SUB (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)),
 184 stmt: CEE_STIND_I (OP_REGVAR, CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
 185 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_ADD (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)) {
 186         int con = state->right->right->tree->inst_c0;
 187         int dreg = state->left->tree->dreg;
 188         int sreg = state->right->left->left->tree->dreg;
 189
 190         if (state->right->op == CEE_ADD)
 191                 tree->opcode = OP_ADD_IMM;
 192         else if (state->right->op == CEE_SUB)
 193                 tree->opcode = OP_SUB_IMM;
 194         else
 195                 g_assert_not_reached ();
 196         tree->inst_imm = con;
 197         tree->sreg1 = sreg;
 198         tree->dreg = dreg;
 199         mono_bblock_add_inst (s->cbb, tree);
 200 }
 201
 202 stmt: OP_OUTARG_MEMBASE (reg) {
 203         MonoPPCArgInfo *ai = tree->backend.data;
 204         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg1);
 205 }
 206
 207 stmt: OP_OUTARG_MEMBASE (OP_REGVAR) {
 208         MonoPPCArgInfo *ai = tree->backend.data;
 209         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->tree->dreg);
 210 }
 211
 212 stmt: OP_OUTARG_MEMBASE (lreg) {
 213         MonoPPCArgInfo *ai = tree->backend.data;
 214         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg2);
 215         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset + 4, state->left->reg1);
 216 }
 217
 218 stmt: OP_OUTARG_MEMBASE (OP_ICONST) {
 219         MonoPPCArgInfo *ai = tree->backend.data;
 220         MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, ppc_r1, ai->offset, state->left->tree->inst_c0);
 221 }
 222
 223 stmt: OP_OUTARG_MEMBASE (CEE_LDIND_REF (OP_REGVAR)) {
 224         MonoPPCArgInfo *ai = tree->backend.data;
 225         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->left->tree->dreg);
 226 }
 227
 228 stmt: OP_OUTARG_MEMBASE (freg) {
 229         MonoPPCArgInfo *ai = tree->backend.data;
 230         int opcode = ai->size  == 4? OP_STORER4_MEMBASE_REG: OP_STORER8_MEMBASE_REG;
 231         MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, ppc_r1, ai->offset, state->left->reg1);
 232 }
 233
 234 stmt: OP_OUTARG (reg) {
 235         MonoCallInst *call = tree->inst_call;
 236
 237         tree->opcode = OP_MOVE;
 238         tree->dreg = mono_regstate_next_int (s->rs);
 239         tree->sreg1 = state->left->reg1;
 240         mono_bblock_add_inst (s->cbb, tree);
 241         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 242 }
 243
 244 stmt: OP_OUTARG (OP_REGVAR) {
 245         MonoCallInst *call = tree->inst_call;
 246
 247         tree->opcode = OP_MOVE;
 248         tree->dreg = mono_regstate_next_int (s->rs);
 249         tree->sreg1 = state->left->tree->dreg;
 250         mono_bblock_add_inst (s->cbb, tree);
 251         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 252 }
 253
 254 stmt: OP_OUTARG (lreg) {
 255         MonoCallInst *call = tree->inst_call;
 256         int tdreg = mono_regstate_next_int (s->rs);
 257
 258         MONO_EMIT_NEW_UNALU (s, OP_MOVE, tdreg, state->left->reg2);
 259         mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
 260         tree->opcode = OP_MOVE;
 261         tree->dreg = mono_regstate_next_int (s->rs);
 262         tree->sreg1 = state->left->reg1;
 263         mono_bblock_add_inst (s->cbb, tree);
 264         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
 265 }
 266
 267 stmt: OP_OUTARG (OP_ICONST) {
 268         MonoCallInst *call = tree->inst_call;
 269
 270         tree->opcode = OP_ICONST;
 271         tree->dreg = mono_regstate_next_int (s->rs);
 272         tree->inst_c0 = state->left->tree->inst_c0;
 273         mono_bblock_add_inst (s->cbb, tree);
 274         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 275 }
 276
 277 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
 278         MonoCallInst *call = tree->inst_call;
 279
 280         tree->opcode = OP_MOVE;
 281         tree->dreg = mono_regstate_next_int (s->rs);
 282         tree->sreg1 = state->left->left->tree->dreg;
 283         mono_bblock_add_inst (s->cbb, tree);
 284         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 285 }
 286
 287 #stmt: OP_OUTARG (CEE_LDOBJ (reg)) {
 288 #       tree->opcode = OP_X86_PUSH;
 289 #       tree->sreg1 = state->left->reg1;
 290 #       mono_bblock_add_inst (s->cbb, tree);
 291 #}
 292
 293 stmt: OP_OUTARG_R8 (freg),
 294 stmt: OP_OUTARG (freg) {
 295         MonoCallInst *call = tree->inst_call;
 296
 297         tree->opcode = OP_FMOVE;
 298         tree->dreg = mono_regstate_next_float (s->rs);
 299         tree->sreg1 = state->left->reg1;
 300         mono_bblock_add_inst (s->cbb, tree);
 301         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
 302 }
 303
 304 stmt: OP_OUTARG_R8 (CEE_LDOBJ (base)) {
 305         /* small struct with fp value goes in a fp register */
 306         MonoInst *vt = state->left->left->tree;
 307         int tmpr, soffset, dreg;
 308         MonoCallInst *call = tree->inst_call;
 309
 310         soffset = vt->inst_offset;
 311         tmpr = mono_regstate_next_float (s->rs);
 312         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR4_MEMBASE, tmpr, vt->inst_basereg, soffset);
 313         dreg = mono_regstate_next_float (s->rs);
 314         MONO_EMIT_NEW_UNALU (s, OP_FMOVE, dreg, tmpr);
 315         mono_call_inst_add_outarg_reg (s, call, dreg, tree->backend.reg3, TRUE);
 316 }
 317
 318 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
 319         MonoCallInst *call = tree->inst_call;
 320         MonoPPCArgInfo *ai = tree->backend.data;
 321         MonoInst *vt = state->left->left->tree;
 322         int start_reg = ai->reg;
 323         int nregs = ai->size;
 324         int ovf_size = ai->vtsize;
 325         int i, tmpr, soffset, dreg;
 326         int size = 0;
 327         soffset = vt->inst_offset;
 328 /*
 329   Darwin needs some special handling for 1 and 2 byte arguments
 330 */
 331 #ifdef __APPLE__
 332         if (vt->inst_vtype && MONO_TYPE_ISSTRUCT (vt->inst_vtype) && vt->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
 333             size =  mono_class_native_size (mono_class_from_mono_type (vt->inst_vtype), NULL);
 334         if (size == 2 || size == 1) {
 335                 tmpr = mono_regstate_next_int (s->rs);
 336                 if (size == 1)
 337                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, tmpr, vt->inst_basereg, soffset);
 338                 else
 339                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, tmpr, vt->inst_basereg, soffset);
 340                 dreg = mono_regstate_next_int (s->rs);
 341                 MONO_EMIT_NEW_UNALU (s, OP_MOVE, dreg, tmpr);
 342                 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg, FALSE);
 343         } else
 344 #endif
 345         for (i = 0; i < nregs; ++i) {
 346                 tmpr = mono_regstate_next_int (s->rs);
 347                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
 348                 dreg = mono_regstate_next_int (s->rs);
 349                 MONO_EMIT_NEW_UNALU (s, OP_MOVE, dreg, tmpr);
 350                 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg + i, FALSE);
 351                 soffset += sizeof (gpointer);
 352         }
 353         //g_print ("vt size: %d at R%d + %d\n", ai->offset, vt->inst_basereg, vt->inst_offset);
 354         if (ovf_size != 0) {
 355                 mini_emit_memcpy (s, ppc_r1, ai->offset + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
 356         }
 357 }
 358
 359 stmt: OP_OUTARG_VT (OP_ICONST) {
 360         MonoCallInst *call = tree->inst_call;
 361         MonoPPCArgInfo *ai = tree->backend.data;
 362         int start_reg = ai->reg;
 363         int nregs = ai->size;
 364         if (nregs) {
 365                 tree->opcode = OP_ICONST;
 366                 tree->dreg = mono_regstate_next_int (s->rs);
 367                 tree->inst_c0 = state->left->tree->inst_c0;
 368                 mono_bblock_add_inst (s->cbb, tree);
 369                 mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
 370         } else {
 371                 g_assert_not_reached ();
 372         }
 373 }
 374
 375 stmt: OP_OUTARG_VT (reg) {
 376         MonoCallInst *call = tree->inst_call;
 377         MonoPPCArgInfo *ai = tree->backend.data;
 378         int start_reg = ai->reg;
 379         int nregs = ai->size;
 380         if (nregs) {
 381                 tree->opcode = OP_MOVE;
 382                 tree->dreg = mono_regstate_next_int (s->rs);
 383                 tree->sreg1 = state->left->reg1;
 384                 mono_bblock_add_inst (s->cbb, tree);
 385                 mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
 386         } else {
 387                 g_assert_not_reached ();
 388         }
 389 }
 390
 391 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
 392         /* nothing to do: the value is already on the FP stack */
 393 }
 394
 395 stmt: CEE_BNE_UN (fpcflags) {
 396         tree->opcode = OP_FBNE_UN;
 397         mono_bblock_add_inst (s->cbb, tree);
 398 }
 399
 400 stmt: CEE_BEQ (fpcflags) {
 401         tree->opcode = OP_FBEQ;
 402         mono_bblock_add_inst (s->cbb, tree);
 403 }
 404
 405 stmt: CEE_BLT (fpcflags) {
 406         tree->opcode = OP_FBLT;
 407         mono_bblock_add_inst (s->cbb, tree);
 408 }
 409
 410 stmt: CEE_BLT_UN (fpcflags) {
 411         tree->opcode = OP_FBLT_UN;
 412         mono_bblock_add_inst (s->cbb, tree);
 413 }
 414
 415 stmt: CEE_BGT (fpcflags) {
 416         tree->opcode = OP_FBGT;
 417         mono_bblock_add_inst (s->cbb, tree);
 418 }
 419
 420 stmt: CEE_BGT_UN (fpcflags) {
 421         tree->opcode = OP_FBGT_UN;
 422         mono_bblock_add_inst (s->cbb, tree);
 423 }
 424
 425 stmt: CEE_BGE  (fpcflags) {
 426         tree->opcode = OP_FBGE;
 427         mono_bblock_add_inst (s->cbb, tree);
 428 }
 429
 430 stmt: CEE_BGE_UN (fpcflags) {
 431         tree->opcode = OP_FBGE_UN;
 432         mono_bblock_add_inst (s->cbb, tree);
 433 }
 434
 435 stmt: CEE_BLE  (fpcflags) {
 436         tree->opcode = OP_FBLE;
 437         mono_bblock_add_inst (s->cbb, tree);
 438 }
 439
 440 stmt: CEE_BLE_UN (fpcflags) {
 441         tree->opcode = OP_FBLE_UN;
 442         mono_bblock_add_inst (s->cbb, tree);
 443 }
 444
 445 stmt: CEE_POP (freg) "0" {
 446         /* nothing to do */
 447 }
 448
 449 freg: OP_LCONV_TO_R8 (lreg) {
 450         /* nothing to do - emulated */
 451 }
 452
 453 freg: OP_LCONV_TO_R4 (lreg) {
 454         /* nothing to do - emulated */
 455 }
 456
 457 freg: OP_LCONV_TO_R_UN (lreg) {
 458         /* nothing to do - emulated */
 459 }
 460
 461 freg: OP_FREM (freg, freg) {
 462         /* nothing to do - emulated */
 463 }
 464
 465 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
 466         MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
 467                          state->left->right->reg1);
 468 }
 469
 470 reg: OP_CLT (OP_COMPARE (freg, freg)) {
 471         MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
 472                          state->left->right->reg1);
 473 }
 474
 475 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
 476         MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
 477                          state->left->right->reg1);
 478 }
 479
 480 reg: OP_CGT (OP_COMPARE (freg, freg)) {
 481         MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
 482                          state->left->right->reg1);
 483 }
 484
 485 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
 486         MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
 487                          state->left->right->reg1);
 488 }
 489
 490 reg: CEE_ADD_OVF (reg, reg) "0" {
 491         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 492 }
 493
 494 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
 495         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 496 }
 497
 498 reg: CEE_SUB_OVF (reg, reg) "0" {
 499         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 500 }
 501
 502 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
 503         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 504 }
 505 %%