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: CEE_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: CEE_ADD_OVF (reg, reg) "0" {
  34         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
  35 }
  36
  37 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
  38         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
  39 }
  40
  41 reg: CEE_SUB_OVF (reg, reg) "0" {
  42         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
  43 }
  44
  45 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
  46         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
  47 }
  48
  49 stmt: CEE_STIND_I8 (OP_REGVAR, reg) {
  50         MONO_EMIT_NEW_UNALU (s, OP_MOVE, state->left->tree->dreg, state->right->reg1);
  51 //      MONO_EMIT_NEW_UNALU (s, OP_MOVE, s390_r2, state->right->reg1);
  52 }
  53
  54 reg: CEE_LDIND_I8 (OP_REGVAR) {
  55         MONO_EMIT_NEW_UNALU (s, OP_MOVE, state->reg1, state->left->tree->dreg);
  56 }
  57
  58 freg: OP_LCONV_TO_R8 (lreg) {
  59         tree->dreg = state->reg1;
  60         tree->sreg1 = state->left->reg1;
  61         tree->sreg2 = state->left->reg2;
  62         mono_bblock_add_inst (s->cbb, tree);
  63 }
  64
  65 freg: OP_LCONV_TO_R4 (lreg) {
  66         tree->dreg = state->reg1;
  67         tree->sreg1 = state->left->reg1;
  68         tree->sreg2 = state->left->reg2;
  69         mono_bblock_add_inst (s->cbb, tree);
  70 }
  71
  72 freg: CEE_CONV_R_UN (reg) {
  73         tree->dreg = state->reg1;
  74         tree->sreg1 = state->left->reg1;
  75         mono_bblock_add_inst (s->cbb, tree);
  76 }
  77
  78 freg: CEE_CONV_R_UN (reg) {
  79         mono_bblock_add_inst (s->cbb, tree);
  80 }
  81
  82 stmt: OP_MEMCPY (reg, reg) "0" {
  83         int size = tree->unused;
  84         if (size > 0)
  85                 MONO_EMIT_NEW_MOVE (s, state->left->reg1, 0, state->right->reg1, 0, size);
  86 }
  87
  88 reg: OP_LOCALLOC (OP_ICONST) {
  89         /* microcoded in mini-s390.c */
  90         tree->sreg1 = mono_regstate_next_int (s->rs);
  91         tree->dreg  = state->reg1;
  92         MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
  93         mono_bblock_add_inst (s->cbb, tree);
  94 }
  95
  96 reg: OP_LOCALLOC (reg) {
  97         tree->dreg = state->reg1;
  98         tree->sreg1 = state->left->reg1;
  99         mono_bblock_add_inst (s->cbb, tree);
 100 }
 101
 102 stmt: OP_SETRET (reg) {
 103         tree->opcode = OP_MOVE;
 104         tree->sreg1 = state->left->reg1;
 105         tree->dreg = s390_r2;
 106         mono_bblock_add_inst (s->cbb, tree);
 107 }
 108
 109 # stmt: OP_SETRET (lreg) {
 110 #       tree->opcode = OP_MOVE;
 111 #       tree->sreg1 = state->left->reg1;
 112 #       tree->dreg = s390_r2;
 113 #       mono_bblock_add_inst (s->cbb, tree);
 114 # }
 115
 116 stmt: OP_SETRET (freg) {
 117         if (s->method->signature->ret->type == MONO_TYPE_R4) {
 118                 tree->opcode = OP_S390_SETF4RET;
 119                 tree->sreg1  = state->left->reg1;
 120                 tree->dreg   = s390_f0;
 121         } else {
 122                 tree->opcode = OP_FMOVE;
 123                 tree->sreg1  = state->left->reg1;
 124                 tree->dreg   = s390_f0;
 125         }
 126         mono_bblock_add_inst (s->cbb, tree);
 127 }
 128
 129 stmt: OP_SETRET (OP_ICONST) {
 130         tree->opcode = OP_ICONST;
 131         tree->inst_c0 = state->left->tree->inst_c0;
 132         tree->dreg = s390_r2;
 133         mono_bblock_add_inst (s->cbb, tree);
 134 }
 135
 136 stmt: OP_OUTARG (reg) {
 137         if (tree->inst_imm) {
 138                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->reg1);
 139                 return;
 140         }
 141         tree->opcode = OP_SETREG;
 142         tree->dreg = tree->unused;
 143         tree->sreg1 = state->left->reg1;
 144         mono_bblock_add_inst (s->cbb, tree);
 145 }
 146
 147 stmt: OP_OUTARG (OP_REGVAR) {
 148         if (tree->inst_imm) {
 149                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->tree->dreg);
 150                 return;
 151         }
 152         tree->opcode = OP_SETREG;
 153         tree->dreg = tree->unused;
 154         tree->sreg1 = state->left->tree->dreg;
 155         mono_bblock_add_inst (s->cbb, tree);
 156 }
 157
 158 stmt: OP_OUTARG (OP_I8CONST) {
 159         if (tree->inst_imm) {
 160                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM,
 161                                                  STK_BASE, tree->inst_imm,
 162                                                  state->left->tree->inst_c0);
 163                 return;
 164         }
 165         tree->opcode = OP_SETREGIMM;
 166         tree->dreg = tree->unused;
 167         tree->inst_c0 = state->left->tree->inst_c0;
 168         mono_bblock_add_inst (s->cbb, tree);
 169 }
 170
 171 stmt: OP_OUTARG (OP_ICONST) {
 172         if (tree->inst_imm) {
 173                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STOREI4_MEMBASE_IMM,
 174                                                  STK_BASE, tree->inst_imm,
 175                                                  state->left->tree->inst_c0);
 176                 return;
 177         }
 178         tree->opcode = OP_SETREGIMM;
 179         tree->dreg = tree->unused;
 180         tree->inst_c0 = state->left->tree->inst_c0;
 181         mono_bblock_add_inst (s->cbb, tree);
 182 }
 183
 184 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
 185         if (tree->inst_imm) {
 186                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->left->tree->dreg);
 187                 return;
 188         }
 189         tree->opcode = OP_SETREG;
 190         tree->sreg1 = state->left->left->tree->dreg;
 191         tree->dreg = tree->unused;
 192         mono_bblock_add_inst (s->cbb, tree);
 193 }
 194
 195 stmt: OP_OUTARG (CEE_LDIND_I (OP_REGVAR)) {
 196         tree->opcode = OP_SETREG;
 197         tree->dreg   = tree->unused;
 198         tree->sreg1  = state->left->left->tree->dreg;
 199         mono_bblock_add_inst (s->cbb, tree);
 200 }
 201
 202 stmt: OP_OUTARG (CEE_LDIND_I8 (OP_REGVAR)) {
 203         tree->opcode = OP_SETREG;
 204         tree->dreg   = tree->unused;
 205         tree->sreg1  = state->left->left->tree->dreg;
 206         mono_bblock_add_inst (s->cbb, tree);
 207 }
 208
 209 stmt: OP_OUTARG (CEE_LDIND_I4 (OP_REGVAR)) {
 210         tree->opcode = OP_SETREG;
 211         tree->dreg   = tree->unused;
 212         tree->sreg1  = state->left->left->tree->dreg;
 213         mono_bblock_add_inst (s->cbb, tree);
 214 }
 215
 216 stmt: OP_OUTARG (CEE_LDIND_I (base)) {
 217         MONO_EMIT_LOAD_MEMBASE (s, tree, tree->unused,
 218                                 state->left->left->tree->inst_basereg,
 219                                 state->left->left->tree->inst_offset);
 220         mono_bblock_add_inst (s->cbb, tree);
 221 }
 222
 223 stmt: OP_OUTARG (CEE_LDIND_I4 (base)) {
 224         MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE,
 225                                 tree->unused, state->left->left->tree->inst_basereg,
 226                                 state->left->left->tree->inst_offset);
 227         mono_bblock_add_inst (s->cbb, tree);
 228 }
 229
 230 stmt: OP_OUTARG (OP_LDADDR (OP_S390_LOADARG)) {
 231         if (tree->inst_imm) {
 232                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, STK_BASE,
 233                                              tree->inst_imm,
 234                                              state->left->left->tree->dreg);
 235                 return;
 236         }
 237         MONO_EMIT_BIALU_IMM (s, tree, OP_ADD_IMM, tree->unused,
 238                              state->left->left->tree->sreg1,
 239                              state->left->left->tree->inst_offset);
 240 }
 241
 242 stmt: OP_OUTARG (freg) {
 243         if (tree->inst_imm) {
 244                 /*----------------------------------------------*/
 245                 /* The length stored in unused tells us whether */
 246                 /* we need to store a float or a double         */
 247                 /*----------------------------------------------*/
 248                 if ((tree->unused & 0xff00) == 0x0400) {
 249                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG,
 250                                                      STK_BASE, tree->inst_imm,
 251                                                      state->left->reg1);
 252                 } else {
 253                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG,
 254                                                      STK_BASE, tree->inst_imm,
 255                                                      state->left->reg1);
 256                 }
 257                 return;
 258         }
 259         tree->opcode = OP_SETFREG;
 260         tree->sreg1 = state->left->reg1;
 261         tree->dreg = tree->unused;
 262         mono_bblock_add_inst (s->cbb, tree);
 263 }
 264
 265 stmt: OP_OUTARG_R4 (freg) {
 266         if (tree->inst_imm) {
 267                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->reg1);
 268                 return;
 269         }
 270         tree->opcode = OP_SETFREG;
 271         tree->sreg1 = state->left->reg1;
 272         tree->dreg = tree->unused;
 273         mono_bblock_add_inst (s->cbb, tree);
 274 }
 275
 276 stmt: OP_OUTARG_R8 (freg) {
 277         if (tree->inst_imm) {
 278                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, STK_BASE, tree->inst_imm, state->left->reg1);
 279                 return;
 280         }
 281         tree->opcode = OP_SETFREG;
 282         tree->sreg1 = state->left->reg1;
 283         tree->dreg = tree->unused;
 284         mono_bblock_add_inst (s->cbb, tree);
 285 }
 286
 287 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
 288         MonoInst *vt  = state->left->left->tree;
 289         int start_reg = tree->sreg1;
 290         int size      = tree->unused;
 291         int soffset   = vt->inst_offset;
 292         int tmpr;
 293
 294 //printf("OP_OUTARG_VT(CEE_LDOBJ(base))\n");
 295         if (size < 0) {
 296                 size = -size;
 297                 if (start_reg != STK_BASE) {
 298                         MONO_EMIT_NEW_MOVE(s, STK_BASE, tree->sreg2,
 299                                            vt->inst_basereg, soffset, size);
 300                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg,
 301                                                  STK_BASE, tree->sreg2);
 302                 } else {
 303                         MONO_EMIT_NEW_MOVE(s, STK_BASE, tree->sreg2+sizeof(gpointer),
 304                                            vt->inst_basereg, soffset, size);
 305                         tmpr = mono_regstate_next_int (s->rs);
 306                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
 307                                                  tree->sreg2+sizeof(gpointer));
 308                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 309                                                      STK_BASE, tree->sreg2, tmpr);
 310                 }
 311         } else {
 312                 if (start_reg != STK_BASE) {
 313                         MONO_OUTPUT_VTR (s, size, start_reg, vt->inst_basereg, soffset);
 314                 } else {
 315                         MONO_OUTPUT_VTS (s, size, STK_BASE, tree->inst_imm,
 316                                          vt->inst_basereg, soffset);
 317                 }
 318         }
 319 }
 320
 321 stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_S390_ARGPTR)) {
 322         MonoInst *vt  = state->left->left->tree;
 323         int start_reg = tree->sreg1;
 324         int size      = tree->unused;
 325         int soffset   = vt->inst_offset;
 326         int tmpr;
 327
 328 //printf("OP_OUTARG_VT(CEE_LDOBJ(OP_S390_ARGPTR))\n");
 329         if (size < 0) {
 330                 size = -size;
 331                 if (start_reg != STK_BASE) {
 332                         MONO_EMIT_NEW_MOVE (s, STK_BASE, tree->inst_imm,
 333                                             vt->inst_basereg, soffset, size);
 334                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg,
 335                                                  STK_BASE, tree->sreg2);
 336                 } else {
 337                         MONO_EMIT_NEW_MOVE (s, STK_BASE,
 338                                             tree->inst_imm+sizeof(gpointer),
 339                                             vt->inst_basereg, soffset, size);
 340                         tmpr = mono_regstate_next_int (s->rs);
 341                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
 342                                                  tree->inst_imm+sizeof(gpointer));
 343                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 344                                                      STK_BASE, tree->inst_imm,
 345                                                      tmpr);
 346                 }
 347         } else {
 348                 if (start_reg != STK_BASE) {
 349                         MONO_OUTPUT_VTR (s, size, start_reg, vt->inst_basereg, soffset);
 350                 } else {
 351                         MONO_OUTPUT_VTS (s, size, STK_BASE,
 352                                          tree->inst_imm,
 353                                          vt->inst_basereg, soffset);
 354                 }
 355         }
 356 }
 357
 358 stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_REGOFFSET)) "0" {
 359         MonoInst *vt  = state->left->left->tree;
 360         int start_reg = tree->sreg1;
 361         int size      = tree->unused;
 362         int soffset   = vt->inst_offset;
 363         int tmpr;
 364
 365 //printf("OP_OUTARG_VT(CEE_LDOBJ(OP_REGOFFSET))\n");
 366         if (size < 0) {
 367                 size = -size;
 368                 if (start_reg != STK_BASE) {
 369                         MONO_EMIT_NEW_MOVE (s, STK_BASE, tree->sreg2,
 370                                             vt->inst_basereg, soffset, size);
 371                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg,
 372                                                  STK_BASE, tree->sreg2);
 373                 } else {
 374                         MONO_EMIT_NEW_MOVE (s, STK_BASE,
 375                                             tree->sreg2+sizeof(gpointer),
 376                                             vt->inst_basereg, soffset, size);
 377                         tmpr = mono_regstate_next_int (s->rs);
 378                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
 379                                                  tree->sreg2+sizeof(gpointer));
 380                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 381                                                      STK_BASE, tree->sreg2,
 382                                                      tmpr);
 383                 }
 384         } else {
 385                 if (start_reg != STK_BASE) {
 386                         MONO_OUTPUT_VTR(s, size, start_reg, vt->inst_basereg, soffset);
 387                 } else {
 388                         MONO_OUTPUT_VTS(s, size, STK_BASE, tree->inst_imm,
 389                                           vt->inst_basereg, soffset);
 390                 }
 391         }
 392 }
 393
 394 stmt: OP_OUTARG_VT (CEE_LDOBJ (OP_S390_LOADARG)) {
 395         MonoInst *vt  = state->left->left->tree;
 396         int start_reg = tree->sreg1;
 397         int size      = -tree->unused;
 398         int soffset   = vt->inst_offset;
 399         int tmpr;
 400
 401 //printf("OP_OUTARG_VT(CEE_LDOBJ(OP_S390_LOADARG))\n");
 402         if (start_reg != STK_BASE) {
 403                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg, STK_BASE, soffset);
 404                 MONO_EMIT_NEW_MOVE (s, STK_BASE, tree->sreg2, start_reg, 0, size);
 405                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg,
 406                                          STK_BASE, tree->sreg2);
 407         } else {
 408                 MONO_EMIT_NEW_MOVE (s, STK_BASE,
 409                                     tree->inst_imm+sizeof(gpointer),
 410                                     vt->inst_basereg, soffset, size);
 411                 tmpr = mono_regstate_next_int (s->rs);
 412                 MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
 413                                          tree->inst_imm+sizeof(gpointer));
 414                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 415                                              STK_BASE, tree->inst_imm,
 416                                              tmpr);
 417         }
 418 }
 419
 420 stmt: OP_OUTARG_VT (OP_ICONST) {
 421         int start_reg = tree->sreg1;
 422         int size      = tree->unused;
 423         int nregs     = size / 4;
 424
 425 //printf("OP_OUTARG_VT(OP_ICONST)\n");
 426         if (start_reg != STK_BASE) {
 427                 if (nregs) {
 428                         tree->opcode  = OP_SETREGIMM;
 429                         tree->dreg    = start_reg;
 430                         tree->inst_c0 = state->left->tree->inst_c0;
 431                         mono_bblock_add_inst (s->cbb, tree);
 432                 }
 433         } else {
 434                 MONO_OUTPUT_VTS (s, size, STK_BASE, tree->inst_c0,
 435                                  s->frame_reg, tree->inst_offset);
 436         }
 437 }
 438
 439 stmt: OP_OUTARG_VT (reg) {
 440         int start_reg = tree->sreg1;
 441         int size      = tree->unused;
 442         int soffset   = tree->sreg2;
 443         int tmpr;
 444
 445 //printf("OP_OUTARG_VT(reg)\n");
 446         if (size < 0) {
 447                 size = -size;
 448                 if (start_reg != STK_BASE) {
 449                         MONO_EMIT_NEW_MOVE (s, STK_BASE, soffset,
 450                                             state->left->tree->sreg1,
 451                                             tree->inst_imm, size);
 452                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, start_reg,
 453                                                  STK_BASE, soffset);
 454                 } else {
 455                         MONO_EMIT_NEW_MOVE (s, STK_BASE,
 456                                             soffset+sizeof(gpointer),
 457                                             state->left->tree->sreg1,
 458                                             tree->inst_imm, size);
 459                         tmpr = mono_regstate_next_int (s->rs);
 460                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
 461                                                  soffset+sizeof(gpointer));
 462                         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG,
 463                                                      STK_BASE, tree->inst_imm,
 464                                                      tmpr);
 465                 }
 466         } else {
 467                 if (start_reg != STK_BASE) {
 468                         MONO_OUTPUT_VTR (s, size, start_reg, STK_BASE,
 469                                          state->left->tree->inst_offset);
 470                 } else {
 471                         MONO_OUTPUT_VTS (s, size, STK_BASE, soffset, tmpr,
 472                                          state->left->tree->inst_offset);
 473                         tmpr = mono_regstate_next_int (s->rs);
 474                         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, STK_BASE,
 475                                                 s->stack_offset);
 476                 }
 477         }
 478 }
 479
 480 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
 481         /* nothing to do: the value is already on the FP stack */
 482 }
 483
 484 stmt: CEE_BNE_UN (fpcflags) {
 485         tree->opcode = OP_FBNE_UN;
 486         mono_bblock_add_inst (s->cbb, tree);
 487 }
 488
 489 stmt: CEE_BEQ (fpcflags) {
 490         tree->opcode = OP_FBEQ;
 491         mono_bblock_add_inst (s->cbb, tree);
 492 }
 493
 494 stmt: CEE_BLT (fpcflags) {
 495         tree->opcode = OP_FBLT;
 496         mono_bblock_add_inst (s->cbb, tree);
 497 }
 498
 499 stmt: CEE_BLT_UN (fpcflags) {
 500         tree->opcode = OP_FBLT_UN;
 501         mono_bblock_add_inst (s->cbb, tree);
 502 }
 503
 504 stmt: CEE_BGT (fpcflags) {
 505         tree->opcode = OP_FBGT;
 506         mono_bblock_add_inst (s->cbb, tree);
 507 }
 508
 509 stmt: CEE_BGT_UN (fpcflags) {
 510         tree->opcode = OP_FBGT_UN;
 511         mono_bblock_add_inst (s->cbb, tree);
 512 }
 513
 514 stmt: CEE_BGE  (fpcflags) {
 515         tree->opcode = OP_FBGE;
 516         mono_bblock_add_inst (s->cbb, tree);
 517 }
 518
 519 stmt: CEE_BGE_UN (fpcflags) {
 520         tree->opcode = OP_FBGE_UN;
 521         mono_bblock_add_inst (s->cbb, tree);
 522 }
 523
 524 stmt: CEE_BLE  (fpcflags) {
 525         tree->opcode = OP_FBLE;
 526         mono_bblock_add_inst (s->cbb, tree);
 527 }
 528
 529 stmt: CEE_BLE_UN (fpcflags) {
 530         tree->opcode = OP_FBLE_UN;
 531         mono_bblock_add_inst (s->cbb, tree);
 532 }
 533
 534 stmt: CEE_POP (freg) "0" {
 535         /* nothing to do */
 536 }
 537
 538 freg: OP_LCONV_TO_R8 (lreg) {
 539         /* nothing to do - emulated */
 540 }
 541
 542 freg: OP_LCONV_TO_R4 (lreg) {
 543         /* nothing to do - emulated */
 544 }
 545
 546 freg: OP_LCONV_TO_R_UN (lreg) {
 547         /* nothing to do - emulated */
 548 }
 549
 550 freg: OP_FREM (freg, freg) {
 551         /* nothing to do - emulated */
 552 }
 553
 554 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
 555         MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
 556                          state->left->right->reg1);
 557 }
 558
 559 reg: OP_CLT (OP_COMPARE (freg, freg)) {
 560         MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
 561                          state->left->right->reg1);
 562 }
 563
 564 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
 565         MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
 566                          state->left->right->reg1);
 567 }
 568
 569 reg: OP_CGT (OP_COMPARE (freg, freg)) {
 570         MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
 571                          state->left->right->reg1);
 572 }
 573
 574 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
 575         MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
 576                          state->left->right->reg1);
 577 }
 578
 579 base: OP_S390_STKARG "0" {
 580         int tmpr;
 581
 582         tmpr = mono_regstate_next_int (s->rs);
 583         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg,
 584                                 (s->stack_offset+state->tree->unused));
 585         tree->inst_offset  = state->tree->inst_offset;
 586         tree->inst_basereg = tmpr;
 587 }
 588
 589 base: OP_LDADDR (OP_S390_LOADARG) "0" {
 590         int tmpr;
 591
 592         tmpr = mono_regstate_next_int (s->rs);
 593         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg,
 594                                  state->left->tree->inst_offset);
 595         tree->inst_offset  = 0;
 596         tree->inst_basereg = tmpr;
 597 }
 598
 599 base: OP_LDADDR (OP_S390_ARGPTR) "0" {
 600         int tmpr;
 601
 602         tmpr = mono_regstate_next_int (s->rs);
 603         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg,
 604                                  state->left->tree->inst_offset);
 605         tree->inst_offset  = 0;
 606         tree->inst_basereg = tmpr;
 607 }
 608
 609 base: OP_LDADDR (OP_S390_STKARG) "0" {
 610         int tmpr;
 611
 612         tmpr = mono_regstate_next_int (s->rs);
 613         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg,
 614                                  (s->stack_offset + state->left->tree->unused));
 615         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, tmpr,
 616                                  state->left->tree->inst_offset);
 617         tree->inst_offset  = 0;
 618         tree->inst_basereg = tmpr;
 619 }
 620
 621 reg: OP_LDADDR (OP_S390_LOADARG) "2" {
 622         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 623                                  state->left->tree->inst_offset);
 624         tree->inst_offset  = 0;
 625         tree->inst_basereg = state->reg1;
 626 }
 627
 628 reg: OP_LDADDR (OP_S390_ARGPTR) "2" {
 629         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 630                                  state->left->tree->inst_offset);
 631         tree->inst_offset  = 0;
 632         tree->inst_basereg = state->reg1;
 633 }
 634
 635 reg: OP_LDADDR (OP_S390_STKARG) "2" {
 636         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 637                                  (s->stack_offset + state->left->tree->unused));
 638         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->reg1,
 639                                  state->left->tree->inst_offset);
 640         tree->inst_offset  = 0;
 641         tree->inst_basereg = state->reg1;
 642 }
 643
 644 reg: CEE_LDOBJ (OP_S390_LOADARG) "1" {
 645         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 646                                  state->left->tree->inst_offset);
 647 }
 648
 649 reg: CEE_LDOBJ (OP_S390_ARGPTR) "1" {
 650         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 651                              state->left->tree->inst_offset);
 652 }
 653
 654 reg: CEE_LDOBJ (OP_S390_STKARG) "1" {
 655         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, s->frame_reg,
 656                                  (s->stack_offset + state->left->tree->unused));
 657         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, state->reg1, state->reg1,
 658                                  state->left->tree->inst_offset);
 659         tree->inst_offset  = 0;
 660         tree->dreg         = state->reg1;
 661 }
 662
 663 base: CEE_LDOBJ (OP_S390_ARGPTR) "0" {
 664         int tmpr;
 665
 666         tmpr = mono_regstate_next_int (s->rs);
 667         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, s->frame_reg,
 668                                     state->left->tree->inst_offset);
 669         tree->inst_offset  = 0;
 670         tree->dreg         = tmpr;
 671 }
 672
 673 base: CEE_LDOBJ (OP_S390_STKARG) "0" {
 674         int tmpr;
 675
 676         tmpr = mono_regstate_next_int (s->rs);
 677         MONO_EMIT_NEW_BIALU_IMM (s, OP_ADD_IMM, tmpr, s->frame_reg,
 678                                  (s->stack_offset + state->left->tree->unused));
 679         MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, tmpr, state->left->tree->inst_offset);
 680         tree->inst_offset  = 0;
 681         tree->inst_basereg = tmpr;
 682 }
 683
 684 %%