diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/config/i386/common.h threaded_with_quick/config/i386/common.h
*** kaffe-1.0.5/config/i386/common.h	Mon Oct 18 07:23:51 1999
--- threaded_with_quick/config/i386/common.h	Sun Oct 31 20:05:44 1999
***************
*** 92,98 ****
  			cmpxchgl %2,%1 \n\
  			sete %0" \
  		  : "=q" (ret), "=m" (*(A)) \
! 		  : "r" (N), "a" (O), "1" (*(A)) : "cc" ); \
  		(ret); \
  	})
  
--- 92,98 ----
  			cmpxchgl %2,%1 \n\
  			sete %0" \
  		  : "=q" (ret), "=m" (*(A)) \
! 		  : "r" (N), "a" (O), "r" (*(A)) : "cc" ); \
  		(ret); \
  	})
  
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/config/i386/threads.h threaded_with_quick/config/i386/threads.h
*** kaffe-1.0.5/config/i386/threads.h	Mon Oct 18 07:23:51 1999
--- threaded_with_quick/config/i386/threads.h	Sun Nov 28 15:36:59 1999
***************
*** 20,29 ****
  /*
   * Set a default size for the stack.
   */
! #if defined(INTERPRETER)
! #define	THREADSTACKSIZE		(64 * 1024)
  #else
! #define	THREADSTACKSIZE		(32 * 1024)
  #endif
  
  /*
--- 20,31 ----
  /*
   * Set a default size for the stack.
   */
! #if defined(THREADED_INT)
! #  define	THREADSTACKSIZE		(128 * 1024)
! #elif defined(INTERPRETER)
! #  define	THREADSTACKSIZE		(64 * 1024)
  #else
! #  define	THREADSTACKSIZE		(32 * 1024)
  #endif
  
  /*
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/configure.in threaded_with_quick/configure.in
*** kaffe-1.0.5/configure.in	Mon Oct 18 07:23:53 1999
--- threaded_with_quick/configure.in	Sun Oct 31 19:17:00 1999
***************
*** 220,226 ****
  dnl Allow selection of a specific execution engine
  dnl -------------------------------------------------------------------------
  
! AC_ARG_WITH(engine,[  --with-engine=ENGINE    Force use given execution engine (intrp, jit, or jit3)])
  
  dnl Translate 'interpreter' to 'intrp'
  if test x"$with_engine" = x"interpreter" ; then
--- 220,226 ----
  dnl Allow selection of a specific execution engine
  dnl -------------------------------------------------------------------------
  
! AC_ARG_WITH(engine,[  --with-engine=ENGINE    Force use given execution engine (intrp, threaded_int, jit, or jit3)])
  
  dnl Translate 'interpreter' to 'intrp'
  if test x"$with_engine" = x"interpreter" ; then
***************
*** 242,248 ****
  dnl If it needs updating, run UPDATE_CMDS.
  dnl If it is not supported at all, run UNSUP_CMDS.
  AC_DEFUN([AC_KAFFE_IF_SUPPORTED_ENGINE], [
!   if test x"$1" = x"intrp"; then
      ifelse([$2],[],[:],[$2])
    else
      if test -f "$srcdir/config/$host_cpu/$1-$host_cpu.def"; then
--- 242,248 ----
  dnl If it needs updating, run UPDATE_CMDS.
  dnl If it is not supported at all, run UNSUP_CMDS.
  AC_DEFUN([AC_KAFFE_IF_SUPPORTED_ENGINE], [
!   if test x"$1" = x"intrp" -o x"$1" = x"threaded_int"; then
      ifelse([$2],[],[:],[$2])
    else
      if test -f "$srcdir/config/$host_cpu/$1-$host_cpu.def"; then
***************
*** 268,274 ****
  		[AC_MSG_ERROR([Configuration $host_cpu-$host_os does not support the $want_engine engine])])
  	with_engine="${want_engine}"
  else
! 	for engine in jit3 jit intrp; do
  		AC_KAFFE_IF_SUPPORTED_ENGINE([${engine}], [
  			with_engine="${engine}"
  			break;
--- 268,274 ----
  		[AC_MSG_ERROR([Configuration $host_cpu-$host_os does not support the $want_engine engine])])
  	with_engine="${want_engine}"
  else
! 	for engine in jit3 jit intrp threaded_int ; do
  		AC_KAFFE_IF_SUPPORTED_ENGINE([${engine}], [
  			with_engine="${engine}"
  			break;
***************
*** 276,282 ****
  	done
  fi
  
! if test x"$with_engine" != x"intrp" ; then
      HAVE_CONFIG_JIT_MD_H=1
      CONFIG_JIT_MD_H="\$(top_srcdir)/config/$host_cpu/$host_os/$with_engine-md.h"
      AC_SUBST(CONFIG_JIT_MD_H)
--- 276,282 ----
  	done
  fi
  
! if test x"$with_engine" != x"intrp" -o x"$with_engine" != x"threaded_int"; then
      HAVE_CONFIG_JIT_MD_H=1
      CONFIG_JIT_MD_H="\$(top_srcdir)/config/$host_cpu/$host_os/$with_engine-md.h"
      AC_SUBST(CONFIG_JIT_MD_H)
***************
*** 292,298 ****
  
  AC_MSG_CHECKING(execution engine)
  AC_MSG_RESULT($with_engine)
! AM_CONDITIONAL(USE_JIT, test x"$with_engine" != x"intrp")
  
  ENGINE_NAME="$with_engine"
  AC_SUBST(ENGINE_NAME)
--- 292,299 ----
  
  AC_MSG_CHECKING(execution engine)
  AC_MSG_RESULT($with_engine)
! AM_CONDITIONAL(USE_JIT, test x"$with_engine" != x"intrp" -o \
!                              x"$with_engine" != x"threaded_int")
  
  ENGINE_NAME="$with_engine"
  AC_SUBST(ENGINE_NAME)
***************
*** 359,365 ****
  dnl Look for trampoline code if in JIT mode
  dnl -------------------------------------------------------------------------
  KAFFEVM_TRAMPOLINES_C=
! if test "$with_engine" != "intrp" ; then
  	AC_MSG_CHECKING(for trampolines)
  	if test -f $srcdir/config/$host_cpu/trampolines.c ; then
  		KAFFEVM_TRAMPOLINES_C="\$(top_srcdir)/config/$host_cpu/trampolines.c"
--- 360,366 ----
  dnl Look for trampoline code if in JIT mode
  dnl -------------------------------------------------------------------------
  KAFFEVM_TRAMPOLINES_C=
! if test "$with_engine" != "intrp" -o "$with_engine" != "threaded_int" ; then
  	AC_MSG_CHECKING(for trampolines)
  	if test -f $srcdir/config/$host_cpu/trampolines.c ; then
  		KAFFEVM_TRAMPOLINES_C="\$(top_srcdir)/config/$host_cpu/trampolines.c"
***************
*** 1042,1047 ****
--- 1043,1049 ----
  libraries/Makefile \
  kaffe/kaffevm/Makefile \
  kaffe/kaffevm/intrp/Makefile \
+ kaffe/kaffevm/threaded_int/Makefile \
  kaffe/kaffevm/jit/Makefile \
  kaffe/kaffevm/jit3/Makefile \
  kaffe/kaffevm/gcj/Makefile \
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/Makefile.am threaded_with_quick/kaffe/kaffevm/Makefile.am
*** kaffe-1.0.5/kaffe/kaffevm/Makefile.am	Mon Oct 18 07:23:57 1999
--- threaded_with_quick/kaffe/kaffevm/Makefile.am	Sun Oct 31 19:12:02 1999
***************
*** 7,13 ****
  # of this file. 
  
  SUBDIRS = $(ENGINE_NAME) systems gcj
! DIST_SUBDIRS = intrp jit jit3 systems gcj
  
  EXTRA_DIST = \
  	kaffe.def \
--- 7,13 ----
  # of this file. 
  
  SUBDIRS = $(ENGINE_NAME) systems gcj
! DIST_SUBDIRS = intrp threaded_int jit jit3 systems gcj
  
  EXTRA_DIST = \
  	kaffe.def \
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/classMethod.c threaded_with_quick/kaffe/kaffevm/classMethod.c
*** kaffe-1.0.5/kaffe/kaffevm/classMethod.c	Mon Oct 18 07:23:57 1999
--- threaded_with_quick/kaffe/kaffevm/classMethod.c	Sun Nov 21 17:50:48 1999
***************
*** 40,45 ****
--- 40,48 ----
  #include "jni.h"
  #include "methodCache.h"
  #include "gcj/gcj.h"
+ #if defined(THREADED_INT) 
+ #   include "engine.h"
+ #endif
  
  #if 0
  #define	METHOD_TRUE_NCODE(METH)			(METH)->c.ncode.ncode_start
***************
*** 664,669 ****
--- 667,679 ----
  	}
  
  	CLASS_NMETHODS(c)++;
+ #if defined(THREADED_INT) 
+ 	{
+ 		static Instr stub[1] = {{NULL}};
+ 		if (stub[0].p==NULL) stub[0] = get_translate_label();
+ 		mt->icode = stub;
+ 	}
+ #endif 
  	return (mt);
  }
  
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/classMethod.h threaded_with_quick/kaffe/kaffevm/classMethod.h
*** kaffe-1.0.5/kaffe/kaffevm/classMethod.h	Mon Oct 18 07:23:57 1999
--- threaded_with_quick/kaffe/kaffevm/classMethod.h	Sun Nov 21 17:50:51 1999
***************
*** 18,23 ****
--- 18,24 ----
  #include "constants.h"
  #include "errors.h"
  
+ 
  #define	MAXMETHOD		64
  
  /* Class state */
***************
*** 42,47 ****
--- 43,51 ----
  	int	dummy;
  } Hjava_lang_ClassLoader;
  
