1 /* src/vm/jit/stack.c - stack analysis
3 Copyright (C) 1996-2005, 2006, 2007 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 $Id: stack.c 7663 2007-04-04 22:14:42Z twisti $
40 #include "mm/memory.h"
42 #include "native/native.h"
44 #include "toolbox/logging.h"
46 #include "vm/global.h"
47 #include "vm/builtin.h"
48 #include "vm/stringlocal.h"
51 #include "vm/jit/abi.h"
52 #include "vm/jit/cfg.h"
53 #include "vm/jit/codegen-common.h"
54 #include "vm/jit/parse.h"
55 #include "vm/jit/show.h"
57 #if defined(ENABLE_DISASSEMBLER)
58 # include "vm/jit/disass.h"
61 #include "vm/jit/jit.h"
62 #include "vm/jit/stack.h"
64 #if defined(ENABLE_SSA)
65 # include "vm/jit/optimizing/lsra.h"
66 # include "vm/jit/optimizing/ssa.h"
67 #elif defined(ENABLE_LSRA)
68 # include "vm/jit/allocator/lsra.h"
71 #include "vmcore/options.h"
72 #include "vm/resolve.h"
74 #if defined(ENABLE_STATISTICS)
75 # include "vmcore/statistics.h"
78 /*#define STACK_VERBOSE*/
81 /* macro for saving #ifdefs ***************************************************/
83 #if defined(ENABLE_STATISTICS)
84 #define STATISTICS_STACKDEPTH_DISTRIBUTION(distr) \
87 if (stackdepth >= 10) \
88 count_store_depth[10]++; \
90 count_store_depth[stackdepth]++; \
93 #else /* !defined(ENABLE_STATISTICS) */
94 #define STATISTICS_STACKDEPTH_DISTRIBUTION(distr)
98 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
101 /* For returnAddresses we use a field of the typeinfo to store from which */
102 /* subroutine the returnAddress will return, if used. */
103 /* XXX It would be nicer to use typeinfo.typeclass, but the verifier seems */
104 /* to need it initialised to NULL. This should be investigated. */
106 #if defined(ENABLE_VERIFIER)
107 #define SBRSTART typeinfo.elementclass.any
111 /* stackdata_t *****************************************************************
113 This struct holds internal data during stack analysis.
115 *******************************************************************************/
117 typedef struct stackdata_t stackdata_t;
120 basicblock *bptr; /* the current basic block being analysed */
121 stackptr new; /* next free stackelement */
122 s4 vartop; /* next free variable index */
123 s4 localcount; /* number of locals (at the start of var) */
124 s4 varcount; /* maximum number of variables expected */
125 s4 varsallocated; /* total number of variables allocated */
126 s4 maxlocals; /* max. number of Java locals */
127 varinfo *var; /* variable array (same as jd->var) */
128 s4 *javalocals; /* map from Java locals to jd->var indices */
129 methodinfo *m; /* the method being analysed */
130 jitdata *jd; /* current jitdata */
131 basicblock *last_real_block; /* the last block before the empty one */
132 bool repeat; /* if true, iterate the analysis again */
133 exception_entry **handlers; /* exception handlers for the current block */
134 exception_entry *extableend; /* points to the last exception entry */
135 stackelement exstack; /* instack for exception handlers */
139 /* macros for allocating/releasing variable indices *****************/
141 #define GET_NEW_INDEX(sd, new_varindex) \
143 assert((sd).vartop < (sd).varcount); \
144 (new_varindex) = ((sd).vartop)++; \
147 /* Not implemented now - could be used to reuse varindices. */
148 /* Pay attention to not release a localvar once implementing it! */
149 #define RELEASE_INDEX(sd, varindex)
151 #define GET_NEW_VAR(sd, newvarindex, newtype) \
153 GET_NEW_INDEX((sd), (newvarindex)); \
154 (sd).var[newvarindex].type = (newtype); \
158 /* macros for querying variable properties **************************/
160 #define IS_INOUT(sp) \
161 (sd.var[(sp)->varnum].flags & INOUT)
163 #define IS_PREALLOC(sp) \
164 (sd.var[(sp)->varnum].flags & PREALLOC)
166 #define IS_TEMPVAR(sp) \
167 ( ((sp)->varnum >= sd.localcount) \
168 && !(sd.var[(sp)->varnum].flags & (INOUT | PREALLOC)) )
171 #define IS_LOCALVAR_SD(sd, sp) \
172 ((sp)->varnum < (sd).localcount)
174 #define IS_LOCALVAR(sp) \
175 IS_LOCALVAR_SD(sd, (sp))
178 /* macros for setting variable properties ****************************/
180 #define SET_TEMPVAR(sp) \
182 if (IS_LOCALVAR((sp))) { \
183 stack_change_to_tempvar(&sd, (sp), iptr); \
185 sd.var[(sp)->varnum].flags &= ~(INOUT | PREALLOC); \
188 #define SET_PREALLOC(sp) \
190 assert(!IS_LOCALVAR((sp))); \
191 sd.var[(sp)->varnum].flags |= PREALLOC; \
195 /* macros for source operands ***************************************/
198 (iptr->s1.varindex = -1)
200 #define USE_S1(type1) \
203 CHECK_BASIC_TYPE(type1, curstack->type); \
204 iptr->s1.varindex = curstack->varnum; \
210 iptr->s1.varindex = curstack->varnum; \
213 #define USE_S1_S2(type1, type2) \
216 CHECK_BASIC_TYPE(type1, curstack->prev->type); \
217 CHECK_BASIC_TYPE(type2, curstack->type); \
218 iptr->sx.s23.s2.varindex = curstack->varnum; \
219 iptr->s1.varindex = curstack->prev->varnum; \
222 #define USE_S1_S2_ANY_ANY \
225 iptr->sx.s23.s2.varindex = curstack->varnum; \
226 iptr->s1.varindex = curstack->prev->varnum; \
229 #define USE_S1_S2_S3(type1, type2, type3) \
232 CHECK_BASIC_TYPE(type1, curstack->prev->prev->type); \
233 CHECK_BASIC_TYPE(type2, curstack->prev->type); \
234 CHECK_BASIC_TYPE(type3, curstack->type); \
235 iptr->sx.s23.s3.varindex = curstack->varnum; \
236 iptr->sx.s23.s2.varindex = curstack->prev->varnum; \
237 iptr->s1.varindex = curstack->prev->prev->varnum; \
240 /* The POPANY macro does NOT check stackdepth, or set stackdepth! */
243 if (curstack->varkind == UNDEFVAR) \
244 curstack->varkind = TEMPVAR; \
245 curstack = curstack->prev; \
248 #define POP_S1(type1) \
251 if (curstack->varkind == UNDEFVAR) \
252 curstack->varkind = TEMPVAR; \
253 curstack = curstack->prev; \
259 if (curstack->varkind == UNDEFVAR) \
260 curstack->varkind = TEMPVAR; \
261 curstack = curstack->prev; \
264 #define POP_S1_S2(type1, type2) \
266 USE_S1_S2(type1, type2); \
267 if (curstack->varkind == UNDEFVAR) \
268 curstack->varkind = TEMPVAR; \
269 if (curstack->prev->varkind == UNDEFVAR) \
270 curstack->prev->varkind = TEMPVAR; \
271 curstack = curstack->prev->prev; \
274 #define POP_S1_S2_ANY_ANY \
277 if (curstack->varkind == UNDEFVAR) \
278 curstack->varkind = TEMPVAR; \
279 if (curstack->prev->varkind == UNDEFVAR) \
280 curstack->prev->varkind = TEMPVAR; \
281 curstack = curstack->prev->prev; \
284 #define POP_S1_S2_S3(type1, type2, type3) \
286 USE_S1_S2_S3(type1, type2, type3); \
287 if (curstack->varkind == UNDEFVAR) \
288 curstack->varkind = TEMPVAR; \
289 if (curstack->prev->varkind == UNDEFVAR) \
290 curstack->prev->varkind = TEMPVAR; \
291 if (curstack->prev->prev->varkind == UNDEFVAR) \
292 curstack->prev->prev->varkind = TEMPVAR; \
293 curstack = curstack->prev->prev->prev; \
300 /* macros for setting the destination operand ***********************/
303 (iptr->dst.varindex = -1)
305 #define DST(typed, index) \
307 NEWSTACKn((typed),(index)); \
308 curstack->creator = iptr; \
309 iptr->dst.varindex = (index); \
312 #define DST_LOCALVAR(typed, index) \
314 NEWSTACK((typed), LOCALVAR, (index)); \
315 curstack->creator = iptr; \
316 iptr->dst.varindex = (index); \
320 /* macro for propagating constant values ****************************/
322 #if defined(ENABLE_VERIFIER)
323 #define COPY_VAL_AND_TYPE_VAR(sv, dv) \
325 if (((dv)->type = (sv)->type) == TYPE_RET) { \
326 (dv)->vv = (sv)->vv; \
327 (dv)->SBRSTART = (sv)->SBRSTART; \
331 #define COPY_VAL_AND_TYPE_VAR(sv, dv) \
333 (dv)->type = (sv)->type; \
334 if (((dv)->type = (sv)->type) == TYPE_RET) { \
335 (dv)->vv = (sv)->vv; \
340 #define COPY_VAL_AND_TYPE(sd, sindex, dindex) \
341 COPY_VAL_AND_TYPE_VAR((sd).var + (sindex), (sd).var + (dindex))
344 /* stack modelling macros *******************************************/
346 #define OP0_1(typed) \
349 GET_NEW_VAR(sd, new_index, (typed)); \
350 DST((typed), new_index); \
361 #define OP1_BRANCH(type1) \
367 #define OP1_1(type1, typed) \
370 GET_NEW_VAR(sd, new_index, (typed)); \
371 DST(typed, new_index); \
374 #define OP2_1(type1, type2, typed) \
376 POP_S1_S2(type1, type2); \
377 GET_NEW_VAR(sd, new_index, (typed)); \
378 DST(typed, new_index); \
393 #define OP1_0(type1) \
400 #define OP2_0(type1, type2) \
402 POP_S1_S2(type1, type2); \
407 #define OP2_BRANCH(type1, type2) \
409 POP_S1_S2(type1, type2); \
413 #define OP2_0_ANY_ANY \
420 #define OP3_0(type1, type2, type3) \
422 POP_S1_S2_S3(type1, type2, type3); \
427 #define LOAD(type1, index) \
429 DST_LOCALVAR(type1, index); \
433 #define STORE(type1, index) \
440 /* macros for DUP elimination ***************************************/
442 /* XXX replace NEW_VAR with NEW_INDEX */
443 #define DUP_SLOT(sp) \
445 GET_NEW_VAR(sd, new_index, (sp)->type); \
446 COPY_VAL_AND_TYPE(sd, (sp)->varnum, new_index); \
447 NEWSTACK((sp)->type, TEMPVAR, new_index); \
450 /* does not check input stackdepth */
451 #define MOVE_UP(sp) \
453 iptr->opc = ICMD_MOVE; \
454 iptr->s1.varindex = (sp)->varnum; \
456 curstack->creator = iptr; \
457 iptr->dst.varindex = curstack->varnum; \
461 /* does not check input stackdepth */
462 #define COPY_UP(sp) \
465 iptr->opc = ICMD_COPY; \
466 iptr->s1.varindex = (sp)->varnum; \
468 curstack->creator = iptr; \
469 iptr->dst.varindex = curstack->varnum; \
473 #define COPY_DOWN(s, d) \
476 iptr->opc = ICMD_COPY; \
477 iptr->s1.varindex = (s)->varnum; \
478 iptr->dst.varindex = (d)->varnum; \
479 (d)->creator = iptr; \
482 #define MOVE_TO_TEMP(sp) \
484 GET_NEW_INDEX(sd, new_index); \
485 iptr->opc = ICMD_MOVE; \
486 iptr->s1.varindex = (sp)->varnum; \
487 iptr->dst.varindex = new_index; \
488 COPY_VAL_AND_TYPE(sd, (sp)->varnum, new_index); \
489 (sp)->varnum = new_index; \
490 (sp)->varkind = TEMPVAR; \
493 /* macros for branching / reaching basic blocks *********************/
495 #define BRANCH_TARGET(bt, tempbptr) \
497 tempbptr = (bt).block; \
498 tempbptr = stack_mark_reached(&sd, tempbptr, curstack, \
500 if (tempbptr == NULL) \
502 (bt).block = tempbptr; \
505 #define BRANCH(tempbptr) \
506 BRANCH_TARGET(iptr->dst, tempbptr)
509 /* forward declarations *******************************************************/
511 static void stack_create_invars(stackdata_t *sd, basicblock *b,
512 stackptr curstack, int stackdepth);
513 static void stack_create_invars_from_outvars(stackdata_t *sd, basicblock *b);
515 #if defined(STACK_VERBOSE)
516 static void stack_verbose_show_varinfo(stackdata_t *sd, varinfo *v);
517 static void stack_verbose_show_variable(stackdata_t *sd, s4 index);
518 static void stack_verbose_show_block(stackdata_t *sd, basicblock *bptr);
519 static void stack_verbose_block_enter(stackdata_t *sd, bool reanalyse);
520 static void stack_verbose_block_exit(stackdata_t *sd, bool superblockend);
521 static void stack_verbose_show_state(stackdata_t *sd, instruction *iptr,
526 /* stack_init ******************************************************************
528 Initialized the stack analysis subsystem (called by jit_init).
530 *******************************************************************************/
532 bool stack_init(void)
538 /* stack_grow_variable_array ***************************************************
540 Grow the variable array so the given number of additional variables fits in.
541 The number is added to `varcount`, which is the maximum number of variables
542 we expect to need at this point. The actual number of variables
543 (`varsallocated`) may be larger than that, in order to avoid too many
547 sd...........stack analysis data
548 num..........number of additional variables
550 *******************************************************************************/
552 static void stack_grow_variable_array(stackdata_t *sd, s4 num)
558 if (sd->varcount + num > sd->varsallocated) {
559 newsize = 2*sd->varsallocated + num;
561 sd->var = DMREALLOC(sd->var, varinfo, sd->varsallocated, newsize);
562 MZERO(sd->var + sd->varsallocated, varinfo, (newsize - sd->varsallocated));
563 sd->varsallocated = newsize;
564 sd->jd->var = sd->var;
568 sd->jd->varcount += num;
570 assert(sd->varcount <= sd->varsallocated);
574 /* stack_append_block **********************************************************
576 Append the given block after the last real block of the method (before
577 the pseudo-block at the end).
580 sd...........stack analysis data
581 b............the block to append
583 *******************************************************************************/
585 static void stack_append_block(stackdata_t *sd, basicblock *b)
587 #if defined(STACK_VERBOSE)
588 printf("APPENDING BLOCK L%0d\n", b->nr);
591 b->next = sd->last_real_block->next;
592 sd->last_real_block->next = b;
593 sd->last_real_block = b;
594 b->nr = sd->jd->basicblockcount++;
595 b->next->nr = b->nr + 1;
599 /* stack_clone_block ***********************************************************
601 Create a copy of the given block and insert it at the end of the method.
603 CAUTION: This function does not copy the any variables or the instruction
604 list. It _does_, however, reserve space for the block's invars in the
608 sd...........stack analysis data
609 b............the block to clone
612 a pointer to the copy
614 *******************************************************************************/
616 static basicblock * stack_clone_block(stackdata_t *sd, basicblock *b)
620 clone = DNEW(basicblock);
623 clone->iinstr = NULL;
624 clone->inlocals = NULL;
625 clone->javalocals = NULL;
626 clone->invars = NULL;
628 clone->original = (b->original) ? b->original : b;
629 clone->copied_to = clone->original->copied_to;
630 clone->original->copied_to = clone;
632 clone->flags = BBREACHED;
634 stack_append_block(sd, clone);
636 /* reserve space for the invars of the clone */
638 stack_grow_variable_array(sd, b->indepth);
640 #if defined(STACK_VERBOSE)
641 printf("cloning block L%03d ------> L%03d\n", b->nr, clone->nr);
648 /* stack_create_locals *********************************************************
650 Create the local variables for the start of the given basic block.
653 sd...........stack analysis data
654 b............block to create the locals for
656 *******************************************************************************/
658 static void stack_create_locals(stackdata_t *sd, basicblock *b)
664 /* copy the current state of the local variables */
665 /* (one extra local is needed by the verifier) */
667 dv = DMNEW(varinfo, sd->localcount + VERIFIER_EXTRA_LOCALS);
669 for (i=0; i<sd->localcount; ++i)
672 /* the current map from java locals to cacao variables */
674 jl = DMNEW(s4, sd->maxlocals);
676 MCOPY(jl, sd->javalocals, s4, sd->maxlocals);
680 /* stack_merge_locals **********************************************************
682 Merge local variables at the beginning of the given basic block.
685 sd...........stack analysis data
686 b............the block that is reached
688 *******************************************************************************/
690 static void stack_merge_locals(stackdata_t *sd, basicblock *b)
696 /* If a javalocal is mapped to different cacao locals along the */
697 /* incoming control-flow edges, it becomes undefined. */
699 for (i=0; i<sd->maxlocals; ++i) {
700 if (b->javalocals[i] != UNUSED && b->javalocals[i] != sd->javalocals[i]) {
701 b->javalocals[i] = UNUSED;
702 if (b->flags >= BBFINISHED)
703 b->flags = BBTYPECHECK_REACHED;
704 if (b->nr <= sd->bptr->nr)
709 #if defined(ENABLE_VERIFIER)
711 for (i=0; i<sd->localcount; ++i) {
712 dv = b->inlocals + i;
714 if ((sv->type == TYPE_RET && dv->type == TYPE_RET)
715 && (sv->SBRSTART != dv->SBRSTART))
717 #if defined(STACK_VERBOSE)
718 printf("JSR MISMATCH: setting variable %d to VOID\n", i);
720 dv->type = TYPE_VOID;
721 if (b->flags >= BBFINISHED)
722 b->flags = BBTYPECHECK_REACHED;
723 sd->repeat = true; /* This is very rare, so just repeat */
727 #endif /* defined(ENABLE_VERIFIER) */
731 /* stack_create_invars *********************************************************
733 Create the invars for the given basic block. Also make a copy of the locals.
736 sd...........stack analysis data
737 b............block to create the invars for
738 curstack.....current stack top
739 stackdepth...current stack depth
741 This function creates STACKDEPTH invars and sets their types to the
742 types to the types of the corresponding slot in the current stack.
744 *******************************************************************************/
746 static void stack_create_invars(stackdata_t *sd, basicblock *b,
747 stackptr curstack, int stackdepth)
755 assert(sd->vartop + stackdepth <= sd->varcount);
757 b->indepth = stackdepth;
758 b->invars = DMNEW(s4, stackdepth);
760 /* allocate the variable indices */
761 index = (sd->vartop += stackdepth);
764 for (sp = curstack; i--; sp = sp->prev) {
765 b->invars[i] = --index;
766 dv = sd->var + index;
767 sv = sd->var + sp->varnum;
769 COPY_VAL_AND_TYPE_VAR(sv, dv);
772 stack_create_locals(sd, b);
776 /* stack_create_invars_from_outvars ********************************************
778 Create the invars for the given basic block. Also make a copy of the locals.
779 Types are propagated from the outvars of the current block.
782 sd...........stack analysis data
783 b............block to create the invars for
785 *******************************************************************************/
787 static void stack_create_invars_from_outvars(stackdata_t *sd, basicblock *b)
793 n = sd->bptr->outdepth;
794 assert(sd->vartop + n <= sd->varcount);
797 b->invars = DMNEW(s4, n);
800 dv = sd->var + sd->vartop;
802 /* allocate the invars */
804 for (i=0; i<n; ++i, ++dv) {
805 sv = sd->var + sd->bptr->outvars[i];
806 b->invars[i] = sd->vartop++;
808 COPY_VAL_AND_TYPE_VAR(sv, dv);
812 stack_create_locals(sd, b);
816 /* stack_check_invars **********************************************************
818 Check the current stack against the invars of the given basic block.
819 Depth and types must match.
822 sd...........stack analysis data
823 b............block which invars to check against
824 curstack.....current stack top
825 stackdepth...current stack depth
829 NULL.........a VerifyError has been thrown
831 *******************************************************************************/
833 static basicblock * stack_check_invars(stackdata_t *sd, basicblock *b,
834 stackptr curstack, int stackdepth)
843 #if defined(STACK_VERBOSE)
844 printf("stack_check_invars(L%03d)\n", b->nr);
847 /* find original of b */
852 #if defined(STACK_VERBOSE)
853 printf("original is L%03d\n", orig->nr);
858 #if defined(ENABLE_VERIFIER)
859 if (i != stackdepth) {
860 exceptions_throw_verifyerror(sd->m, "Stack depth mismatch");
868 #if defined(STACK_VERBOSE)
869 printf("checking against ");
870 stack_verbose_show_block(sd, b); printf("\n");
874 for (i = orig->indepth; i--; sp = sp->prev) {
875 dv = sd->var + b->invars[i];
876 sv = sd->var + sp->varnum;
878 #if defined(ENABLE_VERIFIER)
879 if (dv->type != sp->type) {
880 exceptions_throw_verifyerror_for_stack(sd->m, dv->type);
885 if (sp->type == TYPE_RET) {
886 #if defined(ENABLE_VERIFIER)
887 if (dv->SBRSTART != sv->SBRSTART) {
888 exceptions_throw_verifyerror(sd->m, "Mismatched stack types");
892 if (dv->vv.retaddr != sv->vv.retaddr) {
894 /* don't break! have to check the remaining stackslots */
900 for (i=0; i<sd->localcount; ++i) {
901 dv = b->inlocals + i;
903 if (sv->type == TYPE_RET && dv->type == TYPE_RET) {
905 #if defined(ENABLE_VERIFIER)
906 (sv->SBRSTART == dv->SBRSTART) &&
908 (sv->vv.retaddr != dv->vv.retaddr))
918 /* XXX cascading collapse? */
920 stack_merge_locals(sd, b);
922 #if defined(STACK_VERBOSE)
923 printf("------> using L%03d\n", b->nr);
927 } while ((b = b->copied_to) != NULL);
929 b = stack_clone_block(sd, orig);
933 stack_create_invars(sd, b, curstack, stackdepth);
938 /* stack_check_invars_from_outvars *********************************************
940 Check the outvars of the current block against the invars of the given block.
941 Depth and types must match.
944 sd...........stack analysis data
945 b............block which invars to check against
949 NULL.........a VerifyError has been thrown
951 *******************************************************************************/
953 static basicblock * stack_check_invars_from_outvars(stackdata_t *sd, basicblock *b)
961 #if defined(STACK_VERBOSE)
962 printf("stack_check_invars_from_outvars(L%03d)\n", b->nr);
965 /* find original of b */
970 #if defined(STACK_VERBOSE)
971 printf("original is L%03d\n", orig->nr);
975 n = sd->bptr->outdepth;
977 #if defined(ENABLE_VERIFIER)
979 exceptions_throw_verifyerror(sd->m, "Stack depth mismatch");
987 #if defined(STACK_VERBOSE)
988 printf("checking against ");
989 stack_verbose_show_block(sd, b); printf("\n");
993 dv = sd->var + b->invars[0];
995 for (i=0; i<n; ++i, ++dv) {
996 sv = sd->var + sd->bptr->outvars[i];
998 #if defined(ENABLE_VERIFIER)
999 if (sv->type != dv->type) {
1000 exceptions_throw_verifyerror_for_stack(sd->m, dv->type);
1005 if (dv->type == TYPE_RET) {
1006 #if defined(ENABLE_VERIFIER)
1007 if (sv->SBRSTART != dv->SBRSTART) {
1008 exceptions_throw_verifyerror(sd->m, "Mismatched stack types");
1012 if (sv->vv.retaddr != dv->vv.retaddr) {
1014 /* don't break! have to check the remaining stackslots */
1021 for (i=0; i<sd->localcount; ++i) {
1022 dv = b->inlocals + i;
1025 #if defined(ENABLE_VERIFIER)
1026 (sv->SBRSTART == dv->SBRSTART) &&
1028 (sv->type == TYPE_RET && dv->type == TYPE_RET))
1030 if (sv->vv.retaddr != dv->vv.retaddr) {
1039 /* XXX cascading collapse? */
1041 stack_merge_locals(sd, b);
1043 #if defined(STACK_VERBOSE)
1044 printf("------> using L%03d\n", b->nr);
1048 } while ((b = b->copied_to) != NULL);
1050 b = stack_clone_block(sd, orig);
1054 stack_create_invars_from_outvars(sd, b);
1059 /* stack_create_instack ********************************************************
1061 Create the instack of the current basic block.
1064 sd...........stack analysis data
1067 the current stack top at the start of the basic block.
1069 *******************************************************************************/
1071 static stackptr stack_create_instack(stackdata_t *sd)
1077 if ((depth = sd->bptr->indepth) == 0)
1080 sp = (sd->new += depth);
1084 index = sd->bptr->invars[depth];
1086 sp->type = sd->var[index].type;
1090 sp->varkind = STACKVAR;
1094 /* return the top of the created stack */
1099 /* stack_mark_reached **********************************************************
1101 Mark the given block reached and propagate the current stack and locals to
1102 it. This function specializes the target block, if necessary, and returns
1103 a pointer to the specialized target.
1106 sd...........stack analysis data
1107 b............the block to reach
1108 curstack.....the current stack top
1109 stackdepth...the current stack depth
1112 a pointer to (a specialized version of) the target
1113 NULL.........a VerifyError has been thrown
1115 *******************************************************************************/
1117 static basicblock *stack_mark_reached(stackdata_t *sd, basicblock *b, stackptr curstack, int stackdepth)
1121 #if defined(STACK_VERBOSE)
1122 printf("stack_mark_reached(L%03d from L%03d)\n", b->nr, sd->bptr->nr);
1125 /* mark targets of backward branches */
1127 if (b->nr <= sd->bptr->nr)
1128 b->bitflags |= BBFLAG_REPLACEMENT;
1130 if (b->flags < BBREACHED) {
1131 /* b is reached for the first time. Create its invars. */
1133 #if defined(STACK_VERBOSE)
1134 printf("reached L%03d for the first time\n", b->nr);
1137 stack_create_invars(sd, b, curstack, stackdepth);
1139 b->flags = BBREACHED;
1144 /* b has been reached before. Check that its invars match. */
1146 return stack_check_invars(sd, b, curstack, stackdepth);
1151 /* stack_mark_reached_from_outvars *********************************************
1153 Mark the given block reached and propagate the outvars of the current block
1154 and the current locals to it. This function specializes the target block,
1155 if necessary, and returns a pointer to the specialized target.
1158 sd...........stack analysis data
1159 b............the block to reach
1162 a pointer to (a specialized version of) the target
1163 NULL.........a VerifyError has been thrown
1165 *******************************************************************************/
1167 static basicblock *stack_mark_reached_from_outvars(stackdata_t *sd, basicblock *b)
1171 #if defined(STACK_VERBOSE)
1172 printf("stack_mark_reached_from_outvars(L%03d from L%03d)\n", b->nr, sd->bptr->nr);
1175 /* mark targets of backward branches */
1177 if (b->nr <= sd->bptr->nr)
1178 b->bitflags |= BBFLAG_REPLACEMENT;
1180 if (b->flags < BBREACHED) {
1181 /* b is reached for the first time. Create its invars. */
1183 #if defined(STACK_VERBOSE)
1184 printf("reached L%03d for the first time\n", b->nr);
1187 stack_create_invars_from_outvars(sd, b);
1189 b->flags = BBREACHED;
1194 /* b has been reached before. Check that its invars match. */
1196 return stack_check_invars_from_outvars(sd, b);
1201 /* stack_reach_next_block ******************************************************
1203 Mark the following block reached and propagate the outvars of the
1204 current block and the current locals to it. This function
1205 specializes the target block, if necessary, and returns a pointer
1206 to the specialized target.
1209 sd...........stack analysis data
1212 a pointer to (a specialized version of) the following block
1213 NULL.........a VerifyError has been thrown
1215 *******************************************************************************/
1217 static bool stack_reach_next_block(stackdata_t *sd)
1222 tbptr = (sd->bptr->original) ? sd->bptr->original : sd->bptr;
1223 tbptr = stack_mark_reached_from_outvars(sd, tbptr->next);
1228 if (tbptr != sd->bptr->next) {
1229 #if defined(STACK_VERBOSE)
1230 printf("NEXT IS NON-CONSEQUITIVE L%03d\n", tbptr->nr);
1232 iptr = sd->bptr->iinstr + sd->bptr->icount - 1;
1233 assert(iptr->opc == ICMD_NOP);
1234 iptr->opc = ICMD_GOTO;
1235 iptr->dst.block = tbptr;
1237 if (tbptr->flags < BBFINISHED)
1238 sd->repeat = true; /* XXX check if we really need to repeat */
1245 /* stack_reach_handlers ********************************************************
1247 Reach the exception handlers for the current block.
1250 sd...........stack analysis data
1253 true.........everything ok
1254 false........a VerifyError has been thrown
1256 *******************************************************************************/
1258 static bool stack_reach_handlers(stackdata_t *sd)
1263 #if defined(STACK_VERBOSE)
1264 printf("reaching exception handlers...\n");
1267 for (i=0; sd->handlers[i]; ++i) {
1268 tbptr = sd->handlers[i]->handler;
1270 tbptr->type = BBTYPE_EXH;
1271 tbptr->predecessorcount = CFG_UNKNOWN_PREDECESSORS;
1273 /* reach (and specialize) the handler block */
1275 tbptr = stack_mark_reached(sd, tbptr, &(sd->exstack), 1);
1280 sd->handlers[i]->handler = tbptr;
1287 /* stack_reanalyse_block ******************************************************
1289 Re-analyse the current block. This is called if either the block itself
1290 has already been analysed before, or the current block is a clone of an
1291 already analysed block, and this clone is reached for the first time.
1292 In the latter case, this function does all that is necessary for fully
1293 cloning the block (cloning the instruction list and variables, etc.).
1296 sd...........stack analysis data
1299 true.........everything ok
1300 false........a VerifyError has been thrown
1302 *******************************************************************************/
1304 #define RELOCATE(index) \
1306 if ((index) >= blockvarstart) \
1307 (index) += blockvarshift; \
1308 else if ((index) >= invarstart) \
1309 (index) += invarshift; \
1312 bool stack_reanalyse_block(stackdata_t *sd)
1324 branch_target_t *table;
1325 lookup_target_t *lookup;
1327 bool cloneinstructions;
1328 exception_entry *ex;
1330 #if defined(STACK_VERBOSE)
1331 stack_verbose_block_enter(sd, true);
1338 assert(orig != NULL);
1340 /* clone the instruction list */
1342 cloneinstructions = true;
1344 assert(orig->iinstr);
1346 iptr = DMNEW(instruction, len + 1);
1348 MCOPY(iptr, orig->iinstr, instruction, len);
1349 iptr[len].opc = ICMD_NOP;
1351 iptr[len].flags.bits = 0;
1355 /* reserve space for the clone's block variables */
1357 stack_grow_variable_array(sd, orig->varcount);
1359 /* we already have the invars set */
1361 assert(b->indepth == orig->indepth);
1363 /* calculate relocation shifts for invars and block variables */
1365 if (orig->indepth) {
1366 invarstart = orig->invars[0];
1367 invarshift = b->invars[0] - invarstart;
1370 invarstart = INT_MAX;
1373 blockvarstart = orig->varstart;
1374 blockvarshift = sd->vartop - blockvarstart;
1376 /* copy block variables */
1378 b->varstart = sd->vartop;
1379 b->varcount = orig->varcount;
1380 sd->vartop += b->varcount;
1381 MCOPY(sd->var + b->varstart, sd->var + orig->varstart, varinfo, b->varcount);
1385 b->outdepth = orig->outdepth;
1386 b->outvars = DMNEW(s4, orig->outdepth);
1387 MCOPY(b->outvars, orig->outvars, s4, orig->outdepth);
1389 /* clone exception handlers */
1391 for (i=0; sd->handlers[i]; ++i) {
1392 ex = DNEW(exception_entry);
1393 ex->handler = sd->handlers[i]->handler;
1395 ex->end = b; /* XXX hack, see end of stack_analyse */
1396 ex->catchtype = sd->handlers[i]->catchtype;
1399 assert(sd->extableend->down == NULL);
1400 sd->extableend->down = ex;
1401 sd->extableend = ex;
1402 sd->jd->exceptiontablelength++;
1404 sd->handlers[i] = ex;
1408 cloneinstructions = false;
1411 invarstart = sd->vartop;
1412 blockvarstart = sd->vartop;
1417 /* find exception handlers for the cloned block */
1419 ex = sd->jd->exceptiontable;
1420 for (; ex != NULL; ex = ex->down) {
1421 /* XXX the cloned exception handlers have identical */
1422 /* start end end blocks. */
1423 if ((ex->start == b) && (ex->end == b)) {
1424 sd->handlers[len++] = ex;
1427 sd->handlers[len] = NULL;
1430 #if defined(STACK_VERBOSE)
1431 printf("invarstart = %d, blockvarstart = %d\n", invarstart, blockvarstart);
1432 printf("invarshift = %d, blockvarshift = %d\n", invarshift, blockvarshift);
1435 /* mark block as finished */
1437 b->flags = BBFINISHED;
1439 /* initialize locals at the start of this block */
1442 MCOPY(sd->var, b->inlocals, varinfo, sd->localcount);
1444 MCOPY(sd->javalocals, b->javalocals, s4, sd->maxlocals);
1446 /* reach exception handlers for this block */
1448 if (!stack_reach_handlers(sd))
1451 superblockend = false;
1453 for (len = b->icount; len--; iptr++) {
1454 #if defined(STACK_VERBOSE)
1455 show_icmd(sd->jd, iptr, false, SHOW_STACK);
1459 switch (iptr->opc) {
1461 j = iptr->s1.varindex;
1463 #if defined(ENABLE_VERIFIER)
1464 if (sd->var[j].type != TYPE_RET) {
1465 exceptions_throw_verifyerror(sd->m, "RET with non-returnAddress value");
1470 iptr->dst.block = stack_mark_reached_from_outvars(sd, sd->var[j].vv.retaddr);
1471 superblockend = true;
1475 iptr->sx.s23.s3.jsrtarget.block = stack_mark_reached_from_outvars(sd, iptr->sx.s23.s3.jsrtarget.block);
1476 RELOCATE(iptr->dst.varindex);
1477 superblockend = true;
1481 superblockend = true;
1484 case ICMD_CHECKNULL:
1485 case ICMD_PUTSTATICCONST:
1493 iptr->dst.block = stack_mark_reached_from_outvars(sd, iptr->dst.block);
1494 superblockend = true;
1497 /* pop 0 push 1 const */
1505 /* pop 0 push 1 load */
1512 RELOCATE(iptr->dst.varindex);
1525 RELOCATE(iptr->sx.s23.s2.varindex);
1526 RELOCATE(iptr->s1.varindex);
1527 RELOCATE(iptr->dst.varindex);
1540 RELOCATE(iptr->sx.s23.s3.varindex);
1541 RELOCATE(iptr->sx.s23.s2.varindex);
1542 RELOCATE(iptr->s1.varindex);
1545 /* pop 1 push 0 store */
1552 RELOCATE(iptr->s1.varindex);
1554 j = iptr->dst.varindex;
1555 COPY_VAL_AND_TYPE(*sd, iptr->s1.varindex, j);
1556 i = iptr->sx.s23.s3.javaindex;
1557 if (iptr->flags.bits & INS_FLAG_RETADDR) {
1558 iptr->sx.s23.s2.retaddrnr =
1559 UNUSED - (1 + sd->var[j].vv.retaddr->nr);
1560 sd->javalocals[i] = iptr->sx.s23.s2.retaddrnr;
1563 sd->javalocals[i] = j;
1564 if (iptr->flags.bits & INS_FLAG_KILL_PREV)
1565 sd->javalocals[i-1] = UNUSED;
1566 if (iptr->flags.bits & INS_FLAG_KILL_NEXT)
1567 sd->javalocals[i+1] = UNUSED;
1578 RELOCATE(iptr->s1.varindex);
1579 superblockend = true;
1582 case ICMD_PUTSTATIC:
1583 case ICMD_PUTFIELDCONST:
1585 RELOCATE(iptr->s1.varindex);
1588 /* pop 1 push 0 branch */
1591 case ICMD_IFNONNULL:
1606 RELOCATE(iptr->s1.varindex);
1607 iptr->dst.block = stack_mark_reached_from_outvars(sd, iptr->dst.block);
1610 /* pop 1 push 0 table branch */
1612 case ICMD_TABLESWITCH:
1613 i = iptr->sx.s23.s3.tablehigh - iptr->sx.s23.s2.tablelow + 1 + 1;
1615 if (cloneinstructions) {
1616 table = DMNEW(branch_target_t, i);
1617 MCOPY(table, iptr->dst.table, branch_target_t, i);
1618 iptr->dst.table = table;
1621 table = iptr->dst.table;
1624 RELOCATE(iptr->s1.varindex);
1626 table->block = stack_mark_reached_from_outvars(sd, table->block);
1629 superblockend = true;
1632 case ICMD_LOOKUPSWITCH:
1633 i = iptr->sx.s23.s2.lookupcount;
1634 if (cloneinstructions) {
1635 lookup = DMNEW(lookup_target_t, i);
1636 MCOPY(lookup, iptr->dst.lookup, lookup_target_t, i);
1637 iptr->dst.lookup = lookup;
1640 lookup = iptr->dst.lookup;
1642 RELOCATE(iptr->s1.varindex);
1644 lookup->target.block = stack_mark_reached_from_outvars(sd, lookup->target.block);
1647 iptr->sx.s23.s3.lookupdefault.block = stack_mark_reached_from_outvars(sd, iptr->sx.s23.s3.lookupdefault.block);
1648 superblockend = true;
1651 case ICMD_MONITORENTER:
1652 case ICMD_MONITOREXIT:
1653 RELOCATE(iptr->s1.varindex);
1656 /* pop 2 push 0 branch */
1658 case ICMD_IF_ICMPEQ:
1659 case ICMD_IF_ICMPNE:
1660 case ICMD_IF_ICMPLT:
1661 case ICMD_IF_ICMPGE:
1662 case ICMD_IF_ICMPGT:
1663 case ICMD_IF_ICMPLE:
1665 case ICMD_IF_LCMPEQ:
1666 case ICMD_IF_LCMPNE:
1667 case ICMD_IF_LCMPLT:
1668 case ICMD_IF_LCMPGE:
1669 case ICMD_IF_LCMPGT:
1670 case ICMD_IF_LCMPLE:
1672 case ICMD_IF_FCMPEQ:
1673 case ICMD_IF_FCMPNE:
1675 case ICMD_IF_FCMPL_LT:
1676 case ICMD_IF_FCMPL_GE:
1677 case ICMD_IF_FCMPL_GT:
1678 case ICMD_IF_FCMPL_LE:
1680 case ICMD_IF_FCMPG_LT:
1681 case ICMD_IF_FCMPG_GE:
1682 case ICMD_IF_FCMPG_GT:
1683 case ICMD_IF_FCMPG_LE:
1685 case ICMD_IF_DCMPEQ:
1686 case ICMD_IF_DCMPNE:
1688 case ICMD_IF_DCMPL_LT:
1689 case ICMD_IF_DCMPL_GE:
1690 case ICMD_IF_DCMPL_GT:
1691 case ICMD_IF_DCMPL_LE:
1693 case ICMD_IF_DCMPG_LT:
1694 case ICMD_IF_DCMPG_GE:
1695 case ICMD_IF_DCMPG_GT:
1696 case ICMD_IF_DCMPG_LE:
1698 case ICMD_IF_ACMPEQ:
1699 case ICMD_IF_ACMPNE:
1700 RELOCATE(iptr->sx.s23.s2.varindex);
1701 RELOCATE(iptr->s1.varindex);
1702 iptr->dst.block = stack_mark_reached_from_outvars(sd, iptr->dst.block);
1708 case ICMD_IASTORECONST:
1709 case ICMD_LASTORECONST:
1710 case ICMD_AASTORECONST:
1711 case ICMD_BASTORECONST:
1712 case ICMD_CASTORECONST:
1713 case ICMD_SASTORECONST:
1715 RELOCATE(iptr->sx.s23.s2.varindex);
1716 RELOCATE(iptr->s1.varindex);
1719 /* pop 0 push 1 copy */
1723 RELOCATE(iptr->dst.varindex);
1724 RELOCATE(iptr->s1.varindex);
1725 COPY_VAL_AND_TYPE(*sd, iptr->s1.varindex, iptr->dst.varindex);
1767 RELOCATE(iptr->sx.s23.s2.varindex);
1768 RELOCATE(iptr->s1.varindex);
1769 RELOCATE(iptr->dst.varindex);
1774 case ICMD_CHECKCAST:
1775 case ICMD_ARRAYLENGTH:
1776 case ICMD_INSTANCEOF:
1778 case ICMD_ANEWARRAY:
1780 case ICMD_IADDCONST:
1781 case ICMD_ISUBCONST:
1782 case ICMD_IMULCONST:
1786 case ICMD_IANDCONST:
1788 case ICMD_IXORCONST:
1789 case ICMD_ISHLCONST:
1790 case ICMD_ISHRCONST:
1791 case ICMD_IUSHRCONST:
1792 case ICMD_LADDCONST:
1793 case ICMD_LSUBCONST:
1794 case ICMD_LMULCONST:
1798 case ICMD_LANDCONST:
1800 case ICMD_LXORCONST:
1801 case ICMD_LSHLCONST:
1802 case ICMD_LSHRCONST:
1803 case ICMD_LUSHRCONST:
1807 case ICMD_INT2SHORT:
1823 RELOCATE(iptr->s1.varindex);
1824 RELOCATE(iptr->dst.varindex);
1829 case ICMD_GETSTATIC:
1831 RELOCATE(iptr->dst.varindex);
1834 /* pop many push any */
1836 case ICMD_INVOKESTATIC:
1837 case ICMD_INVOKESPECIAL:
1838 case ICMD_INVOKEVIRTUAL:
1839 case ICMD_INVOKEINTERFACE:
1841 case ICMD_MULTIANEWARRAY:
1842 i = iptr->s1.argcount;
1843 if (cloneinstructions) {
1844 argp = DMNEW(s4, i);
1845 MCOPY(argp, iptr->sx.s23.s2.args, s4, i);
1846 iptr->sx.s23.s2.args = argp;
1849 argp = iptr->sx.s23.s2.args;
1856 RELOCATE(iptr->dst.varindex);
1860 exceptions_throw_internalerror("Unknown ICMD %d during stack re-analysis",
1865 #if defined(STACK_VERBOSE)
1866 show_icmd(sd->jd, iptr, false, SHOW_STACK);
1871 /* relocate outvars */
1873 for (i=0; i<b->outdepth; ++i) {
1874 RELOCATE(b->outvars[i]);
1877 #if defined(STACK_VERBOSE)
1878 stack_verbose_block_exit(sd, superblockend);
1881 /* propagate to the next block */
1884 if (!stack_reach_next_block(sd))
1891 /* stack_change_to_tempvar *****************************************************
1893 Change the given stackslot to a TEMPVAR. This includes creating a new
1894 temporary variable and changing the dst.varindex of the creator of the
1895 stacklot to the new variable index. If this stackslot has been passed
1896 through ICMDs between the point of its creation and the current point,
1897 then the variable index is also changed in these ICMDs.
1900 sd...........stack analysis data
1901 sp...........stackslot to change
1902 ilimit.......instruction up to which to look for ICMDs passing-through
1903 the stackslot (exclusive). This may point exactly after the
1904 last instruction, in which case the search is done to the
1907 *******************************************************************************/
1909 static void stack_change_to_tempvar(stackdata_t *sd, stackptr sp,
1910 instruction *ilimit)
1918 oldindex = sp->varnum;
1920 /* create a new temporary variable */
1922 GET_NEW_VAR(*sd, newindex, sp->type);
1924 sd->var[newindex].flags = sp->flags;
1926 /* change the stackslot */
1928 sp->varnum = newindex;
1929 sp->varkind = TEMPVAR;
1931 /* change the dst.varindex of the stackslot's creator */
1934 sp->creator->dst.varindex = newindex;
1936 /* handle ICMDs this stackslot passed through, if any */
1938 if (sp->flags & PASSTHROUGH) {
1939 iptr = (sp->creator) ? (sp->creator + 1) : sd->bptr->iinstr;
1941 /* assert that the limit points to an ICMD, or after the last one */
1943 assert(ilimit >= sd->bptr->iinstr);
1944 assert(ilimit <= sd->bptr->iinstr + sd->bptr->icount);
1946 /* find the stackdepth under sp plus one */
1947 /* Note: This number is usually known when this function is called, */
1948 /* but calculating it here is less error-prone and should not be */
1949 /* a performance problem. */
1951 for (depth = 0; sp != NULL; sp = sp->prev)
1954 /* iterate over all instructions in the range and replace */
1956 for (; iptr < ilimit; ++iptr) {
1957 switch (iptr->opc) {
1958 case ICMD_INVOKESTATIC:
1959 case ICMD_INVOKESPECIAL:
1960 case ICMD_INVOKEVIRTUAL:
1961 case ICMD_INVOKEINTERFACE:
1963 i = iptr->s1.argcount - depth;
1964 if (iptr->sx.s23.s2.args[i] == oldindex) {
1965 iptr->sx.s23.s2.args[i] = newindex;
1968 /* IMPORTANT: If any ICMD sets the PASSTHROUGH flag of a */
1969 /* stackslot, it must be added in this switch! */
1976 /* stack_init_javalocals *******************************************************
1978 Initialize the mapping from Java locals to cacao variables at method entry.
1981 sd...........stack analysis data
1983 *******************************************************************************/
1985 static void stack_init_javalocals(stackdata_t *sd)
1994 jl = DMNEW(s4, sd->maxlocals);
1995 jd->basicblocks[0].javalocals = jl;
1997 for (i=0; i<sd->maxlocals; ++i)
2000 md = jd->m->parseddesc;
2002 for (i=0; i<md->paramcount; ++i) {
2003 t = md->paramtypes[i].type;
2004 jl[j] = jd->local_map[5*j + t];
2006 if (IS_2_WORD_TYPE(t))
2012 /* stack_analyse ***************************************************************
2014 Analyse_stack uses the intermediate code created by parse.c to
2015 build a model of the JVM operand stack for the current method.
2017 The following checks are performed:
2018 - check for operand stack underflow (before each instruction)
2019 - check for operand stack overflow (after[1] each instruction)
2020 - check for matching stack depth at merging points
2021 - check for matching basic types[2] at merging points
2022 - check basic types for instruction input (except for BUILTIN*
2023 opcodes, INVOKE* opcodes and MULTIANEWARRAY)
2025 [1]) Checking this after the instruction should be ok. parse.c
2026 counts the number of required stack slots in such a way that it is
2027 only vital that we don't exceed `maxstack` at basic block
2030 [2]) 'basic types' means the distinction between INT, LONG, FLOAT,
2031 DOUBLE and ADDRESS types. Subtypes of INT and different ADDRESS
2032 types are not discerned.
2034 *******************************************************************************/
2036 bool stack_analyse(jitdata *jd)
2038 methodinfo *m; /* method being analyzed */
2041 #if defined(ENABLE_SSA)
2045 stackptr curstack; /* current stack top */
2047 int opcode; /* opcode of current instruction */
2050 int len; /* # of instructions after the current one */
2051 bool superblockend; /* if true, no fallthrough to next block */
2052 bool deadcode; /* true if no live code has been reached */
2053 instruction *iptr; /* the current instruction */
2055 basicblock *original;
2056 exception_entry *ex;
2058 stackptr *last_store_boundary;
2059 stackptr coalescing_boundary;
2061 stackptr src1, src2, src3, src4, dst1, dst2;
2063 branch_target_t *table;
2064 lookup_target_t *lookup;
2065 #if defined(ENABLE_VERIFIER)
2066 int expectedtype; /* used by CHECK_BASIC_TYPE */
2068 builtintable_entry *bte;
2070 constant_FMIref *fmiref;
2071 #if defined(ENABLE_STATISTICS)
2072 int iteration_count; /* number of iterations of analysis */
2074 int new_index; /* used to get a new var index with GET_NEW_INDEX*/
2076 #if defined(STACK_VERBOSE)
2077 show_method(jd, SHOW_PARSE);
2080 /* get required compiler data - initialization */
2084 #if defined(ENABLE_SSA)
2088 /* initialize the stackdata_t struct */
2092 sd.varcount = jd->varcount;
2093 sd.vartop = jd->vartop;
2094 sd.localcount = jd->localcount;
2096 sd.varsallocated = sd.varcount;
2097 sd.maxlocals = m->maxlocals;
2098 sd.javalocals = DMNEW(s4, sd.maxlocals);
2099 sd.handlers = DMNEW(exception_entry *, jd->exceptiontablelength + 1);
2101 /* prepare the variable for exception handler stacks */
2102 /* (has been reserved by STACK_EXTRA_VARS, or VERIFIER_EXTRA_VARS) */
2104 sd.exstack.type = TYPE_ADR;
2105 sd.exstack.prev = NULL;
2106 sd.exstack.varnum = sd.localcount;
2107 sd.var[sd.exstack.varnum].type = TYPE_ADR;
2109 #if defined(ENABLE_LSRA)
2110 m->maxlifetimes = 0;
2113 #if defined(ENABLE_STATISTICS)
2114 iteration_count = 0;
2117 /* find the last real basic block */
2119 sd.last_real_block = NULL;
2120 tbptr = jd->basicblocks;
2121 while (tbptr->next) {
2122 sd.last_real_block = tbptr;
2123 tbptr = tbptr->next;
2125 assert(sd.last_real_block);
2127 /* find the last exception handler */
2129 if (jd->exceptiontablelength)
2130 sd.extableend = jd->exceptiontable + jd->exceptiontablelength - 1;
2132 sd.extableend = NULL;
2134 /* init jd->interface_map */
2136 jd->maxinterfaces = m->maxstack;
2137 jd->interface_map = DMNEW(interface_info, m->maxstack * 5);
2138 for (i = 0; i < m->maxstack * 5; i++)
2139 jd->interface_map[i].flags = UNUSED;
2141 last_store_boundary = DMNEW(stackptr, m->maxlocals);
2143 /* initialize flags and invars (none) of first block */
2145 jd->basicblocks[0].flags = BBREACHED;
2146 jd->basicblocks[0].invars = NULL;
2147 jd->basicblocks[0].indepth = 0;
2148 jd->basicblocks[0].inlocals =
2149 DMNEW(varinfo, jd->localcount + VERIFIER_EXTRA_LOCALS);
2150 MCOPY(jd->basicblocks[0].inlocals, jd->var, varinfo,
2151 jd->localcount + VERIFIER_EXTRA_LOCALS);
2153 /* initialize java local mapping of first block */
2155 stack_init_javalocals(&sd);
2157 /* stack analysis loop (until fixpoint reached) **************************/
2160 #if defined(ENABLE_STATISTICS)
2164 /* initialize loop over basic blocks */
2166 sd.bptr = jd->basicblocks;
2167 superblockend = true;
2173 /* iterate over basic blocks *****************************************/
2175 for (; sd.bptr; sd.bptr = sd.bptr->next) {
2177 if (sd.bptr->flags == BBDELETED) {
2178 /* This block has been deleted - do nothing. */
2183 if (sd.bptr->flags == BBTYPECHECK_REACHED) {
2184 /* re-analyse a block because its input changed */
2188 if (!stack_reanalyse_block(&sd))
2191 superblockend = true; /* XXX */
2195 if (superblockend && (sd.bptr->flags < BBREACHED)) {
2196 /* This block has not been reached so far, and we
2197 don't fall into it, so we'll have to iterate
2204 if (sd.bptr->flags > BBREACHED) {
2205 /* This block is already finished. */
2207 superblockend = true;
2211 if (sd.bptr->original && sd.bptr->original->flags < BBFINISHED) {
2212 /* This block is a clone and the original has not been
2213 analysed, yet. Analyse it on the next
2217 /* XXX superblockend? */
2221 /* This block has to be analysed now. */
2225 /* XXX The rest of this block is still indented one level too */
2226 /* much in order to avoid a giant diff by changing that. */
2228 /* We know that sd.bptr->flags == BBREACHED. */
2229 /* This block has been reached before. */
2231 assert(sd.bptr->flags == BBREACHED);
2232 stackdepth = sd.bptr->indepth;
2234 /* find exception handlers for this block */
2236 /* determine the active exception handlers for this block */
2237 /* XXX could use a faster algorithm with sorted lists or */
2240 original = (sd.bptr->original) ? sd.bptr->original : sd.bptr;
2243 ex = jd->exceptiontable;
2244 for (; ex != NULL; ex = ex->down) {
2245 if ((ex->start <= original) && (ex->end > original)) {
2246 sd.handlers[len++] = ex;
2249 sd.handlers[len] = NULL;
2252 /* reanalyse cloned block */
2254 if (sd.bptr->original) {
2255 if (!stack_reanalyse_block(&sd))
2260 /* reset the new pointer for allocating stackslots */
2264 /* create the instack of this block */
2266 curstack = stack_create_instack(&sd);
2268 /* initialize locals at the start of this block */
2270 if (sd.bptr->inlocals)
2271 MCOPY(sd.var, sd.bptr->inlocals, varinfo, sd.localcount);
2273 MCOPY(sd.javalocals, sd.bptr->javalocals, s4, sd.maxlocals);
2275 /* set up local variables for analyzing this block */
2277 superblockend = false;
2278 len = sd.bptr->icount;
2279 iptr = sd.bptr->iinstr;
2281 /* mark the block as analysed */
2283 sd.bptr->flags = BBFINISHED;
2285 /* reset variables for dependency checking */
2287 coalescing_boundary = sd.new;
2288 for( i = 0; i < m->maxlocals; i++)
2289 last_store_boundary[i] = sd.new;
2291 /* remember the start of this block's variables */
2293 sd.bptr->varstart = sd.vartop;
2295 #if defined(STACK_VERBOSE)
2296 stack_verbose_block_enter(&sd, false);
2299 /* reach exception handlers for this block */
2301 if (!stack_reach_handlers(&sd))
2304 /* iterate over ICMDs ****************************************/
2306 while (--len >= 0) {
2308 #if defined(STACK_VERBOSE)
2309 stack_verbose_show_state(&sd, iptr, curstack);
2312 /* fetch the current opcode */
2316 /* automatically replace some ICMDs with builtins */
2318 #if defined(USEBUILTINTABLE)
2319 bte = builtintable_get_automatic(opcode);
2321 if (bte && bte->opcode == opcode) {
2322 iptr->opc = ICMD_BUILTIN;
2323 iptr->flags.bits &= INS_FLAG_ID_MASK;
2324 iptr->sx.s23.s3.bte = bte;
2325 /* iptr->line is already set */
2326 jd->isleafmethod = false;
2329 #endif /* defined(USEBUILTINTABLE) */
2331 /* main opcode switch *************************************/
2343 case ICMD_CHECKNULL:
2344 coalescing_boundary = sd.new;
2345 COUNT(count_check_null);
2348 iptr->dst.varindex = iptr->s1.varindex;
2352 j = iptr->s1.varindex =
2353 jd->local_map[iptr->s1.varindex * 5 + TYPE_ADR];
2355 #if defined(ENABLE_VERIFIER)
2356 if (sd.var[j].type != TYPE_RET) {
2357 exceptions_throw_verifyerror(m, "RET with non-returnAddress value");
2364 iptr->dst.block = stack_mark_reached(&sd, sd.var[j].vv.retaddr, curstack, stackdepth);
2365 superblockend = true;
2369 COUNT(count_pcmd_return);
2372 superblockend = true;
2373 sd.jd->returncount++;
2374 sd.jd->returnblock = sd.bptr;
2378 /* pop 0 push 1 const */
2380 /************************** ICONST OPTIMIZATIONS **************************/
2383 COUNT(count_pcmd_load);
2387 switch (iptr[1].opc) {
2389 iptr->opc = ICMD_IADDCONST;
2393 iptr[1].opc = ICMD_NOP;
2394 OP1_1(TYPE_INT, TYPE_INT);
2395 COUNT(count_pcmd_op);
2399 iptr->opc = ICMD_ISUBCONST;
2400 goto icmd_iconst_tail;
2401 #if SUPPORT_CONST_MUL
2403 iptr->opc = ICMD_IMULCONST;
2404 goto icmd_iconst_tail;
2405 #else /* SUPPORT_CONST_MUL */
2407 if (iptr->sx.val.i == 0x00000002)
2409 else if (iptr->sx.val.i == 0x00000004)
2411 else if (iptr->sx.val.i == 0x00000008)
2413 else if (iptr->sx.val.i == 0x00000010)
2415 else if (iptr->sx.val.i == 0x00000020)
2417 else if (iptr->sx.val.i == 0x00000040)
2419 else if (iptr->sx.val.i == 0x00000080)
2421 else if (iptr->sx.val.i == 0x00000100)
2423 else if (iptr->sx.val.i == 0x00000200)
2425 else if (iptr->sx.val.i == 0x00000400)
2426 iptr->sx.val.i = 10;
2427 else if (iptr->sx.val.i == 0x00000800)
2428 iptr->sx.val.i = 11;
2429 else if (iptr->sx.val.i == 0x00001000)
2430 iptr->sx.val.i = 12;
2431 else if (iptr->sx.val.i == 0x00002000)
2432 iptr->sx.val.i = 13;
2433 else if (iptr->sx.val.i == 0x00004000)
2434 iptr->sx.val.i = 14;
2435 else if (iptr->sx.val.i == 0x00008000)
2436 iptr->sx.val.i = 15;
2437 else if (iptr->sx.val.i == 0x00010000)
2438 iptr->sx.val.i = 16;
2439 else if (iptr->sx.val.i == 0x00020000)
2440 iptr->sx.val.i = 17;
2441 else if (iptr->sx.val.i == 0x00040000)
2442 iptr->sx.val.i = 18;
2443 else if (iptr->sx.val.i == 0x00080000)
2444 iptr->sx.val.i = 19;
2445 else if (iptr->sx.val.i == 0x00100000)
2446 iptr->sx.val.i = 20;
2447 else if (iptr->sx.val.i == 0x00200000)
2448 iptr->sx.val.i = 21;
2449 else if (iptr->sx.val.i == 0x00400000)
2450 iptr->sx.val.i = 22;
2451 else if (iptr->sx.val.i == 0x00800000)
2452 iptr->sx.val.i = 23;
2453 else if (iptr->sx.val.i == 0x01000000)
2454 iptr->sx.val.i = 24;
2455 else if (iptr->sx.val.i == 0x02000000)
2456 iptr->sx.val.i = 25;
2457 else if (iptr->sx.val.i == 0x04000000)
2458 iptr->sx.val.i = 26;
2459 else if (iptr->sx.val.i == 0x08000000)
2460 iptr->sx.val.i = 27;
2461 else if (iptr->sx.val.i == 0x10000000)
2462 iptr->sx.val.i = 28;
2463 else if (iptr->sx.val.i == 0x20000000)
2464 iptr->sx.val.i = 29;
2465 else if (iptr->sx.val.i == 0x40000000)
2466 iptr->sx.val.i = 30;
2467 else if (iptr->sx.val.i == 0x80000000)
2468 iptr->sx.val.i = 31;
2472 iptr->opc = ICMD_IMULPOW2;
2473 goto icmd_iconst_tail;
2474 #endif /* SUPPORT_CONST_MUL */
2476 if (iptr->sx.val.i == 0x00000002)
2478 else if (iptr->sx.val.i == 0x00000004)
2480 else if (iptr->sx.val.i == 0x00000008)
2482 else if (iptr->sx.val.i == 0x00000010)
2484 else if (iptr->sx.val.i == 0x00000020)
2486 else if (iptr->sx.val.i == 0x00000040)
2488 else if (iptr->sx.val.i == 0x00000080)
2490 else if (iptr->sx.val.i == 0x00000100)
2492 else if (iptr->sx.val.i == 0x00000200)
2494 else if (iptr->sx.val.i == 0x00000400)
2495 iptr->sx.val.i = 10;
2496 else if (iptr->sx.val.i == 0x00000800)
2497 iptr->sx.val.i = 11;
2498 else if (iptr->sx.val.i == 0x00001000)
2499 iptr->sx.val.i = 12;
2500 else if (iptr->sx.val.i == 0x00002000)
2501 iptr->sx.val.i = 13;
2502 else if (iptr->sx.val.i == 0x00004000)
2503 iptr->sx.val.i = 14;
2504 else if (iptr->sx.val.i == 0x00008000)
2505 iptr->sx.val.i = 15;
2506 else if (iptr->sx.val.i == 0x00010000)
2507 iptr->sx.val.i = 16;
2508 else if (iptr->sx.val.i == 0x00020000)
2509 iptr->sx.val.i = 17;
2510 else if (iptr->sx.val.i == 0x00040000)
2511 iptr->sx.val.i = 18;
2512 else if (iptr->sx.val.i == 0x00080000)
2513 iptr->sx.val.i = 19;
2514 else if (iptr->sx.val.i == 0x00100000)
2515 iptr->sx.val.i = 20;
2516 else if (iptr->sx.val.i == 0x00200000)
2517 iptr->sx.val.i = 21;
2518 else if (iptr->sx.val.i == 0x00400000)
2519 iptr->sx.val.i = 22;
2520 else if (iptr->sx.val.i == 0x00800000)
2521 iptr->sx.val.i = 23;
2522 else if (iptr->sx.val.i == 0x01000000)
2523 iptr->sx.val.i = 24;
2524 else if (iptr->sx.val.i == 0x02000000)
2525 iptr->sx.val.i = 25;
2526 else if (iptr->sx.val.i == 0x04000000)
2527 iptr->sx.val.i = 26;
2528 else if (iptr->sx.val.i == 0x08000000)
2529 iptr->sx.val.i = 27;
2530 else if (iptr->sx.val.i == 0x10000000)
2531 iptr->sx.val.i = 28;
2532 else if (iptr->sx.val.i == 0x20000000)
2533 iptr->sx.val.i = 29;
2534 else if (iptr->sx.val.i == 0x40000000)
2535 iptr->sx.val.i = 30;
2536 else if (iptr->sx.val.i == 0x80000000)
2537 iptr->sx.val.i = 31;
2541 iptr->opc = ICMD_IDIVPOW2;
2542 goto icmd_iconst_tail;
2545 /*log_text("stack.c: ICMD_ICONST/ICMD_IREM");*/
2546 if ((iptr->sx.val.i == 0x00000002) ||
2547 (iptr->sx.val.i == 0x00000004) ||
2548 (iptr->sx.val.i == 0x00000008) ||
2549 (iptr->sx.val.i == 0x00000010) ||
2550 (iptr->sx.val.i == 0x00000020) ||
2551 (iptr->sx.val.i == 0x00000040) ||
2552 (iptr->sx.val.i == 0x00000080) ||
2553 (iptr->sx.val.i == 0x00000100) ||
2554 (iptr->sx.val.i == 0x00000200) ||
2555 (iptr->sx.val.i == 0x00000400) ||
2556 (iptr->sx.val.i == 0x00000800) ||
2557 (iptr->sx.val.i == 0x00001000) ||
2558 (iptr->sx.val.i == 0x00002000) ||
2559 (iptr->sx.val.i == 0x00004000) ||
2560 (iptr->sx.val.i == 0x00008000) ||
2561 (iptr->sx.val.i == 0x00010000) ||
2562 (iptr->sx.val.i == 0x00020000) ||
2563 (iptr->sx.val.i == 0x00040000) ||
2564 (iptr->sx.val.i == 0x00080000) ||
2565 (iptr->sx.val.i == 0x00100000) ||
2566 (iptr->sx.val.i == 0x00200000) ||
2567 (iptr->sx.val.i == 0x00400000) ||
2568 (iptr->sx.val.i == 0x00800000) ||
2569 (iptr->sx.val.i == 0x01000000) ||
2570 (iptr->sx.val.i == 0x02000000) ||
2571 (iptr->sx.val.i == 0x04000000) ||
2572 (iptr->sx.val.i == 0x08000000) ||
2573 (iptr->sx.val.i == 0x10000000) ||
2574 (iptr->sx.val.i == 0x20000000) ||
2575 (iptr->sx.val.i == 0x40000000) ||
2576 (iptr->sx.val.i == 0x80000000))
2578 iptr->opc = ICMD_IREMPOW2;
2579 iptr->sx.val.i -= 1;
2580 goto icmd_iconst_tail;
2583 #if SUPPORT_CONST_LOGICAL
2585 iptr->opc = ICMD_IANDCONST;
2586 goto icmd_iconst_tail;
2589 iptr->opc = ICMD_IORCONST;
2590 goto icmd_iconst_tail;
2593 iptr->opc = ICMD_IXORCONST;
2594 goto icmd_iconst_tail;
2596 #endif /* SUPPORT_CONST_LOGICAL */
2598 iptr->opc = ICMD_ISHLCONST;
2599 goto icmd_iconst_tail;
2602 iptr->opc = ICMD_ISHRCONST;
2603 goto icmd_iconst_tail;
2606 iptr->opc = ICMD_IUSHRCONST;
2607 goto icmd_iconst_tail;
2608 #if SUPPORT_LONG_SHIFT
2610 iptr->opc = ICMD_LSHLCONST;
2611 goto icmd_lconst_tail;
2614 iptr->opc = ICMD_LSHRCONST;
2615 goto icmd_lconst_tail;
2618 iptr->opc = ICMD_LUSHRCONST;
2619 goto icmd_lconst_tail;
2620 #endif /* SUPPORT_LONG_SHIFT */
2621 case ICMD_IF_ICMPEQ:
2622 iptr[1].opc = ICMD_IFEQ;
2626 /* set the constant for the following icmd */
2627 iptr[1].sx.val.i = iptr->sx.val.i;
2629 /* this instruction becomes a nop */
2630 iptr->opc = ICMD_NOP;
2633 case ICMD_IF_ICMPLT:
2634 iptr[1].opc = ICMD_IFLT;
2635 goto icmd_if_icmp_tail;
2637 case ICMD_IF_ICMPLE:
2638 iptr[1].opc = ICMD_IFLE;
2639 goto icmd_if_icmp_tail;
2641 case ICMD_IF_ICMPNE:
2642 iptr[1].opc = ICMD_IFNE;
2643 goto icmd_if_icmp_tail;
2645 case ICMD_IF_ICMPGT:
2646 iptr[1].opc = ICMD_IFGT;
2647 goto icmd_if_icmp_tail;
2649 case ICMD_IF_ICMPGE:
2650 iptr[1].opc = ICMD_IFGE;
2651 goto icmd_if_icmp_tail;
2653 #if SUPPORT_CONST_STORE
2658 # if SUPPORT_CONST_STORE_ZERO_ONLY
2659 if (iptr->sx.val.i != 0)
2662 switch (iptr[1].opc) {
2664 iptr->opc = ICMD_IASTORECONST;
2665 iptr->flags.bits |= INS_FLAG_CHECK;
2668 iptr->opc = ICMD_BASTORECONST;
2669 iptr->flags.bits |= INS_FLAG_CHECK;
2672 iptr->opc = ICMD_CASTORECONST;
2673 iptr->flags.bits |= INS_FLAG_CHECK;
2676 iptr->opc = ICMD_SASTORECONST;
2677 iptr->flags.bits |= INS_FLAG_CHECK;
2681 iptr[1].opc = ICMD_NOP;
2683 /* copy the constant to s3 */
2684 /* XXX constval -> astoreconstval? */
2685 iptr->sx.s23.s3.constval = iptr->sx.val.i;
2686 OP2_0(TYPE_ADR, TYPE_INT);
2687 COUNT(count_pcmd_op);
2690 case ICMD_PUTSTATIC:
2692 # if SUPPORT_CONST_STORE_ZERO_ONLY
2693 if (iptr->sx.val.i != 0)
2696 /* XXX check field type? */
2698 /* copy the constant to s2 */
2699 /* XXX constval -> fieldconstval? */
2700 iptr->sx.s23.s2.constval = iptr->sx.val.i;
2703 /* set the field reference (s3) */
2704 if (iptr[1].flags.bits & INS_FLAG_UNRESOLVED) {
2705 iptr->sx.s23.s3.uf = iptr[1].sx.s23.s3.uf;
2706 iptr->flags.bits |= INS_FLAG_UNRESOLVED;
2707 fmiref = iptr->sx.s23.s3.uf->fieldref;
2710 fmiref = iptr[1].sx.s23.s3.fmiref;
2711 iptr->sx.s23.s3.fmiref = fmiref;
2714 #if defined(ENABLE_VERIFIER)
2715 expectedtype = fmiref->parseddesc.fd->type;
2716 switch (iptr[0].opc) {
2718 if (expectedtype != TYPE_INT)
2719 goto throw_stack_type_error;
2722 if (expectedtype != TYPE_LNG)
2723 goto throw_stack_type_error;
2726 if (expectedtype != TYPE_ADR)
2727 goto throw_stack_type_error;
2732 #endif /* defined(ENABLE_VERIFIER) */
2734 switch (iptr[1].opc) {
2735 case ICMD_PUTSTATIC:
2736 iptr->opc = ICMD_PUTSTATICCONST;
2740 iptr->opc = ICMD_PUTFIELDCONST;
2745 iptr[1].opc = ICMD_NOP;
2746 COUNT(count_pcmd_op);
2748 #endif /* SUPPORT_CONST_STORE */
2754 /* if we get here, the ICONST has been optimized */
2758 /* normal case of an unoptimized ICONST */
2762 /************************** LCONST OPTIMIZATIONS **************************/
2765 COUNT(count_pcmd_load);
2769 /* switch depending on the following instruction */
2771 switch (iptr[1].opc) {
2772 #if SUPPORT_LONG_ADD
2774 iptr->opc = ICMD_LADDCONST;
2778 /* instruction of type LONG -> LONG */
2779 iptr[1].opc = ICMD_NOP;
2780 OP1_1(TYPE_LNG, TYPE_LNG);
2781 COUNT(count_pcmd_op);
2785 iptr->opc = ICMD_LSUBCONST;
2786 goto icmd_lconst_tail;
2788 #endif /* SUPPORT_LONG_ADD */
2789 #if SUPPORT_LONG_MUL && SUPPORT_CONST_MUL
2791 iptr->opc = ICMD_LMULCONST;
2792 goto icmd_lconst_tail;
2793 #else /* SUPPORT_LONG_MUL && SUPPORT_CONST_MUL */
2794 # if SUPPORT_LONG_SHIFT
2796 if (iptr->sx.val.l == 0x00000002)
2798 else if (iptr->sx.val.l == 0x00000004)
2800 else if (iptr->sx.val.l == 0x00000008)
2802 else if (iptr->sx.val.l == 0x00000010)
2804 else if (iptr->sx.val.l == 0x00000020)
2806 else if (iptr->sx.val.l == 0x00000040)
2808 else if (iptr->sx.val.l == 0x00000080)
2810 else if (iptr->sx.val.l == 0x00000100)
2812 else if (iptr->sx.val.l == 0x00000200)
2814 else if (iptr->sx.val.l == 0x00000400)
2815 iptr->sx.val.i = 10;
2816 else if (iptr->sx.val.l == 0x00000800)
2817 iptr->sx.val.i = 11;
2818 else if (iptr->sx.val.l == 0x00001000)
2819 iptr->sx.val.i = 12;
2820 else if (iptr->sx.val.l == 0x00002000)
2821 iptr->sx.val.i = 13;
2822 else if (iptr->sx.val.l == 0x00004000)
2823 iptr->sx.val.i = 14;
2824 else if (iptr->sx.val.l == 0x00008000)
2825 iptr->sx.val.i = 15;
2826 else if (iptr->sx.val.l == 0x00010000)
2827 iptr->sx.val.i = 16;
2828 else if (iptr->sx.val.l == 0x00020000)
2829 iptr->sx.val.i = 17;
2830 else if (iptr->sx.val.l == 0x00040000)
2831 iptr->sx.val.i = 18;
2832 else if (iptr->sx.val.l == 0x00080000)
2833 iptr->sx.val.i = 19;
2834 else if (iptr->sx.val.l == 0x00100000)
2835 iptr->sx.val.i = 20;
2836 else if (iptr->sx.val.l == 0x00200000)
2837 iptr->sx.val.i = 21;
2838 else if (iptr->sx.val.l == 0x00400000)
2839 iptr->sx.val.i = 22;
2840 else if (iptr->sx.val.l == 0x00800000)
2841 iptr->sx.val.i = 23;
2842 else if (iptr->sx.val.l == 0x01000000)
2843 iptr->sx.val.i = 24;
2844 else if (iptr->sx.val.l == 0x02000000)
2845 iptr->sx.val.i = 25;
2846 else if (iptr->sx.val.l == 0x04000000)
2847 iptr->sx.val.i = 26;
2848 else if (iptr->sx.val.l == 0x08000000)
2849 iptr->sx.val.i = 27;
2850 else if (iptr->sx.val.l == 0x10000000)
2851 iptr->sx.val.i = 28;
2852 else if (iptr->sx.val.l == 0x20000000)
2853 iptr->sx.val.i = 29;
2854 else if (iptr->sx.val.l == 0x40000000)
2855 iptr->sx.val.i = 30;
2856 else if (iptr->sx.val.l == 0x80000000)
2857 iptr->sx.val.i = 31;
2861 iptr->opc = ICMD_LMULPOW2;
2862 goto icmd_lconst_tail;
2863 # endif /* SUPPORT_LONG_SHIFT */
2864 #endif /* SUPPORT_LONG_MUL && SUPPORT_CONST_MUL */
2865 #if SUPPORT_LONG_DIV_POW2
2867 if (iptr->sx.val.l == 0x00000002)
2869 else if (iptr->sx.val.l == 0x00000004)
2871 else if (iptr->sx.val.l == 0x00000008)
2873 else if (iptr->sx.val.l == 0x00000010)
2875 else if (iptr->sx.val.l == 0x00000020)
2877 else if (iptr->sx.val.l == 0x00000040)
2879 else if (iptr->sx.val.l == 0x00000080)
2881 else if (iptr->sx.val.l == 0x00000100)
2883 else if (iptr->sx.val.l == 0x00000200)
2885 else if (iptr->sx.val.l == 0x00000400)
2886 iptr->sx.val.i = 10;
2887 else if (iptr->sx.val.l == 0x00000800)
2888 iptr->sx.val.i = 11;
2889 else if (iptr->sx.val.l == 0x00001000)
2890 iptr->sx.val.i = 12;
2891 else if (iptr->sx.val.l == 0x00002000)
2892 iptr->sx.val.i = 13;
2893 else if (iptr->sx.val.l == 0x00004000)
2894 iptr->sx.val.i = 14;
2895 else if (iptr->sx.val.l == 0x00008000)
2896 iptr->sx.val.i = 15;
2897 else if (iptr->sx.val.l == 0x00010000)
2898 iptr->sx.val.i = 16;
2899 else if (iptr->sx.val.l == 0x00020000)
2900 iptr->sx.val.i = 17;
2901 else if (iptr->sx.val.l == 0x00040000)
2902 iptr->sx.val.i = 18;
2903 else if (iptr->sx.val.l == 0x00080000)
2904 iptr->sx.val.i = 19;
2905 else if (iptr->sx.val.l == 0x00100000)
2906 iptr->sx.val.i = 20;
2907 else if (iptr->sx.val.l == 0x00200000)
2908 iptr->sx.val.i = 21;
2909 else if (iptr->sx.val.l == 0x00400000)
2910 iptr->sx.val.i = 22;
2911 else if (iptr->sx.val.l == 0x00800000)
2912 iptr->sx.val.i = 23;
2913 else if (iptr->sx.val.l == 0x01000000)
2914 iptr->sx.val.i = 24;
2915 else if (iptr->sx.val.l == 0x02000000)
2916 iptr->sx.val.i = 25;
2917 else if (iptr->sx.val.l == 0x04000000)
2918 iptr->sx.val.i = 26;
2919 else if (iptr->sx.val.l == 0x08000000)
2920 iptr->sx.val.i = 27;
2921 else if (iptr->sx.val.l == 0x10000000)
2922 iptr->sx.val.i = 28;
2923 else if (iptr->sx.val.l == 0x20000000)
2924 iptr->sx.val.i = 29;
2925 else if (iptr->sx.val.l == 0x40000000)
2926 iptr->sx.val.i = 30;
2927 else if (iptr->sx.val.l == 0x80000000)
2928 iptr->sx.val.i = 31;
2932 iptr->opc = ICMD_LDIVPOW2;
2933 goto icmd_lconst_tail;
2934 #endif /* SUPPORT_LONG_DIV_POW2 */
2936 #if SUPPORT_LONG_REM_POW2
2938 if ((iptr->sx.val.l == 0x00000002) ||
2939 (iptr->sx.val.l == 0x00000004) ||
2940 (iptr->sx.val.l == 0x00000008) ||
2941 (iptr->sx.val.l == 0x00000010) ||
2942 (iptr->sx.val.l == 0x00000020) ||
2943 (iptr->sx.val.l == 0x00000040) ||
2944 (iptr->sx.val.l == 0x00000080) ||
2945 (iptr->sx.val.l == 0x00000100) ||
2946 (iptr->sx.val.l == 0x00000200) ||
2947 (iptr->sx.val.l == 0x00000400) ||
2948 (iptr->sx.val.l == 0x00000800) ||
2949 (iptr->sx.val.l == 0x00001000) ||
2950 (iptr->sx.val.l == 0x00002000) ||
2951 (iptr->sx.val.l == 0x00004000) ||
2952 (iptr->sx.val.l == 0x00008000) ||
2953 (iptr->sx.val.l == 0x00010000) ||
2954 (iptr->sx.val.l == 0x00020000) ||
2955 (iptr->sx.val.l == 0x00040000) ||
2956 (iptr->sx.val.l == 0x00080000) ||
2957 (iptr->sx.val.l == 0x00100000) ||
2958 (iptr->sx.val.l == 0x00200000) ||
2959 (iptr->sx.val.l == 0x00400000) ||
2960 (iptr->sx.val.l == 0x00800000) ||
2961 (iptr->sx.val.l == 0x01000000) ||
2962 (iptr->sx.val.l == 0x02000000) ||
2963 (iptr->sx.val.l == 0x04000000) ||
2964 (iptr->sx.val.l == 0x08000000) ||
2965 (iptr->sx.val.l == 0x10000000) ||
2966 (iptr->sx.val.l == 0x20000000) ||
2967 (iptr->sx.val.l == 0x40000000) ||
2968 (iptr->sx.val.l == 0x80000000))
2970 iptr->opc = ICMD_LREMPOW2;
2971 iptr->sx.val.l -= 1;
2972 goto icmd_lconst_tail;
2975 #endif /* SUPPORT_LONG_REM_POW2 */
2977 #if SUPPORT_LONG_LOGICAL && SUPPORT_CONST_LOGICAL
2980 iptr->opc = ICMD_LANDCONST;
2981 goto icmd_lconst_tail;
2984 iptr->opc = ICMD_LORCONST;
2985 goto icmd_lconst_tail;
2988 iptr->opc = ICMD_LXORCONST;
2989 goto icmd_lconst_tail;
2990 #endif /* SUPPORT_LONG_LOGICAL && SUPPORT_CONST_LOGICAL */
2992 #if SUPPORT_LONG_CMP_CONST
2994 if ((len <= 1) || (iptr[2].sx.val.i != 0))
2997 /* switch on the instruction after LCONST - LCMP */
2999 switch (iptr[2].opc) {
3001 iptr->opc = ICMD_IF_LEQ;
3004 icmd_lconst_lcmp_tail:
3005 /* convert LCONST, LCMP, IFXX to IF_LXX */
3006 iptr->dst.block = iptr[2].dst.block;
3007 iptr[1].opc = ICMD_NOP;
3008 iptr[2].opc = ICMD_NOP;
3010 OP1_BRANCH(TYPE_LNG);
3012 COUNT(count_pcmd_bra);
3013 COUNT(count_pcmd_op);
3017 iptr->opc = ICMD_IF_LNE;
3018 goto icmd_lconst_lcmp_tail;
3021 iptr->opc = ICMD_IF_LLT;
3022 goto icmd_lconst_lcmp_tail;
3025 iptr->opc = ICMD_IF_LGT;
3026 goto icmd_lconst_lcmp_tail;
3029 iptr->opc = ICMD_IF_LLE;
3030 goto icmd_lconst_lcmp_tail;
3033 iptr->opc = ICMD_IF_LGE;
3034 goto icmd_lconst_lcmp_tail;
3038 } /* end switch on opcode after LCONST - LCMP */
3040 #endif /* SUPPORT_LONG_CMP_CONST */
3042 #if SUPPORT_CONST_STORE
3044 # if SUPPORT_CONST_STORE_ZERO_ONLY
3045 if (iptr->sx.val.l != 0)
3048 #if SIZEOF_VOID_P == 4
3049 /* the constant must fit into a ptrint */
3050 if (iptr->sx.val.l < -0x80000000L || iptr->sx.val.l >= 0x80000000L)
3053 /* move the constant to s3 */
3054 iptr->sx.s23.s3.constval = iptr->sx.val.l;
3056 iptr->opc = ICMD_LASTORECONST;
3057 iptr->flags.bits |= INS_FLAG_CHECK;
3058 OP2_0(TYPE_ADR, TYPE_INT);
3060 iptr[1].opc = ICMD_NOP;
3061 COUNT(count_pcmd_op);
3064 case ICMD_PUTSTATIC:
3066 # if SUPPORT_CONST_STORE_ZERO_ONLY
3067 if (iptr->sx.val.l != 0)
3070 #if SIZEOF_VOID_P == 4
3071 /* the constant must fit into a ptrint */
3072 if (iptr->sx.val.l < -0x80000000L || iptr->sx.val.l >= 0x80000000L)
3075 /* XXX check field type? */
3077 /* copy the constant to s2 */
3078 /* XXX constval -> fieldconstval? */
3079 iptr->sx.s23.s2.constval = iptr->sx.val.l;
3083 #endif /* SUPPORT_CONST_STORE */
3087 } /* end switch opcode after LCONST */
3089 /* if we get here, the LCONST has been optimized */
3093 /* the normal case of an unoptimized LCONST */
3097 /************************ END OF LCONST OPTIMIZATIONS *********************/
3100 COUNT(count_pcmd_load);
3105 COUNT(count_pcmd_load);
3109 /************************** ACONST OPTIMIZATIONS **************************/
3112 coalescing_boundary = sd.new;
3113 COUNT(count_pcmd_load);
3114 #if SUPPORT_CONST_STORE
3115 /* We can only optimize if the ACONST is resolved
3116 * and there is an instruction after it. */
3118 if ((len == 0) || (iptr->flags.bits & INS_FLAG_UNRESOLVED))
3121 switch (iptr[1].opc) {
3123 /* We can only optimize for NULL values
3124 * here because otherwise a checkcast is
3126 if (iptr->sx.val.anyptr != NULL)
3129 /* copy the constant (NULL) to s3 */
3130 iptr->sx.s23.s3.constval = 0;
3131 iptr->opc = ICMD_AASTORECONST;
3132 iptr->flags.bits |= INS_FLAG_CHECK;
3133 OP2_0(TYPE_ADR, TYPE_INT);
3135 iptr[1].opc = ICMD_NOP;
3136 COUNT(count_pcmd_op);
3139 case ICMD_PUTSTATIC:
3141 # if SUPPORT_CONST_STORE_ZERO_ONLY
3142 if (iptr->sx.val.anyptr != NULL)
3145 /* XXX check field type? */
3146 /* copy the constant to s2 */
3147 /* XXX constval -> fieldconstval? */
3148 iptr->sx.s23.s2.constval = (ptrint) iptr->sx.val.anyptr;
3156 /* if we get here the ACONST has been optimized */
3160 #endif /* SUPPORT_CONST_STORE */
3165 /* pop 0 push 1 load */
3172 COUNT(count_load_instruction);
3173 i = opcode - ICMD_ILOAD; /* type */
3175 j = iptr->s1.varindex =
3176 jd->local_map[iptr->s1.varindex * 5 + i];
3178 #if defined(ENABLE_VERIFIER)
3179 if (sd.var[j].type == TYPE_RET) {
3180 exceptions_throw_verifyerror(m, "forbidden load of returnAddress");
3185 #if defined(ENABLE_SSA)
3187 GET_NEW_VAR(sd, new_index, i);
3204 coalescing_boundary = sd.new;
3205 iptr->flags.bits |= INS_FLAG_CHECK;
3206 COUNT(count_check_null);
3207 COUNT(count_check_bound);
3208 COUNT(count_pcmd_mem);
3209 OP2_1(TYPE_ADR, TYPE_INT, opcode - ICMD_IALOAD);
3216 coalescing_boundary = sd.new;
3217 iptr->flags.bits |= INS_FLAG_CHECK;
3218 COUNT(count_check_null);
3219 COUNT(count_check_bound);
3220 COUNT(count_pcmd_mem);
3221 OP2_1(TYPE_ADR, TYPE_INT, TYPE_INT);
3224 /* pop 0 push 0 iinc */
3227 STATISTICS_STACKDEPTH_DISTRIBUTION(count_store_depth);
3228 #if defined(ENABLE_SSA)
3231 jd->local_map[iptr->s1.varindex * 5 +TYPE_INT];
3235 last_store_boundary[iptr->s1.varindex] = sd.new;
3238 jd->local_map[iptr->s1.varindex * 5 + TYPE_INT];
3243 if ((copy->varkind == LOCALVAR) &&
3244 (copy->varnum == iptr->s1.varindex))
3246 assert(IS_LOCALVAR(copy));
3252 #if defined(ENABLE_SSA)
3256 iptr->dst.varindex = iptr->s1.varindex;
3259 /* pop 1 push 0 store */
3268 i = opcode - ICMD_ISTORE; /* type */
3269 javaindex = iptr->dst.varindex;
3270 j = iptr->dst.varindex =
3271 jd->local_map[javaindex * 5 + i];
3273 COPY_VAL_AND_TYPE(sd, curstack->varnum, j);
3275 iptr->sx.s23.s3.javaindex = javaindex;
3277 if (curstack->type == TYPE_RET) {
3278 iptr->flags.bits |= INS_FLAG_RETADDR;
3279 iptr->sx.s23.s2.retaddrnr =
3280 UNUSED - (1 + sd.var[j].vv.retaddr->nr);
3281 sd.javalocals[javaindex] = iptr->sx.s23.s2.retaddrnr;
3284 sd.javalocals[javaindex] = j;
3286 /* invalidate the following javalocal for 2-word types */
3288 if (IS_2_WORD_TYPE(i)) {
3289 sd.javalocals[javaindex+1] = UNUSED;
3290 iptr->flags.bits |= INS_FLAG_KILL_NEXT;
3293 /* invalidate 2-word types if second half was overwritten */
3295 if (javaindex > 0 && (i = sd.javalocals[javaindex-1]) != UNUSED) {
3296 if (IS_2_WORD_TYPE(sd.var[i].type)) {
3297 sd.javalocals[javaindex-1] = UNUSED;
3298 iptr->flags.bits |= INS_FLAG_KILL_PREV;
3302 #if defined(ENABLE_STATISTICS)
3305 i = sd.new - curstack;
3307 count_store_length[20]++;
3309 count_store_length[i]++;
3312 count_store_depth[10]++;
3314 count_store_depth[i]++;
3318 #if defined(ENABLE_SSA)
3321 /* check for conflicts as described in Figure 5.2 */
3323 copy = curstack->prev;
3326 if ((copy->varkind == LOCALVAR) &&
3327 (copy->varnum == j))
3329 copy->varkind = TEMPVAR;
3330 assert(IS_LOCALVAR(copy));
3337 /* if the variable is already coalesced, don't bother */
3339 /* We do not need to check against INOUT, as invars */
3340 /* are always before the coalescing boundary. */
3342 if (curstack->varkind == LOCALVAR)
3345 /* there is no STORE Lj while curstack is live */
3347 if (curstack < last_store_boundary[javaindex])
3348 goto assume_conflict;
3350 /* curstack must be after the coalescing boundary */
3352 if (curstack < coalescing_boundary)
3353 goto assume_conflict;
3355 /* there is no DEF LOCALVAR(j) while curstack is live */
3357 copy = sd.new; /* most recent stackslot created + 1 */
3358 while (--copy > curstack) {
3359 if (copy->varkind == LOCALVAR && copy->varnum == j)
3360 goto assume_conflict;
3363 /* coalesce the temporary variable with Lj */
3364 assert((curstack->varkind == TEMPVAR)
3365 || (curstack->varkind == UNDEFVAR));
3366 assert(!IS_LOCALVAR(curstack)); /* XXX correct? */
3367 assert(!IS_INOUT(curstack));
3368 assert(!IS_PREALLOC(curstack));
3370 assert(curstack->creator);
3371 assert(curstack->creator->dst.varindex == curstack->varnum);
3372 assert(!(curstack->flags & PASSTHROUGH));
3373 RELEASE_INDEX(sd, curstack);
3374 curstack->varkind = LOCALVAR;
3375 curstack->varnum = j;
3376 curstack->creator->dst.varindex = j;
3379 /* revert the coalescing, if it has been done earlier */
3381 if ((curstack->varkind == LOCALVAR)
3382 && (curstack->varnum == j))
3384 assert(IS_LOCALVAR(curstack));
3385 SET_TEMPVAR(curstack);
3388 /* remember the stack boundary at this store */
3390 last_store_boundary[javaindex] = sd.new;
3391 #if defined(ENABLE_SSA)
3392 } /* if (ls != NULL) */
3395 if (opcode == ICMD_ASTORE && curstack->type == TYPE_RET)
3398 STORE(opcode - ICMD_ISTORE, j);
3404 coalescing_boundary = sd.new;
3405 iptr->flags.bits |= INS_FLAG_CHECK;
3406 COUNT(count_check_null);
3407 COUNT(count_check_bound);
3408 COUNT(count_pcmd_mem);
3410 bte = builtintable_get_internal(BUILTIN_canstore);
3413 if (md->memuse > rd->memuse)
3414 rd->memuse = md->memuse;
3415 if (md->argintreguse > rd->argintreguse)
3416 rd->argintreguse = md->argintreguse;
3417 /* XXX non-leaf method? */
3419 /* make all stack variables saved */
3423 sd.var[copy->varnum].flags |= SAVEDVAR;
3424 /* in case copy->varnum is/will be a LOCALVAR */
3425 /* once and set back to a non LOCALVAR */
3426 /* the correct SAVEDVAR flag has to be */
3427 /* remembered in copy->flags, too */
3428 copy->flags |= SAVEDVAR;
3432 OP3_0(TYPE_ADR, TYPE_INT, TYPE_ADR);
3439 coalescing_boundary = sd.new;
3440 iptr->flags.bits |= INS_FLAG_CHECK;
3441 COUNT(count_check_null);
3442 COUNT(count_check_bound);
3443 COUNT(count_pcmd_mem);
3444 OP3_0(TYPE_ADR, TYPE_INT, opcode - ICMD_IASTORE);
3451 coalescing_boundary = sd.new;
3452 iptr->flags.bits |= INS_FLAG_CHECK;
3453 COUNT(count_check_null);
3454 COUNT(count_check_bound);
3455 COUNT(count_pcmd_mem);
3456 OP3_0(TYPE_ADR, TYPE_INT, TYPE_INT);
3462 #ifdef ENABLE_VERIFIER
3465 if (IS_2_WORD_TYPE(curstack->type))
3466 goto throw_stack_category_error;
3477 coalescing_boundary = sd.new;
3478 /* Assert here that no LOCAL or INOUTS get */
3479 /* preallocated, since tha macros are not */
3480 /* available in md-abi.c! */
3481 if (IS_TEMPVAR(curstack))
3482 md_return_alloc(jd, curstack);
3483 COUNT(count_pcmd_return);
3484 OP1_0(opcode - ICMD_IRETURN);
3485 superblockend = true;
3486 sd.jd->returncount++;
3487 sd.jd->returnblock = sd.bptr;
3491 coalescing_boundary = sd.new;
3492 COUNT(count_check_null);
3494 curstack = NULL; stackdepth = 0;
3495 superblockend = true;
3498 case ICMD_PUTSTATIC:
3499 coalescing_boundary = sd.new;
3500 COUNT(count_pcmd_mem);
3501 INSTRUCTION_GET_FIELDREF(iptr, fmiref);
3502 OP1_0(fmiref->parseddesc.fd->type);
3505 /* pop 1 push 0 branch */
3508 case ICMD_IFNONNULL:
3509 COUNT(count_pcmd_bra);
3510 OP1_BRANCH(TYPE_ADR);
3520 COUNT(count_pcmd_bra);
3521 /* iptr->sx.val.i is set implicitly in parse by
3522 clearing the memory or from IF_ICMPxx
3525 OP1_BRANCH(TYPE_INT);
3526 /* iptr->sx.val.i = 0; */
3530 /* pop 0 push 0 branch */
3533 COUNT(count_pcmd_bra);
3536 superblockend = true;
3539 /* pop 1 push 0 table branch */
3541 case ICMD_TABLESWITCH:
3542 COUNT(count_pcmd_table);
3543 OP1_BRANCH(TYPE_INT);
3545 table = iptr->dst.table;
3546 BRANCH_TARGET(*table, tbptr);
3549 i = iptr->sx.s23.s3.tablehigh
3550 - iptr->sx.s23.s2.tablelow + 1;
3553 BRANCH_TARGET(*table, tbptr);
3556 superblockend = true;
3559 /* pop 1 push 0 table branch */
3561 case ICMD_LOOKUPSWITCH:
3562 COUNT(count_pcmd_table);
3563 OP1_BRANCH(TYPE_INT);
3565 BRANCH_TARGET(iptr->sx.s23.s3.lookupdefault, tbptr);
3567 lookup = iptr->dst.lookup;
3569 i = iptr->sx.s23.s2.lookupcount;
3572 BRANCH_TARGET(lookup->target, tbptr);
3575 superblockend = true;
3578 case ICMD_MONITORENTER:
3579 case ICMD_MONITOREXIT:
3580 coalescing_boundary = sd.new;
3581 COUNT(count_check_null);
3585 /* pop 2 push 0 branch */
3587 case ICMD_IF_ICMPEQ:
3588 case ICMD_IF_ICMPNE:
3589 case ICMD_IF_ICMPLT:
3590 case ICMD_IF_ICMPGE:
3591 case ICMD_IF_ICMPGT:
3592 case ICMD_IF_ICMPLE:
3593 COUNT(count_pcmd_bra);
3594 OP2_BRANCH(TYPE_INT, TYPE_INT);
3598 case ICMD_IF_ACMPEQ:
3599 case ICMD_IF_ACMPNE:
3600 COUNT(count_pcmd_bra);
3601 OP2_BRANCH(TYPE_ADR, TYPE_ADR);
3608 coalescing_boundary = sd.new;
3609 COUNT(count_check_null);
3610 COUNT(count_pcmd_mem);
3611 INSTRUCTION_GET_FIELDREF(iptr, fmiref);
3612 OP2_0(TYPE_ADR, fmiref->parseddesc.fd->type);
3617 if (!IS_2_WORD_TYPE(curstack->type)) {
3619 #ifdef ENABLE_VERIFIER
3622 if (IS_2_WORD_TYPE(curstack->prev->type))
3623 goto throw_stack_category_error;
3626 OP2_0_ANY_ANY; /* pop two slots */
3629 iptr->opc = ICMD_POP;
3630 OP1_0_ANY; /* pop one (two-word) slot */
3634 /* pop 0 push 1 dup */
3637 #ifdef ENABLE_VERIFIER
3640 if (IS_2_WORD_TYPE(curstack->type))
3641 goto throw_stack_category_error;
3644 COUNT(count_dup_instruction);
3650 coalescing_boundary = sd.new - 1;
3655 if (IS_2_WORD_TYPE(curstack->type)) {
3657 iptr->opc = ICMD_DUP;
3662 /* ..., ????, cat1 */
3663 #ifdef ENABLE_VERIFIER
3665 if (IS_2_WORD_TYPE(curstack->prev->type))
3666 goto throw_stack_category_error;
3669 src1 = curstack->prev;
3672 COPY_UP(src1); iptr++; len--;
3675 coalescing_boundary = sd.new;
3679 /* pop 2 push 3 dup */
3682 #ifdef ENABLE_VERIFIER
3685 if (IS_2_WORD_TYPE(curstack->type) ||
3686 IS_2_WORD_TYPE(curstack->prev->type))
3687 goto throw_stack_category_error;
3692 src1 = curstack->prev;
3697 /* move non-temporary sources out of the way */
3698 if (!IS_TEMPVAR(src2)) {
3699 MOVE_TO_TEMP(src2); iptr++; len--;
3702 DUP_SLOT(src2); dst1 = curstack; stackdepth++;
3704 MOVE_UP(src1); iptr++; len--;
3705 MOVE_UP(src2); iptr++; len--;
3707 COPY_DOWN(curstack, dst1);
3709 coalescing_boundary = sd.new;
3714 if (IS_2_WORD_TYPE(curstack->type)) {
3715 /* ..., ????, cat2 */
3716 #ifdef ENABLE_VERIFIER
3718 if (IS_2_WORD_TYPE(curstack->prev->type))
3719 goto throw_stack_category_error;
3722 iptr->opc = ICMD_DUP_X1;
3726 /* ..., ????, cat1 */
3727 #ifdef ENABLE_VERIFIER
3730 if (IS_2_WORD_TYPE(curstack->prev->type)
3731 || IS_2_WORD_TYPE(curstack->prev->prev->type))
3732 goto throw_stack_category_error;
3737 src1 = curstack->prev->prev;
3738 src2 = curstack->prev;
3740 POPANY; POPANY; POPANY;
3743 /* move non-temporary sources out of the way */
3744 if (!IS_TEMPVAR(src2)) {
3745 MOVE_TO_TEMP(src2); iptr++; len--;
3747 if (!IS_TEMPVAR(src3)) {
3748 MOVE_TO_TEMP(src3); iptr++; len--;
3751 DUP_SLOT(src2); dst1 = curstack; stackdepth++;
3752 DUP_SLOT(src3); dst2 = curstack; stackdepth++;
3754 MOVE_UP(src1); iptr++; len--;
3755 MOVE_UP(src2); iptr++; len--;
3756 MOVE_UP(src3); iptr++; len--;
3758 COPY_DOWN(curstack, dst2); iptr++; len--;
3759 COPY_DOWN(curstack->prev, dst1);
3761 coalescing_boundary = sd.new;
3765 /* pop 3 push 4 dup */
3769 if (IS_2_WORD_TYPE(curstack->prev->type)) {
3770 /* ..., cat2, ???? */
3771 #ifdef ENABLE_VERIFIER
3773 if (IS_2_WORD_TYPE(curstack->type))
3774 goto throw_stack_category_error;
3777 iptr->opc = ICMD_DUP_X1;
3781 /* ..., cat1, ???? */
3782 #ifdef ENABLE_VERIFIER
3785 if (IS_2_WORD_TYPE(curstack->type)
3786 || IS_2_WORD_TYPE(curstack->prev->prev->type))
3787 goto throw_stack_category_error;
3791 src1 = curstack->prev->prev;
3792 src2 = curstack->prev;
3794 POPANY; POPANY; POPANY;
3797 /* move non-temporary sources out of the way */
3798 if (!IS_TEMPVAR(src2)) {
3799 MOVE_TO_TEMP(src2); iptr++; len--;
3801 if (!IS_TEMPVAR(src3)) {
3802 MOVE_TO_TEMP(src3); iptr++; len--;
3805 DUP_SLOT(src3); dst1 = curstack; stackdepth++;
3807 MOVE_UP(src1); iptr++; len--;
3808 MOVE_UP(src2); iptr++; len--;
3809 MOVE_UP(src3); iptr++; len--;
3811 COPY_DOWN(curstack, dst1);
3813 coalescing_boundary = sd.new;
3819 if (IS_2_WORD_TYPE(curstack->type)) {
3820 /* ..., ????, cat2 */
3821 if (IS_2_WORD_TYPE(curstack->prev->type)) {
3822 /* ..., cat2, cat2 */
3823 iptr->opc = ICMD_DUP_X1;
3827 /* ..., cat1, cat2 */
3828 #ifdef ENABLE_VERIFIER
3831 if (IS_2_WORD_TYPE(curstack->prev->prev->type))
3832 goto throw_stack_category_error;
3835 iptr->opc = ICMD_DUP_X2;
3841 /* ..., ????, ????, cat1 */
3843 if (IS_2_WORD_TYPE(curstack->prev->prev->type)) {
3844 /* ..., cat2, ????, cat1 */
3845 #ifdef ENABLE_VERIFIER
3847 if (IS_2_WORD_TYPE(curstack->prev->type))
3848 goto throw_stack_category_error;
3851 iptr->opc = ICMD_DUP2_X1;
3855 /* ..., cat1, ????, cat1 */
3856 #ifdef ENABLE_VERIFIER
3859 if (IS_2_WORD_TYPE(curstack->prev->type)
3860 || IS_2_WORD_TYPE(curstack->prev->prev->prev->type))
3861 goto throw_stack_category_error;
3865 src1 = curstack->prev->prev->prev;
3866 src2 = curstack->prev->prev;
3867 src3 = curstack->prev;
3869 POPANY; POPANY; POPANY; POPANY;
3872 /* move non-temporary sources out of the way */
3873 if (!IS_TEMPVAR(src2)) {
3874 MOVE_TO_TEMP(src2); iptr++; len--;
3876 if (!IS_TEMPVAR(src3)) {
3877 MOVE_TO_TEMP(src3); iptr++; len--;
3879 if (!IS_TEMPVAR(src4)) {
3880 MOVE_TO_TEMP(src4); iptr++; len--;
3883 DUP_SLOT(src3); dst1 = curstack; stackdepth++;
3884 DUP_SLOT(src4); dst2 = curstack; stackdepth++;
3886 MOVE_UP(src1); iptr++; len--;
3887 MOVE_UP(src2); iptr++; len--;
3888 MOVE_UP(src3); iptr++; len--;
3889 MOVE_UP(src4); iptr++; len--;
3891 COPY_DOWN(curstack, dst2); iptr++; len--;
3892 COPY_DOWN(curstack->prev, dst1);
3894 coalescing_boundary = sd.new;
3898 /* pop 2 push 2 swap */
3901 #ifdef ENABLE_VERIFIER
3904 if (IS_2_WORD_TYPE(curstack->type)
3905 || IS_2_WORD_TYPE(curstack->prev->type))
3906 goto throw_stack_category_error;
3910 src1 = curstack->prev;
3915 /* move non-temporary sources out of the way */
3916 if (!IS_TEMPVAR(src1)) {
3917 MOVE_TO_TEMP(src1); iptr++; len--;
3920 MOVE_UP(src2); iptr++; len--;
3923 coalescing_boundary = sd.new;
3930 coalescing_boundary = sd.new;
3931 #if !SUPPORT_DIVISION
3932 bte = iptr->sx.s23.s3.bte;
3935 if (md->memuse > rd->memuse)
3936 rd->memuse = md->memuse;
3937 if (md->argintreguse > rd->argintreguse)
3938 rd->argintreguse = md->argintreguse;
3940 /* make all stack variables saved */
3944 sd.var[copy->varnum].flags |= SAVEDVAR;
3945 copy->flags |= SAVEDVAR;
3950 #endif /* !SUPPORT_DIVISION */
3961 COUNT(count_pcmd_op);
3962 OP2_1(TYPE_INT, TYPE_INT, TYPE_INT);
3967 coalescing_boundary = sd.new;
3968 #if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV)
3969 bte = iptr->sx.s23.s3.bte;
3972 if (md->memuse > rd->memuse)
3973 rd->memuse = md->memuse;
3974 if (md->argintreguse > rd->argintreguse)
3975 rd->argintreguse = md->argintreguse;
3976 /* XXX non-leaf method? */
3978 /* make all stack variables saved */
3982 sd.var[copy->varnum].flags |= SAVEDVAR;
3983 copy->flags |= SAVEDVAR;
3988 #endif /* !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV) */
3993 #if SUPPORT_LONG_LOGICAL
3997 #endif /* SUPPORT_LONG_LOGICAL */
3998 COUNT(count_pcmd_op);
3999 OP2_1(TYPE_LNG, TYPE_LNG, TYPE_LNG);
4005 COUNT(count_pcmd_op);
4006 OP2_1(TYPE_LNG, TYPE_INT, TYPE_LNG);
4014 COUNT(count_pcmd_op);
4015 OP2_1(TYPE_FLT, TYPE_FLT, TYPE_FLT);
4023 COUNT(count_pcmd_op);
4024 OP2_1(TYPE_DBL, TYPE_DBL, TYPE_DBL);
4028 COUNT(count_pcmd_op);
4029 #if SUPPORT_LONG_CMP_CONST
4030 if ((len == 0) || (iptr[1].sx.val.i != 0))
4033 switch (iptr[1].opc) {
4035 iptr->opc = ICMD_IF_LCMPEQ;
4037 iptr->dst.block = iptr[1].dst.block;
4038 iptr[1].opc = ICMD_NOP;
4040 OP2_BRANCH(TYPE_LNG, TYPE_LNG);
4043 COUNT(count_pcmd_bra);
4046 iptr->opc = ICMD_IF_LCMPNE;
4047 goto icmd_lcmp_if_tail;
4049 iptr->opc = ICMD_IF_LCMPLT;
4050 goto icmd_lcmp_if_tail;
4052 iptr->opc = ICMD_IF_LCMPGT;
4053 goto icmd_lcmp_if_tail;
4055 iptr->opc = ICMD_IF_LCMPLE;
4056 goto icmd_lcmp_if_tail;
4058 iptr->opc = ICMD_IF_LCMPGE;
4059 goto icmd_lcmp_if_tail;
4065 #endif /* SUPPORT_LONG_CMP_CONST */
4066 OP2_1(TYPE_LNG, TYPE_LNG, TYPE_INT);
4069 /* XXX why is this deactivated? */
4072 COUNT(count_pcmd_op);
4073 if ((len == 0) || (iptr[1].sx.val.i != 0))
4076 switch (iptr[1].opc) {
4078 iptr->opc = ICMD_IF_FCMPEQ;
4080 iptr->dst.block = iptr[1].dst.block;
4081 iptr[1].opc = ICMD_NOP;
4083 OP2_BRANCH(TYPE_FLT, TYPE_FLT);
4086 COUNT(count_pcmd_bra);
4089 iptr->opc = ICMD_IF_FCMPNE;
4090 goto icmd_if_fcmpl_tail;
4092 iptr->opc = ICMD_IF_FCMPL_LT;
4093 goto icmd_if_fcmpl_tail;
4095 iptr->opc = ICMD_IF_FCMPL_GT;
4096 goto icmd_if_fcmpl_tail;
4098 iptr->opc = ICMD_IF_FCMPL_LE;
4099 goto icmd_if_fcmpl_tail;
4101 iptr->opc = ICMD_IF_FCMPL_GE;
4102 goto icmd_if_fcmpl_tail;
4109 OPTT2_1(TYPE_FLT, TYPE_FLT, TYPE_INT);
4113 COUNT(count_pcmd_op);
4114 if ((len == 0) || (iptr[1].sx.val.i != 0))
4117 switch (iptr[1].opc) {
4119 iptr->opc = ICMD_IF_FCMPEQ;
4121 iptr->dst.block = iptr[1].dst.block;
4122 iptr[1].opc = ICMD_NOP;
4124 OP2_BRANCH(TYPE_FLT, TYPE_FLT);
4127 COUNT(count_pcmd_bra);
4130 iptr->opc = ICMD_IF_FCMPNE;
4131 goto icmd_if_fcmpg_tail;
4133 iptr->opc = ICMD_IF_FCMPG_LT;
4134 goto icmd_if_fcmpg_tail;
4136 iptr->opc = ICMD_IF_FCMPG_GT;
4137 goto icmd_if_fcmpg_tail;
4139 iptr->opc = ICMD_IF_FCMPG_LE;
4140 goto icmd_if_fcmpg_tail;
4142 iptr->opc = ICMD_IF_FCMPG_GE;
4143 goto icmd_if_fcmpg_tail;
4150 OP2_1(TYPE_FLT, TYPE_FLT, TYPE_INT);
4154 COUNT(count_pcmd_op);
4155 if ((len == 0) || (iptr[1].sx.val.i != 0))
4158 switch (iptr[1].opc) {
4160 iptr->opc = ICMD_IF_DCMPEQ;
4162 iptr->dst.block = iptr[1].dst.block;
4163 iptr[1].opc = ICMD_NOP;
4165 OP2_BRANCH(TYPE_DBL, TYPE_DBL);
4168 COUNT(count_pcmd_bra);
4171 iptr->opc = ICMD_IF_DCMPNE;
4172 goto icmd_if_dcmpl_tail;
4174 iptr->opc = ICMD_IF_DCMPL_LT;
4175 goto icmd_if_dcmpl_tail;
4177 iptr->opc = ICMD_IF_DCMPL_GT;
4178 goto icmd_if_dcmpl_tail;
4180 iptr->opc = ICMD_IF_DCMPL_LE;
4181 goto icmd_if_dcmpl_tail;
4183 iptr->opc = ICMD_IF_DCMPL_GE;
4184 goto icmd_if_dcmpl_tail;
4191 OPTT2_1(TYPE_DBL, TYPE_INT);
4195 COUNT(count_pcmd_op);
4196 if ((len == 0) || (iptr[1].sx.val.i != 0))
4199 switch (iptr[1].opc) {
4201 iptr->opc = ICMD_IF_DCMPEQ;
4203 iptr->dst.block = iptr[1].dst.block;
4204 iptr[1].opc = ICMD_NOP;
4206 OP2_BRANCH(TYPE_DBL, TYPE_DBL);
4209 COUNT(count_pcmd_bra);
4212 iptr->opc = ICMD_IF_DCMPNE;
4213 goto icmd_if_dcmpg_tail;
4215 iptr->opc = ICMD_IF_DCMPG_LT;
4216 goto icmd_if_dcmpg_tail;
4218 iptr->opc = ICMD_IF_DCMPG_GT;
4219 goto icmd_if_dcmpg_tail;
4221 iptr->opc = ICMD_IF_DCMPG_LE;
4222 goto icmd_if_dcmpg_tail;
4224 iptr->opc = ICMD_IF_DCMPG_GE;
4225 goto icmd_if_dcmpg_tail;
4232 OP2_1(TYPE_DBL, TYPE_DBL, TYPE_INT);
4237 COUNT(count_pcmd_op);
4238 OP2_1(TYPE_FLT, TYPE_FLT, TYPE_INT);
4243 COUNT(count_pcmd_op);
4244 OP2_1(TYPE_DBL, TYPE_DBL, TYPE_INT);
4253 case ICMD_INT2SHORT:
4254 COUNT(count_pcmd_op);
4255 OP1_1(TYPE_INT, TYPE_INT);
4258 COUNT(count_pcmd_op);
4259 OP1_1(TYPE_LNG, TYPE_LNG);
4262 COUNT(count_pcmd_op);
4263 OP1_1(TYPE_FLT, TYPE_FLT);
4266 COUNT(count_pcmd_op);
4267 OP1_1(TYPE_DBL, TYPE_DBL);
4271 COUNT(count_pcmd_op);
4272 OP1_1(TYPE_INT, TYPE_LNG);
4275 COUNT(count_pcmd_op);
4276 OP1_1(TYPE_INT, TYPE_FLT);
4279 COUNT(count_pcmd_op);
4280 OP1_1(TYPE_INT, TYPE_DBL);
4283 COUNT(count_pcmd_op);
4284 OP1_1(TYPE_LNG, TYPE_INT);
4287 COUNT(count_pcmd_op);
4288 OP1_1(TYPE_LNG, TYPE_FLT);
4291 COUNT(count_pcmd_op);
4292 OP1_1(TYPE_LNG, TYPE_DBL);
4295 COUNT(count_pcmd_op);
4296 OP1_1(TYPE_FLT, TYPE_INT);
4299 COUNT(count_pcmd_op);
4300 OP1_1(TYPE_FLT, TYPE_LNG);
4303 COUNT(count_pcmd_op);
4304 OP1_1(TYPE_FLT, TYPE_DBL);
4307 COUNT(count_pcmd_op);
4308 OP1_1(TYPE_DBL, TYPE_INT);
4311 COUNT(count_pcmd_op);
4312 OP1_1(TYPE_DBL, TYPE_LNG);
4315 COUNT(count_pcmd_op);
4316 OP1_1(TYPE_DBL, TYPE_FLT);
4319 case ICMD_CHECKCAST:
4320 coalescing_boundary = sd.new;
4321 if (iptr->flags.bits & INS_FLAG_ARRAY) {
4322 /* array type cast-check */
4324 bte = builtintable_get_internal(BUILTIN_arraycheckcast);
4327 if (md->memuse > rd->memuse)
4328 rd->memuse = md->memuse;
4329 if (md->argintreguse > rd->argintreguse)
4330 rd->argintreguse = md->argintreguse;
4332 /* make all stack variables saved */
4336 sd.var[copy->varnum].flags |= SAVEDVAR;
4337 copy->flags |= SAVEDVAR;
4341 OP1_1(TYPE_ADR, TYPE_ADR);
4344 case ICMD_INSTANCEOF:
4345 case ICMD_ARRAYLENGTH:
4346 coalescing_boundary = sd.new;
4347 OP1_1(TYPE_ADR, TYPE_INT);
4351 case ICMD_ANEWARRAY:
4352 coalescing_boundary = sd.new;
4353 OP1_1(TYPE_INT, TYPE_ADR);
4357 coalescing_boundary = sd.new;
4358 COUNT(count_check_null);
4359 COUNT(count_pcmd_mem);
4360 INSTRUCTION_GET_FIELDREF(iptr, fmiref);
4361 OP1_1(TYPE_ADR, fmiref->parseddesc.fd->type);
4366 case ICMD_GETSTATIC:
4367 coalescing_boundary = sd.new;
4368 COUNT(count_pcmd_mem);
4369 INSTRUCTION_GET_FIELDREF(iptr, fmiref);
4370 OP0_1(fmiref->parseddesc.fd->type);
4374 coalescing_boundary = sd.new;
4381 tbptr = iptr->sx.s23.s3.jsrtarget.block;
4382 tbptr->type = BBTYPE_SBR;
4384 assert(sd.bptr->next); /* XXX exception */
4385 sd.var[curstack->varnum].vv.retaddr = sd.bptr->next;
4386 #if defined(ENABLE_VERIFIER)
4387 sd.var[curstack->varnum].SBRSTART = (void*) tbptr;
4390 tbptr = stack_mark_reached(&sd, tbptr, curstack, stackdepth);
4394 iptr->sx.s23.s3.jsrtarget.block = tbptr;
4396 /* We need to check for overflow right here because
4397 * the pushed value is poped afterwards */
4400 superblockend = true;
4401 /* XXX should not be marked as interface, as it does not need to be */
4402 /* allocated. Same for the invar of the target. */
4405 /* pop many push any */
4409 bte = iptr->sx.s23.s3.bte;
4413 case ICMD_INVOKESTATIC:
4414 case ICMD_INVOKESPECIAL:
4415 case ICMD_INVOKEVIRTUAL:
4416 case ICMD_INVOKEINTERFACE:
4417 COUNT(count_pcmd_met);
4419 /* Check for functions to replace with builtin
4422 if (builtintable_replace_function(iptr))
4425 INSTRUCTION_GET_METHODDESC(iptr, md);
4426 /* XXX resurrect this COUNT? */
4427 /* if (lm->flags & ACC_STATIC) */
4428 /* {COUNT(count_check_null);} */
4432 coalescing_boundary = sd.new;
4436 if (md->memuse > rd->memuse)
4437 rd->memuse = md->memuse;
4438 if (md->argintreguse > rd->argintreguse)
4439 rd->argintreguse = md->argintreguse;
4440 if (md->argfltreguse > rd->argfltreguse)
4441 rd->argfltreguse = md->argfltreguse;
4445 iptr->s1.argcount = stackdepth;
4446 iptr->sx.s23.s2.args = DMNEW(s4, stackdepth);
4449 for (i-- ; i >= 0; i--) {
4450 iptr->sx.s23.s2.args[i] = copy->varnum;
4452 /* do not change STACKVARs or LOCALVARS to ARGVAR*/
4453 /* -> won't help anyway */
4454 if (!(IS_INOUT(copy) || IS_LOCALVAR(copy))) {
4456 #if defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
4457 /* If we pass float arguments in integer argument registers, we
4458 * are not allowed to precolor them here. Floats have to be moved
4459 * to this regs explicitly in codegen().
4460 * Only arguments that are passed by stack anyway can be precolored
4461 * (michi 2005/07/24) */
4462 if (!(sd.var[copy->varnum].flags & SAVEDVAR) &&
4463 (!IS_FLT_DBL_TYPE(copy->type)
4464 || md->params[i].inmemory)) {
4466 if (!(sd.var[copy->varnum].flags & SAVEDVAR)) {
4471 if (md->params[i].inmemory) {
4472 sd.var[copy->varnum].vv.regoff =
4473 md->params[i].regoff;
4474 sd.var[copy->varnum].flags |=
4478 if (IS_FLT_DBL_TYPE(copy->type)) {
4479 #if defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
4480 assert(0); /* XXX is this assert ok? */
4482 sd.var[copy->varnum].vv.regoff =
4483 rd->argfltregs[md->params[i].regoff];
4484 #endif /* SUPPORT_PASS_FLOATARGS_IN_INTREGS */
4487 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
4488 if (IS_2_WORD_TYPE(copy->type))
4489 sd.var[copy->varnum].vv.regoff =
4490 PACK_REGS( rd->argintregs[GET_LOW_REG(md->params[i].regoff)],
4491 rd->argintregs[GET_HIGH_REG(md->params[i].regoff)]);
4494 #endif /* SUPPORT_COMBINE_INTEGER_REGISTERS */
4495 sd.var[copy->varnum].vv.regoff =
4496 rd->argintregs[md->params[i].regoff];
4504 /* deal with live-through stack slots "under" the */
4510 iptr->sx.s23.s2.args[i++] = copy->varnum;
4511 sd.var[copy->varnum].flags |= SAVEDVAR;
4512 copy->flags |= SAVEDVAR | PASSTHROUGH;
4516 /* pop the arguments */
4525 /* push the return value */
4527 if (md->returntype.type != TYPE_VOID) {
4528 GET_NEW_VAR(sd, new_index, md->returntype.type);
4529 DST(md->returntype.type, new_index);
4534 case ICMD_MULTIANEWARRAY:
4535 coalescing_boundary = sd.new;
4536 if (rd->argintreguse < MIN(3, INT_ARG_CNT))
4537 rd->argintreguse = MIN(3, INT_ARG_CNT);
4539 i = iptr->s1.argcount;
4543 iptr->sx.s23.s2.args = DMNEW(s4, i);
4545 #if defined(SPECIALMEMUSE)
4546 # if defined(__DARWIN__)
4547 if (rd->memuse < (i + INT_ARG_CNT +LA_SIZE_IN_POINTERS))
4548 rd->memuse = i + LA_SIZE_IN_POINTERS + INT_ARG_CNT;
4550 if (rd->memuse < (i + LA_SIZE_IN_POINTERS + 3))
4551 rd->memuse = i + LA_SIZE_IN_POINTERS + 3;
4554 # if defined(__I386__)
4555 if (rd->memuse < i + 3)
4556 rd->memuse = i + 3; /* n integer args spilled on stack */
4557 # elif defined(__MIPS__) && SIZEOF_VOID_P == 4
4558 if (rd->memuse < i + 2)
4559 rd->memuse = i + 2; /* 4*4 bytes callee save space */
4562 rd->memuse = i; /* n integer args spilled on stack */
4563 # endif /* defined(__I386__) */
4567 /* check INT type here? Currently typecheck does this. */
4568 iptr->sx.s23.s2.args[i] = copy->varnum;
4569 if (!(sd.var[copy->varnum].flags & SAVEDVAR)
4570 && (!IS_INOUT(copy))
4571 && (!IS_LOCALVAR(copy)) ) {
4572 copy->varkind = ARGVAR;
4573 sd.var[copy->varnum].flags |=
4574 INMEMORY & PREALLOC;
4575 #if defined(SPECIALMEMUSE)
4576 # if defined(__DARWIN__)
4577 sd.var[copy->varnum].vv.regoff = i +
4578 LA_SIZE_IN_POINTERS + INT_ARG_CNT;
4580 sd.var[copy->varnum].vv.regoff = i +
4581 LA_SIZE_IN_POINTERS + 3;
4584 # if defined(__I386__)
4585 sd.var[copy->varnum].vv.regoff = i + 3;
4586 # elif defined(__MIPS__) && SIZEOF_VOID_P == 4
4587 sd.var[copy->varnum].vv.regoff = i + 2;
4589 sd.var[copy->varnum].vv.regoff = i;
4590 # endif /* defined(__I386__) */
4591 #endif /* defined(SPECIALMEMUSE) */
4596 sd.var[copy->varnum].flags |= SAVEDVAR;
4597 copy->flags |= SAVEDVAR;
4601 i = iptr->s1.argcount;
4606 GET_NEW_VAR(sd, new_index, TYPE_ADR);
4607 DST(TYPE_ADR, new_index);
4612 exceptions_throw_internalerror("Unknown ICMD %d during stack analysis",
4619 } /* while instructions */
4621 /* show state after last instruction */
4623 #if defined(STACK_VERBOSE)
4624 stack_verbose_show_state(&sd, NULL, curstack);
4627 /* stack slots at basic block end become interfaces */
4629 sd.bptr->outdepth = stackdepth;
4630 sd.bptr->outvars = DMNEW(s4, stackdepth);
4633 for (copy = curstack; copy; i--, copy = copy->prev) {
4637 /* with the new vars rd->interfaces will be removed */
4638 /* and all in and outvars have to be STACKVARS! */
4639 /* in the moment i.e. SWAP with in and out vars can */
4640 /* create an unresolvable conflict */
4645 v = sd.var + copy->varnum;
4648 /* do not allocate variables for returnAddresses */
4650 if (t != TYPE_RET) {
4651 if (jd->interface_map[i*5 + t].flags == UNUSED) {
4652 /* no interface var until now for this depth and */
4654 jd->interface_map[i*5 + t].flags = v->flags;
4657 jd->interface_map[i*5 + t].flags |= v->flags;
4661 sd.bptr->outvars[i] = copy->varnum;
4664 /* check if interface slots at basic block begin must be saved */
4666 for (i=0; i<sd.bptr->indepth; ++i) {
4667 varinfo *v = sd.var + sd.bptr->invars[i];
4672 if (t != TYPE_RET) {
4673 if (jd->interface_map[i*5 + t].flags == UNUSED) {
4674 /* no interface var until now for this depth and */
4676 jd->interface_map[i*5 + t].flags = v->flags;
4679 jd->interface_map[i*5 + t].flags |= v->flags;
4684 /* store the number of this block's variables */
4686 sd.bptr->varcount = sd.vartop - sd.bptr->varstart;
4688 #if defined(STACK_VERBOSE)
4689 stack_verbose_block_exit(&sd, superblockend);
4692 /* reach the following block, if any */
4695 if (!stack_reach_next_block(&sd))
4700 } while (sd.repeat && !deadcode);
4702 /* reset locals of TYPE_RET|VOID to TYPE_ADR */
4704 /* A local variable may be used as both a returnAddress and a reference */
4705 /* type variable, as we do not split variables between these types when */
4706 /* renaming locals. While returnAddresses have been eliminated now, we */
4707 /* must assume that the variable is still used as TYPE_ADR. */
4708 /* The only way that a local can be TYPE_VOID at this point, is that it */
4709 /* was a TYPE_RET variable for which incompatible returnAddresses were */
4710 /* merged. Thus we must treat TYPE_VOID in the same way as TYPE_RET */
4712 /* XXX: It would be nice to remove otherwise unused returnAddress */
4713 /* variables from the local variable array, so they are not */
4714 /* allocated by simplereg. (For LSRA this is not needed). */
4716 for (i=0; i<sd.localcount; ++i) {
4717 if (sd.var[i].type == TYPE_RET || sd.var[i].type == TYPE_VOID)
4718 sd.var[i].type = TYPE_ADR;
4721 /* mark temporaries of TYPE_RET as PREALLOC to avoid allocation */
4723 for (i=sd.localcount; i<sd.vartop; ++i) {
4724 if (sd.var[i].type == TYPE_RET)
4725 sd.var[i].flags |= PREALLOC;
4728 /* XXX hack to fix up the ranges of the cloned single-block handlers */
4730 ex = jd->exceptiontable;
4731 for (; ex != NULL; ex = ex->down) {
4732 if (ex->start == ex->end) {
4733 assert(ex->end->next);
4734 ex->end = ex->end->next;
4738 /* store number of created variables */
4740 jd->vartop = sd.vartop;
4742 /* gather statistics *****************************************************/
4744 #if defined(ENABLE_STATISTICS)
4746 if (jd->basicblockcount > count_max_basic_blocks)
4747 count_max_basic_blocks = jd->basicblockcount;
4748 count_basic_blocks += jd->basicblockcount;
4749 if (jd->instructioncount > count_max_javainstr)
4750 count_max_javainstr = jd->instructioncount;
4751 count_javainstr += jd->instructioncount;
4752 if (jd->stackcount > count_upper_bound_new_stack)
4753 count_upper_bound_new_stack = jd->stackcount;
4754 if ((sd.new - jd->stack) > count_max_new_stack)
4755 count_max_new_stack = (sd.new - jd->stack);
4757 sd.bptr = jd->basicblocks;
4758 for (; sd.bptr; sd.bptr = sd.bptr->next) {
4759 if (sd.bptr->flags > BBREACHED) {
4760 if (sd.bptr->indepth >= 10)
4761 count_block_stack[10]++;
4763 count_block_stack[sd.bptr->indepth]++;
4764 len = sd.bptr->icount;
4766 count_block_size_distribution[len]++;
4768 count_block_size_distribution[10]++;
4770 count_block_size_distribution[11]++;
4772 count_block_size_distribution[12]++;
4774 count_block_size_distribution[13]++;
4776 count_block_size_distribution[14]++;
4778 count_block_size_distribution[15]++;
4780 count_block_size_distribution[16]++;
4782 count_block_size_distribution[17]++;
4786 if (iteration_count == 1)
4787 count_analyse_iterations[0]++;
4788 else if (iteration_count == 2)
4789 count_analyse_iterations[1]++;
4790 else if (iteration_count == 3)
4791 count_analyse_iterations[2]++;
4792 else if (iteration_count == 4)
4793 count_analyse_iterations[3]++;
4795 count_analyse_iterations[4]++;
4797 if (jd->basicblockcount <= 5)
4798 count_method_bb_distribution[0]++;
4799 else if (jd->basicblockcount <= 10)
4800 count_method_bb_distribution[1]++;
4801 else if (jd->basicblockcount <= 15)
4802 count_method_bb_distribution[2]++;
4803 else if (jd->basicblockcount <= 20)
4804 count_method_bb_distribution[3]++;
4805 else if (jd->basicblockcount <= 30)
4806 count_method_bb_distribution[4]++;
4807 else if (jd->basicblockcount <= 40)
4808 count_method_bb_distribution[5]++;
4809 else if (jd->basicblockcount <= 50)
4810 count_method_bb_distribution[6]++;
4811 else if (jd->basicblockcount <= 75)
4812 count_method_bb_distribution[7]++;
4814 count_method_bb_distribution[8]++;
4816 #endif /* defined(ENABLE_STATISTICS) */
4818 /* everything's ok *******************************************************/
4822 /* goto labels for throwing verifier exceptions **************************/
4824 #if defined(ENABLE_VERIFIER)
4826 throw_stack_underflow:
4827 exceptions_throw_verifyerror(m, "Unable to pop operand off an empty stack");
4830 throw_stack_overflow:
4831 exceptions_throw_verifyerror(m, "Stack size too large");
4834 throw_stack_type_error:
4835 exceptions_throw_verifyerror_for_stack(m, expectedtype);
4838 throw_stack_category_error:
4839 exceptions_throw_verifyerror(m, "Attempt to split long or double on the stack");
4846 /* stack_javalocals_store ******************************************************
4848 Model the effect of a ?STORE instruction upon the given javalocals array.
4851 iptr.............the ?STORE instruction
4852 javalocals.......the javalocals array to modify
4854 *******************************************************************************/
4856 void stack_javalocals_store(instruction *iptr, s4 *javalocals)
4858 s4 idx; /* index into the jd->var array */
4859 s4 j; /* java local index */
4861 idx = iptr->dst.varindex;
4862 j = iptr->sx.s23.s3.javaindex;
4865 if (iptr->flags.bits & INS_FLAG_RETADDR)
4866 javalocals[j] = iptr->sx.s23.s2.retaddrnr;
4868 javalocals[j] = idx;
4870 if (iptr->flags.bits & INS_FLAG_KILL_PREV)
4871 javalocals[j-1] = UNUSED;
4873 if (iptr->flags.bits & INS_FLAG_KILL_NEXT)
4874 javalocals[j+1] = UNUSED;
4879 /* functions for verbose stack analysis output ********************************/
4881 #if defined(STACK_VERBOSE)
4882 static void stack_verbose_show_varinfo(stackdata_t *sd, varinfo *v)
4884 printf("%c", show_jit_type_letters[v->type]);
4885 if (v->type == TYPE_RET) {
4886 printf("{L%03d}", v->vv.retaddr->nr);
4887 #if defined(ENABLE_VERIFIER)
4888 printf("{start=L%03d}", ((basicblock *)v->SBRSTART)->nr);
4894 static void stack_verbose_show_variable(stackdata_t *sd, s4 index)
4896 assert(index >= 0 && index < sd->vartop);
4897 stack_verbose_show_varinfo(sd, sd->var + index);
4901 static void stack_verbose_show_block(stackdata_t *sd, basicblock *bptr)
4905 printf("L%03d type:%d in:%d [", bptr->nr, bptr->type, bptr->indepth);
4907 for (i=0; i<bptr->indepth; ++i) {
4910 stack_verbose_show_variable(sd, bptr->invars[i]);
4915 printf("] javalocals ");
4916 show_javalocals_array(sd->jd, sd->javalocals, sd->maxlocals, SHOW_STACK);
4917 printf(" inlocals [");
4918 if (bptr->inlocals) {
4919 for (i=0; i<sd->localcount; ++i) {
4922 stack_verbose_show_varinfo(sd, bptr->inlocals + i);
4927 printf("] out:%d [", bptr->outdepth);
4928 if (bptr->outvars) {
4929 for (i=0; i<bptr->outdepth; ++i) {
4932 stack_verbose_show_variable(sd, bptr->outvars[i]);
4940 printf(" (clone of L%03d)", bptr->original->nr);
4942 basicblock *b = bptr->copied_to;
4944 printf(" (copied to ");
4945 for (; b; b = b->copied_to)
4946 printf("L%03d ", b->nr);
4953 static void stack_verbose_block_enter(stackdata_t *sd, bool reanalyse)
4957 printf("======================================== STACK %sANALYSE BLOCK ",
4958 (reanalyse) ? ((sd->bptr->iinstr == NULL) ? "CLONE-" : "RE-") : "");
4959 stack_verbose_show_block(sd, sd->bptr);
4962 if (sd->handlers[0]) {
4963 printf("HANDLERS: ");
4964 for (i=0; sd->handlers[i]; ++i) {
4965 printf("L%03d ", sd->handlers[i]->handler->nr);
4973 static void stack_verbose_block_exit(stackdata_t *sd, bool superblockend)
4975 printf("%s ", (superblockend) ? "SUPERBLOCKEND" : "END");
4976 stack_verbose_show_block(sd, sd->bptr);
4980 static void stack_verbose_show_state(stackdata_t *sd, instruction *iptr, stackptr curstack)
4988 printf(" javalocals ");
4989 show_javalocals_array(sd->jd, sd->javalocals, sd->maxlocals, SHOW_STACK);
4992 for(i = 0, sp = curstack; sp; sp = sp->prev)
4996 stack = MNEW(stackptr, depth);
4997 for(sp = curstack; sp; sp = sp->prev)
5000 for(i=0; i<depth; ++i) {
5004 v = &(sd->var[sp->varnum]);
5006 if (v->flags & INOUT)
5008 if (v->flags & PREALLOC)
5010 printf("%d:%c", sp->varnum, show_jit_type_letters[sp->type]);
5011 if (v->type == TYPE_RET) {
5012 printf("(L%03d)", v->vv.retaddr->nr);
5017 show_icmd(sd->jd, iptr, false, SHOW_PARSE);
5024 * These are local overrides for various environment variables in Emacs.
5025 * Please do not remove this and leave it at the end of the file, where
5026 * Emacs will automagically detect them.
5027 * ---------------------------------------------------------------------
5030 * indent-tabs-mode: t
5034 * vim:noexpandtab:sw=4:ts=4: