X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Falpha%2Fcodegen.c;h=c37219f23e8e285c30e2e87112c0f014dd8da192;hb=9f859ad50d3d5d98c185d40b86b2179bc4dc9aeb;hp=f000b038fdec75b4b242ec9c4539d220988ef544;hpb=da18c396592f05a89506d491d1b83240273d2816;p=cacao.git

diff --git a/src/vm/jit/alpha/codegen.c b/src/vm/jit/alpha/codegen.c
index f000b038f..c37219f23 100644
--- a/src/vm/jit/alpha/codegen.c
+++ b/src/vm/jit/alpha/codegen.c
@@ -1,6 +1,6 @@
 /* src/vm/jit/alpha/codegen.c - machine code generator for Alpha
 
-   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,18 +22,6 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 
-   Contact: cacao@cacaojvm.org
-
-   Authors: Andreas Krall
-            Reinhard Grafl
-
-   Changes: Joseph Wenninger
-            Christian Thalinger
-            Christian Ullrich
-            Edwin Steiner
-
-   $Id: codegen.c 5266 2006-08-23 12:57:41Z twisti $
-
 */
 
 
@@ -50,58 +38,65 @@
 #include "vm/jit/alpha/arch.h"
 #include "vm/jit/alpha/codegen.h"
 
+#include "mm/memory.h"
+
 #include "native/jni.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/exceptions.h"
 #include "vm/global.h"
-#include "vm/loader.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.h"
+#include "vm/jit/emit-common.h"
 #include "vm/jit/jit.h"
 #include "vm/jit/parse.h"
-#include "vm/jit/patcher.h"
+#include "vm/jit/patcher-common.h"
 #include "vm/jit/reg.h"
 #include "vm/jit/replace.h"
+#include "vm/jit/stacktrace.h"
 
 #if defined(ENABLE_LSRA)
 # include "vm/jit/allocator/lsra.h"
 #endif
 
+#include "vmcore/loader.h"
+#include "vmcore/options.h"
 
-/* codegen *********************************************************************
+
+/* codegen_emit ****************************************************************
 
    Generates machine code.
 
 *******************************************************************************/
 
-bool codegen(jitdata *jd)
+bool codegen_emit(jitdata *jd)
 {
 	methodinfo         *m;
 	codeinfo           *code;
 	codegendata        *cd;
 	registerdata       *rd;
 	s4                  len, s1, s2, s3, d, disp;
-	stackptr            src;
 	varinfo            *var;
 	basicblock         *bptr;
 	instruction        *iptr;
-	exceptiontable     *ex;
+	exception_entry    *ex;
 	u2                  currentline;
 	methodinfo         *lm;             /* local methodinfo for ICMD_INVOKE*  */
+	unresolved_method  *um;
 	builtintable_entry *bte;
 	methoddesc         *md;
-	rplpoint           *replacementpoint;
+	fieldinfo          *fi;
+	unresolved_field   *uf;
+	s4                  fieldtype;
+	s4                 varindex;
 
 	/* get required compiler data */
 
@@ -112,10 +107,12 @@ bool codegen(jitdata *jd)
 
 	/* prevent compiler warnings */
 
-	d = 0;
+	d           = 0;
+	fieldtype   = 0;
+	lm          = NULL;
+	um          = NULL;
+	bte         = NULL;
 	currentline = 0;
-	lm = NULL;
-	bte = NULL;
 
 	{
 	s4 i, p, t, l;
@@ -128,21 +125,21 @@ bool codegen(jitdata *jd)
 	savedregs_num += (INT_SAV_CNT - rd->savintreguse);
 	savedregs_num += (FLT_SAV_CNT - rd->savfltreguse);
 
-	jd->stackframesize = rd->memuse + savedregs_num;
+	cd->stackframesize = rd->memuse + savedregs_num;
 
 #if defined(ENABLE_THREADS)        /* space to save argument of monitor_enter */
 	if (checksync && (m->flags & ACC_SYNCHRONIZED))
-		jd->stackframesize++;
+		cd->stackframesize++;
 #endif
 
 	/* create method header */
 
 #if 0
-	jd->stackframesize = (jd->stackframesize + 1) & ~1; /* align stack to 16-bytes */
+	cd->stackframesize = (cd->stackframesize + 1) & ~1; /* align stack to 16-bytes */
 #endif
 
 	(void) dseg_add_unique_address(cd, code);              /* CodeinfoPointer */
-	(void) dseg_add_unique_s4(cd, jd->stackframesize * 8); /* FrameSize       */
+	(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
@@ -163,25 +160,25 @@ bool codegen(jitdata *jd)
 
 	dseg_addlinenumbertablesize(cd);
 
-	(void) dseg_add_unique_s4(cd, cd->exceptiontablelength);   /* ExTableSize */
+	(void) dseg_add_unique_s4(cd, jd->exceptiontablelength);   /* ExTableSize */
 
 	/* create exception table */
 
-	for (ex = cd->exceptiontable; ex != NULL; ex = ex->down) {
+	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.cls);
+		(void) dseg_add_unique_address(cd, ex->catchtype.any);
 	}
 	
 	/* create stack frame (if necessary) */
 
-	if (jd->stackframesize)
-		M_LDA(REG_SP, REG_SP, -(jd->stackframesize * 8));
+	if (cd->stackframesize)
+		M_LDA(REG_SP, REG_SP, -(cd->stackframesize * 8));
 
 	/* save return address and used callee saved registers */
 
-	p = jd->stackframesize;
+	p = cd->stackframesize;
 	if (!jd->isleafmethod) {
 		p--; M_AST(REG_RA, REG_SP, p * 8);
 	}
@@ -198,52 +195,49 @@ bool codegen(jitdata *jd)
 
  	for (p = 0, l = 0; p < md->paramcount; p++) {
  		t = md->paramtypes[p].type;
- 		var = &(rd->locals[l][t]);
+
+  		varindex = jd->local_map[l * 5 + t];
+
  		l++;
  		if (IS_2_WORD_TYPE(t))    /* increment local counter for 2 word types */
  			l++;
- 		if (var->type < 0)
- 			continue;
-		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->regoff);
 
-				} else {                             /* reg arg -> spilled    */
- 					M_LST(s2, REG_SP, var->regoff * 8);
- 				}
+		if (varindex == UNUSED)
+			continue;
 
-			} else {                                 /* stack arguments       */
- 				if (!(var->flags & INMEMORY)) {      /* stack arg -> register */
- 					M_LLD(var->regoff, REG_SP, (jd->stackframesize + s1) * 8);
+ 		var = VAR(varindex);
 
- 				} else {                             /* stack arg -> spilled  */
-					var->regoff = jd->stackframesize + s1;
-				}
-			}
+		s1 = md->params[p].regoff;
 
-		} else {                                     /* floating args         */
+		if (IS_INT_LNG_TYPE(t)) {                    /* integer args          */
  			if (!md->params[p].inmemory) {           /* register arguments    */
-				s2 = rd->argfltregs[s1];
- 				if (!(var->flags & INMEMORY)) {      /* reg arg -> register   */
- 					M_FLTMOVE(s2, var->regoff);
-
- 				} else {			                 /* reg arg -> spilled    */
- 					M_DST(s2, REG_SP, var->regoff * 8);
- 				}
-
-			} else {                                 /* stack arguments       */
- 				if (!(var->flags & INMEMORY)) {      /* stack-arg -> register */
- 					M_DLD(var->regoff, REG_SP, (jd->stackframesize + s1) * 8);
-
- 				} else {                             /* stack-arg -> spilled  */
-					var->regoff = jd->stackframesize + s1;
-				}
+ 				if (!IS_INMEMORY(var->flags))
+ 					M_INTMOVE(s1, var->vv.regoff);
+				else
+ 					M_LST(s1, REG_SP, var->vv.regoff);
+			}
+			else {                                   /* stack arguments       */
+ 				if (!IS_INMEMORY(var->flags))
+ 					M_LLD(var->vv.regoff, REG_SP, cd->stackframesize * 8 + s1);
+				else
+					var->vv.regoff = cd->stackframesize * 8 + s1;
+			}
+		}
+		else {                                       /* floating args         */
+ 			if (!md->params[p].inmemory) {           /* register arguments    */
+ 				if (!IS_INMEMORY(var->flags))
+ 					M_FLTMOVE(s1, var->vv.regoff);
+ 				else
+ 					M_DST(s1, REG_SP, var->vv.regoff * 8);
+			}
+			else {                                   /* stack arguments       */
+ 				if (!(var->flags & INMEMORY))
+ 					M_DLD(var->vv.regoff, REG_SP, cd->stackframesize * 8 + s1);
+				else
+					var->vv.regoff = cd->stackframesize * 8 + s1;
 			}
 		}
-	} /* end for */
+	}
 
 	/* call monitorenter function */
 
@@ -258,10 +252,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_LST(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;
 		}
@@ -271,14 +265,14 @@ bool codegen(jitdata *jd)
 
 		if (m->flags & ACC_STATIC) {
 			disp = dseg_add_address(cd, &m->class->object.header);
-			M_ALD(rd->argintregs[0], REG_PV, disp);
+			M_ALD(REG_A0, REG_PV, disp);
 		}
 		else {
-			M_BEQZ(rd->argintregs[0], 0);
-			codegen_add_nullpointerexception_ref(cd);
+			M_BNEZ(REG_A0, 1);
+			M_ALD_INTERN(REG_ZERO, REG_ZERO, EXCEPTION_HARDWARE_NULLPOINTER);
 		}
 
-		M_AST(rd->argintregs[0], REG_SP, s1 * 8);
+		M_AST(REG_A0, REG_SP, s1 * 8);
 		disp = dseg_add_functionptr(cd, LOCK_monitor_enter);
 		M_ALD(REG_PV, REG_PV, disp);
 		M_JSR(REG_RA, REG_PV);
@@ -288,10 +282,10 @@ bool codegen(jitdata *jd)
 #if !defined(NDEBUG)
 		if (opt_verbosecall) {
 			for (p = 0; p < INT_ARG_CNT; p++)
-				M_LLD(rd->argintregs[p], REG_SP, p * 8);
+				M_LLD(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);
 		}
@@ -302,81 +296,21 @@ bool codegen(jitdata *jd)
 	/* call trace function */
 
 #if !defined(NDEBUG)
-	if (opt_verbosecall) {
-		M_LDA(REG_SP, REG_SP, -((INT_ARG_CNT + FLT_ARG_CNT + 2) * 8));
-		M_AST(REG_RA, REG_SP, 1 * 8);
-
-		/* save integer argument registers */
-
-		for (p = 0; p < md->paramcount && p < INT_ARG_CNT; p++)
-			M_LST(rd->argintregs[p], REG_SP, (2 + p) * 8);
-
-		/* save and copy float arguments into integer registers */
-
-		for (p = 0; p < md->paramcount && p < FLT_ARG_CNT; p++) {
-			t = md->paramtypes[p].type;
-
-			if (IS_FLT_DBL_TYPE(t)) {
-				if (IS_2_WORD_TYPE(t)) {
-					M_DST(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8);
-
-				} else {
-					M_FST(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8);
-				}
-
-				M_LLD(rd->argintregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8);
-				
-			} else {
-				M_DST(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8);
-			}
-		}
-
-		disp = dseg_add_address(cd, m);
-		M_ALD(REG_ITMP1, REG_PV, disp);
-		M_AST(REG_ITMP1, REG_SP, 0 * 8);
-		disp = dseg_add_functionptr(cd, builtin_trace_args);
-		M_ALD(REG_PV, REG_PV, disp);
-		M_JSR(REG_RA, REG_PV);
-		disp = (s4) (cd->mcodeptr - cd->mcodebase);
-		M_LDA(REG_PV, REG_RA, -disp);
-		M_ALD(REG_RA, REG_SP, 1 * 8);
-
-		/* restore integer argument registers */
-
-		for (p = 0; p < md->paramcount && p < INT_ARG_CNT; p++)
-			M_LLD(rd->argintregs[p], REG_SP, (2 + p) * 8);
-
-		/* restore float argument registers */
-
-		for (p = 0; p < md->paramcount && p < FLT_ARG_CNT; p++) {
-			t = md->paramtypes[p].type;
-
-			if (IS_FLT_DBL_TYPE(t)) {
-				if (IS_2_WORD_TYPE(t)) {
-					M_DLD(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8);
-
-				} else {
-					M_FLD(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8);
-				}
-
-			} else {
-				M_DLD(rd->argfltregs[p], REG_SP, (2 + INT_ARG_CNT + p) * 8);
-			}
-		}
-
-		M_LDA(REG_SP, REG_SP, (INT_ARG_CNT + FLT_ARG_CNT + 2) * 8);
-	}
-#endif /* !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 */
 