+ 
+ union instr;  /* needed by threaded_int */
+ 
  struct Hjava_lang_Class {
  	Hjava_lang_Object	head;		/* A class is an object too */
  
***************
*** 169,174 ****
--- 173,181 ----
  	struct _jexception*	exception_table;
  	u2			ndeclared_exceptions;
  	constIndex*		declared_exceptions;
+ 
+         union instr *icode; /* needed by threaded_int */
+ 
  #if defined(KAFFE_PROFILER)
  	profiler_click_t	jitClicks;
  	profiler_click_t	totalClicks;
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/Makefile.am threaded_with_quick/kaffe/kaffevm/threaded_int/Makefile.am
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/Makefile.am	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/Makefile.am	Wed Nov 10 12:49:19 1999
***************
*** 0 ****
--- 1,37 ----
+ # Makefile.in for kaffevm JIT compiler
+ #
+ # Copyright (c) 1996, 1997, 1998, 1999
+ #	Transvirtual Technologies, Inc.  All rights reserved.
+ #
+ # See the file "license.terms" for information on usage and redistribution 
+ # of this file. 
+ 
+ @engine_frag@
+ 
+ INCLUDES = -I$(top_srcdir)/kaffe/kaffevm/$(THREAD_DIR) -I.. -I$(srcdir)/.. $(ENGINE_DEFS)
+ 
+ noinst_LTLIBRARIES = libengine.la
+ 
+ libengine_la_LDFLAGS = $(KVMLIBFLAGS)
+ libengine_la_SOURCES = \
+ 	engine.c\
+ 	translator.c\
+ 	threaded_int.def\
+ 	checks.h\
+ 	engine.h\
+ 	icode.h\
+ 	machine.h\
+ 	slots.h\
+ 	translator.h
+ 
+ 
+ engine.i: engine.c threaded_int.def
+ 	$(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS)  $(CPPFLAGS) \
+ 	$(AM_CFLAGS) $(CFLAGS) -E $< -o $@
+ 
+ engine.s: engine.c threaded_int.def
+ 	$(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS)  $(CPPFLAGS) \
+ 	$(AM_CFLAGS) $(CFLAGS) -S $< -o $@
+ 
+ EXTRA_DIST = \
+ 	Makefile.frag \
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/Makefile.frag threaded_with_quick/kaffe/kaffevm/threaded_int/Makefile.frag
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/Makefile.frag	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/Makefile.frag	Sun Oct 31 19:21:07 1999
***************
*** 0 ****
--- 1,12 ----
+ # Makefile.frag for kaffevm Interpreter
+ #
+ # Copyright (c) 1996, 1997
+ #	Transvirtual Technologies, Inc.  All rights reserved.
+ #
+ # See the file "license.terms" for information on usage and redistribution 
+ # of this file. 
+ 
+ ENGINE_INCLUDES = -Ithreaded_int -I$(srcdir)/threaded_int
+ ENGINE_DEFS = -DINTERPRETER -DTHREADED_INT
+ 
+ 
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/checks.h threaded_with_quick/kaffe/kaffevm/threaded_int/checks.h
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/checks.h	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/checks.h	Sun Nov 21 17:51:12 1999
***************
*** 0 ****
--- 1,42 ----
+ /*
+  * checks.h
+  * Validate the given item is of the correct type.
+  *
+  * Copyright (c) 1996, 1997
+  *	Transvirtual Technologies, Inc.  All rights reserved.
+  *
+  * See the file "license.terms" for information on usage and redistribution 
+  * of this file. 
+  */
+ 
+ #ifndef __checks_h
+ #define	__checks_h
+ 
+ #define	check_local_int(l)	CHDBG (dprintf ("- local %d: int %d\n", (l), (int) local(l)->v.tint))
+ #define	check_local_long(l)	CHDBG (dprintf ("- local %d: long %ld\n", (l), (long) local_long(l)->v.tlong))
+ #define	check_local_float(l)	CHDBG (dprintf ("- local %d: float %g\n", (l), (double) local_float(l)->v.tfloat))
+ #define	check_local_double(l)	CHDBG (dprintf ("- local %d: double %g\n", (l), (double) local_double(l)->v.tdouble))
+ #define	check_local_ref(l)	CHDBG (dprintf ("- local %d: ref %p\n", (l), (void *) local(l)->v.taddr))
+ 
+ #define	check_stack_int(l)	CHDBG (dprintf ("- stack %d: int %d\n", (l), (int) stack(l)->v.tint))
+ #define	check_stack_long(l)	CHDBG (dprintf ("- stack %d: long %ld\n", (l), (long) stack(l)->v.tlong))
+ #define	check_stack_float(l)	CHDBG (dprintf ("- stack %d: float %g\n", (l), (double) stack(l)->v.tfloat))
+ #define	check_stack_double(l)	CHDBG (dprintf ("- stack %d: double %g\n", (l), (double) stack(l)->v.tdouble))
+ #define	check_stack_ref(l)	 CHDBG (dprintf ("- stack %d: ref %p\n", (l), (void *) stack(l)->v.taddr))
+ 
+ #define	check_stack_array(l)		CHDBG (dprintf ("- stack %d: array * %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_intarray(l)		CHDBG (dprintf ("- stack %d: array int %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_longarray(l)	CHDBG (dprintf ("- stack %d: array long %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_floatarray(l)	CHDBG (dprintf ("- stack %d: array float %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_doublearray(l)	CHDBG (dprintf ("- stack %d: array double %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_refarray(l)		CHDBG (dprintf ("- stack %d: array ref %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_bytearray(l)	CHDBG (dprintf ("- stack %d: array byte %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_chararray(l)	CHDBG (dprintf ("- stack %d: array char %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ #define	check_stack_shortarray(l)	CHDBG (dprintf ("- stack %d: array short %p[%d]\n", (l), (void *) stack(l)->v.taddr, (int) *(uint32*)(object_array_length+(char*)stack(l)->v.taddr)))
+ 
+ #define check_pc(l)		CHDBG (dprintf ("  ARG %d: %d\n", l, getpc(l)))
+ #define check_pc_wide(l)	CHDBG (dprintf ("  ARG %d: %d = %d + %d[WIDE]\n", l, getpc(l)+wide, getpc(l), wide))
+ #define check_pcidx(l)	CHDBG (dprintf ("  ARG %d-%d: %d\n", l, l+1, (int16)((getpc(l) << 8) | getpc(l+1))))
+ #define check_pcwidx(l)	CHDBG (dprintf ("  ARG %d-%d: %d\n", l, l+3, (int32)((getpc(l) << 24) | (getpc(l+1) << 16) | (getpc(l+2) << 8) | getpc(l+3))))
+ 
+ #endif
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/engine.c threaded_with_quick/kaffe/kaffevm/threaded_int/engine.c
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/engine.c	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/engine.c	Fri Nov 26 22:34:06 1999
***************
*** 0 ****
--- 1,325 ----
+ /* $Id: engine.c,v 1.1.2.1.2.2.2.5 1999/11/26 21:34:06 helmut Exp $ */
+ 
+ 
+ #ifndef __GNUC__
+ #error __FILE__ "requires"
+ #endif
+ 
+ 
+ #include "debug.h"
+ #define	CDBG(s) 	DBG(INT_VMCALL, s)
+ #define	RDBG(s) 	DBG(INT_RETURN, s)
+ #define	NDBG(s) 	DBG(INT_NATIVE, s)
+ #define	IDBG(s)		DBG(INT_INSTR, s)
+ #define	CHDBG(s)	DBG(INT_CHECKS, s)
+ 
+ #ifndef DEBUG
+ #define dprintf printf
+ #endif
+ 
+ #include "config.h"
+ #include "config-std.h"
+ #include "config-math.h"
+ #include "config-mem.h"
+ #include "config-setjmp.h"
+ #include "classMethod.h"
+ #include "gtypes.h"
+ #include "bytecode.h"
+ #include "slots.h"
+ #include "access.h"
+ #include "object.h"
+ #include "constants.h"
+ #include "gc.h"
+ #include "lookup.h"
+ #include "code-analyse.h"
+ #include "soft.h"
+ #include "exception.h"
+ #include "external.h"
+ #include "baseClasses.h"
+ #include "thread.h"
+ #include "jthread.h"
+ #include "locks.h"
+ #include "checks.h"
+ #include "errors.h"
+ #include "md.h"
+ 
+ #include "icode.h"
+ #include "engine.h"
+ #include "checks.h"
+ #include "machine.h"
+ #include "translator.h"
+ 
+ 
+ 
+ /* Define CREATE_NULLPOINTER_CHECKS in md.h when your machine cannot use the
+  * MMU for detecting null pointer accesses */
+ #if defined(CREATE_NULLPOINTER_CHECKS)
+ #define CHECK_NULL(_i, _s, _n)                                  \
+       cbranch_ref_const_ne((_s), 0, reference_label(_i, _n)); \
+       softcall_nullpointer();                                 \
+       set_label(_i, _n)
+ #else
+ #define CHECK_NULL(_i, _s, _n)
+ #endif
+ 
+ #if defined(KAFFE_PROFILER)
+ int profFlag;			 /* flag to control profiling */
+ #endif
+ 
+ 
+ 
+ 
+ static void engine(methods*  meth, slots *  lcl, 
+ 		   slots *  sp0, uintp  new_pc, 
+ 		   slots * retval, volatile vmException 
+ 		   *mjbuf, Hjava_lang_Thread  *tid,
+ 		   Instr **labels);
+ 
+ void virtualMachine (methods*volatile meth, slots* volatile arg, slots* volatile retval, Hjava_lang_Thread* volatile tid) {
+ 	methods *volatile const vmeth = meth;
+ 	Hjava_lang_Object* volatile mobj;
+ 	vmException mjbuf;
+ 	accessFlags methaccflags;
+ 
+ 	slots* volatile lcl;
+ 	slots* volatile sp;
+ 	uintp volatile npc;
+ 
+ 	int32 idx;
+ 	jint low;
+ 
+ 	errorInfo einfo;
+ 	Hjava_lang_Throwable* overflow;
+ 	jint *needOnStack;
+ 
+ 
+ 	if (tid != 0)  {
+ 		/* implement stack overflow check */
+ 		needOnStack = &unhand(tid)->needOnStack;
+ 
+ 		if (jthread_stackcheck(*needOnStack) == false) {
+ 			overflow = (Hjava_lang_Throwable*)
+ 				unhand(tid)->stackOverflowError;
+ 			if (overflow != 0) {
+ 				if (*needOnStack == STACK_LOW) {
+ 					fprintf(stderr, 
+ 					    "Panic: unhandled StackOverflowError()\n");
+ 					ABORT();
+ 				}
+ 				*needOnStack = STACK_LOW;
+ 				throwException(overflow);
+ 			}
+ 		}
+ 	}
+ 
+ CDBG(	dprintf("Call: %s.%s%s.\n", meth->class->name->data, meth->name->data, METHOD_SIGD(meth)); )
+ 
+ 	/* If this is native, then call the real function */
+ 	methaccflags = meth->accflags;
+ 	if (methaccflags & ACC_NATIVE) {
+ NDBG(		dprintf("Call to native %s.%s%s.\n", meth->class->name->data, meth->name->data, METHOD_SIGD(meth)); )
+ 		if (methaccflags & ACC_STATIC) {
+ 			callMethodA(meth, meth, 0, (jvalue*)arg, (jvalue*)retval, 1);
+ 		}
+ 		else {
+ 			callMethodA(meth, meth, ((jvalue*)arg)[0].l, &((jvalue*)arg)[1], (jvalue*)retval, 1);
+ 		}
+ 		return;
+ 	}
+ 
+ 	/* Verify method if required */
+ 	if ((methaccflags & ACC_VERIFIED) == 0) {
+ 		codeinfo* codeInfo;
+ 		bool success = verifyMethod(meth, &codeInfo, &einfo);
+ 		tidyVerifyMethod(&codeInfo);
+ 		if (success == false) {
+ 			throwError(&einfo);
+ 		}
+ 	}
+ 
+ 	/* Allocate stack space and locals. */
+ 	lcl = alloca(sizeof(slots) * (meth->localsz + meth->stacksz));
+ 
+ 	mobj = 0;
+ 	npc = 0;
+ 
+ 	/* If we have any exception handlers we must prepare to catch them.
+ 	 * We also need to catch if we are synchronised (so we can release it).
+ 	 */
+ 	mjbuf.pc = 0;
+ 	mjbuf.mobj = mobj;
+ 	mjbuf.meth = meth;
+ 	if (tid != NULL && unhand(tid)->PrivateInfo != 0) {
+ 		mjbuf.prev = (vmException*)unhand(tid)->exceptPtr;
+ 		unhand(tid)->exceptPtr = (struct Hkaffe_util_Ptr*)&mjbuf;
+ 	}
+ 
+ 	if (meth->exception_table != 0) {
+ 		if (JTHREAD_SETJMP(mjbuf.jbuf) != 0) {
+ 			meth = vmeth;
+ 			unhand(tid)->exceptPtr = (struct Hkaffe_util_Ptr*)&mjbuf;
+ 			npc = mjbuf.pc;
+ 			sp = &lcl[meth->localsz];
+ 			sp->v.taddr = (void*)unhand(tid)->exceptObj;
+ 			unhand(tid)->exceptObj = 0;
+ 			engine(meth, lcl, sp, npc, retval, &mjbuf, tid, NULL);
+ 			goto end;
+ 		}
+ 	}
+ 
+ 	/* Calculate number of arguments */
+ 	idx = sizeofSigMethod(meth, false);
+ 	if (idx == -1) {
+ 		throwError(&einfo);
+ 	}
+ 	idx += (methaccflags & ACC_STATIC ? 0 : 1);
+ 
+ 	/* Copy in the arguments */
+ 	sp = lcl;
+ 	for (low = 0; low < idx; low++) {
+ 		*(sp++) = *(arg++);
+ 	}
+ 
+ 	/* Sync. if required */
+ 	if (methaccflags & ACC_SYNCHRONISED) { 
+ 		if (methaccflags & ACC_STATIC) {
+ 			mobj = &meth->class->head;
+ 		}
+ 		else {
+ 			mobj = (Hjava_lang_Object*)lcl[0].v.taddr;
+ 		}
+ 		/* this lock is safe for Thread.stop() */
+ 		lockObject(mobj);
+ 		/* We must store the object on which we synchronized in
+ 		 * the mjbuf chain or else the exception handler routine
+ 		 * won't find it.
+ 		 */
+ 		mjbuf.mobj = mobj;
+ 	}       
+ 
+ 	sp = &lcl[meth->localsz - 1];
+ 
+ 	engine(meth, lcl, sp, npc, retval, &mjbuf, tid, NULL);
+ 
+  end:
+ 	/* Unsync. if required */
+ 	if (mobj != 0) {
+ 		unlockObject(mobj);
+ 	}       
+ 	if (tid != NULL && unhand(tid)->PrivateInfo != 0) {
+ 		unhand(tid)->exceptPtr = (struct Hkaffe_util_Ptr*)mjbuf.prev;
+ 	}
+ 
+ RDBG(	dprintf("Returning from method %s%s.\n", meth->name->data, METHOD_SIGD(meth)); )
+ }
+ 
+ 
+ 
+ 
+ /**
+  * Evaluates method METH, with local variables beginning at LCL and
+  * the operand stack at SP0.  NEW_PC is used to implement exception
+  * handling, i.e., is only non-zero during exception handling.  If the
+  * method retuns a value it is stored into retval.  The current PC is
+  * stored in mjbuf (before each instruction).  TID is used to
+  * implement synchronization.
+  *
+  * If LABELS is non-NULL a pointer to an array containing the machine
+  * code labels is stored into LABELS and the function returns
+  * immediately (all other arguments are ignored).
+  **/
+ static void engine(methods* meth, slots *  lcl, 
+ 		   slots * sp0, uintp  new_pc, 
+ 		   slots * retval, volatile vmException * mjbuf,
+ 		   Hjava_lang_Thread  *tid,
+ 		   Instr **labels) {
+ 	Instr *__ip=NULL;	/* instuction pointer */
+ 	Instr *icodep;		/* the first instruction of this method. */
+ 	slots *sp = sp0;	/* stack pointer */
+ 	jlong lcc;
+ 	jlong tmpl;
+ 	slots tmp[1];
+ 	slots mtable[1];
+ 	void check_label(Instr label) { label_2_string(label); }
+ 	void dump_stack(void) {
+ 		slots *p;					
+ 		dprintf("----------- top");			
+ 		for(p=MAX(sp,lcl); p >= MIN(sp0,lcl)-1; p--) {	
+ 			if (p==lcl+meth->localsz-1)		
+ 			    dprintf("\n----------- locals");	
+ 			dprintf("\n[%#Lx]",p[0].v.tlong);	
+ 			if (p==sp) dprintf(" <-- sp");		
+ 			if (p==lcl) dprintf(" <-- fp");		
+ 								
+ 		}						
+ 		dprintf("\n----------- bottom \n");		
+ 	}
+ 
+ 	/* Variables used directly in the machine */
+ 	int32 idx;
+ 	jint low;
+ 	jint high;
+ 
+ 	/* Call, field and creation information */
+ 	callInfo cinfo;
+ 	fieldInfo finfo;
+ 	Hjava_lang_Class* crinfo;
+ 	errorInfo einfo;
+ 
+ 	if (labels) {		
+ 		static Instr local_labels[256+N_CUSTOM_INSTRUCTIONS+1] = {
+ #       	  define instr(name,opcode,label,len,syn,body) {&&##label},
+ #       	  define undef(name,opcode,label,len,syn,body) {&&undef},
+ #       	  define custm(name,opcode,label,len,syn,body) {&&##label},
+ #       	  include "threaded_int.def"
+ #       	  undef instr
+ #       	  undef undef
+ #       	  undef custm
+ 		  {&&undef}
+ 		};
+ 		*labels = local_labels; return;
+ 
+ 	}
+ 
+ 	if(((Instr *)meth->icode)[0].p==&&translate){translate_to_icode(meth);}
+ 	icodep=meth->icode;
+ 	JMP(icodep+new_pc);
+ #	define undef(name, opcode, label, length, syntax, body) 
+ #       define instr(name, opcode, label, length, syntax, body)  \
+         label:							 \
+              IDBG( dprintf("%03d: %s\n", PC, #label);)           \
+              body						 \
+              NEXT(length);	
+ #       define custm instr	
+ #       include "threaded_int.def"
+ #       undef instr
+ #       undef undef
+ #       undef custm
+  undef: 
+ 	fprintf(stderr,"undefined opcode.\n"); 
+ 	assert(0);
+  end:
+ 	return;
+ }
+ 
+ 
+ 
+ static Instr *b2i = NULL;
+ 
+ /* get_translate_label -- returns the code label which triggers
+    translation. */
+ Instr  get_translate_label(void) {
+ 	return get_labels()[TRANSLATE];
+ }
+ 
+ /* get_labels -- returns an array of addresses of intermediate
+    instructions. */
+ Instr* get_labels() { 
+ 	if (b2i==NULL) engine(0,0,0,0,0,0,0,&b2i);
+ 	return b2i;
+ }
+ 
+ /* make linker happy */
+ char* getEngine() {return "kaffe.threaded_int";}
+ char* engine_name = "Threaded Code";
+ char* engine_version = KVER;
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/engine.h threaded_with_quick/kaffe/kaffevm/threaded_int/engine.h
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/engine.h	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/engine.h	Sun Nov 28 15:37:42 1999
***************
*** 0 ****
--- 1,89 ----
+ /* $Id: engine.h,v 1.1.2.1.2.4.2.5 1999/11/28 14:37:42 helmut Exp $ */
+ 
+ 
+ #ifndef __engine_h
+ #define __engine_h
+ 
+ 
+ 
+ typedef union instr {
+   void*   p;
+   float	  f;
+   uint32  u;
+   int32   i;
+ } Instr;
+ 
+ 
+ typedef enum {
+   __CustomInstructionsDummyBeg=255,
+ # define instr(name,opcode,label,len,syn,body) 
+ # define undef(name,opcode,label,len,syn,body) 
+ # define custm(name,opcode,label,len,syn,body) name,
+ # include "threaded_int.def"
+ # undef instr
+ # undef undef
+ # undef custm
+   __CustomInstructionsDummyEnd
+ } CustomInstructions;
+ 
+ 
+ #define N_CUSTOM_INSTRUCTIONS \
+ (__CustomInstructionsDummyEnd-__CustomInstructionsDummyBeg)
+ 
+ 
+ /* mjbuf->pc is set each time to remain compatible with
+    kaffes exception handling.   */
+ #define NEXT(step)	{		\
+ 	__ip += (step);			\
+         mjbuf->pc = __ip-icodep;	\
+ 	goto *(__ip->p);}
+ 
+ #define JMP(new_ip)		{__ip = (new_ip); NEXT(0);}
+ #define BRA(offset)		{__ip += (offset); NEXT(0);}
+ #define IP			__ip
+ #define RESTORE_IP(old_ip)	{__ip=(old_ip); }
+ 
+ 
+ #define THIS ((Hjava_lang_Object *)(fp[0].l))
+ #define TOS (sp[0])
+ #define STACK(offset) (sp[-(offset)])
+ #define PUSH_I(value) {push(1); sp[0].v.tint = (value);}
+ #define PUSH_L(value) {push(1); sp[0].v.taddr = (value);}
+ 
+ #define LOCAL(index) (fp[(index)])
+ 
+ 
+ #define SAVE_REGISTERS {rp++; rp->mp = mp; rp->fp = fp; rp->ip = IP;}
+ #define RESTORE_REGISTERS { \
+ 	Instr stored_ip = rp->ip; \
+ 	fp = rp->fp;		\
+ 	mp = rp->mp; 		\
+ 	rp--;			\
+ 	JMP(stored_ip);}
+ 
+ 
+ #define PC (IP-((Instr *)meth->icode))	
+ #define INTERNAL_IP (__ip)
+ #define getpc(x) (meth->c.bcode.code[PC+(x)+1])	/* byte code! */
+ 
+ /* offset 0 means the first operand of the current instruction */
+ #define get_icode_uint8(offset)		(__ip[(offset)+1].u)
+ #define get_icode_int8(offset)		(__ip[(offset)+1].i)
+ #define get_icode_uint16(offset)	(__ip[(offset)+1].u)
+ #define get_icode_int16(offset)		(__ip[(offset)+1].i)
+ #define get_icode_uint32(offset)	(__ip[(offset)+1].u)
+ #define get_icode_int32(offset)		(__ip[(offset)+1].i)
+ #define get_icode_float(offset)		(__ip[(offset)+1].f)
+ #define get_icode_pointer(offset)	(__ip[(offset)+1].p)
+ 
+ /* offset 0 means the instruction being executed */
+ #define set_icode_p(offset,value)  {__ip[offset].p=(value);}
+ #define set_icode_f(offset,value)  {__ip[offset].f=(value);}
+ #define set_icode_i(offset,value)  {__ip[offset].i=(value);}
+ #define set_icode_u(offset,value)  {__ip[offset].u=(value);}
+ 
+ Instr* get_labels(void);
+ Instr  get_translate_label(void);
+ 
+ 
+ #endif /* __engine_h */
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/icode.h threaded_with_quick/kaffe/kaffevm/threaded_int/icode.h
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/icode.h	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/icode.h	Sun Oct 31 19:21:19 1999
***************
*** 0 ****
--- 1,309 ----
+ /*
+  * icode.h
+  * Define the instruction codes macros.
+  *
+  * Copyright (c) 1996, 1997
+  *	Transvirtual Technologies, Inc.  All rights reserved.
+  *
+  * See the file "license.terms" for information on usage and redistribution 
+  * of this file. 
+  */
+ 
+ #ifndef __icode_h
+ #define	__icode_h
+ 
+ #define	move_long_const(t, c)			(t)[0].v.tlong = (c)
+ #define	add_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong + (f2)[0].v.tlong
+ #define	sub_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong - (f2)[0].v.tlong
+ #define	mul_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong * (f2)[0].v.tlong
+ #define	div_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong / (f2)[0].v.tlong
+ #if LONG_LONG_MODULO_BROKEN
+ /* egcs 1.1.* on IRIX 6.3/mips produces an arithmetic exception for
+    LONG_LONG_MIN % -1ll.  Since anything % -1ll is 0, special-case it.  */
+ # define rem_long(t, f1, f2)			(t)[0].v.tlong = (((f2)[0].v.tlong != -1) ? ((f1)[0].v.tlong % (f2)[0].v.tlong) : 0)
+ #else
+ # define rem_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong % (f2)[0].v.tlong
+ #endif
+ #define	neg_long(t, f)				(t)[0].v.tlong = -(f)[0].v.tlong
+ 
+ #define	and_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong & (f2)[0].v.tlong
+ #define	or_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong | (f2)[0].v.tlong
+ #define	xor_long(t, f1, f2)			(t)[0].v.tlong = (f1)[0].v.tlong ^ (f2)[0].v.tlong
+ 
+ #define	lshl_long(t, f1, f2)			(t)[0].v.tlong = ((f1)[0].v.tlong) << ((f2)[0].v.tint & 63)
+ #define	ashr_long(t, f1, f2)			(t)[0].v.tlong = ((int64)(f1)[0].v.tlong) >> ((f2)[0].v.tint & 63)
+ #define	lshr_long(t, f1, f2)			(t)[0].v.tlong = ((uint64)(f1)[0].v.tlong) >> ((f2)[0].v.tint & 63)
+ 
+ #define	lcmp(t, f1, f2)				lcc = ((f2)[0].v.tlong) - ((f1)[0].v.tlong); \
+ 						(t)[0].v.tint = (lcc < 0 ? -1 : lcc > 0 ? 1 : 0)
+ 
+ #define	cvt_int_long(t, f)			(t)[0].v.tlong = (f)[0].v.tint
+ #define	cvt_long_int(t, f)			(t)[0].v.tint = (f)[0].v.tlong
+ #define	cvt_long_float(t, f)			(t)[0].v.tfloat = (f)[0].v.tlong
+ #define	cvt_long_double(t, f)			(t)[0].v.tdouble = (f)[0].v.tlong
+ #define	cvt_float_long(t, f)			(t)[0].v.tlong = floor((f)[0].v.tfloat)
+ #define	cvt_double_long(t, f)			(t)[0].v.tlong = floor((f)[0].v.tdouble)
+ 
+ #define	move_int_const(t, c)			(t)[0].v.tint = (c)
+ #define	move_ref_const(t, c)			(t)[0].v.taddr = (void*)(c)
+ #define	move_label_const(t, c)			move_ref_const(t, c)
+ #define	move_string_const(t, c)			move_ref_const(t, c)
+ 
+ #define	move_int(t, f)				(t)[0].v.tint = (f)[0].v.tint
+ #define	move_ref(t, f)				(t)[0].v.taddr = (f)[0].v.taddr
+ #define	move_any(t, f)				move_long(t, f)
+ 
+ #define	swap_any(t1, t2)			{			\
+ 						  tmp[0] = (t1)[0];	\
+ 						  (t1)[0] = (t2)[0];	\
+ 						  (t2)[0] = tmp[0];	\
+ 						}
+ 
+ #define	load_int(t, f)				(t)[0].v.tint = *(jint*)((f)[0].v.taddr)
+ #define	load_ref(t, f)				(t)[0].v.taddr = *(void**)((f)[0].v.taddr)
+ #define	load_byte(t, f)				(t)[0].v.tint = *(jbyte*)((f)[0].v.taddr)
+ #define	load_char(t, f)				(t)[0].v.tint = *(jchar*)((f)[0].v.taddr)
+ 
+ #define	store_int(t, f)				*(jint*)((t)[0].v.taddr) = ((f)[0].v.tint)
+ #define	store_ref(t, f)				*(void**)((t)[0].v.taddr) = ((f)[0].v.taddr)
+ #define	store_byte(t, f)			*(jbyte*)((t)[0].v.taddr) = ((f)[0].v.tint)
+ #define	store_char(t, f)			*(jchar*)((t)[0].v.taddr) = ((f)[0].v.tint)
+ 
+ #define	load_any(t, f)				load_int(t, f)
+ #define load_offset_any(t, f, o)		load_offset_int(t, f, o)
+ #define	store_any(t, f)				store_int(t, f)
+ #define store_offset_any(t, f, o)		store_offset_int(t, f, o)
+ 
+ #define	add_int_const(t, f, c)			(t)[0].v.tint = ((f)[0].v.tint) + (c)
+ #define	add_ref_const(t, f, c)			(t)[0].v.taddr = (void*)((uint8*)((f)[0].v.taddr) + (c))
+ #define	sub_int_const(t, f, c)			(t)[0].v.tint = ((f)[0].v.tint) - (c)
+ #define	mul_int_const(t, f, c)			(t)[0].v.tint = ((f)[0].v.tint) * (c)
+ 
+ #define	add_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) + ((f2)[0].v.tint)
+ #define	add_ref(t, f1, f2)			(t)[0].v.taddr = (void*)((uint8*)((f1)[0].v.taddr) + ((f2)[0].v.tint))
+ #define	sub_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) - ((f2)[0].v.tint)
+ #define	mul_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) * ((f2)[0].v.tint)
+ #define	div_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) / ((f2)[0].v.tint)
+ #define	rem_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) % ((f2)[0].v.tint)
+ #define	neg_int(t, f)				(t)[0].v.tint = -((f)[0].v.tint)
+ #define	lshl_int_const(t, f, c)			(t)[0].v.tint = ((f)[0].v.tint) << (c & 31)
+ #define	lshl_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) << ((f2)[0].v.tint & 31)
+ #define	ashr_int(t, f1, f2)			(t)[0].v.tint = ((int32)(f1)[0].v.tint) >> ((f2)[0].v.tint & 31)
+ #define	lshr_int(t, f1, f2)			(t)[0].v.tint = ((uint32)(f1)[0].v.tint) >> ((f2)[0].v.tint & 31)
+ #define	and_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) & ((f2)[0].v.tint)
+ #define	or_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) | ((f2)[0].v.tint)
+ #define	xor_int(t, f1, f2)			(t)[0].v.tint = ((f1)[0].v.tint) ^ ((f2)[0].v.tint)
+ 
+ #define	cvt_int_byte(t, f)			(t)[0].v.tint = (((f)[0].v.tint) << 24) >> 24
+ #define	cvt_int_char(t, f)			(t)[0].v.tint = ((f)[0].v.tint) & 0xFFFF
+ #define	cvt_int_short(t, f)			(t)[0].v.tint = (((f)[0].v.tint) << 16) >> 16
+ 
+ #define	branch_indirect(w)			w
+ #define	branch_a(w)				w
+ 
+ #define	cbranch_int_eq(s1, s2, w)		if ((s1)[0].v.tint == (s2)[0].v.tint) w
+ #define	cbranch_int_ne(s1, s2, w)		if ((s1)[0].v.tint != (s2)[0].v.tint) w
+ #define	cbranch_int_lt(s1, s2, w)		if ((s1)[0].v.tint < (s2)[0].v.tint) w
+ #define	cbranch_int_le(s1, s2, w)		if ((s1)[0].v.tint <= (s2)[0].v.tint) w
+ #define	cbranch_int_gt(s1, s2, w)		if ((s1)[0].v.tint > (s2)[0].v.tint) w
+ #define	cbranch_int_ge(s1, s2, w)		if ((s1)[0].v.tint >= (s2)[0].v.tint) w
+ #define	cbranch_int_ult(s1, s2, w)		if ((unsigned int)(s1)[0].v.tint < (unsigned int)(s2)[0].v.tint) w
+ 
+ #define	cbranch_int_const_eq(s1, s2, w)		if ((s1)[0].v.tint == (s2)) w
+ #define	cbranch_int_const_ne(s1, s2, w)		if ((s1)[0].v.tint != (s2)) w
+ #define	cbranch_int_const_lt(s1, s2, w)		if ((s1)[0].v.tint < (s2)) w
+ #define	cbranch_int_const_le(s1, s2, w)		if ((s1)[0].v.tint <= (s2)) w
+ #define	cbranch_int_const_gt(s1, s2, w)		if ((s1)[0].v.tint > (s2)) w
+ #define	cbranch_int_const_ge(s1, s2, w)		if ((s1)[0].v.tint >= (s2)) w
+ #define	cbranch_int_const_ult(s1, s2, w)	if ((unsigned int)(s1)[0].v.tint < (unsigned int)(s2)) w
+ 
+ #define cbranch_ref_eq(s1, s2, w)		if ((s1)[0].v.taddr == (s2)[0].v.taddr) w
+ #define cbranch_ref_ne(s1, s2, w)		if ((s1)[0].v.taddr != (s2)[0].v.taddr) w
+ #define cbranch_ref_const_eq(s1, s2, w)		if ((s1)[0].v.taddr == (void*)(s2)) w
+ #define cbranch_ref_const_ne(s1, s2, w)		if ((s1)[0].v.taddr != (void*)(s2)) w
+ 
+ #define	call(m)					softcall_initialise_class(method_class()); \
+ 						virtualMachine((methods*)(m)[0].v.taddr, sp+1, retval, tid)
+ #define	call_indirect_method(m)			softcall_initialise_class(method_class()); \
+ 						virtualMachine(m, sp+1, retval, tid)
+ 
+ #define	ret()					goto end
+ 
+ #define	returnarg_int(s)			retval[0].v.tint = (s)[0].v.tint
+ #define	returnarg_ref(s)			retval[0].v.taddr = (s)[0].v.taddr
+ #define	returnarg_long(s)			retval[0].v.tlong = (s)[0].v.tlong
+ #define	returnarg_float(s)			retval[0].v.tfloat = (s)[0].v.tfloat
+ #define	returnarg_double(s)			retval[0].v.tdouble = (s)[0].v.tdouble
+ 
+ #define	pusharg_int_const(c, i)			/* Not needed for interpreter */
+ #define	pusharg_int(f, i)			/* Not needed for interpreter */
+ #define	pusharg_ref(f, i)			/* Not needed for interpreter */
+ #define	pusharg_ref_const(f, i)			/* Not needed for interpreter */
+ #define	pusharg_any(f, i)			/* Not needed for interpreter */
+ #define	pusharg_anylong(f, i)			/* Not needed for interpreter */
+ #define	popargs()				/* Not needed for interpreter */
+ 
+ #define	return_int(s)				(s)[0].v.tint = retval[0].v.tint
+ #define	return_long(s)				(s)[0].v.tlong = retval[0].v.tlong
+ #define	return_float(s)				(s)[0].v.tfloat = retval[0].v.tfloat
+ #define	return_double(s)			(s)[0].v.tdouble = retval[0].v.tdouble
+ #define	return_ref(s)				(s)[0].v.taddr = retval[0].v.taddr
+ 
+ #define	monitor_enter()				/* Not needed for interpreter */
+ #define	monitor_exit()				/* Not needed for interpreter */
+ 
+ #define	start_function()			/* Not needed for interpreter */
+ #define	start_basic_block()			/* Not needed for interpreter */
+ #define	end_basic_block()			/* Not needed for interpreter */
+ #define	end_function()				/* Not needed for interpreter */
+ #define	start_sub_block()			/* Not needed for interpreter */
+ #define	end_sub_block()				/* Not needed for interpreter */
+ 
+ #define	set_label(i, l)				label_##i##l:
+ #define	reference_code_label(l)			npc = (l)
+ #define	reference_label(i, l)			goto label_##i##l
+ #define	reference_table_label(l)		&bcode[npc]
+ #define	stored_code_label(l)			npc = (l)[0].v.tint
+ #define	table_code_label(l)			npc = (l)[0].v.tint + pc
+ 
+ #define	load_key(t, f)				(t)[0].v.tint = \
+ 						 ((((uint8*)(f)->v.taddr)[0] << 24) | \
+ 						 (((uint8*)(f)->v.taddr)[1] << 16) | \
+ 						 (((uint8*)(f)->v.taddr)[2] << 8) | \
+ 						 ((uint8*)(f)->v.taddr)[3])
+ #define	load_code_ref				load_key
+ 
+ #define	breakpoint()				ABORT()
+ 
+ #define	move_double(t, f)			(t)[0].v.tdouble = (f)[0].v.tdouble
+ #define	move_double_const(t, c)			(t)[0].v.tdouble = (c)
+ #define	move_float(t, f)			(t)[0].v.tfloat = (f)[0].v.tfloat
+ #define	move_float_const(t, c)			(t)[0].v.tfloat = (c)
+ #define	move_long(t, f)				(t)[0].v.tlong = (f)[0].v.tlong
+ #define	move_anylong(t, f)			move_long(t, f)
+ 
+ #define	load_short(t, f)			(t)[0].v.tint = *(jshort*)((f)[0].v.taddr)
+ #define	load_long(t, f)				(t)[0].v.tlong = *(jlong*)((f)[0].v.taddr)
+ #define	load_anylong(t, f)			load_long(t, f)
+ #define	load_float(t, f)			(t)[0].v.tfloat = *(jfloat*)((f)[0].v.taddr)
+ #define	load_double(t, f)			(t)[0].v.tdouble = *(jdouble*)((f)[0].v.taddr)
+ 
+ #define	store_short(t, f)			*(jshort*)((t)[0].v.taddr) = ((f)[0].v.tint)
+ #define	store_long(t, f)			*(jlong*)((t)[0].v.taddr) = ((f)[0].v.tlong)
+ #define	store_anylong(t, f)			store_long(t, f)
+ #define	store_float(t, f)			*(jfloat*)((t)[0].v.taddr) = ((f)[0].v.tfloat)
+ #define	store_double(t, f)			*(jdouble*)((t)[0].v.taddr) = ((f)[0].v.tdouble)
+ 
+ #define	load_offset_int(t, f, o)		(t)[0].v.tint = *(jint*)((uint8*)(f)[0].v.taddr + (o))
+ #define	load_offset_byte(t, f, o)		(t)[0].v.tint = *(jbyte*)((uint8*)(f)[0].v.taddr + (o))
+ #define	load_offset_char(t, f, o)		(t)[0].v.tint = *(jchar*)((uint8*)(f)[0].v.taddr + (o))
+ #define	load_offset_short(t, f, o)		(t)[0].v.tint = *(jshort*)((uint8*)(f)[0].v.taddr + (o))
+ #define	load_offset_ref(t, f, o)		(t)[0].v.taddr = *(void**)((uint8*)(f)[0].v.taddr + (o))
+ #define	load_offset_long(t, f, o)		(t)[0].v.tlong = *(jlong*)((uint8*)(f)[0].v.taddr + (o))
+ #define	load_offset_float(t, f, o)		(t)[0].v.tfloat = *(jfloat*)((uint8*)(f)[0].v.taddr + (o))
+ #define	load_offset_double(t, f, o)		(t)[0].v.tdouble = *(jdouble*)((uint8*)(f)[0].v.taddr + (o))
+ 
+ #define	store_offset_int(t, o, f)		*(jint*)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.tint)
+ #define	store_offset_byte(t, o, f)		*(jbyte*)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.tint)
+ #define	store_offset_char(t, o, f)		*(jchar*)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.tint)
+ #define	store_offset_short(t, o, f)		*(jshort*)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.tint)
+ #define	store_offset_ref(t, o, f)		*(void**)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.taddr)
+ #define	store_offset_long(t, o, f)		*(jlong*)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.tlong)
+ #define	store_offset_float(t, o, f)		*(jfloat*)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.tfloat)
+ #define	store_offset_double(t, o, f)		*(jdouble*)((uint8*)(t)[0].v.taddr + (o)) = ((f)[0].v.tdouble)
+ 
+ #define	load_offset_scaled_int(t, b, i, o)	(t)[0].v.tint = ((jint*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ #define	load_offset_scaled_byte(t, b, i, o)	(t)[0].v.tint = ((jbyte*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ #define	load_offset_scaled_char(t, b, i, o)	(t)[0].v.tint = ((jchar*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ #define	load_offset_scaled_short(t, b, i, o)	(t)[0].v.tint = ((jshort*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ #define	load_offset_scaled_ref(t, b, i, o)	(t)[0].v.taddr = ((void**)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ #define	load_offset_scaled_long(t, b, i, o)	(t)[0].v.tlong = ((jlong*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ #define	load_offset_scaled_float(t, b, i, o)	(t)[0].v.tfloat = ((jfloat*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ #define	load_offset_scaled_double(t, b, i, o)	(t)[0].v.tdouble = ((jdouble*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint]
+ 
+ #define	store_offset_scaled_int(b, i, o, f)	((jint*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.tint)
+ #define	store_offset_scaled_byte(b, i, o, f)	((jbyte*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.tint)
+ #define	store_offset_scaled_char(b, i, o, f)	((jchar*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.tint)
+ #define	store_offset_scaled_short(b, i, o, f)	((jshort*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.tint)
+ #define	store_offset_scaled_ref(b, i, o, f)	((void**)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.taddr)
+ #define	store_offset_scaled_long(b, i, o, f)	((jlong*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.tlong)
+ #define	store_offset_scaled_float(b, i, o, f)	((jfloat*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.tfloat)
+ #define	store_offset_scaled_double(b, i, o, f)	((jdouble*)((uint8*)(b)[0].v.taddr + (o)))[(i)[0].v.tint] = ((f)[0].v.tdouble)
+ 
+ #define	load_addr_int(t, a)	(t)[0].v.tint = *(jint*)(a)
+ #define	load_addr_byte(t, a)	(t)[0].v.tint = *(jbyte*)(a)
+ #define	load_addr_char(t, a)	(t)[0].v.tint = *(jchar*)(a)
+ #define	load_addr_short(t, a)	(t)[0].v.tint = *(jshort*)(a)
+ #define	load_addr_ref(t, a)	(t)[0].v.taddr = *(void**)(a)
+ #define	load_addr_long(t, a)	(t)[0].v.tlong = *(jlong*)(a)
+ #define	load_addr_float(t, a)	(t)[0].v.tfloat = *(jfloat*)(a)
+ #define	load_addr_double(t, a)	(t)[0].v.tdouble = *(jdouble*)(a)
+ 
+ #define	store_addr_int(a, f)	*(jint*)(a) = (f)[0].v.tint
+ #define	store_addr_byte(a, f)	*(jbyte*)(a) = (f)[0].v.tint
+ #define	store_addr_char(a, f)	*(jchar*)(a) = (f)[0].v.tint
+ #define	store_addr_short(a, f)	*(jshort*)(a) = (f)[0].v.tint
+ #define	store_addr_ref(a, f)	*(void**)(a) = (f)[0].v.taddr
+ #define	store_addr_long(a, f)	*(jlong*)(a) = (f)[0].v.tlong
+ #define	store_addr_float(a, f)	*(jfloat*)(a) = (f)[0].v.tfloat
+ #define	store_addr_double(a, f)	*(jdouble*)(a) = (f)[0].v.tdouble
+ 
+ #define	add_float(t, f1, f2)			(t)[0].v.tfloat = (f1)[0].v.tfloat + (f2)[0].v.tfloat
+ #define	add_double(t, f1, f2)			(t)[0].v.tdouble = (f1)[0].v.tdouble + (f2)[0].v.tdouble
+ #define	sub_float(t, f1, f2)			(t)[0].v.tfloat = (f1)[0].v.tfloat - (f2)[0].v.tfloat
+ #define	sub_double(t, f1, f2)			(t)[0].v.tdouble = (f1)[0].v.tdouble - (f2)[0].v.tdouble
+ #define	mul_float(t, f1, f2)			(t)[0].v.tfloat = (f1)[0].v.tfloat * (f2)[0].v.tfloat
+ #define	mul_double(t, f1, f2)			(t)[0].v.tdouble = (f1)[0].v.tdouble * (f2)[0].v.tdouble
+ #define	div_float(t, f1, f2)			(t)[0].v.tfloat = (f1)[0].v.tfloat / (f2)[0].v.tfloat
+ #define	div_double(t, f1, f2)			(t)[0].v.tdouble = (f1)[0].v.tdouble / (f2)[0].v.tdouble
+ #define	rem_float(t, f1, f2)			(t)[0].v.tfloat = javaRemainderf((f1)[0].v.tfloat, (f2)[0].v.tfloat)
+ #define	rem_double(t, f1, f2)			(t)[0].v.tdouble = javaRemainder((f1)[0].v.tdouble, (f2)[0].v.tdouble)
+ #define	neg_float(t, f)				(t)[0].v.tfloat = -(f)[0].v.tfloat
+ #define	neg_double(t, f)			(t)[0].v.tdouble = -(f)[0].v.tdouble
+ 
+ #define	cmpg_float(t, f1, f2)			(t)[0].v.tint = soft_fcmpg((f1)[0].v.tfloat, (f2)[0].v.tfloat)
+ #define	cmpg_double(t, f1, f2)			(t)[0].v.tint = soft_dcmpg((f1)[0].v.tdouble, (f2)[0].v.tdouble)
+ #define	cmpl_float(t, f1, f2)			(t)[0].v.tint = soft_fcmpl((f1)[0].v.tfloat, (f2)[0].v.tfloat)
+ #define	cmpl_double(t, f1, f2)			(t)[0].v.tint = soft_dcmpl((f1)[0].v.tdouble, (f2)[0].v.tdouble)
+ 
+ #define	cvt_int_float(t, f)			(t)[0].v.tfloat = (f)[0].v.tint
+ #define	cvt_int_double(t, f)			(t)[0].v.tdouble = (f)[0].v.tint
+ #define	cvt_float_int(t, f)			(t)[0].v.tint = floor((f)[0].v.tfloat)
+ #define	cvt_float_double(t, f)			(t)[0].v.tdouble = (f)[0].v.tfloat
+ #define	cvt_double_int(t, f)			(t)[0].v.tint = floor((f)[0].v.tdouble)
+ #define	cvt_double_float(t, f)			(t)[0].v.tfloat = (f)[0].v.tdouble
+ 
+ #define	softcall_lookupmethod(r, n, t)		(r)[0].v.taddr = soft_lookupmethod((t)[0].v.taddr, (n)->class, (n)->idx)
+ #define	softcall_new(r, t)			(r)->v.taddr = soft_new(t)
+ #define	softcall_newarray(r, s, t)		(r)->v.taddr = soft_newarray(t, (s)->v.tint)
+ #define	softcall_anewarray(r, s, t)		(r)->v.taddr = soft_anewarray(t, (s)->v.tint)
+ #define	softcall_athrow(s)			soft_athrow((s)[0].v.taddr)
+ #define	softcall_checkcast(n, o, t)		soft_checkcast(t, (o)->v.taddr)
+ #define softcall_initialise_class(cl)		soft_initialise_class(cl)
+ #define	softcall_instanceof(r, o, t)		(r)->v.tint = soft_instanceof(t, (o)->v.taddr)
+ 
+ /* Thread.stop() knows how to back out of java frames, so we do not
+  * want to disable stop here
+  */
+ #define	softcall_monitorenter(o)		lockObject((o)[0].v.taddr)
+ #define	softcall_monitorexit(o)			unlockObject((o)[0].v.taddr)
+ 
+ #define	softcall_multianewarray(r, z, s, t)	(r)->v.taddr = soft_multianewarray(t, z, s)
+ 
+ #define	softcall_badarrayindex()		soft_badarrayindex()
+ #define	softcall_nullpointer()			soft_nullpointer()
+ #define	softcall_nosuchmethod(c,n,s)		soft_nosuchmethod(c,n,s)
+ 
+ #define	softcall_checkarraystore(a, o)		soft_checkarraystore((a)[0].v.taddr, (o)[0].v.taddr)
+ #define	softcall_addreference(f, t)		soft_addreference((f)[0].v.taddr, (t)[0].v.taddr)
+ #define	softcall_addreference_static(f, t)	soft_addreference((f), (t)[0].v.taddr)
+ 
+ #define	adjustpc(a)				/* Not needed for interpreter */
+ 
+ #define	check_array_index(O, I)			if ((I)[0].v.tint >= ARRAY_SIZE((O)[0].v.taddr)) { \
+ 							soft_badarrayindex(); \
+ 						}
+ #define	build_call_frame(SIG, OBJ, NRARGS)	/* Not needed for interpreter */
+ 
+ 
+ #endif
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/machine.h threaded_with_quick/kaffe/kaffevm/threaded_int/machine.h
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/machine.h	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/machine.h	Thu Nov 11 19:50:37 1999
***************
*** 0 ****
--- 1,84 ----
+ /*
+  * machine.h
+  *
+  * Copyright (c) 1996, 1997
+  *	Transvirtual Technologies, Inc.  All rights reserved.
+  *
+  * See the file "license.terms" for information on usage and redistribution 
+  * of this file. 
+  */
+ 
+ #ifndef __machine_h
+ #define	__machine_h
+ 
+ #define current_class()		(meth->class)
+ 
+ #define getopcode()             (assert(0),0)
+ #define	putpc(n, v)		(assert(0),0)
+ 
+ #define	object_array_offset	(ARRAY_DATA_OFFSET)
+ #define	object_array_length	(ARRAY_SIZE_OFFSET)
+ 
+ #define get_method_info(idx)  \
+   if (getMethodSignatureClass(idx, meth->class, true, 0, &cinfo, &einfo) \
+ 	== false) { throwError(&einfo); }
+ 
+ #define get_special_method_info(idx)  \
+   if (getMethodSignatureClass(idx, meth->class, true, 1, &cinfo, &einfo) \
+         == false) { throwError(&einfo); }
+ 
+ #define get_interface_method_info(idx)  \
+   if (getMethodSignatureClass(idx, meth->class, true, 2, &cinfo, &einfo) \
+         == false) { throwError(&einfo); }
+ 
+ #define	get_dispatch_table(mtable) \
+ 	move_ref(mtable, ((slots*)&cinfo.class->dtable))
+ 
+ #define	method_name()		(cinfo.name)
+ #define	method_sig()		(cinfo.signature)
+ #define method_idx()		(cinfo.method->idx)
+ #define method_method()		(cinfo.method)
+ #define method_class()		(cinfo.class)
+ #define	method_nargs()		(cinfo.in)
+ #define	method_dtable_offset	OBJECT_DTABLE_OFFSET
+ #define	method_returntype()	(cinfo.rettype)
+ 
+ #define	get_field_info(IDX) \
+   if (getField(IDX, meth->class, false, &finfo, &einfo) == false) { \
+     throwError(&einfo); \
+   }
+ 
+ #define	get_static_field_info(IDX) \
+   if (getField(IDX, meth->class, true, &finfo, &einfo) == false) { \
+     throwError(&einfo); \
+   }
+ 
+ #define field_class()		(finfo.class)
+ #define field_statics()		(finfo.class->static_data)
+ 
+ #define	get_class_info(_idx) \
+   crinfo = getClass(_idx, meth->class, &einfo); \
+   if (crinfo == 0) { throwError(&einfo); }
+ 
+ #define	class_object()		(crinfo)
+ 
+ #define compile_time_error(EINFO) throwError(&EINFO)
+ 
+ #define	switchpair_size		8
+ #define	switchpair_addr		4
+ #define	switchtable_shift	2
+ 
+ /* Provide write barrier support for incremental GC */
+ #if defined(GC_INCREMENTAL)
+ #define	SOFT_ADDREFERENCE(_f, _t)	 softcall_addreference(_f, _t)
+ #define	SOFT_ADDREFERENCE_STATIC(_f, _t) softcall_addreference_static(_f, _t)
+ #else
+ #define	SOFT_ADDREFERENCE(_f, _t)
+ #define	SOFT_ADDREFERENCE_STATIC(_f, _t)
+ #endif
+ 
+ struct _methods;
+ struct Hjava_lang_Thread;
+ void virtualMachine(struct _methods*, slots*, slots*, struct Hjava_lang_Thread*);
+ 
+ #endif
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/slots.h threaded_with_quick/kaffe/kaffevm/threaded_int/slots.h
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/slots.h	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/slots.h	Sun Oct 31 19:21:24 1999
***************
*** 0 ****
--- 1,44 ----
+ /*
+  * slots.h
+  *
+  * Copyright (c) 1996, 1997
+  *	Transvirtual Technologies, Inc.  All rights reserved.
+  *
+  * See the file "license.terms" for information on usage and redistribution 
+  * of this file. 
+  */
+ 
+ #ifndef __slots_h
+ #define	__slots_h
+ 
+ #define	push(N)			sp += (N)
+ #define	pop(N)			sp -= (N)
+ 
+ #define	stack(N)		(&sp[-(N)])
+ #define	stack_long(N)		(&sp[-(N)-1])
+ #define	stack_ref		stack
+ #define	stack_float		stack
+ #define	stack_double		stack_long
+ 
+ #define	rstack			stack
+ #define	wstack			stack
+ #define	rstack_ref		stack_ref
+ #define	wstack_ref		stack_ref
+ #define	rstack_long		stack_long
+ #define	wstack_long		stack_long
+ #define	rstack_float		stack_float
+ #define	wstack_float		stack_float
+ #define	rstack_double		stack_double
+ #define	wstack_double		stack_double
+ 
+ #define	local(N)		(&lcl[(N)])
+ #define local_ref		local
+ #define local_long		local
+ #define local_float		local
+ #define local_double		local_long
+ 
+ #define	slot_alloctmp(s)	/* Does nothing for interpreter */
+ #define	slot_nowriteback(s)	/* Does nothing for interpreter */
+ #define	slot_nowriteback2(s)	/* Does nothing for interpreter */
+ 
+ #endif
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/threaded_int.def threaded_with_quick/kaffe/kaffevm/threaded_int/threaded_int.def
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/threaded_int.def	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/threaded_int.def	Sun Nov 21 18:05:37 1999
***************
*** 0 ****
--- 1,2876 ----
+ /* -*- c -*- */
+ /* $Id: threaded_int.def,v 1.1.2.1.2.4.2.7 1999/11/21 17:05:37 helmut Exp $ */
+ 
+ 
+ /*
+ Define the following macros before including this file.
+ 
+ # define instr(name,opcode,label,len,syntax,body) 
+ # define undef(name,opcode,label,len,syntax,body) 
+ # define custm(name,opcode,label,len,syntax,body) 
+ 
+ 
+ To avoid race conditions, rewriting proceeds as follows: 
+  1) the needed operands are fetched from the orignal byte code 
+  2) the new operands are written
+  3) the new operator is written
+  4) the quick-version of the instruction is executed.
+ 
+ Note: the byte code remains unchanged.
+ 
+ */
+ 
+ 
+ 
+ instr(NOP, 0, nop, 1, op, {})
+ 
+ instr(ACONST_NULL, 1, aconst_null, 1, op, {
+ 	/*
+ 	 * ... -> ..., 0
+ 	 */
+ 	push(1);
+ 	move_ref_const(stack(0), 0);
+ })
+ 
+ instr(ICONST_M1, 2, iconst_m1, 1, op, {
+ 	/*
+ 	 * ... -> ..., [-1 .. 5]
+ 	 */
+ 	push(1);
+ 	move_int_const(stack(0), -1);
+ })
+ instr(ICONST_0, 3, iconst_0, 1, op, {
+ 	/*
+ 	 * ... -> ..., [-1 .. 5]
+ 	 */
+ 	push(1);
+ 	move_int_const(stack(0), 0);
+ })
+ 
+ instr(ICONST_1, 4, iconst_1, 1, op, {
+ 	/*
+ 	 * ... -> ..., [-1 .. 5]
+ 	 */
+ 	push(1);
+ 	move_int_const(stack(0), 1);
+ })
+ 
+ instr(ICONST_2, 5, iconst_2, 1, op, {
+ 	/*
+ 	 * ... -> ..., [-1 .. 5]
+ 	 */
+ 	push(1);
+ 	move_int_const(stack(0), 2);
+ })
+ 
+ instr(ICONST_3, 6, iconst_3, 1, op, {
+ 	/*
+ 	 * ... -> ..., [-1 .. 5]
+ 	 */
+ 	push(1);
+ 	move_int_const(stack(0), 3 );
+ })
+ 
+ instr(ICONST_4, 7, iconst_4, 1, op, {
+ 	/*
+ 	 * ... -> ..., [-1 .. 5]
+ 	 */
+ 	push(1);
+ 	move_int_const(stack(0), 4);
+ })
+ 
+ instr(ICONST_5, 8, iconst_5, 1, op, {
+ 	 /*
+ 	  * ... -> ..., [-1 .. 5]
+ 	  */
+ 	 push(1);
+ 	 move_int_const(stack(0), 5 );
+ })
+ 
+ instr(LCONST_0, 9, lconst_0, 1, op, {
+ 	 /*
+ 	  * ... -> ..., 0, [0 .. 1]
+ 	  */
+ 	 push(2);
+ 	 move_long_const(stack_long(0), 0l);
+ })
+ 
+ instr(LCONST_1, 10, lconst_1, 1, op, {
+ 	/*
+ 	 * ... -> ..., 0, [0 .. 1]
+ 	 */
+ 	push(2);
+ 	move_long_const(stack_long(0), 1l);
+  })
+ 
+ instr(FCONST_0, 11, fconst_0, 1, op, {
+ 	/*
+ 	 * ... -> ..., [0.0 .. 2.0]
+ 	 */
+ 	push(1);
+ 	move_float_const(stack(0), (jfloat)0.0);
+ })
+  
+ instr(FCONST_1, 12, fconst_1, 1, op, {
+ 	/*
+ 	 * ... -> ..., [0.0 .. 2.0]
+ 	 */
+ 	push(1);
+ 	move_float_const(stack(0), (jfloat)1.0);
+ })
+ 
+ instr(FCONST_2, 13, fconst_2, 1, op, {
+ 	/*
+ 	 * ... -> ..., [0.0 .. 2.0]
+ 	 */
+ 	push(1);
+ 	move_float_const(stack(0), (jfloat)2.0);
+ })
+ 
+ instr(DCONST_0, 14, dconst_0, 1, op, {
+ 	/*
+ 	 * ... -> ..., [0.0 .. 1.0]
+ 	 */
+ 	push(2);
+ 	move_double_const(stack_double(0), ((jdouble)0.0));
+ })
+ 
+ instr(DCONST_1, 15, dconst_1, 1, op, {
+ 	     /*
+ 	 * ... -> ..., [0.0 .. 1.0]
+ 	 */
+ 	push(2);
+ 	move_double_const(stack_double(0), ((jdouble)1.0));
+ })
+ 
+ instr(BIPUSH, 16, bipush, 2, op_int8, {
+ 	/*
+ 	 * ... -> ..., val
+ 	 */
+ 	low = get_icode_int8(0);
+ 	push(1);
+ 	move_int_const(stack(0), low);
+ })
+ 
+ instr(SIPUSH, 17, sipush, 3, op_int16, {
+ 	/*
+ 	 * ... -> ..., val
+ 	 */
+ 	low = get_icode_int16(0);
+ 	push(1);
+ 	move_int_const(stack(0), low);
+ })
+ 
+ instr(LDC1, 18, ldc1, 2, op_uint8, {
+ 	unsigned index = (uint8)(getpc(0));
+ 	check_pc (0);
+ 	switch (CLASS_CONST_TAG(current_class(), index)) {
+ 	case CONSTANT_String:
+ 	  {
+ 			errorInfo _kdef_einfo;
+ 			void *s = resolveString(current_class(),index, &_kdef_einfo);
+ 
+ 			if (!s) { compile_time_error(_kdef_einfo); }
+ 			set_icode_p(1, s);
+ 			set_icode_p(0, &&ldc1_quick_s);
+ 			goto ldc1_quick_s;
+ 	  }
+ 	case CONSTANT_ResolvedString: {
+ 		void *s = (void*)CLASS_CONST_DATA(current_class(), index); 
+ 		set_icode_p(1, s);
+ 		set_icode_p(0, &&ldc1_quick_s);
+ 		goto ldc1_quick_s;
+ 	  }
+ 	case CONSTANT_Integer:{
+ 		jint i = CLASS_CONST_DATA(current_class(), index);
+ 		set_icode_i(1, i);
+ 		set_icode_p(0, &&ldc1_quick_i);
+ 		goto ldc1_quick_i;
+ 	  }
+ 	case CONSTANT_Float: {
+ 		jfloat f= *(float*)&(CLASS_CONST_DATA(current_class(), index));
+ 		set_icode_f(1, f);
+ 		set_icode_p(0, &&ldc1_quick_f);
+ 		goto ldc1_quick_f;
+ 	  }
+ 	default:
+ 		ABORT();
+ 	}
+ })
+ 
+ instr(LDC2, 19, ldc2, 3, op_uint16, {
+ 	unsigned index = (uint16)(getpc(0)<<8 | getpc(1));
+ 	check_pc (0);
+ 	switch (CLASS_CONST_TAG(current_class(), index)) {
+ 	case CONSTANT_String:
+ 	  {
+ 			errorInfo _kdef_einfo;
+ 			void *s = resolveString(current_class(),index, &_kdef_einfo);
+ 
+ 			if (!s) { compile_time_error(_kdef_einfo); }
+ 			set_icode_p(1, s);
+ 			set_icode_p(0, &&ldc2_quick_s);
+ 			goto ldc2_quick_s;
+ 	  }
+ 	case CONSTANT_ResolvedString: {
+ 		void *s = (void*)CLASS_CONST_DATA(current_class(), index); 
+ 		set_icode_p(1, s);
+ 		set_icode_p(0, &&ldc2_quick_s);
+ 		goto ldc2_quick_s;
+ 	  }
+ 	case CONSTANT_Integer:{
+ 		jint i = CLASS_CONST_DATA(current_class(), index);
+ 		set_icode_i(1, i);
+ 		set_icode_p(0, &&ldc2_quick_i);
+ 		goto ldc2_quick_i;
+ 	  }
+ 	case CONSTANT_Float: {
+ 		jfloat f= *(float*)&(CLASS_CONST_DATA(current_class(), index));
+ 		set_icode_f(1, f);
+ 		set_icode_p(0, &&ldc2_quick_f);
+ 		goto ldc2_quick_f;
+ 	  }
+ 	default:
+ 		ABORT();
+ 	}
+ })
+ 
+ instr(LDC2W, 20, ldc2w, 3, op_uint16, {
+ 	/*
+ 	 * ... -> ..., long const
+ 	 */
+ 	check_pcidx (0);
+ 
+ 	idx = get_icode_uint16(0);
+ 	tmpl = CLASS_CONST_LONG (current_class(), idx);
+ 	push(2);
+ 	switch (CLASS_CONST_TAG(current_class(), idx)) {
+ 	case CONSTANT_Long:
+ 		move_long_const(stack_long(0), tmpl);
+ 		break;
+ 	case CONSTANT_Double:
+ 		move_double_const(stack_double(0), *(jdouble*)&tmpl);
+ 		break;
+ 	default:
+ 		ABORT();
+ 	}
+ })
+ 
+ instr(ILOAD, 21, iload, 2, op_uint8, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_local_int(idx);
+ 
+ 	push(1);
+ 	move_int(stack(0), local(idx));
+ })
+ 
+ instr(LLOAD, 22, lload, 2, op_uint8, {
+ 	/*
+ 	 * ..., -> ..., long local variable
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_local_long(idx+1);
+ 
+ 	push(2);
+ 	move_long(stack_long(0), local_long(idx));
+ })
+ 
+ instr(FLOAD, 23, fload, 2, op_uint8, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_local_float(idx);
+ 
+ 	push(1);
+ 	move_float(stack(0), local_float(idx));
+ })
+ 
+ instr(DLOAD, 24, dload, 2, op_uint8, {
+ 	/*
+ 	 * ..., -> ..., double local variable
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_local_double(idx+1);
+ 
+ 	push(2);
+ 	move_double(stack_double(0), local_double(idx));
+ })
+ 
+ instr(ALOAD, 25, aload, 2, op_uint8, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_local_ref(idx);
+ 	push(1);
+ 	move_ref(stack(0), local(idx));
+ })
+ 
+ instr(ILOAD_0, 26, iload_0, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_int(0);
+ 
+ 	push(1);
+ 	move_int(stack(0), local(0));
+ })
+ 
+ instr(ILOAD_1, 27, iload_1, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_int(1);
+ 
+ 	push(1);
+ 	move_int(stack(0), local(1));
+ })
+ 
+ instr(ILOAD_2, 28, iload_2, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_int(2);
+ 
+ 	push(1);
+ 	move_int(stack(0), local(2));
+ })
+ 
+ instr(ILOAD_3, 29, iload_3, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_int(3);
+ 
+ 	push(1);
+ 	move_int(stack(0), local(3));
+ })
+ 
+ instr(LLOAD_0, 30, lload_0, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_long((0)+1);
+ 
+ 	push(2);
+ 	move_long(stack_long(0), local_long(0));
+ })
+ 
+ instr(LLOAD_1, 31, lload_1, 1, op, {
+ 	     /*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_long((1)+1);
+ 
+ 	push(2);
+ 	move_long(stack_long(0), local_long(1));
+ })
+ 
+ instr(LLOAD_2, 32, lload_2, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_long((2)+1);
+ 
+ 	push(2);
+ 	move_long(stack_long(0), local_long(2));
+ })
+ 
+ instr(LLOAD_3, 33, lload_3, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_long((3)+1);
+ 
+ 	push(2);
+ 	move_long(stack_long(0), local_long(3));
+ })
+ 
+ instr(FLOAD_0, 34, fload_0, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_float(0);
+ 
+ 	push(1);
+ 	move_float(stack(0), local_float(0));
+ })
+ 
+ instr(FLOAD_1, 35, fload_1, 1, op, 
+  {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_float(1);
+ 
+ 	push(1);
+ 	move_float(stack(0), local_float(1));
+ })
+ 
+ instr(FLOAD_2, 36, fload_2, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_float(2);
+ 
+ 	push(1);
+ 	move_float(stack(0), local_float(2));
+ })
+ 
+ instr(FLOAD_3, 37, fload_3, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_float(3);
+ 
+ 	push(1);
+ 	move_float(stack(0), local_float(3));
+ })
+ 
+ instr(DLOAD_0, 38, dload_0, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_double((0)+1);
+ 
+ 	push(2);
+ 	move_double(stack_double(0), local_double(0));
+ })
+ 
+ instr(DLOAD_1, 39, dload_1, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_double((1)+1);
+ 
+ 	push(2);
+ 	move_double(stack_double(0), local_double(1));
+ })
+ 
+ instr(DLOAD_2, 40, dload_2, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_double((2)+1);
+ 
+ 	push(2);
+ 	move_double(stack_double(0), local_double(2));
+ })
+ 
+ instr(DLOAD_3, 41, dload_3, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_double((3)+1);
+ 
+ 	push(2);
+ 	move_double(stack_double(0), local_double(3));
+ })
+ 
+ instr(ALOAD_0, 42, aload_0, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_ref(0);
+ 
+ 	push(1);
+ 	move_ref(stack(0), local(0));
+ })
+ 
+ instr(ALOAD_1, 43, aload_1, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_ref(1);
+ 
+ 	push(1);
+ 	move_ref(stack(0), local(1));
+ })
+ 
+ instr(ALOAD_2, 44, aload_2, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_ref(2);
+ 
+ 	push(1);
+ 	move_ref(stack(0), local(2));
+ })
+ 
+ instr(ALOAD_3, 45, aload_3, 1, op, {
+ 	/*
+ 	 * ..., -> ..., local variable
+ 	 */
+ 	check_local_ref(3);
+ 
+ 	push(1);
+ 	move_ref(stack(0), local(3));
+ })
+ 
+ 
+ instr(IALOAD, 46, iaload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_intarray(1);
+ 
+ 	CHECK_NULL (IALOAD, rstack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_int(stack(1), rstack(1), rstack(0), object_array_offset);
+ 	pop(1);
+ })
+ 
+ instr(LALOAD, 47, laload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., long value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_longarray(1);
+ 
+ 	CHECK_NULL (LALOAD, stack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_long(stack_long(0), stack(1), stack(0), object_array_offset);
+ })
+ 
+ instr(FALOAD, 48, faload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., float value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_floatarray(1);
+ 
+ 	CHECK_NULL (FALOAD, stack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_float(stack(1), stack(1), stack(0), object_array_offset);
+ 
+ 	pop(1);
+ })
+ 
+ instr(DALOAD, 49, daload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., double value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_doublearray(1);
+ 
+ 	CHECK_NULL (DALOAD, stack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_double(stack_double(0), stack(1), stack(0), object_array_offset);
+ })
+ 
+ instr(AALOAD, 50, aaload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., ref value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_refarray(1);
+ 
+ 	CHECK_NULL(AALOAD, rstack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_ref(stack(1), rstack(1), rstack(0), object_array_offset);
+ 	pop(1);
+ })
+ 
+ instr(BALOAD, 51, baload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., byte value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_bytearray(1);
+ 
+ 	CHECK_NULL(BALOAD, rstack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_byte(stack(1), rstack(1), rstack(0), object_array_offset);
+ 	pop(1);
+ })
+ 
+ instr(CALOAD, 52, caload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., char value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_chararray(1);
+ 
+ 	CHECK_NULL(CALOAD, rstack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_char(stack(1), rstack(1), rstack(0), object_array_offset);
+ 	pop(1);
+ })
+ 
+ instr(SALOAD, 53, saload, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx -> ..., short value
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_shortarray(1);
+ 
+ 	CHECK_NULL(SALOAD, rstack(1), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(1), rstack(0));
+ 
+ 	load_offset_scaled_short(stack(1), rstack(1), rstack(0), object_array_offset);
+ 	pop(1);
+ })
+ 
+ instr(ISTORE, 54, istore, 2, op_uint8, {
+ 	/*
+ 	 * ..., var -> ...
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_stack_int(0);
+ 
+ 	move_int(local(idx), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(LSTORE, 55, lstore, 2, op_uint8, {
+ 	/*
+ 	 * ..., long var -> ...
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_stack_long(0);
+ 
+ 	move_long(local_long(idx), stack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(FSTORE, 56, fstore, 2, op_uint8, {
+ 	/*
+ 	 * ..., var -> ...
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_stack_float(0);
+ 
+ 	move_float(local_float(idx), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(DSTORE, 57, dstore, 2, op_uint8, {
+ 	/*
+ 	 * ..., var -> ...
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_stack_double(0);
+ 
+ 	move_double(local_double(idx), stack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(ASTORE, 58, astore, 2, op_uint8, {
+ 	/*
+ 	 * ..., var -> ...
+ 	 */
+ 	check_pc (0);
+ 	idx = get_icode_uint8(0);
+ 
+ 	check_stack_ref(0);
+ 
+ 	move_ref(local(idx), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(ISTORE_0, 59, istore_0, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 
+ 	move_int(local(0), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(ISTORE_1, 60, istore_1, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 
+ 	move_int(local(1), stack(0));
+ 	pop(1);
+  })
+ 
+ instr(ISTORE_2, 61, istore_2, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 
+ 	move_int(local(2), stack(0));
+ 	pop(1);
+  })
+ 
+ instr(ISTORE_3, 62, istore_3, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 
+ 	move_int(local(3), stack(0));
+ 	pop(1);
+  })
+ 
+ instr(LSTORE_0, 63, lstore_0, 1, op, {
+ 	/*
+ 	 * ..., long val -> ...
+ 	 */
+ 	check_stack_long(0);
+ 
+ 	move_long(local_long(0), stack_long(0));
+ 	pop(2);
+  })
+ 
+ instr(LSTORE_1, 64, lstore_1, 1, op, {
+ 	/*
+ 	 * ..., long val -> ...
+ 	 */
+ 	check_stack_long(0);
+ 
+ 	move_long(local_long(1), stack_long(0));
+ 	pop(2);
+  })
+ 
+ instr(LSTORE_2, 65, lstore_2, 1, op, {
+ 	/*
+ 	 * ..., long val -> ...
+ 	 */
+ 	check_stack_long(0);
+ 
+ 	move_long(local_long(2), stack_long(0));
+ 	pop(2);
+  })
+ 
+ instr(LSTORE_3, 66, lstore_3, 1, op, {
+ 	/*
+ 	 * ..., long val -> ...
+ 	 */
+ 	check_stack_long(0);
+ 
+ 	move_long(local_long(3), stack_long(0));
+ 	pop(2);
+  })
+ 
+ instr(FSTORE_0, 67, fstore_0, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_float(0);
+ 
+ 	move_float(local_float(0), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(FSTORE_1, 68, fstore_1, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_float(0);
+ 
+ 	move_float(local_float(1), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(FSTORE_2, 69, fstore_2, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_float(0);
+ 
+ 	move_float(local_float(2), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(FSTORE_3, 70, fstore_3, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_float(0);
+ 
+ 	move_float(local_float(3), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(DSTORE_0, 71, dstore_0, 1, op, {
+ 	/*
+ 	 * ..., double val -> ...
+ 	 */
+ 	check_stack_double(0);
+ 
+ 	move_double(local_double(0), stack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(DSTORE_1, 72, dstore_1, 1, op, {
+ 	/*
+ 	 * ..., double val -> ...
+ 	 */
+ 	check_stack_double(0);
+ 
+ 	move_double(local_double(1), stack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(DSTORE_2, 73, dstore_2, 1, op, {
+ 	/*
+ 	 * ..., double val -> ...
+ 	 */
+ 	check_stack_double(0);
+ 
+ 	move_double(local_double(2), stack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(DSTORE_3, 74, dstore_3, 1, op, {
+ 	/*
+ 	 * ..., double val -> ...
+ 	 */
+ 	check_stack_double(0);
+ 
+ 	move_double(local_double(3), stack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(ASTORE_0, 75, astore_0, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_ref(0);
+ 
+ 	move_ref(local(0), stack(0));
+ 	pop(1);
+ }) 
+ 
+ instr(ASTORE_1, 76, astore_1, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_ref(0);
+ 
+ 	move_ref(local(1), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(ASTORE_2, 77, astore_2, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_ref(0);
+ 
+ 	move_ref(local(2), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(ASTORE_3, 78, astore_3, 1, op, {
+ 	/*
+ 	 * ..., val -> ...
+ 	 */
+ 	check_stack_ref(0);
+ 
+ 	move_ref(local(3), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(IASTORE, 79, iastore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_intarray(2);
+ 
+ 	CHECK_NULL(IASTORE, rstack(2), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(2), rstack(1));
+ 
+ 	store_offset_scaled_int(rstack(2), rstack(1), object_array_offset, rstack(0));
+ 	pop(3);
+ })
+ 
+ instr(LASTORE, 80, lastore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, long val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_longarray(2);
+ 
+ 	CHECK_NULL(LASTORE, stack(3), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(3), rstack(2));
+ 
+ 	store_offset_scaled_long(stack(3), stack(2), object_array_offset, stack_long(0));
+ 	pop(4);
+ })
+ 
+ instr(FASTORE, 81, fastore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, float val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_floatarray(2);
+ 
+ 	CHECK_NULL(FASTORE, stack(2), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(2), rstack(1));
+ 
+ 	store_offset_scaled_float(stack(2), stack(1), object_array_offset, stack(0));
+ 	pop(3);
+ })
+ 
+ instr(DASTORE, 82, dastore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, double val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_doublearray(2);
+ 
+ 	CHECK_NULL(DASTORE, stack(3), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(3), rstack(2));
+ 
+ 	store_offset_scaled_double(stack(3), stack(2), object_array_offset, stack_double(0));
+ 
+ 	pop(4);
+ })
+ 
+ instr(AASTORE, 83, aastore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, val -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_refarray(2);
+ 
+ 	CHECK_NULL(AASTORE, rstack(2), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(2), rstack(1));
+ 
+ 	softcall_checkarraystore(rstack(2), rstack(0));
+ 
+ 	/* rstack(2) may be a kaffe.util.Ptr[].  GC_WRITE must
+ 	 * check for that, but at least rstack(2) is a real java
+ 	 * object. 
+ 	 */
+ 	SOFT_ADDREFERENCE(rstack(2), rstack(0));
+ 
+ 	store_offset_scaled_ref(rstack(2), rstack(1), object_array_offset, rstack(0));
+ 	pop(3);
+ })
+ 
+ instr(BASTORE, 84, bastore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, byte value  -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_bytearray(2);
+ 
+ 	CHECK_NULL(BASTORE, rstack(2), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(2), rstack(1));
+ 
+ 	store_offset_scaled_byte(rstack(2), rstack(1), object_array_offset, rstack(0));
+ 	pop(3);
+ })
+ 
+ instr(CASTORE, 85, castore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, char value  -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_chararray(2);
+ 
+ 	CHECK_NULL(CASTORE, rstack(2), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(2), rstack(1));
+ 
+ 	store_offset_scaled_char(rstack(2), rstack(1), object_array_offset, rstack(0));
+ 	pop(3);
+ })
+ 
+ instr(SASTORE, 86, sastore, 1, op, {
+ 	/*
+ 	 * ..., array ref, idx, short value  -> ...
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 	check_stack_shortarray(2);
+ 
+ 	CHECK_NULL(SASTORE, rstack(2), 34);
+ 
+ 	/* Check we are within the array bounds */
+ 	check_array_index(rstack(2), rstack(1));
+ 
+ 	store_offset_scaled_short(rstack(2), rstack(1), object_array_offset, rstack(0));
+ 	pop(3);
+ })
+ 
+ instr(POP, 87, pop, 1, op, {
+ 	pop(1);
+ })
+ 
+ instr(POP2, 88, pop2, 1, op, {
+ 	pop(2);
+ })
+ 
+ instr(DUP, 89, dup, 1, op, {
+ 	push(1);
+ 	move_any(stack(0), stack(1));
+ })
+ 
+ instr(DUP_X1, 90, dup_x1, 1, op, {
+ 	push(1);
+ 	move_any(stack(0), stack(1));
+ 	move_any(stack(1), stack(2));
+ 	move_any(stack(2), stack(0));
+ })
+ 
+ instr(DUP_X2, 91, dup_x2, 1, op, {
+ 	push(1);
+ 	move_any(stack(0), stack(1));
+ 	move_any(stack(1), stack(2));
+ 	move_any(stack(2), stack(3));
+ 	move_any(stack(3), stack(0));
+ })
+ 
+ instr(DUP2, 92, dup2, 1, op, {
+ 	push(2);
+ 	move_any(stack(0), stack(2));
+ 	move_any(stack(1), stack(3));
+ })
+ 
+ instr(DUP2_X1, 93, dup2_x1, 1, op, {
+ 	push(2);
+ 	move_any(stack(0), stack(2));
+ 	move_any(stack(1), stack(3));
+ 	move_any(stack(2), stack(4));
+ 	move_any(stack(3), stack(0));
+ 	move_any(stack(4), stack(1));
+ })
+ 
+ instr(DUP2_X2, 94, dup2_x2, 1, op, {
+ 	push(2);
+ 	move_any(stack(0), stack(2));
+ 	move_any(stack(1), stack(3));
+ 	move_any(stack(2), stack(4));
+ 	move_any(stack(3), stack(5));
+ 	move_any(stack(4), stack(0));
+ 	move_any(stack(5), stack(1));
+ })
+ 
+ instr(SWAP, 95, swap, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val2, val1
+          */
+ 	swap_any(stack(0), stack(1));
+ })
+ 
+ instr(IADD, 96, iadd, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1+val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	add_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LADD, 97, ladd, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1+val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	add_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(FADD, 98, fadd, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1+val2
+          */
+ 	check_stack_float(0);
+ 	check_stack_float(1);
+ 
+ 	add_float(stack_float(1), rstack_float(1), rstack_float(0));
+ 	pop(1);
+ })
+ 
+ instr(DADD, 99, dadd, 1, op, {
+         /*
+          * ..., double val1, long val2 -> ..., double val1+val2
+          */
+ 	check_stack_double(0);
+ 	check_stack_double(2);
+ 
+ 	add_double(stack_double(2), rstack_double(2), rstack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(ISUB, 100, isub, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1-val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	sub_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LSUB, 101, lsub, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1-val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	sub_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(FSUB, 102, fsub, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1-val2
+          */
+ 	check_stack_float(0);
+ 	check_stack_float(1);
+ 
+ 	sub_float(stack_float(1), rstack_float(1), rstack_float(0));
+ 	pop(1);
+ })
+ 
+ instr(DSUB, 103, dsub, 1, op, {
+         /*
+          * ..., double val1, long val2 -> ..., double val1-val2
+          */
+ 	check_stack_double(0);
+ 	check_stack_double(2);
+ 
+ 	sub_double(stack_double(2), rstack_double(2), rstack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(IMUL, 104, imul, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1*val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	mul_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LMUL, 105, lmul, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1*val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	mul_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(FMUL, 106, fmul, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1*val2
+          */
+ 	check_stack_float(0);
+ 	check_stack_float(1);
+ 
+ 	mul_float(stack_float(1), rstack_float(1), rstack_float(0));
+ 	pop(1);
+ })
+ 
+ instr(DMUL, 107, dmul, 1, op, {
+         /*
+          * ..., double val1, long val2 -> ..., double val1*val2
+          */
+ 	check_stack_double(0);
+ 	check_stack_double(2);
+ 
+ 	mul_double(stack_double(2), rstack_double(2), rstack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(IDIV, 108, idiv, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1/val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	div_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LDIV, 109, ldiv, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1/val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	div_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(FDIV, 110, fdiv, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1/val2
+          */
+ 	check_stack_float(0);
+ 	check_stack_float(1);
+ 
+ 	div_float(stack_float(1), rstack_float(1), rstack_float(0));
+ 	pop(1);
+ })
+ 
+ instr(DDIV, 111, ddiv, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1/val2
+          */
+ 	check_stack_double(0);
+ 	check_stack_double(2);
+ 
+ 	div_double(stack_double(2), rstack_double(2), rstack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(IREM, 112, irem, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1%val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	rem_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LREM, 113, lrem, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1%val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	rem_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(FREM, 114, frem, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1%val2
+          */
+ 	check_stack_float(0);
+ 	check_stack_float(1);
+ 
+ 	rem_float(stack_float(1), rstack_float(1), rstack_float(0));
+ 	pop(1);
+ })
+ 
+ instr(DREM, 115, drem, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1%val2
+          */
+ 	check_stack_double(0);
+ 	check_stack_double(2);
+ 
+ 	rem_double(stack_double(2), rstack_double(2), rstack_double(0));
+ 	pop(2);
+ })
+ 
+ instr(INEG, 116, ineg, 1, op, {
+ 	check_stack_int(0);
+ 
+ 	neg_int(stack(0), rstack(0));
+ })
+ 
+ instr(LNEG, 117, lneg, 1, op, {
+ 	check_stack_long(0);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 
+ 	neg_long(stack_long(0), rstack_long(0));
+ })
+ 
+ instr(FNEG, 118, fneg, 1, op, {
+ 	check_stack_float(0);
+ 
+ 	neg_float(stack_float(0), rstack_float(0));
+ })
+ 
+ instr(DNEG, 119, dneg, 1, op, {
+ 	check_stack_double(0);
+ 
+ 	neg_double(stack_double(0), rstack_double(0));
+ })
+ 
+ instr(ISHL, 120, ishl, 1, op, {
+ 	/*
+ 	 * ..., val1, val2 -> ... val1 << val2
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	lshl_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LSHL, 121, lshl, 1, op, {
+ 	/*
+ 	 * ..., long val1, val2 -> ... long val1 << val2
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_long(1);
+ 
+ 	slot_nowriteback(stack(0));
+ 	slot_nowriteback2(stack_long(1));
+ 
+ 	lshl_long(stack_long(1), stack_long(1), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(ISHR, 122, ishr, 1, op, {
+ 	/*
+ 	 * ..., val1, val2 -> ... val1 >> val2
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	ashr_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LSHR, 123, lshr, 1, op, {
+ 	/*
+ 	 * ..., long val1, val2 -> ... long val1 >> val2
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_long(1);
+ 
+ 	slot_nowriteback(stack(0));
+ 	slot_nowriteback2(stack_long(1));
+ 
+ 	ashr_long(stack_long(1), stack_long(1), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(IUSHR, 124, iushr, 1, op, {
+ 	/*
+ 	 * ..., val1, val2 -> ... val1 >> val2
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	lshr_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LUSHR, 125, lushr, 1, op, {
+ 	/*
+ 	 * ..., long val1, val2 -> ... long val1 >> val2
+ 	 */
+ 	check_stack_int(0);
+ 	check_stack_long(1);
+ 
+ 	slot_nowriteback(stack(0));
+ 	slot_nowriteback2(stack_long(1));
+ 
+ 	lshr_long(stack_long(1), stack_long(1), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(IAND, 126, iand, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1 & val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	and_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LAND, 127, land, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1 & val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	and_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(IOR, 128, ior, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1 | val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	or_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LOR, 129, lor, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1 | val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	or_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(IXOR, 130, ixor, 1, op, {
+         /*
+          * ..., val1, val2 -> ..., val1 ^ val2
+          */
+ 	check_stack_int(0);
+ 	check_stack_int(1);
+ 
+ 	xor_int(stack(1), rstack(1), rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(LXOR, 131, lxor, 1, op, {
+         /*
+          * ..., long val1, long val2 -> ..., long val1 ^ val2
+          */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	xor_long(stack_long(2), rstack_long(2), rstack_long(0));
+ 	pop(2);
+ })
+ 
+ instr(IINC, 132, iinc, 3, op_uint8_int8, {
+ 	idx = get_icode_uint8(0);
+ 	low = get_icode_int8(1);
+ 
+ 	check_local_int(idx);
+ 
+ 	add_int_const(local(idx), local(idx), low);
+ })
+ 
+ instr(I2L, 133, i2l, 1, op, {
+ 	check_stack_int(0);
+ 
+ 	push(1);
+ 	cvt_int_long(stack_long(0), stack(1));
+ })
+ 
+ instr(I2F, 134, i2f, 1, op, {
+ 	check_stack_int(0);
+ 
+ 	cvt_int_float(stack(0), stack(0));
+ })
+ 
+ instr(I2D, 135, i2d, 1, op, {
+ 	check_stack_int(0);
+ 
+ 	push(1);
+ 	cvt_int_double(stack_double(0), stack(1));
+ })
+ 
+ instr(L2I, 136, l2i, 1, op, {
+ 	check_stack_long(0);
+ 
+ 	cvt_long_int(stack(1), stack_long(0));
+ 	pop(1);
+ })
+ 
+ instr(L2F, 137, l2f, 1, op, {
+ 	check_stack_long(0);
+ 
+ 	cvt_long_float(stack(1), stack_long(0));
+ 	pop(1);
+ })
+ 
+ instr(L2D, 138, l2d, 1, op, {
+ 	check_stack_long(0);
+ 
+ 	cvt_long_double(stack_double(0), stack_long(0));
+ })
+ 
+ instr(F2I, 139, f2i, 1, op, {
+ 	check_stack_float(0);
+ 
+ 	cvt_float_int(stack(0), stack(0));
+ })
+ 
+ instr(F2L, 140, f2l, 1, op, {
+ 	check_stack_float(0);
+ 
+ 	push(1);
+ 	cvt_float_long(stack_long(0), stack(1));
+ })
+ 
+ instr(F2D, 141, f2d, 1, op, {
+ 	check_stack_float(0);
+ 
+ 	push(1);
+ 	cvt_float_double(stack_double(0), stack(1));
+ })
+ 
+ instr(D2I, 142, d2i, 1, op, {
+ 	check_stack_double(0);
+ 
+ 	cvt_double_int(stack(1), stack_double(0));
+ 	pop(1);
+ })
+ 
+ instr(D2L, 143, d2l, 1, op, {
+ 	check_stack_double(0);
+ 
+ 	cvt_double_long(stack_long(0), stack_double(0));
+ })
+ 
+ instr(D2F, 144, d2f, 1, op, {
+ 	check_stack_double(0);
+ 
+ 	cvt_double_float(stack(1), stack_double(0));
+ 	pop(1);
+ })
+ 
+ instr(INT2BYTE, 145, int2byte, 1, op, {
+ 	check_stack_int(0);
+ 
+ 	cvt_int_byte(stack(0), rstack(0));
+ })
+ 
+ instr(INT2CHAR, 146, int2char, 1, op, {
+ 	check_stack_int(0);
+ 
+ 	cvt_int_char(stack(0), rstack(0));
+ })
+ 
+ instr(INT2SHORT, 147, int2short, 1, op, {
+ 	check_stack_int(0);
+ 
+ 	cvt_int_short(stack(0), rstack(0));
+ })
+ 
+ instr(LCMP, 148, lcmp, 1, op, {
+ 	/*
+ 	 * ..., long val1, long val2 -> ..., result
+ 	 */
+ 	check_stack_long(0);
+ 	check_stack_long(2);
+ 
+ 	slot_nowriteback2(stack_long(0));
+ 	slot_nowriteback2(stack_long(2));
+ 
+ 	lcmp(stack(3), rstack_long(0), rstack_long(2));
+ 	pop(3);
+ })
+ 
+ instr(FCMPL, 149, fcmpl, 1, op, {
+ 	/*
+ 	 * ..., float val1, float val2 -> ..., result
+ 	 */
+ 	check_stack_float(0);
+ 	check_stack_float(1);
+ 
+ 	cmpl_float(stack(1), stack(1), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(FCMPG, 150, fcmpg, 1, op, {
+ 	/*
+ 	 * ..., float val1, float val2 -> ..., result
+ 	 */
+ 	check_stack_float(0);
+ 	check_stack_float(1);
+ 
+ 	cmpg_float(stack(1), stack(1), stack(0));
+ 	pop(1);
+ })
+ 
+ instr(DCMPL, 151, dcmpl, 1, op, {
+ 	/*
+ 	 * ..., double val1, double val2 -> ..., result
+ 	 */
+ 	check_stack_double(0);
+ 	check_stack_double(2);
+ 
+ 	cmpl_double(stack(3), stack_double(2), stack_double(0));
+ 	pop(3);
+ })
+ 
+ instr(DCMPG, 152, dcmpg, 1, op, {
+ 	/*
+ 	 * ..., double val1, double val2 -> ..., result
+ 	 */
+ 	check_stack_double(0);
+ 	check_stack_double(2);
+ 
+ 	cmpg_double(stack(3), stack_double(2), stack_double(0));
+ 	pop(3);
+ })
+ 
+ /* ..., value => ... */
+ instr(IFEQ, 153, ifeq, 3, op_int16, {
+ 	jint value = stack(0)->v.tint;
+ 	pop(1);
+ 	if (value == 0) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	}
+ })
+ 
+ instr(IFNE, 154, ifne, 3, op_int16, {
+ 	jint value = stack(0)->v.tint;
+ 	pop(1);
+ 	if (value != 0) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	}
+ })
+ 
+ instr(IFLT, 155, iflt, 3, op_int16, {
+ 	jint value = stack(0)->v.tint;
+ 	pop(1);
+ 	if (value < 0) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	}
+ })
+ 
+ instr(IFGE, 156, ifge, 3, op_int16, {
+ 	jint value = stack(0)->v.tint;
+ 	pop(1);
+ 	if (value >= 0) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	}
+ })
+ 
+ instr(IFGT, 157, ifgt, 3, op_int16, {
+ 	jint value = stack(0)->v.tint;
+ 	pop(1);
+ 	if (value > 0) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	}
+ })
+ 
+ instr(IFLE, 158, ifle, 3, op_int16, {
+ 	jint value = stack(0)->v.tint;
+ 	pop(1);
+ 	if (value <= 0) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	}
+ })
+ 
+ 
+ instr(IF_ICMPEQ, 159, if_icmpeq, 3, op_int16, {
+ 	jint value1 = stack(1)->v.tint;
+ 	jint value2 = stack(0)->v.tint;
+ 	pop(2);
+ 	if(value1 == value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	} 
+ })
+ 
+ instr(IF_ICMPNE, 160, if_icmpne, 3, op_int16, {
+ 	jint value1 = stack(1)->v.tint;
+ 	jint value2 = stack(0)->v.tint;
+ 	pop(2);
+ 	if(value1 != value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	} 
+ })
+ 
+ instr(IF_ICMPLT, 161, if_icmplt, 3, op_int16, {
+ 	jint value1 = stack(1)->v.tint;
+ 	jint value2 = stack(0)->v.tint;
+ 	pop(2);
+ 	if(value1 < value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	} 
+ })
+ 
+ instr(IF_ICMPGE, 162, if_icmpge, 3, op_int16, {
+ 	jint value1 = stack(1)->v.tint;
+ 	jint value2 = stack(0)->v.tint;
+ 	pop(2);
+ 	if(value1 >= value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 		
+ 	} 
+ })
+ 
+ instr(IF_ICMPGT, 163, if_icmpgt, 3, op_int16, {
+ 	jint value1 = stack(1)->v.tint;
+ 	jint value2 = stack(0)->v.tint;
+ 	pop(2);
+ 	if(value1 > value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 	} 
+ })
+ 
+ instr(IF_ICMPLE, 164, if_icmple, 3, op_int16, {
+ 	jint value1 = stack(1)->v.tint;
+ 	jint value2 = stack(0)->v.tint;
+ 	pop(2);
+ 	if(value1 <= value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 	} 
+ })
+ 
+ instr(IF_ACMPEQ, 165, if_acmpeq, 3, op_int16, {
+ 	jref value1 = stack(1)->v.taddr;
+ 	jref value2 = stack(0)->v.taddr;
+ 	pop(2);
+ 	if(value1 == value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 	} 
+ })
+ 
+ instr(IF_ACMPNE, 166, if_acmpne, 3, op_int16, {
+ 	jref value1 = stack(1)->v.taddr;
+ 	jref value2 = stack(0)->v.taddr;
+ 	pop(2);
+ 	if(value1 != value2) {
+ 		int offset = get_icode_int16(0);
+ 		BRA(offset);
+ 	} 
+ })
+ 
+ instr(GOTO, 167, goto_, 3, op_int16, {
+ 	int offset = get_icode_int16(0);
+ 	BRA(offset);
+ })
+ 
+ instr(JSR, 168, jsr, 3, op_int16, {
+ 	int offset = get_icode_int16(0);
+ 	Instr *ret_addr = IP+3;
+ 	PUSH_L(ret_addr);
+ 	BRA(offset);
+ })
+ 
+ instr(RET, 169, ret, 2, op_uint8, {
+ 	Instr *saved_ip=0;
+ 	idx = get_icode_uint8(0);
+ 	saved_ip = local(idx)->v.taddr;
+ 	JMP(saved_ip);
+ })
+ 
+ 
+ 
+ 
+ 
+ 
+ instr(TABLESWITCH, 170, tableswitch, 0, special_tableswitch, {
+ 	jint index = stack(0)->v.tint;
+ 	jint low = get_icode_int32(1);
+ 	jint high = get_icode_int32(2);
+ 	pop(1);
+ 	if( index<low || high<index ) {
+ 		jint default_ = get_icode_int32(0);
+ 		BRA(default_);
+ 	} else {
+ 		jint offset = get_icode_int32(3+index-low);
+ 		BRA(offset);
+ 	}
+ })
+ 
+ instr(LOOKUPSWITCH, 171, lookupswitch, 0 , special_lookupswitch, {
+ 	  jint key = stack(0)->v.tint;
+ 	  int npairs = get_icode_int32(1);
+ 	  unsigned i;
+ 	  pop(1);
+ 	  for(i=0; i<npairs; i++) {
+ 		  jint match = get_icode_int32(i*2+2);
+ 		  if (key == match) {
+ 			  int offset = get_icode_int32(i*2+3);
+ 			  BRA(offset);
+ 		  }  
+ 		  if (match > key) break;
+ 	  }
+ 	  {
+ 		  int default_ = get_icode_int32(0);
+ 		  BRA(default_);
+ 	  }
+ })
+ 
+ 
+ 
+ instr(IRETURN, 172, ireturn, 1, special_return, {
+ 	check_stack_int(0);
+ 
+ 	monitor_exit();
+ 	returnarg_int(rstack(0));
+ 	end_function();
+ 	ret();
+ })
+ 
+ instr(LRETURN, 173, lreturn, 1, special_return,  {
+ 	check_stack_long(0);
+ 
+ 	monitor_exit();
+ 	returnarg_long(rstack_long(0));
+ 	end_function();
+ 	ret();
+ })
+ 
+ instr(FRETURN, 174, freturn, 1, special_return, {
+ 	check_stack_float(0);
+ 
+ 	monitor_exit();
+ 	returnarg_float(rstack_float(0));
+ 	end_function();
+ 	ret();
+ })
+ 
+ instr(DRETURN, 175, dreturn, 1, special_return, {
+ 	check_stack_double(0);
+ 
+ 	monitor_exit();
+ 	returnarg_double(rstack_double(0));
+ 	end_function();
+ 	ret();
+ })
+ 
+ instr(ARETURN, 176, areturn, 1, special_return, {
+ 	check_stack_ref(0);
+ 
+ 	monitor_exit();
+ 	returnarg_ref(rstack_ref(0));
+ 	end_function();
+ 	ret();
+ })
+ 
+ instr(RETURN, 177, return_, 1, special_return, {
+ 	monitor_exit();
+ 	end_function();
+ 	ret();
+ })
+ 
+ /*
+  * This macro initialises the static data associated with a class.
+  */
+ #define	INIT_STATIC_CLASS(c)				\
+ 	if (c != 0 && c->state != CSTATE_COMPLETE /* ??? is that right ??? */) {	\
+ 		softcall_initialise_class(c);		\
+ 	}
+ 
+ 	/*
+ 	 * ... -> ..., value
+ 	 */
+ instr(GETSTATIC, 178, getstatic, 3, op_uint16, {
+ 	unsigned index;
+ 	index = get_icode_uint16(0);
+ 	get_static_field_info(index);
+ 	INIT_STATIC_CLASS(field_class());
+ 	set_icode_p(1, FIELD_ADDRESS(finfo.field));
+ 	if (!FIELD_ISPRIM(finfo.field)) {
+ 		set_icode_p(0, &&getstatic_quick_ref);
+ 		goto getstatic_quick_ref;
+ 	}
+ 	else switch (CLASS_PRIM_SIG(FIELD_TYPE(finfo.field))) {
+ 	case 'I':
+ 		set_icode_p(0, &&getstatic_quick_i);
+ 		goto getstatic_quick_i;
+ 	case 'S':
+ 		set_icode_p(0, &&getstatic_quick_s);
+ 		goto getstatic_quick_s;
+ 	case 'B':
+ 	case 'Z':
+ 		set_icode_p(0, &&getstatic_quick_bz);
+ 		goto getstatic_quick_bz;
+ 	case 'C':
+ 		set_icode_p(0, &&getstatic_quick_c);
+ 		goto getstatic_quick_c;
+ 	case 'F':
+ 		set_icode_p(0, &&getstatic_quick_f);
+ 		goto getstatic_quick_f;
+ 	case 'J':
+ 		set_icode_p(0, &&getstatic_quick_j);
+ 		goto getstatic_quick_j;
+ 	case 'D':
+ 		set_icode_p(0, &&getstatic_quick_d);
+ 		goto getstatic_quick_d;
+ 	default:
+ 		ABORT();
+ 	}
+ })
+ 
+ 	/*
+ 	 * ..., value  -> ...
+ 	 */
+ instr(PUTSTATIC, 179, putstatic, 3, op_uint16, {
+ 	unsigned index;
+ 	check_pcidx (0);
+ 	index = (uint16)(getpc(0)<<8 | getpc(1));
+ 	get_static_field_info(index);
+ 	INIT_STATIC_CLASS(field_class());
+ 	set_icode_p(1, FIELD_ADDRESS(finfo.field));
+ 	if (!FIELD_ISPRIM(finfo.field)) {
+ 		if (FIELD_ISREF(finfo.field)) {
+ 			set_icode_p(2, field_statics());
+ 			set_icode_p(0, &&putstatic_quick_ref);
+ 			goto putstatic_quick_ref;
+ 		} else {
+ 			set_icode_p(0, &&putstatic_quick_nref);
+ 			goto putstatic_quick_nref;
+ 		}
+ 	}
+ 	else switch (CLASS_PRIM_SIG(FIELD_TYPE(finfo.field))) {
+ 	case 'I':
+ 		set_icode_p(0, &&putstatic_quick_i);
+ 		goto putstatic_quick_i;
+ 	case 'S':
+ 		set_icode_p(0, &&putstatic_quick_d);
+ 		goto putstatic_quick_s;
+ 	case 'B':
+ 	case 'Z':
+ 		set_icode_p(0, &&putstatic_quick_bz);
+ 		goto putstatic_quick_bz;
+ 	case 'C':
+ 		set_icode_p(0, &&putstatic_quick_c);
+ 		goto putstatic_quick_c;
+ 	case 'F':
+ 		set_icode_p(0, &&putstatic_quick_f);
+ 		goto putstatic_quick_f;
+ 	case 'J':
+ 		set_icode_p(0, &&putstatic_quick_j);
+ 		goto putstatic_quick_j;
+ 	case 'D':
+ 		set_icode_p(0, &&putstatic_quick_d);
+ 		goto putstatic_quick_d;
+ 	default:
+ 		ABORT();
+ 	}
+ })
+ 
+ 	/*
+ 	 * ..., obj-ref -> ..., value
+ 	 */
+ instr(GETFIELD, 180, getfield, 3, op_uint16, {
+ 	unsigned index = (uint16)(getpc(0)<<8 | getpc(1));
+ 	check_pcidx (0);
+ 	check_stack_ref(0);
+ 	CHECK_NULL(GETFIELD, stack(0), 34);
+ 	index = get_icode_uint16(0);
+ 	get_field_info(index);
+ 	if (!FIELD_ISPRIM(finfo.field)) {
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_ref);
+ 		goto getfield_quick_ref;
+ 	}
+ 	else switch (CLASS_PRIM_SIG(FIELD_TYPE(finfo.field))) {
+ 	case 'I':
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_i);
+ 		goto getfield_quick_i;
+ 	case 'S':
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_s);
+ 		goto getfield_quick_s;
+ 	case 'B':
+ 	case 'Z':
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_bz);
+ 		goto getfield_quick_bz;
+ 	case 'C':
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_c);
+ 		goto getfield_quick_c;
+ 	case 'F':
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_f);
+ 		goto getfield_quick_f;
+ 	case 'J':
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_j);
+ 		goto getfield_quick_j;
+ 	case 'D':
+ 		set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 		set_icode_p(0, &&getfield_quick_d);
+ 		goto getfield_quick_d;
+ 	default:
+ 		ABORT();
+ 	}
+ })
+ 	/*
+ 	 * ..., obj-ref, value  -> ...
+ 	 */
+ instr(PUTFIELD, 181, putfield, 3, op_uint16, {
+ 	unsigned index = (uint16)(getpc(0)<<8 | getpc(1));
+ 	check_pcidx (0);
+ 	get_field_info(index);
+ 	if (!FIELD_ISPRIM(finfo.field)) {
+ 		check_stack_ref(1);
+ 		CHECK_NULL(PUTFIELD, rstack(1), 35);
+ 		if (FIELD_ISREF(finfo.field)) {
+ 			set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 			set_icode_p(0, &&putfield_quick_ref);
+ 			goto putfield_quick_ref;
+ 		} else {
+ 			set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 			set_icode_p(0, &&putfield_quick_nref);
+ 			goto putfield_quick_nref;
+ 		}
+ 	}
+ 	else switch (CLASS_PRIM_SIG(FIELD_TYPE(finfo.field))) {
+ 	case 'I':
+ 	    set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 	    set_icode_p(0, &&putfield_quick_i);
+ 	    goto putfield_quick_i;
+ 	case 'S':
+ 	    set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 	    set_icode_p(0, &&putfield_quick_s);
+ 	    goto putfield_quick_s;
+ 	case 'B': case 'Z':
+ 	    set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 	    set_icode_p(0, &&putfield_quick_bz);
+ 	    goto putfield_quick_bz;
+ 	case 'C':
+ 	    set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 	    set_icode_p(0, &&putfield_quick_c);
+ 	    goto putfield_quick_c;
+ 	case 'F':
+ 	    set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 	    set_icode_p(0, &&putfield_quick_f);
+ 	    goto putfield_quick_f;
+ 	case 'J':
+ 	    set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 	    set_icode_p(0, &&putfield_quick_j);
+ 	    goto putfield_quick_j;
+ 	case 'D':
+ 	    set_icode_u(1, FIELD_BOFFSET(finfo.field));
+ 	    set_icode_p(0, &&putfield_quick_d);
+ 	    goto putfield_quick_d;
+ 	default:
+ 		ABORT();
+ 	}
+ })
+ 
+ instr(INVOKEVIRTUAL, 182, invokevirtual, 3, op_uint16, {
+ 	unsigned offset; int nargs; unsigned index;
+ 	check_pcidx (0);
+ 	index = (uint16)((getpc(0) << 8) | getpc(1));
+ 	if (getMethodSignatureClass( index, meth->class, true, 0, 
+ 				     &cinfo, &einfo) == false) { 
+ 		throwError(&einfo); 
+ 	} 
+ 	if (method_method() == 0) {
+ 		softcall_nosuchmethod(method_class(), 
+ 				      method_name(), method_sig());
+ 		assert(0);	
+ 	} else {
+ 		nargs = cinfo.in; /* arguments without this */
+ 		offset = cinfo.method->idx; /* offset in dispatch vector */
+ 		if(cinfo.class->state != CSTATE_COMPLETE) 
+ 		    soft_initialise_class(cinfo.class); /* complete linking */
+ 		set_icode_i(2,nargs); 
+ 		set_icode_u(1,offset);
+ 		switch(cinfo.rettype) {
+ 		case 'V': 
+ 		    set_icode_p(0,&&invokevirtual_quick_0); 
+ 		    goto invokevirtual_quick_0;
+ 		case 'L': case '[': case 'F': case 'I': 
+ 		case 'Z': case 'S': case 'B': case 'C':
+ 		    set_icode_p(0,&&invokevirtual_quick_1); 
+ 		    goto invokevirtual_quick_1;
+ 		case 'J': case 'D':
+ 		    set_icode_p(0,&&invokevirtual_quick_2); 
+ 		    goto invokevirtual_quick_2;
+ 		default:
+ 		    ABORT();
+ 		}
+ 	}
+ })
+ 
+ /* translate [op, idx, _ ] => [op_quick, method, nargs] */
+ instr(INVOKESPECIAL, 183, invokespecial, 3, op_uint16, {
+ 	methods *method;
+ 	int nargs; unsigned index; 
+ 	check_pcidx (0);
+ 	index = (uint16)((getpc(0) << 8) | getpc(1)); // avoids race conditions
+ 	if (getMethodSignatureClass( index, meth->class, true, 1, 
+ 				     &cinfo, &einfo) == false) { 
+ 		throwError(&einfo); 
+ 	} 
+ 	if (method_method() == 0) {
+ 		softcall_nosuchmethod(method_class(), 
+ 				      method_name(), method_sig());
+ 		assert(0);
+ 	} else {
+ 		nargs = cinfo.in; /* arguments without this */
+ 		method = cinfo.method; 
+ 		if(cinfo.class->state != CSTATE_COMPLETE) 
+ 		    soft_initialise_class(cinfo.class); /* complete linking */
+ 		set_icode_i(2,nargs); 
+ 		set_icode_p(1,method);
+ 		switch(cinfo.rettype) {
+ 		case 'V': 
+ 		    set_icode_p(0,&&invokespecial_quick_0); 
+ 		    goto invokespecial_quick_0;
+ 		case 'L': case '[': case 'F': case 'I': 
+ 		case 'Z': case 'S': case 'B': case 'C':
+ 		    set_icode_p(0,&&invokespecial_quick_1); 
+ 		    goto invokespecial_quick_1;
+ 		case 'J': case 'D':
+ 		    set_icode_p(0,&&invokespecial_quick_2); 
+ 		    goto invokespecial_quick_2;
+ 		default:
+ 		    ABORT();
+ 		}
+ 	}
+ })
+ 
+ /* translate [op, idx, _ ] => [op_quick, method, nargs] */
+ instr(INVOKESTATIC, 184, invokestatic, 3, op_uint16, {
+ 	methods *method;
+ 	int nargs; unsigned index;
+ 	check_pcidx (0);
+ 	index = (uint16)((getpc(0) << 8) | getpc(1));
+ 	if (getMethodSignatureClass( index, meth->class, true, 1, 
+ 				     &cinfo, &einfo) == false) { 
+ 		throwError(&einfo); 
+ 	} 
+ 	if (method_method() == 0) {
+ 		softcall_nosuchmethod(method_class(), 
+ 				      method_name(), method_sig());
+ 		assert(0);	/* <- an exception should be raised here  */
+ 	} else {
+ 		nargs = cinfo.in-1; /* arguments without this */
+ 		method = cinfo.method; 
+ 		if(cinfo.class->state != CSTATE_COMPLETE) {
+ 			IDBG(dprintf("complete class...\n"));
+ 			soft_initialise_class(cinfo.class); 
+ 			IDBG(dprintf("complete class...done\n"));
+ 		}
+ 		set_icode_i(2,nargs); 
+ 		set_icode_p(1,method);
+ 		switch(cinfo.rettype) {
+ 		case 'V': 
+ 		    set_icode_p(0,&&invokestatic_quick_0); 
+ 		    goto invokestatic_quick_0;
+ 		case 'L': case '[': case 'F': case 'I': 
+ 		case 'Z': case 'S': case 'B': case 'C':
+ 		    set_icode_p(0,&&invokestatic_quick_1); 
+ 		    goto invokestatic_quick_1;
+ 		case 'J': case 'D':
+ 		    set_icode_p(0,&&invokestatic_quick_2); 
+ 		    goto invokestatic_quick_2;
+ 		default:
+ 		    ABORT();
+ 		}
+ 	}
+ })
+ 
+ 
+ 
+ 
+ /* translate [op, idx, _, nargs, _ ] => 
+      [op_quick, interface, offset, nargs, _ ] 
+ */
+ instr(INVOKEINTERFACE, 185, invokeinterface, 5, special_invokeinterface, {
+ 	Hjava_lang_Class* interface;
+ 	unsigned offset; unsigned  nargs; unsigned index;
+ 	check_pcidx (0);
+ 	check_pc (2);
+ 	index = (uint16)((getpc(0) << 8) | getpc(1));
+ 	if (getMethodSignatureClass( index, meth->class, true, 2, 
+ 				     &cinfo, &einfo) == false) { 
+ 		throwError(&einfo); 
+ 	} 
+ 	if (method_method() == 0) {
+ 		softcall_nosuchmethod(method_class(), 
+ 				      method_name(), method_sig());
+ 		assert(0);	
+ 	} else {
+ 		nargs = cinfo.in; /* arguments without this */
+ 		offset = cinfo.method->idx; /* offset in dispatch vector */
+ 		interface = cinfo.method->class;
+ 		set_icode_i(3, nargs); 
+ 		set_icode_u(2, offset);
+ 		set_icode_p(1, interface);
+ 		switch(cinfo.rettype) {
+ 		case 'V': 
+ 		    set_icode_p(0,&&invokeinterface_quick_0); 
+ 		    goto invokeinterface_quick_0;
+ 		case 'L': case '[': case 'F': case 'I': 
+ 		case 'Z': case 'S': case 'B': case 'C':
+ 		    set_icode_p(0,&&invokeinterface_quick_1); 
+ 		    goto invokeinterface_quick_1;
+ 		case 'J': case 'D':
+ 		    set_icode_p(0,&&invokeinterface_quick_2); 
+ 		    goto invokeinterface_quick_2;
+ 		default:
+ 		    ABORT();
+ 		}
+ 	}
+ })
+ 
+ undef(UNDEF          ,286,undef       ,1,op,{})
+ 
+ 
+ 	/*
+ 	 * ... ->  ..., object ref
+ 	 */
+ instr(NEW, 187, new, 3, op_uint16, {
+ 	unsigned index = (uint16)((getpc(0) << 8) | getpc(1));
+ 	check_pcidx (0);
+ 	index = get_icode_uint16(0);
+ 	get_class_info(index);
+ 	set_icode_p(1, class_object());
+ 	set_icode_p(0, &&new_quick);
+ 	goto new_quick;
+ })
+ 
+ instr(NEWARRAY, 188, newarray, 2, op_uint8, {
+ 	/*
+ 	 * ... size ->  ..., object ref
+ 	 */
+ 	check_pc (0);
+ 	check_stack_int(0);
+ 
+ 	low = get_icode_uint8(0);
+ 	softcall_newarray(stack(0), stack(0), low);
+ })
+ 
+ instr(ANEWARRAY, 189, anewarray, 3, op_uint16, {
+ 	/*
+ 	 * ... size ->  ..., object ref
+ 	 */
+ 	idx = get_icode_uint16(0);
+ 
+ 	get_class_info(idx);
+ 	softcall_anewarray(stack(0), stack(0), class_object());
+ })
+ 
+ instr(ARRAYLENGTH, 190, arraylength, 1, op, {
+ 	/*
+ 	 * ..., obj -> ..., length
+ 	 */
+ 	CHECK_NULL(ARRAYLENGTH, rstack(0), 34);
+ 
+ 	check_stack_array(0);
+ 
+ 	load_offset_int(stack(0), rstack(0), object_array_length);
+ })
+ 
+ instr(ATHROW, 191, athrow, 1, op, {
+ 	/*
+ 	 * ..., obj -> undefined
+ 	 */
+ 	CHECK_NULL(ATHROW, rstack(0), 34);
+ 
+ 	check_stack_ref(0);
+ 
+ 	softcall_athrow(rstack(0));
+ })
+ 
+ 	/*
+ 	 * ..., obj -> ..., obj
+ 	 */
+ instr(CHECKCAST, 192, checkcast, 3, op_uint16, {
+ 	unsigned index = (uint16)((getpc(0) << 8) | getpc(1));
+ 	check_pcidx (0);
+ 	check_stack_ref(0);
+ 	get_class_info(index);
+ 	set_icode_p(1, class_object());
+ 	set_icode_p(0, &&checkcast_quick);
+ 	goto checkcast_quick;
+ })
+ 
+ 	/*
+ 	 * ..., obj -> ..., result
+ 	 */
+ instr(INSTANCEOF, 193, instanceof, 3, op_uint16, {
+ 	unsigned index = (uint16)((getpc(0) << 8) | getpc(1));
+ 	check_pcidx (0);
+ 	check_stack_ref(0);
+ 	get_class_info(index);
+ 	set_icode_p(1, class_object());
+ 	set_icode_p(0, &&instanceof_quick);
+ 	goto instanceof_quick;
+ })
+ 
+ instr(MONITORENTER, 194, monitorenter, 1, op, {
+ 	/*
+ 	 * ... obj -> ...
+ 	 */
+ 	CHECK_NULL(MONITORENTER, rstack(0), 34);
+ 
+ 	check_stack_ref(0);
+ 
+ 	softcall_monitorenter(rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(MONITOREXIT, 195, monitorexit, 1, op, {
+ 	/*
+ 	 * ... obj -> ...
+ 	 */
+ 	CHECK_NULL(MONITOREXIT, rstack(0), 34);
+ 
+ 	check_stack_ref(0);
+ 
+ 	softcall_monitorexit(rstack(0));
+ 	pop(1);
+ })
+ 
+ instr(WIDE, 196, wide, 1, special_wide, {
+ 	assert(0);
+ })
+ 
+ instr(MULTIANEWARRAY, 197, multianewarray, 4, op_uint16_uint8, {
+ 	/*
+ 	 * ... size1, size2, ... sizen ->  ..., object ref
+ 	 */
+ 	check_pcidx (0);
+ 	check_pc (2);
+ 
+ 	idx = get_icode_uint16(0);
+ 	low = get_icode_uint8(1);
+ 
+ 	for (high = 0; high < low; high++) {
+ 		check_stack_int(high);
+ 	}
+ 
+ 	get_class_info(idx);
+ 	softcall_multianewarray(stack(low-1), low, stack(0), class_object());
+ 
+ 	pop(low-1);
+ })
+ 
+ 
+ instr(IFNULL, 198, ifnull, 3, op_int16, {
+ 	jref value = stack(0)->v.taddr;
+ 	pop(1);
+ 	if(value == NULL) {
+ 		int offset = get_icode_int16(0);;
+ 		BRA(offset);
+ 	} 
+ })
+ 
+ instr(IFNONNULL, 199, ifnonnull, 3, op_int16, {
+ 	jref value = stack(0)->v.taddr;
+ 	pop(1);
+ 	if(value != NULL) {
+ 		int offset = get_icode_int16(0);;
+ 		BRA(offset);
+ 	} 
+ })
+ 
+ instr(GOTO_W, 200, goto_w, 5, op_int32, {
+ 	int offset = get_icode_int32(0);
+ 	BRA(offset);
+ })
+ 
+ instr(JSR_W, 201, jsr_w, 5, op_int32, {
+ 	/*
+ 	 * ... -> ..., ret-addr
+ 	 */
+ 	int offset = get_icode_int32(0);
+ 	Instr *ret_addr = IP+5;
+ 	PUSH_L(ret_addr);
+ 	BRA(offset);
+ })
+ 
+ instr(BREAKPOINT, 202, breakpoint, 1, special_breakpoint, {
+ 	breakpoint();
+ })
+ 
+ undef(UNDEF          ,203,undef       ,1,op,{})
+ undef(UNDEF          ,204,undef       ,1,op,{})
+ undef(UNDEF          ,205,undef       ,1,op,{})
+ undef(UNDEF          ,206,undef       ,1,op,{})
+ undef(UNDEF          ,207,undef       ,1,op,{})
+ undef(UNDEF          ,208,undef       ,1,op,{})
+ undef(UNDEF          ,209,undef       ,1,op,{})
+ undef(UNDEF          ,210,undef       ,1,op,{})
+ undef(UNDEF          ,211,undef       ,1,op,{})
+ undef(UNDEF          ,212,undef       ,1,op,{})
+ undef(UNDEF          ,213,undef       ,1,op,{})
+ undef(UNDEF          ,214,undef       ,1,op,{})
+ undef(UNDEF          ,215,undef       ,1,op,{})
+ undef(UNDEF          ,216,undef       ,1,op,{})
+ undef(UNDEF          ,217,undef       ,1,op,{})
+ undef(UNDEF          ,218,undef       ,1,op,{})
+ undef(UNDEF          ,219,undef       ,1,op,{})
+ undef(UNDEF          ,220,undef       ,1,op,{})
+ undef(UNDEF          ,221,undef       ,1,op,{})
+ undef(UNDEF          ,222,undef       ,1,op,{})
+ undef(UNDEF          ,223,undef       ,1,op,{})
+ undef(UNDEF          ,224,undef       ,1,op,{})
+ undef(UNDEF          ,225,undef       ,1,op,{})
+ undef(UNDEF          ,226,undef       ,1,op,{})
+ undef(UNDEF          ,227,undef       ,1,op,{})
+ undef(UNDEF          ,228,undef       ,1,op,{})
+ undef(UNDEF          ,229,undef       ,1,op,{})
+ undef(UNDEF          ,230,undef       ,1,op,{})
+ undef(UNDEF          ,231,undef       ,1,op,{})
+ undef(UNDEF          ,232,undef       ,1,op,{})
+ undef(UNDEF          ,233,undef       ,1,op,{})
+ undef(UNDEF          ,234,undef       ,1,op,{})
+ undef(UNDEF          ,235,undef       ,1,op,{})
+ undef(UNDEF          ,236,undef       ,1,op,{})
+ undef(UNDEF          ,237,undef       ,1,op,{})
+ undef(UNDEF          ,238,undef       ,1,op,{})
+ undef(UNDEF          ,239,undef       ,1,op,{})
+ undef(UNDEF          ,240,undef       ,1,op,{})
+ undef(UNDEF          ,241,undef       ,1,op,{})
+ undef(UNDEF          ,242,undef       ,1,op,{})
+ undef(UNDEF          ,243,undef       ,1,op,{})
+ undef(UNDEF          ,244,undef       ,1,op,{})
+ undef(UNDEF          ,245,undef       ,1,op,{})
+ undef(UNDEF          ,246,undef       ,1,op,{})
+ undef(UNDEF          ,247,undef       ,1,op,{})
+ undef(UNDEF          ,248,undef       ,1,op,{})
+ undef(UNDEF          ,249,undef       ,1,op,{})
+ undef(UNDEF          ,250,undef       ,1,op,{})
+ undef(UNDEF          ,251,undef       ,1,op,{})
+ undef(UNDEF          ,252,undef       ,1,op,{})
+ undef(UNDEF          ,253,undef       ,1,op,{})
+ undef(UNDEF          ,254,undef       ,1,op,{})
+ undef(UNDEF          ,255,undef       ,1,op,{})
+ 
+ 
+ 
+ 
+ custm(TRANSLATE, , translate, 1, , {
+ 	translate_to_icode(meth); 
+ 	assert(0);
+ })
+ 
+ 
+ custm(INVOKEVIRTUAL_QUICK_0,, invokevirtual_quick_0, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	int nargs = get_icode_int32(1);
+ 	methods *new_mp;
+ 	Hjava_lang_Object* target;
+ 	target = (Hjava_lang_Object*)stack(nargs)->v.taddr; 
+ 	new_mp = target->dtable->method[offset]; 
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs-1;
+ }) 
+ custm(INVOKEVIRTUAL_QUICK_1,, invokevirtual_quick_1, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	int nargs = get_icode_int32(1);
+ 	methods *new_mp;
+ 	Hjava_lang_Object* target;
+ 	target = (Hjava_lang_Object*)stack(nargs)->v.taddr; 
+ 	new_mp = target->dtable->method[offset]; 
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs;
+ }) 
+ custm(INVOKEVIRTUAL_QUICK_2,, invokevirtual_quick_2, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	int nargs = get_icode_int32(1);
+ 	methods *new_mp;
+ 	Hjava_lang_Object* target;
+ 	target = (Hjava_lang_Object*)stack(nargs)->v.taddr; 
+ 	new_mp = target->dtable->method[offset]; 
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs+1;
+ }) 
+ custm(INVOKESPECIAL_QUICK_0,, invokespecial_quick_0, 3,, {
+ 	methods *new_mp = get_icode_pointer(0);
+ 	int nargs = get_icode_int32(1);
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs-1;
+ }) 
+ custm(INVOKESPECIAL_QUICK_1,, invokespecial_quick_1, 3,, {
+ 	methods *new_mp = get_icode_pointer(0);
+ 	int nargs = get_icode_int32(1);
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs;
+ }) 
+ custm(INVOKESPECIAL_QUICK_2,, invokespecial_quick_2, 3,, {
+ 	methods *new_mp = get_icode_pointer(0);
+ 	int nargs = get_icode_int32(1);
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs+1;
+ }) 
+ custm(INVOKESTATIC_QUICK_0,, invokestatic_quick_0, 3,, {
+ 	methods *new_mp = get_icode_pointer(0);
+ 	int nargs = get_icode_int32(1);
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs-1;
+ }) 
+ custm(INVOKESTATIC_QUICK_1,, invokestatic_quick_1, 3,, {
+ 	methods *new_mp = get_icode_pointer(0);
+ 	int nargs = get_icode_int32(1);
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs;
+ }) 
+ custm(INVOKESTATIC_QUICK_2,, invokestatic_quick_2, 3,, {
+ 	methods *new_mp = get_icode_pointer(0);
+ 	int nargs = get_icode_int32(1);
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs+1;
+ }) 
+ custm(INVOKEINTERFACE_QUICK_0,, invokeinterface_quick_0, 5,, {
+ 	Hjava_lang_Class* interface = get_icode_pointer(0);
+ 	unsigned offset = get_icode_uint32(1);
+ 	int nargs = get_icode_int32(2);
+ 	Hjava_lang_Object* target;
+ 	methods *new_mp;
+ 	target = (Hjava_lang_Object*)stack(nargs)->v.taddr; 
+ 	/* should be inlined */
+ 	new_mp = soft_lookupmethod(target, interface, offset); 
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs-1;
+ }) 
+ custm(INVOKEINTERFACE_QUICK_1,, invokeinterface_quick_1, 5,, {
+ 	Hjava_lang_Class* interface = get_icode_pointer(0);
+ 	unsigned offset = get_icode_uint32(1);
+ 	int nargs = get_icode_int32(2);
+ 	Hjava_lang_Object* target;
+ 	methods *new_mp;
+ 	target = (Hjava_lang_Object*)stack(nargs)->v.taddr; 
+ 	new_mp = soft_lookupmethod(target, interface, offset); 
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs;
+ }) 
+ custm(INVOKEINTERFACE_QUICK_2,, invokeinterface_quick_2, 5,, {
+ 	Hjava_lang_Class* interface = get_icode_pointer(0);
+ 	unsigned offset = get_icode_uint32(1);
+ 	int nargs = get_icode_int32(2);
+ 	Hjava_lang_Object* target;
+ 	methods *new_mp;
+ 	target = (Hjava_lang_Object*)stack(nargs)->v.taddr; 
+ 	new_mp = soft_lookupmethod(target, interface, offset); 
+ 	virtualMachine(new_mp, sp-nargs, sp-nargs, tid);
+ 	sp = sp-nargs+1;
+ }) 
+ 
+ custm(LDC1_QUICK_S,, ldc1_quick_s, 2,, {
+ 	void *s = get_icode_pointer(0) ;
+ 	push(1);
+ 	move_string_const(stack(0), s);
+ })
+ 
+ custm(LDC1_QUICK_F,, ldc1_quick_f, 2,, {
+ 	jfloat f = get_icode_float(0);
+ 	push(1);
+ 	move_float_const(stack(0), f);
+ })
+ custm(LDC1_QUICK_I,, ldc1_quick_i, 2,, {
+ 	jint i = get_icode_int32(0);
+ 	push(1);
+ 	move_int_const(stack(0), i);
+ })
+ custm(LDC2_QUICK_S,, ldc2_quick_s, 3,, {
+ 	void *s = get_icode_pointer(0) ;
+ 	push(1);
+ 	move_string_const(stack(0), s);
+ })
+ custm(LDC2_QUICK_F,, ldc2_quick_f, 3,, {
+ 	jfloat f = get_icode_float(0);
+ 	push(1);
+ 	move_float_const(stack(0), f);
+ })
+ custm(LDC2_QUICK_I,, ldc2_quick_i, 3,, {
+ 	jint i = get_icode_int32(0);
+ 	push(1);
+ 	move_int_const(stack(0), i);
+ })
+ custm(PUTFIELD_QUICK_REF,, putfield_quick_ref, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	SOFT_ADDREFERENCE(rstack(1), rstack(0));
+ 	store_offset_ref(rstack(1), offset, rstack(0));
+ 	pop(2);
+ })
+ 
+ custm(PUTFIELD_QUICK_NREF,, putfield_quick_nref, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	store_offset_ref(rstack(1), offset, rstack(0));
+ 	pop(2);
+ })
+ custm(PUTFIELD_QUICK_I,, putfield_quick_i, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	check_stack_ref(1);
+ 	CHECK_NULL(PUTFIELD, stack(1), 36);
+ 	store_offset_int(stack(1), offset, stack(0));
+ 	pop(2);
+ })
+ custm(PUTFIELD_QUICK_S,, putfield_quick_s, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	check_stack_ref(1);
+ 	CHECK_NULL(PUTFIELD, stack(1), 36);
+ 	store_offset_short(stack(1), offset, stack(0));
+ 	pop(2);
+ })
+ 
+ custm(PUTFIELD_QUICK_BZ,, putfield_quick_bz, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	check_stack_ref(1);
+ 	CHECK_NULL(PUTFIELD, stack(1), 40);
+ 	store_offset_byte(stack(1), offset, stack(0));
+ 	pop(2);
+ })
+ custm(PUTFIELD_QUICK_C,, putfield_quick_c, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	check_stack_ref(1);
+ 	CHECK_NULL(PUTFIELD, stack(1), 41);
+ 	store_offset_char(stack(1), offset, stack(0));
+ 	pop(2);
+ })
+ custm(PUTFIELD_QUICK_F,, putfield_quick_f, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	check_stack_ref(1);
+ 	CHECK_NULL(PUTFIELD, stack(1), 42);
+ 	store_offset_float(stack(1), offset, stack(0));
+ 	pop(2);
+ })
+ custm(PUTFIELD_QUICK_J,, putfield_quick_j, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	check_stack_ref(2);
+ 	CHECK_NULL(PUTFIELD, stack(2), 38);
+ 	store_offset_long(stack(2), offset, stack_long(0));
+ 	pop(3);
+ })
+ custm(PUTFIELD_QUICK_D,, putfield_quick_d, 3,, {
+ 	unsigned offset = get_icode_uint32(0); 
+ 	check_stack_ref(2);
+ 	CHECK_NULL(PUTFIELD, stack(2), 39);
+ 	store_offset_double(stack(2), offset, stack_double(0));
+ 	pop(3);
+ })
+ custm(GETFIELD_QUICK_REF,, getfield_quick_ref, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_ref(stack(0), rstack(0), offset);
+ })
+ custm(GETFIELD_QUICK_I,, getfield_quick_i, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_int(stack(0), rstack(0), offset);
+ })
+ custm(GETFIELD_QUICK_S,, getfield_quick_s, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_short(stack(0), rstack(0), offset);
+ })
+ custm(GETFIELD_QUICK_BZ,, getfield_quick_bz, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_byte(stack(0), rstack(0), offset);
+ })
+ custm(GETFIELD_QUICK_C,, getfield_quick_c, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_char(stack(0), rstack(0), offset);
+ })
+ custm(GETFIELD_QUICK_F,, getfield_quick_f, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_float(stack(0), stack(0), offset);
+ })
+ custm(GETFIELD_QUICK_J,, getfield_quick_j, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_long(stack_long(-1), stack(0), offset);
+ 	push(1);
+ })
+ custm(GETFIELD_QUICK_D,, getfield_quick_d, 3,, {
+ 	unsigned offset = get_icode_uint32(0);
+ 	load_offset_double(stack_double(-1), stack(0), offset);
+ 	push(1);
+ })
+ custm(PUTSTATIC_QUICK_REF,, putstatic_quick_ref, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	SOFT_ADDREFERENCE_STATIC(get_icode_pointer(1), stack(0));
+ 	store_addr_ref(address, stack(0));
+ 	pop(1);
+ })
+ custm(PUTSTATIC_QUICK_NREF,, putstatic_quick_nref, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_ref(address, stack(0));
+ 	pop(1);
+ })
+ custm(PUTSTATIC_QUICK_I,, putstatic_quick_i, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_int(address, stack(0));
+ 	pop(1);
+ })
+ custm(PUTSTATIC_QUICK_S,, putstatic_quick_s, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_short(address, stack(0));
+ 	pop(1);
+ })
+ custm(PUTSTATIC_QUICK_BZ,, putstatic_quick_bz, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_byte(address, stack(0));
+ 	pop(1);
+ })
+ custm(PUTSTATIC_QUICK_C,, putstatic_quick_c, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_char(address, stack(0));
+ 	pop(1);
+ })
+ custm(PUTSTATIC_QUICK_F,, putstatic_quick_f, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_float(address, stack(0));
+ 	pop(1);
+ })
+ custm(PUTSTATIC_QUICK_J,, putstatic_quick_j, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_long(address, stack_long(0));
+ 	pop(2);
+ })
+ custm(PUTSTATIC_QUICK_D,, putstatic_quick_d, 3,, {
+ 	void *address = get_icode_pointer(0);
+ 	store_addr_double(address, stack_double(0));
+ 	pop(2);
+ })
+ 
+ 
+ custm(GETSTATIC_QUICK_REF,, getstatic_quick_ref, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(1);
+ 	load_addr_ref(stack(0), address);
+ })
+ custm(GETSTATIC_QUICK_I,, getstatic_quick_i, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(1);
+ 	load_addr_int(stack(0), address);
+ })
+ custm(GETSTATIC_QUICK_S,, getstatic_quick_s, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(1);
+ 	load_addr_short(stack(0), address);
+ })
+ custm(GETSTATIC_QUICK_BZ,, getstatic_quick_bz, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(1);
+ 	load_addr_byte(stack(0), address);
+ })
+ custm(GETSTATIC_QUICK_C,, getstatic_quick_c, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(1);
+ 	load_addr_char(stack(0), address);
+ })
+ custm(GETSTATIC_QUICK_F,, getstatic_quick_f, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(1);
+ 	load_addr_float(stack(0), address);
+ })
+ custm(GETSTATIC_QUICK_J,, getstatic_quick_j, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(2);
+ 	load_addr_long(stack_long(0), address);
+ })
+ custm(GETSTATIC_QUICK_D,, getstatic_quick_d, 3,, {
+ 	void *address =  get_icode_pointer(0);
+ 	push(2);
+ 	load_addr_double(stack_double(0), address);
+ })
+ 
+ custm(NEW_QUICK,, new_quick, 3,, {
+ 	Hjava_lang_Class* class = get_icode_pointer(0);
+ 	push(1);
+ 	softcall_new(stack(0), class);
+ })
+ custm(CHECKCAST_QUICK,, checkcast_quick, 3,, {
+ 	Hjava_lang_Class* class = get_icode_pointer(0);
+ 	softcall_checkcast(stack(0), rstack(0), class);
+ })
+ custm(INSTANCEOF_QUICK,, instanceof_quick, 3,, {
+ 	Hjava_lang_Class* class = get_icode_pointer(0);
+ 	softcall_instanceof(stack(0), rstack(0), class);
+ })
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/translator.c threaded_with_quick/kaffe/kaffevm/threaded_int/translator.c
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/translator.c	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/translator.c	Fri Nov 26 22:34:08 1999
***************
*** 0 ****
--- 1,271 ----
+ /* $Id: translator.c,v 1.1.2.1.2.3.2.3 1999/11/26 21:34:08 helmut Exp $ */
+ 
+ 
+ #include "debug.h"
+ #define	CDBG(s) 	DBG(INT_VMCALL, s)
+ #define	RDBG(s) 	DBG(INT_RETURN, s)
+ #define	NDBG(s) 	DBG(INT_NATIVE, s)
+ #define	IDBG(s)		DBG(INT_INSTR, s)
+ #define	CHDBG(s)	DBG(INT_CHECKS, s)
+ 
+ #include "config.h"
+ #include "config-std.h"
+ #include "config-math.h"
+ #include "config-mem.h"
+ #include "config-setjmp.h"
+ #include "classMethod.h"
+ #include "gtypes.h"
+ #include "bytecode.h"
+ #include "slots.h"
+ #include "icode.h"
+ #include "access.h"
+ #include "object.h"
+ #include "constants.h"
+ #include "gc.h"
+ #include "machine.h"
+ #include "lookup.h"
+ #include "code-analyse.h"
+ #include "soft.h"
+ #include "exception.h"
+ #include "external.h"
+ #include "baseClasses.h"
+ #include "thread.h"
+ #include "jthread.h"
+ #include "locks.h"
+ #include "checks.h"
+ #include "errors.h"
+ #include "md.h"
+ 
+ 
+ #include "translator.h"
+ #include "engine.h"
+ 
+ static char* label2string[256+N_CUSTOM_INSTRUCTIONS+1] = {
+ # define instr(name,opcode,label,len,syn,body) #label,
+ # define undef(name,opcode,label,len,syn,body) #label,
+ # define custm(name,opcode,label,len,syn,body) #label,
+ # include "threaded_int.def"
+ # undef instr
+ # undef undef
+ # undef custm
+   "dummy"
+ }; 
+ 
+ static char* mnemonic2string[256+1] = {
+ # define instr(name,opcode,label,len,syn,body) #name,
+ # define undef(name,opcode,label,len,syn,body) #name,
+ # define custm(name,opcode,label,len,syn,body) 
+ # include "threaded_int.def"
+ # undef instr
+ # undef undef
+ # undef custm
+   "dummy"
+ }; 
+ 
+ 
+ char *opcode_2_string(unsigned char opcode) {
+ 	return mnemonic2string[opcode];
+ }
+ 
+ Instr opcode_2_label(unsigned char opcode) {
+ 	static Instr *b2i = NULL;
+ 	if(b2i == NULL) b2i = get_labels();
+ 	return b2i[opcode];
+ }
+ 
+ char *label_2_string(Instr label) {
+ 	return label2string[label_2_opcode(label)]; 
+ }
+ unsigned label_2_opcode(Instr label) {
+ 	unsigned i;
+ 	static Instr *b2i = NULL;
+ 	if(b2i == NULL) b2i = get_labels();
+ 	for(i=0;i<=255+N_CUSTOM_INSTRUCTIONS;i++) 
+ 	    if (label.p == b2i[i].p) return i;
+ 	fprintf(stderr,"invalid label %p\n", label.p);
+ 	abort();
+ }
+ Instr string_2_label(char *label_string) {
+ 	unsigned  i;
+ 	static Instr *b2i = NULL;
+ 	if(b2i == NULL) b2i = get_labels();
+ 	for(i=0;i<=255+N_CUSTOM_INSTRUCTIONS;i++) 
+ 	    if (strcmp(label_2_string(b2i[i]), label_string) == 0) 
+ 		return b2i[i];
+ 	fprintf(stderr,"invalid label-string \"%s\"\n", label_string);
+ 	abort();
+ }
+ unsigned char string_2_opcode(char *opcode_string) {
+ 	unsigned char i;
+ 	for(i=0;i<=255;i++) 
+ 	    if (strcmp(opcode_2_string(i), opcode_string) == 0) return i;
+ 	fprintf(stderr,"invalid mnemonic \"%s\"\n", opcode_string);
+ 	abort();
+ }
+ 
+ unsigned ip_2_pc(Instr* ip, methods *mp) {
+ 	return ip-mp->icode;
+ }
+ 
+ Instr* pc_2_ip(unsigned pc, methods *mp) {
+ 	return mp->icode+pc;
+ }
+ /**
+  * translates the byte code of method METH to intermediate code and
+  * sets the met->icode field. 
+  **/
+ void translate_to_icode(methods *meth) {
+ 	Instr *icode = meth->icode;  
+ 	unsigned char *bcode = meth->c.bcode.code;
+ 	Instr *b2i;
+ 	unsigned i=0;
+ 	unsigned return_modifier = IRETURN;
+ 	static void *tcode[256+1] = {
+ #	  define instr(name,opcode,label,length,syntax,body) &&##syntax,
+ #	  define undef(name,opcode,label,length,syntax,body) &&undef,
+ #	  define custm(name,opcode,label,length,syntax,body) 
+ #         include "threaded_int.def"       			
+ #	  undef instr
+ #	  undef undef
+ #	  undef custm
+ 	  &&undef
+ 	};
+ 	void assign_uint8(unsigned to, unsigned from) {
+ 		icode[to].u = (uint8)(bcode[from]);
+ 		IDBG(dprintf("%#x (uint8)=> %#lx\n", 
+ 			    bcode[from], icode[to].p));
+ 	}
+ 	void assign_int8(unsigned to, unsigned from) {
+ 		icode[to].i = (int8)(bcode[from]);
+ 		IDBG(dprintf("%#x (int8)=> %#lx\n", 
+ 			    bcode[from], icode[to].p));
+ 	}
+ 	void assign_uint16(unsigned to, unsigned from) {
+ 		icode[to].u = (uint16)(bcode[from]<<8|bcode[from+1]);
+ 		IDBG(dprintf("%#x %#x (uint16)=> %#lx\n", 
+ 			     bcode[from], bcode[from+1], icode[to].p));
+ 	}
+ 	void assign_int16(unsigned to, unsigned from) {
+ 		icode[to].i = (int16)(bcode[from]<<8|bcode[from+1]);
+ 		IDBG(dprintf("%#x %#x (int16)=> %#lx\n", 
+ 			     bcode[from], bcode[from+1], icode[to].p));
+ 	}
+ 	void assign_uint32(unsigned to, unsigned from) {
+ 		icode[to].u = 
+ 		  (uint32)(bcode[from  ]<<24 | bcode[from+1]<<16 | 
+ 			   bcode[from+2]<< 8 | bcode[from+3]); 
+ 		IDBG(dprintf("%#x %#x %#x %#x (uint32)=> %#lx\n", 
+ 			     bcode[from], bcode[from+1],
+ 			     bcode[from+2], bcode[from+3], icode[to].p));
+ 	}
+ 	void assign_int32(unsigned to, unsigned from) {
+ 		icode[to].i = 
+ 		    (int32)(bcode[from  ]<<24 | bcode[from+1]<<16 | 
+ 			    bcode[from+2]<< 8 | bcode[from+3]); 
+ 		IDBG(dprintf("%#x %#x %#x %#x (int32)=> %#lx\n", 
+ 			    bcode[from], bcode[from+1],
+ 			    bcode[from+2], bcode[from+3], icode[to].p));
+ 	}
+ 	IDBG(dprintf("translate...: %s.%s%s.\n", meth->class->name->data, 
+ 		     meth->name->data, METHOD_SIGD(meth)));
+ 	assert(meth->c.bcode.codelen>0);
+ 	icode = gc_malloc(meth->c.bcode.codelen*sizeof *icode,
+ 			  GC_ALLOC_BYTECODE);
+ 	assert(icode);
+ 	b2i = get_labels();
+ 	for(i=0;i < meth->c.bcode.codelen;) {
+ 		/* b2i[x] contains the label of the intermediate
+                    instruction to be executed for byte code x.
+                    tcode[x] contains the label of the action to be
+                    performed during translation.  See threaded_int.def */
+ 		icode[i]=b2i[bcode[i]];
+ 		IDBG(dprintf("%s(%u) => %s(%p)\n", 
+ 			     opcode_2_string(bcode[i]), bcode[i],
+ 			     label_2_string(icode[i]), icode[i]));
+ 		goto *tcode[bcode[i]]; 
+ 	op:  
+ 		i++; continue;
+ 	op_uint8:  
+ 		assign_uint8(i+1,i+1);	i += 2; continue;
+ 	op_int8:   
+ 		assign_int8(i+1,i+1);	i += 2; continue;
+ 	op_uint16: 
+ 		assign_uint16(i+1,i+1);	i += 3; continue;
+ 	op_int16:  
+ 		assign_int16(i+1,i+1);	i += 3; continue;
+ 	op_int32:  
+ 		assign_int32(i+1,i+1);	i += 5; continue;
+ 	op_uint8_int8: 
+ 		assign_uint8(i+1,i+1); assign_int8(i+2,i+2);   i+=3; continue; 
+ 	op_uint16_uint8:
+ 		assign_uint16(i+1,i+1);assign_uint8(i+2,i+3); i+=4; continue;
+ 	special_return:
+ 		icode[i]=b2i[bcode[i]-IRETURN+return_modifier]; i++; continue;
+ 	special_wide:
+ 		icode[i]=b2i[bcode[i+1]]; 
+ 		IDBG(dprintf("%s(%u) (wide)=> %s(%p)\n", 
+ 			     opcode_2_string(bcode[i+1]), bcode[i+1],
+ 			     label_2_string(icode[i]), icode[i]));
+ 		switch(bcode[i+1]) {
+ 		case IINC:
+ 		    assign_uint16(i+1,i+2);
+ 		    assign_int16(i+2,i+4);
+ 		    i += 6; continue; 
+ 		case ILOAD: case FLOAD: case  ALOAD: 
+ 		case LLOAD: case DLOAD: case ISTORE: 
+ 		case FSTORE: case ASTORE: case LSTORE: 
+ 		case DSTORE: case RET:
+ 		    assign_uint16(i+1,i+2);
+ 		    i += 4; continue; 
+ 		default:
+ 		    fprintf(stderr,"invalid wide opcode %s(%i)\n",
+ 			    opcode_2_string(bcode[i+1]), bcode[i+1]);
+ 		    assert(0);
+ 		}
+ 	special_lookupswitch: 
+ 		{
+ 				/* padding is in [0..3]; padding
+ 				   should be 3 if i=0 */
+ 			unsigned padding = 3-i%4;
+ 			unsigned base = i+1+padding;
+ 			int32 npairs, j;
+ 			assign_int32(i+1,base+0*4); /* default */
+ 			assign_int32(i+2,base+1*4); /* npairs */
+ 			npairs = icode[i+2].i; 
+ 			for(j=0;j<npairs;j++) {
+ 				assign_int32(i+3+j*2, base+2*4+j*8);
+ 				assign_int32(i+4+j*2, base+3*4+j*8);
+ 			}
+ 			i += 1+padding+8+(npairs*2)*4; continue;
+ 		}
+ 	special_tableswitch: 
+ 		{
+ 				/* padding is in [0..3]; padding
+                                    should be 3 if i=0 */
+ 			unsigned padding = 3-i%4;
+ 			unsigned base = i+1+padding;
+ 			int32 low, high, j;
+ 			assign_int32(i+1,base+0*4); /* default */
+ 			assign_int32(i+2,base+1*4); /* low */
+ 			assign_int32(i+3,base+2*4); /* high */
+ 			low = icode[i+2].i;
+ 			high = icode[i+3].i;
+ 			for(j=0;j<high-low+1;j++)
+ 			    assign_int32(i+4+j,base+3*4+j*4);
+ 			i += 1+padding+12+4*(high-low+1); continue;
+ 		}
+ 	special_invokeinterface:
+ 		assign_uint16(i+1,i+1);
+ 		assign_int8(i+3,i+3);
+ 		/* bcode[i+4] is empty */
+ 		i += 5; continue;
+ 	special_breakpoint:
+ 		fprintf(stderr,"Don't know what do at opcode `breakpoint'.\n");
+ 		abort();
+ 	undef:
+ 		fprintf(stderr,"undefined opcode\n");
+ 		assert(0);
+ 	}
+ 	meth->icode = icode;
+ 	IDBG(dprintf("translate...done\n"));
+ } 
diff -c -r -N -x configure -x Makefile -x Makefile.in -x *.m4 -x .cvsignore -x mkinstalldirs -x JavaP.java kaffe-1.0.5/kaffe/kaffevm/threaded_int/translator.h threaded_with_quick/kaffe/kaffevm/threaded_int/translator.h
*** kaffe-1.0.5/kaffe/kaffevm/threaded_int/translator.h	Thu Jan  1 01:00:00 1970
--- threaded_with_quick/kaffe/kaffevm/threaded_int/translator.h	Fri Nov 26 22:34:09 1999
***************
*** 0 ****
--- 1,21 ----
+ /* $Id: translator.h,v 1.1.2.1.2.1.2.1 1999/11/26 21:34:09 helmut Exp $ */
+ 
+ 
+ #ifndef __translator_h
+ #define __translator_h
+ 
+ #include "code.h"
+ #include "engine.h"
+ 
+ void translate_to_icode(methods *meth);
+ 
+ char *opcode_2_string(unsigned char opcode);
+ Instr opcode_2_label(unsigned char opcode);
+ char *label_2_string(Instr label);
+ unsigned label_2_opcode(Instr label);
+ Instr string_2_label(char *label_string);
+ unsigned char string_2_opcode(char *opcode_string);
+ unsigned ip_2_pc(Instr* ip, methods *mp);
+ Instr* pc_2_ip(unsigned pc, methods *mp);
+ 
+ #endif __translator_h