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"
58 #include "vm/jit/stack.h"
61 /* global variables ***********************************************************/
63 #if defined(ENABLE_THREADS) && !defined(NDEBUG)
64 static java_objectheader *show_global_lock;
68 /* forward declarations *******************************************************/
71 static void new_show_variable_array(jitdata *jd, s4 *vars, int n, int stage);
75 /* show_init *******************************************************************
77 Initialized the show subsystem (called by jit_init).
79 *******************************************************************************/
84 #if defined(ENABLE_THREADS)
85 /* initialize the show lock */
87 show_global_lock = NEW(java_objectheader);
89 lock_init_object_lock(show_global_lock);
100 static char *jit_type[] = {
110 /* show_method *****************************************************************
112 Print the intermediate representation of a method.
114 NOTE: Currently this function may only be called after register allocation!
116 *******************************************************************************/
119 void new_show_method(jitdata *jd, int stage)
126 basicblock *lastbptr;
131 /* get required compiler data */
138 /* We need to enter a lock here, since the binutils disassembler
139 is not reentrant-able and we could not read functions printed
142 LOCK_MONITOR_ENTER(show_global_lock);
144 /* get the last basic block */
146 for (lastbptr = jd->new_basicblocks; lastbptr->next != NULL; lastbptr = lastbptr->next);
152 printf("\n(NEW INSTRUCTION FORMAT)\n");
153 printf("\nBasic blocks: %d\n", jd->new_basicblockcount);
154 if (stage >= SHOW_CODE) {
155 printf("Code length: %d\n", (lastbptr->mpc - jd->new_basicblocks[0].mpc));
156 printf("Data length: %d\n", cd->dseglen);
157 printf("Stub length: %d\n", (s4) (code->mcodelength -
158 ((ptrint) cd->dseglen + lastbptr->mpc)));
160 printf("Max locals: %d\n", cd->maxlocals);
161 printf("Max stack: %d\n", cd->maxstack);
162 printf("Line number table length: %d\n", m->linenumbercount);
164 if (stage >= SHOW_PARSE) {
165 printf("Exceptions (Number: %d):\n", cd->exceptiontablelength);
166 for (ex = cd->exceptiontable; ex != NULL; ex = ex->down) {
167 printf(" L%03d ... ", ex->start->nr );
168 printf("L%03d = ", ex->end->nr);
169 printf("L%03d", ex->handler->nr);
170 printf(" (catchtype: ");
171 if (ex->catchtype.any)
172 if (IS_CLASSREF(ex->catchtype))
173 utf_display_printable_ascii_classname(ex->catchtype.ref->name);
175 utf_display_printable_ascii_classname(ex->catchtype.cls->name);
182 if (stage >= SHOW_PARSE && rd) {
183 printf("Local Table:\n");
184 for (i = 0; i < cd->maxlocals; i++) {
187 #if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
188 /* for (j = TYPE_INT; j <= TYPE_ADR; j++) { */
189 # if defined(ENABLE_INTRP)
192 /* if (rd->locals[i][j].type >= 0) { */
193 printf(" (%s) ", jit_type[jd->var[i].type]);
194 if (stage >= SHOW_REGS) {
195 if (jd->var[i].flags & INMEMORY)
196 printf("m%2d", jd->var[i].regoff);
197 # ifdef HAS_ADDRESS_REGISTER_FILE
198 else if (jd->var[i].type == TYPE_ADR)
199 printf("r%02d", jd->var[i].regoff);
201 else if ((jd->var[i].type == TYPE_FLT) ||
202 (jd->var[i].type == TYPE_DBL))
203 printf("f%02d", jd->var[i].regoff);
205 # if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
206 if (IS_2_WORD_TYPE(j))
208 regs[GET_LOW_REG(jd->var[i].regoff)],
209 regs[GET_HIGH_REG(jd->var[i].regoff)]);
212 printf("%3s", regs[jd->var[i].regoff]);
216 # if defined(ENABLE_INTRP)
220 #endif /* defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER) */
227 if (cd->maxlocals > 0) {
228 for (i = 0; i < 5; i++) {
229 printf("%5s ",jit_type[i]);
230 for (j = 0; j < cd->maxlocals; j++)
231 printf("%3i ",jd->local_map[j*5+i]);
237 printf("Interface Table:(In/Outvars)\n");
238 if (cd->maxstack > 0) {
240 s4 *mapptr = jd->interface_map;
242 /* look if there exist IN/OUTVARS */
243 if (mapptr != NULL) {
244 for (i = 0; (i < (5 * cd->maxstack)) && !exist; i++, mapptr++)
245 exist = (*mapptr != UNUSED);
248 for (i = 0; i < 5; i++) {
249 printf("%5s ",jit_type[i]);
250 for (j = 0; j < cd->maxstack; j++)
251 printf("%3i ",jd->interface_map[j*5+i]);
258 if (code->rplpoints) {
259 printf("Replacement Points:\n");
260 replace_show_replacement_points(code);
264 #if defined(ENABLE_DISASSEMBLER)
265 /* show code before first basic block */
267 if ((stage >= SHOW_CODE) && JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd)) {
268 u1ptr = (u1 *) ((ptrint) code->mcode + cd->dseglen);
270 for (; u1ptr < (u1 *) ((ptrint) code->mcode + cd->dseglen + jd->new_basicblocks[0].mpc);)
277 /* show code of all basic blocks */
279 for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next)
280 new_show_basicblock(jd, bptr, stage);
282 #if defined(ENABLE_DISASSEMBLER)
283 /* show stubs code */
285 if (stage >= SHOW_CODE && opt_showdisassemble && opt_showexceptionstubs) {
286 printf("\nStubs code:\n");
287 printf("Length: %d\n\n", (s4) (code->mcodelength -
288 ((ptrint) cd->dseglen + lastbptr->mpc)));
290 u1ptr = (u1 *) ((ptrint) code->mcode + cd->dseglen + lastbptr->mpc);
292 for (; (ptrint) u1ptr < ((ptrint) code->mcode + code->mcodelength);)
299 LOCK_MONITOR_EXIT(show_global_lock);
301 /* finally flush the output */
305 #endif /* !defined(NDEBUG) */
308 /* show_basicblock *************************************************************
310 Print the intermediate representation of a basic block.
312 NOTE: Currently this function may only be called after register allocation!
314 *******************************************************************************/
317 void new_show_basicblock(jitdata *jd, basicblock *bptr, int stage)
327 /* get required compiler data */
333 if (bptr->flags != BBDELETED) {
334 deadcode = bptr->flags <= BBREACHED;
336 printf("======== %sL%03d ======== (flags: %d, bitflags: %01x, next: %d, type: ",
337 (bptr->bitflags & BBFLAG_REPLACEMENT) ? "<REPLACE> " : "",
338 bptr->nr, bptr->flags, bptr->bitflags,
339 (bptr->next) ? (bptr->next->nr) : -1);
341 switch (bptr->type) {
353 printf(", instruction count: %d, predecessors: %d [ ",
354 bptr->icount, bptr->predecessorcount);
356 for (i = 0; i < bptr->predecessorcount; i++)
357 printf("%d ", bptr->predecessors[i]->nr);
361 if (stage >= SHOW_STACK) {
363 new_show_variable_array(jd, bptr->invars, bptr->indepth, stage);
369 for (i = 0; i < bptr->icount; i++, iptr++) {
370 printf("%4d: ", iptr->line);
372 new_show_icmd(jd, iptr, deadcode, stage);
376 if (stage >= SHOW_STACK) {
378 new_show_variable_array(jd, bptr->outvars, bptr->outdepth, stage);
382 #if defined(ENABLE_DISASSEMBLER)
383 if ((stage >= SHOW_CODE) && JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd) &&
387 u1ptr = (u1 *) (code->mcode + cd->dseglen + bptr->mpc);
389 if (bptr->next != NULL) {
390 for (; u1ptr < (u1 *) (code->mcode + cd->dseglen + bptr->next->mpc);)
395 for (; u1ptr < (u1 *) (code->mcode + code->mcodelength);)
403 #endif /* !defined(NDEBUG) */
406 /* show_icmd *******************************************************************
408 Print the intermediate representation of an instruction.
410 NOTE: Currently this function may only be called after register allocation!
412 *******************************************************************************/
416 #define SHOW_TARGET(target) \
417 if (stage >= SHOW_STACK) { \
418 printf("--> L%03d ", (target).block->nr); \
420 else if (stage >= SHOW_PARSE) { \
421 printf("--> insindex %d (L%03d) ", (target).insindex, \
422 jd->new_basicblocks[jd->new_basicblockindex[ \
423 (target).insindex]].nr); \
426 printf("--> insindex %d ", (target).insindex); \
429 #define SHOW_INT_CONST(val) \
430 if (stage >= SHOW_PARSE) { \
431 printf("%ld ", (long) (val)); \
437 #define SHOW_LNG_CONST(val) \
438 if (stage >= SHOW_PARSE) { \
439 printf("%lld ", (long long)(val)); \
445 #define SHOW_FLT_CONST(val) \
446 if (stage >= SHOW_PARSE) { \
447 printf("%g ", (val)); \
453 #define SHOW_DBL_CONST(val) \
454 if (stage >= SHOW_PARSE) { \
455 printf("%g ", (val)); \
461 #define SHOW_INDEX(index) \
462 if (stage >= SHOW_PARSE) { \
463 printf("%d ", index); \
469 #define SHOW_STRING(val) \
470 if (stage >= SHOW_PARSE) { \
472 utf_display_printable_ascii( \
473 javastring_toutf((java_lang_String *)(val), false)); \
480 #define SHOW_CLASSREF_OR_CLASSINFO(c) \
481 if (stage >= SHOW_PARSE) { \
482 if (IS_CLASSREF(c)) \
483 class_classref_print(c.ref); \
485 class_print(c.cls); \
492 #define SHOW_FIELD(fmiref) \
493 if (stage >= SHOW_PARSE) { \
494 field_fieldref_print(fmiref); \
501 #define SHOW_STACKVAR(sp) \
502 new_show_stackvar(jd, (sp), stage)
504 #define SHOW_S1(iptr) \
505 if (stage >= SHOW_STACK) { \
506 SHOW_STACKVAR(iptr->s1.varindex); \
509 #define SHOW_S2(iptr) \
510 if (stage >= SHOW_STACK) { \
511 SHOW_STACKVAR(iptr->sx.s23.s2.varindex); \
514 #define SHOW_S3(iptr) \
515 if (stage >= SHOW_STACK) { \
516 SHOW_STACKVAR(iptr->sx.s23.s3.varindex); \
519 #define SHOW_DST(iptr) \
520 if (stage >= SHOW_STACK) { \
522 SHOW_STACKVAR(iptr->dst.varindex); \
525 #define SHOW_S1_LOCAL(iptr) \
526 if (stage >= SHOW_STACK) { \
527 printf("L%d ", iptr->s1.varindex); \
530 #define SHOW_DST_LOCAL(iptr) \
531 if (stage >= SHOW_STACK) { \
532 printf("=> L%d ", iptr->dst.varindex); \
535 static void new_show_stackvar(jitdata *jd, s4 index, int stage)
540 sp = &(jd->var[index]);
543 case TYPE_INT: type = 'i'; break;
544 case TYPE_LNG: type = 'l'; break;
545 case TYPE_FLT: type = 'f'; break;
546 case TYPE_DBL: type = 'd'; break;
547 case TYPE_ADR: type = 'a'; break;
551 switch (sp->varkind) {
552 case TEMPVAR: printf("T%c%d", type, (int) (sp - jd->new_stack)); break;
553 case LOCALVAR: printf("L%c%d(T%d)", type, sp->varnum, (int) (sp - jd->new_stack)); break;
554 case STACKVAR: printf("I%c%d(T%d)", type, sp->varnum, (int) (sp - jd->new_stack)); break;
555 case ARGVAR: printf("A%c%d(T%d)", type, sp->varnum, (int) (sp - jd->new_stack)); break;
556 default: printf("?%c%d", type, index); break;
560 if (sp->flags & PREALLOC)
562 else if (sp->flags & OUTVAR)
564 else if (index < jd->localcount)
567 printf("%c%d", type, index);
569 if (stage >= SHOW_REGS) {
572 if (sp->flags & INMEMORY)
573 printf("M%02d", sp->regoff);
574 #ifdef HAS_ADDRESS_REGISTER_FILE
575 else if (sp->type == TYPE_ADR)
576 printf("R%02d", sp->regoff);
578 else if (IS_FLT_DBL_TYPE(sp->type))
579 printf("F%02d", sp->regoff);
581 #if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
582 if (IS_2_WORD_TYPE(sp->type)) {
583 # if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
584 # if defined(ENABLE_INTRP)
586 printf("%3d/%3d", GET_LOW_REG(sp->regoff),
587 GET_HIGH_REG(sp->regoff));
590 printf("%3s/%3s", regs[GET_LOW_REG(sp->regoff)],
591 regs[GET_HIGH_REG(sp->regoff)]);
593 printf("%3d/%3d", GET_LOW_REG(sp->regoff),
594 GET_HIGH_REG(sp->regoff));
598 #endif /* defined(SUPPORT_COMBINE_INTEGER_REGISTERS) */
600 #if defined(ENABLE_JIT) && defined(ENABLE_DISASSEMBLER)
601 # if defined(ENABLE_INTRP)
603 printf("%3d", sp->regoff);
606 printf("%3s", regs[sp->regoff]);
608 printf("%3d", sp->regoff);
620 static void new_show_variable_array(jitdata *jd, s4 *vars, int n, int stage)
625 for (i=0; i<n; ++i) {
628 new_show_stackvar(jd, vars[i], stage);
633 void new_show_icmd(jitdata *jd, instruction *iptr, bool deadcode, int stage)
636 branch_target_t *table;
637 lookup_target_t *lookup;
638 constant_FMIref *fmiref;
642 /* get the opcode and the condition */
646 printf("%s ", icmd_names[opcode]);
648 if (stage < SHOW_PARSE)
654 /* Print the condition for conditional instructions. */
656 /* XXX print condition from flags */
658 if (iptr->flags.bits & INS_FLAG_UNRESOLVED)
659 printf("(UNRESOLVED) ");
665 case ICMD_CHECKNULL_POP:
670 case ICMD_ARRAYLENGTH:
737 /* binary/const INT */
749 case ICMD_IUSHRCONST:
752 case ICMD_LUSHRCONST:
754 SHOW_INT_CONST(iptr->sx.val.i);
758 /* ?ASTORECONST (trinary/const INT) */
759 case ICMD_IASTORECONST:
760 case ICMD_BASTORECONST:
761 case ICMD_CASTORECONST:
762 case ICMD_SASTORECONST:
765 SHOW_INT_CONST(iptr->sx.s23.s3.constval);
770 SHOW_INT_CONST(iptr->sx.val.i);
774 /* binary/const LNG */
785 SHOW_LNG_CONST(iptr->sx.val.l);
789 /* trinary/const LNG (<= pointer size) */
790 case ICMD_LASTORECONST:
793 SHOW_LNG_CONST(iptr->sx.s23.s3.constval);
798 SHOW_LNG_CONST(iptr->sx.val.l);
804 SHOW_FLT_CONST(iptr->sx.val.f);
810 SHOW_DBL_CONST(iptr->sx.val.d);
816 if (iptr->flags.bits & INS_FLAG_CLASS) {
817 SHOW_CLASSREF_OR_CLASSINFO(iptr->sx.val.c);
819 else if (iptr->sx.val.anyptr == NULL) {
823 SHOW_STRING(iptr->sx.val.stringconst);
828 case ICMD_AASTORECONST:
831 printf("%p ", (void*) iptr->sx.s23.s3.constval);
834 case ICMD_GETFIELD: /* 1 -> 1 */
835 case ICMD_PUTFIELD: /* 2 -> 0 */
836 case ICMD_PUTSTATIC: /* 1 -> 0 */
837 case ICMD_GETSTATIC: /* 0 -> 1 */
838 case ICMD_PUTSTATICCONST: /* 0 -> 0 */
839 case ICMD_PUTFIELDCONST: /* 1 -> 0 */
840 if (opcode != ICMD_GETSTATIC && opcode != ICMD_PUTSTATICCONST) {
842 if (opcode == ICMD_PUTFIELD) {
846 INSTRUCTION_GET_FIELDREF(iptr, fmiref);
849 if (opcode == ICMD_GETSTATIC || opcode == ICMD_GETFIELD) {
856 SHOW_INT_CONST(iptr->sx.val.i);
857 SHOW_DST_LOCAL(iptr);
905 SHOW_DST_LOCAL(iptr);
920 case ICMD_MULTIANEWARRAY:
921 if (stage >= SHOW_STACK) {
922 argp = iptr->sx.s23.s2.args;
923 i = iptr->s1.argcount;
925 SHOW_STACKVAR(*(argp++));
929 printf("argcount=%d ", iptr->s1.argcount);
939 case ICMD_INSTANCEOF:
944 case ICMD_INLINE_START:
945 case ICMD_INLINE_END:
949 if (stage >= SHOW_STACK) {
950 argp = iptr->sx.s23.s2.args;
951 i = iptr->s1.argcount;
953 if ((iptr->s1.argcount - 1 - i) == iptr->sx.s23.s3.bte->md->paramcount)
954 printf(" pass-through: ");
955 SHOW_STACKVAR(*(argp++));
958 printf("%s ", iptr->sx.s23.s3.bte->cname);
959 if (iptr->sx.s23.s3.bte->md->returntype.type != TYPE_VOID) {
964 case ICMD_INVOKEVIRTUAL:
965 case ICMD_INVOKESPECIAL:
966 case ICMD_INVOKESTATIC:
967 case ICMD_INVOKEINTERFACE:
968 if (stage >= SHOW_STACK) {
970 INSTRUCTION_GET_METHODDESC(iptr, md);
971 argp = iptr->sx.s23.s2.args;
972 i = iptr->s1.argcount;
974 if ((iptr->s1.argcount - 1 - i) == md->paramcount)
975 printf(" pass-through: ");
976 SHOW_STACKVAR(*(argp++));
979 INSTRUCTION_GET_METHODREF(iptr, fmiref);
980 method_methodref_print(fmiref);
981 if (fmiref->parseddesc.md->returntype.type != TYPE_VOID) {
993 SHOW_TARGET(iptr->dst);
1003 SHOW_TARGET(iptr->dst);
1007 case ICMD_INLINE_GOTO:
1008 SHOW_TARGET(iptr->dst);
1012 SHOW_TARGET(iptr->sx.s23.s3.jsrtarget);
1017 case ICMD_IFNONNULL:
1019 SHOW_TARGET(iptr->dst);
1022 case ICMD_IF_ICMPEQ:
1023 case ICMD_IF_ICMPNE:
1024 case ICMD_IF_ICMPLT:
1025 case ICMD_IF_ICMPGE:
1026 case ICMD_IF_ICMPGT:
1027 case ICMD_IF_ICMPLE:
1029 case ICMD_IF_LCMPEQ:
1030 case ICMD_IF_LCMPNE:
1031 case ICMD_IF_LCMPLT:
1032 case ICMD_IF_LCMPGE:
1033 case ICMD_IF_LCMPGT:
1034 case ICMD_IF_LCMPLE:
1036 case ICMD_IF_FCMPEQ:
1037 case ICMD_IF_FCMPNE:
1039 case ICMD_IF_FCMPL_LT:
1040 case ICMD_IF_FCMPL_GE:
1041 case ICMD_IF_FCMPL_GT:
1042 case ICMD_IF_FCMPL_LE:
1044 case ICMD_IF_FCMPG_LT:
1045 case ICMD_IF_FCMPG_GE:
1046 case ICMD_IF_FCMPG_GT:
1047 case ICMD_IF_FCMPG_LE:
1049 case ICMD_IF_DCMPEQ:
1050 case ICMD_IF_DCMPNE:
1052 case ICMD_IF_DCMPL_LT:
1053 case ICMD_IF_DCMPL_GE:
1054 case ICMD_IF_DCMPL_GT:
1055 case ICMD_IF_DCMPL_LE:
1057 case ICMD_IF_DCMPG_LT:
1058 case ICMD_IF_DCMPG_GE:
1059 case ICMD_IF_DCMPG_GT:
1060 case ICMD_IF_DCMPG_LE:
1062 case ICMD_IF_ACMPEQ:
1063 case ICMD_IF_ACMPNE:
1066 SHOW_TARGET(iptr->dst);
1069 case ICMD_TABLESWITCH:
1071 table = iptr->dst.table;
1073 i = iptr->sx.s23.s3.tablehigh
1074 - iptr->sx.s23.s2.tablelow + 1;
1076 printf("high=%d low=%d count=%d\n", iptr->sx.s23.s3.tablehigh, iptr->sx.s23.s2.tablelow, i);
1078 printf("\t\t%d --> ", table - iptr->dst.table);
1079 if (stage >= SHOW_STACK) {
1080 printf("L%03d\n", table->block->nr);
1083 printf("insindex %d (L%03d)\n", table->insindex, BLOCK_OF(table->insindex)->nr);
1090 case ICMD_LOOKUPSWITCH:
1093 printf("count=%d, default=", iptr->sx.s23.s2.lookupcount);
1094 if (stage >= SHOW_STACK) {
1095 printf("L%03d\n", iptr->sx.s23.s3.lookupdefault.block->nr);
1098 printf("insindex %d (L%03d)\n", iptr->sx.s23.s3.lookupdefault.insindex, BLOCK_OF(iptr->sx.s23.s3.lookupdefault.insindex)->nr);
1101 lookup = iptr->dst.lookup;
1102 i = iptr->sx.s23.s2.lookupcount;
1104 printf("\t\t%d --> ", lookup->value);
1105 if (stage >= SHOW_STACK) {
1106 printf("L%03d\n", lookup->target.block->nr);
1109 printf("insindex %d (L%03d)\n", lookup->target.insindex, BLOCK_OF(lookup->target.insindex)->nr);
1131 if (stage >= SHOW_STACK) {
1132 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1133 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1135 SHOW_STACKVAR(iptr->dst.dupslots[2+0]);
1136 SHOW_STACKVAR(iptr->dst.dupslots[2+1]);
1141 if (stage >= SHOW_STACK) {
1142 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1143 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1145 SHOW_STACKVAR(iptr->dst.dupslots[2+0]);
1146 SHOW_STACKVAR(iptr->dst.dupslots[2+1]);
1147 SHOW_STACKVAR(iptr->dst.dupslots[2+2]);
1152 if (stage >= SHOW_STACK) {
1153 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1154 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1155 SHOW_STACKVAR(iptr->dst.dupslots[2]);
1157 SHOW_STACKVAR(iptr->dst.dupslots[3+0]);
1158 SHOW_STACKVAR(iptr->dst.dupslots[3+1]);
1159 SHOW_STACKVAR(iptr->dst.dupslots[3+2]);
1160 SHOW_STACKVAR(iptr->dst.dupslots[3+3]);
1161 SHOW_STACKVAR(iptr->dst.dupslots[3+4]);
1166 if (stage >= SHOW_STACK) {
1167 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1168 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1169 SHOW_STACKVAR(iptr->dst.dupslots[2]);
1171 SHOW_STACKVAR(iptr->dst.dupslots[3+0]);
1172 SHOW_STACKVAR(iptr->dst.dupslots[3+1]);
1173 SHOW_STACKVAR(iptr->dst.dupslots[3+2]);
1174 SHOW_STACKVAR(iptr->dst.dupslots[3+3]);
1179 if (stage >= SHOW_STACK) {
1180 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1181 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1182 SHOW_STACKVAR(iptr->dst.dupslots[2]);
1183 SHOW_STACKVAR(iptr->dst.dupslots[4]);
1185 SHOW_STACKVAR(iptr->dst.dupslots[4+0]);
1186 SHOW_STACKVAR(iptr->dst.dupslots[4+1]);
1187 SHOW_STACKVAR(iptr->dst.dupslots[4+2]);
1188 SHOW_STACKVAR(iptr->dst.dupslots[4+3]);
1189 SHOW_STACKVAR(iptr->dst.dupslots[4+4]);
1190 SHOW_STACKVAR(iptr->dst.dupslots[4+5]);
1195 if (stage >= SHOW_STACK) {
1196 SHOW_STACKVAR(iptr->dst.dupslots[0]);
1197 SHOW_STACKVAR(iptr->dst.dupslots[1]);
1199 SHOW_STACKVAR(iptr->dst.dupslots[2+0]);
1200 SHOW_STACKVAR(iptr->dst.dupslots[2+1]);
1207 #endif /* !defined(NDEBUG) */
1211 * These are local overrides for various environment variables in Emacs.
1212 * Please do not remove this and leave it at the end of the file, where
1213 * Emacs will automagically detect them.
1214 * ---------------------------------------------------------------------
1217 * indent-tabs-mode: t
1221 * vim:noexpandtab:sw=4:ts=4: