obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1944 insertions, 0 deletions

diff --git a/libjava/interpret.cc b/libjava/interpret.cc
new file mode 100644
index 000000000..3f690d7b2
--- /dev/null
+++ b/libjava/interpret.cc
@@ -0,0 +1,1944 @@
+// interpret.cc - Code for the interpreter
+
+/* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+/* 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/System.h>
+#include <java/lang/String.h>
+#include <java/lang/Integer.h>
+#include <java/lang/Long.h>
+#include <java/lang/StringBuffer.h>
+#include <java/lang/Class.h>
+#include <java/lang/reflect/Modifier.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/gcj/jvmti/Breakpoint.h>
+#include <gnu/gcj/jvmti/BreakpointManager.h>
+
+// Execution engine for interpreted code.
+_Jv_InterpreterEngine _Jv_soleInterpreterEngine;
+
+#include <stdlib.h>
+
+using namespace gcj;
+
+static void throw_internal_error (const char *msg)
+  __attribute__ ((__noreturn__));
+static void throw_incompatible_class_change_error (jstring msg)
+  __attribute__ ((__noreturn__));
+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<unsigned char> (op_breakpoint);
+pc_t _Jv_InterpMethod::breakpoint_insn = &_Jv_InterpMethod::bp_insn_opcode;
+#endif
+
+extern "C" double __ieee754_fmod (double,double);
+
+static inline void dupx (_Jv_word *sp, int n, int x)
+{
+  // first "slide" n+x elements n to the right
+  int top = n-1;
+  for (int i = 0; i < n+x; i++)
+    {
+      sp[(top-i)] = sp[(top-i)-n];
+    }
+  
+  // next, copy the n top elements, n+x down
+  for (int i = 0; i < n; i++)
+    {
+      sp[top-(n+x)-i] = sp[top-i];
+    }
+}
+
+// Used to convert from floating types to integral types.
+template<typename TO, typename FROM>
+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)
+#define PUSHF(V)  (sp++)->f = (V)
+#if SIZEOF_VOID_P == 8
+# define PUSHL(V)   (sp->l = (V), sp += 2)
+# define PUSHD(V)   (sp->d = (V), sp += 2)
+#else
+# define PUSHL(V)  do { _Jv_word2 w2; w2.l=(V); \
+                        (sp++)->ia[0] = w2.ia[0]; \
+                        (sp++)->ia[0] = w2.ia[1]; } while (0)
+# define PUSHD(V)  do { _Jv_word2 w2; w2.d=(V); \
+                        (sp++)->ia[0] = w2.ia[0]; \
+                        (sp++)->ia[0] = w2.ia[1]; } while (0)
+#endif
+
+#define POPA()    ((--sp)->o)
+#define POPI()    ((jint) (--sp)->i) // cast since it may be promoted
+#define POPF()    ((jfloat) (--sp)->f)
+#if SIZEOF_VOID_P == 8
+# define POPL()	  (sp -= 2, (jlong) sp->l)
+# define POPD()	  (sp -= 2, (jdouble) sp->d)
+#else
+# define POPL()    ({ _Jv_word2 w2; \
+                     w2.ia[1] = (--sp)->ia[0]; \
+                     w2.ia[0] = (--sp)->ia[0]; w2.l; })
+# define POPD()    ({ _Jv_word2 w2; \
+                     w2.ia[1] = (--sp)->ia[0]; \
+                     w2.ia[0] = (--sp)->ia[0]; w2.d; })
+#endif
+
+#define LOADA(I)  (sp++)->o = locals[I].o
+#define LOADI(I)  (sp++)->i = locals[I].i
+#define LOADF(I)  (sp++)->f = locals[I].f
+#if SIZEOF_VOID_P == 8
+# define LOADL(I)  (sp->l = locals[I].l, sp += 2)
+# define LOADD(I)  (sp->d = locals[I].d, sp += 2)
+#else
+# define LOADL(I)  do { jint __idx = (I); \
+    			(sp++)->ia[0] = locals[__idx].ia[0]; \
+    			(sp++)->ia[0] = locals[__idx+1].ia[0]; \
+ 		   } while (0)
+# define LOADD(I)  LOADL(I)
+#endif
+
+#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) \
+  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);				\
+      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)			\
+  do					\
+    {					\
+      jint __idx = (I);			\
+      DEBUG_LOCALS_INSN (__idx, 'i');	\
+      ((locals + __idx)->i = (V));	\
+    }					\
+  while (0)
+
+
+#define BINOPI(OP) { \
+   jint value2 = POPI(); \
+   jint value1 = POPI(); \
+   PUSHI(value1 OP value2); \
+}
+
+#define BINOPF(OP) { \
+   jfloat value2 = POPF(); \
+   jfloat value1 = POPF(); \
+   PUSHF(value1 OP value2); \
+}
+
+#define BINOPL(OP) { \
+   jlong value2 = POPL(); \
+   jlong value1 = POPL(); \
+   PUSHL(value1 OP value2); \
+}
+
+#define BINOPD(OP) { \
+   jdouble value2 = POPD(); \
+   jdouble value1 = POPD(); \
+   PUSHD(value1 OP value2); \
+}
+
+static inline jint
+get1s (unsigned char* loc)
+{
+  return *(signed char*)loc;
+}
+
+static inline jint
+get1u (unsigned char* loc)
+{
+  return *loc;
+}
+
+static inline jint
+get2s(unsigned char* loc)
+{
+  return (((jint)*(signed char*)loc) << 8) | ((jint)*(loc+1));
+}
+
+static inline jint
+get2u (unsigned char* loc)
+{
+  return (((jint)(*loc)) << 8) | ((jint)*(loc+1));
+}
+
+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 NULLARRAYCHECK(X) SAVE_PC()
+#else
+#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)
+
+void
+_Jv_InterpMethod::run_normal (ffi_cif *,
+			      void *ret,
+			      INTERP_FFI_RAW_TYPE *args,
+			      void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+  run (ret, args, _this);
+}
+
+void
+_Jv_InterpMethod::run_normal_debug (ffi_cif *,
+				    void *ret,
+				    INTERP_FFI_RAW_TYPE *args,
+				    void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+  run_debug (ret, args, _this);
+}
+
+void
+_Jv_InterpMethod::run_synch_object (ffi_cif *,
+				    void *ret,
+				    INTERP_FFI_RAW_TYPE *args,
+				    void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+
+  jobject rcv = (jobject) args[0].ptr;
+  JvSynchronize mutex (rcv);
+
+  run (ret, args, _this);
+}
+
+void
+_Jv_InterpMethod::run_synch_object_debug (ffi_cif *,
+					  void *ret,
+					  INTERP_FFI_RAW_TYPE *args,
+					  void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+
+  jobject rcv = (jobject) args[0].ptr;
+  JvSynchronize mutex (rcv);
+
+  run_debug (ret, args, _this);
+}
+
+void
+_Jv_InterpMethod::run_class (ffi_cif *,
+			     void *ret,
+			     INTERP_FFI_RAW_TYPE *args,
+			     void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+  _Jv_InitClass (_this->defining_class);
+  run (ret, args, _this);
+}
+
+void
+_Jv_InterpMethod::run_class_debug (ffi_cif *,
+				   void *ret,
+				   INTERP_FFI_RAW_TYPE *args,
+				   void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+  _Jv_InitClass (_this->defining_class);
+  run_debug (ret, args, _this);
+}
+
+void
+_Jv_InterpMethod::run_synch_class (ffi_cif *,
+				   void *ret,
+				   INTERP_FFI_RAW_TYPE *args,
+				   void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+
+  jclass sync = _this->defining_class;
+  _Jv_InitClass (sync);
+  JvSynchronize mutex (sync);
+
+  run (ret, args, _this);
+}
+
+void
+_Jv_InterpMethod::run_synch_class_debug (ffi_cif *,
+					 void *ret,
+					 INTERP_FFI_RAW_TYPE *args,
+					 void *__this)
+{
+  _Jv_InterpMethod *_this = (_Jv_InterpMethod *) __this;
+
+  jclass sync = _this->defining_class;
+  _Jv_InitClass (sync);
+  JvSynchronize mutex (sync);
+
+  run_debug (ret, args, _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)
+{
+  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;
+
+      if (! first_pass)
+	{
+	  insns = (insn_slot *) _Jv_AllocBytes (sizeof (insn_slot) * next);
+	  number_insn_slots = next;
+	  next = 0;
+	}
+
+      unsigned char *pc = codestart;
+      while (pc < end)
+	{
+	  int base_pc_val = pc - codestart;
+	  if (first_pass)
+	    pc_mapping[base_pc_val] = next;
+
+	  java_opcode opcode = (java_opcode) *pc++;
+	  // Just elide NOPs.
+	  if (opcode == op_nop)
+	    continue;
+	  SET_INSN (insn_targets[opcode]);
+
+	  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;
+
+	    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;
+
+	    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;
+
+	    case op_invokeinterface:
+	      {
+		jint index = get2u (pc);
+		pc += 2;
+		// We ignore the next two bytes.
+		pc += 2;
+		SET_INT (index);
+	      }
+	      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 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;
+	    }
+	}
+    }
+
+  // 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;
+    }
+
+  // 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<void *> (insn_targets[op_breakpoint]);
+      breakpoint_insn = &bp_insn_slot;
+    }
+}
+#endif /* DIRECT_THREADED */
+
+/* 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)
+
+#include "interpret-run.cc"
+}
+
+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"
+}
+
+static void
+throw_internal_error (const char *msg)
+{
+  jthrowable t = new java::lang::InternalError (JvNewStringLatin1 (msg));
+  REPORT_EXCEPTION (t);
+  throw t;
+}
+
+static void 
+throw_incompatible_class_change_error (jstring msg)
+{
+  jthrowable t = new java::lang::IncompatibleClassChangeError (msg);
+  REPORT_EXCEPTION (t);
+  throw t;
+}
+
+static void 
+throw_null_pointer_exception ()
+{
+  jthrowable t = new java::lang::NullPointerException;
+  REPORT_EXCEPTION (t);
+  throw t;
+}
+
+/* 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;
+}
+
+/** Do static initialization for fields with a constant initializer */
+void
+_Jv_InitField (jobject obj, jclass klass, int index)
+{
+  using namespace java::lang::reflect;
+
+  if (obj != 0 && klass == 0)
+    klass = obj->getClass ();
+
+  if (!_Jv_IsInterpretedClass (klass))
+    return;
+
+  _Jv_InterpClass *iclass = (_Jv_InterpClass*)klass->aux_info;
+
+  _Jv_Field * field = (&klass->fields[0]) + index;
+
+  if (index > klass->field_count)
+    throw_internal_error ("field out of range");
+
+  int init = iclass->field_initializers[index];
+  if (init == 0)
+    return;
+
+  _Jv_Constants *pool = &klass->constants;
+  int tag = pool->tags[init];
+
+  if (! field->isResolved ())
+    throw_internal_error ("initializing unresolved field");
+
+  if (obj==0 && ((field->flags & Modifier::STATIC) == 0))
+    throw_internal_error ("initializing non-static field with no object");
+
+  void *addr = 0;
+
+  if ((field->flags & Modifier::STATIC) != 0)
+    addr = (void*) field->u.addr;
+  else
+    addr = (void*) (((char*)obj) + field->u.boffset);
+
+  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 */
+
+    case JV_CONSTANT_ResolvedString:
+      if (! (field->type == &java::lang::String::class$
+ 	     || field->type == &java::lang::Class::class$))
+	throw_class_format_error ("string initialiser to non-string field");
+
+      *(jstring*)addr = pool->data[init].string;
+      break;
+
+    case JV_CONSTANT_Integer:
+      {
+	int value = pool->data[init].i;
+
+	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;
+
+	else if (field->type == JvPrimClass (short))
+	  *(jshort*)addr = (jshort)value;
+	
+	else if (field->type == JvPrimClass (int))
+	  *(jint*)addr = (jint)value;
+
+	else
+	  throw_class_format_error ("erroneous field initializer");
+      }  
+      break;
+
+    case JV_CONSTANT_Long:
+      if (field->type != JvPrimClass (long))
+	throw_class_format_error ("erroneous field initializer");
+
+      *(jlong*)addr = _Jv_loadLong (&pool->data[init]);
+      break;
+
+    case JV_CONSTANT_Float:
+      if (field->type != JvPrimClass (float))
+	throw_class_format_error ("erroneous field initializer");
+
+      *(jfloat*)addr = pool->data[init].f;
+      break;
+
+    case JV_CONSTANT_Double:
+      if (field->type != JvPrimClass (double))
+	throw_class_format_error ("erroneous field initializer");
+
+      *(jdouble*)addr = _Jv_loadDouble (&pool->data[init]);
+      break;
+
+    default:
+      throw_class_format_error ("erroneous field initializer");
+    }
+}
+
+inline static unsigned char*
+skip_one_type (unsigned char* ptr)
+{
+  int ch = *ptr++;
+
+  while (ch == '[')
+    { 
+      ch = *ptr++;
+    }
+  
+  if (ch == 'L')
+    {
+      do { ch = *ptr++; } while (ch != ';');
+    }
+
+  return ptr;
+}
+
+static ffi_type*
+get_ffi_type_from_signature (unsigned char* ptr)
+{
+  switch (*ptr) 
+    {
+    case 'L':
+    case '[':
+      return &ffi_type_pointer;
+      break;
+
+    case 'Z':
+      // On some platforms a bool is a byte, on others an int.
+      if (sizeof (jboolean) == sizeof (jbyte))
+	return &ffi_type_sint8;
+      else
+	{
+	  JvAssert (sizeof (jbyte) == sizeof (jint));
+	  return &ffi_type_sint32;
+	}
+      break;
+
+    case 'B':
+      return &ffi_type_sint8;
+      break;
+      
+    case 'C':
+      return &ffi_type_uint16;
+      break;
+	  
+    case 'S': 
+      return &ffi_type_sint16;
+      break;
+	  
+    case 'I':
+      return &ffi_type_sint32;
+      break;
+	  
+    case 'J':
+      return &ffi_type_sint64;
+      break;
+	  
+    case 'F':
+      return &ffi_type_float;
+      break;
+	  
+    case 'D':
+      return &ffi_type_double;
+      break;
+
+    case 'V':
+      return &ffi_type_void;
+      break;
+    }
+
+  throw_internal_error ("unknown type in signature");
+}
+
+/* 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 */
+
+int 
+_Jv_count_arguments (_Jv_Utf8Const *signature,
+		     jboolean staticp)
+{
+  unsigned char *ptr = (unsigned char*) signature->chars();
+  int arg_count = staticp ? 0 : 1;
+
+  /* first, count number of arguments */
+
+  // skip '('
+  ptr++;
+
+  // count args
+  while (*ptr != ')')
+    {
+      ptr = skip_one_type (ptr);
+      arg_count += 1;
+    }
+
+  return arg_count;
+}
+
+/* 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();
+
+  int arg_index = 0;		// arg number
+  int item_count = 0;		// stack-item count
+
+  // setup receiver
+  if (!staticp)
+    {
+      arg_types[arg_index++] = &ffi_type_pointer;
+      item_count += 1;
+    }
+
+  // skip '('
+  ptr++;
+
+  // assign arg types
+  while (*ptr != ')')
+    {
+      arg_types[arg_index++] = get_ffi_type_from_signature (ptr);
+
+      if (*ptr == 'J' || *ptr == 'D')
+	item_count += 2;
+      else
+	item_count += 1;
+
+      ptr = skip_one_type (ptr);
+    }
+
+  // skip ')'
+  ptr++;
+  ffi_type *rtype = get_ffi_type_from_signature (ptr);
+
+  ptr = skip_one_type (ptr);
+  if (ptr != (unsigned char*)signature->chars() + signature->len())
+    throw_internal_error ("did not find end of signature");
+
+  if (ffi_prep_cif (cif, FFI_DEFAULT_ABI,
+		    arg_count, rtype, arg_types) != FFI_OK)
+    throw_internal_error ("ffi_prep_cif failed");
+
+  if (rtype_p != NULL)
+    *rtype_p = rtype;
+
+  return item_count;
+}
+
+/* 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. */
+
+#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
+
+void *
+_Jv_InterpMethod::ncode (jclass klass)
+{
+  using namespace java::lang::reflect;
+
+  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);
+
+  _Jv_init_cif (self->signature,
+		arg_count,
+		staticp,
+		&closure->cif,
+		&closure->arg_types[0],
+		NULL);
+
+  ffi_closure_fun fun;
+
+  args_raw_size = FFI_RAW_SIZE (&closure->cif);
+
+  JvAssert ((self->accflags & Modifier::NATIVE) == 0);
+
+  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;
+        }
+    }
+
+  FFI_PREP_RAW_CLOSURE (&closure->closure,
+		        &closure->cif, 
+		        fun,
+		        (void*)this,
+			code);
+
+  self->ncode = code;
+
+  return self->ncode;
+}
+
+/* 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
+
+  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;
+    }
+
+  return -1;
+}
+
+// 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 ();
+
+  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;
+}
+
+
+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
+}
+
+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
+
+  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;
+
+#ifdef DIRECT_THREADED
+      *startloc = insn_index (local_var_table[table_slot].pc);
+#else
+      *startloc = static_cast<jlong> (local_var_table[table_slot].bytecode_pc);
+#endif
+      *length = static_cast<jint> (local_var_table[table_slot].length);
+      *slot = static_cast<jint> (local_var_table[table_slot].slot);
+    }
+  return local_var_table_len - table_slot - 1;
+}
+
+pc_t
+_Jv_InterpMethod::install_break (jlong index)
+{
+  return set_insn (index, breakpoint_insn);
+}
+
+pc_t
+_Jv_InterpMethod::get_insn (jlong index)
+{
+  pc_t code;
+
+#ifdef DIRECT_THREADED
+  if (index >= number_insn_slots || index < 0)
+    return NULL;
+
+  code = prepared;
+#else // !DIRECT_THREADED
+  if (index >= code_length || index < 0)
+    return NULL;
+
+  code = reinterpret_cast<pc_t> (bytecode ());
+#endif // !DIRECT_THREADED
+
+  return &code[index];
+}
+
+pc_t
+_Jv_InterpMethod::set_insn (jlong index, pc_t insn)
+{
+#ifdef DIRECT_THREADED
+  if (index >= number_insn_slots || index < 0)
+    return NULL;
+
+  pc_t code = prepared;
+  code[index].insn = insn->insn;
+#else // !DIRECT_THREADED
+  if (index >= code_length || index < 0)
+    return NULL;
+
+  pc_t code = reinterpret_cast<pc_t> (bytecode ());
+  code[index] = *insn;
+#endif // !DIRECT_THREADED
+
+  return &code[index];
+}
+
+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<pc_t> (bytecode ());
+      return (code[index] == breakpoint_insn);
+#endif
+    }
+
+  return false;
+}
+
+void *
+_Jv_JNIMethod::ncode (jclass klass)
+{
+  using namespace java::lang::reflect;
+
+  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;
+}
+
+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;
+}
+
+static void
+throw_class_format_error (const char *msg)
+{
+  throw_class_format_error (JvNewStringLatin1 (msg));
+}
+
+/* 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.
+
+   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;
+
+  _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;
+	}
+
+      frame = frame->next_interp;
+    }
+}
+
+/* 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 ());
+    }
+
+  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);
+}
+
+
+
+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);
+	}
+    }
+}
+
+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);
+	}
+    }
+}
+
+_Jv_ClosureList **
+_Jv_InterpreterEngine::do_get_closure_list (jclass klass)
+{
+  _Jv_InterpClass *iclass = (_Jv_InterpClass *) klass->aux_info;
+
+  if (!iclass->closures)
+    iclass->closures = _Jv_ClosureListFinalizer ();
+
+  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];
+
+      if ((field->flags & java::lang::reflect::Modifier::STATIC) == 0)
+	continue;
+
+      char *base = field->isRef() ? reference_fields : non_reference_fields;
+      field->u.addr  = base + field->u.boffset;
+
+      if (iclass->field_initializers[i] != 0)
+	{
+	  _Jv_Linker::resolve_field (field, klass->loader);
+	  _Jv_InitField (0, klass, i);
+	}
+    }
+
+  // Now we don't need the field_initializers anymore, so let the
+  // collector get rid of it.
+  iclass->field_initializers = 0;
+}
+
+_Jv_ResolvedMethod *
+_Jv_InterpreterEngine::do_resolve_method (_Jv_Method *method, jclass klass,
+					  jboolean staticp)
+{
+  int arg_count = _Jv_count_arguments (method->signature, staticp);
+
+  _Jv_ResolvedMethod* result = (_Jv_ResolvedMethod*)
+    _Jv_AllocBytes (sizeof (_Jv_ResolvedMethod)
+		    + arg_count*sizeof (ffi_type*));
+
+  result->stack_item_count
+    = _Jv_init_cif (method->signature,
+		    arg_count,
+		    staticp,
+		    &result->cif,
+		    &result->arg_types[0],
+		    NULL);
+
+  result->method              = method;
+  result->klass               = klass;
+
+  return result;
+}
+
+void
+_Jv_InterpreterEngine::do_post_miranda_hook (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;
+      // 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];
+    }
+}
+
+#ifdef DIRECT_THREADED
+void
+_Jv_CompileMethod (_Jv_InterpMethod* method)
+{
+  if (method->prepared == NULL)
+    {
+      if (JVMTI::enabled)
+	_Jv_InterpMethod::run_debug (NULL, NULL, method);
+      else
+      _Jv_InterpMethod::run (NULL, NULL, method);
+    }
+}
+#endif // DIRECT_THREADED