Author: zoltan
Date: 2007-08-28 05:14:36 -0400 (Tue, 28 Aug 2007)
New Revision: 84930

Modified:
   trunk/mono/mono/mini/ChangeLog
   trunk/mono/mono/mini/inssel-ia64.brg
   trunk/mono/mono/mini/inssel-s390.brg
   trunk/mono/mono/mini/inssel-s390x.brg
   trunk/mono/mono/mini/inssel-sparc.brg
   trunk/mono/mono/mini/inssel.brg
   trunk/mono/mono/mini/mini.c
   trunk/mono/mono/mini/mini.h
Log:
2007-08-28  Zoltan Varga  <[EMAIL PROTECTED]>

        * mini.h mini.c inssel-*.brg: Pass alignment information to 
OP_MEMCPY/MEMSET.


Modified: trunk/mono/mono/mini/ChangeLog
===================================================================
--- trunk/mono/mono/mini/ChangeLog      2007-08-28 03:25:36 UTC (rev 84929)
+++ trunk/mono/mono/mini/ChangeLog      2007-08-28 09:14:36 UTC (rev 84930)
@@ -1,3 +1,7 @@
+2007-08-28  Zoltan Varga  <[EMAIL PROTECTED]>
+
+       * mini.h mini.c inssel-*.brg: Pass alignment information to 
OP_MEMCPY/MEMSET.
+
 2007-08-26  Zoltan Varga  <[EMAIL PROTECTED]>
 
        * mini-exceptions.c (mono_handle_exception_internal): Skip the first 
frame for

