mono/mini/inssel-long.brg

   1 %%
   2
   3 #
   4 # inssel-long.brg: burg file for 64bit architectures
   5 #
   6 # Author:
   7 #   Dietmar Maurer (dietmar@ximian.com)
   8 #
   9 # (C) 2002 Ximian, Inc.
  10 #
  11
  12 reg: OP_I8CONST {
  13         MONO_EMIT_NEW_I8CONST (s, state->reg1, tree->inst_l);
  14 }
  15
  16 reg: CEE_LDIND_I8 (base) {
  17         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI8_MEMBASE, state->reg1,
  18                                    state->left->tree->inst_basereg, state->left->tree->inst_offset);
  19 }
  20
  21 stmt: CEE_STIND_I8 (base, reg) {
  22         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI8_MEMBASE_REG, state->left->tree->inst_basereg,
  23                                  state->left->tree->inst_offset, state->right->reg1);
  24 }
  25
  26 stmt: CEE_STIND_REF (base, OP_I8CONST),
  27 stmt: CEE_STIND_I (base, OP_I8CONST),
  28 stmt: CEE_STIND_I8 (base, OP_I8CONST),
  29 stmt: CEE_STIND_REF (base, OP_ICONST),
  30 stmt: CEE_STIND_I (base, OP_ICONST),
  31 stmt: CEE_STIND_I8 (base, OP_ICONST) {
  32         MONO_EMIT_STORE_MEMBASE_IMM (s, tree, OP_STOREI8_MEMBASE_IMM, state->left->tree->inst_basereg,
  33                                      state->left->tree->inst_offset, state->right->tree->inst_l);
  34 }
  35
  36 stmt: CEE_STIND_I8 (reg, reg) {
  37         MONO_EMIT_STORE_MEMBASE (s, tree, OP_STOREI8_MEMBASE_REG, state->left->tree->inst_basereg,
  38                                  state->left->tree->inst_offset, state->right->reg1);
  39 }
  40
  41 base: OP_LADD (base, OP_ICONST) "0" {
  42         tree->inst_offset = state->left->tree->inst_offset + state->right->tree->inst_c0;
  43         tree->inst_basereg = state->left->tree->inst_basereg;
  44 }
  45
  46 base: OP_LADD (CEE_LDIND_REF (OP_REGVAR), OP_ICONST),
  47 base: OP_LADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST) "0" {
  48         tree->inst_offset = state->right->tree->inst_c0;
  49         tree->inst_basereg = state->left->left->tree->dreg;
  50 }
  51
  52 reg: OP_LADD (reg, reg) {
  53         MONO_EMIT_NEW_BIALU (s, CEE_ADD, state->reg1, state->left->reg1, state->right->reg1);
  54 }
  55
  56 reg: OP_LSUB (reg, reg) {
  57         MONO_EMIT_NEW_BIALU (s, CEE_SUB, state->reg1, state->left->reg1, state->right->reg1);
  58 }
  59
  60 reg: OP_LNEG (reg) {
  61         MONO_EMIT_NEW_UNALU (s, CEE_NEG, state->reg1, state->left->reg1);
  62 }
  63
  64 reg: OP_LNOT (reg) {
  65         MONO_EMIT_NEW_UNALU (s, CEE_NOT, state->reg1, state->left->reg1);
  66 }
  67
  68 reg: OP_LAND (reg, reg) {
  69         MONO_EMIT_NEW_BIALU (s, CEE_AND, state->reg1, state->left->reg1, state->right->reg1);
  70 }
  71
  72 reg: OP_LOR (reg, reg) {
  73         MONO_EMIT_NEW_BIALU (s, CEE_OR, state->reg1, state->left->reg1, state->right->reg1);
  74 }
  75
  76 reg: OP_LXOR (reg, reg) {
  77         MONO_EMIT_NEW_BIALU (s, CEE_XOR, state->reg1, state->left->reg1, state->right->reg1);
  78 }
  79
  80
  81 reg: OP_LADD_OVF (reg, reg) {
  82         MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
  83         MONO_EMIT_NEW_COND_EXC (s, OV, "OverflowException");
  84 }
  85
  86 reg: OP_LADD_OVF_UN (reg, reg) {
  87         MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
  88         MONO_EMIT_NEW_COND_EXC (s, C, "OverflowException");
  89 }
  90
  91 reg: OP_LSUB_OVF (reg, reg) {
  92         MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
  93         MONO_EMIT_NEW_COND_EXC (s, OV, "OverflowException");
  94 }
  95
  96 reg: OP_LSUB_OVF_UN (reg, reg) {
  97         MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
  98         MONO_EMIT_NEW_COND_EXC (s, C, "OverflowException");
  99 }
 100
 101 reg: OP_LONG_SHRUN_32 (reg) {
 102         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHR_UN_IMM, state->reg1, state->left->reg1, 32);
 103 }
 104
 105 #
 106 # shift operations
 107 #
 108
 109 reg: OP_LSHL (reg, reg) {
 110         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 111 }
 112
 113 reg: OP_LSHL (reg, OP_ICONST) {
 114         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHL_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 115 }
 116
 117 reg: OP_LSHR (reg, reg) {
 118         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 119 }
 120
 121 reg: OP_LSHR_IMM (reg, OP_ICONST) {
 122         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHR_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 123 }
 124
 125 reg: OP_LSHR_UN (reg, reg) {
 126         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 127 }
 128
 129 reg: OP_LSHR_UN (reg, OP_ICONST) {
 130         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHR_UN_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 131 }
 132
 133 #
 134 # Conversions
 135 #
 136
 137 reg: CEE_CONV_I8 (reg) {
 138         /* Sign extend the value in the lower word into the upper word */
 139         tree->sreg1 = state->left->reg1;
 140         tree->dreg = state->reg1;
 141         mono_bblock_add_inst (s->cbb, tree);
 142 }
 143
 144 reg: CEE_CONV_U8 (reg) {
 145         /* Clean out the upper word */
 146         /* Sign extend the value in the lower word into the upper word */
 147         tree->sreg1 = state->left->reg1;
 148         tree->dreg = state->reg1;
 149         mono_bblock_add_inst (s->cbb, tree);
 150 }
 151
 152 i8con: CEE_CONV_U8 (OP_ICONST) "0" {
 153         /*
 154          * This is needed since constant propagation eliminates some
 155      * stind.i4/ldind.i4 pairs, along with the conversions done by them.
 156          */
 157         int data = state->left->tree->inst_c0;
 158         tree->opcode = OP_I8CONST;
 159         tree->inst_ls_word = data;
 160         tree->inst_ms_word = 0;
 161 }
 162
 163 reg: OP_LCONV_TO_I4 (reg) {
 164         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 165 }
 166
 167 reg: OP_FCONV_TO_I8 (freg) {
 168         MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 169 }
 170
 171 reg: OP_FCONV_TO_U8 (freg) {
 172         MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 173 }
 174
 175 reg: OP_LCONV_TO_I4 (i8con) {
 176      MONO_EMIT_NEW_ICONST (s, state->reg1, state->left->tree->inst_ls_word);
 177 }
 178
 179 reg: OP_LCONV_TO_I4 (reg) {
 180         /* Sign extend the value in the lower word into the upper word */
 181         MONO_EMIT_BIALU_IMM (s, tree, OP_SHR_IMM, state->reg1, state->left->reg1, 0);
 182 }
 183
 184 reg: OP_LCONV_TO_U4 (reg) {
 185         /* Clean out the upper word */
 186         MONO_EMIT_BIALU_IMM (s, tree, OP_SHR_UN_IMM, state->reg1, state->left->reg1, 0);
 187 }
 188
 189 reg: OP_LCONV_TO_U8 (reg) {
 190         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 191 }
 192
 193 reg: OP_LCONV_TO_I8 (reg) {
 194         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 195 }
 196
 197 reg: OP_LCONV_TO_U (reg) {
 198         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 199 }
 200
 201 reg: OP_LCONV_TO_I (reg) {
 202         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 203 }
 204
 205 reg: OP_LCONV_TO_I1 (reg) {
 206         MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
 207 }
 208
 209 reg: OP_LCONV_TO_U1 (reg) {
 210         MONO_EMIT_UNALU (s, tree, CEE_CONV_U1, state->reg1, state->left->reg1);
 211 }
 212
 213 reg: OP_LCONV_TO_I2 (reg) {
 214         MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
 215 }
 216
 217 reg: OP_LCONV_TO_U2 (reg) {
 218         MONO_EMIT_UNALU (s, tree, CEE_CONV_U2, state->reg1, state->left->reg1);
 219 }
 220
 221
 222 reg: OP_LCONV_TO_OVF_I1 (reg) {
 223         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 127);
 224         MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
 225         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, -128);
 226         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 227         MONO_EMIT_UNALU (s, tree, CEE_CONV_I1, state->reg1, state->left->reg1);
 228 }
 229
 230 reg: OP_LCONV_TO_OVF_U1 (reg) {
 231         /* probe value to be within 0 to 255 */
 232         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 255);
 233         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 234         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff);
 235 }
 236
 237 reg: OP_LCONV_TO_OVF_U1_UN (reg) {
 238         /* probe value to be within 0 to 255 */
 239         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 255);
 240         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 241         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xff);
 242 }
 243
 244 reg: OP_LCONV_TO_OVF_I2 (reg) {
 245         /* Probe value to be within -32768 and 32767 */
 246         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 32767);
 247         MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
 248         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, -32768);
 249         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 250         MONO_EMIT_UNALU (s, tree, CEE_CONV_I2, state->reg1, state->left->reg1);
 251 }
 252
 253 reg: OP_LCONV_TO_OVF_U2 (reg) {
 254         /* Probe value to be within 0 and 65535 */
 255         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0xffff);
 256         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 257         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff);
 258 }
 259
 260 reg: OP_LCONV_TO_OVF_U2_UN (reg) {
 261         /* Probe value to be within 0 and 65535 */
 262         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0xffff);
 263         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 264         MONO_EMIT_BIALU_IMM (s, tree, OP_AND_IMM, state->reg1, state->left->reg1, 0xffff);
 265 }
 266
 267 reg: OP_LCONV_TO_OVF_I4 (reg) {
 268         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0x7fffffff);
 269         MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
 270         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, -2147483648);
 271         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 272         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 273 }
 274
 275 reg: OP_LCONV_TO_OVF_I4_UN (reg) {
 276         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0x7fffffff);
 277         MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
 278         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 279 }
 280
 281 reg: OP_LCONV_TO_OVF_U4_UN (reg) {
 282         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0xffffffff);
 283         MONO_EMIT_NEW_COND_EXC (s, GT_UN, "OverflowException");
 284         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 285 }
 286
 287 reg: OP_LCONV_TO_OVF_U4 (reg) {
 288         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0xffffffffUL);
 289         MONO_EMIT_NEW_COND_EXC (s, GT, "OverflowException");
 290         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, 0);
 291         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 292         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 293 }
 294
 295 reg: OP_LCONV_TO_OVF_I_UN (reg),
 296 reg: OP_LCONV_TO_OVF_I8_UN (reg) {
 297         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, 0);
 298         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 299
 300         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 301 }
 302
 303 reg: OP_LCONV_TO_OVF_U8 (reg) {
 304         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, 0);
 305         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 306
 307         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 308 }
 309
 310 reg: OP_LCONV_TO_OVF_I8 (reg) {
 311         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 312 }
 313
 314 reg: OP_LCONV_TO_OVF_U8_UN (reg) {
 315         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 316 }
 317
 318 reg: OP_LCONV_TO_OVF_I (reg) {
 319         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 320 }
 321
 322 freg: OP_LCONV_TO_R_UN (lreg) {
 323         MONO_EMIT_UNALU (s, tree, tree->opcode, state->reg1, state->left->reg1);
 324 }
 325
 326 reg: CEE_CONV_OVF_I8 (reg) {
 327         /* Sign extend the value in the lower word into the upper word */
 328         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHR_IMM, state->reg1, state->left->reg1, 0);
 329 }
 330
 331 reg: CEE_CONV_OVF_I8_UN (reg) {
 332         /* an unsigned 32 bit num always fits in a signed 64 bit one */
 333         /* Clean out the upper word */
 334         MONO_EMIT_BIALU_IMM (s, tree, OP_SHR_UN_IMM, state->reg1, state->left->reg1, 0);
 335 }
 336
 337 reg: CEE_CONV_OVF_U8 (reg) {
 338         MONO_EMIT_NEW_COMPARE_IMM (s, state->left->reg1, 0);
 339         MONO_EMIT_NEW_COND_EXC (s, LT, "OverflowException");
 340         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->reg1, state->left->reg1);
 341 }
 342
 343 reg: CEE_CONV_OVF_U8_UN (reg) {
 344         g_assert_not_reached ();
 345 }
 346
 347
 348
 349
 350 reg: OP_LCALLVIRT (reg) {
 351         mini_emit_virtual_call (s, state, tree, OP_LCALL, OP_LCALL_MEMBASE);
 352 }
 353
 354 reg: OP_LCALL {
 355         tree->dreg = state->reg1;
 356         mono_bblock_add_inst (s->cbb, tree);
 357 }
 358
 359 reg: OP_LCALL_REG (reg) {
 360         tree->sreg1 = state->left->reg1;
 361         tree->dreg = state->reg1;
 362         mono_bblock_add_inst (s->cbb, tree);
 363 }
 364
 365 reg: OP_LCALL_REG (OP_ICONST) {
 366         tree->opcode = OP_LCALL;
 367         ((MonoCallInst*)tree)->fptr = state->left->tree->inst_p0;
 368         tree->dreg = state->reg1;
 369         mono_bblock_add_inst (s->cbb, tree);
 370 }
 371
 372
 373
 374 stmt: CEE_STIND_I4 (OP_REGVAR, OP_ICONST) {
 375         tree->inst_c0 = state->right->tree->inst_c0;
 376         tree->opcode = OP_ICONST;
 377         tree->dreg = state->left->tree->dreg;
 378         mono_bblock_add_inst (s->cbb, tree);
 379 }
 380
 381 stmt: CEE_STIND_I4 (OP_REGVAR, reg) {
 382         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->left->tree->dreg, state->right->reg1);
 383 }
 384
 385 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_LDIND_I4 (OP_REGVAR)) {
 386         MONO_EMIT_UNALU (s, tree, OP_MOVE, state->left->tree->dreg, state->right->left->tree->dreg);
 387 }
 388
 389 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_LDIND_I4 (base)) {
 390         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->left->tree->dreg,
 391                                    state->right->left->tree->inst_basereg,
 392                                    state->right->left->tree->inst_offset);
 393 }
 394
 395 cflags: OP_LCOMPARE (reg, reg) {
 396         tree->sreg1 = state->left->reg1;
 397         tree->sreg2 = state->right->reg1;
 398         mono_bblock_add_inst (s->cbb, tree);
 399 }
 400
 401 cflags: OP_LCOMPARE (CEE_LDIND_I8 (OP_REGVAR), reg) {
 402         tree->sreg1 = state->left->left->tree->dreg;
 403         tree->sreg2 = state->right->reg1;
 404         mono_bblock_add_inst (s->cbb, tree);
 405 }
 406
 407 cflags: OP_LCOMPARE (CEE_LDIND_I (OP_REGVAR), CEE_LDIND_I (OP_REGVAR)) {
 408         tree->sreg1 = state->left->left->tree->dreg;
 409         tree->sreg2 = state->right->left->tree->dreg;
 410         mono_bblock_add_inst (s->cbb, tree);
 411 }
 412
 413 cflags: OP_LCOMPARE (CEE_LDIND_I8 (OP_REGVAR), OP_ICONST) {
 414         tree->opcode = OP_COMPARE_IMM;
 415         tree->sreg1 = state->left->left->tree->dreg;
 416         tree->inst_imm = state->right->tree->inst_c0;
 417         mono_bblock_add_inst (s->cbb, tree);
 418 } cost {
 419         MBCOND (mono_arch_is_inst_imm (state->right->tree->inst_c0));
 420
 421         return 0;
 422 }
 423
 424 cflags: OP_LCOMPARE (reg, OP_ICONST) {
 425         tree->opcode = OP_COMPARE_IMM;
 426         tree->sreg1 = state->left->reg1;
 427         tree->inst_imm = state->right->tree->inst_c0;
 428         mono_bblock_add_inst (s->cbb, tree);
 429 } cost {
 430         MBCOND (mono_arch_is_inst_imm (state->right->tree->inst_c0));
 431
 432         return 0;
 433 }
 434
 435 cflags: OP_LCOMPARE (reg, OP_I8CONST) {
 436         tree->opcode = OP_COMPARE_IMM;
 437         tree->sreg1 = state->left->reg1;
 438         tree->inst_imm = state->right->tree->inst_l;
 439         mono_bblock_add_inst (s->cbb, tree);
 440 } cost {
 441         MBCOND (mono_arch_is_inst_imm (state->right->tree->inst_l));
 442
 443         return 0;
 444 }
 445
 446 stmt: CEE_BNE_UN (cflags) {
 447         mono_bblock_add_inst (s->cbb, tree);
 448 }
 449
 450 stmt: CEE_BEQ (cflags) {
 451         mono_bblock_add_inst (s->cbb, tree);
 452 }
 453
 454 stmt: CEE_BLT (cflags) {
 455         mono_bblock_add_inst (s->cbb, tree);
 456 }
 457
 458 stmt: CEE_BLT_UN (cflags) {
 459         mono_bblock_add_inst (s->cbb, tree);
 460 }
 461
 462 stmt: CEE_BGT (cflags) {
 463         mono_bblock_add_inst (s->cbb, tree);
 464 }
 465
 466 stmt: CEE_BGT_UN (cflags) {
 467         mono_bblock_add_inst (s->cbb, tree);
 468 }
 469
 470 stmt: CEE_BGE  (cflags) {
 471         mono_bblock_add_inst (s->cbb, tree);
 472 }
 473
 474 stmt: CEE_BGE_UN (cflags) {
 475         mono_bblock_add_inst (s->cbb, tree);
 476 }
 477
 478 stmt: CEE_BLE  (cflags) {
 479         mono_bblock_add_inst (s->cbb, tree);
 480 }
 481
 482 stmt: CEE_BLE_UN (cflags) {
 483         mono_bblock_add_inst (s->cbb, tree);
 484 }
 485
 486 #
 487 # 32 bit rules
 488 #
 489
 490 #
 491 # basic alu operations
 492 #
 493
 494 reg: CEE_AND (reg, reg) {
 495         MONO_EMIT_BIALU (s, tree, OP_IAND, state->reg1, state->left->reg1, state->right->reg1);
 496 }
 497
 498 reg: CEE_AND (reg, OP_ICONST) {
 499         MONO_EMIT_BIALU_IMM (s, tree, OP_IAND_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 500 }
 501
 502 reg: CEE_OR (reg, reg) {
 503         MONO_EMIT_BIALU (s, tree, OP_IOR, state->reg1, state->left->reg1, state->right->reg1);
 504 }
 505
 506 reg: CEE_OR (reg, OP_ICONST) {
 507         MONO_EMIT_BIALU_IMM (s, tree, OP_IOR_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 508 }
 509
 510 reg: CEE_XOR (reg, reg) {
 511         MONO_EMIT_BIALU (s, tree, OP_IXOR, state->reg1, state->left->reg1, state->right->reg1);
 512 }
 513
 514 reg: CEE_XOR (reg, OP_ICONST) {
 515         MONO_EMIT_BIALU_IMM (s, tree, OP_IXOR_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 516 }
 517
 518 reg: CEE_NEG (reg) {
 519         MONO_EMIT_UNALU (s, tree, OP_INEG, state->reg1, state->left->reg1);
 520 }
 521
 522 reg: CEE_NOT (reg) {
 523         MONO_EMIT_UNALU (s, tree, OP_INOT, state->reg1, state->left->reg1);
 524 }
 525
 526 reg: CEE_ADD (reg, reg) {
 527         MONO_EMIT_BIALU (s, tree, OP_IADD, state->reg1, state->left->reg1, state->right->reg1);
 528 }
 529
 530 reg: CEE_ADD (reg, OP_ICONST) {
 531         MONO_EMIT_BIALU_IMM (s, tree, OP_IADD_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 532 }
 533
 534 reg: CEE_ADD_OVF (reg, reg) {
 535         MONO_EMIT_NEW_BIALU (s, OP_IADDCC, state->reg1, state->left->reg1, state->right->reg1);
 536         MONO_EMIT_NEW_COND_EXC (s, IOV, "OverflowException");
 537 }
 538
 539 reg: CEE_ADD_OVF_UN (reg, reg) {
 540         MONO_EMIT_NEW_BIALU (s, OP_IADDCC, state->reg1, state->left->reg1, state->right->reg1);
 541         MONO_EMIT_NEW_COND_EXC (s, IC, "OverflowException");
 542 }
 543
 544 reg: CEE_SUB (reg, reg) {
 545         MONO_EMIT_BIALU (s, tree, OP_ISUB, state->reg1, state->left->reg1, state->right->reg1);
 546 }
 547
 548 reg: CEE_SUB (reg, CEE_LDIND_I4 (OP_REGVAR)) {
 549         MONO_EMIT_BIALU (s, tree, OP_ISUB, state->reg1, state->left->reg1, state->right->left->tree->dreg);
 550 }
 551
 552 reg: CEE_SUB (reg, OP_ICONST) {
 553         MONO_EMIT_BIALU_IMM (s, tree, OP_ISUB_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 554 }
 555
 556 reg: CEE_SUB_OVF (reg, reg) {
 557         MONO_EMIT_NEW_BIALU (s, OP_ISUBCC, state->reg1, state->left->reg1, state->right->reg1);
 558         MONO_EMIT_NEW_COND_EXC (s, IOV, "OverflowException");
 559 }
 560
 561 reg: CEE_SUB_OVF_UN (reg, reg) {
 562         MONO_EMIT_NEW_BIALU (s, OP_ISUBCC, state->reg1, state->left->reg1, state->right->reg1);
 563         MONO_EMIT_NEW_COND_EXC (s, IC, "OverflowException");
 564 }
 565
 566 #
 567 # shift operations
 568 #
 569
 570 reg: CEE_SHL (reg, reg) {
 571         MONO_EMIT_BIALU (s, tree, OP_ISHL, state->reg1, state->left->reg1, state->right->reg1);
 572 }
 573
 574 reg: CEE_SHL (reg, OP_ICONST) {
 575         MONO_EMIT_BIALU_IMM (s, tree, OP_ISHL_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 576 }
 577
 578 reg: CEE_SHR (reg, reg) {
 579         MONO_EMIT_BIALU (s, tree, OP_ISHR, state->reg1, state->left->reg1, state->right->reg1);
 580 }
 581
 582 reg: CEE_SHR (reg, OP_ICONST) {
 583         MONO_EMIT_BIALU_IMM (s, tree, OP_ISHR_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 584 }
 585
 586 reg: CEE_SHR_UN (reg, reg) {
 587         MONO_EMIT_BIALU (s, tree, OP_ISHR_UN, state->reg1, state->left->reg1, state->right->reg1);
 588 }
 589
 590 reg: CEE_SHR_UN (reg, OP_ICONST) {
 591         MONO_EMIT_BIALU_IMM (s, tree, OP_ISHR_UN_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 592 }
 593
 594 #
 595 # mult/div operations
 596 #
 597
 598 reg: CEE_MUL (reg, reg) {
 599         MONO_EMIT_BIALU (s, tree, OP_IMUL, state->reg1, state->left->reg1, state->right->reg1);
 600 }
 601
 602 reg: CEE_MUL (reg, OP_ICONST) {
 603         MONO_EMIT_BIALU_IMM (s, tree, OP_IMUL_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 604 }
 605
 606 reg: CEE_MUL_OVF (reg, reg) {
 607         MONO_EMIT_BIALU (s, tree, OP_IMUL_OVF, state->reg1, state->left->reg1, state->right->reg1);
 608 }
 609
 610 reg: CEE_MUL_OVF_UN (reg, reg) {
 611         MONO_EMIT_BIALU (s, tree, OP_IMUL_OVF_UN, state->reg1, state->left->reg1, state->right->reg1);
 612 }
 613
 614 reg: CEE_DIV (reg, reg) {
 615         MONO_EMIT_BIALU (s, tree, OP_IDIV, state->reg1, state->left->reg1, state->right->reg1);
 616 }
 617
 618 #reg: CEE_DIV (reg, OP_ICONST) {
 619 #       MONO_EMIT_BIALU_IMM (s, tree, OP_IDIV_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 620 #}
 621
 622 reg: CEE_DIV_UN (reg, reg) {
 623         MONO_EMIT_BIALU (s, tree, OP_IDIV_UN, state->reg1, state->left->reg1, state->right->reg1);
 624 }
 625
 626 #reg: CEE_DIV_UN (reg, OP_ICONST) {
 627 #       MONO_EMIT_BIALU_IMM (s, tree, OP_IDIV_UN_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 628 #}
 629
 630 reg: CEE_REM (reg, reg) {
 631         MONO_EMIT_BIALU (s, tree, OP_IREM, state->reg1, state->left->reg1, state->right->reg1);
 632 }
 633
 634 #reg: CEE_REM (reg, OP_ICONST) {
 635 #       MONO_EMIT_BIALU_IMM (s, tree, OP_IREM_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 636 #}
 637
 638 reg: CEE_REM_UN (reg, reg) {
 639         MONO_EMIT_BIALU (s, tree, OP_IREM_UN, state->reg1, state->left->reg1, state->right->reg1);
 640 }
 641
 642 #reg: CEE_REM_UN (reg, OP_ICONST) {
 643 #       MONO_EMIT_BIALU_IMM (s, tree, OP_IREM_UN_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 644 #}
 645
 646 c32flags: OP_COMPARE (reg, reg) {
 647         tree->opcode = OP_ICOMPARE;
 648         tree->sreg1 = state->left->reg1;
 649         tree->sreg2 = state->right->reg1;
 650         mono_bblock_add_inst (s->cbb, tree);
 651 }
 652
 653 c32flags: OP_COMPARE (CEE_LDIND_I (OP_REGVAR), CEE_LDIND_I (OP_REGVAR)) {
 654         tree->opcode = OP_ICOMPARE;
 655         tree->sreg1 = state->left->left->tree->dreg;
 656         tree->sreg2 = state->right->left->tree->dreg;
 657         mono_bblock_add_inst (s->cbb, tree);
 658 }
 659
 660 c32flags: OP_COMPARE (CEE_LDIND_I (OP_REGVAR), OP_ICONST) {
 661         tree->opcode = OP_ICOMPARE_IMM;
 662         tree->sreg1 = state->left->left->tree->dreg;
 663         tree->inst_imm = state->right->tree->inst_c0;
 664         mono_bblock_add_inst (s->cbb, tree);
 665 }
 666
 667 c32flags: OP_COMPARE (CEE_LDIND_I4 (OP_REGVAR), reg) {
 668         tree->opcode = OP_ICOMPARE;
 669         tree->sreg1 = state->left->left->tree->dreg;
 670         tree->sreg2 = state->right->reg1;
 671         mono_bblock_add_inst (s->cbb, tree);
 672 }
 673
 674 c32flags: OP_COMPARE (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST) {
 675         tree->opcode = OP_ICOMPARE_IMM;
 676         tree->sreg1 = state->left->left->tree->dreg;
 677         tree->inst_imm = state->right->tree->inst_c0;
 678         mono_bblock_add_inst (s->cbb, tree);
 679 }
 680
 681 c32flags: OP_COMPARE (reg, OP_ICONST) {
 682         tree->opcode = OP_ICOMPARE_IMM;
 683         tree->sreg1 = state->left->reg1;
 684         tree->inst_imm = state->right->tree->inst_c0;
 685         mono_bblock_add_inst (s->cbb, tree);
 686 }
 687
 688 stmt: CEE_BNE_UN (c32flags) {
 689         tree->opcode = OP_IBNE_UN;
 690         mono_bblock_add_inst (s->cbb, tree);
 691 }
 692
 693 stmt: CEE_BEQ (c32flags) {
 694         tree->opcode = OP_IBEQ;
 695         mono_bblock_add_inst (s->cbb, tree);
 696 }
 697
 698 stmt: CEE_BLT (c32flags) {
 699         tree->opcode = OP_IBLT;
 700         mono_bblock_add_inst (s->cbb, tree);
 701 }
 702
 703 stmt: CEE_BLT_UN (c32flags) {
 704         tree->opcode = OP_IBLT_UN;
 705         mono_bblock_add_inst (s->cbb, tree);
 706 }
 707
 708 stmt: CEE_BGT (c32flags) {
 709         tree->opcode = OP_IBGT;
 710         mono_bblock_add_inst (s->cbb, tree);
 711 }
 712
 713 stmt: CEE_BGT_UN (c32flags) {
 714         tree->opcode = OP_IBGT_UN;
 715         mono_bblock_add_inst (s->cbb, tree);
 716 }
 717
 718 stmt: CEE_BGE  (c32flags) {
 719         tree->opcode = OP_IBGE;
 720         mono_bblock_add_inst (s->cbb, tree);
 721 }
 722
 723 stmt: CEE_BGE_UN (c32flags) {
 724         tree->opcode = OP_IBGE_UN;
 725         mono_bblock_add_inst (s->cbb, tree);
 726 }
 727
 728 stmt: CEE_BLE  (c32flags) {
 729         tree->opcode = OP_IBLE;
 730         mono_bblock_add_inst (s->cbb, tree);
 731 }
 732
 733 stmt: CEE_BLE_UN (c32flags) {
 734         tree->opcode = OP_IBLE_UN;
 735         mono_bblock_add_inst (s->cbb, tree);
 736 }
 737
 738 reg: OP_CEQ (c32flags) {
 739         tree->opcode = OP_ICEQ;
 740         tree->dreg = state->reg1;
 741         mono_bblock_add_inst (s->cbb, tree);
 742 }
 743
 744 reg: OP_CLT (c32flags) {
 745         tree->opcode = OP_ICLT;
 746         tree->dreg = state->reg1;
 747         mono_bblock_add_inst (s->cbb, tree);
 748 }
 749
 750 reg: OP_CLT_UN (c32flags) {
 751         tree->opcode = OP_ICLT_UN;
 752         tree->dreg = state->reg1;
 753         mono_bblock_add_inst (s->cbb, tree);
 754 }
 755
 756 reg: OP_CGT (c32flags) {
 757         tree->opcode = OP_ICGT;
 758         tree->dreg = state->reg1;
 759         mono_bblock_add_inst (s->cbb, tree);
 760 }
 761
 762 reg: OP_CGT_UN (c32flags) {
 763         tree->opcode = OP_ICGT_UN;
 764         tree->dreg = state->reg1;
 765         mono_bblock_add_inst (s->cbb, tree);
 766 }
 767
 768 %%