JIT: uae_p32 (2)

diff --git a/jit/codegen_x86.cpp b/jit/codegen_x86.cpp
index 8782311b43a055707d2c5a586867e6bcf8c09291..78d39080383ff22c4379a4ee416f09dbe815d90c 100644 (file)
--- a/jit/codegen_x86.cpp
+++ b/jit/codegen_x86.cpp
@@ -3726,7 +3726,7 @@ LOWFUNC(NONE,WRITE,3,raw_fmovi_mrb,(MEMW m, FR r, double *bounds))
        emit_byte(0xdd);
        emit_byte(0x05);
 /* FIXME: 32-bit address prefix needed? */
-       emit_long(uae_ptr32(&bounds[0])); /* fld double from lower */
+       emit_long(uae_p32(&bounds[0])); /* fld double from lower */
 
        /* Clamp to lower */
        emit_byte(0xdb);
@@ -3740,7 +3740,7 @@ LOWFUNC(NONE,WRITE,3,raw_fmovi_mrb,(MEMW m, FR r, double *bounds))
        emit_byte(0xdd);
        emit_byte(0x05);
 /* FIXME: 32-bit address prefix needed? */
-       emit_long(uae_ptr32(&bounds[1])); /* fld double from upper */
+       emit_long(uae_p32(&bounds[1])); /* fld double from upper */
 
        /* Clamp to upper */
        emit_byte(0xdb);
@@ -4181,7 +4181,7 @@ LOWFUNC(NONE,NONE,2,raw_ftwotox_rr,(FW d, FR s))
        emit_byte(0xf0);    /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one)); /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one)); /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);    /* fscale (2^frac(x))*2^int(x) */
        emit_byte(0xdd);
@@ -4217,7 +4217,7 @@ LOWFUNC(NONE,NONE,2,raw_fetox_rr,(FW d, FR s))
        emit_byte(0xf0);    /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);    /* fscale (2^frac(x))*2^int(x*log2(e)) */
        emit_byte(0xdd);
@@ -4288,7 +4288,7 @@ LOWFUNC(NONE,NONE,2,raw_ftentox_rr,(FW d, FR s))
        emit_byte(0xf0);    /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);    /* fscale (2^frac(x))*2^int(x*log2(10)) */
        emit_byte(0xdd);
@@ -4435,7 +4435,7 @@ LOWFUNC(NONE,NONE,2,raw_facos_rr,(FW d, FR s))
        emit_byte(0xf3);    /* fpatan atan(x/sqrt(1-(x^2))) & pop */
        emit_byte(0xdb);
        emit_byte(0x2d);
-       emit_long(uae_ptr32(&pihalf)); /* fld load pi/2 from pihalf */
+       emit_long(uae_p32(&pihalf)); /* fld load pi/2 from pihalf */
        emit_byte(0xde);
        emit_byte(0xe1);    /* fsubrp pi/2 - asin(x) & pop */
        tos_make(d);        /* store y=acos(x) */
@@ -4539,7 +4539,7 @@ LOWFUNC(NONE,NONE,2,raw_fsinh_rr,(FW d, FR s))
        emit_byte(0xf0);     /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);     /* fscale (2^frac(x))*2^int(x*log2(e)) */
        emit_byte(0xd9);
@@ -4556,7 +4556,7 @@ LOWFUNC(NONE,NONE,2,raw_fsinh_rr,(FW d, FR s))
        emit_byte(0xf0);     /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);     /* fscale (2^frac(x))*2^int(x*log2(e)) */
        emit_byte(0xdd);
@@ -4634,7 +4634,7 @@ LOWFUNC(NONE,NONE,2,raw_fcosh_rr,(FW d, FR s))
        emit_byte(0xf0);     /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);     /* fscale (2^frac(x))*2^int(x*log2(e)) */
        emit_byte(0xd9);
@@ -4651,7 +4651,7 @@ LOWFUNC(NONE,NONE,2,raw_fcosh_rr,(FW d, FR s))
        emit_byte(0xf0);     /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);     /* fscale (2^frac(x))*2^int(x*log2(e)) */
        emit_byte(0xdd);
@@ -4725,7 +4725,7 @@ LOWFUNC(NONE,NONE,2,raw_ftanh_rr,(FW d, FR s))
        emit_byte(0xf0);     /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);     /* fscale (2^frac(x))*2^int(x*log2(e)) */
        emit_byte(0xd9);
@@ -4742,7 +4742,7 @@ LOWFUNC(NONE,NONE,2,raw_ftanh_rr,(FW d, FR s))
        emit_byte(0xf0);     /* f2xm1 (2^frac(x))-1 */
        emit_byte(0xd8);
        emit_byte(0x05);
-       emit_long(uae_ptr32(&one));  /* fadd (2^frac(x))-1 + 1 */
+       emit_long(uae_p32(&one));  /* fadd (2^frac(x))-1 + 1 */
        emit_byte(0xd9);
        emit_byte(0xfd);     /* fscale (2^frac(x))*2^int(x*log2(e)) */
        emit_byte(0xdd);

diff --git a/jit/compemu.h b/jit/compemu.h
index 49e17a88e4f557972623aa70be946ccbe6078a8f..1deb9b1661838b9e49f38bc0f3ae61359e0b5b8b 100644 (file)
--- a/jit/compemu.h
+++ b/jit/compemu.h
@@ -482,20 +482,19 @@ LONG WINAPI EvalException(LPEXCEPTION_POINTERS info);
 #endif
 #endif
 
+#endif
+
+#endif /* COMPEMU_H */
+
 #ifdef CPU_64_BIT
-static inline uae_u32 uae_ptr32(const void* address)
+static inline uae_u32 check_uae_p32(uae_u64 address)
 {
-       uintptr value = (uintptr) address;
-       if (value > 0xffffffffLL) {
+       if (address > 0xffffffffLL) {
                abort();
        }
-       return value;
+       return (uae_u32) address;
 }
+#define uae_p32(x) (check_uae_p32((uae_u64)(x)))
 #else
-#define uae_ptr32(x) ((uae_u32)(x))
+#define uae_p32(x) ((uae_u32)(x))
 #endif
-
-
-#endif
-
-#endif /* COMPEMU_H */

diff --git a/jit/compemu_fpp.cpp b/jit/compemu_fpp.cpp
index 1b44196a033c0ae19fb621cc12d1374d55d2ec51..d025fdd7924c3eef25aa8cc7ea5219e417ff9911 100644 (file)
--- a/jit/compemu_fpp.cpp
+++ b/jit/compemu_fpp.cpp
@@ -70,22 +70,22 @@ STATIC_INLINE int comp_fp_get (uae_u32 opcode, uae_u16 extra, int treg)
                case 0: /* Dn */
                switch (size) {
                        case 0: /* Long */
-                       mov_l_mr (uae_ptr32(temp_fp), reg);
-                       fmovi_rm (treg, uae_ptr32(temp_fp));
+                       mov_l_mr (uae_p32(temp_fp), reg);
+                       fmovi_rm (treg, uae_p32(temp_fp));
                        return 2;
                        case 1: /* Single */
-                       mov_l_mr (uae_ptr32(temp_fp), reg);
-                       fmovs_rm (treg, uae_ptr32(temp_fp));
+                       mov_l_mr (uae_p32(temp_fp), reg);
+                       fmovs_rm (treg, uae_p32(temp_fp));
                        return 1;
                        case 4: /* Word */
                        sign_extend_16_rr (S1, reg);
-                       mov_l_mr (uae_ptr32(temp_fp), S1);
-                       fmovi_rm (treg, uae_ptr32(temp_fp));
+                       mov_l_mr (uae_p32(temp_fp), S1);
+                       fmovi_rm (treg, uae_p32(temp_fp));
                        return 1;
                        case 6: /* Byte */
                        sign_extend_8_rr (S1, reg);
-                       mov_l_mr (uae_ptr32(temp_fp), S1);
-                       fmovi_rm (treg, uae_ptr32(temp_fp));
+                       mov_l_mr (uae_p32(temp_fp), S1);
+                       fmovi_rm (treg, uae_p32(temp_fp));
                        return 1;
                        default:
                        return -1;
@@ -150,34 +150,34 @@ STATIC_INLINE int comp_fp_get (uae_u32 opcode, uae_u16 extra, int treg)
 
                                        if (li == (int)si) {
                                                //write_log ("converted immediate LONG constant to SINGLE\n");
-                                               mov_l_mi(uae_ptr32(temp_fp), *(uae_u32 *)&si);
-                                               fmovs_rm(treg, uae_ptr32(temp_fp));
+                                               mov_l_mi(uae_p32(temp_fp), *(uae_u32 *)&si);
+                                               fmovs_rm(treg, uae_p32(temp_fp));
                                                return 1;
                                        }
                                        //write_log ("immediate LONG constant\n");
-                                       mov_l_mi(uae_ptr32(temp_fp), *(uae_u32 *)&li);
-                                       fmovi_rm(treg, uae_ptr32(temp_fp));
+                                       mov_l_mi(uae_p32(temp_fp), *(uae_u32 *)&li);
+                                       fmovi_rm(treg, uae_p32(temp_fp));
                                        return 2;
                                }
                                case 1:
                                //write_log (_T("immediate SINGLE constant\n"));
-                               mov_l_mi(uae_ptr32(temp_fp), comp_get_ilong(m68k_pc_offset - 4));
-                               fmovs_rm(treg, uae_ptr32(temp_fp));
+                               mov_l_mi(uae_p32(temp_fp), comp_get_ilong(m68k_pc_offset - 4));
+                               fmovs_rm(treg, uae_p32(temp_fp));
                                return 1;
                                case 2:
                                //write_log (_T("immediate LONG DOUBLE constant\n"));
-                               mov_l_mi(uae_ptr32(temp_fp), comp_get_ilong(m68k_pc_offset - 4));
-                               mov_l_mi((uae_ptr32(temp_fp)) + 4, comp_get_ilong(m68k_pc_offset - 8));
-                               mov_l_mi((uae_ptr32(temp_fp)) + 8, (uae_u32)comp_get_iword(m68k_pc_offset - 12));
-                               fmov_ext_rm(treg, uae_ptr32(temp_fp));
+                               mov_l_mi(uae_p32(temp_fp), comp_get_ilong(m68k_pc_offset - 4));
+                               mov_l_mi((uae_p32(temp_fp)) + 4, comp_get_ilong(m68k_pc_offset - 8));
+                               mov_l_mi((uae_p32(temp_fp)) + 8, (uae_u32)comp_get_iword(m68k_pc_offset - 12));
+                               fmov_ext_rm(treg, uae_p32(temp_fp));
                                return 0;
                                case 4:
                                {
                                        float si = (float)(uae_s16)comp_get_iword(m68k_pc_offset-2);
 
                                        //write_log (_T("converted immediate WORD constant %f to SINGLE\n"), si);
-                                       mov_l_mi(uae_ptr32(temp_fp),*(uae_u32 *)&si);
-                                       fmovs_rm(treg,uae_ptr32(temp_fp));
+                                       mov_l_mi(uae_p32(temp_fp),*(uae_u32 *)&si);
+                                       fmovs_rm(treg,uae_p32(temp_fp));
                                        return 1;
                                }
                                case 5:
@@ -188,14 +188,14 @@ STATIC_INLINE int comp_fp_get (uae_u32 opcode, uae_u16 extra, int treg)
 
                                        if (*(double *)longarray == (double)si) {
                                                //write_log (_T("SPEED GAIN: converted a DOUBLE constant to SINGLE\n"));
-                                               mov_l_mi(uae_ptr32(temp_fp), *(uae_u32 *)&si);
-                                               fmovs_rm(treg, uae_ptr32(temp_fp));
+                                               mov_l_mi(uae_p32(temp_fp), *(uae_u32 *)&si);
+                                               fmovs_rm(treg, uae_p32(temp_fp));
                                                return 1;
                                        }
                                        //write_log (_T("immediate DOUBLE constant\n"));
-                                       mov_l_mi(uae_ptr32(temp_fp), longarray[0]);
-                                       mov_l_mi((uae_ptr32(temp_fp)) + 4, longarray[1]);
-                                       fmov_rm(treg, uae_ptr32(temp_fp));
+                                       mov_l_mi(uae_p32(temp_fp), longarray[0]);
+                                       mov_l_mi((uae_p32(temp_fp)) + 4, longarray[1]);
+                                       fmov_rm(treg, uae_p32(temp_fp));
                                        return 2;
                                }
                                case 6:
