mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_ENDFINALLY {
+stmt: OP_ENDFINALLY {
MonoInst *spvar = mono_find_spvar_for_region (s, s->cbb->region);
tree->inst_left = spvar;
mono_bblock_add_inst (s->cbb, tree);
}
stmt: OP_SETRET (freg) {
- tree->opcode = OP_FMOVE;
- tree->sreg1 = state->left->reg1;
- tree->dreg = 0;
- mono_bblock_add_inst (s->cbb, tree);
+ if (SOFT_FLOAT_IMPL) {
+ tree->opcode = OP_SETLRET;
+ tree->sreg1 = state->left->reg1;
+ tree->sreg2 = state->left->reg2;
+ tree->dreg = ARMREG_R0;
+ mono_bblock_add_inst (s->cbb, tree);
+ } else {
+ tree->opcode = OP_FMOVE;
+ tree->sreg1 = state->left->reg1;
+ tree->dreg = 0;
+ mono_bblock_add_inst (s->cbb, tree);
+ }
}
stmt: OP_SETRET (OP_ICONST) {
stmt: OP_OUTARG (reg) {
MonoCallInst *call = (MonoCallInst*)tree->inst_right;
- tree->opcode = OP_SETREG;
+ tree->opcode = OP_MOVE;
tree->dreg = mono_regstate_next_int (s->rs);
tree->sreg1 = state->left->reg1;
mono_bblock_add_inst (s->cbb, tree);
- mono_call_inst_add_outarg_reg (call, tree->dreg, tree->unused, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
stmt: OP_OUTARG (OP_REGVAR) {
MonoCallInst *call = (MonoCallInst*)tree->inst_right;
- tree->opcode = OP_SETREG;
+ tree->opcode = OP_MOVE;
tree->dreg = mono_regstate_next_int (s->rs);
tree->sreg1 = state->left->tree->dreg;
mono_bblock_add_inst (s->cbb, tree);
- mono_call_inst_add_outarg_reg (call, tree->dreg, tree->unused, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
stmt: OP_OUTARG (lreg) {
MonoCallInst *call = (MonoCallInst*)tree->inst_right;
int tdreg;
tdreg = mono_regstate_next_int (s->rs);
- MONO_EMIT_NEW_UNALU (s, OP_SETREG, tdreg, state->left->reg2);
+ MONO_EMIT_NEW_UNALU (s, OP_MOVE, tdreg, state->left->reg2);
/* An #if would be better here, but monoburg
strips them out as comments */
if (G_BYTE_ORDER == G_BIG_ENDIAN)
- mono_call_inst_add_outarg_reg (call, tdreg, tree->unused, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
else
- mono_call_inst_add_outarg_reg (call, tdreg, tree->unused + 1, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3 + 1, FALSE);
- tree->opcode = OP_SETREG;
+ tree->opcode = OP_MOVE;
tree->dreg = mono_regstate_next_int (s->rs);
tree->sreg1 = state->left->reg1;
mono_bblock_add_inst (s->cbb, tree);
if (G_BYTE_ORDER == G_BIG_ENDIAN)
- mono_call_inst_add_outarg_reg (call, tree->dreg, tree->unused + 1, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
else
- mono_call_inst_add_outarg_reg (call, tree->dreg, tree->unused, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
stmt: OP_OUTARG (OP_ICONST) {
tree->inst_c0 = state->left->tree->inst_c0;
mono_bblock_add_inst (s->cbb, tree);
- mono_call_inst_add_outarg_reg (call, tree->dreg, tree->unused, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
MonoCallInst *call = (MonoCallInst*)tree->inst_right;
- tree->opcode = OP_SETREG;
+ tree->opcode = OP_MOVE;
tree->sreg1 = state->left->left->tree->dreg;
tree->dreg = mono_regstate_next_int (s->rs);
mono_bblock_add_inst (s->cbb, tree);
- mono_call_inst_add_outarg_reg (call, tree->dreg, tree->unused, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
}
stmt: OP_OUTARG_R8 (freg),
stmt: OP_OUTARG (freg) {
MonoCallInst *call = (MonoCallInst*)tree->inst_right;
int creg;
- /* FIXME: call mono_call_inst_add_outarg_reg () on the out regs */
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
- creg = mono_regstate_next_int (s->rs);
- mono_call_inst_add_outarg_reg (call, creg, tree->unused, FALSE);
- MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
- creg = mono_regstate_next_int (s->rs);
- mono_call_inst_add_outarg_reg (call, creg, tree->unused + 1, FALSE);
- MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8 + 4));
+ if (SOFT_FLOAT_IMPL) {
+ /* same as the OUTARG (lreg) case */
+ int tdreg;
+ tdreg = mono_regstate_next_int (s->rs);
+ MONO_EMIT_NEW_UNALU (s, OP_MOVE, tdreg, state->left->reg2);
+
+ /* An #if would be better here, but monoburg
+ strips them out as comments */
+ if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
+ else
+ mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3 + 1, FALSE);
+
+ tree->opcode = OP_MOVE;
+ tree->dreg = mono_regstate_next_int (s->rs);
+ tree->sreg1 = state->left->reg1;
+ mono_bblock_add_inst (s->cbb, tree);
+
+ if (G_BYTE_ORDER == G_BIG_ENDIAN)
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3 + 1, FALSE);
+ else
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
+ } else {
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
+ creg = mono_regstate_next_int (s->rs);
+ mono_call_inst_add_outarg_reg (s, call, creg, tree->backend.reg3, FALSE);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
+ creg = mono_regstate_next_int (s->rs);
+ mono_call_inst_add_outarg_reg (s, call, creg, tree->backend.reg3 + 1, FALSE);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8 + 4));
+ }
}
stmt: OP_OUTARG_R4 (freg) {
int creg;
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
creg = mono_regstate_next_int (s->rs);
- mono_call_inst_add_outarg_reg (call, creg, tree->unused, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, creg, tree->backend.reg3, FALSE);
MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
}
stmt: OP_OUTARG_MEMBASE (reg) {
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, tree->unused >> 8, state->left->reg1);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, tree->backend.arg_info >> 8, state->left->reg1);
}
stmt: OP_OUTARG_MEMBASE (lreg) {
- int offset = tree->unused >> 8;
+ int offset = tree->backend.arg_info >> 8;
+ int partial = (tree->backend.arg_info & 0xff) == 0xff;
+ if (partial) {
+ MonoCallInst *call = (MonoCallInst*)tree->inst_right;
+ if (G_BYTE_ORDER == G_BIG_ENDIAN) {
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
+ } else {
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg2);
+ }
+ tree->opcode = OP_MOVE;
+ tree->dreg = mono_regstate_next_int (s->rs);
+ tree->sreg1 = G_BYTE_ORDER == G_BIG_ENDIAN? state->left->reg2: state->left->reg1;
+ mono_bblock_add_inst (s->cbb, tree);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, ARMREG_R3, FALSE);
+ return;
+ }
if (G_BYTE_ORDER == G_BIG_ENDIAN) {
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg2);
MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg1);
}
stmt: OP_OUTARG_MEMBASE (freg) {
- int offset = tree->unused >> 8;
- if ((tree->unused & 0xff) == 8)
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
- else if ((tree->unused & 0xff) == 4)
- MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
- else
- g_assert_not_reached ();
+ int offset = tree->backend.arg_info >> 8;
+ if (SOFT_FLOAT_IMPL) {
+ int partial = (tree->backend.arg_info & 0xff) == 0xff;
+ /* same as OP_OUTARG_MEMBASE (lreg) */
+ if (G_BYTE_ORDER == G_BIG_ENDIAN) {
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg2);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg1);
+ } else {
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset + 4, state->left->reg2);
+ }
+ } else {
+ if ((tree->backend.arg_info & 0xff) == 8)
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
+ else if ((tree->backend.arg_info & 0xff) == 4)
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ARMREG_SP, offset, state->left->reg1);
+ else if ((tree->backend.arg_info & 0xff) == 0xff) {
+ MonoCallInst *call = (MonoCallInst*)tree->inst_right;
+ int creg;
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ARMREG_SP, (s->param_area - 8), state->left->reg1);
+ creg = mono_regstate_next_int (s->rs);
+ mono_call_inst_add_outarg_reg (s, call, creg, ARMREG_R3, FALSE);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 8));
+ creg = mono_regstate_next_int (s->rs);
+ MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOAD_MEMBASE, creg, ARMREG_SP, (s->param_area - 4));
+ MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ARMREG_SP, offset, creg);
+ } else
+ g_assert_not_reached ();
+ }
}
stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
MonoCallInst *call = (MonoCallInst*)tree->inst_right;
MonoInst *vt = state->left->left->tree;
- int start_reg = tree->unused & 0xf;
- int nregs = (tree->unused >> 4) & 0xf;
- int ovf_size = (tree->unused >> 8) & 0xfff;
- int doffset = ((tree->unused >> 20) & 0xfff) * 4;
+ int start_reg = tree->backend.arg_info & 0xf;
+ int nregs = (tree->backend.arg_info >> 4) & 0xf;
+ int ovf_size = (tree->backend.arg_info >> 8) & 0xfff;
+ int doffset = ((tree->backend.arg_info >> 20) & 0xfff) * 4;
int i, tmpr, soffset, dreg;
int size = 0;
soffset = vt->inst_offset;
tmpr = mono_regstate_next_int (s->rs);
dreg = mono_regstate_next_int (s->rs);
MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
- MONO_EMIT_NEW_UNALU (s, OP_SETREG, start_reg + i, tmpr);
- mono_call_inst_add_outarg_reg (call, dreg, start_reg + i, FALSE);
+ MONO_EMIT_NEW_UNALU (s, OP_MOVE, dreg, tmpr);
+ mono_call_inst_add_outarg_reg (s, call, dreg, start_reg + i, FALSE);
soffset += sizeof (gpointer);
}
//g_print ("vt size: %d at R%d + %d\n", doffset, vt->inst_basereg, vt->inst_offset);
}
stmt: OP_OUTARG_VT (OP_ICONST) {
- int nregs = (tree->unused >> 4) & 0xf;
+ int nregs = (tree->backend.arg_info >> 4) & 0xf;
if (nregs) {
MonoCallInst *call = (MonoCallInst*)tree->inst_right;
tree->opcode = OP_ICONST;
tree->inst_c0 = state->left->tree->inst_c0;
mono_bblock_add_inst (s->cbb, tree);
- mono_call_inst_add_outarg_reg (call, tree->dreg, tree->unused & 0xf, FALSE);
+ mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.arg_info & 0xf, FALSE);
} else {
g_assert_not_reached ();
}
}
stmt: OP_OUTARG_VT (reg) {
- int start_reg = tree->unused & 0xff;
- int nregs = (tree->unused >> 8) & 0xff;
+ int start_reg = tree->backend.arg_info & 0xff;
+ int nregs = (tree->backend.arg_info >> 8) & 0xff;
if (nregs) {
- tree->opcode = OP_SETREG;
+ tree->opcode = OP_MOVE;
tree->dreg = start_reg;
tree->sreg1 = state->left->reg1;
mono_bblock_add_inst (s->cbb, tree);
stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
/* nothing to do: the value is already on the FP stack */
}
-
-stmt: CEE_BNE_UN (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBNE_UN, -1, state->left->left->reg1, state->left->right->reg1);
+
+stmt: CEE_BNE_UN (fpcflags) {
+ tree->opcode = OP_FBNE_UN;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BEQ (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBEQ, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BEQ (fpcflags) {
+ tree->opcode = OP_FBEQ;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BLT (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBLT, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BLT (fpcflags) {
+ tree->opcode = OP_FBLT;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BLT_UN (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBLT_UN, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BLT_UN (fpcflags) {
+ tree->opcode = OP_FBLT_UN;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BGT (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBGT, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BGT (fpcflags) {
+ tree->opcode = OP_FBGT;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BGT_UN (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBGT_UN, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BGT_UN (fpcflags) {
+ tree->opcode = OP_FBGT_UN;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BGE (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBGE, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BGE (fpcflags) {
+ tree->opcode = OP_FBGE;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BGE_UN (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBGE_UN, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BGE_UN (fpcflags) {
+ tree->opcode = OP_FBGE_UN;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BLE (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBLE, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BLE (fpcflags) {
+ tree->opcode = OP_FBLE;
+ mono_bblock_add_inst (s->cbb, tree);
}
-stmt: CEE_BLE_UN (OP_COMPARE (freg, freg)) {
- MONO_EMIT_BIALU (s, tree, OP_FBLE_UN, -1, state->left->left->reg1, state->left->right->reg1);
+stmt: CEE_BLE_UN (fpcflags) {
+ tree->opcode = OP_FBLE_UN;
+ mono_bblock_add_inst (s->cbb, tree);
}
stmt: CEE_POP (freg) "0" {
MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
}
-stmt: CEE_SWITCH (reg) {
+stmt: OP_SWITCH (reg) {
MonoInst *label;
int n = GPOINTER_TO_INT (tree->klass);
MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, n);
MONO_EMIT_NEW_BRANCH_BLOCK (s, CEE_BGE_UN, tree->inst_many_bb [n]);
- mono_bblock_add_inst (s->cbb, label);
- mono_create_jump_table (s, label, tree->inst_many_bb, n);
- /* the backend code will deal with aot vs normal case */
- tree->sreg1 = state->left->reg1;
- mono_bblock_add_inst (s->cbb, tree);
+
+ if (s->compile_aot) {
+ /* FIXME: Optimize this */
+ int offset_reg = mono_regstate_next_int (s->rs);
+ int target_reg = mono_regstate_next_int (s->rs);
+ int table_reg = mono_regstate_next_int (s->rs);
+ int sum_reg = mono_regstate_next_int (s->rs);
+ MonoJumpInfoBBTable *table;
+
+ MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, offset_reg, state->left->reg1, 2);
+
+ table = mono_mempool_alloc (s->mempool, sizeof (MonoJumpInfoBBTable));
+ table->table = tree->inst_many_bb;
+ table->table_size = n;
+
+ MONO_EMIT_NEW_AOTCONST (s, table_reg, table, MONO_PATCH_INFO_SWITCH);
+
+ MONO_EMIT_NEW_BIALU (s, CEE_ADD, sum_reg, table_reg, offset_reg);
+ MONO_EMIT_NEW_LOAD_MEMBASE (s, target_reg, sum_reg, 0);
+ MONO_EMIT_UNALU (s, tree, OP_BR_REG, -1, target_reg);
+ } else {
+ mono_bblock_add_inst (s->cbb, label);
+ mono_create_jump_table (s, label, tree->inst_many_bb, n);
+ /* the backend code will deal with aot vs normal case */
+ tree->sreg1 = state->left->reg1;
+ mono_bblock_add_inst (s->cbb, tree);
+ }
}
%%
projects / mono.git / blobdiff