-/* jit/reg.inc - register allocator
+/* src/vm/jit/reg.inc - register allocator
- Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
- Institut f. Computersprachen, TU Wien
- R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser, M. Probst,
- S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich,
- J. Wenninger
+ Copyright (C) 1996-2005 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
This file is part of CACAO.
Changes: Stefan Ring
Christian Thalinger
- $Id: reg.inc 1506 2004-11-14 14:48:49Z jowenn $
+ $Id: reg.inc 2333 2005-04-22 13:26:36Z twisti $
*/
-#include "jit/reg.h"
-#include "toolbox/memory.h"
+#include "arch.h"
+#include "mm/memory.h"
+#include "vm/method.h"
+#include "vm/resolve.h"
+#include "vm/jit/reg.h"
/* function prototypes for this file */
rd->savintregs[rd->savintreguse++] = i;
break;
case REG_TMP:
- rd->tmpintregs[rd->tmpintreguse++] = i;
+ rd->tmpintregs[rd->tmpintreguse++] = i;
break;
case REG_ARG:
rd->argintregs[rd->intreg_argnum++] = i;
rd->secondregs[rd->argintregs[rd->intreg_argnum - 1]] = REG_ITMP3;
#endif
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ /* setup the address register table */
+ rd->adrreg_argnum = 0;
+ rd->tmpadrregcnt = 0;
+ rd->savadrregcnt = 0;
+
+ for (rd->adrregsnum = 0; nregdescadr[rd->adrregsnum] != REG_END; rd->adrregsnum++) {
+ switch (nregdescadr[rd->adrregsnum]) {
+ case REG_SAV:
+ rd->savadrregcnt++;
+ break;
+ case REG_TMP:
+ rd->tmpadrregcnt++;
+ break;
+ case REG_ARG:
+ rd->adrreg_argnum++;
+ break;
+ }
+ }
+
+ rd->argadrregs = DMNEW(s4, rd->adrreg_argnum);
+ rd->tmpadrregs = DMNEW(s4, rd->tmpadrregcnt);
+ rd->savadrregs = DMNEW(s4, rd->savadrregcnt);
+ rd->freeargadrregs = DMNEW(s4, rd->adrreg_argnum);
+ rd->freetmpadrregs = DMNEW(s4, rd->tmpadrregcnt);
+ rd->freesavadrregs = DMNEW(s4, rd->savadrregcnt);
+
+ rd->adrreg_argnum = 0;
+ rd->argadrreguse = 0;
+ rd->tmpadrreguse = 0;
+ rd->savadrreguse = 0;
+
+ for (i = 0; i < rd->adrregsnum; i++) {
+ switch (nregdescadr[i]) {
+ case REG_RET:
+ rd->adrreg_ret = i;
+ break;
+ case REG_SAV:
+ rd->savadrregs[rd->savadrreguse++] = i;
+ break;
+ case REG_TMP:
+ rd->tmpadrregs[rd->tmpadrreguse++] = i;
+ break;
+ case REG_ARG:
+ rd->argadrregs[rd->adrreg_argnum++] = i;
+ rd->argadrreguse++;
+ break;
+ }
+ }
+
+/* #if defined(????) */
+ /*
+ * on xdsp the argument registers are in ascending order ???
+ */
+/* #endif */
+#endif
+
/* setup the float register table */
rd->fltreg_argnum = 0;
rd->tmpfltregcnt = 0;
rd->savfltregcnt = 0;
- for (rd->floatregsnum = 0; nregdescfloat[rd->floatregsnum] != REG_END; rd->floatregsnum++) {
- switch (nregdescfloat[rd->floatregsnum]) {
+ for (rd->fltregsnum = 0; nregdescfloat[rd->fltregsnum] != REG_END; rd->fltregsnum++) {
+ switch (nregdescfloat[rd->fltregsnum]) {
case REG_SAV:
rd->savfltregcnt++;
break;
rd->tmpfltreguse = 0;
rd->savfltreguse = 0;
- for (i = 0; i < rd->floatregsnum; i++) {
+ for (i = 0; i < rd->fltregsnum; i++) {
switch (nregdescfloat[i]) {
case REG_RET:
- rd->floatreg_ret = i;
+ rd->fltreg_ret = i;
break;
case REG_SAV:
rd->savfltregs[rd->savfltreguse++] = i;
v[0][TYPE_ADR].type = -1;
v[0][TYPE_ADR].flags = 0;
}
+#ifdef SPECIALMEMUSE
+ 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
}
static void interface_regalloc(methodinfo *m, codegendata *cd, registerdata *rd)
{
int s, t, saved;
- int intalloc, fltalloc;
+ int intalloc, fltalloc; /* ?per Interface slot only one flt or one int type can be allocated to a register? */
varinfo *v;
int regsneeded = 0;
/* allocate stack space for passing arguments to called methods */
+#ifdef INVOKE_NEW_DEBUG
+ 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 */
+ /* less or equal the float argument register count (e.g. x86_64). */
+ /* (arch.h: INT_ARG_CNT <= FLT_ARG_CNT) */
+ if (rd->arguments_num > INT_ARG_CNT) {
+ rd->ifmemuse = rd->arguments_num - INT_ARG_CNT;
-#ifndef SPECIALMEMUSE
-#if defined(__X86_64__)
- /*
- * XXX: we have a problem here, but allocating a little more stack space
- * is better than having a bug
- */
- /* if (arguments_num > (intreg_argnum + fltreg_argnum)) */
- /* ifmemuse = arguments_num - (intreg_argnum + fltreg_argnum); */
- if (rd->arguments_num > rd->fltreg_argnum)
- rd->ifmemuse = rd->arguments_num - rd->fltreg_argnum;
-#else
- if (rd->arguments_num > rd->intreg_argnum)
- rd->ifmemuse = rd->arguments_num - rd->intreg_argnum;
+ } else {
+ rd->ifmemuse = 0;
+ }
#endif
- else
- rd->ifmemuse = 0;
+ if (compileverbose) {
+ 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->ifmemuse = temp;
+ }
#endif
rd->iftmpintregcnt = rd->tmpintregcnt;
rd->ifsavintregcnt = rd->savintregcnt;
rd->iftmpfltregcnt = rd->tmpfltregcnt;
rd->ifsavfltregcnt = rd->savfltregcnt;
-
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ 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 |
regsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
#endif
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];
+ }
+ else if (rd->ifsavadrregcnt > 0) {
+ rd->ifsavadrregcnt--;
+ v->regoff = rd->savadrregs[rd->ifsavadrregcnt];
+ }
+ else {
+ v->flags |= INMEMORY;
+ v->regoff = rd->ifmemuse;
+ rd->ifmemuse += regsneeded + 1;
+ }
+ } else {
+#endif
if (IS_FLT_DBL_TYPE(t)) {
if (fltalloc >= 0) {
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];
#endif
intalloc = t;
}
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ }
+#endif
}
else {
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ if (t == TYPE_ADR) {
+ if (rd->ifsavadrregcnt > 0) {
+ rd->ifsavadrregcnt--;
+ v->regoff = rd->savadrregs[rd->ifsavadrregcnt];
+ }
+ else {
+ v->flags |= INMEMORY;
+ v->regoff = rd->ifmemuse;
+ rd->ifmemuse += regsneeded + 1;
+ }
+ } else {
+#endif
if (IS_FLT_DBL_TYPE(t)) {
if (fltalloc >= 0) {
v->flags |= rd->interfaces[s][fltalloc].flags & INMEMORY;
#endif
intalloc = t;
}
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ }
+#endif
}
} /* if (type >= 0) */
} /* for t */
} /* 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;
+
+#if defined(HAS_ADDRESS_REGISTER_FILE)
+
+ rd->maxargadrreguse = rd->ifargadrregcnt;
+ rd->maxtmpadrreguse = rd->iftmpadrregcnt;
+ rd->maxsavadrreguse = rd->ifsavadrregcnt;
+#endif
}
if (m->isleafmethod) {
int arg, doublewordarg, iargcnt, fargcnt;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ int aargcnt;
+#endif
arg = 0, iargcnt = 0, fargcnt = 0;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ aargcnt = 0;
+#endif
doublewordarg = 0;
for (s = 0; s < cd->maxlocals; s++) {
intalloc = -1; fltalloc = -1;
if (v->type >= 0) {
#ifdef USETWOREGS
regsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#endif
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ if (t == TYPE_ADR) {
+ /* doublewordarg not possible for xdsp */
+#if !defined(CONSECUTIVE_ADDRESSARGS)
+ aargcnt = arg;
+#endif
+ if ((arg < m->paramcount) && (aargcnt < rd->adrreg_argnum)) {
+ v->flags = 0;
+ v->regoff = rd->argadrregs[aargcnt];
+ }
+ if (rd->maxtmpadrreguse > 0) {
+ rd->maxtmpadrreguse--;
+ v->flags = 0;
+ v->regoff = rd->tmpadrregs[rd->maxtmpadrreguse];
+ }
+ else if (rd->maxsavadrreguse > 0) {
+ rd->maxsavadrreguse--;
+ v->flags = 0;
+ v->regoff = rd->savadrregs[rd->maxsavadrreguse];
+ }
+ else {
+ v->flags |= INMEMORY;
+ v->regoff = rd->ifmemuse;
+ rd->ifmemuse += regsneeded + 1;
+ }
+ } else {
#endif
if (IS_FLT_DBL_TYPE(t)) {
#if !defined(CONSECUTIVE_FLOATARGS)
#endif
intalloc = t;
}
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ }
+#endif
}
}
if (arg < m->paramcount) {
doublewordarg = 1;
} else {
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ if ( TYPE_ADR == m->paramtypes[arg] ) {
+ aargcnt++;
+ } else {
+#endif
if (IS_FLT_DBL_TYPE(m->paramtypes[arg])) {
fargcnt++;
} else {
iargcnt++;
}
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ }
+#endif
arg++;
}
}
if (v->type >= 0) {
#ifdef USETWOREGS
regsneeded = (IS_2_WORD_TYPE(t)) ? 1 : 0;
+#endif
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ if ( t == TYPE_ADR ) {
+ if (rd->maxsavadrreguse > 0) {
+ rd->maxsavadrreguse--;
+ v->flags = 0;
+ v->regoff = rd->savadrregs[rd->maxsavadrreguse];
+ }
+ else {
+ v->flags = INMEMORY;
+ v->regoff = rd->maxmemuse;
+ rd->maxmemuse += regsneeded + 1;
+ }
+ } else {
#endif
if (IS_FLT_DBL_TYPE(t)) {
if (fltalloc >= 0) {
#endif
intalloc = t;
}
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ }
+#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->freesavinttop = 0;
rd->freetmpflttop = 0;
rd->freesavflttop = 0;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ rd->freetmpadrtop = 0;
+ rd->freesavadrtop = 0;
+#endif
rd->tmpintreguse = rd->iftmpintregcnt;
rd->savintreguse = rd->ifsavintregcnt;
rd->tmpfltreguse = rd->iftmpfltregcnt;
rd->savfltreguse = rd->ifsavfltregcnt;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ rd->tmpadrreguse = rd->iftmpadrregcnt;
+ rd->savadrreguse = rd->ifsavadrregcnt;
+#endif
- /* 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->freeargadrtop = 0;
+#endif
+ 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)
if (tryagain == 1) {
if (!(s->flags & SAVEDVAR))
s->flags |= SAVEDTMP;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ if (s->type == TYPE_ADR) {
+ if (rd->freesavadrtop > 0) {
+ rd->freesavadrtop--;
+ s->regoff = rd->freesavadrregs[rd->freesavadrtop];
+ return;
+
+ } else if (rd->savadrreguse > 0) {
+ rd->savadrreguse--;
+ if (rd->savadrreguse < rd->maxsavadrreguse)
+ rd->maxsavadrreguse = rd->savadrreguse;
+ s->regoff = rd->savadrregs[rd->savadrreguse];
+ return;
+ }
+ } else {
+#endif
if (IS_FLT_DBL_TYPE(s->type)) {
if (rd->freesavflttop > 0) {
rd->freesavflttop--;
}
#endif
}
-
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ }
+#endif
} else {
- if (IS_FLT_DBL_TYPE(s->type)) {
- if (rd->freetmpflttop > 0) {
- rd->freetmpflttop--;
- s->regoff = rd->freetmpfltregs[rd->freetmpflttop];
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ if (s->type == TYPE_ADR) {
+ if (rd->freetmpadrtop > 0) {
+ rd->freetmpadrtop--;
+ s->regoff = rd->freetmpadrregs[rd->freetmpadrtop];
return;
- } else if (rd->tmpfltreguse > 0) {
- rd->tmpfltreguse--;
- if (rd->tmpfltreguse < rd->maxtmpfltreguse)
- rd->maxtmpfltreguse = rd->tmpfltreguse;
- s->regoff = rd->tmpfltregs[rd->tmpfltreguse];
+ } else if (rd->tmpadrreguse > 0) {
+ rd->tmpadrreguse--;
+ if (rd->tmpadrreguse < rd->maxtmpadrreguse)
+ rd->maxtmpadrreguse = rd->tmpadrreguse;
+ s->regoff = rd->tmpadrregs[rd->tmpadrreguse];
return;
}
-
} else {
+#endif
+ 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 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;
}
#endif
}
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ }
+#endif
}
}
rd->freemem[rd->freememtop + 1] = s->regoff + 1;
rd->freememtop += regsneeded + 1;
+#ifdef HAS_ADDRESS_REGISTER_FILE
+ } else if (s->type == TYPE_ADR) {
+ if (s->flags & (SAVEDVAR | SAVEDTMP)) {
+ s->flags &= ~SAVEDTMP;
+ rd->freesavadrregs[rd->freesavadrtop++] = s->regoff;
+
+ } else
+ rd->freetmpadrregs[rd->freetmpadrtop++] = s->regoff;
+#endif
} else if (IS_FLT_DBL_TYPE(s->type)) {
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;
case ICMD_RET:
case ICMD_RETURN:
case ICMD_GOTO:
+ case ICMD_PUTSTATICCONST:
case ICMD_INLINE_START:
case ICMD_INLINE_END:
break;
case ICMD_ATHROW:
case ICMD_PUTSTATIC:
+ case ICMD_PUTFIELDCONST:
/* pop 1 push 0 branch */
case ICMD_IADDCONST:
case ICMD_ISUBCONST:
case ICMD_IMULCONST:
+ case ICMD_IMULPOW2:
case ICMD_IDIVPOW2:
case ICMD_IREMPOW2:
case ICMD_IANDCONST:
case ICMD_LADDCONST:
case ICMD_LSUBCONST:
case ICMD_LMULCONST:
+ case ICMD_LMULPOW2:
case ICMD_LDIVPOW2:
case ICMD_LREMPOW2:
case ICMD_LANDCONST:
reg_free_temp(rd, src);
src = src->prev;
}
+#if defined(__X86_64__) || defined(__I386__)
+ 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;
}
+#ifdef STATISTICS
+void reg_make_statistics( methodinfo *m, codegendata *cd, registerdata *rd) {
+ int i,type;
+ s4 len;
+ stackptr src, src_old;
+ stackptr dst;
+ instruction *iptr;
+ basicblock *bptr;
+ int size_interface; /* == maximum size of in/out stack at basic block boundaries */
+ bool in_register;
+
+ in_register = true;
+
+ size_interface = 0;
+
+ /* count how many local variables are held in memory or register */
+ for(i=0; i < cd->maxlocals; i++)
+ for (type=0; type <=4; type++)
+ if (rd->locals[i][type].type != -1) { /* valid local */
+ if (rd->locals[i][type].flags & INMEMORY) {
+ count_locals_spilled++;
+ in_register=false;
+ }
+ else
+ count_locals_register++;
+ }
+ /* count how many stack slots are held in memory or register */
+
+ bptr = m->basicblocks;
+ while (bptr != NULL) {
+ if (bptr->flags >= BBREACHED) {
+
+#ifdef LSRA
+ if (!opt_lsra) {
+#endif
+ /* check for memory moves from interface to BB instack */
+ dst = bptr->instack;
+ len = bptr->indepth;
+
+ if (len > size_interface) size_interface = len;
+
+ while (dst != NULL) {
+ len--;
+ if (dst->varkind != STACKVAR) {
+ if ( (dst->flags & INMEMORY) ||
+ (rd->interfaces[len][dst->type].flags & INMEMORY) ||
+ ( (dst->flags & INMEMORY) &&
+ (rd->interfaces[len][dst->type].flags & INMEMORY) &&
+ (dst->regoff != rd->interfaces[len][dst->type].regoff) ))
+ {
+ /* one in memory or both inmemory at different offsets */
+ count_mem_move_bb++;
+ in_register=false;
+ }
+ }
+
+ dst = dst->prev;
+ }
+
+ /* check for memory moves from BB outstack to interface */
+ dst = bptr->outstack;
+ len = bptr->outdepth;
+ if (len > size_interface) size_interface = len;
+
+ while (dst) {
+ len--;
+ if (dst->varkind != STACKVAR) {
+ if ( (dst->flags & INMEMORY) || \
+ (rd->interfaces[len][dst->type].flags & INMEMORY) || \
+ ( (dst->flags & INMEMORY) && \
+ (rd->interfaces[len][dst->type].flags & INMEMORY) && \
+ (dst->regoff != rd->interfaces[len][dst->type].regoff) ))
+ {
+ /* one in memory or both inmemory at different offsets */
+ count_mem_move_bb++;
+ in_register=false;
+ }
+ }
+
+ dst = dst->prev;
+ }
+#ifdef LSRA
+ }
+#endif
+
+
+ dst = bptr->instack;
+ iptr = bptr->iinstr;
+ len = bptr->icount;
+ src_old = NULL;
+
+ while (--len >= 0) {
+ src = dst;
+ dst = iptr->dst;
+
+ if ((src!= NULL) && (src != src_old)) { /* new stackslot */
+ switch (src->varkind) {
+ case TEMPVAR:
+ case STACKVAR:
+ if (!(src->flags & INMEMORY))
+ count_ss_register++;
+ else {
+ count_ss_spilled++;
+ in_register=false;
+ }
+ break;
+ /* case LOCALVAR: */
+ /* if (!(rd->locals[src->varnum][src->type].flags & INMEMORY)) */
+ /* count_ss_register++; */
+ /* else */
+ /* count_ss_spilled++; */
+ /* break; */
+ case ARGVAR:
+ if (!(src->flags & INMEMORY))
+ count_argument_mem_ss++;
+ else
+ count_argument_reg_ss++;
+ break;
+
+
+ /* if (IS_FLT_DBL_TYPE(src->type)) { */
+ /* if (src->varnum < FLT_ARG_CNT) { */
+ /* count_ss_register++; */
+ /* break; */
+ /* } */
+ /* } else { */
+ /* #if defined(__POWERPC__) */
+ /* if (src->varnum < INT_ARG_CNT - (IS_2_WORD_TYPE(src->type) != 0)) { */
+ /* #else */
+ /* if (src->varnum < INT_ARG_CNT) { */
+ /* #endif */
+ /* count_ss_register++; */
+ /* break; */
+ /* } */
+ /* } */
+ /* count_ss_spilled++; */
+ /* break; */
+ }
+ }
+ src_old = src;
+
+ iptr++;
+ } /* while instructions */
+ } /* if */
+ bptr = bptr->next;
+ } /* while blocks */
+ count_interface_size += size_interface; /* accummulate the size of the interface (between bb boundaries) */
+ if (in_register) count_method_in_register++;
+}
+#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
projects / cacao.git / blobdiff