@@ -203,8 +203,8 @@ STATIC_INLINE int comp_fp_get (uae_u32 opcode, uae_u16 extra, int treg)
                                        float si = (float)(uae_s8)comp_get_ibyte(m68k_pc_offset - 2);
 
                                        //write_log (_T("converted immediate BYTE constant to SINGLE\n"));
-                                       mov_l_mi(uae_ptr32(temp_fp), *(uae_u32 *)&si);
-                                       fmovs_rm(treg, uae_ptr32(temp_fp));
+                                       mov_l_mi(uae_p32(temp_fp), *(uae_u32 *)&si);
+                                       fmovs_rm(treg, uae_p32(temp_fp));
                                        return 1;
                                }
                                default: /* never reached */
@@ -218,44 +218,44 @@ STATIC_INLINE int comp_fp_get (uae_u32 opcode, uae_u16 extra, int treg)
        switch (size) {
                case 0: /* Long */
                readlong (S1, S2, S3);
-               mov_l_mr (uae_ptr32(temp_fp), S2);
-               fmovi_rm (treg, uae_ptr32(temp_fp));
+               mov_l_mr (uae_p32(temp_fp), S2);
+               fmovi_rm (treg, uae_p32(temp_fp));
                return 2;
                case 1: /* Single */
                readlong (S1, S2, S3);
-               mov_l_mr (uae_ptr32(temp_fp), S2);
-               fmovs_rm (treg, uae_ptr32(temp_fp));
+               mov_l_mr (uae_p32(temp_fp), S2);
+               fmovs_rm (treg, uae_p32(temp_fp));
                return 1;
                case 2: /* Long Double */
                readword (S1, S2, S3);
-               mov_w_mr ((uae_ptr32(temp_fp)) + 8, S2);
+               mov_w_mr ((uae_p32(temp_fp)) + 8, S2);
                add_l_ri (S1, 4);
                readlong (S1, S2, S3);
-               mov_l_mr ((uae_ptr32(temp_fp)) + 4, S2);
+               mov_l_mr ((uae_p32(temp_fp)) + 4, S2);
                add_l_ri (S1, 4);
                readlong (S1, S2, S3);
-               mov_l_mr ((uae_ptr32(temp_fp)), S2);
-               fmov_ext_rm (treg, uae_ptr32(temp_fp));
+               mov_l_mr ((uae_p32(temp_fp)), S2);
+               fmov_ext_rm (treg, uae_p32(temp_fp));
                return 0;
                case 4: /* Word */
                readword (S1, S2, S3);
                sign_extend_16_rr (S2, S2);
-               mov_l_mr (uae_ptr32(temp_fp), S2);
-               fmovi_rm (treg, uae_ptr32(temp_fp));
+               mov_l_mr (uae_p32(temp_fp), S2);
+               fmovi_rm (treg, uae_p32(temp_fp));
                return 1;
                case 5: /* Double */
                readlong (S1, S2, S3);
-               mov_l_mr ((uae_ptr32(temp_fp)) + 4, S2);
+               mov_l_mr ((uae_p32(temp_fp)) + 4, S2);
                add_l_ri (S1, 4);
                readlong (S1, S2, S3);
-               mov_l_mr ((uae_ptr32(temp_fp)), S2);
-               fmov_rm (treg, uae_ptr32(temp_fp));
+               mov_l_mr ((uae_p32(temp_fp)), S2);
+               fmov_rm (treg, uae_p32(temp_fp));
                return 2;
                case 6: /* Byte */
                readbyte (S1, S2, S3);
                sign_extend_8_rr (S2, S2);
-               mov_l_mr (uae_ptr32(temp_fp), S2);
-               fmovi_rm (treg, uae_ptr32(temp_fp));
+               mov_l_mr (uae_p32(temp_fp), S2);
+               fmovi_rm (treg, uae_p32(temp_fp));
                return 1;
                default:
                return -1;
@@ -281,52 +281,52 @@ STATIC_INLINE int comp_fp_put (uae_u32 opcode, uae_u16 extra)
                        if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */
                                mov_l_ri(S1,0x10); /* use extended round to zero mode */
                                fldcw_m_indexed(S1,(uae_u32)x86_fpucw);
-                               fmovi_mrb(uae_ptr32(temp_fp),sreg, clamp_bounds.l);
-                               mov_l_rm(reg,uae_ptr32(temp_fp));
+                               fmovi_mrb(uae_p32(temp_fp),sreg, clamp_bounds.l);
+                               mov_l_rm(reg,uae_p32(temp_fp));
                                mov_l_rm(S1,(uae_u32)&regs.fpcr);
                                and_l_ri(S1,0xf0); /* restore control word */
                                fldcw_m_indexed(S1,(uae_u32)x86_fpucw);
                                return 0;
                        }
 #endif
-                       fmovi_mrb (uae_ptr32(temp_fp), sreg, clamp_bounds.l);
-                       mov_l_rm (reg, uae_ptr32(temp_fp));
+                       fmovi_mrb (uae_p32(temp_fp), sreg, clamp_bounds.l);
+                       mov_l_rm (reg, uae_p32(temp_fp));
                        return 0;
                        case 1: /* FMOVE.S FPx, Dn */
-                       fmovs_mr (uae_ptr32(temp_fp), sreg);
-                       mov_l_rm (reg, uae_ptr32(temp_fp));
+                       fmovs_mr (uae_p32(temp_fp), sreg);
+                       mov_l_rm (reg, uae_p32(temp_fp));
                        return 0;
                        case 4: /* FMOVE.W FPx, Dn */
 #if USE_X86_FPUCW && 0
                        if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */
                                mov_l_ri(S1,0x10); /* use extended round to zero mode */
                                fldcw_m_indexed(S1,(uae_u32)x86_fpucw);
