X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Fmips%2Fcodegen.c;h=35502fe003154eb2f90b2b97ebbea77fc77366c3;hb=a9be6929d101f0ed22f3acf1c24a8c44dbfd7e2d;hp=f536beac2a42c15b5fb75c401d2a07459a0054d9;hpb=0b248de7d65afc26137808193030b402750bf619;p=cacao.git

diff --git a/src/vm/jit/mips/codegen.c b/src/vm/jit/mips/codegen.c
index f536beac2..35502fe00 100644
--- a/src/vm/jit/mips/codegen.c
+++ b/src/vm/jit/mips/codegen.c
@@ -1,6 +1,6 @@
 /* src/vm/jit/mips/codegen.c - machine code generator for MIPS
 
-   Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel,
+   Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
    J. Wenninger, Institut f. Computersprachen - TU Wien
@@ -22,21 +22,6 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 
-   Contact: cacao@cacaojvm.org
-
-   Authors: Andreas Krall
-            Reinhard Grafl
-
-   Changes: Christian Thalinger
-            Christian Ullrich
-            Edwin Steiner
-
-   Contains the codegenerator for an MIPS (R4000 or higher) processor.
-   This module generates MIPS machine code for a sequence of
-   intermediate code commands (ICMDs).
-
-   $Id: codegen.c 5891 2006-11-01 20:19:44Z twisti $
-
 */
 
 
@@ -52,24 +37,25 @@
 #include "vm/jit/mips/arch.h"
 #include "vm/jit/mips/codegen.h"
 
+#include "mm/memory.h"
+
+#include "native/localref.h"
 #include "native/native.h"
 
-#if defined(ENABLE_THREADS)
-# include "threads/native/lock.h"
-#endif
+#include "threads/lock-common.h"
 
 #include "vm/builtin.h"
-#include "vm/class.h"
 #include "vm/exceptions.h"
-#include "vm/options.h"
-#include "vm/stringlocal.h"
 #include "vm/vm.h"
+
+#include "vm/jit/abi.h"
 #include "vm/jit/asmpart.h"
 #include "vm/jit/codegen-common.h"
 #include "vm/jit/dseg.h"
 #include "vm/jit/emit-common.h"
 #include "vm/jit/jit.h"
-#include "vm/jit/patcher.h"
+#include "vm/jit/linenumbertable.h"
+#include "vm/jit/patcher-common.h"
 #include "vm/jit/reg.h"
 #include "vm/jit/replace.h"
 
@@ -77,14 +63,17 @@
 # include "vm/jit/allocator/lsra.h"
 #endif
 
+#include "vmcore/class.h"
+#include "vmcore/options.h"
+
 
-/* codegen *********************************************************************
+/* codegen_emit ****************************************************************
 
    Generates machine code.
 
 *******************************************************************************/
 
