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