-                               fmovi_mrb(uae_ptr32(temp_fp),sreg, clamp_bounds.w);
-                               mov_w_rm(reg,uae_ptr32(temp_fp));
+                               fmovi_mrb(uae_p32(temp_fp),sreg, clamp_bounds.w);
+                               mov_w_rm(reg,uae_p32(temp_fp));
                                mov_l_rm(S1,(uae_u32)&regs.fpcr);
                                and_l_ri(S1,0xf0); /* restore control word */
                                fldcw_m_indexed(S1,(uae_u32)x86_fpucw);
                                return 0;
                        }
 #endif
-                       fmovi_mrb (uae_ptr32(temp_fp), sreg, clamp_bounds.w);
-                       mov_w_rm (reg, uae_ptr32(temp_fp));
+                       fmovi_mrb (uae_p32(temp_fp), sreg, clamp_bounds.w);
+                       mov_w_rm (reg, uae_p32(temp_fp));
                        return 0;
                        case 6: /* FMOVE.B FPx, Dn */
 #if USE_X86_FPUCW && 0
                        if (!(regs.fpcr & 0xf0)) { /* if extended round to nearest */
                                mov_l_ri(S1,0x10); /* use extended round to zero mode */
                                fldcw_m_indexed(S1,(uae_u32)x86_fpucw);
-                               fmovi_mrb(uae_ptr32(temp_fp),sreg, clamp_bounds.b);
-                               mov_b_rm(reg,uae_ptr32(temp_fp));
+                               fmovi_mrb(uae_p32(temp_fp),sreg, clamp_bounds.b);
+                               mov_b_rm(reg,uae_p32(temp_fp));
                                mov_l_rm(S1,(uae_u32)&regs.fpcr);
                                and_l_ri(S1,0xf0); /* restore control word */
                                fldcw_m_indexed(S1,(uae_u32)x86_fpucw);
                                return 0;
                        }
 #endif
-                       fmovi_mrb (uae_ptr32(temp_fp), sreg, clamp_bounds.b);
-                       mov_b_rm (reg, uae_ptr32(temp_fp));
+                       fmovi_mrb (uae_p32(temp_fp), sreg, clamp_bounds.b);
+                       mov_b_rm (reg, uae_p32(temp_fp));
                        return 0;
                        default:
                        return -1;
