* src/vm/jit/alpha/emit.c (emit_load): Changed to new variable

structure (varinfo * instead of stackptr) and the use of Macro
IS_INMEMORY.
(emit_store): Likewise.
(emit_copy): Likewise.
(emit_load_s1): Likewise and reuse emit_load.
(emit_load_s2): Likewise and reuse emit_load.
(emit_load_s3): Likewise and reuse emit_load.
(emit_store_dst): Likewise and reuse emit_store.

* src/vm/jit/alpha/codegen.c (codegen): Changed to new variable
structure (varinfo * instead of stackptr, adapting of Argument
handling, no interface copying anymore at BB Boundaries ) and the use
of Macro IS_INMEMORY. ICMD_xSTORE and ICMD_xLOAD use now
emit_copy. ICMD_DUPx and ICMD_SWAP were replaced by ICMD_MOVE and ICMD_COPY. Invars are now regarded
for EXH and JSR Blocks. Changed ICMD_RET handling like with i386.

* src/vm/jit/alpha/codegen.h (M_COPY): Changed to new variable
structure.

* src/vm/jit/alpha/md-abi.c (md_return_alloc): Changed to new
variable structure.

--HG--
branch : unified_variables

diff --git a/src/vm/jit/alpha/codegen.c b/src/vm/jit/alpha/codegen.c
index 3978a20b4620253d831cdfb01c8bb95d07fd0269..828831dd5a8e0a31b75694f6045e056fbcd24c08 100644 (file)
--- a/src/vm/jit/alpha/codegen.c
+++ b/src/vm/jit/alpha/codegen.c
@@ -32,7 +32,7 @@
             Christian Ullrich
             Edwin Steiner
 
-   $Id: codegen.c 5488 2006-09-13 00:21:40Z edwin $
+   $Id: codegen.c 5518 2006-09-15 16:31:47Z christian $
 
 */
 
@@ -92,8 +92,7 @@ bool codegen(jitdata *jd)
        codegendata        *cd;
        registerdata       *rd;
        s4                  len, s1, s2, s3, d, disp;
-       stackptr            src;
-       varinfo            *var;
+       varinfo            *var, *var1, *var2, *dst;
        basicblock         *bptr;
        instruction        *iptr;
        exceptiontable     *ex;
@@ -104,6 +103,7 @@ bool codegen(jitdata *jd)
        methoddesc         *md;
        rplpoint           *replacementpoint;
        s4                  fieldtype;
+       s4                 varindex;
 
        /* get required compiler data */
 
@@ -200,48 +200,55 @@ bool codegen(jitdata *jd)
 
        for (p = 0, l = 0; p < md->paramcount; p++) {
                t = md->paramtypes[p].type;
-               var = &(rd->locals[l][t]);
+
+               varindex = jd->local_map[l * 5 + t];
+
                l++;
                if (IS_2_WORD_TYPE(t))    /* increment local counter for 2 word types */
                        l++;
-               if (var->type < 0)
-                       continue;
+
+               if (varindex == UNUSED)
+                       continue;
+
+               var = jd->var + varindex;
+
                s1 = md->params[p].regoff;
+
                if (IS_INT_LNG_TYPE(t)) {                    /* integer args          */
                        if (!md->params[p].inmemory) {           /* register arguments    */
                                s2 = rd->argintregs[s1];
-                               if (!(var->flags & INMEMORY)) {      /* reg arg -> register   */
-                                       M_INTMOVE(s2, var->regoff);
+                               if (!IS_INMEMORY(var->flags)) {      /* reg arg -> register   */
+                                       M_INTMOVE(s2, var->vv.regoff);
 
                                } else {                             /* reg arg -> spilled    */
-                                       M_LST(s2, REG_SP, var->regoff * 8);
+                                       M_LST(s2, REG_SP, var->vv.regoff * 8);
                                }
 
                        } else {                                 /* stack arguments       */
-                               if (!(var->flags & INMEMORY)) {      /* stack arg -> register */
-                                       M_LLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 8);
+                               if (!IS_INMEMORY(var->flags)) {      /* stack arg -> register */
+                                       M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) *8);
 
                                } else {                             /* stack arg -> spilled  */
-                                       var->regoff = cd->stackframesize + s1;
+                                       var->vv.regoff = cd->stackframesize + s1;
                                }
                        }
 
                } else {                                     /* floating args         */
                        if (!md->params[p].inmemory) {           /* register arguments    */
                                s2 = rd->argfltregs[s1];
-                               if (!(var->flags & INMEMORY)) {      /* reg arg -> register   */
-                                       M_FLTMOVE(s2, var->regoff);
+                               if (!IS_INMEMORY(var->flags)) {      /* reg arg -> register   */
+                                       M_FLTMOVE(s2, var->vv.regoff);
 
                                } else {                                         /* reg arg -> spilled    */
-                                       M_DST(s2, REG_SP, var->regoff * 8);
+                                       M_DST(s2, REG_SP, var->vv.regoff * 8);
                                }
 
                        } else {                                 /* stack arguments       */
                                if (!(var->flags & INMEMORY)) {      /* stack-arg -> register */
-                                       M_DLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 8);
+                                       M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
 
                                } else {                             /* stack-arg -> spilled  */
-                                       var->regoff = cd->stackframesize + s1;
+                                       var->vv.regoff = cd->stackframesize + s1;
                                }
                        }
                }
