X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=libjava%2Finterpret.cc;h=78686fd55b7a605034ef067d6eed5de291fbff09;hp=43d627921fb808eb7a9c05e179b446a024bbd5ec;hb=11ba5d591c5736e46afec6b9c43d97ba26b67836;hpb=82733f8decd8b228c8152ae27fd102701250c456 diff --git a/libjava/interpret.cc b/libjava/interpret.cc index 43d627921fb..78686fd55b7 100644 --- a/libjava/interpret.cc +++ b/libjava/interpret.cc @@ -1,6 +1,6 @@ // interpret.cc - Code for the interpreter -/* Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation +/* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation This file is part of libgcj. @@ -11,11 +11,7 @@ details. */ /* Author: Kresten Krab Thorup */ #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 +#include #pragma implementation "java-interp.h" @@ -29,53 +25,87 @@ details. */ #include #include #include -#include -#include #include #include #include #include +#include #include #include #include +#include +#include +#include + +#include +#include "jvmti-int.h" + +#include +#include -#ifdef INTERPRETER +// Execution engine for interpreted code. +_Jv_InterpreterEngine _Jv_soleInterpreterEngine; #include using namespace gcj; -static void throw_internal_error (char *msg) +static void throw_internal_error (const char *msg) __attribute__ ((__noreturn__)); static void throw_incompatible_class_change_error (jstring msg) __attribute__ ((__noreturn__)); -#ifndef HANDLE_SEGV static void throw_null_pointer_exception () __attribute__ ((__noreturn__)); -#endif -extern "C" double __ieee754_fmod (double,double); +static void throw_class_format_error (jstring msg) + __attribute__ ((__noreturn__)); +static void throw_class_format_error (const char *msg) + __attribute__ ((__noreturn__)); + +static void find_catch_location (jthrowable, jthread, jmethodID *, jlong *); + +// A macro to facilitate JVMTI exception reporting +#define REPORT_EXCEPTION(Jthrowable) \ + do { \ + if (JVMTI_REQUESTED_EVENT (Exception)) \ + _Jv_ReportJVMTIExceptionThrow (Jthrowable); \ + } \ + while (0) + +#ifdef DIRECT_THREADED +// Lock to ensure that methods are not compiled concurrently. +// We could use a finer-grained lock here, however it is not safe to use +// the Class monitor as user code in another thread could hold it. +static _Jv_Mutex_t compile_mutex; + +// See class ThreadCountAdjuster and REWRITE_INSN for how this is +// used. +_Jv_Mutex_t _Jv_InterpMethod::rewrite_insn_mutex; -// This represents a single slot in the "compiled" form of the -// bytecode. -union insn_slot +void +_Jv_InitInterpreter() { - // Address of code. - void *insn; - // An integer value used by an instruction. - jint int_val; - // A pointer value used by an instruction. - void *datum; -}; - -// The type of the PC depends on whether we're doing direct threading -// or a more ordinary bytecode interpreter. + _Jv_MutexInit (&compile_mutex); + _Jv_MutexInit (&_Jv_InterpMethod::rewrite_insn_mutex); +} +#else +void _Jv_InitInterpreter() {} +#endif + +// The breakpoint instruction. For the direct threaded case, +// _Jv_InterpMethod::compile will initialize breakpoint_insn +// the first time it is called. #ifdef DIRECT_THREADED -typedef insn_slot *pc_t; +insn_slot _Jv_InterpMethod::bp_insn_slot; +pc_t _Jv_InterpMethod::breakpoint_insn = NULL; #else -typedef unsigned char *pc_t; +unsigned char _Jv_InterpMethod::bp_insn_opcode + = static_cast (op_breakpoint); +pc_t _Jv_InterpMethod::breakpoint_insn = &_Jv_InterpMethod::bp_insn_opcode; #endif +extern "C" double __ieee754_fmod (double,double); + static inline void dupx (_Jv_word *sp, int n, int x) { // first "slide" n+x elements n to the right @@ -90,7 +120,6 @@ static inline void dupx (_Jv_word *sp, int n, int x) { sp[top-(n+x)-i] = sp[top-i]; } - } // Used to convert from floating types to integral types. @@ -154,24 +183,81 @@ convert (FROM val, TO min, TO max) # define LOADD(I) LOADL(I) #endif -#define STOREA(I) locals[I].o = (--sp)->o -#define STOREI(I) locals[I].i = (--sp)->i -#define STOREF(I) locals[I].f = (--sp)->f +#define STOREA(I) \ + do \ + { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'o'); \ + locals[__idx].o = (--sp)->o; \ + } \ + while (0) +#define STOREI(I) \ + do \ + { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'i'); \ + locals[__idx].i = (--sp)->i; \ + } while (0) +#define STOREF(I) \ + do \ + { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'f'); \ + locals[__idx].f = (--sp)->f; \ + } \ + while (0) #if SIZEOF_VOID_P == 8 -# define STOREL(I) (sp -= 2, locals[I].l = sp->l) -# define STORED(I) (sp -= 2, locals[I].d = sp->d) +# define STOREL(I) \ + do \ + { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'l'); \ + DEBUG_LOCALS_INSN (__idx + 1, 'x'); \ + (sp -= 2, locals[__idx].l = sp->l); \ + } \ + while (0) +# define STORED(I) \ + do \ + { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'd'); \ + DEBUG_LOCALS_INSN (__idx + 1, 'x'); \ + (sp -= 2, locals[__idx].d = sp->d); \ + } \ + while (0) + #else -# define STOREL(I) do { jint __idx = (I); \ - locals[__idx+1].ia[0] = (--sp)->ia[0]; \ - locals[__idx].ia[0] = (--sp)->ia[0]; \ - } while (0) -# define STORED(I) STOREL(I) +# define STOREL(I) \ + do \ + { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'l'); \ + DEBUG_LOCALS_INSN (__idx + 1, 'x'); \ + locals[__idx + 1].ia[0] = (--sp)->ia[0]; \ + locals[__idx].ia[0] = (--sp)->ia[0]; \ + } \ + while (0) +# define STORED(I) \ + do { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'd'); \ + DEBUG_LOCALS_INSN (__idx + 1, 'x'); \ + locals[__idx + 1].ia[0] = (--sp)->ia[0]; \ + locals[__idx].ia[0] = (--sp)->ia[0]; \ + } while (0) #endif #define PEEKI(I) (locals+(I))->i #define PEEKA(I) (locals+(I))->o -#define POKEI(I,V) ((locals+(I))->i = (V)) +#define POKEI(I,V) \ + do \ + { \ + jint __idx = (I); \ + DEBUG_LOCALS_INSN (__idx, 'i'); \ + ((locals + __idx)->i = (V)); \ + } \ + while (0) #define BINOPI(OP) { \ @@ -198,88 +284,160 @@ convert (FROM val, TO min, TO max) PUSHD(value1 OP value2); \ } -static inline jint get1s(unsigned char* loc) { +static inline jint +get1s (unsigned char* loc) +{ return *(signed char*)loc; } -static inline jint get1u(unsigned char* loc) { +static inline jint +get1u (unsigned char* loc) +{ return *loc; } -static inline jint get2s(unsigned char* loc) { +static inline jint +get2s(unsigned char* loc) +{ return (((jint)*(signed char*)loc) << 8) | ((jint)*(loc+1)); } -static inline jint get2u(unsigned char* loc) { +static inline jint +get2u (unsigned char* loc) +{ return (((jint)(*loc)) << 8) | ((jint)*(loc+1)); } -static jint get4(unsigned char* loc) { +static jint +get4 (unsigned char* loc) +{ return (((jint)(loc[0])) << 24) | (((jint)(loc[1])) << 16) | (((jint)(loc[2])) << 8) | (((jint)(loc[3])) << 0); } +#define SAVE_PC() frame_desc.pc = pc +// We used to define this conditionally, depending on HANDLE_SEGV. +// However, that runs into a problem if a chunk in low memory is +// mapped and we try to look at a field near the end of a large +// object. See PR 26858 for details. It is, most likely, relatively +// inexpensive to simply do this check always. +#define NULLCHECK(X) \ + do { SAVE_PC(); if ((X)==NULL) throw_null_pointer_exception (); } while (0) + +// Note that we can still conditionally define NULLARRAYCHECK, since +// we know that all uses of an array will first reference the length +// field, which is first -- and thus will trigger a SEGV. #ifdef HANDLE_SEGV -#define NULLCHECK(X) -#define NULLARRAYCHECK(X) +#define NULLARRAYCHECK(X) SAVE_PC() #else -#define NULLCHECK(X) \ - do { if ((X)==NULL) throw_null_pointer_exception (); } while (0) -#define NULLARRAYCHECK(X) \ - do { if ((X)==NULL) { throw_null_pointer_exception (); } } while (0) +#define NULLARRAYCHECK(X) \ + do \ + { \ + SAVE_PC(); \ + if ((X) == NULL) { throw_null_pointer_exception (); } \ + } while (0) #endif -#define ARRAYBOUNDSCHECK(array, index) \ - do \ - { \ - if (((unsigned) index) >= (unsigned) (array->length)) \ - _Jv_ThrowBadArrayIndex (index); \ - } \ - while (0) +#define ARRAYBOUNDSCHECK(array, index) \ + do \ + { \ + if (((unsigned) index) >= (unsigned) (array->length)) \ + _Jv_ThrowBadArrayIndex (index); \ + } while (0) void _Jv_InterpMethod::run_normal (ffi_cif *, - void* ret, - ffi_raw * args, - void* __this) + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) +{ + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; + run (ret, args, _this); +} + +void +_Jv_InterpMethod::run_normal_debug (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) { _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; - _this->run (ret, args); + run_debug (ret, args, _this); } void _Jv_InterpMethod::run_synch_object (ffi_cif *, - void* ret, - ffi_raw * args, - void* __this) + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) +{ + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; + + jobject rcv = (jobject) args[0].ptr; + JvSynchronize mutex (rcv); + + run (ret, args, _this); +} + +void +_Jv_InterpMethod::run_synch_object_debug (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) { _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; jobject rcv = (jobject) args[0].ptr; JvSynchronize mutex (rcv); - _this->run (ret, args); + run_debug (ret, args, _this); } void _Jv_InterpMethod::run_class (ffi_cif *, - void* ret, - ffi_raw * args, - void* __this) + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) +{ + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; + _Jv_InitClass (_this->defining_class); + run (ret, args, _this); +} + +void +_Jv_InterpMethod::run_class_debug (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) { _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; _Jv_InitClass (_this->defining_class); - _this->run (ret, args); + run_debug (ret, args, _this); } void _Jv_InterpMethod::run_synch_class (ffi_cif *, - void* ret, - ffi_raw * args, - void* __this) + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) +{ + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; + + jclass sync = _this->defining_class; + _Jv_InitClass (sync); + JvSynchronize mutex (sync); + + run (ret, args, _this); +} + +void +_Jv_InterpMethod::run_synch_class_debug (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) { _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; @@ -287,7 +445,7 @@ _Jv_InterpMethod::run_synch_class (ffi_cif *, _Jv_InitClass (sync); JvSynchronize mutex (sync); - _this->run (ret, args); + run_debug (ret, args, _this); } #ifdef DIRECT_THREADED @@ -328,6 +486,7 @@ _Jv_InterpMethod::compile (const void * const *insn_targets) if (! first_pass) { insns = (insn_slot *) _Jv_AllocBytes (sizeof (insn_slot) * next); + number_insn_slots = next; next = 0; } @@ -505,7 +664,16 @@ _Jv_InterpMethod::compile (const void * const *insn_targets) { int index = get1u (pc); ++pc; - SET_DATUM (pool_data[index].o); + // For an unresolved class we want to delay resolution + // until execution. + if (defining_class->constants.tags[index] == JV_CONSTANT_Class) + { + --next; + SET_INSN (insn_targets[int (op_jsr_w) + 1]); + SET_INT (index); + } + else + SET_DATUM (pool_data[index].o); } break; @@ -535,7 +703,16 @@ _Jv_InterpMethod::compile (const void * const *insn_targets) { int index = get2u (pc); pc += 2; - SET_DATUM (pool_data[index].o); + // For an unresolved class we want to delay resolution + // until execution. + if (defining_class->constants.tags[index] == JV_CONSTANT_Class) + { + --next; + SET_INSN (insn_targets[int (op_jsr_w) + 1]); + SET_INT (index); + } + else + SET_DATUM (pool_data[index].o); } break; @@ -736,6 +913,7 @@ _Jv_InterpMethod::compile (const void * const *insn_targets) case op_getstatic_4: case op_getstatic_8: case op_getstatic_a: + case op_breakpoint: default: // Fail somehow. break; @@ -750,2492 +928,1022 @@ _Jv_InterpMethod::compile (const void * const *insn_targets) exc[i].start_pc.p = &insns[pc_mapping[exc[i].start_pc.i]]; exc[i].end_pc.p = &insns[pc_mapping[exc[i].end_pc.i]]; exc[i].handler_pc.p = &insns[pc_mapping[exc[i].handler_pc.i]]; - jclass handler = (_Jv_ResolvePoolEntry (defining_class, - exc[i].handler_type.i)).clazz; + // FIXME: resolve_pool_entry can throw - we shouldn't be doing this + // during compilation. + jclass handler + = (_Jv_Linker::resolve_pool_entry (defining_class, + exc[i].handler_type.i)).clazz; exc[i].handler_type.p = handler; } + // Translate entries in the LineNumberTable from bytecode PC's to direct + // threaded interpreter instruction values. + for (int i = 0; i < line_table_len; i++) + { + int byte_pc = line_table[i].bytecode_pc; + // It isn't worth throwing an exception if this table is + // corrupted, but at the same time we don't want a crash. + if (byte_pc < 0 || byte_pc >= code_length) + byte_pc = 0; + line_table[i].pc = &insns[pc_mapping[byte_pc]]; + } + prepared = insns; + + // Now remap the variable table for this method. + for (int i = 0; i < local_var_table_len; ++i) + { + int start_byte = local_var_table[i].bytecode_pc; + if (start_byte < 0 || start_byte >= code_length) + start_byte = 0; + jlocation start = pc_mapping[start_byte]; + + int end_byte = start_byte + local_var_table[i].length; + if (end_byte < 0) + end_byte = 0; + jlocation end = ((end_byte >= code_length) + ? number_insn_slots + : pc_mapping[end_byte]); + + local_var_table[i].pc = &insns[start]; + local_var_table[i].length = end - start + 1; + } + + if (breakpoint_insn == NULL) + { + bp_insn_slot.insn = const_cast (insn_targets[op_breakpoint]); + breakpoint_insn = &bp_insn_slot; + } } #endif /* DIRECT_THREADED */ -// This function exists so that the stack-tracing code can find the -// boundaries of the interpreter. +/* Run the given method. + When args is NULL, don't run anything -- just compile it. */ void -_Jv_StartOfInterpreter (void) +_Jv_InterpMethod::run (void *retp, INTERP_FFI_RAW_TYPE *args, + _Jv_InterpMethod *meth) { +#undef __GCJ_DEBUG +#undef DEBUG_LOCALS_INSN +#define DEBUG_LOCALS_INSN(s, t) do {} while (0) + +#include "interpret-run.cc" } void -_Jv_InterpMethod::run (void *retp, ffi_raw *args) +_Jv_InterpMethod::run_debug (void *retp, INTERP_FFI_RAW_TYPE *args, + _Jv_InterpMethod *meth) { - using namespace java::lang::reflect; - - // FRAME_DESC registers this particular invocation as the top-most - // interpreter frame. This lets the stack tracing code (for - // Throwable) print information about the method being interpreted - // rather than about the interpreter itself. FRAME_DESC has a - // destructor so it cleans up automatically when the interpreter - // returns. - java::lang::Thread *thread = java::lang::Thread::currentThread(); - _Jv_MethodChain frame_desc (this, - (_Jv_MethodChain **) &thread->interp_frame); - - _Jv_word stack[max_stack]; - _Jv_word *sp = stack; - - _Jv_word locals[max_locals]; +#define __GCJ_DEBUG +#undef DEBUG_LOCALS_INSN +#define DEBUG_LOCALS_INSN(s, t) \ + do \ + { \ + frame_desc.locals_type[s] = t; \ + } \ + while (0) - /* Go straight at it! the ffi raw format matches the internal - stack representation exactly. At least, that's the idea. - */ - memcpy ((void*) locals, (void*) args, args_raw_size); +#include "interpret-run.cc" +} - _Jv_word *pool_data = defining_class->constants.data; +static void +throw_internal_error (const char *msg) +{ + jthrowable t = new java::lang::InternalError (JvNewStringLatin1 (msg)); + REPORT_EXCEPTION (t); + throw t; +} - /* These three are temporaries for common code used by several - instructions. */ - void (*fun)(); - _Jv_ResolvedMethod* rmeth; - int tmpval; - -#define INSN_LABEL(op) &&insn_##op - - static const void *const insn_target[] = - { - INSN_LABEL(nop), - INSN_LABEL(aconst_null), - INSN_LABEL(iconst_m1), - INSN_LABEL(iconst_0), - INSN_LABEL(iconst_1), - INSN_LABEL(iconst_2), - INSN_LABEL(iconst_3), - INSN_LABEL(iconst_4), - INSN_LABEL(iconst_5), - INSN_LABEL(lconst_0), - INSN_LABEL(lconst_1), - INSN_LABEL(fconst_0), - INSN_LABEL(fconst_1), - INSN_LABEL(fconst_2), - INSN_LABEL(dconst_0), - INSN_LABEL(dconst_1), - INSN_LABEL(bipush), - INSN_LABEL(sipush), - INSN_LABEL(ldc), - INSN_LABEL(ldc_w), - INSN_LABEL(ldc2_w), - INSN_LABEL(iload), - INSN_LABEL(lload), - INSN_LABEL(fload), - INSN_LABEL(dload), - INSN_LABEL(aload), - INSN_LABEL(iload_0), - INSN_LABEL(iload_1), - INSN_LABEL(iload_2), - INSN_LABEL(iload_3), - INSN_LABEL(lload_0), - INSN_LABEL(lload_1), - INSN_LABEL(lload_2), - INSN_LABEL(lload_3), - INSN_LABEL(fload_0), - INSN_LABEL(fload_1), - INSN_LABEL(fload_2), - INSN_LABEL(fload_3), - INSN_LABEL(dload_0), - INSN_LABEL(dload_1), - INSN_LABEL(dload_2), - INSN_LABEL(dload_3), - INSN_LABEL(aload_0), - INSN_LABEL(aload_1), - INSN_LABEL(aload_2), - INSN_LABEL(aload_3), - INSN_LABEL(iaload), - INSN_LABEL(laload), - INSN_LABEL(faload), - INSN_LABEL(daload), - INSN_LABEL(aaload), - INSN_LABEL(baload), - INSN_LABEL(caload), - INSN_LABEL(saload), - INSN_LABEL(istore), - INSN_LABEL(lstore), - INSN_LABEL(fstore), - INSN_LABEL(dstore), - INSN_LABEL(astore), - INSN_LABEL(istore_0), - INSN_LABEL(istore_1), - INSN_LABEL(istore_2), - INSN_LABEL(istore_3), - INSN_LABEL(lstore_0), - INSN_LABEL(lstore_1), - INSN_LABEL(lstore_2), - INSN_LABEL(lstore_3), - INSN_LABEL(fstore_0), - INSN_LABEL(fstore_1), - INSN_LABEL(fstore_2), - INSN_LABEL(fstore_3), - INSN_LABEL(dstore_0), - INSN_LABEL(dstore_1), - INSN_LABEL(dstore_2), - INSN_LABEL(dstore_3), - INSN_LABEL(astore_0), - INSN_LABEL(astore_1), - INSN_LABEL(astore_2), - INSN_LABEL(astore_3), - INSN_LABEL(iastore), - INSN_LABEL(lastore), - INSN_LABEL(fastore), - INSN_LABEL(dastore), - INSN_LABEL(aastore), - INSN_LABEL(bastore), - INSN_LABEL(castore), - INSN_LABEL(sastore), - INSN_LABEL(pop), - INSN_LABEL(pop2), - INSN_LABEL(dup), - INSN_LABEL(dup_x1), - INSN_LABEL(dup_x2), - INSN_LABEL(dup2), - INSN_LABEL(dup2_x1), - INSN_LABEL(dup2_x2), - INSN_LABEL(swap), - INSN_LABEL(iadd), - INSN_LABEL(ladd), - INSN_LABEL(fadd), - INSN_LABEL(dadd), - INSN_LABEL(isub), - INSN_LABEL(lsub), - INSN_LABEL(fsub), - INSN_LABEL(dsub), - INSN_LABEL(imul), - INSN_LABEL(lmul), - INSN_LABEL(fmul), - INSN_LABEL(dmul), - INSN_LABEL(idiv), - INSN_LABEL(ldiv), - INSN_LABEL(fdiv), - INSN_LABEL(ddiv), - INSN_LABEL(irem), - INSN_LABEL(lrem), - INSN_LABEL(frem), - INSN_LABEL(drem), - INSN_LABEL(ineg), - INSN_LABEL(lneg), - INSN_LABEL(fneg), - INSN_LABEL(dneg), - INSN_LABEL(ishl), - INSN_LABEL(lshl), - INSN_LABEL(ishr), - INSN_LABEL(lshr), - INSN_LABEL(iushr), - INSN_LABEL(lushr), - INSN_LABEL(iand), - INSN_LABEL(land), - INSN_LABEL(ior), - INSN_LABEL(lor), - INSN_LABEL(ixor), - INSN_LABEL(lxor), - INSN_LABEL(iinc), - INSN_LABEL(i2l), - INSN_LABEL(i2f), - INSN_LABEL(i2d), - INSN_LABEL(l2i), - INSN_LABEL(l2f), - INSN_LABEL(l2d), - INSN_LABEL(f2i), - INSN_LABEL(f2l), - INSN_LABEL(f2d), - INSN_LABEL(d2i), - INSN_LABEL(d2l), - INSN_LABEL(d2f), - INSN_LABEL(i2b), - INSN_LABEL(i2c), - INSN_LABEL(i2s), - INSN_LABEL(lcmp), - INSN_LABEL(fcmpl), - INSN_LABEL(fcmpg), - INSN_LABEL(dcmpl), - INSN_LABEL(dcmpg), - INSN_LABEL(ifeq), - INSN_LABEL(ifne), - INSN_LABEL(iflt), - INSN_LABEL(ifge), - INSN_LABEL(ifgt), - INSN_LABEL(ifle), - INSN_LABEL(if_icmpeq), - INSN_LABEL(if_icmpne), - INSN_LABEL(if_icmplt), - INSN_LABEL(if_icmpge), - INSN_LABEL(if_icmpgt), - INSN_LABEL(if_icmple), - INSN_LABEL(if_acmpeq), - INSN_LABEL(if_acmpne), - INSN_LABEL(goto), - INSN_LABEL(jsr), - INSN_LABEL(ret), - INSN_LABEL(tableswitch), - INSN_LABEL(lookupswitch), - INSN_LABEL(ireturn), - INSN_LABEL(lreturn), - INSN_LABEL(freturn), - INSN_LABEL(dreturn), - INSN_LABEL(areturn), - INSN_LABEL(return), - INSN_LABEL(getstatic), - INSN_LABEL(putstatic), - INSN_LABEL(getfield), - INSN_LABEL(putfield), - INSN_LABEL(invokevirtual), - INSN_LABEL(invokespecial), - INSN_LABEL(invokestatic), - INSN_LABEL(invokeinterface), - 0, /* Unused. */ - INSN_LABEL(new), - INSN_LABEL(newarray), - INSN_LABEL(anewarray), - INSN_LABEL(arraylength), - INSN_LABEL(athrow), - INSN_LABEL(checkcast), - INSN_LABEL(instanceof), - INSN_LABEL(monitorenter), - INSN_LABEL(monitorexit), -#ifdef DIRECT_THREADED - 0, // wide -#else - INSN_LABEL(wide), -#endif - INSN_LABEL(multianewarray), - INSN_LABEL(ifnull), - INSN_LABEL(ifnonnull), - INSN_LABEL(goto_w), - INSN_LABEL(jsr_w), - 0 - }; +static void +throw_incompatible_class_change_error (jstring msg) +{ + jthrowable t = new java::lang::IncompatibleClassChangeError (msg); + REPORT_EXCEPTION (t); + throw t; +} - pc_t pc; +static void +throw_null_pointer_exception () +{ + jthrowable t = new java::lang::NullPointerException; + REPORT_EXCEPTION (t); + throw t; +} -#ifdef DIRECT_THREADED +/* Look up source code line number for given bytecode (or direct threaded + interpreter) PC. */ +int +_Jv_InterpMethod::get_source_line(pc_t mpc) +{ + int line = line_table_len > 0 ? line_table[0].line : -1; + for (int i = 1; i < line_table_len; i++) + if (line_table[i].pc > mpc) + break; + else + line = line_table[i].line; + + return line; +} -#define NEXT_INSN goto *((pc++)->insn) -#define INTVAL() ((pc++)->int_val) -#define AVAL() ((pc++)->datum) - -#define GET1S() INTVAL () -#define GET2S() INTVAL () -#define GET1U() INTVAL () -#define GET2U() INTVAL () -#define AVAL1U() AVAL () -#define AVAL2U() AVAL () -#define AVAL2UP() AVAL () -#define SKIP_GOTO ++pc -#define GOTO_VAL() (insn_slot *) pc->datum -#define PCVAL(unionval) unionval.p -#define AMPAMP(label) &&label - - // Compile if we must. - if (prepared == NULL) - compile (insn_target); - pc = (insn_slot *) prepared; +/** Do static initialization for fields with a constant initializer */ +void +_Jv_InitField (jobject obj, jclass klass, int index) +{ + using namespace java::lang::reflect; -#else + if (obj != 0 && klass == 0) + klass = obj->getClass (); -#define NEXT_INSN goto *(insn_target[*pc++]) + if (!_Jv_IsInterpretedClass (klass)) + return; -#define GET1S() get1s (pc++) -#define GET2S() (pc += 2, get2s (pc- 2)) -#define GET1U() get1u (pc++) -#define GET2U() (pc += 2, get2u (pc - 2)) -#define AVAL1U() ({ int index = get1u (pc++); pool_data[index].o; }) -#define AVAL2U() ({ int index = get2u (pc); pc += 2; pool_data[index].o; }) -#define AVAL2UP() ({ int index = get2u (pc); pc += 2; &pool_data[index]; }) -#define SKIP_GOTO pc += 2 -#define GOTO_VAL() pc - 1 + get2s (pc) -#define PCVAL(unionval) unionval.i -#define AMPAMP(label) NULL + _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info; - pc = bytecode (); + _Jv_Field * field = (&klass->fields[0]) + index; -#endif /* DIRECT_THREADED */ + if (index > klass->field_count) + throw_internal_error ("field out of range"); -#define TAKE_GOTO pc = GOTO_VAL () + int init = iclass->field_initializers[index]; + if (init == 0) + return; - try - { - // We keep nop around. It is used if we're interpreting the - // bytecodes and not doing direct threading. - insn_nop: - NEXT_INSN; + _Jv_Constants *pool = &klass->constants; + int tag = pool->tags[init]; - /* The first few instructions here are ordered according to their - frequency, in the hope that this will improve code locality a - little. */ + if (! field->isResolved ()) + throw_internal_error ("initializing unresolved field"); - insn_aload_0: // 0x2a - LOADA (0); - NEXT_INSN; + if (obj==0 && ((field->flags & Modifier::STATIC) == 0)) + throw_internal_error ("initializing non-static field with no object"); - insn_iload: // 0x15 - LOADI (GET1U ()); - NEXT_INSN; + void *addr = 0; - insn_iload_1: // 0x1b - LOADI (1); - NEXT_INSN; + if ((field->flags & Modifier::STATIC) != 0) + addr = (void*) field->u.addr; + else + addr = (void*) (((char*)obj) + field->u.boffset); - insn_invokevirtual: // 0xb6 + switch (tag) + { + case JV_CONSTANT_String: { - int index = GET2U (); - - /* _Jv_ResolvePoolEntry returns immediately if the value already - * is resolved. If we want to clutter up the code here to gain - * a little performance, then we can check the corresponding bit - * JV_CONSTANT_ResolvedFlag in the tag directly. For now, I - * don't think it is worth it. */ - - rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod; - - sp -= rmeth->stack_item_count; - // We don't use NULLCHECK here because we can't rely on that - // working if the method is final. So instead we do an - // explicit test. - if (! sp[0].o) - throw new java::lang::NullPointerException; - - if (rmeth->vtable_index == -1) - { - // final methods do not appear in the vtable, - // if it does not appear in the superclass. - fun = (void (*)()) rmeth->method->ncode; - } - else - { - jobject rcv = sp[0].o; - _Jv_VTable *table = *(_Jv_VTable**) rcv; - fun = (void (*)()) table->get_method (rmeth->vtable_index); - } - -#ifdef DIRECT_THREADED - // Rewrite instruction so that we use a faster pre-resolved - // method. - pc[-2].insn = &&invokevirtual_resolved; - pc[-1].datum = rmeth; -#endif /* DIRECT_THREADED */ + jstring str; + str = _Jv_NewStringUtf8Const (pool->data[init].utf8); + pool->data[init].string = str; + pool->tags[init] = JV_CONSTANT_ResolvedString; } - goto perform_invoke; + /* fall through */ -#ifdef DIRECT_THREADED - invokevirtual_resolved: - { - rmeth = (_Jv_ResolvedMethod *) AVAL (); - sp -= rmeth->stack_item_count; - // We don't use NULLCHECK here because we can't rely on that - // working if the method is final. So instead we do an - // explicit test. - if (! sp[0].o) - throw new java::lang::NullPointerException; - - if (rmeth->vtable_index == -1) - { - // final methods do not appear in the vtable, - // if it does not appear in the superclass. - fun = (void (*)()) rmeth->method->ncode; - } - else - { - jobject rcv = sp[0].o; - _Jv_VTable *table = *(_Jv_VTable**) rcv; - fun = (void (*)()) table->get_method (rmeth->vtable_index); - } - } - goto perform_invoke; -#endif /* DIRECT_THREADED */ + case JV_CONSTANT_ResolvedString: + if (! (field->type == &java::lang::String::class$ + || field->type == &java::lang::Class::class$)) + throw_class_format_error ("string initialiser to non-string field"); + + *(jstring*)addr = pool->data[init].string; + break; - perform_invoke: + case JV_CONSTANT_Integer: { - /* here goes the magic again... */ - ffi_cif *cif = &rmeth->cif; - ffi_raw *raw = (ffi_raw*) sp; + int value = pool->data[init].i; - jdouble rvalue; + if (field->type == JvPrimClass (boolean)) + *(jboolean*)addr = (jboolean)value; + + else if (field->type == JvPrimClass (byte)) + *(jbyte*)addr = (jbyte)value; + + else if (field->type == JvPrimClass (char)) + *(jchar*)addr = (jchar)value; -#if FFI_NATIVE_RAW_API - /* We assume that this is only implemented if it's correct */ - /* to use it here. On a 64 bit machine, it never is. */ - ffi_raw_call (cif, fun, (void*)&rvalue, raw); -#else - ffi_java_raw_call (cif, fun, (void*)&rvalue, raw); -#endif + else if (field->type == JvPrimClass (short)) + *(jshort*)addr = (jshort)value; + + else if (field->type == JvPrimClass (int)) + *(jint*)addr = (jint)value; - int rtype = cif->rtype->type; - - /* the likelyhood of object, int, or void return is very high, - * so those are checked before the switch */ - if (rtype == FFI_TYPE_POINTER) - { - PUSHA (*(jobject*)&rvalue); - } - else if (rtype == FFI_TYPE_SINT32) - { - PUSHI (*(jint*)&rvalue); - } - else if (rtype == FFI_TYPE_VOID) - { - /* skip */ - } else - { - switch (rtype) - { - case FFI_TYPE_SINT8: - { - jbyte value = (*(jint*)&rvalue) & 0xff; - PUSHI (value); - } - break; - - case FFI_TYPE_SINT16: - { - jshort value = (*(jint*)&rvalue) & 0xffff; - PUSHI (value); - } - break; - - case FFI_TYPE_UINT16: - { - jint value = (*(jint*)&rvalue) & 0xffff; - PUSHI (value); - } - break; - - case FFI_TYPE_FLOAT: - PUSHF (*(jfloat*)&rvalue); - break; - - case FFI_TYPE_DOUBLE: - PUSHD (rvalue); - break; - - case FFI_TYPE_SINT64: - PUSHL (*(jlong*)&rvalue); - break; - - default: - throw_internal_error ("unknown return type in invokeXXX"); - } - } - } - NEXT_INSN; + throw_class_format_error ("erroneous field initializer"); + } + break; - insn_aconst_null: - PUSHA (NULL); - NEXT_INSN; + case JV_CONSTANT_Long: + if (field->type != JvPrimClass (long)) + throw_class_format_error ("erroneous field initializer"); - insn_iconst_m1: - PUSHI (-1); - NEXT_INSN; + *(jlong*)addr = _Jv_loadLong (&pool->data[init]); + break; - insn_iconst_0: - PUSHI (0); - NEXT_INSN; + case JV_CONSTANT_Float: + if (field->type != JvPrimClass (float)) + throw_class_format_error ("erroneous field initializer"); - insn_iconst_1: - PUSHI (1); - NEXT_INSN; + *(jfloat*)addr = pool->data[init].f; + break; - insn_iconst_2: - PUSHI (2); - NEXT_INSN; + case JV_CONSTANT_Double: + if (field->type != JvPrimClass (double)) + throw_class_format_error ("erroneous field initializer"); - insn_iconst_3: - PUSHI (3); - NEXT_INSN; + *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]); + break; - insn_iconst_4: - PUSHI (4); - NEXT_INSN; + default: + throw_class_format_error ("erroneous field initializer"); + } +} - insn_iconst_5: - PUSHI (5); - NEXT_INSN; +inline static unsigned char* +skip_one_type (unsigned char* ptr) +{ + int ch = *ptr++; - insn_lconst_0: - PUSHL (0); - NEXT_INSN; + while (ch == '[') + { + ch = *ptr++; + } + + if (ch == 'L') + { + do { ch = *ptr++; } while (ch != ';'); + } - insn_lconst_1: - PUSHL (1); - NEXT_INSN; + return ptr; +} - insn_fconst_0: - PUSHF (0); - NEXT_INSN; +static ffi_type* +get_ffi_type_from_signature (unsigned char* ptr) +{ + switch (*ptr) + { + case 'L': + case '[': + return &ffi_type_pointer; + break; + + case 'Z': + // On some platforms a bool is a byte, on others an int. + if (sizeof (jboolean) == sizeof (jbyte)) + return &ffi_type_sint8; + else + { + JvAssert (sizeof (jbyte) == sizeof (jint)); + return &ffi_type_sint32; + } + break; + + case 'B': + return &ffi_type_sint8; + break; + + case 'C': + return &ffi_type_uint16; + break; + + case 'S': + return &ffi_type_sint16; + break; + + case 'I': + return &ffi_type_sint32; + break; + + case 'J': + return &ffi_type_sint64; + break; + + case 'F': + return &ffi_type_float; + break; + + case 'D': + return &ffi_type_double; + break; + + case 'V': + return &ffi_type_void; + break; + } - insn_fconst_1: - PUSHF (1); - NEXT_INSN; + throw_internal_error ("unknown type in signature"); +} - insn_fconst_2: - PUSHF (2); - NEXT_INSN; +/* this function yields the number of actual arguments, that is, if the + * function is non-static, then one is added to the number of elements + * found in the signature */ - insn_dconst_0: - PUSHD (0); - NEXT_INSN; +int +_Jv_count_arguments (_Jv_Utf8Const *signature, + jboolean staticp) +{ + unsigned char *ptr = (unsigned char*) signature->chars(); + int arg_count = staticp ? 0 : 1; - insn_dconst_1: - PUSHD (1); - NEXT_INSN; + /* first, count number of arguments */ - insn_bipush: - // For direct threaded, bipush and sipush are the same. -#ifndef DIRECT_THREADED - PUSHI (GET1S ()); - NEXT_INSN; -#endif /* DIRECT_THREADED */ - insn_sipush: - PUSHI (GET2S ()); - NEXT_INSN; - - insn_ldc: - // For direct threaded, ldc and ldc_w are the same. -#ifndef DIRECT_THREADED - PUSHA ((jobject) AVAL1U ()); - NEXT_INSN; -#endif /* DIRECT_THREADED */ - insn_ldc_w: - PUSHA ((jobject) AVAL2U ()); - NEXT_INSN; + // skip '(' + ptr++; - insn_ldc2_w: - { - void *where = AVAL2UP (); - memcpy (sp, where, 2*sizeof (_Jv_word)); - sp += 2; - } - NEXT_INSN; + // count args + while (*ptr != ')') + { + ptr = skip_one_type (ptr); + arg_count += 1; + } - insn_lload: - LOADL (GET1U ()); - NEXT_INSN; + return arg_count; +} - insn_fload: - LOADF (GET1U ()); - NEXT_INSN; +/* This beast will build a cif, given the signature. Memory for + * the cif itself and for the argument types must be allocated by the + * caller. + */ + +int +_Jv_init_cif (_Jv_Utf8Const* signature, + int arg_count, + jboolean staticp, + ffi_cif *cif, + ffi_type **arg_types, + ffi_type **rtype_p) +{ + unsigned char *ptr = (unsigned char*) signature->chars(); - insn_dload: - LOADD (GET1U ()); - NEXT_INSN; + int arg_index = 0; // arg number + int item_count = 0; // stack-item count - insn_aload: - LOADA (GET1U ()); - NEXT_INSN; + // setup receiver + if (!staticp) + { + arg_types[arg_index++] = &ffi_type_pointer; + item_count += 1; + } - insn_iload_0: - LOADI (0); - NEXT_INSN; + // skip '(' + ptr++; - insn_iload_2: - LOADI (2); - NEXT_INSN; + // assign arg types + while (*ptr != ')') + { + arg_types[arg_index++] = get_ffi_type_from_signature (ptr); - insn_iload_3: - LOADI (3); - NEXT_INSN; + if (*ptr == 'J' || *ptr == 'D') + item_count += 2; + else + item_count += 1; - insn_lload_0: - LOADL (0); - NEXT_INSN; + ptr = skip_one_type (ptr); + } - insn_lload_1: - LOADL (1); - NEXT_INSN; + // skip ')' + ptr++; + ffi_type *rtype = get_ffi_type_from_signature (ptr); - insn_lload_2: - LOADL (2); - NEXT_INSN; + ptr = skip_one_type (ptr); + if (ptr != (unsigned char*)signature->chars() + signature->len()) + throw_internal_error ("did not find end of signature"); - insn_lload_3: - LOADL (3); - NEXT_INSN; + ffi_abi cabi = FFI_DEFAULT_ABI; +#if defined (X86_WIN32) && !defined (__CYGWIN__) + if (!staticp) + cabi = FFI_THISCALL; +#endif + if (ffi_prep_cif (cif, cabi, + arg_count, rtype, arg_types) != FFI_OK) + throw_internal_error ("ffi_prep_cif failed"); - insn_fload_0: - LOADF (0); - NEXT_INSN; + if (rtype_p != NULL) + *rtype_p = rtype; - insn_fload_1: - LOADF (1); - NEXT_INSN; + return item_count; +} - insn_fload_2: - LOADF (2); - NEXT_INSN; +/* we put this one here, and not in interpret.cc because it + * calls the utility routines _Jv_count_arguments + * which are static to this module. The following struct defines the + * layout we use for the stubs, it's only used in the ncode method. */ - insn_fload_3: - LOADF (3); - NEXT_INSN; +#if FFI_NATIVE_RAW_API +# define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure_loc +# define FFI_RAW_SIZE ffi_raw_size +typedef struct { + ffi_raw_closure closure; + _Jv_ClosureList list; + ffi_cif cif; + ffi_type *arg_types[0]; +} ncode_closure; +typedef void (*ffi_closure_fun) (ffi_cif*,void*,INTERP_FFI_RAW_TYPE*,void*); +#else +# define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure_loc +# define FFI_RAW_SIZE ffi_java_raw_size +typedef struct { + ffi_java_raw_closure closure; + _Jv_ClosureList list; + ffi_cif cif; + ffi_type *arg_types[0]; +} ncode_closure; +typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_java_raw*,void*); +#endif - insn_dload_0: - LOADD (0); - NEXT_INSN; +void * +_Jv_InterpMethod::ncode (jclass klass) +{ + using namespace java::lang::reflect; - insn_dload_1: - LOADD (1); - NEXT_INSN; + if (self->ncode != 0) + return self->ncode; - insn_dload_2: - LOADD (2); - NEXT_INSN; + jboolean staticp = (self->accflags & Modifier::STATIC) != 0; + int arg_count = _Jv_count_arguments (self->signature, staticp); - insn_dload_3: - LOADD (3); - NEXT_INSN; + void *code; + ncode_closure *closure = + (ncode_closure*)ffi_closure_alloc (sizeof (ncode_closure) + + arg_count * sizeof (ffi_type*), + &code); + closure->list.registerClosure (klass, closure); - insn_aload_1: - LOADA(1); - NEXT_INSN; + _Jv_init_cif (self->signature, + arg_count, + staticp, + &closure->cif, + &closure->arg_types[0], + NULL); - insn_aload_2: - LOADA(2); - NEXT_INSN; + ffi_closure_fun fun; - insn_aload_3: - LOADA(3); - NEXT_INSN; + args_raw_size = FFI_RAW_SIZE (&closure->cif); - insn_iaload: - { - jint index = POPI(); - jintArray arr = (jintArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHI( elements(arr)[index] ); - } - NEXT_INSN; + JvAssert ((self->accflags & Modifier::NATIVE) == 0); - insn_laload: - { - jint index = POPI(); - jlongArray arr = (jlongArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHL( elements(arr)[index] ); - } - NEXT_INSN; + if ((self->accflags & Modifier::SYNCHRONIZED) != 0) + { + if (staticp) + { + if (JVMTI::enabled) + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class_debug; + else + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class; + } + else + { + if (JVMTI::enabled) + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object_debug; + else + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object; + } + } + else + { + if (staticp) + { + if (JVMTI::enabled) + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class_debug; + else + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class; + } + else + { + if (JVMTI::enabled) + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal_debug; + else + fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal; + } + } - insn_faload: - { - jint index = POPI(); - jfloatArray arr = (jfloatArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHF( elements(arr)[index] ); - } - NEXT_INSN; + FFI_PREP_RAW_CLOSURE (&closure->closure, + &closure->cif, + fun, + (void*)this, + code); - insn_daload: - { - jint index = POPI(); - jdoubleArray arr = (jdoubleArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHD( elements(arr)[index] ); - } - NEXT_INSN; + self->ncode = code; - insn_aaload: - { - jint index = POPI(); - jobjectArray arr = (jobjectArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHA( elements(arr)[index] ); - } - NEXT_INSN; + return self->ncode; +} - insn_baload: - { - jint index = POPI(); - jbyteArray arr = (jbyteArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHI( elements(arr)[index] ); - } - NEXT_INSN; +/* Find the index of the given insn in the array of insn slots + for this method. Returns -1 if not found. */ +jlong +_Jv_InterpMethod::insn_index (pc_t pc) +{ + jlong left = 0; +#ifdef DIRECT_THREADED + jlong right = number_insn_slots; + pc_t insns = prepared; +#else + jlong right = code_length; + pc_t insns = bytecode (); +#endif - insn_caload: - { - jint index = POPI(); - jcharArray arr = (jcharArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHI( elements(arr)[index] ); - } - NEXT_INSN; + while (right >= 0) + { + jlong mid = (left + right) / 2; + if (&insns[mid] == pc) + return mid; + + if (pc < &insns[mid]) + right = mid - 1; + else + left = mid + 1; + } - insn_saload: - { - jint index = POPI(); - jshortArray arr = (jshortArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - PUSHI( elements(arr)[index] ); - } - NEXT_INSN; + return -1; +} - insn_istore: - STOREI (GET1U ()); - NEXT_INSN; +// Method to check if an exception is caught at some location in a method +// (meth). Returns true if this method (meth) contains a catch block for the +// exception (ex). False otherwise. If there is a catch block, it sets the pc +// to the location of the beginning of the catch block. +jboolean +_Jv_InterpMethod::check_handler (pc_t *pc, _Jv_InterpMethod *meth, + java::lang::Throwable *ex) +{ +#ifdef DIRECT_THREADED + void *logical_pc = (void *) ((insn_slot *) (*pc) - 1); +#else + int logical_pc = (*pc) - 1 - meth->bytecode (); +#endif + _Jv_InterpException *exc = meth->exceptions (); + jclass exc_class = ex->getClass (); - insn_lstore: - STOREL (GET1U ()); - NEXT_INSN; + for (int i = 0; i < meth->exc_count; i++) + { + if (PCVAL (exc[i].start_pc) <= logical_pc + && logical_pc < PCVAL (exc[i].end_pc)) + { +#ifdef DIRECT_THREADED + jclass handler = (jclass) exc[i].handler_type.p; +#else + jclass handler = NULL; + if (exc[i].handler_type.i != 0) + handler + = (_Jv_Linker::resolve_pool_entry (meth->defining_class, + exc[i].handler_type.i)).clazz; +#endif /* DIRECT_THREADED */ + if (handler == NULL || handler->isAssignableFrom (exc_class)) + { +#ifdef DIRECT_THREADED + (*pc) = (insn_slot *) exc[i].handler_pc.p; +#else + (*pc) = meth->bytecode () + exc[i].handler_pc.i; +#endif /* DIRECT_THREADED */ + return true; + } + } + } + return false; +} - insn_fstore: - STOREF (GET1U ()); - NEXT_INSN; - insn_dstore: - STORED (GET1U ()); - NEXT_INSN; +void +_Jv_InterpMethod::get_line_table (jlong& start, jlong& end, + jintArray& line_numbers, + jlongArray& code_indices) +{ +#ifdef DIRECT_THREADED + /* For the DIRECT_THREADED case, if the method has not yet been + * compiled, the linetable will change to insn slots instead of + * bytecode PCs. It is probably easiest, in this case, to simply + * compile the method and guarantee that we are using insn + * slots. + */ + _Jv_CompileMethod (this); + + if (line_table_len > 0) + { + start = 0; + end = number_insn_slots; + line_numbers = JvNewIntArray (line_table_len); + code_indices = JvNewLongArray (line_table_len); + + jint* lines = elements (line_numbers); + jlong* indices = elements (code_indices); + for (int i = 0; i < line_table_len; ++i) + { + lines[i] = line_table[i].line; + indices[i] = insn_index (line_table[i].pc); + } + } +#else // !DIRECT_THREADED + if (line_table_len > 0) + { + start = 0; + end = code_length; + line_numbers = JvNewIntArray (line_table_len); + code_indices = JvNewLongArray (line_table_len); + + jint* lines = elements (line_numbers); + jlong* indices = elements (code_indices); + for (int i = 0; i < line_table_len; ++i) + { + lines[i] = line_table[i].line; + indices[i] = (jlong) line_table[i].bytecode_pc; + } + } +#endif // !DIRECT_THREADED +} - insn_astore: - STOREA (GET1U ()); - NEXT_INSN; +int +_Jv_InterpMethod::get_local_var_table (char **name, char **sig, + char **generic_sig, jlong *startloc, + jint *length, jint *slot, + int table_slot) +{ +#ifdef DIRECT_THREADED + _Jv_CompileMethod (this); +#endif - insn_istore_0: - STOREI (0); - NEXT_INSN; + if (local_var_table == NULL) + return -2; + if (table_slot >= local_var_table_len) + return -1; + else + { + *name = local_var_table[table_slot].name; + *sig = local_var_table[table_slot].descriptor; + *generic_sig = local_var_table[table_slot].descriptor; - insn_istore_1: - STOREI (1); - NEXT_INSN; +#ifdef DIRECT_THREADED + *startloc = insn_index (local_var_table[table_slot].pc); +#else + *startloc = static_cast (local_var_table[table_slot].bytecode_pc); +#endif + *length = static_cast (local_var_table[table_slot].length); + *slot = static_cast (local_var_table[table_slot].slot); + } + return local_var_table_len - table_slot - 1; +} - insn_istore_2: - STOREI (2); - NEXT_INSN; +pc_t +_Jv_InterpMethod::install_break (jlong index) +{ + return set_insn (index, breakpoint_insn); +} - insn_istore_3: - STOREI (3); - NEXT_INSN; +pc_t +_Jv_InterpMethod::get_insn (jlong index) +{ + pc_t code; - insn_lstore_0: - STOREL (0); - NEXT_INSN; +#ifdef DIRECT_THREADED + if (index >= number_insn_slots || index < 0) + return NULL; - insn_lstore_1: - STOREL (1); - NEXT_INSN; + code = prepared; +#else // !DIRECT_THREADED + if (index >= code_length || index < 0) + return NULL; - insn_lstore_2: - STOREL (2); - NEXT_INSN; + code = reinterpret_cast (bytecode ()); +#endif // !DIRECT_THREADED - insn_lstore_3: - STOREL (3); - NEXT_INSN; + return &code[index]; +} - insn_fstore_0: - STOREF (0); - NEXT_INSN; +pc_t +_Jv_InterpMethod::set_insn (jlong index, pc_t insn) +{ +#ifdef DIRECT_THREADED + if (index >= number_insn_slots || index < 0) + return NULL; - insn_fstore_1: - STOREF (1); - NEXT_INSN; + pc_t code = prepared; + code[index].insn = insn->insn; +#else // !DIRECT_THREADED + if (index >= code_length || index < 0) + return NULL; - insn_fstore_2: - STOREF (2); - NEXT_INSN; + pc_t code = reinterpret_cast (bytecode ()); + code[index] = *insn; +#endif // !DIRECT_THREADED - insn_fstore_3: - STOREF (3); - NEXT_INSN; + return &code[index]; +} - insn_dstore_0: - STORED (0); - NEXT_INSN; +bool +_Jv_InterpMethod::breakpoint_at (jlong index) +{ + pc_t insn = get_insn (index); + if (insn != NULL) + { +#ifdef DIRECT_THREADED + return (insn->insn == breakpoint_insn->insn); +#else + pc_t code = reinterpret_cast (bytecode ()); + return (code[index] == bp_insn_opcode); +#endif + } - insn_dstore_1: - STORED (1); - NEXT_INSN; + return false; +} - insn_dstore_2: - STORED (2); - NEXT_INSN; +void * +_Jv_JNIMethod::ncode (jclass klass) +{ + using namespace java::lang::reflect; - insn_dstore_3: - STORED (3); - NEXT_INSN; + if (self->ncode != 0) + return self->ncode; + + jboolean staticp = (self->accflags & Modifier::STATIC) != 0; + int arg_count = _Jv_count_arguments (self->signature, staticp); + + void *code; + ncode_closure *closure = + (ncode_closure*)ffi_closure_alloc (sizeof (ncode_closure) + + arg_count * sizeof (ffi_type*), + &code); + closure->list.registerClosure (klass, closure); + + ffi_type *rtype; + _Jv_init_cif (self->signature, + arg_count, + staticp, + &closure->cif, + &closure->arg_types[0], + &rtype); + + ffi_closure_fun fun; + + args_raw_size = FFI_RAW_SIZE (&closure->cif); + + // Initialize the argument types and CIF that represent the actual + // underlying JNI function. + int extra_args = 1; + if ((self->accflags & Modifier::STATIC)) + ++extra_args; + jni_arg_types = (ffi_type **) _Jv_AllocBytes ((extra_args + arg_count) + * sizeof (ffi_type *)); + int offset = 0; + jni_arg_types[offset++] = &ffi_type_pointer; + if ((self->accflags & Modifier::STATIC)) + jni_arg_types[offset++] = &ffi_type_pointer; + memcpy (&jni_arg_types[offset], &closure->arg_types[0], + arg_count * sizeof (ffi_type *)); + + if (ffi_prep_cif (&jni_cif, _Jv_platform_ffi_abi, + extra_args + arg_count, rtype, + jni_arg_types) != FFI_OK) + throw_internal_error ("ffi_prep_cif failed for JNI function"); + + JvAssert ((self->accflags & Modifier::NATIVE) != 0); + + // FIXME: for now we assume that all native methods for + // interpreted code use JNI. + fun = (ffi_closure_fun) &_Jv_JNIMethod::call; + + FFI_PREP_RAW_CLOSURE (&closure->closure, + &closure->cif, + fun, + (void*) this, + code); + + self->ncode = code; + return self->ncode; +} - insn_astore_0: - STOREA(0); - NEXT_INSN; +static void +throw_class_format_error (jstring msg) +{ + jthrowable t = (msg + ? new java::lang::ClassFormatError (msg) + : new java::lang::ClassFormatError); + REPORT_EXCEPTION (t); + throw t; +} - insn_astore_1: - STOREA(1); - NEXT_INSN; +static void +throw_class_format_error (const char *msg) +{ + throw_class_format_error (JvNewStringLatin1 (msg)); +} - insn_astore_2: - STOREA(2); - NEXT_INSN; +/* This function finds the method and location where the exception EXC + is caught in the stack frame. On return, it sets CATCH_METHOD and + CATCH_LOCATION with the method and location where the catch will + occur. If the exception is not caught, these are set to 0. - insn_astore_3: - STOREA(3); - NEXT_INSN; - - insn_iastore: - { - jint value = POPI(); - jint index = POPI(); - jintArray arr = (jintArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_lastore: - { - jlong value = POPL(); - jint index = POPI(); - jlongArray arr = (jlongArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_fastore: - { - jfloat value = POPF(); - jint index = POPI(); - jfloatArray arr = (jfloatArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_dastore: - { - jdouble value = POPD(); - jint index = POPI(); - jdoubleArray arr = (jdoubleArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_aastore: - { - jobject value = POPA(); - jint index = POPI(); - jobjectArray arr = (jobjectArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - _Jv_CheckArrayStore (arr, value); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_bastore: - { - jbyte value = (jbyte) POPI(); - jint index = POPI(); - jbyteArray arr = (jbyteArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_castore: - { - jchar value = (jchar) POPI(); - jint index = POPI(); - jcharArray arr = (jcharArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_sastore: - { - jshort value = (jshort) POPI(); - jint index = POPI(); - jshortArray arr = (jshortArray) POPA(); - NULLARRAYCHECK (arr); - ARRAYBOUNDSCHECK (arr, index); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_pop: - sp -= 1; - NEXT_INSN; - - insn_pop2: - sp -= 2; - NEXT_INSN; - - insn_dup: - sp[0] = sp[-1]; - sp += 1; - NEXT_INSN; - - insn_dup_x1: - dupx (sp, 1, 1); sp+=1; - NEXT_INSN; - - insn_dup_x2: - dupx (sp, 1, 2); sp+=1; - NEXT_INSN; - - insn_dup2: - sp[0] = sp[-2]; - sp[1] = sp[-1]; - sp += 2; - NEXT_INSN; - - insn_dup2_x1: - dupx (sp, 2, 1); sp+=2; - NEXT_INSN; - - insn_dup2_x2: - dupx (sp, 2, 2); sp+=2; - NEXT_INSN; - - insn_swap: - { - jobject tmp1 = POPA(); - jobject tmp2 = POPA(); - PUSHA (tmp1); - PUSHA (tmp2); - } - NEXT_INSN; - - insn_iadd: - BINOPI(+); - NEXT_INSN; - - insn_ladd: - BINOPL(+); - NEXT_INSN; - - insn_fadd: - BINOPF(+); - NEXT_INSN; - - insn_dadd: - BINOPD(+); - NEXT_INSN; - - insn_isub: - BINOPI(-); - NEXT_INSN; - - insn_lsub: - BINOPL(-); - NEXT_INSN; - - insn_fsub: - BINOPF(-); - NEXT_INSN; - - insn_dsub: - BINOPD(-); - NEXT_INSN; - - insn_imul: - BINOPI(*); - NEXT_INSN; - - insn_lmul: - BINOPL(*); - NEXT_INSN; - - insn_fmul: - BINOPF(*); - NEXT_INSN; - - insn_dmul: - BINOPD(*); - NEXT_INSN; - - insn_idiv: - { - jint value2 = POPI(); - jint value1 = POPI(); - jint res = _Jv_divI (value1, value2); - PUSHI (res); - } - NEXT_INSN; - - insn_ldiv: - { - jlong value2 = POPL(); - jlong value1 = POPL(); - jlong res = _Jv_divJ (value1, value2); - PUSHL (res); - } - NEXT_INSN; - - insn_fdiv: - { - jfloat value2 = POPF(); - jfloat value1 = POPF(); - jfloat res = value1 / value2; - PUSHF (res); - } - NEXT_INSN; - - insn_ddiv: - { - jdouble value2 = POPD(); - jdouble value1 = POPD(); - jdouble res = value1 / value2; - PUSHD (res); - } - NEXT_INSN; - - insn_irem: - { - jint value2 = POPI(); - jint value1 = POPI(); - jint res = _Jv_remI (value1, value2); - PUSHI (res); - } - NEXT_INSN; - - insn_lrem: - { - jlong value2 = POPL(); - jlong value1 = POPL(); - jlong res = _Jv_remJ (value1, value2); - PUSHL (res); - } - NEXT_INSN; - - insn_frem: - { - jfloat value2 = POPF(); - jfloat value1 = POPF(); - jfloat res = __ieee754_fmod (value1, value2); - PUSHF (res); - } - NEXT_INSN; - - insn_drem: - { - jdouble value2 = POPD(); - jdouble value1 = POPD(); - jdouble res = __ieee754_fmod (value1, value2); - PUSHD (res); - } - NEXT_INSN; - - insn_ineg: - { - jint value = POPI(); - PUSHI (value * -1); - } - NEXT_INSN; - - insn_lneg: - { - jlong value = POPL(); - PUSHL (value * -1); - } - NEXT_INSN; - - insn_fneg: - { - jfloat value = POPF(); - PUSHF (value * -1); - } - NEXT_INSN; - - insn_dneg: - { - jdouble value = POPD(); - PUSHD (value * -1); - } - NEXT_INSN; - - insn_ishl: - { - jint shift = (POPI() & 0x1f); - jint value = POPI(); - PUSHI (value << shift); - } - NEXT_INSN; - - insn_lshl: - { - jint shift = (POPI() & 0x3f); - jlong value = POPL(); - PUSHL (value << shift); - } - NEXT_INSN; - - insn_ishr: - { - jint shift = (POPI() & 0x1f); - jint value = POPI(); - PUSHI (value >> shift); - } - NEXT_INSN; - - insn_lshr: - { - jint shift = (POPI() & 0x3f); - jlong value = POPL(); - PUSHL (value >> shift); - } - NEXT_INSN; - - insn_iushr: - { - jint shift = (POPI() & 0x1f); - UINT32 value = (UINT32) POPI(); - PUSHI ((jint) (value >> shift)); - } - NEXT_INSN; - - insn_lushr: - { - jint shift = (POPI() & 0x3f); - UINT64 value = (UINT64) POPL(); - PUSHL ((value >> shift)); - } - NEXT_INSN; - - insn_iand: - BINOPI (&); - NEXT_INSN; - - insn_land: - BINOPL (&); - NEXT_INSN; - - insn_ior: - BINOPI (|); - NEXT_INSN; - - insn_lor: - BINOPL (|); - NEXT_INSN; - - insn_ixor: - BINOPI (^); - NEXT_INSN; - - insn_lxor: - BINOPL (^); - NEXT_INSN; - - insn_iinc: - { - jint index = GET1U (); - jint amount = GET1S (); - locals[index].i += amount; - } - NEXT_INSN; - - insn_i2l: - {jlong value = POPI(); PUSHL (value);} - NEXT_INSN; - - insn_i2f: - {jfloat value = POPI(); PUSHF (value);} - NEXT_INSN; - - insn_i2d: - {jdouble value = POPI(); PUSHD (value);} - NEXT_INSN; - - insn_l2i: - {jint value = POPL(); PUSHI (value);} - NEXT_INSN; - - insn_l2f: - {jfloat value = POPL(); PUSHF (value);} - NEXT_INSN; - - insn_l2d: - {jdouble value = POPL(); PUSHD (value);} - NEXT_INSN; - - insn_f2i: - { - using namespace java::lang; - jint value = convert (POPF (), Integer::MIN_VALUE, Integer::MAX_VALUE); - PUSHI(value); - } - NEXT_INSN; - - insn_f2l: - { - using namespace java::lang; - jlong value = convert (POPF (), Long::MIN_VALUE, Long::MAX_VALUE); - PUSHL(value); - } - NEXT_INSN; - - insn_f2d: - { jdouble value = POPF (); PUSHD(value); } - NEXT_INSN; - - insn_d2i: - { - using namespace java::lang; - jint value = convert (POPD (), Integer::MIN_VALUE, Integer::MAX_VALUE); - PUSHI(value); - } - NEXT_INSN; - - insn_d2l: - { - using namespace java::lang; - jlong value = convert (POPD (), Long::MIN_VALUE, Long::MAX_VALUE); - PUSHL(value); - } - NEXT_INSN; - - insn_d2f: - { jfloat value = POPD (); PUSHF(value); } - NEXT_INSN; - - insn_i2b: - { jbyte value = POPI (); PUSHI(value); } - NEXT_INSN; - - insn_i2c: - { jchar value = POPI (); PUSHI(value); } - NEXT_INSN; - - insn_i2s: - { jshort value = POPI (); PUSHI(value); } - NEXT_INSN; - - insn_lcmp: - { - jlong value2 = POPL (); - jlong value1 = POPL (); - if (value1 > value2) - { PUSHI (1); } - else if (value1 == value2) - { PUSHI (0); } - else - { PUSHI (-1); } - } - NEXT_INSN; - - insn_fcmpl: - tmpval = -1; - goto fcmp; - - insn_fcmpg: - tmpval = 1; - - fcmp: - { - jfloat value2 = POPF (); - jfloat value1 = POPF (); - if (value1 > value2) - PUSHI (1); - else if (value1 == value2) - PUSHI (0); - else if (value1 < value2) - PUSHI (-1); - else - PUSHI (tmpval); - } - NEXT_INSN; - - insn_dcmpl: - tmpval = 1; - goto dcmp; - - insn_dcmpg: - tmpval = -1; - - dcmp: - { - jdouble value2 = POPD (); - jdouble value1 = POPD (); - if (value1 > value2) - PUSHI (1); - else if (value1 == value2) - PUSHI (0); - else if (value1 < value2) - PUSHI (-1); - else - PUSHI (tmpval); - } - NEXT_INSN; - - insn_ifeq: - { - if (POPI() == 0) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_ifne: - { - if (POPI() != 0) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_iflt: - { - if (POPI() < 0) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_ifge: - { - if (POPI() >= 0) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_ifgt: - { - if (POPI() > 0) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_ifle: - { - if (POPI() <= 0) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_icmpeq: - { - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 == value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_icmpne: - { - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 != value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_icmplt: - { - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 < value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_icmpge: - { - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 >= value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_icmpgt: - { - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 > value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_icmple: - { - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 <= value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_acmpeq: - { - jobject value2 = POPA(); - jobject value1 = POPA(); - if (value1 == value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_if_acmpne: - { - jobject value2 = POPA(); - jobject value1 = POPA(); - if (value1 != value2) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_goto_w: -#ifndef DIRECT_THREADED - // For direct threaded, goto and goto_w are the same. - pc = pc - 1 + get4 (pc); - NEXT_INSN; -#endif /* DIRECT_THREADED */ - insn_goto: - TAKE_GOTO; - NEXT_INSN; - - insn_jsr_w: -#ifndef DIRECT_THREADED - // For direct threaded, jsr and jsr_w are the same. - { - pc_t next = pc - 1 + get4 (pc); - pc += 4; - PUSHA ((jobject) pc); - pc = next; - } - NEXT_INSN; -#endif /* DIRECT_THREADED */ - insn_jsr: - { - pc_t next = GOTO_VAL(); - SKIP_GOTO; - PUSHA ((jobject) pc); - pc = next; - } - NEXT_INSN; - - insn_ret: - { - jint index = GET1U (); - pc = (pc_t) PEEKA (index); - } - NEXT_INSN; - - insn_tableswitch: - { -#ifdef DIRECT_THREADED - void *def = (pc++)->datum; - - int index = POPI(); - - jint low = INTVAL (); - jint high = INTVAL (); - - if (index < low || index > high) - pc = (insn_slot *) def; - else - pc = (insn_slot *) ((pc + index - low)->datum); -#else - pc_t base_pc = pc - 1; - int index = POPI (); - - pc_t base = (pc_t) bytecode (); - while ((pc - base) % 4 != 0) - ++pc; - - jint def = get4 (pc); - jint low = get4 (pc + 4); - jint high = get4 (pc + 8); - if (index < low || index > high) - pc = base_pc + def; - else - pc = base_pc + get4 (pc + 4 * (index - low + 3)); -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - - insn_lookupswitch: - { -#ifdef DIRECT_THREADED - void *def = (pc++)->insn; - - int index = POPI(); - - jint npairs = INTVAL (); - - int max = npairs - 1; - int min = 0; - - // Simple binary search... - while (min < max) - { - int half = (min + max) / 2; - int match = pc[2 * half].int_val; - - if (index == match) - { - // Found it. - pc = (insn_slot *) pc[2 * half + 1].datum; - NEXT_INSN; - } - else if (index < match) - // We can use HALF - 1 here because we check again on - // loop exit. - max = half - 1; - else - // We can use HALF + 1 here because we check again on - // loop exit. - min = half + 1; - } - if (index == pc[2 * min].int_val) - pc = (insn_slot *) pc[2 * min + 1].datum; - else - pc = (insn_slot *) def; -#else - unsigned char *base_pc = pc-1; - int index = POPI(); - - unsigned char* base = bytecode (); - while ((pc-base) % 4 != 0) - ++pc; - - jint def = get4 (pc); - jint npairs = get4 (pc+4); - - int max = npairs-1; - int min = 0; - - // Simple binary search... - while (min < max) - { - int half = (min+max)/2; - int match = get4 (pc+ 4*(2 + 2*half)); - - if (index == match) - min = max = half; - else if (index < match) - // We can use HALF - 1 here because we check again on - // loop exit. - max = half - 1; - else - // We can use HALF + 1 here because we check again on - // loop exit. - min = half + 1; - } - - if (index == get4 (pc+ 4*(2 + 2*min))) - pc = base_pc + get4 (pc+ 4*(2 + 2*min + 1)); - else - pc = base_pc + def; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - - insn_areturn: - *(jobject *) retp = POPA (); - return; - - insn_lreturn: - *(jlong *) retp = POPL (); - return; - - insn_freturn: - *(jfloat *) retp = POPF (); - return; - - insn_dreturn: - *(jdouble *) retp = POPD (); - return; - - insn_ireturn: - *(jint *) retp = POPI (); - return; - - insn_return: - return; - - insn_getstatic: - { - jint fieldref_index = GET2U (); - _Jv_ResolvePoolEntry (defining_class, fieldref_index); - _Jv_Field *field = pool_data[fieldref_index].field; - - if ((field->flags & Modifier::STATIC) == 0) - throw_incompatible_class_change_error - (JvNewStringLatin1 ("field no longer static")); - - jclass type = field->type; - - // We rewrite the instruction once we discover what it refers - // to. - void *newinsn = NULL; - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - PUSHI (*(jbyte*) (field->u.addr)); - newinsn = AMPAMP (getstatic_resolved_1); - break; - - case 2: - if (type == JvPrimClass (char)) - { - PUSHI(*(jchar*) (field->u.addr)); - newinsn = AMPAMP (getstatic_resolved_char); - } - else - { - PUSHI(*(jshort*) (field->u.addr)); - newinsn = AMPAMP (getstatic_resolved_short); - } - break; - - case 4: - PUSHI(*(jint*) (field->u.addr)); - newinsn = AMPAMP (getstatic_resolved_4); - break; - - case 8: - PUSHL(*(jlong*) (field->u.addr)); - newinsn = AMPAMP (getstatic_resolved_8); - break; - } - } - else - { - PUSHA(*(jobject*) (field->u.addr)); - newinsn = AMPAMP (getstatic_resolved_obj); - } - -#ifdef DIRECT_THREADED - pc[-2].insn = newinsn; - pc[-1].datum = field->u.addr; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - getstatic_resolved_1: - PUSHI (*(jbyte *) AVAL ()); - NEXT_INSN; - - getstatic_resolved_char: - PUSHI (*(jchar *) AVAL ()); - NEXT_INSN; - - getstatic_resolved_short: - PUSHI (*(jshort *) AVAL ()); - NEXT_INSN; - - getstatic_resolved_4: - PUSHI (*(jint *) AVAL ()); - NEXT_INSN; - - getstatic_resolved_8: - PUSHL (*(jlong *) AVAL ()); - NEXT_INSN; - - getstatic_resolved_obj: - PUSHA (*(jobject *) AVAL ()); - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_getfield: - { - jint fieldref_index = GET2U (); - _Jv_ResolvePoolEntry (defining_class, fieldref_index); - _Jv_Field *field = pool_data[fieldref_index].field; - - if ((field->flags & Modifier::STATIC) != 0) - throw_incompatible_class_change_error - (JvNewStringLatin1 ("field is static")); - - jclass type = field->type; - jint field_offset = field->u.boffset; - if (field_offset > 0xffff) - throw new java::lang::VirtualMachineError; - - jobject obj = POPA(); - NULLCHECK(obj); - - void *newinsn = NULL; - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - PUSHI (*(jbyte*) ((char*)obj + field_offset)); - newinsn = AMPAMP (getfield_resolved_1); - break; - - case 2: - if (type == JvPrimClass (char)) - { - PUSHI (*(jchar*) ((char*)obj + field_offset)); - newinsn = AMPAMP (getfield_resolved_char); - } - else - { - PUSHI (*(jshort*) ((char*)obj + field_offset)); - newinsn = AMPAMP (getfield_resolved_short); - } - break; - - case 4: - PUSHI (*(jint*) ((char*)obj + field_offset)); - newinsn = AMPAMP (getfield_resolved_4); - break; - - case 8: - PUSHL(*(jlong*) ((char*)obj + field_offset)); - newinsn = AMPAMP (getfield_resolved_8); - break; - } - } - else - { - PUSHA(*(jobject*) ((char*)obj + field_offset)); - newinsn = AMPAMP (getfield_resolved_obj); - } - -#ifdef DIRECT_THREADED - pc[-2].insn = newinsn; - pc[-1].int_val = field_offset; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - getfield_resolved_1: - { - char *obj = (char *) POPA (); - NULLCHECK (obj); - PUSHI (*(jbyte *) (obj + INTVAL ())); - } - NEXT_INSN; - - getfield_resolved_char: - { - char *obj = (char *) POPA (); - NULLCHECK (obj); - PUSHI (*(jchar *) (obj + INTVAL ())); - } - NEXT_INSN; - - getfield_resolved_short: - { - char *obj = (char *) POPA (); - NULLCHECK (obj); - PUSHI (*(jshort *) (obj + INTVAL ())); - } - NEXT_INSN; - - getfield_resolved_4: - { - char *obj = (char *) POPA (); - NULLCHECK (obj); - PUSHI (*(jint *) (obj + INTVAL ())); - } - NEXT_INSN; - - getfield_resolved_8: - { - char *obj = (char *) POPA (); - NULLCHECK (obj); - PUSHL (*(jlong *) (obj + INTVAL ())); - } - NEXT_INSN; - - getfield_resolved_obj: - { - char *obj = (char *) POPA (); - NULLCHECK (obj); - PUSHA (*(jobject *) (obj + INTVAL ())); - } - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_putstatic: - { - jint fieldref_index = GET2U (); - _Jv_ResolvePoolEntry (defining_class, fieldref_index); - _Jv_Field *field = pool_data[fieldref_index].field; - - jclass type = field->type; - - // ResolvePoolEntry cannot check this - if ((field->flags & Modifier::STATIC) == 0) - throw_incompatible_class_change_error - (JvNewStringLatin1 ("field no longer static")); - - void *newinsn = NULL; - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - { - jint value = POPI(); - *(jbyte*) (field->u.addr) = value; - newinsn = AMPAMP (putstatic_resolved_1); - break; - } - - case 2: - { - jint value = POPI(); - *(jchar*) (field->u.addr) = value; - newinsn = AMPAMP (putstatic_resolved_2); - break; - } - - case 4: - { - jint value = POPI(); - *(jint*) (field->u.addr) = value; - newinsn = AMPAMP (putstatic_resolved_4); - break; - } - - case 8: - { - jlong value = POPL(); - *(jlong*) (field->u.addr) = value; - newinsn = AMPAMP (putstatic_resolved_8); - break; - } - } - } - else - { - jobject value = POPA(); - *(jobject*) (field->u.addr) = value; - newinsn = AMPAMP (putstatic_resolved_obj); - } - -#ifdef DIRECT_THREADED - pc[-2].insn = newinsn; - pc[-1].datum = field->u.addr; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - putstatic_resolved_1: - *(jbyte *) AVAL () = POPI (); - NEXT_INSN; - - putstatic_resolved_2: - *(jchar *) AVAL () = POPI (); - NEXT_INSN; - - putstatic_resolved_4: - *(jint *) AVAL () = POPI (); - NEXT_INSN; - - putstatic_resolved_8: - *(jlong *) AVAL () = POPL (); - NEXT_INSN; - - putstatic_resolved_obj: - *(jobject *) AVAL () = POPA (); - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_putfield: - { - jint fieldref_index = GET2U (); - _Jv_ResolvePoolEntry (defining_class, fieldref_index); - _Jv_Field *field = pool_data[fieldref_index].field; - - jclass type = field->type; - - if ((field->flags & Modifier::STATIC) != 0) - throw_incompatible_class_change_error - (JvNewStringLatin1 ("field is static")); - - jint field_offset = field->u.boffset; - if (field_offset > 0xffff) - throw new java::lang::VirtualMachineError; - - void *newinsn = NULL; - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - { - jint value = POPI(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jbyte*) ((char*)obj + field_offset) = value; - newinsn = AMPAMP (putfield_resolved_1); - break; - } - - case 2: - { - jint value = POPI(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jchar*) ((char*)obj + field_offset) = value; - newinsn = AMPAMP (putfield_resolved_2); - break; - } - - case 4: - { - jint value = POPI(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jint*) ((char*)obj + field_offset) = value; - newinsn = AMPAMP (putfield_resolved_4); - break; - } - - case 8: - { - jlong value = POPL(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jlong*) ((char*)obj + field_offset) = value; - newinsn = AMPAMP (putfield_resolved_8); - break; - } - } - } - else - { - jobject value = POPA(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jobject*) ((char*)obj + field_offset) = value; - newinsn = AMPAMP (putfield_resolved_obj); - } - -#ifdef DIRECT_THREADED - pc[-2].insn = newinsn; - pc[-1].int_val = field_offset; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - putfield_resolved_1: - { - jint val = POPI (); - char *obj = (char *) POPA (); - NULLCHECK (obj); - *(jbyte *) (obj + INTVAL ()) = val; - } - NEXT_INSN; - - putfield_resolved_2: - { - jint val = POPI (); - char *obj = (char *) POPA (); - NULLCHECK (obj); - *(jchar *) (obj + INTVAL ()) = val; - } - NEXT_INSN; - - putfield_resolved_4: - { - jint val = POPI (); - char *obj = (char *) POPA (); - NULLCHECK (obj); - *(jint *) (obj + INTVAL ()) = val; - } - NEXT_INSN; - - putfield_resolved_8: - { - jlong val = POPL (); - char *obj = (char *) POPA (); - NULLCHECK (obj); - *(jlong *) (obj + INTVAL ()) = val; - } - NEXT_INSN; - - putfield_resolved_obj: - { - jobject val = POPA (); - char *obj = (char *) POPA (); - NULLCHECK (obj); - *(jobject *) (obj + INTVAL ()) = val; - } - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_invokespecial: - { - int index = GET2U (); - - rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod; - - sp -= rmeth->stack_item_count; - - // We don't use NULLCHECK here because we can't rely on that - // working for . So instead we do an explicit test. - if (! sp[0].o) - throw new java::lang::NullPointerException; - - fun = (void (*)()) rmeth->method->ncode; - -#ifdef DIRECT_THREADED - // Rewrite instruction so that we use a faster pre-resolved - // method. - pc[-2].insn = &&invokespecial_resolved; - pc[-1].datum = rmeth; -#endif /* DIRECT_THREADED */ - } - goto perform_invoke; - -#ifdef DIRECT_THREADED - invokespecial_resolved: - { - rmeth = (_Jv_ResolvedMethod *) AVAL (); - sp -= rmeth->stack_item_count; - // We don't use NULLCHECK here because we can't rely on that - // working for . So instead we do an explicit test. - if (! sp[0].o) - throw new java::lang::NullPointerException; - fun = (void (*)()) rmeth->method->ncode; - } - goto perform_invoke; -#endif /* DIRECT_THREADED */ - - insn_invokestatic: - { - int index = GET2U (); - - rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod; - - sp -= rmeth->stack_item_count; - - fun = (void (*)()) rmeth->method->ncode; - -#ifdef DIRECT_THREADED - // Rewrite instruction so that we use a faster pre-resolved - // method. - pc[-2].insn = &&invokestatic_resolved; - pc[-1].datum = rmeth; -#endif /* DIRECT_THREADED */ - } - goto perform_invoke; - -#ifdef DIRECT_THREADED - invokestatic_resolved: - { - rmeth = (_Jv_ResolvedMethod *) AVAL (); - sp -= rmeth->stack_item_count; - fun = (void (*)()) rmeth->method->ncode; - } - goto perform_invoke; -#endif /* DIRECT_THREADED */ - - insn_invokeinterface: - { - int index = GET2U (); - - rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod; - - sp -= rmeth->stack_item_count; - - jobject rcv = sp[0].o; - - NULLCHECK (rcv); - - fun = (void (*)()) - _Jv_LookupInterfaceMethod (rcv->getClass (), - rmeth->method->name, - rmeth->method->signature); - -#ifdef DIRECT_THREADED - // Rewrite instruction so that we use a faster pre-resolved - // method. - pc[-2].insn = &&invokeinterface_resolved; - pc[-1].datum = rmeth; -#else - // Skip dummy bytes. - pc += 2; -#endif /* DIRECT_THREADED */ - } - goto perform_invoke; - -#ifdef DIRECT_THREADED - invokeinterface_resolved: - { - rmeth = (_Jv_ResolvedMethod *) AVAL (); - sp -= rmeth->stack_item_count; - jobject rcv = sp[0].o; - NULLCHECK (rcv); - fun = (void (*)()) - _Jv_LookupInterfaceMethod (rcv->getClass (), - rmeth->method->name, - rmeth->method->signature); - } - goto perform_invoke; -#endif /* DIRECT_THREADED */ - - insn_new: - { - int index = GET2U (); - jclass klass = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - // We initialize here because otherwise `size_in_bytes' may - // not be set correctly, leading us to pass `0' as the size. - // FIXME: fix in the allocator? There is a PR for this. - _Jv_InitClass (klass); - jobject res = _Jv_AllocObject (klass, klass->size_in_bytes); - PUSHA (res); - -#ifdef DIRECT_THREADED - pc[-2].insn = &&new_resolved; - pc[-1].datum = klass; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - new_resolved: - { - jclass klass = (jclass) AVAL (); - jobject res = _Jv_AllocObject (klass, klass->size_in_bytes); - PUSHA (res); - } - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_newarray: - { - int atype = GET1U (); - int size = POPI(); - jobject result = _Jv_NewArray (atype, size); - PUSHA (result); - } - NEXT_INSN; - - insn_anewarray: - { - int index = GET2U (); - jclass klass = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - int size = POPI(); - jobject result = _Jv_NewObjectArray (size, klass, 0); - PUSHA (result); - -#ifdef DIRECT_THREADED - pc[-2].insn = &&anewarray_resolved; - pc[-1].datum = klass; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - anewarray_resolved: - { - jclass klass = (jclass) AVAL (); - int size = POPI (); - jobject result = _Jv_NewObjectArray (size, klass, 0); - PUSHA (result); - } - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_arraylength: - { - __JArray *arr = (__JArray*)POPA(); - NULLARRAYCHECK (arr); - PUSHI (arr->length); - } - NEXT_INSN; - - insn_athrow: - { - jobject value = POPA(); - throw static_cast(value); - } - NEXT_INSN; - - insn_checkcast: - { - jobject value = POPA(); - jint index = GET2U (); - jclass to = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - - if (value != NULL && ! to->isInstance (value)) - throw new java::lang::ClassCastException (to->getName()); - - PUSHA (value); - -#ifdef DIRECT_THREADED - pc[-2].insn = &&checkcast_resolved; - pc[-1].datum = to; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - checkcast_resolved: - { - jobject value = POPA (); - jclass to = (jclass) AVAL (); - if (value != NULL && ! to->isInstance (value)) - throw new java::lang::ClassCastException (to->getName()); - PUSHA (value); - } - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_instanceof: - { - jobject value = POPA(); - jint index = GET2U (); - jclass to = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - PUSHI (to->isInstance (value)); - -#ifdef DIRECT_THREADED - pc[-2].insn = &&instanceof_resolved; - pc[-1].datum = to; -#endif /* DIRECT_THREADED */ - } - NEXT_INSN; - -#ifdef DIRECT_THREADED - instanceof_resolved: - { - jobject value = POPA (); - jclass to = (jclass) AVAL (); - PUSHI (to->isInstance (value)); - } - NEXT_INSN; -#endif /* DIRECT_THREADED */ - - insn_monitorenter: - { - jobject value = POPA(); - NULLCHECK(value); - _Jv_MonitorEnter (value); - } - NEXT_INSN; - - insn_monitorexit: - { - jobject value = POPA(); - NULLCHECK(value); - _Jv_MonitorExit (value); - } - NEXT_INSN; - - insn_ifnull: - { - jobject val = POPA(); - if (val == NULL) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_ifnonnull: - { - jobject val = POPA(); - if (val != NULL) - TAKE_GOTO; - else - SKIP_GOTO; - } - NEXT_INSN; - - insn_multianewarray: - { - int kind_index = GET2U (); - int dim = GET1U (); - - jclass type - = (_Jv_ResolvePoolEntry (defining_class, kind_index)).clazz; - jint *sizes = (jint*) __builtin_alloca (sizeof (jint)*dim); - - for (int i = dim - 1; i >= 0; i--) - { - sizes[i] = POPI (); - } - - jobject res = _Jv_NewMultiArray (type,dim, sizes); - - PUSHA (res); - } - NEXT_INSN; - -#ifndef DIRECT_THREADED - insn_wide: - { - jint the_mod_op = get1u (pc++); - jint wide = get2u (pc); pc += 2; + This function should only be used with the __GCJ_DEBUG interpreter. */ +static void +find_catch_location (::java::lang::Throwable *exc, jthread thread, + jmethodID *catch_method, jlong *catch_loc) +{ + *catch_method = 0; + *catch_loc = 0; - switch (the_mod_op) - { - case op_istore: - STOREI (wide); - NEXT_INSN; + _Jv_InterpFrame *frame + = reinterpret_cast<_Jv_InterpFrame *> (thread->interp_frame); + while (frame != NULL) + { + pc_t pc = frame->get_pc (); + _Jv_InterpMethod *imeth + = reinterpret_cast<_Jv_InterpMethod *> (frame->self); + if (imeth->check_handler (&pc, imeth, exc)) + { + // This method handles the exception. + *catch_method = imeth->get_method (); + *catch_loc = imeth->insn_index (pc); + return; + } - case op_fstore: - STOREF (wide); - NEXT_INSN; + frame = frame->next_interp; + } +} - case op_astore: - STOREA (wide); - NEXT_INSN; +/* This method handles JVMTI notifications of thrown exceptions. It + calls find_catch_location to figure out where the exception is + caught (if it is caught). + + Like find_catch_location, this should only be called with the + __GCJ_DEBUG interpreter. Since a few exceptions occur outside the + interpreter proper, it is important to not call this function + without checking JVMTI_REQUESTED_EVENT(Exception) first. */ +void +_Jv_ReportJVMTIExceptionThrow (jthrowable ex) +{ + jthread thread = ::java::lang::Thread::currentThread (); + _Jv_Frame *frame = reinterpret_cast<_Jv_Frame *> (thread->frame); + jmethodID throw_meth = frame->self->get_method (); + jlocation throw_loc = -1; + if (frame->frame_type == frame_interpreter) + { + _Jv_InterpFrame * iframe + = reinterpret_cast<_Jv_InterpFrame *> (frame); + _Jv_InterpMethod *imeth + = reinterpret_cast<_Jv_InterpMethod *> (frame->self); + throw_loc = imeth->insn_index (iframe->get_pc ()); + } - case op_lload: - LOADL (wide); - NEXT_INSN; + jlong catch_loc; + jmethodID catch_method; + find_catch_location (ex, thread, &catch_method, &catch_loc); + _Jv_JVMTI_PostEvent (JVMTI_EVENT_EXCEPTION, thread, + _Jv_GetCurrentJNIEnv (), throw_meth, throw_loc, + ex, catch_method, catch_loc); +} - case op_dload: - LOADD (wide); - NEXT_INSN; + - case op_iload: - LOADI (wide); - NEXT_INSN; +void +_Jv_InterpreterEngine::do_verify (jclass klass) +{ + _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info; + for (int i = 0; i < klass->method_count; i++) + { + using namespace java::lang::reflect; + _Jv_MethodBase *imeth = iclass->interpreted_methods[i]; + _Jv_ushort accflags = klass->methods[i].accflags; + if ((accflags & (Modifier::NATIVE | Modifier::ABSTRACT)) == 0) + { + _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth); + _Jv_VerifyMethod (im); + } + } +} - case op_aload: - LOADA (wide); - NEXT_INSN; +void +_Jv_InterpreterEngine::do_create_ncode (jclass klass) +{ + _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info; + for (int i = 0; i < klass->method_count; i++) + { + // Just skip abstract methods. This is particularly important + // because we don't resize the interpreted_methods array when + // miranda methods are added to it. + if ((klass->methods[i].accflags + & java::lang::reflect::Modifier::ABSTRACT) + != 0) + continue; + + _Jv_MethodBase *imeth = iclass->interpreted_methods[i]; + + if ((klass->methods[i].accflags & java::lang::reflect::Modifier::NATIVE) + != 0) + { + // You might think we could use a virtual `ncode' method in + // the _Jv_MethodBase and unify the native and non-native + // cases. Well, we can't, because we don't allocate these + // objects using `new', and thus they don't get a vtable. + _Jv_JNIMethod *jnim = reinterpret_cast<_Jv_JNIMethod *> (imeth); + klass->methods[i].ncode = jnim->ncode (klass); + } + else if (imeth != 0) // it could be abstract + { + _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth); + klass->methods[i].ncode = im->ncode (klass); + } + } +} - case op_lstore: - STOREL (wide); - NEXT_INSN; +_Jv_ClosureList ** +_Jv_InterpreterEngine::do_get_closure_list (jclass klass) +{ + _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info; - case op_dstore: - STORED (wide); - NEXT_INSN; + if (!iclass->closures) + iclass->closures = _Jv_ClosureListFinalizer (); - case op_ret: - pc = (unsigned char*) PEEKA (wide); - NEXT_INSN; + return iclass->closures; +} - case op_iinc: - { - jint amount = get2s (pc); pc += 2; - jint value = PEEKI (wide); - POKEI (wide, value+amount); - } - NEXT_INSN; +void +_Jv_InterpreterEngine::do_allocate_static_fields (jclass klass, + int pointer_size, + int other_size) +{ + _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info; + + // Splitting the allocations here lets us scan reference fields and + // avoid scanning non-reference fields. How reference fields are + // scanned is a bit tricky: we allocate using _Jv_AllocRawObj, which + // means that this memory will be scanned conservatively (same + // difference, since we know all the contents here are pointers). + // Then we put pointers into this memory into the 'fields' + // structure. Most of these are interior pointers, which is ok (but + // even so the pointer to the first reference field will be used and + // that is not an interior pointer). The 'fields' array is also + // allocated with _Jv_AllocRawObj (see defineclass.cc), so it will + // be scanned. A pointer to this array is held by Class and thus + // seen by the collector. + char *reference_fields = (char *) _Jv_AllocRawObj (pointer_size); + char *non_reference_fields = (char *) _Jv_AllocBytes (other_size); + + for (int i = 0; i < klass->field_count; i++) + { + _Jv_Field *field = &klass->fields[i]; - default: - throw_internal_error ("illegal bytecode modified by wide"); - } + if ((field->flags & java::lang::reflect::Modifier::STATIC) == 0) + continue; - } -#endif /* DIRECT_THREADED */ - } - catch (java::lang::Throwable *ex) - { -#ifdef DIRECT_THREADED - void *logical_pc = (void *) ((insn_slot *) pc - 1); -#else - int logical_pc = pc - 1 - bytecode (); -#endif - _Jv_InterpException *exc = exceptions (); - jclass exc_class = ex->getClass (); + char *base = field->isRef() ? reference_fields : non_reference_fields; + field->u.addr = base + field->u.boffset; - for (int i = 0; i < exc_count; i++) + if (iclass->field_initializers[i] != 0) { - if (PCVAL (exc[i].start_pc) <= logical_pc - && logical_pc < PCVAL (exc[i].end_pc)) - { -#ifdef DIRECT_THREADED - jclass handler = (jclass) exc[i].handler_type.p; -#else - jclass handler = NULL; - if (exc[i].handler_type.i != 0) - handler = (_Jv_ResolvePoolEntry (defining_class, - exc[i].handler_type.i)).clazz; -#endif /* DIRECT_THREADED */ - - if (handler == NULL || handler->isAssignableFrom (exc_class)) - { -#ifdef DIRECT_THREADED - pc = (insn_slot *) exc[i].handler_pc.p; -#else - pc = bytecode () + exc[i].handler_pc.i; -#endif /* DIRECT_THREADED */ - sp = stack; - sp++->o = ex; // Push exception. - NEXT_INSN; - } - } + _Jv_Linker::resolve_field (field, klass->loader); + _Jv_InitField (0, klass, i); } - - // No handler, so re-throw. - throw ex; } -} -// This function exists so that the stack-tracing code can find the -// boundaries of the interpreter. -void -_Jv_EndOfInterpreter (void) -{ + // Now we don't need the field_initializers anymore, so let the + // collector get rid of it. + iclass->field_initializers = 0; } -static void -throw_internal_error (char *msg) +_Jv_ResolvedMethod * +_Jv_InterpreterEngine::do_resolve_method (_Jv_Method *method, jclass klass, + jboolean staticp) { - throw new java::lang::InternalError (JvNewStringLatin1 (msg)); + int arg_count = _Jv_count_arguments (method->signature, staticp); + + _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*) + _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod) + + arg_count*sizeof (ffi_type*)); + + result->stack_item_count + = _Jv_init_cif (method->signature, + arg_count, + staticp, + &result->cif, + &result->arg_types[0], + NULL); + + result->method = method; + result->klass = klass; + + return result; } -static void -throw_incompatible_class_change_error (jstring msg) +void +_Jv_InterpreterEngine::do_post_miranda_hook (jclass klass) { - throw new java::lang::IncompatibleClassChangeError (msg); + _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info; + for (int i = 0; i < klass->method_count; i++) + { + // Just skip abstract methods. This is particularly important + // because we don't resize the interpreted_methods array when + // miranda methods are added to it. + if ((klass->methods[i].accflags + & java::lang::reflect::Modifier::ABSTRACT) + != 0) + continue; + // Miranda method additions mean that the `methods' array moves. + // We cache a pointer into this array, so we have to update. + iclass->interpreted_methods[i]->self = &klass->methods[i]; + } } -#ifndef HANDLE_SEGV -static java::lang::NullPointerException *null_pointer_exc; -static void -throw_null_pointer_exception () +#ifdef DIRECT_THREADED +void +_Jv_CompileMethod (_Jv_InterpMethod* method) { - if (null_pointer_exc == NULL) - null_pointer_exc = new java::lang::NullPointerException; - - throw null_pointer_exc; + if (method->prepared == NULL) + { + if (JVMTI::enabled) + _Jv_InterpMethod::run_debug (NULL, NULL, method); + else + _Jv_InterpMethod::run (NULL, NULL, method); + } } -#endif - -#endif // INTERPRETER +#endif // DIRECT_THREADED