-	for (bptr = m->basicblocks; bptr != NULL; bptr = bptr->next) {
+	for (bptr = jd->basicblocks; bptr != NULL; bptr = bptr->next) {
 
 		bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
 
@@ -384,76 +318,44 @@ bool codegen(jitdata *jd)
 
 		/* branch resolving */
 
-		{
-		branchref *brefs;
-		for (brefs = bptr->branchrefs; brefs != NULL; brefs = brefs->next) {
-			gen_resolvebranch((u1*) cd->mcodebase + brefs->branchpos, 
-			                  brefs->branchpos, bptr->mpc);
-			}
-		}
+		codegen_resolve_branchrefs(cd, bptr);
 
 		/* handle replacement points */
 
-		if (bptr->bitflags & BBFLAG_REPLACEMENT) {
-			replacementpoint->pc = (u1*)(ptrint)bptr->mpc; /* will be resolved later */
-			
-			replacementpoint++;
-		}
+		REPLACEMENT_POINT_BLOCK_START(cd, bptr);
 
 		/* copy interface registers to their destination */
 
-		src = bptr->instack;
 		len = bptr->indepth;
 		MCODECHECK(64+len);
 #if defined(ENABLE_LSRA)
 		if (opt_lsra) {
-		while (src != NULL) {
+		while (len) {
 			len--;
-			if ((len == 0) && (bptr->type != BBTYPE_STD)) {
+			src = bptr->invars[len];
+			if ((len == bptr->indepth-1) && (bptr->type == BBTYPE_EXH)) {
 					/* 				d = reg_of_var(m, src, REG_ITMP1); */
 					if (!(src->flags & INMEMORY))
-						d = src->regoff;
+						d = src->vv.regoff;
 					else
 						d = REG_ITMP1;
 					M_INTMOVE(REG_ITMP1, d);
 					emit_store(jd, NULL, src, d);
 				}
-				src = src->prev;
 			}
 		} else {
 #endif
-			while (src != NULL) {
+			while (len) {
 				len--;
-				if ((len == 0) && (bptr->type != BBTYPE_STD)) {
-					d = codegen_reg_of_var(rd, 0, src, REG_ITMP1);
+				var = VAR(bptr->invars[len]);
+ 				if ((len == bptr->indepth-1) && (bptr->type == BBTYPE_EXH)) {
+					d = codegen_reg_of_var(0, var, REG_ITMP1);
 					M_INTMOVE(REG_ITMP1, d);
-					emit_store(jd, NULL, src, d);
-
-				} else {
-					d = codegen_reg_of_var(rd, 0, src, REG_IFTMP);
-					if ((src->varkind != STACKVAR)) {
-						s2 = src->type;
-						if (IS_FLT_DBL_TYPE(s2)) {
-							if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-								s1 = rd->interfaces[len][s2].regoff;
-								M_FLTMOVE(s1, d);
-							} else {
-								M_DLD(d, REG_SP, rd->interfaces[len][s2].regoff * 8);
-							}
-							emit_store(jd, NULL, src, d);
-						}
-						else {
-							if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-								s1 = rd->interfaces[len][s2].regoff;
-								M_INTMOVE(s1, d);
-							} else {
-								M_LLD(d, REG_SP, rd->interfaces[len][s2].regoff * 8);
-							}
-							emit_store(jd, NULL, src, d);
-						}
-					}
+					emit_store(jd, NULL, var, d);
+				}
+				else {
+					assert((var->flags & INOUT));
 				}
-				src = src->prev;
 			}
 #if defined(ENABLE_LSRA)
 		}
@@ -461,10 +363,9 @@ bool codegen(jitdata *jd)
 
 		/* walk through all instructions */
 		
-		src = bptr->instack;
 		len = bptr->icount;
 
-		for (iptr = bptr->iinstr; len > 0; src = iptr->dst, len--, iptr++) {
+		for (iptr = bptr->iinstr; len > 0; len--, iptr++) {
 			if (iptr->line != currentline) {
 				dseg_addlinenumber(cd, iptr->line);
 				currentline = iptr->line;
@@ -473,216 +374,119 @@ bool codegen(jitdata *jd)
 		MCODECHECK(64);       /* an instruction usually needs < 64 words      */
 		switch (iptr->opc) {
 
+		case ICMD_NOP:        /* ...  ==> ...                                 */
+		case ICMD_POP:        /* ..., value  ==> ...                          */
+		case ICMD_POP2:       /* ..., value, value  ==> ...                   */
+			break;
+
 		case ICMD_INLINE_START:
-		case ICMD_INLINE_END:
+
+			REPLACEMENT_POINT_INLINE_START(cd, iptr);
 			break;
 
-		case ICMD_NOP:        /* ...  ==> ...                                 */
+		case ICMD_INLINE_BODY:
+
+			REPLACEMENT_POINT_INLINE_BODY(cd, iptr);
+			dseg_addlinenumber_inline_start(cd, iptr);
+			dseg_addlinenumber(cd, iptr->line);
+			break;
+
+		case ICMD_INLINE_END:
+
+			dseg_addlinenumber_inline_end(cd, iptr);
+			dseg_addlinenumber(cd, iptr->line);
 			break;
 
 		case ICMD_CHECKNULL:  /* ..., objectref  ==> ..., objectref           */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			M_BEQZ(s1, 0);
-			codegen_add_nullpointerexception_ref(cd);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			emit_nullpointer_check(cd, iptr, s1);
 			break;
 
 		/* constant operations ************************************************/
 
 		case ICMD_ICONST:     /* ...  ==> ..., constant                       */
-		                      /* op1 = 0, val.i = constant                    */
 
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
-			ICONST(d, iptr->val.i);
-			emit_store(jd, iptr, iptr->dst, d);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
+			ICONST(d, iptr->sx.val.i);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LCONST:     /* ...  ==> ..., constant                       */
-		                      /* op1 = 0, val.l = constant                    */
 
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
-			LCONST(d, iptr->val.l);
-			emit_store(jd, iptr, iptr->dst, d);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
+			LCONST(d, iptr->sx.val.l);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_FCONST:     /* ...  ==> ..., constant                       */
-		                      /* op1 = 0, val.f = constant                    */
 
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
-			disp = dseg_add_float(cd, iptr->val.f);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
+			disp = dseg_add_float(cd, iptr->sx.val.f);
 			M_FLD(d, REG_PV, disp);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 			
 		case ICMD_DCONST:     /* ...  ==> ..., constant                       */
-		                      /* op1 = 0, val.d = constant                    */
 
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
-			disp = dseg_add_double(cd, iptr->val.d);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
+			disp = dseg_add_double(cd, iptr->sx.val.d);
 			M_DLD(d, REG_PV, disp);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_ACONST:     /* ...  ==> ..., constant                       */
-		                      /* op1 = 0, val.a = constant                    */
 
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				constant_classref *cr = ICMD_ACONST_UNRESOLVED_CLASSREF(iptr);
+				constant_classref *cr = iptr->sx.val.c.ref;
 
 				disp = dseg_add_unique_address(cd, cr);
 
 				/* XXX Only add the patcher, if this position needs to
 				   be patched.  If there was a previous position which
 				   resolved the same class, the returned displacement
-				   of dseg_addaddress is ok to use. */
-
-				codegen_addpatchref(cd, PATCHER_aconst, cr, disp);
+				   of dseg_add_address is ok to use. */
 
-				if (opt_showdisassemble)
-					M_NOP;
+				patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_classinfo,
+									  cr, disp);
 
 				M_ALD(d, REG_PV, disp);
 			}
 			else {
-				if (iptr->val.a == NULL)
+				if (iptr->sx.val.anyptr == NULL)
 					M_INTMOVE(REG_ZERO, d);
 				else {
-					disp = dseg_add_address(cd, iptr->val.a);
+					disp = dseg_add_address(cd, iptr->sx.val.anyptr);
 					M_ALD(d, REG_PV, disp);
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 
-		/* load/store operations **********************************************/
+		/* load/store/move/copy operations ************************************/
 
 		case ICMD_ILOAD:      /* ...  ==> ..., content of local variable      */
-		case ICMD_LLOAD:      /* op1 = local variable                         */
-		case ICMD_ALOAD:
-
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
-			if ((iptr->dst->varkind == LOCALVAR) &&
-			    (iptr->dst->varnum == iptr->op1))
-				break;
-			var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ILOAD]);
-			if (var->flags & INMEMORY) {
-				M_LLD(d, REG_SP, var->regoff * 8);
-			} else {
-				M_INTMOVE(var->regoff, d);
-			}
-			emit_store(jd, iptr, iptr->dst, d);
-			break;
-
-		case ICMD_FLOAD:      /* ...  ==> ..., content of local variable      */
-		case ICMD_DLOAD:      /* op1 = local variable                         */
-
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
-			if ((iptr->dst->varkind == LOCALVAR) &&
-			    (iptr->dst->varnum == iptr->op1))
-				break;
-			var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ILOAD]);
-			if (var->flags & INMEMORY) {
-				M_DLD(d, REG_SP, var->regoff * 8);
-			} else {
-				M_FLTMOVE(var->regoff, d);
-			}
-			emit_store(jd, iptr, iptr->dst, d);
-			break;
-
-
+		case ICMD_ALOAD:      /* s1 = local variable                          */
+		case ICMD_LLOAD:
+		case ICMD_FLOAD:  
+		case ICMD_DLOAD:  
 		case ICMD_ISTORE:     /* ..., value  ==> ...                          */
-		case ICMD_LSTORE:     /* op1 = local variable                         */
-		case ICMD_ASTORE:
-
-			if ((src->varkind == LOCALVAR) &&
-			    (src->varnum == iptr->op1))
-				break;
-			var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]);
-			if (var->flags & INMEMORY) {
-				s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-				M_LST(s1, REG_SP, var->regoff * 8);
-			} else {
-				s1 = emit_load_s1(jd, iptr, src, var->regoff);
-				M_INTMOVE(s1, var->regoff);
-			}
-			break;
-
-		case ICMD_FSTORE:     /* ..., value  ==> ...                          */
-		case ICMD_DSTORE:     /* op1 = local variable                         */
-
-			if ((src->varkind == LOCALVAR) &&
-			    (src->varnum == iptr->op1))
-				break;
-			var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]);
-			if (var->flags & INMEMORY) {
-				s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
-				M_DST(s1, REG_SP, var->regoff * 8);
-			} else {
-				s1 = emit_load_s1(jd, iptr, src, var->regoff);
-				M_FLTMOVE(s1, var->regoff);
-			}
-			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  ==> ...                   */
-			break;
-
-		case ICMD_DUP:        /* ..., a ==> ..., a, a                         */
-			M_COPY(src, iptr->dst);
-			break;
-
-		case ICMD_DUP_X1:     /* ..., a, b ==> ..., b, a, b                   */
-
-			M_COPY(src,       iptr->dst);
-			M_COPY(src->prev, iptr->dst->prev);
-			M_COPY(iptr->dst, iptr->dst->prev->prev);
-			break;
-
-		case ICMD_DUP_X2:     /* ..., a, b, c ==> ..., c, a, b, c             */
-
-			M_COPY(src,             iptr->dst);
-			M_COPY(src->prev,       iptr->dst->prev);
-			M_COPY(src->prev->prev, iptr->dst->prev->prev);
-			M_COPY(iptr->dst,       iptr->dst->prev->prev->prev);
-			break;
+		case ICMD_LSTORE:
+		case ICMD_FSTORE:
+		case ICMD_DSTORE: 
+		case ICMD_COPY:
+		case ICMD_MOVE:
 
-		case ICMD_DUP2:       /* ..., a, b ==> ..., a, b, a, b                */
-
-			M_COPY(src,       iptr->dst);
-			M_COPY(src->prev, iptr->dst->prev);
-			break;
-
-		case ICMD_DUP2_X1:    /* ..., a, b, c ==> ..., b, c, a, b, c          */
-
-			M_COPY(src,             iptr->dst);
-			M_COPY(src->prev,       iptr->dst->prev);
-			M_COPY(src->prev->prev, iptr->dst->prev->prev);
-			M_COPY(iptr->dst,       iptr->dst->prev->prev->prev);
-			M_COPY(iptr->dst->prev, iptr->dst->prev->prev->prev->prev);
+			emit_copy(jd, iptr);
 			break;
+	
+		case ICMD_ASTORE:
 
-		case ICMD_DUP2_X2:    /* ..., a, b, c, d ==> ..., c, d, a, b, c, d    */
-
-			M_COPY(src,                   iptr->dst);
-			M_COPY(src->prev,             iptr->dst->prev);
-			M_COPY(src->prev->prev,       iptr->dst->prev->prev);
-			M_COPY(src->prev->prev->prev, iptr->dst->prev->prev->prev);
-			M_COPY(iptr->dst,             iptr->dst->prev->prev->prev->prev);
-			M_COPY(iptr->dst->prev,       iptr->dst->prev->prev->prev->prev->prev);
-			break;
-
-		case ICMD_SWAP:       /* ..., a, b ==> ..., b, a                      */
-
-			M_COPY(src,       iptr->dst->prev);
-			M_COPY(src->prev, iptr->dst);
+			if (!(iptr->flags.bits & INS_FLAG_RETADDR))
+				emit_copy(jd, iptr);
 			break;
 
 
@@ -690,221 +494,224 @@ bool codegen(jitdata *jd)
 
 		case ICMD_INEG:       /* ..., value  ==> ..., - value                 */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); 
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1); 
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_ISUB(REG_ZERO, s1, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LNEG:       /* ..., value  ==> ..., - value                 */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_LSUB(REG_ZERO, s1, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_I2L:        /* ..., value  ==> ..., value                   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP1);
 			M_INTMOVE(s1, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_L2I:        /* ..., value  ==> ..., value                   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			M_IADD(s1, REG_ZERO, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_INT2BYTE:   /* ..., value  ==> ..., value                   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			if (has_ext_instr_set) {
 				M_BSEXT(s1, d);
 			} else {
 				M_SLL_IMM(s1, 56, d);
 				M_SRA_IMM( d, 56, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_INT2CHAR:   /* ..., value  ==> ..., value                   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
             M_CZEXT(s1, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_INT2SHORT:  /* ..., value  ==> ..., value                   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 			if (has_ext_instr_set) {
 				M_SSEXT(s1, d);
 			} else {
 				M_SLL_IMM(s1, 48, d);
 				M_SRA_IMM( d, 48, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 
 		case ICMD_IADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_IADD(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
+		case ICMD_IINC:
 		case ICMD_IADDCONST:  /* ..., value  ==> ..., value + constant        */
-		                      /* val.i = constant                             */
-
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_IADD_IMM(s1, iptr->val.i, d);
+		                      /* sx.val.i = constant                             */
+
+			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 <= 255)) {
+				M_IADD_IMM(s1, iptr->sx.val.i, d);
+			} else if ((iptr->sx.val.i > -256) && (iptr->sx.val.i < 0)) {
+				M_ISUB_IMM(s1, (-iptr->sx.val.i), d);
 			} else {
-				ICONST(REG_ITMP2, iptr->val.i);
+				/* XXX maybe use M_LDA? */
+				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_IADD(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LADDCONST:  /* ..., value  ==> ..., value + constant        */
-		                      /* val.l = constant                             */
+		                      /* sx.val.l = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
-				M_LADD_IMM(s1, iptr->val.l, d);
+			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 <= 255)) {
+				M_LADD_IMM(s1, iptr->sx.val.l, d);
 			} else {
-				LCONST(REG_ITMP2, iptr->val.l);
+				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_LADD(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_ISUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_ISUB(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_ISUBCONST:  /* ..., value  ==> ..., value + constant        */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_ISUB_IMM(s1, iptr->val.i, d);
+			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 <= 255)) {
+				M_ISUB_IMM(s1, iptr->sx.val.i, d);
 			} else {
-				ICONST(REG_ITMP2, iptr->val.i);
+				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_ISUB(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LSUBCONST:  /* ..., value  ==> ..., value - constant        */
-		                      /* val.l = constant                             */
+		                      /* sx.val.l = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
-				M_LSUB_IMM(s1, iptr->val.l, d);
+			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 <= 255)) {
+				M_LSUB_IMM(s1, iptr->sx.val.l, d);
 			} else {
-				LCONST(REG_ITMP2, iptr->val.l);
+				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_LSUB(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_IMUL(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IMULCONST:  /* ..., value  ==> ..., value * constant        */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_IMUL_IMM(s1, iptr->val.i, d);
+			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 <= 255)) {
+				M_IMUL_IMM(s1, iptr->sx.val.i, d);
 			} else {
-				ICONST(REG_ITMP2, iptr->val.i);
+				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_IMUL(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_LMUL(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LMULCONST:  /* ..., value  ==> ..., value * constant        */
-		                      /* val.l = constant                             */
+		                      /* sx.val.l = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
-				M_LMUL_IMM(s1, iptr->val.l, d);
+			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 <= 255)) {
+				M_LMUL_IMM(s1, iptr->sx.val.l, d);
 			} else {
-				LCONST(REG_ITMP2, iptr->val.l);
+				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_LMUL(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 		case ICMD_IREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT);
-			M_BEQZ(s2, 0);
-			codegen_add_arithmeticexception_ref(cd);
+			s1 = emit_load_s1(jd, iptr, REG_A0);
+			s2 = emit_load_s2(jd, iptr, REG_A1);
+			d = codegen_reg_of_dst(jd, iptr, REG_RESULT);
+			emit_arithmetic_check(cd, iptr, s2);
 
-			M_MOV(s1, rd->argintregs[0]);
-			M_MOV(s2, rd->argintregs[1]);
-			bte = iptr->val.a;
+			M_INTMOVE(s1, REG_A0);
+			M_INTMOVE(s2, REG_A1);
+			bte = iptr->sx.s23.s3.bte;
 			disp = dseg_add_functionptr(cd, bte->fp);
 			M_ALD(REG_PV, REG_PV, disp);
 			M_JSR(REG_RA, REG_PV);
@@ -912,21 +719,20 @@ bool codegen(jitdata *jd)
 			M_LDA(REG_PV, REG_RA, -disp);
 
 			M_IADD(REG_RESULT, REG_ZERO, d); /* sign extend (bugfix for gcc -O2) */
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 		case ICMD_LREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT);
-			M_BEQZ(s2, 0);
-			codegen_add_arithmeticexception_ref(cd);
+			s1 = emit_load_s1(jd, iptr, REG_A0);
+			s2 = emit_load_s2(jd, iptr, REG_A1);
+			d = codegen_reg_of_dst(jd, iptr, REG_RESULT);
+			emit_arithmetic_check(cd, iptr, s2);
 
-			M_MOV(s1, rd->argintregs[0]);
-			M_MOV(s2, rd->argintregs[1]);
-			bte = iptr->val.a;
+			M_INTMOVE(s1, REG_A0);
+			M_INTMOVE(s2, REG_A1);
+			bte = iptr->sx.s23.s3.bte;
 			disp = dseg_add_functionptr(cd, bte->fp);
 			M_ALD(REG_PV, REG_PV, disp);
 			M_JSR(REG_RA, REG_PV);
@@ -934,395 +740,373 @@ bool codegen(jitdata *jd)
 			M_LDA(REG_PV, REG_RA, -disp);
 
 			M_INTMOVE(REG_RESULT, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IDIVPOW2:   /* ..., value  ==> ..., value << constant       */
 		case ICMD_LDIVPOW2:   /* val.i = constant                             */
 		                      
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if (iptr->val.i <= 15) {
-				M_LDA(REG_ITMP2, s1, (1 << iptr->val.i) -1);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			if (iptr->sx.val.i <= 15) {
+				M_LDA(REG_ITMP2, s1, (1 << iptr->sx.val.i) -1);
 				M_CMOVGE(s1, s1, REG_ITMP2);
 			} else {
 				M_SRA_IMM(s1, 63, REG_ITMP2);
-				M_SRL_IMM(REG_ITMP2, 64 - iptr->val.i, REG_ITMP2);
+				M_SRL_IMM(REG_ITMP2, 64 - iptr->sx.val.i, REG_ITMP2);
 				M_LADD(s1, REG_ITMP2, REG_ITMP2);
 			}
-			M_SRA_IMM(REG_ITMP2, iptr->val.i, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			M_SRA_IMM(REG_ITMP2, iptr->sx.val.i, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_ISHL:       /* ..., val1, val2  ==> ..., val1 << val2       */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_AND_IMM(s2, 0x1f, REG_ITMP3);
 			M_SLL(s1, REG_ITMP3, d);
 			M_IADD(d, REG_ZERO, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_ISHLCONST:  /* ..., value  ==> ..., value << constant       */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			M_SLL_IMM(s1, iptr->val.i & 0x1f, d);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_SLL_IMM(s1, iptr->sx.val.i & 0x1f, d);
 			M_IADD(d, REG_ZERO, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_ISHR:       /* ..., val1, val2  ==> ..., val1 >> val2       */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_AND_IMM(s2, 0x1f, REG_ITMP3);
 			M_SRA(s1, REG_ITMP3, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_ISHRCONST:  /* ..., value  ==> ..., value >> constant       */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			M_SRA_IMM(s1, iptr->val.i & 0x1f, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_SRA_IMM(s1, iptr->sx.val.i & 0x1f, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IUSHR:      /* ..., val1, val2  ==> ..., val1 >>> val2      */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_AND_IMM(s2, 0x1f, REG_ITMP2);
             M_IZEXT(s1, d);
 			M_SRL(d, REG_ITMP2, d);
 			M_IADD(d, REG_ZERO, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IUSHRCONST: /* ..., value  ==> ..., value >>> constant      */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
             M_IZEXT(s1, d);
-			M_SRL_IMM(d, iptr->val.i & 0x1f, d);
+			M_SRL_IMM(d, iptr->sx.val.i & 0x1f, d);
 			M_IADD(d, REG_ZERO, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LSHL:       /* ..., val1, val2  ==> ..., val1 << val2       */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_SLL(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LSHLCONST:  /* ..., value  ==> ..., value << constant       */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			M_SLL_IMM(s1, iptr->val.i & 0x3f, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_SLL_IMM(s1, iptr->sx.val.i & 0x3f, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LSHR:       /* ..., val1, val2  ==> ..., val1 >> val2       */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_SRA(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LSHRCONST:  /* ..., value  ==> ..., value >> constant       */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			M_SRA_IMM(s1, iptr->val.i & 0x3f, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_SRA_IMM(s1, iptr->sx.val.i & 0x3f, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LUSHR:      /* ..., val1, val2  ==> ..., val1 >>> val2      */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_SRL(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LUSHRCONST: /* ..., value  ==> ..., value >>> constant      */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			M_SRL_IMM(s1, iptr->val.i & 0x3f, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			M_SRL_IMM(s1, iptr->sx.val.i & 0x3f, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IAND:       /* ..., val1, val2  ==> ..., val1 & val2        */
 		case ICMD_LAND:
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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_AND(s1, s2, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IANDCONST:  /* ..., value  ==> ..., value & constant        */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_AND_IMM(s1, iptr->val.i, d);
-			} else if (iptr->val.i == 0xffff) {
+			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 <= 255)) {
+				M_AND_IMM(s1, iptr->sx.val.i, d);
+			} else if (iptr->sx.val.i == 0xffff) {
 				M_CZEXT(s1, d);
-			} else if (iptr->val.i == 0xffffff) {
+			} else if (iptr->sx.val.i == 0xffffff) {
 				M_ZAPNOT_IMM(s1, 0x07, d);
 			} else {
-				ICONST(REG_ITMP2, iptr->val.i);
+				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_AND(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IREMPOW2:   /* ..., value  ==> ..., value % constant        */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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;
 			}
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_AND_IMM(s1, iptr->val.i, d);
+			if ((iptr->sx.val.i >= 0) && (iptr->sx.val.i <= 255)) {
+				M_AND_IMM(s1, iptr->sx.val.i, d);
 				M_BGEZ(s1, 3);
 				M_ISUB(REG_ZERO, s1, d);
-				M_AND_IMM(d, iptr->val.i, d);
-			} else if (iptr->val.i == 0xffff) {
+				M_AND_IMM(d, iptr->sx.val.i, d);
+			} else if (iptr->sx.val.i == 0xffff) {
 				M_CZEXT(s1, d);
 				M_BGEZ(s1, 3);
 				M_ISUB(REG_ZERO, s1, d);
 				M_CZEXT(d, d);
-			} else if (iptr->val.i == 0xffffff) {
+			} else if (iptr->sx.val.i == 0xffffff) {
 				M_ZAPNOT_IMM(s1, 0x07, d);
 				M_BGEZ(s1, 3);
 				M_ISUB(REG_ZERO, s1, d);
 				M_ZAPNOT_IMM(d, 0x07, d);
 			} else {
-				ICONST(REG_ITMP2, iptr->val.i);
+				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_AND(s1, REG_ITMP2, d);
 				M_BGEZ(s1, 3);
 				M_ISUB(REG_ZERO, s1, d);
 				M_AND(d, REG_ITMP2, d);
 			}
 			M_ISUB(REG_ZERO, d, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LANDCONST:  /* ..., value  ==> ..., value & constant        */
-		                      /* val.l = constant                             */
+		                      /* sx.val.l = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
-				M_AND_IMM(s1, iptr->val.l, d);
-			} else if (iptr->val.l == 0xffffL) {
+			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 <= 255)) {
+				M_AND_IMM(s1, iptr->sx.val.l, d);
+			} else if (iptr->sx.val.l == 0xffffL) {
 				M_CZEXT(s1, d);
-			} else if (iptr->val.l == 0xffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffL) {
 				M_ZAPNOT_IMM(s1, 0x07, d);
-			} else if (iptr->val.l == 0xffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffL) {
 				M_IZEXT(s1, d);
-			} else if (iptr->val.l == 0xffffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffffL) {
 				M_ZAPNOT_IMM(s1, 0x1f, d);
-			} else if (iptr->val.l == 0xffffffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffffffL) {
 				M_ZAPNOT_IMM(s1, 0x3f, d);
-			} else if (iptr->val.l == 0xffffffffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffffffffL) {
 				M_ZAPNOT_IMM(s1, 0x7f, d);
 			} else {
-				LCONST(REG_ITMP2, iptr->val.l);
+				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_AND(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LREMPOW2:   /* ..., value  ==> ..., value % constant        */
-		                      /* val.l = constant                             */
+		                      /* sx.val.l = constant                             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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;
 			}
-			if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
-				M_AND_IMM(s1, iptr->val.l, d);
+			if ((iptr->sx.val.l >= 0) && (iptr->sx.val.l <= 255)) {
+				M_AND_IMM(s1, iptr->sx.val.l, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
-				M_AND_IMM(d, iptr->val.l, d);
-			} else if (iptr->val.l == 0xffffL) {
+				M_AND_IMM(d, iptr->sx.val.l, d);
+			} else if (iptr->sx.val.l == 0xffffL) {
 				M_CZEXT(s1, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
 				M_CZEXT(d, d);
-			} else if (iptr->val.l == 0xffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffL) {
 				M_ZAPNOT_IMM(s1, 0x07, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
 				M_ZAPNOT_IMM(d, 0x07, d);
-			} else if (iptr->val.l == 0xffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffL) {
 				M_IZEXT(s1, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
 				M_IZEXT(d, d);
-			} else if (iptr->val.l == 0xffffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffffL) {
  				M_ZAPNOT_IMM(s1, 0x1f, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
 				M_ZAPNOT_IMM(d, 0x1f, d);
-			} else if (iptr->val.l == 0xffffffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffffffL) {
 				M_ZAPNOT_IMM(s1, 0x3f, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
 				M_ZAPNOT_IMM(d, 0x3f, d);
-			} else if (iptr->val.l == 0xffffffffffffffL) {
+			} else if (iptr->sx.val.l == 0xffffffffffffffL) {
 				M_ZAPNOT_IMM(s1, 0x7f, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
 				M_ZAPNOT_IMM(d, 0x7f, d);
 			} else {
-				LCONST(REG_ITMP2, iptr->val.l);
+				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_AND(s1, REG_ITMP2, d);
 				M_BGEZ(s1, 3);
 				M_LSUB(REG_ZERO, s1, d);
 				M_AND(d, REG_ITMP2, d);
 			}
 			M_LSUB(REG_ZERO, d, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IOR:        /* ..., val1, val2  ==> ..., val1 | val2        */
 		case ICMD_LOR:
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IORCONST:   /* ..., value  ==> ..., value | constant        */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                          */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_OR_IMM(s1, iptr->val.i, d);
+			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 <= 255)) {
+				M_OR_IMM(s1, iptr->sx.val.i, d);
 			} else {
-				ICONST(REG_ITMP2, iptr->val.i);
+				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_OR(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LORCONST:   /* ..., value  ==> ..., value | constant        */
-		                      /* val.l = constant                             */
+		                      /* sx.val.l = constant                          */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
-				M_OR_IMM(s1, iptr->val.l, d);
+			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 <= 255)) {
+				M_OR_IMM(s1, iptr->sx.val.l, d);
 			} else {
-				LCONST(REG_ITMP2, iptr->val.l);
+				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_OR(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IXOR:       /* ..., val1, val2  ==> ..., val1 ^ val2        */
 		case ICMD_LXOR:
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IXORCONST:  /* ..., value  ==> ..., value ^ constant        */
-		                      /* val.i = constant                             */
+		                      /* sx.val.i = constant                          */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_XOR_IMM(s1, iptr->val.i, d);
+			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 <= 255)) {
+				M_XOR_IMM(s1, iptr->sx.val.i, d);
 			} else {
-				ICONST(REG_ITMP2, iptr->val.i);
+				ICONST(REG_ITMP2, iptr->sx.val.i);
 				M_XOR(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LXORCONST:  /* ..., value  ==> ..., value ^ constant        */
-		                      /* val.l = constant                             */
+		                      /* sx.val.l = constant                          */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
-				M_XOR_IMM(s1, iptr->val.l, d);
+			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 <= 255)) {
+				M_XOR_IMM(s1, iptr->sx.val.l, d);
 			} else {
-				LCONST(REG_ITMP2, iptr->val.l);
+				LCONST(REG_ITMP2, iptr->sx.val.l);
 				M_XOR(s1, REG_ITMP2, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 
 		case ICMD_LCMP:       /* ..., val1, val2  ==> ..., val1 cmp val2      */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+			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);
-			emit_store(jd, iptr, iptr->dst, d);
-			break;
-
-
-		case ICMD_IINC:       /* ..., value  ==> ..., value + constant        */
-		                      /* op1 = variable, val.i = constant             */
-
-			var = &(rd->locals[iptr->op1][TYPE_INT]);
-			if (var->flags & INMEMORY) {
-				s1 = REG_ITMP1;
-				M_LLD(s1, REG_SP, var->regoff * 8);
-			} else
-				s1 = var->regoff;
-			if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
-				M_IADD_IMM(s1, iptr->val.i, s1);
-			} else if ((iptr->val.i > -256) && (iptr->val.i < 0)) {
-				M_ISUB_IMM(s1, (-iptr->val.i), s1);
-			} else {
-				M_LDA (s1, s1, iptr->val.i);
-				M_IADD(s1, REG_ZERO, s1);
-			}
-			if (var->flags & INMEMORY)
-				M_LST(s1, REG_SP, var->regoff * 8);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 
@@ -1330,25 +1114,25 @@ bool codegen(jitdata *jd)
 
 		case ICMD_FNEG:       /* ..., value  ==> ..., - value                 */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
 			M_FMOVN(s1, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_DNEG:       /* ..., value  ==> ..., - value                 */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
 			M_FMOVN(s1, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_FADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_FADD(s1, s2, d);
 			} else {
@@ -1361,14 +1145,14 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_DADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_DADD(s1, s2, d);
 			} else {
@@ -1381,14 +1165,14 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_FSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_FSUB(s1, s2, d);
 			} else {
@@ -1401,14 +1185,14 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_DSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_DSUB(s1, s2, d);
 			} else {
@@ -1421,14 +1205,14 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_FMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_FMUL(s1, s2, d);
 			} else {
@@ -1441,14 +1225,14 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_DMUL:       /* ..., val1, val2  ==> ..., val1 *** val2      */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_DMUL(s1, s2, d);
 			} else {
@@ -1461,14 +1245,14 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_FDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_FDIV(s1, s2, d);
 			} else {
@@ -1481,14 +1265,14 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_DDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_DDIV(s1, s2, d);
 			} else {
@@ -1501,81 +1285,81 @@ bool codegen(jitdata *jd)
 					M_TRAPB;
 				}
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 		
 		case ICMD_I2F:       /* ..., value  ==> ..., (float) value            */
 		case ICMD_L2F:
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			disp = dseg_add_unique_double(cd, 0.0);
 			M_LST(s1, REG_PV, disp);
 			M_DLD(d, REG_PV, disp);
 			M_CVTLF(d, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_I2D:       /* ..., value  ==> ..., (double) value           */
 		case ICMD_L2D:
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			disp = dseg_add_unique_double(cd, 0.0);
 			M_LST(s1, REG_PV, disp);
 			M_DLD(d, REG_PV, disp);
 			M_CVTLD(d, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 			
 		case ICMD_F2I:       /* ..., value  ==> ..., (int) value              */
 		case ICMD_D2I:
-			s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
 			disp = dseg_add_unique_double(cd, 0.0);
 			M_CVTDL_C(s1, REG_FTMP2);
 			M_CVTLI(REG_FTMP2, REG_FTMP3);
 			M_DST(REG_FTMP3, REG_PV, disp);
 			M_ILD(d, REG_PV, disp);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 		
 		case ICMD_F2L:       /* ..., value  ==> ..., (long) value             */
 		case ICMD_D2L:
-			s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
 			disp = dseg_add_unique_double(cd, 0.0);
 			M_CVTDL_C(s1, REG_FTMP2);
 			M_DST(REG_FTMP2, REG_PV, disp);
 			M_LLD(d, REG_PV, disp);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_F2D:       /* ..., value  ==> ..., (double) value           */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			M_CVTFDS(s1, d);
 			M_TRAPB;
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 					
 		case ICMD_D2F:       /* ..., value  ==> ..., (float) value            */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP3);
 			if (opt_noieee) {
 				M_CVTDF(s1, d);
 			} else {
 				M_CVTDFS(s1, d);
 				M_TRAPB;
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 		
 		case ICMD_FCMPL:      /* ..., val1, val2  ==> ..., val1 fcmpl val2    */
 		case ICMD_DCMPL:
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
 			if (opt_noieee) {
 				M_LSUB_IMM(REG_ZERO, 1, d);
 				M_FCMPEQ(s1, s2, REG_FTMP3);
@@ -1595,14 +1379,14 @@ bool codegen(jitdata *jd)
 				M_FBEQZ (REG_FTMP3, 1);        /* jump over next instruction  */
 				M_LADD_IMM(REG_ZERO, 1, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 			
 		case ICMD_FCMPG:      /* ..., val1, val2  ==> ..., val1 fcmpg val2    */
 		case ICMD_DCMPG:
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_FTMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_FTMP1);
+			s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP3);
 			if (opt_noieee) {
 				M_LADD_IMM(REG_ZERO, 1, d);
 				M_FCMPEQ(s1, s2, REG_FTMP3);
@@ -1622,7 +1406,7 @@ bool codegen(jitdata *jd)
 				M_FBEQZ (REG_FTMP3, 1);        /* jump over next instruction  */
 				M_LSUB_IMM(REG_ZERO, 1, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 
@@ -1630,171 +1414,156 @@ bool codegen(jitdata *jd)
 
 		case ICMD_ARRAYLENGTH: /* ..., arrayref  ==> ..., length              */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			gen_nullptr_check(s1);
-			M_ILD(d, s1, OFFSET(java_arrayheader, size));
-			emit_store(jd, iptr, iptr->dst, d);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			M_ILD(d, s1, OFFSET(java_array_t, size));
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_BALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			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);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			if (has_ext_instr_set) {
-				M_LADD   (s2, s1, REG_ITMP1);
-				M_BLDU   (d, REG_ITMP1, OFFSET (java_bytearray, data[0]));
-				M_BSEXT  (d, d);
-			} else {
 				M_LADD(s2, s1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray, data[0])+1);
+				M_BLDU(d, REG_ITMP1, OFFSET (java_bytearray_t, data[0]));
+				M_BSEXT(d, d);
+			}
+			else {
+				M_LADD(s2, s1, REG_ITMP1);
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray_t, data[0])+1);
 				M_EXTQH(REG_ITMP2, REG_ITMP1, d);
 				M_SRA_IMM(d, 56, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_CALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			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);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_SLDU(d, REG_ITMP1, OFFSET(java_chararray, data[0]));
-			} else {
+				M_SLDU(d, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
+			}
+			else {
 				M_LADD (s2, s1, REG_ITMP1);
 				M_LADD (s2, REG_ITMP1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray, data[0]));
-				M_LDA  (REG_ITMP1, REG_ITMP1, OFFSET(java_chararray, data[0]));
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
+				M_LDA  (REG_ITMP1, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
 				M_EXTWL(REG_ITMP2, REG_ITMP1, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;			
 
 		case ICMD_SALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			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);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_SLDU( d, REG_ITMP1, OFFSET (java_shortarray, data[0]));
+				M_SLDU( d, REG_ITMP1, OFFSET (java_shortarray_t, data[0]));
 				M_SSEXT(d, d);
 			} else {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray, data[0])+2);
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray_t, data[0])+2);
 				M_EXTQH(REG_ITMP2, REG_ITMP1, d);
 				M_SRA_IMM(d, 48, d);
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_IALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			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);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_S4ADDQ(s2, s1, REG_ITMP1);
-			M_ILD(d, REG_ITMP1, OFFSET(java_intarray, data[0]));
-			emit_store(jd, iptr, iptr->dst, d);
+			M_ILD(d, REG_ITMP1, OFFSET(java_intarray_t, data[0]));
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_LALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			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);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_S8ADDQ(s2, s1, REG_ITMP1);
-			M_LLD(d, REG_ITMP1, OFFSET(java_longarray, data[0]));
-			emit_store(jd, iptr, iptr->dst, d);
+			M_LLD(d, REG_ITMP1, OFFSET(java_longarray_t, data[0]));
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_FALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_S4ADDQ(s2, s1, REG_ITMP1);
-			M_FLD(d, REG_ITMP1, OFFSET(java_floatarray, data[0]));
-			emit_store(jd, iptr, iptr->dst, d);
+			M_FLD(d, REG_ITMP1, OFFSET(java_floatarray_t, data[0]));
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_DALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			d = codegen_reg_of_dst(jd, iptr, REG_FTMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_S8ADDQ(s2, s1, REG_ITMP1);
-			M_DLD(d, REG_ITMP1, OFFSET(java_doublearray, data[0]));
-			emit_store(jd, iptr, iptr->dst, d);
+			M_DLD(d, REG_ITMP1, OFFSET(java_doublearray_t, data[0]));
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_AALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			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);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			M_SAADDQ(s2, s1, REG_ITMP1);
-			M_ALD(d, REG_ITMP1, OFFSET(java_objectarray, data[0]));
-			emit_store(jd, iptr, iptr->dst, d);
+			M_ALD(d, REG_ITMP1, OFFSET(java_objectarray_t, data[0]));
+			emit_store_dst(jd, iptr, d);
 			break;
 
 
 		case ICMD_BASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
-				M_BST(s3, REG_ITMP1, OFFSET(java_bytearray, data[0]));
-			} else {
+				M_BST(s3, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
+			}
+			else {
 				M_LADD(s2, s1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray, data[0]));
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
 				M_INSBL(s3, REG_ITMP1, REG_ITMP3);
 				M_MSKBL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
 				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP2);
@@ -1804,22 +1573,21 @@ bool codegen(jitdata *jd)
 
 		case ICMD_CASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_SST(s3, REG_ITMP1, OFFSET(java_chararray, data[0]));
-			} else {
+				M_SST(s3, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
+			}
+			else {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_chararray, data[0]));
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
 				M_INSWL(s3, REG_ITMP1, REG_ITMP3);
 				M_MSKWL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
 				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP2);
@@ -1829,22 +1597,21 @@ bool codegen(jitdata *jd)
 
 		case ICMD_SASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_SST(s3, REG_ITMP1, OFFSET(java_shortarray, data[0]));
-			} else {
+				M_SST(s3, REG_ITMP1, OFFSET(java_shortarray_t, data[0]));
+			}
+			else {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray, data[0]));
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray_t, data[0]));
 				M_INSWL(s3, REG_ITMP1, REG_ITMP3);
 				M_MSKWL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
 				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP2);
@@ -1854,137 +1621,88 @@ bool codegen(jitdata *jd)
 
 		case ICMD_IASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
 			M_S4ADDQ(s2, s1, REG_ITMP1);
-			M_IST(s3, REG_ITMP1, OFFSET(java_intarray, data[0]));
+			M_IST(s3, REG_ITMP1, OFFSET(java_intarray_t, data[0]));
 			break;
 
 		case ICMD_LASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
 			M_S8ADDQ(s2, s1, REG_ITMP1);
-			M_LST(s3, REG_ITMP1, OFFSET(java_longarray, data[0]));
+			M_LST(s3, REG_ITMP1, OFFSET(java_longarray_t, data[0]));
 			break;
 
 		case ICMD_FASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_FTMP3);
 			M_S4ADDQ(s2, s1, REG_ITMP1);
-			M_FST(s3, REG_ITMP1, OFFSET(java_floatarray, data[0]));
+			M_FST(s3, REG_ITMP1, OFFSET(java_floatarray_t, data[0]));
 			break;
 
 		case ICMD_DASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_FTMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_FTMP3);
 			M_S8ADDQ(s2, s1, REG_ITMP1);
-			M_DST(s3, REG_ITMP1, OFFSET(java_doublearray, data[0]));
+			M_DST(s3, REG_ITMP1, OFFSET(java_doublearray_t, data[0]));
 			break;
 
 		case ICMD_AASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_A0);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			s3 = emit_load_s3(jd, iptr, REG_A1);
+
+			M_INTMOVE(s1, REG_A0);
+			M_INTMOVE(s3, REG_A1);
 
-			M_MOV(s1, rd->argintregs[0]);
-			M_MOV(s3, rd->argintregs[1]);
 			disp = dseg_add_functionptr(cd, BUILTIN_canstore);
 			M_ALD(REG_PV, REG_PV, disp);
 			M_JSR(REG_RA, REG_PV);
 			disp = (s4) (cd->mcodeptr - cd->mcodebase);
 			M_LDA(REG_PV, REG_RA, -disp);
+			emit_exception_check(cd, iptr);
 
-			M_BEQZ(REG_RESULT, 0);
-			codegen_add_arraystoreexception_ref(cd);
-
-			s1 = emit_load_s1(jd, iptr, src->prev->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src->prev, REG_ITMP2);
-			s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			s3 = emit_load_s3(jd, iptr, REG_ITMP3);
 			M_SAADDQ(s2, s1, REG_ITMP1);
-			M_AST(s3, REG_ITMP1, OFFSET(java_objectarray, data[0]));
-			break;
-
-
-		case ICMD_IASTORECONST:   /* ..., arrayref, index  ==> ...            */
-
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			M_S4ADDQ(s2, s1, REG_ITMP1);
-			M_IST(REG_ZERO, REG_ITMP1, OFFSET(java_intarray, data[0]));
-			break;
-
-		case ICMD_LASTORECONST:   /* ..., arrayref, index  ==> ...            */
-
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			M_S8ADDQ(s2, s1, REG_ITMP1);
-			M_LST(REG_ZERO, REG_ITMP1, OFFSET(java_longarray, data[0]));
+			M_AST(s3, REG_ITMP1, OFFSET(java_objectarray_t, data[0]));
 			break;
 
-		case ICMD_AASTORECONST:   /* ..., arrayref, index  ==> ...            */
-
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
-			M_SAADDQ(s2, s1, REG_ITMP1);
-			M_AST(REG_ZERO, REG_ITMP1, OFFSET(java_objectarray, data[0]));
-			break;
 
 		case ICMD_BASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
-				M_BST(REG_ZERO, REG_ITMP1, OFFSET(java_bytearray, data[0]));
-
-			} else {
+				M_BST(REG_ZERO, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
+			}
+			else {
 				M_LADD(s2, s1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray, data[0]));
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray_t, data[0]));
 				M_INSBL(REG_ZERO, REG_ITMP1, REG_ITMP3);
 				M_MSKBL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
 				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP2);
@@ -1994,22 +1712,20 @@ bool codegen(jitdata *jd)
 
 		case ICMD_CASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_SST(REG_ZERO, REG_ITMP1, OFFSET(java_chararray, data[0]));
-
-			} else {
+				M_SST(REG_ZERO, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
+			}
+			else {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_chararray, data[0]));
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_chararray_t, data[0]));
 				M_INSWL(REG_ZERO, REG_ITMP1, REG_ITMP3);
 				M_MSKWL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
 				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP2);
