X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=libjava%2Finterpret.cc;h=3f690d7b27c0b95e66868fb63aefde0ff5c283a1;hp=5bfe4e7fbba91d8b979b2955724cd6370a3801f2;hb=HEAD;hpb=380cddab526fcf3c2f33dc8ebeb61c2d42703f41 diff --git a/libjava/interpret.cc b/libjava/interpret.cc index 5bfe4e7fbba..3f690d7b27c 100644 --- a/libjava/interpret.cc +++ b/libjava/interpret.cc @@ -1,6 +1,6 @@ // interpret.cc - Code for the interpreter -/* Copyright (C) 1999, 2000, 2001 Free Software Foundation +/* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation This file is part of libgcj. @@ -11,41 +11,97 @@ details. */ /* Author: Kresten Krab Thorup */ #include +#include #pragma implementation "java-interp.h" #include #include #include -// #include #include #include #include +#include #include #include #include -#include -#include #include #include #include #include +#include +#include #include #include +#include +#include +#include + +#include +#include "jvmti-int.h" -#ifdef INTERPRETER +#include +#include + +// 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__)); + +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; + +void +_Jv_InitInterpreter() +{ + _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 +insn_slot _Jv_InterpMethod::bp_insn_slot; +pc_t _Jv_InterpMethod::breakpoint_insn = NULL; +#else +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); @@ -64,9 +120,24 @@ 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. +template +static inline TO +convert (FROM val, TO min, TO max) +{ + TO ret; + if (val >= (FROM) max) + ret = max; + else if (val <= (FROM) min) + ret = min; + else if (val != val) + ret = 0; + else + ret = (TO) val; + return ret; +} #define PUSHA(V) (sp++)->o = (V) #define PUSHI(V) (sp++)->i = (V) @@ -112,24 +183,81 @@ static inline void dupx (_Jv_word *sp, int n, int x) # 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) { \ @@ -156,2280 +284,1661 @@ static inline void dupx (_Jv_word *sp, int n, int x) 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) SAVE_PC() #else -#define NULLCHECK(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 - -// this method starts the actual running of the method. It is inlined -// in three different variants in the static methods run_normal, -// run_sync_object and run_sync_class (see below). Those static methods -// are installed directly in the stub for this method (by -// _Jv_InterpMethod::ncode, in resolve.cc). - -inline jobject -_Jv_InterpMethod::run (ffi_cif* cif, - void *retp, - ffi_raw *args, - _Jv_InterpMethodInvocation *inv) +#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, + INTERP_FFI_RAW_TYPE *args, + void *__this) { - inv->running = this; - inv->pc = bytecode (); - inv->sp = inv->stack_base (); - _Jv_word *locals = inv->local_base (); - - /* 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); + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; + run (ret, args, _this); +} - next_segment: +void +_Jv_InterpMethod::run_normal_debug (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) +{ + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; + run_debug (ret, args, _this); +} - jobject ex = NULL; +void +_Jv_InterpMethod::run_synch_object (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) +{ + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; - try - { - continue1 (inv); - } - catch (java::lang::Throwable *ex2) - { - ex = ex2; - } + jobject rcv = (jobject) args[0].ptr; + JvSynchronize mutex (rcv); - if (ex == 0) // no exception... - { - /* define sp locally, so the POP? macros will pick it up */ - _Jv_word *sp = inv->sp; - int rtype = cif->rtype->type; + run (ret, args, _this); +} - if (rtype == FFI_TYPE_POINTER) - { - jobject r = POPA(); - *(jobject*) retp = r; - return 0; - } - else if (rtype == FFI_TYPE_SINT32) - { - jint r = POPI(); - *(jint*)retp = r; - return 0; - } - else if (rtype == FFI_TYPE_VOID) - { - return 0; - } - else switch (rtype) - { - case FFI_TYPE_FLOAT: - { - jfloat r = POPF(); - *(jfloat*)retp = r; - return 0; - } - - case FFI_TYPE_DOUBLE: - { - jdouble r = POPD(); - *(jdouble*)retp = r; - return 0; - } - - case FFI_TYPE_UINT8: - case FFI_TYPE_UINT16: - case FFI_TYPE_UINT32: - case FFI_TYPE_SINT8: - case FFI_TYPE_SINT16: - { - jint r = POPI(); - *(jint*)retp = r; - return 0; - } - - case FFI_TYPE_SINT64: - { - jlong r = POPL(); - *(jlong*)retp = r; - return 0; - } - - default: - throw_internal_error ("unknown return type"); - } - } +void +_Jv_InterpMethod::run_synch_object_debug (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) +{ + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; - /** handle an exception */ - if ( find_exception (ex, inv) ) - goto next_segment; + jobject rcv = (jobject) args[0].ptr; + JvSynchronize mutex (rcv); - return ex; + run_debug (ret, args, _this); } -bool _Jv_InterpMethod::find_exception (jobject ex, - _Jv_InterpMethodInvocation *inv) +void +_Jv_InterpMethod::run_class (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) { - int logical_pc = inv->pc - bytecode (); - _Jv_InterpException *exc = exceptions (); - jclass exc_class = ex->getClass (); - - for (int i = 0; i < exc_count; i++) - { - if (exc[i].start_pc <= logical_pc && logical_pc < exc[i].end_pc) - { - jclass handler; + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; + _Jv_InitClass (_this->defining_class); + run (ret, args, _this); +} - if (exc[i].handler_type != 0) - handler = (_Jv_ResolvePoolEntry (defining_class, - exc[i].handler_type)).clazz; - else - handler = NULL; - - if (handler==NULL || handler->isAssignableFrom (exc_class)) - { - inv->pc = bytecode () + exc[i].handler_pc; - inv->sp = inv->stack_base (); // reset stack - (inv->sp++)->o = ex; // push exception - return true; - } - } - } - return false; +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); + run_debug (ret, args, _this); } -void _Jv_InterpMethod::run_normal (ffi_cif* cif, - void* ret, - ffi_raw * args, - void* __this) +void +_Jv_InterpMethod::run_synch_class (ffi_cif *, + void *ret, + INTERP_FFI_RAW_TYPE *args, + void *__this) { - _Jv_InterpMethod* _this = (_Jv_InterpMethod*)__this; + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; - // we do the alloca of the method invocation here, to allow the method - // "run" ro be inlined. Otherwise gcc will ignore the inline directive. - int storage_size = _this->max_stack+_this->max_locals; - _Jv_InterpMethodInvocation* inv = (_Jv_InterpMethodInvocation*) - __builtin_alloca (sizeof (_Jv_InterpMethodInvocation) - + storage_size * sizeof (_Jv_word)); + jclass sync = _this->defining_class; + _Jv_InitClass (sync); + JvSynchronize mutex (sync); - jobject ex = _this->run (cif, ret, args, inv); - if (ex != 0) throw static_cast(ex); + run (ret, args, _this); } -void _Jv_InterpMethod::run_synch_object (ffi_cif* cif, - void* ret, - ffi_raw * args, - void* __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; - jobject rcv = (jobject)args[0].ptr; + _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this; - int storage_size = _this->max_stack+_this->max_locals; - _Jv_InterpMethodInvocation* inv = (_Jv_InterpMethodInvocation*) - __builtin_alloca (sizeof (_Jv_InterpMethodInvocation) - + storage_size * sizeof (_Jv_word)); + jclass sync = _this->defining_class; + _Jv_InitClass (sync); + JvSynchronize mutex (sync); - _Jv_MonitorEnter (rcv); - jobject ex = _this->run (cif, ret, args, inv); - _Jv_MonitorExit (rcv); - - if (ex != 0) throw static_cast(ex); + run_debug (ret, args, _this); } -void _Jv_InterpMethod::run_synch_class (ffi_cif* cif, - void* ret, - ffi_raw * args, - void* __this) +#ifdef DIRECT_THREADED +// "Compile" a method by turning it from bytecode to direct-threaded +// code. +void +_Jv_InterpMethod::compile (const void * const *insn_targets) { - _Jv_InterpMethod* _this = (_Jv_InterpMethod*)__this; - jclass sync = _this->defining_class; - - int storage_size = _this->max_stack+_this->max_locals; - _Jv_InterpMethodInvocation* inv = (_Jv_InterpMethodInvocation*) - __builtin_alloca (sizeof (_Jv_InterpMethodInvocation) - + storage_size * sizeof (_Jv_word)); + insn_slot *insns = NULL; + int next = 0; + unsigned char *codestart = bytecode (); + unsigned char *end = codestart + code_length; + _Jv_word *pool_data = defining_class->constants.data; + +#define SET_ONE(Field, Value) \ + do \ + { \ + if (first_pass) \ + ++next; \ + else \ + insns[next++].Field = Value; \ + } \ + while (0) + +#define SET_INSN(Value) SET_ONE (insn, (void *) Value) +#define SET_INT(Value) SET_ONE (int_val, Value) +#define SET_DATUM(Value) SET_ONE (datum, Value) + + // Map from bytecode PC to slot in INSNS. + int *pc_mapping = (int *) __builtin_alloca (sizeof (int) * code_length); + for (int i = 0; i < code_length; ++i) + pc_mapping[i] = -1; + + for (int i = 0; i < 2; ++i) + { + jboolean first_pass = i == 0; - _Jv_MonitorEnter (sync); - jobject ex = _this->run (cif, ret, args, inv); - _Jv_MonitorExit (sync); + if (! first_pass) + { + insns = (insn_slot *) _Jv_AllocBytes (sizeof (insn_slot) * next); + number_insn_slots = next; + next = 0; + } - if (ex != 0) throw static_cast(ex); -} + unsigned char *pc = codestart; + while (pc < end) + { + int base_pc_val = pc - codestart; + if (first_pass) + pc_mapping[base_pc_val] = next; -/* - This proceeds execution, as designated in "inv". If an exception - happens, then it is simply thrown, and handled in Java. Thus, the pc - needs to be stored in the inv->pc at all times, so we can figure - out which handler (if any) to invoke. + java_opcode opcode = (java_opcode) *pc++; + // Just elide NOPs. + if (opcode == op_nop) + continue; + SET_INSN (insn_targets[opcode]); - One design issue, which I have not completely considered, is if it - should be possible to have interpreted classes linked in! Seldom used - (or non-critical) classes could reasonably be interpreted. -*/ + switch (opcode) + { + case op_nop: + case op_aconst_null: + case op_iconst_m1: + case op_iconst_0: + case op_iconst_1: + case op_iconst_2: + case op_iconst_3: + case op_iconst_4: + case op_iconst_5: + case op_lconst_0: + case op_lconst_1: + case op_fconst_0: + case op_fconst_1: + case op_fconst_2: + case op_dconst_0: + case op_dconst_1: + case op_iload_0: + case op_iload_1: + case op_iload_2: + case op_iload_3: + case op_lload_0: + case op_lload_1: + case op_lload_2: + case op_lload_3: + case op_fload_0: + case op_fload_1: + case op_fload_2: + case op_fload_3: + case op_dload_0: + case op_dload_1: + case op_dload_2: + case op_dload_3: + case op_aload_0: + case op_aload_1: + case op_aload_2: + case op_aload_3: + case op_iaload: + case op_laload: + case op_faload: + case op_daload: + case op_aaload: + case op_baload: + case op_caload: + case op_saload: + case op_istore_0: + case op_istore_1: + case op_istore_2: + case op_istore_3: + case op_lstore_0: + case op_lstore_1: + case op_lstore_2: + case op_lstore_3: + case op_fstore_0: + case op_fstore_1: + case op_fstore_2: + case op_fstore_3: + case op_dstore_0: + case op_dstore_1: + case op_dstore_2: + case op_dstore_3: + case op_astore_0: + case op_astore_1: + case op_astore_2: + case op_astore_3: + case op_iastore: + case op_lastore: + case op_fastore: + case op_dastore: + case op_aastore: + case op_bastore: + case op_castore: + case op_sastore: + case op_pop: + case op_pop2: + case op_dup: + case op_dup_x1: + case op_dup_x2: + case op_dup2: + case op_dup2_x1: + case op_dup2_x2: + case op_swap: + case op_iadd: + case op_isub: + case op_imul: + case op_idiv: + case op_irem: + case op_ishl: + case op_ishr: + case op_iushr: + case op_iand: + case op_ior: + case op_ixor: + case op_ladd: + case op_lsub: + case op_lmul: + case op_ldiv: + case op_lrem: + case op_lshl: + case op_lshr: + case op_lushr: + case op_land: + case op_lor: + case op_lxor: + case op_fadd: + case op_fsub: + case op_fmul: + case op_fdiv: + case op_frem: + case op_dadd: + case op_dsub: + case op_dmul: + case op_ddiv: + case op_drem: + case op_ineg: + case op_i2b: + case op_i2c: + case op_i2s: + case op_lneg: + case op_fneg: + case op_dneg: + case op_i2l: + case op_i2f: + case op_i2d: + case op_l2i: + case op_l2f: + case op_l2d: + case op_f2i: + case op_f2l: + case op_f2d: + case op_d2i: + case op_d2l: + case op_d2f: + case op_lcmp: + case op_fcmpl: + case op_fcmpg: + case op_dcmpl: + case op_dcmpg: + case op_monitorenter: + case op_monitorexit: + case op_ireturn: + case op_lreturn: + case op_freturn: + case op_dreturn: + case op_areturn: + case op_return: + case op_athrow: + case op_arraylength: + // No argument, nothing else to do. + break; + + case op_bipush: + SET_INT (get1s (pc)); + ++pc; + break; + + case op_ldc: + { + int index = get1u (pc); + ++pc; + // 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; + + case op_ret: + case op_iload: + case op_lload: + case op_fload: + case op_dload: + case op_aload: + case op_istore: + case op_lstore: + case op_fstore: + case op_dstore: + case op_astore: + case op_newarray: + SET_INT (get1u (pc)); + ++pc; + break; + + case op_iinc: + SET_INT (get1u (pc)); + SET_INT (get1s (pc + 1)); + pc += 2; + break; + + case op_ldc_w: + { + int index = get2u (pc); + pc += 2; + // 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; + case op_ldc2_w: + { + int index = get2u (pc); + pc += 2; + SET_DATUM (&pool_data[index]); + } + break; + + case op_sipush: + SET_INT (get2s (pc)); + pc += 2; + break; + + case op_new: + case op_getstatic: + case op_getfield: + case op_putfield: + case op_putstatic: + case op_anewarray: + case op_instanceof: + case op_checkcast: + case op_invokespecial: + case op_invokestatic: + case op_invokevirtual: + SET_INT (get2u (pc)); + pc += 2; + break; + + case op_multianewarray: + SET_INT (get2u (pc)); + SET_INT (get1u (pc + 2)); + pc += 3; + break; + + case op_jsr: + case op_ifeq: + case op_ifne: + case op_iflt: + case op_ifge: + case op_ifgt: + case op_ifle: + case op_if_icmpeq: + case op_if_icmpne: + case op_if_icmplt: + case op_if_icmpge: + case op_if_icmpgt: + case op_if_icmple: + case op_if_acmpeq: + case op_if_acmpne: + case op_ifnull: + case op_ifnonnull: + case op_goto: + { + int offset = get2s (pc); + pc += 2; + + int new_pc = base_pc_val + offset; + + bool orig_was_goto = opcode == op_goto; + + // Thread jumps. We limit the loop count; this lets + // us avoid infinite loops if the bytecode contains + // such. `10' is arbitrary. + int count = 10; + while (codestart[new_pc] == op_goto && count-- > 0) + new_pc += get2s (&codestart[new_pc + 1]); + + // If the jump takes us to a `return' instruction and + // the original branch was an unconditional goto, then + // we hoist the return. + opcode = (java_opcode) codestart[new_pc]; + if (orig_was_goto + && (opcode == op_ireturn || opcode == op_lreturn + || opcode == op_freturn || opcode == op_dreturn + || opcode == op_areturn || opcode == op_return)) + { + --next; + SET_INSN (insn_targets[opcode]); + } + else + SET_DATUM (&insns[pc_mapping[new_pc]]); + } + break; -void _Jv_InterpMethod::continue1 (_Jv_InterpMethodInvocation *inv) -{ - using namespace java::lang::reflect; + case op_tableswitch: + { + while ((pc - codestart) % 4 != 0) + ++pc; + + jint def = get4 (pc); + SET_DATUM (&insns[pc_mapping[base_pc_val + def]]); + pc += 4; + + int low = get4 (pc); + SET_INT (low); + pc += 4; + int high = get4 (pc); + SET_INT (high); + pc += 4; + + for (int i = low; i <= high; ++i) + { + SET_DATUM (&insns[pc_mapping[base_pc_val + get4 (pc)]]); + pc += 4; + } + } + break; - _Jv_word *sp = inv->sp; - unsigned char *pc = inv->pc; - _Jv_word *locals = inv->local_base (); + case op_lookupswitch: + { + while ((pc - codestart) % 4 != 0) + ++pc; + + jint def = get4 (pc); + SET_DATUM (&insns[pc_mapping[base_pc_val + def]]); + pc += 4; + + jint npairs = get4 (pc); + pc += 4; + SET_INT (npairs); + + while (npairs-- > 0) + { + jint match = get4 (pc); + jint offset = get4 (pc + 4); + SET_INT (match); + SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]); + pc += 8; + } + } + break; - _Jv_word *pool_data = defining_class->constants.data; - - /* these two are used in the invokeXXX instructions */ - void (*fun)(); - _Jv_ResolvedMethod* rmeth; - -#define INSN_LABEL(op) &&insn_##op -#define GOTO_INSN(op) goto *(insn_target[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, /* op_xxxunusedxxx1, */ - 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), - INSN_LABEL(wide), - INSN_LABEL(multianewarray), - INSN_LABEL(ifnull), - INSN_LABEL(ifnonnull), - INSN_LABEL(goto_w), - INSN_LABEL(jsr_w), - }; - -#define SAVE_PC inv->pc = pc-1 - - /* If the macro INLINE_SWITCH is not defined, then the main loop - operates as one big (normal) switch statement. If it is defined, - then the case selection is performed `inline' in the end of the - code for each case. The latter saves a native branch instruction - for each java-instruction, but expands the code size somewhat. - - NOTE: On i386 defining INLINE_SWITCH improves over all - performance approximately seven percent, but it may be different - for other machines. At some point, this may be made into a proper - configuration parameter. */ - -#define INLINE_SWITCH - -#ifdef INLINE_SWITCH - -#define NEXT_INSN do { GOTO_INSN(*pc++); } while (0) - - - NEXT_INSN; -#else + case op_invokeinterface: + { + jint index = get2u (pc); + pc += 2; + // We ignore the next two bytes. + pc += 2; + SET_INT (index); + } + break; -#define NEXT_INSN goto next_insn + case op_wide: + { + opcode = (java_opcode) get1u (pc); + pc += 1; + jint val = get2u (pc); + pc += 2; + + // We implement narrow and wide instructions using the + // same code in the interpreter. So we rewrite the + // instruction slot here. + if (! first_pass) + insns[next - 1].insn = (void *) insn_targets[opcode]; + SET_INT (val); + + if (opcode == op_iinc) + { + SET_INT (get2s (pc)); + pc += 2; + } + } + break; - next_insn: - GOTO_INSN (*pc++); + case op_jsr_w: + case op_goto_w: + { + jint offset = get4 (pc); + pc += 4; + SET_DATUM (&insns[pc_mapping[base_pc_val + offset]]); + } + break; + + // Some "can't happen" cases that we include for + // error-checking purposes. + case op_putfield_1: + case op_putfield_2: + case op_putfield_4: + case op_putfield_8: + case op_putfield_a: + case op_putstatic_1: + case op_putstatic_2: + case op_putstatic_4: + case op_putstatic_8: + case op_putstatic_a: + case op_getfield_1: + case op_getfield_2s: + case op_getfield_2u: + case op_getfield_4: + case op_getfield_8: + case op_getfield_a: + case op_getstatic_1: + case op_getstatic_2s: + case op_getstatic_2u: + case op_getstatic_4: + case op_getstatic_8: + case op_getstatic_a: + case op_breakpoint: + default: + // Fail somehow. + break; + } + } + } -#endif + // Now update exceptions. + _Jv_InterpException *exc = exceptions (); + for (int i = 0; i < exc_count; ++i) + { + 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]]; + // 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; + } - /* The first few instructions here are ordered according to their - frequency, in the hope that this will improve code locality a - little. */ + // 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 */ - insn_aload_0: // 0x2a - LOADA(0); - NEXT_INSN; +/* Run the given method. + When args is NULL, don't run anything -- just compile it. */ +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) - insn_iload: // 0x15 - LOADI (get1u (pc++)); - NEXT_INSN; +#include "interpret-run.cc" +} - insn_iload_1: // 0x1b - LOADI (1); - NEXT_INSN; +void +_Jv_InterpMethod::run_debug (void *retp, INTERP_FFI_RAW_TYPE *args, + _Jv_InterpMethod *meth) +{ +#define __GCJ_DEBUG +#undef DEBUG_LOCALS_INSN +#define DEBUG_LOCALS_INSN(s, t) \ + do \ + { \ + frame_desc.locals_type[s] = t; \ + } \ + while (0) + +#include "interpret-run.cc" +} - insn_invokevirtual: // 0xb6 - SAVE_PC; - { - int index = get2u (pc); pc += 2; - - /* _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); - } - } - goto perform_invoke; +static void +throw_internal_error (const char *msg) +{ + jthrowable t = new java::lang::InternalError (JvNewStringLatin1 (msg)); + REPORT_EXCEPTION (t); + throw t; +} - perform_invoke: - { - /* here goes the magic again... */ - ffi_cif *cif = &rmeth->cif; - ffi_raw *raw = (ffi_raw*) sp; +static void +throw_incompatible_class_change_error (jstring msg) +{ + jthrowable t = new java::lang::IncompatibleClassChangeError (msg); + REPORT_EXCEPTION (t); + throw t; +} - jdouble rvalue; +static void +throw_null_pointer_exception () +{ + jthrowable t = new java::lang::NullPointerException; + REPORT_EXCEPTION (t); + throw t; +} -#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 +/* 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; +} - 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; +/** Do static initialization for fields with a constant initializer */ +void +_Jv_InitField (jobject obj, jclass klass, int index) +{ + using namespace java::lang::reflect; - case FFI_TYPE_SINT16: - { - jshort value = (*(jint*)&rvalue) & 0xffff; - PUSHI (value); - } - break; + if (obj != 0 && klass == 0) + klass = obj->getClass (); - case FFI_TYPE_UINT16: - { - jint value = (*(jint*)&rvalue) & 0xffff; - PUSHI (value); - } - break; + if (!_Jv_IsInterpretedClass (klass)) + return; - case FFI_TYPE_FLOAT: - PUSHF (*(jfloat*)&rvalue); - break; + _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info; - case FFI_TYPE_DOUBLE: - PUSHD (rvalue); - break; + _Jv_Field * field = (&klass->fields[0]) + index; - case FFI_TYPE_SINT64: - PUSHL (*(jlong*)&rvalue); - break; + if (index > klass->field_count) + throw_internal_error ("field out of range"); - default: - throw_internal_error ("unknown return type in invokeXXX"); - } + int init = iclass->field_initializers[index]; + if (init == 0) + return; - } - NEXT_INSN; + _Jv_Constants *pool = &klass->constants; + int tag = pool->tags[init]; + if (! field->isResolved ()) + throw_internal_error ("initializing unresolved field"); - insn_nop: - NEXT_INSN; + if (obj==0 && ((field->flags & Modifier::STATIC) == 0)) + throw_internal_error ("initializing non-static field with no object"); - insn_aconst_null: - PUSHA (NULL); - NEXT_INSN; + void *addr = 0; - insn_iconst_m1: - PUSHI (-1); - NEXT_INSN; + if ((field->flags & Modifier::STATIC) != 0) + addr = (void*) field->u.addr; + else + addr = (void*) (((char*)obj) + field->u.boffset); - insn_iconst_0: - PUSHI (0); - NEXT_INSN; + switch (tag) + { + case JV_CONSTANT_String: + { + jstring str; + str = _Jv_NewStringUtf8Const (pool->data[init].utf8); + pool->data[init].string = str; + pool->tags[init] = JV_CONSTANT_ResolvedString; + } + /* fall through */ - insn_iconst_1: - PUSHI (1); - NEXT_INSN; + 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"); - insn_iconst_2: - PUSHI (2); - NEXT_INSN; + *(jstring*)addr = pool->data[init].string; + break; - insn_iconst_3: - PUSHI (3); - NEXT_INSN; + case JV_CONSTANT_Integer: + { + int value = pool->data[init].i; - insn_iconst_4: - PUSHI (4); - NEXT_INSN; + 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; - insn_iconst_5: - PUSHI (5); - NEXT_INSN; + else if (field->type == JvPrimClass (short)) + *(jshort*)addr = (jshort)value; + + else if (field->type == JvPrimClass (int)) + *(jint*)addr = (jint)value; - insn_lconst_0: - PUSHL (0); - NEXT_INSN; + else + throw_class_format_error ("erroneous field initializer"); + } + break; - insn_lconst_1: - PUSHL (1); - NEXT_INSN; + case JV_CONSTANT_Long: + if (field->type != JvPrimClass (long)) + throw_class_format_error ("erroneous field initializer"); - insn_fconst_0: - PUSHF (0); - NEXT_INSN; + *(jlong*)addr = _Jv_loadLong (&pool->data[init]); + break; - insn_fconst_1: - PUSHF (1); - NEXT_INSN; + case JV_CONSTANT_Float: + if (field->type != JvPrimClass (float)) + throw_class_format_error ("erroneous field initializer"); - insn_fconst_2: - PUSHF (2); - NEXT_INSN; + *(jfloat*)addr = pool->data[init].f; + break; - insn_dconst_0: - PUSHD (0); - NEXT_INSN; + case JV_CONSTANT_Double: + if (field->type != JvPrimClass (double)) + throw_class_format_error ("erroneous field initializer"); - insn_dconst_1: - PUSHD (1); - NEXT_INSN; + *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]); + break; - insn_bipush: - PUSHI (get1s(pc++)); - NEXT_INSN; + default: + throw_class_format_error ("erroneous field initializer"); + } +} - insn_sipush: - PUSHI (get2s(pc)); pc += 2; - NEXT_INSN; +inline static unsigned char* +skip_one_type (unsigned char* ptr) +{ + int ch = *ptr++; - insn_ldc: - { - int index = get1u (pc++); - PUSHA(pool_data[index].o); - } - NEXT_INSN; + while (ch == '[') + { + ch = *ptr++; + } + + if (ch == 'L') + { + do { ch = *ptr++; } while (ch != ';'); + } - insn_ldc_w: - { - int index = get2u (pc); pc += 2; - PUSHA(pool_data[index].o); - } - NEXT_INSN; + return ptr; +} - insn_ldc2_w: - { - int index = get2u (pc); pc += 2; - memcpy (sp, &pool_data[index], 2*sizeof (_Jv_word)); - sp += 2; - } - 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; - insn_lload: - LOADL (get1u (pc++)); - NEXT_INSN; + 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; - insn_fload: - LOADF (get1u (pc++)); - NEXT_INSN; + case 'V': + return &ffi_type_void; + break; + } - insn_dload: - LOADD (get1u (pc++)); - NEXT_INSN; + throw_internal_error ("unknown type in signature"); +} - insn_aload: - LOADA (get1u (pc++)); - 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_iload_0: - LOADI (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_iload_2: - LOADI (2); - NEXT_INSN; + /* first, count number of arguments */ - insn_iload_3: - LOADI (3); - NEXT_INSN; + // skip '(' + ptr++; - insn_lload_0: - LOADL (0); - NEXT_INSN; + // count args + while (*ptr != ')') + { + ptr = skip_one_type (ptr); + arg_count += 1; + } - insn_lload_1: - LOADL (1); - NEXT_INSN; + return arg_count; +} - insn_lload_2: - LOADL (2); - 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_lload_3: - LOADL (3); - NEXT_INSN; + int arg_index = 0; // arg number + int item_count = 0; // stack-item count - insn_fload_0: - LOADF (0); - NEXT_INSN; + // setup receiver + if (!staticp) + { + arg_types[arg_index++] = &ffi_type_pointer; + item_count += 1; + } - insn_fload_1: - LOADF (1); - NEXT_INSN; + // skip '(' + ptr++; - insn_fload_2: - LOADF (2); - NEXT_INSN; + // assign arg types + while (*ptr != ')') + { + arg_types[arg_index++] = get_ffi_type_from_signature (ptr); - insn_fload_3: - LOADF (3); - NEXT_INSN; + if (*ptr == 'J' || *ptr == 'D') + item_count += 2; + else + item_count += 1; - insn_dload_0: - LOADD (0); - NEXT_INSN; + ptr = skip_one_type (ptr); + } - insn_dload_1: - LOADD (1); - NEXT_INSN; + // skip ')' + ptr++; + ffi_type *rtype = get_ffi_type_from_signature (ptr); - insn_dload_2: - LOADD (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_dload_3: - LOADD (3); - NEXT_INSN; + if (ffi_prep_cif (cif, FFI_DEFAULT_ABI, + arg_count, rtype, arg_types) != FFI_OK) + throw_internal_error ("ffi_prep_cif failed"); - insn_aload_1: - LOADA(1); - NEXT_INSN; + if (rtype_p != NULL) + *rtype_p = rtype; - insn_aload_2: - LOADA(2); - NEXT_INSN; + return item_count; +} - insn_aload_3: - LOADA(3); - 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_iaload: - SAVE_PC; - { - jint index = POPI(); - jintArray arr = (jintArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHI( elements(arr)[index] ); - } - 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_laload: - SAVE_PC; - { - jint index = POPI(); - jlongArray arr = (jlongArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHL( elements(arr)[index] ); - } - NEXT_INSN; +void * +_Jv_InterpMethod::ncode (jclass klass) +{ + using namespace java::lang::reflect; - insn_faload: - SAVE_PC; - { - jint index = POPI(); - jfloatArray arr = (jfloatArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHF( elements(arr)[index] ); - } - NEXT_INSN; + if (self->ncode != 0) + return self->ncode; - insn_daload: - SAVE_PC; - { - jint index = POPI(); - jdoubleArray arr = (jdoubleArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHD( elements(arr)[index] ); - } - NEXT_INSN; + jboolean staticp = (self->accflags & Modifier::STATIC) != 0; + int arg_count = _Jv_count_arguments (self->signature, staticp); - insn_aaload: - SAVE_PC; - { - jint index = POPI(); - jobjectArray arr = (jobjectArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHA( elements(arr)[index] ); - } - 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_baload: - SAVE_PC; - { - jint index = POPI(); - jbyteArray arr = (jbyteArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHI( elements(arr)[index] ); - } - NEXT_INSN; + _Jv_init_cif (self->signature, + arg_count, + staticp, + &closure->cif, + &closure->arg_types[0], + NULL); - insn_caload: - SAVE_PC; - { - jint index = POPI(); - jcharArray arr = (jcharArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHI( elements(arr)[index] ); - } - NEXT_INSN; + ffi_closure_fun fun; - insn_saload: - SAVE_PC; - { - jint index = POPI(); - jshortArray arr = (jshortArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - PUSHI( elements(arr)[index] ); - } - NEXT_INSN; + args_raw_size = FFI_RAW_SIZE (&closure->cif); - insn_istore: - STOREI (get1u (pc++)); - NEXT_INSN; + JvAssert ((self->accflags & Modifier::NATIVE) == 0); - insn_lstore: - STOREL (get1u (pc++)); - 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_fstore: - STOREF (get1u (pc++)); - NEXT_INSN; + FFI_PREP_RAW_CLOSURE (&closure->closure, + &closure->cif, + fun, + (void*)this, + code); - insn_dstore: - STORED (get1u (pc++)); - NEXT_INSN; + self->ncode = code; - insn_astore: - STOREA (get1u (pc++)); - NEXT_INSN; + return self->ncode; +} - insn_istore_0: - STOREI (0); - 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_istore_1: - STOREI (1); - 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_istore_2: - STOREI (2); - NEXT_INSN; + return -1; +} - insn_istore_3: - STOREI (3); - 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_0: - STOREL (0); - 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, + ex$ +#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_lstore_1: - STOREL (1); - NEXT_INSN; - insn_lstore_2: - STOREL (2); - 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_lstore_3: - STOREL (3); - 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_fstore_0: - STOREF (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_fstore_1: - STOREF (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_fstore_2: - STOREF (2); - NEXT_INSN; +pc_t +_Jv_InterpMethod::install_break (jlong index) +{ + return set_insn (index, breakpoint_insn); +} - insn_fstore_3: - STOREF (3); - NEXT_INSN; +pc_t +_Jv_InterpMethod::get_insn (jlong index) +{ + pc_t code; - insn_dstore_0: - STORED (0); - NEXT_INSN; +#ifdef DIRECT_THREADED + if (index >= number_insn_slots || index < 0) + return NULL; - insn_dstore_1: - STORED (1); - NEXT_INSN; + code = prepared; +#else // !DIRECT_THREADED + if (index >= code_length || index < 0) + return NULL; - insn_dstore_2: - STORED (2); - NEXT_INSN; + code = reinterpret_cast (bytecode ()); +#endif // !DIRECT_THREADED - insn_dstore_3: - STORED (3); - NEXT_INSN; + return &code[index]; +} - insn_astore_0: - STOREA(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_astore_1: - STOREA(1); - NEXT_INSN; + pc_t code = prepared; + code[index].insn = insn->insn; +#else // !DIRECT_THREADED + if (index >= code_length || index < 0) + return NULL; - insn_astore_2: - STOREA(2); - NEXT_INSN; + pc_t code = reinterpret_cast (bytecode ()); + code[index] = *insn; +#endif // !DIRECT_THREADED - insn_astore_3: - STOREA(3); - NEXT_INSN; + return &code[index]; +} - insn_iastore: - SAVE_PC; - { - jint value = POPI(); - jint index = POPI(); - jintArray arr = (jintArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_lastore: - SAVE_PC; - { - jlong value = POPL(); - jint index = POPI(); - jlongArray arr = (jlongArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_fastore: - SAVE_PC; - { - jfloat value = POPF(); - jint index = POPI(); - jfloatArray arr = (jfloatArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_dastore: - SAVE_PC; - { - jdouble value = POPD(); - jint index = POPI(); - jdoubleArray arr = (jdoubleArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_aastore: - SAVE_PC; - { - jobject value = POPA(); - jint index = POPI(); - jobjectArray arr = (jobjectArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - _Jv_CheckArrayStore (arr, value); - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_bastore: - SAVE_PC; - { - jbyte value = (jbyte) POPI(); - jint index = POPI(); - jbyteArray arr = (jbyteArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_castore: - SAVE_PC; - { - jchar value = (jchar) POPI(); - jint index = POPI(); - jcharArray arr = (jcharArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (index); - } - elements(arr)[index] = value; - } - NEXT_INSN; - - insn_sastore: - SAVE_PC; - { - jshort value = (jshort) POPI(); - jint index = POPI(); - jshortArray arr = (jshortArray) POPA(); - NULLCHECK (arr); - if (index < 0 || index >= arr->length) - { - _Jv_ThrowBadArrayIndex (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: - SAVE_PC; - { - jint value2 = POPI(); - jint value1 = POPI(); - jint res = _Jv_divI (value1, value2); - PUSHI (res); - } - NEXT_INSN; - - insn_ldiv: - SAVE_PC; - { - jlong value2 = POPL(); - jlong value1 = POPL(); - jlong res = _Jv_divJ (value1, value2); - PUSHL (res); - } - NEXT_INSN; - - insn_fdiv: - SAVE_PC; - { - jfloat value2 = POPF(); - jfloat value1 = POPF(); - jfloat res = value1 / value2; - PUSHF (res); - } - NEXT_INSN; - - insn_ddiv: - SAVE_PC; - { - jdouble value2 = POPD(); - jdouble value1 = POPD(); - jdouble res = value1 / value2; - PUSHD (res); - } - NEXT_INSN; - - insn_irem: - SAVE_PC; - { - jint value2 = POPI(); - jint value1 = POPI(); - jint res = _Jv_remI (value1, value2); - PUSHI (res); - } - NEXT_INSN; - - insn_lrem: - SAVE_PC; - { - jlong value2 = POPL(); - jlong value1 = POPL(); - jlong res = _Jv_remJ (value1, value2); - PUSHL (res); - } - NEXT_INSN; - - insn_frem: - SAVE_PC; - { - jfloat value2 = POPF(); - jfloat value1 = POPF(); - jfloat res = __ieee754_fmod (value1, value2); - PUSHF (res); - } - NEXT_INSN; - - insn_drem: - SAVE_PC; - { - 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); - unsigned long value = 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 (pc++); - jint amount = get1s (pc++); - 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: - { jint value = (jint)POPF (); PUSHI(value); } - NEXT_INSN; - - insn_f2l: - { jlong value = (jlong)POPF (); PUSHL(value); } - NEXT_INSN; - - insn_f2d: - { jdouble value = POPF (); PUSHD(value); } - NEXT_INSN; - - insn_d2i: - { jint value = (jint)POPD (); PUSHI(value); } - NEXT_INSN; - - insn_d2l: - { jlong value = (jlong)POPD (); 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: - insn_fcmpg: - { - jfloat value2 = POPF (); - jfloat value1 = POPF (); - if (value1 > value2) - PUSHI (1); - else if (value1 == value2) - PUSHI (0); - else if (value1 < value2) - PUSHI (-1); - else if ((*(pc-1)) == op_fcmpg) - PUSHI (1); - else - PUSHI (-1); - } - NEXT_INSN; - - insn_dcmpl: - insn_dcmpg: - { - jdouble value2 = POPD (); - jdouble value1 = POPD (); - if (value1 > value2) - PUSHI (1); - else if (value1 == value2) - PUSHI (0); - else if (value1 < value2) - PUSHI (-1); - else if ((*(pc-1)) == op_dcmpg) - PUSHI (1); - else - PUSHI (-1); - } - NEXT_INSN; - - insn_ifeq: - { - jint offset = get2s (pc); - if (POPI() == 0) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_ifne: - { - jint offset = get2s (pc); - if (POPI() != 0) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_iflt: - { - jint offset = get2s (pc); - if (POPI() < 0) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_ifge: - { - jint offset = get2s (pc); - if (POPI() >= 0) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_ifgt: - { - jint offset = get2s (pc); - if (POPI() > 0) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_ifle: - { - jint offset = get2s (pc); - if (POPI() <= 0) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_icmpeq: - { - jint offset = get2s (pc); - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 == value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_icmpne: - { - jint offset = get2s (pc); - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 != value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_icmplt: - { - jint offset = get2s (pc); - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 < value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_icmpge: - { - jint offset = get2s (pc); - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 >= value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_icmpgt: - { - jint offset = get2s (pc); - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 > value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_icmple: - { - jint offset = get2s (pc); - jint value2 = POPI(); - jint value1 = POPI(); - if (value1 <= value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_acmpeq: - { - jint offset = get2s (pc); - jobject value2 = POPA(); - jobject value1 = POPA(); - if (value1 == value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_if_acmpne: - { - jint offset = get2s (pc); - jobject value2 = POPA(); - jobject value1 = POPA(); - if (value1 != value2) - pc = pc-1+offset; - else - pc = pc+2; - } - NEXT_INSN; - - insn_goto: - { - jint offset = get2s (pc); - pc = pc-1+offset; - } - NEXT_INSN; - - insn_jsr: - { - unsigned char *base_pc = pc-1; - jint offset = get2s (pc); pc += 2; - PUSHA ((jobject)pc); - pc = base_pc+offset; - } - NEXT_INSN; - - insn_ret: - { - jint index = get1u (pc); - pc = (unsigned char*) PEEKA (index); - } - NEXT_INSN; - - insn_tableswitch: - { - unsigned char *base_pc = pc-1; - int index = POPI(); - - unsigned char* base = 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)); - } - NEXT_INSN; - - insn_lookupswitch: - { - 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) - max = half-1; - - else - 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; - } - NEXT_INSN; - - /* on return, just save the sp and return to caller */ - insn_ireturn: - insn_lreturn: - insn_freturn: - insn_dreturn: - insn_areturn: - insn_return: - inv->sp = sp; - return; - - insn_getstatic: - SAVE_PC; - { - jint fieldref_index = get2u (pc); pc += 2; - _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; - - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - PUSHI (*(jbyte*) (field->u.addr)); - break; - - case 2: - if (type == JvPrimClass (char)) - PUSHI(*(jchar*) (field->u.addr)); - else - PUSHI(*(jshort*) (field->u.addr)); - break; - - case 4: - PUSHI(*(jint*) (field->u.addr)); - break; - - case 8: - PUSHL(*(jlong*) (field->u.addr)); - break; - } - } - else - { - PUSHA(*(jobject*) (field->u.addr)); - } - } - NEXT_INSN; - - insn_getfield: - SAVE_PC; - { - jint fieldref_index = get2u (pc); pc += 2; - _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); - - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - PUSHI (*(jbyte*) ((char*)obj + field_offset)); - break; - - case 2: - if (type == JvPrimClass (char)) - PUSHI (*(jchar*) ((char*)obj + field_offset)); - else - PUSHI (*(jshort*) ((char*)obj + field_offset)); - break; - - case 4: - PUSHI (*(jint*) ((char*)obj + field_offset)); - break; - - case 8: - PUSHL(*(jlong*) ((char*)obj + field_offset)); - break; - } - } - else - { - PUSHA(*(jobject*) ((char*)obj + field_offset)); - } - } - NEXT_INSN; - - insn_putstatic: - SAVE_PC; - { - jint fieldref_index = get2u (pc); pc += 2; - _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")); - - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - { - jint value = POPI(); - *(jbyte*) (field->u.addr) = value; - break; - } - - case 2: - { - jint value = POPI(); - *(jchar*) (field->u.addr) = value; - break; - } - - case 4: - { - jint value = POPI(); - *(jint*) (field->u.addr) = value; - break; - } - - case 8: - { - jlong value = POPL(); - *(jlong*) (field->u.addr) = value; - break; - } - } - } - else - { - jobject value = POPA(); - *(jobject*) (field->u.addr) = value; - } - } - NEXT_INSN; - - - insn_putfield: - SAVE_PC; - { - jint fieldref_index = get2u (pc); pc += 2; - _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; - - if (type->isPrimitive ()) - { - switch (type->size_in_bytes) - { - case 1: - { - jint value = POPI(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jbyte*) ((char*)obj + field_offset) = value; - break; - } - - case 2: - { - jint value = POPI(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jchar*) ((char*)obj + field_offset) = value; - break; - } - - case 4: - { - jint value = POPI(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jint*) ((char*)obj + field_offset) = value; - break; - } - - case 8: - { - jlong value = POPL(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jlong*) ((char*)obj + field_offset) = value; - break; - } - } - } - else - { - jobject value = POPA(); - jobject obj = POPA(); - NULLCHECK(obj); - *(jobject*) ((char*)obj + field_offset) = value; - } - } - NEXT_INSN; - - insn_invokespecial: - SAVE_PC; - { - int index = get2u (pc); pc += 2; - - rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod; - - sp -= rmeth->stack_item_count; - - NULLCHECK (sp[0].o); - - fun = (void (*)()) rmeth->method->ncode; - } - goto perform_invoke; - - insn_invokestatic: - SAVE_PC; - { - int index = get2u (pc); pc += 2; - - rmeth = (_Jv_ResolvePoolEntry (defining_class, index)).rmethod; - - sp -= rmeth->stack_item_count; - - _Jv_InitClass (rmeth->klass); - fun = (void (*)()) rmeth->method->ncode; - } - goto perform_invoke; - - insn_invokeinterface: - SAVE_PC; - { - int index = get2u (pc); pc += 2; - - // invokeinterface has two unused bytes... - pc += 2; - - 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); - } - goto perform_invoke; - - - insn_new: - SAVE_PC; - { - int index = get2u (pc); pc += 2; - jclass klass = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - _Jv_InitClass (klass); - jobject res = _Jv_AllocObject (klass, klass->size_in_bytes); - PUSHA (res); - } - NEXT_INSN; - - insn_newarray: - SAVE_PC; - { - int atype = get1u (pc++); - int size = POPI(); - jobject result = _Jv_NewArray (atype, size); - PUSHA (result); - } - NEXT_INSN; - - insn_anewarray: - SAVE_PC; - { - int index = get2u (pc); pc += 2; - jclass klass = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - int size = POPI(); - _Jv_InitClass (klass); - jobject result = _Jv_NewObjectArray (size, klass, 0); - PUSHA (result); - } - NEXT_INSN; - - insn_arraylength: - SAVE_PC; - { - __JArray *arr = (__JArray*)POPA(); - PUSHI (arr->length); - } - NEXT_INSN; - - insn_athrow: - SAVE_PC; - { - jobject value = POPA(); - throw static_cast(value); - } - NEXT_INSN; - - insn_checkcast: - SAVE_PC; - { - jobject value = POPA(); - jint index = get2u (pc); pc += 2; - jclass to = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - - if (value != NULL && ! to->isInstance (value)) - { - throw new java::lang::ClassCastException (to->getName()); - } - - PUSHA (value); - } - NEXT_INSN; - - insn_instanceof: - SAVE_PC; - { - jobject value = POPA(); - jint index = get2u (pc); pc += 2; - jclass to = (_Jv_ResolvePoolEntry (defining_class, index)).clazz; - PUSHI (to->isInstance (value)); - } - 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] == breakpoint_insn); +#endif + } - insn_monitorenter: - SAVE_PC; - { - jobject value = POPA(); - NULLCHECK(value); - _Jv_MonitorEnter (value); - } - NEXT_INSN; + return false; +} - insn_monitorexit: - SAVE_PC; - { - jobject value = POPA(); - NULLCHECK(value); - _Jv_MonitorExit (value); - } - NEXT_INSN; +void * +_Jv_JNIMethod::ncode (jclass klass) +{ + using namespace java::lang::reflect; - insn_ifnull: - { - unsigned char* base_pc = pc-1; - jint offset = get2s (pc); pc += 2; - jobject val = POPA(); - if (val == NULL) - pc = base_pc+offset; - } - 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_ifnonnull: - { - unsigned char* base_pc = pc-1; - jint offset = get2s (pc); pc += 2; - jobject val = POPA(); - if (val != NULL) - pc = base_pc+offset; - } - 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_wide: - SAVE_PC; - { - jint the_mod_op = get1u (pc++); - jint wide = get2u (pc); pc += 2; +static void +throw_class_format_error (const char *msg) +{ + throw_class_format_error (JvNewStringLatin1 (msg)); +} - switch (the_mod_op) - { - case op_istore: - STOREI (wide); - 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. - case op_fstore: - STOREF (wide); - NEXT_INSN; + 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; - case op_astore: - STOREA (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_lload: - LOADL (wide); - NEXT_INSN; + frame = frame->next_interp; + } +} - case op_dload: - LOADD (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_iload: - LOADI (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_aload: - LOADA (wide); - NEXT_INSN; + - case op_lstore: - STOREL (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_dstore: - STORED (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_ret: - pc = (unsigned char*) PEEKA (wide); - NEXT_INSN; +_Jv_ClosureList ** +_Jv_InterpreterEngine::do_get_closure_list (jclass klass) +{ + _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info; - case op_iinc: - { - jint amount = get2s (pc); pc += 2; - jint value = PEEKI (wide); - POKEI (wide, value+amount); - } - NEXT_INSN; + if (!iclass->closures) + iclass->closures = _Jv_ClosureListFinalizer (); - default: - throw_internal_error ("illegal bytecode modified by wide"); - } + return iclass->closures; +} - } +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]; - insn_multianewarray: - SAVE_PC; - { - int kind_index = get2u (pc); pc += 2; - int dim = get1u (pc); pc += 1; + if ((field->flags & java::lang::reflect::Modifier::STATIC) == 0) + continue; - jclass type - = (_Jv_ResolvePoolEntry (defining_class, kind_index)).clazz; - _Jv_InitClass (type); - jint *sizes = (jint*) __builtin_alloca (sizeof (jint)*dim); + char *base = field->isRef() ? reference_fields : non_reference_fields; + field->u.addr = base + field->u.boffset; - for (int i = dim - 1; i >= 0; i--) - { - sizes[i] = POPI (); - } + if (iclass->field_initializers[i] != 0) + { + _Jv_Linker::resolve_field (field, klass->loader); + _Jv_InitField (0, klass, i); + } + } - jobject res = _Jv_NewMultiArray (type,dim, sizes); + // Now we don't need the field_initializers anymore, so let the + // collector get rid of it. + iclass->field_initializers = 0; +} - PUSHA (res); - } - NEXT_INSN; +_Jv_ResolvedMethod * +_Jv_InterpreterEngine::do_resolve_method (_Jv_Method *method, jclass klass, + jboolean staticp) +{ + int arg_count = _Jv_count_arguments (method->signature, staticp); - insn_goto_w: - { - unsigned char* base_pc = pc-1; - int offset = get4 (pc); pc += 4; - pc = base_pc+offset; - } - NEXT_INSN; + _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*) + _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod) + + arg_count*sizeof (ffi_type*)); - insn_jsr_w: - { - unsigned char* base_pc = pc-1; - int offset = get4 (pc); pc += 4; - PUSHA((jobject)pc); - pc = base_pc+offset; - } - NEXT_INSN; -} + 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; -static void -throw_internal_error (char *msg) -{ - throw new java::lang::InternalError (JvNewStringLatin1 (msg)); + 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