--- uae/src/include/newcpu.h	2018/04/24 16:38:39	1.1
+++ uae/src/include/newcpu.h	2018/04/24 16:45:11	1.1.1.5
@@ -1,6 +1,6 @@
- /* 
+ /*
   * UAE - The Un*x Amiga Emulator
-  * 
+  *
   * MC68000 emulation
   *
   * Copyright 1995 Bernd Schmidt
@@ -19,48 +19,23 @@ extern int fpp_movem_next[256];
 
 extern int broken_in;
 
-typedef void cpuop_func(ULONG) REGPARAM;
+typedef unsigned long cpuop_func (uae_u32) REGPARAM;
 
 struct cputbl {
     cpuop_func *handler;
     int specific;
-    UWORD opcode;
+    uae_u16 opcode;
 };
 
-extern struct cputbl smallcputbl[];
-
-extern cpuop_func *cpufunctbl[65536];
-extern void op_illg(ULONG) REGPARAM;
+extern unsigned long op_illg (uae_u32) REGPARAM;
 
-typedef char flagtype; 
+typedef char flagtype;
 
-/* Arrrghh.. */
-
-#if defined(USE_COMPILER) && !defined(USE_POINTER)
-#define USE_POINTER
-#undef NEED_TO_DEBUG_BADLY
-#endif
-#if defined(NEED_TO_DEBUG_BADLY) && !defined(USE_POINTER)
-#define USE_POINTER
-#endif
-
-struct flag_struct {
-    unsigned int c:1; /* first byte */
-    int :5;
-    unsigned int z:1;
-    unsigned int n:1;
-    int :3;
-    unsigned int v:1; /* second byte */
-    int :4;
-    unsigned int x:1; /* third & fourth */
-    int :15;
-};
-
-extern struct regstruct 
+extern struct regstruct
 {
-    ULONG d[8];
-    CPTR  a[8],usp,isp,msp;
-    UWORD sr;
+    uae_u32 regs[16];
+    uaecptr  usp,isp,msp;
+    uae_u16 sr;
     flagtype t1;
     flagtype t0;
     flagtype s;
@@ -68,196 +43,197 @@ extern struct regstruct
     flagtype x;
     flagtype stopped;
     int intmask;
-    ULONG pc;
-#ifdef USE_POINTER
-    UBYTE *pc_p;
-    UBYTE *pc_oldp;
-#endif
-    
-    ULONG vbr,sfc,dfc;
+
+    uae_u32 pc;
+    uae_u8 *pc_p;
+    uae_u8 *pc_oldp;
+
+    uae_u32 vbr,sfc,dfc;
 
     double fp[8];
-    ULONG fpcr,fpsr,fpiar;
-    ULONG spcflags;
+    uae_u32 fpcr,fpsr,fpiar;
+
+    uae_u32 spcflags;
+    uae_u32 kick_mask;
+
+    /* Fellow sources say this is 4 longwords. That's impossible. It needs
+     * to be at least a longword. The HRM has some cryptic comment about two
+     * instructions being on the same longword boundary.
+     * The way this is implemented now seems like a good compromise.
+     */
+    uae_u32 prefetch;
 } regs, lastint_regs;
 
-#ifdef INTEL_FLAG_OPT
-extern struct flag_struct regflags __asm__ ("regflags");
+#define m68k_dreg(r,num) ((r).regs[(num)])
+#define m68k_areg(r,num) (((r).regs + 8)[(num)])
+
+#define get_ibyte(o) do_get_mem_byte((uae_u8 *)(regs.pc_p + (o) + 1))
+#define get_iword(o) do_get_mem_word((uae_u16 *)(regs.pc_p + (o)))
+#define get_ilong(o) do_get_mem_long((uae_u32 *)(regs.pc_p + (o)))
+
+#ifdef HAVE_GET_WORD_UNSWAPPED
+#define GET_OPCODE (do_get_mem_word_unswapped (regs.pc_p))
 #else
-extern struct flag_struct regflags;
+#define GET_OPCODE (get_iword (0))
 #endif
 
-#define ZFLG (regflags.z)
-#define NFLG (regflags.n)
-#define CFLG (regflags.c)
-#define VFLG (regflags.v)
-#define XFLG (regflags.x)
+static __inline__ uae_u32 get_ibyte_prefetch (uae_s32 o)
+{
+    if (o > 3 || o < 0)
+	return do_get_mem_byte((uae_u8 *)(regs.pc_p + o + 1));
 
-#ifdef USE_POINTER
-static __inline__ UWORD nextiword(void)
+    return do_get_mem_byte((uae_u8 *)(((uae_u8 *)&regs.prefetch) + o + 1));
+}
+static __inline__ uae_u32 get_iword_prefetch (uae_s32 o)
 {
-    UWORD r = (*(regs.pc_p) << 8) | (*(regs.pc_p + 1) << 0);
-    regs.pc_p += 2;
-    return r;
+    if (o > 3 || o < 0)
+	return do_get_mem_word((uae_u16 *)(regs.pc_p + o));
+
+    return do_get_mem_word((uae_u16 *)(((uae_u8 *)&regs.prefetch) + o));
 }
+static __inline__ uae_u32 get_ilong_prefetch (uae_s32 o)
+{
+    if (o > 3 || o < 0)
+	return do_get_mem_long((uae_u32 *)(regs.pc_p + o));
+    if (o == 0)
+	return do_get_mem_long(&regs.prefetch);
+    return (do_get_mem_word (((uae_u16 *)&regs.prefetch) + 1) << 16) | do_get_mem_word ((uae_u16 *)(regs.pc_p + 4));
+}
+
+#define m68k_incpc(o) (regs.pc_p += (o))
 
-static __inline__ ULONG nextilong(void)
+static __inline__ void fill_prefetch_0 (void)
 {
-    ULONG r = (*regs.pc_p << 24) | (*(regs.pc_p + 1) << 16) | (*(regs.pc_p + 2) << 8) | (*(regs.pc_p + 3) << 0);
-    regs.pc_p += 4;
-    return r;
+    uae_u32 r;
+#ifdef UNALIGNED_PROFITABLE
+    r = *(uae_u32 *)regs.pc_p;
+    regs.prefetch = r;
+#else
+    r = do_get_mem_long ((uae_u32 *)regs.pc_p);
+    do_put_mem_long (&regs.prefetch, r);
+#endif
+}
+
+#if 0
+static __inline__ void fill_prefetch_2 (void)
+{
+    uae_u32 r = do_get_mem_long (&regs.prefetch) << 16;
+    uae_u32 r2 = do_get_mem_word (((uae_u16 *)regs.pc_p) + 1);
+    r |= r2;
+    do_put_mem_long (&regs.prefetch, r);
 }
 #else
+#define fill_prefetch_2 fill_prefetch_0
+#endif
 
-static __inline__ UWORD nextiword(void)
+/* These are only used by the 68020/68881 code, and therefore don't
+ * need to handle prefetch.  */
+static __inline__ uae_u32 next_ibyte (void)
 {
-    UWORD r = get_aword(regs.pc);
-    regs.pc += 2;
+    uae_u32 r = get_ibyte (0);
+    m68k_incpc (2);
     return r;
 }
 
-static __inline__ ULONG nextilong(void)
+static __inline__ uae_u32 next_iword (void)
 {
-    ULONG r = get_along(regs.pc);
-    regs.pc += 4;
+    uae_u32 r = get_iword (0);
+    m68k_incpc (2);
     return r;
 }
 
-#endif
-
-#ifdef USE_POINTER
+static __inline__ uae_u32 next_ilong (void)
+{
+    uae_u32 r = get_ilong (0);
+    m68k_incpc (4);
+    return r;
+}
 
-#if !defined(NEED_TO_DEBUG_BADLY) && !defined(USE_COMPILER)
-static __inline__ void m68k_setpc(CPTR newpc)
+#if !defined USE_COMPILER
+static __inline__ void m68k_setpc (uaecptr newpc)
 {
-    regs.pc = newpc;
     regs.pc_p = regs.pc_oldp = get_real_address(newpc);
+    regs.pc = newpc;
 }
 #else
-extern void m68k_setpc(CPTR newpc);
+extern void m68k_setpc (uaecptr newpc);
 #endif
 
-static __inline__ CPTR m68k_getpc(void)
+static __inline__ uaecptr m68k_getpc (void)
 {
     return regs.pc + ((char *)regs.pc_p - (char *)regs.pc_oldp);
 }
 
-#else
-
-static __inline__ void m68k_setpc(CPTR newpc)
+static __inline__ uaecptr m68k_getpc_p (uae_u8 *p)
 {
-    regs.pc = newpc;
+    return regs.pc + ((char *)p - (char *)regs.pc_oldp);
 }
 
-static __inline__ CPTR m68k_getpc(void)
-{
-    return regs.pc;
-}
-#endif
-
 #ifdef USE_COMPILER
-extern void m68k_setpc_fast(CPTR newpc);
-extern void m68k_setpc_bcc(CPTR newpc);
-extern void m68k_setpc_rte(CPTR newpc);
+extern void m68k_setpc_fast (uaecptr newpc);
+extern void m68k_setpc_bcc (uaecptr newpc);
+extern void m68k_setpc_rte (uaecptr newpc);
 #else
 #define m68k_setpc_fast m68k_setpc
 #define m68k_setpc_bcc  m68k_setpc
 #define m68k_setpc_rte  m68k_setpc
 #endif
 
-static __inline__ void m68k_setstopped(int stop)
+static __inline__ void m68k_setstopped (int stop)
 {
     regs.stopped = stop;
     if (stop)
 	regs.spcflags |= SPCFLAG_STOP;
 }
 
-static __inline__ int cctrue(const int cc)
-{
-    switch(cc){
-     case 0: return 1;                       /* T */
-     case 1: return 0;                       /* F */
-     case 2: return !CFLG && !ZFLG;          /* HI */
-     case 3: return CFLG || ZFLG;            /* LS */
-     case 4: return !CFLG;                   /* CC */
-     case 5: return CFLG;                    /* CS */
-     case 6: return !ZFLG;                   /* NE */
-     case 7: return ZFLG;                    /* EQ */
-     case 8: return !VFLG;                   /* VC */
-     case 9: return VFLG;                    /* VS */
-     case 10:return !NFLG;                   /* PL */
-     case 11:return NFLG;                    /* MI */
-     case 12:return NFLG == VFLG;            /* GE */
-     case 13:return NFLG != VFLG;            /* LT */
-     case 14:return !ZFLG && (NFLG == VFLG); /* GT */
-     case 15:return ZFLG || (NFLG != VFLG);  /* LE */
-    }
-    abort();
-    return 0;
-}
-
-#if CPU_LEVEL > 1
-static __inline__ ULONG get_disp_ea (ULONG base)
-{
-    UWORD dp = nextiword();
-    int reg = (dp >> 12) & 7;
-    LONG regd = dp & 0x8000 ? regs.a[reg] : regs.d[reg];
-    if ((dp & 0x800) == 0)
-	regd = (LONG)(WORD)regd;
-    regd <<= (dp >> 9) & 3;
-    if (dp & 0x100) {
-	LONG outer = 0;
-	if (dp & 0x80) base = 0;
-	if (dp & 0x40) regd = 0;
-
-	if ((dp & 0x30) == 0x20) base += (LONG)(WORD)nextiword();
-	if ((dp & 0x30) == 0x30) base += nextilong();
-	
-	if ((dp & 0x3) == 0x2) outer = (LONG)(WORD)nextiword();
-	if ((dp & 0x3) == 0x3) outer = nextilong();
-	
-	if ((dp & 0x4) == 0) base += regd;
-	if (dp & 0x3) base = get_long (base);
-	if (dp & 0x4) base += regd;
-	
-	return base + outer;
-    } else {
-	return base + (LONG)((BYTE)dp) + regd;
-    }
-}
-#else
-static __inline__ ULONG get_disp_ea (ULONG base)
-{
-    UWORD dp = nextiword();
-    int reg = (dp >> 12) & 7;
-    LONG regd = dp & 0x8000 ? regs.a[reg] : regs.d[reg];
-    if ((dp & 0x800) == 0)
-	regd = (LONG)(WORD)regd;
-    return base + (BYTE)(dp) + regd;
-}
-#endif
+extern uae_u32 get_disp_ea_020 (uae_u32 base, uae_u32 dp);
+extern uae_u32 get_disp_ea_000 (uae_u32 base, uae_u32 dp);
+
+extern uae_s32 ShowEA (int reg, amodes mode, wordsizes size, char *buf);
 
