Merged trunk and subtype.
[cacao.git] / src / vm / jit / i386 / patcher.c
index c60d44234eb0d30aa56509722b012d1b00236f5c..034ca21ef2239421c87fcad37a950f382a7e9550 100644 (file)
@@ -1,9 +1,7 @@
 /* src/vm/jit/i386/patcher.c - i386 code patching functions
 
-   Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates,
-   R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner,
-   C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger,
-   Institut f. Computersprachen - TU Wien
+   Copyright (C) 1996-2005, 2006, 2007, 2008
+   CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
 
    This file is part of CACAO.
 
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-   02111-1307, USA.
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.
 
-   Contact: cacao@complang.tuwien.ac.at
+*/
 
-   Authors: Christian Thalinger
 
-   Changes:
+#include "config.h"
 
-   $Id: patcher.c 2335 2005-04-22 13:28:28Z twisti $
+#include <stdint.h>
 
-*/
+#include "vm/types.h"
+
+#include "vm/jit/i386/codegen.h"
+#include "vm/jit/i386/md.h"
 
+#include "mm/memory.h"
 
-#include "vm/jit/i386/types.h"
-#include "vm/field.h"
+#include "native/native.h"
+
+#include "vm/jit/builtin.hpp"
+#include "vm/class.h"
+#include "vm/field.hpp"
+#include "vm/initialize.h"
+#include "vm/options.h"
 #include "vm/references.h"
-#include "vm/jit/asmhelper.c"
+#include "vm/resolve.h"
 
+#include "vm/jit/patcher-common.hpp"
 
-/* patcher_get_putstatic *******************************************************
 
-   XXX
+#define PATCH_BACK_ORIGINAL_MCODE                                                      \
+       do {                                                                                                    \
+               *((uint16_t*) pr->mpc) = (uint16_t) pr->mcode;          \
+               md_icacheflush((void*) pr->mpc, PATCHER_CALL_SIZE);     \
+       } while (0)
+
+
+/* patcher_patch_code **********************************************************
+
+   Just patches back the original machine code.
+
+*******************************************************************************/
+
+void patcher_patch_code(patchref_t *pr)
+{
+       PATCH_BACK_ORIGINAL_MCODE;
+}
+
+
+/* patcher_get_putstatic *******************************************************
 
    Machine code:
 
+   <patched call position>
    b8 00 00 00 00             mov    $0x00000000,%eax
 
 *******************************************************************************/
 
-bool patcher_get_putstatic(u1 *sp)
+bool patcher_get_putstatic(patchref_t *pr)
 {
        u1               *ra;
-       u8                mcode;
        unresolved_field *uf;
        fieldinfo        *fi;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)               *((ptrint *) (sp + 3 * 4));
-       mcode =                      *((u8 *)     (sp + 1 * 4));
-       uf    = (unresolved_field *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)               pr->mpc;
+       uf    = (unresolved_field *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(fi = helper_resolve_fieldinfo(uf)))
+       if (!(fi = resolve_field_eager(uf)))
                return false;
 
        /* check if the field's class is initialized */
 
-       if (!fi->class->initialized)
-               if (!initialize_class(fi->class))
+       if (!(fi->clazz->state & CLASS_INITIALIZED))
+               if (!initialize_class(fi->clazz))
                        return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch the field value's address */
 
-       *((ptrint *) (ra + 1)) = (ptrint) &(fi->value);
+       *((intptr_t *) (ra + 1)) = (intptr_t) fi->value;
 
        return true;
 }
@@ -92,44 +109,30 @@ bool patcher_get_putstatic(u1 *sp)
 
 /* patcher_getfield ************************************************************
 
-   XXX
-
    Machine code:
 
-   from:
-   e8 00 00 00 00             call   0x00000000
-
-   to:
+   <patched call position>
    8b 88 00 00 00 00          mov    0x00000000(%eax),%ecx
 
 *******************************************************************************/
 
-bool patcher_getfield(u1 *sp)
+bool patcher_getfield(patchref_t *pr)
 {
        u1               *ra;
-       u8                mcode;
        unresolved_field *uf;
        fieldinfo        *fi;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)               *((ptrint *) (sp + 3 * 4));
