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 (s, 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 (s, 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         /* An #if would be better here, but monoburg
 180            strips them out as comments */
 181         if (G_BYTE_ORDER == G_BIG_ENDIAN)
 182                 mono_call_inst_add_outarg_reg (s, call, tdreg, tree->unused, FALSE);
 183         else
 184                 mono_call_inst_add_outarg_reg (s, call, tdreg, tree->unused + 1, FALSE);
 185
 186         tree->opcode = OP_SETREG;
 187         tree->dreg = mono_regstate_next_int (s->rs);
 188         tree->sreg1 = state->left->reg1;
 189         mono_bblock_add_inst (s->cbb, tree);
 190
 191         if (G_BYTE_ORDER == G_BIG_ENDIAN)
 192                 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->unused + 1, FALSE);
 193         else
 194                 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->unused, FALSE);
 195 }
 196
 197 stmt: OP_OUTARG (OP_ICONST) {
 198         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 199         tree->opcode = OP_ICONST;
 200         tree->dreg = mono_regstate_next_int (s->rs);
 201         tree->inst_c0 = state->left->tree->inst_c0;
 202         mono_bblock_add_inst (s->cbb, tree);
 203
 204         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->unused, FALSE);
 205 }
 206
 207 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
 208         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 209         tree->opcode = OP_SETREG;
 210         tree->sreg1 = state->left->left->tree->dreg;
 211         tree->dreg = mono_regstate_next_int (s->rs);
 212         mono_bblock_add_inst (s->cbb, tree);
 213
 214         mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->unused, FALSE);
 215 }
 216
 217 stmt: OP_OUTARG_R8 (freg),
 218 stmt: OP_OUTARG (freg) {
 219         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 220         int creg;
 221         /* FIXME: call mono_call_inst_add_outarg_reg () on the out regs */
 222         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
 223         creg = mono_regstate_next_int (s->rs);
 224         mono_call_inst_add_outarg_reg (s, call, creg, tree->unused, FALSE);
 225         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
 226         creg = mono_regstate_next_int (s->rs);
 227         mono_call_inst_add_outarg_reg (s, call, creg, tree->unused + 1, FALSE);
 228         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8 + 4));
 229 }
 230
 231 stmt: OP_OUTARG_R4 (freg) {
 232         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 233         int creg;
 234         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
 235         creg = mono_regstate_next_int (s->rs);
 236         mono_call_inst_add_outarg_reg (s, call, creg, tree->unused, FALSE);
 237         MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
 238 }
 239
 240 stmt: OP_OUTARG_MEMBASE (reg) {
 241         MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, tree->unused >> 8, state->left->reg1);
 242 }
 243
 244 stmt: OP_OUTARG_MEMBASE (lreg) {
 245         int offset = tree->unused >> 8;
 246         if (G_BYTE_ORDER == G_BIG_ENDIAN) {
 247                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg2);
 248                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg1);
 249         } else {
 250                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
 251                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg2);
 252         }
 253 }
 254
 255 stmt: OP_OUTARG_MEMBASE (freg) {
 256         int offset = tree->unused >> 8;
 257         if ((tree->unused & 0xff) == 8)
 258                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
 259         else if ((tree->unused & 0xff) == 4)
 260                 MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
 261         else
 262                 g_assert_not_reached ();
 263 }
 264
 265 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
 266         MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 267         MonoInst *vt = state->left->left->tree;
 268         int start_reg = tree->unused & 0xf;
 269         int nregs = (tree->unused >> 4) & 0xf;
 270         int ovf_size = (tree->unused >> 8) & 0xfff;
 271         int doffset = ((tree->unused >> 20) & 0xfff) * 4;
 272         int i, tmpr, soffset, dreg;
 273         int size = 0;
 274         soffset = vt->inst_offset;
 275
 276         for (i = 0; i < nregs; ++i) {
 277                 tmpr = mono_regstate_next_int (s->rs);
 278                 dreg = mono_regstate_next_int (s->rs);
 279                 MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
 280                 MONO_EMIT_NEW_UNALU (s, OP_SETREG, dreg, tmpr);
 281                 mono_call_inst_add_outarg_reg (s, call, dreg, start_reg + i, FALSE);
 282                 soffset += sizeof (gpointer);
 283         }
 284         //g_print ("vt size: %d at R%d + %d\n", doffset, vt->inst_basereg, vt->inst_offset);
 285         if (ovf_size != 0) {
 286                 mini_emit_memcpy (s, ARMREG_SP, doffset, vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
 287         }
 288 }
 289
 290 stmt: OP_OUTARG_VT (OP_ICONST) {
 291         int nregs = (tree->unused >> 4) & 0xf;
 292         if (nregs) {
 293                 MonoCallInst *call = (MonoCallInst*)tree->inst_right;
 294                 tree->opcode = OP_ICONST;
 295                 tree->dreg = mono_regstate_next_int (s->rs);
 296                 tree->inst_c0 = state->left->tree->inst_c0;
 297                 mono_bblock_add_inst (s->cbb, tree);
 298
 299                 mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->unused & 0xf, FALSE);
 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->reg1;
 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 (OP_COMPARE (freg, freg)) {
 323         MONO_EMIT_BIALU (s, tree, OP_FBNE_UN, -1, state->left->left->reg1, state->left->right->reg1);
 324 }
 325
 326 stmt: CEE_BEQ (OP_COMPARE (freg, freg)) {
 327         MONO_EMIT_BIALU (s, tree, OP_FBEQ, -1, state->left->left->reg1, state->left->right->reg1);
 328 }
 329
 330 stmt: CEE_BLT (OP_COMPARE (freg, freg)) {
 331         MONO_EMIT_BIALU (s, tree, OP_FBLT, -1, state->left->left->reg1, state->left->right->reg1);
 332 }
 333
 334 stmt: CEE_BLT_UN (OP_COMPARE (freg, freg)) {
 335         MONO_EMIT_BIALU (s, tree, OP_FBLT_UN, -1, state->left->left->reg1, state->left->right->reg1);
 336 }
 337
 338 stmt: CEE_BGT (OP_COMPARE (freg, freg)) {
 339         MONO_EMIT_BIALU (s, tree, OP_FBGT, -1, state->left->left->reg1, state->left->right->reg1);
 340 }
 341
 342 stmt: CEE_BGT_UN (OP_COMPARE (freg, freg)) {
 343         MONO_EMIT_BIALU (s, tree, OP_FBGT_UN, -1, state->left->left->reg1, state->left->right->reg1);
 344 }
 345
 346 stmt: CEE_BGE  (OP_COMPARE (freg, freg)) {
 347         MONO_EMIT_BIALU (s, tree, OP_FBGE, -1, state->left->left->reg1, state->left->right->reg1);
 348 }
 349
 350 stmt: CEE_BGE_UN (OP_COMPARE (freg, freg)) {
 351         MONO_EMIT_BIALU (s, tree, OP_FBGE_UN, -1, state->left->left->reg1, state->left->right->reg1);
 352 }
 353
 354 stmt: CEE_BLE  (OP_COMPARE (freg, freg)) {
 355         MONO_EMIT_BIALU (s, tree, OP_FBLE, -1, state->left->left->reg1, state->left->right->reg1);
 356 }
 357
 358 stmt: CEE_BLE_UN (OP_COMPARE (freg, freg)) {
 359         MONO_EMIT_BIALU (s, tree, OP_FBLE_UN, -1, state->left->left->reg1, state->left->right->reg1);
 360 }
 361
 362 stmt: CEE_POP (freg) "0" {
 363         /* nothing to do */
 364 }
 365
 366 freg: OP_LCONV_TO_R8 (lreg) {
 367         /* nothing to do - emulated */
 368 }
 369
 370 freg: OP_LCONV_TO_R4 (lreg) {
 371         /* nothing to do - emulated */
 372 }
 373
 374 freg: OP_LCONV_TO_R_UN (lreg) {
 375         /* nothing to do - emulated */
 376 }
 377
 378 freg: OP_FREM (freg, freg) {
 379         /* nothing to do - emulated */
 380 }
 381
 382 reg: OP_CEQ (OP_COMPARE (freg, freg)) {
 383         MONO_EMIT_BIALU (s, tree, OP_FCEQ, state->reg1, state->left->left->reg1,
 384                          state->left->right->reg1);
 385 }
 386
 387 reg: OP_CLT (OP_COMPARE (freg, freg)) {
 388         MONO_EMIT_BIALU (s, tree, OP_FCLT, state->reg1, state->left->left->reg1,
 389                          state->left->right->reg1);
 390 }
 391
 392 reg: OP_CLT_UN (OP_COMPARE (freg, freg)) {
 393         MONO_EMIT_BIALU (s, tree, OP_FCLT_UN, state->reg1, state->left->left->reg1,
 394                          state->left->right->reg1);
 395 }
 396
 397 reg: OP_CGT (OP_COMPARE (freg, freg)) {
 398         MONO_EMIT_BIALU (s, tree, OP_FCGT, state->reg1, state->left->left->reg1,
 399                          state->left->right->reg1);
 400 }
 401
 402 reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
 403         MONO_EMIT_BIALU (s, tree, OP_FCGT_UN, state->reg1, state->left->left->reg1,
 404                          state->left->right->reg1);
 405 }
 406
 407 reg: CEE_ADD_OVF (reg, reg) "0" {
 408         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 409 }
 410
 411 reg: CEE_ADD_OVF_UN (reg, reg) "0" {
 412         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 413 }
 414
 415 reg: CEE_SUB_OVF (reg, reg) "0" {
 416         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 417 }
 418
 419 reg: CEE_SUB_OVF_UN (reg, reg) "0" {
 420         MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
 421 }
 422
 423 stmt: CEE_SWITCH (reg) {
 424         MonoInst *label;
 425         int n = GPOINTER_TO_INT (tree->klass);
 426
 427         MONO_NEW_LABEL (s, label);
 428
 429         MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n);
 430         MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]);
 431         mono_bblock_add_inst (s->cbb, label);
 432         mono_create_jump_table (s, label, tree->inst_many_bb, n);
 433         /* the backend code will deal with aot vs normal case */
 434         tree->sreg1 = state->left->reg1;
 435         mono_bblock_add_inst (s->cbb, tree);
 436 }
 437
 438 %%