mono/mini/inssel-s390x.brg

   1 %%
   2
   3 #
   4 # inssel-s390x.brg: burg file for special s390 instructions
   5 #
   6 # Author:
   7 #   Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com)
   8 #   Dietmar Maurer (dietmar@ximian.com)
   9 #   Paolo Molaro (lupus@ximian.com)
  10 #
  11 # (C) 2002 Ximian, Inc.
  12 #
  13
  14 stmt: OP_START_HANDLER {
  15         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  16         tree->inst_left = spvar;
  17         mono_bblock_add_inst (s->cbb, tree);
  18 }
  19
  20 stmt: OP_ENDFINALLY {
  21         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  22         tree->inst_left = spvar;
  23         mono_bblock_add_inst (s->cbb, tree);
  24 }
  25
  26 stmt: OP_ENDFILTER (reg) {
  27         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  28         tree->inst_left = spvar;
  29         tree->sreg1 = state->left->reg1;
  30         mono_bblock_add_inst (s->cbb, tree);
  31 }
  32
  33 reg: OP_LADD_OVF (reg, reg),
  34 reg: OP_LADD_OVF_UN (reg, reg),
  35 reg: OP_LSUB_OVF (reg, reg),
  36 reg: OP_LSUB_OVF_UN (reg, reg) "0" {
  37         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
  38 }
  39
  40 reg: CEE_ADD_OVF (reg, reg) "0" {
  41         MONO_EMIT_BIALU (s, tree, OP_IADD_OVF, state->reg1, state->left->reg1, state->right->reg1);
  42 }
  43
  44 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
  45         MONO_EMIT_BIALU (s, tree, OP_IADD_OVF_UN, state->reg1, state->left->reg1, state->right->reg1);
  46 }
  47
  48 reg: CEE_SUB_OVF (reg, reg) "0" {
  49         MONO_EMIT_BIALU (s, tree, OP_ISUB_OVF, state->reg1, state->left->reg1, state->right->reg1);
  50 }
  51
  52 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
  53         MONO_EMIT_BIALU (s, tree, OP_ISUB_OVF_UN, state->reg1, state->left->reg1, state->right->reg1);
  54 }
  55
  56 stmt: CEE_STIND_I8 (OP_REGVAR, reg) {
  57         MONO_EMIT_NEW_UNALU (s, OP_MOVE, state->left->tree->dreg, state->right->reg1);
  58 }
  59
  60 reg: CEE_LDIND_I8 (OP_REGVAR) {
  61         state->reg1 = state->left->tree->dreg;
  62 }
  63
  64 freg: OP_LCONV_TO_R8 (lreg) {
  65         tree->dreg = state->reg1;
  66         tree->sreg1 = state->left->reg1;
  67         tree->sreg2 = state->left->reg2;
  68         mono_bblock_add_inst (s->cbb, tree);
  69 }
  70
  71 freg: OP_LCONV_TO_R4 (lreg) {
  72         tree->dreg = state->reg1;
  73         tree->sreg1 = state->left->reg1;
  74         tree->sreg2 = state->left->reg2;
  75         mono_bblock_add_inst (s->cbb, tree);
  76 }
  77
  78 freg: CEE_CONV_R_UN (reg) {
  79         tree->dreg = state->reg1;
  80         tree->sreg1 = state->left->reg1;
  81         mono_bblock_add_inst (s->cbb, tree);
  82 }
  83
  84 freg: CEE_CONV_R_UN (reg) {
  85         mono_bblock_add_inst (s->cbb, tree);
  86 }
  87
  88 stmt: OP_MEMCPY (reg, reg) "0" {
  89         int size = tree->backend.memcpy_args->size;
  90         if (size > 0)
  91                 MONO_EMIT_NEW_MOVE (s, state->left->reg1, 0, state->right->reg1, 0, size);
  92 }
  93
  94 stmt: OP_MEMCPY (base, base) "0" {
  95         int size = tree->backend.memcpy_args->size;
  96         if (size > 0)
  97                 MONO_EMIT_NEW_MOVE (s, state->left->tree->sreg1,
  98                                     state->left->tree->inst_offset,
  99                                     state->right->tree->sreg1,
 100                                     state->right->tree->inst_offset,
 101                                     size);
 102 }
 103
 104 reg: OP_LOCALLOC (OP_ICONST) {
 105         /* microcoded in mini-s390.c */
 106         tree->sreg1 = mono_regstate_next_int (s->rs);
 107         tree->dreg  = state->reg1;
 108         MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
 109         mono_bblock_add_inst (s->cbb, tree);
 110 }
 111
 112 reg: OP_LOCALLOC (reg) {
 113         tree->dreg = state->reg1;
 114         tree->sreg1 = state->left->reg1;
 115         mono_bblock_add_inst (s->cbb, tree);
 116 }
 117
 118 stmt: OP_SETRET (reg) {
 119         tree->opcode = OP_MOVE;
 120         tree->sreg1 = state->left->reg1;
 121         tree->dreg = s390_r2;
 122         mono_bblock_add_inst (s->cbb, tree);
 123 }
 124
 125 stmt: OP_SETRET (freg) {
 126         if (mono_method_signature (s->method)->ret->type == MONO_TYPE_R4) {
 127                 tree->opcode = OP_S390_SETF4RET;
 128                 tree->sreg1  = state->left->reg1;
 129         } else {
 130                 tree->opcode = OP_FMOVE;
 131             tree->dreg = s390_f0;
 132                 tree->sreg1  = state->left->reg1;
 133         }
 134         mono_bblock_add_inst (s->cbb, tree);
 135 }
 136
 137 stmt: OP_SETRET (OP_ICONST) {
 138         tree->opcode = OP_ICONST;
 139         tree->inst_c0 = state->left->tree->inst_c0;
 140         tree->dreg = s390_r2;
 141         mono_bblock_add_inst (s->cbb, tree);
 142 }
 143
 144 stmt: OP_OUTARG (reg) {
 145         MonoCallInst *call = (MonoCallInst*) tree->inst_right;
 146
 147         tree->opcode = OP_MOVE;
 148         tree->dreg   = mono_regstate_next_int (s->rs);
 149         tree->sreg1  = state->left->reg1;
 150         mono_bblock_add_inst (s->cbb, tree);
 151
 152         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 153 }
 154
 155 stmt: OP_OUTARG_MEMBASE (reg) {
 156         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 157
 158         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE,
 159                                      arg->offset, state->left->reg1);
 160 }
 161
 162 stmt: OP_OUTARG (OP_REGVAR) {
 163         MonoCallInst *call = (MonoCallInst*) tree->inst_right;
 164
 165         tree->opcode       = OP_MOVE;
 166         tree->dreg         = mono_regstate_next_int (s->rs);
 167         tree->sreg1        = state->left->tree->dreg;
 168         mono_bblock_add_inst (s->cbb, tree);
 169
 170         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 171 }
 172
 173 stmt: OP_OUTARG_MEMBASE (OP_REGVAR) {
 174         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 175
 176         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE,
 177                                      arg->offset, state->left->tree->dreg);
 178 }
 179
 180 stmt: OP_OUTARG (OP_I8CONST),
 181 stmt: OP_OUTARG (OP_ICONST) {
 182         MonoCallInst *call = (MonoCallInst*) tree->inst_right;
 183
 184         tree->opcode       = OP_ICONST;
 185         tree->dreg         = mono_regstate_next_int (s->rs);
 186         tree->inst_c0      = state->left->tree->inst_c0;
 187         mono_bblock_add_inst (s->cbb, tree);
 188
 189         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 190 }
 191
 192 stmt: OP_OUTARG_MEMBASE (OP_ICONST) {
 193         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 194
 195         MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, STK_BASE,
 196                                          arg->offset, state->left->tree->inst_c0);
 197 }
 198
 199 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
 200         MonoCallInst *call = (MonoCallInst*) tree->inst_right;
 201
 202         tree->opcode       = OP_MOVE;
 203         tree->sreg1        = state->left->left->tree->dreg;
 204         tree->dreg         = mono_regstate_next_int (s->rs);
 205         mono_bblock_add_inst (s->cbb, tree);
 206
 207         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 208 }
 209
 210 stmt: OP_OUTARG_MEMBASE (CEE_LDIND_REF (OP_REGVAR)) {
 211         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 212
 213         MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, STK_BASE,
 214                                          arg->offset, state->left->tree->inst_c0);
 215 }
 216
 217 stmt: OP_OUTARG_MEMBASE (OP_LDADDR (OP_S390_LOADARG)) {
 218         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 219
 220         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE,
 221                                      arg->offset, state->left->left->tree->dreg);
 222 }
 223
 224 freg: OP_FCONV_TO_R4 (freg) "0" {
 225         MONO_EMIT_UNALU (s, tree, OP_FMOVE, state->reg1, state->left->reg1);
 226 }
 227
 228 stmt: OP_OUTARG_R4 (freg) {
 229         MonoCallInst *call = (MonoCallInst*) tree->inst_right;
 230
 231         tree->opcode = OP_S390_SETF4RET;
 232         tree->dreg   = mono_regstate_next_float (s->rs);
 233         tree->sreg1  = state->left->reg1;
 234         mono_bblock_add_inst (s->cbb, tree);
 235
 236         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
 237 }
 238
 239 stmt: OP_OUTARG_R8 (freg),
 240 stmt: OP_OUTARG (freg) {
 241         MonoCallInst *call = (MonoCallInst*) tree->inst_right;
 242
 243         tree->opcode = OP_FMOVE;
 244         tree->dreg   = mono_regstate_next_float (s->rs);
 245         tree->sreg1  = state->left->reg1;
 246         mono_bblock_add_inst (s->cbb, tree);
 247
 248         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
 249 }
 250
 251 stmt: OP_OUTARG_MEMBASE (freg) {
 252         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 253
 254         /*----------------------------------------------*/
 255         /* The length stored in size tells us whether   */
 256         /* we need to store a float or a double         */
 257         /*----------------------------------------------*/
 258         if (arg->size == 4) {
 259                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG,
 260                                              STK_BASE, arg->offset+4,
 261                                              state->left->reg1);
 262         } else {
 263                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG,
 264                                              STK_BASE, arg->offset,
 265                                              state->left->reg1);
 266         }
 267 }
 268
 269 stmt: OP_OUTARG_R4 (CEE_LDOBJ (OP_REGOFFSET)),
 270 stmt: OP_OUTARG_R8 (CEE_LDOBJ (OP_REGOFFSET)) {
 271         MonoCallInst *call = (MonoCallInst*) tree->inst_right;
 272
 273         tree->opcode = OP_FMOVE;
 274         tree->dreg   = mono_regstate_next_float (s->rs);
 275         tree->sreg1  = state->left->reg1;
 276         mono_bblock_add_inst (s->cbb, tree);
 277
 278         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
 279 }
 280
 281 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
 282         MonoCallInst *call   = (MonoCallInst*) tree->inst_right;
 283         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 284         MonoInst *vt         = state->left->left->tree;
 285
 286         int start_reg = tree->sreg1;
 287         int size      = arg->size;
 288         int soffset   = vt->inst_offset;
 289         int treg;
 290
 291         if (size < 0) {
 292                 size = -size;
 293                 treg = mono_regstate_next_int (s->rs);
 294                 MONO_EMIT_NEW_MOVE(s, STK_BASE, arg->offPrm,
 295                                    vt->inst_basereg, soffset, size);
 296                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, STK_BASE, arg->offPrm);
 297                 if (start_reg != STK_BASE) {
 298                         mono_call_inst_add_outarg_reg (s, call, treg, start_reg, FALSE);
 299                 } else {
 300                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 301                                                      STK_BASE, arg->offset, treg);
 302                 }
 303         } else {
 304                 if (start_reg != STK_BASE) {
 305                         MONO_OUTPUT_VTR (s, size, start_reg, vt->inst_basereg, soffset);
 306                 } else {
 307                         MONO_OUTPUT_VTS (s, size, STK_BASE, arg->offset,
 308                                          vt->inst_basereg, soffset);
 309                 }
 310         }
 311 }
 312
 313 stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_S390_ARGPTR)) {
 314         MonoCallInst *call   = (MonoCallInst*) tree->inst_right;
 315         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 316         MonoInst *vt         = state->left->left->tree;
 317
 318         int start_reg = tree->sreg1;
 319         int size      = arg->size;
 320         int soffset   = vt->inst_offset;
 321
 322 //printf("OP_OUTARG_VT(CEE_LDOBJ(OP_S390_ARGPTR))\n");
 323         if (start_reg != STK_BASE) {
 324                 MONO_OUTPUT_VTR (s, size, start_reg, vt->inst_basereg, soffset);
 325         } else {
 326                 MONO_OUTPUT_VTS (s, size, STK_BASE, arg->offset,
 327                                  vt->inst_basereg, soffset);
 328         }
 329 }
 330
 331 stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_REGOFFSET)) "0" {
 332         MonoCallInst *call   = (MonoCallInst*) tree->inst_right;
 333         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 334         MonoInst *vt         = state->left->left->tree;
 335
 336         int start_reg = tree->sreg1;
 337         int size      = arg->size;
 338         int soffset   = vt->inst_offset;
 339         int treg;
 340
 341 //printf("OP_OUTARG_VT(CEE_LDOBJ(OP_REGOFFSET))\n");
 342         if (size < 0) {
 343                 size = -size;
 344                 treg = mono_regstate_next_int (s->rs);
 345                 MONO_EMIT_NEW_MOVE (s, STK_BASE, arg->offPrm,
 346                                     vt->inst_basereg, soffset, size);
 347                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, STK_BASE, arg->offPrm);
 348                 if (start_reg != STK_BASE) {
 349                         mono_call_inst_add_outarg_reg (s, call, treg, start_reg, FALSE);
 350                 } else {
 351                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 352                                                      STK_BASE, arg->offset, treg);
 353                 }
 354         } else {
 355                 if (start_reg != STK_BASE) {
 356                         MONO_OUTPUT_VTR(s, size, start_reg, vt->inst_basereg, soffset);
 357                 } else {
 358                         MONO_OUTPUT_VTS(s, size, STK_BASE, arg->offset,
 359                                           vt->inst_basereg, soffset);
 360                 }
 361         }
 362 }
 363
 364 stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_S390_LOADARG)) {
 365         MonoCallInst *call   = (MonoCallInst*) tree->inst_right;
 366         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 367         MonoInst *vt         = state->left->left->tree;
 368
 369         int start_reg = tree->inst_basereg;
 370         int size      = -arg->size;
 371         int soffset   = vt->inst_offset;
 372         int treg;
 373
 374 //printf("OP_OUTARG_VT(CEE_LDOBJ(OP_S390_LOADARG))\n");
 375         treg = mono_regstate_next_int (s->rs);
 376         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, treg, s->frame_reg);
 377         MONO_EMIT_NEW_LOAD_MEMBASE (s, treg, treg, vt->backend.arg_info);
 378         MONO_EMIT_NEW_MOVE (s, STK_BASE, soffset, treg, 0, size);
 379         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, STK_BASE, soffset);
 380         if (start_reg != STK_BASE) {
 381                 mono_call_inst_add_outarg_reg (s, call, treg, start_reg, FALSE);
 382         } else {
 383                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 384                                              STK_BASE, arg->offset, treg);
 385         }
 386 }
 387
 388 stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_S390_ARGREG)) {
 389         MonoCallInst *call   = (MonoCallInst*) tree->inst_right;
 390         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 391         MonoInst *vt         = state->left->left->tree;
 392
 393         int start_reg = tree->inst_basereg;
 394         int size      = -arg->size;
 395         int soffset   = vt->inst_offset;
 396         int treg;
 397
 398 //printf("OP_OUTARG_VT(CEE_LDOBJ(OP_S390_ARGREG))\n");
 399         treg = mono_regstate_next_int (s->rs);
 400         MONO_EMIT_NEW_LOAD_MEMBASE (s, treg, s->frame_reg, soffset);
 401         MONO_EMIT_NEW_MOVE (s, STK_BASE, arg->offPrm, treg, 0, size);
 402         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, STK_BASE, arg->offPrm);
 403         if (start_reg != STK_BASE) {
 404                 mono_call_inst_add_outarg_reg (s, call, treg, start_reg, FALSE);
 405         } else {
 406                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 407                                              STK_BASE, arg->offset, treg);
 408         }
 409 }
 410
 411 stmt: OP_OUTARG_VT (OP_ICONST) {
 412         MonoCallInst *call   = (MonoCallInst*) tree->inst_right;
 413         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 414
 415         int start_reg = tree->sreg1;
 416         int size      = arg->size;
 417         int nregs     = size / 4;
 418
 419 //printf("OP_OUTARG_VT(OP_ICONST) %d\n",nregs);
 420         if (start_reg != STK_BASE) {
 421                 if (nregs) {
 422                         tree->opcode  = OP_ICONST;
 423                         tree->dreg    = mono_regstate_next_int (s->rs);
 424                         tree->inst_c0 = state->left->tree->inst_c0;
 425                         mono_bblock_add_inst (s->cbb, tree);
 426                         mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
 427                 }
 428         } else {
 429                 MONO_OUTPUT_VTS (s, size, STK_BASE, tree->inst_c0,
 430                                  s->frame_reg, tree->inst_offset);
 431         }
 432 }
 433
 434 stmt: OP_OUTARG_VT (reg) {
 435         MonoCallInst *call   = (MonoCallInst*) tree->inst_right;
 436         MonoCallArgParm *arg = (MonoCallArgParm *) tree;
 437         MonoInst *vt         = state->left->left->tree;
 438         int start_reg        = tree->sreg1;
 439         int size             = arg->size;
 440         int soffset          = vt->inst_offset;
 441         int treg;
 442
 443         if (size < 0) {
 444                 size = -size;
 445                 treg = mono_regstate_next_int (s->rs);
 446                 if (start_reg != STK_BASE) {
 447 //printf("OP_OUTARG_VT(reg) 1\n");
 448                         MONO_EMIT_NEW_MOVE (s, STK_BASE, arg->offPrm, state->left->reg1,
 449                                             0, size);
 450                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg,
 451                                                  STK_BASE, arg->offPrm);
 452                         mono_call_inst_add_outarg_reg (s, call, treg, start_reg, FALSE);
 453                 } else {
 454 //printf("OP_OUTARG_VT(reg) 1\n");
 455                         MONO_EMIT_NEW_MOVE (s, STK_BASE, soffset+size, state->left->reg1,
 456                                             0, size);
 457                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, STK_BASE,
 458                                                  soffset+size);
 459                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 460                                                      STK_BASE, arg->offset, treg);
 461                 }
 462         } else {
 463                 if (start_reg != STK_BASE) {
 464                         MONO_OUTPUT_VTR (s, size, start_reg, STK_BASE, soffset);
 465                 } else {
 466 //printf("OP_OUTARG_VT(reg) 2\n");
 467                         treg = mono_regstate_next_int (s->rs);
 468                         MONO_OUTPUT_VTS (s, size, STK_BASE, soffset, treg,
 469                                          state->left->tree->inst_offset);
 470                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, STK_BASE,
 471                                                  s->stack_offset);
 472                 }
 473         }
 474 }
 475
 476 stmt: OP_OUTARG_VT (OP_REFANYTYPE (reg)) "0" {
 477 //printf("OP_OUTARG_VT (OP_REFANYTYPE (base))\n");
 478         MONO_EMIT_NEW_LOAD_MEMBASE (s, state->tree->sreg1, state->left->left->reg1,
 479                                     G_STRUCT_OFFSET (MonoTypedRef, type));
 480 }
 481
 482 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
 483         /* nothing to do: the value is already on the FP stack */
 484 }
 485
 486 stmt: CEE_BNE_UN (fpcflags) {
 487         tree->opcode = OP_FBNE_UN;
 488         mono_bblock_add_inst (s->cbb, tree);
 489 }
 490
 491 stmt: CEE_BEQ (fpcflags) {
 492         tree->opcode = OP_FBEQ;
 493         mono_bblock_add_inst (s->cbb, tree);
 494 }
 495
 496 stmt: CEE_BLT (fpcflags) {
 497         tree->opcode = OP_FBLT;
 498         mono_bblock_add_inst (s->cbb, tree);
 499 }
 500
 501 stmt: CEE_BLT_UN (fpcflags) {
 502         tree->opcode = OP_FBLT_UN;
 503         mono_bblock_add_inst (s->cbb, tree);
 504 }
 505
 506 stmt: CEE_BGT (fpcflags) {
 507         tree->opcode = OP_FBGT;
 508         mono_bblock_add_inst (s->cbb, tree);
 509 }
 510
 511 stmt: CEE_BGT_UN (fpcflags) {
 512         tree->opcode = OP_FBGT_UN;
 513         mono_bblock_add_inst (s->cbb, tree);
 514 }
 515
 516 stmt: CEE_BGE  (fpcflags) {
 517         tree->opcode = OP_FBGE;
 518         mono_bblock_add_inst (s->cbb, tree);
 519 }
 520
 521 stmt: CEE_BGE_UN (fpcflags) {
 522         tree->opcode = OP_FBGE_UN;
 523         mono_bblock_add_inst (s->cbb, tree);
 524 }
 525
 526 stmt: CEE_BLE  (fpcflags) {
 527         tree->opcode = OP_FBLE;
 528         mono_bblock_add_inst (s->cbb, tree);
 529 }
 530
 531 stmt: CEE_BLE_UN (fpcflags) {
 532         tree->opcode = OP_FBLE_UN;
 533         mono_bblock_add_inst (s->cbb, tree);
 534 }
 535
 536 stmt: CEE_POP (freg) "0" {
 537         /* nothing to do */
 538 }
 539
 540 freg: OP_LCONV_TO_R8 (lreg) {
 541         /* nothing to do - emulated */
 542 }
 543
 544 freg: OP_LCONV_TO_R4 (lreg) {
 545         /* nothing to do - emulated */
 546 }
 547
 548 freg: OP_LCONV_TO_R_UN (lreg) {
 549         /* nothing to do - emulated */
 550 }
 551
 552 freg: OP_FREM (freg, freg) {
 553         /* nothing to do - emulated */
 554 }
 555
 556 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
 557         MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
 558                          state->left->right->reg1);
 559 }
 560
 561 reg: OP_CLT (OP_COMPARE (freg, freg)) {
 562         MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
 563                          state->left->right->reg1);
 564 }
 565
 566 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
 567         MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
 568                          state->left->right->reg1);
 569 }
 570
 571 reg: OP_CGT (OP_COMPARE (freg, freg)) {
 572         MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
 573                          state->left->right->reg1);
 574 }
 575
 576 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
 577         MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
 578                          state->left->right->reg1);
 579 }
 580
 581 base: OP_S390_STKARG "0" {
 582         int tmpr;
 583
 584         tmpr = mono_regstate_next_int (s->rs);
 585         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, tmpr, s->frame_reg);
 586         tree->inst_offset  = state->tree->inst_offset;
 587         tree->inst_basereg = tmpr;
 588 }
 589
 590 reg: CEE_LDIND_I4 (CEE_REFANYVAL (base)) "0" {
 591         MonoInst *base = state->left->left->left->tree;
 592         int tmpr;
 593
 594         tmpr = mono_regstate_next_int (s->rs);
 595         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, base->sreg1, base->inst_offset);
 596         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, G_STRUCT_OFFSET (MonoTypedRef, value));
 597         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->reg1, tmpr, 4);
 598 }
 599
 600 reg: CEE_LDIND_I2 (CEE_REFANYVAL (base)) "0" {
 601         MonoInst *base = state->left->left->left->tree;
 602         int tmpr;
 603
 604         tmpr = mono_regstate_next_int (s->rs);
 605         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, base->sreg1, base->inst_offset);
 606         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, G_STRUCT_OFFSET (MonoTypedRef, value));
 607         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI2_MEMBASE, state->reg1, tmpr, 6);
 608 }
 609
 610 reg: CEE_LDIND_I1 (CEE_REFANYVAL (base)) "0" {
 611         MonoInst *base = state->left->left->left->tree;
 612         int tmpr;
 613
 614         tmpr = mono_regstate_next_int (s->rs);
 615         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, base->sreg1, base->inst_offset);
 616         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, G_STRUCT_OFFSET (MonoTypedRef, value));
 617         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI1_MEMBASE, state->reg1, tmpr, 7);
 618 }
 619
 620 reg: CEE_LDIND_U4 (CEE_REFANYVAL (base)) "0" {
 621         MonoInst *base = state->left->left->left->tree;
 622         int tmpr;
 623
 624         tmpr = mono_regstate_next_int (s->rs);
 625         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, base->sreg1, base->inst_offset);
 626         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, G_STRUCT_OFFSET (MonoTypedRef, value));
 627         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU4_MEMBASE, state->reg1, tmpr, 4);
 628 }
 629
 630 reg: CEE_LDIND_U2 (CEE_REFANYVAL (base)) "0" {
 631         MonoInst *base = state->left->left->left->tree;
 632         int tmpr;
 633
 634         tmpr = mono_regstate_next_int (s->rs);
 635         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, base->sreg1, base->inst_offset);
 636         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, G_STRUCT_OFFSET (MonoTypedRef, value));
 637         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU2_MEMBASE, state->reg1, tmpr, 6);
 638 }
 639
 640 reg: CEE_LDIND_U1 (CEE_REFANYVAL (base)) "0" {
 641         MonoInst *base = state->left->left->left->tree;
 642         int tmpr;
 643
 644         tmpr = mono_regstate_next_int (s->rs);
 645         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, base->sreg1, base->inst_offset);
 646         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, G_STRUCT_OFFSET (MonoTypedRef, value));
 647         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADU1_MEMBASE, state->reg1, tmpr, 7);
 648 }
 649
 650 reg: OP_LDADDR (OP_S390_ARGREG),
 651 reg: CEE_LDOBJ (OP_S390_ARGREG) "0" {
 652         MONO_EMIT_LOAD_MEMBASE (s, tree, state->reg1, s->frame_reg, state->left->tree->inst_offset);
 653 }
 654
 655 base: OP_LDADDR (OP_S390_LOADARG) "0" {
 656         int treg;
 657
 658         treg = mono_regstate_next_int (s->rs);
 659         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, treg, s->frame_reg);
 660         MONO_EMIT_NEW_LOAD_MEMBASE (s, treg, treg, state->left->tree->backend.arg_info);
 661         tree->inst_offset  = 0;
 662         tree->inst_basereg = treg;
 663 }
 664
 665 base: OP_LDADDR (OP_S390_ARGPTR) "0" {
 666         int treg;
 667
 668         treg = mono_regstate_next_int (s->rs);
 669         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, s->frame_reg,
 670                                  state->left->tree->inst_offset);
 671         tree->inst_offset  = 0;
 672         tree->inst_basereg = treg;
 673 }
 674
 675 base: OP_LDADDR (OP_S390_STKARG) "0" {
 676         int tmpr;
 677
 678         tmpr = mono_regstate_next_int (s->rs);
 679         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, tmpr, s->frame_reg);
 680         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, tmpr,
 681                                   state->left->tree->inst_offset);
 682         tree->inst_offset  = 0;
 683         tree->inst_basereg = tmpr;
 684 }
 685
 686 reg: OP_LDADDR (OP_S390_LOADARG) {
 687         int treg;
 688
 689         treg = mono_regstate_next_int (s->rs);
 690         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, treg, s->frame_reg);
 691         MONO_EMIT_LOAD_MEMBASE (s, tree, state->reg1, treg, state->left->tree->inst_offset);
 692 }
 693
 694 reg: OP_LDADDR (OP_S390_ARGPTR) "2" {
 695         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 696                                  state->left->tree->inst_offset);
 697         tree->inst_offset  = 0;
 698         tree->inst_basereg = state->reg1;
 699 }
 700
 701 reg: OP_LDADDR (OP_S390_STKARG) "2" {
 702         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, state->reg1, s->frame_reg);
 703         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->reg1,
 704                                  (state->left->tree->backend.arg_info +
 705                                   state->left->tree->inst_offset));
 706         tree->inst_offset  = 0;
 707         tree->inst_basereg = state->reg1;
 708 }
 709
 710 reg: CEE_LDOBJ (OP_S390_LOADARG) "1" {
 711         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 712                                  state->left->tree->inst_offset);
 713 }
 714
 715 reg: CEE_LDOBJ (OP_S390_ARGPTR) "0" {
 716         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 717                              state->left->tree->inst_offset);
 718 }
 719
 720 reg: CEE_LDOBJ (OP_S390_STKARG) "1" {
 721         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, state->reg1, s->frame_reg);
 722         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->reg1,
 723                                  (state->left->tree->backend.arg_info +
 724                                   state->left->tree->inst_offset));
 725         tree->inst_offset  = 0;
 726         tree->dreg         = state->reg1;
 727 }
 728
 729 base: CEE_LDOBJ (OP_S390_ARGPTR) "0" {
 730         int treg;
 731
 732         treg = mono_regstate_next_int (s->rs);
 733         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, treg, s->frame_reg,
 734                                     state->left->tree->inst_offset);
 735         tree->inst_offset  = 0;
 736         tree->inst_basereg = treg;
 737 }
 738
 739 base: CEE_LDOBJ (OP_S390_STKARG) "0" {
 740         int tmpr;
 741
 742         tmpr = mono_regstate_next_int (s->rs);
 743         MONO_EMIT_NEW_UNALU (s, OP_S390_BKCHAIN, tmpr, s->frame_reg);
 744         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, tmpr, state->left->tree->backend.arg_info);
 745         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, state->left->tree->inst_offset);
 746         tree->inst_offset  = 0;
 747         tree->inst_basereg = tmpr;
 748 }
 749
 750
 751 reg: OP_ATOMIC_ADD_NEW_I8 (base, reg),
 752 reg: OP_ATOMIC_ADD_NEW_I4 (base, reg),
 753 reg: OP_ATOMIC_ADD_I8 (base, reg),
 754 reg: OP_ATOMIC_ADD_I4 (base, reg) {
 755         tree->inst_basereg = state->left->tree->inst_basereg;
 756         tree->inst_offset = state->left->tree->inst_offset;
 757         tree->dreg = state->reg1;
 758         tree->sreg2 = state->right->reg1;
 759
 760         mono_bblock_add_inst (s->cbb, tree);
 761 }
 762
 763 reg: OP_ATOMIC_EXCHANGE_I8 (base, reg),
 764 reg: OP_ATOMIC_EXCHANGE_I4 (base, reg) {
 765         tree->dreg = state->reg1;
 766         tree->sreg2 = state->right->reg1;
 767         tree->inst_basereg = state->left->tree->inst_basereg;
 768         tree->inst_offset = state->left->tree->inst_offset;
 769
 770         mono_bblock_add_inst (s->cbb, tree);
 771 }
 772
 773 reg: OP_LSHL (reg, reg),
 774 reg: OP_LSHR (reg, reg),
 775 reg: OP_LSHR_UN (reg, reg),
 776 reg: OP_LMUL (reg, reg),
 777 reg: OP_LDIV (reg, reg),
 778 reg: OP_LDIV_UN (reg, reg),
 779 reg: OP_LREM (reg, reg),
 780 reg: OP_LREM_UN (reg, reg),
 781 reg: OP_LMUL_OVF (reg, reg),
 782 reg: OP_LMUL_OVF_UN (reg, reg) "0" {
 783         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 784 }
 785
 786 reg: OP_LSHL (reg, OP_ICONST) {
 787         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHL_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 788 } cost {
 789         MBCOND (mono_arch_is_inst_imm (state->right->tree->inst_c0));
 790         return 0;
 791 }
 792
 793 reg: OP_LSHR (reg, OP_ICONST) {
 794         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHR_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 795 } cost {
 796         MBCOND (mono_arch_is_inst_imm (state->right->tree->inst_c0));
 797         return 0;
 798 }
 799
 800 reg: OP_LSHR_UN (reg, OP_ICONST) {
 801         MONO_EMIT_BIALU_IMM (s, tree, OP_LSHR_UN_IMM, state->reg1, state->left->reg1, state->right->tree->inst_c0);
 802 } cost {
 803         MBCOND (mono_arch_is_inst_imm (state->right->tree->inst_c0));
 804         return 0;
 805 }
 806
 807 reg: OP_LCONV_TO_I4 (reg) "0" {
 808         /* Sign extend the value in the lower word into the upper word */
 809         MONO_EMIT_BIALU_IMM (s, tree, CEE_CONV_I4, state->reg1, state->left->reg1, 0);
 810 }
 811
 812 reg: OP_LCONV_TO_U4 (reg) "0" {
 813         /* Clean out the upper word */
 814         MONO_EMIT_BIALU_IMM (s, tree, CEE_CONV_U4, state->reg1, state->left->reg1, 0);
 815 }
 816
 817 freg: OP_LCONV_TO_R8 (reg) {
 818         /* FIXME: Move this inssel-long.brg */
 819         tree->sreg1 = state->left->reg1;
 820         tree->dreg = state->reg1;
 821         mono_bblock_add_inst (s->cbb, tree);
 822 }
 823
 824 freg: OP_LCONV_TO_R4 (reg) {
 825         /* FIXME: Move this inssel-long.brg */
 826         tree->sreg1 = state->left->reg1;
 827         tree->dreg = state->reg1;
 828         mono_bblock_add_inst (s->cbb, tree);
 829 }
 830
 831 %%