projects / mono.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
2006-07-08 Zoltan Varga <vargaz@gmail.com>
[mono.git] / mono / mini / inssel-ppc.brg
diff --git a/mono/mini/inssel-ppc.brg b/mono/mini/inssel-ppc.brg
index 1573d923b694fb4e4e8898a7e45985ab7801643c..a1883912efd1981e87e16d4826420581dec8538c 100644 (file)
--- a/mono/mini/inssel-ppc.brg
+++ b/mono/mini/inssel-ppc.brg
@@ -31,6 +31,30 @@ stmt: OP_ENDFILTER (reg) {
        mono_bblock_add_inst (s->cbb, tree);
 }
 
+lreg: OP_LADD_OVF (lreg, lreg) "0" {
+       /* ADC sets the condition code */
+       MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
+       MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
+lreg: OP_LADD_OVF_UN (lreg, lreg) "0" {
+       /* ADC sets the condition code */
+       MONO_EMIT_NEW_BIALU (s, OP_ADDCC, state->reg1, state->left->reg1, state->right->reg1);
+       MONO_EMIT_NEW_BIALU (s, OP_ADD_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
+lreg: OP_LSUB_OVF (lreg, lreg) "0" {
+       /* SBB sets the condition code */
+       MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
+       MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
+lreg: OP_LSUB_OVF_UN (lreg, lreg) "0" {
+       /* SBB sets the condition code */
+       MONO_EMIT_NEW_BIALU (s, OP_SUBCC, state->reg1, state->left->reg1, state->right->reg1);
+       MONO_EMIT_NEW_BIALU (s, OP_SUB_OVF_UN_CARRY, state->reg2, state->left->reg2, state->right->reg2);
+}
+
 stmt: CEE_STIND_I8 (OP_REGVAR, lreg) {
        /* this should only happen for methods returning a long */
        MONO_EMIT_NEW_UNALU (s, OP_MOVE, ppc_r3, state->right->reg1);
@@ -43,25 +67,36 @@ lreg: OP_LNEG (lreg) "2" {
 }
 
 freg: OP_LCONV_TO_R8 (lreg) {
+       tree->dreg = state->reg1;
+       tree->sreg1 = state->left->reg1;
+       tree->sreg2 = state->left->reg2;
        mono_bblock_add_inst (s->cbb, tree);
 }
 
 freg: OP_LCONV_TO_R4 (lreg) {
+       tree->dreg = state->reg1;
+       tree->sreg1 = state->left->reg1;
+       tree->sreg2 = state->left->reg2;
        mono_bblock_add_inst (s->cbb, tree);
 }
 
 freg: CEE_CONV_R_UN (reg) {
+       tree->dreg = state->reg1;
+       tree->sreg1 = state->left->reg1;
        mono_bblock_add_inst (s->cbb, tree);
 }
 
 reg: OP_LOCALLOC (OP_ICONST) {
        /* microcoded in mini-ppc.c */
        tree->sreg1 = mono_regstate_next_int (s->rs);
+       tree->dreg = state->reg1;
        MONO_EMIT_NEW_ICONST (s, tree->sreg1, state->left->tree->inst_c0);
        mono_bblock_add_inst (s->cbb, tree);
 }
 
 reg: OP_LOCALLOC (reg) {
+       tree->dreg = state->reg1;
+       tree->sreg1 = state->left->reg1;
        mono_bblock_add_inst (s->cbb, tree);
 }
 
@@ -76,6 +111,7 @@ stmt: OP_SETRET (lreg) {
        tree->opcode = OP_SETLRET;
        tree->sreg1 = state->left->reg1;
        tree->sreg2 = state->left->reg2;
+       tree->dreg = ppc_r3;
        mono_bblock_add_inst (s->cbb, tree);
 }
 
@@ -93,7 +129,31 @@ stmt: OP_SETRET (OP_ICONST) {
        mono_bblock_add_inst (s->cbb, tree);
 }
 
+stmt: CEE_STIND_I (OP_REGVAR, CEE_SUB (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
+stmt: CEE_STIND_I4 (OP_REGVAR, CEE_SUB (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)),
+stmt: CEE_STIND_I (OP_REGVAR, CEE_ADD (CEE_LDIND_I (OP_REGVAR), OP_ICONST)),
+stmt: CEE_STIND_I4 (OP_REGVAR, CEE_ADD (CEE_LDIND_I4 (OP_REGVAR), OP_ICONST)) {
+       int con = state->right->right->tree->inst_c0;
+       int dreg = state->left->tree->dreg;
+       int sreg = state->right->left->left->tree->dreg;
+
+       if (state->right->op == CEE_ADD)
+               tree->opcode = OP_ADD_IMM;
+       else if (state->right->op == CEE_SUB)
+               tree->opcode = OP_SUB_IMM;
+       else
+               g_assert_not_reached ();
+       tree->inst_imm = con;
+       tree->sreg1 = sreg;
+       tree->dreg = dreg;
+       mono_bblock_add_inst (s->cbb, tree);
+}
+
 stmt: OP_OUTARG (reg) {
+       if (tree->inst_imm) {
+               MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
+               return;
+       }
        tree->opcode = OP_SETREG;
        tree->dreg = tree->unused;
        tree->sreg1 = state->left->reg1;
@@ -101,6 +161,10 @@ stmt: OP_OUTARG (reg) {
 }
 
 stmt: OP_OUTARG (OP_REGVAR) {
+       if (tree->inst_imm) {
+               MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->tree->dreg);
+               return;
+       }
        tree->opcode = OP_SETREG;
        tree->dreg = tree->unused;
        tree->sreg1 = state->left->tree->dreg;
@@ -108,6 +172,11 @@ stmt: OP_OUTARG (OP_REGVAR) {
 }
 
 stmt: OP_OUTARG (lreg) {
+       if (tree->inst_imm) {
+               MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg2);
+               MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm + 4, state->left->reg1);
+               return;
+       }
        MONO_EMIT_NEW_UNALU (s, OP_SETREG, tree->unused, state->left->reg2);
        tree->opcode = OP_SETREG;
        tree->dreg = tree->unused + 1;
@@ -116,6 +185,10 @@ stmt: OP_OUTARG (lreg) {
 }
 
 stmt: OP_OUTARG (OP_ICONST) {
+       if (tree->inst_imm) {
+               MONO_EMIT_NEW_STORE_MEMBASE_IMM (s, OP_STORE_MEMBASE_IMM, ppc_r1, tree->inst_imm, state->left->tree->inst_c0);
+               return;
+       }
        tree->opcode = OP_SETREGIMM;
        tree->dreg = tree->unused;
        tree->inst_c0 = state->left->tree->inst_c0;
@@ -151,6 +224,10 @@ stmt: OP_OUTARG (OP_ICONST) {
 #}
 
 stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
+       if (tree->inst_imm) {
+               MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORE_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->left->tree->dreg);
+               return;
+       }
        tree->opcode = OP_SETREG;
        tree->sreg1 = state->left->left->tree->dreg;
        tree->dreg = tree->unused;
@@ -164,13 +241,22 @@ stmt: OP_OUTARG (CEE_LDIND_REF (OP_REGVAR)) {
 #}
 
 stmt: OP_OUTARG (freg) {
+       if (tree->inst_imm) {
+               int opcode = (tree->unused & 0xff00) == 0x0400? OP_STORER4_MEMBASE_REG: OP_STORER8_MEMBASE_REG;
+               MONO_EMIT_NEW_STORE_MEMBASE (s, opcode, ppc_r1, tree->inst_imm, state->left->reg1);
+               return;
+       }
        tree->opcode = OP_SETFREG;
        tree->sreg1 = state->left->reg1;
-       tree->dreg = tree->unused;
+       tree->dreg = tree->unused & 0xff;
        mono_bblock_add_inst (s->cbb, tree);
 }
 
 stmt: OP_OUTARG_R4 (freg) {
+       if (tree->inst_imm) {
+               MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER4_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
+               return;
+       }
        tree->opcode = OP_SETFREG;
        tree->sreg1 = state->left->reg1;
        tree->dreg = tree->unused;
@@ -178,19 +264,49 @@ stmt: OP_OUTARG_R4 (freg) {
 }
 
 stmt: OP_OUTARG_R8 (freg) {
+       if (tree->inst_imm) {
+               MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STORER8_MEMBASE_REG, ppc_r1, tree->inst_imm, state->left->reg1);
+               return;
+       }
        tree->opcode = OP_SETFREG;
        tree->sreg1 = state->left->reg1;
        tree->dreg = tree->unused;
        mono_bblock_add_inst (s->cbb, tree);
 }
 
+stmt: OP_OUTARG_R8 (CEE_LDOBJ (base)) {
+       /* small struct with fp value goes in a fp register */
+       MonoInst *vt = state->left->left->tree;
+       int tmpr, soffset;
+       soffset = vt->inst_offset;
+       tmpr = mono_regstate_next_float (s->rs);
+       MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADR4_MEMBASE, tmpr, vt->inst_basereg, soffset);
+       MONO_EMIT_NEW_UNALU (s, OP_SETFREG, tree->unused, tmpr);
+}
+
 stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
        MonoInst *vt = state->left->left->tree;
        int start_reg = tree->unused & 0xff;
        int nregs = (tree->unused >> 8) & 0xff;
        int ovf_size = (tree->unused >> 16) & 0xffff;
        int i, tmpr, soffset;
+       int size = 0;
        soffset = vt->inst_offset;
+/*
+  Darwin needs some special handling for 1 and 2 byte arguments
+*/
+#ifdef __APPLE__
+       if (vt->inst_vtype && MONO_TYPE_ISSTRUCT (vt->inst_vtype) && vt->inst_vtype->type != MONO_TYPE_TYPEDBYREF)
+           size =  mono_class_native_size (mono_class_from_mono_type (vt->inst_vtype), NULL);
+       if (size == 2 || size == 1) {
+               tmpr = mono_regstate_next_int (s->rs);
+               if (size == 1)
+                       MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI1_MEMBASE, tmpr, vt->inst_basereg, soffset);
+               else
+                       MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI2_MEMBASE, tmpr, vt->inst_basereg, soffset);
+               MONO_EMIT_NEW_UNALU (s, OP_SETREG, start_reg, tmpr);
+       } else
+#endif
        for (i = 0; i < nregs; ++i) {
                tmpr = mono_regstate_next_int (s->rs);
                MONO_EMIT_NEW_LOAD_MEMBASE (s, tmpr, vt->inst_basereg, soffset);
@@ -198,13 +314,14 @@ stmt: OP_OUTARG_VT (CEE_LDOBJ (base)) {
                soffset += sizeof (gpointer);
        }
        //g_print ("vt size: %d at R%d + %d\n", tree->inst_imm, vt->inst_basereg, vt->inst_offset);
-       g_assert (ovf_size == 0); /* not yet supported */
+       if (ovf_size != 0) {
+               mini_emit_memcpy (s, ppc_r1, tree->inst_imm + (soffset - vt->inst_offset), vt->inst_basereg, soffset, ovf_size * sizeof (gpointer), 0);
+       }
 }
 
 stmt: OP_OUTARG_VT (OP_ICONST) {
        int start_reg = tree->unused & 0xff;
        int nregs = (tree->unused >> 8) & 0xff;
-       int ovf_size = (tree->unused >> 16) & 0xffff;
        if (nregs) {
                tree->opcode = OP_SETREGIMM;
                tree->dreg = start_reg;
@@ -215,6 +332,19 @@ stmt: OP_OUTARG_VT (OP_ICONST) {
        }
 }
 
+stmt: OP_OUTARG_VT (reg) {
+       int start_reg = tree->unused & 0xff;
+       int nregs = (tree->unused >> 8) & 0xff;
+       if (nregs) {
+               tree->opcode = OP_SETREG;
+               tree->dreg = start_reg;
+               tree->sreg1 = state->left->reg1;
+               mono_bblock_add_inst (s->cbb, tree);
+       } else {
+               g_assert_not_reached ();
+       }
+}
+
 stmt: CEE_STIND_R8 (OP_REGVAR, freg) {
        /* nothing to do: the value is already on the FP stack */
 }
@@ -314,4 +444,19 @@ reg: OP_CGT_UN (OP_COMPARE (freg, freg)) {
                         state->left->right->reg1);
 }
 
+reg: CEE_ADD_OVF (reg, reg) "0" {
+       MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
+
+reg: CEE_ADD_OVF_UN (reg, reg) "0" {
+       MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
+
+reg: CEE_SUB_OVF (reg, reg) "0" {
+       MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
+
+reg: CEE_SUB_OVF_UN (reg, reg) "0" {
+       MONO_EMIT_BIALU (s, tree, tree->opcode, state->reg1, state->left->reg1, state->right->reg1);
+}
 %%
my mono mirror. check out Moved to http://github.com/mono/mono