1 /* src/vm/jit/show.c - showing the intermediate representation
3 Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
4 C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
5 E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
6 J. Wenninger, Institut f. Computersprachen - TU Wien
8 This file is part of CACAO.
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2, or (at
13 your option) any later version.
15 This program is distributed in the hope that it will be useful, but
16 WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 Contact: cacao@cacaojvm.org
27 Authors: Andreas Krall
29 Changes: Edwin Steiner
43 #include "mm/memory.h"
45 #if defined(ENABLE_THREADS)
46 # include "threads/native/lock.h"
48 # include "threads/none/lock.h"
51 #include "vm/global.h"
52 #include "vm/options.h"
53 #include "vm/builtin.h"
54 #include "vm/stringlocal.h"
55 #include "vm/jit/jit.h"
56 #include "vm/jit/show.h"
57 #include "vm/jit/disass.h"
60 /* global variables ***********************************************************/
62 #if defined(ENABLE_THREADS) && !defined(NDEBUG)
63 static java_objectheader *show_global_lock;
67 /* forward declarations *******************************************************/
70 static void new_show_variable_array(jitdata *jd, stackptr *vars, int n, int stage);
74 /* show_init *******************************************************************
76 Initialized the show subsystem (called by jit_init).
78 *******************************************************************************/
83 #if defined(ENABLE_THREADS)
84 /* initialize the show lock */
86 show_global_lock = NEW(java_objectheader);
88 lock_init_object_lock(show_global_lock);
99 static char *jit_type[] = {
109 /* show_method *****************************************************************
111 Print the intermediate representation of a method.
113 NOTE: Currently this function may only be called after register allocation!
115 *******************************************************************************/
118 void new_show_method(jitdata *jd, int stage)
125 basicblock *lastbptr;
130 /* get required compiler data */
137 /* We need to enter a lock here, since the binutils disassembler
138 is not reentrant-able and we could not read functions printed
141 LOCK_MONITOR_ENTER(show_global_lock);
143 /* get the last basic block */
145 for (lastbptr = jd->new_basicblocks; lastbptr->next != NULL; lastbptr = lastbptr->next);
151 printf("\n(NEW INSTRUCTION FORMAT)\n");
152 printf("\nBasic blocks: %d\n", jd->new_basicblockcount);
153 if (stage >= SHOW_CODE) {
154 printf("Code length: %d\n", (lastbptr->mpc - jd->new_basicblocks[0].mpc));
155 printf("Data length: %d\n", cd->dseglen);
156 printf("Stub length: %d\n", (s4) (code->mcodelength -
157 ((ptrint) cd->dseglen + lastbptr->mpc)));
159 printf("Max locals: %d\n", cd->maxlocals);
160 printf("Max stack: %d\n", cd->maxstack);
161 printf("Line number table length: %d\n", m->linenumbercount);
163 if (stage >= SHOW_PARSE) {
164 printf("Exceptions (Number: %d):\n", cd->exceptiontablelength);
165 for (ex = cd->exceptiontable; ex != NULL; ex = ex->down) {
166 printf(" L%03d ... ", ex->start->nr );
167 printf("L%03d = ", ex->end->nr);
168 printf("L%03d", ex->handler->nr);
169 printf(" (catchtype: ");
170 if (ex->catchtype.any)
171 if (IS_CLASSREF(ex->catchtype))
172 utf_display_printable_ascii_classname(ex->catchtype.ref->name);
174 utf_display_printable_ascii_classname(ex->catchtype.cls->name);
181 if (stage >= SHOW_PARSE && rd) {
182 printf("Local Table:\n");
183 for (i = 0; i < cd->maxlocals; i++) {
186 #if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
187 for (j = TYPE_INT; j <= TYPE_ADR; j++) {
188 # if defined(ENABLE_INTRP)
191 if (rd->locals[i][j].type >= 0) {
192 printf(" (%s) ", jit_type[j]);
193 if (stage >= SHOW_REGS) {
194 if (rd->locals[i][j].flags & INMEMORY)
195 printf("m%2d", rd->locals[i][j].regoff);
196 # ifdef HAS_ADDRESS_REGISTER_FILE
197 else if (j == TYPE_ADR)
198 printf("r%02d", rd->locals[i][j].regoff);
200 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
201 printf("f%02d", rd->locals[i][j].regoff);
203 # if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
204 if (IS_2_WORD_TYPE(j))
206 regs[GET_LOW_REG(rd->locals[i][j].regoff)],
207 regs[GET_HIGH_REG(rd->locals[i][j].regoff)]);
210 printf("%3s", regs[rd->locals[i][j].regoff]);
214 # if defined(ENABLE_INTRP)
218 #endif /* defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER) */
225 if (stage >= SHOW_STACK && rd) {
226 #if defined(ENABLE_LSRA) || defined(ENABLE_SSA)
229 #if defined(ENABLE_INTRP)
232 printf("Interface Table:\n");
233 for (i = 0; i < cd->maxstack; i++) {
234 if ((rd->interfaces[i][0].type >= 0) ||
235 (rd->interfaces[i][1].type >= 0) ||
236 (rd->interfaces[i][2].type >= 0) ||
237 (rd->interfaces[i][3].type >= 0) ||
238 (rd->interfaces[i][4].type >= 0)) {
241 #if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
242 # if defined(ENABLE_INTRP)
245 for (j = TYPE_INT; j <= TYPE_ADR; j++) {
246 if (rd->interfaces[i][j].type >= 0) {
247 printf(" (%s) ", jit_type[j]);
248 if (stage >= SHOW_REGS) {
249 if (rd->interfaces[i][j].flags & SAVEDVAR) {
250 if (rd->interfaces[i][j].flags & INMEMORY)
251 printf("M%2d", rd->interfaces[i][j].regoff);
252 #ifdef HAS_ADDRESS_REGISTER_FILE
253 else if (j == TYPE_ADR)
254 printf("R%02d", rd->interfaces[i][j].regoff);
256 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
257 printf("F%02d", rd->interfaces[i][j].regoff);
259 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
260 if (IS_2_WORD_TYPE(j))
262 regs[GET_LOW_REG(rd->interfaces[i][j].regoff)],
263 regs[GET_HIGH_REG(rd->interfaces[i][j].regoff)]);
266 printf("%3s",regs[rd->interfaces[i][j].regoff]);
270 if (rd->interfaces[i][j].flags & INMEMORY)
271 printf("m%2d", rd->interfaces[i][j].regoff);
272 #ifdef HAS_ADDRESS_REGISTER_FILE
273 else if (j == TYPE_ADR)
274 printf("r%02d", rd->interfaces[i][j].regoff);
276 else if ((j == TYPE_FLT) || (j == TYPE_DBL))
277 printf("f%02d", rd->interfaces[i][j].regoff);
279 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
280 if (IS_2_WORD_TYPE(j))
282 regs[GET_LOW_REG(rd->interfaces[i][j].regoff)],
283 regs[GET_HIGH_REG(rd->interfaces[i][j].regoff)]);
286 printf("%3s",regs[rd->interfaces[i][j].regoff]);
293 # if defined(ENABLE_INTRP)
296 #endif /* defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER) */
302 #if defined(ENABLE_INTRP)
305 #if defined(ENABLE_LSRA) || defined(ENABLE_SSA)
308 } /* if >= SHOW_STACK */
310 if (code->rplpoints) {
311 printf("Replacement Points:\n");
312 replace_show_replacement_points(code);
316 #if defined(ENABLE_DISASSEMBLER)
317 /* show code before first basic block */
319 if ((stage >= SHOW_CODE) && JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd)) {
320 u1ptr = (u1 *) ((ptrint) code->mcode + cd->dseglen);
322 for (; u1ptr < (u1 *) ((ptrint) code->mcode + cd->dseglen + jd->new_basicblocks[0].mpc);)
329 /* show code of all basic blocks */
331 for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next)
332 new_show_basicblock(jd, bptr, stage);
334 #if defined(ENABLE_DISASSEMBLER)
335 /* show stubs code */
337 if (stage >= SHOW_CODE && opt_showdisassemble && opt_showexceptionstubs) {
338 printf("\nStubs code:\n");
339 printf("Length: %d\n\n", (s4) (code->mcodelength -
340 ((ptrint) cd->dseglen + lastbptr->mpc)));
342 u1ptr = (u1 *) ((ptrint) code->mcode + cd->dseglen + lastbptr->mpc);
344 for (; (ptrint) u1ptr < ((ptrint) code->mcode + code->mcodelength);)
351 LOCK_MONITOR_EXIT(show_global_lock);
353 /* finally flush the output */
357 #endif /* !defined(NDEBUG) */
360 /* show_basicblock *************************************************************
362 Print the intermediate representation of a basic block.
364 NOTE: Currently this function may only be called after register allocation!
366 *******************************************************************************/
369 void new_show_basicblock(jitdata *jd, basicblock *bptr, int stage)
376 new_instruction *iptr;
379 /* get required compiler data */
385 if (bptr->flags != BBDELETED) {
386 deadcode = bptr->flags <= BBREACHED;
388 printf("======== %sL%03d ======== (flags: %d, bitflags: %01x, next: %d, type: ",
389 (bptr->bitflags & BBFLAG_REPLACEMENT) ? "<REPLACE> " : "",
390 bptr->nr, bptr->flags, bptr->bitflags,
391 (bptr->next) ? (bptr->next->nr) : -1);
393 switch (bptr->type) {
405 printf(", instruction count: %d, predecessors: %d [ ",
406 bptr->icount, bptr->predecessorcount);
408 for (i = 0; i < bptr->predecessorcount; i++)
409 printf("%d ", bptr->predecessors[i]->nr);
413 if (stage >= SHOW_STACK) {
415 new_show_variable_array(jd, bptr->invars, bptr->indepth, stage);
421 for (i = 0; i < bptr->icount; i++, iptr++) {
422 printf("%4d: ", iptr->line);
424 new_show_icmd(jd, iptr, deadcode, stage);
428 if (stage >= SHOW_STACK) {
430 new_show_variable_array(jd, bptr->outvars, bptr->outdepth, stage);
434 #if defined(ENABLE_DISASSEMBLER)
435 if ((stage >= SHOW_CODE) && JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd) &&
438 u1ptr = (u1 *) (code->mcode + cd->dseglen + bptr->mpc);
440 if (bptr->next != NULL) {
441 for (; u1ptr < (u1 *) (code->mcode + cd->dseglen + bptr->next->mpc);)
446 for (; u1ptr < (u1 *) (code->mcode + code->mcodelength);)
454 #endif /* !defined(NDEBUG) */
457 /* show_icmd *******************************************************************
459 Print the intermediate representation of an instruction.
461 NOTE: Currently this function may only be called after register allocation!
463 *******************************************************************************/
467 #define SHOW_TARGET(target) \
468 if (stage >= SHOW_STACK) { \
469 printf("--> L%03d ", (target).block->nr); \
471 else if (stage >= SHOW_PARSE) { \
472 printf("--> insindex %d (L%03d) ", (target).insindex, \
473 jd->new_basicblocks[jd->new_basicblockindex[ \
474 (target).insindex]].nr); \
477 printf("--> insindex %d ", (target).insindex); \
480 #define SHOW_INT_CONST(val) \
481 if (stage >= SHOW_PARSE) { \
482 printf("%ld ", (long) (val)); \
488 #define SHOW_LNG_CONST(val) \
489 if (stage >= SHOW_PARSE) { \
490 printf("%lld ", (long long)(val)); \
496 #define SHOW_FLT_CONST(val) \
497 if (stage >= SHOW_PARSE) { \
498 printf("%g ", (val)); \
504 #define SHOW_DBL_CONST(val) \
505 if (stage >= SHOW_PARSE) { \
506 printf("%g ", (val)); \
512 #define SHOW_INDEX(index) \
513 if (stage >= SHOW_PARSE) { \
514 printf("%d ", index); \
520 #define SHOW_STRING(val) \
521 if (stage >= SHOW_PARSE) { \
523 utf_display_printable_ascii( \
524 javastring_toutf((java_lang_String *)(val), false)); \
531 #define SHOW_CLASSREF_OR_CLASSINFO(c) \
532 if (stage >= SHOW_PARSE) { \
533 if (IS_CLASSREF(c)) \
534 class_classref_print(c.ref); \
536 class_print(c.cls); \
543 #define SHOW_FIELD(fmiref) \
544 if (stage >= SHOW_PARSE) { \
545 field_fieldref_print(fmiref); \
552 #define SHOW_STACKVAR(sp) \
553 new_show_stackvar(jd, (sp), stage)
555 #define SHOW_S1(iptr) \
556 if (stage >= SHOW_STACK) { \
557 SHOW_STACKVAR(iptr->s1.var); \
560 #define SHOW_S2(iptr) \
561 if (stage >= SHOW_STACK) { \
562 SHOW_STACKVAR(iptr->sx.s23.s2.var); \
565 #define SHOW_S3(iptr) \
566 if (stage >= SHOW_STACK) { \
567 SHOW_STACKVAR(iptr->sx.s23.s3.var); \
570 #define SHOW_DST(iptr) \
571 if (stage >= SHOW_STACK) { \
573 SHOW_STACKVAR(iptr->dst.var); \
576 #define SHOW_S1_LOCAL(iptr) \
577 if (stage >= SHOW_STACK) { \
578 printf("L%d ", iptr->s1.localindex); \
581 #define SHOW_DST_LOCAL(iptr) \
582 if (stage >= SHOW_STACK) { \
583 printf("=> L%d ", iptr->dst.localindex); \
586 static void new_show_stackvar(jitdata *jd, stackptr sp, int stage)
591 case TYPE_INT: type = 'i'; break;
592 case TYPE_LNG: type = 'l'; break;
593 case TYPE_FLT: type = 'f'; break;
594 case TYPE_DBL: type = 'd'; break;
595 case TYPE_ADR: type = 'a'; break;
598 printf("S%c%d", type, (int) (sp - jd->new_stack));
600 if (stage >= SHOW_REGS) {
603 if (sp->flags & SAVEDVAR) {
604 switch (sp->varkind) {
606 if (sp->flags & INMEMORY)
607 printf("M%02d", sp->regoff);
608 #ifdef HAS_ADDRESS_REGISTER_FILE
609 else if (sp->type == TYPE_ADR)
610 printf("R%02d", sp->regoff);
612 else if (IS_FLT_DBL_TYPE(sp->type))
613 printf("F%02d", sp->regoff);
615 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
616 if (IS_2_WORD_TYPE(sp->type)) {
617 # if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
618 # if defined(ENABLE_INTRP)
620 printf("%3d/%3d", GET_LOW_REG(sp->regoff),
621 GET_HIGH_REG(sp->regoff));
624 printf("%3s/%3s", regs[GET_LOW_REG(sp->regoff)],
625 regs[GET_HIGH_REG(sp->regoff)]);
627 printf("%3d/%3d", GET_LOW_REG(sp->regoff),
628 GET_HIGH_REG(sp->regoff));
632 #endif /* defined(SUPPORT_COMBINE_INTEGER_REGISTERS) */
634 #if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
635 # if defined(ENABLE_INTRP)
637 printf("%3d", sp->regoff);
640 printf("%3s", regs[sp->regoff]);
642 printf("%3d", sp->regoff);
648 printf("I%02d", sp->varnum);
651 printf("L%02d", sp->varnum);
654 if (sp->varnum == -1) {
656 /* varkind ARGVAR "misused for this special case */
659 else /* "normal" Argvar */
660 printf("A%02d", sp->varnum);
663 printf("!xx {kind=%d, num=%d}", sp->varkind, sp->varnum);
666 else { /* not SAVEDVAR */
667 switch (sp->varkind) {
669 if (sp->flags & INMEMORY)
670 printf("m%02d", sp->regoff);
671 #ifdef HAS_ADDRESS_REGISTER_FILE
672 else if (sp->type == TYPE_ADR)
673 printf("r%02d", sp->regoff);
675 else if (IS_FLT_DBL_TYPE(sp->type))
676 printf("f%02d", sp->regoff);
678 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
679 if (IS_2_WORD_TYPE(sp->type)) {
680 # if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
681 # if defined(ENABLE_INTRP)
683 printf("%3d/%3d", GET_LOW_REG(sp->regoff),
684 GET_HIGH_REG(sp->regoff));
687 printf("%3s/%3s", regs[GET_LOW_REG(sp->regoff)],
688 regs[GET_HIGH_REG(sp->regoff)]);
690 printf("%3d/%3d", GET_LOW_REG(sp->regoff),
691 GET_HIGH_REG(sp->regoff));
695 #endif /* defined(SUPPORT_COMBINE_INTEGER_REGISTERS) */
697 #if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
698 # if defined(ENABLE_INTRP)
700 printf("%3d", sp->regoff);
703 printf("%3s", regs[sp->regoff]);
705 printf("%3d", sp->regoff);
711 printf("i%02d", sp->varnum);
714 printf("l%02d", sp->varnum);
717 if (sp->varnum == -1) {
719 /* varkind ARGVAR "misused for this special case */
722 else /* "normal" Argvar */
723 printf("a%02d", sp->varnum);
726 printf("?xx {kind=%d, num=%d}", sp->varkind, sp->varnum);
735 static void new_show_variable_array(jitdata *jd, stackptr *vars, int n, int stage)
740 for (i=0; i<n; ++i) {
743 new_show_stackvar(jd, vars[i], stage);
748 void new_show_icmd(jitdata *jd, new_instruction *iptr, bool deadcode, int stage)
751 branch_target_t *table;
752 lookup_target_t *lookup;
753 constant_FMIref *fmiref;
757 /* get the opcode and the condition */
761 printf("%s ", icmd_names[opcode]);
763 if (stage < SHOW_PARSE)
769 /* Print the condition for conditional instructions. */
771 /* XXX print condition from flags */
773 if (iptr->flags.bits & INS_FLAG_UNRESOLVED)
774 printf("(UNRESOLVED) ");
780 case ICMD_CHECKNULL_POP:
785 case ICMD_ARRAYLENGTH:
852 /* binary/const INT */
864 case ICMD_IUSHRCONST:
867 case ICMD_LUSHRCONST:
869 SHOW_INT_CONST(iptr->sx.val.i);
873 /* ?ASTORECONST (trinary/const INT) */
874 case ICMD_IASTORECONST:
875 case ICMD_BASTORECONST:
876 case ICMD_CASTORECONST:
877 case ICMD_SASTORECONST:
880 SHOW_INT_CONST(iptr->sx.s23.s3.constval);
885 SHOW_INT_CONST(iptr->sx.val.i);
889 /* binary/const LNG */
900 SHOW_LNG_CONST(iptr->sx.val.l);
904 /* trinary/const LNG (<= pointer size) */
905 case ICMD_LASTORECONST:
908 SHOW_LNG_CONST(iptr->sx.s23.s3.constval);
913 SHOW_LNG_CONST(iptr->sx.val.l);
919 SHOW_FLT_CONST(iptr->sx.val.f);
925 SHOW_DBL_CONST(iptr->sx.val.d);
931 if (iptr->flags.bits & INS_FLAG_CLASS) {
932 SHOW_CLASSREF_OR_CLASSINFO(iptr->sx.val.c);
934 else if (iptr->sx.val.anyptr == NULL) {
938 SHOW_STRING(iptr->sx.val.stringconst);
943 case ICMD_AASTORECONST:
946 printf("%p ", (void*) iptr->sx.s23.s3.constval);
949 case ICMD_GETFIELD: /* 1 -> 1 */
950 case ICMD_PUTFIELD: /* 2 -> 0 */
951 case ICMD_PUTSTATIC: /* 1 -> 0 */
952 case ICMD_GETSTATIC: /* 0 -> 1 */
953 case ICMD_PUTSTATICCONST: /* 0 -> 0 */
954 case ICMD_PUTFIELDCONST: /* 1 -> 0 */
955 if (opcode != ICMD_GETSTATIC && opcode != ICMD_PUTSTATICCONST) {
957 if (opcode == ICMD_PUTFIELD) {
961 INSTRUCTION_GET_FIELDREF(iptr, fmiref);
964 if (opcode == ICMD_GETSTATIC || opcode == ICMD_GETFIELD) {
971 SHOW_INT_CONST(iptr->sx.val.i);
972 SHOW_DST_LOCAL(iptr);
1002 SHOW_S1_LOCAL(iptr);
1010 SHOW_S1_LOCAL(iptr);
1020 SHOW_DST_LOCAL(iptr);
1031 case ICMD_ANEWARRAY:
1035 case ICMD_MULTIANEWARRAY:
1036 if (stage >= SHOW_STACK) {
1037 argp = iptr->sx.s23.s2.args;
1038 i = iptr->s1.argcount;
1040 SHOW_STACKVAR(*(argp++));
1044 printf("argcount=%d ", iptr->s1.argcount);
1049 case ICMD_CHECKCAST:
1054 case ICMD_INSTANCEOF:
1059 case ICMD_INLINE_START:
1060 case ICMD_INLINE_END:
1064 if (stage >= SHOW_STACK) {
1065 argp = iptr->sx.s23.s2.args;
1066 i = iptr->s1.argcount;
1068 SHOW_STACKVAR(*(argp++));
1071 printf("%s ", iptr->sx.s23.s3.bte->cname);
1072 if (iptr->sx.s23.s3.bte->md->returntype.type != TYPE_VOID) {
1077 case ICMD_INVOKEVIRTUAL:
1078 case ICMD_INVOKESPECIAL:
1079 case ICMD_INVOKESTATIC:
1080 case ICMD_INVOKEINTERFACE:
1081 if (stage >= SHOW_STACK) {
1082 argp = iptr->sx.s23.s2.args;
1083 i = iptr->s1.argcount;
1085 SHOW_STACKVAR(*(argp++));
1088 INSTRUCTION_GET_METHODREF(iptr, fmiref);
1089 method_methodref_print(fmiref);
1090 if (fmiref->parseddesc.md->returntype.type != TYPE_VOID) {
1102 SHOW_TARGET(iptr->dst);
1112 SHOW_TARGET(iptr->dst);
1116 case ICMD_INLINE_GOTO:
1117 SHOW_TARGET(iptr->dst);
1121 SHOW_TARGET(iptr->sx.s23.s3.jsrtarget);
1126 case ICMD_IFNONNULL:
1128 SHOW_TARGET(iptr->dst);
1131 case ICMD_IF_ICMPEQ:
1132 case ICMD_IF_ICMPNE:
1133 case ICMD_IF_ICMPLT:
1134 case ICMD_IF_ICMPGE:
1135 case ICMD_IF_ICMPGT:
1136 case ICMD_IF_ICMPLE:
1138 case ICMD_IF_LCMPEQ:
1139 case ICMD_IF_LCMPNE:
1140 case ICMD_IF_LCMPLT:
1141 case ICMD_IF_LCMPGE:
1142 case ICMD_IF_LCMPGT:
1143 case ICMD_IF_LCMPLE:
1145 case ICMD_IF_FCMPEQ:
1146 case ICMD_IF_FCMPNE:
1148 case ICMD_IF_FCMPL_LT:
1149 case ICMD_IF_FCMPL_GE:
1150 case ICMD_IF_FCMPL_GT:
1151 case ICMD_IF_FCMPL_LE:
1153 case ICMD_IF_FCMPG_LT:
1154 case ICMD_IF_FCMPG_GE:
1155 case ICMD_IF_FCMPG_GT:
1156 case ICMD_IF_FCMPG_LE:
1158 case ICMD_IF_DCMPEQ:
1159 case ICMD_IF_DCMPNE:
1161 case ICMD_IF_DCMPL_LT:
1162 case ICMD_IF_DCMPL_GE:
1163 case ICMD_IF_DCMPL_GT:
1164 case ICMD_IF_DCMPL_LE:
1166 case ICMD_IF_DCMPG_LT:
1167 case ICMD_IF_DCMPG_GE:
1168 case ICMD_IF_DCMPG_GT:
1169 case ICMD_IF_DCMPG_LE:
1171 case ICMD_IF_ACMPEQ:
1172 case ICMD_IF_ACMPNE:
1175 SHOW_TARGET(iptr->dst);
1178 case ICMD_TABLESWITCH:
1182 case ICMD_LOOKUPSWITCH:
1200 if (stage >= SHOW_STACK) {
1201 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1202 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1204 SHOW_STACKVAR(iptr->dst.dupslots[2+0]);
1205 SHOW_STACKVAR(iptr->dst.dupslots[2+1]);
1210 if (stage >= SHOW_STACK) {
1211 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1212 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1214 SHOW_STACKVAR(iptr->dst.dupslots[2+0]);
1215 SHOW_STACKVAR(iptr->dst.dupslots[2+1]);
1216 SHOW_STACKVAR(iptr->dst.dupslots[2+2]);
1221 if (stage >= SHOW_STACK) {
1222 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1223 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1224 SHOW_STACKVAR(iptr->dst.dupslots[2]);
1226 SHOW_STACKVAR(iptr->dst.dupslots[3+0]);
1227 SHOW_STACKVAR(iptr->dst.dupslots[3+1]);
1228 SHOW_STACKVAR(iptr->dst.dupslots[3+2]);
1229 SHOW_STACKVAR(iptr->dst.dupslots[3+3]);
1230 SHOW_STACKVAR(iptr->dst.dupslots[3+4]);
1235 if (stage >= SHOW_STACK) {
1236 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1237 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1238 SHOW_STACKVAR(iptr->dst.dupslots[2]);
1240 SHOW_STACKVAR(iptr->dst.dupslots[3+0]);
1241 SHOW_STACKVAR(iptr->dst.dupslots[3+1]);
1242 SHOW_STACKVAR(iptr->dst.dupslots[3+2]);
1243 SHOW_STACKVAR(iptr->dst.dupslots[3+3]);
1248 if (stage >= SHOW_STACK) {
1249 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1250 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1251 SHOW_STACKVAR(iptr->dst.dupslots[2]);
1252 SHOW_STACKVAR(iptr->dst.dupslots[4]);
1254 SHOW_STACKVAR(iptr->dst.dupslots[4+0]);
1255 SHOW_STACKVAR(iptr->dst.dupslots[4+1]);
1256 SHOW_STACKVAR(iptr->dst.dupslots[4+2]);
1257 SHOW_STACKVAR(iptr->dst.dupslots[4+3]);
1258 SHOW_STACKVAR(iptr->dst.dupslots[4+4]);
1259 SHOW_STACKVAR(iptr->dst.dupslots[4+5]);
1264 if (stage >= SHOW_STACK) {
1265 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1266 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1268 SHOW_STACKVAR(iptr->dst.dupslots[2+0]);
1269 SHOW_STACKVAR(iptr->dst.dupslots[2+1]);
1275 #endif /* !defined(NDEBUG) */
1279 * These are local overrides for various environment variables in Emacs.
1280 * Please do not remove this and leave it at the end of the file, where
1281 * Emacs will automagically detect them.
1282 * ---------------------------------------------------------------------
1285 * indent-tabs-mode: t
1289 * vim:noexpandtab:sw=4:ts=4: