Merged changes from trunk.
[cacao.git] / src / vm / jit / alpha / codegen.c
index 5ac5add885f650580b394e4fe8dae0fce8df3d86..71a9f5095c6703e6d5b34a880fa44134f50532c0 100644 (file)
@@ -32,7 +32,7 @@
             Christian Ullrich
             Edwin Steiner
 
-   $Id: codegen.c 4653 2006-03-18 04:14:17Z edwin $
+   $Id: codegen.c 5323 2006-09-05 16:45:24Z edwin $
 
 */
 
 
 #include "native/jni.h"
 #include "native/native.h"
+
+#if defined(ENABLE_THREADS)
+# include "threads/native/lock.h"
+#endif
+
 #include "vm/builtin.h"
 #include "vm/exceptions.h"
 #include "vm/global.h"
@@ -62,6 +67,7 @@
 #include "vm/jit/asmpart.h"
 #include "vm/jit/codegen-common.h"
 #include "vm/jit/dseg.h"
+#include "vm/jit/emit.h"
 #include "vm/jit/jit.h"
 #include "vm/jit/parse.h"
 #include "vm/jit/patcher.h"
 
 *******************************************************************************/
 
-bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
+bool codegen(jitdata *jd)
 {
+       methodinfo         *m;
+       codeinfo           *code;
+       codegendata        *cd;
+       registerdata       *rd;
        s4                  len, s1, s2, s3, d, disp;
-       s4                  parentargs_base;
-       s4                 *mcodeptr;
        stackptr            src;
        varinfo            *var;
        basicblock         *bptr;
@@ -95,6 +103,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
        methoddesc         *md;
        rplpoint           *replacementpoint;
 
+       /* get required compiler data */
+
+       m    = jd->m;
+       code = jd->code;
+       cd   = jd->cd;
+       rd   = jd->rd;
+
        /* prevent compiler warnings */
 
        d = 0;
@@ -106,26 +121,30 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
        s4 i, p, t, l;
        s4 savedregs_num;
 
-       savedregs_num = (m->isleafmethod) ? 0 : 1;        /* space to save the RA */
+       savedregs_num = (jd->isleafmethod) ? 0 : 1;       /* space to save the RA */
 
        /* space to save used callee saved registers */
 
        savedregs_num += (INT_SAV_CNT - rd->savintreguse);
        savedregs_num += (FLT_SAV_CNT - rd->savfltreguse);
 
-       parentargs_base = rd->memuse + savedregs_num;
+       cd->stackframesize = rd->memuse + savedregs_num;
 
-#if defined(USE_THREADS)           /* space to save argument of monitor_enter */
+#if defined(ENABLE_THREADS)        /* space to save argument of monitor_enter */
        if (checksync && (m->flags & ACC_SYNCHRONIZED))
-               parentargs_base++;
+               cd->stackframesize++;
 #endif
 
        /* create method header */
 
-       (void) dseg_addaddress(cd, m);                          /* MethodPointer  */
-       (void) dseg_adds4(cd, parentargs_base * 8);             /* FrameSize      */
+#if 0
+       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, cd->stackframesize * 8); /* FrameSize       */
 
-#if defined(USE_THREADS)
+#if defined(ENABLE_THREADS)
        /* IsSync contains the offset relative to the stack pointer for the
           argument of monitor_exit used in the exception handler. Since the
           offset could be zero and give a wrong meaning of the flag it is
@@ -133,41 +152,37 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
        */
 
        if (checksync && (m->flags & ACC_SYNCHRONIZED))
-               (void) dseg_adds4(cd, (rd->memuse + 1) * 8);        /* IsSync         */
+               (void) dseg_add_unique_s4(cd, (rd->memuse + 1) * 8);       /* IsSync  */
        else
 #endif
-               (void) dseg_adds4(cd, 0);                           /* IsSync         */
-                                              
-       (void) dseg_adds4(cd, m->isleafmethod);                 /* IsLeaf         */
-       (void) dseg_adds4(cd, INT_SAV_CNT - rd->savintreguse);  /* IntSave        */
-       (void) dseg_adds4(cd, FLT_SAV_CNT - rd->savfltreguse);  /* FltSave        */
+               (void) dseg_add_unique_s4(cd, 0);                          /* IsSync  */
+
+       (void) dseg_add_unique_s4(cd, jd->isleafmethod);               /* IsLeaf  */
+       (void) dseg_add_unique_s4(cd, INT_SAV_CNT - rd->savintreguse); /* IntSave */
+       (void) dseg_add_unique_s4(cd, FLT_SAV_CNT - rd->savfltreguse); /* FltSave */
 
        dseg_addlinenumbertablesize(cd);
 
-       (void) dseg_adds4(cd, cd->exceptiontablelength);        /* ExTableSize    */
+       (void) dseg_add_unique_s4(cd, cd->exceptiontablelength);   /* ExTableSize */
 
        /* create exception table */
 
        for (ex = cd->exceptiontable; ex != NULL; ex = ex->down) {
-               dseg_addtarget(cd, ex->start);
-               dseg_addtarget(cd, ex->end);
-               dseg_addtarget(cd, ex->handler);
-               (void) dseg_addaddress(cd, ex->catchtype.cls);
+               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);
        }
        
-       /* initialize mcode variables */
-       
-       mcodeptr = (s4 *) cd->mcodeptr;
-
        /* create stack frame (if necessary) */
 
-       if (parentargs_base)
-               M_LDA(REG_SP, REG_SP, -parentargs_base * 8);
+       if (cd->stackframesize)
+               M_LDA(REG_SP, REG_SP, -(cd->stackframesize * 8));
 
        /* save return address and used callee saved registers */
 
-       p = parentargs_base;
-       if (!m->isleafmethod) {
+       p = cd->stackframesize;
+       if (!jd->isleafmethod) {
                p--; M_AST(REG_RA, REG_SP, p * 8);
        }
        for (i = INT_SAV_CNT - 1; i >= rd->savintreguse; i--) {
@@ -202,10 +217,10 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                        } else {                                 /* stack arguments       */
                                if (!(var->flags & INMEMORY)) {      /* stack arg -> register */
-                                       M_LLD(var->regoff, REG_SP, (parentargs_base + s1) * 8);
+                                       M_LLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 8);
 
                                } else {                             /* stack arg -> spilled  */
-                                       var->regoff = parentargs_base + s1;
+                                       var->regoff = cd->stackframesize + s1;
                                }
                        }
 
@@ -221,10 +236,10 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                        } else {                                 /* stack arguments       */
                                if (!(var->flags & INMEMORY)) {      /* stack-arg -> register */
-                                       M_DLD(var->regoff, REG_SP, (parentargs_base + s1) * 8);
+                                       M_DLD(var->regoff, REG_SP, (cd->stackframesize + s1) * 8);
 
                                } else {                             /* stack-arg -> spilled  */
-                                       var->regoff = parentargs_base + s1;
+                                       var->regoff = cd->stackframesize + s1;
                                }
                        }
                }
@@ -232,12 +247,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
        /* call monitorenter function */
 
-#if defined(USE_THREADS)
+#if defined(ENABLE_THREADS)
        if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
                /* stack offset for monitor argument */
 
                s1 = rd->memuse;
 
+#if !defined(NDEBUG)
                if (opt_verbosecall) {
                        M_LDA(REG_SP, REG_SP, -(INT_ARG_CNT + FLT_ARG_CNT) * 8);
 
@@ -249,30 +265,27 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                        s1 += INT_ARG_CNT + FLT_ARG_CNT;
                }
+#endif /* !defined(NDEBUG) */
 
                /* decide which monitor enter function to call */
 
                if (m->flags & ACC_STATIC) {
-                       disp = dseg_addaddress(cd, m->class);
+                       disp = dseg_add_address(cd, &m->class->object.header);
                        M_ALD(rd->argintregs[0], REG_PV, disp);
-                       M_AST(rd->argintregs[0], REG_SP, s1 * 8);
-                       disp = dseg_addaddress(cd, BUILTIN_staticmonitorenter);
-                       M_ALD(REG_PV, REG_PV, disp);
-                       M_JSR(REG_RA, REG_PV);
-                       disp = -(s4) ((u1 *) mcodeptr - cd->mcodebase);
-                       M_LDA(REG_PV, REG_RA, disp);
-
-               } else {
+               }
+               else {
                        M_BEQZ(rd->argintregs[0], 0);
-                       codegen_add_nullpointerexception_ref(cd, mcodeptr);
-                       M_AST(rd->argintregs[0], REG_SP, s1 * 8);
-                       disp = dseg_addaddress(cd, BUILTIN_monitorenter);
-                       M_ALD(REG_PV, REG_PV, disp);
-                       M_JSR(REG_RA, REG_PV);
-                       disp = -(s4) ((u1 *) mcodeptr - cd->mcodebase);
-                       M_LDA(REG_PV, REG_RA, disp);
+                       codegen_add_nullpointerexception_ref(cd);
                }
 
+               M_AST(rd->argintregs[0], 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);
+               disp = (s4) (cd->mcodeptr - cd->mcodebase);
+               M_LDA(REG_PV, REG_RA, -disp);
+
+#if !defined(NDEBUG)
                if (opt_verbosecall) {
                        for (p = 0; p < INT_ARG_CNT; p++)
                                M_LLD(rd->argintregs[p], REG_SP, p * 8);
@@ -282,87 +295,28 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                        M_LDA(REG_SP, REG_SP, (INT_ARG_CNT + FLT_ARG_CNT) * 8);
                }
+#endif /* !defined(NDEBUG) */
        }                       
 #endif
 
        /* call trace function */
 
-       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_addaddress(cd, m);
-               M_ALD(REG_ITMP1, REG_PV, disp);
-               M_AST(REG_ITMP1, REG_SP, 0 * 8);
-               disp = dseg_addaddress(cd, (void *) builtin_trace_args);
-               M_ALD(REG_PV, REG_PV, disp);
-               M_JSR(REG_RA, REG_PV);
-               disp = -(s4) ((u1 *) 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);
-       }
+#if !defined(NDEBUG)
+       if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
+               emit_verbosecall_enter(jd);
+#endif
 
        }
 
        /* end of header generation */
 
-       replacementpoint = cd->code->rplpoints;
+       replacementpoint = jd->code->rplpoints;
 
        /* walk through all basic blocks */
 
        for (bptr = m->basicblocks; bptr != NULL; bptr = bptr->next) {
 
-               bptr->mpc = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+               bptr->mpc = (s4) (cd->mcodeptr - cd->mcodebase);
 
                if (bptr->flags >= BBREACHED) {
 
@@ -400,7 +354,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        else
                                                d = REG_ITMP1;
                                        M_INTMOVE(REG_ITMP1, d);
-                                       store_reg_to_var_int(src, d);
+                                       emit_store(jd, NULL, src, d);
                                }
                                src = src->prev;
                        }
@@ -409,11 +363,12 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                        while (src != NULL) {
                                len--;
                                if ((len == 0) && (bptr->type != BBTYPE_STD)) {
-                                       d = reg_of_var(rd, src, REG_ITMP1);
+                                       d = codegen_reg_of_var(rd, 0, src, REG_ITMP1);
                                        M_INTMOVE(REG_ITMP1, d);
-                                       store_reg_to_var_int(src, d);
+                                       emit_store(jd, NULL, src, d);
+
                                } else {
-                                       d = reg_of_var(rd, src, REG_IFTMP);
+                                       d = codegen_reg_of_var(rd, 0, src, REG_IFTMP);
                                        if ((src->varkind != STACKVAR)) {
                                                s2 = src->type;
                                                if (IS_FLT_DBL_TYPE(s2)) {
@@ -423,7 +378,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                                        } else {
                                                                M_DLD(d, REG_SP, rd->interfaces[len][s2].regoff * 8);
                                                        }
-                                                       store_reg_to_var_flt(src, d);
+                                                       emit_store(jd, NULL, src, d);
                                                }
                                                else {
                                                        if (!(rd->interfaces[len][s2].flags & INMEMORY)) {
@@ -432,7 +387,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                                        } else {
                                                                M_LLD(d, REG_SP, rd->interfaces[len][s2].regoff * 8);
                                                        }
-                                                       store_reg_to_var_int(src, d);
+                                                       emit_store(jd, NULL, src, d);
                                                }
                                        }
                                }
@@ -449,7 +404,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                for (iptr = bptr->iinstr; len > 0; src = iptr->dst, len--, iptr++) {
                        if (iptr->line != currentline) {
-                               dseg_addlinenumber(cd, iptr->line, (u1 *) mcodeptr);
+                               dseg_addlinenumber(cd, iptr->line);
                                currentline = iptr->line;
                        }
 
@@ -465,9 +420,9 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_CHECKNULL:  /* ..., objectref  ==> ..., objectref           */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        M_BEQZ(s1, 0);
-                       codegen_add_nullpointerexception_ref(cd, mcodeptr);
+                       codegen_add_nullpointerexception_ref(cd);
                        break;
 
                /* constant operations ************************************************/
@@ -475,63 +430,69 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                case ICMD_ICONST:     /* ...  ==> ..., constant                       */
                                      /* op1 = 0, val.i = constant                    */
 
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
                        ICONST(d, iptr->val.i);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LCONST:     /* ...  ==> ..., constant                       */
                                      /* op1 = 0, val.l = constant                    */
 
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
                        LCONST(d, iptr->val.l);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_FCONST:     /* ...  ==> ..., constant                       */
                                      /* op1 = 0, val.f = constant                    */
 
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP1);
-                       disp = dseg_addfloat(cd, iptr->val.f);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
+                       disp = dseg_add_float(cd, iptr->val.f);
                        M_FLD(d, REG_PV, disp);
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
                        
                case ICMD_DCONST:     /* ...  ==> ..., constant                       */
                                      /* op1 = 0, val.d = constant                    */
 
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP1);
-                       disp = dseg_adddouble(cd, iptr->val.d);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
+                       disp = dseg_add_double(cd, iptr->val.d);
                        M_DLD(d, REG_PV, disp);
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_ACONST:     /* ...  ==> ..., constant                       */
                                      /* op1 = 0, val.a = constant                    */
 
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
 
