-/* src/vm/jit/stacktrace.c
+/* src/vm/jit/stacktrace.c - machine independent stacktrace system
- Copyright (C) 1996-2005 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 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
This file is part of CACAO.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA.
-
- Contact: cacao@complang.tuwien.ac.at
-
- Authors: Joseph Wenninger
-
- Changes: Christian Thalinger
-
- $Id: stacktrace.c 2974 2005-07-10 21:46:48Z twisti $
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
*/
+#include "config.h"
+
#include <assert.h>
#include <stdlib.h>
#include <string.h>
-#include "config.h"
-#include "asmoffsets.h"
+#include "vm/types.h"
+
+#include "mm/gc-common.h"
+#include "mm/memory.h"
-#include "mm/boehm.h"
-#include "native/native.h"
+#include "vm/jit/stacktrace.h"
#include "vm/global.h" /* required here for native includes */
-#include "native/include/java_lang_ClassLoader.h"
+#include "native/jni.h"
+#include "native/llni.h"
+#include "native/include/java_lang_Throwable.h"
+
+#if defined(WITH_CLASSPATH_GNU)
+# include "native/include/java_lang_VMThrowable.h"
+#endif
+
+#if defined(ENABLE_THREADS)
+# include "threads/native/threads.h"
+#else
+# include "threads/none/threads.h"
+#endif
#include "toolbox/logging.h"
+
#include "vm/builtin.h"
-#include "vm/class.h"
+#include "vm/cycles-stats.h"
#include "vm/exceptions.h"
-#include "vm/loader.h"
#include "vm/stringlocal.h"
-#include "vm/tables.h"
+#include "vm/vm.h"
+
#include "vm/jit/asmpart.h"
-#include "vm/jit/codegen.inc.h"
+#include "vm/jit/codegen-common.h"
+#include "vm/jit/methodheader.h"
+#include "vmcore/class.h"
+#include "vmcore/loader.h"
+#include "vmcore/options.h"
-#undef JWDEBUG
-#undef JWDEBUG2
-#undef JWDEBUG3
-/*JoWenn: simplify collectors (trace doesn't contain internal methods)*/
+/* global variables ***********************************************************/
+#if !defined(ENABLE_THREADS)
+stackframeinfo *_no_threads_stackframeinfo = NULL;
+#endif
-/* the line number is only u2, but to avoid alignment problems it is made the same size as a native
- pointer. In the structures where this is used, values of -1 or -2 have a special meainging, so
- if java bytecode is ever extended to support more than 65535 lines/file, this could will have to
- be changed.*/
+CYCLES_STATS_DECLARE(stacktrace_overhead ,100,1)
+CYCLES_STATS_DECLARE(stacktrace_fillInStackTrace,40,5000)
+CYCLES_STATS_DECLARE(stacktrace_getClassContext ,40,5000)
+CYCLES_STATS_DECLARE(stacktrace_getCurrentClass ,40,5000)
+CYCLES_STATS_DECLARE(stacktrace_getStack ,40,10000)
-#if defined(_ALPHA_) || defined(__X86_64__)
- #define LineNumber u8
-#else
- #define LineNumber u4
+
+/* stacktrace_create_stackframeinfo ********************************************
+
+ Creates an stackframe info structure for inline code in the
+ interpreter.
+
+*******************************************************************************/
+
+#if defined(ENABLE_INTRP)
+void stacktrace_create_stackframeinfo(stackframeinfo *sfi, u1 *pv, u1 *sp,
+ u1 *ra)
+{
+ stackframeinfo **psfi;
+ methodinfo *m;
+ codeinfo *code;
+
+ /* get current stackframe info pointer */
+
+ psfi = &STACKFRAMEINFO;
+
+ /* if we don't have pv handy */
+
+ if (pv == NULL) {
+#if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ pv = codegen_get_pv_from_pc(ra);
+ else
+#endif
+ {
+#if defined(ENABLE_JIT)
+ pv = md_codegen_get_pv_from_pc(ra);
#endif
+ }
+ }
+
+ /* get codeinfo pointer from data segment */
+
+ code = *((codeinfo **) (pv + CodeinfoPointer));
+
+ /* For asm_vm_call_method the codeinfo pointer is NULL. */
-typedef struct lineNumberTableEntry {
-/* The special value of -1 means that a inlined function starts, a value of -2 means that an inlined function ends*/
- LineNumber lineNr;
- u1 *pc;
-} lineNumberTableEntry;
+ m = (code == NULL) ? NULL : code->m;
-typedef struct lineNumberTableEntryInlineBegin {
-/*this should have the same layout and size as the lineNumberTableEntry*/
- LineNumber lineNrOuter;
- methodinfo *method;
-} lineNumberTableEntryInlineBegin;
+ /* fill new stackframe info structure */
+ sfi->prev = *psfi;
+ sfi->method = m;
+ sfi->pv = pv;
+ sfi->sp = sp;
+ sfi->ra = ra;
-typedef void(*CacaoStackTraceCollector)(void **,stackTraceBuffer*);
+ /* xpc is the same as ra, but is required in stacktrace_create */
-#define BLOCK_INITIALSIZE 40
-#define BLOCK_SIZEINCREMENT 40
+ sfi->xpc = ra;
+ /* store new stackframe info pointer */
-/* stacktrace_create_inline_stackframeinfo *************************************
+ *psfi = sfi;
+}
+#endif /* defined(ENABLE_INTRP) */
- Creates an stackframe info structure for an inline exception.
+
+/* stacktrace_create_extern_stackframeinfo *************************************
+
+ Creates an stackframe info structure for an extern exception
+ (hardware or assembler).
*******************************************************************************/
-void stacktrace_create_inline_stackframeinfo(stackframeinfo *sfi, u1 *pv,
- u1 *sp, functionptr ra)
+void stacktrace_create_extern_stackframeinfo(stackframeinfo *sfi, u1 *pv,
+ u1 *sp, u1 *ra, u1 *xpc)
{
- void **osfi;
+ stackframeinfo **psfi;
+#if !defined(__I386__) && !defined(__X86_64__) && !defined(__S390__) && !defined(__M68K__)
+ bool isleafmethod;
+#endif
+#if defined(ENABLE_JIT)
+ s4 framesize;
+#endif
/* get current stackframe info pointer */
- osfi = builtin_asm_get_stackframeinfo();
+ psfi = &STACKFRAMEINFO;
- /* sometimes we don't have pv in asmpart.S handy */
+ /* sometimes we don't have pv handy (e.g. in asmpart.S:
+ L_asm_call_jit_compiler_exception or in the interpreter). */
- if (pv == NULL)
- pv = (u1 *) codegen_findmethod(ra);
+ if (pv == NULL) {
+#if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ pv = codegen_get_pv_from_pc(ra);
+ else
+#endif
+ {
+#if defined(ENABLE_JIT)
+# if defined(__SPARC_64__)
+ pv = md_get_pv_from_stackframe(sp);
+# else
+ pv = md_codegen_get_pv_from_pc(ra);
+# endif
+#endif
+ }
+ }
+
+#if defined(ENABLE_JIT)
+# if defined(ENABLE_INTRP)
+ /* When using the interpreter, we pass RA to the function. */
+
+ if (!opt_intrp) {
+# endif
+# if defined(__I386__) || defined(__X86_64__) || defined(__S390__) || defined(__M68K__)
+ /* On i386 and x86_64 we always have to get the return address
+ from the stack. */
+ /* m68k has return address on stack always */
+ /* On S390 we use REG_RA as REG_ITMP3, so we have always to get
+ the RA from stack. */
+
+ framesize = *((u4 *) (pv + FrameSize));
+
+ ra = md_stacktrace_get_returnaddress(sp, framesize);
+# else
+ /* If the method is a non-leaf function, we need to get the return
+ address from the stack. For leaf functions the return address
+ is set correctly. This makes the assembler and the signal
+ handler code simpler. */
+
+ isleafmethod = *((s4 *) (pv + IsLeaf));
+
+ if (!isleafmethod) {
+ framesize = *((u4 *) (pv + FrameSize));
+
+ ra = md_stacktrace_get_returnaddress(sp, framesize);
+ }
+# endif
+# if defined(ENABLE_INTRP)
+ }
+# endif
+#endif /* defined(ENABLE_JIT) */
/* fill new stackframe info structure */
- sfi->oldThreadspecificHeadValue = *osfi;
- sfi->addressOfThreadspecificHead = osfi;
+ sfi->prev = *psfi;
sfi->method = NULL;
- sfi->pv = pv;
- sfi->beginOfJavaStackframe = sp;
- sfi->returnToFromNative = ra;
+ sfi->pv = pv;
+ sfi->sp = sp;
+ sfi->ra = ra;
+ sfi->xpc = xpc;
/* store new stackframe info pointer */
- *osfi = sfi;
+ *psfi = sfi;
}
*******************************************************************************/
void stacktrace_create_native_stackframeinfo(stackframeinfo *sfi, u1 *pv,
- u1 *sp, functionptr ra)
+ u1 *sp, u1 *ra)
{
- void **osfi;
- methodinfo *m;
+ stackframeinfo **psfi;
+ methodinfo *m;
+ codeinfo *code;
+
+ /* get codeinfo pointer from data segment */
- /* get methodinfo pointer from data segment */
+ code = *((codeinfo **) (pv + CodeinfoPointer));
- m = *((methodinfo **) (pv + MethodPointer));
+ /* For asm_vm_call_method the codeinfo pointer is NULL. */
+
+ m = (code == NULL) ? NULL : code->m;
/* get current stackframe info pointer */
- osfi = builtin_asm_get_stackframeinfo();
+ psfi = &STACKFRAMEINFO;
/* fill new stackframe info structure */
- sfi->oldThreadspecificHeadValue = *osfi;
- sfi->addressOfThreadspecificHead = osfi;
+ sfi->prev = *psfi;
sfi->method = m;
- sfi->pv = NULL;
- sfi->beginOfJavaStackframe = sp;
- sfi->returnToFromNative = ra;
+ sfi->pv = NULL;
+ sfi->sp = sp;
+ sfi->ra = ra;
+ sfi->xpc = NULL;
/* store new stackframe info pointer */
- *osfi = sfi;
+ *psfi = sfi;
}
/* stacktrace_remove_stackframeinfo ********************************************
- XXX
+ Remove the topmost stackframeinfo in the current thread.
*******************************************************************************/
void stacktrace_remove_stackframeinfo(stackframeinfo *sfi)
{
- void **osfi;
+ stackframeinfo **psfi;
- /* get address of pointer */
+ /* get current stackframe info pointer */
- osfi = sfi->addressOfThreadspecificHead;
+ psfi = &STACKFRAMEINFO;
/* restore the old pointer */
- *osfi = sfi->oldThreadspecificHeadValue;
+ *psfi = sfi->prev;
}
-/* stacktrace_new_arithmeticexception ******************************************
+/* stacktrace_add_entry ********************************************************
- Creates an ArithemticException for inline stub.
+ Adds a new entry to the stacktrace buffer.
*******************************************************************************/
-java_objectheader *stacktrace_new_arithmeticexception(u1 *pv, u1 *sp,
- functionptr ra)
+static void stacktrace_add_entry(stacktracebuffer *stb, methodinfo *m, u2 line)
{
- stackframeinfo sfi;
- java_objectheader *o;
-
- /* create stackframeinfo */
+ stacktrace_entry *ste;
- stacktrace_create_inline_stackframeinfo(&sfi, pv, sp, ra);
+ /* check if we already reached the buffer capacity */
- /* create exception */
+ if (stb->used >= stb->capacity) {
+ /* reallocate new memory */
- o = new_arithmeticexception();
+ stb->entries = DMREALLOC(stb->entries, stacktrace_entry, stb->capacity,
+ stb->capacity + STACKTRACE_CAPACITY_INCREMENT);
- /* remove stackframeinfo */
+ /* set new buffer capacity */
- stacktrace_remove_stackframeinfo(&sfi);
-
- return o;
-}
-
-
-/* stacktrace_new_arrayindexoutofboundsexception *******************************
-
- Creates an ArrayIndexOutOfBoundsException for inline stub.
+ stb->capacity = stb->capacity + STACKTRACE_CAPACITY_INCREMENT;
+ }
-*******************************************************************************/
+ /* insert the current entry */
-java_objectheader *stacktrace_new_arrayindexoutofboundsexception(u1 *pv,
- u1 *sp,
- functionptr ra,
- s4 index)
-{
- stackframeinfo sfi;
- java_objectheader *o;
+ ste = &(stb->entries[stb->used]);
- /* create stackframeinfo */
+ ste->method = m;
+ ste->linenumber = line;
- stacktrace_create_inline_stackframeinfo(&sfi, pv, sp, ra);
+ /* increase entries used count */
- /* create exception */
-
- o = new_arrayindexoutofboundsexception(index);
+ stb->used += 1;
+}
- /* remove stackframeinfo */
- stacktrace_remove_stackframeinfo(&sfi);
+/* stacktrace_add_method *******************************************************
- return o;
-}
+ Add stacktrace entries[1] for the given method to the stacktrace buffer.
+ IN:
+ stb.........stacktracebuffer to fill
+ m...........method for which entries should be created
+ pv..........pv of method
+ pc..........position of program counter within the method's code
-/* stacktrace_new_arraystoreexception ******************************************
+ OUT:
+ true, if stacktrace entries were successfully created, false otherwise.
- Creates an ArrayStoreException for inline stub.
+ [1] In case of inlined methods there may be more than one stacktrace
+ entry for a codegen-level method. (see doc/inlining_stacktrace.txt)
*******************************************************************************/
-java_objectheader *stacktrace_new_arraystoreexception(u1 *pv, u1 *sp,
- functionptr ra)
+static bool stacktrace_add_method(stacktracebuffer *stb, methodinfo *m, u1 *pv,
+ u1 *pc)
{
- stackframeinfo sfi;
- java_objectheader *o;
+ codeinfo *code; /* compiled realization of method */
+ s4 linenumber;
- /* create stackframeinfo */
+ /* find the realization of the method the pc is in */
- stacktrace_create_inline_stackframeinfo(&sfi, pv, sp, ra);
+ code = *((codeinfo **) (pv + CodeinfoPointer));
- /* create exception */
+ /* search the line number table */
- o = new_arraystoreexception();
+ linenumber = dseg_get_linenumber_from_pc(&m, pv, pc);
- /* remove stackframeinfo */
+ /* now add a new entry to the staktrace */
- stacktrace_remove_stackframeinfo(&sfi);
+ stacktrace_add_entry(stb, m, linenumber);
- return o;
+ return true;
}
-/* stacktrace_new_classcastexception *******************************************
+/* stacktrace_create ***********************************************************
+
+ Generates a stacktrace from the thread passed into a
+ stacktracebuffer. The stacktracebuffer is allocated on the
+ dump memory.
+
+ NOTE: The first element in the stackframe chain must always be a
+ native stackframeinfo (e.g. VMThrowable.fillInStackTrace() is
+ a native function).
- Creates an ClassCastException for inline stub.
+ RETURN VALUE:
+ pointer to the stacktracebuffer, or
+ NULL if there is no stacktrace available for the
+ given thread.
*******************************************************************************/
-java_objectheader *stacktrace_new_classcastexception(u1 *pv, u1 *sp,
- functionptr ra)
+stacktracebuffer *stacktrace_create(stackframeinfo *sfi)
{
- stackframeinfo sfi;
- java_objectheader *o;
-
- /* create stackframeinfo */
-
- stacktrace_create_inline_stackframeinfo(&sfi, pv, sp, ra);
-
- /* create exception */
+ stacktracebuffer *stb;
+ methodinfo *m;
+ codeinfo *code;
+ u1 *pv;
+ u1 *sp;
+ u4 framesize;
+ u1 *ra;
+ u1 *xpc;
- o = new_classcastexception();
+ /* prevent compiler warnings */
- /* remove stackframeinfo */
+ pv = NULL;
+ sp = NULL;
+ ra = NULL;
- stacktrace_remove_stackframeinfo(&sfi);
+ /* create a stacktracebuffer in dump memory */
- return o;
-}
+ stb = DNEW(stacktracebuffer);
+ stb->capacity = STACKTRACE_CAPACITY_DEFAULT;
+ stb->used = 0;
+ stb->entries = DMNEW(stacktrace_entry, STACKTRACE_CAPACITY_DEFAULT);
-/* stacktrace_new_negativearraysizeexception ***********************************
+#define PRINTMETHODS 0
- Creates an NegativeArraySizeException for inline stub.
+#if PRINTMETHODS
+ printf("\n\nfillInStackTrace start:\n");
+ fflush(stdout);
+#endif
-*******************************************************************************/
+ /* Loop while we have a method pointer (asm_calljavafunction has
+ NULL) or there is a stackframeinfo in the chain. */
-java_objectheader *stacktrace_new_negativearraysizeexception(u1 *pv, u1 *sp,
- functionptr ra)
-{
- stackframeinfo sfi;
- java_objectheader *o;
+ m = NULL;
- /* create stackframeinfo */
+ while ((m != NULL) || (sfi != NULL)) {
+ /* m == NULL should only happen for the first time and inline
+ stackframe infos, like from the exception stubs or the
+ patcher wrapper. */
- stacktrace_create_inline_stackframeinfo(&sfi, pv, sp, ra);
+ if (m == NULL) {
+ /* for native stub stackframe infos, pv is always NULL */
- /* create exception */
+ if (sfi->pv == NULL) {
+ /* get methodinfo, sp and ra from the current stackframe info */
- o = new_negativearraysizeexception();
+ m = sfi->method;
+ sp = sfi->sp; /* sp of parent Java function */
+ ra = sfi->ra;
- /* remove stackframeinfo */
+ if (m)
+ stacktrace_add_entry(stb, m, 0);
- stacktrace_remove_stackframeinfo(&sfi);
+#if PRINTMETHODS
+ printf("ra=%p sp=%p, ", ra, sp);
+ method_print(m);
+ printf(": native stub\n");
+ fflush(stdout);
+#endif
+ /* This is an native stub stackframe info, so we can
+ get the parent pv from the return address
+ (ICMD_INVOKE*). */
+
+#if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ pv = codegen_get_pv_from_pc(ra);
+ else
+#endif
+ {
+#if defined(ENABLE_JIT)
+ pv = md_codegen_get_pv_from_pc(ra);
+#endif
+ }
- return o;
-}
+ /* get methodinfo pointer from parent data segment */
+ code = *((codeinfo **) (pv + CodeinfoPointer));
-/* stacktrace_new_nullpointerexception *****************************************
+ /* For asm_vm_call_method the codeinfo pointer is
+ NULL. */
- Creates an NullPointerException for inline stub.
+ m = (code == NULL) ? NULL : code->m;
-*******************************************************************************/
+ } else {
+ /* Inline stackframe infos are special: they have a
+ xpc of the actual exception position and the return
+ address saved since an inline stackframe info can
+ also be in a leaf method (no return address saved
+ on stack!!!). ATTENTION: This one is also for
+ hardware exceptions!!! */
+
+ /* get methodinfo, sp and ra from the current stackframe info */
+
+ m = sfi->method; /* m == NULL */
+ pv = sfi->pv; /* pv of parent Java function */
+ sp = sfi->sp; /* sp of parent Java function */
+ ra = sfi->ra; /* ra of parent Java function */
+ xpc = sfi->xpc; /* actual exception position */
+
+#if PRINTMETHODS
+ printf("ra=%p sp=%p, ", ra, sp);
+ printf("NULL: inline stub\n");
+ fflush(stdout);
+#endif
-java_objectheader *stacktrace_new_nullpointerexception(u1 *pv, u1 *sp,
- functionptr ra)
-{
- stackframeinfo sfi;
- java_objectheader *o;
+ /* get methodinfo from current Java method */
- /* create stackframeinfo */
+ code = *((codeinfo **) (pv + CodeinfoPointer));
- stacktrace_create_inline_stackframeinfo(&sfi, pv, sp, ra);
+ /* For asm_vm_call_method the codeinfo pointer is
+ NULL. */
- /* create exception */
+ m = (code == NULL) ? NULL : code->m;
- o = new_nullpointerexception();
+ /* if m == NULL, this is a asm_calljavafunction call */
- /* remove stackframeinfo */
+ if (m != NULL) {
+#if PRINTMETHODS
+ printf("ra=%p sp=%p, ", ra, sp);
+ method_print(m);
+ printf(": inline stub parent");
+ fflush(stdout);
+#endif
- stacktrace_remove_stackframeinfo(&sfi);
+#if defined(ENABLE_INTRP)
+ if (!opt_intrp) {
+#endif
- return o;
-}
+ /* add the method to the stacktrace */
+ stacktrace_add_method(stb, m, pv, (u1 *) ((ptrint) xpc));
-/* stacktrace_fillInStackTrace *************************************************
+ /* get the current stack frame size */
- Fills in the correct stacktrace into an existing exception object.
+ framesize = *((u4 *) (pv + FrameSize));
-*******************************************************************************/
+#if PRINTMETHODS
+ printf(", framesize=%d\n", framesize);
+ fflush(stdout);
+#endif
-java_objectheader *stacktrace_fillInStackTrace(u1 *pv, u1 *sp, functionptr ra)
-{
- stackframeinfo sfi;
- java_objectheader *o;
- methodinfo *m;
+ /* Set stack pointer to stackframe of parent Java
+ function of the current Java function. */
- /* create stackframeinfo */
+#if defined(__I386__) || defined (__X86_64__) || defined (__M68K__)
+ sp += framesize + SIZEOF_VOID_P;
+#elif defined(__SPARC_64__)
+ sp = md_get_framepointer(sp);
+#else
+ sp += framesize;
+#endif
- stacktrace_create_inline_stackframeinfo(&sfi, pv, sp, ra);
+ /* get data segment and methodinfo pointer from
+ parent method */
- /* get exception */
+#if defined(ENABLE_JIT)
+ pv = md_codegen_get_pv_from_pc(ra);
+#endif
- o = *exceptionptr;
+ code = *((codeinfo **) (pv + CodeinfoPointer));
- /* clear exception */
+ /* For asm_vm_call_method the codeinfo pointer is
+ NULL. */
- *exceptionptr = NULL;
+ m = (code == NULL) ? NULL : code->m;
- /* resolve methodinfo pointer from exception object */
+#if defined(ENABLE_INTRP)
+ }
+#endif
+ }
+#if PRINTMETHODS
+ else {
+ printf("ra=%p sp=%p, ", ra, sp);
+ printf("asm_calljavafunction\n");
+ fflush(stdout);
+ }
+#endif
+ }
- m = class_resolvemethod(o->vftbl->class,
- utf_fillInStackTrace,
- utf_void__java_lang_Throwable);
+ /* get previous stackframeinfo in the chain */
- /* call function */
+ sfi = sfi->prev;
- asm_calljavafunction(m, o, NULL, NULL, NULL);
+ } else {
+#if PRINTMETHODS
+ printf("ra=%p sp=%p, ", ra, sp);
+ method_print(m);
+ printf(": JIT");
+ fflush(stdout);
+#endif
- /* remove stackframeinfo */
+ /* JIT method found, add it to the stacktrace (we subtract
+ 1 from the return address since it points the the
+ instruction after call). */
- stacktrace_remove_stackframeinfo(&sfi);
+ stacktrace_add_method(stb, m, pv, (u1 *) ((ptrint) ra) - 1);
- return o;
-}
+ /* get the current stack frame size */
+ framesize = *((u4 *) (pv + FrameSize));
-static void addEntry(stackTraceBuffer* buffer,methodinfo*method ,LineNumber line) {
- if (buffer->size>buffer->full) {
- stacktraceelement *tmp=&(buffer->start[buffer->full]);
- tmp->method=method;
- tmp->linenumber=line;
- buffer->full = buffer->full + 1;
-#if (defined(JWDEBUG) || defined (JWDEBUG2))
- log_text("addEntry (stacktrace):");
- printf("method %p\n",method);
- if (method) printf("method->name %p\n",method->name);
- if (method) utf_display(method->name); else printf("Native");
- if (method) {printf("\n");utf_display(method->class->name);}
- printf("\nnext buffer item %d\nLine:%ld\n",buffer->full,line);
+#if PRINTMETHODS
+ printf(", framesize=%d\n", framesize);
+ fflush(stdout);
#endif
- } else {
- stacktraceelement *newBuffer;
-#ifdef JWDEBUG
- log_text("stacktrace buffer full, resizing");
+ /* get return address of current stack frame */
+
+#if defined(ENABLE_JIT)
+# if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ ra = intrp_md_stacktrace_get_returnaddress(sp, framesize);
+ else
+# endif
+ ra = md_stacktrace_get_returnaddress(sp, framesize);
+#else
+ ra = intrp_md_stacktrace_get_returnaddress(sp, framesize);
#endif
- newBuffer =
- (stacktraceelement *) malloc((buffer->size + BLOCK_SIZEINCREMENT) *
- sizeof(stacktraceelement));
-
- if (newBuffer==0) {
- log_text("OOM during stacktrace creation");
- assert(0);
- }
-
- memcpy(newBuffer,buffer->start,buffer->size*sizeof(stacktraceelement));
- if (buffer->needsFree) free(buffer->start);
- buffer->start=newBuffer;
- buffer->size=buffer->size+BLOCK_SIZEINCREMENT;
- buffer->needsFree=1;
- addEntry(buffer,method,line);
- }
-}
+ /* get data segment and methodinfo pointer from parent method */
+#if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ pv = codegen_get_pv_from_pc(ra);
+ else
+#endif
+ {
+#if defined(ENABLE_JIT)
+# if defined(__SPARC_64__)
+ sp = md_get_framepointer(sp);
+ pv = md_get_pv_from_stackframe(sp);
+# else
+ pv = md_codegen_get_pv_from_pc(ra);
+# endif
+#endif
+ }
-/* stacktrace_fillInStackTrace_methodRecursive *********************************
+ code = *((codeinfo **) (pv + CodeinfoPointer));
- XXX
+ /* For asm_vm_call_method the codeinfo pointer is NULL. */
-*******************************************************************************/
+ m = (code == NULL) ? NULL : code->m;
-static int stacktrace_fillInStackTrace_methodRecursive(stackTraceBuffer *buffer,
- methodinfo *method,
- lineNumberTableEntry *startEntry,
- lineNumberTableEntry **entry,
- size_t *entriesAhead,
- u1 *address)
-{
+ /* walk the stack */
- size_t ahead=*entriesAhead;
- lineNumberTableEntry *ent=*entry;
- lineNumberTableEntryInlineBegin *ilStart;
-
- for (; ahead > 0; ahead--, ent++) {
- if (address >= ent->pc) {
- switch (ent->lineNr) {
- case -1: /* begin of inlined method */
- ilStart=(lineNumberTableEntryInlineBegin*)(++ent);
- ent ++;
- ahead--; ahead--;
- if (stacktrace_fillInStackTrace_methodRecursive(buffer,ilStart->method,ent,&ent,&ahead,address)) {
- addEntry(buffer,method,ilStart->lineNrOuter);
- return 1;
- }
- break;
- case -2: /* end of inlined method */
- *entry=ent;
- *entriesAhead=ahead;
- return 0;
- break;
- default:
- if (address == ent->pc) {
- addEntry(buffer, method, ent->lineNr);
- return 1;
+#if defined(ENABLE_INTRP)
+ if (opt_intrp)
+ sp = *(u1 **) (sp - framesize);
+ else
+#endif
+ {
+#if defined(__I386__) || defined (__X86_64__) || defined (__M68K__)
+ sp += framesize + SIZEOF_VOID_P;
+#elif defined(__SPARC_64__)
+ /* already has the new sp */
+#else
+ sp += framesize;
+#endif
}
- break;
- }
-
- } else {
- if (address > startEntry->pc) {
- ent--;
- addEntry(buffer, method, ent->lineNr);
- return 1;
-
- } else {
- printf("trace point: %p\n", address);
- log_text("trace point before method");
- assert(0);
- }
}
}
- ent--;
- addEntry(buffer, method, ent->lineNr);
- return 1;
+ /* return the stacktracebuffer */
+
+ if (stb->used == 0)
+ return NULL;
+ else
+ return stb;
}
-/* stacktrace_fillInStackTrace_method ******************************************
+/* stacktrace_fillInStackTrace *************************************************
- XXX
+ Generate a stacktrace from the current thread for
+ java.lang.VMThrowable.fillInStackTrace.
*******************************************************************************/
-static void stacktrace_fillInStackTrace_method(stackTraceBuffer *buffer,
- methodinfo *method, u1 *dataSeg,
- u1 *address)
+stacktracecontainer *stacktrace_fillInStackTrace(void)
{
- size_t lineNumberTableSize=(*((size_t*)(dataSeg+LineNumberTableSize)));
- lineNumberTableEntry *ent;
- void **calc;
- lineNumberTableEntry *startEntry;
+ stacktracebuffer *stb;
+ stacktracecontainer *gcstc;
+ s4 gcstc_size;
+ s4 dumpsize;
+ CYCLES_STATS_DECLARE_AND_START_WITH_OVERHEAD
- if (lineNumberTableSize == 0) {
- /* right now this happens only on i386,if the native stub causes an */
- /* exception in a <clinit> invocation (jowenn) */
+ /* mark start of dump memory area */
- addEntry(buffer, method, 0);
- return;
+ dumpsize = dump_size();
- } else {
- calc = (void **) (dataSeg + LineNumberTableStart);
- ent = (lineNumberTableEntry *) (((char *) (*calc) - (sizeof(lineNumberTableEntry) - SIZEOF_VOID_P)));
+ /* create a stacktrace from the current thread */
- ent -= (lineNumberTableSize - 1);
- startEntry = ent;
-
- if (!stacktrace_fillInStackTrace_methodRecursive(buffer, method,
- startEntry, &ent,
- &lineNumberTableSize,
- address)) {
- log_text("Trace point not found in suspected method");
- assert(0);
- }
- }
-}
+ stb = stacktrace_create(STACKFRAMEINFO);
+ if (stb == NULL)
+ goto return_NULL;
-/* cacao_stacktrace_fillInStackTrace *******************************************
+ /* allocate memory from the GC heap and copy the stacktrace buffer */
+ /* ATTENTION: use stacktracecontainer for this and make it look like
+ an array */
- XXX
+ gcstc_size = sizeof(stacktracebuffer) +
+ sizeof(stacktrace_entry) * stb->used;
+ gcstc = (stacktracecontainer *) builtin_newarray_byte(gcstc_size);
-*******************************************************************************/
+ if (gcstc == NULL)
+ goto return_NULL;
-void cacao_stacktrace_fillInStackTrace(void **target,
- CacaoStackTraceCollector coll)
-{
- stacktraceelement primaryBlock[BLOCK_INITIALSIZE*sizeof(stacktraceelement)];
- stackTraceBuffer buffer;
- stackframeinfo *info;
- methodinfo *m;
- u1 *pv;
- u1 *sp;
- u4 framesize;
- functionptr ra;
+ gcstc->stb.capacity = stb->capacity;
+ gcstc->stb.used = stb->used;
+ gcstc->stb.entries = gcstc->data;
+ MCOPY(gcstc->data, stb->entries, stacktrace_entry, stb->used);
- /* In most cases this should be enough -> one malloc less. I don't think */
- /* temporary data should be allocated with the GC, only the result. */
+ /* release dump memory */
- buffer.needsFree = 0;
- buffer.start = primaryBlock;
- buffer.size = BLOCK_INITIALSIZE; /* *sizeof(stacktraceelement); */
- buffer.full = 0;
+ dump_release(dumpsize);
- info = *((void **) builtin_asm_get_stackframeinfo());
+ CYCLES_STATS_END_WITH_OVERHEAD(stacktrace_fillInStackTrace,
+ stacktrace_overhead)
+ return gcstc;
- if (!info) {
- *target = NULL;
- return;
+return_NULL:
+ dump_release(dumpsize);
- } else {
- m = NULL;
+ CYCLES_STATS_END_WITH_OVERHEAD(stacktrace_fillInStackTrace,
+ stacktrace_overhead)
- while (m || info) {
- /* some builtin native */
+ return NULL;
+}
- if (m == NULL) {
- m = info->method;
- ra = (functionptr) info->returnToFromNative;
-#if 0
- if (m) {
- utf_display_classname(m->class->name);
- printf(".");
- utf_display(m->name);
- utf_display(m->descriptor);
- printf(": native\n");
+/* stacktrace_getClassContext **************************************************
- addEntry(&buffer, m, 0);
- } else {
- printf("NULL: native\n");
- }
-#else
- if (m) {
- addEntry(&buffer, m, 0);
- }
-#endif
+ Creates a Class context array.
- /* get data segment address */
+ RETURN VALUE:
+ the array of java.lang.Class objects, or
+ NULL if an exception has been thrown
- if (info->pv) {
- /* this is an inline info */
+*******************************************************************************/
- pv = info->pv;
+java_handle_objectarray_t *stacktrace_getClassContext(void)
+{
+ stacktracebuffer *stb;
+ stacktrace_entry *ste;
+ java_handle_objectarray_t *oa;
+ s4 oalength;
+ s4 i;
+ s4 dumpsize;
+ CYCLES_STATS_DECLARE_AND_START
- } else {
- /* this is an native stub info */
+ /* mark start of dump memory area */
- pv = (u1 *) codegen_findmethod(ra);
- }
+ dumpsize = dump_size();
- /* get methodinfo pointer from data segment */
+ /* create a stacktrace for the current thread */
- m = *((methodinfo **) (pv + MethodPointer));
+ stb = stacktrace_create(STACKFRAMEINFO);
- /* get stackpointer from stackframeinfo structure */
+ if (stb == NULL)
+ goto return_NULL;
- sp = (u1 *) info->beginOfJavaStackframe;
+ /* calculate the size of the Class array */
- info = info->oldThreadspecificHeadValue;
+ for (i = 0, oalength = 0; i < stb->used; i++)
+ if (stb->entries[i].method != NULL)
+ oalength++;
- } else {
- /* JIT method */
-
-#if 0
- utf_display_classname(m->class->name);
- printf(".");
- utf_display(m->name);
- utf_display(m->descriptor);
- printf(": JIT\n");
-#endif
+ /* The first entry corresponds to the method whose implementation */
+ /* calls stacktrace_getClassContext. We remove that entry. */
- /* add the current method to the stacktrace */
+ ste = &(stb->entries[0]);
+ ste++;
+ oalength--;
- stacktrace_fillInStackTrace_method(&buffer, m, pv,
- ((u1 *) ra) - 1);
+ /* allocate the Class array */
- /* get the current stack frame size */
+ oa = builtin_anewarray(oalength, class_java_lang_Class);
+ if (!oa)
+ goto return_NULL;
- framesize = *((u4 *) (pv + FrameSize));
+ /* fill the Class array from the stacktracebuffer */
- /* get return address of current stack frame */
+ for(i = 0; i < oalength; i++, ste++) {
+ if (ste->method == NULL) {
+ i--;
+ continue;
+ }
- ra = md_stacktrace_get_returnaddress(sp, framesize);
+ oa->data[i] = (java_object_t *) ste->method->class;
+ }
- /* get data segment and methodinfo pointer from parent method */
+ /* release dump memory */
- pv = (u1 *) codegen_findmethod(ra);
- m = *((methodinfo **) (pv + MethodPointer));
+ dump_release(dumpsize);
- /* walk the stack */
+ CYCLES_STATS_END(stacktrace_getClassContext)
-#if defined(__I386__) || defined (__X86_64__)
- sp += framesize + SIZEOF_VOID_P;
-#else
- sp += framesize;
-#endif
- }
- }
-
- if (coll)
- coll(target, &buffer);
+ return oa;
- if (buffer.needsFree)
- free(buffer.start);
+return_NULL:
+ dump_release(dumpsize);
- return;
- }
+ CYCLES_STATS_END(stacktrace_getClassContext)
- *target = NULL;
+ return NULL;
}
-static
-void stackTraceCollector(void **target, stackTraceBuffer *buffer) {
- stackTraceBuffer *dest=*target=heap_allocate(sizeof(stackTraceBuffer)+buffer->full*sizeof(stacktraceelement),true,0);
- memcpy(*target,buffer,sizeof(stackTraceBuffer));
- memcpy(dest+1,buffer->start,buffer->full*sizeof(stacktraceelement));
+/* stacktrace_getCurrentClass **************************************************
- dest->needsFree=0;
- dest->size=dest->full;
- dest->start=(stacktraceelement*)(dest+1);
+ Find the current class by walking the stack trace.
- /*
- if (buffer->full>0) {
- printf("SOURCE BUFFER:%s\n",buffer->start[0].method->name->text);
- printf("DEST BUFFER:%s\n",dest->start[0].method->name->text);
- } else printf("Buffer is empty\n");
- */
-}
+ Quote from the JNI documentation:
+
+ In the Java 2 Platform, FindClass locates the class loader
+ associated with the current native method. If the native code
+ belongs to a system class, no class loader will be
+ involved. Otherwise, the proper class loader will be invoked to
+ load and link the named class. When FindClass is called through the
+ Invocation Interface, there is no current native method or its
+ associated class loader. In that case, the result of
+ ClassLoader.getBaseClassLoader is used."
+*******************************************************************************/
-void cacao_stacktrace_NormalTrace(void **target)
+#if defined(ENABLE_JAVASE)
+classinfo *stacktrace_getCurrentClass(void)
{
- cacao_stacktrace_fillInStackTrace(target, &stackTraceCollector);
-}
+ stacktracebuffer *stb;
+ stacktrace_entry *ste;
+ methodinfo *m;
+ s4 i;
+ s4 dumpsize;
+ CYCLES_STATS_DECLARE_AND_START
+ /* mark start of dump memory area */
+ dumpsize = dump_size();
-static void classContextCollector(void **target, stackTraceBuffer *buffer)
-{
- java_objectarray *tmpArray;
- stacktraceelement *current;
- stacktraceelement *start;
- size_t size;
- size_t targetSize;
- s4 i;
-
- size = buffer->full;
- targetSize = 0;
-
- for (i = 0; i < size; i++)
- if (buffer->start[i].method != 0)
- targetSize++;
-
- start = buffer->start;
- start++;
- targetSize--;
-
- if (targetSize > 0) {
- if (start->method && (start->method->class == class_java_lang_SecurityManager)) {
- targetSize--;
- start++;
- }
- }
+ /* create a stacktrace for the current thread */
- tmpArray = builtin_anewarray(targetSize, class_java_lang_Class);
+ stb = stacktrace_create(STACKFRAMEINFO);
- for(i = 0, current = start; i < targetSize; i++, current++) {
- /* XXX TWISTI: should we use this skipping for native stubs? */
+ if (stb == NULL)
+ goto return_NULL; /* XXX exception: how to distinguish from normal NULL return? */
- if (!current->method) {
- i--;
+ /* iterate over all stacktrace entries and find the first suitable
+ class */
+
+ for (i = 0, ste = &(stb->entries[0]); i < stb->used; i++, ste++) {
+ m = ste->method;
+
+ if (m == NULL)
continue;
- }
- use_class_as_object(current->method->class);
+ if (m->class == class_java_security_PrivilegedAction)
+ goto return_NULL;
- tmpArray->data[i] = (java_objectheader *) current->method->class;
- }
+ if (m->class != NULL) {
+ dump_release(dumpsize);
- *target = tmpArray;
-}
+ CYCLES_STATS_END(stacktrace_getCurrentClass)
+ return m->class;
+ }
+ }
+ /* no Java method found on the stack */
-java_objectarray *cacao_createClassContextArray(void)
-{
- java_objectarray *array=0;
+return_NULL:
+ dump_release(dumpsize);
- cacao_stacktrace_fillInStackTrace((void **) &array, &classContextCollector);
+ CYCLES_STATS_END(stacktrace_getCurrentClass)
- return array;
+ return NULL;
}
+#endif /* ENABLE_JAVASE */
-/* stacktrace_classLoaderCollector *********************************************
+/* stacktrace_getStack *********************************************************
- XXX
+ Create a 2-dimensional array for java.security.VMAccessControler.
+
+ RETURN VALUE:
+ the arrary, or
+ NULL if an exception has been thrown
*******************************************************************************/
-static void stacktrace_classLoaderCollector(void **target,
- stackTraceBuffer *buffer)
+#if defined(ENABLE_JAVASE)
+java_handle_objectarray_t *stacktrace_getStack(void)
{
- stacktraceelement *current;
- stacktraceelement *start;
- methodinfo *m;
- ptrint size;
- s4 i;
+ stacktracebuffer *stb;
+ stacktrace_entry *ste;
+ java_handle_objectarray_t *oa;
+ java_handle_objectarray_t *classes;
+ java_handle_objectarray_t *methodnames;
+ classinfo *c;
+ java_handle_t *string;
+ s4 i;
+ s4 dumpsize;
+ CYCLES_STATS_DECLARE_AND_START
- size = buffer->full;
- start = &(buffer->start[0]);
+ /* mark start of dump memory area */
- for(i = 0, current = start; i < size; i++, current++) {
- m = current->method;
+ dumpsize = dump_size();
- if (!m)
- continue;
+ /* create a stacktrace for the current thread */
- if (m->class == class_java_security_PrivilegedAction) {
- *target = NULL;
- return;
- }
+ stb = stacktrace_create(STACKFRAMEINFO);
- if (m->class->classloader) {
- *target = (java_lang_ClassLoader *) m->class->classloader;
- return;
- }
- }
+ if (stb == NULL)
+ goto return_NULL;
- *target = NULL;
-}
+ /* get the first stacktrace entry */
+ ste = &(stb->entries[0]);
-/* cacao_currentClassLoader ****************************************************
+ /* allocate all required arrays */
- XXX
+ oa = builtin_anewarray(2, arrayclass_java_lang_Object);
-*******************************************************************************/
+ if (oa == NULL)
+ goto return_NULL;
-java_objectheader *cacao_currentClassLoader(void)
-{
- java_objectheader *header=0;
-
- cacao_stacktrace_fillInStackTrace((void**)&header,
- &stacktrace_classLoaderCollector);
+ classes = builtin_anewarray(stb->used, class_java_lang_Class);
- return header;
-}
+ if (classes == NULL)
+ goto return_NULL;
+ methodnames = builtin_anewarray(stb->used, class_java_lang_String);
-static
-void callingMethodCollector(void **target, stackTraceBuffer *buffer) {
- if (buffer->full >2) (*target)=buffer->start[2].method;
- else (*target=0);
-}
+ if (methodnames == NULL)
+ goto return_NULL;
-methodinfo *cacao_callingMethod() {
- methodinfo *method;
- cacao_stacktrace_fillInStackTrace((void**)&method,&callingMethodCollector);
- return method;
-}
+ /* set up the 2-dimensional array */
+ oa->data[0] = (java_object_t *) classes;
+ oa->data[1] = (java_object_t *) methodnames;
-static
-void getStackCollector(void **target, stackTraceBuffer *buffer)
-{
- java_objectarray *classes;
- java_objectarray *methodnames;
- java_objectarray **result=(java_objectarray**)target;
- java_lang_String *str;
- classinfo *c;
- stacktraceelement *current;
- int i,size;
+ /* iterate over all stacktrace entries */
- /*log_text("getStackCollector");*/
+ for (i = 0, ste = &(stb->entries[0]); i < stb->used; i++, ste++) {
+ c = ste->method->class;
- size = buffer->full;
+ classes->data[i] = (java_object_t *) c;
- *result = builtin_anewarray(2, arrayclass_java_lang_Object);
+ string = javastring_new(ste->method->name);
- if (!(*result))
- return;
+ if (string == NULL)
+ goto return_NULL;
- classes = builtin_anewarray(size, class_java_lang_Class);
+ methodnames->data[i] = string;
+ }
- if (!classes)
- return;
+ /* return the 2-dimensional array */
- methodnames = builtin_anewarray(size, class_java_lang_String);
+ dump_release(dumpsize);
- if (!methodnames)
- return;
+ CYCLES_STATS_END(stacktrace_getStack)
- (*result)->data[0] = (java_objectheader *) classes;
- (*result)->data[1] = (java_objectheader *) methodnames;
-
- /*log_text("Before for loop");*/
- for (i = 0, current = &(buffer->start[0]); i < size; i++, current++) {
- /*log_text("In loop");*/
- c = current->method->class;
- use_class_as_object(c);
- classes->data[i] = (java_objectheader *) c;
- str = javastring_new(current->method->name);
- if (!str)
- return;
- methodnames->data[i] = (java_objectheader *) str;
- /*printf("getStackCollector: %s.%s\n",c->name->text,current->method->name->text);*/
- }
+ return oa;
- /*if (*exceptionptr) panic("Exception in getStackCollector");*/
+return_NULL:
+ dump_release(dumpsize);
- /*log_text("loop left");*/
- return;
+ CYCLES_STATS_END(stacktrace_getStack)
+ return NULL;
}
+#endif /* ENABLE_JAVASE */
-java_objectarray *cacao_getStackForVMAccessController(void)
-{
- java_objectarray *result = NULL;
+/* stacktrace_print_trace_from_buffer ******************************************
- cacao_stacktrace_fillInStackTrace((void **) &result, &getStackCollector);
+ Print the stacktrace of a given stacktracebuffer with CACAO intern
+ methods (no Java help). This method is used by
+ stacktrace_dump_trace and builtin_trace_exception.
- return result;
-}
+*******************************************************************************/
+void stacktrace_print_trace_from_buffer(stacktracebuffer *stb)
+{
+ stacktrace_entry *ste;
+ methodinfo *m;
+ s4 i;
-/* stacktrace_dump_trace *******************************************************
+ ste = &(stb->entries[0]);
- This method is call from signal_handler_sigusr1 to dump the
- stacktrace of the current thread to stdout.
+ for (i = 0; i < stb->used; i++, ste++) {
+ m = ste->method;
-*******************************************************************************/
+ printf("\tat ");
+ utf_display_printable_ascii_classname(m->class->name);
+ printf(".");
+ utf_display_printable_ascii(m->name);
+ utf_display_printable_ascii(m->descriptor);
-void stacktrace_dump_trace(void)
-{
- stackTraceBuffer *buffer;
- stacktraceelement *element;
- methodinfo *m;
- s4 i;
+ if (m->flags & ACC_NATIVE) {
+ puts("(Native Method)");
-#if 0
- /* get thread stackframeinfo */
+ } else {
+ printf("(");
+ utf_display_printable_ascii(m->class->sourcefile);
+ printf(":%d)\n", (u4) ste->linenumber);
+ }
+ }
- info = &THREADINFO->_stackframeinfo;
+ /* just to be sure */
- /* fill stackframeinfo structure */
+ fflush(stdout);
+}
- tmp.oldThreadspecificHeadValue = *info;
- tmp.addressOfThreadspecificHead = info;
- tmp.method = NULL;
- tmp.beginOfJavaStackframe = NULL;
- tmp.returnToFromNative = _mc->gregs[REG_RIP];
- *info = &tmp;
-#endif
+/* stacktrace_print_trace ******************************************************
- /* generate stacktrace */
+ Print the stacktrace of a given exception. More or less a wrapper
+ to stacktrace_print_trace_from_buffer.
- cacao_stacktrace_NormalTrace((void **) &buffer);
+*******************************************************************************/
- /* print stacktrace */
+void stacktrace_print_trace(java_handle_t *xptr)
+{
+ java_lang_Throwable *t;
+#if defined(WITH_CLASSPATH_GNU)
+ java_lang_VMThrowable *vmt;
+#endif
+ stacktracecontainer *stc;
+ stacktracebuffer *stb;
- if (buffer) {
- element = buffer->start;
+ t = (java_lang_Throwable *) xptr;
- for (i = 0; i < buffer->size; i++, element++) {
- m = element->method;
+ if (t == NULL)
+ return;
- printf("\tat ");
- utf_display_classname(m->class->name);
- printf(".");
- utf_display(m->name);
- utf_display(m->descriptor);
+ /* now print the stacktrace */
- if (m->flags & ACC_NATIVE) {
- printf("(Native Method)\n");
+#if defined(WITH_CLASSPATH_GNU)
+ LLNI_field_get_ref(t, vmState, vmt);
+ stc = (stacktracecontainer *) LLNI_field_direct(vmt, vmData);
+#elif defined(WITH_CLASSPATH_SUN) || defined(WITH_CLASSPATH_CLDC1_1)
+ stc = (stacktracecontainer *) t->backtrace;
+#else
+# error unknown classpath configuration
+#endif
- } else {
- printf("(");
- utf_display(m->class->sourcefile);
- printf(":%d)\n", (u4) element->linenumber);
- }
- }
- }
+ stb = &(stc->stb);
- /* flush stdout */
+ stacktrace_print_trace_from_buffer(stb);
+}
- fflush(stdout);
+
+#if defined(ENABLE_CYCLES_STATS)
+void stacktrace_print_cycles_stats(FILE *file)
+{
+ CYCLES_STATS_PRINT_OVERHEAD(stacktrace_overhead,file);
+ CYCLES_STATS_PRINT(stacktrace_fillInStackTrace,file);
+ CYCLES_STATS_PRINT(stacktrace_getClassContext ,file);
+ CYCLES_STATS_PRINT(stacktrace_getCurrentClass ,file);
+ CYCLES_STATS_PRINT(stacktrace_getStack ,file);
}
+#endif
/*
* c-basic-offset: 4
* tab-width: 4
* End:
+ * vim:noexpandtab:sw=4:ts=4:
*/
projects / cacao.git / blobdiff