/* src/vm/jit/stack.c - stack analysis
- 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: Edwin Steiner
- Christian Thalinger
- Christian Ullrich
-
- $Id: stack.c 5517 2006-09-15 15:52:02Z edwin $
-
*/
#include "vm/global.h"
#include "vm/builtin.h"
-#include "vm/options.h"
-#include "vm/resolve.h"
-#include "vm/statistics.h"
#include "vm/stringlocal.h"
#include "vm/types.h"
#include "vm/jit/abi.h"
#include "vm/jit/cfg.h"
#include "vm/jit/codegen-common.h"
+#include "vm/jit/parse.h"
#include "vm/jit/show.h"
#if defined(ENABLE_DISASSEMBLER)
#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
-/*#define STACK_VERBOSE*/
+#include "vmcore/options.h"
+#include "vm/resolve.h"
+#if defined(ENABLE_STATISTICS)
+# include "vmcore/statistics.h"
+#endif
-/* macro for saving #ifdefs ***************************************************/
+/*#define STACK_VERBOSE*/
-#if defined(ENABLE_INTRP)
-#define IF_INTRP(x) if (opt_intrp) { x }
-#define IF_NO_INTRP(x) if (!opt_intrp) { x }
-#else
-#define IF_INTRP(x)
-#define IF_NO_INTRP(x) { x }
-#endif
-#if defined(ENABLE_INTRP)
-#if defined(ENABLE_JIT)
-#define IF_JIT(x) if (!opt_intrp) { x }
-#else
-#define IF_JIT(x)
-#endif
-#else /* !defined(ENABLE_INTRP) */
-#define IF_JIT(x) { x }
-#endif /* defined(ENABLE_INTRP) */
+/* macro for saving #ifdefs ***************************************************/
#if defined(ENABLE_STATISTICS)
#define STATISTICS_STACKDEPTH_DISTRIBUTION(distr) \
#define STATISTICS_STACKDEPTH_DISTRIBUTION(distr)
#endif
+
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+
+
+/* For returnAddresses we use a field of the typeinfo to store from which */
+/* subroutine the returnAddress will return, if used. */
+/* XXX It would be nicer to use typeinfo.typeclass, but the verifier seems */
+/* to need it initialised to NULL. This should be investigated. */
+
+#if defined(ENABLE_VERIFIER)
+#define SBRSTART typeinfo.elementclass.any
+#endif
+
+
/* stackdata_t *****************************************************************
This struct holds internal data during stack analysis.
stackptr new; /* next free stackelement */
s4 vartop; /* next free variable index */
s4 localcount; /* number of locals (at the start of var) */
- s4 varcount; /* total number of variables allocated */
+ s4 varcount; /* maximum number of variables expected */
+ s4 varsallocated; /* total number of variables allocated */
+ s4 maxlocals; /* max. number of Java locals */
varinfo *var; /* variable array (same as jd->var) */
+ s4 *javalocals; /* map from Java locals to jd->var indices */
methodinfo *m; /* the method being analysed */
jitdata *jd; /* current jitdata */
basicblock *last_real_block; /* the last block before the empty one */
bool repeat; /* if true, iterate the analysis again */
- exceptiontable **handlers; /* exception handlers for the current block */
- exceptiontable *extableend; /* points to the last exception entry */
+ exception_entry **handlers; /* exception handlers for the current block */
+ exception_entry *extableend; /* points to the last exception entry */
stackelement exstack; /* instack for exception handlers */
};
/* Pay attention to not release a localvar once implementing it! */
#define RELEASE_INDEX(sd, varindex)
-#define GET_NEW_VAR(sd, new_varindex, newtype) \
+#define GET_NEW_VAR(sd, newvarindex, newtype) \
do { \
- GET_NEW_INDEX((sd), (new_varindex)); \
- (sd).var[new_index].type = (newtype); \
+ GET_NEW_INDEX((sd), (newvarindex)); \
+ (sd).var[newvarindex].type = (newtype); \
} while (0)
/* macros for querying variable properties **************************/
-#define IS_OUTVAR(sp) \
- (sd.var[(sp)->varnum].flags & OUTVAR)
+#define IS_INOUT(sp) \
+ (sd.var[(sp)->varnum].flags & INOUT)
#define IS_PREALLOC(sp) \
(sd.var[(sp)->varnum].flags & PREALLOC)
#define IS_TEMPVAR(sp) \
( ((sp)->varnum >= sd.localcount) \
- && !(sd.var[(sp)->varnum].flags & (OUTVAR | PREALLOC)) )
+ && !(sd.var[(sp)->varnum].flags & (INOUT | PREALLOC)) )
#define IS_LOCALVAR_SD(sd, sp) \
#define SET_TEMPVAR(sp) \
do { \
if (IS_LOCALVAR((sp))) { \
- GET_NEW_VAR(sd, new_index, (sp)->type); \
- sd.var[new_index].flags = (sp)->flags; \
- (sp)->varnum = new_index; \
- (sp)->varkind = TEMPVAR; \
- if ((sp)->creator) \
- (sp)->creator->dst.varindex = new_index; \
+ stack_change_to_tempvar(&sd, (sp), iptr); \
} \
- sd.var[(sp)->varnum].flags &= ~(OUTVAR | PREALLOC); \
+ sd.var[(sp)->varnum].flags &= ~(INOUT | PREALLOC); \
} while (0);
#define SET_PREALLOC(sp) \
/* macro for propagating constant values ****************************/
-#define COPY_VAL_AND_TYPE(sd, sindex, dindex) \
+#if defined(ENABLE_VERIFIER)
+#define COPY_VAL_AND_TYPE_VAR(sv, dv) \
do { \
- (sd).var[(dindex)].type = (sd).var[(sindex)].type; \
- (sd).var[(dindex)].vv = (sd).var[(sindex)].vv; \
- } while (0) \
+ if (((dv)->type = (sv)->type) == TYPE_RET) { \
+ (dv)->vv = (sv)->vv; \
+ (dv)->SBRSTART = (sv)->SBRSTART; \
+ } \
+ } while (0)
+#else
+#define COPY_VAL_AND_TYPE_VAR(sv, dv) \
+ do { \
+ (dv)->type = (sv)->type; \
+ if (((dv)->type = (sv)->type) == TYPE_RET) { \
+ (dv)->vv = (sv)->vv; \
+ } \
+ } while (0)
+#endif
+
+#define COPY_VAL_AND_TYPE(sd, sindex, dindex) \
+ COPY_VAL_AND_TYPE_VAR((sd).var + (sindex), (sd).var + (dindex))
/* stack modelling macros *******************************************/
(d)->creator = iptr; \
} while (0)
+#define MOVE_TO_TEMP(sp) \
+ do { \
+ GET_NEW_INDEX(sd, new_index); \
+ iptr->opc = ICMD_MOVE; \
+ iptr->s1.varindex = (sp)->varnum; \
+ iptr->dst.varindex = new_index; \
+ COPY_VAL_AND_TYPE(sd, (sp)->varnum, new_index); \
+ (sp)->varnum = new_index; \
+ (sp)->varkind = TEMPVAR; \
+ } while (0)
/* macros for branching / reaching basic blocks *********************/
#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 void stack_verbose_show_block(stackdata_t *sd, basicblock *bptr);
static void stack_verbose_block_enter(stackdata_t *sd, bool reanalyse);
static void stack_verbose_block_exit(stackdata_t *sd, bool superblockend);
+static void stack_verbose_show_state(stackdata_t *sd, instruction *iptr,
+ stackptr curstack);
#endif
/* stack_grow_variable_array ***************************************************
Grow the variable array so the given number of additional variables fits in.
+ The number is added to `varcount`, which is the maximum number of variables
+ we expect to need at this point. The actual number of variables
+ (`varsallocated`) may be larger than that, in order to avoid too many
+ reallocations.
IN:
sd...........stack analysis data
static void stack_grow_variable_array(stackdata_t *sd, s4 num)
{
- s4 newcount;
+ s4 newsize;
assert(num >= 0);
- if (num == 0)
- return;
+ if (sd->varcount + num > sd->varsallocated) {
+ newsize = 2*sd->varsallocated + num;
- /* XXX avoid too many reallocations */
- newcount = sd->varcount + num;
+ sd->var = DMREALLOC(sd->var, varinfo, sd->varsallocated, newsize);
+ MZERO(sd->var + sd->varsallocated, varinfo, (newsize - sd->varsallocated));
+ sd->varsallocated = newsize;
+ sd->jd->var = sd->var;
+ }
- sd->var = DMREALLOC(sd->var, varinfo, sd->varcount, newcount);
- sd->varcount = newcount;
- sd->jd->var = sd->var;
- sd->jd->varcount = newcount;
+ sd->varcount += num;
+ sd->jd->varcount += num;
+
+ assert(sd->varcount <= sd->varsallocated);
}
b->next = sd->last_real_block->next;
sd->last_real_block->next = b;
sd->last_real_block = b;
- sd->jd->new_basicblockcount++;
+ b->nr = sd->jd->basicblockcount++;
+ b->next->nr = b->nr + 1;
}
clone->iinstr = NULL;
clone->inlocals = NULL;
+ clone->javalocals = NULL;
clone->invars = NULL;
clone->original = (b->original) ? b->original : b;
clone->copied_to = clone->original->copied_to;
clone->original->copied_to = clone;
- clone->nr = sd->m->c_debug_nr++;
clone->next = NULL;
clone->flags = BBREACHED;
stack_append_block(sd, clone);
- /* allocate space for the invars of the clone */
+ /* reserve space for the invars of the clone */
stack_grow_variable_array(sd, b->indepth);
}
+/* stack_create_locals *********************************************************
+
+ Create the local variables for the start of the given basic block.
+
+ IN:
+ sd...........stack analysis data
+ b............block to create the locals for
+
+*******************************************************************************/
+
+static void stack_create_locals(stackdata_t *sd, basicblock *b)
+{
+ s4 i;
+ s4 *jl;
+ varinfo *dv;
+
+ /* copy the current state of the local variables */
+ /* (one extra local is needed by the verifier) */
+
+ dv = DMNEW(varinfo, sd->localcount + VERIFIER_EXTRA_LOCALS);
+ b->inlocals = dv;
+ for (i=0; i<sd->localcount; ++i)
+ *dv++ = sd->var[i];
+
+ /* the current map from java locals to cacao variables */
+
+ jl = DMNEW(s4, sd->maxlocals);
+ b->javalocals = jl;
+ MCOPY(jl, sd->javalocals, s4, sd->maxlocals);
+}
+
+
+/* stack_merge_locals **********************************************************
+
+ Merge local variables at the beginning of the given basic block.
+
+ IN:
+ sd...........stack analysis data
+ b............the block that is reached
+
+*******************************************************************************/
+
+static void stack_merge_locals(stackdata_t *sd, basicblock *b)
+{
+ s4 i;
+ varinfo *dv;
+ varinfo *sv;
+
+ /* If a javalocal is mapped to different cacao locals along the */
+ /* incoming control-flow edges, it becomes undefined. */
+
+ for (i=0; i<sd->maxlocals; ++i) {
+ if (b->javalocals[i] != UNUSED && b->javalocals[i] != sd->javalocals[i]) {
+ b->javalocals[i] = UNUSED;
+ if (b->flags >= BBFINISHED)
+ b->flags = BBTYPECHECK_REACHED;
+ if (b->nr <= sd->bptr->nr)
+ sd->repeat = true;
+ }
+ }
+
+#if defined(ENABLE_VERIFIER)
+ if (b->inlocals) {
+ for (i=0; i<sd->localcount; ++i) {
+ dv = b->inlocals + i;
+ sv = sd->var + i;
+ if ((sv->type == TYPE_RET && dv->type == TYPE_RET)
+ && (sv->SBRSTART != dv->SBRSTART))
+ {
+#if defined(STACK_VERBOSE)
+ printf("JSR MISMATCH: setting variable %d to VOID\n", i);
+#endif
+ dv->type = TYPE_VOID;
+ if (b->flags >= BBFINISHED)
+ b->flags = BBTYPECHECK_REACHED;
+ sd->repeat = true; /* This is very rare, so just repeat */
+ }
+ }
+ }
+#endif /* defined(ENABLE_VERIFIER) */
+}
+
+
/* stack_create_invars *********************************************************
Create the invars for the given basic block. Also make a copy of the locals.
stackptr sp;
int i;
int index;
- varinfo *v;
+ varinfo *dv;
+ varinfo *sv;
assert(sd->vartop + stackdepth <= sd->varcount);
i = stackdepth;
for (sp = curstack; i--; sp = sp->prev) {
b->invars[i] = --index;
- v = sd->var + index;
- v->type = sp->type;
- v->flags = OUTVAR;
- v->vv = sd->var[sp->varnum].vv;
-#if defined(STACK_VERBOSE) && 0
- printf("\tinvar[%d]: %d\n", i, sd->var[b->invars[i]]);
-#endif
+ dv = sd->var + index;
+ sv = sd->var + sp->varnum;
+ dv->flags = INOUT;
+ COPY_VAL_AND_TYPE_VAR(sv, dv);
}
- /* copy the current state of the local variables */
- /* (one extra local is needed by the verifier) */
-
- v = DMNEW(varinfo, sd->localcount + VERIFIER_EXTRA_LOCALS);
- b->inlocals = v;
- for (i=0; i<sd->localcount; ++i)
- *v++ = sd->var[i];
+ stack_create_locals(sd, b);
}
for (i=0; i<n; ++i, ++dv) {
sv = sd->var + sd->bptr->outvars[i];
b->invars[i] = sd->vartop++;
- dv->type = sv->type;
- dv->flags = OUTVAR;
- dv->vv = sv->vv;
+ dv->flags = INOUT;
+ COPY_VAL_AND_TYPE_VAR(sv, dv);
}
}
- /* copy the current state of the local variables */
- /* (one extra local is needed by the verifier) */
-
- dv = DMNEW(varinfo, sd->localcount + VERIFIER_EXTRA_LOCALS);
- b->inlocals = dv;
- for (i=0; i<sd->localcount; ++i)
- *dv++ = sd->var[i];
+ stack_create_locals(sd, b);
}
stackptr sp;
basicblock *orig;
bool separable;
+ varinfo *sv;
+ varinfo *dv;
#if defined(STACK_VERBOSE)
printf("stack_check_invars(L%03d)\n", b->nr);
i = orig->indepth;
+#if defined(ENABLE_VERIFIER)
if (i != stackdepth) {
exceptions_throw_verifyerror(sd->m, "Stack depth mismatch");
return NULL;
}
+#endif
do {
separable = false;
sp = curstack;
for (i = orig->indepth; i--; sp = sp->prev) {
- if (sd->var[b->invars[i]].type != sp->type) {
- exceptions_throw_verifyerror_for_stack(sd->m,
- sd->var[b->invars[i]].type);
+ dv = sd->var + b->invars[i];
+ sv = sd->var + sp->varnum;
+
+#if defined(ENABLE_VERIFIER)
+ if (dv->type != sp->type) {
+ exceptions_throw_verifyerror_for_stack(sd->m, dv->type);
return NULL;
}
+#endif
if (sp->type == TYPE_RET) {
- if (sd->var[b->invars[i]].vv.retaddr != sd->var[sp->varnum].vv.retaddr) {
+#if defined(ENABLE_VERIFIER)
+ if (dv->SBRSTART != sv->SBRSTART) {
+ exceptions_throw_verifyerror(sd->m, "Mismatched stack types");
+ return NULL;
+ }
+#endif
+ if (dv->vv.retaddr != sv->vv.retaddr) {
separable = true;
- break;
+ /* don't break! have to check the remaining stackslots */
}
}
}
if (b->inlocals) {
for (i=0; i<sd->localcount; ++i) {
- if (sd->var[i].type == TYPE_RET && b->inlocals[i].type == TYPE_RET) {
- if (sd->var[i].vv.retaddr != b->inlocals[i].vv.retaddr) {
+ dv = b->inlocals + i;
+ sv = sd->var + i;
+ if (sv->type == TYPE_RET && dv->type == TYPE_RET) {
+ if (
+#if defined(ENABLE_VERIFIER)
+ (sv->SBRSTART == dv->SBRSTART) &&
+#endif
+ (sv->vv.retaddr != dv->vv.retaddr))
+ {
separable = true;
break;
}
}
if (!separable) {
- /* XXX mark mixed type variables void */
/* XXX cascading collapse? */
+
+ stack_merge_locals(sd, b);
+
#if defined(STACK_VERBOSE)
printf("------> using L%03d\n", b->nr);
#endif
i = orig->indepth;
n = sd->bptr->outdepth;
+#if defined(ENABLE_VERIFIER)
if (i != n) {
exceptions_throw_verifyerror(sd->m, "Stack depth mismatch");
return NULL;
}
+#endif
do {
separable = false;
for (i=0; i<n; ++i, ++dv) {
sv = sd->var + sd->bptr->outvars[i];
+
+#if defined(ENABLE_VERIFIER)
if (sv->type != dv->type) {
exceptions_throw_verifyerror_for_stack(sd->m, dv->type);
return NULL;
}
+#endif
if (dv->type == TYPE_RET) {
+#if defined(ENABLE_VERIFIER)
+ if (sv->SBRSTART != dv->SBRSTART) {
+ exceptions_throw_verifyerror(sd->m, "Mismatched stack types");
+ return NULL;
+ }
+#endif
if (sv->vv.retaddr != dv->vv.retaddr) {
separable = true;
- break;
+ /* don't break! have to check the remaining stackslots */
}
}
}
if (b->inlocals) {
for (i=0; i<sd->localcount; ++i) {
- if (sd->var[i].type == TYPE_RET && b->inlocals[i].type == TYPE_RET) {
- if (sd->var[i].vv.retaddr != b->inlocals[i].vv.retaddr) {
+ dv = b->inlocals + i;
+ sv = sd->var + i;
+ if (
+#if defined(ENABLE_VERIFIER)
+ (sv->SBRSTART == dv->SBRSTART) &&
+#endif
+ (sv->type == TYPE_RET && dv->type == TYPE_RET))
+ {
+ if (sv->vv.retaddr != dv->vv.retaddr) {
separable = true;
break;
}
}
if (!separable) {
- /* XXX mark mixed type variables void */
/* XXX cascading collapse? */
+
+ stack_merge_locals(sd, b);
+
#if defined(STACK_VERBOSE)
printf("------> using L%03d\n", b->nr);
#endif
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 <= sd->bptr)
+
+ if (b->nr <= sd->bptr->nr)
b->bitflags |= BBFLAG_REPLACEMENT;
if (b->flags < BBREACHED) {
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 <= sd->bptr)
+
+ if (b->nr <= sd->bptr->nr)
b->bitflags |= BBFLAG_REPLACEMENT;
if (b->flags < BBREACHED) {
/* 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;
bool superblockend;
- bool maythrow;
bool cloneinstructions;
- exceptiontable *ex;
+ exception_entry *ex;
#if defined(STACK_VERBOSE)
stack_verbose_block_enter(sd, true);
MCOPY(iptr, orig->iinstr, instruction, len);
iptr[len].opc = ICMD_NOP;
+ iptr[len].line = 0;
+ iptr[len].flags.bits = 0;
b->iinstr = iptr;
b->icount = ++len;
- /* allocate space for the clone's block variables */
+ /* reserve space for the clone's block variables */
stack_grow_variable_array(sd, orig->varcount);
/* clone exception handlers */
for (i=0; sd->handlers[i]; ++i) {
- ex = DNEW(exceptiontable);
+ ex = DNEW(exception_entry);
ex->handler = sd->handlers[i]->handler;
ex->start = b;
- ex->end = b; /* XXX hack, see end of new_stack_analyse */
+ ex->end = b; /* XXX hack, see end of stack_analyse */
ex->catchtype = sd->handlers[i]->catchtype;
ex->down = NULL;
assert(sd->extableend->down == NULL);
sd->extableend->down = ex;
sd->extableend = ex;
- sd->jd->cd->exceptiontablelength++;
+ sd->jd->exceptiontablelength++;
sd->handlers[i] = ex;
}
if (b->original) {
/* find exception handlers for the cloned block */
len = 0;
- ex = sd->jd->cd->exceptiontable;
+ ex = sd->jd->exceptiontable;
for (; ex != NULL; ex = ex->down) {
/* XXX the cloned exception handlers have identical */
/* start end end blocks. */
if (b->inlocals)
MCOPY(sd->var, b->inlocals, varinfo, sd->localcount);
+ MCOPY(sd->javalocals, b->javalocals, s4, sd->maxlocals);
+
/* reach exception handlers for this block */
if (!stack_reach_handlers(sd))
for (len = b->icount; len--; iptr++) {
#if defined(STACK_VERBOSE)
- new_show_icmd(sd->jd, iptr, false, SHOW_STACK);
+ show_icmd(sd->jd, iptr, false, SHOW_STACK);
printf("\n");
#endif
- maythrow = false;
-
switch (iptr->opc) {
case ICMD_RET:
- j = iptr->s1.varindex;
+ varindex = iptr->s1.varindex;
- if (sd->var[j].type != TYPE_RET) {
+#if defined(ENABLE_VERIFIER)
+ 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_JSR:
iptr->sx.s23.s3.jsrtarget.block = stack_mark_reached_from_outvars(sd, iptr->sx.s23.s3.jsrtarget.block);
+ RELOCATE(iptr->dst.varindex);
superblockend = true;
break;
case ICMD_CHECKNULL:
case ICMD_PUTSTATICCONST:
- maythrow = true;
break;
case ICMD_NOP:
case ICMD_IINC:
- case ICMD_INLINE_START:
- case ICMD_INLINE_END:
- case ICMD_INLINE_GOTO:
break;
case ICMD_GOTO:
/* pop 0 push 1 const */
case ICMD_ACONST:
- maythrow = true;
case ICMD_ICONST:
case ICMD_LCONST:
case ICMD_FCONST:
RELOCATE(iptr->sx.s23.s2.varindex);
RELOCATE(iptr->s1.varindex);
RELOCATE(iptr->dst.varindex);
- maythrow = true;
break;
/* pop 3 push 0 */
RELOCATE(iptr->sx.s23.s3.varindex);
RELOCATE(iptr->sx.s23.s2.varindex);
RELOCATE(iptr->s1.varindex);
- maythrow = true;
break;
/* pop 1 push 0 store */
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 =
+ JAVALOCAL_FROM_RETADDR(sd->var[varindex].vv.retaddr->nr);
+ sd->javalocals[i] = iptr->sx.s23.s2.retaddrnr;
+ }
+ else
+ 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)
+ sd->javalocals[i+1] = UNUSED;
break;
/* pop 1 push 0 */
case ICMD_ARETURN:
case ICMD_ATHROW:
- maythrow = true;
case ICMD_IRETURN:
case ICMD_LRETURN:
case ICMD_FRETURN:
case ICMD_PUTSTATIC:
case ICMD_PUTFIELDCONST:
- maythrow = true;
case ICMD_POP:
RELOCATE(iptr->s1.varindex);
break;
case ICMD_MONITORENTER:
case ICMD_MONITOREXIT:
RELOCATE(iptr->s1.varindex);
- maythrow = true;
break;
/* pop 2 push 0 branch */
case ICMD_BASTORECONST:
case ICMD_CASTORECONST:
case ICMD_SASTORECONST:
- maythrow = true;
case ICMD_POP2:
RELOCATE(iptr->sx.s23.s2.varindex);
RELOCATE(iptr->s1.varindex);
case ICMD_IREM:
case ICMD_LDIV:
case ICMD_LREM:
- maythrow = true;
case ICMD_IADD:
case ICMD_ISUB:
case ICMD_IMUL:
case ICMD_INSTANCEOF:
case ICMD_NEWARRAY:
case ICMD_ANEWARRAY:
- maythrow = true;
case ICMD_GETFIELD:
case ICMD_IADDCONST:
case ICMD_ISUBCONST:
case ICMD_GETSTATIC:
case ICMD_NEW:
- maythrow = true;
RELOCATE(iptr->dst.varindex);
break;
argp = iptr->sx.s23.s2.args;
}
- maythrow = true;
while (--i >= 0) {
RELOCATE(*argp);
argp++;
break;
default:
- *exceptionptr =
- new_internalerror("Unknown ICMD %d during stack re-analysis",
- iptr->opc);
+ exceptions_throw_internalerror("Unknown ICMD %d during stack re-analysis",
+ iptr->opc);
return false;
} /* switch */
#if defined(STACK_VERBOSE)
- new_show_icmd(sd->jd, iptr, false, SHOW_STACK);
+ show_icmd(sd->jd, iptr, false, SHOW_STACK);
printf("\n");
#endif
}
}
+/* stack_change_to_tempvar *****************************************************
+
+ Change the given stackslot to a TEMPVAR. This includes creating a new
+ temporary variable and changing the dst.varindex of the creator of the
+ stacklot to the new variable index. If this stackslot has been passed
+ through ICMDs between the point of its creation and the current point,
+ then the variable index is also changed in these ICMDs.
+
+ IN:
+ sd...........stack analysis data
+ sp...........stackslot to change
+ ilimit.......instruction up to which to look for ICMDs passing-through
+ the stackslot (exclusive). This may point exactly after the
+ last instruction, in which case the search is done to the
+ basic block end.
+
+*******************************************************************************/
+
+static void stack_change_to_tempvar(stackdata_t *sd, stackptr sp,
+ instruction *ilimit)
+{
+ s4 newindex;
+ s4 oldindex;
+ instruction *iptr;
+ s4 depth;
+ s4 i;
+
+ oldindex = sp->varnum;
+
+ /* create a new temporary variable */
+
+ GET_NEW_VAR(*sd, newindex, sp->type);
+
+ sd->var[newindex].flags = sp->flags;
+
+ /* change the stackslot */
+
+ sp->varnum = newindex;
+ sp->varkind = TEMPVAR;
+
+ /* change the dst.varindex of the stackslot's creator */
+
+ if (sp->creator)
+ sp->creator->dst.varindex = newindex;
+
+ /* handle ICMDs this stackslot passed through, if any */
+
+ if (sp->flags & PASSTHROUGH) {
+ iptr = (sp->creator) ? (sp->creator + 1) : sd->bptr->iinstr;
+
+ /* assert that the limit points to an ICMD, or after the last one */
+
+ assert(ilimit >= sd->bptr->iinstr);
+ assert(ilimit <= sd->bptr->iinstr + sd->bptr->icount);
+
+ /* find the stackdepth under sp plus one */
+ /* Note: This number is usually known when this function is called, */
+ /* but calculating it here is less error-prone and should not be */
+ /* a performance problem. */
+
+ for (depth = 0; sp != NULL; sp = sp->prev)
+ depth++;
+
+ /* iterate over all instructions in the range and replace */
+
+ for (; iptr < ilimit; ++iptr) {
+ switch (iptr->opc) {
+ case ICMD_INVOKESTATIC:
+ case ICMD_INVOKESPECIAL:
+ case ICMD_INVOKEVIRTUAL:
+ case ICMD_INVOKEINTERFACE:
+ case ICMD_BUILTIN:
+ i = iptr->s1.argcount - depth;
+ if (iptr->sx.s23.s2.args[i] == oldindex) {
+ iptr->sx.s23.s2.args[i] = newindex;
+ }
+ break;
+ /* IMPORTANT: If any ICMD sets the PASSTHROUGH flag of a */
+ /* stackslot, it must be added in this switch! */
+ }
+ }
+ }
+}
+
+
+/* stack_init_javalocals *******************************************************
+
+ Initialize the mapping from Java locals to cacao variables at method entry.
+
+ IN:
+ sd...........stack analysis data
+
+*******************************************************************************/
+
+static void stack_init_javalocals(stackdata_t *sd)
+{
+ s4 *jl;
+ s4 type,i,j;
+ methoddesc *md;
+ jitdata *jd;
+
+ jd = sd->jd;
+
+ jl = DMNEW(s4, sd->maxlocals);
+ jd->basicblocks[0].javalocals = jl;
+
+ for (i=0; i<sd->maxlocals; ++i)
+ jl[i] = UNUSED;
+
+ md = jd->m->parseddesc;
+ j = 0;
+ for (i=0; i<md->paramcount; ++i) {
+ type = md->paramtypes[i].type;
+ jl[j] = jd->local_map[5*j + type];
+ j++;
+ if (IS_2_WORD_TYPE(type))
+ j++;
+ }
+}
+
+
/* stack_analyse ***************************************************************
Analyse_stack uses the intermediate code created by parse.c to
*******************************************************************************/
-bool new_stack_analyse(jitdata *jd)
+bool stack_analyse(jitdata *jd)
{
methodinfo *m; /* method being analyzed */
- codeinfo *code;
- codegendata *cd;
registerdata *rd;
stackdata_t sd;
-#if defined(ENABLE_SSA)
- lsradata *ls;
-#endif
- int b_index; /* basic block index */
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 */
instruction *iptr; /* the current instruction */
basicblock *tbptr;
basicblock *original;
- exceptiontable *ex;
+ exception_entry *ex;
stackptr *last_store_boundary;
stackptr coalescing_boundary;
int new_index; /* used to get a new var index with GET_NEW_INDEX*/
#if defined(STACK_VERBOSE)
- new_show_method(jd, SHOW_PARSE);
+ show_method(jd, SHOW_PARSE);
#endif
/* get required compiler data - initialization */
m = jd->m;
- code = jd->code;
- cd = jd->cd;
rd = jd->rd;
-#if defined(ENABLE_SSA)
- ls = jd->ls;
-#endif
/* initialize the stackdata_t struct */
sd.vartop = jd->vartop;
sd.localcount = jd->localcount;
sd.var = jd->var;
- sd.handlers = DMNEW(exceptiontable *, cd->exceptiontablelength + 1);
+ sd.varsallocated = sd.varcount;
+ sd.maxlocals = m->maxlocals;
+ sd.javalocals = DMNEW(s4, sd.maxlocals);
+ sd.handlers = DMNEW(exception_entry *, jd->exceptiontablelength + 1);
+
+ /* prepare the variable for exception handler stacks */
+ /* (has been reserved by STACK_EXTRA_VARS, or VERIFIER_EXTRA_VARS) */
+
sd.exstack.type = TYPE_ADR;
sd.exstack.prev = NULL;
- sd.exstack.varnum = 0; /* XXX do we need a real variable index here? */
-
-#if defined(ENABLE_LSRA)
- m->maxlifetimes = 0;
-#endif
+ sd.exstack.varnum = sd.localcount;
+ sd.var[sd.exstack.varnum].type = TYPE_ADR;
#if defined(ENABLE_STATISTICS)
iteration_count = 0;
/* find the last real basic block */
sd.last_real_block = NULL;
- tbptr = jd->new_basicblocks;
+ tbptr = jd->basicblocks;
while (tbptr->next) {
sd.last_real_block = tbptr;
tbptr = tbptr->next;
/* find the last exception handler */
- if (cd->exceptiontablelength)
- sd.extableend = cd->exceptiontable + cd->exceptiontablelength - 1;
+ if (jd->exceptiontablelength)
+ sd.extableend = jd->exceptiontable + jd->exceptiontablelength - 1;
else
sd.extableend = NULL;
/* init jd->interface_map */
+ jd->maxinterfaces = m->maxstack;
jd->interface_map = DMNEW(interface_info, m->maxstack * 5);
for (i = 0; i < m->maxstack * 5; i++)
jd->interface_map[i].flags = UNUSED;
- last_store_boundary = DMNEW(stackptr, cd->maxlocals);
+ last_store_boundary = DMNEW(stackptr, m->maxlocals);
/* initialize flags and invars (none) of first block */
- jd->new_basicblocks[0].flags = BBREACHED;
- jd->new_basicblocks[0].invars = NULL;
- jd->new_basicblocks[0].indepth = 0;
- jd->new_basicblocks[0].inlocals =
+ jd->basicblocks[0].flags = BBREACHED;
+ jd->basicblocks[0].invars = NULL;
+ jd->basicblocks[0].indepth = 0;
+ jd->basicblocks[0].inlocals =
DMNEW(varinfo, jd->localcount + VERIFIER_EXTRA_LOCALS);
- MCOPY(jd->new_basicblocks[0].inlocals, jd->var, varinfo,
+ MCOPY(jd->basicblocks[0].inlocals, jd->var, varinfo,
jd->localcount + VERIFIER_EXTRA_LOCALS);
+ /* initialize java local mapping of first block */
+
+ stack_init_javalocals(&sd);
+
/* stack analysis loop (until fixpoint reached) **************************/
do {
/* initialize loop over basic blocks */
- sd.bptr = jd->new_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 *****************************************/
continue;
}
+ 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? */
continue;
}
/* This block has to be analysed now. */
+ deadcode = false;
+
/* XXX The rest of this block is still indented one level too */
/* much in order to avoid a giant diff by changing that. */
original = (sd.bptr->original) ? sd.bptr->original : sd.bptr;
len = 0;
- ex = cd->exceptiontable;
+ ex = jd->exceptiontable;
for (; ex != NULL; ex = ex->down) {
if ((ex->start <= original) && (ex->end > original)) {
sd.handlers[len++] = ex;
/* reset the new pointer for allocating stackslots */
- sd.new = jd->new_stack;
+ sd.new = jd->stack;
/* create the instack of this block */
if (sd.bptr->inlocals)
MCOPY(sd.var, sd.bptr->inlocals, varinfo, sd.localcount);
+ MCOPY(sd.javalocals, sd.bptr->javalocals, s4, sd.maxlocals);
+
/* set up local variables for analyzing this block */
- deadcode = false;
superblockend = false;
len = sd.bptr->icount;
iptr = sd.bptr->iinstr;
- b_index = sd.bptr - jd->new_basicblocks;
/* mark the block as analysed */
/* reset variables for dependency checking */
coalescing_boundary = sd.new;
- for( i = 0; i < cd->maxlocals; i++)
+ for( i = 0; i < m->maxlocals; i++)
last_store_boundary[i] = sd.new;
/* remember the start of this block's variables */
while (--len >= 0) {
#if defined(STACK_VERBOSE)
- new_show_icmd(jd, iptr, false, SHOW_PARSE); printf("\n");
- for( copy = curstack; copy; copy = copy->prev ) {
- printf("%2d(%d", copy->varnum, copy->type);
- if (IS_OUTVAR(copy))
- printf("S");
- if (IS_PREALLOC(copy))
- printf("A");
- printf(") ");
- }
- printf("\n");
+ stack_verbose_show_state(&sd, iptr, curstack);
#endif
/* fetch the current opcode */
/* automatically replace some ICMDs with builtins */
-#if defined(USEBUILTINTABLE)
- IF_NO_INTRP(
- bte = builtintable_get_automatic(opcode);
+ bte = builtintable_get_automatic(opcode);
- if (bte && bte->opcode == opcode) {
- iptr->opc = ICMD_BUILTIN;
- iptr->flags.bits = 0;
- iptr->sx.s23.s3.bte = bte;
- /* iptr->line is already set */
- jd->isleafmethod = false;
- goto icmd_BUILTIN;
- }
- );
-#endif /* defined(USEBUILTINTABLE) */
+ if ((bte != NULL) && (bte->opcode == opcode)) {
+ iptr->opc = ICMD_BUILTIN;
+ iptr->flags.bits &= INS_FLAG_ID_MASK;
+ iptr->sx.s23.s3.bte = bte;
+ /* iptr->line is already set */
+ jd->isleafmethod = false;
+ goto icmd_BUILTIN;
+ }
/* main opcode switch *************************************/
COUNT(count_check_null);
USE_S1(TYPE_ADR);
CLR_SX;
- CLR_DST; /* XXX live through? */
+ iptr->dst.varindex = iptr->s1.varindex;
break;
case ICMD_RET:
- j = iptr->s1.varindex =
+ varindex = iptr->s1.varindex =
jd->local_map[iptr->s1.varindex * 5 + TYPE_ADR];
- if (sd.var[j].type != TYPE_RET) {
+#if defined(ENABLE_VERIFIER)
+ if (sd.var[varindex].type != TYPE_RET) {
exceptions_throw_verifyerror(m, "RET with non-returnAddress value");
return false;
}
+#endif
CLR_SX;
- iptr->dst.block = stack_mark_reached(&sd, sd.var[j].vv.retaddr, curstack, stackdepth);
-#if 0
- IF_NO_INTRP( rd->locals[iptr->s1.localindex/*XXX invalid here*/][TYPE_ADR].type = TYPE_ADR; );
-#endif
+ iptr->dst.block = stack_mark_reached(&sd, sd.var[varindex].vv.retaddr, curstack, stackdepth);
superblockend = true;
break;
CLR_SX;
OP0_0;
superblockend = true;
+ sd.jd->returncount++;
+ sd.jd->returnblock = sd.bptr;
break;
case ICMD_BASTORE:
case ICMD_CASTORE:
case ICMD_SASTORE:
- IF_INTRP( goto normal_ICONST; )
# if SUPPORT_CONST_STORE_ZERO_ONLY
if (iptr->sx.val.i != 0)
goto normal_ICONST;
case ICMD_PUTSTATIC:
case ICMD_PUTFIELD:
- IF_INTRP( goto normal_ICONST; )
# if SUPPORT_CONST_STORE_ZERO_ONLY
if (iptr->sx.val.i != 0)
goto normal_ICONST;
if (iptr[1].flags.bits & INS_FLAG_UNRESOLVED) {
iptr->sx.s23.s3.uf = iptr[1].sx.s23.s3.uf;
iptr->flags.bits |= INS_FLAG_UNRESOLVED;
+ fmiref = iptr->sx.s23.s3.uf->fieldref;
}
else {
- iptr->sx.s23.s3.fmiref = iptr[1].sx.s23.s3.fmiref;
+ fmiref = iptr[1].sx.s23.s3.fmiref;
+ iptr->sx.s23.s3.fmiref = fmiref;
}
+
+#if defined(ENABLE_VERIFIER)
+ expectedtype = fmiref->parseddesc.fd->type;
+ switch (iptr[0].opc) {
+ case ICMD_ICONST:
+ if (expectedtype != TYPE_INT)
+ goto throw_stack_type_error;
+ break;
+ case ICMD_LCONST:
+ if (expectedtype != TYPE_LNG)
+ goto throw_stack_type_error;
+ break;
+ case ICMD_ACONST:
+ if (expectedtype != TYPE_ADR)
+ goto throw_stack_type_error;
+ break;
+ default:
+ assert(0);
+ }
+#endif /* defined(ENABLE_VERIFIER) */
switch (iptr[1].opc) {
case ICMD_PUTSTATIC:
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;
#if SUPPORT_CONST_STORE
case ICMD_LASTORE:
- IF_INTRP( goto normal_LCONST; )
# if SUPPORT_CONST_STORE_ZERO_ONLY
if (iptr->sx.val.l != 0)
goto normal_LCONST;
case ICMD_PUTSTATIC:
case ICMD_PUTFIELD:
- IF_INTRP( goto normal_LCONST; )
# if SUPPORT_CONST_STORE_ZERO_ONLY
if (iptr->sx.val.l != 0)
goto normal_LCONST;
coalescing_boundary = sd.new;
COUNT(count_pcmd_load);
#if SUPPORT_CONST_STORE
- IF_INTRP( goto normal_ACONST; )
-
/* We can only optimize if the ACONST is resolved
* and there is an instruction after it. */
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 (sd.var[j].type == TYPE_RET) {
+#if defined(ENABLE_VERIFIER)
+ if (sd.var[varindex].type == TYPE_RET) {
exceptions_throw_verifyerror(m, "forbidden load of returnAddress");
return false;
}
-
-#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, varindex);
+
+ iptr->sx.s23.s3.javaindex = javaindex;
- COPY_VAL_AND_TYPE(sd, curstack->varnum, j);
+ if (curstack->type == TYPE_RET) {
+ iptr->flags.bits |= INS_FLAG_RETADDR;
+ iptr->sx.s23.s2.retaddrnr =
+ JAVALOCAL_FROM_RETADDR(sd.var[varindex].vv.retaddr->nr);
+ sd.javalocals[javaindex] = iptr->sx.s23.s2.retaddrnr;
+ }
+ else
+ sd.javalocals[javaindex] = varindex;
+
+ /* invalidate the following javalocal for 2-word types */
+
+ 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]) >= 0) {
+ if (IS_2_WORD_TYPE(sd.var[i].type)) {
+ sd.javalocals[javaindex-1] = UNUSED;
+ iptr->flags.bits |= INS_FLAG_KILL_PREV;
+ }
+ }
#if defined(ENABLE_STATISTICS)
if (opt_stat) {
}
#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 the variable is already coalesced, don't bother */
- /* We do not need to check against OUTVAR, as invars */
+ /* We do not need to check against INOUT, as invars */
/* are always before the coalescing boundary. */
if (curstack->varkind == LOCALVAR)
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->varkind == TEMPVAR)
|| (curstack->varkind == UNDEFVAR));
assert(!IS_LOCALVAR(curstack)); /* XXX correct? */
- assert(!IS_OUTVAR(curstack));
+ assert(!IS_INOUT(curstack));
assert(!IS_PREALLOC(curstack));
assert(curstack->creator);
assert(curstack->creator->dst.varindex == curstack->varnum);
+ 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_DRETURN:
case ICMD_ARETURN:
coalescing_boundary = sd.new;
- /* Assert here that no LOCAL or OUTVARS get */
+ /* Assert here that no LOCAL or INOUTS get */
/* preallocated, since tha macros are not */
/* available in md-abi.c! */
- IF_JIT( if (IS_TEMPVAR(curstack)) \
- md_return_alloc(jd, curstack); )
+ if (IS_TEMPVAR(curstack))
+ md_return_alloc(jd, curstack);
COUNT(count_pcmd_return);
OP1_0(opcode - ICMD_IRETURN);
superblockend = true;
+ sd.jd->returncount++;
+ sd.jd->returnblock = sd.bptr;
break;
case ICMD_ATHROW:
POPANY; POPANY;
stackdepth -= 2;
+ /* move non-temporary sources out of the way */
+ if (!IS_TEMPVAR(src2)) {
+ MOVE_TO_TEMP(src2); iptr++; len--;
+ }
+
DUP_SLOT(src2); dst1 = curstack; stackdepth++;
MOVE_UP(src1); iptr++; len--;
POPANY; POPANY; POPANY;
stackdepth -= 3;
+ /* move non-temporary sources out of the way */
+ if (!IS_TEMPVAR(src2)) {
+ MOVE_TO_TEMP(src2); iptr++; len--;
+ }
+ if (!IS_TEMPVAR(src3)) {
+ MOVE_TO_TEMP(src3); iptr++; len--;
+ }
+
DUP_SLOT(src2); dst1 = curstack; stackdepth++;
DUP_SLOT(src3); dst2 = curstack; stackdepth++;
POPANY; POPANY; POPANY;
stackdepth -= 3;
+ /* move non-temporary sources out of the way */
+ if (!IS_TEMPVAR(src2)) {
+ MOVE_TO_TEMP(src2); iptr++; len--;
+ }
+ if (!IS_TEMPVAR(src3)) {
+ MOVE_TO_TEMP(src3); iptr++; len--;
+ }
+
DUP_SLOT(src3); dst1 = curstack; stackdepth++;
MOVE_UP(src1); iptr++; len--;
POPANY; POPANY; POPANY; POPANY;
stackdepth -= 4;
+ /* move non-temporary sources out of the way */
+ if (!IS_TEMPVAR(src2)) {
+ MOVE_TO_TEMP(src2); iptr++; len--;
+ }
+ if (!IS_TEMPVAR(src3)) {
+ MOVE_TO_TEMP(src3); iptr++; len--;
+ }
+ if (!IS_TEMPVAR(src4)) {
+ MOVE_TO_TEMP(src4); iptr++; len--;
+ }
+
DUP_SLOT(src3); dst1 = curstack; stackdepth++;
DUP_SLOT(src4); dst2 = curstack; stackdepth++;
POPANY; POPANY;
stackdepth -= 2;
+ /* move non-temporary sources out of the way */
if (!IS_TEMPVAR(src1)) {
- /* move src1 out of the way into a temporary */
- GET_NEW_INDEX(sd, new_index);
- iptr->opc = ICMD_MOVE;
- iptr->s1.varindex = src1->varnum;
- iptr->dst.varindex = new_index;
- COPY_VAL_AND_TYPE(sd, src1->varnum, new_index);
- iptr++; len--;
- src1->varnum = new_index;
+ MOVE_TO_TEMP(src1); iptr++; len--;
}
MOVE_UP(src2); iptr++; len--;
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 = iptr->sx.s23.s3.jsrtarget.block;
+ tbptr->type = BBTYPE_SBR;
+
assert(sd.bptr->next); /* XXX exception */
sd.var[curstack->varnum].vv.retaddr = sd.bptr->next;
-
- tbptr = BLOCK_OF(iptr->sx.s23.s3.jsrtarget.insindex);
- tbptr->type = BBTYPE_SBR;
+#if defined(ENABLE_VERIFIER)
+ sd.var[curstack->varnum].SBRSTART = (void*) tbptr;
+#endif
tbptr = stack_mark_reached(&sd, tbptr, curstack, stackdepth);
- if (!tbptr)
+ if (tbptr == NULL)
return false;
iptr->sx.s23.s3.jsrtarget.block = tbptr;
REQUIRE(i);
- /* XXX optimize for <= 2 args */
- /* XXX not for ICMD_BUILTIN */
iptr->s1.argcount = stackdepth;
iptr->sx.s23.s2.args = DMNEW(s4, stackdepth);
/* do not change STACKVARs or LOCALVARS to ARGVAR*/
/* -> won't help anyway */
- if (!(IS_OUTVAR(copy) || IS_LOCALVAR(copy))) {
+ if (!(IS_INOUT(copy) || IS_LOCALVAR(copy))) {
#if defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
/* If we pass float arguments in integer argument registers, we
SET_PREALLOC(copy);
-#if defined(ENABLE_INTRP)
- if (!opt_intrp) {
-#endif
- if (md->params[i].inmemory) {
- sd.var[copy->varnum].vv.regoff =
- md->params[i].regoff;
- sd.var[copy->varnum].flags |=
- INMEMORY;
- }
- else {
- if (IS_FLT_DBL_TYPE(copy->type)) {
+ if (md->params[i].inmemory) {
+ sd.var[copy->varnum].vv.regoff =
+ md->params[i].regoff;
+ sd.var[copy->varnum].flags |=
+ INMEMORY;
+ }
+ else {
+ if (IS_FLT_DBL_TYPE(copy->type)) {
#if defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
- assert(0); /* XXX is this assert ok? */
+ assert(0); /* XXX is this assert ok? */
#else
- sd.var[copy->varnum].vv.regoff =
- rd->argfltregs[md->params[i].regoff];
+ sd.var[copy->varnum].vv.regoff =
+ md->params[i].regoff;
#endif /* SUPPORT_PASS_FLOATARGS_IN_INTREGS */
- }
- else {
+ }
+ 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)]);
+ if (IS_2_WORD_TYPE(copy->type))
+ sd.var[copy->varnum].vv.regoff =
+ PACK_REGS(GET_LOW_REG(md->params[i].regoff),
+ GET_HIGH_REG(md->params[i].regoff));
- else
+ else
#endif /* SUPPORT_COMBINE_INTEGER_REGISTERS */
- sd.var[copy->varnum].vv.regoff =
- rd->argintregs[md->params[i].regoff];
- }
+ sd.var[copy->varnum].vv.regoff =
+ md->params[i].regoff;
}
-#if defined(ENABLE_INTRP)
- } /* end if (!opt_intrp) */
-#endif
+ }
}
}
copy = copy->prev;
/* deal with live-through stack slots "under" the */
/* arguments */
- /* XXX not for ICMD_BUILTIN */
i = md->paramcount;
while (copy) {
- SET_TEMPVAR(copy);
iptr->sx.s23.s2.args[i++] = copy->varnum;
sd.var[copy->varnum].flags |= SAVEDVAR;
- copy->flags |= SAVEDVAR;
+ copy->flags |= SAVEDVAR | PASSTHROUGH;
copy = copy->prev;
}
}
break;
- case ICMD_INLINE_START:
- case ICMD_INLINE_END:
- CLR_S1;
- CLR_DST;
- break;
-
case ICMD_MULTIANEWARRAY:
coalescing_boundary = sd.new;
- if (rd->argintreguse < 3)
- rd->argintreguse = 3;
+ if (rd->argintreguse < MIN(3, INT_ARG_CNT))
+ rd->argintreguse = MIN(3, INT_ARG_CNT);
i = iptr->s1.argcount;
/* check INT type here? Currently typecheck does this. */
iptr->sx.s23.s2.args[i] = copy->varnum;
if (!(sd.var[copy->varnum].flags & SAVEDVAR)
- && (!IS_OUTVAR(copy))
+ && (!IS_INOUT(copy))
&& (!IS_LOCALVAR(copy)) ) {
copy->varkind = ARGVAR;
sd.var[copy->varnum].flags |=
}
while (copy) {
sd.var[copy->varnum].flags |= SAVEDVAR;
+ copy->flags |= SAVEDVAR;
copy = copy->prev;
}
break;
default:
- *exceptionptr =
- new_internalerror("Unknown ICMD %d", opcode);
+ exceptions_throw_internalerror("Unknown ICMD %d during stack analysis",
+ opcode);
return false;
} /* switch */
iptr++;
} /* while instructions */
+ /* show state after last instruction */
+
+#if defined(STACK_VERBOSE)
+ stack_verbose_show_state(&sd, NULL, curstack);
+#endif
+
/* stack slots at basic block end become interfaces */
sd.bptr->outdepth = stackdepth;
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;
- if (t == TYPE_RET)
- t = TYPE_ADR;
+ type = copy->type;
v = sd.var + copy->varnum;
- v->flags |= OUTVAR;
+ v->flags |= INOUT;
- if (jd->interface_map[i*5 + t].flags == UNUSED) {
- /* no interface var until now for this depth and */
- /* type */
- jd->interface_map[i*5 + t].flags = v->flags;
- }
- else {
- jd->interface_map[i*5 + t].flags |= v->flags;
+ /* do not allocate variables for returnAddresses */
+
+ 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 + type].flags = v->flags;
+ }
+ else {
+ jd->interface_map[i*5 + type].flags |= v->flags;
+ }
}
sd.bptr->outvars[i] = copy->varnum;
}
/* check if interface slots at basic block begin must be saved */
- IF_NO_INTRP(
- for (i=0; i<sd.bptr->indepth; ++i) {
- varinfo *v = sd.var + sd.bptr->invars[i];
- s4 t;
- t = v->type;
- if (t == TYPE_RET)
- t = TYPE_ADR;
+ for (i=0; i<sd.bptr->indepth; ++i) {
+ varinfo *v = sd.var + sd.bptr->invars[i];
- if (jd->interface_map[i*5 + t].flags == UNUSED) {
+ type = v->type;
+
+ 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;
}
}
- );
+ }
/* store the number of this block's variables */
} while (sd.repeat && !deadcode);
- /* XXX reset TYPE_RET to TYPE_ADR */
+ /* reset locals of TYPE_RET|VOID to TYPE_ADR */
+
+ /* A local variable may be used as both a returnAddress and a reference */
+ /* type variable, as we do not split variables between these types when */
+ /* renaming locals. While returnAddresses have been eliminated now, we */
+ /* must assume that the variable is still used as TYPE_ADR. */
+ /* The only way that a local can be TYPE_VOID at this point, is that it */
+ /* was a TYPE_RET variable for which incompatible returnAddresses were */
+ /* merged. Thus we must treat TYPE_VOID in the same way as TYPE_RET */
+ /* here. */
+ /* XXX: It would be nice to remove otherwise unused returnAddress */
+ /* variables from the local variable array, so they are not */
+ /* allocated by simplereg. (For LSRA this is not needed). */
+
+ for (i=0; i<sd.localcount; ++i) {
+ if (sd.var[i].type == TYPE_RET || sd.var[i].type == TYPE_VOID)
+ sd.var[i].type = TYPE_ADR;
+ }
+
+ /* mark temporaries of TYPE_RET as PREALLOC to avoid allocation */
- for (i=0; i<sd.vartop; ++i) {
+ for (i=sd.localcount; i<sd.vartop; ++i) {
if (sd.var[i].type == TYPE_RET)
- sd.var[i].type = TYPE_ADR;
+ sd.var[i].flags |= PREALLOC;
}
/* XXX hack to fix up the ranges of the cloned single-block handlers */
- ex = cd->exceptiontable;
+ ex = jd->exceptiontable;
for (; ex != NULL; ex = ex->down) {
if (ex->start == ex->end) {
assert(ex->end->next);
}
}
+ /* store number of created variables */
+
+ jd->vartop = sd.vartop;
+
/* gather statistics *****************************************************/
#if defined(ENABLE_STATISTICS)
if (opt_stat) {
- if (jd->new_basicblockcount > count_max_basic_blocks)
- count_max_basic_blocks = jd->new_basicblockcount;
- count_basic_blocks += jd->new_basicblockcount;
- if (jd->new_instructioncount > count_max_javainstr)
- count_max_javainstr = jd->new_instructioncount;
- count_javainstr += jd->new_instructioncount;
- if (jd->new_stackcount > count_upper_bound_new_stack)
- count_upper_bound_new_stack = jd->new_stackcount;
- if ((sd.new - jd->new_stack) > count_max_new_stack)
- count_max_new_stack = (sd.new - jd->new_stack);
-
- sd.bptr = jd->new_basicblocks;
+ if (jd->basicblockcount > count_max_basic_blocks)
+ count_max_basic_blocks = jd->basicblockcount;
+ count_basic_blocks += jd->basicblockcount;
+ if (jd->instructioncount > count_max_javainstr)
+ count_max_javainstr = jd->instructioncount;
+ count_javainstr += jd->instructioncount;
+ if (jd->stackcount > count_upper_bound_new_stack)
+ count_upper_bound_new_stack = jd->stackcount;
+ if ((sd.new - jd->stack) > count_max_new_stack)
+ count_max_new_stack = (sd.new - jd->stack);
+
+ sd.bptr = jd->basicblocks;
for (; sd.bptr; sd.bptr = sd.bptr->next) {
if (sd.bptr->flags > BBREACHED) {
if (sd.bptr->indepth >= 10)
else
count_analyse_iterations[4]++;
- if (jd->new_basicblockcount <= 5)
+ if (jd->basicblockcount <= 5)
count_method_bb_distribution[0]++;
- else if (jd->new_basicblockcount <= 10)
+ else if (jd->basicblockcount <= 10)
count_method_bb_distribution[1]++;
- else if (jd->new_basicblockcount <= 15)
+ else if (jd->basicblockcount <= 15)
count_method_bb_distribution[2]++;
- else if (jd->new_basicblockcount <= 20)
+ else if (jd->basicblockcount <= 20)
count_method_bb_distribution[3]++;
- else if (jd->new_basicblockcount <= 30)
+ else if (jd->basicblockcount <= 30)
count_method_bb_distribution[4]++;
- else if (jd->new_basicblockcount <= 40)
+ else if (jd->basicblockcount <= 40)
count_method_bb_distribution[5]++;
- else if (jd->new_basicblockcount <= 50)
+ else if (jd->basicblockcount <= 50)
count_method_bb_distribution[6]++;
- else if (jd->new_basicblockcount <= 75)
+ else if (jd->basicblockcount <= 75)
count_method_bb_distribution[7]++;
else
count_method_bb_distribution[8]++;
exceptions_throw_verifyerror(m, "Stack size too large");
return false;
-throw_stack_depth_error:
- exceptions_throw_verifyerror(m,"Stack depth mismatch");
- return false;
-
throw_stack_type_error:
exceptions_throw_verifyerror_for_stack(m, expectedtype);
return false;
}
+/* stack_javalocals_store ******************************************************
+
+ Model the effect of a ?STORE instruction upon the given javalocals array.
+
+ IN:
+ iptr.............the ?STORE instruction
+ javalocals.......the javalocals array to modify
+
+*******************************************************************************/
+
+void stack_javalocals_store(instruction *iptr, s4 *javalocals)
+{
+ s4 varindex; /* index into the jd->var array */
+ s4 javaindex; /* java local index */
+
+ varindex = iptr->dst.varindex;
+ javaindex = iptr->sx.s23.s3.javaindex;
+
+ if (javaindex != UNUSED) {
+ assert(javaindex >= 0);
+ if (iptr->flags.bits & INS_FLAG_RETADDR)
+ javalocals[javaindex] = iptr->sx.s23.s2.retaddrnr;
+ else
+ javalocals[javaindex] = varindex;
+
+ if (iptr->flags.bits & INS_FLAG_KILL_PREV)
+ javalocals[javaindex-1] = UNUSED;
+
+ if (iptr->flags.bits & INS_FLAG_KILL_NEXT)
+ javalocals[javaindex+1] = UNUSED;
+ }
+}
+
+
/* functions for verbose stack analysis output ********************************/
#if defined(STACK_VERBOSE)
static void stack_verbose_show_varinfo(stackdata_t *sd, varinfo *v)
{
printf("%c", show_jit_type_letters[v->type]);
- if (v->type == TYPE_RET)
+ if (v->type == TYPE_RET) {
printf("{L%03d}", v->vv.retaddr->nr);
+#if defined(ENABLE_VERIFIER)
+ printf("{start=L%03d}", ((basicblock *)v->SBRSTART)->nr);
+#endif
+ }
}
}
else
putchar('-');
- printf("] inlocals [");
+ printf("] javalocals ");
+ show_javalocals_array(sd->jd, sd->javalocals, sd->maxlocals, SHOW_STACK);
+ printf(" inlocals [");
if (bptr->inlocals) {
for (i=0; i<sd->localcount; ++i) {
if (i)
int i;
printf("======================================== STACK %sANALYSE BLOCK ",
- (reanalyse) ? "RE-" : "");
+ (reanalyse) ? ((sd->bptr->iinstr == NULL) ? "CLONE-" : "RE-") : "");
stack_verbose_show_block(sd, sd->bptr);
printf("\n");
stack_verbose_show_block(sd, sd->bptr);
printf("\n");
}
+
+static void stack_verbose_show_state(stackdata_t *sd, instruction *iptr, stackptr curstack)
+{
+ stackptr sp;
+ s4 i;
+ s4 depth;
+ varinfo *v;
+ stackptr *stack;
+
+ printf(" javalocals ");
+ show_javalocals_array(sd->jd, sd->javalocals, sd->maxlocals, SHOW_STACK);
+ printf(" stack [");
+
+ for(i = 0, sp = curstack; sp; sp = sp->prev)
+ i++;
+ depth = i;
+
+ stack = MNEW(stackptr, depth);
+ for(sp = curstack; sp; sp = sp->prev)
+ stack[--i] = sp;
+
+ for(i=0; i<depth; ++i) {
+ if (i)
+ putchar(' ');
+ sp = stack[i];
+ v = &(sd->var[sp->varnum]);
+
+ if (v->flags & INOUT)
+ putchar('I');
+ if (v->flags & PREALLOC)
+ putchar('A');
+ printf("%d:%c", sp->varnum, show_jit_type_letters[sp->type]);
+ if (v->type == TYPE_RET) {
+ printf("(L%03d)", v->vv.retaddr->nr);
+ }
+ }
+ printf("] ... ");
+ if (iptr)
+ show_icmd(sd->jd, iptr, false, SHOW_PARSE);
+ printf("\n");
+}
#endif
projects / cacao.git / blobdiff