@@ -378,42 +378,42 @@ STATIC_INLINE int comp_fp_put (uae_u32 opcode, uae_u16 extra)
        }
        switch (size) {
                case 0: /* Long */
-               fmovi_mrb (uae_ptr32(temp_fp), sreg, clamp_bounds.l);
-               mov_l_rm (S2, uae_ptr32(temp_fp));
+               fmovi_mrb (uae_p32(temp_fp), sreg, clamp_bounds.l);
+               mov_l_rm (S2, uae_p32(temp_fp));
                writelong_clobber (S1, S2, S3);
                return 0;
                case 1: /* Single */
-               fmovs_mr (uae_ptr32(temp_fp), sreg);
-               mov_l_rm (S2, uae_ptr32(temp_fp));
+               fmovs_mr (uae_p32(temp_fp), sreg);
+               mov_l_rm (S2, uae_p32(temp_fp));
                writelong_clobber (S1, S2, S3);
                return 0;
                case 2:/* Long Double */
-               fmov_ext_mr (uae_ptr32(temp_fp), sreg);
-               mov_w_rm (S2, uae_ptr32(temp_fp) + 8);
+               fmov_ext_mr (uae_p32(temp_fp), sreg);
+               mov_w_rm (S2, uae_p32(temp_fp) + 8);
                writeword_clobber (S1, S2, S3);
                add_l_ri (S1, 4);
-               mov_l_rm (S2, uae_ptr32(temp_fp) + 4);
+               mov_l_rm (S2, uae_p32(temp_fp) + 4);
                writelong_clobber (S1, S2, S3);
                add_l_ri (S1, 4);
-               mov_l_rm (S2, uae_ptr32(temp_fp));
+               mov_l_rm (S2, uae_p32(temp_fp));
                writelong_clobber (S1, S2, S3);
                return 0;
                case 4: /* Word */
-               fmovi_mrb (uae_ptr32(temp_fp), sreg, clamp_bounds.w);
-               mov_l_rm (S2, uae_ptr32(temp_fp));
+               fmovi_mrb (uae_p32(temp_fp), sreg, clamp_bounds.w);
+               mov_l_rm (S2, uae_p32(temp_fp));
                writeword_clobber (S1, S2, S3);
                return 0;
                case 5: /* Double */
-               fmov_mr (uae_ptr32(temp_fp), sreg);
-               mov_l_rm (S2, uae_ptr32(temp_fp) + 4);
+               fmov_mr (uae_p32(temp_fp), sreg);
+               mov_l_rm (S2, uae_p32(temp_fp) + 4);
                writelong_clobber (S1, S2, S3);
                add_l_ri (S1, 4);
-               mov_l_rm (S2, uae_ptr32(temp_fp));
+               mov_l_rm (S2, uae_p32(temp_fp));
                writelong_clobber (S1, S2, S3);
                return 0;
                case 6: /* Byte */
-               fmovi_mrb (uae_ptr32(temp_fp), sreg, clamp_bounds.b);
-               mov_l_rm (S2, uae_ptr32(temp_fp));
+               fmovi_mrb (uae_p32(temp_fp), sreg, clamp_bounds.b);
+               mov_l_rm (S2, uae_p32(temp_fp));
                writebyte (S1, S2, S3);
                return 0;
                default:
@@ -558,9 +558,9 @@ void comp_fbcc_opp (uae_u32 opcode)
        else {
                off = comp_get_ilong ((m68k_pc_offset += 4) - 4);
        }
-       mov_l_ri (S1, uae_ptr32(
+       mov_l_ri (S1, uae_p32(
                          comp_pc_p + off - (m68k_pc_offset - start_68k_offset)));
-       mov_l_ri (PC_P, uae_ptr32(comp_pc_p));
+       mov_l_ri (PC_P, uae_p32(comp_pc_p));
 
        /* Now they are both constant. Might as well fold in m68k_pc_offset */
        add_l_ri (S1, m68k_pc_offset);
@@ -720,11 +720,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                case 4: /* FMOVE.L  <EA>, ControlReg */
                if (!(opcode & 0x30)) { /* Dn or An */
                        if (extra & 0x1000) { /* FPCR */
-                               mov_l_mr (uae_ptr32(&regs.fpcr), opcode & 15);
+                               mov_l_mr (uae_p32(&regs.fpcr), opcode & 15);
 #if USE_X86_FPUCW
                                mov_l_rr (S1, opcode & 15);
                                and_l_ri (S1, 0xf0);
-                               fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                               fldcw_m_indexed (S1, uae_p32(x86_fpucw));
 #endif
                                return;
                        }
@@ -734,16 +734,16 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                // set_fpsr(m68k_dreg (regs, opcode & 15));
                        }
                        if (extra & 0x0400) { /* FPIAR */
-                               mov_l_mr (uae_ptr32(&regs.fpiar), opcode & 15); return;
+                               mov_l_mr (uae_p32(&regs.fpiar), opcode & 15); return;
                        }
                }
                else if ((opcode & 0x3f) == 0x3c) {
                        if (extra & 0x1000) { /* FPCR */
                                uae_u32 val = comp_get_ilong ((m68k_pc_offset += 4) - 4);
-                               mov_l_mi (uae_ptr32(&regs.fpcr), val);
+                               mov_l_mi (uae_p32(&regs.fpcr), val);
 #if USE_X86_FPUCW
                                mov_l_ri (S1, val & 0xf0);
-                               fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                               fldcw_m_indexed (S1, uae_p32(x86_fpucw));
 #endif
                                return;
                        }
@@ -753,7 +753,7 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                        }
                        if (extra & 0x0400) { /* FPIAR */
                                uae_u32 val = comp_get_ilong ((m68k_pc_offset += 4) - 4);
-                               mov_l_mi (uae_ptr32(&regs.fpiar), val);
+                               mov_l_mi (uae_p32(&regs.fpiar), val);
                                return;
                        }
                }
@@ -762,14 +762,14 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                case 5: /* FMOVE.L  ControlReg, <EA> */
                if (!(opcode & 0x30)) { /* Dn or An */
                        if (extra & 0x1000) { /* FPCR */
-                               mov_l_rm (opcode & 15, uae_ptr32(&regs.fpcr)); return;
+                               mov_l_rm (opcode & 15, uae_p32(&regs.fpcr)); return;
                        }
                        if (extra & 0x0800) { /* FPSR */
                                FAIL (1);
                                return;
                        }
                        if (extra & 0x0400) { /* FPIAR */
-                               mov_l_rm (opcode & 15, uae_ptr32(&regs.fpiar)); return;
+                               mov_l_rm (opcode & 15, uae_p32(&regs.fpiar)); return;
                        }
                }
                FAIL (1);
@@ -931,7 +931,7 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                        while (list) {
                                if  (extra & 0x1000) { /* postincrement */
                                        readword(ad,S2,S3);
-                                       mov_w_mr((uae_ptr32(temp_fp))+8,S2);
+                                       mov_w_mr((uae_p32(temp_fp))+8,S2);
                                        add_l_ri(ad,4);
                                        readlong(ad,S2,S3);
                                        mov_l_mr((uae_u32)(temp_fp)+4,S2);
@@ -949,7 +949,7 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        mov_l_mr((uae_u32)(temp_fp)+4,S2);
                                        sub_l_ri(ad,4);
                                        readword(ad,S2,S3);
-                                       mov_w_mr((uae_ptr32(temp_fp))+8,S2);
+                                       mov_w_mr((uae_p32(temp_fp))+8,S2);
                                        fmov_ext_rm(fpp_movem_index2[list],(uae_u32)(temp_fp));
                                }
                                list = fpp_movem_next[list];
@@ -965,26 +965,26 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                        if ((ad = comp_fp_adr(opcode)) < 0) {FAIL(1);return;}
                        while (list) {
                                if (extra & 0x1000) { /* postincrement */
-                                       fmov_ext_mr(uae_ptr32(temp_fp),fpp_movem_index2[list]);
-                                       mov_w_rm(S2,uae_ptr32(temp_fp)+8);
+                                       fmov_ext_mr(uae_p32(temp_fp),fpp_movem_index2[list]);
+                                       mov_w_rm(S2,uae_p32(temp_fp)+8);
                                        writeword_clobber(ad,S2,S3);
                                        add_l_ri(ad,4);
-                                       mov_l_rm(S2,uae_ptr32(temp_fp)+4);
+                                       mov_l_rm(S2,uae_p32(temp_fp)+4);
                                        writelong_clobber(ad,S2,S3);
                                        add_l_ri(ad,4);
-                                       mov_l_rm(S2,uae_ptr32(temp_fp));
+                                       mov_l_rm(S2,uae_p32(temp_fp));
                                        writelong_clobber(ad,S2,S3);
                                        add_l_ri(ad,4);
                                } else { /* predecrement */
-                                       fmov_ext_mr(uae_ptr32(temp_fp),fpp_movem_index2[list]);
+                                       fmov_ext_mr(uae_p32(temp_fp),fpp_movem_index2[list]);
                                        sub_l_ri(ad,4);
-                                       mov_l_rm(S2,uae_ptr32(temp_fp));
+                                       mov_l_rm(S2,uae_p32(temp_fp));
                                        writelong_clobber(ad,S2,S3);
                                        sub_l_ri(ad,4);
-                                       mov_l_rm(S2,uae_ptr32(temp_fp)+4);
+                                       mov_l_rm(S2,uae_p32(temp_fp)+4);
                                        writelong_clobber(ad,S2,S3);
                                        sub_l_ri(ad,4);
-                                       mov_w_rm(S2,uae_ptr32(temp_fp)+8);
+                                       mov_w_rm(S2,uae_p32(temp_fp)+8);
                                        writeword_clobber(ad,S2,S3);
                                }
                                list = fpp_movem_next[list];
@@ -1006,16 +1006,16 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                fmov_pi (dreg);
                                break;
                                case 0x0b:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_l10_2));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_l10_2));
                                break;
                                case 0x0c:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_exp_1));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_exp_1));
                                break;
                                case 0x0d:
                                fmov_log2_e (dreg);
                                break;
                                case 0x0e:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_l10_e));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_l10_e));
                                break;
                                case 0x0f:
                                fmov_0 (dreg);
