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 case ICMD_OPT_IALOAD:
728 case ICMD_OPT_LALOAD:
729 case ICMD_OPT_FALOAD:
730 case ICMD_OPT_DALOAD:
731 case ICMD_OPT_AALOAD:
732 COUNT(count_pcmd_mem);
733 OP2IAT_1(opcode-ICMD_IALOAD);
739 COUNT(count_check_null);
740 COUNT(count_check_bound);
741 case ICMD_OPT_BALOAD:
742 case ICMD_OPT_CALOAD:
743 case ICMD_OPT_SALOAD:
744 COUNT(count_pcmd_mem);
748 /* pop 0 push 0 iinc */
754 count_store_depth[10]++;
756 count_store_depth[i]++;
761 if ((copy->varkind == LOCALVAR) &&
762 (copy->varnum == curstack->varnum)) {
763 copy->varkind = TEMPVAR;
772 /* pop 1 push 0 store */
779 i = opcode-ICMD_ISTORE;
780 locals[iptr->op1][i].type = i;
785 count_store_length[20]++;
787 count_store_length[i]++;
790 count_store_depth[10]++;
792 count_store_depth[i]++;
794 copy = curstack->prev;
797 if ((copy->varkind == LOCALVAR) &&
798 (copy->varnum == curstack->varnum)) {
799 copy->varkind = TEMPVAR;
805 if ((new - curstack) == 1) {
806 curstack->varkind = LOCALVAR;
807 curstack->varnum = iptr->op1;
809 STORE(opcode-ICMD_ISTORE);
819 COUNT(count_check_null);
820 COUNT(count_check_bound);
821 case ICMD_OPT_IASTORE:
822 case ICMD_OPT_LASTORE:
823 case ICMD_OPT_FASTORE:
824 case ICMD_OPT_DASTORE:
825 case ICMD_OPT_AASTORE:
826 COUNT(count_pcmd_mem);
827 OP3TIA_0(opcode-ICMD_IASTORE);
832 COUNT(count_check_null);
833 COUNT(count_check_bound);
834 COUNT(count_pcmd_mem);
835 case ICMD_OPT_BASTORE:
836 case ICMD_OPT_CASTORE:
837 case ICMD_OPT_SASTORE:
852 COUNT(count_pcmd_return);
853 OP1_0(opcode-ICMD_IRETURN);
854 superblockend = true;
858 COUNT(count_check_null);
862 superblockend = true;
866 COUNT(count_pcmd_mem);
870 /* pop 1 push 0 branch */
874 COUNT(count_pcmd_bra);
876 tbptr = block + block_index[iptr->op1];
877 MARKREACHED(tbptr, copy);
886 COUNT(count_pcmd_bra);
887 #ifdef CONDITIONAL_LOADCONST
889 tbptr = block + b_index;
890 if ((b_count >= 3) &&
891 ((b_index + 2) == block_index[iptr[0].op1]) &&
892 (tbptr[1].pre_count == 1) &&
893 (iptr[1].opc == ICMD_ICONST) &&
894 (iptr[2].opc == ICMD_GOTO) &&
895 ((b_index + 3) == block_index[iptr[2].op1]) &&
896 (tbptr[2].pre_count == 1) &&
897 (iptr[3].opc == ICMD_ICONST)) {
898 OP1_1(TYPE_INT, TYPE_INT);
899 switch (iptr[0].opc) {
901 iptr[0].opc = ICMD_IFNE_ICONST;
904 iptr[0].opc = ICMD_IFEQ_ICONST;
907 iptr[0].opc = ICMD_IFGE_ICONST;
910 iptr[0].opc = ICMD_IFLT_ICONST;
913 iptr[0].opc = ICMD_IFLE_ICONST;
916 iptr[0].opc = ICMD_IFGT_ICONST;
919 iptr[0].val.i = iptr[1].val.i;
920 iptr[1].opc = ICMD_ELSE_ICONST;
921 iptr[1].val.i = iptr[3].val.i;
922 iptr[2].opc = ICMD_NOP;
923 iptr[3].opc = ICMD_NOP;
924 tbptr[1].flags = BBDELETED;
925 tbptr[2].flags = BBDELETED;
928 if (tbptr[3].pre_count == 2) {
929 len += tbptr[3].icount + 3;
930 bptr->icount += tbptr[3].icount + 3;
931 tbptr[3].flags = BBDELETED;
945 tbptr = block + block_index[iptr->op1];
946 MARKREACHED(tbptr, copy);
949 /* pop 0 push 0 branch */
952 COUNT(count_pcmd_bra);
953 tbptr = block + block_index[iptr->op1];
954 MARKREACHED(tbptr, copy);
956 superblockend = true;
959 /* pop 1 push 0 table branch */
961 case ICMD_TABLESWITCH:
962 COUNT(count_pcmd_table);
965 tbptr = block + block_index[*s4ptr++]; /* default */
966 MARKREACHED(tbptr, copy);
967 i = *s4ptr++; /* low */
968 i = *s4ptr++ - i + 1; /* high */
970 tbptr = block + block_index[*s4ptr++];
971 MARKREACHED(tbptr, copy);
974 superblockend = true;
977 /* pop 1 push 0 table branch */
979 case ICMD_LOOKUPSWITCH:
980 COUNT(count_pcmd_table);
983 tbptr = block + block_index[*s4ptr++]; /* default */
984 MARKREACHED(tbptr, copy);
985 i = *s4ptr++; /* count */
987 tbptr = block + block_index[s4ptr[1]];
988 MARKREACHED(tbptr, copy);
992 superblockend = true;
995 case ICMD_NULLCHECKPOP:
996 case ICMD_MONITORENTER:
997 COUNT(count_check_null);
998 case ICMD_MONITOREXIT:
1002 /* pop 2 push 0 branch */
1004 case ICMD_IF_ICMPEQ:
1005 case ICMD_IF_ICMPNE:
1006 case ICMD_IF_ICMPLT:
1007 case ICMD_IF_ICMPGE:
1008 case ICMD_IF_ICMPGT:
1009 case ICMD_IF_ICMPLE:
1010 COUNT(count_pcmd_bra);
1012 tbptr = block + block_index[iptr->op1];
1013 MARKREACHED(tbptr, copy);
1016 case ICMD_IF_ACMPEQ:
1017 case ICMD_IF_ACMPNE:
1018 COUNT(count_pcmd_bra);
1020 tbptr = block + block_index[iptr->op1];
1021 MARKREACHED(tbptr, copy);
1027 COUNT(count_check_null);
1028 COUNT(count_pcmd_mem);
1029 OPTT2_0(iptr->op1,TYPE_ADR);
1033 if (! IS_2_WORD_TYPE(curstack->type)) {
1034 OP1_0ANY; /* second pop */
1037 iptr->opc = ICMD_POP;
1041 /* pop 0 push 1 dup */
1044 COUNT(count_dup_instruction);
1049 if (IS_2_WORD_TYPE(curstack->type)) {
1050 iptr->opc = ICMD_DUP;
1055 NEWSTACK(copy[-1].type, copy[-1].varkind,
1057 NEWSTACK(copy[ 0].type, copy[ 0].varkind,
1064 /* pop 2 push 3 dup */
1071 if (IS_2_WORD_TYPE(curstack->type)) {
1072 iptr->opc = ICMD_DUP_X1;
1080 /* pop 3 push 4 dup */
1083 if (IS_2_WORD_TYPE(curstack[-1].type)) {
1084 iptr->opc = ICMD_DUP_X1;
1093 if (IS_2_WORD_TYPE(curstack->type)) {
1094 if (IS_2_WORD_TYPE(curstack[-1].type)) {
1095 iptr->opc = ICMD_DUP_X1;
1099 iptr->opc = ICMD_DUP_X2;
1104 if (IS_2_WORD_TYPE(curstack[-2].type)) {
1105 iptr->opc = ICMD_DUP2_X1;
1113 /* pop 2 push 2 swap */
1122 if (!(SUPPORT_DIVISION)) {
1123 iptr[0].opc = ICMD_BUILTIN2;
1124 iptr[0].op1 = TYPE_INT;
1125 iptr[0].val.a = (functionptr) asm_builtin_idiv;
1126 isleafmethod = false;
1131 if (!(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV)) {
1132 iptr[0].opc = ICMD_BUILTIN2;
1133 iptr[0].op1 = TYPE_LNG;
1134 iptr[0].val.a = (functionptr) asm_builtin_ldiv;
1135 isleafmethod = false;
1140 if (!(SUPPORT_DIVISION)) {
1141 iptr[0].opc = ICMD_BUILTIN2;
1142 iptr[0].op1 = TYPE_INT;
1143 iptr[0].val.a = (functionptr) asm_builtin_irem;
1144 isleafmethod = false;
1149 if (!(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_MULDIV)) {
1150 iptr[0].opc = ICMD_BUILTIN2;
1151 iptr[0].op1 = TYPE_LNG;
1152 iptr[0].val.a = (functionptr) asm_builtin_lrem;
1153 isleafmethod = false;
1167 COUNT(count_pcmd_op);
1178 COUNT(count_pcmd_op);
1185 COUNT(count_pcmd_op);
1194 COUNT(count_pcmd_op);
1203 COUNT(count_pcmd_op);
1208 COUNT(count_pcmd_op);
1209 if ((len > 0) && (iptr[1].val.i == 0)) {
1210 switch (iptr[1].opc) {
1212 iptr[0].opc = ICMD_IF_LCMPEQ;
1214 iptr[0].op1 = iptr[1].op1;
1217 /* iptr[1].opc = ICMD_NOP; */
1219 tbptr = block + block_index[iptr->op1];
1220 MARKREACHED(tbptr, copy);
1221 COUNT(count_pcmd_bra);
1224 iptr[0].opc = ICMD_IF_LCMPNE;
1225 goto icmd_lcmp_if_tail;
1227 iptr[0].opc = ICMD_IF_LCMPLT;
1228 goto icmd_lcmp_if_tail;
1230 iptr[0].opc = ICMD_IF_LCMPGT;
1231 goto icmd_lcmp_if_tail;
1233 iptr[0].opc = ICMD_IF_LCMPLE;
1234 goto icmd_lcmp_if_tail;
1236 iptr[0].opc = ICMD_IF_LCMPGE;
1237 goto icmd_lcmp_if_tail;
1239 OPTT2_1(TYPE_LNG, TYPE_INT);
1243 OPTT2_1(TYPE_LNG, TYPE_INT);
1247 COUNT(count_pcmd_op);
1248 OPTT2_1(TYPE_FLT, TYPE_INT);
1252 COUNT(count_pcmd_op);
1253 OPTT2_1(TYPE_DBL, TYPE_INT);
1261 case ICMD_INT2SHORT:
1262 COUNT(count_pcmd_op);
1263 OP1_1(TYPE_INT, TYPE_INT);
1266 COUNT(count_pcmd_op);
1267 OP1_1(TYPE_LNG, TYPE_LNG);
1270 COUNT(count_pcmd_op);
1271 OP1_1(TYPE_FLT, TYPE_FLT);
1274 COUNT(count_pcmd_op);
1275 OP1_1(TYPE_DBL, TYPE_DBL);
1279 COUNT(count_pcmd_op);
1280 OP1_1(TYPE_INT, TYPE_LNG);
1283 COUNT(count_pcmd_op);
1284 OP1_1(TYPE_INT, TYPE_FLT);
1287 COUNT(count_pcmd_op);
1288 OP1_1(TYPE_INT, TYPE_DBL);
1291 COUNT(count_pcmd_op);
1292 OP1_1(TYPE_LNG, TYPE_INT);
1295 COUNT(count_pcmd_op);
1296 OP1_1(TYPE_LNG, TYPE_FLT);
1299 COUNT(count_pcmd_op);
1300 OP1_1(TYPE_LNG, TYPE_DBL);
1303 COUNT(count_pcmd_op);
1304 OP1_1(TYPE_FLT, TYPE_INT);
1307 COUNT(count_pcmd_op);
1308 OP1_1(TYPE_FLT, TYPE_LNG);
1311 COUNT(count_pcmd_op);
1312 OP1_1(TYPE_FLT, TYPE_DBL);
1315 COUNT(count_pcmd_op);
1316 OP1_1(TYPE_DBL, TYPE_INT);
1319 COUNT(count_pcmd_op);
1320 OP1_1(TYPE_DBL, TYPE_LNG);
1323 COUNT(count_pcmd_op);
1324 OP1_1(TYPE_DBL, TYPE_FLT);
1327 case ICMD_CHECKCAST:
1328 OP1_1(TYPE_ADR, TYPE_ADR);
1331 case ICMD_ARRAYLENGTH:
1332 case ICMD_INSTANCEOF:
1333 OP1_1(TYPE_ADR, TYPE_INT);
1337 case ICMD_ANEWARRAY:
1338 OP1_1(TYPE_INT, TYPE_ADR);
1342 COUNT(count_check_null);
1343 COUNT(count_pcmd_mem);
1344 OP1_1(TYPE_ADR, iptr->op1);
1349 case ICMD_GETSTATIC:
1350 COUNT(count_pcmd_mem);
1360 tbptr = block + block_index[iptr->op1];
1361 tbptr->type=BBTYPE_SBR;
1362 MARKREACHED(tbptr, copy);
1366 /* pop many push any */
1368 case ICMD_INVOKEVIRTUAL:
1369 case ICMD_INVOKESPECIAL:
1370 case ICMD_INVOKEINTERFACE:
1371 case ICMD_INVOKESTATIC:
1372 COUNT(count_pcmd_met);
1374 methodinfo *m = iptr->val.a;
1375 if (m->flags & ACC_STATIC)
1376 {COUNT(count_check_null);}
1378 if (i > arguments_num)
1382 if (! (copy->flags & SAVEDVAR)) {
1383 copy->varkind = ARGVAR;
1389 copy->flags |= SAVEDVAR;
1394 if (m->returntype != TYPE_VOID) {
1395 OP0_1(m->returntype);
1401 if (! (curstack->flags & SAVEDVAR)) {
1402 curstack->varkind = ARGVAR;
1403 curstack->varnum = 2;
1408 if (! (curstack->flags & SAVEDVAR)) {
1409 curstack->varkind = ARGVAR;
1410 curstack->varnum = 1;
1414 if (! (curstack->flags & SAVEDVAR)) {
1415 curstack->varkind = ARGVAR;
1416 curstack->varnum = 0;
1421 copy->flags |= SAVEDVAR;
1424 if (iptr->op1 != TYPE_VOID)
1428 case ICMD_MULTIANEWARRAY:
1430 if ((i + intreg_argnum) > arguments_num)
1431 arguments_num = i + intreg_argnum;
1434 if (! (copy->flags & SAVEDVAR)) {
1435 copy->varkind = ARGVAR;
1436 copy->varnum = i + intreg_argnum;
1441 copy->flags |= SAVEDVAR;
1450 printf("ICMD %d at %d\n", iptr->opc, (int)(iptr-instr));
1451 panic("Missing ICMD code during stack analysis");
1454 } /* while instructions */
1455 bptr->outstack = curstack;
1456 bptr->outdepth = stackdepth;
1460 superblockend = true;
1462 } /* while blocks */
1463 } while (repeat && ! deadcode);
1466 if (block_count > count_max_basic_blocks)
1467 count_max_basic_blocks = block_count;
1468 count_basic_blocks += block_count;
1469 if (instr_count > count_max_javainstr)
1470 count_max_javainstr = instr_count;
1471 count_javainstr += instr_count;
1472 if (stack_count > count_upper_bound_new_stack)
1473 count_upper_bound_new_stack = stack_count;
1474 if ((new - stack) > count_max_new_stack)
1475 count_max_new_stack = (new - stack);
1477 b_count = block_count;
1479 while (--b_count >= 0) {
1480 if (bptr->flags > BBREACHED) {
1481 if (bptr->indepth >= 10)
1482 count_block_stack[10]++;
1484 count_block_stack[bptr->indepth]++;
1487 count_block_size_distribution[len - 1]++;
1489 count_block_size_distribution[10]++;
1491 count_block_size_distribution[11]++;
1493 count_block_size_distribution[12]++;
1495 count_block_size_distribution[13]++;
1497 count_block_size_distribution[14]++;
1499 count_block_size_distribution[15]++;
1501 count_block_size_distribution[16]++;
1503 count_block_size_distribution[17]++;
1509 count_analyse_iterations[0]++;
1510 else if (loops == 2)
1511 count_analyse_iterations[1]++;
1512 else if (loops == 3)
1513 count_analyse_iterations[2]++;
1514 else if (loops == 4)
1515 count_analyse_iterations[3]++;
1517 count_analyse_iterations[4]++;
1519 if (block_count <= 5)
1520 count_method_bb_distribution[0]++;
1521 else if (block_count <= 10)
1522 count_method_bb_distribution[1]++;
1523 else if (block_count <= 15)
1524 count_method_bb_distribution[2]++;
1525 else if (block_count <= 20)
1526 count_method_bb_distribution[3]++;
1527 else if (block_count <= 30)
1528 count_method_bb_distribution[4]++;
1529 else if (block_count <= 40)
1530 count_method_bb_distribution[5]++;
1531 else if (block_count <= 50)
1532 count_method_bb_distribution[6]++;
1533 else if (block_count <= 75)
1534 count_method_bb_distribution[7]++;
1536 count_method_bb_distribution[8]++;
1541 static void print_stack(stackptr s) {
1557 if (s->flags & SAVEDVAR)
1558 switch (s->varkind) {
1560 if (s->flags & INMEMORY)
1561 printf(" M%02d", s->regoff);
1562 else if ((s->type == TYPE_FLT) || (s->type == TYPE_DBL))
1563 printf(" F%02d", s->regoff);
1565 printf(" %3s", regs[s->regoff]);
1568 printf(" I%02d", s->varnum);
1571 printf(" L%02d", s->varnum);
1574 printf(" A%02d", s->varnum);
1577 printf(" !%02d", j);
1580 switch (s->varkind) {
1582 if (s->flags & INMEMORY)
1583 printf(" m%02d", s->regoff);
1584 else if ((s->type == TYPE_FLT) || (s->type == TYPE_DBL))
1585 printf(" f%02d", s->regoff);
1587 printf(" %3s", regs[s->regoff]);
1590 printf(" i%02d", s->varnum);
1593 printf(" l%02d", s->varnum);
1596 printf(" a%02d", s->varnum);
1599 printf(" ?%02d", j);
1607 static void print_reg(stackptr s) {
1609 if (s->flags & SAVEDVAR)
1610 switch (s->varkind) {
1612 if (s->flags & INMEMORY)
1613 printf(" tm%02d", s->regoff);
1615 printf(" tr%02d", s->regoff);
1618 printf(" s %02d", s->varnum);
1621 printf(" l %02d", s->varnum);
1624 printf(" a %02d", s->varnum);
1627 printf(" ! %02d", s->varnum);
1630 switch (s->varkind) {
1632 if (s->flags & INMEMORY)
1633 printf(" Tm%02d", s->regoff);
1635 printf(" Tr%02d", s->regoff);
1638 printf(" S %02d", s->varnum);
1641 printf(" L %02d", s->varnum);
1644 printf(" A %02d", s->varnum);
1647 printf(" ? %02d", s->varnum);
1657 static char *builtin_name(functionptr bptr)
1659 builtin_descriptor *bdesc = builtin_desc;
1660 while ((bdesc->bptr != NULL) && (bdesc->bptr != bptr))
1666 static char *jit_type[] = {
1675 static void show_icmd_method()
1683 unicode_fprint(stdout, class->name);
1685 unicode_fprint(stdout, method->name);
1687 unicode_fprint(stdout, method->descriptor);
1688 printf ("\n\nMax locals: %d\n", (int) maxlocals);
1689 printf ("Max stack: %d\n", (int) maxstack);
1691 printf ("Exceptions:\n");
1692 for (i = 0; i < exceptiontablelength; i++) {
1693 printf(" L%03d ... ", block_index[extable[i].startpc]);
1694 printf("L%03d = ", block_index[extable[i].endpc]);
1695 printf("L%03d\n", block_index[extable[i].handlerpc]);
1698 printf ("Local Table:\n");
1699 for (i = 0; i < maxlocals; i++) {
1700 printf(" %3d: ", i);
1701 for (j = TYPE_INT; j <= TYPE_ADR; j++)
1702 if (locals[i][j].type >= 0) {
1703 printf(" (%s) ", jit_type[j]);
1704 if (locals[i][j].flags & INMEMORY)
1705 printf("m%2d", locals[i][j].regoff);
1706 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
1707 printf("f%02d", locals[i][j].regoff);
1709 printf("%3s", regs[locals[i][j].regoff]);
1715 printf ("Interface Table:\n");
1716 for (i = 0; i < maxstack; i++) {
1717 if ((interfaces[i][0].type >= 0) || (interfaces[i][1].type >= 0) ||
1718 (interfaces[i][2].type >= 0) || (interfaces[i][3].type >= 0) ||
1719 (interfaces[i][4].type >= 0)) {
1720 printf(" %3d: ", i);
1721 for (j = TYPE_INT; j <= TYPE_ADR; j++)
1722 if (interfaces[i][j].type >= 0) {
1723 printf(" (%s) ", jit_type[j]);
1724 if (interfaces[i][j].flags & SAVEDVAR) {
1725 if (interfaces[i][j].flags & INMEMORY)
1726 printf("M%2d", interfaces[i][j].regoff);
1727 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
1728 printf("F%02d", interfaces[i][j].regoff);
1730 printf("%3s", regs[interfaces[i][j].regoff]);
1733 if (interfaces[i][j].flags & INMEMORY)
1734 printf("m%2d", interfaces[i][j].regoff);
1735 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
1736 printf("f%02d", interfaces[i][j].regoff);
1738 printf("%3s", regs[interfaces[i][j].regoff]);
1746 if (showdisassemble) {
1747 s4ptr = (s4 *) (method->mcode + dseglen);
1748 for (i = 0; i < block[0].mpc; i += 4, s4ptr++) {
1749 disassinstr(*s4ptr, i);
1754 for (b = 0; b < block_count; b++)
1755 if (block[b].flags != BBDELETED) {
1756 deadcode = block[b].flags <= BBREACHED;
1759 for (j = maxstack; j > 0; j--)
1762 print_stack(block[b].instack);
1763 printf("] L%03d(%d):\n", b, block[b].pre_count);
1764 iptr = block[b].iinstr;
1766 for (last = i + block[b].icount; i < last; i++, iptr++) {
1769 for (j = maxstack; j > 0; j--)
1773 print_stack(iptr->dst);
1774 printf("] %4d %s", i, icmd_names[iptr->opc]);
1775 switch ((int) iptr->opc) {
1776 case ICMD_IADDCONST:
1777 case ICMD_ISUBCONST:
1778 case ICMD_IMULCONST:
1781 case ICMD_IREM0X10001:
1782 case ICMD_IANDCONST:
1784 case ICMD_IXORCONST:
1785 case ICMD_ISHLCONST:
1786 case ICMD_ISHRCONST:
1787 case ICMD_IUSHRCONST:
1789 case ICMD_ELSE_ICONST:
1790 case ICMD_IFEQ_ICONST:
1791 case ICMD_IFNE_ICONST:
1792 case ICMD_IFLT_ICONST:
1793 case ICMD_IFGE_ICONST:
1794 case ICMD_IFGT_ICONST:
1795 case ICMD_IFLE_ICONST:
1796 printf(" %d", iptr->val.i);
1798 case ICMD_LADDCONST:
1799 case ICMD_LSUBCONST:
1800 case ICMD_LMULCONST:
1803 case ICMD_LANDCONST:
1805 case ICMD_LXORCONST:
1806 case ICMD_LSHLCONST:
1807 case ICMD_LSHRCONST:
1808 case ICMD_LUSHRCONST:
1810 printf(" %ld", iptr->val.l);
1813 printf(" %f", iptr->val.f);
1816 printf(" %f", iptr->val.d);
1819 printf(" %p", iptr->val.a);
1823 printf(" %d,", ((fieldinfo *) iptr->val.a)->offset);
1824 case ICMD_PUTSTATIC:
1825 case ICMD_GETSTATIC:
1827 unicode_fprint(stdout,
1828 ((fieldinfo *) iptr->val.a)->name);
1831 printf(" %d + %d", iptr->op1, iptr->val.i);
1844 printf(" %d", iptr->op1);
1848 unicode_fprint(stdout,
1849 ((classinfo *) iptr->val.a)->name);
1852 switch (iptr->op1) {
1879 case ICMD_ANEWARRAY:
1882 unicode_fprint(stdout,
1883 ((classinfo *) iptr->val.a)->name);
1886 case ICMD_CHECKCAST:
1887 case ICMD_INSTANCEOF:
1889 classinfo *c = iptr->val.a;
1890 if (c->flags & ACC_INTERFACE)
1891 printf(" (INTERFACE) ");
1893 printf(" (CLASS,%3d) ", c->vftbl->diffval);
1894 unicode_fprint(stdout, c->name);
1900 printf(" %s", builtin_name((functionptr) iptr->val.a));
1902 case ICMD_INVOKEVIRTUAL:
1903 case ICMD_INVOKESPECIAL:
1904 case ICMD_INVOKESTATIC:
1905 case ICMD_INVOKEINTERFACE:
1907 unicode_fprint(stdout,
1908 ((methodinfo *) iptr->val.a)->class->name);
1910 unicode_fprint(stdout,
1911 ((methodinfo *) iptr->val.a)->name);
1925 printf("(%d) L%03d", iptr->val.i, block_index[iptr->op1]);
1930 case ICMD_IFNONNULL:
1931 case ICMD_IF_ICMPEQ:
1932 case ICMD_IF_ICMPNE:
1933 case ICMD_IF_ICMPLT:
1934 case ICMD_IF_ICMPGE:
1935 case ICMD_IF_ICMPGT:
1936 case ICMD_IF_ICMPLE:
1937 case ICMD_IF_LCMPEQ:
1938 case ICMD_IF_LCMPNE:
1939 case ICMD_IF_LCMPLT:
1940 case ICMD_IF_LCMPGE:
1941 case ICMD_IF_LCMPGT:
1942 case ICMD_IF_LCMPLE:
1943 case ICMD_IF_ACMPEQ:
1944 case ICMD_IF_ACMPNE:
1945 printf(" L%03d", block_index[iptr->op1]);
1947 case ICMD_TABLESWITCH:
1948 s4ptr = iptr->val.a;
1949 printf(" L%03d;", block_index[*s4ptr++]); /* default */
1950 j = *s4ptr++; /* low */
1951 j = *s4ptr++ - j; /* high */
1953 printf(" L%03d", block_index[*s4ptr++]);
1957 case ICMD_LOOKUPSWITCH:
1958 s4ptr = iptr->val.a;
1959 printf(" L%d", block_index[*s4ptr++]); /* default */
1960 j = *s4ptr++; /* count */
1962 printf(" L%03d", block_index[s4ptr[1]]);
1970 if (showdisassemble && (!deadcode)) {
1973 s4ptr = (s4 *) (method->mcode + dseglen + i);
1974 for (; i < block[b + 1].mpc; i += 4, s4ptr++) {
1975 disassinstr(*s4ptr, i);
1981 s4ptr = (s4 *) (method->mcode + dseglen + i);
1982 if (showdisassemble && (s4ptr < (s4 *) (method->mcode + method->mcodelength))) {
1984 for (; s4ptr < (s4 *) (method->mcode + method->mcodelength); i += 4, s4ptr++) {
1985 disassinstr(*s4ptr, i);
1993 * These are local overrides for various environment variables in Emacs.
1994 * Please do not remove this and leave it at the end of the file, where
1995 * Emacs will automagically detect them.
1996 * ---------------------------------------------------------------------
1999 * indent-tabs-mode: t