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-interp.h | 76 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 63 insertions(+), 13 deletions(-) (limited to 'libjava/include/java-interp.h') diff --git a/libjava/include/java-interp.h b/libjava/include/java-interp.h index 4126c2f..5692861 100644 --- a/libjava/include/java-interp.h +++ b/libjava/include/java-interp.h @@ -23,6 +23,11 @@ details. */ #include #include +// Define this to get the direct-threaded interpreter. If undefined, +// we revert to a basic bytecode interpreter. The former is faster +// but uses more memory. +#define DIRECT_THREADED + extern "C" { #include } @@ -95,6 +100,41 @@ public: } }; +// The type of the PC depends on whether we're doing direct threading +// or a more ordinary bytecode interpreter. +#ifdef DIRECT_THREADED +// Slot in the "compiled" form of the bytecode. +union insn_slot +{ + // Address of code. + void *insn; + // An integer value used by an instruction. + jint int_val; + // A pointer value used by an instruction. + void *datum; +}; + +typedef insn_slot *pc_t; +#else +typedef unsigned char *pc_t; +#endif + + +// This structure holds the bytecode pc and corresponding source code +// line number. An array (plus length field) of this structure is put +// in each _Jv_InterpMethod and used to resolve the (internal) program +// counter of the interpreted method to an actual java source file +// line. +struct _Jv_LineTableEntry +{ + union + { + pc_t pc; + int bytecode_pc; + }; + int line; +}; + class _Jv_InterpMethod : public _Jv_MethodBase { _Jv_ushort max_stack; @@ -103,6 +143,10 @@ class _Jv_InterpMethod : public _Jv_MethodBase _Jv_ushort exc_count; + // Length of the line_table - when this is zero then line_table is NULL. + int line_table_len; + _Jv_LineTableEntry *line_table; + void *prepared; unsigned char* bytecode () @@ -135,17 +179,19 @@ class _Jv_InterpMethod : public _Jv_MethodBase static void run_class (ffi_cif*, void*, ffi_raw*, void*); static void run_synch_class (ffi_cif*, void*, ffi_raw*, void*); - void run (void*, ffi_raw *); + static void run (void*, ffi_raw *, _Jv_InterpMethod *); + + // Returns source file line number for given PC value, or -1 if line + // number info is unavailable. + int get_source_line(pc_t mpc); public: static void dump_object(jobject o); friend class _Jv_ClassReader; friend class _Jv_BytecodeVerifier; - friend class gnu::gcj::runtime::NameFinder; - friend class gnu::gcj::runtime::StackTrace; + friend class _Jv_StackTrace; friend class _Jv_InterpreterEngine; - #ifdef JV_MARKOBJ_DECL friend JV_MARKOBJ_DECL; @@ -155,11 +201,14 @@ class _Jv_InterpMethod : public _Jv_MethodBase class _Jv_InterpClass { _Jv_MethodBase **interpreted_methods; - _Jv_ushort *field_initializers; + _Jv_ushort *field_initializers; + jstring source_file_name; friend class _Jv_ClassReader; friend class _Jv_InterpMethod; + friend class _Jv_StackTrace; friend class _Jv_InterpreterEngine; + friend void _Jv_InitField (jobject, jclass, int); #ifdef JV_MARKOBJ_DECL friend JV_MARKOBJ_DECL; @@ -219,23 +268,24 @@ public: } }; -// A structure of this type is used to link together interpreter -// invocations on the stack. -struct _Jv_MethodChain +// The interpreted call stack, represented by a linked list of frames. +struct _Jv_InterpFrame { - const _Jv_InterpMethod *self; - _Jv_MethodChain **ptr; - _Jv_MethodChain *next; + _Jv_InterpMethod *self; + _Jv_InterpFrame **ptr; + _Jv_InterpFrame *next; + pc_t pc; - _Jv_MethodChain (const _Jv_InterpMethod *s, _Jv_MethodChain **n) + _Jv_InterpFrame (_Jv_InterpMethod *s, _Jv_InterpFrame **n) { self = s; ptr = n; next = *n; *n = this; + pc = NULL; } - ~_Jv_MethodChain () + ~_Jv_InterpFrame () { *ptr = next; } -- cgit v1.1