-bool codegen(jitdata *jd)
+bool codegen_emit(jitdata *jd)
 {
 	methodinfo         *m;
 	codeinfo           *code;
@@ -94,15 +83,15 @@ bool codegen(jitdata *jd)
 	varinfo            *var;
 	basicblock         *bptr;
 	instruction        *iptr;
-	exception_entry    *ex;
 	u2                  currentline;
+	constant_classref  *cr;
+	unresolved_class   *uc;
 	methodinfo         *lm;             /* local methodinfo for ICMD_INVOKE*  */
 	unresolved_method  *um;
 	builtintable_entry *bte;
 	methoddesc         *md;
 	fieldinfo          *fi;
 	unresolved_field   *uf;
-	rplpoint           *replacementpoint;
 	s4                  fieldtype;
 	s4                  varindex;
 
@@ -115,18 +104,20 @@ bool codegen(jitdata *jd)
 
 	/* prevent compiler warnings */
 
+	s1          = 0;
 	d           = 0;
 	fieldtype   = 0;
 	lm          = NULL;
 	um          = NULL;
 	bte         = NULL;
 	currentline = 0;
+	uf          = NULL;
 
 	{
 	s4 i, p, t, l;
 	s4 savedregs_num;
 
-	savedregs_num = (jd->isleafmethod) ? 0 : 1;       /* space to save the RA */
+	savedregs_num = code_is_leafmethod(code) ? 0 : 1; /* space to save the RA */
 
 	/* space to save used callee saved registers */
 
@@ -138,8 +129,14 @@ bool codegen(jitdata *jd)
 #if defined(ENABLE_THREADS)
 	/* space to save argument of monitor_enter */
 
-	if (checksync && (m->flags & ACC_SYNCHRONIZED))
+	if (checksync && code_is_synchronized(code)) {
+# if SIZEOF_VOID_P == 8
 		cd->stackframesize++;
+# else
+		rd->memuse++;
+		cd->stackframesize += 2;
+# endif
+	}
 #endif
 
 	/* keep stack 16-byte aligned */
@@ -152,34 +149,18 @@ bool codegen(jitdata *jd)
 	(void) dseg_add_unique_address(cd, code);              /* CodeinfoPointer */
 	(void) dseg_add_unique_s4(cd, cd->stackframesize * 8); /* FrameSize       */
 
-#if defined(ENABLE_THREADS)
-	/* IsSync contains the offset relative to the stack pointer for the
-	   argument of monitor_exit used in the exception handler. Since the
-	   offset could be zero and give a wrong meaning of the flag it is
-	   offset by one.
-	*/
-
-	if (checksync && (m->flags & ACC_SYNCHRONIZED))
-		(void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 8); /* IsSync        */
+	code->synchronizedoffset = rd->memuse * 8;
+
+	/* REMOVEME: We still need it for exception handling in assembler. */
+
+	if (code_is_leafmethod(code))
+		(void) dseg_add_unique_s4(cd, 1);
 	else
-#endif
-		(void) dseg_add_unique_s4(cd, 0);                  /* IsSync          */
-	                                       
-	(void) dseg_add_unique_s4(cd, jd->isleafmethod);       /* IsLeaf          */
+		(void) dseg_add_unique_s4(cd, 0);
+
 	(void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
 	(void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
-	dseg_addlinenumbertablesize(cd);
-	(void) dseg_add_unique_s4(cd, jd->exceptiontablelength); /* ExTableSize   */
-
-	/* create exception table */
 
-	for (ex = jd->exceptiontable; ex != NULL; ex = ex->down) {
-		dseg_add_target(cd, ex->start);
-   		dseg_add_target(cd, ex->end);
-		dseg_add_target(cd, ex->handler);
-		(void) dseg_add_unique_address(cd, ex->catchtype.any);
-	}
-	
 	/* create stack frame (if necessary) */
 
 	if (cd->stackframesize)
@@ -188,7 +169,7 @@ bool codegen(jitdata *jd)
 	/* save return address and used callee saved registers */
 
 	p = cd->stackframesize;
-	if (!jd->isleafmethod) {
+	if (!code_is_leafmethod(code)) {
 		p--; M_AST(REG_RA, REG_SP, p * 8);
 	}
 	for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
@@ -215,56 +196,77 @@ bool codegen(jitdata *jd)
 			continue;
 
  		var = VAR(varindex);
+		s1  = md->params[p].regoff;
 
-		s1 = md->params[p].regoff;
 		if (IS_INT_LNG_TYPE(t)) {                    /* integer args          */
  			if (!md->params[p].inmemory) {           /* register arguments    */
-				s2 = rd->argintregs[s1];
- 				if (!(var->flags & INMEMORY)) {      /* reg arg -> register   */
- 					M_INTMOVE(s2, var->vv.regoff);
- 				} else {                             /* reg arg -> spilled    */
- 					M_LST(s2, REG_SP, var->vv.regoff * 8);
- 				}
-
- 			} else {                                 /* stack arguments       */
- 				if (!(var->flags & INMEMORY)) {      /* stack arg -> register */
- 					M_LLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
- 				} else {                             /* stack arg -> spilled  */
-					var->vv.regoff = cd->stackframesize + s1;
+#if SIZEOF_VOID_P == 8
+ 				if (!(var->flags & INMEMORY))
+ 					M_INTMOVE(s1, var->vv.regoff);
+ 				else
+ 					M_LST(s1, REG_SP, var->vv.regoff);
+#else
+				if (!(var->flags & INMEMORY)) {
+					if (IS_2_WORD_TYPE(t))
+						M_LNGMOVE(s1, var->vv.regoff);
+					else
+						M_INTMOVE(s1, var->vv.regoff);
 				}
+				else {
+					if (IS_2_WORD_TYPE(t))
+						M_LST(s1, REG_SP, var->vv.regoff);
+					else
+						M_IST(s1, REG_SP, var->vv.regoff);
+				}
+#endif
+ 			}
+			else {                                   /* stack arguments       */
+ 				if (!(var->flags & INMEMORY)) {
+#if SIZEOF_VOID_P == 8
+ 					M_LLD(var->vv.regoff, REG_SP, cd->stackframesize * 8 + s1);
+#else
+					if (IS_2_WORD_TYPE(t))
+						M_LLD(var->vv.regoff, REG_SP, cd->stackframesize * 8 + s1);
+					else
+						M_ILD(var->vv.regoff, REG_SP, cd->stackframesize * 8 + s1);
+#endif
+ 				}
+				else
+					var->vv.regoff = cd->stackframesize * 8 + s1;
 			}
-
- 		} else {                                     /* floating args         */
- 			if (!md->params[p].inmemory) {           /* register arguments    */
-				s2 = rd->argfltregs[s1];
- 				if (!(var->flags & INMEMORY)) {      /* reg arg -> register   */
+ 		}
+		else {                                       /* floating args         */
+ 			if (!md->params[p].inmemory) {
+ 				if (!(var->flags & INMEMORY)) {
 					if (IS_2_WORD_TYPE(t))
-						M_DMOV(s2, var->vv.regoff);
+						M_DBLMOVE(s1, var->vv.regoff);
 					else
-						M_FMOV(s2, var->vv.regoff);
- 				} else {			                 /* reg arg -> spilled    */
+						M_FLTMOVE(s1, var->vv.regoff);
+ 				}
+				else {
 					if (IS_2_WORD_TYPE(t))
-						M_DST(s2, REG_SP, var->vv.regoff * 8);
+						M_DST(s1, REG_SP, var->vv.regoff);
 					else
-						M_FST(s2, REG_SP, var->vv.regoff * 8);
+						M_FST(s1, REG_SP, var->vv.regoff);
  				}
-
- 			} else {                                 /* stack arguments       */
- 				if (!(var->flags & INMEMORY)) {      /* stack-arg -> register */
+ 			}
+			else {
+ 				if (!(var->flags & INMEMORY)) {
 					if (IS_2_WORD_TYPE(t))
-						M_DLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
+						M_DLD(var->vv.regoff, REG_SP, cd->stackframesize * 8 + s1);
 					else
-						M_FLD(var->vv.regoff, REG_SP, (cd->stackframesize + s1) * 8);
-				} else                               /* stack-arg -> spilled  */
-					var->vv.regoff = cd->stackframesize + s1;
+						M_FLD(var->vv.regoff, REG_SP, cd->stackframesize * 8 + s1);
+				}
+				else
+					var->vv.regoff = cd->stackframesize * 8 + s1;
 			}
 		}
-	} /* end for */
+	}
 
 	/* call monitorenter function */
 
 #if defined(ENABLE_THREADS)
-	if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
+	if (checksync && code_is_synchronized(code)) {
 		/* stack offset for monitor argument */
 
 		s1 = rd->memuse;
@@ -274,10 +276,10 @@ bool codegen(jitdata *jd)
 			M_LDA(REG_SP, REG_SP, -(INT_ARG_CNT + FLT_ARG_CNT) * 8);
 
 			for (p = 0; p < INT_ARG_CNT; p++)
-				M_LST(rd->argintregs[p], REG_SP, p * 8);
+				M_AST(abi_registers_integer_argument[p], REG_SP, p * 8);
 
 			for (p = 0; p < FLT_ARG_CNT; p++)
-				M_DST(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+				M_DST(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
 
 			s1 += INT_ARG_CNT + FLT_ARG_CNT;
 		}
@@ -288,24 +290,27 @@ bool codegen(jitdata *jd)
 		if (m->flags & ACC_STATIC) {
 			disp = dseg_add_address(cd, &m->class->object.header);
 			M_ALD(REG_A0, REG_PV, disp);
+			disp = dseg_add_functionptr(cd, LOCK_monitor_enter);
+			M_ALD(REG_ITMP3, REG_PV, disp);
 		}
 		else {
-			M_BEQZ(REG_A0, 0);
-			codegen_add_nullpointerexception_ref(cd);
+/* 			emit_nullpointer_check(cd, iptr, REG_A0); */
+			M_BNEZ(REG_A0, 2);
+			disp = dseg_add_functionptr(cd, LOCK_monitor_enter);
+			M_ALD(REG_ITMP3, REG_PV, disp);                   /* branch delay */
+			M_ALD_INTERN(REG_ZERO, REG_ZERO, EXCEPTION_HARDWARE_NULLPOINTER);
 		}
 
-		disp = dseg_add_functionptr(cd, LOCK_monitor_enter);
-		M_ALD(REG_ITMP3, REG_PV, disp);
 		M_JSR(REG_RA, REG_ITMP3);
-		M_AST(REG_A0, REG_SP, s1 * 8);         /* branch delay */
+		M_AST(REG_A0, REG_SP, s1 * 8);                        /* branch delay */
 
 # if !defined(NDEBUG)
 		if (opt_verbosecall) {
 			for (p = 0; p < INT_ARG_CNT; p++)
-				M_LLD(rd->argintregs[p], REG_SP, p * 8);
+				M_ALD(abi_registers_integer_argument[p], REG_SP, p * 8);
 
 			for (p = 0; p < FLT_ARG_CNT; p++)
-				M_DLD(rd->argfltregs[p], REG_SP, (INT_ARG_CNT + p) * 8);
+				M_DLD(abi_registers_float_argument[p], REG_SP, (INT_ARG_CNT + p) * 8);
 
 
 			M_LDA(REG_SP, REG_SP, (INT_ARG_CNT + FLT_ARG_CNT) * 8);
@@ -313,17 +318,18 @@ bool codegen(jitdata *jd)
 # endif
 	}
 #endif
+	}
 
 #if !defined(NDEBUG)
 	if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
 		emit_verbosecall_enter(jd);
 #endif
 
-	}
-
 	/* end of header generation */
 
-	replacementpoint = jd->code->rplpoints;
+	/* create replacement points */
+
+	REPLACEMENT_POINTS_INIT(cd, jd);
 
 	/* walk through all basic blocks */
 
@@ -331,37 +337,16 @@ bool codegen(jitdata *jd)
 
 		/* handle replacement points */
 
-#if 0
-		if (bptr->bitflags & BBFLAG_REPLACEMENT && bptr->flags >= BBREACHED) {
-
-			/* 8-byte align pc */
-			if ((ptrint) cd->mcodeptr & 4) {
-				M_NOP;
-			}
-			
-			replacementpoint->pc = (u1*)(ptrint) (cd->mcodeptr - cd->mcodebase);
-			replacementpoint++;
-
-			assert(cd->lastmcodeptr <= cd->mcodeptr);
-			cd->lastmcodeptr = cd->mcodeptr + 2 * 4;       /* br + delay slot */
-		}
-#endif
+		REPLACEMENT_POINT_BLOCK_START(cd, bptr);
 
 		/* store relative start of block */
 
 		bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
 
 		if (bptr->flags >= BBREACHED) {
-
 			/* branch resolving */
-			{
-				branchref *bref;
-				for (bref = bptr->branchrefs; bref != NULL; bref = bref->next) {
-					gen_resolvebranch(cd->mcodebase + bref->branchpos, 
-									  bref->branchpos,
-									  bptr->mpc);
-				}
-			}
+
+			codegen_resolve_branchrefs(cd, bptr);
 
 		/* copy interface registers to their destination */
 
@@ -402,27 +387,45 @@ bool codegen(jitdata *jd)
 		/* walk through all instructions */
 		
 		len = bptr->icount;
-		currentline = 0;
+/* 		currentline = 0; */
 
 		for (iptr = bptr->iinstr; len > 0; len--, iptr++) {
 			if (iptr->line != currentline) {
-				dseg_addlinenumber(cd, iptr->line);
+				linenumbertable_list_entry_add(cd, iptr->line);
 				currentline = iptr->line;
 			}
 
-			MCODECHECK(64);   /* an instruction usually needs < 64 words      */
+		MCODECHECK(64);       /* an instruction usually needs < 64 words      */
 
-			switch (iptr->opc) {
+		switch (iptr->opc) {
 
 		case ICMD_NOP:        /* ...  ==> ...                                 */
+		case ICMD_POP:        /* ..., value  ==> ...                          */
+		case ICMD_POP2:       /* ..., value, value  ==> ...                   */
+			break;
+
+		case ICMD_INLINE_START:
+
+			REPLACEMENT_POINT_INLINE_START(cd, iptr);
+			break;
+
+		case ICMD_INLINE_BODY:
+
+			REPLACEMENT_POINT_INLINE_BODY(cd, iptr);
+			linenumbertable_list_entry_add_inline_start(cd, iptr);
+			linenumbertable_list_entry_add(cd, iptr->line);
+			break;
+
+		case ICMD_INLINE_END:
+
+			linenumbertable_list_entry_add_inline_end(cd, iptr);
+			linenumbertable_list_entry_add(cd, iptr->line);
 			break;
 
 		case ICMD_CHECKNULL:  /* ..., objectref  ==> ..., objectref           */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			M_BEQZ(s1, 0);
-			codegen_add_nullpointerexception_ref(cd);
-			M_NOP;
+			emit_nullpointer_check(cd, iptr, s1);
 			break;
 
 		/* constant operations ************************************************/
@@ -436,7 +439,11 @@ bool codegen(jitdata *jd)
 
 		case ICMD_LCONST:     /* ...  ==> ..., constant                       */
 
+#if SIZEOF_VOID_P == 8
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+#endif
 			LCONST(d, iptr->sx.val.l);
 			emit_store_dst(jd, iptr, d);
 			break;
@@ -462,15 +469,11 @@ bool codegen(jitdata *jd)
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				constant_classref *cr = iptr->sx.val.c.ref;
-
+				cr   = iptr->sx.val.c.ref;
 				disp = dseg_add_unique_address(cd, cr);
 
-				codegen_addpatchref(cd, PATCHER_aconst, cr, disp);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_classinfo,
+									  cr, disp);
 
 				M_ALD(d, REG_PV, disp);
 			}
@@ -489,28 +492,23 @@ bool codegen(jitdata *jd)
 		/* load/store/copy/move operations ************************************/
 
 		case ICMD_ILOAD:      /* ...  ==> ..., content of local variable      */
-		case ICMD_LLOAD:      /* ...  ==> ..., content of local variable      */
-		case ICMD_ALOAD:      /* ...  ==> ..., content of local variable      */
-		case ICMD_FLOAD:      /* ...  ==> ..., content of local variable      */
-		case ICMD_DLOAD:      /* ...  ==> ..., content of local variable      */
+		case ICMD_LLOAD:
+		case ICMD_ALOAD:
+		case ICMD_FLOAD:
+		case ICMD_DLOAD:
 		case ICMD_ISTORE:     /* ..., value  ==> ...                          */
-		case ICMD_LSTORE:     /* ..., value  ==> ...                          */
-		case ICMD_ASTORE:     /* ..., value  ==> ...                          */
-		case ICMD_FSTORE:     /* ..., value  ==> ...                          */
-		case ICMD_DSTORE:     /* ..., value  ==> ...                          */
+		case ICMD_LSTORE:
+		case ICMD_FSTORE:
+		case ICMD_DSTORE:
 		case ICMD_COPY:
 		case ICMD_MOVE:
 
-			emit_copy(jd, iptr, VAROP(iptr->s1), VAROP(iptr->dst));
+			emit_copy(jd, iptr);
 			break;
 
-
-		/* pop/dup/swap operations ********************************************/
-
-		/* attention: double and longs are only one entry in CACAO ICMDs      */
-
-		case ICMD_POP:        /* ..., value  ==> ...                          */
-		case ICMD_POP2:       /* ..., value, value  ==> ...                   */
+		case ICMD_ASTORE:
+			if (!(iptr->flags.bits & INS_FLAG_RETADDR))
+				emit_copy(jd, iptr);
 			break;
 
 
@@ -526,25 +524,46 @@ bool codegen(jitdata *jd)
 
 		case ICMD_LNEG:       /* ..., value  ==> ..., - value                 */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_LSUB(REG_ZERO, s1, d);
+#else
+			s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_ISUB(REG_ZERO, GET_LOW_REG(s1), GET_LOW_REG(d));
+			M_ISUB(REG_ZERO, GET_HIGH_REG(s1), GET_HIGH_REG(d));
+			M_CMPULT(REG_ZERO, GET_LOW_REG(d), REG_ITMP3);
+			M_ISUB(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_I2L:        /* ..., value  ==> ..., value                   */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+#if SIZEOF_VOID_P == 8
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_INTMOVE(s1, d);
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_INTMOVE(s1, GET_LOW_REG(d));
+			M_ISRA_IMM(GET_LOW_REG(d), 31, GET_HIGH_REG(d));
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_L2I:        /* ..., value  ==> ..., value                   */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			M_ISLL_IMM(s1, 0, d );
+			M_ISLL_IMM(s1, 0, d);
+#else
+			s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_INTMOVE(GET_LOW_REG(s1), d);
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -552,8 +571,13 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+#if SIZEOF_VOID_P == 8
 			M_LSLL_IMM(s1, 56, d);
 			M_LSRA_IMM( d, 56, d);
+#else
+			M_ISLL_IMM(s1, 24, d);
+			M_ISRA_IMM( d, 24, d);
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -561,7 +585,7 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-            M_CZEXT(s1, d);
+			M_AND_IMM(s1, 0xffff, d);
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -569,8 +593,13 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+#if SIZEOF_VOID_P == 8
 			M_LSLL_IMM(s1, 48, d);
 			M_LSRA_IMM( d, 48, d);
+#else
+			M_ISLL_IMM(s1, 16, d);
+			M_ISRA_IMM( d, 16, d);
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -601,16 +630,33 @@ bool codegen(jitdata *jd)
 
 		case ICMD_LADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_LADD(s1, s2, d);
+#else
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_IADD(s1, s2, GET_HIGH_REG(d));
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+			s2 = emit_load_s2_low(jd, iptr, GET_LOW_REG(REG_ITMP12_PACKED));
+			if (s1 == GET_LOW_REG(d)) {
+				M_MOV(s1, REG_ITMP3);
+				s1 = REG_ITMP3;
+			}
+			M_IADD(s1, s2, GET_LOW_REG(d));
+			M_CMPULT(GET_LOW_REG(d), s1, REG_ITMP3);
+			M_IADD(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LADDCONST:  /* ..., value  ==> ..., value + constant        */
 		                      /* sx.val.l = constant                          */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			if ((iptr->sx.val.l >= -32768) && (iptr->sx.val.l <= 32767))
@@ -619,6 +665,33 @@ bool codegen(jitdata *jd)
 				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_LADD(s1, REG_ITMP2, d);
 			}
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 32767)) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_IADD_IMM(GET_LOW_REG(s1), iptr->sx.val.l, GET_LOW_REG(d));
+				M_CMPULT_IMM(GET_LOW_REG(d), iptr->sx.val.l, REG_ITMP3);
+				M_IADD(GET_HIGH_REG(s1), REG_ITMP3, GET_HIGH_REG(d));
+			}
+			else if ((iptr->sx.val.l >= (-32768 + 1)) && (iptr->sx.val.l < 0)) {
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
+				M_ISUB_IMM(s1, -(iptr->sx.val.l), GET_LOW_REG(d));
+				M_CMPULT_IMM(GET_LOW_REG(d), iptr->sx.val.l, REG_ITMP3);
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP2);
+				M_ISUB_IMM(s1, 1, GET_HIGH_REG(d));
+				M_IADD(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+			}
+			else {
+				ICONST(REG_ITMP2, iptr->sx.val.l & 0xffffffff);
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_IADD(s1, REG_ITMP2, GET_LOW_REG(d));
+				M_CMPULT(GET_LOW_REG(d), s1, REG_ITMP3);
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP2);
+				M_IADD(s1, REG_ITMP3, GET_HIGH_REG(d));
+				ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
+				M_IADD(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+			}
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -647,16 +720,34 @@ bool codegen(jitdata *jd)
 
 		case ICMD_LSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_LSUB(s1, s2, d);
+#else
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_ISUB(s1, s2, GET_HIGH_REG(d));
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP1);
+			M_CMPULT(s1, s2, REG_ITMP3);
+			M_ISUB(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+			/* if s1 is equal to REG_ITMP3 we have to reload it, since
+			   the CMPULT instruction destroyed it */
+			if (s1 == REG_ITMP3)
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+			M_ISUB(s1, s2, GET_LOW_REG(d));
+
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LSUBCONST:  /* ..., value  ==> ..., value - constant        */
 		                      /* sx.val.l = constant                          */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			if ((iptr->sx.val.l >= -32767) && (iptr->sx.val.l <= 32768))
@@ -665,6 +756,33 @@ bool codegen(jitdata *jd)
 				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_LSUB(s1, REG_ITMP2, d);
 			}
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 32768)) {
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
+				M_ISUB_IMM(s1, iptr->sx.val.l, GET_LOW_REG(d));
+				M_CMPULT_IMM(GET_LOW_REG(d), -(iptr->sx.val.l), REG_ITMP3);
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP2);
+				M_ISUB_IMM(s1, 1, GET_HIGH_REG(d));
+				M_IADD(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+			}
+			else if ((iptr->sx.val.l >= -32767) && (iptr->sx.val.l < 0)) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_IADD_IMM(GET_LOW_REG(s1), -(iptr->sx.val.l), GET_LOW_REG(d));
+				M_CMPULT_IMM(GET_LOW_REG(d), -(iptr->sx.val.l), REG_ITMP3);
+				M_IADD(GET_HIGH_REG(s1), REG_ITMP3, GET_HIGH_REG(d));
+			}
+			else {
+				ICONST(REG_ITMP2, iptr->sx.val.l & 0xffffffff);
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_ISUB(s1, REG_ITMP2, GET_LOW_REG(d));
+				M_CMPULT(s1, REG_ITMP2, REG_ITMP3);
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP2);
+				M_ISUB(s1, REG_ITMP3, GET_HIGH_REG(d));
+				ICONST(REG_ITMP3, iptr->sx.val.l >> 32);
+				M_ISUB(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+			}
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -695,6 +813,7 @@ bool codegen(jitdata *jd)
 
 		case ICMD_LMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
@@ -702,6 +821,28 @@ bool codegen(jitdata *jd)
 			M_MFLO(d);
 			M_NOP;
 			M_NOP;
+#else
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_IMUL(s2, s1);
+			M_MFLO(REG_ITMP3);
+			M_NOP;
+			M_NOP;
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			M_IMULU(s2, s1);
+			M_MFHI(GET_HIGH_REG(d));
+			M_MFLO(GET_LOW_REG(d));
+			M_NOP;
+			M_NOP;
+			M_IADD(GET_HIGH_REG(d), REG_ITMP3, REG_ITMP3);
+
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			M_IMUL(s1, s2);
+			M_MFLO(s2);
+			/* XXX do we need nops here? */
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -723,7 +864,7 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			gen_div_check(s2);
+			emit_arithmetic_check(cd, iptr, s2);
 			M_IDIV(s1, s2);
 			M_MFLO(d);
 			M_NOP;
@@ -731,27 +872,29 @@ bool codegen(jitdata *jd)
 			emit_store_dst(jd, iptr, d);
 			break;
 
-		case ICMD_LDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
+		case ICMD_IREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			gen_div_check(s2);
-			M_LDIV(s1, s2);
-			M_MFLO(d);
+			emit_arithmetic_check(cd, iptr, s2);
+			M_IDIV(s1, s2);
+			M_MFHI(d);
 			M_NOP;
 			M_NOP;
 			emit_store_dst(jd, iptr, d);
 			break;
 
-		case ICMD_IREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
+#if SIZEOF_VOID_P == 8
+
+		case ICMD_LDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			gen_div_check(s2);
-			M_IDIV(s1, s2);
-			M_MFHI(d);
+			emit_arithmetic_check(cd, iptr, s2);
+			M_LDIV(s1, s2);
+			M_MFLO(d);
 			M_NOP;
 			M_NOP;
 			emit_store_dst(jd, iptr, d);
@@ -762,7 +905,7 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			gen_div_check(s2);
+			emit_arithmetic_check(cd, iptr, s2);
 			M_LDIV(s1, s2);
 			M_MFHI(d);
 			M_NOP;
@@ -770,20 +913,55 @@ bool codegen(jitdata *jd)
 			emit_store_dst(jd, iptr, d);
 			break;
 
+#else /* SIZEOF_VOID_P == 8 */
+
+		case ICMD_LDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
+		case ICMD_LREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
+
+			s1 = emit_load_s1(jd, iptr, REG_A0_A1_PACKED);
+			s2 = emit_load_s2(jd, iptr, REG_A2_A3_PACKED);
+
+			/* XXX TODO: only do this if arithmetic check is really done! */
+			M_OR(GET_HIGH_REG(s2), GET_LOW_REG(s2), REG_ITMP3);
+			emit_arithmetic_check(cd, iptr, REG_ITMP3);
+
+			M_LNGMOVE(s1, REG_A0_A1_PACKED);
+			M_LNGMOVE(s2, REG_A2_A3_PACKED);
+
+			bte = iptr->sx.s23.s3.bte;
+			disp = dseg_add_functionptr(cd, bte->fp);
+			M_ALD(REG_ITMP3, REG_PV, disp);
+			M_JSR(REG_RA, REG_ITMP3);
+			M_NOP;
+
+			d = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
+			M_LNGMOVE(REG_RESULT_PACKED, d);
+			emit_store_dst(jd, iptr, d);
+			break;
+
+#endif /* SIZEOF_VOID_P == 8 */
+
 		case ICMD_IDIVPOW2:   /* ..., value  ==> ..., value << constant       */
-		case ICMD_LDIVPOW2:   /* val.i = constant                             */
+		                      /* val.i = constant                             */
 		                      
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+#if SIZEOF_VOID_P == 8
 			M_LSRA_IMM(s1, 63, REG_ITMP2);
 			M_LSRL_IMM(REG_ITMP2, 64 - iptr->sx.val.i, REG_ITMP2);
 			M_LADD(s1, REG_ITMP2, REG_ITMP2);
 			M_LSRA_IMM(REG_ITMP2, iptr->sx.val.i, d);
+#else
+			M_ISRA_IMM(s1, 31, REG_ITMP2);
+			M_ISRL_IMM(REG_ITMP2, 32 - iptr->sx.val.i, REG_ITMP2);
+			M_IADD(s1, REG_ITMP2, REG_ITMP2);
+			M_ISRA_IMM(REG_ITMP2, iptr->sx.val.i, d);
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IREMPOW2:   /* ..., value  ==> ..., value % constant        */
-		                      /* sx.val.i = constant                          */
+		                      /* val.i = constant                             */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
@@ -810,8 +988,22 @@ bool codegen(jitdata *jd)
 			emit_store_dst(jd, iptr, d);
 			break;
 
+#if SIZEOF_VOID_P == 8
+
+		case ICMD_LDIVPOW2:   /* ..., value  ==> ..., value << constant       */
+		                      /* val.i = constant                             */
+		                      
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_LSRA_IMM(s1, 63, REG_ITMP2);
+			M_LSRL_IMM(REG_ITMP2, 64 - iptr->sx.val.i, REG_ITMP2);
+			M_LADD(s1, REG_ITMP2, REG_ITMP2);
+			M_LSRA_IMM(REG_ITMP2, iptr->sx.val.i, d);
+			emit_store_dst(jd, iptr, d);
+			break;
+
 		case ICMD_LREMPOW2:   /* ..., value  ==> ..., value % constant        */
-		                      /* sx.val.l = constant                          */
+		                      /* val.l = constant                             */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
@@ -838,6 +1030,8 @@ bool codegen(jitdata *jd)
 			emit_store_dst(jd, iptr, d);
 			break;
 
+#endif /* SIZEOF_VOID_P == 8 */
+
 		case ICMD_ISHL:       /* ..., val1, val2  ==> ..., val1 << val2       */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
@@ -894,13 +1088,43 @@ bool codegen(jitdata *jd)
 
 		case ICMD_LSHL:       /* ..., val1, val2  ==> ..., val1 << val2       */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_LSLL(s1, s2, d);
+#else
+			s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP3);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+
+			M_ISLL(s2, 26, REG_ITMP1);
+			M_BGEZ(REG_ITMP1, 3);
+			M_NOP;
+
+			M_ISLL(GET_LOW_REG(s1), s2, GET_HIGH_REG(d));
+			M_BR(7);
+			M_MOV(REG_ZERO, GET_LOW_REG(d));                    /* delay slot */
+
+#if 1
+			M_ISLL(GET_LOW_REG(s1), s2, GET_LOW_REG(d));
+#endif
+			M_BEQZ(REG_ITMP1, 4);
+			M_ISLL(GET_HIGH_REG(s1), s2, GET_HIGH_REG(d));      /* delay slot */
+
+			M_ISUB(s2, REG_ZERO, REG_ITMP3);
+			M_ISRL(GET_LOW_REG(s1), REG_ITMP3, REG_ITMP3);
+			M_OR(GET_HIGH_REG(d), REG_ITMP3, GET_HIGH_REG(d));
+
+#if 0
+			M_ISLL(GET_LOW_REG(s1), s2, GET_LOW_REG(d));
+#endif
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
+#if SIZEOF_VOID_P == 8
+
 		case ICMD_LSHLCONST:  /* ..., value  ==> ..., value << constant       */
 		                      /* sx.val.i = constant                             */
 
@@ -946,8 +1170,9 @@ bool codegen(jitdata *jd)
 			emit_store_dst(jd, iptr, d);
 			break;
 
+#endif /* SIZEOF_VOID_P == 8 */
+
 		case ICMD_IAND:       /* ..., val1, val2  ==> ..., val1 & val2        */
-		case ICMD_LAND:
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
@@ -961,18 +1186,38 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			if ((iptr->sx.val.i >= 0) && (iptr->sx.val.i <= 0xffff)) {
+			if ((iptr->sx.val.i >= 0) && (iptr->sx.val.i <= 0xffff))
 				M_AND_IMM(s1, iptr->sx.val.i, d);
-			} else {
+			else {
 				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_AND(s1, REG_ITMP2, d);
 			}
 			emit_store_dst(jd, iptr, d);
 			break;
 
+		case ICMD_LAND:       /* ..., val1, val2  ==> ..., val1 & val2        */
+
+#if SIZEOF_VOID_P == 8
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
+			M_AND(s1, s2, d);
+#else
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP3);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_AND(s1, s2, GET_LOW_REG(d));
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP2);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);
+			M_AND(s1, s2, GET_HIGH_REG(d));
+#endif
+			emit_store_dst(jd, iptr, d);
+			break;
+
 		case ICMD_LANDCONST:  /* ..., value  ==> ..., value & constant        */
 		                      /* sx.val.l = constant                          */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff))
@@ -981,16 +1226,30 @@ bool codegen(jitdata *jd)
 				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_AND(s1, REG_ITMP2, d);
 			}
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_AND_IMM(GET_LOW_REG(s1), iptr->sx.val.l, GET_LOW_REG(d));
+				M_AND_IMM(GET_HIGH_REG(s1), 0, GET_HIGH_REG(d));
+			}
+			else {
+				LCONST(REG_ITMP12_PACKED, iptr->sx.val.l);
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_AND(s1, GET_LOW_REG(REG_ITMP12_PACKED), GET_LOW_REG(d));
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP3);
+				M_AND(s1, GET_HIGH_REG(REG_ITMP12_PACKED), GET_HIGH_REG(d));
+			}
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IOR:        /* ..., val1, val2  ==> ..., val1 | val2        */
-		case ICMD_LOR:
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			M_OR(s1,s2, d);
+			M_OR(s1, s2, d);
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1008,9 +1267,29 @@ bool codegen(jitdata *jd)
 			emit_store_dst(jd, iptr, d);
 			break;
 
+		case ICMD_LOR:        /* ..., val1, val2  ==> ..., val1 | val2        */
+
+#if SIZEOF_VOID_P == 8
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_OR(s1, s2, d);
+#else
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP3);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_OR(s1, s2, GET_LOW_REG(d));
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP2);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);
+			M_OR(s1, s2, GET_HIGH_REG(d));
+#endif
+			emit_store_dst(jd, iptr, d);
+			break;
+
 		case ICMD_LORCONST:   /* ..., value  ==> ..., value | constant        */
 		                      /* sx.val.l = constant                          */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff))
@@ -1019,11 +1298,25 @@ bool codegen(jitdata *jd)
 				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_OR(s1, REG_ITMP2, d);
 			}
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_OR_IMM(GET_LOW_REG(s1), iptr->sx.val.l, GET_LOW_REG(d));
+				M_OR_IMM(GET_HIGH_REG(s1), 0, GET_HIGH_REG(d));
+			}
+			else {
+				LCONST(REG_ITMP12_PACKED, iptr->sx.val.l);
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_OR(s1, GET_LOW_REG(REG_ITMP12_PACKED), GET_LOW_REG(d));
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP3);
+				M_OR(s1, GET_HIGH_REG(REG_ITMP12_PACKED), GET_HIGH_REG(d));
+			}
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IXOR:       /* ..., val1, val2  ==> ..., val1 ^ val2        */
-		case ICMD_LXOR:
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
@@ -1046,9 +1339,29 @@ bool codegen(jitdata *jd)
 			emit_store_dst(jd, iptr, d);
 			break;
 
+		case ICMD_LXOR:       /* ..., val1, val2  ==> ..., val1 ^ val2        */
+
+#if SIZEOF_VOID_P == 8
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_XOR(s1, s2, d);
+#else
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP2);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP3);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			M_XOR(s1, s2, GET_LOW_REG(d));
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP2);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP3);
+			M_XOR(s1, s2, GET_HIGH_REG(d));
+#endif
+			emit_store_dst(jd, iptr, d);
+			break;
+
 		case ICMD_LXORCONST:  /* ..., value  ==> ..., value ^ constant        */
 		                      /* sx.val.l = constant                          */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff))
@@ -1057,18 +1370,49 @@ bool codegen(jitdata *jd)
 				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_XOR(s1, REG_ITMP2, d);
 			}
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 0xffff)) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_XOR_IMM(GET_LOW_REG(s1), iptr->sx.val.l, GET_LOW_REG(d));
+				M_XOR_IMM(GET_HIGH_REG(s1), 0, GET_HIGH_REG(d));
+			}
+			else {
+				LCONST(REG_ITMP12_PACKED, iptr->sx.val.l);
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_XOR(s1, GET_LOW_REG(REG_ITMP12_PACKED), GET_LOW_REG(d));
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP3);
+				M_XOR(s1, GET_HIGH_REG(REG_ITMP12_PACKED), GET_HIGH_REG(d));
+			}
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
 
 		case ICMD_LCMP:       /* ..., val1, val2  ==> ..., val1 cmp val2      */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_CMPLT(s1, s2, REG_ITMP3);
 			M_CMPLT(s2, s1, REG_ITMP1);
 			M_LSUB(REG_ITMP1, REG_ITMP3, d);
+#else
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_CMPLT(s1, s2, REG_ITMP3);
+			M_CMPLT(s2, s1, REG_ITMP1);
+			M_ISUB(REG_ITMP1, REG_ITMP3, d);
+			M_BNEZ(d, 4);
+			M_NOP;
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			M_CMPULT(s1, s2, REG_ITMP3);
+			M_CMPULT(s2, s1, REG_ITMP1);
+			M_ISUB(REG_ITMP1, REG_ITMP3, d);
+#endif
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1268,7 +1612,8 @@ bool codegen(jitdata *jd)
 			M_CVTDF(s1, d);
 			emit_store_dst(jd, iptr, d);
 			break;
-		
+
+#if SUPPORT_FLOAT_CMP
 		case ICMD_FCMPL:      /* ..., val1, val2  ==> ..., val1 fcmpl val2    */
 
 			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
@@ -1276,47 +1621,49 @@ bool codegen(jitdata *jd)
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 			M_FCMPULEF(s1, s2);
 			M_FBT(3);
-			M_LADD_IMM(REG_ZERO, 1, d);
+			M_AADD_IMM(REG_ZERO, 1, d);
 			M_BR(4);
 			M_NOP;
 			M_FCMPEQF(s1, s2);
-			M_LSUB_IMM(REG_ZERO, 1, d);
+			M_ASUB_IMM(REG_ZERO, 1, d);
 			M_CMOVT(REG_ZERO, d);
 			emit_store_dst(jd, iptr, d);
 			break;
 
-		case ICMD_DCMPL:      /* ..., val1, val2  ==> ..., val1 fcmpl val2    */
+		case ICMD_FCMPG:      /* ..., val1, val2  ==> ..., val1 fcmpg val2    */
 
 			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
 			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
-			M_FCMPULED(s1, s2);
-			M_FBT(3);
-			M_LADD_IMM(REG_ZERO, 1, d);
+			M_FCMPOLTF(s1, s2);
+			M_FBF(3);
+			M_ASUB_IMM(REG_ZERO, 1, d);
 			M_BR(4);
 			M_NOP;
-			M_FCMPEQD(s1, s2);
-			M_LSUB_IMM(REG_ZERO, 1, d);
+			M_FCMPEQF(s1, s2);
+			M_AADD_IMM(REG_ZERO, 1, d);
 			M_CMOVT(REG_ZERO, d);
 			emit_store_dst(jd, iptr, d);
 			break;
-			
-		case ICMD_FCMPG:      /* ..., val1, val2  ==> ..., val1 fcmpg val2    */
+#endif
+
+#if SUPPORT_DOUBLE_CMP
+		case ICMD_DCMPL:      /* ..., val1, val2  ==> ..., val1 fcmpl val2    */
 
 			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
 			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
-			M_FCMPOLTF(s1, s2);
-			M_FBF(3);
-			M_LSUB_IMM(REG_ZERO, 1, d);
+			M_FCMPULED(s1, s2);
+			M_FBT(3);
+			M_AADD_IMM(REG_ZERO, 1, d);
 			M_BR(4);
 			M_NOP;
-			M_FCMPEQF(s1, s2);
-			M_LADD_IMM(REG_ZERO, 1, d);
+			M_FCMPEQD(s1, s2);
+			M_ASUB_IMM(REG_ZERO, 1, d);
 			M_CMOVT(REG_ZERO, d);
 			emit_store_dst(jd, iptr, d);
 			break;
-
+			
 		case ICMD_DCMPG:      /* ..., val1, val2  ==> ..., val1 fcmpg val2    */
 
 			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
@@ -1324,14 +1671,15 @@ bool codegen(jitdata *jd)
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 			M_FCMPOLTD(s1, s2);
 			M_FBF(3);
-			M_LSUB_IMM(REG_ZERO, 1, d);
+			M_ASUB_IMM(REG_ZERO, 1, d);
 			M_BR(4);
 			M_NOP;
 			M_FCMPEQD(s1, s2);
-			M_LADD_IMM(REG_ZERO, 1, d);
+			M_AADD_IMM(REG_ZERO, 1, d);
 			M_CMOVT(REG_ZERO, d);
 			emit_store_dst(jd, iptr, d);
 			break;
+#endif
 
 
 		/* memory operations **************************************************/
@@ -1340,8 +1688,8 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			gen_nullptr_check(s1);
-			M_ILD(d, s1, OFFSET(java_arrayheader, size));
+			/* implicit null-pointer check */
+			M_ILD(d, s1, OFFSET(java_array_t, size));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1350,12 +1698,10 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_AADD(s2, s1, REG_ITMP3);
-			M_BLDS(d, REG_ITMP3, OFFSET(java_bytearray, data[0]));
+			/* implicit null-pointer check */
+			M_BLDS(d, REG_ITMP3, OFFSET(java_bytearray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1364,13 +1710,11 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_AADD(s2, s1, REG_ITMP3);
 			M_AADD(s2, REG_ITMP3, REG_ITMP3);
-			M_SLDU(d, REG_ITMP3, OFFSET(java_chararray, data[0]));
+			/* implicit null-pointer check */
+			M_SLDU(d, REG_ITMP3, OFFSET(java_chararray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;			
 
@@ -1379,13 +1723,11 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_AADD(s2, s1, REG_ITMP3);
 			M_AADD(s2, REG_ITMP3, REG_ITMP3);
-			M_SLDS(d, REG_ITMP3, OFFSET(java_shortarray, data[0]));
+			/* implicit null-pointer check */
+			M_SLDS(d, REG_ITMP3, OFFSET(java_shortarray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1394,13 +1736,11 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 2, REG_ITMP3);
 			M_AADD(REG_ITMP3, s1, REG_ITMP3);
-			M_ILD(d, REG_ITMP3, OFFSET(java_intarray, data[0]));
+			/* implicit null-pointer check */
+			M_ILD_INTERN(d, REG_ITMP3, OFFSET(java_intarray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1408,14 +1748,16 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+#if SIZEOF_VOID_P == 8
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+#else
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP12_PACKED);
+#endif
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 3, REG_ITMP3);
 			M_AADD(REG_ITMP3, s1, REG_ITMP3);
-			M_LLD(d, REG_ITMP3, OFFSET(java_longarray, data[0]));
+			/* implicit null-pointer check */
+			M_LLD_INTERN(d, REG_ITMP3, OFFSET(java_longarray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1424,13 +1766,11 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 2, REG_ITMP3);
 			M_AADD(REG_ITMP3, s1, REG_ITMP3);
-			M_FLD(d, REG_ITMP3, OFFSET(java_floatarray, data[0]));
+			/* implicit null-pointer check */
+			M_FLD_INTERN(d, REG_ITMP3, OFFSET(java_floatarray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1439,13 +1779,11 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 3, REG_ITMP3);
 			M_AADD(REG_ITMP3, s1, REG_ITMP3);
-			M_DLD(d, REG_ITMP3, OFFSET(java_doublearray, data[0]));
+			/* implicit null-pointer check */
+			M_DLD_INTERN(d, REG_ITMP3, OFFSET(java_doublearray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1454,13 +1792,11 @@ bool codegen(jitdata *jd)
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP3);
 			M_AADD(REG_ITMP3, s1, REG_ITMP3);
-			M_ALD(d, REG_ITMP3, OFFSET(java_objectarray, data[0]));
+			/* implicit null-pointer check */
+			M_ALD_INTERN(d, REG_ITMP3, OFFSET(java_objectarray_t, data[0]));
 			emit_store_dst(jd, iptr, d);
 			break;
 
@@ -1469,13 +1805,11 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_AADD(s2, s1, REG_ITMP1);
 			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
-			M_BST(s3, REG_ITMP1, OFFSET(java_bytearray, data[0]));
+			/* implicit null-pointer check */
+			M_BST(s3, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
 			break;
 
 		case ICMD_CASTORE:    /* ..., arrayref, index, value  ==> ...         */
@@ -1483,70 +1817,64 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_AADD(s2, s1, REG_ITMP1);
 			M_AADD(s2, REG_ITMP1, REG_ITMP1);
 			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
-			M_SST(s3, REG_ITMP1, OFFSET(java_chararray, data[0]));
+			/* implicit null-pointer check */
+			M_SST(s3, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
 			break;
 
 		case ICMD_IASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 2, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
 			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
-			M_IST_INTERN(s3, REG_ITMP1, OFFSET(java_intarray, data[0]));
+			/* implicit null-pointer check */
+			M_IST_INTERN(s3, REG_ITMP1, OFFSET(java_intarray_t, data[0]));
 			break;
 
 		case ICMD_LASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 3, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
+#if SIZEOF_VOID_P == 8
 			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
-			M_LST_INTERN(s3, REG_ITMP1, OFFSET(java_longarray, data[0]));
+#else
+			s3 = emit_load_s3(jd, iptr, REG_ITMP23_PACKED);
+#endif
+			/* implicit null-pointer check */
+			M_LST_INTERN(s3, REG_ITMP1, OFFSET(java_longarray_t, data[0]));
 			break;
 
 		case ICMD_FASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 2, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
 			s3 = emit_load_s3(jd, iptr, REG_FTMP1);
-			M_FST_INTERN(s3, REG_ITMP1, OFFSET(java_floatarray, data[0]));
+			/* implicit null-pointer check */
+			M_FST_INTERN(s3, REG_ITMP1, OFFSET(java_floatarray_t, data[0]));
 			break;
 
 		case ICMD_DASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 3, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
 			s3 = emit_load_s3(jd, iptr, REG_FTMP1);
-			M_DST_INTERN(s3, REG_ITMP1, OFFSET(java_doublearray, data[0]));
+			/* implicit null-pointer check */
+			M_DST_INTERN(s3, REG_ITMP1, OFFSET(java_doublearray_t, data[0]));
 			break;
 
 
@@ -1554,29 +1882,24 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
 
-			M_MOV(s1, REG_A0);
-			M_MOV(s3, REG_A1);
-			disp = dseg_add_functionptr(cd, BUILTIN_canstore);
+			M_INTMOVE(s1, REG_A0);
+			M_INTMOVE(s3, REG_A1);
+			disp = dseg_add_functionptr(cd, BUILTIN_FAST_canstore);
 			M_ALD(REG_ITMP3, REG_PV, disp);
 			M_JSR(REG_RA, REG_ITMP3);
 			M_NOP;
-
-			M_BEQZ(REG_RESULT, 0);
-			codegen_add_arraystoreexception_ref(cd);
-			M_NOP;
+			emit_arraystore_check(cd, iptr);
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
 			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
-			M_AST_INTERN(s3, REG_ITMP1, OFFSET(java_objectarray, data[0]));
+			/* implicit null-pointer check */
+			M_AST_INTERN(s3, REG_ITMP1, OFFSET(java_objectarray_t, data[0]));
 			break;
 
 
@@ -1584,12 +1907,10 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_AADD(s2, s1, REG_ITMP1);
-			M_BST(REG_ZERO, REG_ITMP1, OFFSET(java_bytearray, data[0]));
+			/* implicit null-pointer check */
+			M_BST(REG_ZERO, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
 			break;
 
 		case ICMD_CASTORECONST:   /* ..., arrayref, index  ==> ...            */
@@ -1597,52 +1918,48 @@ bool codegen(jitdata *jd)
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_AADD(s2, s1, REG_ITMP1);
 			M_AADD(s2, REG_ITMP1, REG_ITMP1);
-			M_SST(REG_ZERO, REG_ITMP1, OFFSET(java_chararray, data[0]));
+			/* implicit null-pointer check */
+			M_SST(REG_ZERO, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
 			break;
 
 		case ICMD_IASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 2, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
-			M_IST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_intarray, data[0]));
+			/* implicit null-pointer check */
+			M_IST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_intarray_t, data[0]));
 			break;
 
 		case ICMD_LASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, 3, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
-			M_LST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_longarray, data[0]));
+			/* implicit null-pointer check */
+#if SIZEOF_VOID_P == 8
+			M_LST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_longarray_t, data[0]));
+#else
+			M_LST_INTERN(PACK_REGS(REG_ZERO, REG_ZERO), REG_ITMP1, OFFSET(java_longarray_t, data[0]));
+#endif
 			break;
 
 		case ICMD_AASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2);
 			M_AADD(REG_ITMP2, s1, REG_ITMP1);
-			M_AST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_objectarray, data[0]));
+			/* implicit null-pointer check */
+			M_AST_INTERN(REG_ZERO, REG_ITMP1, OFFSET(java_objectarray_t, data[0]));
 			break;
 
 
@@ -1653,24 +1970,16 @@ bool codegen(jitdata *jd)
 				fieldtype = uf->fieldref->parseddesc.fd->type;
 				disp      = dseg_add_unique_address(cd, uf);
 
-				codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, disp);
 			}
 			else {
 				fi        = iptr->sx.s23.s3.fmiref->p.field;
 				fieldtype = fi->type;
-				disp      = dseg_add_address(cd, &(fi->value));
-
-				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
-					codegen_addpatchref(cd, PATCHER_clinit, fi->class, disp);
+				disp      = dseg_add_address(cd, fi->value);
 
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
-				}
+				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
+					patcher_add_patch_ref(jd, PATCHER_initialize_class,
+										  fi->class, disp);
   			}
 
 			M_ALD(REG_ITMP1, REG_PV, disp);
@@ -1681,7 +1990,11 @@ bool codegen(jitdata *jd)
 				M_ILD_INTERN(d, REG_ITMP1, 0);
 				break;
 			case TYPE_LNG:
+#if SIZEOF_VOID_P == 8
 				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+#else
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP23_PACKED);
+#endif
 				M_LLD_INTERN(d, REG_ITMP1, 0);
 				break;
 			case TYPE_ADR:
@@ -1707,24 +2020,16 @@ bool codegen(jitdata *jd)
 				fieldtype = uf->fieldref->parseddesc.fd->type;
 				disp      = dseg_add_unique_address(cd, uf);
 
-				codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, disp);
 			}
 			else {
 				fi        = iptr->sx.s23.s3.fmiref->p.field;
 				fieldtype = fi->type;
-				disp      = dseg_add_address(cd, &(fi->value));
+				disp      = dseg_add_address(cd, fi->value);
 
-				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
-					codegen_addpatchref(cd, PATCHER_clinit, fi->class, disp);
-
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
-				}
+				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
+					patcher_add_patch_ref(jd, PATCHER_initialize_class,
+										  fi->class, disp);
   			}
 
 			M_ALD(REG_ITMP1, REG_PV, disp);
@@ -1735,7 +2040,11 @@ bool codegen(jitdata *jd)
 				M_IST_INTERN(s1, REG_ITMP1, 0);
 				break;
 			case TYPE_LNG:
+#if SIZEOF_VOID_P == 8
 				s1 = emit_load_s1(jd, iptr, REG_ITMP2);
+#else
+				s1 = emit_load_s1(jd, iptr, REG_ITMP23_PACKED);
+#endif
 				M_LST_INTERN(s1, REG_ITMP1, 0);
 				break;
 			case TYPE_ADR:
@@ -1754,32 +2063,22 @@ bool codegen(jitdata *jd)
 			break;
 
 		case ICMD_PUTSTATICCONST: /* ...  ==> ...                             */
-		                          /* val = value (in current instruction)     */
-		                          /* following NOP)                           */
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
 				uf        = iptr->sx.s23.s3.uf;
 				fieldtype = uf->fieldref->parseddesc.fd->type;
 				disp      = dseg_add_unique_address(cd, uf);
 
-				codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, disp);
 			}
 			else {
 				fi        = iptr->sx.s23.s3.fmiref->p.field;
 				fieldtype = fi->type;
-				disp      = dseg_add_address(cd, &(fi->value));
+				disp      = dseg_add_address(cd, fi->value);
 
-				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
-					codegen_addpatchref(cd, PATCHER_clinit, fi->class, disp);
-
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
-				}
+				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
+					patcher_add_patch_ref(jd, PATCHER_initialize_class,
+										  fi->class, disp);
   			}
 
 			M_ALD(REG_ITMP1, REG_PV, disp);
@@ -1807,18 +2106,14 @@ bool codegen(jitdata *jd)
 		case ICMD_GETFIELD:   /* ...  ==> ..., value                          */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			gen_nullptr_check(s1);
+			emit_nullpointer_check(cd, iptr, s1);
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
 				uf        = iptr->sx.s23.s3.uf;
 				fieldtype = uf->fieldref->parseddesc.fd->type;
 				disp      = 0;
 
-				codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
 			}
 			else {
 				fi        = iptr->sx.s23.s3.fmiref->p.field;
@@ -1832,8 +2127,13 @@ bool codegen(jitdata *jd)
 				M_ILD(d, s1, disp);
 				break;
 			case TYPE_LNG:
+#if SIZEOF_VOID_P == 8
 				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 				M_LLD(d, s1, disp);
+#else
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP23_PACKED);
+				M_LLD_GETFIELD(d, s1, disp);
+#endif
 				break;
 			case TYPE_ADR:
 				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
@@ -1854,7 +2154,7 @@ bool codegen(jitdata *jd)
 		case ICMD_PUTFIELD:   /* ..., objectref, value  ==> ...               */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			gen_nullptr_check(s1);
+			emit_nullpointer_check(cd, iptr, s1);
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
 				uf        = iptr->sx.s23.s3.uf;
@@ -1867,18 +2167,24 @@ bool codegen(jitdata *jd)
 				disp      = fi->offset;
 			}
 
+#if SIZEOF_VOID_P == 8
 			if (IS_INT_LNG_TYPE(fieldtype))
 				s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			else
 				s2 = emit_load_s2(jd, iptr, REG_FTMP1);
-
-			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+#else
+			if (IS_INT_LNG_TYPE(fieldtype)) {
+				if (IS_2_WORD_TYPE(fieldtype))
+					s2 = emit_load_s2(jd, iptr, REG_ITMP23_PACKED);
+				else
+					s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			}
+			else
+				s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+#endif
+
+			if (INSTRUCTION_IS_UNRESOLVED(iptr))
+				patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
 
 			switch (fieldtype) {
 			case TYPE_INT:
@@ -1902,25 +2208,19 @@ bool codegen(jitdata *jd)
 		case ICMD_PUTFIELDCONST:  /* ..., objectref  ==> ...                  */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			gen_nullptr_check(s1);
+			emit_nullpointer_check(cd, iptr, s1);
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				unresolved_field *uf = iptr->sx.s23.s3.uf;
-
+				uf        = iptr->sx.s23.s3.uf;
 				fieldtype = uf->fieldref->parseddesc.fd->type;
+				disp      = 0;
 
-				codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
-
-				disp = 0;
+				patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
 			}
 			else {
-				fieldinfo *fi = iptr->sx.s23.s3.fmiref->p.field;
+				fi        = iptr->sx.s23.s3.fmiref->p.field;
 				fieldtype = fi->type;
-				disp = fi->offset;
+				disp      = fi->offset;
 			}
 
 			switch (fieldtype) {
@@ -1952,12 +2252,9 @@ bool codegen(jitdata *jd)
 			
 #ifdef ENABLE_VERIFIER
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				codegen_addpatchref(cd, PATCHER_athrow_areturn,
-									iptr->sx.s23.s2.uc, 0);
+				uc = iptr->sx.s23.s2.uc;
 
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_resolve_class, uc, 0);
 			}
 #endif /* ENABLE_VERIFIER */
 
@@ -1973,358 +2270,539 @@ bool codegen(jitdata *jd)
 		case ICMD_GOTO:         /* ... ==> ...                                */
 		case ICMD_RET:          /* ... ==> ...                                */
 
-			M_BR(0);
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			emit_br(cd, iptr->dst.block);
 			ALIGNCODENOP;
 			break;
 
 		case ICMD_JSR:          /* ... ==> ...                                */
 
-			M_BR(0);
-			codegen_addreference(cd, iptr->sx.s23.s3.jsrtarget.block);
-			M_NOP;
+			emit_br(cd, iptr->sx.s23.s3.jsrtarget.block);
 			ALIGNCODENOP;
 			break;
 			
 		case ICMD_IFNULL:       /* ..., value ==> ...                         */
+		case ICMD_IFNONNULL:
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			M_BEQZ(s1, 0);
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
-			break;
-
-		case ICMD_IFNONNULL:    /* ..., value ==> ...                         */
-
-			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			M_BNEZ(s1, 0);
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			emit_bccz(cd, iptr->dst.block, iptr->opc - ICMD_IFNULL, s1, BRANCH_OPT_NONE);
 			break;
 
 		case ICMD_IFEQ:         /* ..., value ==> ...                         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.i == 0) {
-				M_BEQZ(s1, 0);
-			} else {
+			if (iptr->sx.val.i == 0)
+				emit_beqz(cd, iptr->dst.block, s1);
+			else {
 				ICONST(REG_ITMP2, iptr->sx.val.i);
-				M_BEQ(s1, REG_ITMP2, 0);
+				emit_beq(cd, iptr->dst.block, s1, REG_ITMP2);
 			}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
 			break;
 
 		case ICMD_IFLT:         /* ..., value ==> ...                         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.i == 0) {
-				M_BLTZ(s1, 0);
-			} else {
-				if ((iptr->sx.val.i >= -32768) && (iptr->sx.val.i <= 32767)) {
+			if (iptr->sx.val.i == 0)
+				emit_bltz(cd, iptr->dst.block, s1);
+			else {
+				if ((iptr->sx.val.i >= -32768) && (iptr->sx.val.i <= 32767))
 					M_CMPLT_IMM(s1, iptr->sx.val.i, REG_ITMP1);
-				} else {
+				else {
 					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
 				}
-				M_BNEZ(REG_ITMP1, 0);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP1);
 			}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
 			break;
 
 		case ICMD_IFLE:         /* ..., value ==> ...                         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.i == 0) {
-				M_BLEZ(s1, 0);
-				}
+			if (iptr->sx.val.i == 0)
+				emit_blez(cd, iptr->dst.block, s1);
 			else {
 				if ((iptr->sx.val.i >= -32769) && (iptr->sx.val.i <= 32766)) {
 					M_CMPLT_IMM(s1, iptr->sx.val.i + 1, REG_ITMP1);
-					M_BNEZ(REG_ITMP1, 0);
-					}
+					emit_bnez(cd, iptr->dst.block, REG_ITMP1);
+				}
 				else {
 					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
-					M_BEQZ(REG_ITMP1, 0);
-					}
+					emit_beqz(cd, iptr->dst.block, REG_ITMP1);
 				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			}
 			break;
 
 		case ICMD_IFNE:         /* ..., value ==> ...                         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.i == 0) {
-				M_BNEZ(s1, 0);
-				}
+			if (iptr->sx.val.i == 0)
+				emit_bnez(cd, iptr->dst.block, s1);
 			else {
 				ICONST(REG_ITMP2, iptr->sx.val.i);
-				M_BNE(s1, REG_ITMP2, 0);
-				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+				emit_bne(cd, iptr->dst.block, s1, REG_ITMP2);
+			}
 			break;
 
 		case ICMD_IFGT:         /* ..., value ==> ...                         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.i == 0) {
-				M_BGTZ(s1, 0);
-				}
+			if (iptr->sx.val.i == 0)
+				emit_bgtz(cd, iptr->dst.block, s1);
 			else {
 				if ((iptr->sx.val.i >= -32769) && (iptr->sx.val.i <= 32766)) {
 					M_CMPLT_IMM(s1, iptr->sx.val.i + 1, REG_ITMP1);
-					M_BEQZ(REG_ITMP1, 0);
-					}
+					emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+				}
 				else {
 					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
-					M_BNEZ(REG_ITMP1, 0);
-					}
+					emit_bnez(cd, iptr->dst.block, REG_ITMP1);
 				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			}
 			break;
 
 		case ICMD_IFGE:         /* ..., value ==> ...                         */
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.i == 0) {
-				M_BGEZ(s1, 0);
-				}
+			if (iptr->sx.val.i == 0)
+				emit_bgez(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->sx.val.i >= -32768) && (iptr->sx.val.i <= 32767)) {
+				if ((iptr->sx.val.i >= -32768) && (iptr->sx.val.i <= 32767))
 					M_CMPLT_IMM(s1, iptr->sx.val.i, REG_ITMP1);
-					}
 				else {
 					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+				emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_LEQ:       /* ..., value ==> ...                         */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.l == 0) {
-				M_BEQZ(s1, 0);
-				}
+			if (iptr->sx.val.l == 0)
+				emit_beqz(cd, iptr->dst.block, s1);
 			else {
 				LCONST(REG_ITMP2, iptr->sx.val.l);
-				M_BEQ(s1, REG_ITMP2, 0);
-				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+				emit_beq(cd, iptr->dst.block, s1, REG_ITMP2);
+			}
+#else
+			if (iptr->sx.val.l == 0) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_OR(GET_LOW_REG(s1), GET_HIGH_REG(s1), REG_ITMP3);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP3);
+			}
+			else {
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP2, iptr->sx.val.l >> 32);
+				M_XOR(s1, REG_ITMP2, REG_ITMP2);
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
+				M_XOR(s1, REG_ITMP3, REG_ITMP3);
+				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP3);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP3);
+			}
+#endif
 			break;
 
 		case ICMD_IF_LLT:       /* ..., value ==> ...                         */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.l == 0) {
-				M_BLTZ(s1, 0);
-				}
+			if (iptr->sx.val.l == 0)
+				emit_bltz(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->sx.val.l >= -32768) && (iptr->sx.val.l <= 32767)) {
-					M_CMPLT_IMM(s1, iptr->sx.val.l, REG_ITMP1);
-					}
+				if ((iptr->sx.val.l >= -32768) && (iptr->sx.val.l <= 32767))
+					M_CMPLT_IMM(s1, iptr->sx.val.l, REG_ITMP3);
 				else {
 					LCONST(REG_ITMP2, iptr->sx.val.l);
-					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BNEZ(REG_ITMP1, 0);
+					M_CMPLT(s1, REG_ITMP2, REG_ITMP3);
 				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			}
