mono/mini/inssel-ppc.brg

   1 %%
   2
   3 #
   4 # inssel-ppc.brg: burg file for special ppc instructions
   5 #
   6 # Author:
   7 #   Dietmar Maurer (dietmar@ximian.com)
   8 #   Paolo Molaro (lupus@ximian.com)
   9 #
  10 # (C) 2002 Ximian, Inc.
  11 #
  12
  13 stmt: OP_START_HANDLER {
  14         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  15         /*MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, spvar->inst_basereg, spvar->inst_offset, ppc_sp);
  16         */
  17         tree->inst_left = spvar;
  18         mono_bblock_add_inst (s->cbb, tree);
  19 }
  20
  21 stmt: CEE_ENDFINALLY {
  22         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  23         tree->inst_left = spvar;
  24         mono_bblock_add_inst (s->cbb, tree);
  25 }
  26
  27 stmt: OP_ENDFILTER (reg) {
  28         MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
  29         tree->inst_left = spvar;
  30         tree->sreg1 = state->left->reg1;
  31         mono_bblock_add_inst (s->cbb, tree);
  32 }
  33
  34 lreg: OP_LADD_OVF (lreg, lreg) "0" {
  35         /* ADC sets the condition code */
  36         MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
  37         MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  38 }
  39
  40 lreg: OP_LADD_OVF_UN (lreg, lreg) "0" {
  41         /* ADC sets the condition code */
  42         MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
  43         MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  44 }
  45
  46 lreg: OP_LSUB_OVF (lreg, lreg) "0" {
  47         /* SBB sets the condition code */
  48         MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
  49         MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  50 }
  51
  52 lreg: OP_LSUB_OVF_UN (lreg, lreg) "0" {
  53         /* SBB sets the condition code */
  54         MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
  55         MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
  56 }
  57
  58 stmt: CEE_STIND_I8 (OP_REGVAR, lreg) {
  59         /* this should only happen for methods returning a long */
  60         MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r3, state->right->reg1);
  61         MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r4, state->right->reg2);
  62 }
  63
  64 lreg: OP_LNEG (lreg) "2" {
  65         MONO_EMIT_NEW_BIALU_IMM (s, OP_PPC_SUBFIC, state->reg1, state->left->reg1, 0);
  66         MONO_EMIT_UNALU (s, tree, OP_PPC_SUBFZE, state->reg2, state->left->reg2);
  67 }
  68
  69 freg: OP_LCONV_TO_R8 (lreg) {
  70         tree->dreg = state->reg1;
  71         tree->sreg1 = state->left->reg1;
  72         tree->sreg2 = state->left->reg2;
  73         mono_bblock_add_inst (s->cbb, tree);
  74 }
  75
  76 freg: OP_LCONV_TO_R4 (lreg) {
  77         tree->dreg = state->reg1;
  78         tree->sreg1 = state->left->reg1;
  79         tree->sreg2 = state->left->reg2;
  80         mono_bblock_add_inst (s->cbb, tree);
  81 }
  82
  83 freg: CEE_CONV_R_UN (reg) {
  84         tree->dreg = state->reg1;
  85         tree->sreg1 = state->left->reg1;
  86         mono_bblock_add_inst (s->cbb, tree);
  87 }
  88
  89 reg: OP_LOCALLOC (OP_ICONST) {
  90         /* microcoded in mini-ppc.c */
  91         tree->sreg1 = mono_regstate_next_int (s->rs);
  92         tree->dreg = state->reg1;
  93         MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
  94         mono_bblock_add_inst (s->cbb, tree);
  95 }
  96
  97 reg: OP_LOCALLOC (reg) {
  98         tree->dreg = state->reg1;
  99         tree->sreg1 = state->left->reg1;
 100         mono_bblock_add_inst (s->cbb, tree);
 101 }
 102
 103 stmt: OP_SETRET (reg) {
 104         tree->opcode = OP_MOVE;
 105         tree->sreg1 = state->left->reg1;
 106         tree->dreg = ppc_r3;
 107         mono_bblock_add_inst (s->cbb, tree);
 108 }
 109
 110 stmt: OP_SETRET (lreg) {
 111         tree->opcode = OP_SETLRET;
 112         tree->sreg1 = state->left->reg1;
 113         tree->sreg2 = state->left->reg2;
 114         tree->dreg = ppc_r3;
 115         mono_bblock_add_inst (s->cbb, tree);
 116 }
 117
 118 stmt: OP_SETRET (freg) {
 119         tree->opcode = OP_FMOVE;
 120         tree->sreg1 = state->left->reg1;
 121         tree->dreg = ppc_f1;
 122         mono_bblock_add_inst (s->cbb, tree);
 123 }
 124
 125 stmt: OP_SETRET (OP_ICONST) {
 126         tree->opcode = OP_ICONST;
 127         tree->inst_c0 = state->left->tree->inst_c0;
 128         tree->dreg = ppc_r3;
 129         mono_bblock_add_inst (s->cbb, tree);
 130 }
 131
 132 stmt: CEE_STIND_I (OP_REGVAR, CEE_SUB (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
 133 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_SUB (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)),
 134 stmt: CEE_STIND_I (OP_REGVAR, CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
 135 stmt: CEE_STIND_I4 (OP_REGVAR, CEE_ADD (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)) {
 136         int con = state->right->right->tree->inst_c0;
 137         int dreg = state->left->tree->dreg;
 138         int sreg = state->right->left->left->tree->dreg;
 139
 140         if (state->right->op == CEE_ADD)
 141                 tree->opcode = OP_ADD_IMM;
 142         else if (state->right->op == CEE_SUB)
 143                 tree->opcode = OP_SUB_IMM;
 144         else
 145                 g_assert_not_reached ();
 146         tree->inst_imm = con;
 147         tree->sreg1 = sreg;
 148         tree->dreg = dreg;
 149         mono_bblock_add_inst (s->cbb, tree);
 150 }
 151
 152 stmt: OP_OUTARG_MEMBASE (reg) {
 153         MonoPPCArgInfo *ai = tree->backend.data;
 154         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg1);
 155 }
 156
 157 stmt: OP_OUTARG_MEMBASE (OP_REGVAR) {
 158         MonoPPCArgInfo *ai = tree->backend.data;
 159         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->tree->dreg);
 160 }
 161
 162 stmt: OP_OUTARG_MEMBASE (lreg) {
 163         MonoPPCArgInfo *ai = tree->backend.data;
 164         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->reg2);
 165         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset + 4, state->left->reg1);
 166 }
 167
 168 stmt: OP_OUTARG_MEMBASE (OP_ICONST) {
 169         MonoPPCArgInfo *ai = tree->backend.data;
 170         MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, ppc_r1, ai->offset, state->left->tree->inst_c0);
 171 }
 172
 173 stmt: OP_OUTARG_MEMBASE (CEE_LDIND_REF (OP_REGVAR)) {
 174         MonoPPCArgInfo *ai = tree->backend.data;
 175         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, ai->offset, state->left->left->tree->dreg);
 176 }
 177
 178 stmt: OP_OUTARG_MEMBASE (freg) {
 179         MonoPPCArgInfo *ai = tree->backend.data;
 180         int opcode = ai->size  == 4? OP_STORER4_MEMBASE_REG: OP_STORER8_MEMBASE_REG;
 181         MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, ppc_r1, ai->offset, state->left->reg1);
 182 }
 183
 184 stmt: OP_OUTARG (reg) {
 185         MonoCallInst *call = tree->inst_call;
 186
 187         tree->opcode = OP_SETREG;
 188         tree->dreg = mono_regstate_next_int (s->rs);
 189         tree->sreg1 = state->left->reg1;
 190         mono_bblock_add_inst (s->cbb, tree);
 191         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 192 }
 193
 194 stmt: OP_OUTARG (OP_REGVAR) {
 195         MonoCallInst *call = tree->inst_call;
 196
 197         tree->opcode = OP_SETREG;
 198         tree->dreg = mono_regstate_next_int (s->rs);
 199         tree->sreg1 = state->left->tree->dreg;
 200         mono_bblock_add_inst (s->cbb, tree);
 201         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 202 }
 203
 204 stmt: OP_OUTARG (lreg) {
 205         MonoCallInst *call = tree->inst_call;
 206         int tdreg = mono_regstate_next_int (s->rs);
 207
 208         MONO_EMIT_NEW_UNALU (s, OP_SETREG, tdreg, state->left->reg2);
 209         mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
 210         tree->opcode = OP_SETREG;
 211         tree->dreg = mono_regstate_next_int (s->rs);
 212         tree->sreg1 = state->left->reg1;
 213         mono_bblock_add_inst (s->cbb, tree);
 214         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
 215 }
 216
 217 stmt: OP_OUTARG (OP_ICONST) {
 218         MonoCallInst *call = tree->inst_call;
 219
 220         tree->opcode = OP_SETREGIMM;
 221         tree->dreg = mono_regstate_next_int (s->rs);
 222         tree->inst_c0 = state->left->tree->inst_c0;
 223         mono_bblock_add_inst (s->cbb, tree);
 224         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 225 }
 226
 227 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
 228         MonoCallInst *call = tree->inst_call;
 229
 230         tree->opcode = OP_SETREG;
 231         tree->dreg = mono_regstate_next_int (s->rs);
 232         tree->sreg1 = state->left->left->tree->dreg;
 233         mono_bblock_add_inst (s->cbb, tree);
 234         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 235 }
 236
 237 #stmt: OP_OUTARG (CEE_LDOBJ (reg)) {
 238 #       tree->opcode = OP_X86_PUSH;
 239 #       tree->sreg1 = state->left->reg1;
 240 #       mono_bblock_add_inst (s->cbb, tree);
 241 #}
 242
 243 stmt: OP_OUTARG_R8 (freg),
 244 stmt: OP_OUTARG (freg) {
 245         MonoCallInst *call = tree->inst_call;
 246
 247         tree->opcode = OP_SETFREG;
 248         tree->dreg = mono_regstate_next_float (s->rs);
 249         tree->sreg1 = state->left->reg1;
 250         mono_bblock_add_inst (s->cbb, tree);
 251         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, TRUE);
 252 }
 253
 254 stmt: OP_OUTARG_R8 (CEE_LDOBJ (base)) {
 255         /* small struct with fp value goes in a fp register */
 256         MonoInst *vt = state->left->left->tree;
 257         int tmpr, soffset, dreg;
 258         MonoCallInst *call = tree->inst_call;
 259
 260         soffset = vt->inst_offset;
 261         tmpr = mono_regstate_next_float (s->rs);
 262         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR4_MEMBASE, tmpr, vt->inst_basereg, soffset);
 263         dreg = mono_regstate_next_float (s->rs);
 264         MONO_EMIT_NEW_UNALU (s, OP_SETFREG, dreg, tmpr);
 265         mono_call_inst_add_outarg_reg (s, call, dreg, tree->backend.reg3, TRUE);
 266 }
 267
 268 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
 269         MonoCallInst *call = tree->inst_call;
 270         MonoPPCArgInfo *ai = tree->backend.data;
 271         MonoInst *vt = state->left->left->tree;
 272         int start_reg = ai->reg;
 273         int nregs = ai->size;
 274         int ovf_size = ai->vtsize;
 275         int i, tmpr, soffset, dreg;
 276         int size = 0;
 277         soffset = vt->inst_offset;
 278 /*
 279   Darwin needs some special handling for 1 and 2 byte arguments
 280 */
 281 #ifdef __APPLE__
 282         if (vt->inst_vtype && MONO_TYPE_ISSTRUCT (vt->inst_vtype) && vt->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
 283             size =  mono_class_native_size (mono_class_from_mono_type (vt->inst_vtype), NULL);
 284         if (size == 2 || size == 1) {
 285                 tmpr = mono_regstate_next_int (s->rs);
 286                 if (size == 1)
 287                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, tmpr, vt->inst_basereg, soffset);
 288                 else
 289                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, tmpr, vt->inst_basereg, soffset);
 290                 dreg = mono_regstate_next_int (s->rs);
 291                 MONO_EMIT_NEW_UNALU (s, OP_SETREG, dreg, tmpr);
 292                 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg, FALSE);
 293         } else
 294 #endif
 295         for (i = 0; i < nregs; ++i) {
 296                 tmpr = mono_regstate_next_int (s->rs);
 297                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
 298                 dreg = mono_regstate_next_int (s->rs);
 299                 MONO_EMIT_NEW_UNALU (s, OP_SETREG, dreg, tmpr);
 300                 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg + i, FALSE);
 301                 soffset += sizeof (gpointer);
 302         }
 303         //g_print ("vt size: %d at R%d + %d\n", ai->offset, vt->inst_basereg, vt->inst_offset);
 304         if (ovf_size != 0) {
 305                 mini_emit_memcpy (s, ppc_r1, ai->offset + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
 306         }
 307 }
 308
 309 stmt: OP_OUTARG_VT (OP_ICONST) {
 310         MonoCallInst *call = tree->inst_call;
 311         MonoPPCArgInfo *ai = tree->backend.data;
 312         int start_reg = ai->reg;
 313         int nregs = ai->size;
 314         if (nregs) {
 315                 tree->opcode = OP_SETREGIMM;
 316                 tree->dreg = mono_regstate_next_int (s->rs);
 317                 tree->inst_c0 = state->left->tree->inst_c0;
 318                 mono_bblock_add_inst (s->cbb, tree);
 319                 mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
 320         } else {
 321                 g_assert_not_reached ();
 322         }
 323 }
 324
 325 stmt: OP_OUTARG_VT (reg) {
 326         MonoCallInst *call = tree->inst_call;
 327         MonoPPCArgInfo *ai = tree->backend.data;
 328         int start_reg = ai->reg;
 329         int nregs = ai->size;
 330         if (nregs) {
 331                 tree->opcode = OP_SETREG;
 332                 tree->dreg = mono_regstate_next_int (s->rs);
 333                 tree->sreg1 = state->left->reg1;
 334                 mono_bblock_add_inst (s->cbb, tree);
 335                 mono_call_inst_add_outarg_reg (s, call, tree->dreg, start_reg, FALSE);
 336         } else {
 337                 g_assert_not_reached ();
 338         }
 339 }
 340
 341 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
 342         /* nothing to do: the value is already on the FP stack */
 343 }
 344
 345 stmt: CEE_BNE_UN (fpcflags) {
 346         tree->opcode = OP_FBNE_UN;
 347         mono_bblock_add_inst (s->cbb, tree);
 348 }
 349
 350 stmt: CEE_BEQ (fpcflags) {
 351         tree->opcode = OP_FBEQ;
 352         mono_bblock_add_inst (s->cbb, tree);
 353 }
 354
 355 stmt: CEE_BLT (fpcflags) {
 356         tree->opcode = OP_FBLT;
 357         mono_bblock_add_inst (s->cbb, tree);
 358 }
 359
 360 stmt: CEE_BLT_UN (fpcflags) {
 361         tree->opcode = OP_FBLT_UN;
 362         mono_bblock_add_inst (s->cbb, tree);
 363 }
 364
 365 stmt: CEE_BGT (fpcflags) {
 366         tree->opcode = OP_FBGT;
 367         mono_bblock_add_inst (s->cbb, tree);
 368 }
 369
 370 stmt: CEE_BGT_UN (fpcflags) {
 371         tree->opcode = OP_FBGT_UN;
 372         mono_bblock_add_inst (s->cbb, tree);
 373 }
 374
 375 stmt: CEE_BGE  (fpcflags) {
 376         tree->opcode = OP_FBGE;
 377         mono_bblock_add_inst (s->cbb, tree);
 378 }
 379
 380 stmt: CEE_BGE_UN (fpcflags) {
 381         tree->opcode = OP_FBGE_UN;
 382         mono_bblock_add_inst (s->cbb, tree);
 383 }
 384
 385 stmt: CEE_BLE  (fpcflags) {
 386         tree->opcode = OP_FBLE;
 387         mono_bblock_add_inst (s->cbb, tree);
 388 }
 389
 390 stmt: CEE_BLE_UN (fpcflags) {
 391         tree->opcode = OP_FBLE_UN;
 392         mono_bblock_add_inst (s->cbb, tree);
 393 }
 394
 395 stmt: CEE_POP (freg) "0" {
 396         /* nothing to do */
 397 }
 398
 399 freg: OP_LCONV_TO_R8 (lreg) {
 400         /* nothing to do - emulated */
 401 }
 402
 403 freg: OP_LCONV_TO_R4 (lreg) {
 404         /* nothing to do - emulated */
 405 }
 406
 407 freg: OP_LCONV_TO_R_UN (lreg) {
 408         /* nothing to do - emulated */
 409 }
 410
 411 freg: OP_FREM (freg, freg) {
 412         /* nothing to do - emulated */
 413 }
 414
 415 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
 416         MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
 417                          state->left->right->reg1);
 418 }
 419
 420 reg: OP_CLT (OP_COMPARE (freg, freg)) {
 421         MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
 422                          state->left->right->reg1);
 423 }
 424
 425 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
 426         MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
 427                          state->left->right->reg1);
 428 }
 429
 430 reg: OP_CGT (OP_COMPARE (freg, freg)) {
 431         MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
 432                          state->left->right->reg1);
 433 }
 434
 435 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
 436         MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
 437                          state->left->right->reg1);
 438 }
 439
 440 reg: CEE_ADD_OVF (reg, reg) "0" {
 441         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 442 }
 443
 444 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
 445         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 446 }
 447
 448 reg: CEE_SUB_OVF (reg, reg) "0" {
 449         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 450 }
 451
 452 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
 453         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 454 }
 455 %%