mono/mini/inssel-arm.brg

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