// interpret.cc - Code for the interpreter
-/* Copyright (C) 1999, 2000, 2001 , 2002 Free Software Foundation
+/* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation
This file is part of libgcj.
/* Author: Kresten Krab Thorup <krab@gnu.org> */
#include <config.h>
+#include <platform.h>
#pragma implementation "java-interp.h"
#include <jvm.h>
#include <java-cpool.h>
#include <java-interp.h>
-// #include <java/lang/fdlibm.h>
#include <java/lang/System.h>
#include <java/lang/String.h>
#include <java/lang/Integer.h>
#include <java/lang/StringBuffer.h>
#include <java/lang/Class.h>
#include <java/lang/reflect/Modifier.h>
-#include <java/lang/ClassCastException.h>
-#include <java/lang/VirtualMachineError.h>
#include <java/lang/InternalError.h>
#include <java/lang/NullPointerException.h>
#include <java/lang/ArithmeticException.h>
#include <java/lang/IncompatibleClassChangeError.h>
+#include <java/lang/InstantiationException.h>
+#include <java/lang/Thread.h>
#include <java-insns.h>
#include <java-signal.h>
+#include <java/lang/ClassFormatError.h>
+#include <execution.h>
+#include <java/lang/reflect/Modifier.h>
+
+#include <jvmti.h>
+#include "jvmti-int.h"
+
+#include <gnu/classpath/jdwp/Jdwp.h>
+#include <gnu/gcj/jvmti/Breakpoint.h>
+#include <gnu/gcj/jvmti/BreakpointManager.h>
#ifdef INTERPRETER
+// Execution engine for interpreted code.
+_Jv_InterpreterEngine _Jv_soleInterpreterEngine;
+
#include <stdlib.h>
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__));
+
+#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;
+
+void
+_Jv_InitInterpreter()
+{
+ _Jv_MutexInit (&compile_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<unsigned char> (op_breakpoint);
+pc_t _Jv_InterpMethod::breakpoint_insn = &_Jv_InterpMethod::bp_insn_opcode;
#endif
extern "C" double __ieee754_fmod (double,double);
{
sp[top-(n+x)-i] = sp[top-i];
}
-
-};
+}
// Used to convert from floating types to integral types.
template<typename TO, typename FROM>
# 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 { \
+ DEBUG_LOCALS_INSN (I, 'o'); \
+ locals[I].o = (--sp)->o; \
+ } while (0)
+#define STOREI(I) \
+ do { \
+ DEBUG_LOCALS_INSN (I, 'i'); \
+ locals[I].i = (--sp)->i; \
+ } while (0)
+#define STOREF(I) \
+ do { \
+ DEBUG_LOCALS_INSN (I, 'f'); \
+ locals[I].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 { \
+ DEBUG_LOCALS_INSN (I, 'l'); \
+ (sp -= 2, locals[I].l = sp->l); \
+ } while (0)
+# define STORED(I) \
+ do { \
+ DEBUG_LOCALS_INSN (I, 'd'); \
+ (sp -= 2, locals[I].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 { \
+ DEBUG_LOCALS_INSN (I, 'l'); \
+ jint __idx = (I); \
+ locals[__idx+1].ia[0] = (--sp)->ia[0]; \
+ locals[__idx].ia[0] = (--sp)->ia[0]; \
+ } while (0)
+# define STORED(I) \
+ do { \
+ DEBUG_LOCALS_INSN(I, 'd'); \
+ jint __idx = (I); \
+ 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) \
+ DEBUG_LOCALS_INSN(I,'i'); \
+ ((locals+(I))->i = (V))
#define BINOPI(OP) { \
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) do { SAVE_PC; } while (0)
+#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) { SAVE_PC; 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)
-
-// 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,
+ ffi_raw *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);
-
- next_segment:
-
- jobject ex = NULL;
-
- try
- {
- continue1 (inv);
- }
- catch (java::lang::Throwable *ex2)
- {
- ex = ex2;
- }
-
- 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;
-
- 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");
- }
- }
-
- /** handle an exception */
- if ( find_exception (ex, inv) )
- goto next_segment;
-
- return ex;
+ _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+ run (ret, args, _this);
}
-#define SAVE_PC inv->pc = pc
-
-bool _Jv_InterpMethod::find_exception (jobject ex,
- _Jv_InterpMethodInvocation *inv)
+void
+_Jv_InterpMethod::run_normal_debug (ffi_cif *,
+ void *ret,
+ ffi_raw *args,
+ void *__this)
{
- // We subtract one because the PC was incremented before it was
- // saved.
- int logical_pc = inv->pc - 1 - 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;
-
- 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;
+ _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+ 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_object (ffi_cif *,
+ void *ret,
+ ffi_raw *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));
+ jobject rcv = (jobject) args[0].ptr;
+ JvSynchronize mutex (rcv);
- jobject ex = _this->run (cif, ret, args, inv);
- if (ex != 0) throw static_cast<jthrowable>(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_object_debug (ffi_cif *,
+ void *ret,
+ ffi_raw *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));
+ jobject rcv = (jobject) args[0].ptr;
+ JvSynchronize mutex (rcv);
- _Jv_MonitorEnter (rcv);
- jobject ex = _this->run (cif, ret, args, inv);
- _Jv_MonitorExit (rcv);
+ run_debug (ret, args, _this);
+}
- if (ex != 0) throw static_cast<jthrowable>(ex);
+void
+_Jv_InterpMethod::run_class (ffi_cif *,
+ void *ret,
+ ffi_raw *args,
+ void *__this)
+{
+ _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+ _Jv_InitClass (_this->defining_class);
+ run (ret, args, _this);
}
-void _Jv_InterpMethod::run_synch_class (ffi_cif* cif,
- void* ret,
- ffi_raw * args,
- void* __this)
+void
+_Jv_InterpMethod::run_class_debug (ffi_cif *,
+ void *ret,
+ ffi_raw *args,
+ void *__this)
{
- _Jv_InterpMethod* _this = (_Jv_InterpMethod*)__this;
- jclass sync = _this->defining_class;
+ _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+ _Jv_InitClass (_this->defining_class);
+ run_debug (ret, args, _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));
+void
+_Jv_InterpMethod::run_synch_class (ffi_cif *,
+ void *ret,
+ ffi_raw *args,
+ void *__this)
+{
+ _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
- _Jv_MonitorEnter (sync);
- jobject ex = _this->run (cif, ret, args, inv);
- _Jv_MonitorExit (sync);
+ jclass sync = _this->defining_class;
+ _Jv_InitClass (sync);
+ JvSynchronize mutex (sync);
- if (ex != 0) throw static_cast<jthrowable>(ex);
+ run (ret, args, _this);
}
-/*
- 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.
+void
+_Jv_InterpMethod::run_synch_class_debug (ffi_cif *,
+ void *ret,
+ ffi_raw *args,
+ void *__this)
+{
+ _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
- 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.
-*/
+ jclass sync = _this->defining_class;
+ _Jv_InitClass (sync);
+ JvSynchronize mutex (sync);
+ run_debug (ret, args, _this);
+}
-void _Jv_InterpMethod::continue1 (_Jv_InterpMethodInvocation *inv)
+#ifdef DIRECT_THREADED
+// "Compile" a method by turning it from bytecode to direct-threaded
+// code.
+void
+_Jv_InterpMethod::compile (const void * const *insn_targets)
{
- using namespace java::lang::reflect;
-
- _Jv_word *sp = inv->sp;
- unsigned char *pc = inv->pc;
- _Jv_word *locals = inv->local_base ();
-
- _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),
- };
-
- /* 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
+ 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 NEXT_INSN goto next_insn
+#define SET_ONE(Field, Value) \
+ do \
+ { \
+ if (first_pass) \
+ ++next; \
+ else \
+ insns[next++].Field = Value; \
+ } \
+ while (0)
- next_insn:
- GOTO_INSN (*pc++);
+#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)
-#endif
+ // 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;
- /* The first few instructions here are ordered according to their
- frequency, in the hope that this will improve code locality a
- little. */
+ for (int i = 0; i < 2; ++i)
+ {
+ jboolean first_pass = i == 0;
- insn_aload_0: // 0x2a
- LOADA(0);
- NEXT_INSN;
+ if (! first_pass)
+ {
+ insns = (insn_slot *) _Jv_AllocBytes (sizeof (insn_slot) * next);
+ number_insn_slots = next;
+ next = 0;
+ }
- insn_iload: // 0x15
- LOADI (get1u (pc++));
- NEXT_INSN;
+ unsigned char *pc = codestart;
+ while (pc < end)
+ {
+ int base_pc_val = pc - codestart;
+ if (first_pass)
+ pc_mapping[base_pc_val] = next;
- insn_iload_1: // 0x1b
- LOADI (1);
- NEXT_INSN;
+ java_opcode opcode = (java_opcode) *pc++;
+ // Just elide NOPs.
+ if (opcode == op_nop)
+ continue;
+ SET_INSN (insn_targets[opcode]);
- 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;
+ 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;
- perform_invoke:
- {
- /* here goes the magic again... */
- ffi_cif *cif = &rmeth->cif;
- ffi_raw *raw = (ffi_raw*) sp;
+ 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;
- jdouble rvalue;
+ 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;
-#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
+ 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;
- 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 op_invokeinterface:
+ {
+ jint index = get2u (pc);
+ pc += 2;
+ // We ignore the next two bytes.
+ pc += 2;
+ SET_INT (index);
+ }
+ break;
- case FFI_TYPE_SINT16:
- {
- jshort value = (*(jint*)&rvalue) & 0xffff;
- PUSHI (value);
- }
- break;
+ 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;
- case FFI_TYPE_UINT16:
- {
- jint value = (*(jint*)&rvalue) & 0xffff;
- PUSHI (value);
+ 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;
}
- break;
+ }
+ }
- case FFI_TYPE_FLOAT:
- PUSHF (*(jfloat*)&rvalue);
- break;
+ // 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;
+ }
- case FFI_TYPE_DOUBLE:
- PUSHD (rvalue);
- break;
+ // 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]];
+ }
- case FFI_TYPE_SINT64:
- PUSHL (*(jlong*)&rvalue);
- break;
+ prepared = insns;
- default:
- throw_internal_error ("unknown return type in invokeXXX");
- }
+ if (breakpoint_insn == NULL)
+ {
+ bp_insn_slot.insn = const_cast<void *> (insn_targets[op_breakpoint]);
+ breakpoint_insn = &bp_insn_slot;
+ }
+}
+#endif /* DIRECT_THREADED */
- }
- NEXT_INSN;
+/* Run the given method.
+ When args is NULL, don't run anything -- just compile it. */
+void
+_Jv_InterpMethod::run (void *retp, ffi_raw *args, _Jv_InterpMethod *meth)
+{
+#undef DEBUG
+#undef DEBUG_LOCALS_INSN
+#define DEBUG_LOCALS_INSN(s, t) do {} while(0)
+#include "interpret-run.cc"
+}
- insn_nop:
- NEXT_INSN;
+void
+_Jv_InterpMethod::run_debug (void *retp, ffi_raw *args, _Jv_InterpMethod *meth)
+{
+#define DEBUG
+#undef DEBUG_LOCALS_INSN
+#define DEBUG_LOCALS_INSN(s, t) do {} while(0)
- insn_aconst_null:
- PUSHA (NULL);
- NEXT_INSN;
+#include "interpret-run.cc"
+}
- insn_iconst_m1:
- PUSHI (-1);
- NEXT_INSN;
+static void
+throw_internal_error (const char *msg)
+{
+ throw new java::lang::InternalError (JvNewStringLatin1 (msg));
+}
- insn_iconst_0:
- PUSHI (0);
- NEXT_INSN;
+static void
+throw_incompatible_class_change_error (jstring msg)
+{
+ throw new java::lang::IncompatibleClassChangeError (msg);
+}
- insn_iconst_1:
- PUSHI (1);
- NEXT_INSN;
+static void
+throw_null_pointer_exception ()
+{
+ throw new java::lang::NullPointerException;
+}
- insn_iconst_2:
- PUSHI (2);
- NEXT_INSN;
+/* 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;
+}
- insn_iconst_3:
- PUSHI (3);
- NEXT_INSN;
+/** Do static initialization for fields with a constant initializer */
+void
+_Jv_InitField (jobject obj, jclass klass, int index)
+{
+ using namespace java::lang::reflect;
- insn_iconst_4:
- PUSHI (4);
- NEXT_INSN;
+ if (obj != 0 && klass == 0)
+ klass = obj->getClass ();
- insn_iconst_5:
- PUSHI (5);
- NEXT_INSN;
+ if (!_Jv_IsInterpretedClass (klass))
+ return;
- insn_lconst_0:
- PUSHL (0);
- NEXT_INSN;
+ _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
- insn_lconst_1:
- PUSHL (1);
- NEXT_INSN;
+ _Jv_Field * field = (&klass->fields[0]) + index;
- insn_fconst_0:
- PUSHF (0);
- NEXT_INSN;
+ if (index > klass->field_count)
+ throw_internal_error ("field out of range");
- insn_fconst_1:
- PUSHF (1);
- NEXT_INSN;
+ int init = iclass->field_initializers[index];
+ if (init == 0)
+ return;
- insn_fconst_2:
- PUSHF (2);
- NEXT_INSN;
+ _Jv_Constants *pool = &klass->constants;
+ int tag = pool->tags[init];
- insn_dconst_0:
- PUSHD (0);
- NEXT_INSN;
+ if (! field->isResolved ())
+ throw_internal_error ("initializing unresolved field");
- insn_dconst_1:
- PUSHD (1);
- NEXT_INSN;
+ if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
+ throw_internal_error ("initializing non-static field with no object");
- insn_bipush:
- PUSHI (get1s(pc++));
- NEXT_INSN;
+ void *addr = 0;
- insn_sipush:
- PUSHI (get2s(pc)); pc += 2;
- NEXT_INSN;
+ if ((field->flags & Modifier::STATIC) != 0)
+ addr = (void*) field->u.addr;
+ else
+ addr = (void*) (((char*)obj) + field->u.boffset);
- insn_ldc:
+ switch (tag)
+ {
+ case JV_CONSTANT_String:
{
- int index = get1u (pc++);
- PUSHA(pool_data[index].o);
+ jstring str;
+ str = _Jv_NewStringUtf8Const (pool->data[init].utf8);
+ pool->data[init].string = str;
+ pool->tags[init] = JV_CONSTANT_ResolvedString;
}
- NEXT_INSN;
+ /* fall through */
- insn_ldc_w:
- {
- int index = get2u (pc); pc += 2;
- PUSHA(pool_data[index].o);
- }
- 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_ldc2_w:
+ *(jstring*)addr = pool->data[init].string;
+ break;
+
+ case JV_CONSTANT_Integer:
{
- int index = get2u (pc); pc += 2;
- memcpy (sp, &pool_data[index], 2*sizeof (_Jv_word));
- sp += 2;
- }
- NEXT_INSN;
+ int value = pool->data[init].i;
- insn_lload:
- LOADL (get1u (pc++));
- 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_fload:
- LOADF (get1u (pc++));
- NEXT_INSN;
+ else if (field->type == JvPrimClass (short))
+ *(jshort*)addr = (jshort)value;
+
+ else if (field->type == JvPrimClass (int))
+ *(jint*)addr = (jint)value;
- insn_dload:
- LOADD (get1u (pc++));
- NEXT_INSN;
+ else
+ throw_class_format_error ("erroneous field initializer");
+ }
+ break;
- insn_aload:
- LOADA (get1u (pc++));
- NEXT_INSN;
+ case JV_CONSTANT_Long:
+ if (field->type != JvPrimClass (long))
+ throw_class_format_error ("erroneous field initializer");
- insn_iload_0:
- LOADI (0);
- NEXT_INSN;
+ *(jlong*)addr = _Jv_loadLong (&pool->data[init]);
+ break;
- insn_iload_2:
- LOADI (2);
- NEXT_INSN;
+ case JV_CONSTANT_Float:
+ if (field->type != JvPrimClass (float))
+ throw_class_format_error ("erroneous field initializer");
- insn_iload_3:
- LOADI (3);
- NEXT_INSN;
+ *(jfloat*)addr = pool->data[init].f;
+ break;
- insn_lload_0:
- LOADL (0);
- NEXT_INSN;
+ case JV_CONSTANT_Double:
+ if (field->type != JvPrimClass (double))
+ throw_class_format_error ("erroneous field initializer");
- insn_lload_1:
- LOADL (1);
- NEXT_INSN;
+ *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]);
+ break;
- insn_lload_2:
- LOADL (2);
- NEXT_INSN;
+ default:
+ throw_class_format_error ("erroneous field initializer");
+ }
+}
- insn_lload_3:
- LOADL (3);
- NEXT_INSN;
+inline static unsigned char*
+skip_one_type (unsigned char* ptr)
+{
+ int ch = *ptr++;
- insn_fload_0:
- LOADF (0);
- NEXT_INSN;
+ while (ch == '[')
+ {
+ ch = *ptr++;
+ }
+
+ if (ch == 'L')
+ {
+ do { ch = *ptr++; } while (ch != ';');
+ }
- insn_fload_1:
- LOADF (1);
- NEXT_INSN;
+ return ptr;
+}
- insn_fload_2:
- LOADF (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_fload_3:
- LOADF (3);
- 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_dload_0:
- LOADD (0);
- NEXT_INSN;
+ case 'V':
+ return &ffi_type_void;
+ break;
+ }
- insn_dload_1:
- LOADD (1);
- NEXT_INSN;
+ throw_internal_error ("unknown type in signature");
+}
- insn_dload_2:
- LOADD (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_dload_3:
- LOADD (3);
- 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_aload_1:
- LOADA(1);
- NEXT_INSN;
+ /* first, count number of arguments */
- insn_aload_2:
- LOADA(2);
- NEXT_INSN;
+ // skip '('
+ ptr++;
- insn_aload_3:
- LOADA(3);
- NEXT_INSN;
+ // count args
+ while (*ptr != ')')
+ {
+ ptr = skip_one_type (ptr);
+ arg_count += 1;
+ }
- insn_iaload:
- {
- jint index = POPI();
- jintArray arr = (jintArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHI( elements(arr)[index] );
- }
- NEXT_INSN;
+ return arg_count;
+}
- insn_laload:
- {
- jint index = POPI();
- jlongArray arr = (jlongArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHL( elements(arr)[index] );
- }
- 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_faload:
- {
- jint index = POPI();
- jfloatArray arr = (jfloatArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHF( elements(arr)[index] );
- }
- NEXT_INSN;
+ int arg_index = 0; // arg number
+ int item_count = 0; // stack-item count
- insn_daload:
- {
- jint index = POPI();
- jdoubleArray arr = (jdoubleArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHD( elements(arr)[index] );
- }
- NEXT_INSN;
+ // setup receiver
+ if (!staticp)
+ {
+ arg_types[arg_index++] = &ffi_type_pointer;
+ item_count += 1;
+ }
- insn_aaload:
- {
- jint index = POPI();
- jobjectArray arr = (jobjectArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHA( elements(arr)[index] );
- }
- NEXT_INSN;
+ // skip '('
+ ptr++;
- insn_baload:
- {
- jint index = POPI();
- jbyteArray arr = (jbyteArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHI( elements(arr)[index] );
- }
- NEXT_INSN;
+ // assign arg types
+ while (*ptr != ')')
+ {
+ arg_types[arg_index++] = get_ffi_type_from_signature (ptr);
- insn_caload:
- {
- jint index = POPI();
- jcharArray arr = (jcharArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHI( elements(arr)[index] );
- }
- NEXT_INSN;
+ if (*ptr == 'J' || *ptr == 'D')
+ item_count += 2;
+ else
+ item_count += 1;
- insn_saload:
- {
- jint index = POPI();
- jshortArray arr = (jshortArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- PUSHI( elements(arr)[index] );
- }
- NEXT_INSN;
+ ptr = skip_one_type (ptr);
+ }
- insn_istore:
- STOREI (get1u (pc++));
- NEXT_INSN;
+ // skip ')'
+ ptr++;
+ ffi_type *rtype = get_ffi_type_from_signature (ptr);
- insn_lstore:
- STOREL (get1u (pc++));
- 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_fstore:
- STOREF (get1u (pc++));
- 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_dstore:
- STORED (get1u (pc++));
- NEXT_INSN;
+ if (rtype_p != NULL)
+ *rtype_p = rtype;
- insn_astore:
- STOREA (get1u (pc++));
- NEXT_INSN;
+ return item_count;
+}
- insn_istore_0:
- STOREI (0);
- NEXT_INSN;
+#if FFI_NATIVE_RAW_API
+# define FFI_PREP_RAW_CLOSURE ffi_prep_raw_closure
+# define FFI_RAW_SIZE ffi_raw_size
+#else
+# define FFI_PREP_RAW_CLOSURE ffi_prep_java_raw_closure
+# define FFI_RAW_SIZE ffi_java_raw_size
+#endif
- insn_istore_1:
- STOREI (1);
- 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_istore_2:
- STOREI (2);
- NEXT_INSN;
+typedef struct {
+ ffi_raw_closure closure;
+ ffi_cif cif;
+ ffi_type *arg_types[0];
+} ncode_closure;
- insn_istore_3:
- STOREI (3);
- NEXT_INSN;
+typedef void (*ffi_closure_fun) (ffi_cif*,void*,ffi_raw*,void*);
- insn_lstore_0:
- STOREL (0);
- NEXT_INSN;
+void *
+_Jv_InterpMethod::ncode ()
+{
+ using namespace java::lang::reflect;
- insn_lstore_1:
- STOREL (1);
- NEXT_INSN;
+ if (self->ncode != 0)
+ return self->ncode;
- insn_lstore_2:
- STOREL (2);
- NEXT_INSN;
+ jboolean staticp = (self->accflags & Modifier::STATIC) != 0;
+ int arg_count = _Jv_count_arguments (self->signature, staticp);
- insn_lstore_3:
- STOREL (3);
- NEXT_INSN;
+ ncode_closure *closure =
+ (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
+ + arg_count * sizeof (ffi_type*));
- insn_fstore_0:
- STOREF (0);
- NEXT_INSN;
+ _Jv_init_cif (self->signature,
+ arg_count,
+ staticp,
+ &closure->cif,
+ &closure->arg_types[0],
+ NULL);
- insn_fstore_1:
- STOREF (1);
- NEXT_INSN;
+ ffi_closure_fun fun;
- insn_fstore_2:
- STOREF (2);
- NEXT_INSN;
+ args_raw_size = FFI_RAW_SIZE (&closure->cif);
- insn_fstore_3:
- STOREF (3);
- NEXT_INSN;
+ JvAssert ((self->accflags & Modifier::NATIVE) == 0);
- insn_dstore_0:
- STORED (0);
- NEXT_INSN;
+ if ((self->accflags & Modifier::SYNCHRONIZED) != 0)
+ {
+ if (staticp)
+ {
+ if (::gnu::classpath::jdwp::Jdwp::isDebugging)
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class_debug;
+ else
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_class;
+ }
+ else
+ {
+ if (::gnu::classpath::jdwp::Jdwp::isDebugging)
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object_debug;
+ else
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_synch_object;
+ }
+ }
+ else
+ {
+ if (staticp)
+ {
+ if (::gnu::classpath::jdwp::Jdwp::isDebugging)
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class_debug;
+ else
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_class;
+ }
+ else
+ {
+ if (::gnu::classpath::jdwp::Jdwp::isDebugging)
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal_debug;
+ else
+ fun = (ffi_closure_fun)&_Jv_InterpMethod::run_normal;
+ }
+ }
- insn_dstore_1:
- STORED (1);
- NEXT_INSN;
+ FFI_PREP_RAW_CLOSURE (&closure->closure,
+ &closure->cif,
+ fun,
+ (void*)this);
- insn_dstore_2:
- STORED (2);
- NEXT_INSN;
+ self->ncode = (void*)closure;
+ return self->ncode;
+}
- insn_dstore_3:
- STORED (3);
- 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_astore_0:
- STOREA(0);
- 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_astore_1:
- STOREA(1);
- NEXT_INSN;
+ return -1;
+}
- insn_astore_2:
- STOREA(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_astore_3:
- STOREA(3);
- NEXT_INSN;
+pc_t
+_Jv_InterpMethod::install_break (jlong index)
+{
+ return set_insn (index, breakpoint_insn);
+}
- insn_iastore:
- {
- jint value = POPI();
- jint index = POPI();
- jintArray arr = (jintArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- elements(arr)[index] = value;
- }
- NEXT_INSN;
+pc_t
+_Jv_InterpMethod::get_insn (jlong index)
+{
+ pc_t code;
- insn_lastore:
- {
- jlong value = POPL();
- jint index = POPI();
- jlongArray arr = (jlongArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- elements(arr)[index] = value;
- }
- NEXT_INSN;
+#ifdef DIRECT_THREADED
+ if (index >= number_insn_slots || index < 0)
+ return NULL;
- insn_fastore:
- {
- jfloat value = POPF();
- jint index = POPI();
- jfloatArray arr = (jfloatArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- elements(arr)[index] = value;
- }
- NEXT_INSN;
+ code = prepared;
+#else // !DIRECT_THREADED
+ if (index >= code_length || index < 0)
+ return NULL;
- insn_dastore:
- {
- jdouble value = POPD();
- jint index = POPI();
- jdoubleArray arr = (jdoubleArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- elements(arr)[index] = value;
- }
- NEXT_INSN;
+ code = reinterpret_cast<pc_t> (bytecode ());
+#endif // !DIRECT_THREADED
- 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;
+ return &code[index];
+}
- insn_bastore:
- {
- jbyte value = (jbyte) POPI();
- jint index = POPI();
- jbyteArray arr = (jbyteArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- elements(arr)[index] = value;
- }
- 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_castore:
- {
- jchar value = (jchar) POPI();
- jint index = POPI();
- jcharArray arr = (jcharArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- elements(arr)[index] = value;
- }
- NEXT_INSN;
+ pc_t code = prepared;
+ code[index].insn = insn->insn;
+#else // !DIRECT_THREADED
+ if (index >= code_length || index < 0)
+ return NULL;
- insn_sastore:
- {
- jshort value = (jshort) POPI();
- jint index = POPI();
- jshortArray arr = (jshortArray) POPA();
- NULLARRAYCHECK (arr);
- ARRAYBOUNDSCHECK (arr, index);
- elements(arr)[index] = value;
- }
- NEXT_INSN;
+ pc_t code = reinterpret_cast<pc_t> (bytecode ());
+ code[index] = *insn;
+#endif // !DIRECT_THREADED
- insn_pop:
- sp -= 1;
- NEXT_INSN;
+ return &code[index];
+}
- insn_pop2:
- sp -= 2;
- NEXT_INSN;
+void *
+_Jv_JNIMethod::ncode ()
+{
+ using namespace java::lang::reflect;
- 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:
- {
- 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:
- 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:
- {
- 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);
- 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:
- {
- 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);
- PUSHI(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:
- 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:
- {
- __JArray *arr = (__JArray*)POPA();
- NULLARRAYCHECK (arr);
- PUSHI (arr->length);
- }
- NEXT_INSN;
-
- insn_athrow:
- SAVE_PC;
- {
- jobject value = POPA();
- throw static_cast<jthrowable>(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;
-
- insn_monitorenter:
- SAVE_PC;
- {
- jobject value = POPA();
- NULLCHECK(value);
- _Jv_MonitorEnter (value);
- }
- NEXT_INSN;
-
- insn_monitorexit:
- SAVE_PC;
- {
- jobject value = POPA();
- NULLCHECK(value);
- _Jv_MonitorExit (value);
- }
- NEXT_INSN;
-
- 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;
-
- 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;
-
- insn_wide:
- SAVE_PC;
- {
- jint the_mod_op = get1u (pc++);
- jint wide = get2u (pc); pc += 2;
-
- switch (the_mod_op)
- {
- case op_istore:
- STOREI (wide);
- NEXT_INSN;
-
- case op_fstore:
- STOREF (wide);
- NEXT_INSN;
-
- case op_astore:
- STOREA (wide);
- NEXT_INSN;
-
- case op_lload:
- LOADL (wide);
- NEXT_INSN;
-
- case op_dload:
- LOADD (wide);
- NEXT_INSN;
-
- case op_iload:
- LOADI (wide);
- NEXT_INSN;
-
- case op_aload:
- LOADA (wide);
- 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);
+
+ ncode_closure *closure =
+ (ncode_closure*)_Jv_AllocBytes (sizeof (ncode_closure)
+ + arg_count * sizeof (ffi_type*));
+
+ 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);
+
+ self->ncode = (void *) closure;
+ return self->ncode;
+}
- case op_lstore:
- STOREL (wide);
- NEXT_INSN;
+static void
+throw_class_format_error (jstring msg)
+{
+ throw (msg
+ ? new java::lang::ClassFormatError (msg)
+ : new java::lang::ClassFormatError);
+}
- case op_dstore:
- STORED (wide);
- NEXT_INSN;
+static void
+throw_class_format_error (const char *msg)
+{
+ throw_class_format_error (JvNewStringLatin1 (msg));
+}
- case op_ret:
- pc = (unsigned char*) PEEKA (wide);
- NEXT_INSN;
+\f
- case op_iinc:
- {
- jint amount = get2s (pc); pc += 2;
- jint value = PEEKI (wide);
- POKEI (wide, value+amount);
- }
- 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);
+ }
+ }
+}
- default:
- throw_internal_error ("illegal bytecode modified by wide");
- }
+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 ();
+ }
+ else if (imeth != 0) // it could be abstract
+ {
+ _Jv_InterpMethod *im = reinterpret_cast<_Jv_InterpMethod *> (imeth);
+ klass->methods[i].ncode = im->ncode ();
+ }
+ }
+}
- }
+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)
+ _Jv_InterpMethod::run (NULL, NULL, method);
}
-#endif
+#endif // DIRECT_THREADED
#endif // INTERPRETER
OSDN Git Service