-       mcode =                      *((u8 *)     (sp + 1 * 4));
-       uf    = (unresolved_field *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)               pr->mpc;
+       uf    = (unresolved_field *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(fi = helper_resolve_fieldinfo(uf)))
+       if (!(fi = resolve_field_eager(uf)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch the field's offset */
 
@@ -146,148 +149,129 @@ bool patcher_getfield(u1 *sp)
 
 /* patcher_putfield ************************************************************
 
-   XXX
-
    Machine code:
 
-   from:
-   e8 00 00 00 00             call   0x00000000
-
-   to:
+   <patched call position>
    8b 88 00 00 00 00          mov    0x00000000(%eax),%ecx
 
 *******************************************************************************/
 
-bool patcher_putfield(u1 *sp)
+bool patcher_putfield(patchref_t *pr)
 {
        u1               *ra;
-       u8                mcode;
        unresolved_field *uf;
        fieldinfo        *fi;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)               *((ptrint *) (sp + 3 * 4));
-       mcode =                      *((u8 *)     (sp + 1 * 4));
-       uf    = (unresolved_field *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)               pr->mpc;
+       uf    = (unresolved_field *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(fi = helper_resolve_fieldinfo(uf)))
+       if (!(fi = resolve_field_eager(uf)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch the field's offset */
 
        if (fi->type != TYPE_LNG) {
                *((u4 *) (ra + 2)) = (u4) (fi->offset);
-
-       else {
-               /* long code is very special:
+       }
+       else {
+               /* The long code is special:
                 *
-                * 8b 8c 24 00 00 00 00       mov    0x00000000(%esp),%ecx
-                * 8b 94 24 00 00 00 00       mov    0x00000000(%esp),%edx
                 * 89 8d 00 00 00 00          mov    %ecx,0x00000000(%ebp)
                 * 89 95 00 00 00 00          mov    %edx,0x00000000(%ebp)
                 */
 
-               *((u4 *) (ra + 7 + 7 + 2)) = (u4) (fi->offset);
-               *((u4 *) (ra + 7 + 7 + 6 + 2)) = (u4) (fi->offset + 4);
+               *((u4 *) (ra + 2))     = (u4) (fi->offset);
+               *((u4 *) (ra + 6 + 2)) = (u4) (fi->offset + 4);
        }
 
        return true;
 }
 
 
-/* patcher_builtin_new *********************************************************
-
-   XXX
+/* patcher_putfieldconst *******************************************************
 
    Machine code:
 
-   c7 04 24 00 00 00 00       movl   $0x0000000,(%esp)
-   b8 00 00 00 00             mov    $0x0000000,%eax
-   ff d0                      call   *%eax
+   <patched call position>
+   c7 85 00 00 00 00 7b 00 00 00    movl   $0x7b,0x0(%ebp)
 
 *******************************************************************************/
 
-bool patcher_builtin_new(constant_classref *cr, u1 *sp)
+bool patcher_putfieldconst(patchref_t *pr)
 {
-       u1                *ra;
-       classinfo         *c;
+       u1               *ra;
+       unresolved_field *uf;
+       fieldinfo        *fi;
 
        /* get stuff from the stack */
 
-       ra = (u1 *)                *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
+       ra    = (u1 *)               pr->mpc;
+       uf    = (unresolved_field *) pr->ref;
 
-       ra = ra - (7 + 5 + 2);
-       *((ptrint *) (sp + 0 * 4)) = (ptrint) ra;
-
-       /* get the classinfo */
+       /* get the fieldinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(fi = resolve_field_eager(uf)))
                return false;
 
-       /* patch the classinfo pointer */
+       PATCH_BACK_ORIGINAL_MCODE;
 
-       *((ptrint *) (ra + 3)) = (ptrint) c;
+       /* patch the field's offset */
 
-       /* patch new function address */
+       if (!IS_2_WORD_TYPE(fi->type)) {
+               *((u4 *) (ra + 2)) = (u4) (fi->offset);
+       }
+       else {
+               /* long/double code is different:
+                *
+                * c7 80 00 00 00 00 c8 01 00 00    movl   $0x1c8,0x0(%eax)
+                * c7 80 04 00 00 00 00 00 00 00    movl   $0x0,0x4(%eax)
+                */
 
-       *((ptrint *) (ra + 7 + 1)) = (ptrint) BUILTIN_new;
+               *((u4 *) (ra + 2))      = (u4) (fi->offset);
+               *((u4 *) (ra + 10 + 2)) = (u4) (fi->offset + 4);
+       }
 
        return true;
 }
 
 
-/* patcher_builtin_newarray ****************************************************
-
-   XXX
+/* patcher_aconst **************************************************************
 
    Machine code:
 
-   c7 44 24 08 00 00 00 00    movl   $0x00000000,0x8(%esp)
-   b8 00 00 00 00             mov    $0x00000000,%eax
-   ff d0                      call   *%eax
+   <patched call postition>
+   c7 04 24 00 00 00 00       movl   $0x0000000,(%esp)
+   b8 00 00 00 00             mov    $0x0000000,%eax
 
 *******************************************************************************/
 
-bool patcher_builtin_newarray(u1 *sp, constant_classref *cr)
+bool patcher_aconst(patchref_t *pr)
 {
        u1                *ra;
+       constant_classref *cr;
        classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra = (u1 *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - (8 + 5 + 2);
-       *((ptrint *) (sp + 0 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
        /* get the classinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(c = resolve_classref_eager(cr)))
                return false;
 
-       /* patch the class' vftbl pointer */
+       PATCH_BACK_ORIGINAL_MCODE;
 
-       *((ptrint *) (ra + 4)) = (ptrint) c->vftbl;
-
-       /* patch new function address */
+       /* patch the classinfo pointer */
 
-       *((ptrint *) (ra + 8 + 1)) = (ptrint) BUILTIN_newarray;
+       *((ptrint *) (ra + 1)) = (ptrint) c;
 
        return true;
 }
@@ -295,132 +279,81 @@ bool patcher_builtin_newarray(u1 *sp, constant_classref *cr)
 
 /* patcher_builtin_multianewarray **********************************************
 
-   XXX
-
    Machine code:
 
+   <patched call position>
    c7 04 24 02 00 00 00       movl   $0x2,(%esp)
-   c7 44 24 08 00 00 00 00    movl   $0x00000000,0x8(%esp)
+   c7 44 24 04 00 00 00 00    movl   $0x00000000,0x4(%esp)
    89 e0                      mov    %esp,%eax
-   83 c0 18                   add    $0x18,%eax
-   89 44 24 10                mov    %eax,0x10(%esp)
+   83 c0 0c                   add    $0xc,%eax
+   89 44 24 08                mov    %eax,0x8(%esp)
    b8 00 00 00 00             mov    $0x00000000,%eax
    ff d0                      call   *%eax
 
 *******************************************************************************/
 
-bool patcher_builtin_multianewarray(u1 *sp, constant_classref *cr)
+bool patcher_builtin_multianewarray(patchref_t *pr)
 {
        u1                *ra;
+       constant_classref *cr;
        classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra = (u1 *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - (7 + 8 + 2 + 3 + 4 + 5 + 2);
-       *((ptrint *) (sp + 0 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
        /* get the classinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(c = resolve_classref_eager(cr)))
                return false;
 
-       /* patch the class' vftbl pointer */
-
-       *((ptrint *) (ra + 7 + 4)) = (ptrint) c->vftbl;
+       PATCH_BACK_ORIGINAL_MCODE;
 
-       /* patch new function address */
+       /* patch the classinfo pointer */
 
-       *((ptrint *) (ra + 7 + 8 + 2 + 3 + 4 + 1)) = (ptrint) BUILTIN_multianewarray;
+       *((ptrint *) (ra + 7 + 4)) = (ptrint) c;
 
        return true;
 }
 
 
-/* patcher_builtin_checkarraycast **********************************************
-
-   XXX
+/* patcher_builtin_arraycheckcast **********************************************
 
    Machine code:
 
-   c7 44 24 08 00 00 00 00    movl   $0x00000000,0x8(%esp)
-   b8 00 00 00 00             mov    $0x00000000,%eax
-   ff d0                      call   *%eax
+   <patched call position>
+   c7 44 24 04 00 00 00 00    movl   $0x00000000,0x4(%esp)
+   ba 00 00 00 00             mov    $0x00000000,%edx
+   ff d2                      call   *%edx
 
 *******************************************************************************/
 
-bool patcher_builtin_checkarraycast(u1 *sp, constant_classref *cr)
+bool patcher_builtin_arraycheckcast(patchref_t *pr)
 {
        u1                *ra;
+       constant_classref *cr;
        classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra = (u1 *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - (8 + 5 + 2);
-       *((ptrint *) (sp + 0 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
        /* get the classinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(c = resolve_classref_eager(cr)))
                return false;
 
-       /* patch the class' vftbl pointer */
-
-       *((ptrint *) (ra + 4)) = (ptrint) c->vftbl;
-
-       /* patch new function address */
-
-       *((ptrint *) (ra + 8 + 1)) = (ptrint) BUILTIN_checkarraycast;
-
-       return true;
-}
-
-
-/* patcher_builtin_arrayinstanceof *********************************************
+       PATCH_BACK_ORIGINAL_MCODE;
 
-   XXX
-
-   Machine code:
-
-   c7 44 24 08 00 00 00 00    movl   $0x00000000,0x8(%esp)
-   b8 00 00 00 00             mov    $0x00000000,%eax
-   ff d0                      call   *%eax
-
-*******************************************************************************/
-
-bool patcher_builtin_arrayinstanceof(u1 *sp, constant_classref *cr)
-{
-       u1                *ra;
-       classinfo         *c;
-
-       /* get stuff from the stack */
-
-       ra = (u1 *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - (8 + 5 + 2);
-       *((ptrint *) (sp + 0 * 4)) = (ptrint) ra;
-
-       /* get the classinfo */
-
-       if (!(c = helper_resolve_classinfo(cr)))
-               return false;
-
-       /* patch the class' vftbl pointer */
+       /* patch the classinfo pointer */
 
-       *((ptrint *) (ra + 4)) = (ptrint) c->vftbl;
+       *((ptrint *) (ra + 4)) = (ptrint) c;
 
        /* patch new function address */
 
-       *((ptrint *) (ra + 8 + 1)) = (ptrint) BUILTIN_arrayinstanceof;
+       *((ptrint *) (ra + 8 + 1)) = (ptrint) BUILTIN_arraycheckcast;
 
        return true;
 }
@@ -428,41 +361,31 @@ bool patcher_builtin_arrayinstanceof(u1 *sp, constant_classref *cr)
 
 /* patcher_invokestatic_special ************************************************
 
-   XXX
-
    Machine code:
 
+   <patched call position>
    b9 00 00 00 00             mov    $0x00000000,%ecx
    ff d1                      call   *%ecx
 
 *******************************************************************************/
 
-bool patcher_invokestatic_special(u1 *sp)
+bool patcher_invokestatic_special(patchref_t *pr)
 {
        u1                *ra;
-       u8                 mcode;
        unresolved_method *um;
        methodinfo        *m;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)                *((ptrint *) (sp + 3 * 4));
-       mcode =                       *((u8 *)     (sp + 1 * 4));
-       um    = (unresolved_method *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       um    = (unresolved_method *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(m = helper_resolve_methodinfo(um)))
+       if (!(m = resolve_method_eager(um)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch stubroutine */
 
@@ -474,42 +397,32 @@ bool patcher_invokestatic_special(u1 *sp)
 
 /* patcher_invokevirtual *******************************************************
 
-   XXX
-
    Machine code:
 
+   <patched call position>
    8b 08                      mov    (%eax),%ecx
    8b 81 00 00 00 00          mov    0x00000000(%ecx),%eax
    ff d0                      call   *%eax
 
 *******************************************************************************/
 
-bool patcher_invokevirtual(u1 *sp)
+bool patcher_invokevirtual(patchref_t *pr)
 {
        u1                *ra;
-       u8                 mcode;
        unresolved_method *um;
        methodinfo        *m;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)                *((ptrint *) (sp + 3 * 4));
-       mcode =                       *((u8 *)     (sp + 1 * 4));
-       um    = (unresolved_method *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       um    = (unresolved_method *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(m = helper_resolve_methodinfo(um)))
+       if (!(m = resolve_method_eager(um)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch vftbl index */
 
@@ -522,10 +435,9 @@ bool patcher_invokevirtual(u1 *sp)
 
 /* patcher_invokeinterface *****************************************************
 
-   XXX
-
    Machine code:
 
+   <patched call position>
    8b 00                      mov    (%eax),%eax
    8b 88 00 00 00 00          mov    0x00000000(%eax),%ecx
    8b 81 00 00 00 00          mov    0x00000000(%ecx),%eax
@@ -533,42 +445,33 @@ bool patcher_invokevirtual(u1 *sp)
 
 *******************************************************************************/
 
-bool patcher_invokeinterface(u1 *sp)
+bool patcher_invokeinterface(patchref_t *pr)
 {
        u1                *ra;
-       u8                 mcode;
        unresolved_method *um;
        methodinfo        *m;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)                *((ptrint *) (sp + 3 * 4));
-       mcode =                       *((u8 *)     (sp + 1 * 4));
-       um    = (unresolved_method *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       um    = (unresolved_method *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(m = helper_resolve_methodinfo(um)))
+       if (!(m = resolve_method_eager(um)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch interfacetable index */
 
        *((s4 *) (ra + 2 + 2)) = (s4) (OFFSET(vftbl_t, interfacetable[0]) -
-                                                                  sizeof(methodptr) * m->class->index);
+                                                                  sizeof(methodptr) * m->clazz->index);
 
        /* patch method offset */
 
        *((s4 *) (ra + 2 + 6 + 2)) =
-               (s4) (sizeof(methodptr) * (m - m->class->methods));
+               (s4) (sizeof(methodptr) * (m - m->clazz->methods));
 
        return true;
 }
@@ -576,40 +479,30 @@ bool patcher_invokeinterface(u1 *sp)
 
 /* patcher_checkcast_instanceof_flags ******************************************
 
-   XXX
-
    Machine code:
 
+   <patched call position>
    b9 00 00 00 00             mov    $0x00000000,%ecx
 
 *******************************************************************************/
 
-bool patcher_checkcast_instanceof_flags(u1 *sp)
+bool patcher_checkcast_instanceof_flags(patchref_t *pr)
 {
        u1                *ra;
-       u8                 mcode;
        constant_classref *cr;
        classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)                *((ptrint *) (sp + 3 * 4));
-       mcode =                       *((u8 *)     (sp + 1 * 4));
-       cr    = (constant_classref *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(c = resolve_classref_eager(cr)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch class flags */
 
@@ -619,52 +512,43 @@ bool patcher_checkcast_instanceof_flags(u1 *sp)
 }
 
 
-/* patcher_checkcast_instanceof_interface **************************************
-
-   XXX
+/* patcher_checkcast_interface *************************************************
 
    Machine code:
 
+   <patched call position>
    8b 91 00 00 00 00          mov    0x00000000(%ecx),%edx
    81 ea 00 00 00 00          sub    $0x00000000,%edx
    85 d2                      test   %edx,%edx
-   0f 8e 00 00 00 00          jle    0x00000000
+   0f 8f 06 00 00 00          jg     0x00000000
+   8b 35 03 00 00 00          mov    0x3,%esi
    8b 91 00 00 00 00          mov    0x00000000(%ecx),%edx
 
 *******************************************************************************/
 
-bool patcher_checkcast_instanceof_interface(u1 *sp)
+bool patcher_checkcast_interface(patchref_t *pr)
 {
        u1                *ra;
-       u8                 mcode;
        constant_classref *cr;
        classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)                *((ptrint *) (sp + 3 * 4));
-       mcode =                       *((u8 *)     (sp + 1 * 4));
-       cr    = (constant_classref *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(c = resolve_classref_eager(cr)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch super class index */
 
        *((s4 *) (ra + 6 + 2)) = (s4) c->index;
 
-       *((s4 *) (ra + 6 + 6 + 2 + 6 + 2)) =
+       *((s4 *) (ra + 6 + 6 + 2 + 6 + 6 + 2)) =
                (s4) (OFFSET(vftbl_t, interfacetable[0]) -
                          c->index * sizeof(methodptr*));
 
@@ -672,90 +556,79 @@ bool patcher_checkcast_instanceof_interface(u1 *sp)
 }
 
 
-/* patcher_checkcast_class *****************************************************
-
-   XXX
+/* patcher_instanceof_interface ************************************************
 
    Machine code:
 
-   ba 00 00 00 00             mov    $0x00000000,%edx
-   8b 89 00 00 00 00          mov    0x00000000(%ecx),%ecx
-   8b 92 00 00 00 00          mov    0x00000000(%edx),%edx
-   29 d1                      sub    %edx,%ecx
-   ba 00 00 00 00             mov    $0x00000000,%edx
+   <patched call position>
+   8b 91 00 00 00 00          mov    0x00000000(%ecx),%edx
+   81 ea 00 00 00 00          sub    $0x00000000,%edx
+   85 d2                      test   %edx,%edx
+   0f 8e 13 00 00 00          jle    0x00000000
+   8b 91 00 00 00 00          mov    0x00000000(%ecx),%edx
 
 *******************************************************************************/
 
-bool patcher_checkcast_class(u1 *sp)
+bool patcher_instanceof_interface(patchref_t *pr)
 {
        u1                *ra;
-       u8                 mcode;
        constant_classref *cr;
        classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)                *((ptrint *) (sp + 3 * 4));
-       mcode =                       *((u8 *)     (sp + 1 * 4));
-       cr    = (constant_classref *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(c = resolve_classref_eager(cr)))
                return false;
 
-       /* patch back original code */
+       PATCH_BACK_ORIGINAL_MCODE;
 
-       *((u8 *) ra) = mcode;
+       /* patch super class index */
 
-       /* patch super class' vftbl */
+       *((s4 *) (ra + 6 + 2)) = (s4) c->index;
 
-       *((ptrint *) (ra + 1)) = (ptrint) c->vftbl;
-       *((ptrint *) (ra + 5 + 6 + 6 + 2 + 1)) = (ptrint) c->vftbl;
+       *((s4 *) (ra + 6 + 6 + 2 + 6 + 2)) =
+               (s4) (OFFSET(vftbl_t, interfacetable[0]) -
+                         c->index * sizeof(methodptr*));
 
        return true;
 }
 
 
-/* patcher_instanceof_class ****************************************************
-
-   XXX
+/* patcher_checkcast_class *****************************************************
 
    Machine code:
 
+   <patched call position>
+   ba 00 00 00 00             mov    $0x00000000,%edx
+   8b 89 00 00 00 00          mov    0x00000000(%ecx),%ecx
+   8b 92 00 00 00 00          mov    0x00000000(%edx),%edx
+   29 d1                      sub    %edx,%ecx
+   ba 00 00 00 00             mov    $0x00000000,%edx
+
 *******************************************************************************/
 
-bool patcher_instanceof_class(u1 *sp)
+bool patcher_checkcast_class(patchref_t *pr)
 {
        u1                *ra;
-       u8                 mcode;
        constant_classref *cr;
        classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)                *((ptrint *) (sp + 3 * 4));
-       mcode =                       *((u8 *)     (sp + 1 * 4));
-       cr    = (constant_classref *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
-
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
        /* get the fieldinfo */
 
-       if (!(c = helper_resolve_classinfo(cr)))
+       if (!(c = resolve_classref_eager(cr)))
                return false;
 
-       /* patch back original code */
-
-       *((u8 *) ra) = mcode;
+       PATCH_BACK_ORIGINAL_MCODE;
 
        /* patch super class' vftbl */
 
@@ -765,38 +638,39 @@ bool patcher_instanceof_class(u1 *sp)
 }
 
 
-/* patcher_clinit **************************************************************
+/* patcher_instanceof_class ****************************************************
 
-   XXX
+   Machine code:
+
+   <patched call position>
+   b9 00 00 00 00             mov    $0x0,%ecx
+   8b 40 14                   mov    0x14(%eax),%eax
+   8b 51 18                   mov    0x18(%ecx),%edx
+   8b 49 14                   mov    0x14(%ecx),%ecx
 
 *******************************************************************************/
 
-bool patcher_clinit(u1 *sp)
+bool patcher_instanceof_class(patchref_t *pr)
 {
-       u1        *ra;
-       u8         mcode;
-       classinfo *c;
+       u1                *ra;
+       constant_classref *cr;
+       classinfo         *c;
 
        /* get stuff from the stack */
 
-       ra    = (u1 *)        *((ptrint *) (sp + 3 * 4));
-       mcode =               *((u8 *)     (sp + 1 * 4));
-       c     = (classinfo *) *((ptrint *) (sp + 0 * 4));
-
-       /* calculate and set the new return address */
+       ra    = (u1 *)                pr->mpc;
+       cr    = (constant_classref *) pr->ref;
 
-       ra = ra - 5;
-       *((ptrint *) (sp + 3 * 4)) = (ptrint) ra;
+       /* get the fieldinfo */
 
-       /* check if the class is initialized */
+       if (!(c = resolve_classref_eager(cr)))
+               return false;
 
-       if (!c->initialized)
-               if (!initialize_class(c))
-                       return false;
+       PATCH_BACK_ORIGINAL_MCODE;
 
-       /* patch back original code */
+       /* patch super class' vftbl */
 
-       *((u8 *) ra) = mcode;
+       *((ptrint *) (ra + 1)) = (ptrint) c->vftbl;
 
        return true;
 }