@@ -1024,49 +1024,49 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                fmov_loge_2 (dreg);
                                break;
                                case 0x31:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_ln_10));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_ln_10));
                                break;
                                case 0x32:
                                fmov_1 (dreg);
                                break;
                                case 0x33:
-                               fmovs_rm (dreg, uae_ptr32(&fp_1e1));
+                               fmovs_rm (dreg, uae_p32(&fp_1e1));
                                break;
                                case 0x34:
-                               fmovs_rm (dreg, uae_ptr32(&fp_1e2));
+                               fmovs_rm (dreg, uae_p32(&fp_1e2));
                                break;
                                case 0x35:
-                               fmovs_rm (dreg, uae_ptr32(&fp_1e4));
+                               fmovs_rm (dreg, uae_p32(&fp_1e4));
                                break;
                                case 0x36:
-                               fmov_rm (dreg, uae_ptr32(&fp_1e8));
+                               fmov_rm (dreg, uae_p32(&fp_1e8));
                                break;
                                case 0x37:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e16));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e16));
                                break;
                                case 0x38:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e32));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e32));
                                break;
                                case 0x39:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e64));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e64));
                                break;
                                case 0x3a:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e128));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e128));
                                break;
                                case 0x3b:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e256));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e256));
                                break;
                                case 0x3c:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e512));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e512));
                                break;
                                case 0x3d:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e1024));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e1024));
                                break;
                                case 0x3e:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e2048));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e2048));
                                break;
                                case 0x3f:
-                               fmov_ext_rm (dreg, uae_ptr32(&xhex_1e4096));
+                               fmov_ext_rm (dreg, uae_p32(&xhex_1e4096));
                                break;
                                default:
                                FAIL (1);
@@ -1109,11 +1109,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                frndint_rr (dreg, sreg); /* during the JIT compilation and not at runtime */
                        else {
                                mov_l_ri (S1, 0x10); /* extended round to zero */
-                               fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                               fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                frndint_rr (dreg, sreg);
-                               mov_l_rm (S1, uae_ptr32(&regs.fpcr));
+                               mov_l_rm (S1, uae_p32(&regs.fpcr));
                                and_l_ri (S1, 0xf0); /* restore control word */
-                               fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                               fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                        }
                        break;
 #endif
@@ -1177,11 +1177,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
 #if USE_X86_FPUCW
                        if ((regs.fpcr & 0x30) != 0x10) { /* use round to zero */
                                mov_l_ri (S1, (regs.fpcr & 0xC0) | 0x10);
-                               fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                               fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                facos_rr (dreg, sreg);
-                               mov_l_rm (S1, uae_ptr32(&regs.fpcr));
+                               mov_l_rm (S1, uae_p32(&regs.fpcr));
                                and_l_ri (S1, 0xf0); /* restore control word */
-                               fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                               fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                break;
                        }
 #endif
@@ -1267,8 +1267,8 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        fmov_rr (dreg, sreg);
                        }
                        else {
-                               fmovs_mr (uae_ptr32(temp_fp), sreg);
-                               fmovs_rm (dreg, uae_ptr32(temp_fp));
+                               fmovs_mr (uae_p32(temp_fp), sreg);
+                               fmovs_rm (dreg, uae_p32(temp_fp));
                        }
                        break;
                        case 0x44: /* FDMOVE */
@@ -1277,8 +1277,8 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        fmov_rr (dreg, sreg);
                        }
                        else {
-                               fmov_mr (uae_ptr32(temp_fp), sreg);
-                               fmov_rm (dreg, uae_ptr32(temp_fp));
+                               fmov_mr (uae_p32(temp_fp), sreg);
+                               fmov_rm (dreg, uae_p32(temp_fp));
                        }
                        break;
                        case 0x41: /* FSSQRT */
@@ -1302,11 +1302,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        fsqrt_rr (dreg, sreg);
                                else { /* if we have SINGLE presision, force DOUBLE */
                                        mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80);
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                        fsqrt_rr (dreg, sreg);
-                                       mov_l_rm (S1, uae_ptr32(&regs.fpcr));
+                                       mov_l_rm (S1, uae_p32(&regs.fpcr));
                                        and_l_ri (S1, 0xf0); /* restore control word */
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                }
                                break;
                        }
@@ -1355,11 +1355,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        fdiv_rr (dreg, sreg);
                                else { /* if we have SINGLE presision, force DOUBLE */
                                        mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80);
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                        fdiv_rr (dreg, sreg);
-                                       mov_l_rm (S1, uae_ptr32(&regs.fpcr));
+                                       mov_l_rm (S1, uae_p32(&regs.fpcr));
                                        and_l_ri (S1, 0xf0); /* restore control word */
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                }
                                break;
                        }
@@ -1378,11 +1378,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        fadd_rr (dreg, sreg);
                                else { /* if we have SINGLE presision, force DOUBLE */
                                        mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80);
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                        fadd_rr (dreg, sreg);
-                                       mov_l_rm (S1, uae_ptr32(&regs.fpcr));
+                                       mov_l_rm (S1, uae_p32(&regs.fpcr));
                                        and_l_ri (S1, 0xf0); /* restore control word */
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                }
                                break;
                        }
@@ -1401,11 +1401,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        fmul_rr (dreg, sreg);
                                else { /* if we have SINGLE presision, force DOUBLE */
                                        mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80);
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                        fmul_rr (dreg, sreg);
-                                       mov_l_rm (S1, uae_ptr32(&regs.fpcr));
+                                       mov_l_rm (S1, uae_p32(&regs.fpcr));
                                        and_l_ri (S1, 0xf0); /* restore control word */
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                }
                                break;
                        }
@@ -1434,11 +1434,11 @@ void comp_fpp_opp (uae_u32 opcode, uae_u16 extra)
                                        fsub_rr (dreg, sreg);
                                else { /* if we have SINGLE presision, force DOUBLE */
                                        mov_l_ri (S1, (regs.fpcr & 0x30) | 0x80);
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                        fsub_rr (dreg, sreg);
-                                       mov_l_rm (S1, uae_ptr32(&regs.fpcr));
+                                       mov_l_rm (S1, uae_p32(&regs.fpcr));
                                        and_l_ri (S1, 0xf0); /* restore control word */
-                                       fldcw_m_indexed (S1, uae_ptr32(x86_fpucw));
+                                       fldcw_m_indexed (S1, uae_p32(x86_fpucw));
                                }
                                break;
                        }