Modified: trunk/mono/mono/mini/inssel-ia64.brg
===================================================================
--- trunk/mono/mono/mini/inssel-ia64.brg        2007-08-28 03:25:36 UTC (rev 
84929)
+++ trunk/mono/mono/mini/inssel-ia64.brg        2007-08-28 09:14:36 UTC (rev 
84930)
@@ -333,7 +333,7 @@
 # Optimized memset implementation
 stmt: OP_MEMSET (base) "0" {
        int dest_reg, dest_reg2, val_reg, unit, align;
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
 
        dest_reg = mono_regstate_next_int (s->rs);
 
@@ -385,7 +385,7 @@
 # Optimized memcpy implementation
 stmt: OP_MEMCPY (base, base) "0" {
        int cur_reg, src_reg, dest_reg, unit;
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
        int align;
 
        src_reg = mono_regstate_next_int (s->rs);

Modified: trunk/mono/mono/mini/inssel-s390.brg
===================================================================
--- trunk/mono/mono/mini/inssel-s390.brg        2007-08-28 03:25:36 UTC (rev 
84929)
+++ trunk/mono/mono/mini/inssel-s390.brg        2007-08-28 09:14:36 UTC (rev 
84930)
@@ -118,14 +118,14 @@
 }
 
 stmt: OP_MEMCPY (reg, reg) "0" {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
        if (size > 0) 
                MONO_EMIT_NEW_MOVE (s, state->left->reg1, 0, 
                                    state->right->reg1, 0, size);
 }
 
 stmt: OP_MEMCPY (base, base) "0" {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
        if (size > 0)  
                MONO_EMIT_NEW_MOVE (s, state->left->tree->sreg1, 
                                    state->left->tree->inst_offset, 

Modified: trunk/mono/mono/mini/inssel-s390x.brg
===================================================================
--- trunk/mono/mono/mini/inssel-s390x.brg       2007-08-28 03:25:36 UTC (rev 
84929)
+++ trunk/mono/mono/mini/inssel-s390x.brg       2007-08-28 09:14:36 UTC (rev 
84930)
@@ -74,13 +74,13 @@
 }
 
 stmt: OP_MEMCPY (reg, reg) "0" {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
        if (size > 0) 
                MONO_EMIT_NEW_MOVE (s, state->left->reg1, 0, 
state->right->reg1, 0, size);
 }
 
 stmt: OP_MEMCPY (base, base) "0" {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
        if (size > 0)  
                MONO_EMIT_NEW_MOVE (s, state->left->tree->sreg1, 
                                    state->left->tree->inst_offset, 

Modified: trunk/mono/mono/mini/inssel-sparc.brg
===================================================================
--- trunk/mono/mono/mini/inssel-sparc.brg       2007-08-28 03:25:36 UTC (rev 
84929)
+++ trunk/mono/mono/mini/inssel-sparc.brg       2007-08-28 09:14:36 UTC (rev 
84930)
@@ -678,7 +678,8 @@
 
 # Optimized version for initializing valuetypes on the stack
 stmt: OP_MEMSET (OP_LDADDR(OP_REGOFFSET)) "0" {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
+       int align = tree->backend.memcpy_args->align;
        int offset = state->left->left->tree->inst_offset;
        int destreg = state->left->left->tree->inst_basereg;
        int val_reg;
@@ -731,7 +732,8 @@
 }              
 
 stmt: OP_MEMSET (reg) "0" {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
+       int align = tree->backend.memcpy_args->align;
        int offset = 0;
        int destreg = state->left->reg1;
        int val_reg;

Modified: trunk/mono/mono/mini/inssel.brg
===================================================================
--- trunk/mono/mono/mini/inssel.brg     2007-08-28 03:25:36 UTC (rev 84929)
+++ trunk/mono/mono/mini/inssel.brg     2007-08-28 09:14:36 UTC (rev 84930)
@@ -637,16 +637,18 @@
 }
 
 stmt: OP_MEMCPY (base, base) {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
+       int align = tree->backend.memcpy_args->align;
        if (size > 0)
                mini_emit_memcpy (s, state->left->tree->inst_basereg, 
state->left->tree->inst_offset,
-                                 state->right->tree->inst_basereg, 
state->right->tree->inst_offset, size, 0);
+                                 state->right->tree->inst_basereg, 
state->right->tree->inst_offset, size, align);
 }
 
 stmt: OP_MEMSET (base) {
-       int size = tree->backend.size;
+       int size = tree->backend.memcpy_args->size;
+       int align = tree->backend.memcpy_args->align;
        if (size > 0)
-               mini_emit_memset (s, state->left->tree->inst_basereg, 
state->left->tree->inst_offset, size, tree->inst_imm, 0);
+               mini_emit_memset (s, state->left->tree->inst_basereg, 
state->left->tree->inst_offset, size, tree->inst_imm, align);
 }
 
 reg: OP_LDELEMA2D (reg, OP_GROUP (reg, reg)) "20" {

Modified: trunk/mono/mono/mini/mini.c
===================================================================
--- trunk/mono/mono/mini/mini.c 2007-08-28 03:25:36 UTC (rev 84929)
+++ trunk/mono/mono/mini/mini.c 2007-08-28 09:14:36 UTC (rev 84930)
@@ -666,6 +666,26 @@
                (dest)->klass = (dest)->inst_i0->klass; \
        } while (0)
 
+#define NEW_MEMCPY(cfg,dest,dst,src,memcpy_size,memcpy_align) do { \
+               MONO_INST_NEW (cfg, dest, OP_MEMCPY); \
+        (dest)->inst_left = (dst); \
+               (dest)->inst_right = (src); \
+               (dest)->cil_code = ip; \
+        (dest)->backend.memcpy_args = mono_mempool_alloc0 ((cfg)->mempool, 
sizeof (MonoMemcpyArgs)); \
+               (dest)->backend.memcpy_args->size = (memcpy_size); \
+               (dest)->backend.memcpy_args->align = (memcpy_align); \
+    } while (0)
+
+#define NEW_MEMSET(cfg,dest,dst,imm,memcpy_size,memcpy_align) do { \
+               MONO_INST_NEW (cfg, dest, OP_MEMSET); \
+        (dest)->inst_left = (dst); \
+               (dest)->inst_imm = (imm); \
+               (dest)->cil_code = ip; \
+        (dest)->backend.memcpy_args = mono_mempool_alloc0 ((cfg)->mempool, 
sizeof (MonoMemcpyArgs)); \
+               (dest)->backend.memcpy_args->size = (memcpy_size); \
+               (dest)->backend.memcpy_args->align = (memcpy_align); \
+    } while (0)
+
 #define NEW_DUMMY_USE(cfg,dest,load) do { \
                (dest) = mono_mempool_alloc0 ((cfg)->mempool, sizeof 
(MonoInst));       \
                (dest)->opcode = OP_DUMMY_USE; \
@@ -2817,11 +2837,7 @@
                        NEW_DUMMY_STORE (cfg, inst, dest->inst_i0->inst_c0);
                        MONO_ADD_INS (bblock, inst);
                }
