/* src/vm/jit/show.c - showing the intermediate representation
- Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
- C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
- E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
- J. Wenninger, Institut f. Computersprachen - TU Wien
+ Copyright (C) 1996-2005, 2006, 2007, 2008
+ CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
This file is part of CACAO.
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.
- Contact: cacao@cacaojvm.org
-
- Authors: Andreas Krall
-
- Changes: Edwin Steiner
- Christian Thalinger
- Christian Ullrich
-
- $Id$
-
*/
#include "config.h"
-#include "vm/types.h"
#include <assert.h>
+#include <stdint.h>
+
+#include "vm/types.h"
#include "mm/memory.h"
-#if defined(ENABLE_THREADS)
-# include "threads/native/lock.h"
-#else
-# include "threads/none/lock.h"
-#endif
+#include "threads/lock-common.h"
#include "vm/global.h"
-#include "vm/options.h"
#include "vm/builtin.h"
#include "vm/stringlocal.h"
+#include "vm/vm.h"
+
+#include "vm/jit/abi.h"
#include "vm/jit/jit.h"
#include "vm/jit/show.h"
#include "vm/jit/disass.h"
#include "vm/jit/stack.h"
+#include "vm/jit/parse.h"
+
+#include "vmcore/options.h"
+
+#if defined(ENABLE_DEBUG_FILTER)
+# include <sys/types.h>
+# include <regex.h>
+# include "threads/thread.h"
+#endif
/* global variables ***********************************************************/
#if defined(ENABLE_THREADS) && !defined(NDEBUG)
-static java_objectheader *show_global_lock;
+static java_object_t *show_global_lock;
#endif
-/* forward declarations *******************************************************/
+/* prototypes *****************************************************************/
#if !defined(NDEBUG)
-static void new_show_variable_array(jitdata *jd, s4 *vars, int n, int stage);
-static void show_allocation(s4 type, s4 flags, s4 regoff);
-static void show_variable(jitdata *jd, s4 index, int stage);
+static void show_variable_intern(jitdata *jd, s4 index, int stage);
#endif
#if defined(ENABLE_THREADS)
/* initialize the show lock */
- show_global_lock = NEW(java_objectheader);
+ show_global_lock = NEW(java_object_t);
- lock_init_object_lock(show_global_lock);
+ LOCK_INIT_OBJECT_LOCK(show_global_lock);
+#endif
+
+#if defined(ENABLE_DEBUG_FILTER)
+ show_filters_init();
#endif
/* everything's ok */
*******************************************************************************/
#if !defined(NDEBUG)
-void new_show_method(jitdata *jd, int stage)
+void show_method(jitdata *jd, int stage)
{
methodinfo *m;
codeinfo *code;
registerdata *rd;
basicblock *bptr;
basicblock *lastbptr;
- exceptiontable *ex;
+ exception_entry *ex;
s4 i, j;
- u1 *u1ptr;
+ int irstage;
+#if defined(ENABLE_DISASSEMBLER)
+ u1 *pc;
+#endif
/* get required compiler data */
LOCK_MONITOR_ENTER(show_global_lock);
+#if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ irstage = SHOW_PARSE;
+ else
+#endif
+ irstage = stage;
+
/* get the last basic block */
- for (lastbptr = jd->new_basicblocks; lastbptr->next != NULL; lastbptr = lastbptr->next);
+ for (lastbptr = jd->basicblocks; lastbptr->next != NULL; lastbptr = lastbptr->next);
printf("\n");
method_println(m);
- printf("\n(NEW INSTRUCTION FORMAT)\n");
- if (jd->isleafmethod)
+ if (code_is_leafmethod(code))
printf("LEAFMETHOD\n");
- printf("\nBasic blocks: %d\n", jd->new_basicblockcount);
+
+ printf("\nBasic blocks: %d\n", jd->basicblockcount);
if (stage >= SHOW_CODE) {
- printf("Code length: %d\n", (lastbptr->mpc - jd->new_basicblocks[0].mpc));
+ printf("Code length: %d\n", (lastbptr->mpc - jd->basicblocks[0].mpc));
printf("Data length: %d\n", cd->dseglen);
printf("Stub length: %d\n", (s4) (code->mcodelength -
((ptrint) cd->dseglen + lastbptr->mpc)));
}
- printf("Max locals: %d\n", cd->maxlocals);
- printf("Max stack: %d\n", cd->maxstack);
- printf("Line number table length: %d\n", m->linenumbercount);
+ printf("Variables: %d (%d used)\n", jd->varcount, jd->vartop);
+ if (stage >= SHOW_STACK)
+ printf("Max interfaces: %d\n", jd->maxinterfaces);
+ printf("Max locals: %d\n", jd->maxlocals);
+ printf("Max stack: %d\n", m->maxstack);
+ printf("Linenumbers: %d\n", m->linenumbercount);
+ printf("Branch to entry: %s\n", (jd->branchtoentry) ? "yes" : "no");
+ printf("Branch to end: %s\n", (jd->branchtoend) ? "yes" : "no");
+ if (stage >= SHOW_STACK) {
+ printf("Number of RETURNs: %d", jd->returncount);
+ if (jd->returncount == 1)
+ printf(" (block L%03d)", jd->returnblock->nr);
+ printf("\n");
+ }
if (stage >= SHOW_PARSE) {
- printf("Exceptions (Number: %d):\n", cd->exceptiontablelength);
- for (ex = cd->exceptiontable; ex != NULL; ex = ex->down) {
+ printf("Exceptions (Number: %d):\n", jd->exceptiontablelength);
+ for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) {
printf(" L%03d ... ", ex->start->nr );
printf("L%03d = ", ex->end->nr);
printf("L%03d", ex->handler->nr);
}
}
- if (stage >= SHOW_PARSE && rd && jd->localcount > 0) {
+ if (irstage >= SHOW_PARSE && rd && jd->localcount > 0) {
printf("Local Table:\n");
for (i = 0; i < jd->localcount; i++) {
printf(" %3d: ", i);
if (!opt_intrp) {
# endif
printf(" (%s) ", show_jit_type_names[VAR(i)->type]);
- if (stage >= SHOW_REGS)
+ if (irstage >= SHOW_REGS)
show_allocation(VAR(i)->type, VAR(i)->flags, VAR(i)->vv.regoff);
printf("\n");
# if defined(ENABLE_INTRP)
printf("\n");
}
- if (cd->maxlocals > 0) {
+ if (jd->maxlocals > 0 && jd->local_map != NULL) {
printf("Local Map:\n");
printf(" index ");
- for (j = 0; j < cd->maxlocals; j++) {
+ for (j = 0; j < jd->maxlocals; j++) {
printf(" [%2d]", j);
}
printf("\n");
for (i = 0; i < 5; i++) {
printf(" %5s ",show_jit_type_names[i]);
- for (j = 0; j < cd->maxlocals; j++) {
+ for (j = 0; j < jd->maxlocals; j++) {
if (jd->local_map[j*5+i] == UNUSED)
printf(" -- ");
else
printf("\n");
}
- if (cd->maxstack > 0 && jd->interface_map && stage >= SHOW_STACK) {
+ if (jd->maxinterfaces > 0 && jd->interface_map && irstage >= SHOW_STACK) {
bool exist = false;
interface_info *mapptr = jd->interface_map;
- /* look if there exist any IN/OUTVARS */
- for (i = 0; (i < (5 * cd->maxstack)) && !exist; i++, mapptr++)
+ /* look if there exist any INOUTS */
+ for (i = 0; (i < (5 * jd->maxinterfaces)) && !exist; i++, mapptr++)
exist = (mapptr->flags != UNUSED);
if (exist) {
printf("Interface Table: (In/Outvars)\n");
printf(" depth ");
- for (j = 0; j < cd->maxstack; j++) {
+ for (j = 0; j < jd->maxinterfaces; j++) {
printf(" [%2d]", j);
}
printf("\n");
for (i = 0; i < 5; i++) {
printf(" %5s ",show_jit_type_names[i]);
- for (j = 0; j < cd->maxstack; j++) {
+ for (j = 0; j < jd->maxinterfaces; j++) {
s4 flags = jd->interface_map[j*5+i].flags;
s4 regoff = jd->interface_map[j*5+i].regoff;
if (flags == UNUSED)
else {
int ch;
- if (stage >= SHOW_REGS) {
+ if (irstage >= SHOW_REGS) {
if (flags & SAVEDVAR) {
if (flags & INMEMORY)
ch = 'M';
}
}
- if (rd->memuse && stage >= SHOW_REGS) {
+ if (rd->memuse && irstage >= SHOW_REGS) {
int max;
max = rd->memuse;
printf("Stack slots: (memuse=%d", rd->memuse);
- if (stage >= SHOW_CODE) {
+ if (irstage >= SHOW_CODE) {
printf(", stackframesize=%d", cd->stackframesize);
max = cd->stackframesize;
}
printf(")\n");
- for (i=0; i<max; ++i) {
+ for (i = 0; i < max; ++i) {
#if defined(HAS_4BYTE_STACKSLOT)
printf(" M%02d = 0x%02x(sp): ", i, i * 4);
#else
printf(" M%02d = 0x%02x(sp): ", i, i * 8);
#endif
- for (j=0; j<jd->varcount; ++j) {
+ for (j = 0; j < jd->vartop; ++j) {
varinfo *v = VAR(j);
if ((v->flags & INMEMORY) && (v->vv.regoff == i)) {
- show_variable(jd, j, stage);
+ show_variable(jd, j, irstage);
putchar(' ');
}
}
printf("\n");
}
+#if defined(ENABLE_REPLACEMENT)
if (code->rplpoints) {
printf("Replacement Points:\n");
replace_show_replacement_points(code);
printf("\n");
}
+#endif /* defined(ENABLE_REPLACEMENT) */
#if defined(ENABLE_DISASSEMBLER)
/* show code before first basic block */
if ((stage >= SHOW_CODE) && JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd)) {
- u1ptr = (u1 *) ((ptrint) code->mcode + cd->dseglen);
+ pc = (u1 *) ((ptrint) code->mcode + cd->dseglen);
- for (; u1ptr < (u1 *) ((ptrint) code->mcode + cd->dseglen + jd->new_basicblocks[0].mpc);)
- DISASSINSTR(u1ptr);
+ for (; pc < (u1 *) ((ptrint) code->mcode + cd->dseglen + jd->basicblocks[0].mpc);)
+ DISASSINSTR(pc);
printf("\n");
}
/* show code of all basic blocks */
- for (bptr = jd->new_basicblocks; bptr != NULL; bptr = bptr->next)
- new_show_basicblock(jd, bptr, stage);
+ for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next)
+ show_basicblock(jd, bptr, stage);
-#if defined(ENABLE_DISASSEMBLER)
- /* show stubs code */
+#if 0 && defined(ENABLE_DISASSEMBLER)
+ /* show code after last basic block */
- if (stage >= SHOW_CODE && opt_showdisassemble && opt_showexceptionstubs) {
+ if (stage >= SHOW_CODE && opt_showdisassemble) {
printf("\nStubs code:\n");
printf("Length: %d\n\n", (s4) (code->mcodelength -
((ptrint) cd->dseglen + lastbptr->mpc)));
- u1ptr = (u1 *) ((ptrint) code->mcode + cd->dseglen + lastbptr->mpc);
+ pc = (u1 *) ((ptrint) code->mcode + cd->dseglen + lastbptr->mpc);
- for (; (ptrint) u1ptr < ((ptrint) code->mcode + code->mcodelength);)
- DISASSINSTR(u1ptr);
+ for (; (ptrint) pc < ((ptrint) code->mcode + code->mcodelength);)
+ DISASSINSTR(pc);
printf("\n");
}
#endif /* !defined(NDEBUG) */
+#if !defined(NDEBUG) && defined(ENABLE_INLINING)
+static void show_inline_info(jitdata *jd, insinfo_inline *ii, s4 opcode, s4 stage)
+{
+ s4 *jl;
+ s4 n;
+
+ printf("(pt %d+%d+%d st ",
+ ii->throughcount - (ii->stackvarscount - ii->paramcount),
+ ii->stackvarscount - ii->paramcount,
+ ii->paramcount);
+ show_variable_array(jd, ii->stackvars, ii->stackvarscount, stage);
+
+ if (opcode == ICMD_INLINE_START || opcode == ICMD_INLINE_END) {
+ printf(" jl ");
+ jl = (opcode == ICMD_INLINE_START) ? ii->javalocals_start : ii->javalocals_end;
+ n = (opcode == ICMD_INLINE_START) ? ii->method->maxlocals : ii->outer->maxlocals;
+ show_javalocals_array(jd, jl, n, stage);
+ }
+
+ printf(") ");
+
+#if 0
+ printf("(");
+ method_print(ii->outer);
+ printf(" ==> ");
+#endif
+
+ method_print(ii->method);
+}
+#endif /* !defined(NDEBUG) && defined(ENABLE_INLINING) */
+
+
/* show_basicblock *************************************************************
Print the intermediate representation of a basic block.
*******************************************************************************/
#if !defined(NDEBUG)
-void new_show_basicblock(jitdata *jd, basicblock *bptr, int stage)
+void show_basicblock(jitdata *jd, basicblock *bptr, int stage)
{
- methodinfo *m;
codeinfo *code;
codegendata *cd;
s4 i;
bool deadcode;
instruction *iptr;
- u1 *u1ptr;
+ int irstage;
+#if defined(ENABLE_DISASSEMBLER)
+ methodinfo *m; /* this is only a dummy */
+ void *pc;
+ s4 linenumber;
+ s4 currentlinenumber;
+#endif
/* get required compiler data */
- m = jd->m;
code = jd->code;
cd = jd->cd;
if (bptr->flags != BBDELETED) {
- deadcode = bptr->flags <= BBREACHED;
+#if defined(ENABLE_INTRP)
+ if (opt_intrp) {
+ deadcode = false;
+ irstage = SHOW_PARSE;
+ }
+ else
+#endif
+ {
+ deadcode = (bptr->flags < BBREACHED);
+ irstage = stage;
+ }
printf("======== %sL%03d ======== %s(flags: %d, bitflags: %01x, next: %d, type: ",
- (bptr->bitflags & BBFLAG_REPLACEMENT) ? "<REPLACE> " : "",
+#if defined(ENABLE_REPLACEMENT)
+ (bptr->bitflags & BBFLAG_REPLACEMENT) ? "<REPLACE> " :
+#endif
+ "",
bptr->nr,
(deadcode && stage >= SHOW_STACK) ? "DEADCODE! " : "",
bptr->flags, bptr->bitflags,
printf(", icount: %d", bptr->icount);
- if (stage >= SHOW_CFG) {
+ if (irstage >= SHOW_CFG) {
printf(", preds: %d [ ", bptr->predecessorcount);
for (i = 0; i < bptr->predecessorcount; i++)
printf("]");
}
- printf("):\n");
+ printf("):");
if (bptr->original)
printf(" (clone of L%03d)", bptr->original->nr);
printf("\n");
- if (stage >= SHOW_STACK) {
+ if (irstage >= SHOW_CFG) {
+ printf("succs: %d [ ", bptr->successorcount);
+
+ for (i = 0; i < bptr->successorcount; i++)
+ printf("%d ", bptr->successors[i]->nr);
+
+ printf("]\n");
+ }
+
+ if (irstage >= SHOW_STACK) {
printf("IN: ");
- new_show_variable_array(jd, bptr->invars, bptr->indepth, stage);
+ show_variable_array(jd, bptr->invars, bptr->indepth, irstage);
+ printf(" javalocals: ");
+ if (bptr->javalocals)
+ show_javalocals_array(jd, bptr->javalocals, bptr->method->maxlocals, irstage);
+ else
+ printf("null");
+ printf("\n");
+ }
+
+#if defined(ENABLE_INLINING)
+ if (bptr->inlineinfo) {
+ printf("inlineinfo: ");
+ show_inline_info(jd, bptr->inlineinfo, -1, irstage);
+ printf("\n");
+ }
+#endif /* defined(ENABLE_INLINING) */
+
+#if defined(ENABLE_SSA)
+
+ iptr = bptr->phis;
+
+ for (i = 0; i < bptr->phicount; i++, iptr++) {
+ printf("%4d:%4d: ", iptr->line, iptr->flags.bits >> INS_FLAG_ID_SHIFT);
+
+ show_icmd(jd, iptr, deadcode, irstage);
printf("\n");
}
+#endif
iptr = bptr->iinstr;
for (i = 0; i < bptr->icount; i++, iptr++) {
- printf("%4d: ", iptr->line);
+ printf("%4d:%4d: ", iptr->line, iptr->flags.bits >> INS_FLAG_ID_SHIFT);
- new_show_icmd(jd, iptr, deadcode, stage);
+ show_icmd(jd, iptr, deadcode, irstage);
printf("\n");
}
- if (stage >= SHOW_STACK) {
+ if (irstage >= SHOW_STACK) {
printf("OUT: ");
- new_show_variable_array(jd, bptr->outvars, bptr->outdepth, stage);
+ show_variable_array(jd, bptr->outvars, bptr->outdepth, irstage);
printf("\n");
}
(!deadcode))
{
printf("\n");
- u1ptr = (u1 *) (code->mcode + cd->dseglen + bptr->mpc);
+ pc = (void *) (code->mcode + cd->dseglen + bptr->mpc);
+ linenumber = 0;
if (bptr->next != NULL) {
- for (; u1ptr < (u1 *) (code->mcode + cd->dseglen + bptr->next->mpc);)
- DISASSINSTR(u1ptr);
+ for (; pc < (void *) (code->mcode + cd->dseglen + bptr->next->mpc);) {
+ currentlinenumber =
+ linenumbertable_linenumber_for_pc(&m, code, pc);
+
+ if (currentlinenumber != linenumber) {
+ linenumber = currentlinenumber;
+ printf("%4d:\n", linenumber);
+ }
- }
+ DISASSINSTR(pc);
+ }
+ }
else {
- for (; u1ptr < (u1 *) (code->mcode + code->mcodelength);)
- DISASSINSTR(u1ptr);
+ for (; pc < (void *) (code->mcode + code->mcodelength);) {
+ currentlinenumber =
+ linenumbertable_linenumber_for_pc(&m, code, pc);
+
+ if (currentlinenumber != linenumber) {
+ linenumber = currentlinenumber;
+ printf("%4d:\n", linenumber);
+ }
+
+ DISASSINSTR(pc);
+ }
}
printf("\n");
}
#if !defined(NDEBUG)
#define SHOW_TARGET(target) \
- if (stage >= SHOW_STACK) { \
+ if (stage >= SHOW_PARSE) { \
printf("--> L%03d ", (target).block->nr); \
} \
- else if (stage >= SHOW_PARSE) { \
- printf("--> insindex %d (L%03d) ", (target).insindex, \
- jd->new_basicblocks[jd->new_basicblockindex[ \
- (target).insindex]].nr); \
- } \
else { \
printf("--> insindex %d ", (target).insindex); \
}
#define SHOW_INT_CONST(val) \
if (stage >= SHOW_PARSE) { \
- printf("%ld ", (long) (val)); \
+ printf("%d (0x%08x) ", (int32_t) (val), (int32_t) (val)); \
} \
else { \
printf("iconst "); \
}
+#if SIZEOF_VOID_P == 4
#define SHOW_LNG_CONST(val) \
- if (stage >= SHOW_PARSE) { \
- printf("%lld ", (long long)(val)); \
- } \
- else { \
- printf("lconst "); \
- }
+ if (stage >= SHOW_PARSE) \
+ printf("%lld (0x%016llx) ", (val), (val)); \
+ else \
+ printf("lconst ");
+#else
+#define SHOW_LNG_CONST(val) \
+ if (stage >= SHOW_PARSE) \
+ printf("%ld (0x%016lx) ", (val), (val)); \
+ else \
+ printf("lconst ");
+#endif
+
+#if SIZEOF_VOID_P == 4
+#define SHOW_ADR_CONST(val) \
+ if (stage >= SHOW_PARSE) \
+ printf("0x%08x ", (ptrint) (val)); \
+ else \
+ printf("aconst ");
+#else
+#define SHOW_ADR_CONST(val) \
+ if (stage >= SHOW_PARSE) \
+ printf("0x%016lx ", (ptrint) (val)); \
+ else \
+ printf("aconst ");
+#endif
#define SHOW_FLT_CONST(val) \
if (stage >= SHOW_PARSE) { \
- printf("%g ", (val)); \
+ imm_union v; \
+ v.f = (val); \
+ printf("%g (0x%08x) ", (val), v.i); \
} \
else { \
printf("fconst "); \
}
+#if SIZEOF_VOID_P == 4
#define SHOW_DBL_CONST(val) \
if (stage >= SHOW_PARSE) { \
- printf("%g ", (val)); \
+ imm_union v; \
+ v.d = (val); \
+ printf("%g (0x%016llx) ", (val), v.l); \
} \
- else { \
- printf("dconst "); \
- }
+ else \
+ printf("dconst ");
+#else
+#define SHOW_DBL_CONST(val) \
+ if (stage >= SHOW_PARSE) { \
+ imm_union v; \
+ v.d = (val); \
+ printf("%g (0x%016lx) ", (val), v.l); \
+ } \
+ else \
+ printf("dconst ");
+#endif
#define SHOW_INDEX(index) \
if (stage >= SHOW_PARSE) { \
if (stage >= SHOW_PARSE) { \
putchar('"'); \
utf_display_printable_ascii( \
- javastring_toutf((java_lang_String *)(val), false)); \
+ javastring_toutf((java_handle_t *)(val), false)); \
printf("\" "); \
} \
else { \
printf("=> JavaL%d ", iptr->dst.varindex); \
}
-static void show_allocation(s4 type, s4 flags, s4 regoff)
+void show_allocation(s4 type, s4 flags, s4 regoff)
{
+ if (type == TYPE_RET) {
+ printf("N/A");
+ return;
+ }
+
if (flags & INMEMORY) {
printf("M%02d", regoff);
return;
GET_HIGH_REG(regoff));
else
# endif
- printf("%3s/%3s", regs[GET_LOW_REG(regoff)],
- regs[GET_HIGH_REG(regoff)]);
+ printf("%3s/%3s", abi_registers_integer_name[GET_LOW_REG(regoff)],
+ abi_registers_integer_name[GET_HIGH_REG(regoff)]);
# else
printf("%3d/%3d", GET_LOW_REG(regoff),
- GET_HIGH_REG(regoff));
+ GET_HIGH_REG(regoff));
# endif
return;
}
printf("%3d", regoff);
else
# endif
- printf("%3s", regs[regoff]);
+ printf("%3s", abi_registers_integer_name[regoff]);
#else
printf("%3d", regoff);
#endif
}
-static void show_variable(jitdata *jd, s4 index, int stage)
+void show_variable(jitdata *jd, s4 index, int stage)
+{
+ show_variable_intern(jd, index, stage);
+ putchar(' ');
+}
+
+static void show_variable_intern(jitdata *jd, s4 index, int stage)
{
char type;
char kind;
varinfo *v;
+ if (index < 0 || index >= jd->vartop) {
+ printf("<INVALID INDEX:%d>", index);
+ return;
+ }
+
v = VAR(index);
switch (v->type) {
if (index < jd->localcount) {
kind = 'L';
- if (v->flags & (PREALLOC | OUTVAR))
+ if (v->flags & (PREALLOC | INOUT))
printf("<INVALID FLAGS!>");
}
else {
if (v->flags & PREALLOC) {
kind = 'A';
- if (v->flags & OUTVAR)
- printf("<INVALID FLAGS!>");
+ if (v->flags & INOUT) {
+ /* PREALLOC is used to avoid allocation of TYPE_RET */
+ if (v->type == TYPE_RET)
+ kind = 'i';
+ else
+ printf("<INVALID FLAGS!>");
+ }
}
- else if (v->flags & OUTVAR)
+ else if (v->flags & INOUT)
kind = 'I';
else
kind = 'T';
if (v->flags & SAVEDVAR)
putchar('!');
- if (stage >= SHOW_REGS) {
+ if (stage >= SHOW_REGS || (v->flags & PREALLOC)) {
putchar('(');
show_allocation(v->type, v->flags, v->vv.regoff);
putchar(')');
}
- putchar(' ');
- fflush(stdout);
+
+ if (v->type == TYPE_RET && (v->flags & PREALLOC)) {
+ printf("(L%03d)", v->vv.retaddr->nr);
+ }
}
-static void new_show_variable_array(jitdata *jd, s4 *vars, int n, int stage)
+static void show_variable_array_intern(jitdata *jd, s4 *vars, int n, int stage,
+ bool javalocals)
{
int i;
+ int nr;
+
+ if (vars == NULL) {
+ printf("<null>");
+ return;
+ }
printf("[");
for (i=0; i<n; ++i) {
if (i)
- printf(" ");
- show_variable(jd, vars[i], stage);
+ putchar(' ');
+ if (vars[i] < 0) {
+ if (vars[i] == UNUSED)
+ putchar('-');
+ else if (javalocals) {
+ nr = RETADDR_FROM_JAVALOCAL(vars[i]);
+ printf("ret(L%03d)", nr);
+ }
+ else {
+ printf("<INVALID INDEX:%d>", vars[i]);
+ }
+ }
+ else
+ show_variable_intern(jd, vars[i], stage);
}
printf("]");
}
-void new_show_icmd(jitdata *jd, instruction *iptr, bool deadcode, int stage)
+void show_variable_array(jitdata *jd, s4 *vars, int n, int stage)
+{
+ show_variable_array_intern(jd, vars, n, stage, false);
+}
+
+void show_javalocals_array(jitdata *jd, s4 *vars, int n, int stage)
+{
+ show_variable_array_intern(jd, vars, n, stage, true);
+}
+
+void show_icmd(jitdata *jd, instruction *iptr, bool deadcode, int stage)
{
u2 opcode;
branch_target_t *table;
lookup_target_t *lookup;
constant_FMIref *fmiref;
- s4 *argp;
+ s4 *argp;
s4 i;
/* get the opcode and the condition */
opcode = iptr->opc;
- printf("%s ", icmd_names[opcode]);
+ printf("%s ", icmd_table[opcode].name);
if (stage < SHOW_PARSE)
return;
case ICMD_POP:
case ICMD_CHECKNULL:
- case ICMD_CHECKNULL_POP:
SHOW_S1(iptr);
break;
case ICMD_LORCONST:
case ICMD_LXORCONST:
SHOW_S1(iptr);
- SHOW_LNG_CONST(iptr->sx.val.l);
+ SHOW_LNG_CONST(iptr->sx.val.l);
SHOW_DST(iptr);
break;
case ICMD_LASTORECONST:
SHOW_S1(iptr);
SHOW_S2(iptr);
- SHOW_LNG_CONST(iptr->sx.s23.s3.constval);
+ SHOW_ADR_CONST(iptr->sx.s23.s3.constval);
break;
/* const LNG */
/* const ADR */
case ICMD_ACONST:
if (iptr->flags.bits & INS_FLAG_CLASS) {
+ SHOW_ADR_CONST(iptr->sx.val.anyptr);
SHOW_CLASSREF_OR_CLASSINFO(iptr->sx.val.c);
}
else if (iptr->sx.val.anyptr == NULL) {
printf("NULL ");
}
else {
+ SHOW_ADR_CONST(iptr->sx.val.anyptr);
SHOW_STRING(iptr->sx.val.stringconst);
}
SHOW_DST(iptr);
case ICMD_ASTORE:
SHOW_S1(iptr);
SHOW_DST_LOCAL(iptr);
+ if (stage >= SHOW_STACK && iptr->sx.s23.s3.javaindex != UNUSED)
+ printf(" (javaindex %d)", iptr->sx.s23.s3.javaindex);
+ if (iptr->flags.bits & INS_FLAG_RETADDR) {
+ printf(" (retaddr L%03d)", RETADDR_FROM_JAVALOCAL(iptr->sx.s23.s2.retaddrnr));
+ }
break;
case ICMD_NEW:
else {
printf("argcount=%d ", iptr->s1.argcount);
}
+ class_classref_or_classinfo_print(iptr->sx.s23.s3.c);
+ putchar(' ');
SHOW_DST(iptr);
break;
case ICMD_CHECKCAST:
SHOW_S1(iptr);
- putchar(' ');
class_classref_or_classinfo_print(iptr->sx.s23.s3.c);
+ putchar(' ');
SHOW_DST(iptr);
break;
case ICMD_INLINE_START:
case ICMD_INLINE_END:
+ case ICMD_INLINE_BODY:
+#if defined(ENABLE_INLINING)
+ {
+ insinfo_inline *ii = iptr->sx.s23.s3.inlineinfo;
+ show_inline_info(jd, ii, opcode, stage);
+ }
+#endif
break;
case ICMD_BUILTIN:
case ICMD_IFGT:
case ICMD_IFLE:
SHOW_S1(iptr);
+ SHOW_INT_CONST(iptr->sx.val.i);
SHOW_TARGET(iptr->dst);
break;
case ICMD_IF_LGT:
case ICMD_IF_LLE:
SHOW_S1(iptr);
+ SHOW_LNG_CONST(iptr->sx.val.l);
SHOW_TARGET(iptr->dst);
break;
case ICMD_GOTO:
- case ICMD_INLINE_GOTO:
SHOW_TARGET(iptr->dst);
break;
case ICMD_IF_LCMPGT:
case ICMD_IF_LCMPLE:
- case ICMD_IF_FCMPEQ:
- case ICMD_IF_FCMPNE:
-
- case ICMD_IF_FCMPL_LT:
- case ICMD_IF_FCMPL_GE:
- case ICMD_IF_FCMPL_GT:
- case ICMD_IF_FCMPL_LE:
-
- case ICMD_IF_FCMPG_LT:
- case ICMD_IF_FCMPG_GE:
- case ICMD_IF_FCMPG_GT:
- case ICMD_IF_FCMPG_LE:
-
- case ICMD_IF_DCMPEQ:
- case ICMD_IF_DCMPNE:
-
- case ICMD_IF_DCMPL_LT:
- case ICMD_IF_DCMPL_GE:
- case ICMD_IF_DCMPL_GT:
- case ICMD_IF_DCMPL_LE:
-
- case ICMD_IF_DCMPG_LT:
- case ICMD_IF_DCMPG_GE:
- case ICMD_IF_DCMPG_GT:
- case ICMD_IF_DCMPG_LE:
-
case ICMD_IF_ACMPEQ:
case ICMD_IF_ACMPNE:
SHOW_S1(iptr);
SHOW_S1(iptr);
table = iptr->dst.table;
- i = iptr->sx.s23.s3.tablehigh
- - iptr->sx.s23.s2.tablelow + 1;
+ i = iptr->sx.s23.s3.tablehigh - iptr->sx.s23.s2.tablelow + 1;
printf("high=%d low=%d count=%d\n", iptr->sx.s23.s3.tablehigh, iptr->sx.s23.s2.tablelow, i);
while (--i >= 0) {
- printf("\t\t%d --> ", table - iptr->dst.table);
- if (stage >= SHOW_STACK) {
- printf("L%03d\n", table->block->nr);
- }
- else {
- printf("insindex %d (L%03d)\n", table->insindex, BLOCK_OF(table->insindex)->nr);
- }
+ printf("\t\t%d --> ", (int) (table - iptr->dst.table));
+ printf("L%03d\n", table->block->nr);
table++;
}
case ICMD_LOOKUPSWITCH:
SHOW_S1(iptr);
- printf("count=%d, default=", iptr->sx.s23.s2.lookupcount);
- if (stage >= SHOW_STACK) {
- printf("L%03d\n", iptr->sx.s23.s3.lookupdefault.block->nr);
- }
- else {
- printf("insindex %d (L%03d)\n", iptr->sx.s23.s3.lookupdefault.insindex, BLOCK_OF(iptr->sx.s23.s3.lookupdefault.insindex)->nr);
- }
+ printf("count=%d, default=L%03d\n",
+ iptr->sx.s23.s2.lookupcount,
+ iptr->sx.s23.s3.lookupdefault.block->nr);
lookup = iptr->dst.lookup;
i = iptr->sx.s23.s2.lookupcount;
+
while (--i >= 0) {
- printf("\t\t%d --> ", lookup->value);
- if (stage >= SHOW_STACK) {
- printf("L%03d\n", lookup->target.block->nr);
- }
- else {
- printf("insindex %d (L%03d)\n", lookup->target.insindex, BLOCK_OF(lookup->target.insindex)->nr);
- }
+ printf("\t\t%d --> L%03d\n",
+ lookup->value,
+ lookup->target.block->nr);
lookup++;
}
break;
- case ICMD_ARETURN:
case ICMD_FRETURN:
case ICMD_IRETURN:
case ICMD_DRETURN:
SHOW_S1(iptr);
break;
+ case ICMD_ARETURN:
case ICMD_ATHROW:
SHOW_S1(iptr);
+ if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+ /* XXX this needs more work */
+#if 0
+ unresolved_class_debug_dump(iptr->sx.s23.s2.uc, stdout);
+#endif
+ }
break;
case ICMD_COPY:
SHOW_S1(iptr);
SHOW_DST(iptr);
break;
+ case ICMD_GETEXCEPTION:
+ SHOW_DST(iptr);
+ break;
+#if defined(ENABLE_SSA)
+ case ICMD_PHI:
+ printf("[ ");
+ for (i = 0; i < iptr->s1.argcount; ++i) {
+ SHOW_VARIABLE(iptr->sx.s23.s2.iargs[i]->dst.varindex);
+ }
+ printf("] ");
+ SHOW_DST(iptr);
+ if (iptr->flags.bits & (1 << 0)) printf("used ");
+ if (iptr->flags.bits & (1 << 1)) printf("redundantAll ");
+ if (iptr->flags.bits & (1 << 2)) printf("redundantOne ");
+ break;
+#endif
}
fflush(stdout);
}
#endif /* !defined(NDEBUG) */
+/* Debug output filtering */
+
+#if defined(ENABLE_DEBUG_FILTER)
+
+#if !defined(ENABLE_THREADS)
+u2 _no_threads_filterverbosecallctr[2] = { 0, 0 };
+#endif
+
+struct show_filter {
+ /* Boolean indicating if filter is enabled. */
+ u1 enabled;
+ /* Regular expression the method name is matched against */
+ regex_t regex;
+ /* Flag set on m->filtermatches if regex matches */
+ u1 flag;
+};
+
+typedef struct show_filter show_filter_t;
+
+#define SHOW_FILTERS_SIZE 3
+
+/* Array of filters applyed on a method */
+static struct show_filter show_filters[SHOW_FILTERS_SIZE];
+
+static void show_filter_init(show_filter_t *cf, const char *str, u1 flag, u1 default_flag, const char *description) {
+ int err;
+ char err_buf[128];
+
+ if (str) {
+ err = regcomp(&cf->regex, str, REG_EXTENDED | REG_NOSUB);
+ if (err != 0) {
+ regerror(err, &cf->regex, err_buf, sizeof(err_buf));
+ vm_abort(
+ "Invalid value given for %s: `%s' (%s).",
+ description, str, err_buf
+ );
+ }
+ cf->flag = flag;
+ cf->enabled = 1;
+ } else {
+ cf->flag = default_flag;
+ cf->enabled = 0;
+ }
+}
+
+void show_filters_init(void) {
+
+ show_filter_init(
+ show_filters + 0,
+ opt_filter_verbosecall_include,
+ SHOW_FILTER_FLAG_VERBOSECALL_INCLUDE,
+ SHOW_FILTER_FLAG_VERBOSECALL_INCLUDE,
+ "verbose call include filter"
+ );
+
+ show_filter_init(
+ show_filters + 1,
+ opt_filter_verbosecall_exclude,
+ SHOW_FILTER_FLAG_VERBOSECALL_EXCLUDE,
+ 0,
+ "verbose call exclude filter"
+ );
+
+ show_filter_init(
+ show_filters + 2,
+ opt_filter_show_method,
+ SHOW_FILTER_FLAG_SHOW_METHOD,
+ SHOW_FILTER_FLAG_SHOW_METHOD,
+ "show method filter"
+ );
+}
+
+/*
+
+ (Pseudo)State machine:
+
+ States are INITIAL, INCLUDE1, INCLUDE2, ..., EXCLUDE1, ..., EXCLUDE2, ...
+
+ Enter Enter
+ Enter Include Include
+ Exclude | | | |
+ | | Enter Enter Enter | | Enter | |
+ | | Include Include Exclude | | Exclude | |
+ | v ---------> ----------> ----------> | v ----------> | v
+INITIAL INCLUDE1 INCLUDE2 EXCLUDE1 EXCLUDE2
+ | ^ <--------- <---------- <---------- | ^ <---------- | ^
+ | | Exit Exit Exit | | Exit | |
+ | | Include Include Exclude | | Exclude | |
+ | | | | | |
+ Exit Exit Exit
+ Exclude Include Include
+
+ Verbose call scope is active if we are in a INCLUDE state.
+
+ State encoding:
+
+ INITIAL: ctr[0] == 0, ctr[1] == 0
+ INCLUDEN: ctr[1] == N, ctr[1] == 0
+ EXCLUDEN: ctr[1] == N
+*/
+
+void show_filters_apply(methodinfo *m) {
+ int i;
+ int res;
+ char *method_name;
+ s4 len;
+ int32_t dumpmarker;
+
+ /* compose full name of method */
+
+ len =
+ utf_bytes(m->clazz->name) +
+ 1 +
+ utf_bytes(m->name) +
+ utf_bytes(m->descriptor) +
+ 1;
+
+ DMARKER;
+
+ method_name = DMNEW(char, len);
+
+ utf_cat_classname(method_name, m->clazz->name);
+ strcat(method_name, ".");
+ utf_cat(method_name, m->name);
+ utf_cat(method_name, m->descriptor);
+
+ /* reset all flags */
+
+ m->filtermatches = 0;
+
+ for (i = 0; i < SHOW_FILTERS_SIZE; ++i) {
+ if (show_filters[i].enabled) {
+
+ res = regexec(&show_filters[i].regex, method_name, 0, NULL, 0);
+
+ if (res == 0) {
+ m->filtermatches |= show_filters[i].flag;
+ }
+ } else {
+ /* Default is to show all */
+ m->filtermatches |= show_filters[i].flag;
+ }
+ }
+
+ /* release memory */
+
+ DRELEASE;
+}
+
+#define STATE_IS_INITIAL() ((FILTERVERBOSECALLCTR[0] == 0) && (FILTERVERBOSECALLCTR[1] == 0))
+#define STATE_IS_INCLUDE() ((FILTERVERBOSECALLCTR[0] > 0) && (FILTERVERBOSECALLCTR[1] == 0))
+#define STATE_IS_EXCLUDE() (FILTERVERBOSECALLCTR[1] > 0)
+#define EVENT_INCLUDE() (m->filtermatches & SHOW_FILTER_FLAG_VERBOSECALL_INCLUDE)
+#define EVENT_EXCLUDE() (m->filtermatches & SHOW_FILTER_FLAG_VERBOSECALL_EXCLUDE)
+#define TRANSITION_NEXT_INCLUDE() ++FILTERVERBOSECALLCTR[0]
+#define TRANSITION_PREV_INCLUDE() --FILTERVERBOSECALLCTR[0]
+#define TRANSITION_NEXT_EXCLUDE() ++FILTERVERBOSECALLCTR[1]
+#define TRANSITION_PREV_EXCLUDE() --FILTERVERBOSECALLCTR[1]
+
+#if 0
+void dump_state() {
+ if (STATE_IS_INITIAL()) printf("<INITIAL>\n");
+ else if (STATE_IS_INCLUDE()) printf("<INCLUDE %hd>\n", FILTERVERBOSECALLCTR[0]);
+ else if (STATE_IS_EXCLUDE()) printf("<EXCLUDE %hd>\n", FILTERVERBOSECALLCTR[1]);
+}
+#endif
+
+int show_filters_test_verbosecall_enter(methodinfo *m) {
+
+ int force_show = 0;
+
+ if (STATE_IS_INITIAL()) {
+ if (EVENT_INCLUDE()) {
+ TRANSITION_NEXT_INCLUDE();
+ }
+ } else if (STATE_IS_INCLUDE()) {
+ if (EVENT_EXCLUDE()) {
+ TRANSITION_NEXT_EXCLUDE();
+ /* just entered exclude, show this method */
+ force_show = 1;
+ } else if (EVENT_INCLUDE()) {
+ TRANSITION_NEXT_INCLUDE();
+ }
+ } else if (STATE_IS_EXCLUDE()) {
+ if (EVENT_EXCLUDE()) {
+ TRANSITION_NEXT_EXCLUDE();
+ }
+ }
+
+ return STATE_IS_INCLUDE() || force_show;
+}
+
+int show_filters_test_verbosecall_exit(methodinfo *m) {
+
+ int force_show = 0;
+
+ if (m) {
+ if (STATE_IS_INCLUDE()) {
+ if (EVENT_INCLUDE()) {
+ TRANSITION_PREV_INCLUDE();
+ /* just entered initial, show this method */
+ if (STATE_IS_INITIAL()) force_show = 1;
+ }
+ } else if (STATE_IS_EXCLUDE()) {
+ if (EVENT_EXCLUDE()) {
+ TRANSITION_PREV_EXCLUDE();
+ }
+ }
+ }
+
+ return STATE_IS_INCLUDE() || force_show;
+}
+
+#endif
+
/*
* These are local overrides for various environment variables in Emacs.