mono/mini/inssel-alpha.brg

   1
   2 %%
   3
   4 #
   5 # inssel-alpha.brg: burg file for special Alpha instructions
   6 #
   7 # Author:
   8 #   Sergey Tikhonov (tsv@solvo.ru)
   9 #
  10 # Derived work from other arches
  11 #
  12 #
  13
  14
  15 stmt: OP_OUTARG_REG (reg) {
  16         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
  17
  18         tree->opcode = OP_MOVE;
  19         tree->sreg1 = state->left->reg1;
  20         tree->dreg = mono_regstate_next_int (s->rs);
  21         mono_bblock_add_inst (s->cbb, tree);
  22
  23         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
  24 }
  25
  26 stmt: OP_OUTARG_FREG (freg) {
  27         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
  28
  29         tree->opcode = OP_FMOVE;
  30         tree->sreg1 = state->left->reg1;
  31         tree->dreg = mono_regstate_next_float (s->rs);
  32         mono_bblock_add_inst (s->cbb, tree);
  33
  34         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
  35 }
  36
  37 stmt: OP_SETRET (reg) {
  38         tree->opcode = OP_MOVE;
  39         tree->sreg1 = state->left->reg1;
  40         tree->dreg = alpha_r0;
  41         mono_bblock_add_inst (s->cbb, tree);
  42 }
  43
  44 stmt: OP_SETRET (freg) {
  45         tree->opcode = OP_FMOVE;
  46         tree->sreg1 = state->left->reg1;
  47         tree->dreg = alpha_f0;
  48         mono_bblock_add_inst (s->cbb, tree);
  49 }
  50
  51
  52 reg: OP_LOCALLOC (OP_ICONST) {
  53         /* microcoded in mini-arm.c */
  54         tree->sreg1 = mono_regstate_next_int (s->rs);
  55         tree->dreg = state->reg1;
  56
  57         if (tree->flags & MONO_INST_INIT)
  58             tree->sreg2 = mono_regstate_next_int (s->rs);
  59
  60         MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
  61         mono_bblock_add_inst (s->cbb, tree);
  62 }
  63
  64 reg: OP_LOCALLOC (reg) {
  65         tree->dreg = state->reg1;
  66         tree->sreg1 = state->left->reg1;
  67
  68         if (tree->flags & MONO_INST_INIT)
  69             tree->sreg2 = mono_regstate_next_int (s->rs);
  70
  71         mono_bblock_add_inst (s->cbb, tree);
  72 }
  73
  74
  75 # This handles trees like outarg_vt (refanytype)
  76 #stmt: OP_OUTARG_VT (reg, base) {
  77 #        MonoInst *stack_addr = state->right->tree;
  78 #
  79 #        MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG,
  80 #       stack_addr->inst_basereg, stack_addr->inst_offset, state->left->reg1);
  81 #}
  82
  83
  84 stmt: OP_OUTARG_REG (CEE_LDIND_I (base)),
  85 stmt: OP_OUTARG_REG (CEE_LDIND_REF (base)),
  86 stmt: OP_OUTARG_REG (CEE_LDIND_I1 (base)),
  87 stmt: OP_OUTARG_REG (CEE_LDIND_U1 (base)),
  88 stmt: OP_OUTARG_REG (CEE_LDIND_I2 (base)),
  89 stmt: OP_OUTARG_REG (CEE_LDIND_U2 (base)),
  90 stmt: OP_OUTARG_REG (CEE_LDIND_I4 (base)),
  91 stmt: OP_OUTARG_REG (CEE_LDIND_U4 (base)),
  92 stmt: OP_OUTARG_REG (CEE_LDIND_I8 (base)) {
  93         /* FIXME: Move this to inssel.brg or inssel-long.brg */
  94         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
  95         guint32 dreg;
  96         MonoInst *base = state->left->left->tree;
  97
  98         dreg = mono_regstate_next_int (s->rs);
  99         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, ldind_to_load_membase (state->left->tree->opcode),
 100                                         dreg, base->inst_basereg, base->inst_offset);
 101
 102         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 103 }
 104
 105 stmt: OP_OUTARG_REG (OP_I8CONST) {
 106         /* FIXME: Move this to inssel.brg or inssel-long.brg */
 107         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 108
 109         tree->opcode = OP_I8CONST;
 110         tree->inst_c0 = state->left->tree->inst_c0;
 111         tree->dreg = mono_regstate_next_int (s->rs);
 112         mono_bblock_add_inst (s->cbb, tree);
 113
 114         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 115 }
 116
 117 stmt: OP_OUTARG_REG (OP_ICONST) {
 118         /* FIXME: Move this to inssel.brg or inssel-long.brg */
 119         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 120
 121         tree->opcode = OP_ICONST;
 122         tree->inst_c0 = state->left->tree->inst_c0;
 123         tree->dreg = mono_regstate_next_int (s->rs);
 124         mono_bblock_add_inst (s->cbb, tree);
 125
 126         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 127 }
 128
 129 stmt: OP_OUTARG_REG (CEE_LDIND_I (OP_REGVAR)),
 130 stmt: OP_OUTARG_REG (CEE_LDIND_I8 (OP_REGVAR)),
 131 stmt: OP_OUTARG_REG (CEE_LDIND_I4 (OP_REGVAR)),
 132 stmt: OP_OUTARG_REG (CEE_LDIND_U4 (OP_REGVAR)),
 133 stmt: OP_OUTARG_REG (CEE_LDIND_REF (OP_REGVAR)) {
 134         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 135
 136         tree->opcode = OP_MOVE;
 137         tree->sreg1 = state->left->left->tree->dreg;
 138         tree->dreg = mono_regstate_next_int (s->rs);
 139         mono_bblock_add_inst (s->cbb, tree);
 140
 141         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 142 }
 143
 144 stmt: OP_OUTARG_REG (OP_LDADDR (OP_REGOFFSET)),
 145 stmt: OP_OUTARG_REG (CEE_LDOBJ (OP_REGOFFSET)) {
 146         /* FIXME: Move this to inssel.brg */
 147         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 148
 149         tree->opcode = OP_ADD_IMM;
 150         tree->sreg1 = state->left->left->tree->inst_basereg;
 151         tree->inst_imm = state->left->left->tree->inst_offset;
 152         tree->dreg = mono_regstate_next_int (s->rs);
 153         mono_bblock_add_inst (s->cbb, tree);
 154
 155         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 156 }
 157
 158 stmt: OP_OUTARG (reg) {
 159         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, alpha_sp,
 160                 tree->dreg, state->left->reg1);
 161 }
 162
 163 stmt: OP_OUTARG (freg) {
 164         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, alpha_sp,
 165                 tree->dreg, state->left->reg1);
 166 }
 167
 168 stmt: OP_OUTARG_R4 (freg) {
 169         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, alpha_sp,
 170                 tree->dreg, state->left->reg1);
 171 }
 172
 173 stmt: OP_OUTARG_R8 (freg) {
 174         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, alpha_sp,
 175                 tree->dreg, state->left->reg1);
 176 }
 177
 178 stmt: OP_OUTARG_VT (CEE_LDOBJ (base), base) {
 179         MonoInst *vt = state->left->left->tree;
 180         MonoInst *stack_addr = state->right->tree;
 181         int sz = stack_addr->inst_imm;
 182
 183         if (!sz)
 184                 return;
 185
 186         mini_emit_memcpy (s, stack_addr->inst_basereg, stack_addr->inst_offset,
 187                 vt->inst_basereg, vt->inst_offset, sz, 0);
 188 }
 189
 190 # This handles trees like outarg_vt (refanytype)
 191 stmt: OP_OUTARG_VT (reg, base) {
 192         MonoInst *stack_addr = state->right->tree;
 193
 194         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, stack_addr->inst_basereg, stack_addr->inst_offset, state->left->reg1);
 195 }
 196
 197 stmt: OP_START_HANDLER {
 198         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
 199         tree->inst_left = spvar;
 200         mono_bblock_add_inst (s->cbb, tree);
 201 }
 202
 203 stmt: OP_ENDFINALLY {
 204         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
 205         tree->inst_left = spvar;
 206         mono_bblock_add_inst (s->cbb, tree);
 207 }
 208
 209 stmt: OP_ENDFILTER (reg) {
 210         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
 211         tree->inst_left = spvar;
 212         tree->sreg1 = state->left->reg1;
 213         mono_bblock_add_inst (s->cbb, tree);
 214 }
 215
 216 stmt: OP_SWITCH (reg) {
 217         MonoInst *label;
 218         int offset_reg = mono_regstate_next_int (s->rs);
 219         int target_reg = mono_regstate_next_int (s->rs);
 220         int n = GPOINTER_TO_INT (tree->klass);
 221
 222         MONO_NEW_LABEL (s, label);
 223
 224         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n);
 225         MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]);
 226         if (sizeof (gpointer) == 8)
 227                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg,
 228                         state->left->reg1, 3);
 229         else
 230                 MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg,
 231                         state->left->reg1, 2);
 232         mono_bblock_add_inst (s->cbb, label);
 233         if (s->compile_aot) {
 234                 int table_reg = mono_regstate_next_int (s->rs);
 235                 int sum_reg = mono_regstate_next_int (s->rs);
 236                 MonoJumpInfoBBTable *table;
 237
 238                 table = mono_mempool_alloc (s->mempool,
 239                                 sizeof (MonoJumpInfoBBTable));
 240                 table->table = tree->inst_many_bb;
 241                 table->table_size = n;
 242
 243                 MONO_EMIT_NEW_AOTCONST (s, table_reg, table,
 244                         MONO_PATCH_INFO_SWITCH);
 245
 246                 MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, table_reg,
 247                                 offset_reg);
 248                 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, sum_reg, 0);
 249         } else {
 250                 mono_create_jump_table (s, label, tree->inst_many_bb, n);
 251
 252                 /* On Alpha GP points to the beginning of procedure.
 253                    Here is a sequence:
 254                    unop
 255                    lda at, offset(gp)
 256                    br ... skip two longs
 257                    2 longs = jump table address
 258                    addq at, offset_reg, dest_reg
 259                    br_reg dest_reg */
 260
 261                 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
 262                 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
 263                 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
 264                 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
 265                 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
 266                 MONO_EMIT_NEW_UNALU(s, OP_MOVE, alpha_at, alpha_at);
 267
 268                 MONO_EMIT_NEW_BIALU (s, CEE_ADD, target_reg, alpha_at,
 269                         offset_reg);
 270                 MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg,
 271                         target_reg, 0);
 272
 273                 /* the backend must patch the address.
 274                         we use 0xf0f0f0f0 to avoid the usage
 275                   * of special (short) opcodes on x86
 276                 if (sizeof (gpointer) == 8)
 277                         MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg,
 278                         offset_reg, (long)0xf0f0f0f0f0f0f0f1LL);
 279                 else
 280                         MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg,
 281                         offset_reg, 0xf0f0f0f0);
 282                 */
 283         }
 284         MONO_EMIT_UNALU (s, tree, OP_BR_REG, -1, target_reg);
 285 }
 286
 287 stmt: CEE_STIND_I8 (OP_REGVAR, reg) {
 288         MONO_EMIT_NEW_UNALU (s, OP_MOVE, state->left->tree->dreg,
 289                 state->right->reg1);
 290 }
 291
 292 reg: CEE_LDIND_I1 (OP_REGVAR) {
 293         MONO_EMIT_UNALU (s, tree, OP_SEXT_I1, state->reg1,
 294         state->left->tree->dreg);
 295 }
 296
 297 reg: CEE_LDIND_I2 (OP_REGVAR) {
 298         MONO_EMIT_UNALU (s, tree, OP_SEXT_I2, state->reg1,
 299         state->left->tree->dreg);
 300 }
 301
 302
 303
 304 #stmt: CEE_BEQ (OP_LCOMPARE(reg, OP_I8CONST)) {
 305 #       printf("Found match for CEE_BEQ (OP_LCOMPARE(reg, OP_I8CONST))\n");
 306 #}
 307
 308 # Compare floats sequences (comments from Zoltan Varga)
 309 #
 310 # non-un comparisions should return false if the arguments are not
 311 # comparable, ie. 1.0 < nan is false. The un comparisions are needed
 312 # to implement the opposite of normal comparisions, i.e.
 313 # (a < b) is bl, while !(a < b) is translated into bge.un. This is
 314 # because fp comparirions can return 4 values, not just three: lesser,
 315 # greater, equal or unordered
 316
 317
 318 stmt: CEE_BLT_UN (OP_COMPARE (freg, freg)) {
 319         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 320                 state->left->left->reg1, state->left->right->reg1);
 321         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 322                 state->left->left->reg1, state->left->right->reg1);
 323         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 324
 325         MONO_EMIT_UNALU (s, tree, OP_FBLT_UN, -1, -1);
 326 }
 327
 328 stmt: CEE_BLT (OP_COMPARE (freg, freg)) {
 329         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 330                 state->left->left->reg1, state->left->right->reg1);
 331         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 332                 state->left->left->reg1, state->left->right->reg1);
 333         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 334
 335         MONO_EMIT_UNALU (s, tree, OP_FBLT, -1, -1);
 336 }
 337
 338
 339 stmt: CEE_BLE_UN (OP_COMPARE (freg, freg)) {
 340         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 341                 state->left->left->reg1, state->left->right->reg1);
 342         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
 343                 state->left->left->reg1, state->left->right->reg1);
 344         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 345
 346         MONO_EMIT_UNALU (s, tree, OP_FBLE_UN, -1, -1);
 347 }
 348
 349 stmt: CEE_BLE (OP_COMPARE (freg, freg)) {
 350         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 351                 state->left->left->reg1, state->left->right->reg1);
 352         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
 353                 state->left->left->reg1, state->left->right->reg1);
 354         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 355
 356         MONO_EMIT_UNALU (s, tree, OP_FBLE, -1, -1);
 357 }
 358
 359 stmt: CEE_BGT_UN (OP_COMPARE (freg, freg)) {
 360         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 361                 state->left->left->reg1, state->left->right->reg1);
 362         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
 363                 state->left->left->reg1, state->left->right->reg1);
 364         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 365
 366         MONO_EMIT_UNALU (s, tree, OP_FBGT_UN, -1, -1);
 367 }
 368
 369 stmt: CEE_BGT (OP_COMPARE (freg, freg)) {
 370         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 371                 state->left->left->reg1, state->left->right->reg1);
 372         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LE_SU, alpha_at,
 373                 state->left->left->reg1, state->left->right->reg1);
 374         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 375
 376         MONO_EMIT_UNALU (s, tree, OP_FBGT, -1, -1);
 377 }
 378
 379 stmt: CEE_BGE_UN (OP_COMPARE (freg, freg)) {
 380         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 381                 state->left->left->reg1, state->left->right->reg1);
 382         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 383                 state->left->left->reg1, state->left->right->reg1);
 384         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 385
 386         MONO_EMIT_UNALU (s, tree, OP_FBGE_UN, -1, -1);
 387 }
 388
 389 stmt: CEE_BGE (OP_COMPARE (freg, freg)) {
 390         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 391                 state->left->left->reg1, state->left->right->reg1);
 392         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 393                 state->left->left->reg1, state->left->right->reg1);
 394         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 395
 396         MONO_EMIT_UNALU (s, tree, OP_FBGE, -1, -1);
 397 }
 398
 399 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
 400         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_EQ_SU, alpha_at,
 401                 state->left->left->reg1, state->left->right->reg1);
 402         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 403
 404         tree->dreg = state->reg1;
 405         tree->opcode = OP_FCEQ;
 406         mono_bblock_add_inst (s->cbb, tree);
 407 }
 408
 409 reg: OP_CLT (OP_COMPARE (freg, freg)) {
 410         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 411                 state->left->left->reg1, state->left->right->reg1);
 412         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 413
 414         tree->dreg = state->reg1;
 415         tree->opcode = OP_FCLT;
 416         mono_bblock_add_inst (s->cbb, tree);
 417 }
 418
 419 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
 420         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 421                 state->left->right->reg1, state->left->left->reg1);
 422         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 423                 state->left->left->reg1, state->left->right->reg1);
 424         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 425
 426         tree->dreg = state->reg1;
 427         tree->opcode = OP_FCLT_UN;
 428         mono_bblock_add_inst (s->cbb, tree);
 429 }
 430
 431
 432 reg: OP_CGT (OP_COMPARE (freg, freg)) {
 433 // Same as CLT_n (OP_COMPARE) - just exchange parameters
 434         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 435 //                state->left->left->reg1, state->left->right->reg1);
 436                 state->left->right->reg1, state->left->left->reg1);
 437         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 438
 439 //        tree->opcode = OP_FCGT;
 440         tree->dreg = state->reg1;
 441         tree->opcode = OP_FCLT;
 442         mono_bblock_add_inst (s->cbb, tree);
 443 }
 444
 445 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
 446 // Same as above
 447         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 448                 state->left->right->reg1, state->left->left->reg1);
 449         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_LT_SU, alpha_at,
 450                 state->left->right->reg1, state->left->left->reg1);
 451         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 452
 453         tree->dreg = state->reg1;
 454         tree->opcode = OP_FCLT_UN;
 455         mono_bblock_add_inst (s->cbb, tree);
 456 }
 457
 458
 459 stmt: CEE_BEQ (OP_COMPARE (freg, freg)) {
 460         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_EQ_SU, alpha_at,
 461                 state->left->left->reg1, state->left->right->reg1);
 462         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 463
 464         MONO_EMIT_UNALU (s, tree, OP_FBEQ, -1, -1);
 465 }
 466
 467 stmt: CEE_BNE_UN (OP_COMPARE (freg, freg)) {
 468         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_UN_SU, (alpha_at+1),
 469                 state->left->left->reg1, state->left->right->reg1);
 470         MONO_EMIT_NEW_BIALU (s, OP_ALPHA_CMPT_EQ_SU, alpha_at,
 471                 state->left->left->reg1, state->left->right->reg1);
 472         MONO_EMIT_NEW_UNALU (s, OP_ALPHA_TRAPB, -1, -1);
 473
 474         MONO_EMIT_UNALU (s, tree, OP_FBNE_UN, -1, -1);
 475 }
 476
 477
 478 fpcflags: OP_COMPARE (freg, freg) {
 479         tree->opcode = OP_FCOMPARE;
 480         mono_bblock_add_inst (s->cbb, tree);
 481 }
 482 reg: OP_CEQ (fpcflags) {
 483         tree->dreg = state->reg1;
 484         tree->opcode = OP_FCEQ;
 485         mono_bblock_add_inst (s->cbb, tree);
 486 }
 487
 488 reg: OP_CLT (fpcflags) {
 489         tree->dreg = state->reg1;
 490         tree->opcode = OP_FCLT;
 491         mono_bblock_add_inst (s->cbb, tree);
 492 }
 493
 494 reg: OP_CLT_UN (fpcflags) {
 495         tree->dreg = state->reg1;
 496         tree->opcode = OP_FCLT_UN;
 497         mono_bblock_add_inst (s->cbb, tree);
 498 }
 499
 500 reg: OP_CGT (fpcflags) {
 501         tree->dreg = state->reg1;
 502         tree->opcode = OP_FCGT;
 503         mono_bblock_add_inst (s->cbb, tree);
 504 }
 505
 506 reg: OP_CGT_UN (fpcflags) {
 507         tree->dreg = state->reg1;
 508         tree->opcode = OP_FCGT_UN;
 509         mono_bblock_add_inst (s->cbb, tree);
 510 }
 511
 512 reg: OP_LCONV_TO_I4 (reg) "0" {
 513         /* Sign extend the value in the lower word into the upper word */
 514         MONO_EMIT_BIALU_IMM (s, tree, CEE_CONV_I4, state->reg1,
 515                 state->left->reg1, 0);
 516 }
 517
 518 reg: OP_LCONV_TO_U4 (reg) "0" {
 519         /* Clean out the upper word */
 520         MONO_EMIT_BIALU_IMM (s, tree, CEE_CONV_U4, state->reg1,
 521                 state->left->reg1, 0);
 522 }
 523
 524 freg: OP_LCONV_TO_R8 (reg) {
 525         /* FIXME: Move this inssel-long.brg */
 526         tree->sreg1 = state->left->reg1;
 527         tree->dreg = state->reg1;
 528         mono_bblock_add_inst (s->cbb, tree);
 529 }
 530
 531 freg: OP_LCONV_TO_R4 (reg) {
 532         /* FIXME: Move this inssel-long.brg */
 533         tree->sreg1 = state->left->reg1;
 534         tree->dreg = state->reg1;
 535         mono_bblock_add_inst (s->cbb, tree);
 536 }
 537
 538 reg: CEE_LDIND_REF (OP_REGVAR),
 539 reg: CEE_LDIND_I (OP_REGVAR),
 540 reg: CEE_LDIND_I8 (OP_REGVAR),
 541 reg: CEE_LDIND_I4 (OP_REGVAR),
 542 reg: CEE_LDIND_U4 (OP_REGVAR) "0" {
 543         state->reg1 = state->left->tree->dreg;
 544         tree->dreg = state->reg1;
 545 }
 546