/* vm/jit/stack.h - stack analysis header
- 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
+ Copyright (C) 1996-2005, 2006 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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA.
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
- Contact: cacao@complang.tuwien.ac.at
+ Contact: cacao@cacaojvm.org
Authors: Christian Thalinger
- $Id: stack.h 2568 2005-06-06 15:28:11Z twisti $
+ Changes: Christian Ullrich
+
+ $Id: stack.h 5404 2006-09-07 13:29:05Z christian $
*/
#ifndef _STACK_H
#define _STACK_H
-#include "vm/global.h"
+#include "config.h"
+
+#include "vm/types.h"
+
#include "vm/exceptions.h"
+#include "vm/global.h"
+#include "vm/jit/jit.h"
#include "vm/jit/reg.h"
-/**********************************************************************/
-/* Macros used internally by analyse_stack */
-/**********************************************************************/
+/* macros used internally by analyse_stack ************************************/
-#ifdef STATISTICS
-#define COUNT(cnt) cnt++
-#else
-#define COUNT(cnt)
-#endif
-
/* convenient abbreviations */
#define CURKIND curstack->varkind
#define CURTYPE curstack->type
+
/*--------------------------------------------------*/
-/* SIGNALING ERRORS */
+/* STACK DEPTH CHECKING */
/*--------------------------------------------------*/
-#define TYPE_VERIFYERROR(t) \
- do { \
- char *type; \
- switch ((t)) { \
- case TYPE_INT: \
- type = "integer"; \
- break; \
- case TYPE_LNG: \
- type = "long"; \
- break; \
- case TYPE_FLT: \
- type = "float"; \
- break; \
- case TYPE_DBL: \
- type = "double"; \
- break; \
- case TYPE_ADR: \
- type = "object/array"; \
- break; \
- } \
- *exceptionptr = new_verifyerror(m, \
- "Expecting to find %s on stack", \
- type); \
- return NULL; \
- } while (0)
+#if defined(ENABLE_VERIFIER)
+#define CHECK_STACK_DEPTH(depthA,depthB) \
+ do { \
+ if ((depthA) != (depthB)) \
+ goto throw_stack_depth_error; \
+ } while (0)
+#else /* !ENABLE_VERIFIER */
+#define CHECK_STACK_DEPTH(depthA,depthB)
+#endif /* ENABLE_VERIFIER */
+
+/*--------------------------------------------------*/
+/* BASIC TYPE CHECKING */
+/*--------------------------------------------------*/
+
+/* XXX would be nice if we did not have to pass the expected type */
+
+#if defined(ENABLE_VERIFIER)
+#define CHECK_BASIC_TYPE(expected,actual) \
+ do { \
+ if ((actual) != (expected)) { \
+ expectedtype = (expected); \
+ goto throw_stack_type_error; \
+ } \
+ } while (0)
+#else /* !ENABLE_VERIFIER */
+#define CHECK_BASIC_TYPE(expected,actual)
+#endif /* ENABLE_VERIFIER */
/*--------------------------------------------------*/
/* STACK UNDERFLOW/OVERFLOW CHECKS */
/* underflow checks */
+#if defined(ENABLE_VERIFIER)
#define REQUIRE(num) \
do { \
- if (stackdepth < (num)) { \
- *exceptionptr = \
- new_verifyerror(m, "Unable to pop operand off an empty stack"); \
- return NULL; \
- } \
- } while(0)
+ if (stackdepth < (num)) \
+ goto throw_stack_underflow; \
+ } while (0)
+#else /* !ENABLE_VERIFIER */
+#define REQUIRE(num)
+#endif /* ENABLE_VERIFIER */
#define REQUIRE_1 REQUIRE(1)
#define REQUIRE_2 REQUIRE(2)
* against maximum stack depth only at block boundaries?
*/
+/* XXX we should find a way to remove the opc/op1 check */
+#if defined(ENABLE_VERIFIER)
#define CHECKOVERFLOW \
do { \
- if (stackdepth > m->maxstack) { \
- if (iptr[0].opc != ICMD_ACONST || iptr[0].op1 == 0) { \
- *exceptionptr = new_verifyerror(m, "Stack size too large"); \
- return NULL; \
- } \
- } \
+ if (stackdepth > m->maxstack) \
+ if ((iptr->opc != ICMD_ACONST) || INSTRUCTION_MUST_CHECK(iptr)) \
+ goto throw_stack_overflow; \
} while(0)
-
+#else /* !ENABLE_VERIFIER */
+#define CHECKOVERFLOW
+#endif /* ENABLE_VERIFIER */
/*--------------------------------------------------*/
/* ALLOCATING STACK SLOTS */
/*--------------------------------------------------*/
-#define NEWSTACK_(s,v,n) {new->prev=curstack;new->type=s;new->flags=0; \
- new->varkind=v;new->varnum=n;curstack=new;new++;}
- /* Initialize regoff, so -sia can show regnames even before reg.inc */
- /* regs[rd->intregargnum has to be set for this */
- /* new->regoff = (IS_FLT_DBL_TYPE(s))?-1:rd->intreg_argnum; }*/
-#ifdef LSRA
- #define NEWSTACK(s,v,n) {NEWSTACK_(s,v,n); m->maxlifetimes++;}
-#else
- #define NEWSTACK(s,v,n) NEWSTACK_(s,v,n)
-#endif
+#define NEWSTACK(s,v,n) \
+ do { \
+ new->prev = curstack; \
+ new->type = (s); \
+ new->flags = 0; \
+ new->varkind = (v); \
+ new->varnum = (n); \
+ curstack = new; \
+ jd->var[(n)].type = (s); \
+ jd->var[(n)].flags = 0; \
+ new++; \
+ } while (0)
+
+/* Initialize regoff, so -sia can show regnames even before reg.inc */
+/* regs[rd->intregargnum] has to be set for this */
+/* new->regoff = (IS_FLT_DBL_TYPE(s))?-1:rd->intreg_argnum; } */
#define NEWSTACKn(s,n) NEWSTACK(s,UNDEFVAR,n)
#define NEWSTACK0(s) NEWSTACK(s,UNDEFVAR,0)
/* allocate the input stack for an exception handler */
#define NEWXSTACK {NEWSTACK(TYPE_ADR,STACKVAR,0);curstack=0;}
-
/*--------------------------------------------------*/
/* STACK MANIPULATION */
/*--------------------------------------------------*/
#define POP(s) \
do { \
- if ((s) != curstack->type) { \
- TYPE_VERIFYERROR((s)); \
- } \
+ CHECK_BASIC_TYPE((s),curstack->type); \
if (curstack->varkind == UNDEFVAR) \
curstack->varkind = TEMPVAR; \
curstack = curstack->prev; \
curstack = curstack->prev; \
} while (0)
+/* Do not copy Interface Stackslots over DUPx, Swaps! */
#define COPY(s,d) \
do { \
(d)->flags = 0; \
(d)->type = (s)->type; \
- (d)->varkind = (s)->varkind; \
- (d)->varnum = (s)->varnum; \
- } while (0)
-
-
-/*--------------------------------------------------*/
-/* STACK OPERATIONS MODELING */
-/*--------------------------------------------------*/
-
-/* The following macros are used to model the stack manipulations of
- * different kinds of instructions.
- *
- * These macros check the input stackdepth and they set the output
- * stackdepth and the output stack of the instruction (iptr->dst).
- *
- * These macros do *not* check for stack overflows!
- */
-
-#define PUSHCONST(s){NEWSTACKn(s,stackdepth);SETDST;stackdepth++;}
-#define LOAD(s,v,n) {NEWSTACK(s,v,n);SETDST;stackdepth++;}
-#define STORE(s) {REQUIRE_1;POP(s);SETDST;stackdepth--;}
-#define OP1_0(s) {REQUIRE_1;POP(s);SETDST;stackdepth--;}
-#define OP1_0ANY {REQUIRE_1;POPANY;SETDST;stackdepth--;}
-
-#define OP0_1(s) \
- do { \
- NEWSTACKn((s),stackdepth); \
- SETDST; \
- stackdepth++; \
- } while (0)
-
-#define OP1_1(s,d) \
- do { \
- REQUIRE_1; \
- POP((s)); \
- NEWSTACKn((d),stackdepth - 1);\
- SETDST; \
- } while (0)
-
-#define OP2_0(s) {REQUIRE_2;POP(s);POP(s);SETDST;stackdepth-=2;}
-#define OPTT2_0(t,b){REQUIRE_2;POP(t);POP(b);SETDST;stackdepth-=2;}
-#define OP2_1(s) {REQUIRE_2;POP(s);POP(s);NEWSTACKn(s,stackdepth-2);SETDST;stackdepth--;}
-#define OP2IAT_1(s) {REQUIRE_2;POP(TYPE_INT);POP(TYPE_ADR);NEWSTACKn(s,stackdepth-2);\
- SETDST;stackdepth--;}
-#define OP2IT_1(s) {REQUIRE_2;POP(TYPE_INT);POP(s);NEWSTACKn(s,stackdepth-2);\
- SETDST;stackdepth--;}
-#define OPTT2_1(s,d){REQUIRE_2;POP(s);POP(s);NEWSTACKn(d,stackdepth-2);SETDST;stackdepth--;}
-#define OP2_2(s) {REQUIRE_2;POP(s);POP(s);NEWSTACKn(s,stackdepth-2);\
- NEWSTACKn(s,stackdepth-1);SETDST;}
-#define OP3TIA_0(s) {REQUIRE_3;POP(s);POP(TYPE_INT);POP(TYPE_ADR);SETDST;stackdepth-=3;}
-#define OP3_0(s) {REQUIRE_3;POP(s);POP(s);POP(s);SETDST;stackdepth-=3;}
-
-#define POPMANY(i) \
- do { \
- REQUIRE((i)); \
- stackdepth -= (i); \
- while(--(i) >= 0) { \
- POPANY; \
- } \
- SETDST; \
+ if ( (s)->varkind != STACKVAR) { \
+ (d)->varkind = (s)->varkind; \
+ (d)->varnum = (s)->varnum; \
+ } else { \
+ (d)->varkind = TEMPVAR; \
+ (d)->varnum = 0; \
+ } \
} while (0)
-#define DUP {REQUIRE_1;NEWSTACK(CURTYPE,CURKIND,curstack->varnum);SETDST; \
- stackdepth++;}
-#define SWAP {REQUIRE_2;COPY(curstack,new);POPANY;COPY(curstack,new+1);POPANY;\
- new[0].prev=curstack;new[1].prev=new;\
- curstack=new+1;new+=2;SETDST;}
-#define DUP_X1 {REQUIRE_2;COPY(curstack,new);COPY(curstack,new+2);POPANY;\
- COPY(curstack,new+1);POPANY;new[0].prev=curstack;\
- new[1].prev=new;new[2].prev=new+1;\
- curstack=new+2;new+=3;SETDST;stackdepth++;}
-#define DUP2_X1 {REQUIRE_3;COPY(curstack,new+1);COPY(curstack,new+4);POPANY;\
- COPY(curstack,new);COPY(curstack,new+3);POPANY;\
- COPY(curstack,new+2);POPANY;new[0].prev=curstack;\
- new[1].prev=new;new[2].prev=new+1;\
- new[3].prev=new+2;new[4].prev=new+3;\
- curstack=new+4;new+=5;SETDST;stackdepth+=2;}
-#define DUP_X2 {REQUIRE_3;COPY(curstack,new);COPY(curstack,new+3);POPANY;\
- COPY(curstack,new+2);POPANY;COPY(curstack,new+1);POPANY;\
- new[0].prev=curstack;new[1].prev=new;\
- new[2].prev=new+1;new[3].prev=new+2;\
- curstack=new+3;new+=4;SETDST;stackdepth++;}
-#define DUP2_X2 {REQUIRE_4;COPY(curstack,new+1);COPY(curstack,new+5);POPANY;\
- COPY(curstack,new);COPY(curstack,new+4);POPANY;\
- COPY(curstack,new+3);POPANY;COPY(curstack,new+2);POPANY;\
- new[0].prev=curstack;new[1].prev=new;\
- new[2].prev=new+1;new[3].prev=new+2;\
- new[4].prev=new+3;new[5].prev=new+4;\
- curstack=new+5;new+=6;SETDST;stackdepth+=2;}
-
/*--------------------------------------------------*/
/* MACROS FOR HANDLING BASIC BLOCKS */
* block to another. The destination block receives the copy as its
* input stack.
*/
-#define COPYCURSTACK(copy) {\
+#if defined(NEW_VAR)
+# define COPYCURSTACK(copy) {\
+ stackptr s;\
+ if(curstack){\
+ s=curstack;\
+ new+=stackdepth;\
+ copy=new;\
+ while(s){\
+ copy--; \
+ copy->prev=copy-1;\
+ copy->type=s->type;\
+ copy->flags=0;\
+ copy->varkind=STACKVAR;\
+ copy->varnum=s->varnum;\
+ SET_OUTVAR(s); \
+ s=s->prev;\
+ }\
+ copy->prev=NULL;\
+ copy=new-1;\
+ }\
+ else\
+ copy=NULL;\
+}
+#else
+# define COPYCURSTACK(copy) {\
int d;\
stackptr s;\
if(curstack){\
else\
copy=NULL;\
}
-
-/* BBEND is called at the end of each basic block (after the last
- * instruction of the block has been processed).
- */
-
-#define BBEND(s,i) { \
- (i) = stackdepth - 1; \
- copy = (s); \
- while (copy) { \
- if ((copy->varkind == STACKVAR) && (copy->varnum > (i))) \
- copy->varkind = TEMPVAR; \
- else { \
- copy->varkind = STACKVAR; \
- copy->varnum = (i);\
- } \
- rd->interfaces[(i)][copy->type].type = copy->type; \
- rd->interfaces[(i)][copy->type].flags |= copy->flags; \
- (i)--; copy = copy->prev; \
- } \
- (i) = bptr->indepth - 1; \
- copy = bptr->instack; \
- while (copy) { \
- rd->interfaces[(i)][copy->type].type = copy->type; \
- if (copy->varkind == STACKVAR) { \
- if (copy->flags & SAVEDVAR) \
- rd->interfaces[(i)][copy->type].flags |= SAVEDVAR; \
- } \
- (i)--; copy = copy->prev; \
- } \
-}
-
+#endif
/* MARKREACHED marks the destination block <b> as reached. If this
* block has been reached before we check if stack depth and types
* c...current stack
*/
+/* XXX this macro is much too big! */
+
#define MARKREACHED(b,c) \
do { \
- if ((b)->flags < 0) { \
+ if ((b) <= (bptr)) \
+ (b)->bitflags |= BBFLAG_REPLACEMENT; \
+ if ((b)->flags < BBREACHED) { \
+ int locali; \
COPYCURSTACK((c)); \
- (b)->flags = 0; \
+ (b)->flags = BBREACHED; \
(b)->instack = (c); \
(b)->indepth = stackdepth; \
+ (b)->invars = DMNEW(s4, stackdepth); \
+ for (locali = stackdepth; locali--; (c) = (c)->prev) { \
+ (b)->invars[locali] = (c)->varnum; \
+ SET_OUTVAR((c)); \
+ } \
} else { \
stackptr s = curstack; \
stackptr t = (b)->instack; \
- if ((b)->indepth != stackdepth) { \
- show_icmd_method(m, cd, rd); \
- log_text("Stack depth mismatch"); \
- assert(0); \
- } \
+ CHECK_STACK_DEPTH((b)->indepth, stackdepth); \
while (s) { \
- if (s->type != t->type) \
- TYPE_VERIFYERROR(t->type); \
+ CHECK_BASIC_TYPE(s->type,t->type); \
s = s->prev; \
t = t->prev; \
} \
} while (0)
+/* external macros ************************************************************/
+
+#define BLOCK_OF(index) \
+ (jd->new_basicblocks + jd->new_basicblockindex[index])
+
+
/* function prototypes ********************************************************/
-methodinfo *analyse_stack(methodinfo *m, codegendata *cd, registerdata *rd);
+bool stack_init(void);
-void icmd_print_stack(codegendata *cd, stackptr s);
-void show_icmd_method(methodinfo *m, codegendata *cd, registerdata *rd);
-void show_icmd_block(methodinfo *m, codegendata *cd, basicblock *bptr);
-void show_icmd(instruction *iptr, bool deadcode);
+bool new_stack_analyse(jitdata *jd);
#endif /* _STACK_H */
* c-basic-offset: 4
* tab-width: 4
* End:
+ * vim:noexpandtab:sw=4:ts=4:
*/
projects / cacao.git / blobdiff