-               MONO_INST_NEW (cfg, inst, OP_MEMCPY);
-               inst->inst_left = dest;
-               inst->inst_right = src;
-               inst->cil_code = ip;
-               inst->backend.size = n;
+               NEW_MEMCPY (cfg, inst, dest, src, n, align);
                MONO_ADD_INS (bblock, inst);
                return;
        }
@@ -2851,12 +2867,13 @@
        MonoInst *iargs [3];
        MonoInst *ins, *zero_int32;
        int n;
+       guint32 align;
        MonoMethod *memset_method;
 
        NEW_ICONST (cfg, zero_int32, 0);
 
        mono_class_init (klass);
-       n = mono_class_value_size (klass, NULL);
+       n = mono_class_value_size (klass, &align);
        MONO_INST_NEW (cfg, ins, 0);
        ins->cil_code = ip;
        ins->inst_left = dest;
@@ -2876,9 +2893,7 @@
                break;
        default:
                if (n <= sizeof (gpointer) * 5) {
-                       ins->opcode = OP_MEMSET;
-                       ins->inst_imm = 0;
-                       ins->backend.size = n;
+                       NEW_MEMSET (cfg, ins, dest, 0, n, align);
                        MONO_ADD_INS (bblock, ins);
                        break;
                }
@@ -3502,7 +3517,7 @@
        new_locals_offset = cfg->num_varinfo;
        for (i = 0; i < cheader->num_locals; ++i)
                mono_compile_create_var (cfg, cheader->locals [i], OP_LOCAL);
-       
+
        /* allocate starte and end blocks */
        sbblock = NEW_BBLOCK (cfg);
        sbblock->block_num = cfg->num_bblocks++;
@@ -5502,14 +5517,12 @@
                                store->inst_i1 = load;
                                store->flags |= ins_flag;
                        } else {
-                               n = mono_class_value_size (klass, NULL);
+                               guint32 align;
+
+                               n = mono_class_value_size (klass, &align);
                                if ((cfg->opt & MONO_OPT_INTRINS) && n <= 
sizeof (gpointer) * 5) {
                                        MonoInst *copy;
-                                       MONO_INST_NEW (cfg, copy, OP_MEMCPY);
-                                       copy->inst_left = sp [0];
-                                       copy->inst_right = sp [1];
-                                       copy->cil_code = ip;
-                                       copy->backend.size = n;
+                                       NEW_MEMCPY (cfg, copy, sp [0], sp [1], 
n, align);
                                        MONO_ADD_INS (bblock, copy);
                                } else {
                                        MonoMethod *memcpy_method = 
get_memcpy_method ();
@@ -5529,6 +5542,8 @@
                        MonoInst *iargs [3];
                        int loc_index = -1;
                        int stloc_len = 0;
+                       guint32 align;
+
                        CHECK_OPSIZE (5);
                        CHECK_STACK (1);
                        --sp;
@@ -5581,16 +5596,12 @@
                                }
                        }
 
-                       n = mono_class_value_size (klass, NULL);
+                       n = mono_class_value_size (klass, &align);
                        ins = mono_compile_create_var (cfg, &klass->byval_arg, 
OP_LOCAL);
                        NEW_TEMPLOADA (cfg, iargs [0], ins->inst_c0);
                        if ((cfg->opt & MONO_OPT_INTRINS) && n <= sizeof 
(gpointer) * 5) {
                                MonoInst *copy;
-                               MONO_INST_NEW (cfg, copy, OP_MEMCPY);
-                               copy->inst_left = iargs [0];
-                               copy->inst_right = *sp;
-                               copy->cil_code = ip;
-                               copy->backend.size = n;
+                               NEW_MEMCPY (cfg, copy, iargs [0], *sp, n, 
align);
                                MONO_ADD_INS (bblock, copy);
                        } else {
                                MonoMethod *memcpy_method = get_memcpy_method 
();
@@ -5858,6 +5869,7 @@
                case CEE_UNBOX_ANY: {
                        MonoInst *add, *vtoffset;
                        MonoInst *iargs [3];
+                       guint32 align;
 
                        CHECK_STACK (1);
                        --sp;
@@ -5933,16 +5945,12 @@
                        *sp = add;
                        ip += 5;
                        /* LDOBJ impl */
-                       n = mono_class_value_size (klass, NULL);
+                       n = mono_class_value_size (klass, &align);
                        ins = mono_compile_create_var (cfg, &klass->byval_arg, 
OP_LOCAL);
                        NEW_TEMPLOADA (cfg, iargs [0], ins->inst_c0);
                        if ((cfg->opt & MONO_OPT_INTRINS) && n <= sizeof 
(gpointer) * 5) {
                                MonoInst *copy;
-                               MONO_INST_NEW (cfg, copy, OP_MEMCPY);
-                               copy->inst_left = iargs [0];
-                               copy->inst_right = *sp;
-                               copy->cil_code = ip;
-                               copy->backend.size = n;
+                               NEW_MEMCPY (cfg, copy, iargs [0], *sp, n, 
align);
                                MONO_ADD_INS (bblock, copy);
                        } else {
                                MonoMethod *memcpy_method = get_memcpy_method 
();
@@ -7620,11 +7628,7 @@
                                sp -= 3;
                                if ((cfg->opt & MONO_OPT_INTRINS) && (ip [1] == 
CEE_CPBLK) && (sp [2]->opcode == OP_ICONST) && ((n = sp [2]->inst_c0) <= sizeof 
(gpointer) * 5)) {
                                        MonoInst *copy;
-                                       MONO_INST_NEW (cfg, copy, OP_MEMCPY);
-                                       copy->inst_left = sp [0];
-                                       copy->inst_right = sp [1];
-                                       copy->cil_code = ip;
-                                       copy->backend.size = n;
+                                       NEW_MEMCPY (cfg, copy, sp [0], sp [1], 
n, 0);
                                        MONO_ADD_INS (bblock, copy);
                                        ip += 2;
                                        break;
@@ -9938,6 +9942,7 @@
 
        if (cfg->verbose_level > 2)
                g_print ("creating locals\n");
+
        for (i = 0; i < header->num_locals; ++i)
                mono_compile_create_var (cfg, header->locals [i], OP_LOCAL);
        if (cfg->verbose_level > 2)

Modified: trunk/mono/mono/mini/mini.h
===================================================================
--- trunk/mono/mono/mini/mini.h 2007-08-28 03:25:36 UTC (rev 84929)
+++ trunk/mono/mono/mini/mini.h 2007-08-28 09:14:36 UTC (rev 84930)
@@ -268,6 +268,10 @@
        BB_EXCEPTION_HANDLER  = 1 << 4
 };
 
+typedef struct MonoMemcpyArgs {
+       int size, align;
+} MonoMemcpyArgs;
+
 struct MonoInst {
        union {
                union {
@@ -299,7 +303,8 @@
        union {
                gint32 reg3;
                gint32 arg_info;
-               gint32 size; /* in OP_MEMSET and OP_MEMCPY */
+               gint32 size;
+               MonoMemcpyArgs *memcpy_args; /* in OP_MEMSET and OP_MEMCPY */
                gint shift_amount;
                gboolean is_pinvoke; /* for variables in the unmanaged marshal 
format */
                gpointer data;

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to