Michael Starzinger
Edwin Steiner
- $Id: simplereg.c 4454 2006-02-06 00:02:50Z edwin $
+ $Id: simplereg.c 4524 2006-02-16 19:39:36Z christian $
*/
void regalloc(methodinfo *m, codegendata *cd, registerdata *rd)
{
+ /* There is a problem with the use of unused float argument registers in */
+ /* leafmethods for stackslots on c7 (3* Dual Core AMD Opteron(tm) */
+ /* Processor 270) - runtime for the jvm98 _mtrt benchmark is heaviliy */
+ /* increased. This could be prevented by setting rd->argfltreguse to */
+ /* FLT_ARG_CNT before calling allocate_scratch_registers and setting it */
+ /* back to the original value before calling local_regalloc. */
+
interface_regalloc(m, cd, rd);
allocate_scratch_registers(m, rd);
local_regalloc(m, cd, rd);
v->flags |= rd->interfaces[s][fltalloc].flags
& INMEMORY;
v->regoff = rd->interfaces[s][fltalloc].regoff;
- } else if (!m->isleafmethod
- && (rd->argfltreguse < FLT_ARG_CNT)) {
+ } else if (rd->argfltreguse < FLT_ARG_CNT) {
v->regoff = rd->argfltregs[rd->argfltreguse++];
} else if (rd->tmpfltreguse > 0) {
v->regoff = rd->tmpfltregs[--rd->tmpfltreguse];
v->regoff =
rd->interfaces[s][intalloc].regoff;
} else
- if (!m->isleafmethod &&
- (rd->argintreguse
- + intregsneeded < INT_ARG_CNT)) {
+ if (rd->argintreguse + intregsneeded
+ < INT_ARG_CNT) {
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
if (intregsneeded)
v->regoff=PACK_REGS(
}
-#define reg_free_temp(rd,s) if (s->varkind == TEMPVAR) reg_free_temp_func(rd, s)
+#define reg_free_temp(rd,s) if ((s->varkind == TEMPVAR) && (!(s->flags & STCOPY))) reg_free_temp_func(rd, s)
+
+/* Do not free regs/memory locations used by Stackslots flagged STCOPY! There is still another Stackslot */
+/* alive using this reg/memory location */
static void reg_free_temp_func(registerdata *rd, stackptr s)
{
}
}
-
+static bool reg_alloc_dup(stackptr src, stackptr dst) {
+ /* only copy TEMPVARS, do not mess with STACKVAR, */
+ /* LOCALVAR, or ARGVAR */
+ if ((src->varkind == TEMPVAR) && (dst->varkind == TEMPVAR)) {
+ /* can not allocate a REG_TMP to a REG_SAV Slot */
+ if (src->flags & INMEMORY) {
+ dst->regoff = src->regoff;
+ dst->flags |= INMEMORY;
+ return true;
+ } else if ((src->flags & SAVEDVAR) == (dst->flags & SAVEDVAR)) {
+ dst->regoff = src->regoff;
+ dst->flags |= src->flags & SAVEDTMP;
+ dst->flags |= src->flags & TMPARG;
+ return true;
+ } else if ((dst->flags & SAVEDVAR) == 0) {
+ /* can only use a REG_SAV as REG_TMP! */
+ dst->regoff = src->regoff;
+ dst->flags |= SAVEDTMP;
+ return true;
+ }
+ }
+ /* no copy possible - allocate a new reg/memory location*/
+ return false;
+}
static void allocate_scratch_registers(methodinfo *m, registerdata *rd)
{
/* pop 0 push 1 dup */
case ICMD_DUP:
- reg_new_temp(rd, dst);
+ /* src === dst->prev (identical Stackslot Element) */
+ /* src --> dst (copied value, take same reg/mem) */
+
+ if (!reg_alloc_dup(src, dst)) {
+ reg_new_temp(rd, dst);
+ } else {
+ dst->flags |= STCOPY;
+ }
break;
/* pop 0 push 2 dup */
case ICMD_DUP2:
- reg_new_temp(rd, dst->prev);
- reg_new_temp(rd, dst);
+ /* src->prev === dst->prev->prev->prev (identical Stackslot Element) */
+ /* src === dst->prev->prev (identical Stackslot Element) */
+ /* src->prev --> dst->prev (copied value, take same reg/mem) */
+ /* src --> dst (copied value, take same reg/mem) */
+
+ if (!reg_alloc_dup(src->prev, dst->prev)) {
+ reg_new_temp(rd, dst->prev);
+ } else {
+ dst->prev->flags |= STCOPY;
+ }
+ if (!reg_alloc_dup(src, dst)) {
+ reg_new_temp(rd, dst);
+ } else {
+ dst->flags |= STCOPY;
+ }
break;
/* pop 2 push 3 dup */
case ICMD_DUP_X1:
- reg_free_temp(rd, src);
- reg_new_temp(rd, dst);
- reg_free_temp(rd, src->prev);
- reg_new_temp(rd, dst->prev);
- reg_new_temp(rd, dst->prev->prev);
+ /* src->prev --> dst->prev (copied value, take same reg/mem) */
+ /* src --> dst (copied value, take same reg/mem) */
+ /* src --> dst->prev->prev (copied value, take same reg/mem) */
+
+ {
+ bool ret, ret1;
+ if (!(ret = reg_alloc_dup(src, dst->prev->prev))) {
+ reg_new_temp(rd, dst->prev->prev);
+ }
+ if (!(ret1 = reg_alloc_dup(src, dst))) {
+ reg_new_temp(rd, dst);
+ }
+ if (!(ret || ret1)) {
+ /* no reallocation was possible -> free src */
+ reg_free_temp(rd, src);
+ }
+ if (ret && ret1) {
+ dst->flags |= STCOPY;
+ }
+ if (!reg_alloc_dup(src->prev, dst->prev)) {
+ reg_free_temp(rd, src->prev);
+ reg_new_temp(rd, dst->prev);
+ }
+ }
break;
/* pop 3 push 4 dup */
case ICMD_DUP_X2:
- reg_free_temp(rd, src);
- reg_new_temp(rd, dst);
- reg_free_temp(rd, src->prev);
- reg_new_temp(rd, dst->prev);
- reg_free_temp(rd, src->prev->prev);
- reg_new_temp(rd, dst->prev->prev);
- reg_new_temp(rd, dst->prev->prev->prev);
+ /* src->prev->prev --> dst->prev->prev */
+ /* src->prev --> dst->prev */
+ /* src --> dst */
+ /* src --> dst->prev->prev->prev */
+
+ {
+ bool ret, ret1;
+ if (!(ret = reg_alloc_dup(src, dst->prev->prev->prev))) {
+ reg_new_temp(rd, dst->prev->prev->prev);
+ }
+ if (!(ret1 = reg_alloc_dup(src, dst))) {
+ reg_new_temp(rd, dst);
+ }
+ if (!(ret || ret1)) {
+ /* no reallocation was possible -> free src */
+ reg_free_temp(rd, src);
+ }
+ if (ret && ret1) {
+ dst->flags |= STCOPY;
+ }
+ if (!reg_alloc_dup(src->prev, dst->prev)) {
+ reg_free_temp(rd, src->prev);
+ reg_new_temp(rd, dst->prev);
+ }
+ if (!reg_alloc_dup(src->prev->prev, dst->prev->prev)) {
+ reg_free_temp(rd, src->prev->prev);
+ reg_new_temp(rd, dst->prev->prev);
+ }
+ }
break;
/* pop 3 push 5 dup */
case ICMD_DUP2_X1:
- reg_free_temp(rd, src);
- reg_new_temp(rd, dst);
- reg_free_temp(rd, src->prev);
- reg_new_temp(rd, dst->prev);
- reg_free_temp(rd, src->prev->prev);
- reg_new_temp(rd, dst->prev->prev);
- reg_new_temp(rd, dst->prev->prev->prev);
- reg_new_temp(rd, dst->prev->prev->prev->prev);
+ /* src->prev->prev --> dst->prev->prev */
+ /* src->prev --> dst->prev */
+ /* src --> dst */
+ /* src->prev --> dst->prev->prev->prev->prev */
+ /* src --> dst->prev->prev->prev */
+
+ {
+ bool ret, ret1;
+ if (!(ret = reg_alloc_dup(src, dst->prev->prev->prev))) {
+ reg_new_temp(rd, dst->prev->prev->prev);
+ }
+ if (!(ret1 = reg_alloc_dup(src, dst))) {
+ reg_new_temp(rd, dst);
+ }
+ if (!(ret || ret1)) {
+ /* no reallocation was possible -> free src */
+ reg_free_temp(rd, src);
+ }
+ if (ret && ret1) {
+ dst->flags |= STCOPY;
+ }
+
+ if (!(ret = reg_alloc_dup(src->prev, dst->prev->prev->prev->prev))) {
+ reg_new_temp(rd, dst->prev->prev->prev->prev);
+ }
+ if (!(ret1 = reg_alloc_dup(src->prev, dst->prev))) {
+ reg_new_temp(rd, dst->prev);
+ }
+ if (!(ret || ret1)) {
+ /* no reallocation was possible -> free src->prev */
+ reg_free_temp(rd, src->prev);
+ }
+ if (ret && ret1) {
+ dst->prev->flags |= STCOPY;
+ }
+
+ if (!reg_alloc_dup(src->prev->prev, dst->prev->prev)) {
+ reg_free_temp(rd, src->prev->prev);
+ reg_new_temp(rd, dst->prev->prev);
+ }
+ }
break;
/* pop 4 push 6 dup */
case ICMD_DUP2_X2:
- reg_free_temp(rd, src);
- reg_new_temp(rd, dst);
- reg_free_temp(rd, src->prev);
- reg_new_temp(rd, dst->prev);
- reg_free_temp(rd, src->prev->prev);
- reg_new_temp(rd, dst->prev->prev);
- reg_free_temp(rd, src->prev->prev->prev);
- reg_new_temp(rd, dst->prev->prev->prev);
- reg_new_temp(rd, dst->prev->prev->prev->prev);
- reg_new_temp(rd, dst->prev->prev->prev->prev->prev);
+ /* src->prev->prev->prev --> dst->prev->prev->prev */
+ /* src->prev->prev --> dst->prev->prev */
+ /* src->prev --> dst->prev */
+ /* src --> dst */
+ /* src->prev --> dst->prev->prev->prev->prev->prev */
+ /* src --> dst->prev->prev->prev->prev */
+
+ {
+ bool ret, ret1;
+ if (!(ret = reg_alloc_dup(src, dst->prev->prev->prev->prev))) {
+ reg_new_temp(rd, dst->prev->prev->prev->prev);
+ }
+ if (!(ret1 = reg_alloc_dup(src, dst))) {
+ reg_new_temp(rd, dst);
+ }
+ if (!(ret || ret1)) {
+ /* no reallocation was possible -> free src */
+ reg_free_temp(rd, src);
+ }
+ if (ret && ret1) {
+ dst->flags |= STCOPY;
+ }
+
+ if (!(ret = reg_alloc_dup(src->prev, dst->prev->prev->prev->prev->prev))) {
+ reg_new_temp(rd, dst->prev->prev->prev->prev->prev);
+ }
+ if (!(ret1 = reg_alloc_dup(src->prev, dst->prev))) {
+ reg_new_temp(rd, dst->prev);
+ }
+ if (!(ret || ret1)) {
+ /* no reallocation was possible -> free src->prev */
+ reg_free_temp(rd, src->prev);
+ }
+ if (ret && ret1) {
+ dst->prev->flags |= STCOPY;
+ }
+
+ if (!reg_alloc_dup(src->prev->prev, dst->prev->prev)) {
+ reg_free_temp(rd, src->prev->prev);
+ reg_new_temp(rd, dst->prev->prev);
+ }
+ if (!reg_alloc_dup(src->prev->prev->prev, dst->prev->prev->prev)) {
+ reg_free_temp(rd, src->prev->prev->prev);
+ reg_new_temp(rd, dst->prev->prev->prev);
+ }
+ }
break;
/* pop 2 push 2 swap */
case ICMD_SWAP:
- reg_free_temp(rd, src);
- reg_new_temp(rd, dst->prev);
- reg_free_temp(rd, src->prev);
- reg_new_temp(rd, dst);
+ /* src --> dst->prev (copy) */
+ /* src->prev --> dst (copy) */
+
+ if (!reg_alloc_dup(src, dst->prev)) {
+ reg_free_temp(rd, src);
+ reg_new_temp(rd, dst->prev);
+ }
+ if (!reg_alloc_dup(src->prev, dst->prev)) {
+ reg_free_temp(rd, src->prev);
+ reg_new_temp(rd, dst);
+ }
break;
/* pop 2 push 1 */
Christian Thalinger
Christian Ullrich
- $Id: stack.c 4455 2006-02-06 01:02:59Z edwin $
+ $Id: stack.c 4524 2006-02-16 19:39:36Z christian $
*/
stackptr curstack;
stackptr new;
stackptr copy;
- int opcode, i, len, loops;
+ int opcode, i, j, len, loops;
int superblockend, repeat, deadcode;
instruction *iptr;
basicblock *bptr;
s4 *s4ptr;
void **tptr;
s4 *argren;
+ s4 *last_store;/* instruction index of last XSTORE */
+ /* [ local_index * 5 + type ] */
+ s4 last_pei; /* instruction index of last possible exception */
+ /* used for conflict resolution for copy */
+ /* elimination (XLOAD, IINC, XSTORE) */
+ s4 last_dupx;
builtintable_entry *bte;
unresolved_method *um;
argren = DMNEW(s4, cd->maxlocals); /* table for argument renaming */
for (i = 0; i < cd->maxlocals; i++)
argren[i] = i;
+
+ last_store = DMNEW(s4 , cd->maxlocals * 5);
new = m->stack;
loops = 0;
iptr = bptr->iinstr;
b_index = bptr - m->basicblocks;
+ last_pei = -1;
+ last_dupx = -1;
+ for( i = 0; i < cd->maxlocals; i++)
+ for( j = 0; j < 5; j++)
+ last_store[5 * i + j] = -1;
+
bptr->stack = new;
while (--len >= 0) {
count_store_depth[i]++;
}
#endif
+ last_store[5 * iptr->op1 + TYPE_INT] = bptr->icount - len - 1;
+
copy = curstack;
i = stackdepth - 1;
while (copy) {
i--;
copy = copy->prev;
}
-
- /* allocate a dummy stack slot to keep ISTORE from */
- /* marking its input stack as a LOCALVAR, since we */
- /* change the value of the local variable here. */
- NEWSTACK0(TYPE_INT);
- POP(TYPE_INT);
SETDST;
break;
count_store_depth[i]++;
}
#endif
+ /* check for conflicts as described in Figure 5.2 */
copy = curstack->prev;
i = stackdepth - 2;
while (copy) {
i--;
copy = copy->prev;
}
- if ((new - curstack) == 1) {
- curstack->varkind = LOCALVAR;
- curstack->varnum = iptr->op1;
- };
+
+ /* do not change instack Stackslots */
+ /* it won't improve performance if we copy the interface */
+ /* at the BB begin or here, and lsra relies that no */
+ /* instack stackslot is marked LOCALVAR */
+ if (curstack->varkind == STACKVAR)
+ goto _possible_conflict;
+
+ /* check for a DUPX,SWAP while the lifetime of curstack */
+ /* and as creator curstack */
+ if (last_dupx != -1) {
+ /* we have to look at the dst stack of DUPX */
+ /* == src Stack of PEI */
+ copy = bptr->iinstr[last_dupx].dst;
+ /*
+ if (last_pei == 0)
+ copy = bptr->instack;
+ else
+ copy = bptr->iinstr[last_pei-1].dst;
+ */
+ if ((copy != NULL) && (curstack <= copy)) {
+ /* curstack alive at or created by DUPX */
+
+ /* TODO:.... */
+ /* now look, if there is a LOCALVAR at anyone of */
+ /* the src stacklots used by DUPX */
+
+ goto _possible_conflict;
+ }
+ }
+
+ /* check for a PEI while the lifetime of curstack */
+ if (last_pei != -1) {
+ /* && there are exception handler in this method */
+ /* when this is checked prevent ARGVAR from */
+ /* overwriting LOCALVAR!!! */
+
+ /* we have to look at the stack _before_ the PEI! */
+ /* == src Stack of PEI */
+ if (last_pei == 0)
+ copy = bptr->instack;
+ else
+ copy = bptr->iinstr[last_pei-1].dst;
+ if ((copy != NULL) && (curstack <= copy)) {
+ /* curstack alive at PEI */
+ goto _possible_conflict;
+ }
+ }
+
+ /* check if there is a possible conflicting XSTORE */
+ if (last_store[5 * iptr->op1 + opcode - ICMD_ISTORE] != -1) {
+ /* we have to look at the stack _before_ the XSTORE! */
+ /* == src Stack of XSTORE */
+ if (last_store[5 * iptr->op1 + opcode - ICMD_ISTORE] == 0)
+ copy = bptr->instack;
+ else
+ copy = bptr->iinstr[last_store[5 * iptr->op1 + opcode - ICMD_ISTORE] - 1].dst;
+ if ((copy != NULL) && (curstack <= copy)) {
+ /* curstack alive at Last Store */
+ goto _possible_conflict;
+ }
+ }
+
+ /* check if there is a conflict with a XLOAD */
+ /* this is done indirectly by looking if a Stackslot is */
+ /* marked LOCALVAR and is live while curstack is live */
+ /* see figure 5.3 */
+
+ /* First check "above" stackslots of the instack */
+ copy = curstack + 1;
+ for(;(copy <= bptr->instack); copy++)
+ if ((copy->varkind == LOCALVAR) && (copy->varnum == iptr->op1)) {
+ goto _possible_conflict;
+ }
+
+ /* "intra" Basic Block Stackslots are allocated above */
+ /* bptr->stack (see doc/stack.txt), so if curstack + 1 */
+ /* is an instack, copy could point now to the stackslots */
+ /* of an inbetween analysed Basic Block */
+ if (copy < bptr->stack)
+ copy = bptr->stack;
+ while (copy < new) {
+ if ((copy->varkind == LOCALVAR) && (copy->varnum == iptr->op1)) {
+ goto _possible_conflict;
+ }
+ copy++;
+ }
+ /* no conflict - mark the Stackslot as LOCALVAR */
+ curstack->varkind = LOCALVAR;
+ curstack->varnum = iptr->op1;
+
+ goto _local_join;
+ _possible_conflict:
+ if ((curstack->varkind == LOCALVAR)
+ && (curstack->varnum == iptr->op1)) {
+ curstack->varkind = TEMPVAR;
+ curstack->varnum = stackdepth-1;
+ }
+ _local_join:
+ last_store[5 * iptr->op1 + opcode - ICMD_ISTORE] = bptr->icount - len - 1;
+
STORE(opcode - ICMD_ISTORE);
break;
}
}
#endif
+ last_dupx = bptr->icount - len - 1;
COUNT(count_dup_instruction);
DUP;
break;
case ICMD_DUP2:
+ last_dupx = bptr->icount - len - 1;
REQUIRE_1;
if (IS_2_WORD_TYPE(curstack->type)) {
/* ..., cat2 */
}
}
#endif
+ last_dupx = bptr->icount - len - 1;
DUP_X1;
break;
case ICMD_DUP2_X1:
+ last_dupx = bptr->icount - len - 1;
REQUIRE_2;
if (IS_2_WORD_TYPE(curstack->type)) {
/* ..., ????, cat2 */
/* pop 3 push 4 dup */
case ICMD_DUP_X2:
+ last_dupx = bptr->icount - len - 1;
REQUIRE_2;
if (IS_2_WORD_TYPE(curstack->prev->type)) {
/* ..., cat2, ???? */
break;
case ICMD_DUP2_X2:
+ last_dupx = bptr->icount - len - 1;
REQUIRE_2;
if (IS_2_WORD_TYPE(curstack->type)) {
/* ..., ????, cat2 */
/* pop 2 push 2 swap */
case ICMD_SWAP:
+ last_dupx = bptr->icount - len - 1;
#ifdef TYPECHECK_STACK_COMPCAT
if (opt_verify) {
REQUIRE_2;
/* {COUNT(count_check_null);} */
_callhandling:
+
+ last_pei = bptr->icount - len - 1;
+
i = md->paramcount;
if (md->memuse > rd->memuse)
projects / cacao.git / commitdiff