1 /* src/vm/jit/stack.c - stack analysis
3 Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
4 R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
5 C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
6 Institut f. Computersprachen - TU Wien
8 This file is part of CACAO.
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2, or (at
13 your option) any later version.
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
25 Contact: cacao@complang.tuwien.ac.at
27 Authors: Andreas Krall
29 Changes: Edwin Steiner
33 $Id: stack.c 3367 2005-10-06 09:23:36Z edwin $
47 #include "mm/memory.h"
48 #include "native/native.h"
49 #include "toolbox/logging.h"
50 #include "vm/global.h"
51 #include "vm/builtin.h"
52 #include "vm/options.h"
53 #include "vm/resolve.h"
54 #include "vm/statistics.h"
55 #include "vm/stringlocal.h"
56 #include "vm/tables.h"
57 #include "vm/jit/codegen.inc.h"
58 #include "vm/jit/disass.h"
59 #include "vm/jit/jit.h"
60 #include "vm/jit/reg.h"
61 #include "vm/jit/stack.h"
62 #include "vm/jit/lsra.h"
65 /* global variables ***********************************************************/
67 #if defined(USE_THREADS)
68 static java_objectheader show_icmd_lock;
72 /* stack_init ******************************************************************
74 Initialized the stack analysis subsystem (called by jit_init).
76 *******************************************************************************/
80 #if defined(USE_THREADS)
81 /* initialize the show lock */
83 show_icmd_lock.monitorPtr = get_dummyLR();
92 /**********************************************************************/
94 /**********************************************************************/
96 /* analyse_stack uses the intermediate code created by parse.c to
97 * build a model of the JVM operand stack for the current method.
99 * The following checks are performed:
100 * - check for operand stack underflow (before each instruction)
101 * - check for operand stack overflow (after[1] each instruction)
102 * - check for matching stack depth at merging points
103 * - check for matching basic types[2] at merging points
104 * - check basic types for instruction input (except for BUILTIN*
105 * opcodes, INVOKE* opcodes and MULTIANEWARRAY)
107 * [1]) Checking this after the instruction should be ok. parse.c
108 * counts the number of required stack slots in such a way that it is
109 * only vital that we don't exceed `maxstack` at basic block
112 * [2]) 'basic types' means the distinction between INT, LONG, FLOAT,
113 * DOUBLE and ADDRESS types. Subtypes of INT and different ADDRESS
114 * types are not discerned.
117 methodinfo *analyse_stack(methodinfo *m, codegendata *cd, registerdata *rd)
125 int opcode, i, len, loops;
126 int superblockend, repeat, deadcode;
134 builtintable_entry *bte;
135 unresolved_method *um;
142 argren = DMNEW(s4, cd->maxlocals); /* table for argument renaming */
143 for (i = 0; i < cd->maxlocals; i++)
148 m->basicblocks[0].flags = BBREACHED;
149 m->basicblocks[0].instack = 0;
150 m->basicblocks[0].indepth = 0;
152 for (i = 0; i < cd->exceptiontablelength; i++) {
153 bptr = &m->basicblocks[m->basicblockindex[cd->exceptiontable[i].handlerpc]];
154 bptr->flags = BBREACHED;
155 bptr->type = BBTYPE_EXH;
158 bptr->pre_count = 10000;
163 #if CONDITIONAL_LOADCONST
164 b_count = m->basicblockcount;
165 bptr = m->basicblocks;
166 while (--b_count >= 0) {
167 if (bptr->icount != 0) {
168 iptr = bptr->iinstr + bptr->icount - 1;
201 m->basicblocks[m->basicblockindex[iptr->op1]].pre_count++;
204 case ICMD_TABLESWITCH:
206 m->basicblocks[m->basicblockindex[*s4ptr++]].pre_count++;
207 i = *s4ptr++; /* low */
208 i = *s4ptr++ - i + 1; /* high */
210 m->basicblocks[m->basicblockindex[*s4ptr++]].pre_count++;
214 case ICMD_LOOKUPSWITCH:
216 m->basicblocks[m->basicblockindex[*s4ptr++]].pre_count++;
217 i = *s4ptr++; /* count */
219 m->basicblocks[m->basicblockindex[s4ptr[1]]].pre_count++;
230 #endif /* CONDITIONAL_LOADCONST */
235 b_count = m->basicblockcount;
236 bptr = m->basicblocks;
237 superblockend = true;
242 while (--b_count >= 0) {
243 if (bptr->flags == BBDELETED) {
246 } else if (superblockend && (bptr->flags < BBREACHED)) {
249 } else if (bptr->flags <= BBREACHED) {
251 stackdepth = bptr->indepth;
253 } else if (bptr->flags < BBREACHED) {
255 bptr->instack = copy;
256 bptr->indepth = stackdepth;
258 } else if (bptr->indepth != stackdepth) {
259 show_icmd_method(m, cd, rd);
260 printf("Block: %d, required depth: %d, current depth: %d\n", bptr->debug_nr, bptr->indepth, stackdepth);
261 *exceptionptr = new_verifyerror(m,"Stack depth mismatch");
265 curstack = bptr->instack;
267 superblockend = false;
268 bptr->flags = BBFINISHED;
271 b_index = bptr - m->basicblocks;
276 #if defined(USEBUILTINTABLE)
277 # if defined(ENABLE_INTRP)
280 bte = builtintable_get_automatic(opcode);
282 if (bte && bte->opcode == opcode) {
283 iptr->opc = ICMD_BUILTIN;
284 iptr->op1 = false; /* don't check for exception */
286 m->isleafmethod = false;
289 # if defined(ENABLE_INTRP)
292 #endif /* defined(USEBUILTINTABLE) */
299 COUNT(count_check_null);
302 case ICMD_IFEQ_ICONST:
303 case ICMD_IFNE_ICONST:
304 case ICMD_IFLT_ICONST:
305 case ICMD_IFGE_ICONST:
306 case ICMD_IFGT_ICONST:
307 case ICMD_IFLE_ICONST:
308 case ICMD_ELSE_ICONST:
313 #if defined(ENABLE_INTRP)
316 rd->locals[iptr->op1][TYPE_ADR].type = TYPE_ADR;
318 COUNT(count_pcmd_return);
320 superblockend = true;
323 /* pop 0 push 1 const */
326 COUNT(count_pcmd_load);
328 switch (iptr[1].opc) {
330 iptr[0].opc = ICMD_IADDCONST;
332 iptr[1].opc = ICMD_NOP;
333 OP1_1(TYPE_INT, TYPE_INT);
334 COUNT(count_pcmd_op);
337 iptr[0].opc = ICMD_ISUBCONST;
338 goto icmd_iconst_tail;
339 #if SUPPORT_CONST_MUL
341 iptr[0].opc = ICMD_IMULCONST;
342 goto icmd_iconst_tail;
343 #else /* SUPPORT_CONST_MUL */
345 if (iptr[0].val.i == 0x00000002)
347 else if (iptr[0].val.i == 0x00000004)
349 else if (iptr[0].val.i == 0x00000008)
351 else if (iptr[0].val.i == 0x00000010)
353 else if (iptr[0].val.i == 0x00000020)
355 else if (iptr[0].val.i == 0x00000040)
357 else if (iptr[0].val.i == 0x00000080)
359 else if (iptr[0].val.i == 0x00000100)
361 else if (iptr[0].val.i == 0x00000200)
363 else if (iptr[0].val.i == 0x00000400)
365 else if (iptr[0].val.i == 0x00000800)
367 else if (iptr[0].val.i == 0x00001000)
369 else if (iptr[0].val.i == 0x00002000)
371 else if (iptr[0].val.i == 0x00004000)
373 else if (iptr[0].val.i == 0x00008000)
375 else if (iptr[0].val.i == 0x00010000)
377 else if (iptr[0].val.i == 0x00020000)
379 else if (iptr[0].val.i == 0x00040000)
381 else if (iptr[0].val.i == 0x00080000)
383 else if (iptr[0].val.i == 0x00100000)
385 else if (iptr[0].val.i == 0x00200000)
387 else if (iptr[0].val.i == 0x00400000)
389 else if (iptr[0].val.i == 0x00800000)
391 else if (iptr[0].val.i == 0x01000000)
393 else if (iptr[0].val.i == 0x02000000)
395 else if (iptr[0].val.i == 0x04000000)
397 else if (iptr[0].val.i == 0x08000000)
399 else if (iptr[0].val.i == 0x10000000)
401 else if (iptr[0].val.i == 0x20000000)
403 else if (iptr[0].val.i == 0x40000000)
405 else if (iptr[0].val.i == 0x80000000)
411 iptr[0].opc = ICMD_IMULPOW2;
412 goto icmd_iconst_tail;
413 #endif /* SUPPORT_CONST_MUL */
415 if (iptr[0].val.i == 0x00000002)
417 else if (iptr[0].val.i == 0x00000004)
419 else if (iptr[0].val.i == 0x00000008)
421 else if (iptr[0].val.i == 0x00000010)
423 else if (iptr[0].val.i == 0x00000020)
425 else if (iptr[0].val.i == 0x00000040)
427 else if (iptr[0].val.i == 0x00000080)
429 else if (iptr[0].val.i == 0x00000100)
431 else if (iptr[0].val.i == 0x00000200)
433 else if (iptr[0].val.i == 0x00000400)
435 else if (iptr[0].val.i == 0x00000800)
437 else if (iptr[0].val.i == 0x00001000)
439 else if (iptr[0].val.i == 0x00002000)
441 else if (iptr[0].val.i == 0x00004000)
443 else if (iptr[0].val.i == 0x00008000)
445 else if (iptr[0].val.i == 0x00010000)
447 else if (iptr[0].val.i == 0x00020000)
449 else if (iptr[0].val.i == 0x00040000)
451 else if (iptr[0].val.i == 0x00080000)
453 else if (iptr[0].val.i == 0x00100000)
455 else if (iptr[0].val.i == 0x00200000)
457 else if (iptr[0].val.i == 0x00400000)
459 else if (iptr[0].val.i == 0x00800000)
461 else if (iptr[0].val.i == 0x01000000)
463 else if (iptr[0].val.i == 0x02000000)
465 else if (iptr[0].val.i == 0x04000000)
467 else if (iptr[0].val.i == 0x08000000)
469 else if (iptr[0].val.i == 0x10000000)
471 else if (iptr[0].val.i == 0x20000000)
473 else if (iptr[0].val.i == 0x40000000)
475 else if (iptr[0].val.i == 0x80000000)
481 iptr[0].opc = ICMD_IDIVPOW2;
482 goto icmd_iconst_tail;
484 /*log_text("stack.c: ICMD_ICONST/ICMD_IREM");*/
485 if ((iptr[0].val.i == 0x00000002) ||
486 (iptr[0].val.i == 0x00000004) ||
487 (iptr[0].val.i == 0x00000008) ||
488 (iptr[0].val.i == 0x00000010) ||
489 (iptr[0].val.i == 0x00000020) ||
490 (iptr[0].val.i == 0x00000040) ||
491 (iptr[0].val.i == 0x00000080) ||
492 (iptr[0].val.i == 0x00000100) ||
493 (iptr[0].val.i == 0x00000200) ||
494 (iptr[0].val.i == 0x00000400) ||
495 (iptr[0].val.i == 0x00000800) ||
496 (iptr[0].val.i == 0x00001000) ||
497 (iptr[0].val.i == 0x00002000) ||
498 (iptr[0].val.i == 0x00004000) ||
499 (iptr[0].val.i == 0x00008000) ||
500 (iptr[0].val.i == 0x00010000) ||
501 (iptr[0].val.i == 0x00020000) ||
502 (iptr[0].val.i == 0x00040000) ||
503 (iptr[0].val.i == 0x00080000) ||
504 (iptr[0].val.i == 0x00100000) ||
505 (iptr[0].val.i == 0x00200000) ||
506 (iptr[0].val.i == 0x00400000) ||
507 (iptr[0].val.i == 0x00800000) ||
508 (iptr[0].val.i == 0x01000000) ||
509 (iptr[0].val.i == 0x02000000) ||
510 (iptr[0].val.i == 0x04000000) ||
511 (iptr[0].val.i == 0x08000000) ||
512 (iptr[0].val.i == 0x10000000) ||
513 (iptr[0].val.i == 0x20000000) ||
514 (iptr[0].val.i == 0x40000000) ||
515 (iptr[0].val.i == 0x80000000)) {
516 iptr[0].opc = ICMD_IREMPOW2;
518 goto icmd_iconst_tail;
522 #if SUPPORT_CONST_LOGICAL
524 iptr[0].opc = ICMD_IANDCONST;
525 goto icmd_iconst_tail;
527 iptr[0].opc = ICMD_IORCONST;
528 goto icmd_iconst_tail;
530 iptr[0].opc = ICMD_IXORCONST;
531 goto icmd_iconst_tail;
532 #endif /* SUPPORT_CONST_LOGICAL */
534 iptr[0].opc = ICMD_ISHLCONST;
535 goto icmd_iconst_tail;
537 iptr[0].opc = ICMD_ISHRCONST;
538 goto icmd_iconst_tail;
540 iptr[0].opc = ICMD_IUSHRCONST;
541 goto icmd_iconst_tail;
542 #if SUPPORT_LONG_SHIFT
544 iptr[0].opc = ICMD_LSHLCONST;
545 goto icmd_lconst_tail;
547 iptr[0].opc = ICMD_LSHRCONST;
548 goto icmd_lconst_tail;
550 iptr[0].opc = ICMD_LUSHRCONST;
551 goto icmd_lconst_tail;
552 #endif /* SUPPORT_LONG_SHIFT */
554 iptr[0].opc = ICMD_IFEQ;
556 iptr[0].op1 = iptr[1].op1;
557 /* IF_ICMPxx is the last instruction in the */
558 /* basic block, just remove it */
559 /* iptr[1].opc = ICMD_NOP; */
564 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
566 iptr[0].target = (void *) tbptr;
568 MARKREACHED(tbptr, copy);
569 COUNT(count_pcmd_bra);
572 iptr[0].opc = ICMD_IFLT;
573 goto icmd_if_icmp_tail;
575 iptr[0].opc = ICMD_IFLE;
576 goto icmd_if_icmp_tail;
578 iptr[0].opc = ICMD_IFNE;
579 goto icmd_if_icmp_tail;
581 iptr[0].opc = ICMD_IFGT;
582 goto icmd_if_icmp_tail;
584 iptr[0].opc = ICMD_IFGE;
585 goto icmd_if_icmp_tail;
587 #if SUPPORT_CONST_STORE
592 # if defined(ENABLE_INTRP)
595 #if SUPPORT_CONST_STORE_ZERO_ONLY
596 if (iptr[0].val.i == 0) {
597 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
598 switch (iptr[1].opc) {
600 iptr[0].opc = ICMD_IASTORECONST;
603 iptr[0].opc = ICMD_BASTORECONST;
606 iptr[0].opc = ICMD_CASTORECONST;
609 iptr[0].opc = ICMD_SASTORECONST;
613 iptr[1].opc = ICMD_NOP;
614 OPTT2_0(TYPE_INT, TYPE_ADR);
615 COUNT(count_pcmd_op);
616 #if SUPPORT_CONST_STORE_ZERO_ONLY
619 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
620 # if defined(ENABLE_INTRP)
628 #if SUPPORT_CONST_STORE_ZERO_ONLY
629 if (iptr[0].val.i == 0) {
630 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
631 switch (iptr[1].opc) {
633 iptr[0].opc = ICMD_PUTSTATICCONST;
637 iptr[0].opc = ICMD_PUTFIELDCONST;
642 iptr[1].opc = ICMD_NOP;
643 iptr[0].op1 = TYPE_INT;
644 COUNT(count_pcmd_op);
645 #if SUPPORT_CONST_STORE_ZERO_ONLY
648 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
650 #endif /* SUPPORT_CONST_STORE */
660 COUNT(count_pcmd_load);
662 switch (iptr[1].opc) {
665 iptr[0].opc = ICMD_LADDCONST;
667 iptr[1].opc = ICMD_NOP;
668 OP1_1(TYPE_LNG,TYPE_LNG);
669 COUNT(count_pcmd_op);
672 iptr[0].opc = ICMD_LSUBCONST;
673 goto icmd_lconst_tail;
674 #endif /* SUPPORT_LONG_ADD */
675 #if SUPPORT_LONG_MUL && SUPPORT_CONST_MUL
677 iptr[0].opc = ICMD_LMULCONST;
678 goto icmd_lconst_tail;
679 #else /* SUPPORT_LONG_MUL && SUPPORT_CONST_MUL */
680 # if SUPPORT_LONG_SHIFT
682 if (iptr[0].val.l == 0x00000002)
684 else if (iptr[0].val.l == 0x00000004)
686 else if (iptr[0].val.l == 0x00000008)
688 else if (iptr[0].val.l == 0x00000010)
690 else if (iptr[0].val.l == 0x00000020)
692 else if (iptr[0].val.l == 0x00000040)
694 else if (iptr[0].val.l == 0x00000080)
696 else if (iptr[0].val.l == 0x00000100)
698 else if (iptr[0].val.l == 0x00000200)
700 else if (iptr[0].val.l == 0x00000400)
702 else if (iptr[0].val.l == 0x00000800)
704 else if (iptr[0].val.l == 0x00001000)
706 else if (iptr[0].val.l == 0x00002000)
708 else if (iptr[0].val.l == 0x00004000)
710 else if (iptr[0].val.l == 0x00008000)
712 else if (iptr[0].val.l == 0x00010000)
714 else if (iptr[0].val.l == 0x00020000)
716 else if (iptr[0].val.l == 0x00040000)
718 else if (iptr[0].val.l == 0x00080000)
720 else if (iptr[0].val.l == 0x00100000)
722 else if (iptr[0].val.l == 0x00200000)
724 else if (iptr[0].val.l == 0x00400000)
726 else if (iptr[0].val.l == 0x00800000)
728 else if (iptr[0].val.l == 0x01000000)
730 else if (iptr[0].val.l == 0x02000000)
732 else if (iptr[0].val.l == 0x04000000)
734 else if (iptr[0].val.l == 0x08000000)
736 else if (iptr[0].val.l == 0x10000000)
738 else if (iptr[0].val.l == 0x20000000)
740 else if (iptr[0].val.l == 0x40000000)
742 else if (iptr[0].val.l == 0x80000000)
748 iptr[0].opc = ICMD_LMULPOW2;
749 goto icmd_lconst_tail;
750 # endif /* SUPPORT_LONG_SHIFT */
751 #endif /* SUPPORT_LONG_MUL && SUPPORT_CONST_MUL */
754 if (iptr[0].val.l == 0x00000002)
756 else if (iptr[0].val.l == 0x00000004)
758 else if (iptr[0].val.l == 0x00000008)
760 else if (iptr[0].val.l == 0x00000010)
762 else if (iptr[0].val.l == 0x00000020)
764 else if (iptr[0].val.l == 0x00000040)
766 else if (iptr[0].val.l == 0x00000080)
768 else if (iptr[0].val.l == 0x00000100)
770 else if (iptr[0].val.l == 0x00000200)
772 else if (iptr[0].val.l == 0x00000400)
774 else if (iptr[0].val.l == 0x00000800)
776 else if (iptr[0].val.l == 0x00001000)
778 else if (iptr[0].val.l == 0x00002000)
780 else if (iptr[0].val.l == 0x00004000)
782 else if (iptr[0].val.l == 0x00008000)
784 else if (iptr[0].val.l == 0x00010000)
786 else if (iptr[0].val.l == 0x00020000)
788 else if (iptr[0].val.l == 0x00040000)
790 else if (iptr[0].val.l == 0x00080000)
792 else if (iptr[0].val.l == 0x00100000)
794 else if (iptr[0].val.l == 0x00200000)
796 else if (iptr[0].val.l == 0x00400000)
798 else if (iptr[0].val.l == 0x00800000)
800 else if (iptr[0].val.l == 0x01000000)
802 else if (iptr[0].val.l == 0x02000000)
804 else if (iptr[0].val.l == 0x04000000)
806 else if (iptr[0].val.l == 0x08000000)
808 else if (iptr[0].val.l == 0x10000000)
810 else if (iptr[0].val.l == 0x20000000)
812 else if (iptr[0].val.l == 0x40000000)
814 else if (iptr[0].val.l == 0x80000000)
820 iptr[0].opc = ICMD_LDIVPOW2;
821 goto icmd_lconst_tail;
823 if ((iptr[0].val.l == 0x00000002) ||
824 (iptr[0].val.l == 0x00000004) ||
825 (iptr[0].val.l == 0x00000008) ||
826 (iptr[0].val.l == 0x00000010) ||
827 (iptr[0].val.l == 0x00000020) ||
828 (iptr[0].val.l == 0x00000040) ||
829 (iptr[0].val.l == 0x00000080) ||
830 (iptr[0].val.l == 0x00000100) ||
831 (iptr[0].val.l == 0x00000200) ||
832 (iptr[0].val.l == 0x00000400) ||
833 (iptr[0].val.l == 0x00000800) ||
834 (iptr[0].val.l == 0x00001000) ||
835 (iptr[0].val.l == 0x00002000) ||
836 (iptr[0].val.l == 0x00004000) ||
837 (iptr[0].val.l == 0x00008000) ||
838 (iptr[0].val.l == 0x00010000) ||
839 (iptr[0].val.l == 0x00020000) ||
840 (iptr[0].val.l == 0x00040000) ||
841 (iptr[0].val.l == 0x00080000) ||
842 (iptr[0].val.l == 0x00100000) ||
843 (iptr[0].val.l == 0x00200000) ||
844 (iptr[0].val.l == 0x00400000) ||
845 (iptr[0].val.l == 0x00800000) ||
846 (iptr[0].val.l == 0x01000000) ||
847 (iptr[0].val.l == 0x02000000) ||
848 (iptr[0].val.l == 0x04000000) ||
849 (iptr[0].val.l == 0x08000000) ||
850 (iptr[0].val.l == 0x10000000) ||
851 (iptr[0].val.l == 0x20000000) ||
852 (iptr[0].val.l == 0x40000000) ||
853 (iptr[0].val.l == 0x80000000)) {
854 iptr[0].opc = ICMD_LREMPOW2;
856 goto icmd_lconst_tail;
860 #endif /* SUPPORT_LONG_DIV */
861 #if SUPPORT_LONG_LOGICAL && SUPPORT_CONST_LOGICAL
864 iptr[0].opc = ICMD_LANDCONST;
865 goto icmd_lconst_tail;
867 iptr[0].opc = ICMD_LORCONST;
868 goto icmd_lconst_tail;
870 iptr[0].opc = ICMD_LXORCONST;
871 goto icmd_lconst_tail;
872 #endif /* SUPPORT_LONG_LOGICAL && SUPPORT_CONST_LOGICAL */
873 #if !defined(NOLONG_CONDITIONAL)
875 if ((len > 1) && (iptr[2].val.i == 0)) {
876 switch (iptr[2].opc) {
878 iptr[0].opc = ICMD_IF_LEQ;
879 icmd_lconst_lcmp_tail:
880 iptr[0].op1 = iptr[2].op1;
883 /* iptr[1].opc = ICMD_NOP;
884 iptr[2].opc = ICMD_NOP; */
886 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
888 iptr[0].target = (void *) tbptr;
890 MARKREACHED(tbptr, copy);
891 COUNT(count_pcmd_bra);
892 COUNT(count_pcmd_op);
895 iptr[0].opc = ICMD_IF_LNE;
896 goto icmd_lconst_lcmp_tail;
898 iptr[0].opc = ICMD_IF_LLT;
899 goto icmd_lconst_lcmp_tail;
901 iptr[0].opc = ICMD_IF_LGT;
902 goto icmd_lconst_lcmp_tail;
904 iptr[0].opc = ICMD_IF_LLE;
905 goto icmd_lconst_lcmp_tail;
907 iptr[0].opc = ICMD_IF_LGE;
908 goto icmd_lconst_lcmp_tail;
911 } /* switch (iptr[2].opc) */
912 } /* if (iptr[2].val.i == 0) */
916 #endif /* !defined(NOLONG_CONDITIONAL) */
918 #if SUPPORT_CONST_STORE
920 # if defined(ENABLE_INTRP)
923 #if SUPPORT_CONST_STORE_ZERO_ONLY
924 if (iptr[0].val.l == 0) {
925 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
926 iptr[0].opc = ICMD_LASTORECONST;
927 iptr[1].opc = ICMD_NOP;
928 OPTT2_0(TYPE_INT, TYPE_ADR);
929 COUNT(count_pcmd_op);
930 #if SUPPORT_CONST_STORE_ZERO_ONLY
933 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
934 # if defined(ENABLE_INTRP)
942 #if SUPPORT_CONST_STORE_ZERO_ONLY
943 if (iptr[0].val.l == 0) {
944 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
945 switch (iptr[1].opc) {
947 iptr[0].opc = ICMD_PUTSTATICCONST;
951 iptr[0].opc = ICMD_PUTFIELDCONST;
956 iptr[1].opc = ICMD_NOP;
957 iptr[0].op1 = TYPE_LNG;
958 COUNT(count_pcmd_op);
959 #if SUPPORT_CONST_STORE_ZERO_ONLY
962 #endif /* SUPPORT_CONST_STORE_ZERO_ONLY */
964 #endif /* SUPPORT_CONST_STORE */
974 COUNT(count_pcmd_load);
979 COUNT(count_pcmd_load);
984 COUNT(count_pcmd_load);
985 #if SUPPORT_CONST_STORE
986 if (len > 0 && iptr->val.a == 0) {
987 switch (iptr[1].opc) {
988 #if !defined(__POWERPC__) && !defined(__X86_64__) && !defined(__I386__) && !defined(__ALPHA__) && !defined(__MIPS__)
990 if (iptr[1].val.fp != BUILTIN_aastore) {
998 switch (iptr[1].opc) {
1000 iptr[0].opc = ICMD_AASTORECONST;
1001 OPTT2_0(TYPE_INT, TYPE_ADR);
1003 case ICMD_PUTSTATIC:
1004 iptr[0].opc = ICMD_PUTSTATICCONST;
1005 iptr[0].op1 = TYPE_ADR;
1009 iptr[0].opc = ICMD_PUTFIELDCONST;
1010 iptr[0].op1 = TYPE_ADR;
1015 iptr[1].opc = ICMD_NOP;
1016 COUNT(count_pcmd_op);
1020 PUSHCONST(TYPE_ADR);
1023 #endif /* SUPPORT_CONST_STORE */
1024 PUSHCONST(TYPE_ADR);
1027 /* pop 0 push 1 load */
1034 COUNT(count_load_instruction);
1035 i = opcode - ICMD_ILOAD;
1036 iptr->op1 = argren[iptr->op1];
1037 #if defined(ENABLE_INTRP)
1040 rd->locals[iptr->op1][i].type = i;
1041 LOAD(i, LOCALVAR, iptr->op1);
1051 COUNT(count_check_null);
1052 COUNT(count_check_bound);
1053 COUNT(count_pcmd_mem);
1054 OP2IAT_1(opcode - ICMD_IALOAD);
1060 COUNT(count_check_null);
1061 COUNT(count_check_bound);
1062 COUNT(count_pcmd_mem);
1066 /* pop 0 push 0 iinc */
1069 #if defined(STATISTICS)
1073 count_store_depth[10]++;
1075 count_store_depth[i]++;
1081 if ((copy->varkind == LOCALVAR) &&
1082 (copy->varnum == iptr->op1)) {
1083 copy->varkind = TEMPVAR;
1092 /* pop 1 push 0 store */
1102 i = opcode - ICMD_ISTORE;
1103 #if defined(ENABLE_INTRP)
1106 rd->locals[iptr->op1][i].type = i;
1107 #if defined(STATISTICS)
1112 count_store_length[20]++;
1114 count_store_length[i]++;
1117 count_store_depth[10]++;
1119 count_store_depth[i]++;
1122 copy = curstack->prev;
1125 if ((copy->varkind == LOCALVAR) &&
1126 (copy->varnum == iptr->op1)) {
1127 copy->varkind = TEMPVAR;
1133 if ((new - curstack) == 1) {
1134 curstack->varkind = LOCALVAR;
1135 curstack->varnum = iptr->op1;
1137 STORE(opcode - ICMD_ISTORE);
1143 COUNT(count_check_null);
1144 COUNT(count_check_bound);
1145 COUNT(count_pcmd_mem);
1147 bte = (builtintable_entry *) iptr->val.a;
1151 if (md->memuse > rd->memuse)
1152 rd->memuse = md->memuse;
1153 if (md->argintreguse > rd->argintreguse)
1154 rd->argintreguse = md->argintreguse;
1156 /* make all stack variables saved */
1160 copy->flags |= SAVEDVAR;
1171 COUNT(count_check_null);
1172 COUNT(count_check_bound);
1173 COUNT(count_pcmd_mem);
1174 OP3TIA_0(opcode - ICMD_IASTORE);
1180 COUNT(count_check_null);
1181 COUNT(count_check_bound);
1182 COUNT(count_pcmd_mem);
1189 #ifdef TYPECHECK_STACK_COMPCAT
1192 if (IS_2_WORD_TYPE(curstack->type)) {
1193 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1206 md_return_alloc(m, rd, opcode - ICMD_IRETURN, curstack);
1207 COUNT(count_pcmd_return);
1208 OP1_0(opcode - ICMD_IRETURN);
1209 superblockend = true;
1213 COUNT(count_check_null);
1217 superblockend = true;
1220 case ICMD_PUTSTATIC:
1221 COUNT(count_pcmd_mem);
1225 /* pop 1 push 0 branch */
1228 case ICMD_IFNONNULL:
1229 COUNT(count_pcmd_bra);
1231 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
1233 iptr[0].target = (void *) tbptr;
1235 MARKREACHED(tbptr, copy);
1244 COUNT(count_pcmd_bra);
1245 #if CONDITIONAL_LOADCONST
1246 # if defined(ENABLE_INTRP)
1249 tbptr = m->basicblocks + b_index;
1250 if ((b_count >= 3) &&
1251 ((b_index + 2) == m->basicblockindex[iptr[0].op1]) &&
1252 (tbptr[1].pre_count == 1) &&
1253 (tbptr[1].iinstr[0].opc == ICMD_ICONST) &&
1254 (tbptr[1].iinstr[1].opc == ICMD_GOTO) &&
1255 ((b_index + 3) == m->basicblockindex[tbptr[1].iinstr[1].op1]) &&
1256 (tbptr[2].pre_count == 1) &&
1257 (tbptr[2].iinstr[0].opc == ICMD_ICONST) &&
1258 (tbptr[2].icount==1)) {
1259 /*printf("tbptr[2].icount=%d\n",tbptr[2].icount);*/
1260 OP1_1(TYPE_INT, TYPE_INT);
1261 switch (iptr[0].opc) {
1263 iptr[0].opc = ICMD_IFNE_ICONST;
1266 iptr[0].opc = ICMD_IFEQ_ICONST;
1269 iptr[0].opc = ICMD_IFGE_ICONST;
1272 iptr[0].opc = ICMD_IFLT_ICONST;
1275 iptr[0].opc = ICMD_IFLE_ICONST;
1278 iptr[0].opc = ICMD_IFGT_ICONST;
1282 iptr[0].val.i = iptr[1].val.i;
1283 iptr[1].opc = ICMD_ELSE_ICONST;
1284 iptr[1].val.i = iptr[3].val.i;
1285 iptr[2].opc = ICMD_NOP;
1286 iptr[3].opc = ICMD_NOP;
1288 /* HACK: save compare value in iptr[1].op1 */
1289 iptr[1].op1 = iptr[0].val.i;
1290 iptr[0].val.i = tbptr[1].iinstr[0].val.i;
1291 iptr[1].opc = ICMD_ELSE_ICONST;
1292 iptr[1].val.i = tbptr[2].iinstr[0].val.i;
1293 tbptr[1].iinstr[0].opc = ICMD_NOP;
1294 tbptr[1].iinstr[1].opc = ICMD_NOP;
1295 tbptr[2].iinstr[0].opc = ICMD_NOP;
1297 tbptr[1].flags = BBDELETED;
1298 tbptr[2].flags = BBDELETED;
1299 tbptr[1].icount = 0;
1300 tbptr[2].icount = 0;
1301 if (tbptr[3].pre_count == 2) {
1302 len += tbptr[3].icount + 3;
1303 bptr->icount += tbptr[3].icount + 3;
1304 tbptr[3].flags = BBDELETED;
1305 tbptr[3].icount = 0;
1315 # if defined(ENABLE_INTRP)
1319 #endif /* CONDITIONAL_LOADCONST */
1323 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
1325 iptr[0].target = (void *) tbptr;
1327 MARKREACHED(tbptr, copy);
1330 /* pop 0 push 0 branch */
1333 COUNT(count_pcmd_bra);
1334 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
1336 iptr[0].target = (void *) tbptr;
1338 MARKREACHED(tbptr, copy);
1340 superblockend = true;
1343 /* pop 1 push 0 table branch */
1345 case ICMD_TABLESWITCH:
1346 COUNT(count_pcmd_table);
1348 s4ptr = iptr->val.a;
1349 tbptr = m->basicblocks + m->basicblockindex[*s4ptr++];
1350 MARKREACHED(tbptr, copy);
1351 i = *s4ptr++; /* low */
1352 i = *s4ptr++ - i + 1; /* high */
1354 tptr = DMNEW(void*, i+1);
1355 iptr->target = (void *) tptr;
1357 tptr[0] = (void *) tbptr;
1361 tbptr = m->basicblocks + m->basicblockindex[*s4ptr++];
1363 tptr[0] = (void *) tbptr;
1366 MARKREACHED(tbptr, copy);
1369 superblockend = true;
1372 /* pop 1 push 0 table branch */
1374 case ICMD_LOOKUPSWITCH:
1375 COUNT(count_pcmd_table);
1377 s4ptr = iptr->val.a;
1378 tbptr = m->basicblocks + m->basicblockindex[*s4ptr++];
1379 MARKREACHED(tbptr, copy);
1380 i = *s4ptr++; /* count */
1382 tptr = DMNEW(void*, i+1);
1383 iptr->target = (void *) tptr;
1385 tptr[0] = (void *) tbptr;
1389 tbptr = m->basicblocks + m->basicblockindex[s4ptr[1]];
1391 tptr[0] = (void *) tbptr;
1394 MARKREACHED(tbptr, copy);
1398 superblockend = true;
1401 case ICMD_MONITORENTER:
1402 COUNT(count_check_null);
1403 case ICMD_MONITOREXIT:
1407 /* pop 2 push 0 branch */
1409 case ICMD_IF_ICMPEQ:
1410 case ICMD_IF_ICMPNE:
1411 case ICMD_IF_ICMPLT:
1412 case ICMD_IF_ICMPGE:
1413 case ICMD_IF_ICMPGT:
1414 case ICMD_IF_ICMPLE:
1415 COUNT(count_pcmd_bra);
1417 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
1419 iptr[0].target = (void *) tbptr;
1421 MARKREACHED(tbptr, copy);
1424 case ICMD_IF_ACMPEQ:
1425 case ICMD_IF_ACMPNE:
1426 COUNT(count_pcmd_bra);
1428 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
1430 iptr[0].target = (void *) tbptr;
1432 MARKREACHED(tbptr, copy);
1438 COUNT(count_check_null);
1439 COUNT(count_pcmd_mem);
1440 OPTT2_0(iptr->op1,TYPE_ADR);
1445 if (!IS_2_WORD_TYPE(curstack->type)) {
1447 #ifdef TYPECHECK_STACK_COMPCAT
1450 if (IS_2_WORD_TYPE(curstack->prev->type)) {
1451 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1456 OP1_0ANY; /* second pop */
1459 iptr->opc = ICMD_POP;
1463 /* pop 0 push 1 dup */
1466 #ifdef TYPECHECK_STACK_COMPCAT
1469 if (IS_2_WORD_TYPE(curstack->type)) {
1470 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1475 COUNT(count_dup_instruction);
1481 if (IS_2_WORD_TYPE(curstack->type)) {
1483 iptr->opc = ICMD_DUP;
1488 /* ..., ????, cat1 */
1489 #ifdef TYPECHECK_STACK_COMPCAT
1491 if (IS_2_WORD_TYPE(curstack->prev->type)) {
1492 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1498 NEWSTACK(copy->prev->type, copy->prev->varkind,
1499 copy->prev->varnum);
1500 NEWSTACK(copy->type, copy->varkind,
1507 /* pop 2 push 3 dup */
1510 #ifdef TYPECHECK_STACK_COMPCAT
1513 if (IS_2_WORD_TYPE(curstack->type) ||
1514 IS_2_WORD_TYPE(curstack->prev->type)) {
1515 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1525 if (IS_2_WORD_TYPE(curstack->type)) {
1526 /* ..., ????, cat2 */
1527 #ifdef TYPECHECK_STACK_COMPCAT
1529 if (IS_2_WORD_TYPE(curstack->prev->type)) {
1530 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1535 iptr->opc = ICMD_DUP_X1;
1539 /* ..., ????, cat1 */
1540 #ifdef TYPECHECK_STACK_COMPCAT
1543 if (IS_2_WORD_TYPE(curstack->prev->type)
1544 || IS_2_WORD_TYPE(curstack->prev->prev->type)) {
1545 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1554 /* pop 3 push 4 dup */
1558 if (IS_2_WORD_TYPE(curstack->prev->type)) {
1559 /* ..., cat2, ???? */
1560 #ifdef TYPECHECK_STACK_COMPCAT
1562 if (IS_2_WORD_TYPE(curstack->type)) {
1563 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1568 iptr->opc = ICMD_DUP_X1;
1572 /* ..., cat1, ???? */
1573 #ifdef TYPECHECK_STACK_COMPCAT
1576 if (IS_2_WORD_TYPE(curstack->type)
1577 || IS_2_WORD_TYPE(curstack->prev->prev->type)) {
1578 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1589 if (IS_2_WORD_TYPE(curstack->type)) {
1590 /* ..., ????, cat2 */
1591 if (IS_2_WORD_TYPE(curstack->prev->type)) {
1592 /* ..., cat2, cat2 */
1593 iptr->opc = ICMD_DUP_X1;
1597 /* ..., cat1, cat2 */
1598 #ifdef TYPECHECK_STACK_COMPCAT
1601 if (IS_2_WORD_TYPE(curstack->prev->prev->type)) {
1602 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1607 iptr->opc = ICMD_DUP_X2;
1613 /* ..., ????, ????, cat1 */
1614 if (IS_2_WORD_TYPE(curstack->prev->prev->type)) {
1615 /* ..., cat2, ????, cat1 */
1616 #ifdef TYPECHECK_STACK_COMPCAT
1618 if (IS_2_WORD_TYPE(curstack->prev->type)) {
1619 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1624 iptr->opc = ICMD_DUP2_X1;
1628 /* ..., cat1, ????, cat1 */
1629 #ifdef TYPECHECK_STACK_COMPCAT
1632 if (IS_2_WORD_TYPE(curstack->prev->type)
1633 || IS_2_WORD_TYPE(curstack->prev->prev->prev->type)) {
1634 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1644 /* pop 2 push 2 swap */
1647 #ifdef TYPECHECK_STACK_COMPCAT
1650 if (IS_2_WORD_TYPE(curstack->type)
1651 || IS_2_WORD_TYPE(curstack->prev->type)) {
1652 *exceptionptr = new_verifyerror(m, "Attempt to split long or double on the stack");
1664 #if !SUPPORT_DIVISION
1665 bte = (builtintable_entry *) iptr->val.a;
1669 if (md->memuse > rd->memuse)
1670 rd->memuse = md->memuse;
1671 if (md->argintreguse > rd->argintreguse)
1672 rd->argintreguse = md->argintreguse;
1674 /* make all stack variables saved */
1678 copy->flags |= SAVEDVAR;
1681 #endif /* !SUPPORT_DIVISION */
1692 COUNT(count_pcmd_op);
1698 #if !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV)
1699 bte = (builtintable_entry *) iptr->val.a;
1703 if (md->memuse > rd->memuse)
1704 rd->memuse = md->memuse;
1705 if (md->argintreguse > rd->argintreguse)
1706 rd->argintreguse = md->argintreguse;
1708 /* make all stack variables saved */
1712 copy->flags |= SAVEDVAR;
1715 #endif /* !(SUPPORT_DIVISION && SUPPORT_LONG && SUPPORT_LONG_DIV) */
1720 #if SUPPORT_LONG_LOGICAL
1724 #endif /* SUPPORT_LONG_LOGICAL */
1725 COUNT(count_pcmd_op);
1732 COUNT(count_pcmd_op);
1741 COUNT(count_pcmd_op);
1750 COUNT(count_pcmd_op);
1755 COUNT(count_pcmd_op);
1756 #if !defined(NOLONG_CONDITIONAL)
1757 if ((len > 0) && (iptr[1].val.i == 0)) {
1758 switch (iptr[1].opc) {
1760 iptr[0].opc = ICMD_IF_LCMPEQ;
1762 iptr[0].op1 = iptr[1].op1;
1765 /* iptr[1].opc = ICMD_NOP; */
1767 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
1769 iptr[0].target = (void *) tbptr;
1771 MARKREACHED(tbptr, copy);
1772 COUNT(count_pcmd_bra);
1775 iptr[0].opc = ICMD_IF_LCMPNE;
1776 goto icmd_lcmp_if_tail;
1778 iptr[0].opc = ICMD_IF_LCMPLT;
1779 goto icmd_lcmp_if_tail;
1781 iptr[0].opc = ICMD_IF_LCMPGT;
1782 goto icmd_lcmp_if_tail;
1784 iptr[0].opc = ICMD_IF_LCMPLE;
1785 goto icmd_lcmp_if_tail;
1787 iptr[0].opc = ICMD_IF_LCMPGE;
1788 goto icmd_lcmp_if_tail;
1790 OPTT2_1(TYPE_LNG, TYPE_INT);
1795 OPTT2_1(TYPE_LNG, TYPE_INT);
1799 COUNT(count_pcmd_op);
1800 OPTT2_1(TYPE_FLT, TYPE_INT);
1804 COUNT(count_pcmd_op);
1805 OPTT2_1(TYPE_DBL, TYPE_INT);
1813 case ICMD_INT2SHORT:
1814 COUNT(count_pcmd_op);
1815 OP1_1(TYPE_INT, TYPE_INT);
1818 COUNT(count_pcmd_op);
1819 OP1_1(TYPE_LNG, TYPE_LNG);
1822 COUNT(count_pcmd_op);
1823 OP1_1(TYPE_FLT, TYPE_FLT);
1826 COUNT(count_pcmd_op);
1827 OP1_1(TYPE_DBL, TYPE_DBL);
1831 COUNT(count_pcmd_op);
1832 OP1_1(TYPE_INT, TYPE_LNG);
1835 COUNT(count_pcmd_op);
1836 OP1_1(TYPE_INT, TYPE_FLT);
1839 COUNT(count_pcmd_op);
1840 OP1_1(TYPE_INT, TYPE_DBL);
1843 COUNT(count_pcmd_op);
1844 OP1_1(TYPE_LNG, TYPE_INT);
1847 COUNT(count_pcmd_op);
1848 OP1_1(TYPE_LNG, TYPE_FLT);
1851 COUNT(count_pcmd_op);
1852 OP1_1(TYPE_LNG, TYPE_DBL);
1855 COUNT(count_pcmd_op);
1856 OP1_1(TYPE_FLT, TYPE_INT);
1859 COUNT(count_pcmd_op);
1860 OP1_1(TYPE_FLT, TYPE_LNG);
1863 COUNT(count_pcmd_op);
1864 OP1_1(TYPE_FLT, TYPE_DBL);
1867 COUNT(count_pcmd_op);
1868 OP1_1(TYPE_DBL, TYPE_INT);
1871 COUNT(count_pcmd_op);
1872 OP1_1(TYPE_DBL, TYPE_LNG);
1875 COUNT(count_pcmd_op);
1876 OP1_1(TYPE_DBL, TYPE_FLT);
1879 case ICMD_CHECKCAST:
1880 OP1_1(TYPE_ADR, TYPE_ADR);
1883 case ICMD_ARRAYCHECKCAST:
1884 bte = (builtintable_entry *) iptr->val.a;
1887 if (md->memuse > rd->memuse)
1888 rd->memuse = md->memuse;
1889 if (md->argintreguse > rd->argintreguse)
1890 rd->argintreguse = md->argintreguse;
1892 /* make all stack variables saved */
1896 copy->flags |= SAVEDVAR;
1900 OP1_1(TYPE_ADR, TYPE_ADR);
1903 case ICMD_INSTANCEOF:
1904 case ICMD_ARRAYLENGTH:
1905 OP1_1(TYPE_ADR, TYPE_INT);
1909 case ICMD_ANEWARRAY:
1910 OP1_1(TYPE_INT, TYPE_ADR);
1914 COUNT(count_check_null);
1915 COUNT(count_pcmd_mem);
1916 OP1_1(TYPE_ADR, iptr->op1);
1921 case ICMD_GETSTATIC:
1922 COUNT(count_pcmd_mem);
1932 tbptr = m->basicblocks + m->basicblockindex[iptr->op1];
1934 iptr[0].target = (void *) tbptr;
1936 /* This is a dirty hack. The typechecker
1937 * needs it because the OP1_0ANY below
1938 * overwrites iptr->dst.
1940 iptr->val.a = (void *) iptr->dst;
1942 tbptr->type = BBTYPE_SBR;
1944 /* We need to check for overflow right here because
1945 * the pushed value is poped after MARKREACHED. */
1947 MARKREACHED(tbptr, copy);
1951 /* pop many push any */
1954 #if defined(USEBUILTINTABLE)
1957 bte = (builtintable_entry *) iptr->val.a;
1961 case ICMD_INVOKESTATIC:
1962 case ICMD_INVOKESPECIAL:
1963 case ICMD_INVOKEVIRTUAL:
1964 case ICMD_INVOKEINTERFACE:
1965 COUNT(count_pcmd_met);
1967 md = um->methodref->parseddesc.md;
1968 /* if (lm->flags & ACC_STATIC) */
1969 /* {COUNT(count_check_null);} */
1974 if (md->memuse > rd->memuse)
1975 rd->memuse = md->memuse;
1976 if (md->argintreguse > rd->argintreguse)
1977 rd->argintreguse = md->argintreguse;
1978 if (md->argfltreguse > rd->argfltreguse)
1979 rd->argfltreguse = md->argfltreguse;
1984 for (i-- ; i >= 0; i--) {
1985 #if defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
1986 /* If we pass float arguments in integer argument registers, we
1987 * are not allowed to precolor them here. Floats have to be moved
1988 * to this regs explicitly in codegen().
1989 * Only arguments that are passed by stack anyway can be precolored
1990 * (michi 2005/07/24) */
1991 if (!(copy->flags & SAVEDVAR) &&
1992 (!IS_FLT_DBL_TYPE(copy->type) || md->params[i].inmemory)) {
1994 if (!(copy->flags & SAVEDVAR)) {
1996 copy->varkind = ARGVAR;
1999 #if defined(ENABLE_INTRP)
2002 if (md->params[i].inmemory) {
2003 copy->flags = INMEMORY;
2004 copy->regoff = md->params[i].regoff;
2007 if (IS_FLT_DBL_TYPE(copy->type))
2008 #if defined(SUPPORT_PASS_FLOATARGS_IN_INTREGS)
2009 assert(0); /* XXX is this assert ok? */
2012 rd->argfltregs[md->params[i].regoff];
2015 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
2016 if (IS_2_WORD_TYPE(copy->type))
2017 copy->regoff = PACK_REGS(
2018 rd->argintregs[GET_LOW_REG(md->params[i].regoff)],
2019 rd->argintregs[GET_HIGH_REG(md->params[i].regoff)]);
2023 rd->argintregs[md->params[i].regoff];
2026 #if defined(ENABLE_INTRP)
2034 copy->flags |= SAVEDVAR;
2040 if (md->returntype.type != TYPE_VOID)
2041 OP0_1(md->returntype.type);
2044 case ICMD_INLINE_START:
2045 case ICMD_INLINE_END:
2049 case ICMD_MULTIANEWARRAY:
2050 if (rd->argintreguse < 3)
2051 rd->argintreguse = 3;
2056 #if defined(SPECIALMEMUSE)
2057 # if defined(__DARWIN__)
2058 if (rd->memuse < (i + INT_ARG_CNT + LA_WORD_SIZE))
2059 rd->memuse = i + LA_WORD_SIZE + INT_ARG_CNT;
2061 if (rd->memuse < (i + LA_WORD_SIZE + 3))
2062 rd->memuse = i + LA_WORD_SIZE + 3;
2065 # if defined(__I386__)
2066 if (rd->memuse < i + 3)
2067 rd->memuse = i + 3; /* n integer args spilled on stack */
2070 rd->memuse = i; /* n integer args spilled on stack */
2071 # endif /* defined(__I386__) */
2075 /* check INT type here? Currently typecheck does this. */
2076 if (!(copy->flags & SAVEDVAR)) {
2077 copy->varkind = ARGVAR;
2078 copy->varnum = i + INT_ARG_CNT;
2079 copy->flags |= INMEMORY;
2080 #if defined(SPECIALMEMUSE)
2081 # if defined(__DARWIN__)
2082 copy->regoff = i + LA_WORD_SIZE + INT_ARG_CNT;
2084 copy->regoff = i + LA_WORD_SIZE + 3;
2087 # if defined(__I386__)
2088 copy->regoff = i + 3;
2091 # endif /* defined(__I386__) */
2092 #endif /* defined(SPECIALMEMUSE) */
2097 copy->flags |= SAVEDVAR;
2105 case ICMD_CLEAR_ARGREN:
2106 for (i = iptr->op1; i < cd->maxlocals; i++)
2108 iptr->opc = opcode = ICMD_NOP;
2112 case ICMD_READONLY_ARG:
2113 case ICMD_READONLY_ARG+1:
2114 case ICMD_READONLY_ARG+2:
2115 case ICMD_READONLY_ARG+3:
2116 case ICMD_READONLY_ARG+4:
2119 if (curstack->varkind == LOCALVAR) {
2120 i = curstack->varnum;
2121 argren[iptr->op1] = i;
2124 opcode = iptr->opc = opcode - ICMD_READONLY_ARG + ICMD_ISTORE;
2131 new_exception_message(string_java_lang_InternalError,
2138 } /* while instructions */
2140 bptr->outstack = curstack;
2141 bptr->outdepth = stackdepth;
2145 superblockend = true;
2147 } /* while blocks */
2148 } while (repeat && !deadcode);
2150 #if defined(STATISTICS)
2152 if (m->basicblockcount > count_max_basic_blocks)
2153 count_max_basic_blocks = m->basicblockcount;
2154 count_basic_blocks += m->basicblockcount;
2155 if (m->instructioncount > count_max_javainstr) count_max_javainstr = m->instructioncount;
2156 count_javainstr += m->instructioncount;
2157 if (m->stackcount > count_upper_bound_new_stack)
2158 count_upper_bound_new_stack = m->stackcount;
2159 if ((new - m->stack) > count_max_new_stack)
2160 count_max_new_stack = (new - m->stack);
2162 b_count = m->basicblockcount;
2163 bptr = m->basicblocks;
2164 while (--b_count >= 0) {
2165 if (bptr->flags > BBREACHED) {
2166 if (bptr->indepth >= 10)
2167 count_block_stack[10]++;
2169 count_block_stack[bptr->indepth]++;
2172 count_block_size_distribution[len]++;
2174 count_block_size_distribution[10]++;
2176 count_block_size_distribution[11]++;
2178 count_block_size_distribution[12]++;
2180 count_block_size_distribution[13]++;
2182 count_block_size_distribution[14]++;
2184 count_block_size_distribution[15]++;
2186 count_block_size_distribution[16]++;
2188 count_block_size_distribution[17]++;
2194 count_analyse_iterations[0]++;
2195 else if (loops == 2)
2196 count_analyse_iterations[1]++;
2197 else if (loops == 3)
2198 count_analyse_iterations[2]++;
2199 else if (loops == 4)
2200 count_analyse_iterations[3]++;
2202 count_analyse_iterations[4]++;
2204 if (m->basicblockcount <= 5)
2205 count_method_bb_distribution[0]++;
2206 else if (m->basicblockcount <= 10)
2207 count_method_bb_distribution[1]++;
2208 else if (m->basicblockcount <= 15)
2209 count_method_bb_distribution[2]++;
2210 else if (m->basicblockcount <= 20)
2211 count_method_bb_distribution[3]++;
2212 else if (m->basicblockcount <= 30)
2213 count_method_bb_distribution[4]++;
2214 else if (m->basicblockcount <= 40)
2215 count_method_bb_distribution[5]++;
2216 else if (m->basicblockcount <= 50)
2217 count_method_bb_distribution[6]++;
2218 else if (m->basicblockcount <= 75)
2219 count_method_bb_distribution[7]++;
2221 count_method_bb_distribution[8]++;
2225 /* just return methodinfo* to signal everything was ok */
2231 /**********************************************************************/
2232 /* DEBUGGING HELPERS */
2233 /**********************************************************************/
2235 void icmd_print_stack(codegendata *cd, stackptr s)
2247 j = cd->maxstack - i;
2253 if (s->flags & SAVEDVAR)
2254 switch (s->varkind) {
2256 if (s->flags & INMEMORY)
2257 printf(" M%02d", s->regoff);
2258 #ifdef HAS_ADDRESS_REGISTER_FILE
2259 else if (s->type == TYPE_ADR)
2260 printf(" R%02d", s->regoff);
2262 else if (IS_FLT_DBL_TYPE(s->type))
2263 printf(" F%02d", s->regoff);
2265 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
2266 if (IS_2_WORD_TYPE(s->type))
2267 printf(" %3s/%3s", regs[GET_LOW_REG(s->regoff)],
2268 regs[GET_HIGH_REG(s->regoff)]);
2271 #if defined(ENABLE_INTRP)
2272 printf(" %3d", s->regoff);
2274 printf(" %3s", regs[s->regoff]);
2279 printf(" I%02d", s->varnum);
2282 printf(" L%02d", s->varnum);
2285 if (s->varnum == -1) {
2287 /* varkind ARGVAR "misused for this special case */
2289 } else /* "normal" Argvar */
2290 printf(" A%02d", s->varnum);
2291 #ifdef INVOKE_NEW_DEBUG
2292 if (s->flags & INMEMORY)
2293 printf("(M%i)", s->regoff);
2295 printf("(R%i)", s->regoff);
2299 printf(" !%02d", j);
2302 switch (s->varkind) {
2304 if (s->flags & INMEMORY)
2305 printf(" m%02d", s->regoff);
2306 #ifdef HAS_ADDRESS_REGISTER_FILE
2307 else if (s->type == TYPE_ADR)
2308 printf(" r%02d", s->regoff);
2310 else if (IS_FLT_DBL_TYPE(s->type))
2311 printf(" f%02d", s->regoff);
2313 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
2314 if (IS_2_WORD_TYPE(s->type))
2315 printf(" %3s/%3s", regs[GET_LOW_REG(s->regoff)],
2316 regs[GET_HIGH_REG(s->regoff)]);
2319 #if defined(ENABLE_INTRP)
2320 printf(" %3d", s->regoff);
2322 printf(" %3s", regs[s->regoff]);
2327 printf(" i%02d", s->varnum);
2330 printf(" l%02d", s->varnum);
2333 if (s->varnum == -1) {
2335 /* varkind ARGVAR "misused for this special case */
2337 } else /* "normal" Argvar */
2338 printf(" a%02d", s->varnum);
2339 #ifdef INVOKE_NEW_DEBUG
2340 if (s->flags & INMEMORY)
2341 printf("(M%i)", s->regoff);
2343 printf("(R%i)", s->regoff);
2347 printf(" ?%02d", j);
2355 static void print_reg(stackptr s) {
2357 if (s->flags & SAVEDVAR)
2358 switch (s->varkind) {
2360 if (s->flags & INMEMORY)
2361 printf(" tm%02d", s->regoff);
2363 printf(" tr%02d", s->regoff);
2366 printf(" s %02d", s->varnum);
2369 printf(" l %02d", s->varnum);
2372 printf(" a %02d", s->varnum);
2375 printf(" ! %02d", s->varnum);
2378 switch (s->varkind) {
2380 if (s->flags & INMEMORY)
2381 printf(" Tm%02d", s->regoff);
2383 printf(" Tr%02d", s->regoff);
2386 printf(" S %02d", s->varnum);
2389 printf(" L %02d", s->varnum);
2392 printf(" A %02d", s->varnum);
2395 printf(" ? %02d", s->varnum);
2405 static char *jit_type[] = {
2414 /* show_icmd_method ************************************************************
2418 *******************************************************************************/
2420 void show_icmd_method(methodinfo *m, codegendata *cd, registerdata *rd)
2427 #if defined(USE_THREADS)
2428 /* We need to enter a lock here, since the binutils disassembler is not */
2429 /* reentrant-able and we could not read functions printed at the same */
2432 builtin_monitorenter(&show_icmd_lock);
2436 utf_fprint_classname(stdout, m->class->name);
2438 utf_fprint(stdout, m->name);
2439 utf_fprint(stdout, m->descriptor);
2440 printf("\n\nMax locals: %d\n", (int) cd->maxlocals);
2441 printf("Max stack: %d\n", (int) cd->maxstack);
2442 printf("Line number table length: %d\n", m->linenumbercount);
2444 printf("Exceptions (Number: %d):\n", cd->exceptiontablelength);
2445 for (ex = cd->exceptiontable; ex != NULL; ex = ex->down) {
2446 printf(" L%03d ... ", ex->start->debug_nr );
2447 printf("L%03d = ", ex->end->debug_nr);
2448 printf("L%03d", ex->handler->debug_nr);
2449 printf(" (catchtype: ");
2450 if (ex->catchtype.any)
2451 if (IS_CLASSREF(ex->catchtype))
2452 utf_display_classname(ex->catchtype.ref->name);
2454 utf_display_classname(ex->catchtype.cls->name);
2460 printf("Local Table:\n");
2461 for (i = 0; i < cd->maxlocals; i++) {
2462 printf(" %3d: ", i);
2463 for (j = TYPE_INT; j <= TYPE_ADR; j++) {
2464 #if defined(ENABLE_INTRP)
2467 if (rd->locals[i][j].type >= 0) {
2468 printf(" (%s) ", jit_type[j]);
2469 if (rd->locals[i][j].flags & INMEMORY)
2470 printf("m%2d", rd->locals[i][j].regoff);
2471 #ifdef HAS_ADDRESS_REGISTER_FILE
2472 else if (j == TYPE_ADR)
2473 printf("r%02d", rd->locals[i][j].regoff);
2475 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
2476 printf("f%02d", rd->locals[i][j].regoff);
2478 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
2479 if (IS_2_WORD_TYPE(j))
2481 regs[GET_LOW_REG(rd->locals[i][j].regoff)],
2482 regs[GET_HIGH_REG(rd->locals[i][j].regoff)]);
2485 printf("%3s", regs[rd->locals[i][j].regoff]);
2488 #if defined(ENABLE_INTRP)
2499 #if defined(ENABLE_INTRP)
2502 printf("Interface Table:\n");
2503 for (i = 0; i < cd->maxstack; i++) {
2504 if ((rd->interfaces[i][0].type >= 0) ||
2505 (rd->interfaces[i][1].type >= 0) ||
2506 (rd->interfaces[i][2].type >= 0) ||
2507 (rd->interfaces[i][3].type >= 0) ||
2508 (rd->interfaces[i][4].type >= 0)) {
2509 printf(" %3d: ", i);
2510 for (j = TYPE_INT; j <= TYPE_ADR; j++)
2511 if (rd->interfaces[i][j].type >= 0) {
2512 printf(" (%s) ", jit_type[j]);
2513 if (rd->interfaces[i][j].flags & SAVEDVAR) {
2514 if (rd->interfaces[i][j].flags & INMEMORY)
2515 printf("M%2d", rd->interfaces[i][j].regoff);
2516 #ifdef HAS_ADDRESS_REGISTER_FILE
2517 else if (j == TYPE_ADR)
2518 printf("R%02d", rd->interfaces[i][j].regoff);
2520 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
2521 printf("F%02d", rd->interfaces[i][j].regoff);
2523 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
2524 if (IS_2_WORD_TYPE(j))
2526 regs[GET_LOW_REG(rd->interfaces[i][j].regoff)],
2527 regs[GET_HIGH_REG(rd->interfaces[i][j].regoff)]);
2530 printf("%3s",regs[rd->interfaces[i][j].regoff]);
2534 if (rd->interfaces[i][j].flags & INMEMORY)
2535 printf("m%2d", rd->interfaces[i][j].regoff);
2536 #ifdef HAS_ADDRESS_REGISTER_FILE
2537 else if (j == TYPE_ADR)
2538 printf("r%02d", rd->interfaces[i][j].regoff);
2540 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
2541 printf("f%02d", rd->interfaces[i][j].regoff);
2543 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
2544 if (IS_2_WORD_TYPE(j))
2546 regs[GET_LOW_REG(rd->interfaces[i][j].regoff)],
2547 regs[GET_HIGH_REG(rd->interfaces[i][j].regoff)]);
2550 printf("%3s",regs[rd->interfaces[i][j].regoff]);
2559 #if defined(ENABLE_INTRP)
2566 /* show code before first basic block */
2568 if (opt_showdisassemble) {
2569 u1ptr = (u1 *) ((ptrint) m->mcode + cd->dseglen);
2571 for (; u1ptr < (u1 *) ((ptrint) m->mcode + cd->dseglen + m->basicblocks[0].mpc);)
2572 u1ptr = disassinstr(u1ptr);
2577 /* show code of all basic blocks */
2579 for (bptr = m->basicblocks; bptr != NULL; bptr = bptr->next) {
2580 show_icmd_block(m, cd, bptr);
2583 /* show stubs code */
2585 if (opt_showdisassemble && opt_showexceptionstubs) {
2586 printf("\nException stubs code:\n");
2587 printf("Length: %d\n\n", (s4) (m->mcodelength -
2588 ((ptrint) cd->dseglen +
2589 m->basicblocks[m->basicblockcount].mpc)));
2591 u1ptr = (u1 *) ((ptrint) m->mcode + cd->dseglen +
2592 m->basicblocks[m->basicblockcount].mpc);
2594 for (; (ptrint) u1ptr < ((ptrint) m->mcode + m->mcodelength);)
2595 u1ptr = disassinstr(u1ptr);
2600 #if defined(USE_THREADS)
2601 builtin_monitorexit(&show_icmd_lock);
2606 void show_icmd_block(methodinfo *m, codegendata *cd, basicblock *bptr)
2613 if (bptr->flags != BBDELETED) {
2614 deadcode = bptr->flags <= BBREACHED;
2617 for (j = cd->maxstack; j > 0; j--)
2620 icmd_print_stack(cd, bptr->instack);
2621 printf("] L%03d(%d - %d) flags=%d:\n", bptr->debug_nr, bptr->icount, bptr->pre_count,bptr->flags);
2622 iptr = bptr->iinstr;
2624 for (i = 0; i < bptr->icount; i++, iptr++) {
2627 for (j = cd->maxstack; j > 0; j--)
2631 icmd_print_stack(cd, iptr->dst);
2632 printf("] %5d (line: %5d) ", i, iptr->line);
2635 if (icmd_uses_tmp[iptr->opc][0])
2639 if (icmd_uses_tmp[iptr->opc][1])
2643 if (icmd_uses_tmp[iptr->opc][2])
2649 show_icmd(iptr, deadcode);
2653 if (opt_showdisassemble && (!deadcode)) {
2655 u1ptr = (u1 *) ((ptrint) m->mcode + cd->dseglen + bptr->mpc);
2657 if (bptr->next != NULL) {
2658 for (; u1ptr < (u1 *) ((ptrint) m->mcode + cd->dseglen + bptr->next->mpc);)
2659 u1ptr = disassinstr(u1ptr);
2662 for (; u1ptr < (u1 *) ((ptrint) m->mcode + m->mcodelength);)
2663 u1ptr = disassinstr(u1ptr);
2671 void show_icmd(instruction *iptr, bool deadcode)
2677 printf("%s", icmd_names[iptr->opc]);
2679 switch (iptr->opc) {
2680 case ICMD_IADDCONST:
2681 case ICMD_ISUBCONST:
2682 case ICMD_IMULCONST:
2686 case ICMD_IANDCONST:
2688 case ICMD_IXORCONST:
2689 case ICMD_ISHLCONST:
2690 case ICMD_ISHRCONST:
2691 case ICMD_IUSHRCONST:
2692 case ICMD_LSHLCONST:
2693 case ICMD_LSHRCONST:
2694 case ICMD_LUSHRCONST:
2696 case ICMD_ELSE_ICONST:
2697 case ICMD_IASTORECONST:
2698 case ICMD_BASTORECONST:
2699 case ICMD_CASTORECONST:
2700 case ICMD_SASTORECONST:
2701 printf(" %d (0x%08x)", iptr->val.i, iptr->val.i);
2704 case ICMD_IFEQ_ICONST:
2705 case ICMD_IFNE_ICONST:
2706 case ICMD_IFLT_ICONST:
2707 case ICMD_IFGE_ICONST:
2708 case ICMD_IFGT_ICONST:
2709 case ICMD_IFLE_ICONST:
2710 printf("(%d) %d", iptr[1].op1, iptr->val.i);
2713 case ICMD_LADDCONST:
2714 case ICMD_LSUBCONST:
2715 case ICMD_LMULCONST:
2719 case ICMD_LANDCONST:
2721 case ICMD_LXORCONST:
2723 case ICMD_LASTORECONST:
2724 #if SIZEOF_VOID_P == 4
2725 printf(" %lld (0x%016llx)", iptr->val.l, iptr->val.l);
2727 printf(" %ld (0x%016lx)", iptr->val.l, iptr->val.l);
2732 printf(" %f (0x%08x)", iptr->val.f, iptr->val.i);
2736 #if SIZEOF_VOID_P == 4
2737 printf(" %g (0x%016llx)", iptr->val.d, iptr->val.l);
2739 printf(" %g (0x%016lx)", iptr->val.d, iptr->val.l);
2744 case ICMD_AASTORECONST:
2745 printf(" %p", iptr->val.a);
2748 /* check if this is a constant string */
2750 if (iptr->op1 == 0) {
2751 printf(", String = \"");
2752 utf_display(javastring_toutf(iptr->val.a, false));
2756 /* it is a BUILTIN argument */
2758 printf(", Class = \"");
2760 /* is it resolved? */
2762 if (iptr[1].target == NULL) {
2763 builtintable_entry *bte = iptr[1].val.a;
2765 /* NEW gets a classinfo* as argument */
2767 if (bte->fp == BUILTIN_new) {
2768 utf_display(((classinfo *) iptr->val.a)->name);
2771 utf_display(((vftbl_t *) iptr->val.a)->class->name);
2775 /* iptr->target is a constant_classref */
2777 utf_display(((constant_classref *) iptr->val.a)->name);
2787 printf(" %d, ", ((fieldinfo *) iptr->val.a)->offset);
2789 printf(" (NOT RESOLVED), ");
2790 utf_display_classname(((unresolved_field *) iptr->target)->fieldref->classref->name);
2792 utf_display(((unresolved_field *) iptr->target)->fieldref->name);
2794 utf_display(((unresolved_field *) iptr->target)->fieldref->descriptor);
2798 case ICMD_PUTSTATIC:
2799 case ICMD_GETSTATIC:
2801 if (!((fieldinfo *) iptr->val.a)->class->initialized)
2802 printf(" (NOT INITIALIZED) ");
2806 printf(" (NOT RESOLVED) ");
2807 utf_display_classname(((unresolved_field *) iptr->target)->fieldref->classref->name);
2809 utf_display(((unresolved_field *) iptr->target)->fieldref->name);
2811 utf_display(((unresolved_field *) iptr->target)->fieldref->descriptor);
2815 case ICMD_PUTSTATICCONST:
2816 case ICMD_PUTFIELDCONST:
2817 switch (iptr[1].op1) {
2819 printf(" %d,", iptr->val.i);
2822 #if SIZEOF_VOID_P == 4
2823 printf(" %lld,", iptr->val.l);
2825 printf(" %ld,", iptr->val.l);
2829 printf(" %p,", iptr->val.a);
2832 printf(" %g,", iptr->val.f);
2835 printf(" %g,", iptr->val.d);
2838 if (iptr->opc == ICMD_PUTFIELDCONST)
2839 printf(" NOT RESOLVED,");
2841 utf_display_classname(((unresolved_field *) iptr[1].target)->fieldref->classref->name);
2843 utf_display(((unresolved_field *) iptr[1].target)->fieldref->name);
2845 utf_display(((unresolved_field *) iptr[1].target)->fieldref->descriptor);
2850 printf(" %d + %d", iptr->op1, iptr->val.i);
2885 printf(" %d", iptr->op1);
2890 utf_display_classname(((classinfo *) iptr->val.a)->name);
2894 switch (iptr->op1) {
2922 case ICMD_ANEWARRAY:
2925 utf_display_classname(((classinfo *) iptr->val.a)->name);
2929 case ICMD_MULTIANEWARRAY:
2931 printf(" (NOT RESOLVED) %d ",iptr->op1);
2932 utf_display(((constant_classref *) iptr->val.a)->name);
2934 printf(" %d ",iptr->op1);
2935 utf_display_classname(((vftbl_t *) iptr->val.a)->class->name);
2939 case ICMD_CHECKCAST:
2940 case ICMD_INSTANCEOF:
2942 classinfo *c = iptr->val.a;
2944 if (c->flags & ACC_INTERFACE)
2945 printf(" (INTERFACE) ");
2947 printf(" (CLASS,%3d) ", c->vftbl->diffval);
2949 printf(" (NOT RESOLVED) ");
2951 utf_display_classname(((constant_classref *) iptr->target)->name);
2955 case ICMD_ARRAYCHECKCAST:
2957 classinfo *c = ((vftbl_t *) iptr->target)->class;
2958 if (c->flags & ACC_INTERFACE)
2959 printf(" (INTERFACE) ");
2961 printf(" (CLASS,%3d) ", c->vftbl->diffval);
2962 utf_display_classname(c->name);
2964 printf(" (NOT RESOLVED) ");
2965 utf_display_classname(((constant_classref *) iptr->target)->name);
2969 case ICMD_INLINE_START:
2971 utf_display_classname(iptr->method->class->name);
2973 utf_display_classname(iptr->method->name);
2974 utf_display_classname(iptr->method->descriptor);
2975 printf(", depth=%i", iptr->op1);
2977 case ICMD_INLINE_END:
2981 printf(" %s", ((builtintable_entry *) iptr->val.a)->name);
2984 case ICMD_INVOKEVIRTUAL:
2985 case ICMD_INVOKESPECIAL:
2986 case ICMD_INVOKESTATIC:
2987 case ICMD_INVOKEINTERFACE:
2989 printf(" (NOT RESOLVED) ");
2992 utf_display_classname(((unresolved_method *) iptr->target)->methodref->classref->name);
2994 utf_display(((unresolved_method *) iptr->target)->methodref->name);
2995 utf_display(((unresolved_method *) iptr->target)->methodref->descriptor);
3004 if (deadcode || !iptr->target)
3005 printf("(%d) op1=%d", iptr->val.i, iptr->op1);
3007 printf("(%d) L%03d", iptr->val.i, ((basicblock *) iptr->target)->debug_nr);
3016 if (deadcode || !iptr->target)
3017 #if SIZEOF_VOID_P == 4
3018 printf("(%lld) op1=%d", iptr->val.l, iptr->op1);
3020 printf("(%ld) op1=%d", iptr->val.l, iptr->op1);
3023 #if SIZEOF_VOID_P == 4
3024 printf("(%lld) L%03d", iptr->val.l, ((basicblock *) iptr->target)->debug_nr);
3026 printf("(%ld) L%03d", iptr->val.l, ((basicblock *) iptr->target)->debug_nr);
3033 case ICMD_IFNONNULL:
3034 case ICMD_IF_ICMPEQ:
3035 case ICMD_IF_ICMPNE:
3036 case ICMD_IF_ICMPLT:
3037 case ICMD_IF_ICMPGE:
3038 case ICMD_IF_ICMPGT:
3039 case ICMD_IF_ICMPLE:
3040 case ICMD_IF_LCMPEQ:
3041 case ICMD_IF_LCMPNE:
3042 case ICMD_IF_LCMPLT:
3043 case ICMD_IF_LCMPGE:
3044 case ICMD_IF_LCMPGT:
3045 case ICMD_IF_LCMPLE:
3046 case ICMD_IF_ACMPEQ:
3047 case ICMD_IF_ACMPNE:
3048 if (deadcode || !iptr->target)
3049 printf(" op1=%d", iptr->op1);
3051 printf(" L%03d", ((basicblock *) iptr->target)->debug_nr);
3054 case ICMD_TABLESWITCH:
3055 s4ptr = (s4*)iptr->val.a;
3057 if (deadcode || !iptr->target) {
3058 printf(" %d;", *s4ptr);
3061 tptr = (void **) iptr->target;
3062 printf(" L%03d;", ((basicblock *) *tptr)->debug_nr);
3066 s4ptr++; /* skip default */
3067 j = *s4ptr++; /* low */
3068 j = *s4ptr++ - j; /* high */
3070 if (deadcode || !*tptr)
3071 printf(" %d", *s4ptr++);
3073 printf(" L%03d", ((basicblock *) *tptr)->debug_nr);
3080 case ICMD_LOOKUPSWITCH:
3081 s4ptr = (s4*)iptr->val.a;
3083 if (deadcode || !iptr->target) {
3084 printf(" %d;", *s4ptr);
3087 tptr = (void **) iptr->target;
3088 printf(" L%03d;", ((basicblock *) *tptr)->debug_nr);
3091 s4ptr++; /* default */
3092 j = *s4ptr++; /* count */
3095 if (deadcode || !*tptr) {
3096 s4ptr++; /* skip value */
3097 printf(" %d",*s4ptr++);
3100 printf(" L%03d", ((basicblock *) *tptr)->debug_nr);
3110 * These are local overrides for various environment variables in Emacs.
3111 * Please do not remove this and leave it at the end of the file, where
3112 * Emacs will automagically detect them.
3113 * ---------------------------------------------------------------------
3116 * indent-tabs-mode: t
projects / cacao.git / blob