-extern void MakeSR(void);
-extern void MakeFromSR(void);
-extern void Exception(int, CPTR);
-extern void dump_counts(void);
-extern void m68k_move2c(int, ULONG *);
-extern void m68k_movec2(int, ULONG *);
-extern void m68k_divl (ULONG, ULONG, UWORD, CPTR);
-extern void m68k_mull (ULONG, ULONG, UWORD);
+extern void MakeSR (void);
+extern void MakeFromSR (void);
+extern void Exception (int, uaecptr);
+extern void dump_counts (void);
+extern void m68k_move2c (int, uae_u32 *);
+extern void m68k_movec2 (int, uae_u32 *);
+extern void m68k_divl (uae_u32, uae_u32, uae_u16, uaecptr);
+extern void m68k_mull (uae_u32, uae_u32, uae_u16);
 extern void init_m68k (void);
-extern void m68k_run(void);
-extern void m68k_go(int);
-extern void m68k_run_2(void);
-extern void m68k_dumpstate(CPTR *);
-extern void m68k_disasm(CPTR,CPTR *,int);
-extern void m68k_reset(void);
-extern void mmu_op (ULONG, UWORD);
-extern void fpp_opp (ULONG, UWORD);
-extern void fdbcc_opp (ULONG, UWORD);
-extern void fscc_opp (ULONG, UWORD);
-extern void ftrapcc_opp (ULONG,CPTR);
-extern void fbcc_opp (ULONG, CPTR, ULONG);
-extern void fsave_opp (ULONG);
-extern void frestore_opp (ULONG);
+extern void m68k_go (int);
+extern void m68k_dumpstate (uaecptr *);
+extern void m68k_disasm (uaecptr, uaecptr *, int);
+extern void m68k_reset (void);
+
+extern void mmu_op (uae_u32, uae_u16);
+
+extern void fpp_opp (uae_u32, uae_u16);
+extern void fdbcc_opp (uae_u32, uae_u16);
+extern void fscc_opp (uae_u32, uae_u16);
+extern void ftrapcc_opp (uae_u32,uaecptr);
+extern void fbcc_opp (uae_u32, uaecptr, uae_u32);
+extern void fsave_opp (uae_u32);
+extern void frestore_opp (uae_u32);
+
+/* Opcode of faulting instruction */
+extern uae_u16 last_op_for_exception_3;
+/* PC at fault time */
+extern uaecptr last_addr_for_exception_3;
+/* Address that generated the exception */
+extern uaecptr last_fault_for_exception_3;
+
+#define CPU_OP_NAME(a) op ## a
+
+/* 68020 + 68881 */
+extern struct cputbl op_smalltbl_0[];
+/* 68020 */
+extern struct cputbl op_smalltbl_1[];
+/* 68010 */
+extern struct cputbl op_smalltbl_2[];
+/* 68000 */
+extern struct cputbl op_smalltbl_3[];
+/* 68000 slow but compatible.  */
+extern struct cputbl op_smalltbl_4[];
+
+extern cpuop_func *cpufunctbl[65536] ASM_SYM_FOR_FUNC ("cpufunctbl");