1 /* jit/stack.c *****************************************************************
3 Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
5 See file COPYRIGHT for information on usage and disclaimer of warranties
7 Parser for JavaVM to intermediate code translation
9 Authors: Andreas Krall EMAIL: cacao@complang.tuwien.ac.at
11 Last Change: 1997/11/18
13 *******************************************************************************/
16 #define COUNT(cnt) cnt++
21 #define STACKRESET {curstack=0;stackdepth=0;}
23 #define TYPEPANIC {show_icmd_method();panic("Stack type mismatch");}
24 #define CURKIND curstack->varkind
25 #define CURTYPE curstack->type
27 #define NEWSTACK(s,v,n) {new->prev=curstack;new->type=s;new->flags=0;\
28 new->varkind=v;new->varnum=n;curstack=new;new++;}
29 #define NEWSTACKn(s,n) NEWSTACK(s,UNDEFVAR,n)
30 #define NEWSTACK0(s) NEWSTACK(s,UNDEFVAR,0)
31 #define NEWXSTACK {NEWSTACK(TYPE_ADR,STACKVAR,0);curstack=0;}
33 #define SETDST {iptr->dst=curstack;}
34 #define POP(s) {if(s!=curstack->type){TYPEPANIC;}\
35 if(curstack->varkind==UNDEFVAR)curstack->varkind=TEMPVAR;\
36 curstack=curstack->prev;}
37 #define POPANY {if(curstack->varkind==UNDEFVAR)curstack->varkind=TEMPVAR;\
38 curstack=curstack->prev;}
39 #define COPY(s,d) {(d)->flags=0;(d)->type=(s)->type;\
40 (d)->varkind=(s)->varkind;(d)->varnum=(s)->varnum;}
42 #define PUSHCONST(s){NEWSTACKn(s,stackdepth);SETDST;stackdepth++;}
43 #define LOAD(s,v,n) {NEWSTACK(s,v,n);SETDST;stackdepth++;}
44 #define STORE(s) {POP(s);SETDST;stackdepth--;}
45 #define OP1_0(s) {POP(s);SETDST;stackdepth--;}
46 #define OP1_0ANY {POPANY;SETDST;stackdepth--;}
47 #define OP0_1(s) {NEWSTACKn(s,stackdepth);SETDST;stackdepth++;}
48 #define OP1_1(s,d) {POP(s);NEWSTACKn(d,stackdepth-1);SETDST;}
49 #define OP2_0(s) {POP(s);POP(s);SETDST;stackdepth-=2;}
50 #define OPTT2_0(t,b){POP(t);POP(b);SETDST;stackdepth-=2;}
51 #define OP2_1(s) {POP(s);POP(s);NEWSTACKn(s,stackdepth-2);SETDST;stackdepth--;}
52 #define OP2IAT_1(s) {POP(TYPE_INT);POP(TYPE_ADR);NEWSTACKn(s,stackdepth-2);\
54 #define OP2IT_1(s) {POP(TYPE_INT);POP(s);NEWSTACKn(s,stackdepth-2);\
56 #define OPTT2_1(s,d){POP(s);POP(s);NEWSTACKn(d,stackdepth-2);SETDST;stackdepth--;}
57 #define OP2_2(s) {POP(s);POP(s);NEWSTACKn(s,stackdepth-2);\
58 NEWSTACKn(s,stackdepth-1);SETDST;}
59 #define OP3TIA_0(s) {POP(s);POP(TYPE_INT);POP(TYPE_ADR);SETDST;stackdepth-=3;}
60 #define OP3_0(s) {POP(s);POP(s);POP(s);SETDST;stackdepth-=3;}
61 #define POPMANY(i) {stackdepth-=i;while(--i>=0){POPANY;}SETDST;}
62 #define DUP {NEWSTACK(CURTYPE,CURKIND,curstack->varnum);SETDST;\
64 #define SWAP {COPY(curstack,new);POPANY;COPY(curstack,new+1);POPANY;\
65 new[0].prev=curstack;new[1].prev=new;\
66 curstack=new+1;new+=2;SETDST;}
67 #define DUP_X1 {COPY(curstack,new);COPY(curstack,new+2);POPANY;\
68 COPY(curstack,new+1);POPANY;new[0].prev=curstack;\
69 new[1].prev=new;new[2].prev=new+1;\
70 curstack=new+2;new+=3;SETDST;stackdepth++;}
71 #define DUP2_X1 {COPY(curstack,new+1);COPY(curstack,new+4);POPANY;\
72 COPY(curstack,new);COPY(curstack,new+3);POPANY;\
73 COPY(curstack,new+2);POPANY;new[0].prev=curstack;\
74 new[1].prev=new;new[2].prev=new+1;\
75 new[3].prev=new+2;new[4].prev=new+3;\
76 curstack=new+4;new+=5;SETDST;stackdepth+=2;}
77 #define DUP_X2 {COPY(curstack,new);COPY(curstack,new+3);POPANY;\
78 COPY(curstack,new+2);POPANY;COPY(curstack,new+1);POPANY;\
79 new[0].prev=curstack;new[1].prev=new;\
80 new[2].prev=new+1;new[3].prev=new+2;\
81 curstack=new+3;new+=4;SETDST;stackdepth++;}
82 #define DUP2_X2 {COPY(curstack,new+1);COPY(curstack,new+5);POPANY;\
83 COPY(curstack,new);COPY(curstack,new+4);POPANY;\
84 COPY(curstack,new+3);POPANY;COPY(curstack,new+2);POPANY;\
85 new[0].prev=curstack;new[1].prev=new;\
86 new[2].prev=new+1;new[3].prev=new+2;\
87 new[4].prev=new+3;new[5].prev=new+4;\
88 curstack=new+5;new+=6;SETDST;stackdepth+=2;}
90 #define COPYCURSTACK(copy) {\
103 copy->varkind=STACKVAR;\
119 if((copy->varkind==STACKVAR)&&(copy->varnum>i))\
120 copy->varkind=TEMPVAR;\
122 copy->varkind=STACKVAR;\
125 interfaces[i][copy->type].type = copy->type;\
126 interfaces[i][copy->type].flags |= copy->flags;\
127 i--;copy=copy->prev;\
132 interfaces[i][copy->type].type = copy->type;\
133 if(copy->varkind==STACKVAR){\
134 if (copy->flags & SAVEDVAR)\
135 interfaces[i][copy->type].flags |= SAVEDVAR;\
137 i--;copy=copy->prev;\
142 #define MARKREACHED(b,c) {\
144 {COPYCURSTACK(c);b->flags=0;b->instack=c;b->indepth=stackdepth;}\
145 else {stackptr s=curstack;stackptr t=b->instack;\
146 if(b->indepth!=stackdepth)\
147 {show_icmd_method();panic("Stack depth mismatch");}\
148 while(s){if (s->type!=t->type)\
150 s=s->prev;t=t->prev;\
156 static void show_icmd_method();
158 static void analyse_stack()
160 int b_count, b_index;
162 stackptr curstack, new, copy;
163 int opcode, i, len, loops;
164 int superblockend, repeat, deadcode;
165 instruction *iptr = instr;
166 basicblock *bptr, *tbptr;
172 block[0].flags = BBREACHED;
173 block[0].instack = 0;
174 block[0].indepth = 0;
176 for (i = 0; i < exceptiontablelength; i++) {
177 bptr = &block[block_index[extable[i].handlerpc]];
178 bptr->flags = BBREACHED;
179 bptr->type = BBTYPE_EXH;
182 bptr->pre_count = 10000;
187 #ifdef CONDITIONAL_LOADCONST
188 b_count = block_count;
190 while (--b_count >= 0) {
191 if (bptr->icount != 0) {
192 iptr = bptr->iinstr + bptr->icount - 1;
225 block[block_index[iptr->op1]].pre_count++;
228 case ICMD_TABLESWITCH:
230 block[block_index[*s4ptr++]].pre_count++; /* default */
231 i = *s4ptr++; /* low */
232 i = *s4ptr++ - i + 1; /* high */
234 block[block_index[*s4ptr++]].pre_count++;
238 case ICMD_LOOKUPSWITCH:
240 block[block_index[*s4ptr++]].pre_count++; /* default */
241 i = *s4ptr++; /* count */
243 block[block_index[s4ptr[1]]].pre_count++;
259 b_count = block_count;
261 superblockend = true;
265 while (--b_count >= 0) {
266 if (bptr->flags == BBDELETED) {
269 else if (superblockend && (bptr->flags < BBREACHED))
271 else if (bptr->flags <= BBREACHED) {
273 stackdepth = bptr->indepth;
274 else if (bptr->flags < BBREACHED) {
276 bptr->instack = copy;
277 bptr->indepth = stackdepth;
279 else if (bptr->indepth != stackdepth) {
281 panic("Stack depth mismatch");
284 curstack = bptr->instack;
286 superblockend = false;
287 bptr->flags = BBFINISHED;
290 b_index = bptr - block;
298 case ICMD_CHECKASIZE:
300 case ICMD_IFEQ_ICONST:
301 case ICMD_IFNE_ICONST:
302 case ICMD_IFLT_ICONST:
303 case ICMD_IFGE_ICONST:
304 case ICMD_IFGT_ICONST:
305 case ICMD_IFLE_ICONST:
306 case ICMD_ELSE_ICONST:
311 locals[iptr->op1][TYPE_ADR].type = TYPE_ADR;
313 COUNT(count_pcmd_return);
315 superblockend = true;
318 /* pop 0 push 1 const */
321 COUNT(count_pcmd_load);
323 switch (iptr[1].opc) {
325 iptr[0].opc = ICMD_IADDCONST;
327 iptr[1].opc = ICMD_NOP;
328 OP1_1(TYPE_INT,TYPE_INT);
329 COUNT(count_pcmd_op);
332 iptr[0].opc = ICMD_ISUBCONST;
333 goto icmd_iconst_tail;
335 iptr[0].opc = ICMD_IMULCONST;
336 goto icmd_iconst_tail;
338 if (iptr[0].val.i == 0x00000002)
340 else if (iptr[0].val.i == 0x00000004)
342 else if (iptr[0].val.i == 0x00000008)
344 else if (iptr[0].val.i == 0x00000010)
346 else if (iptr[0].val.i == 0x00000020)
348 else if (iptr[0].val.i == 0x00000040)
350 else if (iptr[0].val.i == 0x00000080)
352 else if (iptr[0].val.i == 0x00000100)
354 else if (iptr[0].val.i == 0x00000200)
356 else if (iptr[0].val.i == 0x00000400)
358 else if (iptr[0].val.i == 0x00000800)
360 else if (iptr[0].val.i == 0x00001000)
362 else if (iptr[0].val.i == 0x00002000)
364 else if (iptr[0].val.i == 0x00004000)
366 else if (iptr[0].val.i == 0x00008000)
368 else if (iptr[0].val.i == 0x00010000)
370 else if (iptr[0].val.i == 0x00020000)
372 else if (iptr[0].val.i == 0x00040000)
374 else if (iptr[0].val.i == 0x00080000)
376 else if (iptr[0].val.i == 0x00100000)
378 else if (iptr[0].val.i == 0x00200000)
380 else if (iptr[0].val.i == 0x00400000)
382 else if (iptr[0].val.i == 0x00800000)
384 else if (iptr[0].val.i == 0x01000000)
386 else if (iptr[0].val.i == 0x02000000)
388 else if (iptr[0].val.i == 0x04000000)
390 else if (iptr[0].val.i == 0x08000000)
392 else if (iptr[0].val.i == 0x10000000)
394 else if (iptr[0].val.i == 0x20000000)
396 else if (iptr[0].val.i == 0x40000000)
398 else if (iptr[0].val.i == 0x80000000)
404 iptr[0].opc = ICMD_IDIVPOW2;
405 goto icmd_iconst_tail;
407 if (iptr[0].val.i == 0x10001) {
408 iptr[0].opc = ICMD_IREM0X10001;
409 goto icmd_iconst_tail;
411 if ((iptr[0].val.i == 0x00000002) ||
412 (iptr[0].val.i == 0x00000004) ||
413 (iptr[0].val.i == 0x00000008) ||
414 (iptr[0].val.i == 0x00000010) ||
415 (iptr[0].val.i == 0x00000020) ||
416 (iptr[0].val.i == 0x00000040) ||
417 (iptr[0].val.i == 0x00000080) ||
418 (iptr[0].val.i == 0x00000100) ||
419 (iptr[0].val.i == 0x00000200) ||
420 (iptr[0].val.i == 0x00000400) ||
421 (iptr[0].val.i == 0x00000800) ||
422 (iptr[0].val.i == 0x00001000) ||
423 (iptr[0].val.i == 0x00002000) ||
424 (iptr[0].val.i == 0x00004000) ||
425 (iptr[0].val.i == 0x00008000) ||
426 (iptr[0].val.i == 0x00010000) ||
427 (iptr[0].val.i == 0x00020000) ||
428 (iptr[0].val.i == 0x00040000) ||
429 (iptr[0].val.i == 0x00080000) ||
430 (iptr[0].val.i == 0x00100000) ||
431 (iptr[0].val.i == 0x00200000) ||
432 (iptr[0].val.i == 0x00400000) ||
433 (iptr[0].val.i == 0x00800000) ||
434 (iptr[0].val.i == 0x01000000) ||
435 (iptr[0].val.i == 0x02000000) ||
436 (iptr[0].val.i == 0x04000000) ||
437 (iptr[0].val.i == 0x08000000) ||
438 (iptr[0].val.i == 0x10000000) ||
439 (iptr[0].val.i == 0x20000000) ||
440 (iptr[0].val.i == 0x40000000) ||
441 (iptr[0].val.i == 0x80000000)) {
442 iptr[0].opc = ICMD_IREMPOW2;
444 goto icmd_iconst_tail;
449 iptr[0].opc = ICMD_IANDCONST;
450 goto icmd_iconst_tail;
452 iptr[0].opc = ICMD_IORCONST;
453 goto icmd_iconst_tail;
455 iptr[0].opc = ICMD_IXORCONST;
456 goto icmd_iconst_tail;
458 iptr[0].opc = ICMD_ISHLCONST;
459 goto icmd_iconst_tail;
461 iptr[0].opc = ICMD_ISHRCONST;
462 goto icmd_iconst_tail;
464 iptr[0].opc = ICMD_IUSHRCONST;
465 goto icmd_iconst_tail;
467 iptr[0].opc = ICMD_IFEQ;
469 iptr[0].op1 = iptr[1].op1;
472 /* iptr[1].opc = ICMD_NOP; */
474 tbptr = block + block_index[iptr->op1];
475 MARKREACHED(tbptr, copy);
476 COUNT(count_pcmd_bra);
479 iptr[0].opc = ICMD_IFLT;
480 goto icmd_if_icmp_tail;
482 iptr[0].opc = ICMD_IFLE;
483 goto icmd_if_icmp_tail;
485 iptr[0].opc = ICMD_IFNE;
486 goto icmd_if_icmp_tail;
488 iptr[0].opc = ICMD_IFGT;
489 goto icmd_if_icmp_tail;
491 iptr[0].opc = ICMD_IFGE;
492 goto icmd_if_icmp_tail;
501 COUNT(count_pcmd_load);
503 switch (iptr[1].opc) {
505 iptr[0].opc = ICMD_LADDCONST;
507 iptr[1].opc = ICMD_NOP;
508 OP1_1(TYPE_LNG,TYPE_LNG);
509 COUNT(count_pcmd_op);
512 iptr[0].opc = ICMD_LSUBCONST;
513 goto icmd_lconst_tail;
515 iptr[0].opc = ICMD_LMULCONST;
516 goto icmd_lconst_tail;
518 if (iptr[0].val.l == 0x00000002)
520 else if (iptr[0].val.l == 0x00000004)
522 else if (iptr[0].val.l == 0x00000008)
524 else if (iptr[0].val.l == 0x00000010)
526 else if (iptr[0].val.l == 0x00000020)
528 else if (iptr[0].val.l == 0x00000040)
530 else if (iptr[0].val.l == 0x00000080)
532 else if (iptr[0].val.l == 0x00000100)
534 else if (iptr[0].val.l == 0x00000200)
536 else if (iptr[0].val.l == 0x00000400)
538 else if (iptr[0].val.l == 0x00000800)
540 else if (iptr[0].val.l == 0x00001000)
542 else if (iptr[0].val.l == 0x00002000)
544 else if (iptr[0].val.l == 0x00004000)
546 else if (iptr[0].val.l == 0x00008000)
548 else if (iptr[0].val.l == 0x00010000)
550 else if (iptr[0].val.l == 0x00020000)
552 else if (iptr[0].val.l == 0x00040000)
554 else if (iptr[0].val.l == 0x00080000)
556 else if (iptr[0].val.l == 0x00100000)
558 else if (iptr[0].val.l == 0x00200000)
560 else if (iptr[0].val.l == 0x00400000)
562 else if (iptr[0].val.l == 0x00800000)
564 else if (iptr[0].val.l == 0x01000000)
566 else if (iptr[0].val.l == 0x02000000)
568 else if (iptr[0].val.l == 0x04000000)
570 else if (iptr[0].val.l == 0x08000000)
572 else if (iptr[0].val.l == 0x10000000)
574 else if (iptr[0].val.l == 0x20000000)
576 else if (iptr[0].val.l == 0x40000000)
578 else if (iptr[0].val.l == 0x80000000)
584 iptr[0].opc = ICMD_LDIVPOW2;
585 goto icmd_lconst_tail;
587 if (iptr[0].val.l == 0x10001) {
588 iptr[0].opc = ICMD_LREM0X10001;
589 goto icmd_lconst_tail;
591 if ((iptr[0].val.l == 0x00000002) ||
592 (iptr[0].val.l == 0x00000004) ||
593 (iptr[0].val.l == 0x00000008) ||
594 (iptr[0].val.l == 0x00000010) ||
595 (iptr[0].val.l == 0x00000020) ||
596 (iptr[0].val.l == 0x00000040) ||
597 (iptr[0].val.l == 0x00000080) ||
598 (iptr[0].val.l == 0x00000100) ||
599 (iptr[0].val.l == 0x00000200) ||
600 (iptr[0].val.l == 0x00000400) ||
601 (iptr[0].val.l == 0x00000800) ||
602 (iptr[0].val.l == 0x00001000) ||
603 (iptr[0].val.l == 0x00002000) ||
604 (iptr[0].val.l == 0x00004000) ||
605 (iptr[0].val.l == 0x00008000) ||
606 (iptr[0].val.l == 0x00010000) ||
607 (iptr[0].val.l == 0x00020000) ||
608 (iptr[0].val.l == 0x00040000) ||
609 (iptr[0].val.l == 0x00080000) ||
610 (iptr[0].val.l == 0x00100000) ||
611 (iptr[0].val.l == 0x00200000) ||
612 (iptr[0].val.l == 0x00400000) ||
613 (iptr[0].val.l == 0x00800000) ||
614 (iptr[0].val.l == 0x01000000) ||
615 (iptr[0].val.l == 0x02000000) ||
616 (iptr[0].val.l == 0x04000000) ||
617 (iptr[0].val.l == 0x08000000) ||
618 (iptr[0].val.l == 0x10000000) ||
619 (iptr[0].val.l == 0x20000000) ||
620 (iptr[0].val.l == 0x40000000) ||
621 (iptr[0].val.l == 0x80000000)) {
622 iptr[0].opc = ICMD_LREMPOW2;
624 goto icmd_lconst_tail;
629 iptr[0].opc = ICMD_LANDCONST;
630 goto icmd_lconst_tail;
632 iptr[0].opc = ICMD_LORCONST;
633 goto icmd_lconst_tail;
635 iptr[0].opc = ICMD_LXORCONST;
636 goto icmd_lconst_tail;
638 iptr[0].opc = ICMD_LSHLCONST;
639 goto icmd_lconst_tail;
641 iptr[0].opc = ICMD_LSHRCONST;
642 goto icmd_lconst_tail;
644 iptr[0].opc = ICMD_LUSHRCONST;
645 goto icmd_lconst_tail;
647 if ((len > 1) && (iptr[2].val.i == 0)) {
648 switch (iptr[2].opc) {
650 iptr[0].opc = ICMD_IF_LEQ;
651 icmd_lconst_lcmp_tail:
652 iptr[0].op1 = iptr[2].op1;
655 /* iptr[1].opc = ICMD_NOP;
656 iptr[2].opc = ICMD_NOP; */
658 tbptr = block + block_index[iptr->op1];
659 MARKREACHED(tbptr, copy);
660 COUNT(count_pcmd_bra);
661 COUNT(count_pcmd_op);
664 iptr[0].opc = ICMD_IF_LNE;
665 goto icmd_lconst_lcmp_tail;
667 iptr[0].opc = ICMD_IF_LLT;
668 goto icmd_lconst_lcmp_tail;
670 iptr[0].opc = ICMD_IF_LGT;
671 goto icmd_lconst_lcmp_tail;
673 iptr[0].opc = ICMD_IF_LLE;
674 goto icmd_lconst_lcmp_tail;
676 iptr[0].opc = ICMD_IF_LGE;
677 goto icmd_lconst_lcmp_tail;
680 } /* switch (iptr[2].opc) */
681 } /* if (iptr[2].val.i == 0) */
693 COUNT(count_pcmd_load);
697 COUNT(count_pcmd_load);
701 COUNT(count_pcmd_load);
705 /* pop 0 push 1 load */
712 COUNT(count_load_instruction);
713 i = opcode-ICMD_ILOAD;
714 locals[iptr->op1][i].type = i;
715 LOAD(i, LOCALVAR, iptr->op1);
725 COUNT(count_check_null);
726 COUNT(count_check_bound);
727 COUNT(count_pcmd_mem);
728 OP2IAT_1(opcode-ICMD_IALOAD);
734 COUNT(count_check_null);
735 COUNT(count_check_bound);
736 COUNT(count_pcmd_mem);
740 /* pop 0 push 0 iinc */
746 count_store_depth[10]++;
748 count_store_depth[i]++;
753 if ((copy->varkind == LOCALVAR) &&
754 (copy->varnum == curstack->varnum)) {
755 copy->varkind = TEMPVAR;
764 /* pop 1 push 0 store */
771 i = opcode-ICMD_ISTORE;
772 locals[iptr->op1][i].type = i;
777 count_store_length[20]++;
779 count_store_length[i]++;
782 count_store_depth[10]++;
784 count_store_depth[i]++;
786 copy = curstack->prev;
789 if ((copy->varkind == LOCALVAR) &&
790 (copy->varnum == curstack->varnum)) {
791 copy->varkind = TEMPVAR;
797 if ((new - curstack) == 1) {
798 curstack->varkind = LOCALVAR;
799 curstack->varnum = iptr->op1;
801 STORE(opcode-ICMD_ISTORE);
811 COUNT(count_check_null);
812 COUNT(count_check_bound);
813 COUNT(count_pcmd_mem);
814 OP3TIA_0(opcode-ICMD_IASTORE);
819 COUNT(count_check_null);
820 COUNT(count_check_bound);
821 COUNT(count_pcmd_mem);
836 COUNT(count_pcmd_return);
837 OP1_0(opcode-ICMD_IRETURN);
838 superblockend = true;
842 COUNT(count_check_null);
846 superblockend = true;
850 COUNT(count_pcmd_mem);
854 /* pop 1 push 0 branch */
858 COUNT(count_pcmd_bra);
860 tbptr = block + block_index[iptr->op1];
861 MARKREACHED(tbptr, copy);
870 COUNT(count_pcmd_bra);
871 #ifdef CONDITIONAL_LOADCONST
873 tbptr = block + b_index;
874 if ((b_count >= 3) &&
875 ((b_index + 2) == block_index[iptr[0].op1]) &&
876 (tbptr[1].pre_count == 1) &&
877 (iptr[1].opc == ICMD_ICONST) &&
878 (iptr[2].opc == ICMD_GOTO) &&
879 ((b_index + 3) == block_index[iptr[2].op1]) &&
880 (tbptr[2].pre_count == 1) &&
881 (iptr[3].opc == ICMD_ICONST)) {
882 OP1_1(TYPE_INT, TYPE_INT);
883 switch (iptr[0].opc) {
885 iptr[0].opc = ICMD_IFNE_ICONST;
888 iptr[0].opc = ICMD_IFEQ_ICONST;
891 iptr[0].opc = ICMD_IFGE_ICONST;
894 iptr[0].opc = ICMD_IFLT_ICONST;
897 iptr[0].opc = ICMD_IFLE_ICONST;
900 iptr[0].opc = ICMD_IFGT_ICONST;
903 iptr[0].val.i = iptr[1].val.i;
904 iptr[1].opc = ICMD_ELSE_ICONST;
905 iptr[1].val.i = iptr[3].val.i;
906 iptr[2].opc = ICMD_NOP;
907 iptr[3].opc = ICMD_NOP;
908 tbptr[1].flags = BBDELETED;
909 tbptr[2].flags = BBDELETED;
912 if (tbptr[3].pre_count == 2) {
913 len += tbptr[3].icount + 3;
914 bptr->icount += tbptr[3].icount + 3;
915 tbptr[3].flags = BBDELETED;
929 tbptr = block + block_index[iptr->op1];
930 MARKREACHED(tbptr, copy);
933 /* pop 0 push 0 branch */
936 COUNT(count_pcmd_bra);
937 tbptr = block + block_index[iptr->op1];
938 MARKREACHED(tbptr, copy);
940 superblockend = true;
943 /* pop 1 push 0 table branch */
945 case ICMD_TABLESWITCH:
946 COUNT(count_pcmd_table);
949 tbptr = block + block_index[*s4ptr++]; /* default */
950 MARKREACHED(tbptr, copy);
951 i = *s4ptr++; /* low */
952 i = *s4ptr++ - i + 1; /* high */
954 tbptr = block + block_index[*s4ptr++];
955 MARKREACHED(tbptr, copy);
958 superblockend = true;
961 /* pop 1 push 0 table branch */
963 case ICMD_LOOKUPSWITCH:
964 COUNT(count_pcmd_table);
967 tbptr = block + block_index[*s4ptr++]; /* default */
968 MARKREACHED(tbptr, copy);
969 i = *s4ptr++; /* count */
971 tbptr = block + block_index[s4ptr[1]];
972 MARKREACHED(tbptr, copy);
976 superblockend = true;
979 case ICMD_NULLCHECKPOP:
980 case ICMD_MONITORENTER:
981 COUNT(count_check_null);
982 case ICMD_MONITOREXIT:
986 /* pop 2 push 0 branch */
994 COUNT(count_pcmd_bra);
996 tbptr = block + block_index[iptr->op1];
997 MARKREACHED(tbptr, copy);
1000 case ICMD_IF_ACMPEQ:
1001 case ICMD_IF_ACMPNE:
1002 COUNT(count_pcmd_bra);
1004 tbptr = block + block_index[iptr->op1];
1005 MARKREACHED(tbptr, copy);
1011 COUNT(count_check_null);
1012 COUNT(count_pcmd_mem);
1013 OPTT2_0(iptr->op1,TYPE_ADR);
1017 if (! IS_2_WORD_TYPE(curstack->type)) {
1018 OP1_0ANY; /* second pop */
1021 iptr->opc = ICMD_POP;
1025 /* pop 0 push 1 dup */
1028 COUNT(count_dup_instruction);
1033 if (IS_2_WORD_TYPE(curstack->type)) {
1034 iptr->opc = ICMD_DUP;
1039 NEWSTACK(copy->prev->type, copy->prev->varkind,
1040 copy->prev->varnum);
1041 NEWSTACK(copy->type, copy->varkind,
1048 /* pop 2 push 3 dup */
1055 if (IS_2_WORD_TYPE(curstack->type)) {
1056 iptr->opc = ICMD_DUP_X1;
1064 /* pop 3 push 4 dup */
1067 if (IS_2_WORD_TYPE(curstack[-1].type)) {
1068 iptr->opc = ICMD_DUP_X1;
1077 if (IS_2_WORD_TYPE(curstack->type)) {
1078 if (IS_2_WORD_TYPE(curstack[-1].type)) {
1079 iptr->opc = ICMD_DUP_X1;
1083 iptr->opc = ICMD_DUP_X2;
1088 if (IS_2_WORD_TYPE(curstack[-2].type)) {
1089 iptr->opc = ICMD_DUP2_X1;
1097 /* pop 2 push 2 swap */
1106 if (!(SUPPORT_DIVISION)) {
1107 iptr[0].opc = ICMD_BUILTIN2;
1108 iptr[0].op1 = TYPE_INT;
1109 iptr[0].val.a = (functionptr) asm_builtin_idiv;
1110 isleafmethod = false;
1115 if (!(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV)) {
1116 iptr[0].opc = ICMD_BUILTIN2;
1117 iptr[0].op1 = TYPE_LNG;
1118 iptr[0].val.a = (functionptr) asm_builtin_ldiv;
1119 isleafmethod = false;
1124 if (!(SUPPORT_DIVISION)) {
1125 iptr[0].opc = ICMD_BUILTIN2;
1126 iptr[0].op1 = TYPE_INT;
1127 iptr[0].val.a = (functionptr) asm_builtin_irem;
1128 isleafmethod = false;
1133 if (!(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV)) {
1134 iptr[0].opc = ICMD_BUILTIN2;
1135 iptr[0].op1 = TYPE_LNG;
1136 iptr[0].val.a = (functionptr) asm_builtin_lrem;
1137 isleafmethod = false;
1151 COUNT(count_pcmd_op);
1162 COUNT(count_pcmd_op);
1169 COUNT(count_pcmd_op);
1178 COUNT(count_pcmd_op);
1187 COUNT(count_pcmd_op);
1192 COUNT(count_pcmd_op);
1193 if ((len > 0) && (iptr[1].val.i == 0)) {
1194 switch (iptr[1].opc) {
1196 iptr[0].opc = ICMD_IF_LCMPEQ;
1198 iptr[0].op1 = iptr[1].op1;
1201 /* iptr[1].opc = ICMD_NOP; */
1203 tbptr = block + block_index[iptr->op1];
1204 MARKREACHED(tbptr, copy);
1205 COUNT(count_pcmd_bra);
1208 iptr[0].opc = ICMD_IF_LCMPNE;
1209 goto icmd_lcmp_if_tail;
1211 iptr[0].opc = ICMD_IF_LCMPLT;
1212 goto icmd_lcmp_if_tail;
1214 iptr[0].opc = ICMD_IF_LCMPGT;
1215 goto icmd_lcmp_if_tail;
1217 iptr[0].opc = ICMD_IF_LCMPLE;
1218 goto icmd_lcmp_if_tail;
1220 iptr[0].opc = ICMD_IF_LCMPGE;
1221 goto icmd_lcmp_if_tail;
1223 OPTT2_1(TYPE_LNG, TYPE_INT);
1227 OPTT2_1(TYPE_LNG, TYPE_INT);
1231 COUNT(count_pcmd_op);
1232 OPTT2_1(TYPE_FLT, TYPE_INT);
1236 COUNT(count_pcmd_op);
1237 OPTT2_1(TYPE_DBL, TYPE_INT);
1245 case ICMD_INT2SHORT:
1246 COUNT(count_pcmd_op);
1247 OP1_1(TYPE_INT, TYPE_INT);
1250 COUNT(count_pcmd_op);
1251 OP1_1(TYPE_LNG, TYPE_LNG);
1254 COUNT(count_pcmd_op);
1255 OP1_1(TYPE_FLT, TYPE_FLT);
1258 COUNT(count_pcmd_op);
1259 OP1_1(TYPE_DBL, TYPE_DBL);
1263 COUNT(count_pcmd_op);
1264 OP1_1(TYPE_INT, TYPE_LNG);
1267 COUNT(count_pcmd_op);
1268 OP1_1(TYPE_INT, TYPE_FLT);
1271 COUNT(count_pcmd_op);
1272 OP1_1(TYPE_INT, TYPE_DBL);
1275 COUNT(count_pcmd_op);
1276 OP1_1(TYPE_LNG, TYPE_INT);
1279 COUNT(count_pcmd_op);
1280 OP1_1(TYPE_LNG, TYPE_FLT);
1283 COUNT(count_pcmd_op);
1284 OP1_1(TYPE_LNG, TYPE_DBL);
1287 COUNT(count_pcmd_op);
1288 OP1_1(TYPE_FLT, TYPE_INT);
1291 COUNT(count_pcmd_op);
1292 OP1_1(TYPE_FLT, TYPE_LNG);
1295 COUNT(count_pcmd_op);
1296 OP1_1(TYPE_FLT, TYPE_DBL);
1299 COUNT(count_pcmd_op);
1300 OP1_1(TYPE_DBL, TYPE_INT);
1303 COUNT(count_pcmd_op);
1304 OP1_1(TYPE_DBL, TYPE_LNG);
1307 COUNT(count_pcmd_op);
1308 OP1_1(TYPE_DBL, TYPE_FLT);
1311 case ICMD_CHECKCAST:
1312 OP1_1(TYPE_ADR, TYPE_ADR);
1315 case ICMD_ARRAYLENGTH:
1316 case ICMD_INSTANCEOF:
1317 OP1_1(TYPE_ADR, TYPE_INT);
1321 case ICMD_ANEWARRAY:
1322 OP1_1(TYPE_INT, TYPE_ADR);
1326 COUNT(count_check_null);
1327 COUNT(count_pcmd_mem);
1328 OP1_1(TYPE_ADR, iptr->op1);
1333 case ICMD_GETSTATIC:
1334 COUNT(count_pcmd_mem);
1344 tbptr = block + block_index[iptr->op1];
1345 tbptr->type=BBTYPE_SBR;
1346 MARKREACHED(tbptr, copy);
1350 /* pop many push any */
1352 case ICMD_INVOKEVIRTUAL:
1353 case ICMD_INVOKESPECIAL:
1354 case ICMD_INVOKEINTERFACE:
1355 case ICMD_INVOKESTATIC:
1356 COUNT(count_pcmd_met);
1358 methodinfo *m = iptr->val.a;
1359 if (m->flags & ACC_STATIC)
1360 {COUNT(count_check_null);}
1362 if (i > arguments_num)
1366 if (! (copy->flags & SAVEDVAR)) {
1367 copy->varkind = ARGVAR;
1373 copy->flags |= SAVEDVAR;
1378 if (m->returntype != TYPE_VOID) {
1379 OP0_1(m->returntype);
1385 if (! (curstack->flags & SAVEDVAR)) {
1386 curstack->varkind = ARGVAR;
1387 curstack->varnum = 2;
1392 if (! (curstack->flags & SAVEDVAR)) {
1393 curstack->varkind = ARGVAR;
1394 curstack->varnum = 1;
1398 if (! (curstack->flags & SAVEDVAR)) {
1399 curstack->varkind = ARGVAR;
1400 curstack->varnum = 0;
1405 copy->flags |= SAVEDVAR;
1408 if (iptr->op1 != TYPE_VOID)
1412 case ICMD_MULTIANEWARRAY:
1414 if ((i + intreg_argnum) > arguments_num)
1415 arguments_num = i + intreg_argnum;
1418 if (! (copy->flags & SAVEDVAR)) {
1419 copy->varkind = ARGVAR;
1420 copy->varnum = i + intreg_argnum;
1425 copy->flags |= SAVEDVAR;
1434 printf("ICMD %d at %d\n", iptr->opc, (int)(iptr-instr));
1435 panic("Missing ICMD code during stack analysis");
1438 } /* while instructions */
1439 bptr->outstack = curstack;
1440 bptr->outdepth = stackdepth;
1444 superblockend = true;
1446 } /* while blocks */
1447 } while (repeat && ! deadcode);
1450 if (block_count > count_max_basic_blocks)
1451 count_max_basic_blocks = block_count;
1452 count_basic_blocks += block_count;
1453 if (instr_count > count_max_javainstr)
1454 count_max_javainstr = instr_count;
1455 count_javainstr += instr_count;
1456 if (stack_count > count_upper_bound_new_stack)
1457 count_upper_bound_new_stack = stack_count;
1458 if ((new - stack) > count_max_new_stack)
1459 count_max_new_stack = (new - stack);
1461 b_count = block_count;
1463 while (--b_count >= 0) {
1464 if (bptr->flags > BBREACHED) {
1465 if (bptr->indepth >= 10)
1466 count_block_stack[10]++;
1468 count_block_stack[bptr->indepth]++;
1471 count_block_size_distribution[len - 1]++;
1473 count_block_size_distribution[10]++;
1475 count_block_size_distribution[11]++;
1477 count_block_size_distribution[12]++;
1479 count_block_size_distribution[13]++;
1481 count_block_size_distribution[14]++;
1483 count_block_size_distribution[15]++;
1485 count_block_size_distribution[16]++;
1487 count_block_size_distribution[17]++;
1493 count_analyse_iterations[0]++;
1494 else if (loops == 2)
1495 count_analyse_iterations[1]++;
1496 else if (loops == 3)
1497 count_analyse_iterations[2]++;
1498 else if (loops == 4)
1499 count_analyse_iterations[3]++;
1501 count_analyse_iterations[4]++;
1503 if (block_count <= 5)
1504 count_method_bb_distribution[0]++;
1505 else if (block_count <= 10)
1506 count_method_bb_distribution[1]++;
1507 else if (block_count <= 15)
1508 count_method_bb_distribution[2]++;
1509 else if (block_count <= 20)
1510 count_method_bb_distribution[3]++;
1511 else if (block_count <= 30)
1512 count_method_bb_distribution[4]++;
1513 else if (block_count <= 40)
1514 count_method_bb_distribution[5]++;
1515 else if (block_count <= 50)
1516 count_method_bb_distribution[6]++;
1517 else if (block_count <= 75)
1518 count_method_bb_distribution[7]++;
1520 count_method_bb_distribution[8]++;
1525 static void print_stack(stackptr s) {
1541 if (s->flags & SAVEDVAR)
1542 switch (s->varkind) {
1544 if (s->flags & INMEMORY)
1545 printf(" M%02d", s->regoff);
1546 else if ((s->type == TYPE_FLT) || (s->type == TYPE_DBL))
1547 printf(" F%02d", s->regoff);
1549 printf(" %3s", regs[s->regoff]);
1552 printf(" I%02d", s->varnum);
1555 printf(" L%02d", s->varnum);
1558 printf(" A%02d", s->varnum);
1561 printf(" !%02d", j);
1564 switch (s->varkind) {
1566 if (s->flags & INMEMORY)
1567 printf(" m%02d", s->regoff);
1568 else if ((s->type == TYPE_FLT) || (s->type == TYPE_DBL))
1569 printf(" f%02d", s->regoff);
1571 printf(" %3s", regs[s->regoff]);
1574 printf(" i%02d", s->varnum);
1577 printf(" l%02d", s->varnum);
1580 printf(" a%02d", s->varnum);
1583 printf(" ?%02d", j);
1591 static void print_reg(stackptr s) {
1593 if (s->flags & SAVEDVAR)
1594 switch (s->varkind) {
1596 if (s->flags & INMEMORY)
1597 printf(" tm%02d", s->regoff);
1599 printf(" tr%02d", s->regoff);
1602 printf(" s %02d", s->varnum);
1605 printf(" l %02d", s->varnum);
1608 printf(" a %02d", s->varnum);
1611 printf(" ! %02d", s->varnum);
1614 switch (s->varkind) {
1616 if (s->flags & INMEMORY)
1617 printf(" Tm%02d", s->regoff);
1619 printf(" Tr%02d", s->regoff);
1622 printf(" S %02d", s->varnum);
1625 printf(" L %02d", s->varnum);
1628 printf(" A %02d", s->varnum);
1631 printf(" ? %02d", s->varnum);
1641 static char *builtin_name(functionptr bptr)
1643 builtin_descriptor *bdesc = builtin_desc;
1644 while ((bdesc->bptr != NULL) && (bdesc->bptr != bptr))
1650 static char *jit_type[] = {
1659 static void show_icmd_method()
1667 unicode_fprint(stdout, class->name);
1669 unicode_fprint(stdout, method->name);
1671 unicode_fprint(stdout, method->descriptor);
1672 printf ("\n\nMax locals: %d\n", (int) maxlocals);
1673 printf ("Max stack: %d\n", (int) maxstack);
1675 printf ("Exceptions:\n");
1676 for (i = 0; i < exceptiontablelength; i++) {
1677 printf(" L%03d ... ", block_index[extable[i].startpc]);
1678 printf("L%03d = ", block_index[extable[i].endpc]);
1679 printf("L%03d\n", block_index[extable[i].handlerpc]);
1682 printf ("Local Table:\n");
1683 for (i = 0; i < maxlocals; i++) {
1684 printf(" %3d: ", i);
1685 for (j = TYPE_INT; j <= TYPE_ADR; j++)
1686 if (locals[i][j].type >= 0) {
1687 printf(" (%s) ", jit_type[j]);
1688 if (locals[i][j].flags & INMEMORY)
1689 printf("m%2d", locals[i][j].regoff);
1690 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
1691 printf("f%02d", locals[i][j].regoff);
1693 printf("%3s", regs[locals[i][j].regoff]);
1699 printf ("Interface Table:\n");
1700 for (i = 0; i < maxstack; i++) {
1701 if ((interfaces[i][0].type >= 0) || (interfaces[i][1].type >= 0) ||
1702 (interfaces[i][2].type >= 0) || (interfaces[i][3].type >= 0) ||
1703 (interfaces[i][4].type >= 0)) {
1704 printf(" %3d: ", i);
1705 for (j = TYPE_INT; j <= TYPE_ADR; j++)
1706 if (interfaces[i][j].type >= 0) {
1707 printf(" (%s) ", jit_type[j]);
1708 if (interfaces[i][j].flags & SAVEDVAR) {
1709 if (interfaces[i][j].flags & INMEMORY)
1710 printf("M%2d", interfaces[i][j].regoff);
1711 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
1712 printf("F%02d", interfaces[i][j].regoff);
1714 printf("%3s", regs[interfaces[i][j].regoff]);
1717 if (interfaces[i][j].flags & INMEMORY)
1718 printf("m%2d", interfaces[i][j].regoff);
1719 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
1720 printf("f%02d", interfaces[i][j].regoff);
1722 printf("%3s", regs[interfaces[i][j].regoff]);
1730 if (showdisassemble) {
1731 s4ptr = (s4 *) (method->mcode + dseglen);
1732 for (i = 0; i < block[0].mpc; i += 4, s4ptr++) {
1733 disassinstr(*s4ptr, i);
1738 for (b = 0; b < block_count; b++)
1739 if (block[b].flags != BBDELETED) {
1740 deadcode = block[b].flags <= BBREACHED;
1743 for (j = maxstack; j > 0; j--)
1746 print_stack(block[b].instack);
1747 printf("] L%03d(%d):\n", b, block[b].pre_count);
1748 iptr = block[b].iinstr;
1750 for (last = i + block[b].icount; i < last; i++, iptr++) {
1753 for (j = maxstack; j > 0; j--)
1757 print_stack(iptr->dst);
1758 printf("] %4d %s", i, icmd_names[iptr->opc]);
1759 switch ((int) iptr->opc) {
1760 case ICMD_IADDCONST:
1761 case ICMD_ISUBCONST:
1762 case ICMD_IMULCONST:
1765 case ICMD_IREM0X10001:
1766 case ICMD_IANDCONST:
1768 case ICMD_IXORCONST:
1769 case ICMD_ISHLCONST:
1770 case ICMD_ISHRCONST:
1771 case ICMD_IUSHRCONST:
1773 case ICMD_ELSE_ICONST:
1774 case ICMD_IFEQ_ICONST:
1775 case ICMD_IFNE_ICONST:
1776 case ICMD_IFLT_ICONST:
1777 case ICMD_IFGE_ICONST:
1778 case ICMD_IFGT_ICONST:
1779 case ICMD_IFLE_ICONST:
1780 printf(" %d", iptr->val.i);
1782 case ICMD_LADDCONST:
1783 case ICMD_LSUBCONST:
1784 case ICMD_LMULCONST:
1787 case ICMD_LANDCONST:
1789 case ICMD_LXORCONST:
1790 case ICMD_LSHLCONST:
1791 case ICMD_LSHRCONST:
1792 case ICMD_LUSHRCONST:
1794 printf(" %ld", iptr->val.l);
1797 printf(" %f", iptr->val.f);
1800 printf(" %f", iptr->val.d);
1803 printf(" %p", iptr->val.a);
1807 printf(" %d,", ((fieldinfo *) iptr->val.a)->offset);
1808 case ICMD_PUTSTATIC:
1809 case ICMD_GETSTATIC:
1811 unicode_fprint(stdout,
1812 ((fieldinfo *) iptr->val.a)->name);
1815 printf(" %d + %d", iptr->op1, iptr->val.i);
1828 printf(" %d", iptr->op1);
1832 unicode_fprint(stdout,
1833 ((classinfo *) iptr->val.a)->name);
1836 switch (iptr->op1) {
1863 case ICMD_ANEWARRAY:
1866 unicode_fprint(stdout,
1867 ((classinfo *) iptr->val.a)->name);
1870 case ICMD_CHECKCAST:
1871 case ICMD_INSTANCEOF:
1873 classinfo *c = iptr->val.a;
1874 if (c->flags & ACC_INTERFACE)
1875 printf(" (INTERFACE) ");
1877 printf(" (CLASS,%3d) ", c->vftbl->diffval);
1878 unicode_fprint(stdout, c->name);
1884 printf(" %s", builtin_name((functionptr) iptr->val.a));
1886 case ICMD_INVOKEVIRTUAL:
1887 case ICMD_INVOKESPECIAL:
1888 case ICMD_INVOKESTATIC:
1889 case ICMD_INVOKEINTERFACE:
1891 unicode_fprint(stdout,
1892 ((methodinfo *) iptr->val.a)->class->name);
1894 unicode_fprint(stdout,
1895 ((methodinfo *) iptr->val.a)->name);
1909 printf("(%d) L%03d", iptr->val.i, block_index[iptr->op1]);
1914 case ICMD_IFNONNULL:
1915 case ICMD_IF_ICMPEQ:
1916 case ICMD_IF_ICMPNE:
1917 case ICMD_IF_ICMPLT:
1918 case ICMD_IF_ICMPGE:
1919 case ICMD_IF_ICMPGT:
1920 case ICMD_IF_ICMPLE:
1921 case ICMD_IF_LCMPEQ:
1922 case ICMD_IF_LCMPNE:
1923 case ICMD_IF_LCMPLT:
1924 case ICMD_IF_LCMPGE:
1925 case ICMD_IF_LCMPGT:
1926 case ICMD_IF_LCMPLE:
1927 case ICMD_IF_ACMPEQ:
1928 case ICMD_IF_ACMPNE:
1929 printf(" L%03d", block_index[iptr->op1]);
1931 case ICMD_TABLESWITCH:
1932 s4ptr = iptr->val.a;
1933 printf(" L%03d;", block_index[*s4ptr++]); /* default */
1934 j = *s4ptr++; /* low */
1935 j = *s4ptr++ - j; /* high */
1937 printf(" L%03d", block_index[*s4ptr++]);
1941 case ICMD_LOOKUPSWITCH:
1942 s4ptr = iptr->val.a;
1943 printf(" L%d", block_index[*s4ptr++]); /* default */
1944 j = *s4ptr++; /* count */
1946 printf(" L%03d", block_index[s4ptr[1]]);
1954 if (showdisassemble && (!deadcode)) {
1957 s4ptr = (s4 *) (method->mcode + dseglen + i);
1958 for (; i < block[b + 1].mpc; i += 4, s4ptr++) {
1959 disassinstr(*s4ptr, i);
1965 s4ptr = (s4 *) (method->mcode + dseglen + i);
1966 if (showdisassemble && (s4ptr < (s4 *) (method->mcode + method->mcodelength))) {
1968 for (; s4ptr < (s4 *) (method->mcode + method->mcodelength); i += 4, s4ptr++) {
1969 disassinstr(*s4ptr, i);
1977 * These are local overrides for various environment variables in Emacs.
1978 * Please do not remove this and leave it at the end of the file, where
1979 * Emacs will automagically detect them.
1980 * ---------------------------------------------------------------------
1983 * indent-tabs-mode: t