ICMD_xRETURN changed, so that REG_RESULTs are saved in case of monitorexit (MIPS, POWERPC)
new lsra version (i386 uses now reserved registers as temp)
spilled local vars use now the memory location of corresponding spilled arguments (MIPS, ALPHA, x86_64)
- Calling the class loader
- Running the main method
- $Id: cacao.c 2211 2005-04-04 10:39:36Z christian $
+ $Id: cacao.c 2297 2005-04-13 12:50:07Z christian $
*/
#define OPT_EAGER 33
#if defined(LSRA)
-# define OPT_LSRA 34
+#define OPT_LSRA 34
#endif /* defined(LSRA) */
#define OPT_JAR 35
#ifdef LSRA
case OPT_LSRA:
-/* #if defined(__I386__) || defined(__ALPHA__) || defined (__X86_64__) || defined(__POWERPC__) */
opt_lsra = true;
-/* #else */
-/* printf("LSRA not available for this architecture\n"); */
-/* opt_lsra = false; */
-/* #endif */
break;
#endif
Changes: Joseph Wenninger
Christian Thalinger
- $Id: codegen.c 2296 2005-04-12 22:57:45Z twisti $
+ $Id: codegen.c 2297 2005-04-13 12:50:07Z christian $
*/
M_LLD(var->regoff, REG_SP, 8 * (parentargs_base + pa));
} else { /* stack arg -> spilled */
- M_LLD(REG_ITMP1, REG_SP, 8 * (parentargs_base + pa));
- M_LST(REG_ITMP1, REG_SP, 8 * var->regoff);
+/* M_LLD(REG_ITMP1, REG_SP, 8 * (parentargs_base + pa)); */
+/* M_LST(REG_ITMP1, REG_SP, 8 * var->regoff); */
+ var->regoff = parentargs_base + pa;
}
}
M_DLD(var->regoff, REG_SP, 8 * (parentargs_base + pa) );
} else { /* stack-arg -> spilled */
- M_DLD(REG_FTMP1, REG_SP, 8 * (parentargs_base + pa));
- M_DST(REG_FTMP1, REG_SP, 8 * var->regoff);
+/* M_DLD(REG_FTMP1, REG_SP, 8 * (parentargs_base + pa)); */
+/* M_DST(REG_FTMP1, REG_SP, 8 * var->regoff); */
+ var->regoff = parentargs_base + pa;
}
}
}
}
}
}
+#if 1
+ {
+ s4 i;
+
+ if (m->flags & ACC_STATIC) {
+ /* shift iargs count if less than INT_ARG_CNT, or all */
+ for (i = (m->paramcount < (INT_ARG_CNT - 2)) ? m->paramcount : (INT_ARG_CNT - 2); i >= 0; i--) {
+ M_MOV(rd->argintregs[i], rd->argintregs[i + 2]);
+ M_FMOV(rd->argfltregs[i], rd->argfltregs[i + 2]);
+ }
+
+ /* put class into second argument register */
+ M_ALD(rd->argintregs[1], REG_PV, -8 * 8);
+ } else {
+ /* shift iargs count if less than INT_ARG_CNT, or all */
+ for (i = (m->paramcount < (INT_ARG_CNT - 1)) ? m->paramcount : (INT_ARG_CNT - 1); i >= 0; i--) {
+ M_MOV(rd->argintregs[i], rd->argintregs[i + 1]);
+ M_FMOV(rd->argfltregs[i], rd->argfltregs[i + 1]);
+ }
+ }
+ }
+#else
if (m->flags & ACC_STATIC) {
M_MOV(rd->argintregs[3], rd->argintregs[5]);
M_MOV(rd->argintregs[2], rd->argintregs[4]);
M_FMOV(rd->argfltregs[1], rd->argfltregs[2]);
M_FMOV(rd->argfltregs[0], rd->argfltregs[1]);
}
+#endif
/* put env into first argument register */
M_ALD(rd->argintregs[0], REG_PV, -4 * 8);
Authors: Andreas Krall
Reinhard Grafl
- $Id: codegen.h 2222 2005-04-05 17:38:04Z christian $
+ $Id: codegen.h 2297 2005-04-13 12:50:07Z christian $
*/
#include <ucontext.h>
-/* Macro for stack.c to set Argument Stackslots */
+/* SET_ARG_STACKSLOTS ***************************************************
+Macro for stack.c to set Argument Stackslots
+Sets the first call_argcount stackslots of curstack to varkind ARGVAR, if
+they to not have the SAVEDVAR flag set. According to the calling
+conventions these stackslots are assigned argument registers or memory
+locations
+
+--- in
+i,call_argcount: Number of arguments for this method
+curstack: instack of the method invokation
+
+--- uses
+i, copy
+
+--- out
+copy: Points to first stackslot after the parameters
+rd->argintreguse: max. number of used integer argument register so far
+rd->argfltreguse: max. number of used float argument register so far
+rd->ifmemuse: max. number of stackslots used for spilling parameters
+ so far
+************************************************************************/
#define SET_ARG_STACKSLOTS { \
s4 stacksize; /* Stackoffset for spilled arg */ \
- stacksize = (i < rd->intreg_argnum)? 0 : (i - rd->intreg_argnum); \
- copy = curstack; \
+ s4 iarg = 0; \
+ s4 farg = 0; \
\
+ stacksize = (i < rd->intreg_argnum)? 0 : (i - rd->intreg_argnum); \
if (rd->ifmemuse < stacksize) \
rd->ifmemuse = stacksize; \
\
+ copy = curstack; \
+ for (;i > 0; i--) { \
+ if (IS_FLT_DBL_TYPE(copy->type)) { \
+ if (farg == 0) farg = i; \
+ } else { \
+ if (iarg == 0) iarg = i; \
+ } \
+ copy = copy->prev; \
+ } \
+ \
+ if (rd->argintreguse < iarg) \
+ rd->argintreguse = iarg; \
+ if (rd->argfltreguse < farg) \
+ rd->argfltreguse = farg; \
+ \
+ i = call_argcount; \
+ copy = curstack; \
while (--i >= 0) { \
if (!(copy->flags & SAVEDVAR)) { \
copy->varnum = i; \
} \
copy = copy->prev; \
} \
- } \
+ }
/* additional functions and macros to generate code ***************************/
Changes:
- $Id: arch.h 2289 2005-04-12 21:57:30Z twisti $
+ $Id: arch.h 2297 2005-04-13 12:50:07Z christian $
*/
#define TRACE_ARGS_NUM 8
+#define REG_RES_CNT 3 /* number of reserved registers */
+
/* define architecture features ***********************************************/
#define CONDITIONAL_LOADCONST 1
-/* #define CONSECUTIVE_INTARGS */
-/* #define CONSECUTIVE_FLOATARGS */
-
#endif /* _ARCH_H */
Changes: Joseph Wenninger
- $Id: codegen.c 2291 2005-04-12 21:59:24Z twisti $
+ $Id: codegen.c 2297 2005-04-13 12:50:07Z christian $
*/
#include "vm/jit/codegen.inc"
#include "vm/jit/reg.inc"
#ifdef LSRA
+#ifdef LSRA_USES_REG_RES
+#include "vm/jit/i386/icmd_uses_reg_res.inc"
+#endif
#include "vm/jit/lsra.inc"
#endif
case ICMD_FLOAD: /* ... ==> ..., content of local variable */
/* op1 = local variable */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_FTMP1);
case ICMD_DLOAD: /* ... ==> ..., content of local variable */
/* op1 = local variable */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_FTMP1);
case ICMD_ISTORE: /* ..., value ==> ... */
case ICMD_ASTORE: /* op1 = local variable */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
if ((src->varkind == LOCALVAR) &&
case ICMD_LSTORE: /* ..., value ==> ... */
/* op1 = local variable */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
if ((src->varkind == LOCALVAR) &&
case ICMD_FSTORE: /* ..., value ==> ... */
/* op1 = local variable */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
if ((src->varkind == LOCALVAR) &&
case ICMD_DSTORE: /* ..., value ==> ... */
/* op1 = local variable */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
if ((src->varkind == LOCALVAR) &&
case ICMD_POP: /* ..., value ==> ... */
case ICMD_POP2: /* ..., value, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
break;
case ICMD_DUP: /* ..., a ==> ..., a, a */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
M_COPY(src, iptr->dst);
break;
case ICMD_DUP2: /* ..., a, b ==> ..., a, b, a, b */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
M_COPY(src, iptr->dst);
break;
case ICMD_DUP_X1: /* ..., a, b ==> ..., b, a, b */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
M_COPY(src, iptr->dst);
break;
case ICMD_DUP2_X1: /* ..., a, b, c ==> ..., b, c, a, b, c */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
M_COPY(src, iptr->dst);
break;
case ICMD_DUP2_X2: /* ..., a, b, c, d ==> ..., c, d, a, b, c, d */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
M_COPY(src, iptr->dst);
break;
case ICMD_SWAP: /* ..., a, b ==> ..., b, a */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
M_COPY(src, iptr->dst->prev);
/* integer operations *************************************************/
case ICMD_INEG: /* ..., value ==> ..., - value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LNEG: /* ..., value ==> ..., - value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_I2L: /* ..., value ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: YES */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_L2I: /* ..., value ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_INT2BYTE: /* ..., value ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_INT2CHAR: /* ..., value ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_INT2SHORT: /* ..., value ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IADD: /* ..., val1, val2 ==> ..., val1 + val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IADDCONST: /* ..., value ==> ..., value + constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LADD: /* ..., val1, val2 ==> ..., val1 + val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_LADDCONST: /* ..., value ==> ..., value + constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
/* else path can never happen? longs stay in memory! */
break;
case ICMD_ISUB: /* ..., val1, val2 ==> ..., val1 - val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_ISUBCONST: /* ..., value ==> ..., value + constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LSUB: /* ..., val1, val2 ==> ..., val1 - val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO */
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_LSUBCONST: /* ..., value ==> ..., value - constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO */
/* else path can never happen? longs stay in memory! */
break;
case ICMD_IMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO OUTPUT: EAX*/ /* EDX really not destroyed by IMUL? */
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IMULCONST: /* ..., value ==> ..., value * constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: EAX*/ /* EDX really not destroyed by IMUL? */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_LMULCONST: /* ..., value ==> ..., value * constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_IDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: EAX*/ /* Really uses EDX? */
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_IREM: /* ..., val1, val2 ==> ..., val1 % val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: EDX*/
case ICMD_IDIVPOW2: /* ..., value ==> ..., value >> constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
/* TODO: optimize for `/ 2' */
case ICMD_LDIVPOW2: /* ..., value ==> ..., value >> constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IREMPOW2: /* ..., value ==> ..., value % constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src, REG_ITMP1);
case ICMD_LREMPOW2: /* ..., value ==> ..., value % constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_ISHL: /* ..., val1, val2 ==> ..., val1 << val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: YES ECX: D|S|YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
i386_emit_ishift(cd, I386_SHL, src, iptr);
case ICMD_ISHLCONST: /* ..., value ==> ..., value << constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_ISHR: /* ..., val1, val2 ==> ..., val1 >> val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: YES ECX: D|S|YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
i386_emit_ishift(cd, I386_SAR, src, iptr);
case ICMD_ISHRCONST: /* ..., value ==> ..., value >> constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_IUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: YES ECX: D|S|YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
i386_emit_ishift(cd, I386_SHR, src, iptr);
case ICMD_IUSHRCONST: /* ..., value ==> ..., value >>> constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LSHL: /* ..., val1, val2 ==> ..., val1 << val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: S|YES ECX: YES EDX: S|YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
if (iptr->dst->flags & INMEMORY ){
case ICMD_LSHLCONST: /* ..., value ==> ..., value << constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LSHR: /* ..., val1, val2 ==> ..., val1 >> val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: S|YES ECX: YES S|EDX: YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
if (iptr->dst->flags & INMEMORY ){
case ICMD_LSHRCONST: /* ..., value ==> ..., value >> constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LUSHR: /* ..., val1, val2 ==> ..., val1 >>> val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: S|YES ECX: YES EDX: S|YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
if (iptr->dst->flags & INMEMORY ){
case ICMD_LUSHRCONST: /* ..., value ==> ..., value >>> constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_IAND: /* ..., val1, val2 ==> ..., val1 & val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IANDCONST: /* ..., value ==> ..., value & constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LAND: /* ..., val1, val2 ==> ..., val1 & val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_LANDCONST: /* ..., value ==> ..., value & constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_IOR: /* ..., val1, val2 ==> ..., val1 | val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IORCONST: /* ..., value ==> ..., value | constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LOR: /* ..., val1, val2 ==> ..., val1 | val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_LORCONST: /* ..., value ==> ..., value | constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_IXOR: /* ..., val1, val2 ==> ..., val1 ^ val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IXORCONST: /* ..., value ==> ..., value ^ constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_LXOR: /* ..., val1, val2 ==> ..., val1 ^ val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_LXORCONST: /* ..., value ==> ..., value ^ constant */
/* val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IINC: /* ..., value ==> ..., value + constant */
/* op1 = variable, val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
var = &(rd->locals[iptr->op1][TYPE_INT]);
#define FPU_SET_53BIT_MODE
#endif
case ICMD_FNEG: /* ..., value ==> ..., - value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_24BIT_MODE;
break;
case ICMD_DNEG: /* ..., value ==> ..., - value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_53BIT_MODE;
break;
case ICMD_FADD: /* ..., val1, val2 ==> ..., val1 + val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_24BIT_MODE;
break;
case ICMD_DADD: /* ..., val1, val2 ==> ..., val1 + val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_53BIT_MODE;
break;
case ICMD_FSUB: /* ..., val1, val2 ==> ..., val1 - val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_24BIT_MODE;
break;
case ICMD_DSUB: /* ..., val1, val2 ==> ..., val1 - val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_53BIT_MODE;
break;
case ICMD_FMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_24BIT_MODE;
break;
case ICMD_DMUL: /* ..., val1, val2 ==> ..., val1 * val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_53BIT_MODE;
break;
case ICMD_FDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_24BIT_MODE;
break;
case ICMD_DDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_53BIT_MODE;
break;
case ICMD_FREM: /* ..., val1, val2 ==> ..., val1 % val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_24BIT_MODE;
break;
case ICMD_DREM: /* ..., val1, val2 ==> ..., val1 % val2 */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
FPU_SET_53BIT_MODE;
case ICMD_I2F: /* ..., value ==> ..., (float) value */
case ICMD_I2D: /* ..., value ==> ..., (double) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: S|YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_FTMP1);
if (src->flags & INMEMORY) {
case ICMD_L2F: /* ..., value ==> ..., (float) value */
case ICMD_L2D: /* ..., value ==> ..., (double) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_FTMP1);
break;
case ICMD_F2I: /* ..., value ==> ..., (int) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: NO EDX: NO OUTPUT: EAX*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: D|YES ECX: NO EDX: NO OUTPUT: EAX*/
var_to_reg_flt(s1, src, REG_FTMP1);
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_D2I: /* ..., value ==> ..., (int) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: NO EDX: NO OUTPUT: EAX*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: D|YES ECX: NO EDX: NO OUTPUT: EAX*/
var_to_reg_flt(s1, src, REG_FTMP1);
d = reg_of_var(rd, iptr->dst, REG_NULL);
break;
case ICMD_F2L: /* ..., value ==> ..., (long) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: YES OUTPUT: REG_NULL*/
var_to_reg_flt(s1, src, REG_FTMP1);
break;
case ICMD_D2L: /* ..., value ==> ..., (long) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: YES OUTPUT: REG_NULL*/
var_to_reg_flt(s1, src, REG_FTMP1);
break;
case ICMD_F2D: /* ..., value ==> ..., (double) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
var_to_reg_flt(s1, src, REG_FTMP1);
break;
case ICMD_D2F: /* ..., value ==> ..., (float) value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
var_to_reg_flt(s1, src, REG_FTMP1);
case ICMD_FCMPL: /* ..., val1, val2 ==> ..., val1 fcmpl val2 */
case ICMD_DCMPL:
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
/* exchanged to skip fxch */
case ICMD_FCMPG: /* ..., val1, val2 ==> ..., val1 fcmpg val2 */
case ICMD_DCMPG:
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
/* exchanged to skip fxch */
/* memory operations **************************************************/
case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src, REG_ITMP1);
break;
case ICMD_AALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_FALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_DALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_CALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_SALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_BALOAD: /* ..., arrayref, index ==> ..., value */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
case ICMD_AASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
break;
case ICMD_IASTORECONST: /* ..., arrayref, index ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_LASTORECONST: /* ..., arrayref, index ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_AASTORECONST: /* ..., arrayref, index ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_BASTORECONST: /* ..., arrayref, index ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_CASTORECONST: /* ..., arrayref, index ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
break;
case ICMD_SASTORECONST: /* ..., arrayref, index ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
var_to_reg_int(s1, src->prev, REG_ITMP1);
case ICMD_PUTSTATIC: /* ..., value ==> ... */
/* op1 = type, val.a = field address */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
/* If the static fields' class is not yet initialized, we do it */
/* val = value (in current instruction) */
/* op1 = type, val.a = field address (in */
/* following NOP) */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: REG_NULL*/
/* If the static fields' class is not yet initialized, we do it */
case ICMD_GETSTATIC: /* ... ==> ..., value */
/* op1 = type, val.a = field address */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: S|YES OUTPUT: EAX*/
/* If the static fields' class is not yet initialized, we do it */
case ICMD_PUTFIELD: /* ..., objectref, value ==> ... */
/* op1 = type, val.a = field address */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
a = ((fieldinfo *) (iptr->val.a))->offset;
/* val = value (in current instruction) */
/* op1 = type, val.a = field address (in */
/* following NOP) */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
a = ((fieldinfo *) (iptr[1].val.a))->offset;
case ICMD_GETFIELD: /* .., objectref. ==> ..., value */
/* op1 = type, val.i = field offset */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: S|YES EDX: NO OUTPUT: REG_NULL*/
a = ((fieldinfo *) (iptr->val.a))->offset;
/* branch operations **************************************************/
case ICMD_ATHROW: /* ..., objectref ==> ... (, objectref) */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src, REG_ITMP1);
case ICMD_GOTO: /* ... ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
i386_jmp_imm(cd, 0);
case ICMD_JSR: /* ... ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
i386_call_imm(cd, 0);
case ICMD_RET: /* ... ==> ... */
/* op1 = local variable */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
var = &(rd->locals[iptr->op1][TYPE_ADR]);
case ICMD_IFNULL: /* ..., value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IFNONNULL: /* ..., value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IFEQ: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IFLT: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IFLE: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IFNE: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IFGT: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IFGE: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IF_LEQ: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IF_LLT: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IF_LLE: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IF_LNE: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IF_LGT: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IF_LGE: /* ..., value ==> ... */
/* op1 = target JavaVM pc, val.l = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_IF_ICMPEQ: /* ..., value, value ==> ... */
case ICMD_IF_ACMPEQ: /* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_LCMPEQ: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_ICMPNE: /* ..., value, value ==> ... */
case ICMD_IF_ACMPNE: /* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_LCMPNE: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_ICMPLT: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_LCMPLT: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_ICMPGT: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_LCMPGT: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_ICMPLE: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_LCMPLE: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_ICMPGE: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
case ICMD_IF_LCMPGE: /* ..., value, value ==> ... */
/* op1 = target JavaVM pc */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if ((src->flags & INMEMORY) && (src->prev->flags & INMEMORY)) {
/* (value xx 0) ? IFxx_ICONST : ELSE_ICONST */
case ICMD_ELSE_ICONST: /* handled by IFxx_ICONST */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
break;
case ICMD_IFEQ_ICONST: /* ..., value ==> ..., constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IFNE_ICONST: /* ..., value ==> ..., constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IFLT_ICONST: /* ..., value ==> ..., constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IFGE_ICONST: /* ..., value ==> ..., constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IFGT_ICONST: /* ..., value ==> ..., constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IFLE_ICONST: /* ..., value ==> ..., constant */
/* val.i = constant */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
d = reg_of_var(rd, iptr->dst, REG_NULL);
case ICMD_IRETURN: /* ..., retvalue ==> ... */
case ICMD_ARETURN:
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
var_to_reg_int(s1, src, REG_RESULT);
goto nowperformreturn;
case ICMD_LRETURN: /* ..., retvalue ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
case ICMD_FRETURN: /* ..., retvalue ==> ... */
case ICMD_DRETURN: /* ..., retvalue ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
var_to_reg_flt(s1, src, REG_FRESULT);
goto nowperformreturn;
case ICMD_RETURN: /* ... ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
nowperformreturn:
case ICMD_TABLESWITCH: /* ..., index ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
{
s4 i, l, *s4ptr;
case ICMD_LOOKUPSWITCH: /* ..., key ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
{
s4 i, l, val, *s4ptr;
case ICMD_BUILTIN3: /* ..., arg1, arg2, arg3 ==> ... */
/* op1 = return type, val.a = function pointer*/
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
s3 = 3;
goto gen_method;
case ICMD_BUILTIN2: /* ..., arg1, arg2 ==> ... */
/* op1 = return type, val.a = function pointer*/
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
s3 = 2;
goto gen_method;
case ICMD_BUILTIN1: /* ..., arg1 ==> ... */
/* op1 = return type, val.a = function pointer*/
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
s3 = 1;
goto gen_method;
case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ... */
/* op1 = arg count, val.a = method pointer */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
/* op1 = arg count, val.a = method pointer */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
case ICMD_INVOKEVIRTUAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
/* op1 = arg count, val.a = method pointer */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
case ICMD_INVOKEINTERFACE:/*.., objectref, [arg1, [arg2 ...]] ==> ... */
/* op1 = arg count, val.a = method pointer */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
s3 = iptr->op1;
/* op1: 0 == array, 1 == class */
/* val.a: (classinfo*) superclass */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: D|YES ECX: YES D|EDX: YES OUTPUT: REG_NULL*/
/* superclass is an interface:
*
break;
case ICMD_CHECKCAST: /* ..., objectref ==> ..., objectref */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
- /* EAX: YES ECX: YES EDX: YES OUTPUT: REG_NULL*/
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
+ /* EAX: YES ECX: I|YES EDX: I|YES OUTPUT: REG_NULL*/
/* op1: 0 == array, 1 == class */
/* val.a: (classinfo*) superclass */
break;
case ICMD_CHECKASIZE: /* ..., size ==> ..., size */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: NO ECX: NO EDX: NO OUTPUT: REG_NULL*/
if (src->flags & INMEMORY) {
break;
case ICMD_CHECKEXCEPTION: /* ... ==> ... */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: YES ECX: NO EDX: NO OUTPUT: REG_NULL*/
i386_test_reg_reg(cd, REG_RESULT, REG_RESULT);
case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref */
/* op1 = dimension, val.a = array descriptor */
- /* REG_RES Register usage: see lsra.inc icmd_uses_tmp */
+ /* REG_RES Register usage: see icmd_uses_reg_res.inc */
/* EAX: S|YES ECX: YES EDX: YES OUTPUT: EAX*/
/* check for negative sizes and copy sizes to stack if necessary */
Authors: Andreas Krall
Christian Thalinger
- $Id: codegen.h 2218 2005-04-05 15:26:35Z christian $
+ $Id: codegen.h 2297 2005-04-13 12:50:07Z christian $
*/
#include <ucontext.h>
-/* Macro for stack.c to set Argument Stackslots */
+#ifdef LSRA
+/* let LSRA allocate reserved registers (REG_ITMP[1|2|3]) */
+#define LSRA_USES_REG_RES
+#endif
+
+/* SET_ARG_STACKSLOTS ***************************************************
+Macro for stack.c to set Argument Stackslots
+
+Sets the first call_argcount stackslots of curstack to varkind ARGVAR, if
+they to not have the SAVEDVAR flag set. According to the calling
+conventions these stackslots are assigned argument registers or memory
+locations
+--- in
+i: Number of arguments for this method
+curstack: instack of the method invokation
+
+--- uses
+i, copy
+
+--- out
+copy: Points to first stackslot after the parameters
+rd->ifmemuse: max. number of stackslots used for spilling parameters
+ so far
+************************************************************************/
#define SET_ARG_STACKSLOTS { \
copy = curstack; \
if (i > rd->ifmemuse) \
} \
copy = copy->prev; \
} \
- } \
+ }
/* additional functions and macros to generate code ***************************/
Changes: Christian Thalinger
- $Id: jit.h 2181 2005-04-01 16:53:33Z edwin $
+ $Id: jit.h 2297 2005-04-13 12:50:07Z christian $
*/
#define SAVEDVAR 1 /* variable has to survive method invocations */
#define INMEMORY 2 /* variable stored in memory */
#define SAVEDTMP 4 /* temporary variable using a saved register */
+#define TMPARG 8 /* temporary variable using a argument register */
/* variable kinds */
Authors: Christian Ullrich
- $Id: lsra.h 2211 2005-04-04 10:39:36Z christian $
+ $Id: lsra.h 2297 2005-04-13 12:50:07Z christian $
*/
/* #define LSRA_SAVEDVAR */
/* #define LSRA_MEMORY */
/* #define LSRA_PRINTLIFETIMES */
-/* #define LSRA_EDX */
+/* #define LSRA_USES_REG_RES */ /* is now in i386/codegen.h */
/* #define LSRA_TESTLT */
/* #define LSRA_LEAF */
#define JOIN_DEST_STACK
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)<(b)?(b):(a))
-#if defined(LSRA_EDX)
-#define REG_RES_COUNT 3
-/* struct tmp_reg { */
-/* int eax; */
-/* int ecx; */
-/* int edx; */
-/* }; */
-
-extern int icmd_uses_tmp[256][REG_RES_COUNT+1];
-extern int lsra_reg_res[REG_RES_COUNT];
-#endif
-
struct _list {
int value;
struct _list *next;
};
struct lsradata {
-#if defined(LSRA_EDX)
- int reg_res_free[REG_RES_COUNT];
+#if defined(LSRA_USES_REG_RES)
+ int reg_res_free[REG_RES_CNT];
#endif
struct _list **succ; /* CFG successors*/
struct _list **pred; /* CFG predecessors */
Authors: Christian Ullrich
- $Id: lsra.inc 2211 2005-04-04 10:39:36Z christian $
+ $Id: lsra.inc 2297 2005-04-13 12:50:07Z christian $
*/
#include <stdio.h>
#ifdef LSRA_LEAF
if (m->isleafmethod)
#endif
- printf("LSRA Start for %s\n", name);
+ printf("LSRA Start for %s opt_from: %i opt_to: %i\n", name, opt_from, opt_to);
#ifndef LSRA_LEAF
- if (strcmp(name,"java/lang/ClassLoader$StaticData.<clinit>()V")==0) {
+ if (strcmp(name,"java/lang/ClassLoader.defaultGetSystemClassLoader()Ljava/lang/ClassLoader;")==0) {
printf("-------------------\n");
}
if (m->isleafmethod)
ls=DNEW(lsradata);
lsra_init(m, cd, id, ls);
+#if 0
+#if defined(LSRA_USES_REG_RES)
+ for (i=opt_from; i<=opt_to; i++) {
+ icmd_uses_reg_res[i][0]=S|D|YES;
+ icmd_uses_reg_res[i][1]=S|D|YES;
+ icmd_uses_reg_res[i][2]=S|D|YES;
+ icmd_uses_reg_res[i][3]=REG_NULL;
+ }
+#endif
+#endif
+
+
if (!lsra_setup(m, cd, rd, ls))
return false;
/* int i; */
for (alt1=alt=*active; alt != NULL; alt1=alt, alt=alt->next) {
- if (alt->lt->i_end >= lt->i_start) return;
+ if (alt->lt->i_end > lt->i_start) return;
if (alt == *active)
*active = (*active)->next;
else
stackptr dst;
instruction *iptr;
bool join_ret; /* for lsra_join* Macros */
-#if defined(LSRA_EDX)
- int v_index_min;
+#if defined(LSRA_USES_REG_RES)
+ int v_index_min_before_instruction;
+ int v_index_min[REG_RES_CNT];
- v_index_min = ls->v_index;
- for (i=0; i < REG_RES_COUNT; i++)
+ for (i=0; i < REG_RES_CNT; i++) {
ls->reg_res_free[i] = -1;
+ v_index_min[i] = ls->v_index;
+ }
#endif
src = m->basicblocks[b_index].instack;
src=(iptr-1)->dst;
else
src=m->basicblocks[b_index].instack;
-
+#if defined(LSRA_USES_REG_RES)
+ v_index_min_before_instruction = ls->v_index;
+#endif
#ifdef LSRA_DEBUG
/* printf("bb: %3i bcount: %3i iindex: %3i ilen: %3i opcode: %3i %s\n",b_index,m->basicblockcount,iindex,len,opcode,icmd_names[opcode]); */
/* lsra_dump_stack(src); */
/* pop 2 push 1 */
case ICMD_IADD:
- case ICMD_ISUB:
case ICMD_IMUL:
case ICMD_ISHL:
lsra_from_stack(ls, src->prev,b_index,iindex);
lsra_new_stack(ls,dst,b_index,iindex);
#ifdef JOIN_DEST_STACK
- lsra_join_3_stack(ls, dst, src, src->prev, JOIN_OP);
+ lsra_join_3_stack(ls, dst, src->prev, src, JOIN_OP);
#endif
break;
+ case ICMD_ISUB:
+ lsra_from_stack(ls, src, b_index, iindex);
+ lsra_from_stack(ls, src->prev,b_index,iindex);
+ lsra_new_stack(ls, dst, b_index, iindex);
+#ifdef JOIN_DEST_STACK
+ lsra_join_2_stack(ls, src, dst, JOIN_OP);
+#endif
+ break;
case ICMD_IDIV:
case ICMD_IREM:
case ICMD_D2I:
case ICMD_D2L:
case ICMD_D2F:
+
+ case ICMD_CHECKCAST:
lsra_from_stack(ls, src, b_index, iindex);
lsra_new_stack(ls, dst, b_index, iindex);
#ifdef JOIN_DEST_STACK
lsra_join_2_stack(ls, src, dst, JOIN_OP);
#endif
break;
- case ICMD_CHECKCAST:
case ICMD_ARRAYLENGTH:
case ICMD_INSTANCEOF:
panic("Missing ICMD code during register allocation");
} /* switch */
-#if defined(LSRA_EDX)
+#if defined(LSRA_USES_REG_RES)
+ if (opt_lsra)
{
- int length, maxlength;
- int index, reg_res;
+ int length, maxlength, j;
+ int index, reg_res,start_iindex;
struct stackslot * ss;
struct lifetime *n;
- for (reg_res = 2; reg_res < REG_RES_COUNT; reg_res++) {
+ for (j=0, reg_res = icmd_uses_reg_res[opcode][REG_RES_CNT]; j < REG_RES_CNT; j++, reg_res=(reg_res+1)%REG_RES_CNT) {
+ if (reg_res == -1) reg_res = EDX; /* patch because icmd_uses_reg_res [][REG_RES_CNT] ist defaulting to -1 */
maxlength = -1;
index = -1;
- if ((iindex == 0) || (icmd_uses_tmp[opcode][reg_res])) {
+ if ((iindex == 0) || (icmd_uses_reg_res[opcode][reg_res])) {
if (ls->reg_res_free[reg_res] != -1) {
/* reg_res is free from ls->reg_res_free[] til here (iindex) */
/* now search for the longest lifetime, which fits in this intervall */
/* and if found assign edx to it */
- for (i = (-v_index_min - 1); i < (-ls->v_index -1); i++) {
+ if (icmd_uses_reg_res[opcode][reg_res] & D) /* ICMD destroys REG_RES as destination operand */
+ start_iindex = iindex +1;
+ else
+ start_iindex = iindex;
+ for (i = (-v_index_min[reg_res] - 1); i < (-ls->v_index -1); i++) {
n = &(ls->lifetime[i]);
- if (!(n->flags & JOINING)) { /* do not assign reserved Regs to lifetimes not fully seen till now */
+ if (!(n->flags & (JOINING || JOIN_BB))) { /* do not assign reserved Regs to lifetimes not fully seen till now */
if ((n->type == TYPE_INT) || (n->type == TYPE_ADR)) {
if (n->savedvar == 0) {
if ((n->bb_last_use == n->bb_first_def) && (n->bb_last_use == ls->sorted_rev[b_index])) {
- if ((n->i_last_use <= ls->reg_res_free[reg_res]) && (n->i_first_def >= iindex)) {
+ if ((n->i_last_use <= ls->reg_res_free[reg_res]) && (n->i_first_def >= start_iindex)) {
length = n->i_last_use - n->i_first_def;
if (length > maxlength) {
}
}
}
- ls->reg_res_free[reg_res] = -1;
+ if (icmd_uses_reg_res[opcode][reg_res] & S) /* ICMD destroys REG_RES as source operand */
+ ls->reg_res_free[reg_res] = -1;
+ else
+ ls->reg_res_free[reg_res] = iindex;
if (index != -1) { /* there is a lifetime, which a reserved register can be assigned to */
#ifdef LSRA_DEBUG
}
ls->lifetime[index].type = -1; /* drop lifetime, no further processing required */
}
-
+
+ v_index_min[reg_res] = v_index_min_before_instruction;
} else
if (ls->reg_res_free[reg_res] == -1)
ls->reg_res_free[reg_res] = iindex;
- }
+ }
}
#endif
#endif
-#if defined(LSRA_EDX)
-
-#define NO 0 /* Register survives this ICMD */
-#define S 1 /* Register can not be an source operand */
-#define D 2 /* Register can not be an destination operand */
-#define YES 4 /* Register does not survive this ICMD */
-/* #define L 32 */
-/* #define D 16 */
-/* #define DP 8 */
-/* #define S 4 */
-/* #define SP 2 */
-/* #define SPP 1 */
-
-int lsra_reg_res[REG_RES_COUNT]={EAX, ECX, EDX};
-
-int icmd_uses_tmp[256][REG_RES_COUNT + 1] ={
-/*EAX, ECX, EDX, OUTPUT */
-{ NO, NO, NO, REG_NULL}, /* ICMD_NOP */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ACONST */
-{ NO, NO, NO, REG_NULL}, /* ICMD_NULLCHECKPOP */
-{ NO, NO, NO, REG_NULL}, /* ICMD_ICONST */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF4 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_IDIVPOW2 */
-{ YES, YES, NO, REG_NULL}, /* ICMD_LDIVPOW2 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF7 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF8 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_LCONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LCMPCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_FCONST */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF12 */
-{ YES, YES, YES, REG_NULL}, /* ICMD_ELSE_ICONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DCONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFEQ_ICONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFNE_ICONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFLT_ICONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFGE_ICONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFGT_ICONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFLE_ICONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ILOAD */
-{ NO, NO, NO, REG_NULL}, /* ICMD_LLOAD */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FLOAD */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DLOAD */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ALOAD */
-{ NO, NO, NO, REG_NULL}, /* ICMD_IADDCONST */
-{ NO, NO, NO, REG_NULL}, /* ICMD_ISUBCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_IMULCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_IANDCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_IORCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_IXORCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ISHLCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ISHRCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_IUSHRCONST */
-{ YES, YES, NO, REG_NULL}, /* ICMD_IREMPOW2 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_LADDCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_LSUBCONST */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_LMULCONST */
-{ NO, NO, NO, REG_NULL}, /* ICMD_LANDCONST */
-{ NO, NO, NO, REG_NULL}, /* ICMD_LORCONST */
-{ NO, NO, NO, REG_NULL}, /* ICMD_LXORCONST */
-{ YES, YES, NO, REG_NULL}, /* ICMD_LSHLCONST */
-{ YES, YES, NO, REG_NULL}, /* ICMD_LSHRCONST */
-{ YES, YES, NO, REG_NULL}, /* ICMD_LUSHRCONST */
-{ YES, YES, NO, REG_NULL}, /* ICMD_LREMPOW2 */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_IALOAD */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_LALOAD */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_FALOAD */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_DALOAD */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_AALOAD */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_BALOAD */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_CALOAD */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_SALOAD */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ISTORE */
-{ NO, NO, NO, REG_NULL}, /* ICMD_LSTORE */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FSTORE */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DSTORE */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ASTORE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LEQ */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LNE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LLT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LGE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LGT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LLE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LCMPEQ */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LCMPNE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LCMPLT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LCMPGE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LCMPGT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_LCMPLE */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF71 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF72 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF73 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF74 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF75 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF76 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF77 */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF78 */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_IASTORE */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_LASTORE */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_FASTORE */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_DASTORE */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_AASTORE */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_BASTORE */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_CASTORE */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_SASTORE */
-{ NO, NO, NO, REG_NULL}, /* ICMD_POP */
-{ NO, NO, NO, REG_NULL}, /* ICMD_POP2 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DUP */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DUP_X1 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DUP_X2 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DUP2 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DUP2_X1 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DUP2_X2 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_SWAP */
-{ S|YES, NO, NO, REG_NULL}, /* ICMD_IADD */
-{ S|YES, NO, NO, REG_NULL}, /* ICMD_LADD */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FADD */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DADD */
-{ S|YES, NO, NO, REG_NULL}, /* ICMD_ISUB */
-{ YES, NO, NO, REG_NULL}, /* ICMD_LSUB */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FSUB */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DSUB */
-{ S|YES, NO, NO, EAX}, /* ICMD_IMUL */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_LMUL */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FMUL */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DMUL */
-{ S|YES, S|YES, S|YES, EAX}, /* ICMD_IDIV */ /* Really uses EDX? */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LDIV */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FDIV */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DDIV */
-{ S|YES, S|YES, S|YES, EDX}, /* ICMD_IREM */ /* last checked */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LREM */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FREM */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DREM */
-{ YES, NO, NO, REG_NULL}, /* ICMD_INEG */
-{ YES, NO, NO, REG_NULL}, /* ICMD_LNEG */
-{ NO, NO, NO, REG_NULL}, /* ICMD_FNEG */
-{ NO, NO, NO, REG_NULL}, /* ICMD_DNEG */
-{ YES, S|YES, NO, REG_NULL}, /* ICMD_ISHL */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LSHL */
-{ YES, S|YES, NO, REG_NULL}, /* ICMD_ISHR */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LSHR */
-{ YES, S|YES, NO, REG_NULL}, /* ICMD_IUSHR */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LUSHR */
-{ S|YES, NO, NO, REG_NULL}, /* ICMD_IAND */
-{ YES, NO, NO, REG_NULL}, /* ICMD_LAND */
-{ S|YES, NO, NO, REG_NULL}, /* ICMD_IOR */
-{ YES, NO, NO, REG_NULL}, /* ICMD_LOR */
-{ S|YES, NO, NO, REG_NULL}, /* ICMD_IXOR */
-{ YES, NO, NO, REG_NULL}, /* ICMD_LXOR */
-{ NO, NO, NO, REG_NULL}, /* ICMD_IINC */
-{ YES, NO, YES, REG_NULL}, /* ICMD_I2L */
-{ YES, NO, NO, REG_NULL}, /* ICMD_I2F */
-{ YES, NO, NO, REG_NULL}, /* ICMD_I2D */
-{ YES, NO, NO, REG_NULL}, /* ICMD_L2I */
-{ NO, NO, NO, REG_NULL}, /* ICMD_L2F */
-{ NO, NO, NO, REG_NULL}, /* ICMD_L2D */
-{ YES, NO, NO, EAX}, /* ICMD_F2I */
-{ YES, NO, YES, REG_NULL}, /* ICMD_F2L */
-{ NO, NO, NO, REG_NULL}, /* ICMD_F2D */
-{ YES, NO, NO, EAX}, /* ICMD_D2I */
-{ YES, NO, YES, REG_NULL}, /* ICMD_D2L */
-{ NO, NO, NO, REG_NULL}, /* ICMD_D2F */
-{ YES, NO, NO, REG_NULL}, /* ICMD_INT2BYTE */
-{ YES, NO, NO, REG_NULL}, /* ICMD_INT2CHAR */
-{ YES, NO, NO, REG_NULL}, /* ICMD_INT2SHORT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LCMP */
-{ YES, NO, NO, REG_NULL}, /* ICMD_FCMPL */
-{ YES, NO, NO, REG_NULL}, /* ICMD_FCMPG */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DCMPL */
-{ YES, NO, NO, REG_NULL}, /* ICMD_DCMPG */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFEQ */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFNE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFLT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFGE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFGT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFLE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ICMPEQ */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ICMPNE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ICMPLT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ICMPGE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ICMPGT */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ICMPLE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ACMPEQ */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IF_ACMPNE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_GOTO */
-{ YES, YES, YES, REG_NULL}, /* ICMD_JSR */
-{ YES, YES, YES, REG_NULL}, /* ICMD_RET */
-{ YES, YES, YES, REG_NULL}, /* ICMD_TABLESWITCH */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LOOKUPSWITCH */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IRETURN */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LRETURN */
-{ YES, YES, YES, REG_NULL}, /* ICMD_FRETURN */
-{ YES, YES, YES, REG_NULL}, /* ICMD_DRETURN */
-{ YES, YES, YES, REG_NULL}, /* ICMD_ARETURN */
-{ YES, YES, YES, REG_NULL}, /* ICMD_RETURN */
-{ S|YES, S|YES, S|YES, EAX}, /* ICMD_GETSTATIC*/
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_PUTSTATIC*/
-{ YES, S|YES, NO, REG_NULL}, /* ICMD_GETFIELD */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_PUTFIELD */
-{ S|YES, YES, YES, EAX}, /* ICMD_INVOKEVIRTUAL */
-{ S|YES, YES, YES, EAX}, /* ICMD_INVOKESPECIAL */
-{ S|YES, YES, YES, EAX}, /* ICMD_INVOKESTATIC */
-{ S|YES, YES, YES, EAX}, /* ICMD_INVOKEINTERFACE*/
-{ NO, NO, NO, REG_NULL}, /* ICMD_CHECKASIZE */
-{ YES, YES, YES, REG_NULL}, /* ICMD_NEW */
-{ YES, YES, YES, REG_NULL}, /* ICMD_NEWARRAY */
-{ YES, YES, YES, REG_NULL}, /* ICMD_ANEWARRAY */
-{ YES, NO, NO, REG_NULL}, /* ICMD_ARRAYLENGTH */
-{ YES, YES, YES, REG_NULL}, /* ICMD_ATHROW */
-{ YES, YES, YES, REG_NULL}, /* ICMD_CHECKCAST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_INSTANCEOF */
-{ YES, YES, YES, REG_NULL}, /* ICMD_MONITORENTER */
-{ YES, YES, YES, REG_NULL}, /* ICMD_MONITOREXIT */
-{ NO, NO, NO, REG_NULL}, /* ICMD_UNDEF196 */
-{ S|YES, YES, YES, EAX}, /* ICMD_MULTIANEWARRAY */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFNULL */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IFNONNULL */
-{ YES, YES, YES, REG_NULL}, /* ICMD_UNDEF200 */
-{ YES, YES, YES, REG_NULL}, /* ICMD_UNDEF201 */
-{ YES, YES, YES, REG_NULL}, /* ICMD_UNDEF202 */
-{ YES, NO, NO, REG_NULL}, /* ICMD_CHECKEXCEPTION */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_IASTORECONST */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_LASTORECONST */
-{ S|YES, S|YES, YES, REG_NULL}, /* ICMD_FASTORECONST */
-{ S|YES, S|YES, YES, REG_NULL}, /* ICMD_DASTORECONST */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_AASTORECONST */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_BASTORECONST */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_CASTORECONST */
-{ S|YES, S|YES, NO, REG_NULL}, /* ICMD_SASTORECONST */
-{ S|YES, S|YES, S|YES, REG_NULL}, /* ICMD_PUTSTATICCONST */
-{ YES, NO, NO, REG_NULL}, /* ICMD_PUTFIELDCONST */
-{ YES, YES, YES, REG_NULL}, /* ICMD_IMULPOW2 */
-{ YES, YES, YES, REG_NULL}, /* ICMD_LMULPOW2 */
-{ NO, NO, NO, REG_NULL}, /* "UNDEF216" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF217" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF218" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF219" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF220", */
-{ NO, NO, NO, REG_NULL}, /* "UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF", */
-{ NO, NO, NO, REG_NULL}, /* "UNDEF226" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF227" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF228" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF229" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF230", */
-{ NO, NO, NO, REG_NULL}, /* "UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF", */
-{ NO, NO, NO, REG_NULL}, /* "UNDEF236" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF237" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF238" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF239" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF240", */
-{ NO, NO, NO, REG_NULL}, /* "UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF", */
-{ NO, NO, NO, REG_NULL}, /* "UNDEF246" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF247" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF248" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF249" */
-{ NO, NO, NO, REG_NULL}, /* ,"UNDEF250", */
-{ NO, NO, NO, REG_NULL}, /* ICMD_INLINE_START */
-{ NO, NO, NO, REG_NULL}, /* ICMD_INLINE_END */
-{ S|YES, YES, YES, EAX}, /* ICMD_BUILTIN3 */
-{ S|YES, YES, YES, EAX}, /* ICMD_BUILTIN2 */
-{ S|YES, YES, YES, EAX}, /* ICMD_BUILTIN1 */
-};
-#endif
-
-
/*
* These are local overrides for various environment variables in Emacs.
* Please do not remove this and leave it at the end of the file, where
This module generates MIPS machine code for a sequence of
intermediate code commands (ICMDs).
- $Id: codegen.c 2296 2005-04-12 22:57:45Z twisti $
+ $Id: codegen.c 2297 2005-04-13 12:50:07Z christian $
*/
M_LLD(var->regoff, REG_SP, 8 * (parentargs_base + pa));
} else { /* stack arg -> spilled */
- M_LLD(REG_ITMP1, REG_SP, 8 * (parentargs_base + pa));
- M_LST(REG_ITMP1, REG_SP, 8 * var->regoff);
+/* M_LLD(REG_ITMP1, REG_SP, 8 * (parentargs_base + pa)); */
+/* M_LST(REG_ITMP1, REG_SP, 8 * var->regoff); */
+ var->regoff = parentargs_base + pa;
}
}
M_DLD(var->regoff, REG_SP, 8 * (parentargs_base + pa));
} else { /* stack-arg -> spilled */
- M_DLD(REG_FTMP1, REG_SP, 8 * (parentargs_base + pa));
- M_DST(REG_FTMP1, REG_SP, 8 * var->regoff);
+/* M_DLD(REG_FTMP1, REG_SP, 8 * (parentargs_base + pa)); */
+/* M_DST(REG_FTMP1, REG_SP, 8 * var->regoff); */
+ var->regoff = parentargs_base + pa;
}
}
}
case ICMD_IRETURN: /* ..., retvalue ==> ... */
case ICMD_LRETURN:
case ICMD_ARETURN:
+ var_to_reg_int(s1, src, REG_RESULT);
+ M_INTMOVE(s1, REG_RESULT);
#if defined(USE_THREADS)
if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
s4 disp;
a = dseg_addaddress(cd, (void *) builtin_monitorexit);
M_ALD(REG_ITMP3, REG_PV, a);
+ M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 8);
M_JSR(REG_RA, REG_ITMP3);
- M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 8); /* delay slot */
+ M_LST(REG_RESULT, REG_SP, rd->maxmemuse * 8); /* delay slot */
+
disp = -(s4) ((u1 *) mcodeptr - cd->mcodebase);
M_LDA(REG_PV, REG_RA, disp);
+ M_LLD(REG_RESULT, REG_SP, rd->maxmemuse * 8);
}
#endif
- var_to_reg_int(s1, src, REG_RESULT);
- M_INTMOVE(s1, REG_RESULT);
goto nowperformreturn;
- case ICMD_FRETURN: /* ..., retvalue ==> ... */
- case ICMD_DRETURN:
+ case ICMD_FRETURN: /* ..., retvalue ==> ... */
+ case ICMD_DRETURN:
+ var_to_reg_flt(s1, src, REG_FRESULT);
+ {
+ int t = ((iptr->opc == ICMD_FRETURN) ? TYPE_FLT : TYPE_DBL);
+ M_TFLTMOVE(t, s1, REG_FRESULT);
+ }
#if defined(USE_THREADS)
if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
s4 disp;
a = dseg_addaddress(cd, (void *) builtin_monitorexit);
M_ALD(REG_ITMP3, REG_PV, a);
+ M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 8);
M_JSR(REG_RA, REG_ITMP3);
- M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 8); /* delay slot */
+ M_DST(REG_FRESULT, REG_SP, rd->maxmemuse * 8); /* delay slot */
+
disp = -(s4) ((u1 *) mcodeptr - cd->mcodebase);
M_LDA(REG_PV, REG_RA, disp);
+ M_DLD(REG_FRESULT, REG_SP, rd->maxmemuse * 8);
}
#endif
- var_to_reg_flt(s1, src, REG_FRESULT);
- {
- int t = ((iptr->opc == ICMD_FRETURN) ? TYPE_FLT : TYPE_DBL);
- M_TFLTMOVE(t, s1, REG_FRESULT);
- }
goto nowperformreturn;
case ICMD_RETURN: /* ... ==> ... */
Authors: Andreas Krall
- $Id: codegen.h 2222 2005-04-05 17:38:04Z christian $
+ $Id: codegen.h 2297 2005-04-13 12:50:07Z christian $
*/
/* Macro for stack.c to set Argument Stackslots */
+/* SET_ARG_STACKSLOTS ***************************************************
+Macro for stack.c to set Argument Stackslots
+
+Sets the first call_argcount stackslots of curstack to varkind ARGVAR, if
+they to not have the SAVEDVAR flag set. According to the calling
+conventions these stackslots are assigned argument registers or memory
+locations
+
+--- in
+i,call_argcount: Number of arguments for this method
+call_intargshift: Amount of shifted argument registers in case of native
+ method invokation or 0.
+curstack: instack of the method invokation
+
+--- uses
+i, copy
+
+--- out
+copy: Points to first stackslot after the parameters
+rd->argintreguse: max. number of used integer argument register so far
+rd->argfltreguse: max. number of used float argument register so far
+rd->ifmemuse: max. number of stackslots used for spilling parameters
+ so far
+************************************************************************/
+/* Todo ****************************************************************
+Change createnativestub in codegen.c to not destroy all not used argument
+registers in case of parametershift and change ICMD_xRETURN in codege.c
+Then delete #define DONT_USE_ARGREGS and delete the corresponding #ifdef
+part in reg.inc
+************************************************************************/
#define SET_ARG_STACKSLOTS { \
s4 stacksize; /* Stackoffset for spilled arg */ \
- stacksize = (i < rd->intreg_argnum)? 0 : (i - rd->intreg_argnum); \
- copy = curstack; \
+ s4 iarg = 0; \
+ s4 farg = 0; \
\
+ stacksize = (i < rd->intreg_argnum)? 0 : (i - rd->intreg_argnum); \
if (rd->ifmemuse < stacksize) \
rd->ifmemuse = stacksize; \
\
+ copy = curstack; \
+ for (;i > 0; i--) { \
+ if (IS_FLT_DBL_TYPE(copy->type)) { \
+ if (farg == 0) farg = i; \
+ } else { \
+ if (iarg == 0) iarg = i; \
+ } \
+ copy = copy->prev; \
+ } \
+ if (rd->argintreguse < iarg) \
+ rd->argintreguse = iarg; \
+ if (rd->argfltreguse < farg) \
+ rd->argfltreguse = farg; \
+ \
+ i = call_argcount; \
+ copy = curstack; \
while (--i >= 0) { \
if (!(copy->flags & SAVEDVAR)) { \
copy->varnum = i; \
} \
copy = copy->prev; \
} \
- } \
+ }
+
/* additional functions and macros to generate code ***************************/
Changes: Christian Thalinger
- $Id: asmpart.S 2206 2005-04-04 09:20:57Z twisti $
+ $Id: asmpart.S 2297 2005-04-13 12:50:07Z christian $
*/
mflr r0
stw r0,8(r1)
- stwu r1,-(26*8)(r1) /* keep stack 16-bytes aligned */
+ stwu r1,-(36*8)(r1) /* keep stack 16-bytes aligned */
stw r3,4*8(r1) /* save argument registers */
stw r4,5*8(r1) /* preserve linkage area (24 bytes) */
stfd fr11,22*8(r1)
stfd fr12,23*8(r1)
stfd fr13,24*8(r1)
-
+
+ stw r2,25*8(r1)
+ stw r16,26*8(r1)
+ stw r17,27*8(r1)
+ stw r18,28*8(r1)
+ stw r19,29*8(r1)
+ stw r20,30*8(r1)
+ stw r21,31*8(r1)
+ stw r22,32*8(r1)
+ stw r23,33*8(r1)
+
+
mr r3,itmp1
bl initialize_class
mr itmp1,r3 /* save return value in temp register */
lfd fr11,22*8(r1)
lfd fr12,23*8(r1)
lfd fr13,24*8(r1)
-
- lwz r0,(26*8)+8(r1)
+
+ lwz r2,25*8(r1)
+ lwz r16,26*8(r1)
+ lwz r17,27*8(r1)
+ lwz r18,28*8(r1)
+ lwz r19,29*8(r1)
+ lwz r20,30*8(r1)
+ lwz r21,31*8(r1)
+ lwz r22,32*8(r1)
+ lwz r23,33*8(r1)
+
+ lwz r0,(36*8)+8(r1)
mtlr r0
- addi r1,r1,(26*8)
+ addi r1,r1,(36*8)
mr. itmp1,itmp1 /* check for an exception */
beq L_initializererror
Changes: Christian Thalinger
- $Id: codegen.c 2228 2005-04-06 09:05:34Z twisti $
+ $Id: codegen.c 2297 2005-04-13 12:50:07Z christian $
*/
parentargs_base = rd->maxmemuse + savedregs_num;
-#ifdef USE_THREADS /* space to save argument of monitor_enter */
-
+#ifdef USE_THREADS /* space to save argument of monitor_enter */
+ /* and Return Values to survive monitor_exit */
if (checksync && (m->flags & ACC_SYNCHRONIZED))
- parentargs_base++;
+ parentargs_base+=3;
#endif
for (i = rd->savfltregcnt - 1; i >= rd->maxsavfltreguse; i--) {
p-=2; M_DST(rd->savfltregs[i], REG_SP, 4 * p);
}
+ /* take arguments out of register or stack frame */
+
+ {
+ int narg=0, niarg=0;
+ int arg, iarg;
+
+ for (p = 0, l = 0; p < m->paramcount; p++) {
+ arg = narg; iarg = niarg;
+ t = m->paramtypes[p];
+ var = &(rd->locals[l][t]);
+ l++, niarg++;
+ if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */
+ l++, niarg++;
+ if (var->type < 0)
+ continue;
+ if (IS_INT_LNG_TYPE(t)) { /* integer args */
+ if (iarg < INT_ARG_CNT -
+ (IS_2_WORD_TYPE(t)!=0)) { /* register arguments */
+ if (!(var->flags & INMEMORY)) { /* reg arg -> register */
+ M_TINTMOVE(t, rd->argintregs[iarg], var->regoff);
+
+ } else { /* reg arg -> spilled */
+ M_IST(rd->argintregs[iarg], REG_SP, 4 * var->regoff);
+ if (IS_2_WORD_TYPE(t))
+ M_IST(rd->secondregs[rd->argintregs[iarg]], REG_SP, 4 * var->regoff + 4);
+ }
+
+ } else { /* stack arguments */
+ pa = iarg + 6;
+ if (!(var->flags & INMEMORY)) { /* stack arg -> register */
+ M_ILD(var->regoff, REG_SP, 4 * (parentargs_base + pa));
+ if (IS_2_WORD_TYPE(t))
+ M_ILD(rd->secondregs[var->regoff], REG_SP, 4 * (parentargs_base + pa) + 4);
+
+ } else { /* stack arg -> spilled */
+ M_ILD(REG_ITMP1, REG_SP, 4 * (parentargs_base + pa));
+ M_IST(REG_ITMP1, REG_SP, 4 * var->regoff);
+ if (IS_2_WORD_TYPE(t)) {
+ M_ILD(REG_ITMP1, REG_SP, 4 * (parentargs_base + pa) + 4);
+ M_IST(REG_ITMP1, REG_SP, 4 * var->regoff + 4);
+ }
+ }
+ }
+
+ } else { /* floating args */
+ ++narg;
+ if (arg < FLT_ARG_CNT) { /* register arguments */
+ if (!(var->flags & INMEMORY)) { /* reg arg -> register */
+ M_FLTMOVE(rd->argfltregs[arg], var->regoff);
+
+ } else { /* reg arg -> spilled */
+ if (IS_2_WORD_TYPE(t))
+ M_DST(rd->argfltregs[arg], REG_SP, 4 * var->regoff);
+ else
+ M_FST(rd->argfltregs[arg], REG_SP, 4 * var->regoff);
+ }
+
+ } else { /* stack arguments */
+ pa = iarg + 6;
+ if (!(var->flags & INMEMORY)) { /* stack-arg -> register */
+ if (IS_2_WORD_TYPE(t))
+ M_DLD(var->regoff, REG_SP, 4 * (parentargs_base + pa));
+
+ else
+ M_FLD(var->regoff, REG_SP, 4 * (parentargs_base + pa));
+
+ } else { /* stack-arg -> spilled */
+ if (IS_2_WORD_TYPE(t)) {
+ M_DLD(REG_FTMP1, REG_SP, 4 * (parentargs_base + pa));
+ M_DST(REG_FTMP1, REG_SP, 4 * var->regoff);
+
+ } else {
+ M_FLD(REG_FTMP1, REG_SP, 4 * (parentargs_base + pa));
+ M_FST(REG_FTMP1, REG_SP, 4 * var->regoff);
+ }
+ }
+ }
+ }
+ } /* end for */
+ }
/* save monitorenter argument */
M_AST(rd->argintregs[0], REG_SP, 4 * rd->maxmemuse);
}
}
+
+ /* call monitorenter function */
+
+ if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
+ s4 func_enter = (m->flags & ACC_STATIC) ?
+ (s4) builtin_staticmonitorenter : (s4) builtin_monitorenter;
+ p = dseg_addaddress(cd, (void *) func_enter);
+ M_ALD(REG_ITMP3, REG_PV, p);
+ M_MTCTR(REG_ITMP3);
+ M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 4);
+ M_JSR;
+ }
#endif
+
/* copy argument registers to stack and call trace function with pointer
to arguments on stack.
*/
M_MTLR(REG_ITMP3);
}
- /* take arguments out of register or stack frame */
-
- {
- int narg=0, niarg=0;
- int arg, iarg;
-
- for (p = 0, l = 0; p < m->paramcount; p++) {
- arg = narg; iarg = niarg;
- t = m->paramtypes[p];
- var = &(rd->locals[l][t]);
- l++, niarg++;
- if (IS_2_WORD_TYPE(t)) /* increment local counter for 2 word types */
- l++, niarg++;
- if (var->type < 0)
- continue;
- if (IS_INT_LNG_TYPE(t)) { /* integer args */
- if (iarg < INT_ARG_CNT -
- (IS_2_WORD_TYPE(t)!=0)) { /* register arguments */
- if (!(var->flags & INMEMORY)) { /* reg arg -> register */
- M_TINTMOVE(t, rd->argintregs[iarg], var->regoff);
-
- } else { /* reg arg -> spilled */
- M_IST(rd->argintregs[iarg], REG_SP, 4 * var->regoff);
- if (IS_2_WORD_TYPE(t))
- M_IST(rd->secondregs[rd->argintregs[iarg]], REG_SP, 4 * var->regoff + 4);
- }
-
- } else { /* stack arguments */
- pa = iarg + 6;
- if (!(var->flags & INMEMORY)) { /* stack arg -> register */
- M_ILD(var->regoff, REG_SP, 4 * (parentargs_base + pa));
- if (IS_2_WORD_TYPE(t))
- M_ILD(rd->secondregs[var->regoff], REG_SP, 4 * (parentargs_base + pa) + 4);
-
- } else { /* stack arg -> spilled */
- M_ILD(REG_ITMP1, REG_SP, 4 * (parentargs_base + pa));
- M_IST(REG_ITMP1, REG_SP, 4 * var->regoff);
- if (IS_2_WORD_TYPE(t)) {
- M_ILD(REG_ITMP1, REG_SP, 4 * (parentargs_base + pa) + 4);
- M_IST(REG_ITMP1, REG_SP, 4 * var->regoff + 4);
- }
- }
- }
-
- } else { /* floating args */
- ++narg;
- if (arg < FLT_ARG_CNT) { /* register arguments */
- if (!(var->flags & INMEMORY)) { /* reg arg -> register */
- M_FLTMOVE(rd->argfltregs[arg], var->regoff);
-
- } else { /* reg arg -> spilled */
- if (IS_2_WORD_TYPE(t))
- M_DST(rd->argfltregs[arg], REG_SP, 4 * var->regoff);
- else
- M_FST(rd->argfltregs[arg], REG_SP, 4 * var->regoff);
- }
-
- } else { /* stack arguments */
- pa = iarg + 6;
- if (!(var->flags & INMEMORY)) { /* stack-arg -> register */
- if (IS_2_WORD_TYPE(t))
- M_DLD(var->regoff, REG_SP, 4 * (parentargs_base + pa));
-
- else
- M_FLD(var->regoff, REG_SP, 4 * (parentargs_base + pa));
- } else { /* stack-arg -> spilled */
- if (IS_2_WORD_TYPE(t)) {
- M_DLD(REG_FTMP1, REG_SP, 4 * (parentargs_base + pa));
- M_DST(REG_FTMP1, REG_SP, 4 * var->regoff);
-
- } else {
- M_FLD(REG_FTMP1, REG_SP, 4 * (parentargs_base + pa));
- M_FST(REG_FTMP1, REG_SP, 4 * var->regoff);
- }
- }
- }
- }
- } /* end for */
- }
- /* call monitorenter function */
-#if defined(USE_THREADS)
- if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
- s4 func_enter = (m->flags & ACC_STATIC) ?
- (s4) builtin_staticmonitorenter : (s4) builtin_monitorenter;
- p = dseg_addaddress(cd, (void *) func_enter);
- M_ALD(REG_ITMP3, REG_PV, p);
- M_MTCTR(REG_ITMP3);
- M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 4);
- M_JSR;
- }
-#endif
}
/* end of header generation */
case ICMD_IRETURN: /* ..., retvalue ==> ... */
case ICMD_LRETURN:
case ICMD_ARETURN:
-
- case ICMD_FRETURN: /* ..., retvalue ==> ... */
- case ICMD_DRETURN:
-
- case ICMD_RETURN: /* ... ==> ... */
-
-#if defined(USE_THREADS)
- if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
- a = dseg_addaddress(cd, (void *) (builtin_monitorexit));
- M_ALD(REG_ITMP3, REG_PV, a);
- M_MTCTR(REG_ITMP3);
- M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 4);
- M_JSR;
- }
-#endif
- switch (iptr->opc) {
- case ICMD_IRETURN:
- case ICMD_LRETURN:
- case ICMD_ARETURN:
var_to_reg_int(s1, src, REG_RESULT);
M_TINTMOVE(src->type, s1, REG_RESULT);
goto nowperformreturn;
- case ICMD_FRETURN:
- case ICMD_DRETURN:
+ case ICMD_FRETURN: /* ..., retvalue ==> ... */
+ case ICMD_DRETURN:
var_to_reg_flt(s1, src, REG_FRESULT);
M_FLTMOVE(s1, REG_FRESULT);
goto nowperformreturn;
- }
+
+ case ICMD_RETURN: /* ... ==> ... */
+
+
nowperformreturn:
{
s4 i, p;
p = parentargs_base;
-
- /* restore return address */
-
- if (!m->isleafmethod) {
- M_ALD(REG_ITMP3, REG_SP, 4 * p + 8);
- M_MTLR(REG_ITMP3);
- }
-
- /* restore saved registers */
-
- for (i = rd->savintregcnt - 1; i >= rd->maxsavintreguse; i--) {
- p--; M_ILD(rd->savintregs[i], REG_SP, 4 * p);
- }
- for (i = rd->savfltregcnt - 1; i >= rd->maxsavfltreguse; i--) {
- p -= 2; M_DLD(rd->savfltregs[i], REG_SP, 4 * p);
- }
-
- /* deallocate stack */
-
- if (parentargs_base) {
- M_LDA(REG_SP, REG_SP, parentargs_base*4);
- }
-
/* call trace function */
if (runverbose) {
M_LDA(REG_SP, REG_SP, 10 * 8);
M_MTLR(REG_ITMP3);
}
+
+#if defined(USE_THREADS)
+ if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
+ /* we need to save the proper return value */
+ switch (iptr->opc) {
+ case ICMD_IRETURN:
+ case ICMD_ARETURN:
+ M_IST(REG_RESULT , REG_SP, rd->maxmemuse * 4 + 4);
+ case ICMD_LRETURN:
+ M_IST(REG_RESULT2, REG_SP, rd->maxmemuse * 4 + 8);
+ break;
+ case ICMD_FRETURN:
+ M_FST(REG_FRESULT, REG_SP, rd->maxmemuse * 4 + 4);
+ break;
+ case ICMD_DRETURN:
+ M_DST(REG_FRESULT, REG_SP, rd->maxmemuse * 4 + 4);
+ break;
+ }
+
+ a = dseg_addaddress(cd, (void *) (builtin_monitorexit));
+ M_ALD(REG_ITMP3, REG_PV, a);
+ M_MTCTR(REG_ITMP3);
+ M_ALD(rd->argintregs[0], REG_SP, rd->maxmemuse * 4);
+ M_JSR;
+
+ /* and now restore the proper return value */
+ switch (iptr->opc) {
+ case ICMD_IRETURN:
+ case ICMD_ARETURN:
+ M_ILD(REG_RESULT , REG_SP, rd->maxmemuse * 4 + 4);
+ case ICMD_LRETURN:
+ M_ILD(REG_RESULT2, REG_SP, rd->maxmemuse * 4 + 8);
+ break;
+ case ICMD_FRETURN:
+ M_FLD(REG_FRESULT, REG_SP, rd->maxmemuse * 4 + 4);
+ break;
+ case ICMD_DRETURN:
+ M_DLD(REG_FRESULT, REG_SP, rd->maxmemuse * 4 + 4);
+ break;
+ }
+ }
+#endif
+
+ /* restore return address */
+
+ if (!m->isleafmethod) {
+ M_ALD(REG_ITMP3, REG_SP, 4 * p + 8);
+ M_MTLR(REG_ITMP3);
+ }
+
+ /* restore saved registers */
+
+ for (i = rd->savintregcnt - 1; i >= rd->maxsavintreguse; i--) {
+ p--; M_ILD(rd->savintregs[i], REG_SP, 4 * p);
+ }
+ for (i = rd->savfltregcnt - 1; i >= rd->maxsavfltreguse; i--) {
+ p -= 2; M_DLD(rd->savfltregs[i], REG_SP, 4 * p);
+ }
+
+ /* deallocate stack */
+
+ if (parentargs_base) {
+ M_LDA(REG_SP, REG_SP, parentargs_base*4);
+ }
+
+
M_RET;
ALIGNCODENOP;
registerdata *rd;
t_inlining_globals *id;
s4 dumpsize;
+ s4 i;
/* mark start of dump memory area */
M_MFLR(REG_ITMP1);
M_AST(REG_ITMP1, REG_SP, 8); /* store return address */
- M_STWU(REG_SP, REG_SP, -64); /* build up stackframe */
+ /* Build up new Stackframe for native call */
+ stackframesize = 24; /* 24 Bytes Linkage Area */
+ stackframesize += (m->flags & ACC_STATIC) ? 8 : 4; /*1 or 2 additional int parameters */
+ for (i = 0; i < m->paramcount; i++) {
+ stackframesize += IS_2_WORD_TYPE(m->paramtypes[i]) ? 8 : 4;
+ }
+
+ if (stackframesize < (24+32)) { /* 24 Byte Linkage Area + 32 Bytes minimum Argument area */
+ stackframesize = 24+32;
+ }
+ stackframesize = stackframesize + 8; /* Reserve Space to store Result registers */
+ M_STWU(REG_SP, REG_SP, -stackframesize); /* build up stackframe */
/* if function is static, check for initialized */
/* M_MTLR(REG_ITMP3); */
}
- /* save argument registers on stack -- if we have to */
- if ((m->flags & ACC_STATIC && m->paramcount > (INT_ARG_CNT - 2)) ||
- m->paramcount > (INT_ARG_CNT - 1)) {
- s4 i;
- u1 *tptr;
- s4 paramshiftcnt = (m->flags & ACC_STATIC) ? 2 : 1;
- s4 stackparamcnt = (m->paramcount > INT_ARG_CNT) ? m->paramcount - INT_ARG_CNT : 0;
-
- /* calculate stackframe size for native function */
- tptr = m->paramtypes;
- for (i = INT_ARG_CNT; i < m->paramcount; i++) {
- stackframesize += IS_2_WORD_TYPE(*tptr++) ? 8 : 4;
+ /* save argument registers on stack -- if we have to */
+ /* and copy spilled argument regs from old stack to the new one */
+ {
+ s4 farg = 0;
+ s4 iarg;
+ s4 paramsize;
+ s4 stack_off;
+ s4 shift;
+
+ stack_off = 0;
+ shift = (m->flags & ACC_STATIC) ? 2 : 1;
+ for (i = 0; i < m->paramcount; i++) {
+ paramsize = IS_2_WORD_TYPE(m->paramtypes[i]) ? 2 : 1;
+ if (IS_FLT_DBL_TYPE(m->paramtypes[i])) {
+ farg++;
+ if (farg >= FLT_ARG_CNT) { /* spilled float arg -> copy from old stack */
+ if (paramsize == 1) { /* float arg */
+ M_FLD(REG_FTMP1, REG_SP, stackframesize + 24 + 4 * stack_off);
+ M_FST(REG_FTMP1, REG_SP, 24 + 4*(shift + stack_off));
+ } else { /* double arg */
+ M_DLD(REG_FTMP1, REG_SP, stackframesize + 24 + 4 * stack_off);
+ M_DST(REG_FTMP1, REG_SP, 24 + 4*(shift + stack_off));
+ }
+ }
+ } else { /* int arg */
+ iarg = stack_off; /* int register are not consecutive like the float*/
+ if (iarg + paramsize -1 < INT_ARG_CNT) {
+ if ( iarg + paramsize -1 == INT_ARG_CNT - shift ) {
+ /* int arg reg(s) spilled through shift to stack */
+ M_IST( rd->argintregs[iarg], REG_SP, 24 + 4 * (shift + stack_off));
+ if (paramsize == 2) /* spill secondreg, too */
+ M_IST( rd->argintregs[iarg+1], REG_SP, 24 + 4 * (shift + stack_off) + 4);
+ }
+ } else { /* already spilled int arg -> copy from old stack */
+ M_ILD(REG_ITMP1, REG_SP, stackframesize + 24 + 4 * stack_off);
+ M_IST(REG_ITMP1, REG_SP, 24 + 4 * (shift + stack_off));
+ if (paramsize == 2) { /* long arg -> copy second half, too */
+ M_ILD(REG_ITMP1, REG_SP, stackframesize + 24 + 4 * stack_off + 4);
+ M_IST(REG_ITMP1, REG_SP, 24 + 4*(shift + stack_off) + 4);
+ }
+ }
+ }
+ stack_off += paramsize;
}
- stackframesize += paramshiftcnt;
-
- M_LDA(REG_SP, REG_SP, -stackframesize * 8);
-
- for (i = 0; i < stackparamcnt; i++) {
- M_ILD(REG_ITMP1, REG_SP, stackparamcnt * 8 + 24 + i * 4);
- M_IST(REG_ITMP1, REG_SP, (paramshiftcnt + i) * 4);
-
- if (IS_2_WORD_TYPE(m->paramtypes[i])) {
- M_ILD(REG_ITMP1, REG_SP, stackparamcnt * 8 + 24 + i * 4 + 4);
- M_IST(REG_ITMP1, REG_SP, (paramshiftcnt + i) * 4);
+ /* now shift integer argument registers */
+ for (i = m->paramcount - 1; i >=0; i--) {
+ paramsize = IS_2_WORD_TYPE(m->paramtypes[i]) ? 2 : 1;
+ stack_off -= paramsize;
+ if (IS_INT_LNG_TYPE(m->paramtypes[i])) {
+ iarg = stack_off;
+ if ( iarg + paramsize -1 < INT_ARG_CNT - shift ) {
+ /* shift integer arg */
+ if (paramsize == 2)
+ M_MOV(rd->argintregs[iarg+1], rd->argintregs[iarg + shift + 1]);
+ M_MOV(rd->argintregs[iarg], rd->argintregs[iarg + shift]);
+ } /* else are already spilled to memory */
}
}
-
-
}
- if (m->flags & ACC_STATIC) {
- M_MOV(rd->argintregs[5], rd->argintregs[7]);
- M_MOV(rd->argintregs[4], rd->argintregs[6]);
- M_MOV(rd->argintregs[3], rd->argintregs[5]);
- M_MOV(rd->argintregs[2], rd->argintregs[4]);
- M_MOV(rd->argintregs[1], rd->argintregs[3]);
- M_MOV(rd->argintregs[0], rd->argintregs[2]);
-
+ if (m->flags & ACC_STATIC)
/* put class into second argument register */
M_ALD(rd->argintregs[1], REG_PV, -8 * 4);
- } else {
- M_MOV(rd->argintregs[6], rd->argintregs[7]);
- M_MOV(rd->argintregs[5], rd->argintregs[6]);
- M_MOV(rd->argintregs[4], rd->argintregs[5]);
- M_MOV(rd->argintregs[3], rd->argintregs[4]);
- M_MOV(rd->argintregs[2], rd->argintregs[3]);
- M_MOV(rd->argintregs[1], rd->argintregs[2]);
- M_MOV(rd->argintregs[0], rd->argintregs[1]);
- }
-
/* put env into first argument register */
M_ALD(rd->argintregs[0], REG_PV, -4 * 4);
M_MFLR(REG_ITMP1);
M_LDA(REG_PV, REG_ITMP1, disp); /* recompute pv from ra */
- /* remove stackframe if there is one */
- if (stackframesize) {
- M_LDA(REG_SP, REG_SP, stackframesize * 8);
- }
-
/* 20 instructions */
if (runverbose) {
M_MFLR(REG_ITMP3);
#if defined(USE_THREADS) && defined(NATIVE_THREADS)
if (IS_FLT_DBL_TYPE(m->returntype))
if (IS_2_WORD_TYPE(m->returntype))
- M_DST(REG_FRESULT, REG_SP, 56);
+ M_DST(REG_FRESULT, REG_SP, stackframesize-8 /*56*/);
else
- M_FST(REG_FRESULT, REG_SP, 56);
+ M_FST(REG_FRESULT, REG_SP, stackframesize-8 /*56*/);
else {
- M_IST(REG_RESULT, REG_SP, 56);
+ M_IST(REG_RESULT, REG_SP, stackframesize-8 /*56*/);
if (IS_2_WORD_TYPE(m->returntype))
- M_IST(REG_RESULT2, REG_SP, 60);
+ M_IST(REG_RESULT2, REG_SP, stackframesize-4 /* 60*/);
}
M_ALD(REG_ITMP2, REG_PV, -2 * 4); /* builtin_get_exceptionptrptr */
if (IS_FLT_DBL_TYPE(m->returntype))
if (IS_2_WORD_TYPE(m->returntype))
- M_DLD(REG_FRESULT, REG_SP, 56);
+ M_DLD(REG_FRESULT, REG_SP, stackframesize-8 /*56*/);
else
- M_FLD(REG_FRESULT, REG_SP, 56);
+ M_FLD(REG_FRESULT, REG_SP, stackframesize-8 /*56*/);
else {
- M_ILD(REG_RESULT, REG_SP, 56);
+ M_ILD(REG_RESULT, REG_SP, stackframesize-8 /*56*/);
if (IS_2_WORD_TYPE(m->returntype))
- M_ILD(REG_RESULT2, REG_SP, 60);
+ M_ILD(REG_RESULT2, REG_SP, stackframesize-4 /*60*/);
}
#else
M_ALD(REG_ITMP2, REG_PV, -2 * 4); /* get address of exceptionptr */
M_TST(REG_ITMP1_XPTR);
M_BNE(4); /* if no exception then return */
- M_ALD(REG_ITMP1, REG_SP, 64 + 8); /* load return address */
+ M_ALD(REG_ITMP1, REG_SP, stackframesize + 8); /* load return address */
M_MTLR(REG_ITMP1);
- M_LDA(REG_SP, REG_SP, 64); /* remove stackframe */
+ M_LDA(REG_SP, REG_SP, stackframesize); /* remove stackframe */
M_RET;
M_CLR(REG_ITMP3);
M_AST(REG_ITMP3, REG_ITMP2, 0); /* store NULL into exceptionptr */
- M_ALD(REG_ITMP2, REG_SP, 64 + 8); /* load return address */
+ M_ALD(REG_ITMP2, REG_SP, stackframesize + 8); /* load return address */
M_MTLR(REG_ITMP2);
- M_LDA(REG_SP, REG_SP, 64); /* remove stackframe */
+ M_LDA(REG_SP, REG_SP, stackframesize); /* remove stackframe */
M_IADD_IMM(REG_ITMP2, -4, REG_ITMP2_XPC); /* fault address */
Authors: Andreas Krall
Stefan Ring
- $Id: codegen.h 2226 2005-04-05 22:52:46Z christian $
+ $Id: codegen.h 2297 2005-04-13 12:50:07Z christian $
*/
#include "vm/global.h"
#include "vm/jit/reg.h"
-/* Macro for stack.c to set Argument Stackslots */
+/* SET_ARG_STACKSLOTS ***************************************************
+Macro for stack.c to set Argument Stackslots
+
+Sets the first call_argcount stackslots of curstack to varkind ARGVAR, if
+they to not have the SAVEDVAR flag set. According to the calling
+conventions these stackslots are assigned argument registers or memory
+locations
+
+--- in
+i,call_argcount: Number of arguments for this method
+curstack: instack of the method invokation
+call_returntype: return type
+
+--- uses
+i, copy
+
+--- out
+copy: Points to first stackslot after the parameters
+rd->argintreguse: max. number of used integer argument register so far
+rd->argfltreguse: max. number of used float argument register so far
+rd->ifmemuse: max. number of stackslots used for spilling parameters
+ so far
+************************************************************************/
#define SET_ARG_STACKSLOTS { \
s4 iarg = 0; \
s4 farg = 0; \
+ s4 iarg_max = 0; \
s4 stacksize; \
\
stacksize = 6; \
\
copy = curstack; \
- while (--i >= 0) { \
+ for (;i > 0; i--) { \
stacksize += (IS_2_WORD_TYPE(copy->type)) ? 2 : 1; \
if (IS_FLT_DBL_TYPE(copy->type)) \
farg++; \
copy = copy->prev; \
} \
+ if (rd->argfltreguse < farg) \
+ rd->argfltreguse = farg; \
+ \
+ /* REG_FRESULT == FLOAT ARGUMENT REGISTER 0 */ \
+ if (IS_FLT_DBL_TYPE(call_returntype)) \
+ if (rd->argfltreguse < 1) \
+ rd->argfltreguse = 1; \
\
if (stacksize > rd->ifmemuse) \
rd->ifmemuse = stacksize; \
} \
} else { \
iarg = stacksize - 6; \
+ if (iarg+(IS_2_WORD_TYPE(copy->type) ? 2 : 1) > iarg_max) \
+ iarg_max = iarg+(IS_2_WORD_TYPE(copy->type) ? 2 : 1); \
+ \
if (!(copy->flags & SAVEDVAR)) { \
copy->varnum = i; \
copy->varkind = ARGVAR; \
} \
copy = copy->prev; \
} \
+ if (rd->argintreguse < iarg_max) \
+ rd->argintreguse = iarg_max; \
+ if (IS_INT_LNG_TYPE(call_returntype)) { \
+ /* REG_RESULT == INTEGER ARGUMENT REGISTER 0 */ \
+ /* REG_RESULT2 == INTEGER ARGUMENT REGISTER 1 */ \
+ if (IS_2_WORD_TYPE(call_returntype)) { \
+ if (rd->argintreguse < 2) \
+ rd->argintreguse = 2; \
+ } else { \
+ if (rd->argintreguse < 1) \
+ rd->argintreguse = 1; \
+ } \
+ } \
}
/* additional functions and macros to generate code ***************************/
Authors: Christian Thalinger
- $Id: reg.h 2222 2005-04-05 17:38:04Z christian $
+ $Id: reg.h 2297 2005-04-13 12:50:07Z christian $
*/
int maxsavadrreguse; /* max used saved address register count */
int freetmpadrtop; /* free scratch address register count */
int freesavadrtop; /* free saved address register count */
-#if defined(USE_UNUSED_ARGUMENT_REGISTERS)
int ifargadrregcnt; /* iface argument address register count */
-#endif
+ int freeargadrtop; /* free argument address register count */
#endif
#ifdef USETWOREGS
int ifsavintregcnt; /* iface saved integer register count */
int iftmpfltregcnt; /* iface scratch float register count */
int ifsavfltregcnt; /* iface saved float register count */
-#if defined(USE_UNUSED_ARGUMENT_REGISTERS)
int ifargintregcnt; /* iface argument float register count */
int ifargfltregcnt; /* iface argument float register count */
-#endif
+ int freearginttop; /* free argument integer register count */
+ int freeargflttop; /* free argument float register count */
int argintreguse; /* used argument integer register count */
int tmpintreguse; /* used scratch integer register count */
Changes: Stefan Ring
Christian Thalinger
- $Id: reg.inc 2263 2005-04-11 09:56:52Z twisti $
+ $Id: reg.inc 2297 2005-04-13 12:50:07Z christian $
*/
#include "arch.h"
#include "mm/memory.h"
-#include "vm/method.h"
-#include "vm/resolve.h"
#include "vm/jit/reg.h"
v[0][TYPE_ADR].flags = 0;
}
#ifdef SPECIALMEMUSE
- rd->ifmemuse = 6;
+ rd->ifmemuse = 6 + 8; /* 6*4=24 byte linkage area + 8*4=32 byte minimum parameter Area */
#else
rd->ifmemuse = 0; /* init to zero -> analyse_stack will set it to a higher value, if appropriate */
#endif
+#if defined(HAS_ADDRESS_REGISTER_FILE)
+ rd->argadrreguse = 0;
+#endif /* defined(HAS_ADDRESS_REGISTER_FILE) */
+ rd->argintreguse = 0;/*Set argintreguse to rd->intreg_argnum to not use unused arguments as temp register*/
+ rd->argfltreguse = 0;/*Set argfltreguse to rd->fltreg_argnum to not use unused arguments as temp register*/
}
interface_regalloc(m, cd, rd);
allocate_scratch_registers(m, rd);
local_regalloc(m, cd, rd);
+#ifdef INVOKE_NEW_DEBUG
+ if (compileverbose) {
+ printf("maxmemuse by reg.inc: %3i\n",rd->maxmemuse);
+ }
+#endif
}
int temp;
if (compileverbose) {
+printf("analyse: argintru %3i argfltru %3i ifmemu %3i\n", rd->argintreguse, rd->argfltreguse, rd->ifmemuse);
temp = rd->ifmemuse;
#if !defined(SPECIALMEMUSE)
/* For this to work properly the integer argument register count must be */
}
#endif
if (compileverbose) {
- printf("ifmemuse by reg.inc: %3i,%3i by stack.c: %3i\n",rd->ifmemuse, rd->maxmemuse,temp);
+ printf("ifmemuse by reg.inc: %3i by stack.c: %3i\n",rd->ifmemuse,temp);
if (temp != rd->ifmemuse)
printf("Warning: Difference in ifmemuse calculated the old way and the new way\n");
}
rd->iftmpadrregcnt = rd->tmpadrregcnt;
rd->ifsavadrregcnt = rd->savadrregcnt;
#endif
-
+ rd->ifargintregcnt = rd->argintreguse;
+ rd->ifargfltregcnt = rd->argfltreguse;
for (s = 0; s < cd->maxstack; s++) {
intalloc = -1; fltalloc = -1;
saved = (rd->interfaces[s][TYPE_INT].flags |
if (!saved) {
#ifdef HAS_ADDRESS_REGISTER_FILE
if (t == TYPE_ADR) {
+#if defined(HAS_ADDRESS_REGISTER_FILE)
+ if (!m->isleafmethod &&(rd->ifargadrregcnt < rd->adrreg_argnum)) {
+ v->regoff = rd->argadrregs[rd->ifargadrregcnt++];
+ } else
+#endif
if (rd->iftmpadrregcnt > 0) {
rd->iftmpadrregcnt--;
v->regoff = rd->tmpadrregs[rd->iftmpadrregcnt];
v->flags |= rd->interfaces[s][fltalloc].flags & INMEMORY;
v->regoff = rd->interfaces[s][fltalloc].regoff;
}
+ else if (!m->isleafmethod &&(rd->ifargfltregcnt < rd->fltreg_argnum)) {
+ v->regoff = rd->argfltregs[rd->ifargfltregcnt++];
+ }
else if (rd->iftmpfltregcnt > 0) {
rd->iftmpfltregcnt--;
v->regoff = rd->tmpfltregs[rd->iftmpfltregcnt];
v->flags |= rd->interfaces[s][intalloc].flags & INMEMORY;
v->regoff = rd->interfaces[s][intalloc].regoff;
}
+ else if (!m->isleafmethod &&(rd->ifargintregcnt +regsneeded < rd->intreg_argnum)) {
+ v->regoff = rd->argintregs[rd->ifargintregcnt];
+ rd->ifargintregcnt+=regsneeded+1;
+ }
else if (rd->iftmpintregcnt > regsneeded) {
rd->iftmpintregcnt -= regsneeded + 1;
v->regoff = rd->tmpintregs[rd->iftmpintregcnt];
} /* for s */
rd->maxmemuse = rd->ifmemuse;
- rd->maxargintreguse = -1;
+
+ rd->maxargintreguse = rd->ifargintregcnt;
+ rd->maxargfltreguse = rd->ifargfltregcnt;
+
rd->maxtmpintreguse = rd->iftmpintregcnt;
rd->maxsavintreguse = rd->ifsavintregcnt;
- rd->maxargfltreguse = -1;
+
rd->maxtmpfltreguse = rd->iftmpfltregcnt;
rd->maxsavfltreguse = rd->ifsavfltregcnt;
-#ifdef HAS_ADDRESS_REGISTER_FILE
- rd->maxargadrreguse = -1;
+
+#if defined(HAS_ADDRESS_REGISTER_FILE)
+
+ rd->maxargadrreguse = rd->ifargadrregcnt;
rd->maxtmpadrreguse = rd->iftmpadrregcnt;
rd->maxsavadrreguse = rd->ifsavadrregcnt;
#endif
}
}
-static void reg_init_temp(registerdata *rd)
+static void reg_init_temp(methodinfo *m, registerdata *rd)
{
rd->freememtop = 0;
rd->memuse = rd->ifmemuse;
rd->savadrreguse = rd->ifsavadrregcnt;
#endif
-#if defined(USE_UNUSED_ARGUMENT_REGISTERS)
- /* all argument registers are available */
- rd->argintreguse = rd->intreg_argnum;
- rd->argfltreguse = rd->fltreg_argnum;
+ rd->freearginttop = 0;
+ rd->freeargflttop = 0;
#ifdef HAS_ADDRESS_REGISTER_FILE
- rd->argadrreguse = rd->adrreg_argnum;
+ rd->freeargadrtop = 0;
#endif
-#endif /*defined(USE_UNUSED_ARGUMENT_REGISTERS)*/
-}
+ if (!m->isleafmethod) {
+ rd->argintreguse = rd->ifargintregcnt;
+ rd->argfltreguse = rd->ifargfltregcnt;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ rd->argadrreguse = rd->ifargadrregcnt;
+#endif
+ } else {
+ rd->argintreguse = rd->intreg_argnum;
+ rd->argfltreguse = rd->fltreg_argnum;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ rd->argadrreguse = rd->adrreg_argnum;
+#endif
+ }
+}
#define reg_new_temp(rd,s) if (s->varkind == TEMPVAR) reg_new_temp_func(rd, s)
}
} else {
#endif
- if (IS_FLT_DBL_TYPE(s->type)) {
- if (rd->freetmpflttop > 0) {
- rd->freetmpflttop--;
- s->regoff = rd->freetmpfltregs[rd->freetmpflttop];
- return;
+ if (IS_FLT_DBL_TYPE(s->type)) {
+ if (rd->freeargflttop > 0) {
+ rd->freeargflttop --;
+ s->regoff = rd->freeargfltregs[rd->freeargflttop];
+ s->flags |= TMPARG;
+ return;
+ } else if (rd->argfltreguse < rd->fltreg_argnum) {
+ if (rd->argfltreguse > rd->maxargfltreguse)
+ rd->maxargfltreguse = rd->argfltreguse;
+ s->regoff = rd->argfltregs[rd->argfltreguse++];
+ s->flags |= TMPARG;
+ return;
+ } else if (rd->freetmpflttop > 0) {
+ rd->freetmpflttop--;
+ s->regoff = rd->freetmpfltregs[rd->freetmpflttop];
+ return;
- } else if (rd->tmpfltreguse > 0) {
- rd->tmpfltreguse--;
- if (rd->tmpfltreguse < rd->maxtmpfltreguse)
- rd->maxtmpfltreguse = rd->tmpfltreguse;
- s->regoff = rd->tmpfltregs[rd->tmpfltreguse];
- return;
- }
+ } else if (rd->tmpfltreguse > 0) {
+ rd->tmpfltreguse--;
+ if (rd->tmpfltreguse < rd->maxtmpfltreguse)
+ rd->maxtmpfltreguse = rd->tmpfltreguse;
+ s->regoff = rd->tmpfltregs[rd->tmpfltreguse];
+ return;
+ }
- } else {
+ } else {
#if defined(__I386__)
/*
* for i386 put all longs in memory
*/
if (!IS_2_WORD_TYPE(s->type)) {
#endif
- if (rd->freetmpinttop > regsneeded) {
+ if (rd->freearginttop > regsneeded) {
+ rd->freearginttop -= regsneeded + 1;
+ s->regoff = rd->freeargintregs[rd->freearginttop];
+ s->flags |= TMPARG;
+ return;
+ } else if (rd->argintreguse < rd->intreg_argnum - regsneeded) {
+ if (rd->argintreguse > rd->maxargintreguse)
+ rd->maxargintreguse = rd->argintreguse;
+ s->regoff = rd->argintregs[rd->argintreguse];
+ s->flags |= TMPARG;
+ rd->argintreguse += regsneeded + 1;
+ return;
+ } else if (rd->freetmpinttop > regsneeded) {
rd->freetmpinttop -= regsneeded + 1;
s->regoff = rd->freetmpintregs[rd->freetmpinttop];
return;
if (s->flags & (SAVEDVAR | SAVEDTMP)) {
s->flags &= ~SAVEDTMP;
rd->freesavfltregs[rd->freesavflttop++] = s->regoff;
-
} else
- rd->freetmpfltregs[rd->freetmpflttop++] = s->regoff;
-
+ if (s->flags & TMPARG) {
+ s->flags &= ~TMPARG;
+ rd->freeargfltregs[rd->freeargflttop++] = s->regoff;
+ } else
+ rd->freetmpfltregs[rd->freetmpflttop++] = s->regoff;
} else {
if (s->flags & (SAVEDVAR | SAVEDTMP)) {
s->flags &= ~SAVEDTMP;
#endif
rd->freesavinttop += regsneeded + 1;
+ } else if (s->flags & TMPARG) {
+ s->flags &= ~TMPARG;
+ rd->freeargintregs[rd->freearginttop] = s->regoff;
+#ifdef USETWOREGS
+ if (regsneeded)
+ rd->freeargintregs[rd->freearginttop + 1] = rd->secondregs[s->regoff];
+#endif
+ rd->freearginttop += regsneeded + 1;
} else {
rd->freetmpintregs[rd->freetmpinttop] = s->regoff;
#ifdef USETWOREGS
if (regsneeded)
rd->freetmpintregs[rd->freetmpinttop + 1] = rd->secondregs[s->regoff];
-#endif
+#endif
rd->freetmpinttop += regsneeded + 1;
}
}
dst = bptr->instack;
/* initialize temp registers */
- reg_init_temp(rd);
+ reg_init_temp(m, rd);
iptr = bptr->iinstr;
len = bptr->icount;
/* pop many push any */
- case ICMD_INVOKESTATIC:
- case ICMD_INVOKESPECIAL:
case ICMD_INVOKEVIRTUAL:
+ case ICMD_INVOKESPECIAL:
+ case ICMD_INVOKESTATIC:
case ICMD_INVOKEINTERFACE:
i = iptr->op1;
while (--i >= 0) {
reg_free_temp(rd, src);
src = src->prev;
}
-#if defined(__X86_64__)
- if (((unresolved_method *) iptr->target)->methodref->parseddesc.md->returntype.type != TYPE_VOID)
-#else
if (((methodinfo *) iptr->val.a)->returntype != TYPE_VOID)
-#endif
reg_new_temp(rd, dst);
break;
Changes: Edwin Steiner
Christian Thalinger
- $Id: stack.c 2271 2005-04-11 15:48:42Z twisti $
+ $Id: stack.c 2297 2005-04-13 12:50:07Z christian $
*/
#include "vm/global.h"
#include "vm/builtin.h"
#include "vm/options.h"
-#include "vm/resolve.h"
#include "vm/statistics.h"
#include "vm/tables.h"
#include "vm/jit/codegen.inc.h"
NEWXSTACK;
}
-#if CONDITIONAL_LOADCONST
+#ifdef CONDITIONAL_LOADCONST
b_count = m->basicblockcount;
bptr = m->basicblocks;
while (--b_count >= 0) {
}
bptr++;
}
-#endif /* CONDITIONAL_LOADCONST */
+#endif
do {
b_index = bptr - m->basicblocks;
while (--len >= 0) {
opcode = iptr->opc;
- /* XXX TWISTI: why is this set to NULL here? */
-/* iptr->target = NULL; */
+ iptr->target = NULL;
/* dolog("p: %04d op: %s stack: %p", iptr - instr, icmd_names[opcode], curstack); */
iptr[0].op1 = iptr[1].op1;
bptr->icount--;
len--;
-#if 1
/* iptr[1].opc = ICMD_NOP; */
OP1_0(TYPE_INT);
tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
MARKREACHED(tbptr, copy);
COUNT(count_pcmd_bra);
-#else
- goto icmd_if;
-#endif
break;
case ICMD_IF_ICMPLT:
iptr[0].opc = ICMD_IFLT;
case ICMD_IFGE:
case ICMD_IFGT:
case ICMD_IFLE:
-#if 0
- icmd_if:
-#endif
COUNT(count_pcmd_bra);
-#if CONDITIONAL_LOADCONST
- tbptr = m->basicblocks + b_index;
- if ((b_count >= 3) &&
- ((b_index + 2) == m->basicblockindex[iptr[0].op1]) &&
- (tbptr[1].pre_count == 1) &&
- (tbptr[1].iinstr[0].opc == ICMD_ICONST) &&
- (tbptr[1].iinstr[1].opc == ICMD_GOTO) &&
- ((b_index + 3) == m->basicblockindex[tbptr[1].iinstr[1].op1]) &&
- (tbptr[2].pre_count == 1) &&
- (tbptr[2].iinstr[0].opc == ICMD_ICONST)) {
- OP1_1(TYPE_INT, TYPE_INT);
- switch (iptr[0].opc) {
- case ICMD_IFEQ:
- iptr[0].opc = ICMD_IFNE_ICONST;
- break;
- case ICMD_IFNE:
- iptr[0].opc = ICMD_IFEQ_ICONST;
- break;
- case ICMD_IFLT:
- iptr[0].opc = ICMD_IFGE_ICONST;
- break;
- case ICMD_IFGE:
- iptr[0].opc = ICMD_IFLT_ICONST;
- break;
- case ICMD_IFGT:
- iptr[0].opc = ICMD_IFLE_ICONST;
- break;
- case ICMD_IFLE:
- iptr[0].opc = ICMD_IFGT_ICONST;
+#ifdef CONDITIONAL_LOADCONST
+ {
+ tbptr = m->basicblocks + b_index;
+ if ((b_count >= 3) &&
+ ((b_index + 2) == m->basicblockindex[iptr[0].op1]) &&
+ (tbptr[1].pre_count == 1) &&
+ (iptr[1].opc == ICMD_ICONST) &&
+ (iptr[2].opc == ICMD_GOTO) &&
+ ((b_index + 3) == m->basicblockindex[iptr[2].op1]) &&
+ (tbptr[2].pre_count == 1) &&
+ (iptr[3].opc == ICMD_ICONST)) {
+ OP1_1(TYPE_INT, TYPE_INT);
+ switch (iptr[0].opc) {
+ case ICMD_IFEQ:
+ iptr[0].opc = ICMD_IFNE_ICONST;
+ break;
+ case ICMD_IFNE:
+ iptr[0].opc = ICMD_IFEQ_ICONST;
+ break;
+ case ICMD_IFLT:
+ iptr[0].opc = ICMD_IFGE_ICONST;
+ break;
+ case ICMD_IFGE:
+ iptr[0].opc = ICMD_IFLT_ICONST;
+ break;
+ case ICMD_IFGT:
+ iptr[0].opc = ICMD_IFLE_ICONST;
+ break;
+ case ICMD_IFLE:
+ iptr[0].opc = ICMD_IFGT_ICONST;
+ break;
+ }
+ iptr[0].val.i = iptr[1].val.i;
+ iptr[1].opc = ICMD_ELSE_ICONST;
+ iptr[1].val.i = iptr[3].val.i;
+ iptr[2].opc = ICMD_NOP;
+ iptr[3].opc = ICMD_NOP;
+ tbptr[1].flags = BBDELETED;
+ tbptr[2].flags = BBDELETED;
+ tbptr[1].icount = 0;
+ tbptr[2].icount = 0;
+ if (tbptr[3].pre_count == 2) {
+ len += tbptr[3].icount + 3;
+ bptr->icount += tbptr[3].icount + 3;
+ tbptr[3].flags = BBDELETED;
+ tbptr[3].icount = 0;
+ b_index++;
+ }
+ else {
+ bptr->icount++;
+ len ++;
+ }
+ b_index += 2;
break;
}
-#if 1
- iptr[0].val.i = iptr[1].val.i;
- iptr[1].opc = ICMD_ELSE_ICONST;
- iptr[1].val.i = iptr[3].val.i;
- iptr[2].opc = ICMD_NOP;
- iptr[3].opc = ICMD_NOP;
-#else
- /* HACK: save compare value in iptr[1].op1 */
- iptr[1].op1 = iptr[0].val.i;
- iptr[0].val.i = tbptr[1].iinstr[0].val.i;
- iptr[1].opc = ICMD_ELSE_ICONST;
- iptr[1].val.i = tbptr[2].iinstr[0].val.i;
- tbptr[1].iinstr[0].opc = ICMD_NOP;
- tbptr[1].iinstr[1].opc = ICMD_NOP;
- tbptr[2].iinstr[0].opc = ICMD_NOP;
-#endif
- tbptr[1].flags = BBDELETED;
- tbptr[2].flags = BBDELETED;
- tbptr[1].icount = 0;
- tbptr[2].icount = 0;
- if (tbptr[3].pre_count == 2) {
- len += tbptr[3].icount + 3;
- bptr->icount += tbptr[3].icount + 3;
- tbptr[3].flags = BBDELETED;
- tbptr[3].icount = 0;
- b_index++;
- }
- else {
- bptr->icount++;
- len ++;
- }
- b_index += 2;
- break;
}
-#endif /* CONDITIONAL_LOADCONST */
+#endif
OP1_0(TYPE_INT);
tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
call_returntype = iptr->op1;
goto _callhandling;
- case ICMD_INVOKESTATIC:
- case ICMD_INVOKESPECIAL:
case ICMD_INVOKEVIRTUAL:
+ case ICMD_INVOKESPECIAL:
case ICMD_INVOKEINTERFACE:
+ case ICMD_INVOKESTATIC:
COUNT(count_pcmd_met);
{
-#if defined(__X86_64__)
- unresolved_method *um = iptr->target;
-/* if (lm->flags & ACC_STATIC) */
-/* {COUNT(count_check_null);} */
- call_argcount = iptr->op1;
- call_returntype =
- um->methodref->parseddesc.md->returntype.type;
-#else
methodinfo *lm = iptr->val.a;
if (lm->flags & ACC_STATIC)
{COUNT(count_check_null);}
call_argcount = iptr->op1;
call_returntype = lm->returntype;
-#endif
_callhandling:
i = call_argcount;
OP0_1(call_returntype);
break;
}
-
case ICMD_INLINE_START:
case ICMD_INLINE_END:
SETDST;
break;
case ICMD_MULTIANEWARRAY:
+ if (rd->argintreguse < 3)
+ rd->argintreguse = 3;
+
i = iptr->op1;
REQUIRE(i);
#ifdef SPECIALMEMUSE
case ICMD_LUSHRCONST:
case ICMD_ICONST:
case ICMD_ELSE_ICONST:
- case ICMD_IASTORECONST:
- case ICMD_BASTORECONST:
- case ICMD_CASTORECONST:
- case ICMD_SASTORECONST:
- printf(" %d (0x%08x)", iptr->val.i, iptr->val.i);
- break;
-
case ICMD_IFEQ_ICONST:
case ICMD_IFNE_ICONST:
case ICMD_IFLT_ICONST:
case ICMD_IFGE_ICONST:
case ICMD_IFGT_ICONST:
case ICMD_IFLE_ICONST:
- printf("(%d) %d", iptr[1].op1, iptr->val.i);
+ case ICMD_IASTORECONST:
+ case ICMD_BASTORECONST:
+ case ICMD_CASTORECONST:
+ case ICMD_SASTORECONST:
+ printf(" %d", iptr->val.i);
break;
case ICMD_LADDCONST:
case ICMD_LCONST:
case ICMD_LASTORECONST:
#if defined(__I386__) || defined(__POWERPC__)
- printf(" %lld (0x%016llx)", iptr->val.l, iptr->val.l);
+ printf(" %lld", iptr->val.l);
#else
- printf(" %ld (0x%016lx)", iptr->val.l, iptr->val.l);
+ printf(" %ld", iptr->val.l);
#endif
break;
case ICMD_GETFIELD:
case ICMD_PUTFIELD:
-#if defined(__X86_64__)
- if (iptr->val.a)
- printf(" %d,", ((fieldinfo *) iptr->val.a)->offset);
- else
- printf(" NOT RESOLVED,");
-#else
printf(" %d,", ((fieldinfo *) iptr->val.a)->offset);
-#endif
- case ICMD_GETSTATIC:
case ICMD_PUTSTATIC:
-#if defined(__X86_64__)
- printf(" ");
- utf_display_classname(((unresolved_field *) iptr->target)->fieldref->classref->name);
- printf(".");
- utf_display(((unresolved_field *) iptr->target)->fieldref->name);
- printf(" (type ");
- utf_display(((unresolved_field *) iptr->target)->fieldref->descriptor);
- printf(")");
-#else
+ case ICMD_GETSTATIC:
printf(" ");
- utf_display_classname(((fieldinfo *) iptr->val.a)->class->name);
+ utf_fprint(stdout, ((fieldinfo *) iptr->val.a)->class->name);
printf(".");
- utf_display(((fieldinfo *) iptr->val.a)->name);
+ utf_fprint(stdout, ((fieldinfo *) iptr->val.a)->name);
printf(" (type ");
- utf_display(((fieldinfo *) iptr->val.a)->descriptor);
+ utf_fprint(stdout, ((fieldinfo *) iptr->val.a)->descriptor);
printf(")");
-#endif
break;
case ICMD_PUTSTATICCONST:
printf(" %g,", iptr->val.d);
break;
}
-#if defined(__X86_64__)
- if (iptr->opc == ICMD_PUTFIELDCONST)
- printf(" NOT RESOLVED,");
- printf(" ");
- utf_display_classname(((unresolved_field *) iptr[1].target)->fieldref->classref->name);
- printf(".");
- utf_display(((unresolved_field *) iptr[1].target)->fieldref->name);
- printf(" (type ");
- utf_display(((unresolved_field *) iptr[1].target)->fieldref->descriptor);
- printf(")");
-#else
if (iptr->opc == ICMD_PUTFIELDCONST)
printf(" %d,", ((fieldinfo *) iptr[1].val.a)->offset);
printf(" ");
- utf_display_classname(((fieldinfo *) iptr[1].val.a)->class->name);
+ utf_fprint(stdout, ((fieldinfo *) iptr[1].val.a)->class->name);
printf(".");
- utf_display(((fieldinfo *) iptr[1].val.a)->name);
+ utf_fprint(stdout, ((fieldinfo *) iptr[1].val.a)->name);
printf(" (type ");
- utf_display(((fieldinfo *) iptr[1].val.a)->descriptor);
+ utf_fprint(stdout, ((fieldinfo *) iptr[1].val.a)->descriptor);
printf(")");
-#endif
break;
case ICMD_IINC:
case ICMD_NEW:
printf(" ");
- utf_display_classname(((classinfo *) iptr->val.a)->name);
+ utf_fprint(stdout,
+ ((classinfo *) iptr->val.a)->name);
break;
case ICMD_NEWARRAY:
case ICMD_ANEWARRAY:
if (iptr->op1) {
printf(" ");
- utf_display_classname(((classinfo *) iptr->val.a)->name);
+ utf_fprint(stdout,
+ ((classinfo *) iptr->val.a)->name);
}
break;
printf(" %d ",iptr->op1);
vft = (vftbl_t *)iptr->val.a;
if (vft)
- utf_display_classname(vft->class->name);
+ utf_fprint(stdout,vft->class->name);
else
printf("<null>");
}
case ICMD_CHECKCAST:
case ICMD_INSTANCEOF:
-#if defined(__X86_64__)
- if (iptr->op1) {
- classinfo *c = iptr->val.a;
- if (c) {
- if (c->flags & ACC_INTERFACE)
- printf(" (INTERFACE) ");
- else
- printf(" (CLASS,%3d) ", c->vftbl->diffval);
- } else {
- printf(" (NOT RESOLVED) ");
- }
- utf_display_classname(((constant_classref *) iptr->target)->name);
- }
- break;
-#endif
if (iptr->op1) {
classinfo *c = iptr->val.a;
if (c->flags & ACC_INTERFACE)
printf(" (INTERFACE) ");
else
printf(" (CLASS,%3d) ", c->vftbl->diffval);
- utf_display_classname(c->name);
+ utf_fprint(stdout, c->name);
}
break;
printf(" %s", icmd_builtin_name((functionptr) iptr->val.fp));
break;
- case ICMD_INVOKESTATIC:
- case ICMD_INVOKESPECIAL:
case ICMD_INVOKEVIRTUAL:
+ case ICMD_INVOKESPECIAL:
+ case ICMD_INVOKESTATIC:
case ICMD_INVOKEINTERFACE:
-#if defined(__X86_64__)
printf(" ");
- utf_display_classname(((unresolved_method *) iptr->target)->methodref->classref->name);
+ utf_fprint(stdout,
+ ((methodinfo *) iptr->val.a)->class->name);
printf(".");
- utf_display(((unresolved_method *) iptr->target)->methodref->name);
- utf_display(((unresolved_method *) iptr->target)->methodref->descriptor);
-#else
- printf(" ");
- utf_display_classname(((methodinfo *) iptr->val.a)->class->name);
- printf(".");
- utf_display(((methodinfo *) iptr->val.a)->name);
- utf_display(((methodinfo *) iptr->val.a)->descriptor);
-#endif
+ utf_fprint(stdout,
+ ((methodinfo *) iptr->val.a)->name);
break;
case ICMD_IFEQ:
Authors: Christian Thalinger
- $Id: stack.h 2211 2005-04-04 10:39:36Z christian $
+ $Id: stack.h 2297 2005-04-13 12:50:07Z christian $
*/
/*--------------------------------------------------*/
#define NEWSTACK_(s,v,n) {new->prev=curstack;new->type=s;new->flags=0; \
- new->varkind=v;new->varnum=n;curstack=new;new++; }
+ new->varkind=v;new->varnum=n;curstack=new;new++;}
+ /* Initialize regoff, so -sia can show regnames even before reg.inc */
+ /* regs[rd->intregargnum has to be set for this */
+ /* new->regoff = (IS_FLT_DBL_TYPE(s))?-1:rd->intreg_argnum; }*/
#ifdef LSRA
#define NEWSTACK(s,v,n) {NEWSTACK_(s,v,n); m->maxlifetimes++;}
#else
Authors: Andreas Krall
Christian Thalinger
- $Id: codegen.h 2265 2005-04-11 09:58:52Z twisti $
-*/
+ $Id: codegen.h 2297 2005-04-13 12:50:07Z christian $
+*/
#ifndef _CODEGEN_H
#define _CODEGEN_H
#include "vm/jit/x86_64/types.h"
-/* Macro for stack.c to set Argument Stackslots */
+/* SET_ARG_STACKSLOTS *************************************************
+Macro for stack.c to set Argument Stackslots
+
+Sets the first call_argcount stackslots of curstack to varkind ARGVAR, if
+they to not have the SAVEDVAR flag set. According to the calling
+conventions these stackslots are assigned argument registers or memory
+locations
+-- in
+i,call_argcount: Number of Parameters
+curstack: stackptr to current instack
+copy : stackptr
+
+--- uses
+i, copy
+
+-- out
+copy: points to first stackslot after the parameters
+rd->ifmemuse: max. number of stackslots needed for spilled parameters so far
+rd->argintreguse: max. number of used integer argument registers used so far
+rd->fltintreguse: max. number of used float argument registers used so far
+************************************************************************/
#define SET_ARG_STACKSLOTS { \
s4 iarg = 0; \
s4 farg = 0; \
} \
stacksize = (farg < rd->fltreg_argnum)? 0 : (farg - rd->fltreg_argnum); \
stacksize += (iarg < rd->intreg_argnum)? 0 : (iarg - rd->intreg_argnum); \
+ if (rd->argintreguse < iarg) \
+ rd->argintreguse = iarg; \
+ if (rd->argfltreguse < farg) \
+ rd->argfltreguse = farg; \
if (rd->ifmemuse < stacksize) \
rd->ifmemuse = stacksize; \
i = call_argcount; \
if (IS_FLT_DBL_TYPE(copy->type)) { \
farg--; \
if (!(copy->flags & SAVEDVAR)) { \
- copy->varnum = i; \
+ copy->varnum = farg; \
copy->varkind = ARGVAR; \
if (farg < rd->fltreg_argnum) { \
copy->flags = 0; \
} else { /* int_arg */ \
iarg--; \
if (!(copy->flags & SAVEDVAR)) { \
- copy->varnum = i; \
+ copy->varnum = iarg; \
copy->varkind = ARGVAR; \
if (iarg < rd->intreg_argnum) { \
copy->flags = 0; \
} \
} \
} \
- copy = copy->prev; \
+ copy = copy->prev; \
} \
- } \
+ }
/* macros to create code ******************************************************/
projects / cacao.git / commitdiff