* src/vm/jit/arm/emit.c (emit_verbosecall_enter): Adapted to use new tracer.

(emit_verbosecall_exit): Likewise.

* src/vm/jit/arm/md-abi.h (TRACE_ARGS_NUM): Removed.

diff --git a/src/vm/jit/arm/emit.c b/src/vm/jit/arm/emit.c
index e3fb9969d010c39fd3a64317dd4c16673b14bae2..6b69432aeb7c55ce8ee5fe42b8ec7edeb034b90e 100644 (file)
--- a/src/vm/jit/arm/emit.c
+++ b/src/vm/jit/arm/emit.c
@@ -40,7 +40,6 @@
 
 #include "threads/lock-common.h"
 
-#include "vm/builtin.h"
 #include "vm/exceptions.h"
 #include "vm/global.h"
 
@@ -50,6 +49,7 @@
 #include "vm/jit/jit.h"
 #include "vm/jit/patcher-common.h"
 #include "vm/jit/replace.h"
+#include "vm/jit/trace.h"
 
 #include "toolbox/logging.h" /* XXX for debugging only */
 
@@ -609,9 +609,8 @@ void emit_verbosecall_enter(jitdata *jd)
        codegendata  *cd;
        registerdata *rd;
        methoddesc   *md;
-       s4            stackframesize;
        s4            disp;
-       s4            i, t, s1, s2;
+       s4            i, s;
 
        /* get required compiler data */
 
@@ -621,87 +620,73 @@ void emit_verbosecall_enter(jitdata *jd)
 
        md = m->parseddesc;
 
-       /* stackframesize is changed below */
-
-       stackframesize = cd->stackframesize;
-
        /* mark trace code */
 
        M_NOP;
 
-       /* Save argument registers to stack (including LR and PV).  Keep
-          stack 8-byte aligned. */
-
-       M_STMFD(BITMASK_ARGS | (1<<REG_LR) | (1<<REG_PV), REG_SP);
-       M_SUB_IMM(REG_SP, REG_SP, (2 + 2 + 1 + 1) * 4); /* space for a3, a4 and m */
-
-       stackframesize += (6 + 2 + 2 + 1 + 1) * 4;
-
-       /* prepare args for tracer */
-
-       i = md->paramcount - 1;
-
-       if (i > 3)
-               i = 3;
+       /* Keep stack 8-byte aligned. */
 
-       for (; i >= 0; i--) {
-               t = md->paramtypes[i].type;
+       M_STMFD((1<<REG_LR) | (1<<REG_PV), REG_SP);
+       M_SUB_IMM(REG_SP, REG_SP, md->paramcount * 8);
 
-               /* load argument into register (s1) and make it of TYPE_LNG */
+       /* save argument registers */
 
+       for (i = 0; i < md->paramcount; i++) {
                if (!md->params[i].inmemory) {
-                       s1 = md->params[i].regoff;
+                       s = md->params[i].regoff;
 
-                       if (!IS_2_WORD_TYPE(t)) {
-                               M_MOV_IMM(REG_ITMP1, 0);
-                               s1 = PACK_REGS(s1, REG_ITMP1);
-                       }
-               }
-               else {
-                       s1 = REG_ITMP12_PACKED;
-                       s2 = md->params[i].regoff + stackframesize;
-
-                       if (IS_2_WORD_TYPE(t))
-                               M_LLD(s1, REG_SP, s2);
-                       else {
-                               M_ILD(GET_LOW_REG(s1), REG_SP, s2);
-                               M_MOV_IMM(GET_HIGH_REG(s1), 0);
+                       switch (md->paramtypes[i].type) {
+                       case TYPE_ADR:
+                       case TYPE_INT:
+                               M_IST(s, REG_SP, i * 8);
+                               break;
+                       case TYPE_LNG:
+                               M_LST(s, REG_SP, i * 8);
+                               break;
+                       case TYPE_FLT:
+                               M_FST(s, REG_SP, i * 8);
+                               break;
+                       case TYPE_DBL:
+                               M_DST(s, REG_SP, i * 8);
+                               break;
                        }
                }
-
-               /* place argument for tracer */
-
-               if (i < 2) {
-#if defined(__ARMEL__)
-                       s2 = PACK_REGS(abi_registers_integer_argument[i * 2],
-                                                  abi_registers_integer_argument[i * 2 + 1]);
-#else /* defined(__ARMEB__) */
-                       s2 = PACK_REGS(abi_registers_integer_argument[i * 2 + 1],
-                                                  abi_registers_integer_argument[i * 2]);
-#endif          
-                       M_LNGMOVE(s1, s2);
-               }
-               else {
-                       s2 = (i - 2) * 2;
-                       M_LST(s1, REG_SP, s2 * 4);
-               }
        }
 
-       /* prepare methodinfo pointer for tracer */
-
        disp = dseg_add_address(cd, m);
-       M_DSEG_LOAD(REG_ITMP1, disp);
-       M_STR_INTERN(REG_ITMP1, REG_SP, 16);
+       M_DSEG_LOAD(REG_A0, disp);
+       M_MOV(REG_A1, REG_SP);
+       M_ADD_IMM(REG_A2, REG_SP, md->paramcount * 8 + 2 * 4 + cd->stackframesize);
+       M_LONGBRANCH(trace_java_call_enter);
 
-       /* call tracer here (we use a long branch) */
+       /* restore argument registers */
 
-       M_LONGBRANCH(builtin_verbosecall_enter);
+       for (i = 0; i < md->paramcount; i++) {
+               if (!md->params[i].inmemory) {
+                       s = md->params[i].regoff;
 
-       /* Restore argument registers from stack.  Keep stack 8-byte
-          aligned. */
+                       switch (md->paramtypes[i].type) {
+                       case TYPE_ADR:
+                       case TYPE_INT:
+                               M_ILD(s, REG_SP, i * 8);
+                               break;
+                       case TYPE_LNG:
+                               M_LLD(s, REG_SP, i * 8);
+                               break;
+                       case TYPE_FLT:
+                               M_FLD(s, REG_SP, i * 8);
+                               break;
+                       case TYPE_DBL:
+                               M_DLD(s, REG_SP, i * 8);
+                               break;
+                       }
+               }
+       }
+
+       /* Keep stack 8-byte aligned. */
 
-       M_ADD_IMM(REG_SP, REG_SP, (2 + 2 + 1 + 1) * 4);    /* free argument stack */
-       M_LDMFD(BITMASK_ARGS | (1<<REG_LR) | (1<<REG_PV), REG_SP);
+       M_ADD_IMM(REG_SP, REG_SP, md->paramcount * 8);
+       M_LDMFD((1<<REG_LR) | (1<<REG_PV), REG_SP);
 
        /* mark trace code */
 
@@ -714,8 +699,6 @@ void emit_verbosecall_enter(jitdata *jd)
 
    Generates the code for the call trace.
 
-   void builtin_verbosecall_exit(s8 l, double d, float f, methodinfo *m);
-
 *******************************************************************************/
 
 #if !defined(NDEBUG)
@@ -741,38 +724,49 @@ void emit_verbosecall_exit(jitdata *jd)
 
        /* Keep stack 8-byte aligned. */
 
-       M_STMFD(BITMASK_RESULT | (1<<REG_LR) | (1<<REG_PV), REG_SP);
-       M_SUB_IMM(REG_SP, REG_SP, (1 + 1) * 4);              /* space for f and m */
+       M_STMFD((1<<REG_LR) | (1<<REG_PV), REG_SP);
+       M_SUB_IMM(REG_SP, REG_SP, 1 * 8);
+
+       /* save argument registers */
 
        switch (md->returntype.type) {
        case TYPE_ADR:
        case TYPE_INT:
-               M_INTMOVE(REG_RESULT, GET_LOW_REG(REG_A0_A1_PACKED));
-               M_MOV_IMM(GET_HIGH_REG(REG_A0_A1_PACKED), 0);
+       case TYPE_FLT:
+               M_IST(REG_RESULT, REG_SP, 0 * 8);
                break;
 
        case TYPE_LNG:
-               M_LNGMOVE(REG_RESULT_PACKED, REG_A0_A1_PACKED);
+       case TYPE_DBL:
+               M_LST(REG_RESULT_PACKED, REG_SP, 0 * 8);
                break;
+       }
+
+       disp = dseg_add_address(cd, m);
+       M_DSEG_LOAD(REG_A0, disp);
+       M_MOV(REG_A1, REG_SP);
+       M_LONGBRANCH(trace_java_call_exit);
 
+       /* restore argument registers */
+
+       switch (md->returntype.type) {
+       case TYPE_ADR:
+       case TYPE_INT:
        case TYPE_FLT:
-               M_IST(REG_RESULT, REG_SP, 0 * 4);
+               M_ILD(REG_RESULT, REG_SP, 0 * 8);
                break;
 
+       case TYPE_LNG:
        case TYPE_DBL:
-               M_LNGMOVE(REG_RESULT_PACKED, REG_A2_A3_PACKED);
+               M_LLD(REG_RESULT_PACKED, REG_SP, 0 * 8);
                break;
        }
 
-       disp = dseg_add_address(cd, m);
-       M_DSEG_LOAD(REG_ITMP1, disp);
-       M_AST(REG_ITMP1, REG_SP, 1 * 4);
-       M_LONGBRANCH(builtin_verbosecall_exit);
 
        /* Keep stack 8-byte aligned. */
 
-       M_ADD_IMM(REG_SP, REG_SP, (1 + 1) * 4);            /* free argument stack */
-       M_LDMFD(BITMASK_RESULT | (1<<REG_LR) | (1<<REG_PV), REG_SP);
+       M_ADD_IMM(REG_SP, REG_SP, 1 * 8);
+       M_LDMFD((1<<REG_LR) | (1<<REG_PV), REG_SP);
 
        /* mark trace code */
 

diff --git a/src/vm/jit/arm/md-abi.h b/src/vm/jit/arm/md-abi.h
index f88ce67325fdcc9e3fcedfea55fb960490ea91ae..597e83eabcb714e34cc45b4112a23ec53be53bd8 100644 (file)
--- a/src/vm/jit/arm/md-abi.h
+++ b/src/vm/jit/arm/md-abi.h
@@ -94,8 +94,6 @@
 # define FLT_RES_CNT    2    /* number of reserved float registers            */
 #endif /* defined(ENABLE_SOFTFLOAT) */
 
-#define TRACE_ARGS_NUM  4
-
 
 /* Register Pack/Unpack Macros ************************************************/
 
@@ -106,7 +104,6 @@
 # define REG_RESULT_PACKED    PACK_REGS(REG_RESULT, REG_RESULT2)
 
 # define REG_A0_A1_PACKED     PACK_REGS(REG_A0, REG_A1)
-# define REG_A1_A2_PACKED     PACK_REGS(REG_A1, REG_A2)
 # define REG_A2_A3_PACKED     PACK_REGS(REG_A2, REG_A3)
 
 #else /* defined(__ARMEB__) */
@@ -116,7 +113,6 @@
 # define REG_RESULT_PACKED    PACK_REGS(REG_RESULT2, REG_RESULT)
 
 # define REG_A0_A1_PACKED     PACK_REGS(REG_A1, REG_A0)
-# define REG_A1_A2_PACKED     PACK_REGS(REG_A2, REG_A1)
 # define REG_A2_A3_PACKED     PACK_REGS(REG_A3, REG_A2)
 
 #endif