@@ -2019,22 +1735,20 @@ bool codegen(jitdata *jd)
 
 		case ICMD_SASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			if (iptr->op1 == 0) {
-				gen_nullptr_check(s1);
-				gen_bound_check;
-			}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
 			if (has_ext_instr_set) {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_SST(REG_ZERO, REG_ITMP1, OFFSET(java_shortarray, data[0]));
-
-			} else {
+				M_SST(REG_ZERO, REG_ITMP1, OFFSET(java_shortarray_t, data[0]));
+			}
+			else {
 				M_LADD(s2, s1, REG_ITMP1);
 				M_LADD(s2, REG_ITMP1, REG_ITMP1);
-				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray, data[0]));
-				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray, data[0]));
+				M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray_t, data[0]));
+				M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray_t, data[0]));
 				M_INSWL(REG_ZERO, REG_ITMP1, REG_ITMP3);
 				M_MSKWL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
 				M_OR(REG_ITMP2, REG_ITMP3, REG_ITMP2);
@@ -2042,140 +1756,149 @@ bool codegen(jitdata *jd)
 			}
 			break;
 
+		case ICMD_IASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-		case ICMD_GETSTATIC:  /* ...  ==> ..., value                          */
-		                      /* op1 = type, val.a = field address            */
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			M_S4ADDQ(s2, s1, REG_ITMP1);
+			M_IST(REG_ZERO, REG_ITMP1, OFFSET(java_intarray_t, data[0]));
+			break;
 
-			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr);
+		case ICMD_LASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-				disp = dseg_add_unique_address(cd, uf);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			M_S8ADDQ(s2, s1, REG_ITMP1);
+			M_LST(REG_ZERO, REG_ITMP1, OFFSET(java_longarray_t, data[0]));
+			break;
 
-				codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
+		case ICMD_AASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-				if (opt_showdisassemble)
-					M_NOP;
-			}
-			else {
-				fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			/* implicit null-pointer check */
+			emit_arrayindexoutofbounds_check(cd, iptr, s1, s2);
+			M_SAADDQ(s2, s1, REG_ITMP1);
+			M_AST(REG_ZERO, REG_ITMP1, OFFSET(java_objectarray_t, data[0]));
+			break;
 
-				disp = dseg_add_address(cd, &(fi->value));
 
-				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
-					codegen_addpatchref(cd, PATCHER_clinit, fi->class, 0);
+		case ICMD_GETSTATIC:  /* ...  ==> ..., value                          */
 
-					if (opt_showdisassemble)
-						M_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);
+
+				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))
+					patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->class,
+										  0);
   			}
 
 			M_ALD(REG_ITMP1, REG_PV, disp);
-			switch (iptr->op1) {
+			switch (fieldtype) {
 			case TYPE_INT:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 				M_ILD(d, REG_ITMP1, 0);
 				break;
 			case TYPE_LNG:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 				M_LLD(d, REG_ITMP1, 0);
 				break;
 			case TYPE_ADR:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 				M_ALD(d, REG_ITMP1, 0);
 				break;
 			case TYPE_FLT:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
+				d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
 				M_FLD(d, REG_ITMP1, 0);
 				break;
 			case TYPE_DBL:				
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
+				d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
 				M_DLD(d, REG_ITMP1, 0);
 				break;
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_PUTSTATIC:  /* ..., value  ==> ...                          */
-		                      /* op1 = type, val.a = field address            */
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr);
-
-				disp = dseg_add_unique_address(cd, uf);
+				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;
+				patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, disp);
 			}
 			else {
-				fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
-
-				disp = dseg_add_address(cd, &(fi->value));
+				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, 0);
-
-					if (opt_showdisassemble)
-						M_NOP;
-				}
+				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
+					patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->class,
+										  0);
   			}
 
 			M_ALD(REG_ITMP1, REG_PV, disp);
