1 /* -*- mode: c; tab-width: 4; c-basic-offset: 4 -*- */
2 /****************************** ncomp/nstack.c *********************************
4 Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
6 See file COPYRIGHT for information on usage and disclaimer of warranties
8 Parser for JavaVM to intermediate code translation
10 Authors: Andreas Krall EMAIL: cacao@complang.tuwien.ac.at
12 Last Change: 1997/11/18
14 *******************************************************************************/
16 #define CONDITIONAL_LOADCONST
19 #define COUNT(cnt) cnt++
24 #define STACKRESET {curstack=0;stackdepth=0;}
26 #define TYPEPANIC {show_icmd_method();panic("Stack type mismatch");}
27 #define CURKIND curstack->varkind
28 #define CURTYPE curstack->type
30 #define NEWSTACK(s,v,n) {new->prev=curstack;new->type=s;new->flags=0;\
31 new->varkind=v;new->varnum=n;curstack=new;new++;}
32 #define NEWSTACKn(s,n) NEWSTACK(s,UNDEFVAR,n)
33 #define NEWSTACK0(s) NEWSTACK(s,UNDEFVAR,0)
34 #define NEWXSTACK {NEWSTACK(TYPE_ADR,STACKVAR,0);curstack=0;}
36 #define SETDST {iptr->dst=curstack;}
37 #define POP(s) {if(s!=curstack->type){TYPEPANIC;}\
38 if(curstack->varkind==UNDEFVAR)curstack->varkind=TEMPVAR;\
39 curstack=curstack->prev;}
40 #define POPANY {if(curstack->varkind==UNDEFVAR)curstack->varkind=TEMPVAR;\
41 curstack=curstack->prev;}
42 #define COPY(s,d) {(d)->flags=0;(d)->type=(s)->type;\
43 (d)->varkind=(s)->varkind;(d)->varnum=(s)->varnum;}
45 #define CONST(s) {NEWSTACKn(s,stackdepth);SETDST;stackdepth++;}
46 #define LOAD(s,v,n) {NEWSTACK(s,v,n);SETDST;stackdepth++;}
47 #define STORE(s) {POP(s);SETDST;stackdepth--;}
48 #define OP1_0(s) {POP(s);SETDST;stackdepth--;}
49 #define OP1_0ANY {POPANY;SETDST;stackdepth--;}
50 #define OP0_1(s) {NEWSTACKn(s,stackdepth);SETDST;stackdepth++;}
51 #define OP1_1(s,d) {POP(s);NEWSTACKn(d,stackdepth-1);SETDST;}
52 #define OP2_0(s) {POP(s);POP(s);SETDST;stackdepth-=2;}
53 #define OPTT2_0(t,b){POP(t);POP(b);SETDST;stackdepth-=2;}
54 #define OP2_1(s) {POP(s);POP(s);NEWSTACKn(s,stackdepth-2);SETDST;stackdepth--;}
55 #define OP2IAT_1(s) {POP(TYPE_INT);POP(TYPE_ADR);NEWSTACKn(s,stackdepth-2);\
57 #define OP2IT_1(s) {POP(TYPE_INT);POP(s);NEWSTACKn(s,stackdepth-2);\
59 #define OPTT2_1(s,d){POP(s);POP(s);NEWSTACKn(d,stackdepth-2);SETDST;stackdepth--;}
60 #define OP2_2(s) {POP(s);POP(s);NEWSTACKn(s,stackdepth-2);\
61 NEWSTACKn(s,stackdepth-1);SETDST;}
62 #define OP3TIA_0(s) {POP(s);POP(TYPE_INT);POP(TYPE_ADR);SETDST;stackdepth-=3;}
63 #define OP3_0(s) {POP(s);POP(s);POP(s);SETDST;stackdepth-=3;}
64 #define POPMANY(i) {stackdepth-=i;while(--i>=0){POPANY;}SETDST;}
65 #define DUP {NEWSTACK(CURTYPE,CURKIND,curstack->varnum);SETDST;\
67 #define SWAP {COPY(curstack,new);POPANY;COPY(curstack,new+1);POPANY;\
68 new[0].prev=curstack;new[1].prev=new;\
69 curstack=new+1;new+=2;SETDST;}
70 #define DUP_X1 {COPY(curstack,new);COPY(curstack,new+2);POPANY;\
71 COPY(curstack,new+1);POPANY;new[0].prev=curstack;\
72 new[1].prev=new;new[2].prev=new+1;\
73 curstack=new+2;new+=3;SETDST;stackdepth++;}
74 #define DUP2_X1 {COPY(curstack,new+1);COPY(curstack,new+4);POPANY;\
75 COPY(curstack,new);COPY(curstack,new+3);POPANY;\
76 COPY(curstack,new+2);POPANY;new[0].prev=curstack;\
77 new[1].prev=new;new[2].prev=new+1;\
78 new[3].prev=new+2;new[4].prev=new+3;\
79 curstack=new+4;new+=5;SETDST;stackdepth+=2;}
80 #define DUP_X2 {COPY(curstack,new);COPY(curstack,new+3);POPANY;\
81 COPY(curstack,new+2);POPANY;COPY(curstack,new+1);POPANY;\
82 new[0].prev=curstack;new[1].prev=new;\
83 new[2].prev=new+1;new[3].prev=new+2;\
84 curstack=new+3;new+=4;SETDST;stackdepth++;}
85 #define DUP2_X2 {COPY(curstack,new+1);COPY(curstack,new+5);POPANY;\
86 COPY(curstack,new);COPY(curstack,new+4);POPANY;\
87 COPY(curstack,new+3);POPANY;COPY(curstack,new+2);POPANY;\
88 new[0].prev=curstack;new[1].prev=new;\
89 new[2].prev=new+1;new[3].prev=new+2;\
90 new[4].prev=new+3;new[5].prev=new+4;\
91 curstack=new+5;new+=6;SETDST;stackdepth+=2;}
93 #define COPYCURSTACK(copy) {\
106 copy->varkind=STACKVAR;\
122 if((copy->varkind==STACKVAR)&&(copy->varnum>i))\
123 copy->varkind=TEMPVAR;\
125 copy->varkind=STACKVAR;\
128 interfaces[i][copy->type].type = copy->type;\
129 interfaces[i][copy->type].flags |= copy->flags;\
130 i--;copy=copy->prev;\
135 interfaces[i][copy->type].type = copy->type;\
136 if(copy->varkind==STACKVAR){\
137 if (copy->flags & SAVEDVAR)\
138 interfaces[i][copy->type].flags |= SAVEDVAR;\
140 i--;copy=copy->prev;\
145 #define MARKREACHED(b,c) {\
147 {COPYCURSTACK(c);b->flags=0;b->instack=c;b->indepth=stackdepth;}\
148 else {stackptr s=curstack;stackptr t=b->instack;\
149 if(b->indepth!=stackdepth)\
150 {show_icmd_method();panic("Stack depth mismatch");}\
151 while(s){if (s->type!=t->type)\
153 s=s->prev;t=t->prev;\
159 static void show_icmd_method();
161 static void analyse_stack()
163 int b_count, b_index;
165 stackptr curstack, new, copy;
166 int opcode, i, len, loops;
167 int superblockend, repeat, deadcode;
168 instruction *iptr = instr;
169 basicblock *bptr, *tbptr;
175 block[0].flags = BBREACHED;
176 block[0].instack = 0;
177 block[0].indepth = 0;
179 for (i = 0; i < exceptiontablelength; i++) {
180 bptr = &block[block_index[extable[i].handlerpc]];
181 bptr->flags = BBREACHED;
182 bptr->type = BBTYPE_EXH;
185 bptr->pre_count = 10000;
190 #ifdef CONDITIONAL_LOADCONST
191 b_count = block_count;
193 while (--b_count >= 0) {
194 if (bptr->icount != 0) {
195 iptr = bptr->iinstr + bptr->icount - 1;
228 block[block_index[iptr->op1]].pre_count++;
231 case ICMD_TABLESWITCH:
233 block[block_index[*s4ptr++]].pre_count++; /* default */
234 i = *s4ptr++; /* low */
235 i = *s4ptr++ - i + 1; /* high */
237 block[block_index[*s4ptr++]].pre_count++;
241 case ICMD_LOOKUPSWITCH:
243 block[block_index[*s4ptr++]].pre_count++; /* default */
244 i = *s4ptr++; /* count */
246 block[block_index[s4ptr[1]]].pre_count++;
262 b_count = block_count;
264 superblockend = true;
268 while (--b_count >= 0) {
269 if (bptr->flags == BBDELETED) {
272 else if (superblockend && (bptr->flags < BBREACHED))
274 else if (bptr->flags <= BBREACHED) {
276 stackdepth = bptr->indepth;
277 else if (bptr->flags < BBREACHED) {
279 bptr->instack = copy;
280 bptr->indepth = stackdepth;
282 else if (bptr->indepth != stackdepth) {
284 panic("Stack depth mismatch");
287 curstack = bptr->instack;
289 superblockend = false;
290 bptr->flags = BBFINISHED;
293 b_index = bptr - block;
301 case ICMD_CHECKASIZE:
303 case ICMD_IFEQ_ICONST:
304 case ICMD_IFNE_ICONST:
305 case ICMD_IFLT_ICONST:
306 case ICMD_IFGE_ICONST:
307 case ICMD_IFGT_ICONST:
308 case ICMD_IFLE_ICONST:
309 case ICMD_ELSE_ICONST:
314 locals[iptr->op1][TYPE_ADR].type = TYPE_ADR;
316 COUNT(count_pcmd_return);
318 superblockend = true;
321 /* pop 0 push 1 const */
324 COUNT(count_pcmd_load);
326 switch (iptr[1].opc) {
328 iptr[0].opc = ICMD_IADDCONST;
330 iptr[1].opc = ICMD_NOP;
331 OP1_1(TYPE_INT,TYPE_INT);
332 COUNT(count_pcmd_op);
335 iptr[0].opc = ICMD_ISUBCONST;
336 goto icmd_iconst_tail;
338 iptr[0].opc = ICMD_IMULCONST;
339 goto icmd_iconst_tail;
341 if (iptr[0].val.i == 0x00000002)
343 else if (iptr[0].val.i == 0x00000004)
345 else if (iptr[0].val.i == 0x00000008)
347 else if (iptr[0].val.i == 0x00000010)
349 else if (iptr[0].val.i == 0x00000020)
351 else if (iptr[0].val.i == 0x00000040)
353 else if (iptr[0].val.i == 0x00000080)
355 else if (iptr[0].val.i == 0x00000100)
357 else if (iptr[0].val.i == 0x00000200)
359 else if (iptr[0].val.i == 0x00000400)
361 else if (iptr[0].val.i == 0x00000800)
363 else if (iptr[0].val.i == 0x00001000)
365 else if (iptr[0].val.i == 0x00002000)
367 else if (iptr[0].val.i == 0x00004000)
369 else if (iptr[0].val.i == 0x00008000)
371 else if (iptr[0].val.i == 0x00010000)
373 else if (iptr[0].val.i == 0x00020000)
375 else if (iptr[0].val.i == 0x00040000)
377 else if (iptr[0].val.i == 0x00080000)
379 else if (iptr[0].val.i == 0x00100000)
381 else if (iptr[0].val.i == 0x00200000)
383 else if (iptr[0].val.i == 0x00400000)
385 else if (iptr[0].val.i == 0x00800000)
387 else if (iptr[0].val.i == 0x01000000)
389 else if (iptr[0].val.i == 0x02000000)
391 else if (iptr[0].val.i == 0x04000000)
393 else if (iptr[0].val.i == 0x08000000)
395 else if (iptr[0].val.i == 0x10000000)
397 else if (iptr[0].val.i == 0x20000000)
399 else if (iptr[0].val.i == 0x40000000)
401 else if (iptr[0].val.i == 0x80000000)
407 iptr[0].opc = ICMD_IDIVPOW2;
408 goto icmd_iconst_tail;
410 if (iptr[0].val.i == 0x10001) {
411 iptr[0].opc = ICMD_IREM0X10001;
412 goto icmd_iconst_tail;
414 if ((iptr[0].val.i == 0x00000002) ||
415 (iptr[0].val.i == 0x00000004) ||
416 (iptr[0].val.i == 0x00000008) ||
417 (iptr[0].val.i == 0x00000010) ||
418 (iptr[0].val.i == 0x00000020) ||
419 (iptr[0].val.i == 0x00000040) ||
420 (iptr[0].val.i == 0x00000080) ||
421 (iptr[0].val.i == 0x00000100) ||
422 (iptr[0].val.i == 0x00000200) ||
423 (iptr[0].val.i == 0x00000400) ||
424 (iptr[0].val.i == 0x00000800) ||
425 (iptr[0].val.i == 0x00001000) ||
426 (iptr[0].val.i == 0x00002000) ||
427 (iptr[0].val.i == 0x00004000) ||
428 (iptr[0].val.i == 0x00008000) ||
429 (iptr[0].val.i == 0x00010000) ||
430 (iptr[0].val.i == 0x00020000) ||
431 (iptr[0].val.i == 0x00040000) ||
432 (iptr[0].val.i == 0x00080000) ||
433 (iptr[0].val.i == 0x00100000) ||
434 (iptr[0].val.i == 0x00200000) ||
435 (iptr[0].val.i == 0x00400000) ||
436 (iptr[0].val.i == 0x00800000) ||
437 (iptr[0].val.i == 0x01000000) ||
438 (iptr[0].val.i == 0x02000000) ||
439 (iptr[0].val.i == 0x04000000) ||
440 (iptr[0].val.i == 0x08000000) ||
441 (iptr[0].val.i == 0x10000000) ||
442 (iptr[0].val.i == 0x20000000) ||
443 (iptr[0].val.i == 0x40000000) ||
444 (iptr[0].val.i == 0x80000000)) {
445 iptr[0].opc = ICMD_IREMPOW2;
447 goto icmd_iconst_tail;
452 iptr[0].opc = ICMD_IANDCONST;
453 goto icmd_iconst_tail;
455 iptr[0].opc = ICMD_IORCONST;
456 goto icmd_iconst_tail;
458 iptr[0].opc = ICMD_IXORCONST;
459 goto icmd_iconst_tail;
461 iptr[0].opc = ICMD_ISHLCONST;
462 goto icmd_iconst_tail;
464 iptr[0].opc = ICMD_ISHRCONST;
465 goto icmd_iconst_tail;
467 iptr[0].opc = ICMD_IUSHRCONST;
468 goto icmd_iconst_tail;
470 iptr[0].opc = ICMD_IFEQ;
472 iptr[0].op1 = iptr[1].op1;
475 /* iptr[1].opc = ICMD_NOP; */
477 tbptr = block + block_index[iptr->op1];
478 MARKREACHED(tbptr, copy);
479 COUNT(count_pcmd_bra);
482 iptr[0].opc = ICMD_IFLT;
483 goto icmd_if_icmp_tail;
485 iptr[0].opc = ICMD_IFLE;
486 goto icmd_if_icmp_tail;
488 iptr[0].opc = ICMD_IFNE;
489 goto icmd_if_icmp_tail;
491 iptr[0].opc = ICMD_IFGT;
492 goto icmd_if_icmp_tail;
494 iptr[0].opc = ICMD_IFGE;
495 goto icmd_if_icmp_tail;
504 COUNT(count_pcmd_load);
506 switch (iptr[1].opc) {
508 iptr[0].opc = ICMD_LADDCONST;
510 iptr[1].opc = ICMD_NOP;
511 OP1_1(TYPE_LNG,TYPE_LNG);
512 COUNT(count_pcmd_op);
515 iptr[0].opc = ICMD_LSUBCONST;
516 goto icmd_lconst_tail;
518 iptr[0].opc = ICMD_LMULCONST;
519 goto icmd_lconst_tail;
521 if (iptr[0].val.l == 0x00000002)
523 else if (iptr[0].val.l == 0x00000004)
525 else if (iptr[0].val.l == 0x00000008)
527 else if (iptr[0].val.l == 0x00000010)
529 else if (iptr[0].val.l == 0x00000020)
531 else if (iptr[0].val.l == 0x00000040)
533 else if (iptr[0].val.l == 0x00000080)
535 else if (iptr[0].val.l == 0x00000100)
537 else if (iptr[0].val.l == 0x00000200)
539 else if (iptr[0].val.l == 0x00000400)
541 else if (iptr[0].val.l == 0x00000800)
543 else if (iptr[0].val.l == 0x00001000)
545 else if (iptr[0].val.l == 0x00002000)
547 else if (iptr[0].val.l == 0x00004000)
549 else if (iptr[0].val.l == 0x00008000)
551 else if (iptr[0].val.l == 0x00010000)
553 else if (iptr[0].val.l == 0x00020000)
555 else if (iptr[0].val.l == 0x00040000)
557 else if (iptr[0].val.l == 0x00080000)
559 else if (iptr[0].val.l == 0x00100000)
561 else if (iptr[0].val.l == 0x00200000)
563 else if (iptr[0].val.l == 0x00400000)
565 else if (iptr[0].val.l == 0x00800000)
567 else if (iptr[0].val.l == 0x01000000)
569 else if (iptr[0].val.l == 0x02000000)
571 else if (iptr[0].val.l == 0x04000000)
573 else if (iptr[0].val.l == 0x08000000)
575 else if (iptr[0].val.l == 0x10000000)
577 else if (iptr[0].val.l == 0x20000000)
579 else if (iptr[0].val.l == 0x40000000)
581 else if (iptr[0].val.l == 0x80000000)
587 iptr[0].opc = ICMD_LDIVPOW2;
588 goto icmd_lconst_tail;
590 if (iptr[0].val.l == 0x10001) {
591 iptr[0].opc = ICMD_LREM0X10001;
592 goto icmd_lconst_tail;
594 if ((iptr[0].val.l == 0x00000002) ||
595 (iptr[0].val.l == 0x00000004) ||
596 (iptr[0].val.l == 0x00000008) ||
597 (iptr[0].val.l == 0x00000010) ||
598 (iptr[0].val.l == 0x00000020) ||
599 (iptr[0].val.l == 0x00000040) ||
600 (iptr[0].val.l == 0x00000080) ||
601 (iptr[0].val.l == 0x00000100) ||
602 (iptr[0].val.l == 0x00000200) ||
603 (iptr[0].val.l == 0x00000400) ||
604 (iptr[0].val.l == 0x00000800) ||
605 (iptr[0].val.l == 0x00001000) ||
606 (iptr[0].val.l == 0x00002000) ||
607 (iptr[0].val.l == 0x00004000) ||
608 (iptr[0].val.l == 0x00008000) ||
609 (iptr[0].val.l == 0x00010000) ||
610 (iptr[0].val.l == 0x00020000) ||
611 (iptr[0].val.l == 0x00040000) ||
612 (iptr[0].val.l == 0x00080000) ||
613 (iptr[0].val.l == 0x00100000) ||
614 (iptr[0].val.l == 0x00200000) ||
615 (iptr[0].val.l == 0x00400000) ||
616 (iptr[0].val.l == 0x00800000) ||
617 (iptr[0].val.l == 0x01000000) ||
618 (iptr[0].val.l == 0x02000000) ||
619 (iptr[0].val.l == 0x04000000) ||
620 (iptr[0].val.l == 0x08000000) ||
621 (iptr[0].val.l == 0x10000000) ||
622 (iptr[0].val.l == 0x20000000) ||
623 (iptr[0].val.l == 0x40000000) ||
624 (iptr[0].val.l == 0x80000000)) {
625 iptr[0].opc = ICMD_LREMPOW2;
627 goto icmd_lconst_tail;
632 iptr[0].opc = ICMD_LANDCONST;
633 goto icmd_lconst_tail;
635 iptr[0].opc = ICMD_LORCONST;
636 goto icmd_lconst_tail;
638 iptr[0].opc = ICMD_LXORCONST;
639 goto icmd_lconst_tail;
641 iptr[0].opc = ICMD_LSHLCONST;
642 goto icmd_lconst_tail;
644 iptr[0].opc = ICMD_LSHRCONST;
645 goto icmd_lconst_tail;
647 iptr[0].opc = ICMD_LUSHRCONST;
648 goto icmd_lconst_tail;
650 if ((len > 1) && (iptr[2].val.i == 0)) {
651 switch (iptr[2].opc) {
653 iptr[0].opc = ICMD_IF_LEQ;
654 icmd_lconst_lcmp_tail:
655 iptr[0].op1 = iptr[2].op1;
658 /* iptr[1].opc = ICMD_NOP;
659 iptr[2].opc = ICMD_NOP; */
661 tbptr = block + block_index[iptr->op1];
662 MARKREACHED(tbptr, copy);
663 COUNT(count_pcmd_bra);
664 COUNT(count_pcmd_op);
667 iptr[0].opc = ICMD_IF_LNE;
668 goto icmd_lconst_lcmp_tail;
670 iptr[0].opc = ICMD_IF_LLT;
671 goto icmd_lconst_lcmp_tail;
673 iptr[0].opc = ICMD_IF_LGT;
674 goto icmd_lconst_lcmp_tail;
676 iptr[0].opc = ICMD_IF_LLE;
677 goto icmd_lconst_lcmp_tail;
679 iptr[0].opc = ICMD_IF_LGE;
680 goto icmd_lconst_lcmp_tail;
683 } /* switch (iptr[2].opc) */
684 } /* if (iptr[2].val.i == 0) */
696 COUNT(count_pcmd_load);
700 COUNT(count_pcmd_load);
704 COUNT(count_pcmd_load);
708 /* pop 0 push 1 load */
715 COUNT(count_load_instruction);
716 i = opcode-ICMD_ILOAD;
717 locals[iptr->op1][i].type = i;
718 LOAD(i, LOCALVAR, iptr->op1);
728 COUNT(count_check_null);
729 COUNT(count_check_bound);
730 COUNT(count_pcmd_mem);
731 OP2IAT_1(opcode-ICMD_IALOAD);
737 COUNT(count_check_null);
738 COUNT(count_check_bound);
739 COUNT(count_pcmd_mem);
743 /* pop 0 push 0 iinc */
749 count_store_depth[10]++;
751 count_store_depth[i]++;
756 if ((copy->varkind == LOCALVAR) &&
757 (copy->varnum == curstack->varnum)) {
758 copy->varkind = TEMPVAR;
767 /* pop 1 push 0 store */
774 i = opcode-ICMD_ISTORE;
775 locals[iptr->op1][i].type = i;
780 count_store_length[20]++;
782 count_store_length[i]++;
785 count_store_depth[10]++;
787 count_store_depth[i]++;
789 copy = curstack->prev;
792 if ((copy->varkind == LOCALVAR) &&
793 (copy->varnum == curstack->varnum)) {
794 copy->varkind = TEMPVAR;
800 if ((new - curstack) == 1) {
801 curstack->varkind = LOCALVAR;
802 curstack->varnum = iptr->op1;
804 STORE(opcode-ICMD_ISTORE);
814 COUNT(count_check_null);
815 COUNT(count_check_bound);
816 COUNT(count_pcmd_mem);
817 OP3TIA_0(opcode-ICMD_IASTORE);
822 COUNT(count_check_null);
823 COUNT(count_check_bound);
824 COUNT(count_pcmd_mem);
839 COUNT(count_pcmd_return);
840 OP1_0(opcode-ICMD_IRETURN);
841 superblockend = true;
845 COUNT(count_check_null);
849 superblockend = true;
853 COUNT(count_pcmd_mem);
857 /* pop 1 push 0 branch */
861 COUNT(count_pcmd_bra);
863 tbptr = block + block_index[iptr->op1];
864 MARKREACHED(tbptr, copy);
873 COUNT(count_pcmd_bra);
874 #ifdef CONDITIONAL_LOADCONST
876 tbptr = block + b_index;
877 if ((b_count >= 3) &&
878 ((b_index + 2) == block_index[iptr[0].op1]) &&
879 (tbptr[1].pre_count == 1) &&
880 (iptr[1].opc == ICMD_ICONST) &&
881 (iptr[2].opc == ICMD_GOTO) &&
882 ((b_index + 3) == block_index[iptr[2].op1]) &&
883 (tbptr[2].pre_count == 1) &&
884 (iptr[3].opc == ICMD_ICONST)) {
885 OP1_1(TYPE_INT, TYPE_INT);
886 switch (iptr[0].opc) {
888 iptr[0].opc = ICMD_IFNE_ICONST;
891 iptr[0].opc = ICMD_IFEQ_ICONST;
894 iptr[0].opc = ICMD_IFGE_ICONST;
897 iptr[0].opc = ICMD_IFLT_ICONST;
900 iptr[0].opc = ICMD_IFLE_ICONST;
903 iptr[0].opc = ICMD_IFGT_ICONST;
906 iptr[0].val.i = iptr[1].val.i;
907 iptr[1].opc = ICMD_ELSE_ICONST;
908 iptr[1].val.i = iptr[3].val.i;
909 iptr[2].opc = ICMD_NOP;
910 iptr[3].opc = ICMD_NOP;
911 tbptr[1].flags = BBDELETED;
912 tbptr[2].flags = BBDELETED;
915 if (tbptr[3].pre_count == 2) {
916 len += tbptr[3].icount + 3;
917 bptr->icount += tbptr[3].icount + 3;
918 tbptr[3].flags = BBDELETED;
932 tbptr = block + block_index[iptr->op1];
933 MARKREACHED(tbptr, copy);
936 /* pop 0 push 0 branch */
939 COUNT(count_pcmd_bra);
940 tbptr = block + block_index[iptr->op1];
941 MARKREACHED(tbptr, copy);
943 superblockend = true;
946 /* pop 1 push 0 table branch */
948 case ICMD_TABLESWITCH:
949 COUNT(count_pcmd_table);
952 tbptr = block + block_index[*s4ptr++]; /* default */
953 MARKREACHED(tbptr, copy);
954 i = *s4ptr++; /* low */
955 i = *s4ptr++ - i + 1; /* high */
957 tbptr = block + block_index[*s4ptr++];
958 MARKREACHED(tbptr, copy);
961 superblockend = true;
964 /* pop 1 push 0 table branch */
966 case ICMD_LOOKUPSWITCH:
967 COUNT(count_pcmd_table);
970 tbptr = block + block_index[*s4ptr++]; /* default */
971 MARKREACHED(tbptr, copy);
972 i = *s4ptr++; /* count */
974 tbptr = block + block_index[s4ptr[1]];
975 MARKREACHED(tbptr, copy);
979 superblockend = true;
982 case ICMD_NULLCHECKPOP:
983 case ICMD_MONITORENTER:
984 COUNT(count_check_null);
985 case ICMD_MONITOREXIT:
989 /* pop 2 push 0 branch */
997 COUNT(count_pcmd_bra);
999 tbptr = block + block_index[iptr->op1];
1000 MARKREACHED(tbptr, copy);
1003 case ICMD_IF_ACMPEQ:
1004 case ICMD_IF_ACMPNE:
1005 COUNT(count_pcmd_bra);
1007 tbptr = block + block_index[iptr->op1];
1008 MARKREACHED(tbptr, copy);
1014 COUNT(count_check_null);
1015 COUNT(count_pcmd_mem);
1016 OPTT2_0(iptr->op1,TYPE_ADR);
1020 if (! IS_2_WORD_TYPE(curstack->type)) {
1021 OP1_0ANY; /* second pop */
1024 iptr->opc = ICMD_POP;
1028 /* pop 0 push 1 dup */
1031 COUNT(count_dup_instruction);
1036 if (IS_2_WORD_TYPE(curstack->type)) {
1037 iptr->opc = ICMD_DUP;
1042 NEWSTACK(copy[-1].type, copy[-1].varkind,
1044 NEWSTACK(copy[ 0].type, copy[ 0].varkind,
1051 /* pop 2 push 3 dup */
1058 if (IS_2_WORD_TYPE(curstack->type)) {
1059 iptr->opc = ICMD_DUP_X1;
1067 /* pop 3 push 4 dup */
1070 if (IS_2_WORD_TYPE(curstack[-1].type)) {
1071 iptr->opc = ICMD_DUP_X1;
1080 if (IS_2_WORD_TYPE(curstack->type)) {
1081 if (IS_2_WORD_TYPE(curstack[-1].type)) {
1082 iptr->opc = ICMD_DUP_X1;
1086 iptr->opc = ICMD_DUP_X2;
1091 if (IS_2_WORD_TYPE(curstack[-2].type)) {
1092 iptr->opc = ICMD_DUP2_X1;
1100 /* pop 2 push 2 swap */
1109 if (!(SUPPORT_DIVISION)) {
1110 iptr[0].opc = ICMD_BUILTIN2;
1111 iptr[0].op1 = TYPE_INT;
1112 iptr[0].val.a = (functionptr) asm_builtin_idiv;
1113 isleafmethod = false;
1118 if (!(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV)) {
1119 iptr[0].opc = ICMD_BUILTIN2;
1120 iptr[0].op1 = TYPE_LNG;
1121 iptr[0].val.a = (functionptr) asm_builtin_ldiv;
1122 isleafmethod = false;
1127 if (!(SUPPORT_DIVISION)) {
1128 iptr[0].opc = ICMD_BUILTIN2;
1129 iptr[0].op1 = TYPE_INT;
1130 iptr[0].val.a = (functionptr) asm_builtin_irem;
1131 isleafmethod = false;
1136 if (!(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV)) {
1137 iptr[0].opc = ICMD_BUILTIN2;
1138 iptr[0].op1 = TYPE_LNG;
1139 iptr[0].val.a = (functionptr) asm_builtin_lrem;
1140 isleafmethod = false;
1154 COUNT(count_pcmd_op);
1165 COUNT(count_pcmd_op);
1172 COUNT(count_pcmd_op);
1181 COUNT(count_pcmd_op);
1190 COUNT(count_pcmd_op);
1195 COUNT(count_pcmd_op);
1196 if ((len > 0) && (iptr[1].val.i == 0)) {
1197 switch (iptr[1].opc) {
1199 iptr[0].opc = ICMD_IF_LCMPEQ;
1201 iptr[0].op1 = iptr[1].op1;
1204 /* iptr[1].opc = ICMD_NOP; */
1206 tbptr = block + block_index[iptr->op1];
1207 MARKREACHED(tbptr, copy);
1208 COUNT(count_pcmd_bra);
1211 iptr[0].opc = ICMD_IF_LCMPNE;
1212 goto icmd_lcmp_if_tail;
1214 iptr[0].opc = ICMD_IF_LCMPLT;
1215 goto icmd_lcmp_if_tail;
1217 iptr[0].opc = ICMD_IF_LCMPGT;
1218 goto icmd_lcmp_if_tail;
1220 iptr[0].opc = ICMD_IF_LCMPLE;
1221 goto icmd_lcmp_if_tail;
1223 iptr[0].opc = ICMD_IF_LCMPGE;
1224 goto icmd_lcmp_if_tail;
1226 OPTT2_1(TYPE_LNG, TYPE_INT);
1230 OPTT2_1(TYPE_LNG, TYPE_INT);
1234 COUNT(count_pcmd_op);
1235 OPTT2_1(TYPE_FLT, TYPE_INT);
1239 COUNT(count_pcmd_op);
1240 OPTT2_1(TYPE_DBL, TYPE_INT);
1248 case ICMD_INT2SHORT:
1249 COUNT(count_pcmd_op);
1250 OP1_1(TYPE_INT, TYPE_INT);
1253 COUNT(count_pcmd_op);
1254 OP1_1(TYPE_LNG, TYPE_LNG);
1257 COUNT(count_pcmd_op);
1258 OP1_1(TYPE_FLT, TYPE_FLT);
1261 COUNT(count_pcmd_op);
1262 OP1_1(TYPE_DBL, TYPE_DBL);
1266 COUNT(count_pcmd_op);
1267 OP1_1(TYPE_INT, TYPE_LNG);
1270 COUNT(count_pcmd_op);
1271 OP1_1(TYPE_INT, TYPE_FLT);
1274 COUNT(count_pcmd_op);
1275 OP1_1(TYPE_INT, TYPE_DBL);
1278 COUNT(count_pcmd_op);
1279 OP1_1(TYPE_LNG, TYPE_INT);
1282 COUNT(count_pcmd_op);
1283 OP1_1(TYPE_LNG, TYPE_FLT);
1286 COUNT(count_pcmd_op);
1287 OP1_1(TYPE_LNG, TYPE_DBL);
1290 COUNT(count_pcmd_op);
1291 OP1_1(TYPE_FLT, TYPE_INT);
1294 COUNT(count_pcmd_op);
1295 OP1_1(TYPE_FLT, TYPE_LNG);
1298 COUNT(count_pcmd_op);
1299 OP1_1(TYPE_FLT, TYPE_DBL);
1302 COUNT(count_pcmd_op);
1303 OP1_1(TYPE_DBL, TYPE_INT);
1306 COUNT(count_pcmd_op);
1307 OP1_1(TYPE_DBL, TYPE_LNG);
1310 COUNT(count_pcmd_op);
1311 OP1_1(TYPE_DBL, TYPE_FLT);
1314 case ICMD_CHECKCAST:
1315 OP1_1(TYPE_ADR, TYPE_ADR);
1318 case ICMD_ARRAYLENGTH:
1319 case ICMD_INSTANCEOF:
1320 OP1_1(TYPE_ADR, TYPE_INT);
1324 case ICMD_ANEWARRAY:
1325 OP1_1(TYPE_INT, TYPE_ADR);
1329 COUNT(count_check_null);
1330 COUNT(count_pcmd_mem);
1331 OP1_1(TYPE_ADR, iptr->op1);
1336 case ICMD_GETSTATIC:
1337 COUNT(count_pcmd_mem);
1347 tbptr = block + block_index[iptr->op1];
1348 tbptr->type=BBTYPE_SBR;
1349 MARKREACHED(tbptr, copy);
1353 /* pop many push any */
1355 case ICMD_INVOKEVIRTUAL:
1356 case ICMD_INVOKESPECIAL:
1357 case ICMD_INVOKEINTERFACE:
1358 case ICMD_INVOKESTATIC:
1359 COUNT(count_pcmd_met);
1361 methodinfo *m = iptr->val.a;
1362 if (m->flags & ACC_STATIC)
1363 {COUNT(count_check_null);}
1365 if (i > arguments_num)
1369 if (! (copy->flags & SAVEDVAR)) {
1370 copy->varkind = ARGVAR;
1376 copy->flags |= SAVEDVAR;
1381 if (m->returntype != TYPE_VOID) {
1382 OP0_1(m->returntype);
1388 if (! (curstack->flags & SAVEDVAR)) {
1389 curstack->varkind = ARGVAR;
1390 curstack->varnum = 2;
1395 if (! (curstack->flags & SAVEDVAR)) {
1396 curstack->varkind = ARGVAR;
1397 curstack->varnum = 1;
1401 if (! (curstack->flags & SAVEDVAR)) {
1402 curstack->varkind = ARGVAR;
1403 curstack->varnum = 0;
1408 copy->flags |= SAVEDVAR;
1411 if (iptr->op1 != TYPE_VOID)
1415 case ICMD_MULTIANEWARRAY:
1417 if ((i + intreg_argnum) > arguments_num)
1418 arguments_num = i + intreg_argnum;
1421 if (! (copy->flags & SAVEDVAR)) {
1422 copy->varkind = ARGVAR;
1423 copy->varnum = i + intreg_argnum;
1428 copy->flags |= SAVEDVAR;
1437 printf("ICMD %d at %d\n", iptr->opc, (int)(iptr-instr));
1438 panic("Missing ICMD code during stack analysis");
1441 } /* while instructions */
1442 bptr->outstack = curstack;
1443 bptr->outdepth = stackdepth;
1447 superblockend = true;
1449 } /* while blocks */
1450 } while (repeat && ! deadcode);
1453 if (block_count > count_max_basic_blocks)
1454 count_max_basic_blocks = block_count;
1455 count_basic_blocks += block_count;
1456 if ((block[block_count].iinstr - instr) > count_max_javainstr)
1457 count_max_javainstr = block[block_count].iinstr - instr;
1458 count_javainstr += block[block_count].iinstr - instr;
1459 if (stack_count > count_upper_bound_new_stack)
1460 count_upper_bound_new_stack = stack_count;
1461 if ((new - stack) > count_max_new_stack)
1462 count_max_new_stack = (new - stack);
1464 b_count = block_count;
1466 while (--b_count >= 0) {
1467 if (bptr->flags > BBREACHED) {
1468 if (bptr->indepth >= 10)
1469 count_block_stack[10]++;
1471 count_block_stack[bptr->indepth]++;
1474 count_block_size_distribution[len - 1]++;
1476 count_block_size_distribution[10]++;
1478 count_block_size_distribution[11]++;
1480 count_block_size_distribution[12]++;
1482 count_block_size_distribution[13]++;
1484 count_block_size_distribution[14]++;
1486 count_block_size_distribution[15]++;
1488 count_block_size_distribution[16]++;
1490 count_block_size_distribution[17]++;
1496 count_analyse_iterations[0]++;
1497 else if (loops == 2)
1498 count_analyse_iterations[1]++;
1499 else if (loops == 3)
1500 count_analyse_iterations[2]++;
1501 else if (loops == 4)
1502 count_analyse_iterations[3]++;
1504 count_analyse_iterations[4]++;
1506 if (block_count <= 5)
1507 count_method_bb_distribution[0]++;
1508 else if (block_count <= 10)
1509 count_method_bb_distribution[1]++;
1510 else if (block_count <= 15)
1511 count_method_bb_distribution[2]++;
1512 else if (block_count <= 20)
1513 count_method_bb_distribution[3]++;
1514 else if (block_count <= 30)
1515 count_method_bb_distribution[4]++;
1516 else if (block_count <= 40)
1517 count_method_bb_distribution[5]++;
1518 else if (block_count <= 50)
1519 count_method_bb_distribution[6]++;
1520 else if (block_count <= 75)
1521 count_method_bb_distribution[7]++;
1523 count_method_bb_distribution[8]++;
1528 static void print_stack(stackptr s) {
1544 if (s->flags & SAVEDVAR)
1545 switch (s->varkind) {
1547 if (s->flags & INMEMORY)
1548 printf(" m%02d", s->regoff);
1550 printf(" r%02d", s->regoff);
1553 printf(" s%02d", s->varnum);
1556 printf(" l%02d", s->varnum);
1559 printf(" a%02d", s->varnum);
1562 printf(" !%02d", j);
1565 switch (s->varkind) {
1567 if (s->flags & INMEMORY)
1568 printf(" M%02d", s->regoff);
1570 printf(" R%02d", s->regoff);
1573 printf(" S%02d", s->varnum);
1576 printf(" L%02d", s->varnum);
1579 printf(" A%02d", s->varnum);
1582 printf(" ?%02d", j);
1589 static void print_reg(stackptr s) {
1591 if (s->flags & SAVEDVAR)
1592 switch (s->varkind) {
1594 if (s->flags & INMEMORY)
1595 printf(" tm%02d", s->regoff);
1597 printf(" tr%02d", s->regoff);
1600 printf(" s %02d", s->varnum);
1603 printf(" l %02d", s->varnum);
1606 printf(" a %02d", s->varnum);
1609 printf(" ! %02d", s->varnum);
1612 switch (s->varkind) {
1614 if (s->flags & INMEMORY)
1615 printf(" Tm%02d", s->regoff);
1617 printf(" Tr%02d", s->regoff);
1620 printf(" S %02d", s->varnum);
1623 printf(" L %02d", s->varnum);
1626 printf(" A %02d", s->varnum);
1629 printf(" ? %02d", s->varnum);
1638 static char *builtin_name(functionptr bptr)
1640 builtin_descriptor *bdesc = builtin_desc;
1641 while ((bdesc->bptr != NULL) && (bdesc->bptr != bptr))
1647 static void show_icmd_method()
1655 unicode_fprint(stdout, class->name);
1657 unicode_fprint(stdout, method->name);
1659 unicode_fprint(stdout, method->descriptor);
1660 printf ("\n\nMax locals: %d\n", (int) maxlocals);
1661 printf ("Max stack: %d\n", (int) maxstack);
1663 printf ("Exceptions:\n");
1664 for (i = 0; i < exceptiontablelength; i++) {
1665 printf(" L%03d ... ", block_index[extable[i].startpc]);
1666 printf("L%03d = ", block_index[extable[i].endpc]);
1667 printf("L%03d\n", block_index[extable[i].handlerpc]);
1670 printf ("Local Table:\n");
1671 for (i = 0; i < maxlocals; i++) {
1672 printf(" %3d: ", i);
1673 for (j = TYPE_INT; j <= TYPE_ADR; j++)
1674 if (locals[i][j].type >= 0) {
1675 printf(" (%d) ", j);
1676 if (locals[i][j].flags)
1680 printf("%2d", locals[i][j].regoff);
1686 printf ("Interface Table:\n");
1687 for (i = 0; i < maxstack; i++) {
1688 if ((interfaces[i][0].type >= 0) || (interfaces[i][1].type >= 0) ||
1689 (interfaces[i][2].type >= 0) || (interfaces[i][3].type >= 0) ||
1690 (interfaces[i][4].type >= 0)) {
1691 printf(" %3d: ", i);
1692 for (j = TYPE_INT; j <= TYPE_ADR; j++)
1693 if (interfaces[i][j].type >= 0) {
1694 printf(" (%d) ", j);
1695 if (interfaces[i][j].flags & SAVEDVAR)
1699 if (interfaces[i][j].flags & INMEMORY)
1703 printf("%2d", interfaces[i][j].regoff);
1710 if (showdisassemble) {
1711 s4ptr = (s4 *) (method->mcode + dseglen);
1712 for (i = 0; i < block[0].mpc; i += 4, s4ptr++) {
1713 disasscmd (*s4ptr, i);
1718 for (b = 0; b < block_count; b++)
1719 if (block[b].flags != BBDELETED) {
1720 deadcode = block[b].flags <= BBREACHED;
1723 for (j = maxstack; j > 0; j--)
1726 print_stack(block[b].instack);
1727 printf("] L%03d(%d):\n", b, block[b].pre_count);
1728 iptr = block[b].iinstr;
1730 for (last = i + block[b].icount; i < last; i++, iptr++) {
1733 for (j = maxstack; j > 0; j--)
1737 print_stack(iptr->dst);
1738 printf("] %4d %s", i, icmd_names[iptr->opc]);
1739 switch ((int) iptr->opc) {
1740 case ICMD_IADDCONST:
1741 case ICMD_ISUBCONST:
1742 case ICMD_IMULCONST:
1745 case ICMD_IREM0X10001:
1746 case ICMD_IANDCONST:
1748 case ICMD_IXORCONST:
1749 case ICMD_ISHLCONST:
1750 case ICMD_ISHRCONST:
1751 case ICMD_IUSHRCONST:
1753 case ICMD_ELSE_ICONST:
1754 case ICMD_IFEQ_ICONST:
1755 case ICMD_IFNE_ICONST:
1756 case ICMD_IFLT_ICONST:
1757 case ICMD_IFGE_ICONST:
1758 case ICMD_IFGT_ICONST:
1759 case ICMD_IFLE_ICONST:
1760 printf(" %d", iptr->val.i);
1762 case ICMD_LADDCONST:
1763 case ICMD_LSUBCONST:
1764 case ICMD_LMULCONST:
1767 case ICMD_LANDCONST:
1769 case ICMD_LXORCONST:
1770 case ICMD_LSHLCONST:
1771 case ICMD_LSHRCONST:
1772 case ICMD_LUSHRCONST:
1774 printf(" %ld", iptr->val.l);
1777 printf(" %f", iptr->val.f);
1780 printf(" %f", iptr->val.d);
1783 printf(" %p", iptr->val.a);
1787 printf(" %d,", ((fieldinfo *) iptr->val.a)->offset);
1788 case ICMD_PUTSTATIC:
1789 case ICMD_GETSTATIC:
1791 unicode_fprint(stdout,
1792 ((fieldinfo *) iptr->val.a)->name);
1795 printf(" %d + %d", iptr->op1, iptr->val.i);
1808 printf(" %d", iptr->op1);
1812 unicode_fprint(stdout,
1813 ((classinfo *) iptr->val.a)->name);
1816 switch (iptr->op1) {
1843 case ICMD_ANEWARRAY:
1846 unicode_fprint(stdout,
1847 ((classinfo *) iptr->val.a)->name);
1850 case ICMD_CHECKCAST:
1851 case ICMD_INSTANCEOF:
1853 classinfo *c = iptr->val.a;
1854 if (c->flags & ACC_INTERFACE)
1855 printf(" (INTERFACE) ");
1857 printf(" (CLASS,%3d) ", c->vftbl->diffval);
1858 unicode_fprint(stdout, c->name);
1864 printf(" %s", builtin_name((functionptr) iptr->val.a));
1866 case ICMD_INVOKEVIRTUAL:
1867 case ICMD_INVOKESPECIAL:
1868 case ICMD_INVOKESTATIC:
1869 case ICMD_INVOKEINTERFACE:
1871 unicode_fprint(stdout,
1872 ((methodinfo *) iptr->val.a)->class->name);
1874 unicode_fprint(stdout,
1875 ((methodinfo *) iptr->val.a)->name);
1889 printf("(%d) L%03d", iptr->val.i, block_index[iptr->op1]);
1894 case ICMD_IFNONNULL:
1895 case ICMD_IF_ICMPEQ:
1896 case ICMD_IF_ICMPNE:
1897 case ICMD_IF_ICMPLT:
1898 case ICMD_IF_ICMPGE:
1899 case ICMD_IF_ICMPGT:
1900 case ICMD_IF_ICMPLE:
1901 case ICMD_IF_LCMPEQ:
1902 case ICMD_IF_LCMPNE:
1903 case ICMD_IF_LCMPLT:
1904 case ICMD_IF_LCMPGE:
1905 case ICMD_IF_LCMPGT:
1906 case ICMD_IF_LCMPLE:
1907 case ICMD_IF_ACMPEQ:
1908 case ICMD_IF_ACMPNE:
1909 printf(" L%03d", block_index[iptr->op1]);
1911 case ICMD_TABLESWITCH:
1912 s4ptr = iptr->val.a;
1913 printf(" L%03d;", block_index[*s4ptr++]); /* default */
1914 j = *s4ptr++; /* low */
1915 j = *s4ptr++ - j; /* high */
1917 printf(" L%03d", block_index[*s4ptr++]);
1921 case ICMD_LOOKUPSWITCH:
1922 s4ptr = iptr->val.a;
1923 printf(" L%d", block_index[*s4ptr++]); /* default */
1924 j = *s4ptr++; /* count */
1926 printf(" L%03d", block_index[s4ptr[1]]);
1934 if (showdisassemble && (!deadcode)) {
1937 s4ptr = (s4 *) (method->mcode + dseglen + i);
1938 for (; i < block[b + 1].mpc; i += 4, s4ptr++) {
1939 disasscmd (*s4ptr, i);
1945 s4ptr = (s4 *) (method->mcode + dseglen + i);
1946 if (showdisassemble && (s4ptr < (s4 *) (method->mcode + method->mcodelength))) {
1948 for (; s4ptr < (s4 *) (method->mcode + method->mcodelength); i += 4, s4ptr++) {
1949 disasscmd (*s4ptr, i);