* src/vm/jit/sparc64/emit.c: emit_{load,store,copy} changed to switch/case for handli...

* src/vm/jit/sparc64/codegen.h: fixed f2d and d2f conversion.

* src/vm/jit/sparc64/md-abi.c: removed md_native_reg_setup(), not needed any longer.

* src/vm/jit/sparc64/codegen.c: implemented ICMD_MULTIANEWARRAY.
fixed FRETURN, DRETURN.
repaired native float arg passing.

diff --git a/src/vm/jit/sparc64/codegen.c b/src/vm/jit/sparc64/codegen.c
index 9f5d4b024901f68084b7b3ed6e07c497153b9c91..7920828491ec03910cf6cfa29199addcd8e2e1d7 100644 (file)
--- a/src/vm/jit/sparc64/codegen.c
+++ b/src/vm/jit/sparc64/codegen.c
@@ -2164,7 +2164,7 @@ bool codegen(jitdata *jd)
                case ICMD_DRETURN:
 
                        s1 = emit_load_s1(jd, iptr, REG_FRESULT);
-                       M_FLTMOVE(s1, REG_FRESULT);
+                       M_DBLMOVE(s1, REG_FRESULT);
                        goto nowperformreturn;
 
                case ICMD_RETURN:       /* ...  ==> ...                               */
@@ -2803,6 +2803,66 @@ gen_method:
                        }
                        break;
 
+               case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref  */
+
+                       /* check for negative sizes and copy sizes to stack if necessary  */
+
+                       MCODECHECK((iptr->s1.argcount << 1) + 64);
+
+                       for (s1 = iptr->s1.argcount; --s1 >= 0; ) {
+
+                               var = VAR(iptr->sx.s23.s2.args[s1]);
+       
+                               /* copy SAVEDVAR sizes to stack */
+
+                               /* Already Preallocated? */
+
+                               if (!(var->flags & PREALLOC)) {
+                                       s2 = emit_load(jd, iptr, var, REG_ITMP1);
+                                       M_STX(s2, REG_SP, CSTACK + (s1 * 8));
+                               }
+                       }
+
+                       /* arg 0 = dimension count */
+
+                       ICONST(REG_OUT0, iptr->s1.argcount);
+
+                       /* is patcher function set? */
+
+                       if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+                               disp = dseg_add_unique_address(cd, 0);
+
+                               codegen_add_patch_ref(cd, PATCHER_builtin_multianewarray,
+                                                                         iptr->sx.s23.s3.c.ref,
+                                                                         disp);
+                       }
+                       else
+                               disp = dseg_add_address(cd, iptr->sx.s23.s3.c.cls);
+
+                       /* arg 1 = arraydescriptor */
+
+                       M_ALD(REG_OUT1, REG_PV, disp);
+
+                       /* arg 2 = pointer to dimensions = stack pointer (absolute) */
+
+                       M_ADD_IMM(REG_SP, CSTACK, REG_OUT2);
+
+                       /* XXX c abi call */
+                       disp = dseg_add_functionptr(cd, BUILTIN_multianewarray);
+                       M_ALD(REG_ITMP3, REG_PV, disp);
+                       M_JMP(REG_RA_CALLER, REG_ITMP3, REG_ZERO);
+                       M_NOP;
+
+                       /* check for exception before result assignment */
+
+                       M_BEQZ(REG_RESULT_CALLER, 0);
+                       codegen_add_fillinstacktrace_ref(cd);
+                       M_NOP;
+
+                       d = codegen_reg_of_dst(jd, iptr, REG_RESULT_CALLER);
+                       M_INTMOVE(REG_RESULT_CALLER, d);
+                       emit_store_dst(jd, iptr, d);
+                       break;
 
                default:
                        exceptions_throw_internalerror("Unknown ICMD %d during code generation",
@@ -2929,8 +2989,7 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
        cd   = jd->cd;
        rd   = jd->rd;
 
-       /* rewrite registers and params */
-       md_native_reg_setup(jd);
+       /* redo param allocation */
        md_native_param_alloc(nmd);
 
        /* initialize variables */
@@ -3039,7 +3098,7 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
                                if (!nmd->params[j].inmemory) {
                                        /* no mapping to regs needed, native flt args use regoff */
-                                       s2 = nmd->params[j].regoff - 6;
+                                       s2 = nmd->params[j].regoff;
                                        
                                        /* we cannot move flt regs to their native arg locations directly */
                                        M_DMOV(s1, s2 + 16);

diff --git a/src/vm/jit/sparc64/codegen.h b/src/vm/jit/sparc64/codegen.h
index b4059fd25789d3713fcc7e97972ffc8bf4cffe17..447718d76b08f88579a83a959e7e77424b2a04fe 100644 (file)
--- a/src/vm/jit/sparc64/codegen.h
+++ b/src/vm/jit/sparc64/codegen.h
@@ -587,8 +587,8 @@ bool fits13(s4 disp);
 #define M_CVTFL(rs,rd)          M_FOP3(0x02,0x34,0x081,DR_X(rd),-1,FR_X(rs))     /* flt2long  */
 #define M_CVTDL(rs,rd)          M_FOP3_DX(0x02,0x34,0x082,rd,-1,rs)       /* dbl2long  */
 
-#define M_CVTFD(rs,rd)          M_FOP3(0x02,0x34,0x0c9,DR_X(rs),-1,FR_X(rs))     /* flt2dbl   */
-#define M_CVTDF(rs,rd)          M_FOP3(0x02,0x34,0x0c6,FR_X(rs),-1,DR_X(rs))     /* dbl2float */
+#define M_CVTFD(rs,rd)          M_FOP3(0x02,0x34,0x0c9,DR_X(rd),-1,FR_X(rs))     /* flt2dbl   */
+#define M_CVTDF(rs,rd)          M_FOP3(0x02,0x34,0x0c6,FR_X(rd),-1,DR_X(rs))     /* dbl2float */
 
 
 

diff --git a/src/vm/jit/sparc64/emit.c b/src/vm/jit/sparc64/emit.c
index b4b58ad65b150502f78fcf772b2801750cb9691b..b015d17be61370f78832673b12e95cd03dd41d54 100644 (file)
--- a/src/vm/jit/sparc64/emit.c
+++ b/src/vm/jit/sparc64/emit.c
@@ -71,10 +71,21 @@ s4 emit_load(jitdata *jd, instruction *iptr, varinfo *src, s4 tempreg)
 
                disp = JITSTACK + src->vv.regoff * 8;
 
-               if (IS_FLT_DBL_TYPE(src->type))
-                       M_DLD(tempreg, REG_SP, disp);
-               else
+               switch(src->type)
+               {
+               case TYPE_INT:
+               case TYPE_LNG:
+               case TYPE_ADR:
                        M_LDX(tempreg, REG_SP, disp);
+                       break;
+               case TYPE_FLT:
+               case TYPE_DBL:
+                       M_DLD(tempreg, REG_SP, disp);
+                       break;
+               default:
+                       vm_abort("emit_load: unknown type %d", src->type);
+                       break;
+               }
 
                reg = tempreg;
        }
@@ -103,12 +114,23 @@ void emit_store(jitdata *jd, instruction *iptr, varinfo *dst, s4 d)
        if (dst->flags & INMEMORY) {
                COUNT_SPILLS;
 
-               disp = JITSTACK + dst->vv.regoff * 8;
-
-               if (IS_FLT_DBL_TYPE(dst->type))
-                       M_DST(d, REG_SP, disp);
-               else
+               disp = JITSTACK + dst->vv.regoff * 8;                   
+                       
+               switch(dst->type)
+               {
+               case TYPE_INT:
+               case TYPE_LNG:
+               case TYPE_ADR:
                        M_STX(d, REG_SP, disp);
+                       break;
+               case TYPE_FLT:
+               case TYPE_DBL:
+                       M_DST(d, REG_SP, disp);
+                       break;
+               default:
+                       vm_abort("emit_store: unknown type %d", dst->type);
+                       break;
+               }
        }
 }
 
@@ -146,11 +168,22 @@ void emit_copy(jitdata *jd, instruction *iptr, varinfo *src, varinfo *dst)
                        d = codegen_reg_of_var(iptr->opc, dst, s1);
                }
 
-               if (s1 != d) {
-                       if (IS_FLT_DBL_TYPE(src->type))
-                               M_DMOV(s1, d);
-               else
+               if (s1 != d) {          
+                       switch(src->type)
+                       {
+                       case TYPE_INT:
+                       case TYPE_LNG:
+                       case TYPE_ADR:
                                M_MOV(s1, d);
+                               break;
+                       case TYPE_FLT:
+                       case TYPE_DBL:
+                               M_DMOV(s1, d);
+                               break;
+                       default:
+                               vm_abort("emit_copy: unknown type %d", src->type);
+                               break;
+                       }
                }
 
                emit_store(jd, iptr, dst, d);

diff --git a/src/vm/jit/sparc64/md-abi.c b/src/vm/jit/sparc64/md-abi.c
index 05e1ed9db4bcda4de087b6b3689d59124f3ee1be..67b40e9eb3633b8c6fb1b9c2217bbfb72b660b73 100644 (file)
--- a/src/vm/jit/sparc64/md-abi.c
+++ b/src/vm/jit/sparc64/md-abi.c
@@ -246,7 +246,7 @@ void md_param_alloc_native(methoddesc *md)
    TODO
 
 *******************************************************************************/
-
+#if 0
 void md_native_reg_setup(jitdata *jd)
 {
        methodinfo   *m;
@@ -283,7 +283,7 @@ void md_native_reg_setup(jitdata *jd)
        assert(rd->argfltreguse == FLT_NATARG_CNT);
 
 }
-
+#endif
 /* md_return_alloc *************************************************************
 
   XXX