diff options
Diffstat (limited to 'libjava/include')
-rw-r--r-- | libjava/include/java-interp.h | 76 | ||||
-rw-r--r-- | libjava/include/java-stack.h | 49 | ||||
-rw-r--r-- | libjava/include/jvm.h | 14 |
3 files changed, 108 insertions, 31 deletions
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 <java/lang/ClassLoader.h> #include <java/lang/reflect/Modifier.h> +// 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 <ffi.h> } @@ -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; } 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 <java/lang/Class.h> #include <java/lang/StackTraceElement.h> #include <java/lang/Throwable.h> +#include <java/lang/Thread.h> #include <gnu/gcj/runtime/NameFinder.h> 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<jclass> *GetClassContext (jclass checkClass); + static ClassLoader *GetFirstNonSystemClassLoader (void); + }; + #endif /* __JV_STACKTRACE_H__ */ diff --git a/libjava/include/jvm.h b/libjava/include/jvm.h index 7668703..4dfdb4d 100644 --- a/libjava/include/jvm.h +++ b/libjava/include/jvm.h @@ -120,20 +120,6 @@ union _Jv_value jobject object_value; }; -// An instance of this type is used to represent a single frame in a -// backtrace. If the interpreter has been built, we also include -// information about the interpreted method. -struct _Jv_frame_info -{ - // PC value. - void *addr; -#ifdef INTERPRETER - // Actually a _Jv_InterpMethod, but we don't want to include - // java-interp.h everywhere. - void *interp; -#endif // INTERPRETER -}; - /* Extract a character from a Java-style Utf8 string. * PTR points to the current character. * LIMIT points to the end of the Utf8 string. |