+#else
+			if (iptr->sx.val.l == 0) {
+				/* if high word is less than zero, the whole long is too */
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				emit_bltz(cd, iptr->dst.block, s1);
+			}
+			else {
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP2, iptr->sx.val.l >> 32);
+				M_CMPLT(s1, REG_ITMP2, REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+				s2 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_BNE(s1, REG_ITMP2, 5); /* XXX */
+				M_NOP;
+				ICONST(REG_ITMP2, iptr->sx.val.l & 0xffffffff);
+				M_CMPULT(s2, REG_ITMP2, REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			}
+#endif
 			break;
 
 		case ICMD_IF_LLE:       /* ..., value ==> ...                         */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.l == 0) {
-				M_BLEZ(s1, 0);
-				}
+			if (iptr->sx.val.l == 0)
+				emit_blez(cd, iptr->dst.block, s1);
 			else {
 				if ((iptr->sx.val.l >= -32769) && (iptr->sx.val.l <= 32766)) {
-					M_CMPLT_IMM(s1, iptr->sx.val.l + 1, REG_ITMP1);
-					M_BNEZ(REG_ITMP1, 0);
-					}
+					M_CMPLT_IMM(s1, iptr->sx.val.l + 1, REG_ITMP2);
+					emit_bnez(cd, iptr->dst.block, REG_ITMP2);
+				}
 				else {
 					LCONST(REG_ITMP2, iptr->sx.val.l);
-					M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
-					M_BEQZ(REG_ITMP1, 0);
-					}
+					M_CMPGT(s1, REG_ITMP2, REG_ITMP3);
+					emit_beqz(cd, iptr->dst.block, REG_ITMP3);
 				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			}
+#else
+			if (iptr->sx.val.l == 0) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_BGTZ(GET_HIGH_REG(s1), 5); /* XXX */
+				M_NOP;
+				emit_bltz(cd, iptr->dst.block, GET_HIGH_REG(s1));
+				emit_beqz(cd, iptr->dst.block, GET_LOW_REG(s1));
+			}
+			else {
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP2, iptr->sx.val.l >> 32);
+				M_CMPLT(s1, REG_ITMP2, REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+				s2 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_BNE(s1, REG_ITMP2, 5); /* XXX */
+				M_NOP;
+				ICONST(REG_ITMP2, iptr->sx.val.l & 0xffffffff);
+				M_CMPUGT(s2, REG_ITMP2, REG_ITMP3);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP3);
+			}
+#endif
 			break;
 
 		case ICMD_IF_LNE:       /* ..., value ==> ...                         */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.l == 0) {
-				M_BNEZ(s1, 0);
-				}
+			if (iptr->sx.val.l == 0)
+				emit_bnez(cd, iptr->dst.block, s1);
 			else {
 				LCONST(REG_ITMP2, iptr->sx.val.l);
-				M_BNE(s1, REG_ITMP2, 0);
-				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+				emit_bne(cd, iptr->dst.block, s1, REG_ITMP2);
+			}
+#else
+			if (iptr->sx.val.l == 0) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				M_OR(GET_LOW_REG(s1), GET_HIGH_REG(s1), REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			}
+			else {
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP2, iptr->sx.val.l >> 32);
+				M_XOR(s1, REG_ITMP2, REG_ITMP2);
+				s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP3, iptr->sx.val.l & 0xffffffff);
+				M_XOR(s1, REG_ITMP3, REG_ITMP3);
+				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			}
+#endif
 			break;
 
 		case ICMD_IF_LGT:       /* ..., value ==> ...                         */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.l == 0) {
-				M_BGTZ(s1, 0);
-				}
+			if (iptr->sx.val.l == 0)
+				emit_bgtz(cd, iptr->dst.block, s1);
 			else {
 				if ((iptr->sx.val.l >= -32769) && (iptr->sx.val.l <= 32766)) {
-					M_CMPLT_IMM(s1, iptr->sx.val.l + 1, REG_ITMP1);
-					M_BEQZ(REG_ITMP1, 0);
-					}
+					M_CMPLT_IMM(s1, iptr->sx.val.l + 1, REG_ITMP2);
+					emit_beqz(cd, iptr->dst.block, REG_ITMP2);
+				}
 				else {
 					LCONST(REG_ITMP2, iptr->sx.val.l);
-					M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
-					M_BNEZ(REG_ITMP1, 0);
-					}
+					M_CMPGT(s1, REG_ITMP2, REG_ITMP3);
+					emit_bnez(cd, iptr->dst.block, REG_ITMP3);
 				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			}
+#else
+			if (iptr->sx.val.l == 0) {
+				s1 = emit_load_s1(jd, iptr, REG_ITMP12_PACKED);
+				emit_bgtz(cd, iptr->dst.block, GET_HIGH_REG(s1));
+				M_BLTZ(GET_HIGH_REG(s1), 3); /* XXX */
+				M_NOP;
+				emit_bnez(cd, iptr->dst.block, GET_LOW_REG(s1));
+			}
+			else {
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP2, iptr->sx.val.l >> 32);
+				M_CMPGT(s1, REG_ITMP2, REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+				s2 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_BNE(s1, REG_ITMP2, 5); /* XXX */
+				M_NOP;
+				ICONST(REG_ITMP2, iptr->sx.val.l & 0xffffffff);
+				M_CMPUGT(s2, REG_ITMP2, REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			}
+#endif
 			break;
 
 		case ICMD_IF_LGE:       /* ..., value ==> ...                         */
 
+#if SIZEOF_VOID_P == 8
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-			if (iptr->sx.val.l == 0) {
-				M_BGEZ(s1, 0);
-				}
+			if (iptr->sx.val.l == 0)
+				emit_bgez(cd, iptr->dst.block, s1);
 			else {
 				if ((iptr->sx.val.l >= -32768) && (iptr->sx.val.l <= 32767)) {
-					M_CMPLT_IMM(s1, iptr->sx.val.l, REG_ITMP1);
-					}
+					M_CMPLT_IMM(s1, iptr->sx.val.l, REG_ITMP3);
+				}
 				else {
 					LCONST(REG_ITMP2, iptr->sx.val.l);
-					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
+					M_CMPLT(s1, REG_ITMP2, REG_ITMP3);
 				}
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+				emit_beqz(cd, iptr->dst.block, REG_ITMP3);
+			}
+#else
+			if (iptr->sx.val.l == 0) {
+				/* if high word is greater equal zero, the whole long is too */
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				emit_bgez(cd, iptr->dst.block, s1);
+			}
+			else {
+				s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+				ICONST(REG_ITMP2, iptr->sx.val.l >> 32);
+				M_CMPGT(s1, REG_ITMP2, REG_ITMP3);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+				s2 = emit_load_s1_low(jd, iptr, REG_ITMP3);
+				M_BNE(s1, REG_ITMP2, 5); /* XXX */
+				M_NOP;
+				ICONST(REG_ITMP2, iptr->sx.val.l & 0xffffffff);
+				M_CMPULT(s2, REG_ITMP2, REG_ITMP3);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP3);
+			}
+#endif
 			break;
 
 		case ICMD_IF_ICMPEQ:    /* ..., value, value ==> ...                  */
-		case ICMD_IF_LCMPEQ:    /* op1 = target JavaVM pc                     */
-		case ICMD_IF_ACMPEQ:
+		case ICMD_IF_ACMPEQ:    /* op1 = target JavaVM pc                     */
+#if SIZEOF_VOID_P == 8
+		case ICMD_IF_LCMPEQ:
+#endif
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			M_BEQ(s1, s2, 0);
-			codegen_addreference(cd, iptr->dst.block);
+			emit_beq(cd, iptr->dst.block, s1, s2);
+			break;
+
+#if SIZEOF_VOID_P == 4
+		case ICMD_IF_LCMPEQ:    /* ..., value, value ==> ...                  */
+		                        /* op1 = target JavaVM pc                     */
+
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			M_BNE(s1, s2, 3); /* XXX TWISTI: uff, that is a problem */
 			M_NOP;
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			emit_beq(cd, iptr->dst.block, s1, s2);
 			break;
+#endif
 
 		case ICMD_IF_ICMPNE:    /* ..., value, value ==> ...                  */
-		case ICMD_IF_LCMPNE:    /* op1 = target JavaVM pc                     */
-		case ICMD_IF_ACMPNE:
+		case ICMD_IF_ACMPNE:    /* op1 = target JavaVM pc                     */
+#if SIZEOF_VOID_P == 8
+		case ICMD_IF_LCMPNE:
+#endif
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			M_BNE(s1, s2, 0);
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			emit_bne(cd, iptr->dst.block, s1, s2);
 			break;
 
+#if SIZEOF_VOID_P == 4
+		case ICMD_IF_LCMPNE:    /* ..., value, value ==> ...                  */
+
+			/* TODO: could be optimized (XOR or SUB) */
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			emit_bne(cd, iptr->dst.block, s1, s2);
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			emit_bne(cd, iptr->dst.block, s1, s2);
+			break;
+#endif
+
 		case ICMD_IF_ICMPLT:    /* ..., value, value ==> ...                  */
+#if SIZEOF_VOID_P == 8
 		case ICMD_IF_LCMPLT:    /* op1 = target JavaVM pc                     */
+#endif
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			M_CMPLT(s1, s2, REG_ITMP1);
-			M_BNEZ(REG_ITMP1, 0);
-			codegen_addreference(cd, iptr->dst.block);
+			M_CMPLT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			break;
+
+#if SIZEOF_VOID_P == 4
+		case ICMD_IF_LCMPLT:    /* ..., value, value ==> ...                  */
+
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			M_CMPLT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			M_CMPGT(s1, s2, REG_ITMP3);
+			/* load low-bits before the branch, so we know the distance */
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			M_BNEZ(REG_ITMP3, 4); /* XXX */
 			M_NOP;
+			M_CMPULT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
 			break;
+#endif
 
 		case ICMD_IF_ICMPGT:    /* ..., value, value ==> ...                  */
+#if SIZEOF_VOID_P == 8
 		case ICMD_IF_LCMPGT:    /* op1 = target JavaVM pc                     */
+#endif
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			M_CMPGT(s1, s2, REG_ITMP1);
-			M_BNEZ(REG_ITMP1, 0);
-			codegen_addreference(cd, iptr->dst.block);
+			M_CMPGT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			break;
+
+#if SIZEOF_VOID_P == 4
+		case ICMD_IF_LCMPGT:    /* ..., value, value ==> ...                  */
+
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			M_CMPGT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			M_CMPLT(s1, s2, REG_ITMP3);
+			/* load low-bits before the branch, so we know the distance */
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			M_BNEZ(REG_ITMP3, 4); /* XXX */
 			M_NOP;
+			M_CMPUGT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
 			break;
+#endif
 
 		case ICMD_IF_ICMPLE:    /* ..., value, value ==> ...                  */
+#if SIZEOF_VOID_P == 8
 		case ICMD_IF_LCMPLE:    /* op1 = target JavaVM pc                     */
+#endif
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			M_CMPGT(s1, s2, REG_ITMP1);
-			M_BEQZ(REG_ITMP1, 0);
-			codegen_addreference(cd, iptr->dst.block);
+			M_CMPGT(s1, s2, REG_ITMP3);
+			emit_beqz(cd, iptr->dst.block, REG_ITMP3);
+			break;
+
+#if SIZEOF_VOID_P == 4
+		case ICMD_IF_LCMPLE:    /* ..., value, value ==> ...                  */
+
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			M_CMPLT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			M_CMPGT(s1, s2, REG_ITMP3);
+			/* load low-bits before the branch, so we know the distance */
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			M_BNEZ(REG_ITMP3, 4); /* XXX */
 			M_NOP;
+			M_CMPUGT(s1, s2, REG_ITMP3);
+			emit_beqz(cd, iptr->dst.block, REG_ITMP3);
 			break;
+#endif
 
 		case ICMD_IF_ICMPGE:    /* ..., value, value ==> ...                  */
+#if SIZEOF_VOID_P == 8
 		case ICMD_IF_LCMPGE:    /* op1 = target JavaVM pc                     */
+#endif
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
-			M_CMPLT(s1, s2, REG_ITMP1);
-			M_BEQZ(REG_ITMP1, 0);
-			codegen_addreference(cd, iptr->dst.block);
-			M_NOP;
+			M_CMPLT(s1, s2, REG_ITMP3);
+			emit_beqz(cd, iptr->dst.block, REG_ITMP3);
 			break;
 
+#if SIZEOF_VOID_P == 4
+		case ICMD_IF_LCMPGE:    /* ..., value, value ==> ...                  */
+
+			s1 = emit_load_s1_high(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_high(jd, iptr, REG_ITMP2);
+			M_CMPGT(s1, s2, REG_ITMP3);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP3);
+			M_CMPLT(s1, s2, REG_ITMP3);
+			/* load low-bits before the branch, so we know the distance */
+			s1 = emit_load_s1_low(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2_low(jd, iptr, REG_ITMP2);
+			M_BNEZ(REG_ITMP3, 4); /* XXX */
+			M_NOP;
+			M_CMPULT(s1, s2, REG_ITMP3);
+			emit_beqz(cd, iptr->dst.block, REG_ITMP3);
+			break;
+#endif
 
 		case ICMD_IRETURN:      /* ..., retvalue ==> ...                      */
+#if SIZEOF_VOID_P == 8
 		case ICMD_LRETURN:
+#endif
 
+			REPLACEMENT_POINT_RETURN(cd, iptr);
 			s1 = emit_load_s1(jd, iptr, REG_RESULT);
 			M_INTMOVE(s1, REG_RESULT);
 			goto nowperformreturn;
 
 		case ICMD_ARETURN:      /* ..., retvalue ==> ...                      */
 
+			REPLACEMENT_POINT_RETURN(cd, iptr);
 			s1 = emit_load_s1(jd, iptr, REG_RESULT);
 			M_INTMOVE(s1, REG_RESULT);
 
 #ifdef ENABLE_VERIFIER
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				codegen_addpatchref(cd, PATCHER_athrow_areturn,
-									iptr->sx.s23.s2.uc, 0);
+				uc = iptr->sx.s23.s2.uc;
 
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_resolve_class, uc, 0);
 			}
 #endif /* ENABLE_VERIFIER */
 			goto nowperformreturn;
 
-	    case ICMD_FRETURN:      /* ..., retvalue ==> ...                      */
+#if SIZEOF_VOID_P == 4
+		case ICMD_LRETURN:      /* ..., retvalue ==> ...                      */
 
+			s1 = emit_load_s1(jd, iptr, REG_RESULT_PACKED);
+			M_LNGMOVE(s1, REG_RESULT_PACKED);
+			goto nowperformreturn;
+#endif
+
+	    case ICMD_FRETURN:      /* ..., retvalue ==> ...                      */
+			REPLACEMENT_POINT_RETURN(cd, iptr);
 			s1 = emit_load_s1(jd, iptr, REG_FRESULT);
 			M_FLTMOVE(s1, REG_FRESULT);
 			goto nowperformreturn;
 
 	    case ICMD_DRETURN:      /* ..., retvalue ==> ...                      */
 
+			REPLACEMENT_POINT_RETURN(cd, iptr);
 			s1 = emit_load_s1(jd, iptr, REG_FRESULT);
 			M_DBLMOVE(s1, REG_FRESULT);
 			goto nowperformreturn;
 
 		case ICMD_RETURN:      /* ...  ==> ...                                */
 
+			REPLACEMENT_POINT_RETURN(cd, iptr);
+
 nowperformreturn:
 			{
 			s4 i, p;
@@ -2337,7 +2815,7 @@ nowperformreturn:
 #endif
 
 #if defined(ENABLE_THREADS)
-			if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
+			if (checksync && code_is_synchronized(code)) {
 				disp = dseg_add_functionptr(cd, LOCK_monitor_exit);
 				M_ALD(REG_ITMP3, REG_PV, disp);
 
@@ -2346,11 +2824,21 @@ nowperformreturn:
 				switch (iptr->opc) {
 				case ICMD_IRETURN:
 				case ICMD_ARETURN:
+#if SIZEOF_VOID_P == 8
 				case ICMD_LRETURN:
+#endif
 					M_ALD(REG_A0, REG_SP, rd->memuse * 8);
 					M_JSR(REG_RA, REG_ITMP3);
-					M_LST(REG_RESULT, REG_SP, rd->memuse * 8);  /* delay slot */
+					M_AST(REG_RESULT, REG_SP, rd->memuse * 8);  /* delay slot */
 					break;
+#if SIZEOF_VOID_P == 4
+				case ICMD_LRETURN:
+					M_ALD(REG_A0, REG_SP, rd->memuse * 8);
+					M_LST(REG_RESULT_PACKED, REG_SP, rd->memuse * 8);
+					M_JSR(REG_RA, REG_ITMP3);
+					M_NOP;
+					break;
+#endif
 				case ICMD_FRETURN:
 				case ICMD_DRETURN:
 					M_ALD(REG_A0, REG_SP, rd->memuse * 8);
@@ -2368,9 +2856,16 @@ nowperformreturn:
 				switch (iptr->opc) {
 				case ICMD_IRETURN:
 				case ICMD_ARETURN:
+#if SIZEOF_VOID_P == 8
+				case ICMD_LRETURN:
+#endif
+					M_ALD(REG_RESULT, REG_SP, rd->memuse * 8);
+					break;
+#if SIZEOF_VOID_P == 4
 				case ICMD_LRETURN:
-					M_LLD(REG_RESULT, REG_SP, rd->memuse * 8);
+					M_LLD(REG_RESULT_PACKED, REG_SP, rd->memuse * 8);
 					break;
+#endif
 				case ICMD_FRETURN:
 				case ICMD_DRETURN:
 					M_DLD(REG_FRESULT, REG_SP, rd->memuse * 8);
@@ -2381,14 +2876,14 @@ nowperformreturn:
 
 			/* restore return address                                         */
 
-			if (!jd->isleafmethod) {
+			if (!code_is_leafmethod(code)) {
 				p--; M_ALD(REG_RA, REG_SP, p * 8);
 			}
 
 			/* restore saved registers                                        */
 
 			for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
-				p--; M_LLD(rd->savintregs[i], REG_SP, p * 8);
+				p--; M_ALD(rd->savintregs[i], REG_SP, p * 8);
 			}
 			for (i = FLT_SAV_CNT - 1; i >= rd->savfltreguse; i--) {
 				p--; M_DLD(rd->savfltregs[i], REG_SP, p * 8);
@@ -2405,12 +2900,12 @@ nowperformreturn:
 
 				if (hi == 0) {
 					M_RET(REG_RA);
-					M_LADD_IMM(REG_SP, lo, REG_SP);             /* delay slot */
+					M_AADD_IMM(REG_SP, lo, REG_SP);             /* delay slot */
 				} else {
 					M_LUI(REG_ITMP3,hi);
-					M_LADD_IMM(REG_ITMP3,lo,REG_ITMP3);
+					M_AADD_IMM(REG_ITMP3,lo,REG_ITMP3);
 					M_RET(REG_RA);
-					M_LADD(REG_ITMP3,REG_SP,REG_SP);            /* delay slot */
+					M_AADD(REG_ITMP3,REG_SP,REG_SP);            /* delay slot */
 				}
 
 			} else {
@@ -2450,9 +2945,7 @@ nowperformreturn:
 			/* range check */
 
 			M_CMPULT_IMM(REG_ITMP1, i, REG_ITMP2);
-			M_BEQZ(REG_ITMP2, 0);
-			codegen_addreference(cd, table[0].block); /* default target */
-			M_ASLL_IMM(REG_ITMP1, POINTERSHIFT, REG_ITMP1);      /* delay slot*/
+			emit_beqz(cd, table[0].block, REG_ITMP2);
 
 			/* build jump table top down and use address of lowest entry */
 
@@ -2466,6 +2959,7 @@ nowperformreturn:
 
 			/* length of dataseg after last dseg_add_target is used by load */
 
+			M_ASLL_IMM(REG_ITMP1, POINTERSHIFT, REG_ITMP1);
 			M_AADD(REG_ITMP1, REG_PV, REG_ITMP2);
 			M_ALD(REG_ITMP2, REG_ITMP2, -(cd->dseglen));
 			M_JMP(REG_ITMP2);
@@ -2488,15 +2982,11 @@ nowperformreturn:
 
 			while (--i >= 0) {
 				ICONST(REG_ITMP2, lookup->value);
-				M_BEQ(s1, REG_ITMP2, 0);
-				codegen_addreference(cd, lookup->target.block); 
-				M_NOP;
+				emit_beq(cd, lookup->target.block, s1, REG_ITMP2);
 				++lookup;
 			}
 
-			M_BR(0);
-			codegen_addreference(cd, iptr->sx.s23.s3.lookupdefault.block);
-			M_NOP;
+			emit_br(cd, iptr->sx.s23.s3.lookupdefault.block);
 			ALIGNCODENOP;
 			break;
 			}
@@ -2514,6 +3004,8 @@ nowperformreturn:
 		case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer    */
 		case ICMD_INVOKEINTERFACE:
 
+			REPLACEMENT_POINT_INVOKE(cd, iptr);
+
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
 				lm = NULL;
 				um = iptr->sx.s23.s3.um;
@@ -2534,84 +3026,119 @@ gen_method:
 
 			for (s3 = s3 - 1; s3 >= 0; s3--) {
 				var = VAR(iptr->sx.s23.s2.args[s3]);
+				d   = md->params[s3].regoff;
 
 				if (var->flags & PREALLOC)
 					continue;
 
 				if (IS_INT_LNG_TYPE(var->type)) {
+#if SIZEOF_VOID_P == 8
 					if (!md->params[s3].inmemory) {
-						s1 = rd->argintregs[md->params[s3].regoff];
-						d = emit_load(jd, iptr, var, s1);
-						M_INTMOVE(d, s1);
+						s1 = emit_load(jd, iptr, var, d);
+						M_INTMOVE(s1, d);
 					}
 					else  {
-						d = emit_load(jd, iptr, var, REG_ITMP1);
-						M_LST(d, REG_SP, md->params[s3].regoff * 8);
+						s1 = emit_load(jd, iptr, var, REG_ITMP1);
+						M_LST(s1, REG_SP, d);
 					}
+#else
+					if (!md->params[s3].inmemory) {
+						s1 = emit_load(jd, iptr, var, d);
+
+						if (IS_2_WORD_TYPE(var->type))
+							M_LNGMOVE(s1, d);
+						else
+							M_INTMOVE(s1, d);
+					}
+					else {
+						if (IS_2_WORD_TYPE(var->type)) {
+							s1 = emit_load(jd, iptr, var, REG_ITMP12_PACKED);
+							M_LST(s1, REG_SP, d);
+						}
+						else {
+							s1 = emit_load(jd, iptr, var, REG_ITMP1);
+							M_IST(s1, REG_SP, d);
+						}
+					}
+#endif
 				}
 				else {
 					if (!md->params[s3].inmemory) {
-						s1 = rd->argfltregs[md->params[s3].regoff];
-						d = emit_load(jd, iptr, var, s1);
+						s1 = emit_load(jd, iptr, var, d);
 						if (IS_2_WORD_TYPE(var->type))
-							M_DMOV(d, s1);
+							M_DBLMOVE(s1, d);
 						else
-							M_FMOV(d, s1);
+							M_FLTMOVE(s1, d);
 					}
 					else {
-						d = emit_load(jd, iptr, var, REG_FTMP1);
+						s1 = emit_load(jd, iptr, var, REG_FTMP1);
 						if (IS_2_WORD_TYPE(var->type))
-							M_DST(d, REG_SP, md->params[s3].regoff * 8);
+							M_DST(s1, REG_SP, d);
 						else
-							M_FST(d, REG_SP, md->params[s3].regoff * 8);
+							M_FST(s1, REG_SP, d);
 					}
 				}
 			}
 
 			switch (iptr->opc) {
 			case ICMD_BUILTIN:
-				disp = dseg_add_functionptr(cd, bte->fp);
+				if (bte->stub == NULL) {
+					disp = dseg_add_functionptr(cd, bte->fp);
+					M_ALD(REG_ITMP3, REG_PV, disp);  /* built-in-function pointer */
 
-				M_ALD(REG_ITMP3, REG_PV, disp);  /* built-in-function pointer */
+					/* generate the actual call */
 
-				/* TWISTI: i actually don't know the reason for using
-				   REG_ITMP3 here instead of REG_PV. */
-				s1 = REG_ITMP3;
+					/* TWISTI: i actually don't know the reason for using
+					   REG_ITMP3 here instead of REG_PV. */
+
+					M_JSR(REG_RA, REG_ITMP3);
+					M_NOP;
+				}
+				else {
+					disp = dseg_add_functionptr(cd, bte->stub);
+					M_ALD(REG_PV, REG_PV, disp);          /* method pointer in pv */
+
+					/* generate the actual call */
+
+					M_JSR(REG_RA, REG_PV);
+					M_NOP;
+				}
+
+				REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
+				disp = (s4) (cd->mcodeptr - cd->mcodebase);
+				M_LDA(REG_PV, REG_RA, -disp);
 				break;
 
 			case ICMD_INVOKESPECIAL:
-				M_BEQZ(REG_A0, 0);
-				codegen_add_nullpointerexception_ref(cd);
-				M_NOP;
+				emit_nullpointer_check(cd, iptr, REG_A0);
 				/* fall through */
 
 			case ICMD_INVOKESTATIC:
 				if (lm == NULL) {
 					disp = dseg_add_unique_address(cd, um);
 
-					codegen_addpatchref(cd, PATCHER_invokestatic_special, um,
-										disp);
-
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
+					patcher_add_patch_ref(jd, PATCHER_invokestatic_special, um,
+										  disp);
 				}
 				else
 					disp = dseg_add_address(cd, lm->stubroutine);
 
 				M_ALD(REG_PV, REG_PV, disp);          /* method pointer in pv */
-				s1 = REG_PV;
+
+				/* generate the actual call */
+
+				M_JSR(REG_RA, REG_PV);
+				M_NOP;
+				REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
+				disp = (s4) (cd->mcodeptr - cd->mcodebase);
+				M_LDA(REG_PV, REG_RA, -disp);
 				break;
 
 			case ICMD_INVOKEVIRTUAL:
-				gen_nullptr_check(REG_A0);
+				emit_nullpointer_check(cd, iptr, REG_A0);
 
 				if (lm == NULL) {
-					codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
-
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
+					patcher_add_patch_ref(jd, PATCHER_invokevirtual, um, 0);
 
 					s1 = 0;
 				}
@@ -2619,21 +3146,24 @@ gen_method:
 					s1 = OFFSET(vftbl_t, table[0]) +
 						sizeof(methodptr) * lm->vftblindex;
 
-				M_ALD(REG_METHODPTR, REG_A0,
-					  OFFSET(java_objectheader, vftbl));
+				/* implicit null-pointer check */
+				M_ALD(REG_METHODPTR, REG_A0, OFFSET(java_object_t, vftbl));
 				M_ALD(REG_PV, REG_METHODPTR, s1);
-				s1 = REG_PV;
+
+				/* generate the actual call */
+
+				M_JSR(REG_RA, REG_PV);
+				M_NOP;
+				REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
+				disp = (s4) (cd->mcodeptr - cd->mcodebase);
+				M_LDA(REG_PV, REG_RA, -disp);
 				break;
 
 			case ICMD_INVOKEINTERFACE:
-				gen_nullptr_check(REG_A0);
+				emit_nullpointer_check(cd, iptr, REG_A0);
 
 				if (lm == NULL) {
-					codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
-
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
+					patcher_add_patch_ref(jd, PATCHER_invokeinterface, um, 0);
 
 					s1 = 0;
 					s2 = 0;
@@ -2645,27 +3175,19 @@ gen_method:
 					s2 = sizeof(methodptr) * (lm - lm->class->methods);
 				}
 
-				M_ALD(REG_METHODPTR, REG_A0,
-					  OFFSET(java_objectheader, vftbl));
+				/* implicit null-pointer check */
+				M_ALD(REG_METHODPTR, REG_A0, OFFSET(java_object_t, vftbl));
 				M_ALD(REG_METHODPTR, REG_METHODPTR, s1);
 				M_ALD(REG_PV, REG_METHODPTR, s2);
-				s1 = REG_PV;
-				break;
-			}
 
-			/* generate the actual call */
+				/* generate the actual call */
 
-			M_JSR(REG_RA, s1);
-			M_NOP;
-			disp = (s4) (cd->mcodeptr - cd->mcodebase);
-			M_LDA(REG_PV, REG_RA, -disp);
-
-			/* actually only used for ICMD_BUILTIN */
-
-			if (INSTRUCTION_MUST_CHECK(iptr)) {
-				M_BEQZ(REG_RESULT, 0);
-				codegen_add_fillinstacktrace_ref(cd);
+				M_JSR(REG_RA, REG_PV);
 				M_NOP;
+				REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
+				disp = (s4) (cd->mcodeptr - cd->mcodebase);
+				M_LDA(REG_PV, REG_RA, -disp);
+				break;
 			}
 
 			/* store return value */
@@ -2674,8 +3196,19 @@ gen_method:
 
 			if (d != TYPE_VOID) {
 				if (IS_INT_LNG_TYPE(d)) {
+#if SIZEOF_VOID_P == 8
 					s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
 					M_INTMOVE(REG_RESULT, s1);
+#else
+					if (IS_2_WORD_TYPE(d)) {
+						s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT_PACKED);
+						M_LNGMOVE(REG_RESULT_PACKED, s1);
+					}
+					else {
+						s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
+						M_INTMOVE(REG_RESULT, s1);
+					}
+#endif
 				}
 				else {
 					s1 = codegen_reg_of_dst(jd, iptr, REG_FRESULT);
@@ -2690,20 +3223,6 @@ gen_method:
 
 
 		case ICMD_CHECKCAST:  /* ..., objectref ==> ..., objectref            */
-		                      /* val.a: (classinfo*) superclass               */
-
-			/*  superclass is an interface:
-			 *
-			 *  OK if ((sub == NULL) ||
-			 *         (sub->vftbl->interfacetablelength > super->index) &&
-			 *         (sub->vftbl->interfacetable[-super->index] != NULL));
-			 *
-			 *  superclass is a class:
-			 *
-			 *  OK if ((sub == NULL) || (0
-			 *         <= (sub->vftbl->baseval - super->vftbl->baseval) <=
-			 *         super->vftbl->diffvall));
-			 */
 
 			if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
 				classinfo *super;
@@ -2714,115 +3233,85 @@ gen_method:
 					superindex = 0;
 				}
 				else {
-					super = iptr->sx.s23.s3.c.cls;
+					super      = iptr->sx.s23.s3.c.cls;
 					superindex = super->index;
 				}
 			
-#if defined(ENABLE_THREADS)
-				codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+				if ((super == NULL) || !(super->flags & ACC_INTERFACE))
+					CODEGEN_CRITICAL_SECTION_NEW;
 
 				s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 
-				/* calculate interface checkcast code size */
-
-				s2 = 8;
-				if (super == NULL)
-					s2 += (opt_showdisassemble ? 2 : 0);
-
-				/* calculate class checkcast code size */
-
-				s3 = 10 /* 10 + (s1 == REG_ITMP1) */;
-				if (super == NULL)
-					s3 += (opt_showdisassemble ? 2 : 0);
-
 				/* if class is not resolved, check which code to call */
 
 				if (super == NULL) {
-					M_BEQZ(s1, 5 + (opt_showdisassemble ? 2 : 0) + s2 + 2 + s3);
-					M_NOP;
+					emit_label_beqz(cd, BRANCH_LABEL_1, s1);
 
+					cr   = iptr->sx.s23.s3.c.ref;
 					disp = dseg_add_unique_s4(cd, 0);         /* super->flags */
 
-					codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags,
-										iptr->sx.s23.s3.c.ref,
-										disp);
-
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
+					patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_flags,
+										  cr, disp);
 
-					/* XXX TWISTI M_ILD can be 2 instructions long (jump offset) */
 					M_ILD(REG_ITMP2, REG_PV, disp);
 					M_AND_IMM(REG_ITMP2, ACC_INTERFACE, REG_ITMP2);
-					M_BEQZ(REG_ITMP2, 1 + s2 + 2);
-					M_NOP;
+					emit_label_beqz(cd, BRANCH_LABEL_2, REG_ITMP2);
 				}
 
 				/* interface checkcast code */
 
 				if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
 					if (super == NULL) {
-						codegen_addpatchref(cd,
-											PATCHER_checkcast_instanceof_interface,
-											iptr->sx.s23.s3.c.ref,
-											0);
+						cr = iptr->sx.s23.s3.c.ref;
 
-						if (opt_showdisassemble) {
-							M_NOP; M_NOP;
-						}
+						patcher_add_patch_ref(jd, PATCHER_checkcast_interface,
+											  cr, 0);
 					}
 					else {
-						M_BEQZ(s1, 1 + s2);
-						M_NOP;
+						emit_label_beqz(cd, BRANCH_LABEL_3, s1);
 					}
 
-					M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl));
-					M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, interfacetablelength));
+					M_ALD(REG_ITMP2, s1, OFFSET(java_object_t, vftbl));
+					M_ILD(REG_ITMP3, REG_ITMP2,
+						  OFFSET(vftbl_t, interfacetablelength));
 					M_IADD_IMM(REG_ITMP3, -superindex, REG_ITMP3);
