* src/vm/jit/reg.h (registerdata): Removed arg{int,flt}regs.
* src/vm/jit/stack.c (stack_analyse): regoff now contains the register
number instead of an offset.
* src/vm/jit/allocator/simplereg.c: Use
abi_registers_{integer,float}_argument instead of arg{int,flt}regs.
* src/vm/jit/alpha/codegen.c,
src/vm/jit/alpha/emit.c,
src/vm/jit/alpha/md-abi.c,
src/vm/jit/arm/codegen.c,
src/vm/jit/arm/emit.c,
src/vm/jit/arm/md-abi.c,
src/vm/jit/arm/md-abi.h,
src/vm/jit/i386/codegen.c,
src/vm/jit/i386/md-abi.c,
src/vm/jit/mips/codegen.c,
src/vm/jit/mips/emit.c,
src/vm/jit/mips/md-abi.c,
src/vm/jit/powerpc/codegen.c,
src/vm/jit/powerpc/emit.c,
src/vm/jit/powerpc/linux/md-abi.c,
src/vm/jit/powerpc/linux/md-abi.h,
src/vm/jit/x86_64/codegen.c,
src/vm/jit/x86_64/emit.c,
src/vm/jit/x86_64/md-abi.c: A lot of changes like the ones above.
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
- $Id: simplereg.c 7645 2007-04-03 11:46:50Z twisti $
+ $Id: simplereg.c 7713 2007-04-15 21:49:48Z twisti $
*/
#include "vm/builtin.h"
#include "vm/exceptions.h"
+#include "vm/resolve.h"
#include "vm/stringlocal.h"
+#include "vm/jit/abi.h"
#include "vm/jit/reg.h"
-#include "vm/jit/allocator/simplereg.h"
#include "vm/jit/show.h"
+#include "vm/jit/allocator/simplereg.h"
#include "vmcore/method.h"
#include "vmcore/options.h"
-#include "vm/resolve.h"
#if 0
#define AVAIL_FREE_TMP_INT AVAIL_BACK_INT(rd->freetmpinttop)
#define AVAIL_FREE_SAV_INT AVAIL_BACK_INT(rd->freesavinttop)
-#define TAKE_ARG_FLT(r) POP_FRONT(rd->argfltregs, rd->argfltreguse, r)
+#define TAKE_ARG_FLT(r) POP_FRONT(abi_registers_float_argument, rd->argfltreguse, r)
#define TAKE_TMP_FLT(r) POP_BACK(rd->tmpfltregs, rd->tmpfltreguse, r)
#define TAKE_SAV_FLT(r) POP_BACK(rd->savfltregs, rd->savfltreguse, r)
#define TAKE_TMP_ADR(r) POP_BACK(rd->tmpadrregs, rd->tmpadrreguse, r)
#define TAKE_SAV_ADR(r) POP_BACK(rd->savadrregs, rd->savadrreguse, r)
-#define TAKE_ARG_INT(r) POP_FRONT_INT(rd->argintregs, rd->argintreguse, r)
+#define TAKE_ARG_INT(r) POP_FRONT_INT(abi_registers_integer_argument, rd->argintreguse, r)
#define TAKE_TMP_INT(r) POP_BACK_INT(rd->tmpintregs, rd->tmpintreguse, r)
#define TAKE_SAV_INT(r) POP_BACK_INT(rd->savintregs, rd->savintreguse, r)
#if !defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
/* We can only use float arguments as local variables,
* if we do not pass them in integer registers. */
- else if ((p < md->paramcount) &&
- !md->params[p].inmemory)
- {
+ else if ((p < md->paramcount) && !md->params[p].inmemory) {
v->flags = 0;
- v->vv.regoff = rd->argfltregs[md->params[p].regoff];
+ v->vv.regoff = md->params[p].regoff;
}
#endif
else if (AVAIL_TMP_FLT) {
TAKE_TMP_FLT(v->vv.regoff);
}
/* use unused argument registers as local registers */
- else if ((p >= md->paramcount) &&
- (fargcnt < FLT_ARG_CNT))
- {
+ else if ((p >= md->paramcount) && (fargcnt < FLT_ARG_CNT)) {
v->flags = 0;
- POP_FRONT(rd->argfltregs, fargcnt, v->vv.regoff);
+ POP_FRONT(abi_registers_float_argument,
+ fargcnt, v->vv.regoff);
}
else if (AVAIL_SAV_FLT) {
v->flags = 0;
v->flags = 0;
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
if (IS_2_WORD_TYPE(t))
- v->vv.regoff = PACK_REGS(
- rd->argintregs[GET_LOW_REG(md->params[p].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[p].regoff)]);
+ v->vv.regoff =
+ PACK_REGS(GET_LOW_REG(md->params[p].regoff),
+ GET_HIGH_REG(md->params[p].regoff));
else
#endif
- v->vv.regoff =
- rd->argintregs[md->params[p].regoff];
+ v->vv.regoff = md->params[p].regoff;
}
else if (AVAIL_TMP_INT) {
v->flags = 0;
(iargcnt + intregsneeded < INT_ARG_CNT))
{
v->flags = 0;
- POP_FRONT_INT(rd->argintregs, iargcnt, v->vv.regoff);
+ POP_FRONT_INT(abi_registers_integer_argument,
+ iargcnt, v->vv.regoff);
}
else if (AVAIL_SAV_INT) {
v->flags = 0;
/* record the interface registers as used */
for (i=0; i<rd->argintreguse; ++i)
- rd->intusedinout[rd->argintregs[i]] = 1;
+ rd->intusedinout[abi_registers_integer_argument[i]] = 1;
for (i=rd->tmpintreguse; i<INT_TMP_CNT; ++i)
rd->intusedinout[rd->tmpintregs[i]] = 1;
for (i=rd->savintreguse; i<INT_SAV_CNT; ++i)
rd->intusedinout[rd->savintregs[i]] = 1;
for (i=0; i<rd->argfltreguse; ++i)
- rd->fltusedinout[rd->argfltregs[i]] = 1;
+ rd->fltusedinout[abi_registers_float_argument[i]] = 1;
for (i=rd->tmpfltreguse; i<FLT_TMP_CNT; ++i)
rd->fltusedinout[rd->tmpfltregs[i]] = 1;
for (i=rd->savfltreguse; i<FLT_SAV_CNT; ++i)
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 7692 2007-04-12 14:47:24Z twisti $
+ $Id: codegen.c 7713 2007-04-15 21:49:48Z twisti $
*/
#include "vm/global.h"
#include "vm/vm.h"
+#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/codegen-common.h"
#include "vm/jit/dseg.h"
if (IS_INT_LNG_TYPE(t)) { /* integer args */
if (!md->params[p].inmemory) { /* register arguments */
- s2 = rd->argintregs[s1];
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
- M_INTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
- M_LST(s2, REG_SP, var->vv.regoff * 8);
- }
-
- } else { /* stack arguments */
- if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
+ if (!IS_INMEMORY(var->flags))
+ M_INTMOVE(s1, var->vv.regoff);
+ else
+ M_LST(s1, REG_SP, var->vv.regoff * 8);
+ }
+ else { /* stack arguments */
+ if (!IS_INMEMORY(var->flags))
M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) *8);
-
- } else { /* stack arg -> spilled */
+ else
var->vv.regoff = cd->stackframesize + s1;
- }
}
-
- } else { /* floating args */
+ }
+ else { /* floating args */
if (!md->params[p].inmemory) { /* register arguments */
- s2 = rd->argfltregs[s1];
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
- M_FLTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
- M_DST(s2, REG_SP, var->vv.regoff * 8);
- }
-
- } else { /* stack arguments */
- if (!(var->flags & INMEMORY)) { /* stack-arg -> register */
+ if (!IS_INMEMORY(var->flags))
+ M_FLTMOVE(s1, var->vv.regoff);
+ else
+ M_DST(s1, REG_SP, var->vv.regoff * 8);
+ }
+ else { /* stack arguments */
+ if (!(var->flags & INMEMORY))
M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
-
- } else { /* stack-arg -> spilled */
+ else
var->vv.regoff = cd->stackframesize + s1;
- }
}
}
- } /* end for */
+ }
/* call monitorenter function */
M_LDA(REG_SP, REG_SP, -(INT_ARG_CNT + FLT_ARG_CNT) * 8);
for (p = 0; p < INT_ARG_CNT; p++)
- M_LST(rd->argintregs[p], REG_SP, p * 8);
+ M_LST(abi_registers_integer_argument[p], REG_SP, p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DST(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+ M_DST(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
s1 += INT_ARG_CNT + FLT_ARG_CNT;
}
#if !defined(NDEBUG)
if (opt_verbosecall) {
for (p = 0; p < INT_ARG_CNT; p++)
- M_LLD(rd->argintregs[p], REG_SP, p * 8);
+ M_LLD(abi_registers_integer_argument[p], REG_SP, p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DLD(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+ M_DLD(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
M_LDA(REG_SP, REG_SP, (INT_ARG_CNT + FLT_ARG_CNT) * 8);
}
for (s3 = s3 - 1; s3 >= 0; s3--) {
var = VAR(iptr->sx.s23.s2.args[s3]);
+ d = md->params[s3].regoff;
/* Already Preallocated (ARGVAR) ? */
if (var->flags & PREALLOC)
if (IS_INT_LNG_TYPE(var->type)) {
if (!md->params[s3].inmemory) {
- s1 = rd->argintregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_INTMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_INTMOVE(s1, d);
}
else {
- d = emit_load(jd, iptr, var, REG_ITMP1);
- M_LST(d, REG_SP, md->params[s3].regoff * 8);
+ s1 = emit_load(jd, iptr, var, REG_ITMP1);
+ M_LST(s1, REG_SP, d * 8);
}
}
else {
if (!md->params[s3].inmemory) {
- s1 = rd->argfltregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
+ s1 = emit_load(jd, iptr, var, d);
M_FLTMOVE(d, s1);
}
else {
- d = emit_load(jd, iptr, var, REG_FTMP1);
- M_DST(d, REG_SP, md->params[s3].regoff * 8);
+ s1 = emit_load(jd, iptr, var, REG_FTMP1);
+ M_DST(s1, REG_SP, d * 8);
}
}
}
void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
{
- methodinfo *m;
- codeinfo *code;
- codegendata *cd;
- registerdata *rd;
- methoddesc *md;
- s4 nativeparams;
- s4 i, j; /* count variables */
- s4 t;
- s4 s1, s2, disp;
- s4 funcdisp; /* displacement of the function */
+ methodinfo *m;
+ codeinfo *code;
+ codegendata *cd;
+ methoddesc *md;
+ s4 nativeparams;
+ s4 i, j; /* count variables */
+ s4 t;
+ s4 s1, s2, disp;
+ s4 funcdisp; /* displacement of the function */
/* get required compiler data */
m = jd->m;
code = jd->code;
cd = jd->cd;
- rd = jd->rd;
/* initialize variables */
for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) {
- M_LST(rd->argintregs[i], REG_SP, j * 8);
+ M_LST(abi_registers_integer_argument[i], REG_SP, j * 8);
j++;
}
}
for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
- M_DST(rd->argfltregs[i], REG_SP, j * 8);
+ M_DST(abi_registers_float_argument[i], REG_SP, j * 8);
j++;
}
}
for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) {
- M_LLD(rd->argintregs[i], REG_SP, j * 8);
+ M_LLD(abi_registers_integer_argument[i], REG_SP, j * 8);
j++;
}
}
for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
- M_DLD(rd->argfltregs[i], REG_SP, j * 8);
+ M_DLD(abi_registers_float_argument[i], REG_SP, j * 8);
j++;
}
}
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[i].inmemory) {
- s1 = rd->argintregs[md->params[i].regoff];
+ s1 = md->params[i].regoff;
+ s2 = nmd->params[j].regoff;
- if (!nmd->params[j].inmemory) {
- s2 = rd->argintregs[nmd->params[j].regoff];
+ if (!nmd->params[j].inmemory)
M_INTMOVE(s1, s2);
-
- } else {
- s2 = nmd->params[j].regoff;
+ else
M_LST(s1, REG_SP, s2 * 8);
- }
-
- } else {
+ }
+ else {
s1 = md->params[i].regoff + cd->stackframesize;
s2 = nmd->params[j].regoff;
M_LLD(REG_ITMP1, REG_SP, s1 * 8);
M_LST(REG_ITMP1, REG_SP, s2 * 8);
}
-
- } else {
+ }
+ else {
if (!md->params[i].inmemory) {
- s1 = rd->argfltregs[md->params[i].regoff];
+ s1 = md->params[i].regoff;
+ s2 = nmd->params[j].regoff;
- if (!nmd->params[j].inmemory) {
- s2 = rd->argfltregs[nmd->params[j].regoff];
+ if (!nmd->params[j].inmemory)
M_FLTMOVE(s1, s2);
-
- } else {
- s2 = nmd->params[j].regoff;
+ else {
if (IS_2_WORD_TYPE(t))
M_DST(s1, REG_SP, s2 * 8);
else
M_FST(s1, REG_SP, s2 * 8);
}
-
- } else {
+ }
+ else {
s1 = md->params[i].regoff + cd->stackframesize;
s2 = nmd->params[j].regoff;
M_DLD(REG_FTMP1, REG_SP, s1 * 8);
/* save return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type))
- M_LST(REG_RESULT, REG_SP, 0 * 8);
- else
- M_DST(REG_FRESULT, REG_SP, 0 * 8);
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LST(REG_RESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DST(REG_FRESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_VOID:
+ break;
}
/* call finished trace */
/* restore return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type))
- M_LLD(REG_RESULT, REG_SP, 0 * 8);
- else
- M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LLD(REG_RESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_VOID:
+ break;
}
M_ALD(REG_RA, REG_SP, (cd->stackframesize - 1) * 8); /* get RA */
M_ALD(REG_ITMP3, REG_PV, disp); /* load asm exception handler address */
M_JMP(REG_ZERO, REG_ITMP3); /* jump to asm exception handler */
-
/* generate patcher stubs */
emit_patcher_stubs(jd);
#include "vm/builtin.h"
#include "vm/exceptions.h"
+#include "vm/jit/abi.h"
#include "vm/jit/abi-asm.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/dseg.h"
/* save argument registers */
for (i = 0; i < INT_ARG_CNT; i++)
- M_LST(rd->argintregs[i], REG_SP, (2 + i) * 8);
+ M_LST(abi_registers_integer_argument[i], REG_SP, (2 + i) * 8);
for (i = 0; i < FLT_ARG_CNT; i++)
- M_DST(rd->argintregs[i], REG_SP, (2 + INT_ARG_CNT + i) * 8);
+ M_DST(abi_registers_float_argument[i], REG_SP, (2 + INT_ARG_CNT + i) * 8);
/* save temporary registers for leaf methods */
if (IS_FLT_DBL_TYPE(t)) {
if (IS_2_WORD_TYPE(t)) {
- M_DST(rd->argfltregs[i], REG_SP, 0 * 8);
- M_LLD(rd->argintregs[i], REG_SP, 0 * 8);
+ M_DST(abi_registers_float_argument[i], REG_SP, 0 * 8);
+ M_LLD(abi_registers_integer_argument[i], REG_SP, 0 * 8);
}
else {
- M_FST(rd->argfltregs[i], REG_SP, 0 * 8);
- M_ILD(rd->argintregs[i], REG_SP, 0 * 8);
+ M_FST(abi_registers_float_argument[i], REG_SP, 0 * 8);
+ M_ILD(abi_registers_integer_argument[i], REG_SP, 0 * 8);
}
}
}
/* restore argument registers */
for (i = 0; i < INT_ARG_CNT; i++)
- M_LLD(rd->argintregs[i], REG_SP, (2 + i) * 8);
+ M_LLD(abi_registers_integer_argument[i], REG_SP, (2 + i) * 8);
for (i = 0; i < FLT_ARG_CNT; i++)
- M_DLD(rd->argintregs[i], REG_SP, (2 + INT_ARG_CNT + i) * 8);
+ M_DLD(abi_registers_float_argument[i], REG_SP, (2 + INT_ARG_CNT + i) * 8);
/* restore temporary registers for leaf methods */
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: md-abi.c 7637 2007-04-02 20:58:30Z twisti $
+ $Id: md-abi.c 7713 2007-04-15 21:49:48Z twisti $
*/
};
+const s4 abi_registers_float_argument[] = {
+ 16, /* fa0 */
+ 17, /* fa1 */
+ 18, /* fa2 */
+ 19, /* fa3 */
+ 20, /* fa4 */
+ 21, /* fa5 */
+};
+
+const s4 abi_registers_float_saved[] = {
+ 2, /* fs0 */
+ 3, /* fs1 */
+ 4, /* fs2 */
+ 5, /* fs3 */
+ 6, /* fs4 */
+ 7, /* fs5 */
+ 8, /* fs6 */
+ 9, /* fs7 */
+};
+
+const s4 abi_registers_float_temporary[] = {
+ 1, /* ft0 */
+ 10, /* ft1 */
+ 11, /* ft2 */
+ 12, /* ft3 */
+ 13, /* ft4 */
+ 14, /* ft5 */
+ 15, /* ft6 */
+ 22, /* ft7 */
+ 23, /* ft8 */
+ 24, /* ft9 */
+ 25, /* ft10 */
+ 26, /* ft11 */
+ 27, /* ft12 */
+};
+
+
/* md_param_alloc **************************************************************
Allocate the parameters of the given method descriptor according to the
/* set default values */
- reguse = 0;
+ reguse = 0;
stacksize = 0;
/* get params field of methoddesc */
case TYPE_LNG:
if (i < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_integer_argument[reguse];
reguse++;
md->argintreguse = reguse;
}
case TYPE_DBL:
if (i < FLT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_float_argument[reguse];
reguse++;
md->argfltreguse = reguse;
}
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 7692 2007-04-12 14:47:24Z twisti $
+ $Id: codegen.c 7713 2007-04-15 21:49:48Z twisti $
*/
if (IS_INT_LNG_TYPE(t)) { /* integer args */
#endif
if (!md->params[i].inmemory) { /* register arguments */
- s2 = ARGUMENT_REGS(t, s1); /* get argument register */
if (!(var->flags & INMEMORY)) { /* reg arg -> register */
if (GET_LOW_REG(var->vv.regoff) == REG_SPLIT || GET_HIGH_REG(var->vv.regoff) == REG_SPLIT) {
/* TODO: remove this!!! */
- dolog("SPLIT in local var: %x>%x (%s.%s)", s2, var->vv.regoff, m->class->name->text, m->name->text);
- assert(s2 == var->vv.regoff);
+ dolog("SPLIT in local var: %x>%x (%s.%s)", s1, var->vv.regoff, m->class->name->text, m->name->text);
+ assert(s1 == var->vv.regoff);
}
s3 = var->vv.regoff;
- SPLIT_OPEN(t, s2, REG_ITMP1);
- SPLIT_LOAD(t, s2, cd->stackframesize);
+ SPLIT_OPEN(t, s1, REG_ITMP1);
+ SPLIT_LOAD(t, s1, cd->stackframesize);
SPLIT_OPEN(t, s3, REG_ITMP1);
if (IS_2_WORD_TYPE(t))
- M_LNGMOVE(s2, s3);
+ M_LNGMOVE(s1, s3);
else
- M_INTMOVE(s2, s3);
+ M_INTMOVE(s1, s3);
SPLIT_STORE_AND_CLOSE(t, s3, cd->stackframesize);
}
else { /* reg arg -> spilled */
- SPLIT_OPEN(t, s2, REG_ITMP1);
- SPLIT_LOAD(t, s2, cd->stackframesize);
+ SPLIT_OPEN(t, s1, REG_ITMP1);
+ SPLIT_LOAD(t, s1, cd->stackframesize);
if (IS_2_WORD_TYPE(t))
- M_LST(s2, REG_SP, var->vv.regoff * 4);
+ M_LST(s1, REG_SP, var->vv.regoff * 4);
else
- M_IST(s2, REG_SP, var->vv.regoff * 4);
+ M_IST(s1, REG_SP, var->vv.regoff * 4);
/* no SPLIT_CLOSE here because arg is fully spilled now */
}
}
#if !defined(ENABLE_SOFTFLOAT)
} else { /* floating args */
if (!md->params[i].inmemory) { /* register arguments */
- s2 = ARGUMENT_REGS(t, s1); /* get argument register */
if (!(var->flags & INMEMORY)) { /* reg arg -> register */
- SPLIT_OPEN(t, s2, REG_ITMP1);
- SPLIT_LOAD(t, s2, cd->stackframesize);
- M_CAST_INT_TO_FLT_TYPED(t, s2, var->vv.regoff);
+ SPLIT_OPEN(t, s1, REG_ITMP1);
+ SPLIT_LOAD(t, s1, cd->stackframesize);
+ M_CAST_INT_TO_FLT_TYPED(t, s1, var->vv.regoff);
}
else { /* reg arg -> spilled */
- SPLIT_OPEN(t, s2, REG_ITMP1);
- SPLIT_LOAD(t, s2, cd->stackframesize);
+ SPLIT_OPEN(t, s1, REG_ITMP1);
+ SPLIT_LOAD(t, s1, cd->stackframesize);
if (IS_2_WORD_TYPE(t))
- M_LST(s2, REG_SP, var->vv.regoff * 4);
+ M_LST(s1, REG_SP, var->vv.regoff * 4);
else
- M_IST(s2, REG_SP, var->vv.regoff * 4);
+ M_IST(s1, REG_SP, var->vv.regoff * 4);
/* no SPLIT_CLOSE here because arg is fully spilled now */
}
}
for (s3 = s3 - 1; s3 >= 0; s3--) {
var = VAR(iptr->sx.s23.s2.args[s3]);
+ d = md->params[s3].regoff;
if (var->flags & PREALLOC) /* argument was precolored? */
continue;
if (IS_INT_LNG_TYPE(var->type)) {
#endif /* !defined(ENABLE_SOFTFLOAT) */
if (!md->params[s3].inmemory) {
- s1 = ARGUMENT_REGS(var->type, md->params[s3].regoff);
SPLIT_OPEN(var->type, s1, REG_ITMP2);
- d = emit_load(jd, iptr, var, s1);
+ s1 = emit_load(jd, iptr, var, d);
if (IS_2_WORD_TYPE(var->type))
- M_LNGMOVE(d, s1);
+ M_LNGMOVE(s1, d);
else
- M_INTMOVE(d, s1);
+ M_INTMOVE(s1, d);
- SPLIT_STORE_AND_CLOSE(var->type, s1, 0);
+ SPLIT_STORE_AND_CLOSE(var->type, d, 0);
}
else {
if (IS_2_WORD_TYPE(var->type)) {
- d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
- M_LST(d, REG_SP, md->params[s3].regoff * 4);
+ s1 = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
+ M_LST(s1, REG_SP, d * 4);
}
else {
- d = emit_load(jd, iptr, var, REG_ITMP1);
- M_IST(d, REG_SP, md->params[s3].regoff * 4);
+ s1 = emit_load(jd, iptr, var, REG_ITMP1);
+ M_IST(s1, REG_SP, d * 4);
}
}
#if !defined(ENABLE_SOFTFLOAT)
}
else {
if (!md->params[s3].inmemory) {
- s1 = ARGUMENT_REGS(var->type, md->params[s3].regoff);
- d = emit_load(jd, iptr, var, REG_FTMP1);
- SPLIT_OPEN(var->type, s1, REG_ITMP1);
- M_CAST_FLT_TO_INT_TYPED(var->type, d, s1);
- SPLIT_STORE_AND_CLOSE(var->type, s1, 0);
+ s1 = emit_load(jd, iptr, var, REG_FTMP1);
+ SPLIT_OPEN(var->type, d, REG_ITMP1);
+ M_CAST_FLT_TO_INT_TYPED(var->type, s1, d);
+ SPLIT_STORE_AND_CLOSE(var->type, d, 0);
}
else {
- d = emit_load(jd, iptr, var, REG_FTMP1);
+ s1 = emit_load(jd, iptr, var, REG_FTMP1);
if (IS_2_WORD_TYPE(var->type))
- M_DST(d, REG_SP, md->params[s3].regoff * 4);
+ M_DST(s1, REG_SP, d * 4);
else
- M_FST(d, REG_SP, md->params[s3].regoff * 4);
+ M_FST(s1, REG_SP, d * 4);
}
}
#endif /* !defined(ENABLE_SOFTFLOAT) */
void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
{
- methodinfo *m;
- codeinfo *code;
- codegendata *cd;
- registerdata *rd;
- s4 nativeparams;
- methoddesc *md;
- s4 i, j;
- s4 t;
- s4 disp, funcdisp, s1, s2;
+ methodinfo *m;
+ codeinfo *code;
+ codegendata *cd;
+ s4 nativeparams;
+ methoddesc *md;
+ s4 i, j;
+ s4 t;
+ s4 disp, funcdisp, s1, s2;
/* get required compiler data */
m = jd->m;
code = jd->code;
cd = jd->cd;
- rd = jd->rd;
/* initialize variables */
t = md->paramtypes[i].type;
if (!md->params[i].inmemory) {
- s1 = ARGUMENT_REGS(t, md->params[i].regoff);
+ s1 = md->params[i].regoff;
+ s2 = nmd->params[j].regoff;
if (!nmd->params[j].inmemory) {
- s2 = ARGUMENT_REGS(t, nmd->params[j].regoff);
-
#if !defined(__ARM_EABI__)
SPLIT_OPEN(t, s1, REG_ITMP1);
SPLIT_LOAD(t, s1, cd->stackframesize);
#endif
}
else {
- s2 = nmd->params[j].regoff;
-
#if !defined(__ARM_EABI__)
SPLIT_OPEN(t, s1, REG_ITMP1);
SPLIT_LOAD(t, s1, cd->stackframesize);
#include "vm/exceptions.h"
#include "vm/global.h"
+#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/emit-common.h"
#include "vm/jit/jit.h"
if (i < 2) {
#if defined(__ARMEL__)
- s2 = PACK_REGS(rd->argintregs[i * 2], rd->argintregs[i * 2 + 1]);
+ s2 = PACK_REGS(abi_registers_integer_argument[i * 2],
+ abi_registers_integer_argument[i * 2 + 1]);
#else /* defined(__ARMEB__) */
- s2 = PACK_REGS(rd->argintregs[i * 2 + 1], rd->argintregs[i * 2]);
+ s2 = PACK_REGS(abi_registers_integer_argument[i * 2 + 1],
+ abi_registers_integer_argument[i * 2]);
#endif
M_LNGMOVE(s1, s2);
}
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: md-abi.c 7353 2007-02-13 23:14:35Z twisti $
+ $Id: md-abi.c 7713 2007-04-15 21:49:48Z twisti $
*/
"v5", "t3", "t1", "t2", "ip", "sp", "lr", "pc",
};
+const s4 abi_registers_integer_argument[] = {
+ 0, /* a0 */
+ 1, /* a1 */
+ 2, /* a2 */
+ 3, /* a3 */
+ REG_SPLIT,
+};
+
+const s4 abi_registers_integer_saved[] = {
+ 4, /* s0 */
+ 5, /* s1 */
+ 6, /* s2 */
+ 7, /* s3 */
+ 8, /* s4 */
+};
+
+const s4 abi_registers_integer_temporary[] = {
+ -1,
+};
+
#if defined(ENABLE_SOFTFLOAT)
s4 nregdescfloat[] = {
};
#endif /* defined(ENABLE_SOFTFLOAT) */
+const s4 abi_registers_float_argument[] = {
+ -1,
+};
+
+const s4 abi_registers_float_saved[] = {
+ -1,
+};
+
+const s4 abi_registers_float_temporary[] = {
+#if defined(ENABLE_SOFTFLOAT)
+ -1,
+#else
+ 0, /* ft0 */
+ 1, /* ft1 */
+ 2, /* ft2 */
+ 3, /* ft3 */
+ 4, /* ft4 */
+ 5, /* ft5 */
+#endif
+};
+
/* md_param_alloc **************************************************************
case TYPE_FLT:
if (reguse < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_integer_argument[reguse];
reguse++;
}
else {
pd->inmemory = true;
- pd->regoff = stacksize;
+ pd->regoff = stacksize;
stacksize++;
}
break;
if (reguse+1 < INT_ARG_CNT) {
pd->inmemory = false;
#if defined(__ARMEL__)
- pd->regoff = PACK_REGS(reguse, reguse+1);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse],
+ abi_registers_integer_argument[reguse + 1]);
#else
- pd->regoff = PACK_REGS(reguse+1, reguse);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse + 1],
+ abi_registers_integer_argument[reguse]);
#endif
reguse += 2;
}
else if (reguse < INT_ARG_CNT) {
pd->inmemory = false;
#if defined(__ARMEL__)
- pd->regoff = PACK_REGS(reguse, INT_ARG_CNT);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse],
+ abi_registers_integer_argument[INT_ARG_CNT]);
#else
- pd->regoff = PACK_REGS(INT_ARG_CNT, reguse);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[INT_ARG_CNT],
+ abi_registers_integer_argument[reguse]);
#endif
reguse++;
stacksize++;
}
else {
pd->inmemory = true;
- pd->regoff = stacksize;
+ pd->regoff = stacksize;
stacksize += 2;
}
break;
case TYPE_FLT:
if (reguse < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_integer_argument[reguse];
reguse++;
}
else {
#endif
pd->inmemory = false;
#if defined(__ARMEL__)
- pd->regoff = PACK_REGS(reguse, reguse + 1);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse],
+ abi_registers_integer_argument[reguse + 1]);
#else
- pd->regoff = PACK_REGS(reguse + 1, reguse);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse + 1],
+ abi_registers_integer_argument[reguse]);
#endif
reguse += 2;
}
else if (reguse < INT_ARG_CNT) {
pd->inmemory = false;
# if defined(__ARMEL__)
- pd->regoff = PACK_REGS(reguse, INT_ARG_CNT);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse],
+ abi_registers_integer_argument[INT_ARG_CNT]);
# else
- pd->regoff = PACK_REGS(INT_ARG_CNT, reguse);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[INT_ARG_CNT],
+ abi_registers_integer_argument[reguse]);
# endif
reguse++;
stacksize++;
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: md-abi.h 7276 2007-02-02 11:58:18Z michi $
+ $Id: md-abi.h 7713 2007-04-15 21:49:48Z twisti $
*/
#define REG_ITMP12_TYPED(t) ((IS_2_WORD_TYPE(t)) ? REG_ITMP12_PACKED : REG_ITMP1)
#define REG_RESULT_TYPED(t) ((IS_2_WORD_TYPE(t)) ? REG_RESULT_PACKED : REG_RESULT)
-#define ARGUMENT_REGS(t,a) ((IS_2_WORD_TYPE(t)) ? \
- (PACK_REGS(rd->argintregs[GET_LOW_REG(a)],rd->argintregs[GET_HIGH_REG(a)])) : \
- (rd->argintregs[(a)]) \
- )
-
#endif /* _MD_ABI_H */
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 7704 2007-04-15 11:55:25Z michi $
+ $Id: codegen.c 7713 2007-04-15 21:49:48Z twisti $
*/
} else {
if (!md->params[s3].inmemory) {
- s1 = rd->argfltregs[md->params[s3].regoff];
+ s1 = md->params[s3].regoff;
d = emit_load(jd, iptr, var, s1);
M_FLTMOVE(d, s1);
void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
{
- methodinfo *m;
- codeinfo *code;
- codegendata *cd;
- registerdata *rd;
- methoddesc *md;
- s4 nativeparams;
- s4 i, j; /* count variables */
- s4 t;
- s4 s1, s2;
+ methodinfo *m;
+ codeinfo *code;
+ codegendata *cd;
+ methoddesc *md;
+ s4 nativeparams;
+ s4 i, j; /* count variables */
+ s4 t;
+ s4 s1, s2;
/* get required compiler data */
m = jd->m;
code = jd->code;
cd = jd->cd;
- rd = jd->rd;
/* set some variables */
/* save return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_IST(REG_RESULT2, REG_SP, 2 * 4);
- M_IST(REG_RESULT, REG_SP, 1 * 4);
- }
- else {
- if (IS_2_WORD_TYPE(md->returntype.type))
- emit_fstl_membase(cd, REG_SP, 1 * 4);
- else
- emit_fsts_membase(cd, REG_SP, 1 * 4);
- }
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_IST(REG_RESULT, REG_SP, 1 * 4);
+ break;
+ case TYPE_LNG:
+ M_LST(REG_RESULT_PACKED, REG_SP, 1 * 4);
+ break;
+ case TYPE_FLT:
+ emit_fsts_membase(cd, REG_SP, 1 * 4);
+ break;
+ case TYPE_DBL:
+ emit_fstl_membase(cd, REG_SP, 1 * 4);
+ break;
+ case TYPE_VOID:
+ break;
}
#if !defined(NDEBUG)
/* restore return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_ILD(REG_RESULT2, REG_SP, 2 * 4);
- M_ILD(REG_RESULT, REG_SP, 1 * 4);
- }
- else {
- if (IS_2_WORD_TYPE(md->returntype.type))
- emit_fldl_membase(cd, REG_SP, 1 * 4);
- else
- emit_flds_membase(cd, REG_SP, 1 * 4);
- }
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_ILD(REG_RESULT, REG_SP, 1 * 4);
+ break;
+ case TYPE_LNG:
+ M_LLD(REG_RESULT_PACKED, REG_SP, 1 * 4);
+ break;
+ case TYPE_FLT:
+ emit_flds_membase(cd, REG_SP, 1 * 4);
+ break;
+ case TYPE_DBL:
+ emit_fldl_membase(cd, REG_SP, 1 * 4);
+ break;
+ case TYPE_VOID:
+ break;
}
M_AADD_IMM(cd->stackframesize * 4, REG_SP);
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: md-abi.c 7706 2007-04-15 12:17:02Z michi $
+ $Id: md-abi.c 7713 2007-04-15 21:49:48Z twisti $
*/
};
const s4 abi_registers_integer_argument[] = {
- -1, /* empty */
+ -1,
};
const s4 abi_registers_integer_saved[] = {
- 5, /* s0 */
- 6, /* s1 */
- 7, /* s2 */
+ 5, /* s0 */
+ 6, /* s1 */
+ 7, /* s2 */
};
const s4 abi_registers_integer_temporary[] = {
- 3, /* t0 */
+ 3, /* t0 */
};
REG_END
};
+const s4 abi_registers_float_argument[] = {
+ -1,
+};
+
+const s4 abi_registers_float_saved[] = {
+ -1,
+};
+
+const s4 abi_registers_float_temporary[] = {
+ -1,
+};
+
/* md_param_alloc **************************************************************
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 7700 2007-04-13 11:48:48Z twisti $
+ $Id: codegen.c 7713 2007-04-15 21:49:48Z twisti $
*/
#include "vm/exceptions.h"
#include "vm/vm.h"
+#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/codegen-common.h"
#include "vm/jit/dseg.h"
continue;
var = VAR(varindex);
+ s1 = md->params[p].regoff;
- s1 = md->params[p].regoff;
if (IS_INT_LNG_TYPE(t)) { /* integer args */
if (!md->params[p].inmemory) { /* register arguments */
#if SIZEOF_VOID_P == 8
- s2 = rd->argintregs[s1];
- if (!(var->flags & INMEMORY)) { /* reg arg -> register */
- M_INTMOVE(s2, var->vv.regoff);
- } else { /* reg arg -> spilled */
- M_LST(s2, REG_SP, var->vv.regoff * 8);
- }
+ if (!(var->flags & INMEMORY))
+ M_INTMOVE(s1, var->vv.regoff);
+ else
+ M_LST(s1, REG_SP, var->vv.regoff * 8);
#else
if (IS_2_WORD_TYPE(t)) {
- s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
- if (!(var->flags & INMEMORY)) /* reg arg -> register */
- M_LNGMOVE(s2, var->vv.regoff);
- else /* reg arg -> spilled */
- M_LST(s2, REG_SP, var->vv.regoff * 8);
+ if (!(var->flags & INMEMORY))
+ M_LNGMOVE(s1, var->vv.regoff);
+ else
+ M_LST(s1, REG_SP, var->vv.regoff * 8);
}
else {
- s2 = rd->argintregs[s1];
- if (!(var->flags & INMEMORY)) /* reg arg -> register */
- M_INTMOVE(s2, var->vv.regoff);
- else /* reg arg -> spilled */
- M_IST(s2, REG_SP, var->vv.regoff * 8);
+ if (!(var->flags & INMEMORY))
+ M_INTMOVE(s1, var->vv.regoff);
+ else
+ M_IST(s1, REG_SP, var->vv.regoff * 8);
}
#endif
- } else { /* stack arguments */
- if (!(var->flags & INMEMORY)) { /* stack arg -> register */
+ }
+ else { /* stack arguments */
+ if (!(var->flags & INMEMORY)) {
#if SIZEOF_VOID_P == 8
M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
#else
else
M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
#endif
- } else { /* stack arg -> spilled */
+ }
+ else
var->vv.regoff = cd->stackframesize + s1;
- }
}
-
- } else { /* floating args */
- if (!md->params[p].inmemory) { /* register arguments */
+ }
+ else { /* floating args */
+ if (!md->params[p].inmemory) {
#if SIZEOF_VOID_P == 8
- s2 = rd->argfltregs[s1];
- if (!(var->flags & INMEMORY)) { /* reg arg -> register */
+ if (!(var->flags & INMEMORY)) {
if (IS_2_WORD_TYPE(t))
- M_DMOV(s2, var->vv.regoff);
+ M_DMOV(s1, var->vv.regoff);
else
- M_FMOV(s2, var->vv.regoff);
- } else { /* reg arg -> spilled */
+ M_FMOV(s1, var->vv.regoff);
+ }
+ else {
if (IS_2_WORD_TYPE(t))
- M_DST(s2, REG_SP, var->vv.regoff * 8);
+ M_DST(s1, REG_SP, var->vv.regoff * 8);
else
- M_FST(s2, REG_SP, var->vv.regoff * 8);
+ M_FST(s1, REG_SP, var->vv.regoff * 8);
}
#else
if ((p == 0) ||
((p == 1) && IS_FLT_DBL_TYPE(md->paramtypes[0].type))) {
- s2 = rd->argfltregs[s1];
- if (!(var->flags & INMEMORY)) { /* reg arg -> register */
+ if (!(var->flags & INMEMORY)) {
if (IS_2_WORD_TYPE(t))
- M_DBLMOVE(s2, var->vv.regoff);
+ M_DBLMOVE(s1, var->vv.regoff);
else
- M_FLTMOVE(s2, var->vv.regoff);
+ M_FLTMOVE(s1, var->vv.regoff);
}
- else { /* reg arg -> spilled */
+ else {
if (IS_2_WORD_TYPE(t))
- M_DST(s2, REG_SP, var->vv.regoff * 8);
+ M_DST(s1, REG_SP, var->vv.regoff * 8);
else
- M_FST(s2, REG_SP, var->vv.regoff * 8);
+ M_FST(s1, REG_SP, var->vv.regoff * 8);
}
}
else {
if (IS_2_WORD_TYPE(t)) {
- s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
if (!(var->flags & INMEMORY)) {
- M_MTC1(GET_LOW_REG(s2), var->vv.regoff);
- M_MTC1(GET_HIGH_REG(s2), var->vv.regoff + 1);
+ M_MTC1(GET_LOW_REG(s1), var->vv.regoff);
+ M_MTC1(GET_HIGH_REG(s1), var->vv.regoff + 1);
M_NOP;
}
else
- M_LST(s2, REG_SP, var->vv.regoff * 8);
+ M_LST(s1, REG_SP, var->vv.regoff * 8);
}
else {
- s2 = rd->argintregs[s1];
if (!(var->flags & INMEMORY)) {
- M_MTC1(s2, var->vv.regoff);
+ M_MTC1(s1, var->vv.regoff);
M_NOP;
}
else
- M_IST(s2, REG_SP, var->vv.regoff * 8);
+ M_IST(s1, REG_SP, var->vv.regoff * 8);
}
}
#endif
-
- } else { /* stack arguments */
- if (!(var->flags & INMEMORY)) { /* stack-arg -> register */
+ }
+ else {
+ if (!(var->flags & INMEMORY)) {
if (IS_2_WORD_TYPE(t))
M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
else
M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
- } else /* stack-arg -> spilled */
+ }
+ else
var->vv.regoff = cd->stackframesize + s1;
}
}
- } /* end for */
+ }
/* call monitorenter function */
M_LDA(REG_SP, REG_SP, -(INT_ARG_CNT + FLT_ARG_CNT) * 8);
for (p = 0; p < INT_ARG_CNT; p++)
- M_AST(rd->argintregs[p], REG_SP, p * 8);
+ M_AST(abi_registers_integer_argument[p], REG_SP, p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DST(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+ M_DST(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
s1 += INT_ARG_CNT + FLT_ARG_CNT;
}
# if !defined(NDEBUG)
if (opt_verbosecall) {
for (p = 0; p < INT_ARG_CNT; p++)
- M_ALD(rd->argintregs[p], REG_SP, p * 8);
+ M_ALD(abi_registers_integer_argument[p], REG_SP, p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DLD(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+ M_DLD(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
M_LDA(REG_SP, REG_SP, (INT_ARG_CNT + FLT_ARG_CNT) * 8);
for (s3 = s3 - 1; s3 >= 0; s3--) {
var = VAR(iptr->sx.s23.s2.args[s3]);
+ d = md->params[s3].regoff;
if (var->flags & PREALLOC)
continue;
if (IS_INT_LNG_TYPE(var->type)) {
#if SIZEOF_VOID_P == 8
if (!md->params[s3].inmemory) {
- s1 = rd->argintregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_INTMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_INTMOVE(s1, d);
}
else {
- d = emit_load(jd, iptr, var, REG_ITMP1);
- M_LST(d, REG_SP, md->params[s3].regoff * 8);
+ s1 = emit_load(jd, iptr, var, REG_ITMP1);
+ M_LST(s1, REG_SP, d * 8);
}
#else
if (!md->params[s3].inmemory) {
- if (IS_2_WORD_TYPE(var->type)) {
- s1 = md->params[s3].regoff;
- s1 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
- d = emit_load(jd, iptr, var, s1);
- M_LNGMOVE(d, s1);
- }
- else {
- s1 = rd->argintregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_INTMOVE(d, s1);
- }
+ s1 = emit_load(jd, iptr, var, d);
+
+ if (IS_2_WORD_TYPE(var->type))
+ M_LNGMOVE(s1, d);
+ else
+ M_INTMOVE(s1, d);
}
else {
if (IS_2_WORD_TYPE(var->type)) {
- d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
- M_LST(d, REG_SP, md->params[s3].regoff * 8);
+ s1 = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
+ M_LST(s1, REG_SP, d * 8);
}
else {
- d = emit_load(jd, iptr, var, REG_ITMP1);
- M_IST(d, REG_SP, md->params[s3].regoff * 8);
+ s1 = emit_load(jd, iptr, var, REG_ITMP1);
+ M_IST(s1, REG_SP, d * 8);
}
}
#endif
else {
if (!md->params[s3].inmemory) {
#if SIZEOF_VOID_P == 8
- s1 = rd->argfltregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
+ s1 = emit_load(jd, iptr, var, d);
if (IS_2_WORD_TYPE(var->type))
- M_DMOV(d, s1);
+ M_DMOV(s1, d);
else
- M_FMOV(d, s1);
+ M_FMOV(s1, d);
#else
if ((s3 == 0) ||
((s3 == 1) && IS_FLT_DBL_TYPE(md->paramtypes[0].type))) {
- s1 = rd->argfltregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
+ s1 = emit_load(jd, iptr, var, d);
if (IS_2_WORD_TYPE(var->type))
- M_DBLMOVE(d, s1);
+ M_DBLMOVE(s1, d);
else
- M_FLTMOVE(d, s1);
+ M_FLTMOVE(s1, d);
}
else {
if (IS_2_WORD_TYPE(var->type)) {
- s1 = md->params[s3].regoff;
- s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
- d = emit_load(jd, iptr, var, REG_FTMP1);
- M_MFC1(GET_LOW_REG(s2), d);
- M_MFC1(GET_HIGH_REG(s2), d + 1);
+ s1 = emit_load(jd, iptr, var, REG_FTMP1);
+ M_MFC1(GET_LOW_REG(d), s1);
+ M_MFC1(GET_HIGH_REG(d), s1 + 1);
M_NOP;
}
else {
- s1 = rd->argintregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_MFC1(s1, d);
+ s1 = emit_load(jd, iptr, var, d);
+ M_MFC1(d, s1);
M_NOP;
}
}
#endif
}
else {
- d = emit_load(jd, iptr, var, REG_FTMP1);
+ s1 = emit_load(jd, iptr, var, REG_FTMP1);
if (IS_2_WORD_TYPE(var->type))
- M_DST(d, REG_SP, md->params[s3].regoff * 8);
+ M_DST(s1, REG_SP, d * 8);
else
- M_FST(d, REG_SP, md->params[s3].regoff * 8);
+ M_FST(s1, REG_SP, d * 8);
}
}
}
void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
{
- methodinfo *m;
- codeinfo *code;
- codegendata *cd;
- registerdata *rd;
- methoddesc *md;
- s4 nativeparams;
- s4 i, j; /* count variables */
- s4 t;
- s4 s1, s2, disp;
- s4 funcdisp; /* displacement of the function */
+ methodinfo *m;
+ codeinfo *code;
+ codegendata *cd;
+ methoddesc *md;
+ s4 nativeparams;
+ s4 i, j;
+ s4 t;
+ s4 s1, s2, disp;
+ s4 funcdisp; /* displacement of the function */
/* get required compiler data */
m = jd->m;
code = jd->code;
cd = jd->cd;
- rd = jd->rd;
/* initialize variables */
#if SIZEOF_VOID_P == 8
for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
if (IS_INT_LNG_TYPE(md->params[i].type)) {
- M_AST(rd->argintregs[i], REG_SP, j * 8);
+ s1 = md->params[i].regoff;
+ M_AST(s1, REG_SP, j * 8);
j++;
}
}
if (IS_INT_LNG_TYPE(md->params[i].type)) {
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
- if (IS_2_WORD_TYPE(md->params[i].type)) {
- s1 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
+
+ if (IS_2_WORD_TYPE(md->params[i].type))
M_LST(s1, REG_SP, j * 8);
- }
- else {
- M_IST(rd->argintregs[s1], REG_SP, j * 8);
- }
+ else
+ M_IST(s1, REG_SP, j * 8);
+
j++;
}
}
for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
if (IS_FLT_DBL_TYPE(md->params[i].type)) {
+ s1 = md->params[i].regoff;
+
if (IS_2_WORD_TYPE(md->params[i].type))
- M_DST(rd->argfltregs[i], REG_SP, j * 8);
+ M_DST(s1, REG_SP, j * 8);
else
- M_FST(rd->argfltregs[i], REG_SP, j * 8);
+ M_FST(s1, REG_SP, j * 8);
+
j++;
}
}
#if SIZEOF_VOID_P == 8
for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
if (IS_INT_LNG_TYPE(md->params[i].type)) {
- M_LLD(rd->argintregs[i], REG_SP, j * 8);
+ s1 = md->params[i].regoff;
+ M_LLD(s1, REG_SP, j * 8);
j++;
}
}
if (IS_INT_LNG_TYPE(md->params[i].type)) {
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
- if (IS_2_WORD_TYPE(md->params[i].type)) {
- s1 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
+
+ if (IS_2_WORD_TYPE(md->params[i].type))
M_LLD(s1, REG_SP, j * 8);
- }
- else {
- M_ILD(rd->argintregs[s1], REG_SP, j * 8);
- }
+ else
+ M_ILD(s1, REG_SP, j * 8);
+
j++;
}
}
for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
if (IS_FLT_DBL_TYPE(md->params[i].type)) {
+ s1 = md->params[i].regoff;
+
if (IS_2_WORD_TYPE(md->params[i].type))
- M_DLD(rd->argfltregs[i], REG_SP, j * 8);
+ M_DLD(s1, REG_SP, j * 8);
else
- M_FLD(rd->argfltregs[i], REG_SP, j * 8);
+ M_FLD(s1, REG_SP, j * 8);
+
j++;
}
}
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
-#if SIZEOF_VOID_P == 8
- s1 = rd->argintregs[s1];
-#else
- if (IS_2_WORD_TYPE(t))
- s1 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
- else
- s1 = rd->argintregs[s1];
-#endif
+ s2 = nmd->params[j].regoff;
if (!nmd->params[j].inmemory) {
- s2 = nmd->params[j].regoff;
#if SIZEOF_VOID_P == 8
- s2 = rd->argintregs[s2];
M_INTMOVE(s1, s2);
#else
- if (IS_2_WORD_TYPE(t)) {
- s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s2)],
- rd->argintregs[GET_HIGH_REG(s2)]);
+ if (IS_2_WORD_TYPE(t))
M_LNGMOVE(s1, s2);
- }
- else {
- s2 = rd->argintregs[s2];
+ else
M_INTMOVE(s1, s2);
- }
#endif
}
else {
- s2 = nmd->params[j].regoff;
-
#if SIZEOF_VOID_P == 8
M_LST(s1, REG_SP, s2 * 8);
#else
M_LST(REG_ITMP1, REG_SP, s2 * 8);
#else
if (IS_2_WORD_TYPE(t)) {
- M_LLD(PACK_REGS(REG_ITMP1, REG_ITMP2), REG_SP, s1 * 8);
- M_LST(PACK_REGS(REG_ITMP1, REG_ITMP2), REG_SP, s2 * 4);
+ M_LLD(REG_ITMP12_PACKED, REG_SP, s1 * 8);
+ M_LST(REG_ITMP12_PACKED, REG_SP, s2 * 4);
}
else {
M_ILD(REG_ITMP1, REG_SP, s1 * 8);
if (!nmd->params[j].inmemory) {
#if SIZEOF_VOID_P == 8
- s1 = rd->argfltregs[s1];
- s2 = rd->argfltregs[s2];
if (IS_2_WORD_TYPE(t))
M_DMOV(s1, s2);
else
argument (JNIenv) */
if (IS_2_WORD_TYPE(t)) {
- s1 = rd->argfltregs[s1];
- s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s2)],
- rd->argintregs[GET_HIGH_REG(s2)]);
-
/* double high/low order is endian
independent: even numbered holds low
32-bits, odd numbered high 32-bits */
M_MFC1(GET_LOW_REG(s2), s1); /* low 32-bits */
M_MFC1(GET_HIGH_REG(s2), s1 + 1); /* high 32-bits */
}
- else {
- s1 = rd->argfltregs[s1];
- s2 = rd->argintregs[s2];
+ else
M_MFC1(s2, s1);
- }
#endif
}
else {
#if SIZEOF_VOID_P == 8
- s1 = rd->argfltregs[s1];
-
if (IS_2_WORD_TYPE(t))
M_DST(s1, REG_SP, s2 * 8);
else
but was moved out by the native function
argument(s), just get low register */
- s1 = rd->argfltregs[GET_LOW_REG(s1)];
-
if (IS_2_WORD_TYPE(t))
- M_DST(s1, REG_SP, s2 * 4);
+ M_DST(GET_LOW_REG(s1), REG_SP, s2 * 4);
else
- M_FST(s1, REG_SP, s2 * 4);
+ M_FST(GET_LOW_REG(s1), REG_SP, s2 * 4);
#endif
}
}
/* save return value */
- if (md->returntype.type != TYPE_VOID) {
+ switch (md->returntype.type) {
#if SIZEOF_VOID_P == 8
- if (IS_INT_LNG_TYPE(md->returntype.type))
- M_LST(REG_RESULT, REG_SP, 0 * 8);
- else
- M_DST(REG_FRESULT, REG_SP, 0 * 8);
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LST(REG_RESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DST(REG_FRESULT, REG_SP, 0 * 8);
+ break;
#else
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- M_IST(REG_RESULT, REG_SP, 1*4 + 0 * 8);
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_IST(REG_RESULT2, REG_SP, 1*4 + 0 * 8 + 4);
- }
- else
- M_DST(REG_FRESULT, REG_SP, 1*4 + 0 * 8);
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_IST(REG_RESULT, REG_SP, 1*4 + 0 * 8);
+ break;
+ case TYPE_LNG:
+ M_LST(REG_RESULT_PACKED, REG_SP, 1*4 + 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DST(REG_FRESULT, REG_SP, 1*4 + 0 * 8);
+ break;
#endif
+ case TYPE_VOID:
+ break;
}
#if !defined(NDEBUG)
/* restore return value */
- if (md->returntype.type != TYPE_VOID) {
+ switch (md->returntype.type) {
#if SIZEOF_VOID_P == 8
- if (IS_INT_LNG_TYPE(md->returntype.type))
- M_LLD(REG_RESULT, REG_SP, 0 * 8);
- else
- M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LLD(REG_RESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+ break;
#else
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- M_ILD(REG_RESULT, REG_SP, 1*4 + 0 * 8);
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_ILD(REG_RESULT2, REG_SP, 1*4 + 0 * 8 + 4);
- }
- else
- M_DLD(REG_FRESULT, REG_SP, 1*4 + 0 * 8);
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_ILD(REG_RESULT, REG_SP, 1*4 + 0 * 8);
+ break;
+ case TYPE_LNG:
+ M_LLD(REG_RESULT_PACKED, REG_SP, 1*4 + 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DLD(REG_FRESULT, REG_SP, 1*4 + 0 * 8);
+ break;
#endif
+ case TYPE_VOID:
+ break;
}
M_ALD(REG_RA, REG_SP, (cd->stackframesize - 1) * 8); /* load RA */
#include "vm/exceptions.h"
#include "vm/stringlocal.h" /* XXX for gen_resolvebranch */
+#include "vm/jit/abi.h"
#include "vm/jit/abi-asm.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/dseg.h"
types, so it's correct for MIPS32 too) */
for (i = 0; i < INT_ARG_CNT; i++)
- M_AST(rd->argintregs[i], REG_SP, PA_SIZE + (2 + i) * 8);
+ M_AST(abi_registers_integer_argument[i], REG_SP, PA_SIZE + (2 + i) * 8);
for (i = 0; i < FLT_ARG_CNT; i++)
- M_DST(rd->argfltregs[i], REG_SP, PA_SIZE + (2 + INT_ARG_CNT + i) * 8);
+ M_DST(abi_registers_float_argument[i], REG_SP, PA_SIZE + (2 + INT_ARG_CNT + i) * 8);
/* save temporary registers for leaf methods */
if (IS_FLT_DBL_TYPE(t)) {
if (IS_2_WORD_TYPE(t)) {
- M_DST(rd->argfltregs[i], REG_SP, 0 * 8);
- M_LLD(rd->argintregs[i], REG_SP, 0 * 8);
+ M_DST(abi_registers_float_argument[i], REG_SP, 0 * 8);
+ M_LLD(abi_registers_integer_argument[i], REG_SP, 0 * 8);
}
else {
- M_FST(rd->argfltregs[i], REG_SP, 0 * 8);
- M_ILD(rd->argintregs[i], REG_SP, 0 * 8);
+ M_FST(abi_registers_float_argument[i], REG_SP, 0 * 8);
+ M_ILD(abi_registers_integer_argument[i], REG_SP, 0 * 8);
}
}
}
if (IS_INT_LNG_TYPE(t)) {
if (IS_2_WORD_TYPE(t)) {
- M_ILD(rd->argintregs[j], REG_SP, PA_SIZE + (2 + i) * 8);
- M_ILD(rd->argintregs[j + 1], REG_SP, PA_SIZE + (2 + i) * 8 + 4);
+ M_ILD(abi_registers_integer_argument[j], REG_SP, PA_SIZE + (2 + i) * 8);
+ M_ILD(abi_registers_integer_argument[j + 1], REG_SP, PA_SIZE + (2 + i) * 8 + 4);
}
else {
# if WORDS_BIGENDIAN == 1
- M_MOV(REG_ZERO, rd->argintregs[j]);
- M_ILD(rd->argintregs[j + 1], REG_SP, PA_SIZE + (2 + i) * 8);
+ M_MOV(REG_ZERO, abi_registers_integer_argument[j]);
+ M_ILD(abi_registers_integer_argument[j + 1], REG_SP, PA_SIZE + (2 + i) * 8);
# else
- M_ILD(rd->argintregs[j], REG_SP, PA_SIZE + (2 + i) * 8);
- M_MOV(REG_ZERO, rd->argintregs[j + 1]);
+ M_ILD(abi_registers_integer_argument[j], REG_SP, PA_SIZE + (2 + i) * 8);
+ M_MOV(REG_ZERO, abi_registers_integer_argument[j + 1]);
# endif
}
j += 2;
/* restore argument registers */
for (i = 0; i < INT_ARG_CNT; i++)
- M_ALD(rd->argintregs[i], REG_SP, PA_SIZE + (2 + i) * 8);
+ M_ALD(abi_registers_integer_argument[i], REG_SP, PA_SIZE + (2 + i) * 8);
for (i = 0; i < FLT_ARG_CNT; i++)
- M_DLD(rd->argfltregs[i], REG_SP, PA_SIZE + (2 + INT_ARG_CNT + i) * 8);
+ M_DLD(abi_registers_float_argument[i], REG_SP, PA_SIZE + (2 + INT_ARG_CNT + i) * 8);
/* restore temporary registers for leaf methods */
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: md-abi.c 7699 2007-04-13 10:42:05Z twisti $
+ $Id: md-abi.c 7713 2007-04-15 21:49:48Z twisti $
*/
"t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra"
};
+const s4 abi_registers_integer_argument[] = {
+ 4, /* a0 */
+ 5, /* a1 */
+ 6, /* a2 */
+ 7, /* a3 */
+ 8, /* a4 */
+ 9, /* a5 */
+ 10, /* a6 */
+ 11, /* a7 */
+};
+
+const s4 abi_registers_integer_saved[] = {
+ 16, /* s0 */
+ 17, /* s1 */
+ 18, /* s2 */
+ 19, /* s3 */
+ 20, /* s4 */
+ 21, /* s5 */
+ 22, /* s6 */
+ 23, /* s7 */
+};
+
+const s4 abi_registers_integer_temporary[] = {
+ 12, /* t0 */
+ 13, /* t1 */
+ 14, /* t2 */
+ 15, /* t3 */
+ 24, /* t4 */
+};
+
s4 nregdescfloat[] = {
/* fv0, ftmp1, ftmp2, ftmp3, ft0, ft1, ft2, ft3, */
REG_END
};
+const s4 abi_registers_float_argument[] = {
+ 12, /* fa0 */
+ 13, /* fa1 */
+ 14, /* fa2 */
+ 15, /* fa3 */
+ 16, /* fa4 */
+ 17, /* fa5 */
+ 18, /* fa6 */
+ 19, /* fa7 */
+};
+
+const s4 abi_registers_float_saved[] = {
+ 24, /* fs0 */
+ 26, /* fs1 */
+ 28, /* fs2 */
+ 30, /* fs3 */
+};
+
+const s4 abi_registers_float_temporary[] = {
+ 4, /* ft0 */
+ 5, /* ft1 */
+ 6, /* ft2 */
+ 7, /* ft3 */
+ 8, /* ft4 */
+ 9, /* ft5 */
+ 10, /* ft6 */
+ 11, /* ft7 */
+ 20, /* ft8 */
+ 21, /* ft9 */
+ 22, /* ft10 */
+ 23, /* ft11 */
+ 25, /* ft12 */
+ 27, /* ft13 */
+ 29, /* ft14 */
+ 31, /* ft15 */
+};
+
#else /* SIZEOF_VOID_P == 8 */
/* MIPS32 */
"t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra"
};
+const s4 abi_registers_integer_argument[] = {
+ 4, /* a0 */
+ 5, /* a1 */
+ 6, /* a2 */
+ 7, /* a3 */
+};
+
+const s4 abi_registers_integer_saved[] = {
+ 16, /* s0 */
+ 17, /* s1 */
+ 18, /* s2 */
+ 19, /* s3 */
+ 20, /* s4 */
+ 21, /* s5 */
+ 22, /* s6 */
+ 23, /* s7 */
+};
+
+const s4 abi_registers_integer_temporary[] = {
+ 8, /* t0 */
+ 9, /* t1 */
+ 10, /* t2 */
+ 11, /* t3 */
+ 12, /* t4 */
+ 13, /* t5 */
+ 14, /* t6 */
+ 15, /* t7 */
+};
+
#if !defined(ENABLE_SOFT_FLOAT)
REG_END
};
+const s4 abi_registers_float_argument[] = {
+ 12, /* fa0 */
+ 14, /* fa1 */
+};
+
+const s4 abi_registers_float_saved[] = {
+ 20, /* fs0 */
+ 22, /* fs1 */
+ 24, /* fs2 */
+ 26, /* fs3 */
+ 28, /* fs4 */
+ 30, /* fs5 */
+};
+
+const s4 abi_registers_float_temporary[] = {
+ 8, /* ft0 */
+ 10, /* ft1 */
+ 16, /* ft2 */
+ 18, /* ft3 */
+};
+
+
#else /* !defined(ENABLE_SOFT_FLOAT) */
s4 nregdescfloat[] = {
/* set default values */
- reguse = 0;
- stacksize = 0;
+ reguse = 0;
+ stacksize = 0;
#if SIZEOF_VOID_P == 4 && !defined(ENABLE_SOFT_FLOAT)
a0_is_float = false;
#endif
case TYPE_LNG:
if (i < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_integer_argument[reguse];
reguse++;
md->argintreguse = reguse;
}
case TYPE_DBL:
if (i < FLT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_float_argument[reguse];
reguse++;
md->argfltreguse = reguse;
}
((i == 0) ||
((i == 1) && IS_FLT_DBL_TYPE(md->paramtypes[0].type)))) {
if (IS_2_WORD_TYPE(t)) {
- pd->type = TYPE_DBL;
- pd->regoff = reguse;
+ pd->type = TYPE_DBL;
+ pd->regoff = abi_registers_float_argument[reguse];
reguse++;
stacksize += 2;
}
else {
- pd->type = TYPE_FLT;
- pd->regoff = reguse;
+ pd->type = TYPE_FLT;
+ pd->regoff = abi_registers_float_argument[reguse];
reguse++;
stacksize++;
}
if (reguse < INT_ARG_CNT) {
pd->inmemory = false;
# if WORDS_BIGENDIAN == 1
- pd->regoff = PACK_REGS(reguse + 1, reguse);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse + 1],
+ abi_registers_integer_argument[reguse]);
# else
- pd->regoff = PACK_REGS(reguse, reguse + 1);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse],
+ abi_registers_integer_argument[reguse + 1]);
# endif
reguse += 2;
md->argintreguse = reguse;
if (reguse < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_integer_argument[reguse];
reguse++;
md->argintreguse = reguse;
}
else {
pd->inmemory = true;
- pd->regoff = stacksize;
+ pd->regoff = stacksize;
}
stacksize++;
}
if (i < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = reguse;
+ pd->regoff = abi_registers_integer_argument[reguse];
reguse++;
md->argintreguse = reguse;
}
if (i < INT_ARG_CNT) {
pd->inmemory = false;
#if WORDS_BIGENDIAN == 1
- pd->regoff = PACK_REGS(reguse + 1, reguse);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse + 1],
+ abi_registers_integer_argument[reguse]);
#else
- pd->regoff = PACK_REGS(reguse, reguse + 1);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[reguse],
+ abi_registers_integer_argument[reguse + 1]);
#endif
reguse += 2;
md->argintreguse = reguse;
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 7692 2007-04-12 14:47:24Z twisti $
+ $Id: codegen.c 7713 2007-04-15 21:49:48Z twisti $
*/
#include "vm/stringlocal.h"
#include "vm/vm.h"
+#include "vm/jit/abi.h"
#include "vm/jit/abi-asm.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/codegen-common.h"
continue;
var = VAR(varindex);
+ s1 = md->params[p].regoff;
- s1 = md->params[p].regoff;
- if (IS_INT_LNG_TYPE(t)) { /* integer args */
- if (IS_2_WORD_TYPE(t))
- s2 = PACK_REGS(rd->argintregs[GET_LOW_REG(s1)],
- rd->argintregs[GET_HIGH_REG(s1)]);
- else
- s2 = rd->argintregs[s1];
- if (!md->params[p].inmemory) { /* register arguments */
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
+ if (IS_INT_LNG_TYPE(t)) {
+ if (!md->params[p].inmemory) {
+ if (!IS_INMEMORY(var->flags)) {
if (IS_2_WORD_TYPE(t))
- M_LNGMOVE(s2, var->vv.regoff);
+ M_LNGMOVE(s1, var->vv.regoff);
else
- M_INTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
+ M_INTMOVE(s1, var->vv.regoff);
+ }
+ else {
if (IS_2_WORD_TYPE(t))
- M_LST(s2, REG_SP, var->vv.regoff * 4);
+ M_LST(s1, REG_SP, var->vv.regoff * 4);
else
- M_IST(s2, REG_SP, var->vv.regoff * 4);
+ M_IST(s1, REG_SP, var->vv.regoff * 4);
}
-
- } else { /* stack arguments */
- if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
+ }
+ else {
+ if (!IS_INMEMORY(var->flags)) {
if (IS_2_WORD_TYPE(t))
M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
else
M_ILD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
-
- } else { /* stack arg -> spilled */
+ }
+ else {
#if 1
M_ILD(REG_ITMP1, REG_SP, (cd->stackframesize + s1) * 4);
M_IST(REG_ITMP1, REG_SP, var->vv.regoff * 4);
#endif
}
}
-
- } else { /* floating args */
- if (!md->params[p].inmemory) { /* register arguments */
- s2 = rd->argfltregs[s1];
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
- M_FLTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
+ }
+ else {
+ if (!md->params[p].inmemory) {
+ if (!IS_INMEMORY(var->flags))
+ M_FLTMOVE(s1, var->vv.regoff);
+ else {
if (IS_2_WORD_TYPE(t))
- M_DST(s2, REG_SP, var->vv.regoff * 4);
+ M_DST(s1, REG_SP, var->vv.regoff * 4);
else
- M_FST(s2, REG_SP, var->vv.regoff * 4);
+ M_FST(s1, REG_SP, var->vv.regoff * 4);
}
-
- } else { /* stack arguments */
- if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
+ }
+ else {
+ if (!IS_INMEMORY(var->flags)) {
if (IS_2_WORD_TYPE(t))
M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
-
else
M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 4);
-
- } else { /* stack-arg -> spilled */
+ }
+ else {
#if 1
if (IS_2_WORD_TYPE(t)) {
M_DLD(REG_FTMP1, REG_SP, (cd->stackframesize + s1) * 4);
}
}
}
- } /* end for */
+ }
#if defined(ENABLE_THREADS)
/* call monitorenter function */
M_AADD_IMM(REG_SP, -((LA_SIZE_IN_POINTERS + ARG_CNT) * 8), REG_SP);
for (p = 0; p < INT_ARG_CNT; p++)
- M_IST(rd->argintregs[p], REG_SP, LA_SIZE + p * 8);
+ M_IST(abi_registers_integer_argument[p], REG_SP, LA_SIZE + p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DST(rd->argfltregs[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
+ M_DST(abi_registers_float_argument[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
/* ATTENTION: We multiply here with 2, because we use * 8
above for simplicity and below * 4! */
}
# endif
- p = dseg_add_functionptr(cd, LOCK_monitor_enter);
- M_ALD(REG_ITMP3, REG_PV, p);
+ disp = dseg_add_functionptr(cd, LOCK_monitor_enter);
+ M_ALD(REG_ITMP3, REG_PV, disp);
M_MTCTR(REG_ITMP3);
/* get or test the lock object */
if (m->flags & ACC_STATIC) {
- p = dseg_add_address(cd, &m->class->object.header);
- M_ALD(REG_A0, REG_PV, p);
+ disp = dseg_add_address(cd, &m->class->object.header);
+ M_ALD(REG_A0, REG_PV, disp);
}
else {
M_TST(REG_A0);
# if !defined(NDEBUG)
if (JITDATA_HAS_FLAG_VERBOSECALL(jd)) {
for (p = 0; p < INT_ARG_CNT; p++)
- M_ILD(rd->argintregs[p], REG_SP, LA_SIZE + p * 8);
+ M_ILD(abi_registers_integer_argument[p], REG_SP, LA_SIZE + p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DLD(rd->argfltregs[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
+ M_DLD(abi_registers_float_argument[p], REG_SP, LA_SIZE + (INT_ARG_CNT + p) * 8);
M_AADD_IMM(REG_SP, (LA_SIZE_IN_POINTERS + ARG_CNT) * 8, REG_SP);
}
case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */
- bte = iptr->sx.s23.s3.bte;
- md = bte->md;
+ s1 = emit_load_s1(jd, iptr, REG_A0_A1_PACKED);
+ s2 = emit_load_s2(jd, iptr, REG_A2_A3_PACKED);
- s2 = emit_load_s2(jd, iptr, REG_ITMP12_PACKED);
+ /* XXX TODO: only do this if arithmetic check is really done! */
M_OR_TST(GET_HIGH_REG(s2), GET_LOW_REG(s2), REG_ITMP3);
/* XXX could be optimized */
emit_arithmetic_check(cd, iptr, REG_ITMP3);
+ bte = iptr->sx.s23.s3.bte;
disp = dseg_add_functionptr(cd, bte->fp);
M_ALD(REG_ITMP3, REG_PV, disp);
M_MTCTR(REG_ITMP3);
- s3 = PACK_REGS(rd->argintregs[GET_LOW_REG(md->params[1].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[1].regoff)]);
- M_LNGMOVE(s2, s3);
-
- s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
- s3 = PACK_REGS(rd->argintregs[GET_LOW_REG(md->params[0].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[0].regoff)]);
- M_LNGMOVE(s1, s3);
+ M_LNGMOVE(s1, REG_A0_A1_PACKED);
+ M_LNGMOVE(s2, REG_A2_A3_PACKED);
M_JSR;
for (s3 = s3 - 1; s3 >= 0; s3--) {
var = VAR(iptr->sx.s23.s2.args[s3]);
+ d = md->params[s3].regoff;
/* Already Preallocated? */
if (var->flags & PREALLOC)
if (IS_INT_LNG_TYPE(var->type)) {
if (!md->params[s3].inmemory) {
if (IS_2_WORD_TYPE(var->type)) {
- s1 = PACK_REGS(
- rd->argintregs[GET_LOW_REG(md->params[s3].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[s3].regoff)]);
- d = emit_load(jd, iptr, var, s1);
- M_LNGMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_LNGMOVE(s1, d);
}
else {
- s1 = rd->argintregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_INTMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_INTMOVE(s1, d);
}
}
else {
if (IS_2_WORD_TYPE(var->type)) {
- d = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
- M_LST(d, REG_SP, md->params[s3].regoff * 4);
+ s1 = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
+ M_LST(s1, REG_SP, d * 4);
}
else {
- d = emit_load(jd, iptr, var, REG_ITMP1);
- M_IST(d, REG_SP, md->params[s3].regoff * 4);
+ s1 = emit_load(jd, iptr, var, REG_ITMP1);
+ M_IST(s1, REG_SP, d * 4);
}
}
}
else {
if (!md->params[s3].inmemory) {
- s1 = rd->argfltregs[md->params[s3].regoff];
- d = emit_load(jd, iptr, var, s1);
- M_FLTMOVE(d, s1);
+ s1 = emit_load(jd, iptr, var, d);
+ M_FLTMOVE(s1, d);
}
else {
- d = emit_load(jd, iptr, var, REG_FTMP1);
+ s1 = emit_load(jd, iptr, var, REG_FTMP1);
if (IS_2_WORD_TYPE(var->type))
- M_DST(d, REG_SP, md->params[s3].regoff * 4);
+ M_DST(s1, REG_SP, d * 4);
else
- M_FST(d, REG_SP, md->params[s3].regoff * 4);
+ M_FST(s1, REG_SP, d * 4);
}
}
}
void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
{
- methodinfo *m;
- codeinfo *code;
- codegendata *cd;
- registerdata *rd;
- methoddesc *md;
- s4 nativeparams;
- s4 i, j; /* count variables */
- s4 t;
- s4 s1, s2, disp;
- s4 funcdisp;
+ methodinfo *m;
+ codeinfo *code;
+ codegendata *cd;
+ methoddesc *md;
+ s4 nativeparams;
+ s4 i, j; /* count variables */
+ s4 t;
+ s4 s1, s2, disp;
+ s4 funcdisp;
/* get required compiler data */
m = jd->m;
code = jd->code;
cd = jd->cd;
- rd = jd->rd;
/* set some variables */
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
+
if (IS_2_WORD_TYPE(t)) {
- M_IST(rd->argintregs[GET_HIGH_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
+ M_IST(GET_HIGH_REG(s1), REG_SP, LA_SIZE + 4 * 4 + j * 4);
j++;
- M_IST(rd->argintregs[GET_LOW_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- } else {
- M_IST(rd->argintregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 4);
+ M_IST(GET_LOW_REG(s1), REG_SP, LA_SIZE + 4 * 4 + j * 4);
}
+ else
+ M_IST(s1, REG_SP, LA_SIZE + 4 * 4 + j * 4);
+
j++;
}
}
if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
- M_DST(rd->argfltregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 8);
+ M_DST(s1, REG_SP, LA_SIZE + 4 * 4 + j * 8);
j++;
}
}
s1 = md->params[i].regoff;
if (IS_2_WORD_TYPE(t)) {
- M_ILD(rd->argintregs[GET_HIGH_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
+ M_ILD(GET_HIGH_REG(s1), REG_SP, LA_SIZE + 4 * 4 + j * 4);
j++;
- M_ILD(rd->argintregs[GET_LOW_REG(s1)], REG_SP, LA_SIZE + 4 * 4 + j * 4);
- } else {
- M_ILD(rd->argintregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 4);
+ M_ILD(GET_LOW_REG(s1), REG_SP, LA_SIZE + 4 * 4 + j * 4);
}
+ else
+ M_ILD(s1, REG_SP, LA_SIZE + 4 * 4 + j * 4);
+
j++;
}
}
if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
- M_DLD(rd->argfltregs[s1], REG_SP, LA_SIZE + 4 * 4 + j * 8);
+ M_DLD(s1, REG_SP, LA_SIZE + 4 * 4 + j * 8);
j++;
}
}
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[i].inmemory) {
- if (IS_2_WORD_TYPE(t))
- s1 = PACK_REGS(
- rd->argintregs[GET_LOW_REG(md->params[i].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[i].regoff)]);
- else
- s1 = rd->argintregs[md->params[i].regoff];
+ s1 = md->params[i].regoff;
+ s2 = nmd->params[j].regoff;
if (!nmd->params[j].inmemory) {
- if (IS_2_WORD_TYPE(t)) {
- s2 = PACK_REGS(
- rd->argintregs[GET_LOW_REG(nmd->params[j].regoff)],
- rd->argintregs[GET_HIGH_REG(nmd->params[j].regoff)]);
+ if (IS_2_WORD_TYPE(t))
M_LNGMOVE(s1, s2);
- } else {
- s2 = rd->argintregs[nmd->params[j].regoff];
+ else
M_INTMOVE(s1, s2);
- }
-
- } else {
- s2 = nmd->params[j].regoff;
+ }
+ else {
if (IS_2_WORD_TYPE(t))
M_LST(s1, REG_SP, s2 * 4);
else
M_IST(s1, REG_SP, s2 * 4);
}
-
- } else {
+ }
+ else {
s1 = md->params[i].regoff + cd->stackframesize;
s2 = nmd->params[j].regoff;
if (IS_2_WORD_TYPE(t))
M_IST(REG_ITMP2, REG_SP, s2 * 4 + 4);
}
-
- } else {
+ }
+ else {
/* We only copy spilled float arguments, as the float
argument registers keep unchanged. */
if (IS_2_WORD_TYPE(t)) {
M_DLD(REG_FTMP1, REG_SP, s1 * 4);
M_DST(REG_FTMP1, REG_SP, s2 * 4);
-
- } else {
+ }
+ else {
M_FLD(REG_FTMP1, REG_SP, s1 * 4);
M_FST(REG_FTMP1, REG_SP, s2 * 4);
}
/* save return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_IST(REG_RESULT2, REG_SP, LA_SIZE + 2 * 4);
- M_IST(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
- }
- else {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_DST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- else
- M_FST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- }
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_IST(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_LNG:
+ M_LST(REG_RESULT_PACKED, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_FLT:
+ M_FST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_DBL:
+ M_DST(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_VOID:
+ break;
}
/* remove native stackframe info */
/* restore return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type)) {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_ILD(REG_RESULT2, REG_SP, LA_SIZE + 2 * 4);
- M_ILD(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
- }
- else {
- if (IS_2_WORD_TYPE(md->returntype.type))
- M_DLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- else
- M_FLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
- }
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_ADR:
+ M_ILD(REG_RESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_LNG:
+ M_LLD(REG_RESULT_PACKED, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_FLT:
+ M_FLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_DBL:
+ M_DLD(REG_FRESULT, REG_SP, LA_SIZE + 1 * 4);
+ break;
+ case TYPE_VOID:
+ break;
}
M_ALD(REG_ITMP2_XPC, REG_SP, cd->stackframesize * 4 + LA_LR_OFFSET);
#include "vm/builtin.h"
#include "vm/exceptions.h"
+#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/codegen-common.h"
#include "vm/jit/dseg.h"
/* integer argument regs */
/* all integer argument registers have to be saved */
for (p = 0; p < 8; p++) {
- d = rd->argintregs[p];
+ d = abi_registers_integer_argument[p];
/* save integer argument registers */
M_IST(d, REG_SP, LA_SIZE + 4 * 8 + 4 + p * 4);
}
p = 4;
#endif
stack_off = LA_SIZE;
+
for (; p < md->paramcount && p < TRACE_ARGS_NUM; p++, stack_off += 8) {
t = md->paramtypes[p].type;
+
if (IS_INT_LNG_TYPE(t)) {
- if (!md->params[p].inmemory) { /* Param in Arg Reg */
+ if (!md->params[p].inmemory) {
+ s1 = md->params[p].regoff;
+
if (IS_2_WORD_TYPE(t)) {
- M_IST(rd->argintregs[GET_HIGH_REG(md->params[p].regoff)]
- , REG_SP, stack_off);
- M_IST(rd->argintregs[GET_LOW_REG(md->params[p].regoff)]
- , REG_SP, stack_off + 4);
- } else {
+ M_IST(GET_HIGH_REG(s1), REG_SP, stack_off);
+ M_IST(GET_LOW_REG(s1), REG_SP, stack_off + 4);
+ }
+ else {
M_IST(REG_ITMP1, REG_SP, stack_off);
- M_IST(rd->argintregs[md->params[p].regoff]
- , REG_SP, stack_off + 4);
+ M_IST(s1, REG_SP, stack_off + 4);
}
- } else { /* Param on Stack */
+ }
+ else {
s1 = (md->params[p].regoff + cd->stackframesize) * 4
+ stack_size;
if (IS_2_WORD_TYPE(t)) {
M_IST(REG_ITMP2, REG_SP, stack_off);
M_ILD(REG_ITMP2, REG_SP, s1 + 4);
M_IST(REG_ITMP2, REG_SP, stack_off + 4);
- } else {
+ }
+ else {
M_IST(REG_ITMP1, REG_SP, stack_off);
M_ILD(REG_ITMP2, REG_SP, s1);
M_IST(REG_ITMP2, REG_SP, stack_off + 4);
}
}
- } else { /* IS_FLT_DBL_TYPE(t) */
- if (!md->params[p].inmemory) { /* in Arg Reg */
- s1 = rd->argfltregs[md->params[p].regoff];
+ }
+ else {
+ if (!md->params[p].inmemory) {
+ s1 = md->params[p].regoff;
+
if (!IS_2_WORD_TYPE(t)) {
M_IST(REG_ITMP1, REG_SP, stack_off);
M_FST(s1, REG_SP, stack_off + 4);
- } else {
- M_DST(s1, REG_SP, stack_off);
}
- } else { /* on Stack */
+ else
+ M_DST(s1, REG_SP, stack_off);
+ }
+ else {
/* this should not happen */
}
}
/* load first 4 (==INT_ARG_CNT/2) arguments into integer registers */
#if defined(__DARWIN__)
for (p = 0; p < 8; p++) {
- d = rd->argintregs[p];
+ d = abi_registers_integer_argument[p];
M_ILD(d, REG_SP, LA_SIZE + p * 4);
}
#else
/* LINUX */
/* Set integer and float argument registers vor trace_args call */
/* offset to saved integer argument registers */
+
stack_off = LA_SIZE + 4 * 8 + 4;
+
for (p = 0; (p < 4) && (p < md->paramcount); p++) {
t = md->paramtypes[p].type;
+
if (IS_INT_LNG_TYPE(t)) {
/* "stretch" int types */
if (!IS_2_WORD_TYPE(t)) {
- M_CLR(rd->argintregs[2 * p]);
- M_ILD(rd->argintregs[2 * p + 1], REG_SP,stack_off);
+ M_CLR(abi_registers_integer_argument[2 * p]);
+ M_ILD(abi_registers_integer_argument[2 * p + 1], REG_SP,stack_off);
stack_off += 4;
- } else {
- M_ILD(rd->argintregs[2 * p + 1], REG_SP,stack_off + 4);
- M_ILD(rd->argintregs[2 * p], REG_SP,stack_off);
+ }
+ else {
+ M_ILD(abi_registers_integer_argument[2 * p + 1], REG_SP,stack_off + 4);
+ M_ILD(abi_registers_integer_argument[2 * p], REG_SP,stack_off);
stack_off += 8;
}
- } else { /* Float/Dbl */
- if (!md->params[p].inmemory) { /* Param in Arg Reg */
+ }
+ else {
+ if (!md->params[p].inmemory) {
/* use reserved Place on Stack (sp + 5 * 16) to copy */
/* float/double arg reg to int reg */
- s1 = rd->argfltregs[md->params[p].regoff];
+
+ s1 = md->params[p].regoff;
+
if (!IS_2_WORD_TYPE(t)) {
M_FST(s1, REG_SP, 5 * 16);
- M_ILD(rd->argintregs[2 * p + 1], REG_SP, 5 * 16);
- M_CLR(rd->argintregs[2 * p]);
- } else {
+ M_ILD(abi_registers_integer_argument[2 * p + 1], REG_SP, 5 * 16);
+ M_CLR(abi_registers_integer_argument[2 * p]);
+ }
+ else {
M_DST(s1, REG_SP, 5 * 16);
- M_ILD(rd->argintregs[2 * p + 1], REG_SP, 5 * 16 + 4);
- M_ILD(rd->argintregs[2 * p], REG_SP, 5 * 16);
+ M_ILD(abi_registers_integer_argument[2 * p + 1], REG_SP, 5 * 16 + 4);
+ M_ILD(abi_registers_integer_argument[2 * p], REG_SP, 5 * 16);
}
}
}
/* restore integer argument registers from the reserved stack space */
stack_off = LA_SIZE;
- for (p = 0; p < md->paramcount && p < TRACE_ARGS_NUM;
- p++, stack_off += 8) {
+
+ for (p = 0; p < md->paramcount && p < TRACE_ARGS_NUM; p++, stack_off += 8) {
t = md->paramtypes[p].type;
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[p].inmemory) {
+ s1 = md->params[p].regoff;
+
if (IS_2_WORD_TYPE(t)) {
- M_ILD(rd->argintregs[GET_HIGH_REG(md->params[p].regoff)]
- , REG_SP, stack_off);
- M_ILD(rd->argintregs[GET_LOW_REG(md->params[p].regoff)]
- , REG_SP, stack_off + 4);
- } else {
- M_ILD(rd->argintregs[md->params[p].regoff]
- , REG_SP, stack_off + 4);
+ M_ILD(GET_HIGH_REG(s1), REG_SP, stack_off);
+ M_ILD(GET_LOW_REG(s1), REG_SP, stack_off + 4);
}
+ else
+ M_ILD(s1, REG_SP, stack_off + 4);
}
}
}
#else
/* LINUX */
for (p = 0; p < 8; p++) {
- d = rd->argintregs[p];
+ d = abi_registers_integer_argument[p];
/* save integer argument registers */
M_ILD(d, REG_SP, LA_SIZE + 4 * 8 + 4 + p * 4);
}
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: md-abi.c 7330 2007-02-11 21:39:54Z twisti $
+ $Id: md-abi.c 7713 2007-04-15 21:49:48Z twisti $
*/
case TYPE_ADR:
if (iarg < INT_ARG_CNT) {
pd->inmemory = false;
-/* pd->regoff = abi_registers_integer_argument[iarg]; */
- pd->regoff = iarg;
+ pd->regoff = abi_registers_integer_argument[iarg];
iarg++;
}
else {
if (iarg < INT_ARG_CNT - 1) {
_ALIGN(iarg);
pd->inmemory = false;
-/* pd->regoff = */
-/* PACK_REGS(abi_registers_integer_argument[iarg + 1], */
-/* abi_registers_integer_argument[iarg]); */
- pd->regoff = PACK_REGS(iarg + 1, iarg);
+ pd->regoff =
+ PACK_REGS(abi_registers_integer_argument[iarg + 1],
+ abi_registers_integer_argument[iarg]);
iarg += 2;
}
else {
case TYPE_FLT:
if (farg < FLT_ARG_CNT) {
pd->inmemory = false;
-/* pd->regoff = abi_registers_float_argument[farg]; */
- pd->regoff = farg;
+ pd->regoff = abi_registers_float_argument[farg];
farg++;
}
else {
case TYPE_DBL:
if (farg < FLT_ARG_CNT) {
pd->inmemory = false;
-/* pd->regoff = abi_registers_integer_argument[farg]; */
- pd->regoff = farg;
+ pd->regoff = abi_registers_float_argument[farg];
farg++;
}
else {
md->argintreguse = iarg;
md->argfltreguse = farg;
- md->memuse = stacksize;
+ md->memuse = stacksize;
}
/* src/vm/jit/powerpc/linux/md-abi.h - defines for PowerPC Linux ABI
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
J. Wenninger, Institut f. Computersprachen - TU Wien
Changes:
- $Id: md-abi.h 7356 2007-02-14 11:00:28Z twisti $
+ $Id: md-abi.h 7713 2007-04-15 21:49:48Z twisti $
*/
#define REG_RESULT_PACKED PACK_REGS(REG_RESULT2, REG_RESULT)
#define REG_A0_A1_PACKED PACK_REGS(REG_A1, REG_A0)
+#define REG_A2_A3_PACKED PACK_REGS(REG_A3, REG_A2)
#define REG_ITMP12_PACKED PACK_REGS(REG_ITMP2, REG_ITMP1)
#define REG_ITMP23_PACKED PACK_REGS(REG_ITMP3, REG_ITMP2)
/* src/vm/jit/reg.c - register allocator setup
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
J. Wenninger, Institut f. Computersprachen - TU Wien
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Andreas Krall
-
- Changes: Stefan Ring
- Christian Thalinger
- Christian Ullrich
- Michael Starzinger
- Edwin Steiner
-
- $Id: reg.c 7596 2007-03-28 21:05:53Z twisti $
+ $Id: reg.c 7713 2007-04-15 21:49:48Z twisti $
*/
/* setup the integer register table */
-#if defined(__ARM__)
- /* On ARM longs can be split across argument regs and stack. This is
- * signed by setting the HIGH_REG to INT_ARG_CNT in md_param_alloc().
- * Here we make sure it resolves to a special dummy reg (REG_SPLIT). */
- rd->argintregs = DMNEW(s4, INT_ARG_CNT + 1);
- rd->argintregs[INT_ARG_CNT] = REG_SPLIT;
-#else
- rd->argintregs = DMNEW(s4, INT_ARG_CNT);
-#endif
rd->tmpintregs = DMNEW(s4, INT_TMP_CNT);
rd->savintregs = DMNEW(s4, INT_SAV_CNT);
rd->freeargintregs = DMNEW(s4, INT_ARG_CNT);
case REG_TMP:
rd->tmpintregs[rd->tmpintreguse++] = i;
break;
- case REG_ARG:
- rd->argintregs[rd->argintreguse++] = i;
- break;
}
}
assert(rd->savintreguse == INT_SAV_CNT);
assert(rd->tmpintreguse == INT_TMP_CNT);
- assert(rd->argintreguse == INT_ARG_CNT);
-
-#if defined(__X86_64__)
- /*
- * on x86_64 the argument registers are not in ascending order
- * a00 (%rdi) <-> a03 (%rcx) and a01 (%rsi) <-> a02 (%rdx)
- */
- i = rd->argintregs[3];
- rd->argintregs[3] = rd->argintregs[0];
- rd->argintregs[0] = i;
-
- i = rd->argintregs[2];
- rd->argintregs[2] = rd->argintregs[1];
- rd->argintregs[1] = i;
-#endif
-
+
#ifdef HAS_ADDRESS_REGISTER_FILE
/* setup the address register table */
/* setup the float register table */
- rd->argfltregs = DMNEW(s4, FLT_ARG_CNT);
rd->tmpfltregs = DMNEW(s4, FLT_TMP_CNT);
rd->savfltregs = DMNEW(s4, FLT_SAV_CNT);
rd->freeargfltregs = DMNEW(s4, FLT_ARG_CNT);
case REG_TMP:
rd->tmpfltregs[rd->tmpfltreguse++] = i;
break;
- case REG_ARG:
- rd->argfltregs[rd->argfltreguse++] = i;
- break;
}
}
assert(rd->savfltreguse == FLT_SAV_CNT);
assert(rd->tmpfltreguse == FLT_TMP_CNT);
- assert(rd->argfltreguse == FLT_ARG_CNT);
rd->freemem = DMNEW(s4, m->maxstack);
/* src/vm/jit/reg.h - register allocator header
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+ Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
J. Wenninger, Institut f. Computersprachen - TU Wien
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Christian Thalinger
-
- Changes: Christian Ullrich
- Edwin Steiner
-
- $Id: reg.h 5708 2006-10-06 22:37:13Z edwin $
+ $Id: reg.h 7713 2007-04-15 21:49:48Z twisti $
*/
int intreg_ret; /* register to return integer values */
int fltreg_ret; /* register for return float values */
- int *argintregs; /* argument integer registers */
int *tmpintregs; /* scratch integer registers */
int *savintregs; /* saved integer registers */
- int *argfltregs; /* argument float registers */
int *tmpfltregs; /* scratch float registers */
int *savfltregs; /* saved float registers */
int *freeargintregs; /* free argument integer registers */
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: stack.c 7695 2007-04-12 19:49:34Z twisti $
+ $Id: stack.c 7713 2007-04-15 21:49:48Z twisti $
*/
assert(0); /* XXX is this assert ok? */
#else
sd.var[copy->varnum].vv.regoff =
- rd->argfltregs[md->params[i].regoff];
+ md->params[i].regoff;
#endif /* SUPPORT_PASS_FLOATARGS_IN_INTREGS */
}
else {
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
if (IS_2_WORD_TYPE(copy->type))
sd.var[copy->varnum].vv.regoff =
- PACK_REGS( rd->argintregs[GET_LOW_REG(md->params[i].regoff)],
- rd->argintregs[GET_HIGH_REG(md->params[i].regoff)]);
+ PACK_REGS(GET_LOW_REG(md->params[i].regoff),
+ GET_HIGH_REG(md->params[i].regoff));
else
#endif /* SUPPORT_COMBINE_INTEGER_REGISTERS */
sd.var[copy->varnum].vv.regoff =
- rd->argintregs[md->params[i].regoff];
+ md->params[i].regoff;
}
}
}
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: codegen.c 7692 2007-04-12 14:47:24Z twisti $
+ $Id: codegen.c 7713 2007-04-15 21:49:48Z twisti $
*/
#include "vm/stringlocal.h"
#include "vm/vm.h"
+#include "vm/jit/abi.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/codegen-common.h"
#include "vm/jit/dseg.h"
s1 = md->params[p].regoff;
if (IS_INT_LNG_TYPE(t)) { /* integer args */
- s2 = rd->argintregs[s1];
if (!md->params[p].inmemory) { /* register arguments */
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
- M_INTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
- M_LST(s2, REG_SP, var->vv.regoff * 8);
- }
-
- } else { /* stack arguments */
- if (!IS_INMEMORY(var->flags)) { /* stack arg -> register */
+ if (!IS_INMEMORY(var->flags))
+ M_INTMOVE(s1, var->vv.regoff);
+ else
+ M_LST(s1, REG_SP, var->vv.regoff * 8);
+ }
+ else { /* stack arguments */
+ if (!IS_INMEMORY(var->flags))
/* + 8 for return address */
M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8 + 8);
-
- } else { /* stack arg -> spilled */
+ else
var->vv.regoff = cd->stackframesize + s1 + 1;
- }
}
-
- } else { /* floating args */
+ }
+ else { /* floating args */
if (!md->params[p].inmemory) { /* register arguments */
- s2 = rd->argfltregs[s1];
- if (!IS_INMEMORY(var->flags)) { /* reg arg -> register */
- M_FLTMOVE(s2, var->vv.regoff);
-
- } else { /* reg arg -> spilled */
- M_DST(s2, REG_SP, var->vv.regoff * 8);
- }
-
- } else { /* stack arguments */
- if (!IS_INMEMORY(var->flags)) { /* stack-arg -> register */
+ if (!IS_INMEMORY(var->flags))
+ M_FLTMOVE(s1, var->vv.regoff);
+ else
+ M_DST(s1, REG_SP, var->vv.regoff * 8);
+ }
+ else { /* stack arguments */
+ if (!IS_INMEMORY(var->flags))
M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8 + 8);
-
- } else {
+ else
var->vv.regoff = cd->stackframesize + s1 + 1;
- }
}
}
- } /* end for */
+ }
/* save monitorenter argument */
M_LSUB_IMM((INT_ARG_CNT + FLT_ARG_CNT) * 8, REG_SP);
for (p = 0; p < INT_ARG_CNT; p++)
- M_LST(rd->argintregs[p], REG_SP, p * 8);
+ M_LST(abi_registers_integer_argument[p], REG_SP, p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DST(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+ M_DST(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
s1 += INT_ARG_CNT + FLT_ARG_CNT;
}
if (opt_verbosecall) {
for (p = 0; p < INT_ARG_CNT; p++)
- M_LLD(rd->argintregs[p], REG_SP, p * 8);
+ M_LLD(abi_registers_integer_argument[p], REG_SP, p * 8);
for (p = 0; p < FLT_ARG_CNT; p++)
- M_DLD(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+ M_DLD(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
M_LADD_IMM((INT_ARG_CNT + FLT_ARG_CNT) * 8, REG_SP);
}
if (IS_INT_LNG_TYPE(var->type)) {
if (!md->params[s3].inmemory) {
- s1 = rd->argintregs[md->params[s3].regoff];
+ s1 = md->params[s3].regoff;
d = emit_load(jd, iptr, var, s1);
M_INTMOVE(d, s1);
}
}
else {
if (!md->params[s3].inmemory) {
- s1 = rd->argfltregs[md->params[s3].regoff];
+ s1 = md->params[s3].regoff;
d = emit_load(jd, iptr, var, s1);
M_FLTMOVE(d, s1);
}
void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
{
- methodinfo *m;
- codeinfo *code;
- codegendata *cd;
- registerdata *rd;
- methoddesc *md;
- s4 nativeparams;
- s4 i, j; /* count variables */
- s4 t;
- s4 s1, s2;
+ methodinfo *m;
+ codeinfo *code;
+ codegendata *cd;
+ methoddesc *md;
+ s4 nativeparams;
+ s4 i, j;
+ s4 t;
+ s4 s1, s2;
/* get required compiler data */
m = jd->m;
code = jd->code;
cd = jd->cd;
- rd = jd->rd;
/* initialize variables */
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
- if (IS_INT_LNG_TYPE(md->paramtypes[i].type))
- M_LST(rd->argintregs[s1], REG_SP, j * 8);
- else
- M_DST(rd->argfltregs[s1], REG_SP, j * 8);
+ switch (md->paramtypes[i].type) {
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LST(s1, REG_SP, j * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DST(s1, REG_SP, j * 8);
+ break;
+ }
j++;
}
if (!md->params[i].inmemory) {
s1 = md->params[i].regoff;
- if (IS_INT_LNG_TYPE(md->paramtypes[i].type))
- M_LLD(rd->argintregs[s1], REG_SP, j * 8);
- else
- M_DLD(rd->argfltregs[s1], REG_SP, j * 8);
+ switch (md->paramtypes[i].type) {
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LLD(s1, REG_SP, j * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DLD(s1, REG_SP, j * 8);
+ break;
+ }
j++;
}
/* copy or spill arguments to new locations */
for (i = md->paramcount - 1, j = i + nativeparams; i >= 0; i--, j--) {
- t = md->paramtypes[i].type;
+ t = md->paramtypes[i].type;
+ s2 = nmd->params[j].regoff;
if (IS_INT_LNG_TYPE(t)) {
if (!md->params[i].inmemory) {
- s1 = rd->argintregs[md->params[i].regoff];
+ s1 = md->params[i].regoff;
- if (!nmd->params[j].inmemory) {
- s2 = rd->argintregs[nmd->params[j].regoff];
+ if (!nmd->params[j].inmemory)
M_INTMOVE(s1, s2);
-
- } else {
- s2 = nmd->params[j].regoff;
+ else
M_LST(s1, REG_SP, s2 * 8);
- }
-
- } else {
+ }
+ else {
s1 = md->params[i].regoff + cd->stackframesize + 1; /* + 1 (RA) */
- s2 = nmd->params[j].regoff;
M_LLD(REG_ITMP1, REG_SP, s1 * 8);
M_LST(REG_ITMP1, REG_SP, s2 * 8);
}
-
- } else {
- /* We only copy spilled float arguments, as the float argument */
- /* registers keep unchanged. */
+ }
+ else {
+ /* We only copy spilled float arguments, as the float
+ argument registers keep unchanged. */
if (md->params[i].inmemory) {
s1 = md->params[i].regoff + cd->stackframesize + 1; /* + 1 (RA) */
- s2 = nmd->params[j].regoff;
if (IS_2_WORD_TYPE(t)) {
M_DLD(REG_FTMP1, REG_SP, s1 * 8);
M_DST(REG_FTMP1, REG_SP, s2 * 8);
- } else {
+ }
+ else {
M_FLD(REG_FTMP1, REG_SP, s1 * 8);
M_FST(REG_FTMP1, REG_SP, s2 * 8);
}
/* save return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type))
- M_LST(REG_RESULT, REG_SP, 0 * 8);
- else
- M_DST(REG_FRESULT, REG_SP, 0 * 8);
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LST(REG_RESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DST(REG_FRESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_VOID:
+ break;
}
#if !defined(NDEBUG)
/* restore return value */
- if (md->returntype.type != TYPE_VOID) {
- if (IS_INT_LNG_TYPE(md->returntype.type))
- M_LLD(REG_RESULT, REG_SP, 0 * 8);
- else
- M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+ switch (md->returntype.type) {
+ case TYPE_INT:
+ case TYPE_LNG:
+ case TYPE_ADR:
+ M_LLD(REG_RESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_FLT:
+ case TYPE_DBL:
+ M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+ break;
+ case TYPE_VOID:
+ break;
}
/* remove stackframe */
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: emit.c 7644 2007-04-03 11:37:30Z twisti $
+ $Id: emit.c 7713 2007-04-15 21:49:48Z twisti $
*/
#include "vm/builtin.h"
#include "vm/exceptions.h"
+#include "vm/jit/abi.h"
#include "vm/jit/abi-asm.h"
#include "vm/jit/asmpart.h"
#include "vm/jit/codegen-common.h"
/* save argument registers */
for (i = 0; i < INT_ARG_CNT; i++)
- M_LST(rd->argintregs[i], REG_SP, (1 + i) * 8);
+ M_LST(abi_registers_integer_argument[i], REG_SP, (1 + i) * 8);
for (i = 0; i < FLT_ARG_CNT; i++)
- M_DST(rd->argfltregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8);
+ M_DST(abi_registers_float_argument[i], REG_SP, (1 + INT_ARG_CNT + i) * 8);
/* save temporary registers for leaf methods */
if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
for (k = INT_ARG_CNT - 2; k >= i; k--)
- M_MOV(rd->argintregs[k], rd->argintregs[k + 1]);
+ M_MOV(abi_registers_integer_argument[k],
+ abi_registers_integer_argument[k + 1]);
- emit_movd_freg_reg(cd, rd->argfltregs[j], rd->argintregs[i]);
+ emit_movd_freg_reg(cd, abi_registers_float_argument[j],
+ abi_registers_integer_argument[i]);
j++;
}
}
/* restore argument registers */
for (i = 0; i < INT_ARG_CNT; i++)
- M_LLD(rd->argintregs[i], REG_SP, (1 + i) * 8);
+ M_LLD(abi_registers_integer_argument[i], REG_SP, (1 + i) * 8);
for (i = 0; i < FLT_ARG_CNT; i++)
- M_DLD(rd->argfltregs[i], REG_SP, (1 + INT_ARG_CNT + i) * 8);
+ M_DLD(abi_registers_float_argument[i], REG_SP, (1 + INT_ARG_CNT + i) * 8);
/* restore temporary registers for leaf methods */
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: md-abi.c 7630 2007-04-02 19:56:14Z twisti $
+ $Id: md-abi.c 7713 2007-04-15 21:49:48Z twisti $
*/
#include "vm/global.h"
+#include "vm/jit/abi.h"
#include "vm/jit/jit.h" /* for REG_* (maybe can be removed) */
#include "vmcore/descriptor.h"
};
+/* float registers *************************************************************
+
+ xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
+ (fa0) (fa1) (fa2) (fa3) (fa4) (fa5) (fa6) (fa7)
+
+ xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15
+ (ftmp1) (ftmp2) (ftmp3) (ft0) (ft1) (ft2) (ft3) (ft4)
+
+*******************************************************************************/
+
s4 nregdescfloat[] = {
REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_ARG,
REG_RES, REG_RES, REG_RES, REG_TMP, REG_TMP, REG_TMP, REG_TMP, REG_TMP,
};
+const s4 abi_registers_float_argument[] = {
+ 0, /* fa0 */
+ 1, /* fa1 */
+ 2, /* fa2 */
+ 3, /* fa3 */
+ 4, /* fa4 */
+ 5, /* fa5 */
+ 6, /* fa6 */
+ 7, /* fa7 */
+};
+
+const s4 abi_registers_float_saved[] = {
+ -1,
+};
+
+const s4 abi_registers_float_temporary[] = {
+ 11, /* ft0 */
+ 12, /* ft1 */
+ 13, /* ft2 */
+ 14, /* ft3 */
+ 15, /* ft4 */
+};
+
+
/* md_param_alloc **************************************************************
XXX
/* set default values */
- iarg = 0;
- farg = 0;
+ iarg = 0;
+ farg = 0;
stacksize = 0;
/* get params field of methoddesc */
case TYPE_LNG:
if (iarg < INT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = iarg;
+ pd->regoff = abi_registers_integer_argument[iarg];
iarg++;
}
else {
case TYPE_DBL:
if (farg < FLT_ARG_CNT) {
pd->inmemory = false;
- pd->regoff = farg;
+ pd->regoff = abi_registers_float_argument[farg];
farg++;
}
else {
projects / cacao.git / commitdiff