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