* src/vm/jit/mips/codegen.c (codegen_emit_stub_native): Removed

[cacao.git] / src / vm / jit / powerpc / md.c

diff --git a/src/vm/jit/powerpc/md.c b/src/vm/jit/powerpc/md.c
index 227a37090b843796258f84103354997354bd1c43..aaee85b6c24352f3d6a88ed20be4c9d2c0ec07fa 100644 (file)
--- a/src/vm/jit/powerpc/md.c
+++ b/src/vm/jit/powerpc/md.c
@@ -22,14 +22,13 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
 
-   $Id: md.c 7596 2007-03-28 21:05:53Z twisti $
-
 */
 
 
 #include "config.h"
 
 #include <assert.h>
+#include <stdint.h>
 
 #include "vm/types.h"
 
@@ -37,14 +36,12 @@
 #include "vm/jit/powerpc/codegen.h"
 
 #include "vm/global.h"
+#include "vm/vm.h"
 
 #include "vm/jit/asmpart.h"
-#include "vm/jit/stacktrace.h"
-
-#if !defined(NDEBUG) && defined(ENABLE_DISASSEMBLER)
-# include "vm/jit/disass.h" /* XXX debug */
-# include "vmcore/options.h" /* XXX debug */
-#endif
+#include "vm/jit/codegen-common.h"
+#include "vm/jit/jit.h"
+#include "vm/jit/md.h"
 
 
 /* md_init *********************************************************************
@@ -78,7 +75,7 @@ u1 *md_stacktrace_get_returnaddress(u1 *sp, u4 framesize)
 }
 
 
-/* md_get_method_patch_address *************************************************
+/* md_jit_method_patch_address *************************************************
 
    Gets the patch address of the currently compiled method. The offset
    is extracted from the load instruction(s) before the jump and added
@@ -107,51 +104,53 @@ u1 *md_stacktrace_get_returnaddress(u1 *sp, u4 framesize)
 
 *******************************************************************************/
 
-u1 *md_get_method_patch_address(u1 *ra, stackframeinfo *sfi, u1 *mptr)
+void *md_jit_method_patch_address(void *pv, void *ra, void *mptr)
 {
-       u4  mcode;
-       s4  offset;
-       u1 *pa;
+       uint32_t *pc;
+       uint32_t  mcode;
+       int32_t   offset;
+       void     *pa;
 
        /* go back to the actual load instruction (3 instructions) */
 
-       ra = ra - 3 * 4;
+       pc = ((uint32_t *) ra) - 3;
 
        /* get first instruction word (lwz) */
 
-       mcode = *((u4 *) ra);
+       mcode = *pc;
 
        /* check if we have 2 instructions (addis, addi) */
 
        if ((mcode >> 16) == 0x3c19) {
                /* XXX write a regression for this */
+               pa = NULL;
                assert(0);
 
                /* get displacement of first instruction (addis) */
 
-               offset = (s4) (mcode << 16);
+               offset = (int32_t) (mcode << 16);
 
                /* get displacement of second instruction (addi) */
 
-               mcode = *((u4 *) (ra + 1 * 4));
+               mcode = *(pc + 1);
 
                assert((mcode >> 16) != 0x6739);
 
-               offset += (s2) (mcode & 0x0000ffff);
-
-       } else {
+               offset += (int16_t) (mcode & 0x0000ffff);
+       }
+       else {
                /* get the offset from the instruction */
 
-               offset = (s2) (mcode & 0x0000ffff);
+               offset = (int16_t) (mcode & 0x0000ffff);
 
                /* check for load from PV */
 
                if ((mcode >> 16) == 0x81ad) {
                        /* get the final data segment address */
 
-                       pa = sfi->pv + offset;
-
-               } else if ((mcode >> 16) == 0x81ac) {
+                       pa = ((uint8_t *) pv) + offset;
+               }
+               else if ((mcode >> 16) == 0x81ac) {
                        /* in this case we use the passed method pointer */
 
                        /* return NULL if no mptr was specified (used for replacement) */
@@ -159,12 +158,17 @@ u1 *md_get_method_patch_address(u1 *ra, stackframeinfo *sfi, u1 *mptr)
                        if (mptr == NULL)
                                return NULL;
 
-                       pa = mptr + offset;
-
-               } else {
+                       pa = ((uint8_t *) mptr) + offset;
+               }
+               else {
                        /* catch any problems */
 
-                       assert(0);
+                       vm_abort("md_jit_method_patch_address: unknown instruction %x",
+                                        mcode);
+
+                       /* keep compiler happy */
+
+                       pa = NULL;
                }
        }
 
@@ -276,40 +280,28 @@ void md_dcacheflush(u1 *addr, s4 nbytes)
 *******************************************************************************/
 
 #if defined(ENABLE_REPLACEMENT)
-void md_patch_replacement_point(codeinfo *code, s4 index, rplpoint *rp, u1 *savedmcode)
+void md_patch_replacement_point(u1 *pc, u1 *savedmcode, bool revert)
 {
-       s4 disp;
        u4 mcode;
 
-       if (index < 0) {
+       if (revert) {
                /* restore the patched-over instruction */
-               *(u4*)(rp->pc) = *(u4*)(savedmcode);
+               *(u4*)(pc) = *(u4*)(savedmcode);
        }
        else {
                /* save the current machine code */
-               *(u4*)(savedmcode) = *(u4*)(rp->pc);
+               *(u4*)(savedmcode) = *(u4*)(pc);
 
                /* build the machine code for the patch */
-               disp = ((u4*)code->replacementstubs - (u4*)rp->pc)
-                          + index * REPLACEMENT_STUB_SIZE
-                          - 1;
-
-        mcode = (18 << 26) | ((((disp) * 4) + 4) & M_BMASK);
+               assert(0); /* XXX build trap instruction below */
+               mcode = 0;
 
                /* write the new machine code */
-               *(u4*)(rp->pc) = (u4) mcode;
+               *(u4*)(pc) = (u4) mcode;
        }
        
-#if !defined(NDEBUG) && defined(ENABLE_DISASSEMBLER) && 0
-       {
-               u1* u1ptr = rp->pc;
-               DISASSINSTR(u1ptr);
-               fflush(stdout);
-       }
-#endif
-                       
        /* flush instruction cache */
-    md_icacheflush(rp->pc,4);
+    md_icacheflush(pc,4);
 }
 #endif /* defined(ENABLE_REPLACEMENT) */