diff --git a/jit/compemu_support.cpp b/jit/compemu_support.cpp
index 32fe3a6d70d397477fc04682189ba51c367e0a2d..121e06e5d336eadff15040153686fccc7db53175 100644 (file)
--- a/jit/compemu_support.cpp
+++ b/jit/compemu_support.cpp
@@ -101,7 +101,7 @@
        uae_log("JIT: " format "\n", ##__VA_ARGS__);
 #define jit_log2(format, ...)
 
-#define MEMBaseDiff uae_ptr32(NATMEM_OFFSET)
+#define MEMBaseDiff uae_p32(NATMEM_OFFSET)
 
 #ifdef NATMEM_OFFSET
 #define FIXED_ADDRESSING 1
@@ -1544,7 +1544,7 @@ static  int alloc_reg_hinted(int r, int size, int willclobber, int hint)
                                else if (r==FLAGX)
                                        raw_load_flagx(bestreg,r);
                                else {
-                                       raw_mov_l_rm(bestreg,uae_ptr32(live.state[r].mem));
+                                       raw_mov_l_rm(bestreg,uae_p32(live.state[r].mem));
                                }
                                live.state[r].dirtysize=0;
                                set_status(r,CLEAN);
@@ -2758,8 +2758,8 @@ static void align_target(uae_u32 a)
 static inline int isinrom(uintptr addr)
 {
 #ifdef UAE
-       return (addr >= uae_ptr32(kickmem_bank.baseaddr) &&
-                       addr < uae_ptr32(kickmem_bank.baseaddr + 8 * 65536));
+       return (addr >= uae_p32(kickmem_bank.baseaddr) &&
+                       addr < uae_p32(kickmem_bank.baseaddr + 8 * 65536));
 #else
        return ((addr >= (uintptr)ROMBaseHost) && (addr < (uintptr)ROMBaseHost + ROMSize));
 #endif
@@ -2870,7 +2870,7 @@ static void writemem_real(int address, int source, int size, int tmp, int clobbe
 
        mov_l_rr(f,address);
        shrl_l_ri(f,16);  /* The index into the baseaddr table */
-       mov_l_rm_indexed(f,uae_ptr32(baseaddr),f);
+       mov_l_rm_indexed(f,uae_p32(baseaddr),f);
 
        if (address==source) { /* IBrowse does this! */
                if (size > 1) {
@@ -2898,7 +2898,7 @@ static inline void writemem(int address, int source, int offset, int size, int t
 
        mov_l_rr(f,address);
        shrl_l_ri(f,16);   /* The index into the mem bank table */
-       mov_l_rm_indexed(f,uae_ptr32(mem_banks),f);
+       mov_l_rm_indexed(f,uae_p32(mem_banks),f);
        /* Now f holds a pointer to the actual membank */
        mov_l_rR(f,f,offset);
        /* Now f holds the address of the b/w/lput function */
@@ -2980,7 +2980,7 @@ static void readmem_real(int address, int dest, int size, int tmp)
 
        mov_l_rr(f,address);
        shrl_l_ri(f,16);   /* The index into the baseaddr table */
-       mov_l_rm_indexed(f,uae_ptr32(baseaddr),f);
+       mov_l_rm_indexed(f,uae_p32(baseaddr),f);
        /* f now holds the offset */
 
        switch(size) {
@@ -2999,7 +2999,7 @@ static inline void readmem(int address, int dest, int offset, int size, int tmp)
 
        mov_l_rr(f,address);
        shrl_l_ri(f,16);   /* The index into the mem bank table */
-       mov_l_rm_indexed(f,uae_ptr32(mem_banks),f);
+       mov_l_rm_indexed(f,uae_p32(mem_banks),f);
        /* Now f holds a pointer to the actual membank */
        mov_l_rR(f,f,offset);
        /* Now f holds the address of the b/w/lget function */
@@ -3062,7 +3062,7 @@ static inline void get_n_addr_real(int address, int dest, int tmp)
        mov_l_rr(f,address);
        mov_l_rr(dest,address); // gb-- nop if dest==address
        shrl_l_ri(f,16);
-       mov_l_rm_indexed(f,uae_ptr32(baseaddr),f);
+       mov_l_rm_indexed(f,uae_p32(baseaddr),f);
        add_l(dest,f);
        forget_about(tmp);
 }
@@ -3093,7 +3093,7 @@ void get_n_addr_jmp(int address, int dest, int tmp)
                f=dest;
        mov_l_rr(f,address);
        shrl_l_ri(f,16);   /* The index into the baseaddr bank table */
-       mov_l_rm_indexed(dest,uae_ptr32(baseaddr),f);
+       mov_l_rm_indexed(dest,uae_p32(baseaddr),f);
        add_l(dest,address);
        and_l_ri (dest, ~1);
        forget_about(tmp);
@@ -3558,9 +3558,9 @@ static inline void create_popalls(void)
        }
        raw_dec_sp(stack_space);
        r=REG_PC_TMP;
-       raw_mov_l_rm(r,(uintptr)&regs.pc_p);
+       raw_mov_l_rm(r, uae_p32(&regs.pc_p));
        raw_and_l_ri(r,TAGMASK);
-       raw_jmp_m_indexed((uintptr)cache_tags,r,SIZEOF_VOID_P);
+       raw_jmp_m_indexed(uae_p32(cache_tags), r, SIZEOF_VOID_P);
 
        /* now the exit points */
        align_target(align_jumps);
@@ -3570,7 +3570,7 @@ static inline void create_popalls(void)
                if (need_to_preserve[i])
                        raw_pop_l_r(i);
        }
-       raw_jmp((uintptr)do_nothing);
+       raw_jmp(uae_p32(do_nothing));
 
        align_target(align_jumps);
        popall_execute_normal=get_target();
@@ -3579,7 +3579,7 @@ static inline void create_popalls(void)
                if (need_to_preserve[i])
                        raw_pop_l_r(i);
        }
-       raw_jmp((uintptr)execute_normal);
+       raw_jmp(uae_p32(execute_normal));
 
        align_target(align_jumps);
        popall_cache_miss=get_target();
@@ -3588,7 +3588,7 @@ static inline void create_popalls(void)
                if (need_to_preserve[i])
                        raw_pop_l_r(i);
        }
-       raw_jmp((uintptr)cache_miss);
+       raw_jmp(uae_p32(cache_miss));
 
        align_target(align_jumps);
        popall_recompile_block=get_target();
@@ -3597,7 +3597,7 @@ static inline void create_popalls(void)
                if (need_to_preserve[i])
                        raw_pop_l_r(i);
        }
-       raw_jmp((uintptr)recompile_block);
+       raw_jmp(uae_p32(recompile_block));
 
        align_target(align_jumps);
        popall_exec_nostats=get_target();
@@ -3606,7 +3606,7 @@ static inline void create_popalls(void)
                if (need_to_preserve[i])
                        raw_pop_l_r(i);
        }