-					M_BLEZ(REG_ITMP3, 0);
-					codegen_add_classcastexception_ref(cd, s1);
-					M_NOP;
+					emit_classcast_check(cd, iptr, ICMD_IFLE, REG_ITMP3, s1);
+
 					M_ALD(REG_ITMP3, REG_ITMP2,
 						  OFFSET(vftbl_t, interfacetable[0]) -
 						  superindex * sizeof(methodptr*));
-					M_BEQZ(REG_ITMP3, 0);
-					codegen_add_classcastexception_ref(cd, s1);
-					M_NOP;
+					emit_classcast_check(cd, iptr, ICMD_IFEQ, REG_ITMP3, s1);
 
-					if (super == NULL) {
-						M_BR(1 + s3);
-						M_NOP;
-					}
+					if (super == NULL)
+						emit_label_br(cd, BRANCH_LABEL_4);
+					else
+						emit_label(cd, BRANCH_LABEL_3);
 				}
 
 				/* class checkcast code */
 
 				if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
 					if (super == NULL) {
-						disp = dseg_add_unique_address(cd, NULL);
+						emit_label(cd, BRANCH_LABEL_2);
 
-						codegen_addpatchref(cd,
-											PATCHER_checkcast_instanceof_class,
-											iptr->sx.s23.s3.c.ref,
-											disp);
+						cr   = iptr->sx.s23.s3.c.ref;
+						disp = dseg_add_unique_address(cd, NULL);
 
-						if (opt_showdisassemble) {
-							M_NOP; M_NOP;
-						}
+						patcher_add_patch_ref(jd,
+											  PATCHER_resolve_classref_to_vftbl,
+											  cr, disp);
 					}
 					else {
 						disp = dseg_add_address(cd, super->vftbl);
 
-						M_BEQZ(s1, 1 + s3);
-						M_NOP;
+						emit_label_beqz(cd, BRANCH_LABEL_5, s1);
 					}
 
-					M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl));
+					M_ALD(REG_ITMP2, s1, OFFSET(java_object_t, vftbl));
 					M_ALD(REG_ITMP3, REG_PV, disp);
-#if defined(ENABLE_THREADS)
-					codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+					CODEGEN_CRITICAL_SECTION_START;
+
 					M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, baseval));
 					/* 				if (s1 != REG_ITMP1) { */
 					/* 					M_ILD(REG_ITMP1, REG_ITMP3, OFFSET(vftbl_t, baseval)); */
@@ -2836,14 +3325,20 @@ gen_method:
 					M_ISUB(REG_ITMP2, REG_ITMP3, REG_ITMP2); 
 					M_ALD(REG_ITMP3, REG_PV, disp);
 					M_ILD(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, diffval));
-#if defined(ENABLE_THREADS)
-					codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+					CODEGEN_CRITICAL_SECTION_END;
+
 					/* 				} */
 					M_CMPULT(REG_ITMP3, REG_ITMP2, REG_ITMP3);
-					M_BNEZ(REG_ITMP3, 0);
-					codegen_add_classcastexception_ref(cd, s1);
-					M_NOP;
+					emit_classcast_check(cd, iptr, ICMD_IFNE, REG_ITMP3, s1);
+
+					if (super != NULL)
+						emit_label(cd, BRANCH_LABEL_5);
+				}
+
+				if (super == NULL) {
+					emit_label(cd, BRANCH_LABEL_1);
+					emit_label(cd, BRANCH_LABEL_4);
 				}
 
 				d = codegen_reg_of_dst(jd, iptr, s1);
@@ -2853,18 +3348,16 @@ gen_method:
 				M_INTMOVE(s1, REG_A0);
 
 				if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+					cr   = iptr->sx.s23.s3.c.ref;
 					disp = dseg_add_unique_address(cd, NULL);
 
-					codegen_addpatchref(cd, PATCHER_builtin_arraycheckcast,
-										iptr->sx.s23.s3.c.ref,
-										disp);
-
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
+					patcher_add_patch_ref(jd,
+										  PATCHER_resolve_classref_to_classinfo,
+										  cr, disp);
 				}
-				else
+				else {
 					disp = dseg_add_address(cd, iptr->sx.s23.s3.c.cls);
+				}
 
 				M_ALD(REG_A1, REG_PV, disp);
 				disp = dseg_add_functionptr(cd, BUILTIN_arraycheckcast);
@@ -2873,9 +3366,7 @@ gen_method:
 				M_NOP;
 
 				s1 = emit_load_s1(jd, iptr, REG_ITMP1);
-				M_BEQZ(REG_RESULT, 0);
-				codegen_add_classcastexception_ref(cd, s1);
-				M_NOP;
+				emit_classcast_check(cd, iptr, ICMD_IFEQ, REG_RESULT, s1);
 
 				d = codegen_reg_of_dst(jd, iptr, s1);
 			}
@@ -2885,20 +3376,6 @@ gen_method:
 			break;
 
 		case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult            */
-		                      /* val.a: (classinfo*) superclass               */
-
-			/*  superclass is an interface:
-			 *
-			 *  return (sub != NULL) &&
-			 *         (sub->vftbl->interfacetablelength > super->index) &&
-			 *         (sub->vftbl->interfacetable[-super->index] != NULL);
-			 *
-			 *  superclass is a class:
-			 *
-			 *  return ((sub != NULL) && (0
-			 *          <= (sub->vftbl->baseval - super->vftbl->baseval) <=
-			 *          super->vftbl->diffvall));
-			 */
 
 			{
 			classinfo *super;
@@ -2915,72 +3392,51 @@ gen_method:
 				superindex = super->index;
 			}
 			
-#if defined(ENABLE_THREADS)
-			codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+			if ((super == NULL) || !(super->flags & ACC_INTERFACE))
+				CODEGEN_CRITICAL_SECTION_NEW;
 
 			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+
 			if (s1 == d) {
 				M_MOV(s1, REG_ITMP1);
 				s1 = REG_ITMP1;
 			}
 
-			/* calculate interface instanceof code size */
-
-			s2 = 7;
-			if (super == NULL)
-				s2 += (opt_showdisassemble ? 2 : 0);
-
-			/* calculate class instanceof code size */
-
-			s3 = 8;
-			if (super == NULL)
-				s3 += (opt_showdisassemble ? 2 : 0);
-
 			M_CLR(d);
 
 			/* if class is not resolved, check which code to call */
 
 			if (super == NULL) {
-				M_BEQZ(s1, 5 + (opt_showdisassemble ? 2 : 0) + s2 + 2 + s3);
-				M_NOP;
+				emit_label_beqz(cd, BRANCH_LABEL_1, s1);
 
+				cr   = iptr->sx.s23.s3.c.ref;
 				disp = dseg_add_unique_s4(cd, 0);             /* super->flags */
 
-				codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags,
-									iptr->sx.s23.s3.c.ref, disp);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_flags,
+									  cr, disp);
 
-				/* XXX TWISTI M_ILD can be 2 instructions long (jump offset) */
 				M_ILD(REG_ITMP3, REG_PV, disp);
 				M_AND_IMM(REG_ITMP3, ACC_INTERFACE, REG_ITMP3);
-				M_BEQZ(REG_ITMP3, 1 + s2 + 2);
-				M_NOP;
+				emit_label_beqz(cd, BRANCH_LABEL_2, REG_ITMP3);
 			}
 
 			/* interface instanceof code */
 
 			if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
 				if (super == NULL) {
-					codegen_addpatchref(cd,
-										PATCHER_checkcast_instanceof_interface,
-										iptr->sx.s23.s3.c.ref, 0);
+					cr = iptr->sx.s23.s3.c.ref;
 
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
+					patcher_add_patch_ref(jd, PATCHER_instanceof_interface,
+										  cr, 0);
 				}
 				else {
-					M_BEQZ(s1, 1 + s2);
-					M_NOP;
+					emit_label_beqz(cd, BRANCH_LABEL_3, s1);
 				}
 
-				M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
-				M_ILD(REG_ITMP3, REG_ITMP1, OFFSET(vftbl_t, interfacetablelength));
+				M_ALD(REG_ITMP1, s1, OFFSET(java_object_t, vftbl));
+				M_ILD(REG_ITMP3, REG_ITMP1,
+					  OFFSET(vftbl_t, interfacetablelength));
 				M_IADD_IMM(REG_ITMP3, -superindex, REG_ITMP3);
 				M_BLEZ(REG_ITMP3, 3);
 				M_NOP;
@@ -2989,48 +3445,54 @@ gen_method:
 					  superindex * sizeof(methodptr*));
 				M_CMPULT(REG_ZERO, REG_ITMP1, d);      /* REG_ITMP1 != 0  */
 
-				if (super == NULL) {
-					M_BR(1 + s3);
-					M_NOP;
-				}
+				if (super == NULL)
+					emit_label_br(cd, BRANCH_LABEL_4);
+				else
+					emit_label(cd, BRANCH_LABEL_3);
 			}
 
 			/* class instanceof code */
 
 			if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
 				if (super == NULL) {
-					disp = dseg_add_unique_address(cd, NULL);
+					emit_label(cd, BRANCH_LABEL_2);
 
-					codegen_addpatchref(cd, PATCHER_checkcast_instanceof_class,
-										iptr->sx.s23.s3.c.ref,
-										disp);
+					cr   = iptr->sx.s23.s3.c.ref;
+					disp = dseg_add_unique_address(cd, NULL);
 
-					if (opt_showdisassemble) {
-						M_NOP; M_NOP;
-					}
+					patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_vftbl,
+										  cr, disp);
 				}
 				else {
 					disp = dseg_add_address(cd, super->vftbl);
 
-					M_BEQZ(s1, 1 + s3);
-					M_NOP;
+					emit_label_beqz(cd, BRANCH_LABEL_5, s1);
 				}
 
-				M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
+				M_ALD(REG_ITMP1, s1, OFFSET(java_object_t, vftbl));
 				M_ALD(REG_ITMP2, REG_PV, disp);
-#if defined(ENABLE_THREADS)
-				codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+				CODEGEN_CRITICAL_SECTION_START;
+
 				M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl_t, baseval));
 				M_ILD(REG_ITMP3, REG_ITMP2, OFFSET(vftbl_t, baseval));
 				M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, diffval));
-#if defined(ENABLE_THREADS)
-				codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
-#endif
+
+				CODEGEN_CRITICAL_SECTION_END;
+
 				M_ISUB(REG_ITMP1, REG_ITMP3, REG_ITMP1); 
 				M_CMPULT(REG_ITMP2, REG_ITMP1, d);
 				M_XOR_IMM(d, 1, d);
+
+				if (super != NULL)
+					emit_label(cd, BRANCH_LABEL_5);
 			}
+
+			if (super == NULL) {
+				emit_label(cd, BRANCH_LABEL_1);
+				emit_label(cd, BRANCH_LABEL_4);
+			}
+
 			emit_store_dst(jd, iptr, d);
 			}
 			break;
@@ -3049,7 +3511,11 @@ gen_method:
 
 				if (!(var->flags & PREALLOC)) {
 					s2 = emit_load(jd, iptr, var, REG_ITMP1);
+#if SIZEOF_VOID_P == 8
 					M_LST(s2, REG_SP, s1 * 8);
+#else
+					M_IST(s2, REG_SP, (s1 + 2) * 8);
+#endif
 				}
 			}
 
@@ -3060,17 +3526,15 @@ gen_method:
 			/* is patcher function set? */
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+				cr   = iptr->sx.s23.s3.c.ref;
 				disp = dseg_add_unique_address(cd, NULL);
 
-				codegen_addpatchref(cd, PATCHER_builtin_multianewarray,
-									iptr->sx.s23.s3.c.ref, disp);
-
-				if (opt_showdisassemble) {
-					M_NOP; M_NOP;
-				}
+				patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_classinfo,
+									  cr, disp);
 			}
-			else
+			else {
 				disp = dseg_add_address(cd, iptr->sx.s23.s3.c.cls);
+			}
 
 			/* a1 = arraydescriptor */
 
@@ -3078,7 +3542,11 @@ gen_method:
 
 			/* a2 = pointer to dimensions = stack pointer */
 
-			M_INTMOVE(REG_SP, REG_A2);
+#if SIZEOF_VOID_P == 8
+			M_MOV(REG_SP, REG_A2);
+#else
+			M_AADD_IMM(REG_SP, 4*4, REG_A2);
+#endif
 
 			disp = dseg_add_functionptr(cd, BUILTIN_multianewarray);
 			M_ALD(REG_ITMP3, REG_PV, disp);
@@ -3087,9 +3555,7 @@ gen_method:
 
 			/* check for exception before result assignment */
 
-			M_BEQZ(REG_RESULT, 0);
-			codegen_add_fillinstacktrace_ref(cd);
-			M_NOP;
+			emit_exception_check(cd, iptr);
 
 			d = codegen_reg_of_dst(jd, iptr, REG_RESULT);
 			M_INTMOVE(REG_RESULT, d);
@@ -3097,7 +3563,8 @@ gen_method:
 			break;
 
 		default:
-			*exceptionptr = new_internalerror("Unknown ICMD %d", iptr->opc);
+			exceptions_throw_internalerror("Unknown ICMD %d during code generation",
+										   iptr->opc);
 			return false;
 	} /* switch */
 		
@@ -3118,18 +3585,9 @@ gen_method:
 	} /* if (bptr -> flags >= BBREACHED) */
 	} /* for basic block */
 
-	dseg_createlinenumbertable(cd);
+	/* generate traps */
 
-	/* generate exception and patcher stubs */
-
-	emit_exception_stubs(jd);
-	emit_patcher_stubs(jd);
-
-#if 0
-	emit_replacement_stubs(jd);
-#endif
-
-	codegen_finish(jd);
+	emit_patcher_traps(jd);
 
 	/* everything's ok */
 
@@ -3137,120 +3595,58 @@ gen_method:
 }
 
 
-/* createcompilerstub **********************************************************
+/* codegen_emit_stub_native ****************************************************
 
-   Creates a stub routine which calls the compiler.
-	
-*******************************************************************************/
-
-#define COMPILERSTUB_DATASIZE    3 * SIZEOF_VOID_P
-#define COMPILERSTUB_CODESIZE    4 * 4
-
-#define COMPILERSTUB_SIZE        COMPILERSTUB_DATASIZE + COMPILERSTUB_CODESIZE
+   Emits a stub routine which calls a native method.
 
+*******************************************************************************/
 