-			switch (iptr->op1) {
+			switch (fieldtype) {
 			case TYPE_INT:
-				s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-				M_IST(s2, REG_ITMP1, 0);
+				s1 = emit_load_s1(jd, iptr, REG_ITMP2);
+				M_IST(s1, REG_ITMP1, 0);
 				break;
 			case TYPE_LNG:
-				s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-				M_LST(s2, REG_ITMP1, 0);
+				s1 = emit_load_s1(jd, iptr, REG_ITMP2);
+				M_LST(s1, REG_ITMP1, 0);
 				break;
 			case TYPE_ADR:
-				s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-				M_AST(s2, REG_ITMP1, 0);
+				s1 = emit_load_s1(jd, iptr, REG_ITMP2);
+				M_AST(s1, REG_ITMP1, 0);
 				break;
 			case TYPE_FLT:
-				s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-				M_FST(s2, REG_ITMP1, 0);
+				s1 = emit_load_s1(jd, iptr, REG_FTMP2);
+				M_FST(s1, REG_ITMP1, 0);
 				break;
 			case TYPE_DBL:
-				s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-				M_DST(s2, REG_ITMP1, 0);
+				s1 = emit_load_s1(jd, iptr, REG_FTMP2);
+				M_DST(s1, REG_ITMP1, 0);
 				break;
 			}
 			break;
 
 		case ICMD_PUTSTATICCONST: /* ...  ==> ...                             */
 		                          /* val = value (in current instruction)     */
-		                          /* op1 = type, val.a = field address (in    */
 		                          /* following NOP)                           */
 
-			if (INSTRUCTION_IS_UNRESOLVED(iptr + 1)) {
-				unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr + 1);
-
-				disp = dseg_add_unique_address(cd, uf);
-
-				codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
+			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+				uf        = iptr->sx.s23.s3.uf;
+				fieldtype = uf->fieldref->parseddesc.fd->type;
+				disp      = dseg_add_unique_address(cd, uf);
 
-				if (opt_showdisassemble)
-					M_NOP;
+				patcher_add_patch_ref(jd, PATCHER_get_putstatic, uf, disp);
 			}
 			else {
-				fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr + 1);
-	
-				disp = dseg_add_address(cd, &(fi->value));
+				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, 0);
-
-					if (opt_showdisassemble)
-						M_NOP;
-				}
+				if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class))
+					patcher_add_patch_ref(jd, PATCHER_initialize_class, fi->class,
+										  0);
   			}
 			
 			M_ALD(REG_ITMP1, REG_PV, disp);