@@ -351,10 +358,10 @@ bool codegen(jitdata *jd)
                while (len) {
                        len--;
                        src = bptr->invars[len];
-                       if ((len == 0) && (bptr->type != BBTYPE_STD)) {
+                       if ((len == bptr->indepth-1) && (bptr->type != BBTYPE_STD)) {
                                        /*                              d = reg_of_var(m, src, REG_ITMP1); */
                                        if (!(src->flags & INMEMORY))
-                                               d = src->regoff;
+                                               d = src->vv.regoff;
                                        else
                                                d = REG_ITMP1;
                                        M_INTMOVE(REG_ITMP1, d);
@@ -365,35 +372,18 @@ bool codegen(jitdata *jd)
 #endif
                        while (len) {
                                len--;
-                               src = bptr->invars[len];
-                               if ((len == 0) && (bptr->type != BBTYPE_STD)) {
-                                       d = codegen_reg_of_var(rd, 0, src, REG_ITMP1);
+                               varindex = bptr->invars[len];
+                               var = jd->var + varindex;
+                               if ((len == bptr->indepth-1) && (bptr->type != BBTYPE_STD)) {
+                                       d = codegen_reg_of_var(0, var, REG_ITMP1);
                                        M_INTMOVE(REG_ITMP1, d);
-                                       emit_store(jd, NULL, src, d);
+                                       emit_store(jd, NULL, var, d);
 
-                               } else {
-                                       d = codegen_reg_of_var(rd, 0, src, REG_IFTMP);
-                                       if ((src->varkind != STACKVAR)) {
-                                               s2 = src->type;
-                                               if (IS_FLT_DBL_TYPE(s2)) {
-                                                       if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-                                                               s1 = rd->interfaces[len][s2].regoff;
-                                                               M_FLTMOVE(s1, d);
-                                                       } else {
-                                                               M_DLD(d, REG_SP, rd->interfaces[len][s2].regoff * 8);
-                                                       }
-                                                       emit_store(jd, NULL, src, d);
-                                               }
-                                               else {
-                                                       if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-                                                               s1 = rd->interfaces[len][s2].regoff;
-                                                               M_INTMOVE(s1, d);
-                                                       } else {
-                                                               M_LLD(d, REG_SP, rd->interfaces[len][s2].regoff * 8);
-                                                       }
-                                                       emit_store(jd, NULL, src, d);
-                                               }
-                                       }
+                               }
+                               else {
+                                       assert((var->flags & OUTVAR));
+                                       d = codegen_reg_of_var(0, var, REG_ITMP1);
+                               
                                }
                        }
 #if defined(ENABLE_LSRA)
@@ -496,130 +486,33 @@ bool codegen(jitdata *jd)
                /* load/store operations **********************************************/
 
                case ICMD_ILOAD:      /* ...  ==> ..., content of local variable      */
-               case ICMD_LLOAD:      /* op1 = local variable                         */
-               case ICMD_ALOAD:
-
-                       d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
-                       if ((iptr->dst.var->varkind == LOCALVAR) &&
-                           (iptr->dst.var->varnum == iptr->s1.localindex))
-                               break;
-                       var = &(rd->locals[iptr->s1.localindex][iptr->opc - ICMD_ILOAD]);
-                       if (var->flags & INMEMORY) {
-                               M_LLD(d, REG_SP, var->regoff * 8);
-                       } else {
-                               M_INTMOVE(var->regoff, d);
-                       }
-                       emit_store_dst(jd, iptr, d);
-                       break;
-
-               case ICMD_FLOAD:      /* ...  ==> ..., content of local variable      */
-               case ICMD_DLOAD:      /* op1 = local variable                         */
-
-                       d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
-                       if ((iptr->dst.var->varkind == LOCALVAR) &&
-                           (iptr->dst.var->varnum == iptr->s1.localindex))
-                               break;
-                       var = &(rd->locals[iptr->s1.localindex][iptr->opc - ICMD_ILOAD]);
-                       if (var->flags & INMEMORY) {
-                               M_DLD(d, REG_SP, var->regoff * 8);
-                       } else {
-                               M_FLTMOVE(var->regoff, d);
-                       }
-                       emit_store_dst(jd, iptr, d);
-                       break;
-
-
+               case ICMD_ALOAD:      /* s1 = local variable                          */
+               case ICMD_LLOAD:
+               case ICMD_FLOAD:  
+               case ICMD_DLOAD:  
                case ICMD_ISTORE:     /* ..., value  ==> ...                          */
-               case ICMD_LSTORE:     /* op1 = local variable                         */
-               case ICMD_ASTORE:
-
-                       if ((iptr->s1.var->varkind == LOCALVAR) &&
-                           (iptr->s1.var->varnum == iptr->dst.localindex))
-                               break;
-                       var = &(rd->locals[iptr->dst.localindex][iptr->opc - ICMD_ISTORE]);
-                       if (var->flags & INMEMORY) {
-                               s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-                               M_LST(s1, REG_SP, var->regoff * 8);
-                       } else {
-                               s1 = emit_load_s1(jd, iptr, var->regoff);
-                               M_INTMOVE(s1, var->regoff);
-                       }
-                       break;
-
-               case ICMD_FSTORE:     /* ..., value  ==> ...                          */
-               case ICMD_DSTORE:     /* op1 = local variable                         */
-
-                       if ((iptr->s1.var->varkind == LOCALVAR) &&
-                           (iptr->s1.var->varnum == iptr->dst.localindex))
-                               break;
-                       var = &(rd->locals[iptr->dst.localindex][iptr->opc - ICMD_ISTORE]);
-                       if (var->flags & INMEMORY) {
-                               s1 = emit_load_s1(jd, iptr, REG_FTMP1);
-                               M_DST(s1, REG_SP, var->regoff * 8);
-                       } else {
-                               s1 = emit_load_s1(jd, iptr, var->regoff);
-                               M_FLTMOVE(s1, var->regoff);
-                       }
+               case ICMD_ASTORE:     /* dst = local variable                         */
+               case ICMD_LSTORE:
+               case ICMD_FSTORE:
+               case ICMD_DSTORE: 
+                       
+                       emit_copy(jd, iptr, jd->var + iptr->s1.varindex, 
+                                                               jd->var + iptr->dst.varindex);
                        break;
 
-
-               /* pop/dup/swap operations ********************************************/
+               /* pop/copy/move operations *******************************************/
 
                /* attention: double and longs are only one entry in CACAO ICMDs      */
 
                case ICMD_POP:        /* ..., value  ==> ...                          */
                case ICMD_POP2:       /* ..., value, value  ==> ...                   */
-                       break;
 
-               case ICMD_DUP:        /* ..., a ==> ..., a, a                         */
-
-                       M_COPY(iptr->s1.var, iptr->dst.var);
-                       break;
-
-               case ICMD_DUP_X1:     /* ..., a, b ==> ..., b, a, b                   */
-
-                       M_COPY(iptr->dst.dupslots[  1], iptr->dst.dupslots[2+2]);
-                       M_COPY(iptr->dst.dupslots[  0], iptr->dst.dupslots[2+1]);
-                       M_COPY(iptr->dst.dupslots[2+2], iptr->dst.dupslots[2+0]);
                        break;
 
-               case ICMD_DUP_X2:     /* ..., a, b, c ==> ..., c, a, b, c             */
+               case ICMD_COPY:
+               case ICMD_MOVE:
 
-                       M_COPY(iptr->dst.dupslots[  2], iptr->dst.dupslots[3+3]);
-                       M_COPY(iptr->dst.dupslots[  1], iptr->dst.dupslots[3+2]);
-                       M_COPY(iptr->dst.dupslots[  0], iptr->dst.dupslots[3+1]);
-                       M_COPY(iptr->dst.dupslots[3+3], iptr->dst.dupslots[3+0]);
-                       break;
-
-               case ICMD_DUP2:       /* ..., a, b ==> ..., a, b, a, b                */
-
-                       M_COPY(iptr->dst.dupslots[  1], iptr->dst.dupslots[2+1]);
-                       M_COPY(iptr->dst.dupslots[  0], iptr->dst.dupslots[2+0]);
-                       break;
-
-               case ICMD_DUP2_X1:    /* ..., a, b, c ==> ..., b, c, a, b, c          */
-
-                       M_COPY(iptr->dst.dupslots[  2], iptr->dst.dupslots[3+4]);
-                       M_COPY(iptr->dst.dupslots[  1], iptr->dst.dupslots[3+3]);
-                       M_COPY(iptr->dst.dupslots[  0], iptr->dst.dupslots[3+2]);
-                       M_COPY(iptr->dst.dupslots[3+4], iptr->dst.dupslots[3+1]);
-                       M_COPY(iptr->dst.dupslots[3+3], iptr->dst.dupslots[3+0]);
-                       break;
-
-               case ICMD_DUP2_X2:    /* ..., a, b, c, d ==> ..., c, d, a, b, c, d    */
-
-                       M_COPY(iptr->dst.dupslots[  3], iptr->dst.dupslots[4+5]);
-                       M_COPY(iptr->dst.dupslots[  2], iptr->dst.dupslots[4+4]);
-                       M_COPY(iptr->dst.dupslots[  1], iptr->dst.dupslots[4+3]);
-                       M_COPY(iptr->dst.dupslots[  0], iptr->dst.dupslots[4+2]);
-                       M_COPY(iptr->dst.dupslots[4+5], iptr->dst.dupslots[4+1]);
-                       M_COPY(iptr->dst.dupslots[4+4], iptr->dst.dupslots[4+0]);
-                       break;
-
-               case ICMD_SWAP:       /* ..., a, b ==> ..., b, a                      */
-
-                       M_COPY(iptr->dst.dupslots[  1], iptr->dst.dupslots[2+0]);
-                       M_COPY(iptr->dst.dupslots[  0], iptr->dst.dupslots[2+1]);
+                       M_COPY(iptr->s1.varindex, iptr->dst.varindex);
                        break;
 
 
@@ -1245,22 +1138,19 @@ bool codegen(jitdata *jd)
                case ICMD_IINC:       /* ..., value  ==> ..., value + constant        */
                                      /* s1.localindex = variable, sx.val.i = constant*/
 
-                       var = &(rd->locals[iptr->s1.localindex][TYPE_INT]);
-                       if (var->flags & INMEMORY) {
-                               s1 = REG_ITMP1;
-                               M_LLD(s1, REG_SP, var->regoff * 8);
-                       } else
-                               s1 = var->regoff;
+                       d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+
                        if ((iptr->sx.val.i >= 0) && (iptr->sx.val.i <= 255)) {
-                               M_IADD_IMM(s1, iptr->sx.val.i, s1);
+                               M_IADD_IMM(s1, iptr->sx.val.i, d);
                        } else if ((iptr->sx.val.i > -256) && (iptr->sx.val.i < 0)) {
-                               M_ISUB_IMM(s1, (-iptr->sx.val.i), s1);
+                               M_ISUB_IMM(s1, (-iptr->sx.val.i), d);
                        } else {
                                M_LDA (s1, s1, iptr->sx.val.i);
-                               M_IADD(s1, REG_ZERO, s1);
+                               M_IADD(s1, REG_ZERO, d);
                        }
-                       if (var->flags & INMEMORY)
-                               M_LST(s1, REG_SP, var->regoff * 8);
+
+                       emit_store_dst(jd, iptr, d);
                        break;
 
 
@@ -2328,13 +2218,15 @@ bool codegen(jitdata *jd)
                case ICMD_RET:          /* ... ==> ...                                */
                                        /* s1.localindex = local variable                       */
 
-                       var = &(rd->locals[iptr->s1.localindex][TYPE_ADR]);
-                       if (var->flags & INMEMORY) {
-                               M_ALD(REG_ITMP1, REG_SP, 8 * var->regoff);
-                               M_RET(REG_ZERO, REG_ITMP1);
-                               }
-                       else
-                               M_RET(REG_ZERO, var->regoff);
+                       M_BR(0);
+                       codegen_addreference(cd, iptr->dst.block);
+/*                     var = &(rd->locals[iptr->s1.localindex][TYPE_ADR]); */
+/*                     if (var->flags & INMEMORY) { */
+/*                             M_ALD(REG_ITMP1, REG_SP, 8 * var->vv.regoff); */
+/*                             M_RET(REG_ZERO, REG_ITMP1); */
+/*                             } */
+/*                     else */
+/*                             M_RET(REG_ZERO, var->vv.regoff); */
                        ALIGNCODENOP;
                        break;
 
@@ -2874,30 +2766,32 @@ gen_method:
                        /* copy arguments to registers or stack location                  */
 
                        for (s3 = s3 - 1; s3 >= 0; s3--) {
-                               src = iptr->sx.s23.s2.args[s3];
+                               s1 = iptr->sx.s23.s2.args[s3];
+                               var1 = jd->var + s1;
 
-                               if (src->varkind == ARGVAR)
+                               /* Already Preallocated (ARGVAR) ? */
+                               if (var1->flags & PREALLOC)
                                        continue;
 
-                               if (IS_INT_LNG_TYPE(src->type)) {
+                               if (IS_INT_LNG_TYPE(var1->type)) {
                                        if (!md->params[s3].inmemory) {
                                                s1 = rd->argintregs[md->params[s3].regoff];
-                                               d = emit_load(jd, iptr, src, s1);
+                                               d = emit_load(jd, iptr, var1, s1);
                                                M_INTMOVE(d, s1);
                                        }
                                        else {
-                                               d = emit_load(jd, iptr, src, REG_ITMP1);
+                                               d = emit_load(jd, iptr, var1, REG_ITMP1);
                                                M_LST(d, REG_SP, md->params[s3].regoff * 8);
                                        }
                                }
                                else {
                                        if (!md->params[s3].inmemory) {
                                                s1 = rd->argfltregs[md->params[s3].regoff];
-                                               d = emit_load(jd, iptr, src, s1);
+                                               d = emit_load(jd, iptr, var1, s1);
                                                M_FLTMOVE(d, s1);
                                        }
                                        else {
-                                               d = emit_load(jd, iptr, src, REG_FTMP1);
+                                               d = emit_load(jd, iptr, var1, REG_FTMP1);
                                                M_DST(d, REG_SP, md->params[s3].regoff * 8);
                                        }
                                }
@@ -3355,12 +3249,15 @@ gen_method:
 
                        for (s1 = iptr->s1.argcount; --s1 >= 0; ) {
 
-                               src = iptr->sx.s23.s2.args[s1];
+                               s3 = iptr->sx.s23.s2.args[s1];
+                               var1 = jd->var + s3;
        
                                /* copy SAVEDVAR sizes to stack */
 
-                               if (src->varkind != ARGVAR) {
-                                       s2 = emit_load(jd, iptr, src, REG_ITMP1);
+                               /* Already Preallocated (ARGVAR) ? */
+
+                               if (!(var1->flags & PREALLOC)) {
+                                       s2 = emit_load(jd, iptr, var1, REG_ITMP1);
                                        M_LST(s2, REG_SP, s1 * 8);
                                }
                        }
@@ -3420,36 +3317,7 @@ gen_method:
 
        len = bptr->outdepth;
        MCODECHECK(64+len);
-#if defined(ENABLE_LSRA)
-       if (!opt_lsra) 
-#endif
-       while (len) {
-               len--;
-               src = bptr->outvars[len];
-               if ((src->varkind != STACKVAR)) {
-                       s2 = src->type;
-                       if (IS_FLT_DBL_TYPE(s2)) {
-                               /* XXX can be one call */
-                               s1 = emit_load(jd, NULL, src, REG_FTMP1);
-                               if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-                                       M_FLTMOVE(s1,rd->interfaces[len][s2].regoff);
-                                       }
-                               else {
-                                       M_DST(s1, REG_SP, 8 * rd->interfaces[len][s2].regoff);
-                                       }
-                               }
-                       else {
-                               /* XXX can be one call */
-                               s1 = emit_load(jd, NULL, src, REG_ITMP1);
-                               if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-                                       M_INTMOVE(s1,rd->interfaces[len][s2].regoff);
-                                       }
-                               else {
-                                       M_LST(s1, REG_SP, 8 * rd->interfaces[len][s2].regoff);
-                                       }
-                               }
-                       }
-               }
+
        } /* if (bptr -> flags >= BBREACHED) */
        } /* for basic block */
 

diff --git a/src/vm/jit/alpha/codegen.h b/src/vm/jit/alpha/codegen.h
index 416736e2d759bb17dc1d143aecbd4dd47913ee53..f41219a8efd37ff3fff65d4bf77dc614c5f3da9b 100644 (file)
--- a/src/vm/jit/alpha/codegen.h
+++ b/src/vm/jit/alpha/codegen.h
@@ -29,7 +29,7 @@
 
    Changes: Christian Thalinger
 
-   $Id: codegen.h 5071 2006-07-03 13:49:14Z twisti $
+   $Id: codegen.h 5518 2006-09-15 16:31:47Z christian $
 
 */
 
@@ -101,9 +101,9 @@
     } while (0)
 
 
