mono/mini/inssel-s390.brg

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