Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- $Id: stack.c 7464 2007-03-06 00:26:31Z edwin $
-
*/
#include "vm/jit/jit.h"
#include "vm/jit/stack.h"
+#if 0
#if defined(ENABLE_SSA)
# include "vm/jit/optimizing/lsra.h"
# include "vm/jit/optimizing/ssa.h"
#elif defined(ENABLE_LSRA)
# include "vm/jit/allocator/lsra.h"
#endif
+#endif
#include "vmcore/options.h"
#include "vm/resolve.h"
#define BRANCH_TARGET(bt, tempbptr) \
do { \
- tempbptr = BLOCK_OF((bt).insindex); \
+ tempbptr = (bt).block; \
tempbptr = stack_mark_reached(&sd, tempbptr, curstack, \
stackdepth); \
if (tempbptr == NULL) \
static basicblock *stack_mark_reached(stackdata_t *sd, basicblock *b, stackptr curstack, int stackdepth)
{
+ assert(b != NULL);
+
#if defined(STACK_VERBOSE)
printf("stack_mark_reached(L%03d from L%03d)\n", b->nr, sd->bptr->nr);
#endif
+
/* mark targets of backward branches */
+
if (b->nr <= sd->bptr->nr)
b->bitflags |= BBFLAG_REPLACEMENT;
static basicblock *stack_mark_reached_from_outvars(stackdata_t *sd, basicblock *b)
{
+ assert(b != NULL);
+
#if defined(STACK_VERBOSE)
printf("stack_mark_reached_from_outvars(L%03d from L%03d)\n", b->nr, sd->bptr->nr);
#endif
+
/* mark targets of backward branches */
+
if (b->nr <= sd->bptr->nr)
b->bitflags |= BBFLAG_REPLACEMENT;
/* stack_reach_next_block ******************************************************
- Mark the following block reached and propagate the outvars of the current block
- and the current locals to it. This function specializes the target block,
- if necessary, and returns a pointer to the specialized target.
+ Mark the following block reached and propagate the outvars of the
+ current block and the current locals to it. This function
+ specializes the target block, if necessary, and returns a pointer
+ to the specialized target.
IN:
sd...........stack analysis data
tbptr = (sd->bptr->original) ? sd->bptr->original : sd->bptr;
tbptr = stack_mark_reached_from_outvars(sd, tbptr->next);
- if (!tbptr)
+
+ if (tbptr == NULL)
return false;
if (tbptr != sd->bptr->next) {
s4 blockvarstart;
s4 invarshift;
s4 blockvarshift;
- s4 i, j;
+ s4 i, varindex;
s4 *argp;
branch_target_t *table;
lookup_target_t *lookup;
switch (iptr->opc) {
case ICMD_RET:
- j = iptr->s1.varindex;
+ varindex = iptr->s1.varindex;
#if defined(ENABLE_VERIFIER)
- if (sd->var[j].type != TYPE_RET) {
+ if (sd->var[varindex].type != TYPE_RET) {
exceptions_throw_verifyerror(sd->m, "RET with non-returnAddress value");
return false;
}
#endif
- iptr->dst.block = stack_mark_reached_from_outvars(sd, sd->var[j].vv.retaddr);
+ iptr->dst.block = stack_mark_reached_from_outvars(sd, sd->var[varindex].vv.retaddr);
superblockend = true;
break;
case ICMD_ASTORE:
RELOCATE(iptr->s1.varindex);
- j = iptr->dst.varindex;
- COPY_VAL_AND_TYPE(*sd, iptr->s1.varindex, j);
+ varindex = iptr->dst.varindex;
+ COPY_VAL_AND_TYPE(*sd, iptr->s1.varindex, varindex);
i = iptr->sx.s23.s3.javaindex;
if (iptr->flags.bits & INS_FLAG_RETADDR) {
iptr->sx.s23.s2.retaddrnr =
- UNUSED - (1 + sd->var[j].vv.retaddr->nr);
+ JAVALOCAL_FROM_RETADDR(sd->var[varindex].vv.retaddr->nr);
sd->javalocals[i] = iptr->sx.s23.s2.retaddrnr;
}
else
- sd->javalocals[i] = j;
+ sd->javalocals[i] = varindex;
if (iptr->flags.bits & INS_FLAG_KILL_PREV)
sd->javalocals[i-1] = UNUSED;
if (iptr->flags.bits & INS_FLAG_KILL_NEXT)
static void stack_init_javalocals(stackdata_t *sd)
{
s4 *jl;
- s4 t,i,j;
+ s4 type,i,j;
methoddesc *md;
jitdata *jd;
md = jd->m->parseddesc;
j = 0;
for (i=0; i<md->paramcount; ++i) {
- t = md->paramtypes[i].type;
- jl[j] = jd->local_map[5*j + t];
+ type = md->paramtypes[i].type;
+ jl[j] = jd->local_map[5*j + type];
j++;
- if (IS_2_WORD_TYPE(t))
+ if (IS_2_WORD_TYPE(type))
j++;
}
}
methodinfo *m; /* method being analyzed */
registerdata *rd;
stackdata_t sd;
-#if defined(ENABLE_SSA)
- lsradata *ls;
-#endif
int stackdepth;
stackptr curstack; /* current stack top */
stackptr copy;
int opcode; /* opcode of current instruction */
- int i, j;
+ int i, varindex;
int javaindex;
+ int type; /* operand type */
int len; /* # of instructions after the current one */
bool superblockend; /* if true, no fallthrough to next block */
bool deadcode; /* true if no live code has been reached */
m = jd->m;
rd = jd->rd;
-#if defined(ENABLE_SSA)
- ls = jd->ls;
-#endif
/* initialize the stackdata_t struct */
sd.exstack.varnum = sd.localcount;
sd.var[sd.exstack.varnum].type = TYPE_ADR;
-#if defined(ENABLE_LSRA)
- m->maxlifetimes = 0;
-#endif
-
#if defined(ENABLE_STATISTICS)
iteration_count = 0;
#endif
/* initialize loop over basic blocks */
- sd.bptr = jd->basicblocks;
+ sd.bptr = jd->basicblocks;
superblockend = true;
- sd.repeat = false;
- curstack = NULL; stackdepth = 0;
- deadcode = true;
+ sd.repeat = false;
+ curstack = NULL;
+ stackdepth = 0;
+ deadcode = true;
/* iterate over basic blocks *****************************************/
if (sd.bptr->flags == BBTYPECHECK_REACHED) {
/* re-analyse a block because its input changed */
+
deadcode = false;
+
if (!stack_reanalyse_block(&sd))
return false;
+
superblockend = true; /* XXX */
continue;
}
if (superblockend && (sd.bptr->flags < BBREACHED)) {
- /* This block has not been reached so far, and we */
- /* don't fall into it, so we'll have to iterate again. */
+ /* This block has not been reached so far, and we
+ don't fall into it, so we'll have to iterate
+ again. */
sd.repeat = true;
continue;
}
if (sd.bptr->original && sd.bptr->original->flags < BBFINISHED) {
- /* This block is a clone and the original has not been */
- /* analysed, yet. Analyse it on the next iteration. */
+ /* This block is a clone and the original has not been
+ analysed, yet. Analyse it on the next
+ iteration. */
sd.repeat = true;
/* XXX superblockend? */
/* automatically replace some ICMDs with builtins */
-#if defined(USEBUILTINTABLE)
bte = builtintable_get_automatic(opcode);
- if (bte && bte->opcode == opcode) {
- iptr->opc = ICMD_BUILTIN;
+ if ((bte != NULL) && (bte->opcode == opcode)) {
+ iptr->opc = ICMD_BUILTIN;
iptr->flags.bits &= INS_FLAG_ID_MASK;
- iptr->sx.s23.s3.bte = bte;
+ iptr->sx.s23.s3.bte = bte;
/* iptr->line is already set */
- jd->isleafmethod = false;
+ jd->isleafmethod = false;
goto icmd_BUILTIN;
}
-#endif /* defined(USEBUILTINTABLE) */
/* main opcode switch *************************************/
break;
case ICMD_RET:
- j = iptr->s1.varindex =
+ varindex = iptr->s1.varindex =
jd->local_map[iptr->s1.varindex * 5 + TYPE_ADR];
#if defined(ENABLE_VERIFIER)
- if (sd.var[j].type != TYPE_RET) {
+ if (sd.var[varindex].type != TYPE_RET) {
exceptions_throw_verifyerror(m, "RET with non-returnAddress value");
return false;
}
CLR_SX;
- iptr->dst.block = stack_mark_reached(&sd, sd.var[j].vv.retaddr, curstack, stackdepth);
+ iptr->dst.block = stack_mark_reached(&sd, sd.var[varindex].vv.retaddr, curstack, stackdepth);
superblockend = true;
break;
icmd_lconst_lcmp_tail:
/* convert LCONST, LCMP, IFXX to IF_LXX */
- iptr->dst.insindex = iptr[2].dst.insindex;
+ iptr->dst.block = iptr[2].dst.block;
iptr[1].opc = ICMD_NOP;
iptr[2].opc = ICMD_NOP;
case ICMD_DLOAD:
case ICMD_ALOAD:
COUNT(count_load_instruction);
- i = opcode - ICMD_ILOAD; /* type */
+ type = opcode - ICMD_ILOAD;
- j = iptr->s1.varindex =
- jd->local_map[iptr->s1.varindex * 5 + i];
+ varindex = iptr->s1.varindex =
+ jd->local_map[iptr->s1.varindex * 5 + type];
#if defined(ENABLE_VERIFIER)
- if (sd.var[j].type == TYPE_RET) {
+ if (sd.var[varindex].type == TYPE_RET) {
exceptions_throw_verifyerror(m, "forbidden load of returnAddress");
return false;
}
#endif
-
-#if defined(ENABLE_SSA)
- if (ls != NULL) {
- GET_NEW_VAR(sd, new_index, i);
- DST(i, new_index);
- stackdepth++;
- }
- else
-
-#else
- LOAD(i, j);
-#endif
+ LOAD(type, varindex);
break;
/* pop 2 push 1 */
case ICMD_IINC:
STATISTICS_STACKDEPTH_DISTRIBUTION(count_store_depth);
-#if defined(ENABLE_SSA)
- if (ls != NULL) {
- iptr->s1.varindex =
- jd->local_map[iptr->s1.varindex * 5 +TYPE_INT];
- }
- else {
-#endif
last_store_boundary[iptr->s1.varindex] = sd.new;
iptr->s1.varindex =
i--;
copy = copy->prev;
}
-#if defined(ENABLE_SSA)
- }
-#endif
iptr->dst.varindex = iptr->s1.varindex;
break;
case ICMD_ASTORE:
REQUIRE(1);
- i = opcode - ICMD_ISTORE; /* type */
+ type = opcode - ICMD_ISTORE;
javaindex = iptr->dst.varindex;
- j = iptr->dst.varindex =
- jd->local_map[javaindex * 5 + i];
+ varindex = iptr->dst.varindex =
+ jd->local_map[javaindex * 5 + type];
- COPY_VAL_AND_TYPE(sd, curstack->varnum, j);
+ COPY_VAL_AND_TYPE(sd, curstack->varnum, varindex);
iptr->sx.s23.s3.javaindex = javaindex;
if (curstack->type == TYPE_RET) {
iptr->flags.bits |= INS_FLAG_RETADDR;
iptr->sx.s23.s2.retaddrnr =
- UNUSED - (1 + sd.var[j].vv.retaddr->nr);
+ JAVALOCAL_FROM_RETADDR(sd.var[varindex].vv.retaddr->nr);
sd.javalocals[javaindex] = iptr->sx.s23.s2.retaddrnr;
}
else
- sd.javalocals[javaindex] = j;
+ sd.javalocals[javaindex] = varindex;
/* invalidate the following javalocal for 2-word types */
- if (IS_2_WORD_TYPE(i)) {
+ if (IS_2_WORD_TYPE(type)) {
sd.javalocals[javaindex+1] = UNUSED;
iptr->flags.bits |= INS_FLAG_KILL_NEXT;
}
/* invalidate 2-word types if second half was overwritten */
- if (javaindex > 0 && (i = sd.javalocals[javaindex-1]) != UNUSED) {
+ if (javaindex > 0 && (i = sd.javalocals[javaindex-1]) >= 0) {
if (IS_2_WORD_TYPE(sd.var[i].type)) {
sd.javalocals[javaindex-1] = UNUSED;
iptr->flags.bits |= INS_FLAG_KILL_PREV;
}
#endif
-#if defined(ENABLE_SSA)
- if (ls != NULL) {
-#endif
/* check for conflicts as described in Figure 5.2 */
copy = curstack->prev;
i = stackdepth - 2;
while (copy) {
if ((copy->varkind == LOCALVAR) &&
- (copy->varnum == j))
+ (copy->varnum == varindex))
{
copy->varkind = TEMPVAR;
assert(IS_LOCALVAR(copy));
if (curstack < coalescing_boundary)
goto assume_conflict;
- /* there is no DEF LOCALVAR(j) while curstack is live */
+ /* there is no DEF LOCALVAR(varindex) while curstack is live */
copy = sd.new; /* most recent stackslot created + 1 */
while (--copy > curstack) {
- if (copy->varkind == LOCALVAR && copy->varnum == j)
+ if (copy->varkind == LOCALVAR && copy->varnum == varindex)
goto assume_conflict;
}
assert(!(curstack->flags & PASSTHROUGH));
RELEASE_INDEX(sd, curstack);
curstack->varkind = LOCALVAR;
- curstack->varnum = j;
- curstack->creator->dst.varindex = j;
+ curstack->varnum = varindex;
+ curstack->creator->dst.varindex = varindex;
goto store_tail;
/* revert the coalescing, if it has been done earlier */
assume_conflict:
if ((curstack->varkind == LOCALVAR)
- && (curstack->varnum == j))
+ && (curstack->varnum == varindex))
{
assert(IS_LOCALVAR(curstack));
SET_TEMPVAR(curstack);
/* remember the stack boundary at this store */
store_tail:
last_store_boundary[javaindex] = sd.new;
-#if defined(ENABLE_SSA)
- } /* if (ls != NULL) */
-#endif
if (opcode == ICMD_ASTORE && curstack->type == TYPE_RET)
- STORE(TYPE_RET, j);
+ STORE(TYPE_RET, varindex);
else
- STORE(opcode - ICMD_ISTORE, j);
+ STORE(opcode - ICMD_ISTORE, varindex);
break;
/* pop 3 push 0 */
case ICMD_IFEQ:
iptr->opc = ICMD_IF_LCMPEQ;
icmd_lcmp_if_tail:
- iptr->dst.insindex = iptr[1].dst.insindex;
+ iptr->dst.block = iptr[1].dst.block;
iptr[1].opc = ICMD_NOP;
OP2_BRANCH(TYPE_LNG, TYPE_LNG);
case ICMD_IFEQ:
iptr->opc = ICMD_IF_FCMPEQ;
icmd_if_fcmpl_tail:
- iptr->dst.insindex = iptr[1].dst.insindex;
+ iptr->dst.block = iptr[1].dst.block;
iptr[1].opc = ICMD_NOP;
OP2_BRANCH(TYPE_FLT, TYPE_FLT);
case ICMD_IFEQ:
iptr->opc = ICMD_IF_FCMPEQ;
icmd_if_fcmpg_tail:
- iptr->dst.insindex = iptr[1].dst.insindex;
+ iptr->dst.block = iptr[1].dst.block;
iptr[1].opc = ICMD_NOP;
OP2_BRANCH(TYPE_FLT, TYPE_FLT);
case ICMD_IFEQ:
iptr->opc = ICMD_IF_DCMPEQ;
icmd_if_dcmpl_tail:
- iptr->dst.insindex = iptr[1].dst.insindex;
+ iptr->dst.block = iptr[1].dst.block;
iptr[1].opc = ICMD_NOP;
OP2_BRANCH(TYPE_DBL, TYPE_DBL);
case ICMD_IFEQ:
iptr->opc = ICMD_IF_DCMPEQ;
icmd_if_dcmpg_tail:
- iptr->dst.insindex = iptr[1].dst.insindex;
+ iptr->dst.block = iptr[1].dst.block;
iptr[1].opc = ICMD_NOP;
OP2_BRANCH(TYPE_DBL, TYPE_DBL);
case ICMD_JSR:
OP0_1(TYPE_RET);
- tbptr = BLOCK_OF(iptr->sx.s23.s3.jsrtarget.insindex);
+ tbptr = iptr->sx.s23.s3.jsrtarget.block;
tbptr->type = BBTYPE_SBR;
assert(sd.bptr->next); /* XXX exception */
#endif
tbptr = stack_mark_reached(&sd, tbptr, curstack, stackdepth);
- if (!tbptr)
+ if (tbptr == NULL)
return false;
iptr->sx.s23.s3.jsrtarget.block = tbptr;
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;
}
}
}
i = stackdepth - 1;
for (copy = curstack; copy; i--, copy = copy->prev) {
varinfo *v;
- s4 t;
/* with the new vars rd->interfaces will be removed */
/* and all in and outvars have to be STACKVARS! */
/* create an unresolvable conflict */
SET_TEMPVAR(copy);
- t = copy->type;
+ type = copy->type;
v = sd.var + copy->varnum;
v->flags |= INOUT;
/* do not allocate variables for returnAddresses */
- if (t != TYPE_RET) {
- if (jd->interface_map[i*5 + t].flags == UNUSED) {
+ if (type != TYPE_RET) {
+ if (jd->interface_map[i*5 + type].flags == UNUSED) {
/* no interface var until now for this depth and */
/* type */
- jd->interface_map[i*5 + t].flags = v->flags;
+ jd->interface_map[i*5 + type].flags = v->flags;
}
else {
- jd->interface_map[i*5 + t].flags |= v->flags;
+ jd->interface_map[i*5 + type].flags |= v->flags;
}
}
for (i=0; i<sd.bptr->indepth; ++i) {
varinfo *v = sd.var + sd.bptr->invars[i];
- s4 t;
- t = v->type;
+ type = v->type;
- if (t != TYPE_RET) {
- if (jd->interface_map[i*5 + t].flags == UNUSED) {
+ if (type != TYPE_RET) {
+ if (jd->interface_map[i*5 + type].flags == UNUSED) {
/* no interface var until now for this depth and */
/* type */
- jd->interface_map[i*5 + t].flags = v->flags;
+ jd->interface_map[i*5 + type].flags = v->flags;
}
else {
- jd->interface_map[i*5 + t].flags |= v->flags;
+ jd->interface_map[i*5 + type].flags |= v->flags;
}
}
}
void stack_javalocals_store(instruction *iptr, s4 *javalocals)
{
- s4 idx; /* index into the jd->var array */
- s4 j; /* java local index */
+ s4 varindex; /* index into the jd->var array */
+ s4 javaindex; /* java local index */
- idx = iptr->dst.varindex;
- j = iptr->sx.s23.s3.javaindex;
+ varindex = iptr->dst.varindex;
+ javaindex = iptr->sx.s23.s3.javaindex;
- if (j != UNUSED) {
+ if (javaindex != UNUSED) {
+ assert(javaindex >= 0);
if (iptr->flags.bits & INS_FLAG_RETADDR)
- javalocals[j] = iptr->sx.s23.s2.retaddrnr;
+ javalocals[javaindex] = iptr->sx.s23.s2.retaddrnr;
else
- javalocals[j] = idx;
+ javalocals[javaindex] = varindex;
if (iptr->flags.bits & INS_FLAG_KILL_PREV)
- javalocals[j-1] = UNUSED;
+ javalocals[javaindex-1] = UNUSED;
if (iptr->flags.bits & INS_FLAG_KILL_NEXT)
- javalocals[j+1] = UNUSED;
+ javalocals[javaindex+1] = UNUSED;
}
}
projects / cacao.git / blobdiff