svn path=/trunk/mono/; revision=53658

[mono.git] / mono / mini / inssel.brg

diff --git a/mono/mini/inssel.brg b/mono/mini/inssel.brg
index d711d893c412e5bab874d1fe0d425f5fbb078d50..ab1ac2a9514e127d07710878501147e0107d37e9 100644 (file)
--- a/mono/mini/inssel.brg
+++ b/mono/mini/inssel.brg
@@ -78,6 +78,15 @@
                mono_bblock_add_inst (cfg->cbb, inst); \
        } while (0)
 
+#define MONO_EMIT_BIALU_MEMBASE(cfg,tree,op,dr,sr,basereg,offset) do { \
+                               tree->opcode = op; \
+                               tree->dreg = dr; \
+                               tree->sreg1 = sr; \
+                               tree->sreg2 = basereg; \
+                               tree->inst_offset = offset; \
+                               mono_bblock_add_inst (s->cbb, tree); \
+       } while (0)
+
 #define MONO_EMIT_LOAD_MEMBASE(cfg,inst,dr,base,offset) do { \
                 (inst)->opcode = OP_LOAD_MEMBASE; \
                 (inst)->dreg = dr; \
@@ -396,6 +405,13 @@ stmt: OP_DUMMY_USE (CEE_LDIND_REF (OP_REGOFFSET)) {
 stmt: OP_DUMMY_STORE {
 }
 
+stmt: OP_NOT_REACHED {
+}
+
+stmt: OP_MEMORY_BARRIER {
+       mono_bblock_add_inst (s->cbb, tree);
+}
+
 #
 # load/store operations
 #
@@ -734,7 +750,7 @@ reg: OP_TLS_GET {
        mono_bblock_add_inst (s->cbb, tree);
 }
 
-stmt: CEE_SWITCH (reg) {
+stmt: CEE_SWITCH (reg) "2" {
        MonoInst *label;
        int offset_reg = mono_regstate_next_int (s->rs);
        int target_reg = mono_regstate_next_int (s->rs);
@@ -919,8 +935,13 @@ stmt: OP_THROW_OR_NULL (reg, reg) {
 
        MONO_NEW_LABEL (s, dont_throw);
 
-       MONO_EMIT_NEW_BIALU (s, OP_COMPARE, 0, state->left->reg1, state->right->reg1);
-       MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BNE_UN, dont_throw);
+       /*
+        * Currently, we allways rethrow the abort exception, despite the fact
+        * that this is not correct. See thread6.cs for an example. But propagating
+        * the abort exception is more important than getting the sematics right.
+     */
+       MONO_EMIT_NEW_BIALU_IMM (s, OP_COMPARE_IMM, -1, state->left->reg1, 0);
+       MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, dont_throw);
        MONO_EMIT_UNALU (s, tree, CEE_THROW, -1, state->left->reg1);
        mono_bblock_add_inst (s->cbb, dont_throw);
 }
@@ -986,7 +1007,7 @@ reg: CEE_ISINST (reg) {
                        MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
                        if (klass->cast_class == mono_defaults.object_class) {
                                int parent_reg = mono_regstate_next_int (s->rs);
-                               int const_reg;
+                               int const_reg = -1;
                                MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
                                if (s->compile_aot) {
                                        const_reg = mono_regstate_next_int (s->rs);
@@ -1005,7 +1026,7 @@ reg: CEE_ISINST (reg) {
                                MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BEQ, object_is_null);
                                MONO_EMIT_NEW_BRANCH_LABEL (s, CEE_BR, false_label);
                        } else if (klass->cast_class == mono_defaults.enum_class->parent) {
-                               int const_reg;
+                               int const_reg = -1;
                                
                                if (s->compile_aot) {
                                        const_reg = mono_regstate_next_int (s->rs);
@@ -1219,7 +1240,7 @@ reg: CEE_CASTCLASS (reg) {
                        MONO_EMIT_NEW_LOAD_MEMBASE (s, eclass_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, cast_class));
                        if (klass->cast_class == mono_defaults.object_class) {
                                int parent_reg = mono_regstate_next_int (s->rs);
-                               int const_reg;
+                               int const_reg = -1;
                                MONO_EMIT_NEW_LOAD_MEMBASE (s, parent_reg, eclass_reg, G_STRUCT_OFFSET (MonoClass, parent));
                                if (s->compile_aot) {
                                        const_reg = mono_regstate_next_int (s->rs);
@@ -1598,7 +1619,6 @@ mini_emit_load_intf_reg (MonoCompile *s, int intf_reg, int ioffset_reg, MonoClas
        if (s->compile_aot) {
                int iid_reg = mono_regstate_next_int (s->rs);
                MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID);
-               /* FIXME: Do a shift instead */
 #if SIZEOF_VOID_P == 8
                MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, iid_reg, iid_reg, 3);
 #else
@@ -1628,7 +1648,16 @@ mini_emit_load_intf_reg_class (MonoCompile *s, int intf_reg, int klass_reg, Mono
        int ioffset_reg = mono_regstate_next_int (s->rs);
 
        MONO_EMIT_NEW_LOAD_MEMBASE (s, ioffset_reg, klass_reg, G_STRUCT_OFFSET (MonoClass, interface_offsets));
-       mini_emit_load_intf_reg (s, intf_reg, ioffset_reg, klass);
+
+       if (s->compile_aot) {
+               int iid_reg = mono_regstate_next_int (s->rs);
+               MONO_EMIT_NEW_AOTCONST (s, iid_reg, klass, MONO_PATCH_INFO_IID);
+               MONO_EMIT_NEW_BIALU_IMM (s, OP_SHL_IMM, iid_reg, iid_reg, 2);
+               MONO_EMIT_NEW_BIALU (s, CEE_ADD, ioffset_reg, ioffset_reg, iid_reg);
+               MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, intf_reg, ioffset_reg, 0);
+       }
+       else
+               MONO_EMIT_NEW_LOAD_MEMBASE_OP (s, OP_LOADI4_MEMBASE, intf_reg, ioffset_reg, klass->interface_id * sizeof (int));
 }
 
 void 
@@ -1793,6 +1822,42 @@ mini_emit_castclass_iface_class (MonoCompile *s, int klass_reg, MonoClass *klass
        MONO_EMIT_NEW_COND_EXC (s, EQ, "InvalidCastException");
 }
 
+static int
+size_to_load_u_membase (int size)
+{
+       switch (size) {
+       case 1:
+               return OP_LOADU1_MEMBASE;
+       case 2:
+               return OP_LOADU2_MEMBASE;
+       case 4:
+               return OP_LOADU4_MEMBASE;
+       case 8:
+               return OP_LOADI8_MEMBASE;
+       default:
+               g_assert_not_reached ();
+               return -1;
+       }
+}
+
+static int
+size_to_store_membase_reg (int size)
+{
+       switch (size) {
+       case 1:
+               return OP_STOREI1_MEMBASE_REG;
+       case 2:
+               return OP_STOREI2_MEMBASE_REG;
+       case 4:
+               return OP_STOREI4_MEMBASE_REG;
+       case 8:
+               return OP_STOREI8_MEMBASE_REG;
+       default:
+               g_assert_not_reached ();
+               return -1;
+       }
+}
+
 void 
 mini_emit_memcpy (MonoCompile *s, int destreg, int doffset, int srcreg, int soffset, int size, int align)
 {
@@ -1839,7 +1904,7 @@ mini_emit_memcpy (MonoCompile *s, int destreg, int doffset, int srcreg, int soff
 }
 
 void 
-mini_emit_memset (MonoCompile *s, int destreg, int offset, int size, int val, int alignl)
+mini_emit_memset (MonoCompile *s, int destreg, int offset, int size, int val, int align)
 {
        int val_reg = mono_regstate_next_int (s->rs);
 
@@ -1848,13 +1913,21 @@ mini_emit_memset (MonoCompile *s, int destreg, int offset, int size, int val, in
        else
                MONO_EMIT_NEW_ICONST (s, val_reg, val);
 
+       /* FIXME: consider alignment for archs that need it. */
+#if !NO_UNALIGNED_ACCESS
        if (sizeof (gpointer) == 8) {
+               if (offset % 8) {
+                       MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);
+                       offset += 4;
+                       size -= 4;
+               }
                while (size >= 8) {
                        MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI8_MEMBASE_REG, destreg, offset, val_reg);
                        offset += 8;
                        size -= 8;
                }
        }       
+#endif
 
        while (size >= 4) {
                MONO_EMIT_NEW_STORE_MEMBASE (s, OP_STOREI4_MEMBASE_REG, destreg, offset, val_reg);