-u1 *createcompilerstub(methodinfo *m)
+void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f, int skipparams)
 {
-	u1          *s;                     /* memory to hold the stub            */
-	ptrint      *d;
+	methodinfo  *m;
 	codeinfo    *code;
 	codegendata *cd;
-	s4           dumpsize;
-
-	s = CNEW(u1, COMPILERSTUB_SIZE);
-
-	/* set data pointer and code pointer */
-
-	d = (ptrint *) s;
-	s = s + COMPILERSTUB_DATASIZE;
-
-	/* mark start of dump memory area */
-
-	dumpsize = dump_size();
-
-	cd = DNEW(codegendata);
-	cd->mcodeptr = s;
-
-	/* Store the codeinfo pointer in the same place as in the
-	   methodheader for compiled methods. */
-
-	code = code_codeinfo_new(m);
-
-	d[0] = (ptrint) asm_call_jit_compiler;
-	d[1] = (ptrint) m;
-	d[2] = (ptrint) code;
-
-	M_ALD_INTERN(REG_ITMP1, REG_PV, -2 * SIZEOF_VOID_P);  /* codeinfo pointer */
-	M_ALD_INTERN(REG_PV, REG_PV, -3 * SIZEOF_VOID_P);  /* pointer to compiler */
-	M_JMP(REG_PV);
-	M_NOP;
-
-	md_cacheflush(s, (s4) (cd->mcodeptr - (u1 *) d));
-
-#if defined(ENABLE_STATISTICS)
-	if (opt_stat)
-		count_cstub_len += COMPILERSTUB_SIZE;
-#endif
-
-	/* release dump area */
-
-	dump_release(dumpsize);
-
-	return s;
-}
-
-
-/* createnativestub ************************************************************
-
-   Creates a stub routine which calls a native method.
-
-*******************************************************************************/
-
-u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
-{
-	methodinfo   *m;
-	codeinfo     *code;
-	codegendata  *cd;
-	registerdata *rd;
-	methoddesc   *md;
-	s4            nativeparams;
-	s4            i, j;                 /* count variables                    */
-	s4            t;
-	s4            s1, s2, disp;
-	s4            funcdisp;             /* displacement of the function       */
+	methoddesc  *md;
+	s4           i, j;
+	s4           t;
+	int          s1, s2;
+	int          disp;
 
 	/* get required compiler data */
 
 	m    = jd->m;
 	code = jd->code;
 	cd   = jd->cd;
-	rd   = jd->rd;
 
 	/* initialize variables */
 
 	md = m->parseddesc;
-	nativeparams = (m->flags & ACC_STATIC) ? 2 : 1;
 
 	/* calculate stack frame size */
 
 	cd->stackframesize =
 		1 +                             /* return address                     */
-		sizeof(stackframeinfo) / SIZEOF_VOID_P +
+		sizeof(stackframeinfo_t) / SIZEOF_VOID_P +
 		sizeof(localref_table) / SIZEOF_VOID_P +
 		md->paramcount +                /* for saving arguments over calls    */
+#if SIZEOF_VOID_P == 4
+		5 +                             /* additional save space (MIPS32)     */
+#endif
 		1 +                             /* for saving return address          */
 		nmd->memuse;
 
+	/* adjust stackframe size for 16-byte alignment */
+
+	if (cd->stackframesize & 1)
+		cd->stackframesize++;
+
 	/* create method header */
 
 	(void) dseg_add_unique_address(cd, code);              /* CodeinfoPointer */
 	(void) dseg_add_unique_s4(cd, cd->stackframesize * 8); /* FrameSize       */
-	(void) dseg_add_unique_s4(cd, 0);                      /* IsSync          */
 	(void) dseg_add_unique_s4(cd, 0);                      /* IsLeaf          */
 	(void) dseg_add_unique_s4(cd, 0);                      /* IntSave         */
 	(void) dseg_add_unique_s4(cd, 0);                      /* FltSave         */
-	(void) dseg_addlinenumbertablesize(cd);
-	(void) dseg_add_unique_s4(cd, 0);                      /* ExTableSize     */
 
 	/* generate stub code */
 
@@ -3262,145 +3658,273 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 		emit_verbosecall_enter(jd);
 #endif
 
-	/* get function address (this must happen before the stackframeinfo) */
-
-	funcdisp = dseg_add_functionptr(cd, f);
-
-#if !defined(WITH_STATIC_CLASSPATH)
-	if (f == NULL) {
-		codegen_addpatchref(cd, PATCHER_resolve_native, m, funcdisp);
+	/* save integer and float argument registers */
 
-		if (opt_showdisassemble) {
-			M_NOP; M_NOP;
+#if SIZEOF_VOID_P == 8
+	for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
+		if (IS_INT_LNG_TYPE(md->params[i].type)) {
+			s1 = md->params[i].regoff;
+			M_AST(s1, REG_SP, j * 8);
+			j++;
 		}
 	}
-#endif
+#else
+	for (i = 0, j = 5; i < md->paramcount && i < INT_ARG_CNT; i++) {
+		if (IS_INT_LNG_TYPE(md->params[i].type)) {
+			if (!md->params[i].inmemory) {
+ 				s1 = md->params[i].regoff;
 
-	/* save integer and float argument registers */
+				if (IS_2_WORD_TYPE(md->params[i].type))
+					M_LST(s1, REG_SP, j * 8);
+				else
+					M_IST(s1, REG_SP, j * 8);
 
-	for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
-		if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) {
-			M_LST(rd->argintregs[i], REG_SP, j * 8);
-			j++;
+				j++;
+			}
 		}
 	}
+#endif
 
 	for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
-		if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
-			M_DST(rd->argfltregs[i], REG_SP, j * 8);
+		if (IS_FLT_DBL_TYPE(md->params[i].type)) {
+			s1 = md->params[i].regoff;
+
+			if (IS_2_WORD_TYPE(md->params[i].type))
+				M_DST(s1, REG_SP, j * 8);
+			else
+				M_FST(s1, REG_SP, j * 8);
+
 			j++;
 		}
 	}
 
 	/* prepare data structures for native function call */
 
-	M_AADD_IMM(REG_SP, (cd->stackframesize - 1) * 8, REG_A0);
+	M_MOV(REG_SP, REG_A0);
 	M_MOV(REG_PV, REG_A1);
-	M_AADD_IMM(REG_SP, cd->stackframesize * 8, REG_A2);
-	M_ALD(REG_A3, REG_SP, (cd->stackframesize - 1) * 8);
 	disp = dseg_add_functionptr(cd, codegen_start_native_call);
 	M_ALD(REG_ITMP3, REG_PV, disp);
 	M_JSR(REG_RA, REG_ITMP3);
 	M_NOP; /* XXX fill me! */
 
+	/* remember class argument */
+
+	if (m->flags & ACC_STATIC)
+		M_MOV(REG_RESULT, REG_ITMP3);
+
 	/* restore integer and float argument registers */
 
+#if SIZEOF_VOID_P == 8
 	for (i = 0, j = 0; i < md->paramcount && i < INT_ARG_CNT; i++) {
-		if (IS_INT_LNG_TYPE(md->paramtypes[i].type)) {
-			M_LLD(rd->argintregs[i], REG_SP, j * 8);
+		if (IS_INT_LNG_TYPE(md->params[i].type)) {
+			s1 = md->params[i].regoff;
+			M_LLD(s1, REG_SP, j * 8);
 			j++;
 		}
 	}
+#else
+	for (i = 0, j = 5; i < md->paramcount && i < INT_ARG_CNT; i++) {
+		if (IS_INT_LNG_TYPE(md->params[i].type)) {
+			if (!md->params[i].inmemory) {
+				s1 = md->params[i].regoff;
+
+				if (IS_2_WORD_TYPE(md->params[i].type))
+					M_LLD(s1, REG_SP, j * 8);
+				else
+					M_ILD(s1, REG_SP, j * 8);
+
+				j++;
+			}
+		}
+	}
+#endif
 
 	for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
-		if (IS_FLT_DBL_TYPE(md->paramtypes[i].type)) {
-			M_DLD(rd->argfltregs[i], REG_SP, j * 8);
+		if (IS_FLT_DBL_TYPE(md->params[i].type)) {
+			s1 = md->params[i].regoff;
+
+			if (IS_2_WORD_TYPE(md->params[i].type))
+				M_DLD(s1, REG_SP, j * 8);
+			else
+				M_FLD(s1, REG_SP, j * 8);
+
 			j++;
 		}
 	}
 
 	/* copy or spill arguments to new locations */
 
-	for (i = md->paramcount - 1, j = i + nativeparams; i >= 0; i--, j--) {
-		t = md->paramtypes[i].type;
+	for (i = md->paramcount - 1, j = i + skipparams; i >= 0; i--, j--) {
+		t = md->params[i].type;
 
 		if (IS_INT_LNG_TYPE(t)) {
 			if (!md->params[i].inmemory) {
-				s1 = rd->argintregs[md->params[i].regoff];
+				s1 = md->params[i].regoff;
+				s2 = nmd->params[j].regoff;
 
 				if (!nmd->params[j].inmemory) {
-					s2 = rd->argintregs[nmd->params[j].regoff];
+#if SIZEOF_VOID_P == 8
 					M_INTMOVE(s1, s2);
-				} else {
-					s2 = nmd->params[j].regoff;
-					M_AST(s1, REG_SP, s2 * 8);
+#else
+					if (IS_2_WORD_TYPE(t))
+						M_LNGMOVE(s1, s2);
+					else
+						M_INTMOVE(s1, s2);
+#endif
+				}
+				else {
+#if SIZEOF_VOID_P == 8
+					M_LST(s1, REG_SP, s2);
+#else
+					if (IS_2_WORD_TYPE(t))
+						M_LST(s1, REG_SP, s2);
+					else
+						M_IST(s1, REG_SP, s2);
+#endif
 				}
-
-			} else {
-				s1 = md->params[i].regoff + cd->stackframesize;
-				s2 = nmd->params[j].regoff;
-				M_ALD(REG_ITMP1, REG_SP, s1 * 8);
-				M_AST(REG_ITMP1, REG_SP, s2 * 8);
 			}
+			else {
+				s1 = md->params[i].regoff + cd->stackframesize * 8;
+				s2 = nmd->params[j].regoff;
 
-		} else {
+#if SIZEOF_VOID_P == 8
+				M_LLD(REG_ITMP1, REG_SP, s1);
+				M_LST(REG_ITMP1, REG_SP, s2);
+#else
+				if (IS_2_WORD_TYPE(t)) {
+					M_LLD(REG_ITMP12_PACKED, REG_SP, s1);
+					M_LST(REG_ITMP12_PACKED, REG_SP, s2);
+				}
+				else {
+					M_ILD(REG_ITMP1, REG_SP, s1);
+					M_IST(REG_ITMP1, REG_SP, s2);
+				}
+#endif
+			}
+		}
+		else {
 			if (!md->params[i].inmemory) {
-				s1 = rd->argfltregs[md->params[i].regoff];
+				s1 = md->params[i].regoff;
+				s2 = nmd->params[j].regoff;
 
 				if (!nmd->params[j].inmemory) {
-					s2 = rd->argfltregs[nmd->params[j].regoff];
+#if SIZEOF_VOID_P == 8
 					if (IS_2_WORD_TYPE(t))
 						M_DMOV(s1, s2);
 					else
 						M_FMOV(s1, s2);
+#else
+					/* On MIPS32 float arguments for native functions
+					   can never be in float argument registers, since
+					   the first argument is _always_ an integer
+					   argument (JNIEnv) */
+
+					if (IS_2_WORD_TYPE(t)) {
+						/* double high/low order is endian
+						   independent: even numbered holds low
+						   32-bits, odd numbered high 32-bits */
+
+						M_MFC1(GET_LOW_REG(s2), s1);           /* low 32-bits */
+						M_MFC1(GET_HIGH_REG(s2), s1 + 1);     /* high 32-bits */
+					}
+					else
+						M_MFC1(s2, s1);
+#endif
+				}
+				else {
+#if SIZEOF_VOID_P == 8
+					if (IS_2_WORD_TYPE(t))
+						M_DST(s1, REG_SP, s2);
+					else
+						M_FST(s1, REG_SP, s2);
+#else
+					/* s1 may have been originally in 2 int registers,
+					   but was moved out by the native function
+					   argument(s), just get low register */
 
-				} else {
-					s2 = nmd->params[j].regoff;
 					if (IS_2_WORD_TYPE(t))
-						M_DST(s1, REG_SP, s2 * 8);
+						M_DST(GET_LOW_REG(s1), REG_SP, s2);
 					else
-						M_FST(s1, REG_SP, s2 * 8);
+						M_FST(GET_LOW_REG(s1), REG_SP, s2);
+#endif
 				}
-
-			} else {
-				s1 = md->params[i].regoff + cd->stackframesize;
+			}
+			else {
+				s1 = md->params[i].regoff + cd->stackframesize * 8;
 				s2 = nmd->params[j].regoff;
+
+#if SIZEOF_VOID_P == 8
 				if (IS_2_WORD_TYPE(t)) {
-					M_DLD(REG_FTMP1, REG_SP, s1 * 8);
-					M_DST(REG_FTMP1, REG_SP, s2 * 8);
-				} else {
-					M_FLD(REG_FTMP1, REG_SP, s1 * 8);
-					M_FST(REG_FTMP1, REG_SP, s2 * 8);
+					M_DLD(REG_FTMP1, REG_SP, s1);
+					M_DST(REG_FTMP1, REG_SP, s2);
 				}
+				else {
+					M_FLD(REG_FTMP1, REG_SP, s1);
+					M_FST(REG_FTMP1, REG_SP, s2);
+				}
+#else
+				if (IS_2_WORD_TYPE(t)) {
+					M_DLD(REG_FTMP1, REG_SP, s1);
+					M_DST(REG_FTMP1, REG_SP, s2);
+				}
+				else {
+					M_FLD(REG_FTMP1, REG_SP, s1);
+					M_FST(REG_FTMP1, REG_SP, s2);
+				}
+#endif
 			}
 		}
 	}
 
-	/* put class into second argument register */
+	/* Handle native Java methods. */
 
-	if (m->flags & ACC_STATIC) {
-		disp = dseg_add_address(cd, m->class);
-		M_ALD(REG_A1, REG_PV, disp);
-	}
+	if (m->flags & ACC_NATIVE) {
+		/* put class into second argument register */
 
-	/* put env into first argument register */
+		if (m->flags & ACC_STATIC)
+			M_MOV(REG_ITMP3, REG_A1);
 
-	disp = dseg_add_address(cd, _Jv_env);
-	M_ALD(REG_A0, REG_PV, disp);
+		/* put env into first argument register */
 
-	/* do the native function call */
+		disp = dseg_add_address(cd, _Jv_env);
+		M_ALD(REG_A0, REG_PV, disp);
+	}
+
+	/* Call the native function. */
 
-	M_ALD(REG_ITMP3, REG_PV, funcdisp); /* load adress of native method       */
+	disp = dseg_add_functionptr(cd, f);
+	M_ALD(REG_ITMP3, REG_PV, disp);     /* load adress of native method       */
 	M_JSR(REG_RA, REG_ITMP3);           /* call native method                 */
 	M_NOP;                              /* delay slot                         */
 
 	/* save return value */
 
-	if (md->returntype.type != TYPE_VOID) {
-		if (IS_INT_LNG_TYPE(md->returntype.type))
-			M_LST(REG_RESULT, REG_SP, 0 * 8);
-		else
-			M_DST(REG_FRESULT, REG_SP, 0 * 8);
+	switch (md->returntype.type) {
+#if SIZEOF_VOID_P == 8
+	case TYPE_INT:
+	case TYPE_LNG:
+	case TYPE_ADR:
+		M_LST(REG_RESULT, REG_SP, 0 * 8);
+		break;
+	case TYPE_FLT:
+	case TYPE_DBL:
+		M_DST(REG_FRESULT, REG_SP, 0 * 8);
+		break;
+#else
+	case TYPE_INT:
+	case TYPE_ADR:
+		M_IST(REG_RESULT, REG_SP, 2*4 + 0 * 8);
+		break;
+	case TYPE_LNG:
+		M_LST(REG_RESULT_PACKED, REG_SP, 2*4 + 0 * 8);
+		break;
+	case TYPE_FLT:
+	case TYPE_DBL:
+		M_DST(REG_FRESULT, REG_SP, 2*4 + 0 * 8);
+		break;
+#endif
+	case TYPE_VOID:
+		break;
 	}
 
 #if !defined(NDEBUG)
@@ -3410,7 +3934,8 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 	/* remove native stackframe info */
 
-	M_AADD_IMM(REG_SP, (cd->stackframesize - 1) * 8, REG_A0);
+	M_MOV(REG_SP, REG_A0);
+	M_MOV(REG_PV, REG_A1);
 	disp = dseg_add_functionptr(cd, codegen_finish_native_call);
 	M_ALD(REG_ITMP3, REG_PV, disp);
 	M_JSR(REG_RA, REG_ITMP3);
@@ -3419,11 +3944,32 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 	/* restore return value */
 
-	if (md->returntype.type != TYPE_VOID) {
-		if (IS_INT_LNG_TYPE(md->returntype.type))
-			M_LLD(REG_RESULT, REG_SP, 0 * 8);
-		else
-			M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+	switch (md->returntype.type) {
+#if SIZEOF_VOID_P == 8
+	case TYPE_INT:
+	case TYPE_LNG:
+	case TYPE_ADR:
+		M_LLD(REG_RESULT, REG_SP, 0 * 8);
+		break;
+	case TYPE_FLT:
+	case TYPE_DBL:
+		M_DLD(REG_FRESULT, REG_SP, 0 * 8);
+		break;
+#else
+	case TYPE_INT:
+	case TYPE_ADR:
+		M_ILD(REG_RESULT, REG_SP, 2*4 + 0 * 8);
+		break;
+	case TYPE_LNG:
+		M_LLD(REG_RESULT_PACKED, REG_SP, 2*4 + 0 * 8);
+		break;
+	case TYPE_FLT:
+	case TYPE_DBL:
+		M_DLD(REG_FRESULT, REG_SP, 2*4 + 0 * 8);
+		break;
+#endif
+	case TYPE_VOID:
+		break;
 	}
 
 	M_ALD(REG_RA, REG_SP, (cd->stackframesize - 1) * 8); /* load RA           */
@@ -3443,13 +3989,9 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 	M_JMP(REG_ITMP3);                   /* jump to asm exception handler      */
 	M_ASUB_IMM(REG_RA, 4, REG_ITMP2_XPC); /* get exception address (DELAY)    */
 
-	/* generate patcher stubs */
-
-	emit_patcher_stubs(jd);
-
-	codegen_finish(jd);
+	/* Generate patcher traps. */
 
-	return code->entrypoint;
+	emit_patcher_traps(jd);
 }