-                       if ((iptr->target != NULL) && (iptr->val.a == NULL)) {
-                               disp = dseg_addaddress(cd, iptr->val.a);
+                       if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+                               constant_classref *cr = ICMD_ACONST_UNRESOLVED_CLASSREF(iptr);
+
+                               disp = dseg_add_unique_address(cd, cr);
 
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_aconst,
-                                                                       (unresolved_class *) iptr->target, disp);
+                               /* 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_resolve_classref_to_classinfo,
+                                                                       cr, disp);
 
                                if (opt_showdisassemble)
                                        M_NOP;
 
                                M_ALD(d, REG_PV, disp);
-
-                       else {
-                               if (iptr->val.a == NULL) {
+                       }
+                       else {
+                               if (iptr->val.a == NULL)
                                        M_INTMOVE(REG_ZERO, d);
-                               else {
-                                       disp = dseg_addaddress(cd, iptr->val.a);
+                               else {
+                                       disp = dseg_add_address(cd, iptr->val.a);
                                        M_ALD(d, REG_PV, disp);
                                }
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
 
@@ -541,7 +502,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                case ICMD_LLOAD:      /* op1 = local variable                         */
                case ICMD_ALOAD:
 
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP1);
                        if ((iptr->dst->varkind == LOCALVAR) &&
                            (iptr->dst->varnum == iptr->op1))
                                break;
@@ -551,13 +512,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                        } else {
                                M_INTMOVE(var->regoff, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_FLOAD:      /* ...  ==> ..., content of local variable      */
                case ICMD_DLOAD:      /* op1 = local variable                         */
 
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
                        if ((iptr->dst->varkind == LOCALVAR) &&
                            (iptr->dst->varnum == iptr->op1))
                                break;
@@ -567,7 +528,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                        } else {
                                M_FLTMOVE(var->regoff, d);
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
 
@@ -580,10 +541,10 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                break;
                        var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]);
                        if (var->flags & INMEMORY) {
-                               var_to_reg_int(s1, src, REG_ITMP1);
+                               s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                                M_LST(s1, REG_SP, var->regoff * 8);
                        } else {
-                               var_to_reg_int(s1, src, var->regoff);
+                               s1 = emit_load_s1(jd, iptr, src, var->regoff);
                                M_INTMOVE(s1, var->regoff);
                        }
                        break;
@@ -596,10 +557,10 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                break;
                        var = &(rd->locals[iptr->op1][iptr->opc - ICMD_ISTORE]);
                        if (var->flags & INMEMORY) {
-                               var_to_reg_flt(s1, src, REG_FTMP1);
+                               s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
                                M_DST(s1, REG_SP, var->regoff * 8);
                        } else {
-                               var_to_reg_flt(s1, src, var->regoff);
+                               s1 = emit_load_s1(jd, iptr, src, var->regoff);
                                M_FLTMOVE(s1, var->regoff);
                        }
                        break;
@@ -668,258 +629,258 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_INEG:       /* ..., value  ==> ..., - value                 */
 
