From 18744d9b72b028b5612e250966f9d165a40ae9d8 Mon Sep 17 00:00:00 2001 From: Bryce McKinlay Date: Thu, 10 Mar 2005 19:02:21 +0000 Subject: New Stack Trace infrastructure. 2005-03-10 Bryce McKinlay New Stack Trace infrastructure. * Makefile.am (libgcj0_convenience_la_SOURCES): Add stacktrace.cc. (gnu/gcj/runtime/StackTrace.lo): Removed. (ordinary_java_source_files): Remove obsolete files. (nat_source_files): Remove obsolete files. Add natVMThrowable.cc. * configure.host (fallback_backtrace_h): Set backtrace header for mingw and cygwin targets. * configure.ac: Make symlink for fallback backtrace headers. * Makefile.in, configure: Rebuilt. * defineclass.cc (_Jv_ClassReader::read_one_code_attribute): Read 'LineNumberTable' attribute. (_Jv_ClassReader::read_one_class_attribute): Read 'SourceFile' attribute. (_Jv_ClassReader::handleCodeAttribute): Initialize method line table fields. * exception.cc: Remove unused include. * interpret.cc (DIRECT_THREADED, insn_slot): Moved to java-interp.h. (SAVE_PC): New macro. Save current PC in the interpreter frame. (NULLCHECK, NULLARRAYCHECK): Use SAVE_PC. (_Jv_InterpMethod::compile): Translate bytecode PC values in the line table to direct threaded instruction values. (_Jv_StartOfInterpreter, _Jv_EndOfInterpreter): Removed. (_Jv_InterpMethod::run): No longer member function. All callers updated. Remove _Unwind calls. Call SAVE_PC whenever a call is made or where an instruction could throw. (_Jv_InterpMethod::get_source_line): New. Look up source line numbers in line_table. * prims.cc (catch_segv): Construct exception after MAKE_THROW_FRAME. (catch_fpe): Likewise. * stacktrace.cc: New file. Stack trace code now here. * gnu/gcj/runtime/MethodRef.java: * gnu/gcj/runtime/NameFinder.java: Mostly reimplemented. Now simply calls addr2line to look up PC addresses in a given binary or shared library. * gnu/gcj/runtime/StackTrace.java, gnu/gcj/runtime/natNameFinder.cc, gnu/gcj/runtime/natStackTrace.cc: Removed. * gnu/java/lang/MainThread.java (call_main): Add comment warning that this function name is specially recognised by the stack trace code and shouldn't be changed. * include/java-interp.h (DIRECT_THREADED, insn_slot): Moved here. (struct _Jv_LineTableEntry, line_table, line_table_len): New. (_Jv_InterpMethod::run): Update declaration. (_Jv_StackTrace_): New friend. NameFinder and StackTrace no longer friends. (_Jv_InterpFrame): Renamed from _Jv_MethodChain. Add PC field. * include/java-stack.h: New file. Declarations for stack tracing. * include/jvm.h (_Jv_Frame_info): Removed. * java/lang/Class.h: Update friend declarations. * java/lang/VMClassLoader.java (getSystemClassLoader): Simplify exception message. * java/lang/VMThrowable.java (fillInStackTrace): Now native. (getStackTrace): Now native. (data): New RawDataManaged field. * java/lang/natClass.cc: Update includes. (forName): Use _Jv_StackTrace::GetCallingClass for calling-classloader check. (getClassLoader): Likewise. * java/lang/natRuntime.cc: Update includes. (_load): Use _Jv_StackTrace::GetFirstNonSystemClassLoader. * java/lang/natVMSecurityManager.cc: Update includes. (getClassContext): Use _Jv_StackTrace::GetClassContext. * java/lang/natVMThrowable.cc: New file. Native methods for VMThrowable. * java/lang/reflect/natArray.cc: Update includes. (newInstance): Use _Jv_StackTrace::GetCallingClass to implement accessibility check. * java/lang/reflect/natConstructor.cc: Update includes. (newInstance): Use _Jv_StackTrace::GetCallingClass to implement accessibility check. * java/lang/reflect/natField.cc: Update includes. (getAddr): Use _Jv_StackTrace::GetCallingClass to implement accessibility check. * java/lang/reflect/natMethod.cc: Update includes. (invoke): Use _Jv_StackTrace::GetCallingClass to implement accessibility check. * java/util/natResourceBundle.cc: Update includes. (getCallingClassLoader): Use _Jv_StackTrace::GetCallingClass. * java/util/logging/natLogger.cc: Update includes. Use _Jv_StackTrace::GetCallerInfo to get call-site info. * sysdep/generic/backtrace.h: Fallback backtrace code. Stub implementation. * sysdep/i386/backtrace.h: New. Fallback backtrace code. i386 implementation. From-SVN: r96253 --- libjava/include/java-stack.h | 49 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 45 insertions(+), 4 deletions(-) (limited to 'libjava/include/java-stack.h') diff --git a/libjava/include/java-stack.h b/libjava/include/java-stack.h index 6c3103c..2d914cb 100644 --- a/libjava/include/java-stack.h +++ b/libjava/include/java-stack.h @@ -1,6 +1,6 @@ // java-stack.h - Definitions for unwinding & inspecting the call stack. -/* Copyright (C) 2003 Free Software Foundation +/* Copyright (C) 2005 Free Software Foundation This file is part of libgcj. @@ -21,10 +21,12 @@ details. */ #include #include #include +#include #include using namespace gnu::gcj::runtime; +using namespace java::lang; enum _Jv_FrameType { @@ -51,13 +53,44 @@ struct _Jv_StackFrame #ifdef INTERPRETER _Jv_InterpFrameInfo interp; #endif - void *ip; + struct { + void *ip; + void *start_ip; + }; }; // _Jv_FrameInfo info; /* Frame-type specific data. */ jclass klass; _Jv_Method *meth; }; +typedef struct _Jv_UnwindState; +typedef _Unwind_Reason_Code (*_Jv_TraceFn) (_Jv_UnwindState *); + +struct _Jv_UnwindState +{ + jint length; // length of FRAMES + jint pos; // current position in FRAMES + _Jv_StackFrame *frames; // array of stack frame data to be filled. + _Jv_InterpFrame *interp_frame; // current frame in the interpreter stack. + _Jv_TraceFn trace_function; // function to call back after each frame + // is enumerated. May be NULL. + void *trace_data; // additional state data for trace_function. + + _Jv_UnwindState (jint ln) + { + length = ln; + pos = 0; + frames = NULL; + Thread *thread = Thread::currentThread(); + // Check for NULL currentThread(), in case an exception is created + // very early during the runtime startup. + if (thread) + interp_frame = (_Jv_InterpFrame *) thread->interp_frame; + trace_function = NULL; + trace_data = NULL; + } +}; + class _Jv_StackTrace { private: @@ -65,20 +98,28 @@ private: _Jv_StackFrame frames[]; static void UpdateNCodeMap (); - static jclass ClassForIP (void *ip, void **ncode); + static jclass ClassForFrame (_Jv_StackFrame *frame); static void FillInFrameInfo (_Jv_StackFrame *frame); static void getLineNumberForFrame(_Jv_StackFrame *frame, NameFinder *finder, jstring *sourceFileName, jint *lineNum); static _Unwind_Reason_Code UnwindTraceFn (struct _Unwind_Context *context, void *state_ptr); + + static _Unwind_Reason_Code calling_class_trace_fn (_Jv_UnwindState *state); + static _Unwind_Reason_Code non_system_trace_fn (_Jv_UnwindState *state); public: static _Jv_StackTrace *GetStackTrace (void); static JArray< ::java::lang::StackTraceElement *>* GetStackTraceElements (_Jv_StackTrace *trace, java::lang::Throwable *throwable); - static jclass GetCallingClass (void); + static jclass GetCallingClass (jclass); + static void GetCallerInfo (jclass checkClass, jclass *, _Jv_Method **); + static JArray *GetClassContext (jclass checkClass); + static ClassLoader *GetFirstNonSystemClassLoader (void); + }; + #endif /* __JV_STACKTRACE_H__ */ -- cgit v1.1