* src/vm/jit/sparc64/codegen.c (codegen_emit): Improved integer argument passing

by swapping variable allocation instead of copying.

* src/vm/jit/sparc64/md-abi.h: Turned %i0 into saved reg.
* src/vm/jit/sparc64/md-abi.c: Likewise.

diff --git a/src/vm/jit/sparc64/codegen.c b/src/vm/jit/sparc64/codegen.c
index e0c75073404507fb77f791fb08bbaa6456000b81..ce53e72005993421c585d54213c1d0c3191664f2 100644 (file)
--- a/src/vm/jit/sparc64/codegen.c
+++ b/src/vm/jit/sparc64/codegen.c
@@ -141,7 +141,7 @@ bool codegen_emit(jitdata *jd)
 
        {
        s4 i, p, t, l;
-       s4 savedregs_num, localbase;
+       s4 savedregs_num;
 
 #if 0 /* no leaf optimization yet */
        savedregs_num = (jd->isleafmethod) ? 0 : 1;       /* space to save the RA */
@@ -272,24 +272,6 @@ bool codegen_emit(jitdata *jd)
        
        md = m->parseddesc;
 
-       /* when storing locals, use this as base */
-       localbase = JITSTACK;
-       
-       /* since the register allocator does not know about the shifting window
-        * arg regs need to be copied via the stack
-        */
-       if (md->argintreguse > 0) {
-               /* allocate scratch space for copying in to save(i&l) regs */
-               M_SUB_IMM(REG_SP, INT_ARG_CNT * 8, REG_SP);
-               
-               localbase += INT_ARG_CNT * 8;
-               
-               /* XXX could use the param slots on the stack for this! */
-               for (p = 0; p < INT_ARG_CNT; p++)
-                       M_STX(REG_WINDOW_TRANSPOSE(abi_registers_integer_argument[p]), REG_SP, JITSTACK + (p * 8));
-       }
-       
-
        for (p = 0, l = 0; p < md->paramcount; p++) {
                t = md->paramtypes[p].type;
 
@@ -306,22 +288,53 @@ bool codegen_emit(jitdata *jd)
                s1 = md->params[p].regoff;
                
                if (IS_INT_LNG_TYPE(t)) {                    /* integer args          */                        
+
+                       s2 = var->vv.regoff;
                        
                        if (!md->params[p].inmemory) {           /* register arguments    */
-                               /*s2 = rd->argintregs[s1];*/
-                               /*s2 = REG_WINDOW_TRANSPOSE(s2);*/
-                               
-                               /* need the argument index (p) here, not the register number */
+                               s1 = REG_WINDOW_TRANSPOSE(s1);
                                
                                if (!(var->flags & INMEMORY)) {      /* reg arg -> register   */
-                                       /*M_INTMOVE(s2, var->vv.regoff);*/                                      
-                                       M_LDX(var->vv.regoff, REG_SP, JITSTACK + (p * 8));
 
-                               } else {                             /* reg arg -> spilled    */
-                                       /*M_STX(s2, REG_SP, (WINSAVE_CNT + var->vv.regoff) * 8);*/
-                                       
-                                       M_LDX(REG_ITMP1, REG_SP, JITSTACK + (p * 8));
-                                       M_STX(REG_ITMP1, REG_SP, localbase + (var->vv.regoff * 8));
+                                       /* the register allocator does not know about the window. */
+                                       /* avoid copying the locals from save to save regs by     */
+                                       /* swapping variables.                                    */
+
+                                       {
+                                       int old_dest = var->vv.regoff;
+                                       int new_dest = p + 24;
+
+                                       /* run through all variables */
+
+                                       for (i = 0; i < jd->varcount; i++) {
+                                               varinfo* uvar = VAR(i);
+
+                                               if (IS_FLT_DBL_TYPE(uvar->type))
+                                                       continue;
+
+                                               s2 = uvar->vv.regoff;
+
+                                               /* free the in reg by moving all other references */
+
+                                               if (s2 == new_dest) {
+                                                       uvar->vv.regoff = old_dest;
+                                                       /*printf("p%d-var[%d]: moved %d -> %d (to free save reg)\n", p, i, s2, old_dest);*/
+                                               }
+
+                                               /* move all variables to the in reg */
+
+                                               if (s2 == old_dest) {
+                                                       uvar->vv.regoff = new_dest;
+                                                       /*printf("p%d-var[%d]: moved %d -> %d (to avoid copy)\n", p, i, s2, new_dest);*/
+                                               }
+                                       }
+                                       }
+
+
+
+                               } 
+                               else {                             /* reg arg -> spilled    */
+                                       M_STX(s1, REG_SP, JITSTACK + (var->vv.regoff * 8));
                                }
 
                        } else {                                 /* stack arguments       */
@@ -340,7 +353,7 @@ bool codegen_emit(jitdata *jd)
                                        M_FLTMOVE(s1, var->vv.regoff);
 
                                } else {                                         /* reg arg -> spilled    */
-                                       M_DST(s1, REG_SP, localbase + (var->vv.regoff) * 8);
+                                       M_DST(s1, REG_SP, JITSTACK + (var->vv.regoff) * 8);
                                }
 
                        } else {                                 /* stack arguments       */
@@ -354,13 +367,6 @@ bool codegen_emit(jitdata *jd)
                }
        } /* end for */
        
-       if (md->argintreguse > 0) {
-               /* release scratch space */
-               M_ADD_IMM(REG_SP, INT_ARG_CNT * 8, REG_SP);
-       }
-
-
-
        
        }
        

diff --git a/src/vm/jit/sparc64/md-abi.c b/src/vm/jit/sparc64/md-abi.c
index a7ea007bd2a0fe38bd54a5d1ef9b4cfeef123f83..32fcb68a343cae2e6f50220d6a1490ac4e3eb175 100644 (file)
--- a/src/vm/jit/sparc64/md-abi.c
+++ b/src/vm/jit/sparc64/md-abi.c
@@ -58,8 +58,8 @@ s4 nregdescint[] = {
        /* l0    l1       l2       l3       l4       l5       l6       l7     */
        REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV,
        
-       /* i0/v0 i1       i2       i3       i4       pv/i5    fp/i6    ra/i7  */
-       REG_RET, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_RES, REG_RES, REG_RES,
+       /* i0    i1       i2       i3       i4       pv/i5    fp/i6    ra/i7  */
+       REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_RES, REG_RES, REG_RES,
        REG_END
 };
 
@@ -87,6 +87,7 @@ const s4 abi_registers_integer_saved[] = {
        21, /* l5  */
        22, /* l6  */
        23, /* l7  */
+       24, /* i0  */
        25, /* i1  */
        26, /* i2  */
        27, /* i3  */

diff --git a/src/vm/jit/sparc64/md-abi.h b/src/vm/jit/sparc64/md-abi.h
index db7735914cb81e8a53496b75e90cbf398fd2c481..772b45ba8e576647054b955ea0ed81ce506e00ab 100644 (file)
--- a/src/vm/jit/sparc64/md-abi.h
+++ b/src/vm/jit/sparc64/md-abi.h
@@ -87,7 +87,7 @@
 
 
 #define INT_REG_CNT     32   /* number of integer registers                   */
-#define INT_SAV_CNT     12   /* number of int callee saved registers          */
+#define INT_SAV_CNT     13   /* number of int callee saved registers          */
 #define INT_ARG_CNT      5   /* number of int argument registers (-1 for PV)  */
 #define INT_TMP_CNT      0   /* int temp registers (%g4-%g5)                  */
 #define INT_RES_CNT     14   /* number of reserved integer registers          */