-			switch (iptr->op1) {
+			switch (fieldtype) {
 			case TYPE_INT:
 				M_IST(REG_ZERO, REG_ITMP1, 0);
 				break;
@@ -2196,79 +1919,74 @@ bool codegen(jitdata *jd)
 
 
 		case ICMD_GETFIELD:   /* ...  ==> ..., value                          */
-		                      /* op1 = type, val.i = field offset             */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			gen_nullptr_check(s1);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(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;
-
-				disp = 0;
+				patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
 			}
 			else {
-				fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
-				disp = fi->offset;
+				fi        = iptr->sx.s23.s3.fmiref->p.field;
+				fieldtype = fi->type;
+				disp      = fi->offset;
 			}
 
-			switch (iptr->op1) {
+			/* implicit null-pointer check */
+			switch (fieldtype) {
 			case TYPE_INT:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 				M_ILD(d, s1, disp);
 				break;
 			case TYPE_LNG:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 				M_LLD(d, s1, disp);
 				break;
 			case TYPE_ADR:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+				d = codegen_reg_of_dst(jd, iptr, REG_ITMP2);
 				M_ALD(d, s1, disp);
 				break;
 			case TYPE_FLT:
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
+				d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
 				M_FLD(d, s1, disp);
 				break;
 			case TYPE_DBL:				
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
+				d = codegen_reg_of_dst(jd, iptr, REG_FTMP1);
 				M_DLD(d, s1, disp);
 				break;
 			}
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_PUTFIELD:   /* ..., objectref, value  ==> ...               */
-		                      /* op1 = type, val.a = field address            */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			gen_nullptr_check(s1);
-
-			if (!IS_FLT_DBL_TYPE(iptr->op1)) {
-				s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
-			} else {
-				s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
-			}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr);
-
-				codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
-
-				if (opt_showdisassemble)
-					M_NOP;
-
-				disp = 0;
+				uf        = iptr->sx.s23.s3.uf;
+				fieldtype = uf->fieldref->parseddesc.fd->type;
+				disp      = 0;
 			}
 			else {
-				fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
-				disp = fi->offset;
+				uf        = NULL;
+				fi        = iptr->sx.s23.s3.fmiref->p.field;
+				fieldtype = fi->type;
+				disp      = fi->offset;
 			}
 
-			switch (iptr->op1) {
+			if (IS_INT_LNG_TYPE(fieldtype))
+				s2 = emit_load_s2(jd, iptr, REG_ITMP2);
+			else
+				s2 = emit_load_s2(jd, iptr, REG_FTMP2);
+
+			if (INSTRUCTION_IS_UNRESOLVED(iptr))
+				patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
+
+			/* implicit null-pointer check */
+			switch (fieldtype) {
 			case TYPE_INT:
 				M_IST(s2, s1, disp);
 				break;
@@ -2289,28 +2007,25 @@ bool codegen(jitdata *jd)
 
 		case ICMD_PUTFIELDCONST:  /* ..., objectref  ==> ...                  */
 		                          /* val = value (in current instruction)     */
-		                          /* op1 = type, val.a = field address (in    */
 		                          /* following NOP)                           */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			gen_nullptr_check(s1);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 
-			if (INSTRUCTION_IS_UNRESOLVED(iptr + 1)) {
-				unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr + 1);
+			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;
-
-				disp = 0;
+				patcher_add_patch_ref(jd, PATCHER_get_putfield, uf, 0);
 			}
 			else {
-				fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr + 1);
-				disp = fi->offset;
+				fi        = iptr->sx.s23.s3.fmiref->p.field;
+				fieldtype = fi->type;
+				disp      = fi->offset;
 			}
 
-			switch (iptr[1].op1) {
+			/* implicit null-pointer check */
+			switch (fieldtype) {
 			case TYPE_INT:
 				M_IST(REG_ZERO, s1, disp);
 				break;
@@ -2334,17 +2049,14 @@ bool codegen(jitdata *jd)
 
 		case ICMD_ATHROW:       /* ..., objectref ==> ... (, objectref)       */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			M_INTMOVE(s1, REG_ITMP1_XPTR);
 
 #ifdef ENABLE_VERIFIER
-			if (iptr->val.a) {
-				unresolved_class *uc = INSTRUCTION_UNRESOLVED_CLASS(iptr);
-
-				codegen_addpatchref(cd, PATCHER_athrow_areturn, uc, 0);
+			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+				unresolved_class *uc = iptr->sx.s23.s2.uc;
 
-				if (opt_showdisassemble)
-					M_NOP;
+				patcher_add_patch_ref(jd, PATCHER_resolve_class, uc, 0);
 			}
 #endif /* ENABLE_VERIFIER */
 
@@ -2357,371 +2069,293 @@ bool codegen(jitdata *jd)
 			break;
 
 		case ICMD_GOTO:         /* ... ==> ...                                */
-		                        /* op1 = target JavaVM pc                     */
-			M_BR(0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
+		case ICMD_RET:          /* ... ==> ...                                */
+
+			emit_br(cd, iptr->dst.block);
 			ALIGNCODENOP;
 			break;
 
 		case ICMD_JSR:          /* ... ==> ...                                */
-		                        /* op1 = target JavaVM pc                     */
-
-			M_BSR(REG_ITMP1, 0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
-			break;
-			
-		case ICMD_RET:          /* ... ==> ...                                */
-		                        /* op1 = local variable                       */
 
-			var = &(rd->locals[iptr->op1][TYPE_ADR]);
-			if (var->flags & INMEMORY) {
-				M_ALD(REG_ITMP1, REG_SP, 8 * var->regoff);
-				M_RET(REG_ZERO, REG_ITMP1);
-				}
-			else
-				M_RET(REG_ZERO, var->regoff);
+			emit_br(cd, iptr->sx.s23.s3.jsrtarget.block);
 			ALIGNCODENOP;
 			break;
-
+			
 		case ICMD_IFNULL:       /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc                     */
-
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			M_BEQZ(s1, 0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
-			break;
-
-		case ICMD_IFNONNULL:    /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc                     */
+		case ICMD_IFNONNULL:
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			M_BNEZ(s1, 0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			emit_bccz(cd, iptr->dst.block, iptr->opc - ICMD_IFNULL, s1, BRANCH_OPT_NONE);
 			break;
 
 		case ICMD_IFEQ:         /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.i = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.i == 0) {
-				M_BEQZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.i == 0)
+				emit_beqz(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
-					M_CMPEQ_IMM(s1, iptr->val.i, REG_ITMP1);
-					}
+				if ((iptr->sx.val.i > 0) && (iptr->sx.val.i <= 255))
+					M_CMPEQ_IMM(s1, iptr->sx.val.i, REG_ITMP1);
 				else {
-					ICONST(REG_ITMP2, iptr->val.i);
+					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BNEZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IFLT:         /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.i = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.i == 0) {
-				M_BLTZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.i == 0)
+				emit_bltz(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
-					M_CMPLT_IMM(s1, iptr->val.i, REG_ITMP1);
-					}
+				if ((iptr->sx.val.i > 0) && (iptr->sx.val.i <= 255))
+					M_CMPLT_IMM(s1, iptr->sx.val.i, REG_ITMP1);
 				else {
-					ICONST(REG_ITMP2, iptr->val.i);
+					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BNEZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IFLE:         /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.i = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.i == 0) {
-				M_BLEZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.i == 0)
+				emit_blez(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
-					M_CMPLE_IMM(s1, iptr->val.i, REG_ITMP1);
-					}
+				if ((iptr->sx.val.i > 0) && (iptr->sx.val.i <= 255))
+					M_CMPLE_IMM(s1, iptr->sx.val.i, REG_ITMP1);
 				else {
-					ICONST(REG_ITMP2, iptr->val.i);
+					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BNEZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IFNE:         /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.i = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.i == 0) {
-				M_BNEZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.i == 0)
+				emit_bnez(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
-					M_CMPEQ_IMM(s1, iptr->val.i, REG_ITMP1);
-					}
+				if ((iptr->sx.val.i > 0) && (iptr->sx.val.i <= 255))
+					M_CMPEQ_IMM(s1, iptr->sx.val.i, REG_ITMP1);
 				else {
-					ICONST(REG_ITMP2, iptr->val.i);
+					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IFGT:         /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.i = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.i == 0) {
-				M_BGTZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.i == 0)
+				emit_bgtz(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
-					M_CMPLE_IMM(s1, iptr->val.i, REG_ITMP1);
-					}
+				if ((iptr->sx.val.i > 0) && (iptr->sx.val.i <= 255))
+					M_CMPLE_IMM(s1, iptr->sx.val.i, REG_ITMP1);
 				else {
-					ICONST(REG_ITMP2, iptr->val.i);
+					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IFGE:         /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.i = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.i == 0) {
-				M_BGEZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.i == 0)
+				emit_bgez(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
-					M_CMPLT_IMM(s1, iptr->val.i, REG_ITMP1);
-					}
+				if ((iptr->sx.val.i > 0) && (iptr->sx.val.i <= 255))
+					M_CMPLT_IMM(s1, iptr->sx.val.i, REG_ITMP1);
 				else {
-					ICONST(REG_ITMP2, iptr->val.i);
+					ICONST(REG_ITMP2, iptr->sx.val.i);
 					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_LEQ:       /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.l = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.l == 0) {
-				M_BEQZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.l == 0)
+				emit_beqz(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
-					M_CMPEQ_IMM(s1, iptr->val.l, REG_ITMP1);
-					}
+				if ((iptr->sx.val.l > 0) && (iptr->sx.val.l <= 255))
+					M_CMPEQ_IMM(s1, iptr->sx.val.l, REG_ITMP1);
 				else {
-					LCONST(REG_ITMP2, iptr->val.l);
+					LCONST(REG_ITMP2, iptr->sx.val.l);
 					M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BNEZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_LLT:       /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.l = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.l == 0) {
-				M_BLTZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.l == 0)
+				emit_bltz(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
-					M_CMPLT_IMM(s1, iptr->val.l, REG_ITMP1);
-					}
+				if ((iptr->sx.val.l > 0) && (iptr->sx.val.l <= 255))
+					M_CMPLT_IMM(s1, iptr->sx.val.l, REG_ITMP1);
 				else {
-					LCONST(REG_ITMP2, iptr->val.l);
+					LCONST(REG_ITMP2, iptr->sx.val.l);
 					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BNEZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_LLE:       /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.l = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.l == 0) {
-				M_BLEZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.l == 0)
+				emit_blez(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
-					M_CMPLE_IMM(s1, iptr->val.l, REG_ITMP1);
-					}
+				if ((iptr->sx.val.l > 0) && (iptr->sx.val.l <= 255))
+					M_CMPLE_IMM(s1, iptr->sx.val.l, REG_ITMP1);
 				else {
-					LCONST(REG_ITMP2, iptr->val.l);
+					LCONST(REG_ITMP2, iptr->sx.val.l);
 					M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BNEZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_bnez(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_LNE:       /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.l = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.l == 0) {
-				M_BNEZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.l == 0)
+				emit_bnez(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
-					M_CMPEQ_IMM(s1, iptr->val.l, REG_ITMP1);
-					}
+				if ((iptr->sx.val.l > 0) && (iptr->sx.val.l <= 255))
+					M_CMPEQ_IMM(s1, iptr->sx.val.l, REG_ITMP1);
 				else {
-					LCONST(REG_ITMP2, iptr->val.l);
+					LCONST(REG_ITMP2, iptr->sx.val.l);
 					M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_LGT:       /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.l = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.l == 0) {
-				M_BGTZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.l == 0)
+				emit_bgtz(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
-					M_CMPLE_IMM(s1, iptr->val.l, REG_ITMP1);
-					}
+				if ((iptr->sx.val.l > 0) && (iptr->sx.val.l <= 255))
+					M_CMPLE_IMM(s1, iptr->sx.val.l, REG_ITMP1);
 				else {
-					LCONST(REG_ITMP2, iptr->val.l);
+					LCONST(REG_ITMP2, iptr->sx.val.l);
 					M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_LGE:       /* ..., value ==> ...                         */
-		                        /* op1 = target JavaVM pc, val.l = constant   */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			if (iptr->val.l == 0) {
-				M_BGEZ(s1, 0);
-				}
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			if (iptr->sx.val.l == 0)
+				emit_bgez(cd, iptr->dst.block, s1);
 			else {
-				if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
-					M_CMPLT_IMM(s1, iptr->val.l, REG_ITMP1);
-					}
+				if ((iptr->sx.val.l > 0) && (iptr->sx.val.l <= 255))
+					M_CMPLT_IMM(s1, iptr->sx.val.l, REG_ITMP1);
 				else {
-					LCONST(REG_ITMP2, iptr->val.l);
+					LCONST(REG_ITMP2, iptr->sx.val.l);
 					M_CMPLT(s1, REG_ITMP2, REG_ITMP1);
-					}
-				M_BEQZ(REG_ITMP1, 0);
 				}
-			codegen_addreference(cd, (basicblock *) iptr->target);
+				emit_beqz(cd, iptr->dst.block, REG_ITMP1);
+			}
 			break;
 
 		case ICMD_IF_ICMPEQ:    /* ..., value, value ==> ...                  */
 		case ICMD_IF_LCMPEQ:    /* op1 = target JavaVM pc                     */
 		case ICMD_IF_ACMPEQ:
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			M_CMPEQ(s1, s2, REG_ITMP1);
-			M_BNEZ(REG_ITMP1, 0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP1);
 			break;
 
 		case ICMD_IF_ICMPNE:    /* ..., value, value ==> ...                  */
 		case ICMD_IF_LCMPNE:    /* op1 = target JavaVM pc                     */
 		case ICMD_IF_ACMPNE:
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			M_CMPEQ(s1, s2, REG_ITMP1);
-			M_BEQZ(REG_ITMP1, 0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
+			emit_beqz(cd, iptr->dst.block, REG_ITMP1);
 			break;
 
 		case ICMD_IF_ICMPLT:    /* ..., value, value ==> ...                  */
 		case ICMD_IF_LCMPLT:    /* op1 = target JavaVM pc                     */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
+			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, (basicblock *) iptr->target);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP1);
 			break;
 
 		case ICMD_IF_ICMPGT:    /* ..., value, value ==> ...                  */
 		case ICMD_IF_LCMPGT:    /* op1 = target JavaVM pc                     */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			M_CMPLE(s1, s2, REG_ITMP1);
-			M_BEQZ(REG_ITMP1, 0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
+			emit_beqz(cd, iptr->dst.block, REG_ITMP1);
 			break;
 
 		case ICMD_IF_ICMPLE:    /* ..., value, value ==> ...                  */
 		case ICMD_IF_LCMPLE:    /* op1 = target JavaVM pc                     */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+			s2 = emit_load_s2(jd, iptr, REG_ITMP2);
 			M_CMPLE(s1, s2, REG_ITMP1);
-			M_BNEZ(REG_ITMP1, 0);
-			codegen_addreference(cd, (basicblock *) iptr->target);
+			emit_bnez(cd, iptr->dst.block, REG_ITMP1);
 			break;
 
 		case ICMD_IF_ICMPGE:    /* ..., value, value ==> ...                  */
 		case ICMD_IF_LCMPGE:    /* op1 = target JavaVM pc                     */
 
-			s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
-			s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
+			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, (basicblock *) iptr->target);
+			emit_beqz(cd, iptr->dst.block, REG_ITMP1);
 			break;
 
 
 		case ICMD_IRETURN:      /* ..., retvalue ==> ...                      */
 		case ICMD_LRETURN:
 
-			s1 = emit_load_s1(jd, iptr, src, REG_RESULT);
+			REPLACEMENT_POINT_RETURN(cd, iptr);
+			s1 = emit_load_s1(jd, iptr, REG_RESULT);
 			M_INTMOVE(s1, REG_RESULT);
 			goto nowperformreturn;
 
 		case ICMD_ARETURN:      /* ..., retvalue ==> ...                      */
 
-			s1 = emit_load_s1(jd, iptr, src, REG_RESULT);
+			REPLACEMENT_POINT_RETURN(cd, iptr);
+			s1 = emit_load_s1(jd, iptr, REG_RESULT);
 			M_INTMOVE(s1, REG_RESULT);
 
 #ifdef ENABLE_VERIFIER
-			if (iptr->val.a) {
-				unresolved_class *uc = INSTRUCTION_UNRESOLVED_CLASS(iptr);
-
-				codegen_addpatchref(cd, PATCHER_athrow_areturn, uc, 0);
+			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+				unresolved_class *uc = iptr->sx.s23.s2.uc;
 
-				if (opt_showdisassemble)
-					M_NOP;
+				patcher_add_patch_ref(jd, PATCHER_resolve_class, uc, 0);
 			}
 #endif /* ENABLE_VERIFIER */
 			goto nowperformreturn;
@@ -2729,49 +2363,31 @@ bool codegen(jitdata *jd)
 		case ICMD_FRETURN:      /* ..., retvalue ==> ...                      */
 		case ICMD_DRETURN:
 
-			s1 = emit_load_s1(jd, iptr, src, REG_FRESULT);
+			REPLACEMENT_POINT_RETURN(cd, iptr);
+			s1 = emit_load_s1(jd, iptr, REG_FRESULT);
 			M_FLTMOVE(s1, REG_FRESULT);
 			goto nowperformreturn;
 
 		case ICMD_RETURN:       /* ...  ==> ...                               */
 
+			REPLACEMENT_POINT_RETURN(cd, iptr);
+
 nowperformreturn:
 			{
 			s4 i, p;
 			
-			p = jd->stackframesize;
+			p = cd->stackframesize;
 			
 			/* call trace function */
 
 #if !defined(NDEBUG)
-			if (opt_verbosecall) {
-				M_LDA(REG_SP, REG_SP, -3 * 8);
-				M_AST(REG_RA, REG_SP, 0 * 8);
-				M_LST(REG_RESULT, REG_SP, 1 * 8);
-				M_DST(REG_FRESULT, REG_SP, 2 * 8);
-
-				disp = dseg_add_address(cd, m);
-				M_ALD(rd->argintregs[0], REG_PV, disp);
-				M_MOV(REG_RESULT, rd->argintregs[1]);
-				M_FLTMOVE(REG_FRESULT, rd->argfltregs[2]);
-				M_FLTMOVE(REG_FRESULT, rd->argfltregs[3]);
-
-				disp = dseg_add_functionptr(cd, builtin_displaymethodstop);
-				M_ALD(REG_PV, REG_PV, disp);
-				M_JSR(REG_RA, REG_PV);
-				disp = (s4) (cd->mcodeptr - cd->mcodebase);
-				M_LDA(REG_PV, REG_RA, -disp);
-
-				M_DLD(REG_FRESULT, REG_SP, 2 * 8);
-				M_LLD(REG_RESULT, REG_SP, 1 * 8);
-				M_ALD(REG_RA, REG_SP, 0 * 8);
-				M_LDA(REG_SP, REG_SP, 3 * 8);
-			}
+			if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
+				emit_verbosecall_exit(jd);
 #endif
 
 #if defined(ENABLE_THREADS)
 			if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
-				M_ALD(rd->argintregs[0], REG_SP, rd->memuse * 8);
+				M_ALD(REG_A0, REG_SP, rd->memuse * 8);
 
 				switch (iptr->opc) {
 				case ICMD_IRETURN:
@@ -2822,8 +2438,8 @@ nowperformreturn:
 
 			/* deallocate stack                                               */
 
-			if (jd->stackframesize)
-				M_LDA(REG_SP, REG_SP, jd->stackframesize * 8);
+			if (cd->stackframesize)
+				M_LDA(REG_SP, REG_SP, cd->stackframesize * 8);
 
 			M_RET(REG_ZERO, REG_RA);
 			ALIGNCODENOP;
@@ -2833,16 +2449,15 @@ nowperformreturn:
 
 		case ICMD_TABLESWITCH:  /* ..., index ==> ...                         */
 			{
-			s4 i, l, *s4ptr;
-			void **tptr;
+			s4 i, l;
+			branch_target_t *table;
 
-			tptr = (void **) iptr->target;
+			table = iptr->dst.table;
 
-			s4ptr = iptr->val.a;
-			l = s4ptr[1];                          /* low     */
-			i = s4ptr[2];                          /* high    */
-			
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+			l = iptr->sx.s23.s2.tablelow;
+			i = iptr->sx.s23.s3.tablehigh;
+
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 			if (l == 0) {
 				M_INTMOVE(s1, REG_ITMP1);
 			} else if (l <= 32768) {
@@ -2851,6 +2466,8 @@ nowperformreturn:
 				ICONST(REG_ITMP2, l);
 				M_ISUB(s1, REG_ITMP2, REG_ITMP1);
 			}
+
+			/* number of targets */
 			i = i - l + 1;
 
 			/* range check */
@@ -2861,17 +2478,15 @@ nowperformreturn:
 				M_LDA(REG_ITMP2, REG_ZERO, i - 1);
 				M_CMPULE(REG_ITMP1, REG_ITMP2, REG_ITMP2);
 			}
-			M_BEQZ(REG_ITMP2, 0);
-			codegen_addreference(cd, (basicblock *) tptr[0]);
+			emit_beqz(cd, table[0].block, REG_ITMP2);
 
 			/* build jump table top down and use address of lowest entry */
 
-			/* s4ptr += 3 + i; */
-			tptr += i;
+			table += i;
 
 			while (--i >= 0) {
-				dseg_add_target(cd, (basicblock *) tptr[0]); 
-				--tptr;
+				dseg_add_target(cd, table->block); 
+				--table;
 			}
 			}
 
@@ -2886,22 +2501,18 @@ nowperformreturn:
 
 		case ICMD_LOOKUPSWITCH: /* ..., key ==> ...                           */
 			{
-			s4 i, l, val, *s4ptr;
-			void **tptr;
+			s4 i, val;
+			lookup_target_t *lookup;
 
-			tptr = (void **) iptr->target;
+			lookup = iptr->dst.lookup;
 
-			s4ptr = iptr->val.a;
-			l = s4ptr[0];                          /* default  */
-			i = s4ptr[1];                          /* count    */
+			i = iptr->sx.s23.s2.lookupcount;
 			
 			MCODECHECK((i<<2)+8);
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			while (--i >= 0) {
-				s4ptr += 2;
-				++tptr;
+			s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 
-				val = s4ptr[0];
+			while (--i >= 0) {
+				val = lookup->value;
 				if ((val >= 0) && (val <= 255)) {
 					M_CMPEQ_IMM(s1, val, REG_ITMP2);
 				} else {
@@ -2913,40 +2524,38 @@ nowperformreturn:
 					}
 					M_CMPEQ(s1, REG_ITMP2, REG_ITMP2);
 				}
-				M_BNEZ(REG_ITMP2, 0);
-				codegen_addreference(cd, (basicblock *) tptr[0]); 
+				emit_bnez(cd, lookup->target.block, REG_ITMP2);
+				lookup++;
 			}
 
-			M_BR(0);
-			
-			tptr = (void **) iptr->target;
-			codegen_addreference(cd, (basicblock *) tptr[0]);
-
+			emit_br(cd, iptr->sx.s23.s3.lookupdefault.block);
 			ALIGNCODENOP;
 			break;
 			}
 
 
 		case ICMD_BUILTIN:      /* ..., arg1, arg2, arg3 ==> ...              */
-		                        /* op1 = arg count val.a = builtintable entry */
 
-			bte = iptr->val.a;
-			md = bte->md;
+			bte = iptr->sx.s23.s3.bte;
+			md  = bte->md;
 			goto gen_method;
 
 		case ICMD_INVOKESTATIC: /* ..., [arg1, [arg2 ...]] ==> ...            */
-		                        /* op1 = arg count, val.a = method pointer    */
 
 		case ICMD_INVOKESPECIAL:/* ..., objectref, [arg1, [arg2 ...]] ==> ... */
 		case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer    */
 		case ICMD_INVOKEINTERFACE:
 
+			REPLACEMENT_POINT_INVOKE(cd, iptr);
+
 			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
-				md = INSTRUCTION_UNRESOLVED_METHOD(iptr)->methodref->parseddesc.md;
 				lm = NULL;
+				um = iptr->sx.s23.s3.um;
+				md = um->methodref->parseddesc.md;
 			}
 			else {
-				lm = INSTRUCTION_RESOLVED_METHODINFO(iptr);
+				lm = iptr->sx.s23.s3.fmiref->p.method;
+				um = NULL;
 				md = lm->parseddesc;
 			}
 
@@ -2957,27 +2566,33 @@ gen_method:
 
 			/* copy arguments to registers or stack location                  */
 
-			for (s3 = s3 - 1; s3 >= 0; s3--, src = src->prev) {
-				if (src->varkind == ARGVAR)
+			for (s3 = s3 - 1; s3 >= 0; s3--) {
+				var = VAR(iptr->sx.s23.s2.args[s3]);
+				d   = md->params[s3].regoff;
+
+				/* already preallocated (ARGVAR)? */
+
+				if (var->flags & PREALLOC)
 					continue;
-				if (IS_INT_LNG_TYPE(src->type)) {
+
+				if (IS_INT_LNG_TYPE(var->type)) {
 					if (!md->params[s3].inmemory) {
-						s1 = rd->argintregs[md->params[s3].regoff];
-						d = emit_load_s1(jd, iptr, src, s1);
-						M_INTMOVE(d, s1);
-					} else {
-						d = emit_load_s1(jd, iptr, src, REG_ITMP1);
-						M_LST(d, REG_SP, md->params[s3].regoff * 8);
+						s1 = emit_load(jd, iptr, var, d);
+						M_INTMOVE(s1, d);
 					}
-
-				} else {
+					else {
+						s1 = emit_load(jd, iptr, var, REG_ITMP1);
+						M_LST(s1, REG_SP, d);
+					}
+				}
+				else {
 					if (!md->params[s3].inmemory) {
-						s1 = rd->argfltregs[md->params[s3].regoff];
-						d = emit_load_s1(jd, iptr, src, s1);
-						M_FLTMOVE(d, s1);
-					} else {
-						d = emit_load_s1(jd, iptr, src, REG_FTMP1);
-						M_DST(d, REG_SP, md->params[s3].regoff * 8);
+						s1 = emit_load(jd, iptr, var, d);
+						M_FLTMOVE(s1, d);
+					}
+					else {
+						s1 = emit_load(jd, iptr, var, REG_FTMP1);
+						M_DST(s1, REG_SP, d);
 					}
 				}
 			}
@@ -2985,260 +2600,204 @@ gen_method:
 			switch (iptr->opc) {
 			case ICMD_BUILTIN:
 				disp = dseg_add_functionptr(cd, bte->fp);
-				d = md->returntype.type;
 
 				M_ALD(REG_PV, REG_PV, disp);  /* Pointer to built-in-function */
+
+				/* generate the actual call */
+
 				M_JSR(REG_RA, REG_PV);
+				REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
 				disp = (s4) (cd->mcodeptr - cd->mcodebase);
 				M_LDA(REG_PV, REG_RA, -disp);
 
-				/* if op1 == true, we need to check for an exception */
-
-				if (iptr->op1 == true) {
-					M_BEQZ(REG_RESULT, 0);
-					codegen_add_fillinstacktrace_ref(cd);
-				}
+				emit_exception_check(cd, iptr);
 				break;
 
 			case ICMD_INVOKESPECIAL:
-				M_BEQZ(rd->argintregs[0], 0);
-				codegen_add_nullpointerexception_ref(cd);
-				/* fall through */
+				emit_nullpointer_check(cd, iptr, REG_A0);
+				/* fall-through */
 
 			case ICMD_INVOKESTATIC:
 				if (lm == NULL) {
-					unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr);
-
 					disp = dseg_add_unique_address(cd, um);
 
-					codegen_addpatchref(cd, PATCHER_invokestatic_special,
-										um, disp);
-
-					if (opt_showdisassemble)
-						M_NOP;
-
-					d = um->methodref->parseddesc.md->returntype.type;
+					patcher_add_patch_ref(jd, PATCHER_invokestatic_special,
+										  um, disp);
 				}
-				else {
+				else
 					disp = dseg_add_address(cd, lm->stubroutine);
-					d = lm->parseddesc->returntype.type;
-				}
 
 				M_ALD(REG_PV, REG_PV, disp);         /* method pointer in r27 */
+
+				/* generate the actual call */
+
 				M_JSR(REG_RA, REG_PV);
+				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(rd->argintregs[0]);
-
 				if (lm == NULL) {
-					unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr);
-
-					codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
-
-					if (opt_showdisassemble)
-						M_NOP;
+					patcher_add_patch_ref(jd, PATCHER_invokevirtual, um, 0);
 
 					s1 = 0;
-					d = um->methodref->parseddesc.md->returntype.type;
 				}
-				else {
+				else
 					s1 = OFFSET(vftbl_t, table[0]) +
 						sizeof(methodptr) * lm->vftblindex;
-					d = lm->parseddesc->returntype.type;
-				}
 
-				M_ALD(REG_METHODPTR, rd->argintregs[0],
-					  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);
+
+				/* generate the actual call */
+
 				M_JSR(REG_RA, REG_PV);
+				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(rd->argintregs[0]);
-
 				if (lm == NULL) {
-					unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr);
-
-					codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
-
-					if (opt_showdisassemble)
-						M_NOP;
+					patcher_add_patch_ref(jd, PATCHER_invokeinterface, um, 0);
 
 					s1 = 0;
 					s2 = 0;
-					d = um->methodref->parseddesc.md->returntype.type;
 				}
 				else {
 					s1 = OFFSET(vftbl_t, interfacetable[0]) -
 						sizeof(methodptr*) * lm->class->index;
 
 					s2 = sizeof(methodptr) * (lm - lm->class->methods);
-
-					d = lm->parseddesc->returntype.type;
 				}
 					
-				M_ALD(REG_METHODPTR, rd->argintregs[0],
-					  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);
+
+				/* generate the actual call */
+
 				M_JSR(REG_RA, REG_PV);
+				REPLACEMENT_POINT_INVOKE_RETURN(cd, iptr);
 				disp = (s4) (cd->mcodeptr - cd->mcodebase);
 				M_LDA(REG_PV, REG_RA, -disp);
 				break;
 			}
 
-			/* d contains return type */
+			/* store the return value */
+
+			d = md->returntype.type;
 
 			if (d != TYPE_VOID) {
-				if (IS_INT_LNG_TYPE(iptr->dst->type)) {
-					s1 = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT);
+				if (IS_INT_LNG_TYPE(d)) {
+					s1 = codegen_reg_of_dst(jd, iptr, REG_RESULT);
 					M_INTMOVE(REG_RESULT, s1);
-/* 					emit_store(jd, iptr, iptr->dst, s1); */
-				} else {
-					s1 = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FRESULT);
+				}
+				else {
+					s1 = codegen_reg_of_dst(jd, iptr, REG_FRESULT);
 					M_FLTMOVE(REG_FRESULT, s1);
-/* 					emit_store(jd, iptr, iptr->dst, s1); */
 				}
-				emit_store(jd, iptr, iptr->dst, s1);
+				emit_store_dst(jd, iptr, s1);
 			}
 			break;
 
 
 		case ICMD_CHECKCAST:  /* ..., objectref ==> ..., objectref            */
 
-		                      /* op1:   0 == array, 1 == class                */
-		                      /* 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->diffval));
-			 */
-
-			if (iptr->op1 == 1) {
+			if (!(iptr->flags.bits & INS_FLAG_ARRAY)) {
 				/* object type cast-check */
 
 				classinfo *super;
-				vftbl_t   *supervftbl;
 				s4         superindex;
 
-				super = (classinfo *) iptr->val.a;
-
-				if (super == NULL) {
+				if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+					super      = NULL;
 					superindex = 0;
-					supervftbl = NULL;
 				}
 				else {
+					super      = iptr->sx.s23.s3.c.cls;
 					superindex = super->index;
-					supervftbl = super->vftbl;
 				}
-			
-#if defined(ENABLE_THREADS)
-				codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
-				s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
 
-				/* calculate interface checkcast code size */
+				if ((super == NULL) || !(super->flags & ACC_INTERFACE))
+					CODEGEN_CRITICAL_SECTION_NEW;
 
-				s2 = 6;
-				if (super == NULL)
-					s2 += opt_showdisassemble ? 1 : 0;
-
-				/* calculate class checkcast code size */
-
-				s3 = 9 /* 8 + (s1 == REG_ITMP1) */;
-				if (super == NULL)
-					s3 += opt_showdisassemble ? 1 : 0;
+				s1 = emit_load_s1(jd, iptr, REG_ITMP1);
 
 				/* if class is not resolved, check which code to call */
 
 				if (super == NULL) {
-					M_BEQZ(s1, 4 + (opt_showdisassemble ? 1 : 0) + s2 + 1 + s3);
+					emit_label_beqz(cd, BRANCH_LABEL_1, s1);
 
 					disp = dseg_add_unique_s4(cd, 0);         /* super->flags */
 
-					codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags,
-										(constant_classref *) iptr->target,
-										disp);
-
-					if (opt_showdisassemble)
-						M_NOP;
+					patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_flags,
+										  iptr->sx.s23.s3.c.ref,
+										  disp);
 
 					M_ILD(REG_ITMP2, REG_PV, disp);
 					disp = dseg_add_s4(cd, ACC_INTERFACE);
 					M_ILD(REG_ITMP3, REG_PV, disp);
 					M_AND(REG_ITMP2, REG_ITMP3, REG_ITMP2);
-					M_BEQZ(REG_ITMP2, s2 + 1);
+					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,
-											(constant_classref *) iptr->target,
-											0);
-
-						if (opt_showdisassemble)
-							M_NOP;
+						patcher_add_patch_ref(jd,
+											  PATCHER_checkcast_interface,
+											  iptr->sx.s23.s3.c.ref,
+											  0);
 					}
 					else
-						M_BEQZ(s1, s2);
+						emit_label_beqz(cd, BRANCH_LABEL_3, s1);
 
-					M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl));
+					M_ALD(REG_ITMP2, s1, OFFSET(java_object_t, vftbl));
 					M_ILD(REG_ITMP3, REG_ITMP2,
 						  OFFSET(vftbl_t, interfacetablelength));
 					M_LDA(REG_ITMP3, REG_ITMP3, -superindex);