-       raw_jmp((uintptr)exec_nostats);
+       raw_jmp(uae_p32(exec_nostats));
 
        align_target(align_jumps);
        popall_check_checksum=get_target();
@@ -3615,7 +3615,7 @@ static inline void create_popalls(void)
                if (need_to_preserve[i])
                        raw_pop_l_r(i);
        }
-       raw_jmp((uintptr)check_checksum);
+       raw_jmp(uae_p32(check_checksum));
 
 #ifdef UAE
        /* FIXME: write-protect popallspace? */
@@ -4216,8 +4216,8 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
 
                bi->handler=
                        bi->handler_to_use=(cpuop_func*)get_target();
-               raw_cmp_l_mi(uae_ptr32(&regs.pc_p),uae_ptr32(pc_hist[0].location));
-               raw_jnz(uae_ptr32(popall_cache_miss));
+               raw_cmp_l_mi(uae_p32(&regs.pc_p),uae_p32(pc_hist[0].location));
+               raw_jnz(uae_p32(popall_cache_miss));
                /* This was 16 bytes on the x86, so now aligned on (n+1)*32 */
 
                was_comp=0;
@@ -4306,7 +4306,7 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
                                                        was_comp=0;
                                                }
                                                raw_mov_l_ri(REG_PAR1,(uae_u32)opcode);
-                                               raw_mov_l_ri(REG_PAR2,uae_ptr32(&regs));
+                                               raw_mov_l_ri(REG_PAR2,uae_p32(&regs));
 #if USE_NORMAL_CALLING_CONVENTION
                                                raw_push_l_r(REG_PAR2);
                                                raw_push_l_r(REG_PAR1);
@@ -4327,7 +4327,7 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
                                                        raw_jz_b_oponly();
                                                        branchadd=(uae_s8*)get_target();
                                                        emit_byte(0);
-                                                       raw_sub_l_mi(uae_ptr32(&countdown),scaled_cycles(totcycles));
+                                                       raw_sub_l_mi(uae_p32(&countdown),scaled_cycles(totcycles));
                                                        raw_jmp((uintptr)popall_do_nothing);
                                                        *branchadd=(uintptr)get_target()-(uintptr)branchadd-1;
                                                }
@@ -4388,7 +4388,7 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
                                /* predicted outcome */
                                tbi=get_blockinfo_addr_new((void*)t1,1);
                                match_states(tbi);
-                               raw_sub_l_mi(uae_ptr32(&countdown),scaled_cycles(totcycles));
+                               raw_sub_l_mi(uae_p32(&countdown),scaled_cycles(totcycles));
                                raw_jcc_l_oponly(9);
                                tba=(uae_u32*)get_target();
                                emit_jmp_target(get_handler(t1));
@@ -4404,7 +4404,7 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
                                match_states(tbi);
 
                                //flush(1); /* Can only get here if was_comp==1 */
-                               raw_sub_l_mi(uae_ptr32(&countdown),scaled_cycles(totcycles));
+                               raw_sub_l_mi(uae_p32(&countdown),scaled_cycles(totcycles));
                                raw_jcc_l_oponly(9);
                                tba=(uae_u32*)get_target();
                                emit_jmp_target(get_handler(t2));
@@ -4424,7 +4424,7 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
                                        raw_and_l_ri(r,TAGMASK);
                                        int r2 = (r==0) ? 1 : 0;
                                        raw_mov_l_ri(r2,(uintptr)popall_do_nothing);
-                                       raw_sub_l_mi(uae_ptr32(&countdown),scaled_cycles(totcycles));
+                                       raw_sub_l_mi(uae_p32(&countdown),scaled_cycles(totcycles));
 #if USE_NEW_RTASM
                                        raw_cmov_l_rm_indexed(r2,(uintptr)cache_tags,r,SIZEOF_VOID_P,9);
 #else
@@ -4440,7 +4440,7 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
                                        tbi=get_blockinfo_addr_new((void*)(uintptr)v,1);
                                        match_states(tbi);
 
-                                       raw_sub_l_mi(uae_ptr32(&countdown),scaled_cycles(totcycles));
+                                       raw_sub_l_mi(uae_p32(&countdown),scaled_cycles(totcycles));
                                        raw_jcc_l_oponly(9);
                                        tba=(uae_u32*)get_target();
                                        emit_jmp_target(get_handler(v));
@@ -4454,11 +4454,11 @@ void compile_block(cpu_history* pc_hist, int blocklen, int totcycles)
                                        raw_and_l_ri(r,TAGMASK);
                                        int r2 = (r==0) ? 1 : 0;
                                        raw_mov_l_ri(r2,(uintptr)popall_do_nothing);
-                                       raw_sub_l_mi(uae_ptr32(&countdown),scaled_cycles(totcycles));
+                                       raw_sub_l_mi(uae_p32(&countdown),scaled_cycles(totcycles));
 #if USE_NEW_RTASM
                                        raw_cmov_l_rm_indexed(r2,(uintptr)cache_tags,r,SIZEOF_VOID_P,9);
 #else
-                                       raw_cmov_l_rm_indexed(r2,(uintptr)cache_tags,r,9);
+                                       raw_cmov_l_rm_indexed(r2, uae_p32(cache_tags),r,9);
 #endif
                                        raw_jmp_r(r2);
                                }