-#define M_COPY(s,d)                     emit_copy(jd, iptr, (s), (d))
-#define ICONST(d,c)                     emit_iconst(cd, (d), (c))
-#define LCONST(d,c)                     emit_lconst(cd, (d), (c))
+#define M_COPY(s,d)        emit_copy(jd, iptr, &(jd->var[(s)]), &(jd->var[(d)]))
+#define ICONST(d,c)        emit_iconst(cd, (d), (c))
+#define LCONST(d,c)        emit_lconst(cd, (d), (c))
 
 
 /* macros to create code ******************************************************/

diff --git a/src/vm/jit/alpha/emit.c b/src/vm/jit/alpha/emit.c
index 365858a1256cd3b54b4f1237abb9ae62c6b0484e..a99639ce299e4341b48c8b656255b7dcc9bbb19f 100644 (file)
--- a/src/vm/jit/alpha/emit.c
+++ b/src/vm/jit/alpha/emit.c
@@ -61,7 +61,7 @@
 
 *******************************************************************************/
 
-s4 emit_load(jitdata *jd, instruction *iptr, stackptr src, s4 tempreg)
+s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
 {
        codegendata  *cd;
        s4            reg;
@@ -70,18 +70,18 @@ s4 emit_load(jitdata *jd, instruction *iptr, stackptr src, s4 tempreg)
 
        cd = jd->cd;
 
-       if (src->flags & INMEMORY) {
+       if (IS_INMEMORY(src->flags)) {
                COUNT_SPILLS;
 
                if (IS_FLT_DBL_TYPE(src->type))
-                       M_DLD(tempreg, REG_SP, src->regoff * 8);
+                       M_DLD(tempreg, REG_SP, src->vv.regoff * 8);
                else
-                       M_LLD(tempreg, REG_SP, src->regoff * 8);
+                       M_LLD(tempreg, REG_SP, src->vv.regoff * 8);
 
                reg = tempreg;
        }
        else
-               reg = src->regoff;
+               reg = src->vv.regoff;
 
        return reg;
 }
@@ -95,9 +95,12 @@ s4 emit_load(jitdata *jd, instruction *iptr, stackptr src, s4 tempreg)
 
 s4 emit_load_s1(jitdata *jd, instruction *iptr, s4 tempreg)
 {
+       varinfo       *src;
        s4 r;
        
-       r = emit_load(jd, iptr, iptr->s1.var, tempreg);
+       src = jd->var + iptr->s1.varindex;
+
+       r = emit_load(jd, iptr, src, tempreg);
 
        return r;
 }
@@ -111,9 +114,12 @@ s4 emit_load_s1(jitdata *jd, instruction *iptr, s4 tempreg)
 
 s4 emit_load_s2(jitdata *jd, instruction *iptr, s4 tempreg)
 {
+       varinfo       *src;
        s4 r;
 
-       r = emit_load(jd, iptr, iptr->sx.s23.s2.var, tempreg);
+       src = jd->var + iptr->sx.s23.s2.varindex;
+
+       r = emit_load(jd, iptr, src, tempreg);
 
        return r;
 }
@@ -127,9 +133,12 @@ s4 emit_load_s2(jitdata *jd, instruction *iptr, s4 tempreg)
 
 s4 emit_load_s3(jitdata *jd, instruction *iptr, s4 tempreg)
 {
+       varinfo       *src;
        s4 r;
 
-       r = emit_load(jd, iptr, iptr->sx.s23.s3.var, tempreg);
+       src = jd->var + iptr->sx.s23.s3.varindex;
+
+       r = emit_load(jd, iptr, src, tempreg);
 
        return r;
 }
@@ -141,7 +150,7 @@ s4 emit_load_s3(jitdata *jd, instruction *iptr, s4 tempreg)
 
 *******************************************************************************/
 
-void emit_store(jitdata *jd, instruction *iptr, stackptr dst, s4 d)
+void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
 {
        codegendata  *cd;
 
@@ -149,13 +158,13 @@ void emit_store(jitdata *jd, instruction *iptr, stackptr dst, s4 d)
 
        cd = jd->cd;
 
-       if (dst->flags & INMEMORY) {
+       if (IS_INMEMORY(dst->flags)) {
                COUNT_SPILLS;
 
                if (IS_FLT_DBL_TYPE(dst->type))
-                       M_DST(d, REG_SP, dst->regoff * 8);
+                       M_DST(d, REG_SP, dst->vv.regoff * 8);
                else
-                       M_LST(d, REG_SP, dst->regoff * 8);
+                       M_LST(d, REG_SP, dst->vv.regoff * 8);
        }
 }
 
@@ -168,7 +177,11 @@ void emit_store(jitdata *jd, instruction *iptr, stackptr dst, s4 d)
 
 void emit_store_dst(jitdata *jd, instruction *iptr, s4 d)
 {
-       emit_store(jd, iptr, iptr->dst.var, d);
+       varinfo *dst;
+       
+       dst = jd->var + iptr->dst.varindex;
+
+       emit_store(jd, iptr, dst, d);
 }
 
 
@@ -178,18 +191,16 @@ void emit_store_dst(jitdata *jd, instruction *iptr, s4 d)
 
 *******************************************************************************/
 
-void emit_copy(jitdata *jd, instruction *iptr, stackptr src, stackptr dst)
+void emit_copy(jitdata *jd, instruction *iptr, varinfo *src, varinfo *dst)
 {
        codegendata  *cd;
-       registerdata *rd;
        s4            s1, d;
 
        /* get required compiler data */
 
        cd = jd->cd;
-       rd = jd->rd;
 
-       if ((src->regoff != dst->regoff) ||
+       if ((src->vv.regoff != dst->vv.regoff) ||
                ((src->flags ^ dst->flags) & INMEMORY)) {
 
                /* If one of the variables resides in memory, we can eliminate
@@ -197,12 +208,12 @@ void emit_copy(jitdata *jd, instruction *iptr, stackptr src, stackptr dst)
                   order of getting the destination register and the load. */
 
                if (IS_INMEMORY(src->flags)) {
-                       d = codegen_reg_of_var(rd, iptr->opc, dst, REG_IFTMP);
+                       d = codegen_reg_of_var(iptr->opc, dst, REG_IFTMP);
                        s1 = emit_load(jd, iptr, src, d);
                }
                else {
                        s1 = emit_load(jd, iptr, src, REG_IFTMP);
-                       d = codegen_reg_of_var(rd, iptr->opc, dst, s1);
+                       d = codegen_reg_of_var(iptr->opc, dst, s1);
                }
 
                if (s1 != d) {

diff --git a/src/vm/jit/alpha/md-abi.c b/src/vm/jit/alpha/md-abi.c
index 803ebf66a7e10ab60866a41174c912b448bcffbe..38e1bfcc2cc5b60bbd8f02e5b148d6b41ba1cecc 100644 (file)
--- a/src/vm/jit/alpha/md-abi.c
+++ b/src/vm/jit/alpha/md-abi.c
@@ -28,7 +28,7 @@
 
    Changes: Christian Ullrich
 
-   $Id: md-abi.c 5115 2006-07-12 14:55:04Z twisti $
+   $Id: md-abi.c 5518 2006-09-15 16:31:47Z christian $
 
 */
 
@@ -150,11 +150,11 @@ void md_param_alloc(methoddesc *md)
    
    --- out
    if precoloring was possible:
-   stackslot->varkind       =ARGVAR
-                       ->varnum        =-1
-                       ->flags         =0
-                       ->regoff        =[REG_RESULT, REG_FRESULT]
+   jd->var[stackslot->varnum]->flags       = PREALLOC
+                                        ->regoff      =[REG_RESULT|REG_FRESULT]
+   rd->arg[flt|int]reguse   set to a value according the register usage
 
+   NOTE: Do not pass a LOCALVAR in stackslot->varnum.
 *******************************************************************************/
 
 void md_return_alloc(jitdata *jd, stackptr stackslot)
@@ -164,6 +164,8 @@ void md_return_alloc(jitdata *jd, stackptr stackslot)
 
        /* get required compiler data */
 
+       return;
+
        m = jd->m;
 
        md = m->parseddesc;
@@ -172,14 +174,18 @@ void md_return_alloc(jitdata *jd, stackptr stackslot)
           not to survive method invokations. */
 
        if (!(stackslot->flags & SAVEDVAR)) {
-               stackslot->varkind = ARGVAR;
-               stackslot->varnum  = -1;
-               stackslot->flags   = 0;
+/*             stackslot->varkind = ARGVAR; */
+/*             stackslot->varnum  = -1; */
+/*             stackslot->flags   = 0; */
+
+               jd->var[stackslot->varnum].flags = PREALLOC;
 
                if (IS_INT_LNG_TYPE(md->returntype.type))
-                       stackslot->regoff = REG_RESULT;
+/*                     stackslot->regoff = REG_RESULT; */
+                       jd->var[stackslot->varnum].vv.regoff = REG_RESULT;
                else
-                       stackslot->regoff = REG_FRESULT;
+/*                     stackslot->regoff = REG_FRESULT; */
+                       jd->var[stackslot->varnum].vv.regoff = REG_FRESULT;
        }
 }