projects / mono.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* Exception.cs: Cosmetic change to default exception message on
[mono.git] / mono / mini / inssel-arm.brg
diff --git a/mono/mini/inssel-arm.brg b/mono/mini/inssel-arm.brg
index 093685297a637255a47297255f0f73d6a319cb1d..5317b948e4ab6128c709359fd6ee7a4e0f4bcf78 100644 (file)
--- a/mono/mini/inssel-arm.brg
+++ b/mono/mini/inssel-arm.brg
@@ -18,7 +18,7 @@ stmt: OP_START_HANDLER {
        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);
@@ -116,10 +116,18 @@ stmt: OP_SETRET (lreg) {
 }
 
 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) {
@@ -157,7 +165,7 @@ stmt: OP_OUTARG (reg) {
        tree->sreg1 = state->left->reg1;
        mono_bblock_add_inst (s->cbb, tree);
 
-       mono_call_inst_add_outarg_reg (s, 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) {
@@ -167,7 +175,7 @@ stmt: OP_OUTARG (OP_REGVAR) {
        tree->sreg1 = state->left->tree->dreg;
        mono_bblock_add_inst (s->cbb, tree);
 
-       mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->unused, FALSE);
+       mono_call_inst_add_outarg_reg (s, call, tree->dreg, tree->backend.reg3, FALSE);
 }
 
 stmt: OP_OUTARG (lreg) {
@@ -179,9 +187,9 @@ stmt: OP_OUTARG (lreg) {
        /* 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->unused, FALSE);
+               mono_call_inst_add_outarg_reg (s, call, tdreg, tree->backend.reg3, FALSE);
        else
-               mono_call_inst_add_outarg_reg (s, 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->dreg = mono_regstate_next_int (s->rs);
@@ -189,9 +197,9 @@ stmt: OP_OUTARG (lreg) {
        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->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 (s, 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) {
@@ -201,7 +209,7 @@ 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 (s, 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)) {
@@ -211,21 +219,44 @@ stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
        tree->dreg = mono_regstate_next_int (s->rs);
        mono_bblock_add_inst (s->cbb, tree);
 
-       mono_call_inst_add_outarg_reg (s, 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 (s, 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 (s, 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_SETREG, 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_SETREG;
+               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) {
@@ -233,16 +264,31 @@ 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 (s, 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_SETREG;
+               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);
@@ -253,22 +299,44 @@ stmt: OP_OUTARG_MEMBASE (lreg) {
 }
 
 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;
@@ -288,7 +356,7 @@ stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
 }
 
 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;
@@ -296,15 +364,15 @@ stmt: OP_OUTARG_VT (OP_ICONST) {
                tree->inst_c0 = state->left->tree->inst_c0;
                mono_bblock_add_inst (s->cbb, tree);
 
-               mono_call_inst_add_outarg_reg (s, 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->dreg = start_reg;
my mono mirror. check out Moved to http://github.com/mono/mono