-                       var_to_reg_int(s1, src, REG_ITMP1); 
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1); 
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        M_ISUB(REG_ZERO, s1, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LNEG:       /* ..., value  ==> ..., - value                 */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        M_LSUB(REG_ZERO, s1, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_I2L:        /* ..., value  ==> ..., value                   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        M_INTMOVE(s1, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_L2I:        /* ..., value  ==> ..., value                   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        M_IADD(s1, REG_ZERO, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_INT2BYTE:   /* ..., value  ==> ..., value                   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        if (has_ext_instr_set) {
                                M_BSEXT(s1, d);
                        } else {
                                M_SLL_IMM(s1, 56, d);
                                M_SRA_IMM( d, 56, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_INT2CHAR:   /* ..., value  ==> ..., value                   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
             M_CZEXT(s1, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_INT2SHORT:  /* ..., value  ==> ..., value                   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        if (has_ext_instr_set) {
                                M_SSEXT(s1, d);
                        } else {
                                M_SLL_IMM(s1, 48, d);
                                M_SRA_IMM( d, 48, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
 
                case ICMD_IADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_IADD(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IADDCONST:  /* ..., value  ==> ..., value + constant        */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                ICONST(REG_ITMP2, iptr->val.i);
                                M_IADD(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_LADD(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LADDCONST:  /* ..., value  ==> ..., value + constant        */
                                      /* val.l = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                LCONST(REG_ITMP2, iptr->val.l);
                                M_LADD(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_ISUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_ISUB(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_ISUBCONST:  /* ..., value  ==> ..., value + constant        */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                ICONST(REG_ITMP2, iptr->val.i);
                                M_ISUB(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_LSUB(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LSUBCONST:  /* ..., value  ==> ..., value - constant        */
                                      /* val.l = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                LCONST(REG_ITMP2, iptr->val.l);
                                M_LSUB(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_IMUL(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IMULCONST:  /* ..., value  ==> ..., value * constant        */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                ICONST(REG_ITMP2, iptr->val.i);
                                M_IMUL(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_LMUL(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LMULCONST:  /* ..., value  ==> ..., value * constant        */
                                      /* val.l = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                LCONST(REG_ITMP2, iptr->val.l);
                                M_LMUL(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
                case ICMD_IREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_RESULT);
+                       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, mcodeptr);
+                       codegen_add_arithmeticexception_ref(cd);
 
                        M_MOV(s1, rd->argintregs[0]);
                        M_MOV(s2, rd->argintregs[1]);
                        bte = iptr->val.a;
-                       disp = dseg_addaddress(cd, bte->fp);
+                       disp = dseg_add_functionptr(cd, bte->fp);
                        M_ALD(REG_PV, REG_PV, disp);
                        M_JSR(REG_RA, REG_PV);
-                       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                       disp = (s4) (cd->mcodeptr - cd->mcodebase);
                        M_LDA(REG_PV, REG_RA, -disp);
 
                        M_IADD(REG_RESULT, REG_ZERO, d); /* sign extend (bugfix for gcc -O2) */
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
                case ICMD_LREM:       /* ..., val1, val2  ==> ..., val1 % val2        */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_RESULT);
+                       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, mcodeptr);
+                       codegen_add_arithmeticexception_ref(cd);
 
                        M_MOV(s1, rd->argintregs[0]);
                        M_MOV(s2, rd->argintregs[1]);
                        bte = iptr->val.a;
-                       disp = dseg_addaddress(cd, bte->fp);
+                       disp = dseg_add_functionptr(cd, bte->fp);
                        M_ALD(REG_PV, REG_PV, disp);
                        M_JSR(REG_RA, REG_PV);
-                       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                       disp = (s4) (cd->mcodeptr - cd->mcodebase);
                        M_LDA(REG_PV, REG_RA, -disp);
 
                        M_INTMOVE(REG_RESULT, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IDIVPOW2:   /* ..., value  ==> ..., value << constant       */
                case ICMD_LDIVPOW2:   /* val.i = constant                             */
                                      
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                                M_CMOVGE(s1, s1, REG_ITMP2);
@@ -929,141 +890,141 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_LADD(s1, REG_ITMP2, REG_ITMP2);
                        }
                        M_SRA_IMM(REG_ITMP2, iptr->val.i, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_ISHL:       /* ..., val1, val2  ==> ..., val1 << val2       */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_AND_IMM(s2, 0x1f, REG_ITMP3);
                        M_SLL(s1, REG_ITMP3, d);
                        M_IADD(d, REG_ZERO, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_ISHLCONST:  /* ..., value  ==> ..., value << constant       */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_IADD(d, REG_ZERO, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_ISHR:       /* ..., val1, val2  ==> ..., val1 >> val2       */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_AND_IMM(s2, 0x1f, REG_ITMP3);
                        M_SRA(s1, REG_ITMP3, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_ISHRCONST:  /* ..., value  ==> ..., value >> constant       */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IUSHR:      /* ..., val1, val2  ==> ..., val1 >>> val2      */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_AND_IMM(s2, 0x1f, REG_ITMP2);
             M_IZEXT(s1, d);
                        M_SRL(d, REG_ITMP2, d);
                        M_IADD(d, REG_ZERO, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IUSHRCONST: /* ..., value  ==> ..., value >>> constant      */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
             M_IZEXT(s1, d);
                        M_SRL_IMM(d, iptr->val.i & 0x1f, d);
                        M_IADD(d, REG_ZERO, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LSHL:       /* ..., val1, val2  ==> ..., val1 << val2       */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_SLL(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LSHLCONST:  /* ..., value  ==> ..., value << constant       */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LSHR:       /* ..., val1, val2  ==> ..., val1 >> val2       */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_SRA(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LSHRCONST:  /* ..., value  ==> ..., value >> constant       */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LUSHR:      /* ..., val1, val2  ==> ..., val1 >>> val2      */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_SRL(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LUSHRCONST: /* ..., value  ==> ..., value >>> constant      */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IAND:       /* ..., val1, val2  ==> ..., val1 & val2        */
                case ICMD_LAND:
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_AND(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IANDCONST:  /* ..., value  ==> ..., value & constant        */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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) {
@@ -1074,14 +1035,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                ICONST(REG_ITMP2, iptr->val.i);
                                M_AND(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IREMPOW2:   /* ..., value  ==> ..., value % constant        */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        if (s1 == d) {
                                M_MOV(s1, REG_ITMP1);
                                s1 = REG_ITMP1;
@@ -1109,14 +1070,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_AND(d, REG_ITMP2, d);
                        }
                        M_ISUB(REG_ZERO, d, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LANDCONST:  /* ..., value  ==> ..., value & constant        */
                                      /* val.l = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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) {
@@ -1135,14 +1096,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                LCONST(REG_ITMP2, iptr->val.l);
                                M_AND(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LREMPOW2:   /* ..., value  ==> ..., value % constant        */
                                      /* val.l = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        if (s1 == d) {
                                M_MOV(s1, REG_ITMP1);
                                s1 = REG_ITMP1;
@@ -1190,95 +1151,95 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_AND(d, REG_ITMP2, d);
                        }
                        M_LSUB(REG_ZERO, d, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IOR:        /* ..., val1, val2  ==> ..., val1 | val2        */
                case ICMD_LOR:
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_OR( s1,s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IORCONST:   /* ..., value  ==> ..., value | constant        */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                ICONST(REG_ITMP2, iptr->val.i);
                                M_OR(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LORCONST:   /* ..., value  ==> ..., value | constant        */
                                      /* val.l = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                LCONST(REG_ITMP2, iptr->val.l);
                                M_OR(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IXOR:       /* ..., val1, val2  ==> ..., val1 ^ val2        */
                case ICMD_LXOR:
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_XOR(s1, s2, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IXORCONST:  /* ..., value  ==> ..., value ^ constant        */
                                      /* val.i = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                ICONST(REG_ITMP2, iptr->val.i);
                                M_XOR(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LXORCONST:  /* ..., value  ==> ..., value ^ constant        */
                                      /* val.l = constant                             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        } else {
                                LCONST(REG_ITMP2, iptr->val.l);
                                M_XOR(s1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
 
                case ICMD_LCMP:       /* ..., val1, val2  ==> ..., val1 cmp val2      */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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);
                        M_CMPLT(s1, s2, REG_ITMP3);
                        M_CMPLT(s2, s1, REG_ITMP1);
                        M_LSUB(REG_ITMP1, REG_ITMP3, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
 
@@ -1308,25 +1269,25 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_FNEG:       /* ..., value  ==> ..., - value                 */
 
-                       var_to_reg_flt(s1, src, REG_FTMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2);
                        M_FMOVN(s1, d);
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_DNEG:       /* ..., value  ==> ..., - value                 */
 
-                       var_to_reg_flt(s1, src, REG_FTMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP2);
                        M_FMOVN(s1, d);
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_FADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_FADD(s1, s2, d);
                        } else {
@@ -1339,14 +1300,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_DADD:       /* ..., val1, val2  ==> ..., val1 + val2        */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_DADD(s1, s2, d);
                        } else {
@@ -1359,14 +1320,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_FSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_FSUB(s1, s2, d);
                        } else {
@@ -1379,14 +1340,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_DSUB:       /* ..., val1, val2  ==> ..., val1 - val2        */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_DSUB(s1, s2, d);
                        } else {
@@ -1399,14 +1360,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_FMUL:       /* ..., val1, val2  ==> ..., val1 * val2        */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_FMUL(s1, s2, d);
                        } else {
@@ -1419,14 +1380,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_DMUL:       /* ..., val1, val2  ==> ..., val1 *** val2      */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_DMUL(s1, s2, d);
                        } else {
@@ -1439,14 +1400,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_FDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_FDIV(s1, s2, d);
                        } else {
@@ -1459,14 +1420,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_DDIV:       /* ..., val1, val2  ==> ..., val1 / val2        */
 
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       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);
                        if (opt_noieee) {
                                M_DDIV(s1, s2, d);
                        } else {
@@ -1479,81 +1440,81 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        M_TRAPB;
                                }
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
                
                case ICMD_I2F:       /* ..., value  ==> ..., (float) value            */
                case ICMD_L2F:
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
-                       disp = dseg_adddouble(cd, 0.0);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, 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);
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_I2D:       /* ..., value  ==> ..., (double) value           */
                case ICMD_L2D:
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
-                       disp = dseg_adddouble(cd, 0.0);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, 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);
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
                        
                case ICMD_F2I:       /* ..., value  ==> ..., (int) value              */
                case ICMD_D2I:
-                       var_to_reg_flt(s1, src, REG_FTMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP3);
-                       disp = dseg_adddouble(cd, 0.0);
+                       s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, 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);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
                
                case ICMD_F2L:       /* ..., value  ==> ..., (long) value             */
                case ICMD_D2L:
-                       var_to_reg_flt(s1, src, REG_FTMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP3);
-                       disp = dseg_adddouble(cd, 0.0);
+                       s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, 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);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_F2D:       /* ..., value  ==> ..., (double) value           */
 
-                       var_to_reg_flt(s1, src, REG_FTMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
                        M_CVTFDS(s1, d);
                        M_TRAPB;
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
                                        
                case ICMD_D2F:       /* ..., value  ==> ..., (float) value            */
 
-                       var_to_reg_flt(s1, src, REG_FTMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP3);
+                       s1 = emit_load_s1(jd, iptr, src, REG_FTMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP3);
                        if (opt_noieee) {
                                M_CVTDF(s1, d);
                        } else {
                                M_CVTDFS(s1, d);
                                M_TRAPB;
                        }
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
                
                case ICMD_FCMPL:      /* ..., val1, val2  ==> ..., val1 fcmpl val2    */
                case ICMD_DCMPL:
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP3);
+                       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);
                        if (opt_noieee) {
                                M_LSUB_IMM(REG_ZERO, 1, d);
                                M_FCMPEQ(s1, s2, REG_FTMP3);
@@ -1573,14 +1534,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_FBEQZ (REG_FTMP3, 1);        /* jump over next instruction  */
                                M_LADD_IMM(REG_ZERO, 1, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
                        
                case ICMD_FCMPG:      /* ..., val1, val2  ==> ..., val1 fcmpg val2    */
                case ICMD_DCMPG:
-                       var_to_reg_flt(s1, src->prev, REG_FTMP1);
-                       var_to_reg_flt(s2, src, REG_FTMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP3);
+                       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);
                        if (opt_noieee) {
                                M_LADD_IMM(REG_ZERO, 1, d);
                                M_FCMPEQ(s1, s2, REG_FTMP3);
@@ -1600,7 +1561,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_FBEQZ (REG_FTMP3, 1);        /* jump over next instruction  */
                                M_LSUB_IMM(REG_ZERO, 1, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
 
@@ -1608,18 +1569,18 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_ARRAYLENGTH: /* ..., arrayref  ==> ..., length              */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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));
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_BALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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;
@@ -1635,14 +1596,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_EXTQH(REG_ITMP2, REG_ITMP1, d);
                                M_SRA_IMM(d, 56, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_CALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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;
@@ -1658,14 +1619,14 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_LDA  (REG_ITMP1, REG_ITMP1, OFFSET(java_chararray, data[0]));
                                M_EXTWL(REG_ITMP2, REG_ITMP1, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;                  
 
                case ICMD_SALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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;
@@ -1683,89 +1644,89 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                M_EXTQH(REG_ITMP2, REG_ITMP1, d);
                                M_SRA_IMM(d, 48, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_IALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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;
                        }
                        M_S4ADDQ(s2, s1, REG_ITMP1);
                        M_ILD(d, REG_ITMP1, OFFSET(java_intarray, data[0]));
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_LALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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;
                        }
                        M_S8ADDQ(s2, s1, REG_ITMP1);
                        M_LLD(d, REG_ITMP1, OFFSET(java_longarray, data[0]));
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_FALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP2);
+                       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;
                        }
                        M_S4ADDQ(s2, s1, REG_ITMP1);
                        M_FLD(d, REG_ITMP1, OFFSET(java_floatarray, data[0]));
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_DALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_FTMP2);
+                       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;
                        }
                        M_S8ADDQ(s2, s1, REG_ITMP1);
                        M_DLD(d, REG_ITMP1, OFFSET(java_doublearray, data[0]));
-                       store_reg_to_var_flt(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_AALOAD:     /* ..., arrayref, index  ==> ..., value         */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       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;
                        }
                        M_SAADDQ(s2, s1, REG_ITMP1);
                        M_ALD(d, REG_ITMP1, OFFSET(java_objectarray, data[0]));
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
 
                case ICMD_BASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_int(s3, src, REG_ITMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
                        if (has_ext_instr_set) {
                                M_LADD(s2, s1, REG_ITMP1);
                                M_BST(s3, REG_ITMP1, OFFSET(java_bytearray, data[0]));
@@ -1782,13 +1743,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_CASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_int(s3, src, REG_ITMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
                        if (has_ext_instr_set) {
                                M_LADD(s2, s1, REG_ITMP1);
                                M_LADD(s2, REG_ITMP1, REG_ITMP1);
@@ -1807,13 +1768,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_SASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_int(s3, src, REG_ITMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
                        if (has_ext_instr_set) {
                                M_LADD(s2, s1, REG_ITMP1);
                                M_LADD(s2, REG_ITMP1, REG_ITMP1);
@@ -1832,80 +1793,80 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_IASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_int(s3, src, REG_ITMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
                        M_S4ADDQ(s2, s1, REG_ITMP1);
                        M_IST(s3, REG_ITMP1, OFFSET(java_intarray, data[0]));
                        break;
 
                case ICMD_LASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_int(s3, src, REG_ITMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
                        M_S8ADDQ(s2, s1, REG_ITMP1);
                        M_LST(s3, REG_ITMP1, OFFSET(java_longarray, data[0]));
                        break;
 
                case ICMD_FASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_flt(s3, src, REG_FTMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_FTMP3);
                        M_S4ADDQ(s2, s1, REG_ITMP1);
                        M_FST(s3, REG_ITMP1, OFFSET(java_floatarray, data[0]));
                        break;
 
                case ICMD_DASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_flt(s3, src, REG_FTMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_FTMP3);
                        M_S8ADDQ(s2, s1, REG_ITMP1);
                        M_DST(s3, REG_ITMP1, OFFSET(java_doublearray, data[0]));
                        break;
 
                case ICMD_AASTORE:    /* ..., arrayref, index, value  ==> ...         */
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
+                       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;
                        }
-                       var_to_reg_int(s3, src, REG_ITMP3);
+                       s3 = emit_load_s3(jd, iptr, src, REG_ITMP3);
 
                        M_MOV(s1, rd->argintregs[0]);
                        M_MOV(s3, rd->argintregs[1]);
-                       disp = dseg_addaddress(cd, BUILTIN_canstore);
+                       disp = dseg_add_functionptr(cd, BUILTIN_canstore);
                        M_ALD(REG_PV, REG_PV, disp);
                        M_JSR(REG_RA, REG_PV);
-                       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                       disp = (s4) (cd->mcodeptr - cd->mcodebase);
                        M_LDA(REG_PV, REG_RA, -disp);
 
                        M_BEQZ(REG_RESULT, 0);
-                       codegen_add_arraystoreexception_ref(cd, mcodeptr);
+                       codegen_add_arraystoreexception_ref(cd);
 
-                       var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src->prev, REG_ITMP2);
-                       var_to_reg_int(s3, src, REG_ITMP3);
+                       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);
                        M_SAADDQ(s2, s1, REG_ITMP1);
                        M_AST(s3, REG_ITMP1, OFFSET(java_objectarray, data[0]));
                        break;
@@ -1913,8 +1874,8 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_IASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       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;
@@ -1925,8 +1886,8 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_LASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       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;
@@ -1937,8 +1898,8 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_AASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       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;
@@ -1949,8 +1910,8 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_BASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       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;
@@ -1972,8 +1933,8 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_CASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       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;
@@ -1997,8 +1958,8 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_SASTORECONST:   /* ..., arrayref, index  ==> ...            */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       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;
@@ -2024,25 +1985,24 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                case ICMD_GETSTATIC:  /* ...  ==> ..., value                          */
                                      /* op1 = type, val.a = field address            */
 
-                       if (iptr->val.a == NULL) {
-                               disp = dseg_addaddress(cd, 0);
+                       if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+                               unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr);
+
+                               disp = dseg_add_unique_address(cd, uf);
 
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_get_putstatic,
-                                                                       (unresolved_field *) iptr->target, disp);
+                               codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
 
                                if (opt_showdisassemble)
                                        M_NOP;
+                       }
+                       else {
+                               fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
 
-
-                       } else {
-                               fieldinfo *fi = iptr->val.a;
-
-                               disp = dseg_addaddress(cd, &(fi->value));
+                               disp = dseg_add_address(cd, &(fi->value));
 
                                if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_clinit, fi->class, 0);
+                                       codegen_addpatchref(cd, PATCHER_initialize_class, fi->class,
+                                                                               0);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
@@ -2052,54 +2012,50 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                        M_ALD(REG_ITMP1, REG_PV, disp);
                        switch (iptr->op1) {
                        case TYPE_INT:
-                               d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                                M_ILD(d, REG_ITMP1, 0);
-                               store_reg_to_var_int(iptr->dst, d);
                                break;
                        case TYPE_LNG:
-                               d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                                M_LLD(d, REG_ITMP1, 0);
-                               store_reg_to_var_int(iptr->dst, d);
                                break;
                        case TYPE_ADR:
-                               d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                                M_ALD(d, REG_ITMP1, 0);
-                               store_reg_to_var_int(iptr->dst, d);
                                break;
                        case TYPE_FLT:
-                               d = reg_of_var(rd, iptr->dst, REG_FTMP1);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
                                M_FLD(d, REG_ITMP1, 0);
-                               store_reg_to_var_flt(iptr->dst, d);
                                break;
                        case TYPE_DBL:                          
-                               d = reg_of_var(rd, iptr->dst, REG_FTMP1);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
                                M_DLD(d, REG_ITMP1, 0);
-                               store_reg_to_var_flt(iptr->dst, d);
                                break;
                        }
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_PUTSTATIC:  /* ..., value  ==> ...                          */
                                      /* op1 = type, val.a = field address            */
 
-                       if (iptr->val.a == NULL) {
-                               disp = dseg_addaddress(cd, 0);
+                       if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+                               unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr);
+
+                               disp = dseg_add_unique_address(cd, uf);
 
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_get_putstatic,
-                                                                       (unresolved_field *) iptr->target, disp);
+                               codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
 
                                if (opt_showdisassemble)
                                        M_NOP;
+                       }
+                       else {
+                               fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
 
-                       } else {
-                               fieldinfo *fi = iptr->val.a;
-
-                               disp = dseg_addaddress(cd, &(fi->value));
+                               disp = dseg_add_address(cd, &(fi->value));
 
                                if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_clinit, fi->class, 0);
+                                       codegen_addpatchref(cd, PATCHER_initialize_class, fi->class,
+                                                                               0);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
@@ -2109,24 +2065,24 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                        M_ALD(REG_ITMP1, REG_PV, disp);
                        switch (iptr->op1) {
                        case TYPE_INT:
-                               var_to_reg_int(s2, src, REG_ITMP2);
-                               M_IST(s2, REG_ITMP1, 0);
+                               s1 = emit_load_s1(jd, iptr, src, REG_ITMP2);
+                               M_IST(s1, REG_ITMP1, 0);
                                break;
                        case TYPE_LNG:
-                               var_to_reg_int(s2, src, REG_ITMP2);
-                               M_LST(s2, REG_ITMP1, 0);
+                               s1 = emit_load_s1(jd, iptr, src, REG_ITMP2);
+                               M_LST(s1, REG_ITMP1, 0);
                                break;
                        case TYPE_ADR:
-                               var_to_reg_int(s2, src, REG_ITMP2);
-                               M_AST(s2, REG_ITMP1, 0);
+                               s1 = emit_load_s1(jd, iptr, src, REG_ITMP2);
+                               M_AST(s1, REG_ITMP1, 0);
                                break;
                        case TYPE_FLT:
-                               var_to_reg_flt(s2, src, REG_FTMP2);
-                               M_FST(s2, REG_ITMP1, 0);
+                               s1 = emit_load_s1(jd, iptr, src, REG_FTMP2);
+                               M_FST(s1, REG_ITMP1, 0);
                                break;
                        case TYPE_DBL:
-                               var_to_reg_flt(s2, src, REG_FTMP2);
-                               M_DST(s2, REG_ITMP1, 0);
+                               s1 = emit_load_s1(jd, iptr, src, REG_FTMP2);
+                               M_DST(s1, REG_ITMP1, 0);
                                break;
                        }
                        break;
@@ -2136,24 +2092,24 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                          /* op1 = type, val.a = field address (in    */
                                          /* following NOP)                           */
 
-                       if (iptr[1].val.a == NULL) {
-                               disp = dseg_addaddress(cd, 0);
+                       if (INSTRUCTION_IS_UNRESOLVED(iptr + 1)) {
+                               unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr + 1);
 
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_get_putstatic,
-                                                                       (unresolved_field *) iptr[1].target, disp);
+                               disp = dseg_add_unique_address(cd, uf);
+
+                               codegen_addpatchref(cd, PATCHER_get_putstatic, uf, disp);
 
                                if (opt_showdisassemble)
                                        M_NOP;
-
-                       else {
-                               fieldinfo *fi = iptr[1].val.a;
+                       }
+                       else {
+                               fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr + 1);
        
-                               disp = dseg_addaddress(cd, &(fi->value));
+                               disp = dseg_add_address(cd, &(fi->value));
 
                                if (!CLASS_IS_OR_ALMOST_INITIALIZED(fi->class)) {
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_clinit, fi->class, 0);
+                                       codegen_addpatchref(cd, PATCHER_initialize_class, fi->class,
+                                                                               0);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
@@ -2184,76 +2140,74 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                case ICMD_GETFIELD:   /* ...  ==> ..., value                          */
                                      /* op1 = type, val.i = field offset             */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        gen_nullptr_check(s1);
 
-                       if (iptr->val.a == NULL) {
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_get_putfield,
-                                                                       (unresolved_field *) iptr->target, 0);
+                       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;
-
-                       } else {
-                               disp = ((fieldinfo *) (iptr->val.a))->offset;
+                       }
+                       else {
+                               fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
+                               disp = fi->offset;
                        }
 
                        switch (iptr->op1) {
                        case TYPE_INT:
-                               d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                                M_ILD(d, s1, disp);
-                               store_reg_to_var_int(iptr->dst, d);
                                break;
                        case TYPE_LNG:
-                               d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                                M_LLD(d, s1, disp);
-                               store_reg_to_var_int(iptr->dst, d);
                                break;
                        case TYPE_ADR:
-                               d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                                M_ALD(d, s1, disp);
-                               store_reg_to_var_int(iptr->dst, d);
                                break;
                        case TYPE_FLT:
-                               d = reg_of_var(rd, iptr->dst, REG_FTMP1);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
                                M_FLD(d, s1, disp);
-                               store_reg_to_var_flt(iptr->dst, d);
                                break;
                        case TYPE_DBL:                          
-                               d = reg_of_var(rd, iptr->dst, REG_FTMP1);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FTMP1);
                                M_DLD(d, s1, disp);
-                               store_reg_to_var_flt(iptr->dst, d);
                                break;
                        }
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_PUTFIELD:   /* ..., objectref, value  ==> ...               */
                                      /* op1 = type, val.a = field address            */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
                        gen_nullptr_check(s1);
 
                        if (!IS_FLT_DBL_TYPE(iptr->op1)) {
-                               var_to_reg_int(s2, src, REG_ITMP2);
+                               s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
                        } else {
-                               var_to_reg_flt(s2, src, REG_FTMP2);
+                               s2 = emit_load_s2(jd, iptr, src, REG_FTMP2);
                        }
 
-                       if (iptr->val.a == NULL) {
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_get_putfield,
-                                                                       (unresolved_field *) iptr->target, 0);
+                       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;
-
-                       } else {
-                               disp = ((fieldinfo *) (iptr->val.a))->offset;
+                       }
+                       else {
+                               fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr);
+                               disp = fi->offset;
                        }
 
                        switch (iptr->op1) {
@@ -2280,21 +2234,22 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                          /* op1 = type, val.a = field address (in    */
                                          /* following NOP)                           */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        gen_nullptr_check(s1);
 
-                       if (iptr[1].val.a == NULL) {
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_get_putfield,
-                                                                       (unresolved_field *) iptr[1].target, 0);
+                       if (INSTRUCTION_IS_UNRESOLVED(iptr + 1)) {
+                               unresolved_field *uf = INSTRUCTION_UNRESOLVED_FIELD(iptr + 1);
+
+                               codegen_addpatchref(cd, PATCHER_get_putfield, uf, 0);
 
                                if (opt_showdisassemble)
                                        M_NOP;
 
                                disp = 0;
-
-                       } else {
-                               disp = ((fieldinfo *) (iptr[1].val.a))->offset;
+                       }
+                       else {
+                               fieldinfo *fi = INSTRUCTION_RESOLVED_FIELDINFO(iptr + 1);
+                               disp = fi->offset;
                        }
 
                        switch (iptr[1].op1) {
@@ -2321,21 +2276,21 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
 
                case ICMD_ATHROW:       /* ..., objectref ==> ... (, objectref)       */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        M_INTMOVE(s1, REG_ITMP1_XPTR);
 
 #ifdef ENABLE_VERIFIER
                        if (iptr->val.a) {
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_athrow_areturn,
-                                                                       (unresolved_class *) iptr->val.a, 0);
+                               unresolved_class *uc = INSTRUCTION_UNRESOLVED_CLASS(iptr);
+
+                               codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
 
                                if (opt_showdisassemble)
                                        M_NOP;
                        }
 #endif /* ENABLE_VERIFIER */
 
-                       disp = dseg_addaddress(cd, asm_handle_exception);
+                       disp = dseg_add_functionptr(cd, asm_handle_exception);
                        M_ALD(REG_ITMP2, REG_PV, disp);
                        M_JMP(REG_ITMP2_XPC, REG_ITMP2);
                        M_NOP;              /* nop ensures that XPC is less than the end */
@@ -2346,7 +2301,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                case ICMD_GOTO:         /* ... ==> ...                                */
                                        /* op1 = target JavaVM pc                     */
                        M_BR(0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        ALIGNCODENOP;
                        break;
 
@@ -2354,7 +2309,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        /* op1 = target JavaVM pc                     */
 
                        M_BSR(REG_ITMP1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
                        
                case ICMD_RET:          /* ... ==> ...                                */
@@ -2373,23 +2328,23 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                case ICMD_IFNULL:       /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc                     */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        M_BEQZ(s1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IFNONNULL:    /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc                     */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        M_BNEZ(s1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IFEQ:         /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.i = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.i == 0) {
                                M_BEQZ(s1, 0);
                                }
@@ -2403,13 +2358,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BNEZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IFLT:         /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.i = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.i == 0) {
                                M_BLTZ(s1, 0);
                                }
@@ -2423,13 +2378,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BNEZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IFLE:         /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.i = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.i == 0) {
                                M_BLEZ(s1, 0);
                                }
@@ -2443,13 +2398,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BNEZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IFNE:         /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.i = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.i == 0) {
                                M_BNEZ(s1, 0);
                                }
@@ -2463,13 +2418,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BEQZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IFGT:         /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.i = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.i == 0) {
                                M_BGTZ(s1, 0);
                                }
@@ -2483,13 +2438,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BEQZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IFGE:         /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.i = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.i == 0) {
                                M_BGEZ(s1, 0);
                                }
@@ -2503,13 +2458,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BEQZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_LEQ:       /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.l = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.l == 0) {
                                M_BEQZ(s1, 0);
                                }
@@ -2523,13 +2478,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BNEZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_LLT:       /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.l = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.l == 0) {
                                M_BLTZ(s1, 0);
                                }
@@ -2543,13 +2498,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BNEZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_LLE:       /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.l = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.l == 0) {
                                M_BLEZ(s1, 0);
                                }
@@ -2563,13 +2518,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BNEZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_LNE:       /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.l = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.l == 0) {
                                M_BNEZ(s1, 0);
                                }
@@ -2583,13 +2538,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BEQZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_LGT:       /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.l = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.l == 0) {
                                M_BGTZ(s1, 0);
                                }
@@ -2603,13 +2558,13 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BEQZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_LGE:       /* ..., value ==> ...                         */
                                        /* op1 = target JavaVM pc, val.l = constant   */
 
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (iptr->val.l == 0) {
                                M_BGEZ(s1, 0);
                                }
@@ -2623,288 +2578,89 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                                        }
                                M_BEQZ(REG_ITMP1, 0);
                                }
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_ICMPEQ:    /* ..., value, value ==> ...                  */
                case ICMD_IF_LCMPEQ:    /* op1 = target JavaVM pc                     */
                case ICMD_IF_ACMPEQ:
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
+                       s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
                        M_CMPEQ(s1, s2, REG_ITMP1);
                        M_BNEZ(REG_ITMP1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_ICMPNE:    /* ..., value, value ==> ...                  */
                case ICMD_IF_LCMPNE:    /* op1 = target JavaVM pc                     */
                case ICMD_IF_ACMPNE:
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
+                       s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
                        M_CMPEQ(s1, s2, REG_ITMP1);
                        M_BEQZ(REG_ITMP1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_ICMPLT:    /* ..., value, value ==> ...                  */
                case ICMD_IF_LCMPLT:    /* op1 = target JavaVM pc                     */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
+                       s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
                        M_CMPLT(s1, s2, REG_ITMP1);
                        M_BNEZ(REG_ITMP1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_ICMPGT:    /* ..., value, value ==> ...                  */
                case ICMD_IF_LCMPGT:    /* op1 = target JavaVM pc                     */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
+                       s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
                        M_CMPLE(s1, s2, REG_ITMP1);
                        M_BEQZ(REG_ITMP1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_ICMPLE:    /* ..., value, value ==> ...                  */
                case ICMD_IF_LCMPLE:    /* op1 = target JavaVM pc                     */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
+                       s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
                        M_CMPLE(s1, s2, REG_ITMP1);
                        M_BNEZ(REG_ITMP1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
                case ICMD_IF_ICMPGE:    /* ..., value, value ==> ...                  */
                case ICMD_IF_LCMPGE:    /* op1 = target JavaVM pc                     */
 
-                       var_to_reg_int(s1, src->prev, REG_ITMP1);
-                       var_to_reg_int(s2, src, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src->prev, REG_ITMP1);
+                       s2 = emit_load_s2(jd, iptr, src, REG_ITMP2);
                        M_CMPLT(s1, s2, REG_ITMP1);
                        M_BEQZ(REG_ITMP1, 0);
-                       codegen_addreference(cd, (basicblock *) iptr->target, mcodeptr);
-                       break;
-
-               /* (value xx 0) ? IFxx_ICONST : ELSE_ICONST                           */
-
-               case ICMD_ELSE_ICONST:  /* handled by IFxx_ICONST                     */
-                       break;
-
-               case ICMD_IFEQ_ICONST:  /* ..., value ==> ..., constant               */
-                                       /* val.i = constant                           */
-
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
-                       s3 = iptr->val.i;
-                       if (iptr[1].opc == ICMD_ELSE_ICONST) {
-                               if ((s3 == 1) && (iptr[1].val.i == 0)) {
-                                       M_CMPEQ(s1, REG_ZERO, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if ((s3 == 0) && (iptr[1].val.i == 1)) {
-                                       M_CMPEQ(s1, REG_ZERO, d);
-                                       M_XOR_IMM(d, 1, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if (s1 == d) {
-                                       M_MOV(s1, REG_ITMP1);
-                                       s1 = REG_ITMP1;
-                               }
-                               ICONST(d, iptr[1].val.i);
-                       }
-                       if ((s3 >= 0) && (s3 <= 255)) {
-                               M_CMOVEQ_IMM(s1, s3, d);
-                       } else {
-                               ICONST(REG_ITMP3, s3);
-                               M_CMOVEQ(s1, REG_ITMP3, d);
-                       }
-                       store_reg_to_var_int(iptr->dst, d);
-                       break;
-
-               case ICMD_IFNE_ICONST:  /* ..., value ==> ..., constant               */
-                                       /* val.i = constant                           */
-
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
-                       s3 = iptr->val.i;
-                       if (iptr[1].opc == ICMD_ELSE_ICONST) {
-                               if ((s3 == 0) && (iptr[1].val.i == 1)) {
-                                       M_CMPEQ(s1, REG_ZERO, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if ((s3 == 1) && (iptr[1].val.i == 0)) {
-                                       M_CMPEQ(s1, REG_ZERO, d);
-                                       M_XOR_IMM(d, 1, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if (s1 == d) {
-                                       M_MOV(s1, REG_ITMP1);
-                                       s1 = REG_ITMP1;
-                               }
-                               ICONST(d, iptr[1].val.i);
-                       }
-                       if ((s3 >= 0) && (s3 <= 255)) {
-                               M_CMOVNE_IMM(s1, s3, d);
-                       } else {
-                               ICONST(REG_ITMP3, s3);
-                               M_CMOVNE(s1, REG_ITMP3, d);
-                       }
-                       store_reg_to_var_int(iptr->dst, d);
-                       break;
-
-               case ICMD_IFLT_ICONST:  /* ..., value ==> ..., constant               */
-                                       /* val.i = constant                           */
-
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
-                       s3 = iptr->val.i;
-                       if ((iptr[1].opc == ICMD_ELSE_ICONST)) {
-                               if ((s3 == 1) && (iptr[1].val.i == 0)) {
-                                       M_CMPLT(s1, REG_ZERO, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if ((s3 == 0) && (iptr[1].val.i == 1)) {
-                                       M_CMPLE(REG_ZERO, s1, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if (s1 == d) {
-                                       M_MOV(s1, REG_ITMP1);
-                                       s1 = REG_ITMP1;
-                               }
-                               ICONST(d, iptr[1].val.i);
-                       }
-                       if ((s3 >= 0) && (s3 <= 255)) {
-                               M_CMOVLT_IMM(s1, s3, d);
-                       } else {
-                               ICONST(REG_ITMP3, s3);
-                               M_CMOVLT(s1, REG_ITMP3, d);
-                       }
-                       store_reg_to_var_int(iptr->dst, d);
-                       break;
-
-               case ICMD_IFGE_ICONST:  /* ..., value ==> ..., constant               */
-                                       /* val.i = constant                           */
-
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
-                       s3 = iptr->val.i;
-                       if ((iptr[1].opc == ICMD_ELSE_ICONST)) {
-                               if ((s3 == 1) && (iptr[1].val.i == 0)) {
-                                       M_CMPLE(REG_ZERO, s1, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if ((s3 == 0) && (iptr[1].val.i == 1)) {
-                                       M_CMPLT(s1, REG_ZERO, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if (s1 == d) {
-                                       M_MOV(s1, REG_ITMP1);
-                                       s1 = REG_ITMP1;
-                               }
-                               ICONST(d, iptr[1].val.i);
-                       }
-                       if ((s3 >= 0) && (s3 <= 255)) {
-                               M_CMOVGE_IMM(s1, s3, d);
-                       } else {
-                               ICONST(REG_ITMP3, s3);
-                               M_CMOVGE(s1, REG_ITMP3, d);
-                       }
-                       store_reg_to_var_int(iptr->dst, d);
-                       break;
-
-               case ICMD_IFGT_ICONST:  /* ..., value ==> ..., constant               */
-                                       /* val.i = constant                           */
-
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
-                       s3 = iptr->val.i;
-                       if ((iptr[1].opc == ICMD_ELSE_ICONST)) {
-                               if ((s3 == 1) && (iptr[1].val.i == 0)) {
-                                       M_CMPLT(REG_ZERO, s1, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if ((s3 == 0) && (iptr[1].val.i == 1)) {
-                                       M_CMPLE(s1, REG_ZERO, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if (s1 == d) {
-                                       M_MOV(s1, REG_ITMP1);
-                                       s1 = REG_ITMP1;
-                               }
-                               ICONST(d, iptr[1].val.i);
-                       }
-                       if ((s3 >= 0) && (s3 <= 255)) {
-                               M_CMOVGT_IMM(s1, s3, d);
-                       } else {
-                               ICONST(REG_ITMP3, s3);
-                               M_CMOVGT(s1, REG_ITMP3, d);
-                       }
-                       store_reg_to_var_int(iptr->dst, d);
-                       break;
-
-               case ICMD_IFLE_ICONST:  /* ..., value ==> ..., constant               */
-                                       /* val.i = constant                           */
-
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
-                       s3 = iptr->val.i;
-                       if ((iptr[1].opc == ICMD_ELSE_ICONST)) {
-                               if ((s3 == 1) && (iptr[1].val.i == 0)) {
-                                       M_CMPLE(s1, REG_ZERO, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if ((s3 == 0) && (iptr[1].val.i == 1)) {
-                                       M_CMPLT(REG_ZERO, s1, d);
-                                       store_reg_to_var_int(iptr->dst, d);
-                                       break;
-                               }
-                               if (s1 == d) {
-                                       M_MOV(s1, REG_ITMP1);
-                                       s1 = REG_ITMP1;
-                               }
-                               ICONST(d, iptr[1].val.i);
-                       }
-                       if ((s3 >= 0) && (s3 <= 255)) {
-                               M_CMOVLE_IMM(s1, s3, d);
-                       } else {
-                               ICONST(REG_ITMP3, s3);
-                               M_CMOVLE(s1, REG_ITMP3, d);
-                       }
-                       store_reg_to_var_int(iptr->dst, d);
+                       codegen_addreference(cd, (basicblock *) iptr->target);
                        break;
 
 
                case ICMD_IRETURN:      /* ..., retvalue ==> ...                      */
                case ICMD_LRETURN:
 
-                       var_to_reg_int(s1, src, REG_RESULT);
+                       s1 = emit_load_s1(jd, iptr, src, REG_RESULT);
                        M_INTMOVE(s1, REG_RESULT);
                        goto nowperformreturn;
 
                case ICMD_ARETURN:      /* ..., retvalue ==> ...                      */
 
-                       var_to_reg_int(s1, src, REG_RESULT);
+                       s1 = emit_load_s1(jd, iptr, src, REG_RESULT);
                        M_INTMOVE(s1, REG_RESULT);
 
 #ifdef ENABLE_VERIFIER
                        if (iptr->val.a) {
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_athrow_areturn,
-                                                                       (unresolved_class *) iptr->val.a, 0);
+                               unresolved_class *uc = INSTRUCTION_UNRESOLVED_CLASS(iptr);
+
+                               codegen_addpatchref(cd, PATCHER_resolve_class, uc, 0);
 
                                if (opt_showdisassemble)
                                        M_NOP;
@@ -2915,7 +2671,7 @@ bool codegen(methodinfo *m, codegendata *cd, registerdata *rd)
                case ICMD_FRETURN:      /* ..., retvalue ==> ...                      */
                case ICMD_DRETURN:
 
-                       var_to_reg_flt(s1, src, REG_FRESULT);
+                       s1 = emit_load_s1(jd, iptr, src, REG_FRESULT);
                        M_FLTMOVE(s1, REG_FRESULT);
                        goto nowperformreturn;
 
@@ -2925,35 +2681,16 @@ nowperformreturn:
                        {
                        s4 i, p;
                        
-                       p = parentargs_base;
+                       p = cd->stackframesize;
                        
                        /* call trace function */
 
-                       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_addaddress(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_addaddress(cd, (void *) builtin_displaymethodstop);
-                               M_ALD(REG_PV, REG_PV, disp);
-                               M_JSR(REG_RA, REG_PV);
-                               disp = (s4) ((u1 *) 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 !defined(NDEBUG)
+                       if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
+                               emit_verbosecall_exit(jd);
+#endif
 
-#if defined(USE_THREADS)
+#if defined(ENABLE_THREADS)
                        if (checksync && (m->flags & ACC_SYNCHRONIZED)) {
                                M_ALD(rd->argintregs[0], REG_SP, rd->memuse * 8);
 
@@ -2969,10 +2706,10 @@ nowperformreturn:
                                        break;
                                }
 
-                               disp = dseg_addaddress(cd, BUILTIN_monitorexit);
+                               disp = dseg_add_functionptr(cd, LOCK_monitor_exit);
                                M_ALD(REG_PV, REG_PV, disp);
                                M_JSR(REG_RA, REG_PV);
-                               disp = -(s4) ((u1 *) mcodeptr - cd->mcodebase);
+                               disp = -(s4) (cd->mcodeptr - cd->mcodebase);
                                M_LDA(REG_PV, REG_RA, disp);
 
                                switch (iptr->opc) {
@@ -2991,7 +2728,7 @@ nowperformreturn:
 
                        /* restore return address                                         */
 
-                       if (!m->isleafmethod) {
+                       if (!jd->isleafmethod) {
                                p--; M_LLD(REG_RA, REG_SP, p * 8);
                        }
 
@@ -3006,9 +2743,8 @@ nowperformreturn:
 
                        /* deallocate stack                                               */
 
-                       if (parentargs_base) {
-                               M_LDA(REG_SP, REG_SP, parentargs_base * 8);
-                       }
+                       if (cd->stackframesize)
+                               M_LDA(REG_SP, REG_SP, cd->stackframesize * 8);
 
                        M_RET(REG_ZERO, REG_RA);
                        ALIGNCODENOP;
@@ -3027,7 +2763,7 @@ nowperformreturn:
                        l = s4ptr[1];                          /* low     */
                        i = s4ptr[2];                          /* high    */
                        
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        if (l == 0) {
                                M_INTMOVE(s1, REG_ITMP1);
                        } else if (l <= 32768) {
@@ -3047,7 +2783,7 @@ nowperformreturn:
                                M_CMPULE(REG_ITMP1, REG_ITMP2, REG_ITMP2);
                        }
                        M_BEQZ(REG_ITMP2, 0);
-                       codegen_addreference(cd, (basicblock *) tptr[0], mcodeptr);
+                       codegen_addreference(cd, (basicblock *) tptr[0]);
 
                        /* build jump table top down and use address of lowest entry */
 
@@ -3055,12 +2791,12 @@ nowperformreturn:
                        tptr += i;
 
                        while (--i >= 0) {
-                               dseg_addtarget(cd, (basicblock *) tptr[0]); 
+                               dseg_add_target(cd, (basicblock *) tptr[0]); 
                                --tptr;
                        }
                        }
 
-                       /* length of dataseg after last dseg_addtarget is used by load */
+                       /* length of dataseg after last dseg_add_target is used by load */
 
                        M_SAADDQ(REG_ITMP1, REG_PV, REG_ITMP2);
                        M_ALD(REG_ITMP2, REG_ITMP2, -(cd->dseglen));
@@ -3081,7 +2817,7 @@ nowperformreturn:
                        i = s4ptr[1];                          /* count    */
                        
                        MCODECHECK((i<<2)+8);
-                       var_to_reg_int(s1, src, REG_ITMP1);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
                        while (--i >= 0) {
                                s4ptr += 2;
                                ++tptr;
@@ -3093,19 +2829,19 @@ nowperformreturn:
                                        if ((val >= -32768) && (val <= 32767)) {
                                                M_LDA(REG_ITMP2, REG_ZERO, val);
                                        } else {
-                                               disp = dseg_adds4(cd, val);
+                                               disp = dseg_add_s4(cd, val);
                                                M_ILD(REG_ITMP2, REG_PV, disp);
                                        }
                                        M_CMPEQ(s1, REG_ITMP2, REG_ITMP2);
                                }
                                M_BNEZ(REG_ITMP2, 0);
-                               codegen_addreference(cd, (basicblock *) tptr[0], mcodeptr); 
+                               codegen_addreference(cd, (basicblock *) tptr[0]); 
                        }
 
                        M_BR(0);
                        
                        tptr = (void **) iptr->target;
-                       codegen_addreference(cd, (basicblock *) tptr[0], mcodeptr);
+                       codegen_addreference(cd, (basicblock *) tptr[0]);
 
                        ALIGNCODENOP;
                        break;
@@ -3126,12 +2862,12 @@ nowperformreturn:
                case ICMD_INVOKEVIRTUAL:/* op1 = arg count, val.a = method pointer    */
                case ICMD_INVOKEINTERFACE:
 
-                       lm = iptr->val.a;
-
-                       if (lm == NULL) {
-                               unresolved_method *um = iptr->target;
-                               md = um->methodref->parseddesc.md;
-                       } else {
+                       if (INSTRUCTION_IS_UNRESOLVED(iptr)) {
+                               md = INSTRUCTION_UNRESOLVED_METHOD(iptr)->methodref->parseddesc.md;
+                               lm = NULL;
+                       }
+                       else {
+                               lm = INSTRUCTION_RESOLVED_METHODINFO(iptr);
                                md = lm->parseddesc;
                        }
 
@@ -3148,20 +2884,20 @@ gen_method:
                                if (IS_INT_LNG_TYPE(src->type)) {
                                        if (!md->params[s3].inmemory) {
                                                s1 = rd->argintregs[md->params[s3].regoff];
-                                               var_to_reg_int(d, src, s1);
+                                               d = emit_load_s1(jd, iptr, src, s1);
                                                M_INTMOVE(d, s1);
                                        } else {
-                                               var_to_reg_int(d, src, REG_ITMP1);
+                                               d = emit_load_s1(jd, iptr, src, REG_ITMP1);
                                                M_LST(d, REG_SP, md->params[s3].regoff * 8);
                                        }
 
                                } else {
                                        if (!md->params[s3].inmemory) {
                                                s1 = rd->argfltregs[md->params[s3].regoff];
-                                               var_to_reg_flt(d, src, s1);
+                                               d = emit_load_s1(jd, iptr, src, s1);
                                                M_FLTMOVE(d, s1);
                                        } else {
-                                               var_to_reg_flt(d, src, REG_FTMP1);
+                                               d = emit_load_s1(jd, iptr, src, REG_FTMP1);
                                                M_DST(d, REG_SP, md->params[s3].regoff * 8);
                                        }
                                }
@@ -3169,68 +2905,67 @@ gen_method:
 
                        switch (iptr->opc) {
                        case ICMD_BUILTIN:
-                               disp = dseg_addaddress(cd, bte->fp);
+                               disp = dseg_add_functionptr(cd, bte->fp);
                                d = md->returntype.type;
 
                                M_ALD(REG_PV, REG_PV, disp);  /* Pointer to built-in-function */
                                M_JSR(REG_RA, REG_PV);
-                               disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                               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, mcodeptr);
+                                       codegen_add_fillinstacktrace_ref(cd);
                                }
                                break;
 
                        case ICMD_INVOKESPECIAL:
                                M_BEQZ(rd->argintregs[0], 0);
-                               codegen_add_nullpointerexception_ref(cd, mcodeptr);
+                               codegen_add_nullpointerexception_ref(cd);
                                /* fall through */
 
                        case ICMD_INVOKESTATIC:
-                               if (!lm) {
-                                       unresolved_method *um = iptr->target;
+                               if (lm == NULL) {
+                                       unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr);
 
-                                       disp = dseg_addaddress(cd, NULL);
+                                       disp = dseg_add_unique_address(cd, um);
 
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_invokestatic_special, um, disp);
+                                       codegen_addpatchref(cd, PATCHER_invokestatic_special,
+                                                                               um, disp);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
 
                                        d = um->methodref->parseddesc.md->returntype.type;
-
-                               else {
-                                       disp = dseg_addaddress(cd, lm->stubroutine);
+                               }
+                               else {
+                                       disp = dseg_add_address(cd, lm->stubroutine);
                                        d = lm->parseddesc->returntype.type;
                                }
 
                                M_ALD(REG_PV, REG_PV, disp);         /* method pointer in r27 */
                                M_JSR(REG_RA, REG_PV);
-                               disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                               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) {
-                                       unresolved_method *um = iptr->target;
+                               if (lm == NULL) {
+                                       unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr);
 
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_invokevirtual, um, 0);
+                                       codegen_addpatchref(cd, PATCHER_invokevirtual, um, 0);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
 
                                        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;
@@ -3240,18 +2975,17 @@ gen_method:
                                          OFFSET(java_objectheader, vftbl));
                                M_ALD(REG_PV, REG_METHODPTR, s1);
                                M_JSR(REG_RA, REG_PV);
-                               disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                               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) {
-                                       unresolved_method *um = iptr->target;
+                               if (lm == NULL) {
+                                       unresolved_method *um = INSTRUCTION_UNRESOLVED_METHOD(iptr);
 
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_invokeinterface, um, 0);
+                                       codegen_addpatchref(cd, PATCHER_invokeinterface, um, 0);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
@@ -3259,8 +2993,8 @@ gen_method:
                                        s1 = 0;
                                        s2 = 0;
                                        d = um->methodref->parseddesc.md->returntype.type;
-
-                               else {
+                               }
+                               else {
                                        s1 = OFFSET(vftbl_t, interfacetable[0]) -
                                                sizeof(methodptr*) * lm->class->index;
 
@@ -3274,7 +3008,7 @@ gen_method:
                                M_ALD(REG_METHODPTR, REG_METHODPTR, s1);
                                M_ALD(REG_PV, REG_METHODPTR, s2);
                                M_JSR(REG_RA, REG_PV);
-                               disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                               disp = (s4) (cd->mcodeptr - cd->mcodebase);
                                M_LDA(REG_PV, REG_RA, -disp);
                                break;
                        }
@@ -3283,14 +3017,15 @@ gen_method:
 
                        if (d != TYPE_VOID) {
                                if (IS_INT_LNG_TYPE(iptr->dst->type)) {
-                                       s1 = reg_of_var(rd, iptr->dst, REG_RESULT);
+                                       s1 = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT);
                                        M_INTMOVE(REG_RESULT, s1);
-                                       store_reg_to_var_int(iptr->dst, s1);
+/*                                     emit_store(jd, iptr, iptr->dst, s1); */
                                } else {
-                                       s1 = reg_of_var(rd, iptr->dst, REG_FRESULT);
+                                       s1 = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_FRESULT);
                                        M_FLTMOVE(REG_FRESULT, s1);
-                                       store_reg_to_var_flt(iptr->dst, s1);
+/*                                     emit_store(jd, iptr, iptr->dst, s1); */
                                }
+                               emit_store(jd, iptr, iptr->dst, s1);
                        }
                        break;
 
@@ -3322,41 +3057,40 @@ gen_method:
 
                                super = (classinfo *) iptr->val.a;
 
-                               if (!super) {
+                               if (super == NULL) {
                                        superindex = 0;
                                        supervftbl = NULL;
-
-                               else {
+                               }
+                               else {
                                        superindex = super->index;
                                        supervftbl = super->vftbl;
                                }
                        
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-                               codegen_threadcritrestart(cd, (u1 *) mcodeptr - cd->mcodebase);
+#if defined(ENABLE_THREADS)
+                               codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
 #endif
-                               var_to_reg_int(s1, src, REG_ITMP1);
+                               s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
 
                                /* calculate interface checkcast code size */
 
                                s2 = 6;
-                               if (!super)
+                               if (super == NULL)
                                        s2 += opt_showdisassemble ? 1 : 0;
 
                                /* calculate class checkcast code size */
 
                                s3 = 9 /* 8 + (s1 == REG_ITMP1) */;
-                               if (!super)
+                               if (super == NULL)
                                        s3 += opt_showdisassemble ? 1 : 0;
 
                                /* if class is not resolved, check which code to call */
 
-                               if (!super) {
+                               if (super == NULL) {
                                        M_BEQZ(s1, 4 + (opt_showdisassemble ? 1 : 0) + s2 + 1 + s3);
 
-                                       disp = dseg_adds4(cd, 0);                 /* super->flags */
+                                       disp = dseg_add_unique_s4(cd, 0);         /* super->flags */
 
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_checkcast_instanceof_flags,
+                                       codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags,
                                                                                (constant_classref *) iptr->target,
                                                                                disp);
 
@@ -3364,7 +3098,7 @@ gen_method:
                                                M_NOP;
 
                                        M_ILD(REG_ITMP2, REG_PV, disp);
-                                       disp = dseg_adds4(cd, ACC_INTERFACE);
+                                       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);
@@ -3372,12 +3106,9 @@ gen_method:
 
                                /* interface checkcast code */
 
-                               if (!super || (super->flags & ACC_INTERFACE)) {
-                                       if (super) {
-                                               M_BEQZ(s1, s2);
-
-                                       } else {
-                                               codegen_addpatchref(cd, mcodeptr,
+                               if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
+                                       if (super == NULL) {
+                                               codegen_addpatchref(cd,
                                                                                        PATCHER_checkcast_instanceof_interface,
                                                                                        (constant_classref *) iptr->target,
                                                                                        0);
@@ -3385,51 +3116,55 @@ gen_method:
                                                if (opt_showdisassemble)
                                                        M_NOP;
                                        }
+                                       else
+                                               M_BEQZ(s1, s2);
 
                                        M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, 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, mcodeptr);
+                                       codegen_add_classcastexception_ref(cd, 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, mcodeptr);
+                                       codegen_add_classcastexception_ref(cd, s1);
 
-                                       if (!super)
+                                       if (super == NULL)
                                                M_BR(s3);
                                }
 
                                /* class checkcast code */
 
-                               if (!super || !(super->flags & ACC_INTERFACE)) {
-                                       disp = dseg_addaddress(cd, supervftbl);
+                               if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
+                                       if (super == NULL) {
+                                               disp = dseg_add_unique_address(cd, NULL);
 
-                                       if (super) {
-                                               M_BEQZ(s1, s3);
-
-                                       } else {
-                                               codegen_addpatchref(cd, mcodeptr,
-                                                                                       PATCHER_checkcast_instanceof_class,
+                                               codegen_addpatchref(cd,
+                                                                                       PATCHER_resolve_classref_to_vftbl,
                                                                                        (constant_classref *) iptr->target,
                                                                                        disp);
 
                                                if (opt_showdisassemble)
                                                        M_NOP;
                                        }
+                                       else {
+                                               disp = dseg_add_address(cd, supervftbl);
+
+                                               M_BEQZ(s1, s3);
+                                       }
 
                                        M_ALD(REG_ITMP2, s1, OFFSET(java_objectheader, vftbl));
                                        M_ALD(REG_ITMP3, REG_PV, disp);
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-                                       codegen_threadcritstart(cd, (u1 *) mcodeptr - cd->mcodebase);
+#if defined(ENABLE_THREADS)
+                                       codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
 #endif
                                        M_ILD(REG_ITMP2, REG_ITMP2, OFFSET(vftbl_t, baseval));
                                        /*                              if (s1 != REG_ITMP1) { */
                                        /*                                      M_ILD(REG_ITMP1, REG_ITMP3, OFFSET(vftbl_t, baseval)); */
                                        /*                                      M_ILD(REG_ITMP3, REG_ITMP3, OFFSET(vftbl_t, diffval)); */
-                                       /*  #if defined(USE_THREADS) && defined(NATIVE_THREADS) */
+                                       /*  #if defined(ENABLE_THREADS) */
                                        /*                                      codegen_threadcritstop(cd, (u1 *) mcodeptr - cd->mcodebase); */
                                        /*  #endif */
                                        /*                                      M_ISUB(REG_ITMP2, REG_ITMP1, REG_ITMP2); */
@@ -3439,27 +3174,28 @@ 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(USE_THREADS) && defined(NATIVE_THREADS)
-                                       codegen_threadcritstop(cd, (u1 *) mcodeptr - cd->mcodebase);
+#if defined(ENABLE_THREADS)
+                                       codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
 #endif
                                        /*                              } */
                                        M_CMPULE(REG_ITMP2, REG_ITMP3, REG_ITMP3);
                                        M_BEQZ(REG_ITMP3, 0);
-                                       codegen_add_classcastexception_ref(cd, mcodeptr);
+                                       codegen_add_classcastexception_ref(cd, s1);
                                }
-                               d = reg_of_var(rd, iptr->dst, s1);
 
-                       } else {
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, s1);
+                       }
+                       else {
                                /* array type cast-check */
 
-                               var_to_reg_int(s1, src, rd->argintregs[0]);
+                               s1 = emit_load_s1(jd, iptr, src, rd->argintregs[0]);
                                M_INTMOVE(s1, rd->argintregs[0]);
 
                                disp = dseg_addaddress(cd, iptr->val.a);
 
                                if (iptr->val.a == NULL) {
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_builtin_arraycheckcast,
+                                       codegen_addpatchref(cd,
+                                                                               PATCHER_resolve_classref_to_classinfo,
                                                                                (constant_classref *) iptr->target,
                                                                                disp);
 
@@ -3471,17 +3207,18 @@ gen_method:
                                disp = dseg_addaddress(cd, BUILTIN_arraycheckcast);
                                M_ALD(REG_PV, REG_PV, disp);
                                M_JSR(REG_RA, REG_PV);
-                               disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                               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, mcodeptr);
+                               codegen_add_classcastexception_ref(cd, s1);
 
-                               var_to_reg_int(s1, src, REG_ITMP1);
-                               d = reg_of_var(rd, iptr->dst, s1);
+                               d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, s1);
                        }
+
                        M_INTMOVE(s1, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                case ICMD_INSTANCEOF: /* ..., objectref ==> ..., intresult            */
@@ -3509,20 +3246,20 @@ gen_method:
 
                        super = (classinfo *) iptr->val.a;
 
-                       if (!super) {
+                       if (super == NULL) {
                                superindex = 0;
                                supervftbl = NULL;
-
-                       else {
+                       }
+                       else {
                                superindex = super->index;
                                supervftbl = super->vftbl;
                        }
                        
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-                       codegen_threadcritrestart(cd, (u1 *) mcodeptr - cd->mcodebase);
+#if defined(ENABLE_THREADS)
+                       codegen_threadcritrestart(cd, cd->mcodeptr - cd->mcodebase);
 #endif
-                       var_to_reg_int(s1, src, REG_ITMP1);
-                       d = reg_of_var(rd, iptr->dst, REG_ITMP2);
+                       s1 = emit_load_s1(jd, iptr, src, REG_ITMP1);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_ITMP2);
                        if (s1 == d) {
                                M_MOV(s1, REG_ITMP1);
                                s1 = REG_ITMP1;
@@ -3531,25 +3268,24 @@ gen_method:
                        /* calculate interface instanceof code size */
 
                        s2 = 6;
-                       if (!super)
+                       if (super == NULL)
                                s2 += (d == REG_ITMP2 ? 1 : 0) + (opt_showdisassemble ? 1 : 0);
 
                        /* calculate class instanceof code size */
 
                        s3 = 7;
-                       if (!super)
+                       if (super == NULL)
                                s3 += (opt_showdisassemble ? 1 : 0);
 
                        /* if class is not resolved, check which code to call */
 
-                       if (!super) {
+                       if (super == NULL) {
                                M_CLR(d);
                                M_BEQZ(s1, 4 + (opt_showdisassemble ? 1 : 0) + s2 + 1 + s3);
 
-                               disp = dseg_adds4(cd, 0);                     /* super->flags */
+                               disp = dseg_add_unique_s4(cd, 0);             /* super->flags */
 
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_checkcast_instanceof_flags,
+                               codegen_addpatchref(cd, PATCHER_resolve_classref_to_flags,
                                                                        (constant_classref *) iptr->target, disp);
 
                                if (opt_showdisassemble)
@@ -3557,7 +3293,7 @@ gen_method:
 
                                M_ILD(REG_ITMP3, REG_PV, disp);
 
-                               disp = dseg_adds4(cd, ACC_INTERFACE);
+                               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);
@@ -3565,24 +3301,24 @@ gen_method:
 
                        /* interface instanceof code */
 
-                       if (!super || (super->flags & ACC_INTERFACE)) {
-                               if (super) {
-                                       M_CLR(d);
-                                       M_BEQZ(s1, s2);
-
-                               } else {
-                                       /* If d == REG_ITMP2, then it's destroyed in check code   */
-                                       /* above.                                                 */
+                       if ((super == NULL) || (super->flags & ACC_INTERFACE)) {
+                               if (super == NULL) {
+                                       /* If d == REG_ITMP2, then it's destroyed in check
+                                          code above. */
                                        if (d == REG_ITMP2)
                                                M_CLR(d);
 
-                                       codegen_addpatchref(cd, mcodeptr,
+                                       codegen_addpatchref(cd,
                                                                                PATCHER_checkcast_instanceof_interface,
                                                                                (constant_classref *) iptr->target, 0);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
                                }
+                               else {
+                                       M_CLR(d);
+                                       M_BEQZ(s1, s2);
+                               }
 
                                M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
                                M_ILD(REG_ITMP3, REG_ITMP1, OFFSET(vftbl_t, interfacetablelength));
@@ -3593,44 +3329,45 @@ gen_method:
                                                        superindex * sizeof(methodptr*)));
                                M_CMPULT(REG_ZERO, REG_ITMP1, d);      /* REG_ITMP1 != 0  */
 
-                               if (!super)
+                               if (super == NULL)
                                        M_BR(s3);
                        }
 
                        /* class instanceof code */
 
-                       if (!super || !(super->flags & ACC_INTERFACE)) {
-                               disp = dseg_addaddress(cd, supervftbl);
+                       if ((super == NULL) || !(super->flags & ACC_INTERFACE)) {
+                               if (super == NULL) {
+                                       disp = dseg_add_unique_address(cd, NULL);
 
-                               if (super) {
-                                       M_CLR(d);
-                                       M_BEQZ(s1, s3);
-
-                               } else {
-                                       codegen_addpatchref(cd, mcodeptr,
-                                                                               PATCHER_checkcast_instanceof_class,
+                                       codegen_addpatchref(cd, PATCHER_resolve_classref_to_vftbl,
                                                                                (constant_classref *) iptr->target,
                                                                                disp);
 
                                        if (opt_showdisassemble)
                                                M_NOP;
                                }
+                               else {
+                                       disp = dseg_add_address(cd, supervftbl);
+
+                                       M_CLR(d);
+                                       M_BEQZ(s1, s3);
+                               }
 
                                M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
                                M_ALD(REG_ITMP2, REG_PV, disp);
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-                               codegen_threadcritstart(cd, (u1 *) mcodeptr - cd->mcodebase);
+#if defined(ENABLE_THREADS)
+                               codegen_threadcritstart(cd, cd->mcodeptr - cd->mcodebase);
 #endif
                                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(USE_THREADS) && defined(NATIVE_THREADS)
-                               codegen_threadcritstop(cd, (u1 *) mcodeptr - cd->mcodebase);
+#if defined(ENABLE_THREADS)
+                               codegen_threadcritstop(cd, cd->mcodeptr - cd->mcodebase);
 #endif
                                M_ISUB(REG_ITMP1, REG_ITMP3, REG_ITMP1);
                                M_CMPULE(REG_ITMP1, REG_ITMP2, d);
                        }
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        }
                        break;
 
@@ -3645,7 +3382,7 @@ gen_method:
                                /* copy SAVEDVAR sizes to stack */
 
                                if (src->varkind != ARGVAR) {
-                                       var_to_reg_int(s2, src, REG_ITMP1);
+                                       s2 = emit_load_s2(jd, iptr, src, REG_ITMP1);
                                        M_LST(s2, REG_SP, s1 * 8);
                                }
                        }
@@ -3657,19 +3394,17 @@ gen_method:
                        /* is patcher function set? */
 
                        if (iptr->val.a == NULL) {
-                               disp = dseg_addaddress(cd, 0);
+                               disp = dseg_add_unique_address(cd, 0);
 
-                               codegen_addpatchref(cd, mcodeptr,
-                                                                       PATCHER_builtin_multianewarray,
+                               codegen_addpatchref(cd, PATCHER_resolve_classref_to_classinfo,
                                                                        (constant_classref *) iptr->target,
                                                                        disp);
 
                                if (opt_showdisassemble)
                                        M_NOP;
-
-                       } else {
-                               disp = dseg_addaddress(cd, iptr->val.a);
                        }
+                       else
+                               disp = dseg_add_address(cd, iptr->val.a);
 
                        /* a1 = arraydescriptor */
 
@@ -3679,20 +3414,20 @@ gen_method:
 
                        M_INTMOVE(REG_SP, rd->argintregs[2]);
 
-                       disp = dseg_addaddress(cd, BUILTIN_multianewarray);
+                       disp = dseg_add_functionptr(cd, BUILTIN_multianewarray);
                        M_ALD(REG_PV, REG_PV, disp);
                        M_JSR(REG_RA, REG_PV);
-                       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+                       disp = (s4) (cd->mcodeptr - cd->mcodebase);
                        M_LDA(REG_PV, REG_RA, -disp);
 
                        /* check for exception before result assignment */
 
                        M_BEQZ(REG_RESULT, 0);
-                       codegen_add_fillinstacktrace_ref(cd, mcodeptr);
+                       codegen_add_fillinstacktrace_ref(cd);
 
-                       d = reg_of_var(rd, iptr->dst, REG_RESULT);
+                       d = codegen_reg_of_var(rd, iptr->opc, iptr->dst, REG_RESULT);
                        M_INTMOVE(REG_RESULT, d);
-                       store_reg_to_var_int(iptr->dst, d);
+                       emit_store(jd, iptr, iptr->dst, d);
                        break;
 
                default:
@@ -3716,7 +3451,8 @@ gen_method:
                if ((src->varkind != STACKVAR)) {
                        s2 = src->type;
                        if (IS_FLT_DBL_TYPE(s2)) {
-                               var_to_reg_flt(s1, src, REG_FTMP1);
+                               /* 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);
                                        }
@@ -3725,7 +3461,8 @@ gen_method:
                                        }
                                }
                        else {
-                               var_to_reg_int(s1, src, REG_ITMP1);
+                               /* 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);
                                        }
@@ -3741,209 +3478,13 @@ gen_method:
 
        dseg_createlinenumbertable(cd);
 
+       /* generate stubs */
 
-       /* generate exception and patcher stubs */
-
-       {
-               exceptionref *eref;
-               patchref     *pref;
-               u4            mcode;
-               s4           *savedmcodeptr;
-               s4           *tmpmcodeptr;
-
-               savedmcodeptr = NULL;
-
-               /* generate exception stubs */
-
-               for (eref = cd->exceptionrefs; eref != NULL; eref = eref->next) {
-                       gen_resolvebranch((u1 *) cd->mcodebase + eref->branchpos, 
-                                                         eref->branchpos,
-                                                         (u1 *) mcodeptr - cd->mcodebase);
-
-                       MCODECHECK(100);
-
-                       /* move index register into REG_ITMP1 */
-
-                       /* Check if the exception is an
-                          ArrayIndexOutOfBoundsException.  If so, move index register
-                          into REG_ITMP1. */
-
-                       if (eref->reg != -1)
-                               M_MOV(eref->reg, REG_ITMP1);
-
-                       /* calcuate exception address */
-
-                       M_LDA(REG_ITMP2_XPC, REG_PV, eref->branchpos - 4);
-
-                       /* move function to call into REG_ITMP3 */
-
-                       disp = dseg_addaddress(cd, eref->function);
-                       M_ALD(REG_ITMP3, REG_PV, disp);
-
-                       if (savedmcodeptr != NULL) {
-                               disp = savedmcodeptr - mcodeptr - 1;
-                               M_BR(disp);
-
-                       } else {
-                               savedmcodeptr = mcodeptr;
-
-                               M_MOV(REG_PV, rd->argintregs[0]);
-                               M_MOV(REG_SP, rd->argintregs[1]);
-
-                               if (m->isleafmethod)
-                                       M_MOV(REG_RA, rd->argintregs[2]);
-                               else
-                                       M_ALD(rd->argintregs[2],
-                                                 REG_SP, parentargs_base * 8 - SIZEOF_VOID_P);
-
-                               M_MOV(REG_ITMP2_XPC, rd->argintregs[3]);
-                               M_MOV(REG_ITMP1, rd->argintregs[4]);
-
-                               M_LDA(REG_SP, REG_SP, -2 * 8);
-                               M_AST(REG_ITMP2_XPC, REG_SP, 0 * 8);
-
-                               if (m->isleafmethod)
-                                       M_AST(REG_RA, REG_SP, 1 * 8);
-
-                               M_MOV(REG_ITMP3, REG_PV);
-                               M_JSR(REG_RA, REG_PV);
-                               disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
-                               M_LDA(REG_PV, REG_RA, -disp);
-
-                               M_MOV(REG_RESULT, REG_ITMP1_XPTR);
-
-                               if (m->isleafmethod)
-                                       M_ALD(REG_RA, REG_SP, 1 * 8);
-
-                               M_ALD(REG_ITMP2_XPC, REG_SP, 0 * 8);
-                               M_LDA(REG_SP, REG_SP, 2 * 8);
-
-                               disp = dseg_addaddress(cd, asm_handle_exception);
-                               M_ALD(REG_ITMP3, REG_PV, disp);
-                               M_JMP(REG_ZERO, REG_ITMP3);
-                       }
-               }
-
-
-               /* generate code patching stub call code */
-
-               for (pref = cd->patchrefs; pref != NULL; pref = pref->next) {
-                       /* check code segment size */
-
-                       MCODECHECK(100);
-
-                       /* Get machine code which is patched back in later. The
-                          call is 1 instruction word long. */
-
-                       savedmcodeptr = (s4 *) (cd->mcodebase + pref->branchpos);
-                       mcode = *savedmcodeptr;
-
-                       /* Patch in the call to call the following code (done at
-                          compile time). */
-
-                       tmpmcodeptr = mcodeptr;         /* save current mcodeptr          */
-                       mcodeptr    = savedmcodeptr;    /* set mcodeptr to patch position */
-
-                       M_BSR(REG_ITMP3, tmpmcodeptr - (savedmcodeptr + 1));
-
-                       mcodeptr = tmpmcodeptr;         /* restore the current mcodeptr   */
-
-                       /* create stack frame */
-
-                       M_LSUB_IMM(REG_SP, 6 * 8, REG_SP);
-
-                       /* move return address onto stack */
-
-                       M_AST(REG_ITMP3, REG_SP, 5 * 8);
-
-                       /* move pointer to java_objectheader onto stack */
-
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-                       /* create a virtual java_objectheader */
-
-                       (void) dseg_addaddress(cd, get_dummyLR());          /* monitorPtr */
-                       disp = dseg_addaddress(cd, NULL);                   /* vftbl      */
-
-                       M_LDA(REG_ITMP3, REG_PV, disp);
-                       M_AST(REG_ITMP3, REG_SP, 4 * 8);
-#else
-                       /* do nothing */
-#endif
-
-                       /* move machine code onto stack */
-
-                       disp = dseg_adds4(cd, mcode);
-                       M_ILD(REG_ITMP3, REG_PV, disp);
-                       M_IST(REG_ITMP3, REG_SP, 3 * 8);
-
-                       /* move class/method/field reference onto stack */
-
-                       disp = dseg_addaddress(cd, pref->ref);
-                       M_ALD(REG_ITMP3, REG_PV, disp);
-                       M_AST(REG_ITMP3, REG_SP, 2 * 8);
-
-                       /* move data segment displacement onto stack */
-
-                       disp = dseg_adds4(cd, pref->disp);
-                       M_ILD(REG_ITMP3, REG_PV, disp);
-                       M_IST(REG_ITMP3, REG_SP, 1 * 8);
-
-                       /* move patcher function pointer onto stack */
-
-                       disp = dseg_addaddress(cd, pref->patcher);
-                       M_ALD(REG_ITMP3, REG_PV, disp);
-                       M_AST(REG_ITMP3, REG_SP, 0 * 8);
-
-                       disp = dseg_addaddress(cd, asm_wrapper_patcher);
-                       M_ALD(REG_ITMP3, REG_PV, disp);
-                       M_JMP(REG_ZERO, REG_ITMP3);
-               }
-
-               /* generate replacement-out stubs */
-
-               {
-                       int i;
-
-                       replacementpoint = cd->code->rplpoints;
-                       for (i=0; i<cd->code->rplpointcount; ++i, ++replacementpoint) {
-                               /* check code segment size */
-
-                               MCODECHECK(100);
-
-                               /* note start of stub code */
-
-                               replacementpoint->outcode = (u1*) (ptrint)((u1*)mcodeptr - cd->mcodebase);
-
-                               /* make machine code for patching */
-
-                               tmpmcodeptr = mcodeptr;
-                               mcodeptr = (s4*) &(replacementpoint->mcode);
-
-                               disp = (ptrint)((s4*)replacementpoint->outcode - (s4*)replacementpoint->pc) - 1;
-                               M_BR(disp);
-
-                               mcodeptr = tmpmcodeptr;
-
-                               /* create stack frame */
-
-                               M_LSUB_IMM(REG_SP, 1 * 8, REG_SP);
-
-                               /* push address of `rplpoint` struct */
-
-                               disp = dseg_addaddress(cd, replacementpoint);
-                               M_ALD(REG_ITMP3, REG_PV, disp);
-                               M_AST(REG_ITMP3, REG_SP, 0 * 8);
+       emit_exception_stubs(jd);
+       emit_patcher_stubs(jd);
+       emit_replacement_stubs(jd);
 
-                               /* jump to replacement function */
-
-                               disp = dseg_addaddress(cd, asm_replacement_out);
-                               M_ALD(REG_ITMP3, REG_PV, disp);
-                               M_JMP(REG_ZERO, REG_ITMP3);
-                       }
-               }
-       }
-
-       codegen_finish(m, cd, (s4) ((u1 *) mcodeptr - cd->mcodebase));
+       codegen_finish(jd);
 
        /* everything's ok */
 
@@ -3957,7 +3498,7 @@ gen_method:
        
 *******************************************************************************/
 
-#define COMPILERSTUB_DATASIZE    2 * SIZEOF_VOID_P
+#define COMPILERSTUB_DATASIZE    3 * SIZEOF_VOID_P
 #define COMPILERSTUB_CODESIZE    3 * 4
 
 #define COMPILERSTUB_SIZE        COMPILERSTUB_DATASIZE + COMPILERSTUB_CODESIZE
@@ -3965,9 +3506,11 @@ gen_method:
 
 u1 *createcompilerstub(methodinfo *m)
 {
-       u1     *s;                          /* memory to hold the stub            */
-       ptrint *d;
-       s4     *mcodeptr;                   /* code generation pointer            */
+       u1          *s;                     /* memory to hold the stub            */
+       ptrint      *d;
+       codeinfo    *code;
+       codegendata *cd;
+       s4           dumpsize;              /* code generation pointer            */
 
        s = CNEW(u1, COMPILERSTUB_SIZE);
 
@@ -3976,18 +3519,26 @@ u1 *createcompilerstub(methodinfo *m)
        d = (ptrint *) s;
        s = s + COMPILERSTUB_DATASIZE;
 
-       mcodeptr = (s4 *) s;
-       
-       /* Store the methodinfo* in the same place as in the methodheader
-          for compiled methods. */
+       /* mark start of dump memory area */
+
+       dumpsize = dump_size();
+
+       cd = DNEW(codegendata);
+       cd->mcodeptr = s;
+
+       /* Store the codeinfo pointer in the same place as in the
+          methodheader for compiled methods. */
+
+       code = code_codeinfo_new(m);
 
        d[0] = (ptrint) asm_call_jit_compiler;
        d[1] = (ptrint) m;
+       d[2] = (ptrint) code;
 
        /* code for the stub */
 
-       M_ALD(REG_ITMP1, REG_PV, -1 * 8);   /* load methodinfo pointer            */
-       M_ALD(REG_PV, REG_PV, -2 * 8);      /* load pointer to the compiler       */
+       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)
@@ -3995,6 +3546,10 @@ u1 *createcompilerstub(methodinfo *m)
                count_cstub_len += COMPILERSTUB_SIZE;
 #endif
 
+       /* release dump area */
+
+       dump_release(dumpsize);
+
        return s;
 }
 
@@ -4005,27 +3560,34 @@ u1 *createcompilerstub(methodinfo *m)
 
 *******************************************************************************/
 
-u1 *createnativestub(functionptr f, methodinfo *m, codegendata *cd,
-                                        registerdata *rd, methoddesc *nmd)
+u1 *createnativestub(functionptr f, jitdata *jd, methoddesc *nmd)
 {
-       s4         *mcodeptr;               /* code generation pointer            */
-       s4          stackframesize;         /* size of stackframe if needed       */
-       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;
+       registerdata *rd;
+       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 */
 
        md = m->parseddesc;
        nativeparams = (m->flags & ACC_STATIC) ? 2 : 1;
 
-
        /* calculate stack frame size */
 
-       stackframesize =
+       cd->stackframesize =
                1 +                             /* return address                     */
                sizeof(stackframeinfo) / SIZEOF_VOID_P +
                sizeof(localref_table) / SIZEOF_VOID_P +
@@ -4033,96 +3595,36 @@ u1 *createnativestub(functionptr f, methodinfo *m, codegendata *cd,
                (md->paramcount > INT_ARG_CNT ? INT_ARG_CNT : md->paramcount) +
                nmd->memuse;
 
-
        /* create method header */
 
-       (void) dseg_addaddress(cd, m);                          /* MethodPointer  */
-       (void) dseg_adds4(cd, stackframesize * 8);              /* FrameSize      */
-       (void) dseg_adds4(cd, 0);                               /* IsSync         */
-       (void) dseg_adds4(cd, 0);                               /* IsLeaf         */
-       (void) dseg_adds4(cd, 0);                               /* IntSave        */
-       (void) dseg_adds4(cd, 0);                               /* FltSave        */
+       (void) dseg_add_unique_address(cd, code);              /* CodeinfoPointer */
+       (void) dseg_add_unique_s4(cd, cd->stackframesize * 8); /* FrameSize       */
+       (void) dseg_add_unique_s4(cd, 0);                      /* IsSync          */
+       (void) dseg_add_unique_s4(cd, 0);                      /* IsLeaf          */
+       (void) dseg_add_unique_s4(cd, 0);                      /* IntSave         */
+       (void) dseg_add_unique_s4(cd, 0);                      /* FltSave         */
        (void) dseg_addlinenumbertablesize(cd);
-       (void) dseg_adds4(cd, 0);                               /* ExTableSize    */
-
-
-       /* initialize mcode variables */
-       
-       mcodeptr = (s4 *) cd->mcodeptr;
-
+       (void) dseg_add_unique_s4(cd, 0);                      /* ExTableSize     */
 
        /* generate stub code */
 
-       M_LDA(REG_SP, REG_SP, -stackframesize * 8);
-       M_AST(REG_RA, REG_SP, 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 (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_addaddress(cd, m);
-               M_ALD(REG_ITMP1, REG_PV, disp);
-               M_AST(REG_ITMP1, REG_SP, 0 * 8);
-               disp = dseg_addaddress(cd, builtin_trace_args);
-               M_ALD(REG_PV, REG_PV, disp);
-               M_JSR(REG_RA, REG_PV);
-               disp = (s4) ((u1 *) 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++;
-                       }
-               }
-       }
+#if !defined(NDEBUG)
+       if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
+               emit_verbosecall_enter(jd);
+#endif
 
        /* get function address (this must happen before the stackframeinfo) */
 
-       funcdisp = dseg_addaddress(cd, f);
+       funcdisp = dseg_add_functionptr(cd, f);
 
 #if !defined(WITH_STATIC_CLASSPATH)
        if (f == NULL) {
-               codegen_addpatchref(cd, mcodeptr, PATCHER_resolve_native, m, funcdisp);
+               codegen_addpatchref(cd, PATCHER_resolve_native_function, m, funcdisp);
 
                if (opt_showdisassemble)
                        M_NOP;
@@ -4147,14 +3649,14 @@ u1 *createnativestub(functionptr f, methodinfo *m, codegendata *cd,
 
        /* prepare data structures for native function call */
 
-       M_LDA(rd->argintregs[0], REG_SP, stackframesize * 8 - SIZEOF_VOID_P);
+       M_LDA(rd->argintregs[0], REG_SP, cd->stackframesize * 8 - SIZEOF_VOID_P);
        M_MOV(REG_PV, rd->argintregs[1]);
-       M_LDA(rd->argintregs[2], REG_SP, stackframesize * 8);
-       M_ALD(rd->argintregs[3], REG_SP, stackframesize * 8 - SIZEOF_VOID_P);
-       disp = dseg_addaddress(cd, codegen_start_native_call);
+       M_LDA(rd->argintregs[2], REG_SP, cd->stackframesize * 8);
+       M_ALD(rd->argintregs[3], 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);
-       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+       disp = (s4) (cd->mcodeptr - cd->mcodebase);
        M_LDA(REG_PV, REG_RA, -disp);
 
        /* restore integer and float argument registers */
@@ -4192,7 +3694,7 @@ u1 *createnativestub(functionptr f, methodinfo *m, codegendata *cd,
                                }
 
                        } else {
-                               s1 = md->params[i].regoff + stackframesize;
+                               s1 = md->params[i].regoff + cd->stackframesize;
                                s2 = nmd->params[j].regoff;
                                M_LLD(REG_ITMP1, REG_SP, s1 * 8);
                                M_LST(REG_ITMP1, REG_SP, s2 * 8);
@@ -4215,7 +3717,7 @@ u1 *createnativestub(functionptr f, methodinfo *m, codegendata *cd,
                                }
 
                        } else {
-                               s1 = md->params[i].regoff + stackframesize;
+                               s1 = md->params[i].regoff + cd->stackframesize;
                                s2 = nmd->params[j].regoff;
                                M_DLD(REG_FTMP1, REG_SP, s1 * 8);
                                if (IS_2_WORD_TYPE(t))
@@ -4229,188 +3731,81 @@ u1 *createnativestub(functionptr f, methodinfo *m, codegendata *cd,
        /* put class into second argument register */
 
        if (m->flags & ACC_STATIC) {
-               disp = dseg_addaddress(cd, m->class);
+               disp = dseg_add_address(cd, m->class);
                M_ALD(rd->argintregs[1], REG_PV, disp);
        }
 
        /* put env into first argument register */
 
-       disp = dseg_addaddress(cd, _Jv_env);
+       disp = dseg_add_address(cd, _Jv_env);
        M_ALD(rd->argintregs[0], REG_PV, disp);
 
        /* do the native function call */
 
        M_ALD(REG_PV, REG_PV, funcdisp);
        M_JSR(REG_RA, REG_PV);              /* call native method                 */
-       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+       disp = (s4) (cd->mcodeptr - cd->mcodebase);
        M_LDA(REG_PV, REG_RA, -disp);       /* recompute pv from ra               */
 
        /* save return value */
 
-       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);
+       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);
+       }
+
+       /* call finished trace */
+
+#if !defined(NDEBUG)
+       if (JITDATA_HAS_FLAG_VERBOSECALL(jd))
+               emit_verbosecall_exit(jd);
+#endif
 
        /* remove native stackframe info */
 
-       M_LDA(rd->argintregs[0], REG_SP, stackframesize * 8 - SIZEOF_VOID_P);
-       disp = dseg_addaddress(cd, codegen_finish_native_call);
+       M_LDA(rd->argintregs[0], 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);
-       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
+       disp = (s4) (cd->mcodeptr - cd->mcodebase);
        M_LDA(REG_PV, REG_RA, -disp);
+       M_MOV(REG_RESULT, REG_ITMP1_XPTR);
 
-       /* call finished trace */
-
-       if (opt_verbosecall) {
-               /* just restore the value we need, don't care about the other */
+       /* 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);
-
-               disp = dseg_addaddress(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_addaddress(cd, builtin_displaymethodstop);
-               M_ALD(REG_PV, REG_PV, disp);
-               M_JSR(REG_RA, REG_PV);
-               disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
-               M_LDA(REG_PV, REG_RA, -disp);
        }
 
-       /* check for exception */
-
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-       disp = dseg_addaddress(cd, builtin_get_exceptionptrptr);
-       M_ALD(REG_PV, REG_PV, disp);
-       M_JSR(REG_RA, REG_PV);
-       disp = (s4) ((u1 *) mcodeptr - cd->mcodebase);
-       M_LDA(REG_PV, REG_RA, -disp);
-       M_MOV(REG_RESULT, REG_ITMP3);
-#else
-       disp = dseg_addaddress(cd, &_exceptionptr);
-       M_ALD(REG_RESULT, REG_PV, disp);    /* get address of exceptionptr        */
-#endif
-       M_ALD(REG_ITMP1, REG_ITMP3, 0);     /* load exception into reg. itmp1     */
-
-       /* restore return value */
+       M_ALD(REG_RA, REG_SP, (cd->stackframesize - 1) * 8); /* get RA            */
+       M_LDA(REG_SP, REG_SP, cd->stackframesize * 8);
 
-       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);
-
-       M_BNEZ(REG_ITMP1, 3);               /* if no exception then return        */
+       /* check for exception */
 
-       M_ALD(REG_RA, REG_SP, (stackframesize - 1) * 8); /* load return address   */
-       M_LDA(REG_SP, REG_SP, stackframesize * 8);
+       M_BNEZ(REG_ITMP1_XPTR, 1);          /* if no exception then return        */
        M_RET(REG_ZERO, REG_RA);            /* return to caller                   */
 
        /* handle exception */
 
-       M_AST(REG_ZERO, REG_ITMP3, 0);      /* store NULL into exceptionptr       */
+       M_ASUB_IMM(REG_RA, 4, REG_ITMP2_XPC); /* get exception address            */
 
-       M_ALD(REG_RA, REG_SP, (stackframesize - 1) * 8); /* load return address   */
-       M_LDA(REG_ITMP2, REG_RA, -4);       /* move fault address into reg. itmp2 */
-
-       M_LDA(REG_SP, REG_SP, stackframesize * 8);
-
-       disp = dseg_addaddress(cd, asm_handle_nat_exception);
+       disp = dseg_add_functionptr(cd, asm_handle_nat_exception);
        M_ALD(REG_ITMP3, REG_PV, disp);     /* load asm exception handler address */
        M_JMP(REG_ZERO, REG_ITMP3);         /* jump to asm exception handler      */
        
 
-       /* process patcher calls **************************************************/
-
-       {
-               patchref *pref;
-               u4        mcode;
-               s4       *savedmcodeptr;
-               s4       *tmpmcodeptr;
-
-               /* there can only be one <clinit> ref entry */
-
-               pref = cd->patchrefs;
+       /* generate patcher stubs */
 
-               for (pref = cd->patchrefs; pref != NULL; pref = pref->next) {
-                       /* Get machine code which is patched back in later. The
-                          call is 1 instruction word long. */
-
-                       savedmcodeptr = (s4 *) (cd->mcodebase + pref->branchpos);
-                       mcode = (u4) *savedmcodeptr;
-
-                       /* patch in the call to call the following code (done at compile  */
-                       /* time)                                                          */
-
-                       tmpmcodeptr = mcodeptr;         /* save current mcodeptr          */
-                       mcodeptr    = savedmcodeptr;    /* set mcodeptr to patch position */
-
-                       M_BSR(REG_ITMP3, tmpmcodeptr - (savedmcodeptr + 1));
-
-                       mcodeptr = tmpmcodeptr;         /* restore the current mcodeptr   */
-
-                       /* create stack frame */
-
-                       M_LSUB_IMM(REG_SP, 6 * 8, REG_SP);
-
-                       /* move return address onto stack */
-
-                       M_AST(REG_ITMP3, REG_SP, 5 * 8);
-
-                       /* move pointer to java_objectheader onto stack */
-
-#if defined(USE_THREADS) && defined(NATIVE_THREADS)
-                       /* create a virtual java_objectheader */
-
-                       (void) dseg_addaddress(cd, get_dummyLR());          /* monitorPtr */
-                       disp = dseg_addaddress(cd, NULL);                   /* vftbl      */
-
-                       M_LDA(REG_ITMP3, REG_PV, disp);
-                       M_AST(REG_ITMP3, REG_SP, 4 * 8);
-#else
-                       M_AST(REG_ZERO, REG_SP, 4 * 8);
-#endif
-
-                       /* move machine code onto stack */
-
-                       disp = dseg_adds4(cd, mcode);
-                       M_ILD(REG_ITMP3, REG_PV, disp);
-                       M_IST(REG_ITMP3, REG_SP, 3 * 8);
-
-                       /* move class/method/field reference onto stack */
-
-                       disp = dseg_addaddress(cd, pref->ref);
-                       M_ALD(REG_ITMP3, REG_PV, disp);
-                       M_AST(REG_ITMP3, REG_SP, 2 * 8);
-
-                       /* move data segment displacement onto stack */
-
-                       disp = dseg_adds4(cd, pref->disp);
-                       M_ILD(REG_ITMP3, REG_PV, disp);
-                       M_IST(REG_ITMP3, REG_SP, 1 * 8);
-
-                       /* move patcher function pointer onto stack */
-
-                       disp = dseg_addaddress(cd, pref->patcher);
-                       M_ALD(REG_ITMP3, REG_PV, disp);
-                       M_AST(REG_ITMP3, REG_SP, 0 * 8);
-
-                       disp = dseg_addaddress(cd, asm_wrapper_patcher);
-                       M_ALD(REG_ITMP3, REG_PV, disp);
-                       M_JMP(REG_ZERO, REG_ITMP3);
-               }
-       }
+       emit_patcher_stubs(jd);
 
-       codegen_finish(m, cd, (s4) ((u1 *) mcodeptr - cd->mcodebase));
+       codegen_finish(jd);
 
-       return cd->code->entrypoint;
+       return code->entrypoint;
 }