-					M_BLEZ(REG_ITMP3, 0);
-					codegen_add_classcastexception_ref(cd, s1);
+					emit_classcast_check(cd, iptr, BRANCH_LE, REG_ITMP3, s1);
+
 					M_ALD(REG_ITMP3, REG_ITMP2,
 						  (s4) (OFFSET(vftbl_t, interfacetable[0]) -
 								superindex * sizeof(methodptr*)));
-					M_BEQZ(REG_ITMP3, 0);
-					codegen_add_classcastexception_ref(cd, s1);
+					emit_classcast_check(cd, iptr, BRANCH_EQ, REG_ITMP3, s1);
 
 					if (super == NULL)
-						M_BR(s3);
+						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,
-											(constant_classref *) iptr->target,
-											disp);
+						disp = dseg_add_unique_address(cd, NULL);
 
-						if (opt_showdisassemble)
-							M_NOP;
+						patcher_add_patch_ref(jd,
+											  PATCHER_resolve_classref_to_vftbl,
+											  iptr->sx.s23.s3.c.ref,
+											  disp);
 					}
 					else {
-						disp = dseg_add_address(cd, supervftbl);
+						disp = dseg_add_address(cd, super->vftbl);
 
-						M_BEQZ(s1, s3);
+						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)); */
@@ -3253,128 +2812,104 @@ 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_CMPULE(REG_ITMP2, REG_ITMP3, REG_ITMP3);
-					M_BEQZ(REG_ITMP3, 0);
-					codegen_add_classcastexception_ref(cd, s1);
+					emit_classcast_check(cd, iptr, BRANCH_EQ, REG_ITMP3, s1);
+
+					if (super != NULL)
+						emit_label(cd, BRANCH_LABEL_5);
 				}
 
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, s1);
+				if (super == NULL) {
+					emit_label(cd, BRANCH_LABEL_1);
+					emit_label(cd, BRANCH_LABEL_4);
+				}
+
+				d = codegen_reg_of_dst(jd, iptr, s1);
 			}
 			else {
 				/* array type cast-check */
 
-				s1 = emit_load_s1(jd, iptr, src, rd->argintregs[0]);
-				M_INTMOVE(s1, rd->argintregs[0]);
-
-				disp = dseg_addaddress(cd, iptr->val.a);
+				s1 = emit_load_s1(jd, iptr, REG_A0);
+				M_INTMOVE(s1, REG_A0);
 
-				if (iptr->val.a == NULL) {
-					codegen_addpatchref(cd, PATCHER_builtin_arraycheckcast,
-										(constant_classref *) iptr->target,
-										disp);
+				if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+					disp = dseg_add_unique_address(cd, NULL);
 
-					if (opt_showdisassemble)
-						M_NOP;
+					patcher_add_patch_ref(jd,
+										  PATCHER_resolve_classref_to_classinfo,
+										  iptr->sx.s23.s3.c.ref,
+										  disp);
 				}
+				else
+					disp = dseg_add_address(cd, iptr->sx.s23.s3.c.cls);
 
-				M_ALD(rd->argintregs[1], REG_PV, disp);
-				disp = dseg_addaddress(cd, BUILTIN_arraycheckcast);
+				M_ALD(REG_A1, REG_PV, disp);
+				disp = dseg_add_functionptr(cd, BUILTIN_arraycheckcast);
 				M_ALD(REG_PV, REG_PV, disp);
 				M_JSR(REG_RA, REG_PV);
 				disp = (s4) (cd->mcodeptr - cd->mcodebase);
 				M_LDA(REG_PV, REG_RA, -disp);
 
-				s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-				M_BEQZ(REG_RESULT, 0);
-				codegen_add_classcastexception_ref(cd, s1);
+				s1 = emit_load_s1(jd, iptr, REG_ITMP1);
+				emit_classcast_check(cd, iptr, BRANCH_EQ, REG_RESULT, s1);
 
-				d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, s1);
+				d = codegen_reg_of_dst(jd, iptr, s1);
 			}
 
 			M_INTMOVE(s1, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult            */
 
-		                      /* op1:   0 == array, 1 == class                */
-		                      /* 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;
 			vftbl_t   *supervftbl;
 			s4         superindex;
 
-			super = (classinfo *) iptr->val.a;
-
-			if (super == NULL) {
+			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+				super = NULL;
 				superindex = 0;
 				supervftbl = NULL;
-			}
-			else {
+
+			} else {
+				super = iptr->sx.s23.s3.c.cls;
 				superindex = super->index;
 				supervftbl = super->vftbl;
 			}
-			
-#if defined(ENABLE_THREADS)
-			codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
-#endif
-			s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
+
+			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 = 6;
-			if (super == NULL)
-				s2 += (d == REG_ITMP2 ? 1 : 0) + (opt_showdisassemble ? 1 : 0);
-
-			/* calculate class instanceof code size */
-
-			s3 = 7;
-			if (super == NULL)
-				s3 += (opt_showdisassemble ? 1 : 0);
-
 			/* if class is not resolved, check which code to call */
 
 			if (super == NULL) {
 				M_CLR(d);
-				M_BEQZ(s1, 4 + (opt_showdisassemble ? 1 : 0) + s2 + 1 + s3);
+				emit_label_beqz(cd, BRANCH_LABEL_1, s1);
 
 				disp = dseg_add_unique_s4(cd, 0);             /* super->flags */
 
-				codegen_addpatchref(cd, PATCHER_checkcast_instanceof_flags,
-									(constant_classref *) iptr->target, disp);
-
-				if (opt_showdisassemble)
-					M_NOP;
+				patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_flags,
+									  iptr->sx.s23.s3.c.ref, disp);
 
 				M_ILD(REG_ITMP3, REG_PV, disp);
 
 				disp = dseg_add_s4(cd, ACC_INTERFACE);
 				M_ILD(REG_ITMP2, REG_PV, disp);
 				M_AND(REG_ITMP3, REG_ITMP2, REG_ITMP3);
-				M_BEQZ(REG_ITMP3, s2 + 1);
+				emit_label_beqz(cd, BRANCH_LABEL_2, REG_ITMP3);
 			}
 
 			/* interface instanceof code */
@@ -3386,19 +2921,16 @@ gen_method:
 					if (d == REG_ITMP2)
 						M_CLR(d);
 
-					codegen_addpatchref(cd,
-										PATCHER_checkcast_instanceof_interface,
-										(constant_classref *) iptr->target, 0);
-
-					if (opt_showdisassemble)
-						M_NOP;
+					patcher_add_patch_ref(jd,
+										  PATCHER_instanceof_interface,
+										  iptr->sx.s23.s3.c.ref, 0);
 				}
 				else {
 					M_CLR(d);
-					M_BEQZ(s1, s2);
+					emit_label_beqz(cd, BRANCH_LABEL_3, s1);
 				}
 
-				M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
+				M_ALD(REG_ITMP1, s1, OFFSET(java_object_t, vftbl));
 				M_ILD(REG_ITMP3, REG_ITMP1, OFFSET(vftbl_t, interfacetablelength));
 				M_LDA(REG_ITMP3, REG_ITMP3, -superindex);
 				M_BLEZ(REG_ITMP3, 2);
@@ -3408,89 +2940,100 @@ gen_method:
 				M_CMPULT(REG_ZERO, REG_ITMP1, d);      /* REG_ITMP1 != 0  */
 
 				if (super == NULL)
-					M_BR(s3);
+					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,
-										(constant_classref *) iptr->target,
-										disp);
+					disp = dseg_add_unique_address(cd, NULL);
 
-					if (opt_showdisassemble)
-						M_NOP;
+					patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_vftbl,
+										  iptr->sx.s23.s3.c.ref,
+										  disp);
 				}
 				else {
 					disp = dseg_add_address(cd, supervftbl);
 
 					M_CLR(d);
-					M_BEQZ(s1, s3);
+					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_CMPULE(REG_ITMP1, REG_ITMP2, 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(jd, iptr, iptr->dst, d);
+
+			emit_store_dst(jd, iptr, d);
 			}
 			break;
 
 		case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref  */
-		                      /* op1 = dimension, val.a = class               */
 
 			/* check for negative sizes and copy sizes to stack if necessary  */
 
-			MCODECHECK((iptr->op1 << 1) + 64);
+			MCODECHECK((iptr->s1.argcount << 1) + 64);
+
+			for (s1 = iptr->s1.argcount; --s1 >= 0; ) {
 
-			for (s1 = iptr->op1; --s1 >= 0; src = src->prev) {
+				var = VAR(iptr->sx.s23.s2.args[s1]);
+	
 				/* copy SAVEDVAR sizes to stack */
 
-				if (src->varkind != ARGVAR) {
-					s2 = emit_load_s2(jd, iptr, src, REG_ITMP1);
+				/* Already Preallocated? */
+
+				if (!(var->flags & PREALLOC)) {
+					s2 = emit_load(jd, iptr, var, REG_ITMP1);
 					M_LST(s2, REG_SP, s1 * 8);
 				}
 			}
 
 			/* a0 = dimension count */
 
-			ICONST(rd->argintregs[0], iptr->op1);
+			ICONST(REG_A0, iptr->s1.argcount);
 
 			/* is patcher function set? */
 
-			if (iptr->val.a == NULL) {
+			if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
 				disp = dseg_add_unique_address(cd, 0);
 
-				codegen_addpatchref(cd, PATCHER_builtin_multianewarray,
-									(constant_classref *) iptr->target,
-									disp);
-
-				if (opt_showdisassemble)
-					M_NOP;
+				patcher_add_patch_ref(jd, PATCHER_resolve_classref_to_classinfo,
+									  iptr->sx.s23.s3.c.ref,
+									  disp);
 			}
 			else
-				disp = dseg_add_address(cd, iptr->val.a);
+				disp = dseg_add_address(cd, iptr->sx.s23.s3.c.cls);
 
 			/* a1 = arraydescriptor */
 
-			M_ALD(rd->argintregs[1], REG_PV, disp);
+			M_ALD(REG_A1, REG_PV, disp);
 
 			/* a2 = pointer to dimensions = stack pointer */
 
-			M_INTMOVE(REG_SP, rd->argintregs[2]);
+			M_INTMOVE(REG_SP, REG_A2);
 
 			disp = dseg_add_functionptr(cd, BUILTIN_multianewarray);
 			M_ALD(REG_PV, REG_PV, disp);
@@ -3500,69 +3043,29 @@ gen_method:
 
 			/* check for exception before result assignment */
 
-			M_BEQZ(REG_RESULT, 0);
-			codegen_add_fillinstacktrace_ref(cd);
+			emit_exception_check(cd, iptr);
 
-			d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT);
+			d = codegen_reg_of_dst(jd, iptr, REG_RESULT);
 			M_INTMOVE(REG_RESULT, d);
-			emit_store(jd, iptr, iptr->dst, d);
+			emit_store_dst(jd, iptr, d);
 			break;
 
 		default:
-			*exceptionptr =
-				new_internalerror("Unknown ICMD %d", iptr->opc);
+			exceptions_throw_internalerror("Unknown ICMD %d during code generation",
+										   iptr->opc);
 			return false;
 	} /* switch */
 		
 	} /* for instruction */
 		
-	/* copy values to interface registers */
-
-	src = bptr->outstack;
-	len = bptr->outdepth;
-	MCODECHECK(64+len);
-#if defined(ENABLE_LSRA)
-	if (!opt_lsra) 
-#endif
-	while (src) {
-		len--;
-		if ((src->varkind != STACKVAR)) {
-			s2 = src->type;
-			if (IS_FLT_DBL_TYPE(s2)) {
-				/* XXX can be one call */
-				s1 = emit_load_s1(jd, NULL, src, REG_FTMP1);
-				if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-					M_FLTMOVE(s1,rd->interfaces[len][s2].regoff);
-					}
-				else {
-					M_DST(s1, REG_SP, 8 * rd->interfaces[len][s2].regoff);
-					}
-				}
-			else {
-				/* XXX can be one call */
-				s1 = emit_load_s1(jd, NULL, src, REG_ITMP1);
-				if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
-					M_INTMOVE(s1,rd->interfaces[len][s2].regoff);
-					}
-				else {
-					M_LST(s1, REG_SP, 8 * rd->interfaces[len][s2].regoff);
-					}
-				}
-			}
-		src = src->prev;
-		}
 	} /* if (bptr -> flags >= BBREACHED) */
 	} /* for basic block */
 
 	dseg_createlinenumbertable(cd);
 
-	/* generate stubs */
-
-	emit_exception_stubs(jd);
-	emit_patcher_stubs(jd);
-	emit_replacement_stubs(jd);
+	/* generate traps */
 
-	codegen_finish(jd);
+	emit_patcher_traps(jd);
 
 	/* everything's ok */
 
@@ -3570,93 +3073,53 @@ gen_method:
 }
 
 
-/* createcompilerstub **********************************************************
+/* codegen_emit_stub_compiler **************************************************
 
-   Creates a stub routine which calls the compiler.
+   Emits a stub routine which calls the compiler.
 	
 *******************************************************************************/
 
-#define COMPILERSTUB_DATASIZE    3 * SIZEOF_VOID_P
-#define COMPILERSTUB_CODESIZE    3 * 4
-
-#define COMPILERSTUB_SIZE        COMPILERSTUB_DATASIZE + COMPILERSTUB_CODESIZE
-
-
-u1 *createcompilerstub(methodinfo *m)
+void codegen_emit_stub_compiler(jitdata *jd)
 {
-	u1          *s;                     /* memory to hold the stub            */
-	ptrint      *d;
-	codeinfo    *code;
+	methodinfo  *m;
 	codegendata *cd;
-	s4           dumpsize;              /* code generation pointer            */
-
-	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);
+	/* get required compiler data */
 
-	d[0] = (ptrint) asm_call_jit_compiler;
-	d[1] = (ptrint) m;
-	d[2] = (ptrint) code;
+	m  = jd->m;
+	cd = jd->cd;
 
 	/* code for the stub */
 
 	M_ALD(REG_ITMP1, REG_PV, -2 * 8);   /* load codeinfo pointer              */
 	M_ALD(REG_PV, REG_PV, -3 * 8);      /* load pointer to the compiler       */
 	M_JMP(REG_ZERO, REG_PV);            /* jump to the compiler               */
-
-#if defined(ENABLE_STATISTICS)
-	if (opt_stat)
-		count_cstub_len += COMPILERSTUB_SIZE;
-#endif
-
-	/* release dump area */
-
-	dump_release(dumpsize);
-
-	return s;
 }
 
 
-/* createnativestub ************************************************************
+/* codegen_emit_stub_native ****************************************************
 
-   Creates a stub routine which calls a native method.
+   Emits a stub routine which calls a native method.
 
 *******************************************************************************/
 
-u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
+void codegen_emit_stub_native(jitdata *jd, methoddesc *nmd, functionptr f)
 {
-	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       */
+	methodinfo  *m;
+	codeinfo    *code;
+	codegendata *cd;
+	methoddesc  *md;
+	s4           nativeparams;
+	s4           i, j;                 /* count variables                    */
+	s4           t;
+	s4           s1, s2, disp;
+	s4           funcdisp;             /* displacement of the function       */
 
 	/* get required compiler data */
 
 	m    = jd->m;
 	code = jd->code;
 	cd   = jd->cd;
-	rd   = jd->rd;
 
 	/* initialize variables */
 
@@ -3665,18 +3128,18 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 	/* calculate stack frame size */
 
-	jd->stackframesize =
+	cd->stackframesize =
 		1 +                             /* return address                     */
 		sizeof(stackframeinfo) / SIZEOF_VOID_P +
 		sizeof(localref_table) / SIZEOF_VOID_P +
 		1 +                             /* methodinfo for call trace          */
-		(md->paramcount > INT_ARG_CNT ? INT_ARG_CNT : md->paramcount) +
+		md->paramcount +
 		nmd->memuse;
 
 	/* create method header */
 
 	(void) dseg_add_unique_address(cd, code);              /* CodeinfoPointer */
-	(void) dseg_add_unique_s4(cd, jd->stackframesize * 8); /* FrameSize       */
+	(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         */
@@ -3686,105 +3149,51 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 	/* generate stub code */
 
-	M_LDA(REG_SP, REG_SP, -(jd->stackframesize * 8));
-	M_AST(REG_RA, REG_SP, jd->stackframesize * 8 - SIZEOF_VOID_P);
+	M_LDA(REG_SP, REG_SP, -(cd->stackframesize * 8));
+	M_AST(REG_RA, REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P);
 
 	/* call trace function */
 
 #if !defined(NDEBUG)
-	if (opt_verbosecall) {
-		/* save integer argument registers */
-
-		for (i = 0, j = 1; 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++;
-			}
-		}
-
-		/* save and copy float arguments into integer registers */
-
-		for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
-			t = md->paramtypes[i].type;
-
-			if (IS_FLT_DBL_TYPE(t)) {
-				if (IS_2_WORD_TYPE(t)) {
-					M_DST(rd->argfltregs[i], REG_SP, j * 8);
-					M_LLD(rd->argintregs[i], REG_SP, j * 8);
-				} else {
-					M_FST(rd->argfltregs[i], REG_SP, j * 8);
-					M_ILD(rd->argintregs[i], REG_SP, j * 8);
-				}
-				j++;
-			}
-		}
-
-		disp = dseg_add_address(cd, m);
-		M_ALD(REG_ITMP1, REG_PV, disp);
-		M_AST(REG_ITMP1, REG_SP, 0 * 8);
-		disp = dseg_add_functionptr(cd, builtin_trace_args);
-		M_ALD(REG_PV, REG_PV, disp);
-		M_JSR(REG_RA, REG_PV);
-		disp = (s4) (cd->mcodeptr - cd->mcodebase);
-		M_LDA(REG_PV, REG_RA, -disp);
-
-		for (i = 0, j = 1; 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);
-				j++;
-			}
-		}
-
-		for (i = 0; i < md->paramcount && i < FLT_ARG_CNT; i++) {
-			t = md->paramtypes[i].type;
-
-			if (IS_FLT_DBL_TYPE(t)) {
-				if (IS_2_WORD_TYPE(t)) {
-					M_DLD(rd->argfltregs[i], REG_SP, j * 8);
-				} else {
-					M_FLD(rd->argfltregs[i], REG_SP, j * 8);
-				}
-				j++;
-			}
-		}
-	}
-#endif /* !defined(NDEBUG) */
+	if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
+		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);
-
-		if (opt_showdisassemble)
-			M_NOP;
-	}
+	if (f == NULL)
+		patcher_add_patch_ref(jd, PATCHER_resolve_native_function, m, funcdisp);
 #endif
 
 	/* save integer and float argument registers */
 
-	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++;
-		}
-	}
+	for (i = 0; i < md->paramcount; i++) {
+		if (!md->params[i].inmemory) {
+			s1 = md->params[i].regoff;
 
-	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);
-			j++;
+			switch (md->paramtypes[i].type) {
+			case TYPE_INT:
+			case TYPE_LNG:
+			case TYPE_ADR:
+				M_LST(s1, REG_SP, i * 8);
+				break;
+			case TYPE_FLT:
+			case TYPE_DBL:
+				M_DST(s1, REG_SP, i * 8);
+				break;
+			}
 		}
 	}
 
 	/* prepare data structures for native function call */
 
-	M_LDA(rd->argintregs[0], REG_SP, jd->stackframesize * 8 - SIZEOF_VOID_P);
-	M_MOV(REG_PV, rd->argintregs[1]);
-	M_LDA(rd->argintregs[2], REG_SP, jd->stackframesize * 8);
-	M_ALD(rd->argintregs[3], REG_SP, jd->stackframesize * 8 - SIZEOF_VOID_P);
+	M_LDA(REG_A0, REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P);
+	M_MOV(REG_PV, REG_A1);
+	M_LDA(REG_A2, REG_SP, cd->stackframesize * 8);
+	M_ALD(REG_A3, REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P);
 	disp = dseg_add_functionptr(cd, codegen_start_native_call);
 	M_ALD(REG_PV, REG_PV, disp);
 	M_JSR(REG_RA, REG_PV);
@@ -3793,17 +3202,21 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 	/* restore integer and float argument registers */
 
-	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);
-			j++;
-		}
-	}
+	for (i = 0; i < md->paramcount; i++) {
+		if (!md->params[i].inmemory) {
+			s1 = md->params[i].regoff;
 
-	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);
-			j++;
+			switch (md->paramtypes[i].type) {
+			case TYPE_INT:
+			case TYPE_LNG:
+			case TYPE_ADR:
+				M_LLD(s1, REG_SP, i * 8);
+				break;
+			case TYPE_FLT:
+			case TYPE_DBL:
+				M_DLD(s1, REG_SP, i * 8);
+				break;
+			}
 		}
 	}
 
@@ -3814,48 +3227,43 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 		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 (!nmd->params[j].inmemory)
 					M_INTMOVE(s1, s2);
-
-				} else {
-					s2 = nmd->params[j].regoff;
-					M_LST(s1, REG_SP, s2 * 8);
-				}
-
-			} else {
-				s1 = md->params[i].regoff + jd->stackframesize;
+				else
+					M_LST(s1, REG_SP, s2);
+			}
+			else {
+				s1 = md->params[i].regoff + cd->stackframesize * 8;
 				s2 = nmd->params[j].regoff;
-				M_LLD(REG_ITMP1, REG_SP, s1 * 8);
-				M_LST(REG_ITMP1, REG_SP, s2 * 8);
+				M_LLD(REG_ITMP1, REG_SP, s1);
+				M_LST(REG_ITMP1, REG_SP, s2);
 			}
-
-		} else {
+		}
+		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 (!nmd->params[j].inmemory)
 					M_FLTMOVE(s1, s2);
-
-				} else {
-					s2 = nmd->params[j].regoff;
+				else {
 					if (IS_2_WORD_TYPE(t))
-						M_DST(s1, REG_SP, s2 * 8);
+						M_DST(s1, REG_SP, s2);
 					else
-						M_FST(s1, REG_SP, s2 * 8);
+						M_FST(s1, REG_SP, s2);
 				}
-
-			} else {
-				s1 = md->params[i].regoff + jd->stackframesize;
+			}
+			else {
+				s1 = md->params[i].regoff + cd->stackframesize * 8;
 				s2 = nmd->params[j].regoff;
-				M_DLD(REG_FTMP1, REG_SP, s1 * 8);
+				M_DLD(REG_FTMP1, REG_SP, s1);
 				if (IS_2_WORD_TYPE(t))
-					M_DST(REG_FTMP1, REG_SP, s2 * 8);
+					M_DST(REG_FTMP1, REG_SP, s2);
 				else
-					M_FST(REG_FTMP1, REG_SP, s2 * 8);
+					M_FST(REG_FTMP1, REG_SP, s2);
 			}
 		}
 	}
@@ -3864,13 +3272,13 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 	if (m->flags & ACC_STATIC) {
 		disp = dseg_add_address(cd, m->class);
-		M_ALD(rd->argintregs[1], REG_PV, disp);
+		M_ALD(REG_A1, REG_PV, disp);
 	}
 
 	/* put env into first argument register */
 
 	disp = dseg_add_address(cd, _Jv_env);
-	M_ALD(rd->argintregs[0], REG_PV, disp);
+	M_ALD(REG_A0, REG_PV, disp);
 
 	/* do the native function call */
 
@@ -3881,44 +3289,30 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 
 	/* 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) {
+	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;
+	case TYPE_VOID:
+		break;
 	}
 
 	/* call finished trace */
 
 #if !defined(NDEBUG)
-	if (opt_verbosecall) {
-		/* just restore the value we need, don't care about the other */
-
-		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);
-		}
-
-		disp = dseg_add_address(cd, m);
-		M_ALD(rd->argintregs[0], REG_PV, disp);
-
-		M_MOV(REG_RESULT, rd->argintregs[1]);
-		M_FMOV(REG_FRESULT, rd->argfltregs[2]);
-		M_FMOV(REG_FRESULT, rd->argfltregs[3]);
-
-		disp = dseg_add_functionptr(cd, builtin_displaymethodstop);
-		M_ALD(REG_PV, REG_PV, disp);
-		M_JSR(REG_RA, REG_PV);
-		disp = (s4) (cd->mcodeptr - cd->mcodebase);
-		M_LDA(REG_PV, REG_RA, -disp);
-	}
-#endif /* !defined(NDEBUG) */
+	if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
+		emit_verbosecall_exit(jd);
+#endif
 
 	/* remove native stackframe info */
 
-	M_LDA(rd->argintregs[0], REG_SP, jd->stackframesize * 8 - SIZEOF_VOID_P);
+	M_LDA(REG_A0, REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P);
 	disp = dseg_add_functionptr(cd, codegen_finish_native_call);
 	M_ALD(REG_PV, REG_PV, disp);
 	M_JSR(REG_RA, REG_PV);
@@ -3928,15 +3322,22 @@ 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) {
+	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;
+	case TYPE_VOID:
+		break;
 	}
 
-	M_ALD(REG_RA, REG_SP, (jd->stackframesize - 1) * 8); /* get RA            */
-	M_LDA(REG_SP, REG_SP, jd->stackframesize * 8);
+	M_ALD(REG_RA, REG_SP, (cd->stackframesize - 1) * 8); /* get RA            */
+	M_LDA(REG_SP, REG_SP, cd->stackframesize * 8);
 
 	/* check for exception */
 
@@ -3951,14 +3352,9 @@ u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 	M_ALD(REG_ITMP3, REG_PV, disp);     /* load asm exception handler address */
 	M_JMP(REG_ZERO, REG_ITMP3);         /* jump to asm exception handler      */
 	
-
 	/* generate patcher stubs */
 
-	emit_patcher_stubs(jd);
-
-	codegen_finish(jd);
-
-	return code->entrypoint;
+	emit_patcher_traps(jd);
 }