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: OP_OUTARG (reg) {
 133         if (tree->inst_imm) {
 134                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
 135                 return;
 136         }
 137         tree->opcode = OP_SETREG;
 138         tree->dreg = tree->unused;
 139         tree->sreg1 = state->left->reg1;
 140         mono_bblock_add_inst (s->cbb, tree);
 141 }
 142
 143 stmt: OP_OUTARG (OP_REGVAR) {
 144         if (tree->inst_imm) {
 145                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->tree->dreg);
 146                 return;
 147         }
 148         tree->opcode = OP_SETREG;
 149         tree->dreg = tree->unused;
 150         tree->sreg1 = state->left->tree->dreg;
 151         mono_bblock_add_inst (s->cbb, tree);
 152 }
 153
 154 stmt: OP_OUTARG (lreg) {
 155         if (tree->inst_imm) {
 156                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg2);
 157                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm + 4, state->left->reg1);
 158                 return;
 159         }
 160         MONO_EMIT_NEW_UNALU (s, OP_SETREG, tree->unused, state->left->reg2);
 161         tree->opcode = OP_SETREG;
 162         tree->dreg = tree->unused + 1;
 163         tree->sreg1 = state->left->reg1;
 164         mono_bblock_add_inst (s->cbb, tree);
 165 }
 166
 167 stmt: OP_OUTARG (OP_ICONST) {
 168         if (tree->inst_imm) {
 169                 MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, ppc_r1, tree->inst_imm, state->left->tree->inst_c0);
 170                 return;
 171         }
 172         tree->opcode = OP_SETREGIMM;
 173         tree->dreg = tree->unused;
 174         tree->inst_c0 = state->left->tree->inst_c0;
 175         mono_bblock_add_inst (s->cbb, tree);
 176 }
 177
 178 #stmt: OP_OUTARG (CEE_LDIND_I4 (base)) {
 179 #       tree->opcode = OP_X86_PUSH_MEMBASE;
 180 #       tree->inst_basereg = state->left->left->tree->inst_basereg;
 181 #       tree->inst_offset = state->left->left->tree->inst_offset;
 182 #       mono_bblock_add_inst (s->cbb, tree);
 183 #}
 184
 185 #stmt: OP_OUTARG (CEE_LDIND_U4 (base)) {
 186 #       tree->opcode = OP_X86_PUSH_MEMBASE;
 187 #       tree->inst_basereg = state->left->left->tree->inst_basereg;
 188 #       tree->inst_offset = state->left->left->tree->inst_offset;
 189 #       mono_bblock_add_inst (s->cbb, tree);
 190 #}
 191
 192 #stmt: OP_OUTARG (CEE_LDIND_I (base)) {
 193 #       tree->opcode = OP_X86_PUSH_MEMBASE;
 194 #       tree->inst_basereg = state->left->left->tree->inst_basereg;
 195 #       tree->inst_offset = state->left->left->tree->inst_offset;
 196 #       mono_bblock_add_inst (s->cbb, tree);
 197 #}
 198
 199 #stmt: OP_OUTARG (CEE_LDIND_REF (base)) {
 200 #       tree->opcode = OP_X86_PUSH_MEMBASE;
 201 #       tree->inst_basereg = state->left->left->tree->inst_basereg;
 202 #       tree->inst_offset = state->left->left->tree->inst_offset;
 203 #       mono_bblock_add_inst (s->cbb, tree);
 204 #}
 205
 206 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
 207         if (tree->inst_imm) {
 208                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->left->tree->dreg);
 209                 return;
 210         }
 211         tree->opcode = OP_SETREG;
 212         tree->sreg1 = state->left->left->tree->dreg;
 213         tree->dreg = tree->unused;
 214         mono_bblock_add_inst (s->cbb, tree);
 215 }
 216
 217 #stmt: OP_OUTARG (CEE_LDOBJ (reg)) {
 218 #       tree->opcode = OP_X86_PUSH;
 219 #       tree->sreg1 = state->left->reg1;
 220 #       mono_bblock_add_inst (s->cbb, tree);
 221 #}
 222
 223 stmt: OP_OUTARG (freg) {
 224         if (tree->inst_imm) {
 225                 int opcode = (tree->unused & 0xff00) == 0x0400? OP_STORER4_MEMBASE_REG: OP_STORER8_MEMBASE_REG;
 226                 MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, ppc_r1, tree->inst_imm, state->left->reg1);
 227                 return;
 228         }
 229         tree->opcode = OP_SETFREG;
 230         tree->sreg1 = state->left->reg1;
 231         tree->dreg = tree->unused & 0xff;
 232         mono_bblock_add_inst (s->cbb, tree);
 233 }
 234
 235 stmt: OP_OUTARG_R4 (freg) {
 236         if (tree->inst_imm) {
 237                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
 238                 return;
 239         }
 240         tree->opcode = OP_SETFREG;
 241         tree->sreg1 = state->left->reg1;
 242         tree->dreg = tree->unused;
 243         mono_bblock_add_inst (s->cbb, tree);
 244 }
 245
 246 stmt: OP_OUTARG_R8 (freg) {
 247         if (tree->inst_imm) {
 248                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
 249                 return;
 250         }
 251         tree->opcode = OP_SETFREG;
 252         tree->sreg1 = state->left->reg1;
 253         tree->dreg = tree->unused;
 254         mono_bblock_add_inst (s->cbb, tree);
 255 }
 256
 257 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
 258         MonoInst *vt = state->left->left->tree;
 259         int start_reg = tree->unused & 0xff;
 260         int nregs = (tree->unused >> 8) & 0xff;
 261         int ovf_size = (tree->unused >> 16) & 0xffff;
 262         int i, tmpr, soffset;
 263         int size = 0;
 264         soffset = vt->inst_offset;
 265 /*
 266   Darwin needs some special handling for 1 and 2 byte arguments
 267 */
 268 #ifdef __APPLE__
 269         if (vt->inst_vtype && MONO_TYPE_ISSTRUCT (vt->inst_vtype) && vt->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
 270             size =  mono_class_native_size (vt->inst_vtype->data.klass, NULL);
 271         if (size == 2 || size == 1) {
 272                 tmpr = mono_regstate_next_int (s->rs);
 273                 if (size == 1)
 274                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, tmpr, vt->inst_basereg, soffset);
 275                 else
 276                         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, tmpr, vt->inst_basereg, soffset);
 277                 MONO_EMIT_NEW_UNALU (s, OP_SETREG, start_reg, tmpr);
 278         } else
 279 #endif
 280         for (i = 0; i < nregs; ++i) {
 281                 tmpr = mono_regstate_next_int (s->rs);
 282                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
 283                 MONO_EMIT_NEW_UNALU (s, OP_SETREG, start_reg + i, tmpr);
 284                 soffset += sizeof (gpointer);
 285         }
 286         //g_print ("vt size: %d at R%d + %d\n", tree->inst_imm, vt->inst_basereg, vt->inst_offset);
 287         if (ovf_size != 0) {
 288                 mini_emit_memcpy (s, ppc_r1, tree->inst_imm + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
 289         }
 290 }
 291
 292 stmt: OP_OUTARG_VT (OP_ICONST) {
 293         int start_reg = tree->unused & 0xff;
 294         int nregs = (tree->unused >> 8) & 0xff;
 295         if (nregs) {
 296                 tree->opcode = OP_SETREGIMM;
 297                 tree->dreg = start_reg;
 298                 tree->inst_c0 = state->left->tree->inst_c0;
 299                 mono_bblock_add_inst (s->cbb, tree);
 300         } else {
 301                 g_assert_not_reached ();
 302         }
 303 }
 304
 305 stmt: OP_OUTARG_VT (reg) {
 306         int start_reg = tree->unused & 0xff;
 307         int nregs = (tree->unused >> 8) & 0xff;
 308         if (nregs) {
 309                 tree->opcode = OP_SETREG;
 310                 tree->dreg = start_reg;
 311                 tree->sreg1 = state->left->tree->dreg;
 312                 mono_bblock_add_inst (s->cbb, tree);
 313         } else {
 314                 g_assert_not_reached ();
 315         }
 316 }
 317
 318 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
 319         /* nothing to do: the value is already on the FP stack */
 320 }
 321
 322 stmt: CEE_BNE_UN (fpcflags) {
 323         tree->opcode = OP_FBNE_UN;
 324         mono_bblock_add_inst (s->cbb, tree);
 325 }
 326
 327 stmt: CEE_BEQ (fpcflags) {
 328         tree->opcode = OP_FBEQ;
 329         mono_bblock_add_inst (s->cbb, tree);
 330 }
 331
 332 stmt: CEE_BLT (fpcflags) {
 333         tree->opcode = OP_FBLT;
 334         mono_bblock_add_inst (s->cbb, tree);
 335 }
 336
 337 stmt: CEE_BLT_UN (fpcflags) {
 338         tree->opcode = OP_FBLT_UN;
 339         mono_bblock_add_inst (s->cbb, tree);
 340 }
 341
 342 stmt: CEE_BGT (fpcflags) {
 343         tree->opcode = OP_FBGT;
 344         mono_bblock_add_inst (s->cbb, tree);
 345 }
 346
 347 stmt: CEE_BGT_UN (fpcflags) {
 348         tree->opcode = OP_FBGT_UN;
 349         mono_bblock_add_inst (s->cbb, tree);
 350 }
 351
 352 stmt: CEE_BGE  (fpcflags) {
 353         tree->opcode = OP_FBGE;
 354         mono_bblock_add_inst (s->cbb, tree);
 355 }
 356
 357 stmt: CEE_BGE_UN (fpcflags) {
 358         tree->opcode = OP_FBGE_UN;
 359         mono_bblock_add_inst (s->cbb, tree);
 360 }
 361
 362 stmt: CEE_BLE  (fpcflags) {
 363         tree->opcode = OP_FBLE;
 364         mono_bblock_add_inst (s->cbb, tree);
 365 }
 366
 367 stmt: CEE_BLE_UN (fpcflags) {
 368         tree->opcode = OP_FBLE_UN;
 369         mono_bblock_add_inst (s->cbb, tree);
 370 }
 371
 372 stmt: CEE_POP (freg) "0" {
 373         /* nothing to do */
 374 }
 375
 376 freg: OP_LCONV_TO_R8 (lreg) {
 377         /* nothing to do - emulated */
 378 }
 379
 380 freg: OP_LCONV_TO_R4 (lreg) {
 381         /* nothing to do - emulated */
 382 }
 383
 384 freg: OP_LCONV_TO_R_UN (lreg) {
 385         /* nothing to do - emulated */
 386 }
 387
 388 freg: OP_FREM (freg, freg) {
 389         /* nothing to do - emulated */
 390 }
 391
 392 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
 393         MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
 394                          state->left->right->reg1);
 395 }
 396
 397 reg: OP_CLT (OP_COMPARE (freg, freg)) {
 398         MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
 399                          state->left->right->reg1);
 400 }
 401
 402 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
 403         MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
 404                          state->left->right->reg1);
 405 }
 406
 407 reg: OP_CGT (OP_COMPARE (freg, freg)) {
 408         MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
 409                          state->left->right->reg1);
 410 }
 411
 412 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
 413         MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
 414                          state->left->right->reg1);
 415 }
 416
 417 reg: CEE_ADD_OVF (reg, reg) "0" {
 418         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 419 }
 420
 421 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
 422         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 423 }
 424
 425 reg: CEE_SUB_OVF (reg, reg) "0" {
 426         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 427 }
 428
 429 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
 430         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 431 }
 432 %%