1 /* vm/jit/stack.h - stack analysis header
3 Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
4 C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
5 E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
6 J. Wenninger, Institut f. Computersprachen - TU Wien
8 This file is part of CACAO.
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2, or (at
13 your option) any later version.
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 Contact: cacao@cacaojvm.org
27 Authors: Christian Thalinger
29 Changes: Christian Ullrich
31 $Id: stack.h 4524 2006-02-16 19:39:36Z christian $
43 #include "vm/exceptions.h"
44 #include "vm/global.h"
45 #include "vm/jit/jit.h"
46 #include "vm/jit/reg.h"
49 /* macros used internally by analyse_stack ************************************/
51 #if defined(ENABLE_LSRA)
52 # define INC_LIFETIMES(a) { m->maxlifetimes += (a); }
54 # define INC_LIFETIMES(a)
57 /* convenient abbreviations */
58 #define CURKIND curstack->varkind
59 #define CURTYPE curstack->type
62 /*--------------------------------------------------*/
63 /* SIGNALING ERRORS */
64 /*--------------------------------------------------*/
66 #define TYPE_VERIFYERROR(t) \
68 exceptions_throw_verifyerror_for_stack(m,t); \
73 /*--------------------------------------------------*/
74 /* STACK UNDERFLOW/OVERFLOW CHECKS */
75 /*--------------------------------------------------*/
77 /* underflow checks */
79 #define REQUIRE(num) \
81 if (stackdepth < (num)) { \
83 new_verifyerror(m, "Unable to pop operand off an empty stack"); \
88 #define REQUIRE_1 REQUIRE(1)
89 #define REQUIRE_2 REQUIRE(2)
90 #define REQUIRE_3 REQUIRE(3)
91 #define REQUIRE_4 REQUIRE(4)
95 /* We allow ACONST instructions inserted as arguments to builtin
96 * functions to exceed the maximum stack depth. Maybe we should check
97 * against maximum stack depth only at block boundaries?
100 #define CHECKOVERFLOW \
102 if (stackdepth > m->maxstack) { \
103 if (iptr[0].opc != ICMD_ACONST || iptr[0].op1 == 0) { \
104 *exceptionptr = new_verifyerror(m, "Stack size too large"); \
111 /*--------------------------------------------------*/
112 /* ALLOCATING STACK SLOTS */
113 /*--------------------------------------------------*/
115 #define NEWSTACK_(s,v,n) \
117 new->prev = curstack; \
120 new->varkind = (v); \
127 /* Initialize regoff, so -sia can show regnames even before reg.inc */
128 /* regs[rd->intregargnum has to be set for this */
129 /* new->regoff = (IS_FLT_DBL_TYPE(s))?-1:rd->intreg_argnum; }*/
131 #define NEWSTACK(s,v,n) { NEWSTACK_(s,v,n); INC_LIFETIMES(1); }
133 #define NEWSTACKn(s,n) NEWSTACK(s,UNDEFVAR,n)
134 #define NEWSTACK0(s) NEWSTACK(s,UNDEFVAR,0)
136 /* allocate the input stack for an exception handler */
137 #define NEWXSTACK {NEWSTACK(TYPE_ADR,STACKVAR,0);curstack=0;}
140 /*--------------------------------------------------*/
141 /* STACK MANIPULATION */
142 /*--------------------------------------------------*/
144 /* resetting to an empty operand stack */
153 /* set the output stack of the current instruction */
155 #define SETDST iptr->dst = curstack;
158 /* The following macros do NOT check stackdepth, set stackdepth or iptr->dst */
162 if ((s) != curstack->type) { \
163 TYPE_VERIFYERROR((s)); \
165 if (curstack->varkind == UNDEFVAR) \
166 curstack->varkind = TEMPVAR; \
167 curstack = curstack->prev; \
172 if (curstack->varkind == UNDEFVAR) \
173 curstack->varkind = TEMPVAR; \
174 curstack = curstack->prev; \
177 /* Do not copy Interface Stackslots over DUPx, Swaps! */
181 (d)->type = (s)->type; \
182 if ( (s)->varkind != STACKVAR) { \
183 (d)->varkind = (s)->varkind; \
184 (d)->varnum = (s)->varnum; \
186 (d)->varkind = TEMPVAR; \
192 /*--------------------------------------------------*/
193 /* STACK OPERATIONS MODELING */
194 /*--------------------------------------------------*/
196 /* The following macros are used to model the stack manipulations of
197 * different kinds of instructions.
199 * These macros check the input stackdepth and they set the output
200 * stackdepth and the output stack of the instruction (iptr->dst).
202 * These macros do *not* check for stack overflows!
205 #define PUSHCONST(s){NEWSTACKn(s,stackdepth);SETDST;stackdepth++;}
206 #define LOAD(s,v,n) {NEWSTACK(s,v,n);SETDST;stackdepth++;}
207 #define STORE(s) {REQUIRE_1;POP(s);SETDST;stackdepth--;}
227 NEWSTACKn(s, stackdepth); \
236 NEWSTACKn(d, stackdepth - 1);\
249 #define OPTT2_0(t,b) \
263 NEWSTACKn(s, stackdepth - 2); \
268 #define OP2IAT_1(s) \
273 NEWSTACKn(s, stackdepth - 2); \
283 NEWSTACKn(s, stackdepth - 2); \
288 #define OPTT2_1(s,d) \
293 NEWSTACKn(d, stackdepth - 2); \
303 NEWSTACKn(s, stackdepth - 2); \
304 NEWSTACKn(s, stackdepth - 1); \
308 #define OP3TIA_0(s) \
332 while(--(i) >= 0) { \
338 /* Do not copy Interface Stackslots over DUP! */
339 #define DUP {REQUIRE_1; \
340 if (CURKIND != STACKVAR) { \
341 NEWSTACK(CURTYPE,CURKIND,curstack->varnum); \
343 NEWSTACK(CURTYPE, TEMPVAR, stackdepth); \
345 SETDST; stackdepth++; INC_LIFETIMES(1);}
346 #define SWAP {REQUIRE_2;COPY(curstack,new);POPANY;COPY(curstack,new+1);POPANY;\
347 new[0].prev=curstack;new[1].prev=new;\
348 curstack=new+1;new+=2;SETDST;}
349 #define DUP_X1 {REQUIRE_2;COPY(curstack,new);COPY(curstack,new+2);POPANY;\
350 COPY(curstack,new+1);POPANY;new[0].prev=curstack;\
351 new[1].prev=new;new[2].prev=new+1;\
352 curstack=new+2;new+=3;SETDST;stackdepth++; INC_LIFETIMES(3);}
353 #define DUP2_X1 {REQUIRE_3;COPY(curstack,new+1);COPY(curstack,new+4);POPANY;\
354 COPY(curstack,new);COPY(curstack,new+3);POPANY;\
355 COPY(curstack,new+2);POPANY;new[0].prev=curstack;\
356 new[1].prev=new;new[2].prev=new+1;\
357 new[3].prev=new+2;new[4].prev=new+3;\
358 curstack=new+4;new+=5;SETDST;stackdepth+=2; INC_LIFETIMES(5);}
359 #define DUP_X2 {REQUIRE_3;COPY(curstack,new);COPY(curstack,new+3);POPANY;\
360 COPY(curstack,new+2);POPANY;COPY(curstack,new+1);POPANY;\
361 new[0].prev=curstack;new[1].prev=new;\
362 new[2].prev=new+1;new[3].prev=new+2;\
363 curstack=new+3;new+=4;SETDST;stackdepth++; INC_LIFETIMES(4);}
364 #define DUP2_X2 {REQUIRE_4;COPY(curstack,new+1);COPY(curstack,new+5);POPANY;\
365 COPY(curstack,new);COPY(curstack,new+4);POPANY;\
366 COPY(curstack,new+3);POPANY;COPY(curstack,new+2);POPANY;\
367 new[0].prev=curstack;new[1].prev=new;\
368 new[2].prev=new+1;new[3].prev=new+2;\
369 new[4].prev=new+3;new[5].prev=new+4;\
370 curstack=new+5;new+=6;SETDST;stackdepth+=2; INC_LIFETIMES(6);}
373 /*--------------------------------------------------*/
374 /* MACROS FOR HANDLING BASIC BLOCKS */
375 /*--------------------------------------------------*/
377 /* COPYCURSTACK makes a copy of the current operand stack (curstack)
378 * and returns it in the variable copy.
380 * This macro is used to propagate the operand stack from one basic
381 * block to another. The destination block receives the copy as its
384 #define COPYCURSTACK(copy) {\
397 copy->varkind=STACKVAR;\
408 /* BBEND is called at the end of each basic block (after the last
409 * instruction of the block has been processed).
413 #if defined(ENABLE_INTRP)
414 #define IF_NO_INTRP(x) if (!opt_intrp) { x }
416 #define IF_NO_INTRP(x) { x }
419 #define BBEND(s,i) { \
420 (i) = stackdepth - 1; \
423 if ((copy->varkind == STACKVAR) && (copy->varnum > (i))) \
424 copy->varkind = TEMPVAR; \
426 copy->varkind = STACKVAR; \
429 IF_NO_INTRP(rd->interfaces[(i)][copy->type].type = copy->type; \
430 rd->interfaces[(i)][copy->type].flags |= copy->flags;) \
431 (i)--; copy = copy->prev; \
433 (i) = bptr->indepth - 1; \
434 copy = bptr->instack; \
437 rd->interfaces[(i)][copy->type].type = copy->type; \
438 if (copy->varkind == STACKVAR) { \
439 if (copy->flags & SAVEDVAR) \
440 rd->interfaces[(i)][copy->type].flags |= SAVEDVAR; \
443 (i)--; copy = copy->prev; \
448 /* MARKREACHED marks the destination block <b> as reached. If this
449 * block has been reached before we check if stack depth and types
450 * match. Otherwise the destination block receives a copy of the
451 * current stack as its input stack.
453 * b...destination block
457 #define MARKREACHED(b,c) \
459 if ((b)->flags < BBREACHED) { \
461 (b)->flags = BBREACHED; \
462 (b)->instack = (c); \
463 (b)->indepth = stackdepth; \
465 stackptr s = curstack; \
466 stackptr t = (b)->instack; \
467 if ((b)->indepth != stackdepth) { \
468 *exceptionptr = new_verifyerror(m,"Stack depth mismatch"); \
472 if (s->type != t->type) \
473 TYPE_VERIFYERROR(t->type); \
481 /* function prototypes ********************************************************/
483 bool stack_init(void);
485 methodinfo *analyse_stack(methodinfo *m, codegendata *cd, registerdata *rd);
487 void icmd_print_stack(codegendata *cd, stackptr s);
488 void show_icmd_method(methodinfo *m, codegendata *cd, registerdata *rd);
489 void show_icmd_block(methodinfo *m, codegendata *cd, basicblock *bptr);
490 void show_icmd(instruction *iptr, bool deadcode);
492 /* machine dependent return value handling function */
493 void md_return_alloc(methodinfo *m, registerdata *rd, s4 return_type,
496 #endif /* _STACK_H */
500 * These are local overrides for various environment variables in Emacs.
501 * Please do not remove this and leave it at the end of the file, where
502 * Emacs will automagically detect them.
503 * ---------------------------------------------------------------------
506 * indent-tabs-mode: t
510 * vim:noexpandtab:sw=4:ts=4: