summaryrefslogtreecommitdiffstatshomepage
path: root/trunk/src/emu/cpu/z8000/z8000ops.c
diff options
context:
space:
mode:
Diffstat (limited to 'trunk/src/emu/cpu/z8000/z8000ops.c')
-rw-r--r--trunk/src/emu/cpu/z8000/z8000ops.c6607
1 files changed, 6607 insertions, 0 deletions
diff --git a/trunk/src/emu/cpu/z8000/z8000ops.c b/trunk/src/emu/cpu/z8000/z8000ops.c
new file mode 100644
index 00000000000..bdbc673e4a1
--- /dev/null
+++ b/trunk/src/emu/cpu/z8000/z8000ops.c
@@ -0,0 +1,6607 @@
+/*****************************************************************************
+ *
+ * z8000ops.c
+ * Portable Z8000(2) emulator
+ * Opcode functions
+ *
+ * Copyright Juergen Buchmueller, all rights reserved.
+ * Bug fixes and MSB_FIRST compliance Ernesto Corvi.
+ *
+ * - This source code is released as freeware for non-commercial purposes.
+ * - You are free to use and redistribute this code in modified or
+ * unmodified form, provided you list me in the credits.
+ * - If you modify this source code, you must add a notice to each modified
+ * source file that it has been changed. If you're a nice person, you
+ * will clearly mark each change too. :)
+ * - If you wish to use this for commercial purposes, please contact me at
+ * pullmoll@t-online.de
+ * - The author of this copywritten work reserves the right to change the
+ * terms of its usage and license at any time, including retroactively
+ * - This entire notice must remain in the source code.
+ *
+ *****************************************************************************/
+
+/******************************************
+ helper functions
+ ******************************************/
+
+/******************************************
+ check new fcw for switch to system mode
+ and swap stack pointer if needed
+ ******************************************/
+INLINE void CHANGE_FCW(z8000_state *cpustate, UINT16 fcw)
+{
+ if (fcw & F_S_N) { /* system mode now? */
+ if (!(cpustate->fcw & F_S_N)) { /* and not before? */
+ UINT16 tmp = cpustate->RW(SP);
+ cpustate->RW(SP) = cpustate->nsp;
+ cpustate->nsp = tmp;
+ }
+ } else { /* user mode now */
+ if (cpustate->fcw & F_S_N) { /* and not before? */
+ UINT16 tmp = cpustate->RW(SP);
+ cpustate->RW(SP) = cpustate->nsp;
+ cpustate->nsp = tmp;
+ }
+ }
+ if (!(cpustate->fcw & F_NVIE) && (fcw & F_NVIE) && (cpustate->irq_state[0] != CLEAR_LINE))
+ cpustate->irq_req |= Z8000_NVI;
+ if (!(cpustate->fcw & F_VIE) && (fcw & F_VIE) && (cpustate->irq_state[1] != CLEAR_LINE))
+ cpustate->irq_req |= Z8000_VI;
+ cpustate->fcw = fcw; /* set new cpustate->fcw */
+}
+
+INLINE void PUSHW(z8000_state *cpustate, UINT8 dst, UINT16 value)
+{
+ cpustate->RW(dst) -= 2;
+ WRMEM_W(cpustate, cpustate->RW(dst), value);
+}
+
+INLINE UINT16 POPW(z8000_state *cpustate, UINT8 src)
+{
+ UINT16 result = RDMEM_W(cpustate, cpustate->RW(src));
+ cpustate->RW(src) += 2;
+ return result;
+}
+
+INLINE void PUSHL(z8000_state *cpustate, UINT8 dst, UINT32 value)
+{
+ cpustate->RW(dst) -= 4;
+ WRMEM_L(cpustate, cpustate->RW(dst), value);
+}
+
+INLINE UINT32 POPL(z8000_state *cpustate, UINT8 src)
+{
+ UINT32 result = RDMEM_L(cpustate, cpustate->RW(src));
+ cpustate->RW(src) += 4;
+ return result;
+}
+
+/* check zero and sign flag for byte, word and long results */
+#define CHK_XXXB_ZS if (!result) SET_Z; else if ((INT8) result < 0) SET_S
+#define CHK_XXXW_ZS if (!result) SET_Z; else if ((INT16)result < 0) SET_S
+#define CHK_XXXL_ZS if (!result) SET_Z; else if ((INT32)result < 0) SET_S
+#define CHK_XXXQ_ZS if (!result) SET_Z; else if ((INT64)result < 0) SET_S
+
+#define CHK_XXXB_ZSP cpustate->fcw |= z8000_zsp[result]
+
+/* check carry for addition and subtraction */
+#define CHK_ADDX_C if (result < dest) SET_C
+#define CHK_ADCX_C if (result < dest || (result == dest && value)) SET_C
+
+#define CHK_SUBX_C if (result > dest) SET_C
+#define CHK_SBCX_C if (result > dest || (result == dest && value)) SET_C
+
+/* check half carry for A addition and S subtraction */
+#define CHK_ADDB_H if ((result & 15) < (dest & 15)) SET_H
+#define CHK_ADCB_H if ((result & 15) < (dest & 15) || ((result & 15) == (dest & 15) && (value & 15))) SET_H
+
+#define CHK_SUBB_H if ((result & 15) > (dest & 15)) SET_H
+#define CHK_SBCB_H if ((result & 15) > (dest & 15) || ((result & 15) == (dest & 15) && (value & 15))) SET_H
+
+/* check overflow for addition for byte, word and long */
+#define CHK_ADDB_V if (((value & dest & ~result) | (~value & ~dest & result)) & S08) SET_V
+#define CHK_ADDW_V if (((value & dest & ~result) | (~value & ~dest & result)) & S16) SET_V
+#define CHK_ADDL_V if (((value & dest & ~result) | (~value & ~dest & result)) & S32) SET_V
+
+/* check overflow for subtraction for byte, word and long */
+#define CHK_SUBB_V if (((~value & dest & ~result) | (value & ~dest & result)) & S08) SET_V
+#define CHK_SUBW_V if (((~value & dest & ~result) | (value & ~dest & result)) & S16) SET_V
+#define CHK_SUBL_V if (((~value & dest & ~result) | (value & ~dest & result)) & S32) SET_V
+
+
+/******************************************
+ add byte
+ flags: CZSVDH
+ ******************************************/
+INLINE UINT8 ADDB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest + value;
+ CLR_CZSVH; /* first clear C, Z, S, P/V and H flags */
+ CLR_DA; /* clear DA (decimal adjust) flag for addb */
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ CHK_ADDX_C; /* set C if result overflowed */
+ CHK_ADDB_V; /* set V if result has incorrect sign */
+ CHK_ADDB_H; /* set H if lower nibble overflowed */
+ return result;
+}
+
+/******************************************
+ add word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 ADDW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest + value;
+ CLR_CZSV; /* first clear C, Z, S, P/V flags */
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ CHK_ADDX_C; /* set C if result overflowed */
+ CHK_ADDW_V; /* set V if result has incorrect sign */
+ return result;
+}
+
+/******************************************
+ add long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 ADDL(z8000_state *cpustate, UINT32 dest, UINT32 value)
+{
+ UINT32 result = dest + value;
+ CLR_CZSV; /* first clear C, Z, S, P/V flags */
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ CHK_ADDX_C; /* set C if result overflowed */
+ CHK_ADDL_V; /* set V if result has incorrect sign */
+ return result;
+}
+
+/******************************************
+ add with carry byte
+ flags: CZSVDH
+ ******************************************/
+INLINE UINT8 ADCB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest + value + GET_C;
+ CLR_CZSVH; /* first clear C, Z, S, P/V and H flags */
+ CLR_DA; /* clear DA (decimal adjust) flag for adcb */
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ CHK_ADCX_C; /* set C if result overflowed */
+ CHK_ADDB_V; /* set V if result has incorrect sign */
+ CHK_ADCB_H; /* set H if lower nibble overflowed */
+ return result;
+}
+
+/******************************************
+ add with carry word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 ADCW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest + value + GET_C;
+ CLR_CZSV; /* first clear C, Z, S, P/V flags */
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ CHK_ADCX_C; /* set C if result overflowed */
+ CHK_ADDW_V; /* set V if result has incorrect sign */
+ return result;
+}
+
+/******************************************
+ subtract byte
+ flags: CZSVDH
+ ******************************************/
+INLINE UINT8 SUBB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest - value;
+ CLR_CZSVH; /* first clear C, Z, S, P/V and H flags */
+ SET_DA; /* set DA (decimal adjust) flag for subb */
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ CHK_SUBX_C; /* set C if result underflowed */
+ CHK_SUBB_V; /* set V if result has incorrect sign */
+ CHK_SUBB_H; /* set H if lower nibble underflowed */
+ return result;
+}
+
+/******************************************
+ subtract word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 SUBW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest - value;
+ CLR_CZSV; /* first clear C, Z, S, P/V flags */
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ CHK_SUBX_C; /* set C if result underflowed */
+ CHK_SUBW_V; /* set V if result has incorrect sign */
+ return result;
+}
+
+/******************************************
+ subtract long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 SUBL(z8000_state *cpustate, UINT32 dest, UINT32 value)
+{
+ UINT32 result = dest - value;
+ CLR_CZSV; /* first clear C, Z, S, P/V flags */
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ CHK_SUBX_C; /* set C if result underflowed */
+ CHK_SUBL_V; /* set V if result has incorrect sign */
+ return result;
+}
+
+/******************************************
+ subtract with carry byte
+ flags: CZSVDH
+ ******************************************/
+INLINE UINT8 SBCB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest - value - GET_C;
+ CLR_CZSVH; /* first clear C, Z, S, P/V and H flags */
+ SET_DA; /* set DA (decimal adjust) flag for sbcb */
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ CHK_SBCX_C; /* set C if result underflowed */
+ CHK_SUBB_V; /* set V if result has incorrect sign */
+ CHK_SBCB_H; /* set H if lower nibble underflowed */
+ return result;
+}
+
+/******************************************
+ subtract with carry word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 SBCW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest - value - GET_C;
+ CLR_CZSV; /* first clear C, Z, S, P/V flags */
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ CHK_SBCX_C; /* set C if result underflowed */
+ CHK_SUBW_V; /* set V if result has incorrect sign */
+ return result;
+}
+
+/******************************************
+ logical or byte
+ flags: -ZSP--
+ ******************************************/
+INLINE UINT8 ORB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest | value;
+ CLR_ZSP; /* first clear Z, S, P/V flags */
+ CHK_XXXB_ZSP; /* set Z, S and P flags for result byte */
+ return result;
+}
+
+/******************************************
+ logical or word
+ flags: -ZS---
+ ******************************************/
+INLINE UINT16 ORW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest | value;
+ CLR_ZS; /* first clear Z, and S flags */
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ return result;
+}
+
+/******************************************
+ logical and byte
+ flags: -ZSP--
+ ******************************************/
+INLINE UINT8 ANDB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest & value;
+ CLR_ZSP; /* first clear Z,S and P/V flags */
+ CHK_XXXB_ZSP; /* set Z, S and P flags for result byte */
+ return result;
+}
+
+/******************************************
+ logical and word
+ flags: -ZS---
+ ******************************************/
+INLINE UINT16 ANDW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest & value;
+ CLR_ZS; /* first clear Z and S flags */
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ return result;
+}
+
+/******************************************
+ logical exclusive or byte
+ flags: -ZSP--
+ ******************************************/
+INLINE UINT8 XORB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest ^ value;
+ CLR_ZSP; /* first clear Z, S and P/V flags */
+ CHK_XXXB_ZSP; /* set Z, S and P flags for result byte */
+ return result;
+}
+
+/******************************************
+ logical exclusive or word
+ flags: -ZS---
+ ******************************************/
+INLINE UINT16 XORW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest ^ value;
+ CLR_ZS; /* first clear Z and S flags */
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ return result;
+}
+
+
+/******************************************
+ compare byte
+ flags: CZSV--
+ ******************************************/
+INLINE void CPB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest - value;
+ CLR_CZSV; /* first clear C, Z, S and P/V flags */
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ CHK_SUBX_C; /* set C if result underflowed */
+ CHK_SUBB_V;
+}
+
+/******************************************
+ compare word
+ flags: CZSV--
+ ******************************************/
+INLINE void CPW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest - value;
+ CLR_CZSV;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ CHK_SUBX_C; /* set C if result underflowed */
+ CHK_SUBW_V;
+}
+
+/******************************************
+ compare long
+ flags: CZSV--
+ ******************************************/
+INLINE void CPL(z8000_state *cpustate, UINT32 dest, UINT32 value)
+{
+ UINT32 result = dest - value;
+ CLR_CZSV;
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ CHK_SUBX_C; /* set C if result underflowed */
+ CHK_SUBL_V;
+}
+
+/******************************************
+ complement byte
+ flags: -ZSP--
+ ******************************************/
+INLINE UINT8 COMB(z8000_state *cpustate, UINT8 dest)
+{
+ UINT8 result = ~dest;
+ CLR_ZSP;
+ CHK_XXXB_ZSP; /* set Z, S and P flags for result byte */
+ return result;
+}
+
+/******************************************
+ complement word
+ flags: -ZS---
+ ******************************************/
+INLINE UINT16 COMW(z8000_state *cpustate, UINT16 dest)
+{
+ UINT16 result = ~dest;
+ CLR_ZS;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ return result;
+}
+
+/******************************************
+ negate byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 NEGB(z8000_state *cpustate, UINT8 dest)
+{
+ UINT8 result = (UINT8) -dest;
+ CLR_CZSV;
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (result > 0) SET_C;
+ if (result == S08) SET_V;
+ return result;
+}
+
+/******************************************
+ negate word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 NEGW(z8000_state *cpustate, UINT16 dest)
+{
+ UINT16 result = (UINT16) -dest;
+ CLR_CZSV;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (result > 0) SET_C;
+ if (result == S16) SET_V;
+ return result;
+}
+
+/******************************************
+ test byte
+ flags: -ZSP--
+ ******************************************/
+INLINE void TESTB(z8000_state *cpustate, UINT8 result)
+{
+ CLR_ZSP;
+ CHK_XXXB_ZSP; /* set Z and S flags for result byte */
+}
+
+/******************************************
+ test word
+ flags: -ZS---
+ ******************************************/
+INLINE void TESTW(z8000_state *cpustate, UINT16 dest)
+{
+ CLR_ZS;
+ if (!dest) SET_Z; else if (dest & S16) SET_S;
+}
+
+/******************************************
+ test long
+ flags: -ZS---
+ ******************************************/
+INLINE void TESTL(z8000_state *cpustate, UINT32 dest)
+{
+ CLR_ZS;
+ if (!dest) SET_Z; else if (dest & S32) SET_S;
+}
+
+/******************************************
+ increment byte
+ flags: -ZSV--
+ ******************************************/
+INLINE UINT8 INCB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest + value;
+ CLR_ZSV;
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ CHK_ADDB_V; /* set V if result overflowed */
+ return result;
+}
+
+/******************************************
+ increment word
+ flags: -ZSV--
+ ******************************************/
+INLINE UINT16 INCW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest + value;
+ CLR_ZSV;
+ CHK_XXXW_ZS; /* set Z and S flags for result byte */
+ CHK_ADDW_V; /* set V if result overflowed */
+ return result;
+}
+
+/******************************************
+ decrement byte
+ flags: -ZSV--
+ ******************************************/
+INLINE UINT8 DECB(z8000_state *cpustate, UINT8 dest, UINT8 value)
+{
+ UINT8 result = dest - value;
+ CLR_ZSV;
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ CHK_SUBB_V; /* set V if result overflowed */
+ return result;
+}
+
+/******************************************
+ decrement word
+ flags: -ZSV--
+ ******************************************/
+INLINE UINT16 DECW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT16 result = dest - value;
+ CLR_ZSV;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ CHK_SUBW_V; /* set V if result overflowed */
+ return result;
+}
+
+/******************************************
+ multiply words
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 MULTW(z8000_state *cpustate, UINT16 dest, UINT16 value)
+{
+ UINT32 result = (INT32)(INT16)dest * (INT16)value;
+ CLR_CZSV;
+ CHK_XXXL_ZS;
+ if(!value)
+ {
+ /* multiplication with zero is faster */
+ cpustate->icount += (70-18);
+ }
+ if((INT32)result < -0x7fff || (INT32)result >= 0x7fff) SET_C;
+ return result;
+}
+
+/******************************************
+ multiply longs
+ flags: CZSV--
+ ******************************************/
+INLINE UINT64 MULTL(z8000_state *cpustate, UINT32 dest, UINT32 value)
+{
+ UINT64 result = (INT64)(INT32)dest * (INT32)value;
+ if(!value)
+ {
+ /* multiplication with zero is faster */
+ cpustate->icount += (282 - 30);
+ }
+ else
+ {
+ int n;
+ for(n = 0; n < 32; n++)
+ if(dest & (1L << n)) cpustate->icount -= 7;
+ }
+ CLR_CZSV;
+ CHK_XXXQ_ZS;
+ if((INT64)result < -0x7fffffffL || (INT64)result >= 0x7fffffffL) SET_C;
+ return result;
+}
+
+/******************************************
+ divide long by word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 DIVW(z8000_state *cpustate, UINT32 dest, UINT16 value)
+{
+ UINT32 result = dest;
+ UINT16 remainder = 0;
+ CLR_CZSV;
+ if (value)
+ {
+ UINT16 qsign = ((dest >> 16) ^ value) & S16;
+ UINT16 rsign = (dest >> 16) & S16;
+ if ((INT32)dest < 0) dest = -dest;
+ if ((INT16)value < 0) value = -value;
+ result = dest / value;
+ remainder = dest % value;
+ if (qsign) result = -result;
+ if (rsign) remainder = -remainder;
+ if ((INT32)result < -0x8000 || (INT32)result > 0x7fff)
+ {
+ INT32 temp = (INT32)result >> 1;
+ SET_V;
+ if (temp >= -0x8000 && temp <= 0x7fff)
+ {
+ result = (temp < 0) ? -1 : 0;
+ CHK_XXXW_ZS;
+ SET_C;
+ }
+ }
+ else
+ {
+ CHK_XXXW_ZS;
+ }
+ result = ((UINT32)remainder << 16) | (result & 0xffff);
+ }
+ else
+ {
+ SET_Z;
+ SET_V;
+ }
+ return result;
+}
+
+/******************************************
+ divide quad word by long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT64 DIVL(z8000_state *cpustate, UINT64 dest, UINT32 value)
+{
+ UINT64 result = dest;
+ UINT32 remainder = 0;
+ CLR_CZSV;
+ if (value)
+ {
+ UINT32 qsign = ((dest >> 32) ^ value) & S32;
+ UINT32 rsign = (dest >> 32) & S32;
+ if ((INT64)dest < 0) dest = -dest;
+ if ((INT32)value < 0) value = -value;
+ result = dest / value;
+ remainder = dest % value;
+ if (qsign) result = -result;
+ if (rsign) remainder = -remainder;
+ if ((INT64)result < -0x80000000 || (INT64)result > 0x7fffffff)
+ {
+ INT64 temp = (INT64)result >> 1;
+ SET_V;
+ if (temp >= -0x80000000 && temp <= 0x7fffffff)
+ {
+ result = (temp < 0) ? -1 : 0;
+ CHK_XXXL_ZS;
+ SET_C;
+ }
+ }
+ else
+ {
+ CHK_XXXL_ZS;
+ }
+ result = ((UINT64)remainder << 32) | (result & 0xffffffff);
+ }
+ else
+ {
+ SET_Z;
+ SET_V;
+ }
+ return result;
+}
+
+/******************************************
+ rotate left byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 RLB(z8000_state *cpustate, UINT8 dest, UINT8 twice)
+{
+ UINT8 result = (dest << 1) | (dest >> 7);
+ CLR_CZSV;
+ if (twice) result = (result << 1) | (result >> 7);
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (result & 0x01) SET_C;
+ if ((result ^ dest) & S08) SET_V;
+ return result;
+}
+
+/******************************************
+ rotate left word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 RLW(z8000_state *cpustate, UINT16 dest, UINT8 twice)
+{
+ UINT16 result = (dest << 1) | (dest >> 15);
+ CLR_CZSV;
+ if (twice) result = (result << 1) | (result >> 15);
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (result & 0x0001) SET_C;
+ if ((result ^ dest) & S16) SET_V;
+ return result;
+}
+
+/******************************************
+ rotate left through carry byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 RLCB(z8000_state *cpustate, UINT8 dest, UINT8 twice)
+{
+ UINT8 c = dest & S08;
+ UINT8 result = (dest << 1) | GET_C;
+ CLR_CZSV;
+ if (twice) {
+ UINT8 c1 = c >> 7;
+ c = result & S08;
+ result = (result << 1) | c1;
+ }
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ if ((result ^ dest) & S08) SET_V;
+ return result;
+}
+
+/******************************************
+ rotate left through carry word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 RLCW(z8000_state *cpustate, UINT16 dest, UINT8 twice)
+{
+ UINT16 c = dest & S16;
+ UINT16 result = (dest << 1) | GET_C;
+ CLR_CZSV;
+ if (twice) {
+ UINT16 c1 = c >> 15;
+ c = result & S16;
+ result = (result << 1) | c1;
+ }
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ if ((result ^ dest) & S16) SET_V;
+ return result;
+}
+
+/******************************************
+ rotate right byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 RRB(z8000_state *cpustate, UINT8 dest, UINT8 twice)
+{
+ UINT8 result = (dest >> 1) | (dest << 7);
+ CLR_CZSV;
+ if (twice) result = (result >> 1) | (result << 7);
+ if (!result) SET_Z; else if (result & S08) SET_SC;
+ if ((result ^ dest) & S08) SET_V;
+ return result;
+}
+
+/******************************************
+ rotate right word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 RRW(z8000_state *cpustate, UINT16 dest, UINT8 twice)
+{
+ UINT16 result = (dest >> 1) | (dest << 15);
+ CLR_CZSV;
+ if (twice) result = (result >> 1) | (result << 15);
+ if (!result) SET_Z; else if (result & S16) SET_SC;
+ if ((result ^ dest) & S16) SET_V;
+ return result;
+}
+
+/******************************************
+ rotate right through carry byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 RRCB(z8000_state *cpustate, UINT8 dest, UINT8 twice)
+{
+ UINT8 c = dest & 1;
+ UINT8 result = (dest >> 1) | (GET_C << 7);
+ CLR_CZSV;
+ if (twice) {
+ UINT8 c1 = c << 7;
+ c = result & 1;
+ result = (result >> 1) | c1;
+ }
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ if ((result ^ dest) & S08) SET_V;
+ return result;
+}
+
+/******************************************
+ rotate right through carry word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 RRCW(z8000_state *cpustate, UINT16 dest, UINT8 twice)
+{
+ UINT16 c = dest & 1;
+ UINT16 result = (dest >> 1) | (GET_C << 15);
+ CLR_CZSV;
+ if (twice) {
+ UINT16 c1 = c << 15;
+ c = result & 1;
+ result = (result >> 1) | c1;
+ }
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ if ((result ^ dest) & S16) SET_V;
+ return result;
+}
+
+/******************************************
+ shift dynamic arithmetic byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 SDAB(z8000_state *cpustate, UINT8 dest, INT8 count)
+{
+ INT8 result = (INT8) dest;
+ UINT8 c = 0;
+ CLR_CZSV;
+ while (count > 0) {
+ c = result & S08;
+ result <<= 1;
+ count--;
+ }
+ while (count < 0) {
+ c = result & 0x01;
+ result >>= 1;
+ count++;
+ }
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ if ((result ^ dest) & S08) SET_V;
+ return (UINT8)result;
+}
+
+/******************************************
+ shift dynamic arithmetic word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 SDAW(z8000_state *cpustate, UINT16 dest, INT8 count)
+{
+ INT16 result = (INT16) dest;
+ UINT16 c = 0;
+ CLR_CZSV;
+ while (count > 0) {
+ c = result & S16;
+ result <<= 1;
+ count--;
+ }
+ while (count < 0) {
+ c = result & 0x0001;
+ result >>= 1;
+ count++;
+ }
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ if ((result ^ dest) & S16) SET_V;
+ return (UINT16)result;
+}
+
+/******************************************
+ shift dynamic arithmetic long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 SDAL(z8000_state *cpustate, UINT32 dest, INT8 count)
+{
+ INT32 result = (INT32) dest;
+ UINT32 c = 0;
+ CLR_CZSV;
+ while (count > 0) {
+ c = result & S32;
+ result <<= 1;
+ count--;
+ }
+ while (count < 0) {
+ c = result & 0x00000001;
+ result >>= 1;
+ count++;
+ }
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ if (c) SET_C;
+ if ((result ^ dest) & S32) SET_V;
+ return (UINT32) result;
+}
+
+/******************************************
+ shift dynamic logic byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 SDLB(z8000_state *cpustate, UINT8 dest, INT8 count)
+{
+ UINT8 result = dest;
+ UINT8 c = 0;
+ CLR_CZSV;
+ while (count > 0) {
+ c = result & S08;
+ result <<= 1;
+ count--;
+ }
+ while (count < 0) {
+ c = result & 0x01;
+ result >>= 1;
+ count++;
+ }
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ if ((result ^ dest) & S08) SET_V;
+ return result;
+}
+
+/******************************************
+ shift dynamic logic word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 SDLW(z8000_state *cpustate, UINT16 dest, INT8 count)
+{
+ UINT16 result = dest;
+ UINT16 c = 0;
+ CLR_CZSV;
+ while (count > 0) {
+ c = result & S16;
+ result <<= 1;
+ count--;
+ }
+ while (count < 0) {
+ c = result & 0x0001;
+ result >>= 1;
+ count++;
+ }
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ if ((result ^ dest) & S16) SET_V;
+ return result;
+}
+
+/******************************************
+ shift dynamic logic long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 SDLL(z8000_state *cpustate, UINT32 dest, INT8 count)
+{
+ UINT32 result = dest;
+ UINT32 c = 0;
+ CLR_CZSV;
+ while (count > 0) {
+ c = result & S32;
+ result <<= 1;
+ count--;
+ }
+ while (count < 0) {
+ c = result & 0x00000001;
+ result >>= 1;
+ count++;
+ }
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ if (c) SET_C;
+ if ((result ^ dest) & S32) SET_V;
+ return result;
+}
+
+/******************************************
+ shift left arithmetic byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 SLAB(z8000_state *cpustate, UINT8 dest, UINT8 count)
+{
+ UINT8 c = (count) ? (dest << (count - 1)) & S08 : 0;
+ UINT8 result = (UINT8)((INT8)dest << count);
+ CLR_CZSV;
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ if ((result ^ dest) & S08) SET_V;
+ return result;
+}
+
+/******************************************
+ shift left arithmetic word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 SLAW(z8000_state *cpustate, UINT16 dest, UINT8 count)
+{
+ UINT16 c = (count) ? (dest << (count - 1)) & S16 : 0;
+ UINT16 result = (UINT16)((INT16)dest << count);
+ CLR_CZSV;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ if ((result ^ dest) & S16) SET_V;
+ return result;
+}
+
+/******************************************
+ shift left arithmetic long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 SLAL(z8000_state *cpustate, UINT32 dest, UINT8 count)
+{
+ UINT32 c = (count) ? (dest << (count - 1)) & S32 : 0;
+ UINT32 result = (UINT32)((INT32)dest << count);
+ CLR_CZSV;
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ if (c) SET_C;
+ if ((result ^ dest) & S32) SET_V;
+ return result;
+}
+
+/******************************************
+ shift left logic byte
+ flags: CZS---
+ ******************************************/
+INLINE UINT8 SLLB(z8000_state *cpustate, UINT8 dest, UINT8 count)
+{
+ UINT8 c = (count) ? (dest << (count - 1)) & S08 : 0;
+ UINT8 result = dest << count;
+ CLR_CZS;
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift left logic word
+ flags: CZS---
+ ******************************************/
+INLINE UINT16 SLLW(z8000_state *cpustate, UINT16 dest, UINT8 count)
+{
+ UINT16 c = (count) ? (dest << (count - 1)) & S16 : 0;
+ UINT16 result = dest << count;
+ CLR_CZS;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift left logic long
+ flags: CZS---
+ ******************************************/
+INLINE UINT32 SLLL(z8000_state *cpustate, UINT32 dest, UINT8 count)
+{
+ UINT32 c = (count) ? (dest << (count - 1)) & S32 : 0;
+ UINT32 result = dest << count;
+ CLR_CZS;
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift right arithmetic byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 SRAB(z8000_state *cpustate, UINT8 dest, UINT8 count)
+{
+ UINT8 c = (count) ? ((INT8)dest >> (count - 1)) & 1 : 0;
+ UINT8 result = (UINT8)((INT8)dest >> count);
+ CLR_CZSV;
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift right arithmetic word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 SRAW(z8000_state *cpustate, UINT16 dest, UINT8 count)
+{
+ UINT8 c = (count) ? ((INT16)dest >> (count - 1)) & 1 : 0;
+ UINT16 result = (UINT16)((INT16)dest >> count);
+ CLR_CZSV;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift right arithmetic long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 SRAL(z8000_state *cpustate, UINT32 dest, UINT8 count)
+{
+ UINT8 c = (count) ? ((INT32)dest >> (count - 1)) & 1 : 0;
+ UINT32 result = (UINT32)((INT32)dest >> count);
+ CLR_CZSV;
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift right logic byte
+ flags: CZSV--
+ ******************************************/
+INLINE UINT8 SRLB(z8000_state *cpustate, UINT8 dest, UINT8 count)
+{
+ UINT8 c = (count) ? (dest >> (count - 1)) & 1 : 0;
+ UINT8 result = dest >> count;
+ CLR_CZS;
+ CHK_XXXB_ZS; /* set Z and S flags for result byte */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift right logic word
+ flags: CZSV--
+ ******************************************/
+INLINE UINT16 SRLW(z8000_state *cpustate, UINT16 dest, UINT8 count)
+{
+ UINT8 c = (count) ? (dest >> (count - 1)) & 1 : 0;
+ UINT16 result = dest >> count;
+ CLR_CZS;
+ CHK_XXXW_ZS; /* set Z and S flags for result word */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ shift right logic long
+ flags: CZSV--
+ ******************************************/
+INLINE UINT32 SRLL(z8000_state *cpustate, UINT32 dest, UINT8 count)
+{
+ UINT8 c = (count) ? (dest >> (count - 1)) & 1 : 0;
+ UINT32 result = dest >> count;
+ CLR_CZS;
+ CHK_XXXL_ZS; /* set Z and S flags for result long */
+ if (c) SET_C;
+ return result;
+}
+
+/******************************************
+ invalid
+ flags: ------
+ ******************************************/
+static void zinvalid(z8000_state *cpustate)
+{
+ logerror("Z8000 invalid opcode %04x: %04x\n", cpustate->pc, cpustate->op[0]);
+}
+
+/******************************************
+ addb rbd,imm8
+ flags: CZSVDH
+ ******************************************/
+static void Z00_0000_dddd_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM8(OP1);
+ cpustate->RB(dst) = ADDB(cpustate, cpustate->RB(dst), imm8);
+}
+
+/******************************************
+ addb rbd,@rs
+ flags: CZSVDH
+ ******************************************/
+static void Z00_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = ADDB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ add rd,imm16
+ flags: CZSV--
+ ******************************************/
+static void Z01_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = ADDW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ add rd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z01_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = ADDW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ subb rbd,imm8
+ flags: CZSVDH
+ ******************************************/
+static void Z02_0000_dddd_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM8(OP1);
+ cpustate->RB(dst) = SUBB(cpustate, cpustate->RB(dst), imm8);
+}
+
+/******************************************
+ subb rbd,@rs
+ flags: CZSVDH
+ ******************************************/
+static void Z02_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = SUBB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src))); /* EHC */
+}
+
+/******************************************
+ sub rd,imm16
+ flags: CZSV--
+ ******************************************/
+static void Z03_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = SUBW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ sub rd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z03_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = SUBW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ orb rbd,imm8
+ flags: CZSP--
+ ******************************************/
+static void Z04_0000_dddd_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM8(OP1);
+ cpustate->RB(dst) = ORB(cpustate, cpustate->RB(dst), imm8);
+}
+
+/******************************************
+ orb rbd,@rs
+ flags: CZSP--
+ ******************************************/
+static void Z04_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = ORB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ or rd,imm16
+ flags: CZS---
+ ******************************************/
+static void Z05_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = ORW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ or rd,@rs
+ flags: CZS---
+ ******************************************/
+static void Z05_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = ORW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ andb rbd,imm8
+ flags: -ZSP--
+ ******************************************/
+static void Z06_0000_dddd_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM8(OP1);
+ cpustate->RB(dst) = ANDB(cpustate, cpustate->RB(dst), imm8);
+}
+
+/******************************************
+ andb rbd,@rs
+ flags: -ZSP--
+ ******************************************/
+static void Z06_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = ANDB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ and rd,imm16
+ flags: -ZS---
+ ******************************************/
+static void Z07_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = ANDW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ and rd,@rs
+ flags: -ZS---
+ ******************************************/
+static void Z07_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = ANDW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ xorb rbd,imm8
+ flags: -ZSP--
+ ******************************************/
+static void Z08_0000_dddd_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM8(OP1);
+ cpustate->RB(dst) = XORB(cpustate, cpustate->RB(dst), imm8);
+}
+
+/******************************************
+ xorb rbd,@rs
+ flags: -ZSP--
+ ******************************************/
+static void Z08_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = XORB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ xor rd,imm16
+ flags: -ZS---
+ ******************************************/
+static void Z09_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = XORW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ xor rd,@rs
+ flags: -ZS---
+ ******************************************/
+static void Z09_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = XORW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ cpb rbd,imm8
+ flags: CZSV--
+ ******************************************/
+static void Z0A_0000_dddd_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM8(OP1);
+ CPB(cpustate, cpustate->RB(dst), imm8);
+}
+
+/******************************************
+ cpb rbd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z0A_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ CPB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ cp rd,imm16
+ flags: CZSV--
+ ******************************************/
+static void Z0B_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ CPW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ cp rd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z0B_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ CPW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ comb @rd
+ flags: -ZSP--
+ ******************************************/
+static void Z0C_ddN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ WRMEM_B(cpustate, cpustate->RW(dst), COMB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst))));
+}
+
+/******************************************
+ cpb @rd,imm8
+ flags: CZSV--
+ ******************************************/
+static void Z0C_ddN0_0001_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM8(OP1);
+ CPB(cpustate, cpustate->RB(dst), imm8);
+}
+
+/******************************************
+ negb @rd
+ flags: CZSV--
+ ******************************************/
+static void Z0C_ddN0_0010(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ WRMEM_B(cpustate, cpustate->RW(dst), NEGB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst))));
+}
+
+/******************************************
+ testb @rd
+ flags: -ZSP--
+ ******************************************/
+static void Z0C_ddN0_0100(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ TESTB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst)));
+}
+
+/******************************************
+ ldb @rd,imm8
+ flags: ------
+ ******************************************/
+static void Z0C_ddN0_0101_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM8(OP1);
+ WRMEM_B(cpustate, cpustate->RW(dst), imm8);
+}
+
+/******************************************
+ tsetb @rd
+ flags: --S---
+ ******************************************/
+static void Z0C_ddN0_0110(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ if (RDMEM_B(cpustate, cpustate->RW(dst)) & S08) SET_S; else CLR_S;
+ WRMEM_B(cpustate, cpustate->RW(dst), 0xff);
+}
+
+/******************************************
+ clrb @rd
+ flags: ------
+ ******************************************/
+static void Z0C_ddN0_1000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ WRMEM_B(cpustate, cpustate->RW(dst), 0);
+}
+
+/******************************************
+ com @rd
+ flags: -ZS---
+ ******************************************/
+static void Z0D_ddN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, cpustate->RW(dst), COMW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst))));
+}
+
+/******************************************
+ cp @rd,imm16
+ flags: CZSV--
+ ******************************************/
+static void Z0D_ddN0_0001_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ CPW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), imm16);
+}
+
+/******************************************
+ neg @rd
+ flags: CZSV--
+ ******************************************/
+static void Z0D_ddN0_0010(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, cpustate->RW(dst), NEGW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst))));
+}
+
+/******************************************
+ test @rd
+ flags: -ZS---
+ ******************************************/
+static void Z0D_ddN0_0100(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ TESTW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)));
+}
+
+/******************************************
+ ld @rd,imm16
+ flags: ------
+ ******************************************/
+static void Z0D_ddN0_0101_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ WRMEM_W(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ tset @rd
+ flags: --S---
+ ******************************************/
+static void Z0D_ddN0_0110(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ if (RDMEM_W(cpustate, cpustate->RW(dst)) & S16) SET_S; else CLR_S;
+ WRMEM_W(cpustate, cpustate->RW(dst), 0xffff);
+}
+
+/******************************************
+ clr @rd
+ flags: ------
+ ******************************************/
+static void Z0D_ddN0_1000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), 0);
+}
+
+/******************************************
+ push @rd,imm16
+ flags: ------
+ ******************************************/
+static void Z0D_ddN0_1001_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ PUSHW(cpustate, dst, imm16);
+}
+
+/******************************************
+ ext0e imm8
+ flags: ------
+ ******************************************/
+static void Z0E_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: ext0e $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ ext0f imm8
+ flags: ------
+ ******************************************/
+static void Z0F_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: ext0f $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ cpl rrd,imm32
+ flags: CZSV--
+ ******************************************/
+static void Z10_0000_dddd_imm32(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM32;
+ CPL(cpustate, cpustate->RL(dst), imm32);
+}
+
+/******************************************
+ cpl rrd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z10_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ CPL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ pushl @rd,@rs
+ flags: ------
+ ******************************************/
+static void Z11_ddN0_ssN0(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ PUSHL(cpustate, dst, RDMEM_L(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ subl rrd,imm32
+ flags: CZSV--
+ ******************************************/
+static void Z12_0000_dddd_imm32(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM32;
+ cpustate->RL(dst) = SUBL(cpustate, cpustate->RL(dst), imm32);
+}
+
+/******************************************
+ subl rrd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z12_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = SUBL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ push @rd,@rs
+ flags: ------
+ ******************************************/
+static void Z13_ddN0_ssN0(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ PUSHW(cpustate, dst, RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ ldl rrd,imm32
+ flags: ------
+ ******************************************/
+static void Z14_0000_dddd_imm32(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM32;
+ cpustate->RL(dst) = imm32;
+}
+
+/******************************************
+ ldl rrd,@rs
+ flags: ------
+ ******************************************/
+static void Z14_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = RDMEM_L(cpustate, cpustate->RW(src));
+}
+
+/******************************************
+ popl @rd,@rs
+ flags: ------
+ ******************************************/
+static void Z15_ssN0_ddN0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = POPL(cpustate, src);
+}
+
+/******************************************
+ addl rrd,imm32
+ flags: CZSV--
+ ******************************************/
+static void Z16_0000_dddd_imm32(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM32;
+ cpustate->RL(dst) = ADDL(cpustate, cpustate->RL(dst), imm32);
+}
+
+/******************************************
+ addl rrd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z16_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = ADDL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ pop @rd,@rs
+ flags: ------
+ ******************************************/
+static void Z17_ssN0_ddN0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = POPW(cpustate, src);
+}
+
+/******************************************
+ multl rqd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z18_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RQ(dst) = MULTL(cpustate, cpustate->RQ(dst), cpustate->RL(src));
+}
+
+/******************************************
+ mult rrd,imm16
+ flags: CZSV--
+ ******************************************/
+static void Z19_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RL(dst) = MULTW(cpustate, cpustate->RL(dst), imm16);
+}
+
+/******************************************
+ mult rrd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z19_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = MULTW(cpustate, cpustate->RL(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ divl rqd,imm32
+ flags: CZSV--
+ ******************************************/
+static void Z1A_0000_dddd_imm32(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM32;
+ cpustate->RQ(dst) = DIVL(cpustate, cpustate->RQ(dst), imm32);
+}
+
+/******************************************
+ divl rqd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z1A_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RQ(dst) = DIVL(cpustate, cpustate->RQ(dst), RDMEM_L(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ div rrd,imm16
+ flags: CZSV--
+ ******************************************/
+static void Z1B_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RL(dst) = DIVW(cpustate, cpustate->RL(dst), imm16);
+}
+
+/******************************************
+ div rrd,@rs
+ flags: CZSV--
+ ******************************************/
+static void Z1B_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = DIVW(cpustate, cpustate->RL(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ testl @rd
+ flags: -ZS---
+ ******************************************/
+static void Z1C_ddN0_1000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ TESTL(cpustate, RDMEM_L(cpustate, cpustate->RW(dst)));
+}
+
+/******************************************
+ ldm @rd,rs,n
+ flags: ------
+ ******************************************/
+static void Z1C_ddN0_1001_0000_ssss_0000_nmin1(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_CNT(OP1,NIB3);
+ GET_SRC(OP1,NIB1);
+ UINT16 idx = cpustate->RW(dst);
+ while (cnt-- >= 0) {
+ WRMEM_W(cpustate, idx, cpustate->RW(src));
+ idx = (idx + 2) & 0xffff;
+ src = (src+1) & 15;
+ }
+}
+
+/******************************************
+ ldm rd,@rs,n
+ flags: ------
+ ******************************************/
+static void Z1C_ssN0_0001_0000_dddd_0000_nmin1(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB3);
+ GET_DST(OP1,NIB1);
+ UINT16 idx = cpustate->RW(src);
+ while (cnt-- >= 0) {
+ cpustate->RW(dst) = RDMEM_W(cpustate, idx);
+ idx = (idx + 2) & 0xffff;
+ dst = (dst+1) & 15;
+ }
+}
+
+/******************************************
+ ldl @rd,rrs
+ flags: ------
+ ******************************************/
+static void Z1D_ddN0_ssss(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ WRMEM_L(cpustate, cpustate->RW(dst), cpustate->RL(src));
+}
+
+/******************************************
+ jp cc,rd
+ flags: ------
+ ******************************************/
+static void Z1E_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_CCC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ switch (cc) {
+ case 0: if (CC0) cpustate->pc = cpustate->RW(dst); break;
+ case 1: if (CC1) cpustate->pc = cpustate->RW(dst); break;
+ case 2: if (CC2) cpustate->pc = cpustate->RW(dst); break;
+ case 3: if (CC3) cpustate->pc = cpustate->RW(dst); break;
+ case 4: if (CC4) cpustate->pc = cpustate->RW(dst); break;
+ case 5: if (CC5) cpustate->pc = cpustate->RW(dst); break;
+ case 6: if (CC6) cpustate->pc = cpustate->RW(dst); break;
+ case 7: if (CC7) cpustate->pc = cpustate->RW(dst); break;
+ case 8: if (CC8) cpustate->pc = cpustate->RW(dst); break;
+ case 9: if (CC9) cpustate->pc = cpustate->RW(dst); break;
+ case 10: if (CCA) cpustate->pc = cpustate->RW(dst); break;
+ case 11: if (CCB) cpustate->pc = cpustate->RW(dst); break;
+ case 12: if (CCC) cpustate->pc = cpustate->RW(dst); break;
+ case 13: if (CCD) cpustate->pc = cpustate->RW(dst); break;
+ case 14: if (CCE) cpustate->pc = cpustate->RW(dst); break;
+ case 15: if (CCF) cpustate->pc = cpustate->RW(dst); break;
+ }
+}
+
+/******************************************
+ call @rd
+ flags: ------
+ ******************************************/
+static void Z1F_ddN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ PUSHW(cpustate, SP, cpustate->pc);
+ cpustate->pc = cpustate->RW(dst);
+}
+
+/******************************************
+ ldb rbd,@rs
+ flags: ------
+ ******************************************/
+static void Z20_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = RDMEM_B(cpustate, cpustate->RW(src));
+}
+
+static void Z20_ssN0_dddd_seg(z8000_state *cpustate)
+{
+ UINT32 addr;
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ addr = (cpustate->RW(src) & 0x0007) << 16;
+ addr|= cpustate->RW(src+1) & 0xffff;
+ cpustate->RB(dst) = RDMEM_B(cpustate, addr);
+ //cycles?
+}
+
+/******************************************
+ ld rd,imm16
+ flags: ------
+ ******************************************/
+static void Z21_0000_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = imm16;
+}
+
+/******************************************
+ ld rd,@rs
+ flags: ------
+ ******************************************/
+static void Z21_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = RDMEM_W(cpustate, cpustate->RW(src));
+}
+
+/******************************************
+ resb rbd,rs
+ flags: ------
+ ******************************************/
+static void Z22_0000_ssss_0000_dddd_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP1,NIB1);
+ cpustate->RB(dst) = cpustate->RB(dst) & ~(1 << (cpustate->RW(src) & 7));
+}
+
+/******************************************
+ resb @rd,imm4
+ flags: ------
+ ******************************************/
+static void Z22_ddN0_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ WRMEM_B(cpustate, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(dst)) & ~bit);
+}
+
+/******************************************
+ result rd,rs
+ flags: ------
+ ******************************************/
+static void Z23_0000_ssss_0000_dddd_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP1,NIB1);
+ cpustate->RW(dst) = cpustate->RW(dst) & ~(1 << (cpustate->RW(src) & 15));
+}
+
+/******************************************
+ res @rd,imm4
+ flags: ------
+ ******************************************/
+static void Z23_ddN0_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(dst)) & ~bit);
+}
+
+/******************************************
+ setb rbd,rs
+ flags: ------
+ ******************************************/
+static void Z24_0000_ssss_0000_dddd_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP1,NIB1);
+ cpustate->RB(dst) = cpustate->RB(dst) | (1 << (cpustate->RW(src) & 7));
+}
+
+/******************************************
+ setb @rd,imm4
+ flags: ------
+ ******************************************/
+static void Z24_ddN0_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ WRMEM_B(cpustate, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(dst)) | bit);
+}
+
+/******************************************
+ set rd,rs
+ flags: ------
+ ******************************************/
+static void Z25_0000_ssss_0000_dddd_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP1,NIB1);
+ cpustate->RW(dst) = cpustate->RW(dst) | (1 << (cpustate->RW(src) & 15));
+}
+
+/******************************************
+ set @rd,imm4
+ flags: ------
+ ******************************************/
+static void Z25_ddN0_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(dst)) | bit);
+}
+
+/******************************************
+ bitb rbd,rs
+ flags: -Z----
+ ******************************************/
+static void Z26_0000_ssss_0000_dddd_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP1,NIB1);
+ if (cpustate->RB(dst) & (1 << (cpustate->RW(src) & 7))) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ bitb @rd,imm4
+ flags: -Z----
+ ******************************************/
+static void Z26_ddN0_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ if (RDMEM_B(cpustate, cpustate->RW(dst)) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ bit rd,rs
+ flags: -Z----
+ ******************************************/
+static void Z27_0000_ssss_0000_dddd_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP1,NIB1);
+ if (cpustate->RW(dst) & (1 << (cpustate->RW(src) & 15))) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ bit @rd,imm4
+ flags: -Z----
+ ******************************************/
+static void Z27_ddN0_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ if (RDMEM_W(cpustate, cpustate->RW(dst)) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ incb @rd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z28_ddN0_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ WRMEM_B(cpustate, cpustate->RW(dst), INCB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst)), i4p1));
+}
+
+/******************************************
+ inc @rd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z29_ddN0_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, cpustate->RW(dst), INCW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), i4p1));
+}
+
+/******************************************
+ decb @rd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z2A_ddN0_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ WRMEM_B(cpustate, cpustate->RW(dst), DECB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst)), i4p1));
+}
+
+/******************************************
+ dec @rd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z2B_ddN0_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, cpustate->RW(dst), DECW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), i4p1));
+}
+
+/******************************************
+ exb rbd,@rs
+ flags: ------
+ ******************************************/
+static void Z2C_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ UINT8 tmp = RDMEM_B(cpustate, cpustate->RW(src));
+ WRMEM_B(cpustate, cpustate->RW(src), cpustate->RB(dst));
+ cpustate->RB(dst) = tmp;
+}
+
+/******************************************
+ ex rd,@rs
+ flags: ------
+ ******************************************/
+static void Z2D_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ UINT16 tmp = RDMEM_W(cpustate, cpustate->RW(src));
+ WRMEM_W(cpustate, cpustate->RW(src), cpustate->RW(dst));
+ cpustate->RW(dst) = tmp;
+}
+
+/******************************************
+ ldb @rd,rbs
+ flags: ------
+ ******************************************/
+static void Z2E_ddN0_ssss(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ WRMEM_B(cpustate, cpustate->RW(dst), cpustate->RB(src));
+}
+
+/******************************************
+ ld @rd,rs
+ flags: ------
+ ******************************************/
+static void Z2F_ddN0_ssss(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ WRMEM_W(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ ldrb rbd,dsp16
+ flags: ------
+ ******************************************/
+static void Z30_0000_dddd_dsp16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_DSP16;
+ cpustate->RB(dst) = RDMEM_B(cpustate, dsp16);
+}
+
+/******************************************
+ ldb rbd,rs(imm16)
+ flags: ------
+ ******************************************/
+static void Z30_ssN0_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ imm16 += cpustate->RW(src);
+ cpustate->RB(dst) = RDMEM_B(cpustate, imm16);
+}
+
+/******************************************
+ ldr rd,dsp16
+ flags: ------
+ ******************************************/
+static void Z31_0000_dddd_dsp16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_DSP16;
+ cpustate->RW(dst) = RDMEM_W(cpustate, dsp16);
+}
+
+/******************************************
+ ld rd,rs(imm16)
+ flags: ------
+ ******************************************/
+static void Z31_ssN0_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ imm16 += cpustate->RW(src);
+ cpustate->RW(dst) = RDMEM_W(cpustate, imm16);
+}
+
+/******************************************
+ ldrb dsp16,rbs
+ flags: ------
+ ******************************************/
+static void Z32_0000_ssss_dsp16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DSP16;
+ WRMEM_B(cpustate, dsp16, cpustate->RB(src));
+}
+
+/******************************************
+ ldb rd(imm16),rbs
+ flags: ------
+ ******************************************/
+static void Z32_ddN0_ssss_imm16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ imm16 += cpustate->RW(dst);
+ WRMEM_B(cpustate, imm16, cpustate->RB(src));
+}
+
+/******************************************
+ ldr dsp16,rs
+ flags: ------
+ ******************************************/
+static void Z33_0000_ssss_dsp16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DSP16;
+ WRMEM_W(cpustate, dsp16, cpustate->RW(src));
+}
+
+/******************************************
+ ld rd(imm16),rs
+ flags: ------
+ ******************************************/
+static void Z33_ddN0_ssss_imm16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ imm16 += cpustate->RW(dst);
+ WRMEM_W(cpustate, imm16, cpustate->RW(src));
+}
+
+/******************************************
+ ldar prd,dsp16
+ flags: ------
+ ******************************************/
+static void Z34_0000_dddd_dsp16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_DSP16;
+ cpustate->RW(dst) = dsp16;
+}
+
+/******************************************
+ lda prd,rs(imm16)
+ flags: ------
+ ******************************************/
+static void Z34_ssN0_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ imm16 += cpustate->RW(src);
+ cpustate->RW(dst) = imm16;
+}
+
+/******************************************
+ ldrl rrd,dsp16
+ flags: ------
+ ******************************************/
+static void Z35_0000_dddd_dsp16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_DSP16;
+ cpustate->RL(dst) = RDMEM_L(cpustate, dsp16);
+}
+
+/******************************************
+ ldl rrd,rs(imm16)
+ flags: ------
+ ******************************************/
+static void Z35_ssN0_dddd_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ imm16 += cpustate->RW(src);
+ cpustate->RL(dst) = RDMEM_L(cpustate, imm16);
+}
+
+/******************************************
+ bpt
+ flags: ------
+ ******************************************/
+static void Z36_0000_0000(z8000_state *cpustate)
+{
+ /* execute break point trap cpustate->irq_req */
+ cpustate->irq_req = Z8000_TRAP;
+}
+
+/******************************************
+ rsvd36
+ flags: ------
+ ******************************************/
+static void Z36_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvd36 $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ ldrl dsp16,rrs
+ flags: ------
+ ******************************************/
+static void Z37_0000_ssss_dsp16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DSP16;
+ WRMEM_L(cpustate, dsp16, cpustate->RL(src));
+}
+
+/******************************************
+ ldl rd(imm16),rrs
+ flags: ------
+ ******************************************/
+static void Z37_ddN0_ssss_imm16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ imm16 += cpustate->RW(dst);
+ WRMEM_L(cpustate, imm16, cpustate->RL(src));
+}
+
+/******************************************
+ rsvd38
+ flags: ------
+ ******************************************/
+static void Z38_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvd38 $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ ldps @rs
+ flags: CZSVDH
+ ******************************************/
+static void Z39_ssN0_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ UINT16 fcw;
+ fcw = RDMEM_W(cpustate, cpustate->RW(src));
+ cpustate->pc = RDMEM_W(cpustate, (UINT16)(cpustate->RW(src) + 2));
+ CHANGE_FCW(cpustate, fcw); /* check for user/system mode change */
+}
+
+/******************************************
+ inib(r) @rd,@rs,ra
+ flags: ---V--
+ ******************************************/
+static void Z3A_ssss_0000_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_B(cpustate, cpustate->RW(dst), RDPORT_B(cpustate, 0, cpustate->RW(src)));
+ cpustate->RW(dst)++;
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ sinib @rd,@rs,ra
+ sinibr @rd,@rs,ra
+ flags: ------
+ ******************************************/
+static void Z3A_ssss_0001_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_B(cpustate, cpustate->RW(dst), RDPORT_B(cpustate, 1, cpustate->RW(src)));
+ cpustate->RW(dst)++;
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ outib @rd,@rs,ra
+ outibr @rd,@rs,ra
+ flags: ---V--
+ ******************************************/
+static void Z3A_ssss_0010_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_B(cpustate, 0, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst)++;
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ soutib @rd,@rs,ra
+ soutibr @rd,@rs,ra
+ flags: ------
+ ******************************************/
+static void Z3A_ssss_0011_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_B(cpustate, 1, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst)++;
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ inb rbd,imm16
+ flags: ------
+ ******************************************/
+static void Z3A_dddd_0100_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ cpustate->RB(dst) = RDPORT_B(cpustate, 0, imm16);
+}
+
+/******************************************
+ sinb rbd,imm16
+ flags: ------
+ ******************************************/
+static void Z3A_dddd_0101_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ cpustate->RB(dst) = RDPORT_B(cpustate, 1, imm16);
+}
+
+/******************************************
+ outb imm16,rbs
+ flags: ---V--
+ ******************************************/
+static void Z3A_ssss_0110_imm16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ WRPORT_B(cpustate, 0, imm16, cpustate->RB(src));
+}
+
+/******************************************
+ soutb imm16,rbs
+ flags: ------
+ ******************************************/
+static void Z3A_ssss_0111_imm16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ WRPORT_B(cpustate, 1, imm16, cpustate->RB(src));
+}
+
+/******************************************
+ indb @rd,@rs,rba
+ indbr @rd,@rs,rba
+ flags: ---V--
+ ******************************************/
+static void Z3A_ssss_1000_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_B(cpustate, cpustate->RW(dst), RDPORT_B(cpustate, 0, cpustate->RW(src)));
+ cpustate->RW(dst)--;
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ sindb @rd,@rs,rba
+ sindbr @rd,@rs,rba
+ flags: ------
+ ******************************************/
+static void Z3A_ssss_1001_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_B(cpustate, cpustate->RW(dst), RDPORT_B(cpustate, 1, cpustate->RW(src)));
+ cpustate->RW(dst)--;
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ outdb @rd,@rs,rba
+ outdbr @rd,@rs,rba
+ flags: ---V--
+ ******************************************/
+static void Z3A_ssss_1010_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_B(cpustate, 0, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst)--;
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ soutdb @rd,@rs,rba
+ soutdbr @rd,@rs,rba
+ flags: ------
+ ******************************************/
+static void Z3A_ssss_1011_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_B(cpustate, 1, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst)--;
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ ini @rd,@rs,ra
+ inir @rd,@rs,ra
+ flags: ---V--
+ ******************************************/
+static void Z3B_ssss_0000_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDPORT_W(cpustate, 0, cpustate->RW(src)));
+ cpustate->RW(dst) += 2;
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ sini @rd,@rs,ra
+ sinir @rd,@rs,ra
+ flags: ------
+ ******************************************/
+static void Z3B_ssss_0001_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDPORT_W(cpustate, 1, cpustate->RW(src)));
+ cpustate->RW(dst) += 2;
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ outi @rd,@rs,ra
+ outir @rd,@rs,ra
+ flags: ---V--
+ ******************************************/
+static void Z3B_ssss_0010_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_W(cpustate, 0, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst) += 2;
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ souti @rd,@rs,ra
+ soutir @rd,@rs,ra
+ flags: ------
+ ******************************************/
+static void Z3B_ssss_0011_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_W(cpustate, 1, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst) += 2;
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ in rd,imm16
+ flags: ------
+ ******************************************/
+static void Z3B_dddd_0100_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = RDPORT_W(cpustate, 0, imm16);
+}
+
+/******************************************
+ sin rd,imm16
+ flags: ------
+ ******************************************/
+static void Z3B_dddd_0101_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ cpustate->RW(dst) = RDPORT_W(cpustate, 1, imm16);
+}
+
+/******************************************
+ out imm16,rs
+ flags: ---V--
+ ******************************************/
+static void Z3B_ssss_0110_imm16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ WRPORT_W(cpustate, 0, imm16, cpustate->RW(src));
+}
+
+/******************************************
+ sout imm16,rbs
+ flags: ------
+ ******************************************/
+static void Z3B_ssss_0111_imm16(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_IMM16(OP1);
+ WRPORT_W(cpustate, 1, imm16, cpustate->RW(src));
+}
+
+/******************************************
+ ind @rd,@rs,ra
+ indr @rd,@rs,ra
+ flags: ---V--
+ ******************************************/
+static void Z3B_ssss_1000_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDPORT_W(cpustate, 0, cpustate->RW(src)));
+ cpustate->RW(dst) -= 2;
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ sind @rd,@rs,ra
+ sindr @rd,@rs,ra
+ flags: ------
+ ******************************************/
+static void Z3B_ssss_1001_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDPORT_W(cpustate, 1, cpustate->RW(src)));
+ cpustate->RW(dst) -= 2;
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ outd @rd,@rs,ra
+ outdr @rd,@rs,ra
+ flags: ---V--
+ ******************************************/
+static void Z3B_ssss_1010_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_W(cpustate, 0, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst) -= 2;
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ soutd @rd,@rs,ra
+ soutdr @rd,@rs,ra
+ flags: ------
+ ******************************************/
+static void Z3B_ssss_1011_0000_aaaa_dddd_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRPORT_W(cpustate, 1, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst) -= 2;
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ inb rbd,@rs
+ flags: ------
+ ******************************************/
+static void Z3C_ssss_dddd(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_DST(OP0,NIB3);
+ cpustate->RB(dst) = RDPORT_B(cpustate, 0, RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ in rd,@rs
+ flags: ------
+ ******************************************/
+static void Z3D_ssss_dddd(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_DST(OP0,NIB3);
+ cpustate->RW(dst) = RDPORT_W(cpustate, 0, RDMEM_W(cpustate, cpustate->RW(src)));
+}
+
+/******************************************
+ outb @rd,rbs
+ flags: ---V--
+ ******************************************/
+static void Z3E_dddd_ssss(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP0,NIB3);
+ WRPORT_B(cpustate, 0, RDMEM_W(cpustate, cpustate->RW(dst)), cpustate->RB(src));
+}
+
+/* FIXME: aforementioned opcode looks bugged. */
+static void Z3E_dddd_ssss_seg(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP0,NIB3);
+ WRPORT_B(cpustate, 0, cpustate->RW(dst), cpustate->RB(src));
+}
+
+/******************************************
+ out @rd,rs
+ flags: ---V--
+ ******************************************/
+static void Z3F_dddd_ssss(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP0,NIB3);
+ WRPORT_W(cpustate, 0, RDMEM_W(cpustate, cpustate->RW(dst)), cpustate->RW(src));
+}
+
+/******************************************
+ addb rbd,addr
+ flags: CZSVDH
+ ******************************************/
+static void Z40_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RB(dst) = ADDB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ addb rbd,addr(rs)
+ flags: CZSVDH
+ ******************************************/
+static void Z40_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RB(dst) = ADDB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ add rd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z41_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RW(dst) = ADDW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr)); /* EHC */
+}
+
+/******************************************
+ add rd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z41_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RW(dst) = ADDW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr)); /* ASG */
+}
+
+/******************************************
+ subb rbd,addr
+ flags: CZSVDH
+ ******************************************/
+static void Z42_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RB(dst) = SUBB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr)); /* EHC */
+}
+
+/******************************************
+ subb rbd,addr(rs)
+ flags: CZSVDH
+ ******************************************/
+static void Z42_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RB(dst) = SUBB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ sub rd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z43_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RW(dst) = SUBW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ sub rd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z43_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RW(dst) = SUBW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ orb rbd,addr
+ flags: CZSP--
+ ******************************************/
+static void Z44_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RB(dst) = ORB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ orb rbd,addr(rs)
+ flags: CZSP--
+ ******************************************/
+static void Z44_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RB(dst) = ORB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ or rd,addr
+ flags: CZS---
+ ******************************************/
+static void Z45_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RW(dst) = ORW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ or rd,addr(rs)
+ flags: CZS---
+ ******************************************/
+static void Z45_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RW(dst) = ORW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ andb rbd,addr
+ flags: -ZSP--
+ ******************************************/
+static void Z46_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RB(dst) = ANDB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ andb rbd,addr(rs)
+ flags: -ZSP--
+ ******************************************/
+static void Z46_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RB(dst) = ANDB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ and rd,addr
+ flags: -ZS---
+ ******************************************/
+static void Z47_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RW(dst) = ANDW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ and rd,addr(rs)
+ flags: -ZS---
+ ******************************************/
+static void Z47_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RW(dst) = ANDW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ xorb rbd,addr
+ flags: -ZSP--
+ ******************************************/
+static void Z48_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RB(dst) = XORB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ xorb rbd,addr(rs)
+ flags: -ZSP--
+ ******************************************/
+static void Z48_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RB(dst) = XORB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ xor rd,addr
+ flags: -ZS---
+ ******************************************/
+static void Z49_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RW(dst) = XORW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ xor rd,addr(rs)
+ flags: -ZS---
+ ******************************************/
+static void Z49_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RW(dst) = XORW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ cpb rbd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z4A_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ CPB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ cpb rbd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z4A_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ CPB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ cp rd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z4B_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ CPW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ cp rd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z4B_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ CPW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ comb addr
+ flags: -ZSP--
+ ******************************************/
+static void Z4C_0000_0000_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, COMB(cpustate, RDMEM_W(cpustate, addr)));
+}
+
+/******************************************
+ cpb addr,imm8
+ flags: CZSV--
+ ******************************************/
+static void Z4C_0000_0001_addr_imm8(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ GET_IMM8(OP2);
+ CPB(cpustate, RDMEM_B(cpustate, addr), imm8);
+}
+
+/******************************************
+ negb addr
+ flags: CZSV--
+ ******************************************/
+static void Z4C_0000_0010_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, NEGB(cpustate, RDMEM_B(cpustate, addr)));
+}
+
+/******************************************
+ testb addr
+ flags: -ZSP--
+ ******************************************/
+static void Z4C_0000_0100_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ TESTB(cpustate, RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ ldb addr,imm8
+ flags: ------
+ ******************************************/
+static void Z4C_0000_0101_addr_imm8(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ GET_IMM8(OP2);
+ WRMEM_B(cpustate, addr, imm8);
+}
+
+/******************************************
+ tsetb addr
+ flags: --S---
+ ******************************************/
+static void Z4C_0000_0110_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ if (RDMEM_B(cpustate, addr) & S08) SET_S; else CLR_S;
+ WRMEM_B(cpustate, addr, 0xff);
+}
+
+/******************************************
+ clrb addr
+ flags: ------
+ ******************************************/
+static void Z4C_0000_1000_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, 0);
+}
+
+static void Z4C_0000_1000_addr_seg(z8000_state *cpustate)
+{
+ static UINT32 offset;
+ UINT16 operand1 = fetch(cpustate);
+
+ if(operand1 & 0x8000)
+ {
+ UINT16 operand2 = fetch(cpustate);
+
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand2 & 0xffff);
+ WRMEM_B(cpustate, offset, 0);
+ cycles(cpustate, 14);
+ }
+ else
+ {
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand1 & 0x00ff);
+ WRMEM_B(cpustate, offset, 0);
+ cycles(cpustate, 12);
+ }
+}
+
+/******************************************
+ comb addr(rd)
+ flags: -ZSP--
+ ******************************************/
+static void Z4C_ddN0_0000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, COMB(cpustate, RDMEM_B(cpustate, addr)));
+}
+
+/******************************************
+ cpb addr(rd),imm8
+ flags: CZSV--
+ ******************************************/
+static void Z4C_ddN0_0001_addr_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ GET_IMM8(OP2);
+ addr += cpustate->RW(dst);
+ CPB(cpustate, RDMEM_B(cpustate, addr), imm8);
+}
+
+/******************************************
+ negb addr(rd)
+ flags: CZSV--
+ ******************************************/
+static void Z4C_ddN0_0010_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, NEGB(cpustate, RDMEM_B(cpustate, addr)));
+}
+
+/******************************************
+ testb addr(rd)
+ flags: -ZSP--
+ ******************************************/
+static void Z4C_ddN0_0100_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ TESTB(cpustate, RDMEM_B(cpustate, addr));
+}
+
+/******************************************
+ ldb addr(rd),imm8
+ flags: ------
+ ******************************************/
+static void Z4C_ddN0_0101_addr_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ GET_IMM8(OP2);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, imm8);
+}
+
+/******************************************
+ tsetb addr(rd)
+ flags: --S---
+ ******************************************/
+static void Z4C_ddN0_0110_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ if (RDMEM_B(cpustate, addr) & S08) SET_S; else CLR_S;
+ WRMEM_B(cpustate, addr, 0xff);
+}
+
+/******************************************
+ clrb addr(rd)
+ flags: ------
+ ******************************************/
+static void Z4C_ddN0_1000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, 0);
+}
+
+/******************************************
+ com addr
+ flags: -ZS---
+ ******************************************/
+static void Z4D_0000_0000_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, COMW(cpustate, RDMEM_W(cpustate, addr)));
+}
+
+/******************************************
+ cp addr,imm16
+ flags: CZSV--
+ ******************************************/
+static void Z4D_0000_0001_addr_imm16(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ GET_IMM16(OP2);
+ CPW(cpustate, RDMEM_W(cpustate, addr), imm16);
+}
+
+/******************************************
+ neg addr
+ flags: CZSV--
+ ******************************************/
+static void Z4D_0000_0010_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, NEGW(cpustate, RDMEM_W(cpustate, addr)));
+}
+
+/******************************************
+ test addr
+ flags: ------
+ ******************************************/
+static void Z4D_0000_0100_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ TESTW(cpustate, RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ ld addr,imm16
+ flags: ------
+ ******************************************/
+static void Z4D_0000_0101_addr_imm16(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ GET_IMM16(OP2);
+ WRMEM_W(cpustate, addr, imm16);
+}
+
+static void Z4D_0000_0101_addr_imm16_seg(z8000_state *cpustate)
+{
+ static UINT32 offset;
+ UINT16 operand1 = fetch(cpustate);
+
+ if(operand1 & 0x8000)
+ {
+ UINT16 operand2 = fetch(cpustate);
+ UINT16 imm16 = fetch(cpustate);
+
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand2 & 0xffff);
+ WRMEM_W(cpustate, offset, imm16);
+ cycles(cpustate, 17);
+ }
+ else
+ {
+ UINT16 imm16 = fetch(cpustate);
+
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand1 & 0x00ff);
+ WRMEM_W(cpustate, offset, imm16);
+ cycles(cpustate, 15);
+ }
+}
+
+/******************************************
+ tset addr
+ flags: --S---
+ ******************************************/
+static void Z4D_0000_0110_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ if (RDMEM_W(cpustate, addr) & S16) SET_S; else CLR_S;
+ WRMEM_W(cpustate, addr, 0xffff);
+}
+
+/******************************************
+ clr addr
+ flags: ------
+ ******************************************/
+static void Z4D_0000_1000_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, 0);
+}
+
+static void Z4D_0000_1000_addr_seg(z8000_state *cpustate)
+{
+ static UINT32 offset;
+ UINT16 operand1 = fetch(cpustate);
+
+ if(operand1 & 0x8000)
+ {
+ UINT16 operand2 = fetch(cpustate);
+
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand2 & 0xffff);
+ WRMEM_W(cpustate, offset, 0);
+ cycles(cpustate, 15);
+ }
+ else
+ {
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand1 & 0x00ff);
+ WRMEM_W(cpustate, offset, 0);
+ cycles(cpustate, 12);
+ }
+}
+
+/******************************************
+ com addr(rd)
+ flags: -ZS---
+ ******************************************/
+static void Z4D_ddN0_0000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, COMW(cpustate, RDMEM_W(cpustate, addr)));
+}
+
+/******************************************
+ cp addr(rd),imm16
+ flags: CZSV--
+ ******************************************/
+static void Z4D_ddN0_0001_addr_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ GET_IMM16(OP2);
+ addr += cpustate->RW(dst);
+ CPW(cpustate, RDMEM_W(cpustate, addr), imm16);
+}
+
+/******************************************
+ neg addr(rd)
+ flags: CZSV--
+ ******************************************/
+static void Z4D_ddN0_0010_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, NEGW(cpustate, RDMEM_W(cpustate, addr)));
+}
+
+/******************************************
+ test addr(rd)
+ flags: ------
+ ******************************************/
+static void Z4D_ddN0_0100_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ TESTW(cpustate, RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ ld addr(rd),imm16
+ flags: ------
+ ******************************************/
+static void Z4D_ddN0_0101_addr_imm16(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ GET_IMM16(OP2);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, imm16);
+}
+
+/******************************************
+ tset addr(rd)
+ flags: --S---
+ ******************************************/
+static void Z4D_ddN0_0110_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ if (RDMEM_W(cpustate, addr) & S16) SET_S; else CLR_S;
+ WRMEM_W(cpustate, addr, 0xffff);
+}
+
+/******************************************
+ clr addr(rd)
+ flags: ------
+ ******************************************/
+static void Z4D_ddN0_1000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, 0);
+}
+
+/******************************************
+ ldb addr(rd),rbs
+ flags: ------
+ ******************************************/
+static void Z4E_ddN0_ssN0_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP0,NIB3);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, cpustate->RB(src));
+}
+
+/******************************************
+ cpl rrd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z50_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ CPL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ cpl rrd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z50_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ CPL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ pushl @rd,addr
+ flags: ------
+ ******************************************/
+static void Z51_ddN0_0000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ PUSHL(cpustate, dst, RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ pushl @rd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z51_ddN0_ssN0_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ PUSHL(cpustate, dst, RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ subl rrd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z52_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RL(dst) = SUBL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ subl rrd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z52_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RL(dst) = SUBL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ push @rd,addr
+ flags: ------
+ ******************************************/
+static void Z53_ddN0_0000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ PUSHW(cpustate, dst, RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ push @rd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z53_ddN0_ssN0_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP0,NIB3);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ PUSHW(cpustate, dst, RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ ldl rrd,addr
+ flags: ------
+ ******************************************/
+static void Z54_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RL(dst) = RDMEM_L(cpustate, addr);
+}
+
+/******************************************
+ ldl rrd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z54_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RL(dst) = RDMEM_L(cpustate, addr);
+}
+
+/******************************************
+ popl addr,@rs
+ flags: ------
+ ******************************************/
+static void Z55_ssN0_0000_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ WRMEM_L(cpustate, addr, POPL(cpustate, src));
+}
+
+/******************************************
+ popl addr(rd),@rs
+ flags: ------
+ ******************************************/
+static void Z55_ssN0_ddN0_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_L(cpustate, addr, POPL(cpustate, src));
+}
+
+/******************************************
+ addl rrd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z56_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RL(dst) = ADDL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ addl rrd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z56_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RL(dst) = ADDL(cpustate, cpustate->RL(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ pop addr,@rs
+ flags: ------
+ ******************************************/
+static void Z57_ssN0_0000_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, POPW(cpustate, src));
+}
+
+/******************************************
+ pop addr(rd),@rs
+ flags: ------
+ ******************************************/
+static void Z57_ssN0_ddN0_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, POPW(cpustate, src));
+}
+
+/******************************************
+ multl rqd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z58_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RQ(dst) = MULTL(cpustate, cpustate->RQ(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ multl rqd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z58_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RQ(dst) = MULTL(cpustate, cpustate->RQ(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ mult rrd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z59_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RL(dst) = MULTW(cpustate, cpustate->RL(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ mult rrd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z59_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RL(dst) = MULTW(cpustate, cpustate->RL(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ divl rqd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z5A_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RQ(dst) = DIVL(cpustate, cpustate->RQ(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ divl rqd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z5A_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RQ(dst) = DIVL(cpustate, cpustate->RQ(dst), RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ div rrd,addr
+ flags: CZSV--
+ ******************************************/
+static void Z5B_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RL(dst) = DIVW(cpustate, cpustate->RL(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ div rrd,addr(rs)
+ flags: CZSV--
+ ******************************************/
+static void Z5B_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RL(dst) = DIVW(cpustate, cpustate->RL(dst), RDMEM_W(cpustate, addr));
+}
+
+/******************************************
+ ldm rd,addr,n
+ flags: ------
+ ******************************************/
+static void Z5C_0000_0001_0000_dddd_0000_nmin1_addr(z8000_state *cpustate)
+{
+ GET_DST(OP1,NIB1);
+ GET_CNT(OP1,NIB3);
+ GET_ADDR(OP2);
+ while (cnt-- >= 0) {
+ cpustate->RW(dst) = RDMEM_W(cpustate, addr);
+ dst = (dst+1) & 15;
+ addr = (addr + 2) & 0xffff;
+ }
+}
+
+/******************************************
+ testl addr
+ flags: -ZS---
+ ******************************************/
+static void Z5C_0000_1000_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ TESTL(cpustate, RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ ldm addr,rs,n
+ flags: ------
+ ******************************************/
+static void Z5C_0000_1001_0000_ssss_0000_nmin1_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP1,NIB1);
+ GET_CNT(OP1,NIB3);
+ GET_ADDR(OP2);
+ while (cnt-- >= 0) {
+ WRMEM_W(cpustate, addr, cpustate->RW(src));
+ src = (src+1) & 15;
+ addr = (addr + 2) & 0xffff;
+ }
+}
+
+/******************************************
+ testl addr(rd)
+ flags: -ZS---
+ ******************************************/
+static void Z5C_ddN0_1000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ TESTL(cpustate, RDMEM_L(cpustate, addr));
+}
+
+/******************************************
+ ldm addr(rd),rs,n
+ flags: ------
+ ******************************************/
+static void Z5C_ddN0_1001_0000_ssN0_0000_nmin1_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB1);
+ GET_CNT(OP1,NIB3);
+ GET_ADDR(OP2);
+ addr += cpustate->RW(dst);
+ while (cnt-- >= 0) {
+ WRMEM_W(cpustate, addr, cpustate->RW(src));
+ src = (src+1) & 15;
+ addr = (addr + 2) & 0xffff;
+ }
+}
+
+/******************************************
+ ldm rd,addr(rs),n
+ flags: ------
+ ******************************************/
+static void Z5C_ssN0_0001_0000_dddd_0000_nmin1_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_DST(OP1,NIB1);
+ GET_CNT(OP1,NIB3);
+ GET_ADDR(OP2);
+ addr += cpustate->RW(src);
+ while (cnt-- >= 0) {
+ cpustate->RW(dst) = RDMEM_W(cpustate, addr);
+ dst = (dst+1) & 15;
+ addr = (addr + 2) & 0xffff;
+ }
+}
+
+/******************************************
+ ldl addr,rrs
+ flags: ------
+ ******************************************/
+static void Z5D_0000_ssss_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_ADDR(OP1);
+ WRMEM_L(cpustate, addr, cpustate->RL(src));
+}
+
+/******************************************
+ ldl addr(rd),rrs
+ flags: ------
+ ******************************************/
+static void Z5D_ddN0_ssss_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_L(cpustate, addr, cpustate->RL(src));
+}
+
+/******************************************
+ jp cc,addr
+ flags: ------
+ ******************************************/
+static void Z5E_0000_cccc_addr(z8000_state *cpustate)
+{
+ GET_CCC(OP0,NIB3);
+ GET_ADDR(OP1);
+ switch (cc) {
+ case 0: if (CC0) cpustate->pc = addr; break;
+ case 1: if (CC1) cpustate->pc = addr; break;
+ case 2: if (CC2) cpustate->pc = addr; break;
+ case 3: if (CC3) cpustate->pc = addr; break;
+ case 4: if (CC4) cpustate->pc = addr; break;
+ case 5: if (CC5) cpustate->pc = addr; break;
+ case 6: if (CC6) cpustate->pc = addr; break;
+ case 7: if (CC7) cpustate->pc = addr; break;
+ case 8: if (CC8) cpustate->pc = addr; break;
+ case 9: if (CC9) cpustate->pc = addr; break;
+ case 10: if (CCA) cpustate->pc = addr; break;
+ case 11: if (CCB) cpustate->pc = addr; break;
+ case 12: if (CCC) cpustate->pc = addr; break;
+ case 13: if (CCD) cpustate->pc = addr; break;
+ case 14: if (CCE) cpustate->pc = addr; break;
+ case 15: if (CCF) cpustate->pc = addr; break;
+ }
+}
+
+/******************************************
+ jp cc,addr(rd)
+ flags: ------
+ ******************************************/
+static void Z5E_ddN0_cccc_addr(z8000_state *cpustate)
+{
+ GET_CCC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ switch (cc) {
+ case 0: if (CC0) cpustate->pc = addr; break;
+ case 1: if (CC1) cpustate->pc = addr; break;
+ case 2: if (CC2) cpustate->pc = addr; break;
+ case 3: if (CC3) cpustate->pc = addr; break;
+ case 4: if (CC4) cpustate->pc = addr; break;
+ case 5: if (CC5) cpustate->pc = addr; break;
+ case 6: if (CC6) cpustate->pc = addr; break;
+ case 7: if (CC7) cpustate->pc = addr; break;
+ case 8: if (CC8) cpustate->pc = addr; break;
+ case 9: if (CC9) cpustate->pc = addr; break;
+ case 10: if (CCA) cpustate->pc = addr; break;
+ case 11: if (CCB) cpustate->pc = addr; break;
+ case 12: if (CCC) cpustate->pc = addr; break;
+ case 13: if (CCD) cpustate->pc = addr; break;
+ case 14: if (CCE) cpustate->pc = addr; break;
+ case 15: if (CCF) cpustate->pc = addr; break;
+ }
+}
+
+/******************************************
+ call addr
+ flags: ------
+ ******************************************/
+static void Z5F_0000_0000_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ PUSHW(cpustate, SP, cpustate->pc);
+ cpustate->pc = addr;
+}
+
+/******************************************
+ call addr(rd)
+ flags: ------
+ ******************************************/
+static void Z5F_ddN0_0000_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ PUSHW(cpustate, SP, cpustate->pc);
+ addr += cpustate->RW(dst);
+ cpustate->pc = addr;
+}
+
+/******************************************
+ ldb rbd,addr
+ flags: ------
+ ******************************************/
+static void Z60_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RB(dst) = RDMEM_B(cpustate, addr);
+}
+
+/******************************************
+ ldb rbd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z60_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RB(dst) = RDMEM_B(cpustate, addr);
+}
+
+/******************************************
+ ld rd,addr
+ flags: ------
+ ******************************************/
+static void Z61_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RW(dst) = RDMEM_W(cpustate, addr);
+}
+
+/******************************************
+ ld rd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z61_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RW(dst) = RDMEM_W(cpustate, addr);
+}
+
+/******************************************
+ resb addr,imm4
+ flags: ------
+ ******************************************/
+static void Z62_0000_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, RDMEM_B(cpustate, addr) & ~bit);
+}
+
+/******************************************
+ resb addr(rd),imm4
+ flags: ------
+ ******************************************/
+static void Z62_ddN0_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, RDMEM_B(cpustate, addr) & ~bit);
+}
+
+/******************************************
+ res addr,imm4
+ flags: ------
+ ******************************************/
+static void Z63_0000_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, RDMEM_W(cpustate, addr) & ~bit);
+}
+
+/******************************************
+ res addr(rd),imm4
+ flags: ------
+ ******************************************/
+static void Z63_ddN0_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, RDMEM_W(cpustate, addr) & ~bit);
+}
+
+/******************************************
+ setb addr,imm4
+ flags: ------
+ ******************************************/
+static void Z64_0000_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, RDMEM_B(cpustate, addr) | bit);
+}
+
+/******************************************
+ setb addr(rd),imm4
+ flags: ------
+ ******************************************/
+static void Z64_ddN0_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, RDMEM_B(cpustate, addr) | bit);
+}
+
+/******************************************
+ set addr,imm4
+ flags: ------
+ ******************************************/
+static void Z65_0000_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, RDMEM_W(cpustate, addr) | bit);
+}
+
+/******************************************
+ set addr(rd),imm4
+ flags: ------
+ ******************************************/
+static void Z65_ddN0_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, RDMEM_W(cpustate, addr) | bit);
+}
+
+/******************************************
+ bitb addr,imm4
+ flags: -Z----
+ ******************************************/
+static void Z66_0000_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_ADDR(OP1);
+ if (RDMEM_B(cpustate, addr) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ bitb addr(rd),imm4
+ flags: -Z----
+ ******************************************/
+static void Z66_ddN0_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ if (RDMEM_B(cpustate, addr) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ bit addr,imm4
+ flags: -Z----
+ ******************************************/
+static void Z67_0000_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_ADDR(OP1);
+ if (RDMEM_W(cpustate, addr) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ bit addr(rd),imm4
+ flags: -Z----
+ ******************************************/
+static void Z67_ddN0_imm4_addr(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ if (RDMEM_W(cpustate, addr) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ incb addr,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z68_0000_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, INCB(cpustate, RDMEM_B(cpustate, addr), i4p1));
+}
+
+/******************************************
+ incb addr(rd),imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z68_ddN0_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, INCB(cpustate, RDMEM_B(cpustate, addr), i4p1));
+}
+
+/******************************************
+ inc addr,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z69_0000_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, INCW(cpustate, RDMEM_W(cpustate, addr), i4p1));
+}
+
+/******************************************
+ inc addr(rd),imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z69_ddN0_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, INCW(cpustate, RDMEM_W(cpustate, addr), i4p1));
+}
+
+/******************************************
+ decb addr,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z6A_0000_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, DECB(cpustate, RDMEM_B(cpustate, addr), i4p1));
+}
+
+/******************************************
+ decb addr(rd),imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z6A_ddN0_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, DECB(cpustate, RDMEM_B(cpustate, addr), i4p1));
+}
+
+/******************************************
+ dec addr,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z6B_0000_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, DECW(cpustate, RDMEM_W(cpustate, addr), i4p1));
+}
+
+/******************************************
+ dec addr(rd),imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void Z6B_ddN0_imm4m1_addr(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, DECW(cpustate, RDMEM_W(cpustate, addr), i4p1));
+}
+
+/******************************************
+ exb rbd,addr
+ flags: ------
+ ******************************************/
+static void Z6C_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ UINT8 tmp = RDMEM_B(cpustate, addr);
+ WRMEM_B(cpustate, addr, cpustate->RB(dst));
+ cpustate->RB(dst) = tmp;
+}
+
+/******************************************
+ exb rbd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z6C_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ UINT8 tmp;
+ addr += cpustate->RW(src);
+ tmp = RDMEM_B(cpustate, addr);
+ WRMEM_B(cpustate, addr, cpustate->RB(dst));
+ cpustate->RB(dst) = tmp;
+}
+
+/******************************************
+ ex rd,addr
+ flags: ------
+ ******************************************/
+static void Z6D_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ UINT16 tmp = RDMEM_W(cpustate, addr);
+ WRMEM_W(cpustate, addr, cpustate->RW(dst));
+ cpustate->RW(dst) = tmp;
+}
+
+/******************************************
+ ex rd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z6D_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ UINT16 tmp;
+ addr += cpustate->RW(src);
+ tmp = RDMEM_W(cpustate, addr);
+ WRMEM_W(cpustate, addr, cpustate->RW(dst));
+ cpustate->RW(dst) = tmp;
+}
+
+/******************************************
+ ldb addr,rbs
+ flags: ------
+ ******************************************/
+static void Z6E_0000_ssss_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_ADDR(OP1);
+ WRMEM_B(cpustate, addr, cpustate->RB(src));
+}
+
+/******************************************
+ ldb addr(rd),rbs
+ flags: ------
+ ******************************************/
+static void Z6E_ddN0_ssss_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_B(cpustate, addr, cpustate->RB(src));
+}
+
+/******************************************
+ ld addr,rs
+ flags: ------
+ ******************************************/
+static void Z6F_0000_ssss_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_ADDR(OP1);
+ WRMEM_W(cpustate, addr, cpustate->RW(src));
+}
+
+/******************************************
+ ld addr(rd),rs
+ flags: ------
+ ******************************************/
+static void Z6F_ddN0_ssss_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(dst);
+ WRMEM_W(cpustate, addr, cpustate->RW(src));
+}
+
+/******************************************
+ ldb rbd,rs(rx)
+ flags: ------
+ ******************************************/
+static void Z70_ssN0_dddd_0000_xxxx_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IDX(OP1,NIB1);
+ cpustate->RB(dst) = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + cpustate->RW(idx)));
+}
+
+/******************************************
+ ld rd,rs(rx)
+ flags: ------
+ ******************************************/
+static void Z71_ssN0_dddd_0000_xxxx_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IDX(OP1,NIB1);
+ cpustate->RW(dst) = RDMEM_W(cpustate, (UINT16)(cpustate->RW(src) + cpustate->RW(idx)));
+}
+
+/******************************************
+ ldb rd(rx),rbs
+ flags: ------
+ ******************************************/
+static void Z72_ddN0_ssss_0000_xxxx_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_IDX(OP1,NIB1);
+ WRMEM_B(cpustate, (UINT16)(cpustate->RW(dst) + cpustate->RW(idx)), cpustate->RB(src));
+}
+
+/******************************************
+ ld rd(rx),rs
+ flags: ------
+ ******************************************/
+static void Z73_ddN0_ssss_0000_xxxx_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_IDX(OP1,NIB1);
+ WRMEM_W(cpustate, (UINT16)(cpustate->RW(dst) + cpustate->RW(idx)), cpustate->RW(src));
+}
+
+/******************************************
+ lda prd,rs(rx)
+ flags: ------
+ ******************************************/
+static void Z74_ssN0_dddd_0000_xxxx_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IDX(OP1,NIB1);
+ cpustate->RW(dst) = (UINT16)(cpustate->RW(src) + cpustate->RW(idx));
+}
+
+/******************************************
+ ldl rrd,rs(rx)
+ flags: ------
+ ******************************************/
+static void Z75_ssN0_dddd_0000_xxxx_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_IDX(OP1,NIB1);
+ cpustate->RL(dst) = RDMEM_L(cpustate, (UINT16)(cpustate->RW(src) + cpustate->RW(idx)));
+}
+
+/******************************************
+ lda prd,addr
+ flags: ------
+ ******************************************/
+static void Z76_0000_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_ADDR(OP1);
+ cpustate->RW(dst) = addr;
+}
+
+static void Z76_0000_dddd_addr_seg(z8000_state *cpustate)
+{
+ static UINT32 offset;
+ UINT16 operand1;
+
+ GET_DST(OP0,NIB3);
+ operand1 = fetch(cpustate);
+
+ if(operand1 & 0x8000)
+ {
+ UINT16 operand2 = fetch(cpustate);
+
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand2 & 0xffff);
+ cpustate->RW(dst) = (offset & 0x70000) >> 16;
+ cpustate->RW(dst+1) = offset & 0xffff;
+ cycles(cpustate, 15);
+ }
+ else
+ {
+ offset = (operand1 & 0x0700) << 8;
+ offset|= (operand1 & 0x00ff);
+ cpustate->RW(dst) = (offset & 0x70000) >> 16;
+ cpustate->RW(dst+1) = offset & 0x00ff;
+ cycles(cpustate, 13);
+ }
+}
+
+/******************************************
+ lda prd,addr(rs)
+ flags: ------
+ ******************************************/
+static void Z76_ssN0_dddd_addr(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ addr += cpustate->RW(src);
+ cpustate->RW(dst) = addr;
+}
+
+/******************************************
+ ldl rd(rx),rrs
+ flags: ------
+ ******************************************/
+static void Z77_ddN0_ssss_0000_xxxx_0000_0000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ GET_IDX(OP1,NIB1);
+ WRMEM_L(cpustate, (UINT16)(cpustate->RW(dst) + cpustate->RW(idx)), cpustate->RL(src));
+}
+
+/******************************************
+ rsvd78
+ flags: ------
+ ******************************************/
+static void Z78_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvd78 $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ ldps addr
+ flags: CZSVDH
+ ******************************************/
+static void Z79_0000_0000_addr(z8000_state *cpustate)
+{
+ GET_ADDR(OP1);
+ UINT16 fcw;
+ fcw = RDMEM_W(cpustate, addr);
+ cpustate->pc = RDMEM_W(cpustate, (UINT16)(addr + 2));
+ CHANGE_FCW(cpustate, fcw); /* check for user/system mode change */
+}
+
+/******************************************
+ ldps addr(rs)
+ flags: CZSVDH
+ ******************************************/
+static void Z79_ssN0_0000_addr(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_ADDR(OP1);
+ UINT16 fcw;
+ addr += cpustate->RW(src);
+ fcw = RDMEM_W(cpustate, addr);
+ cpustate->pc = RDMEM_W(cpustate, (UINT16)(addr + 2));
+ CHANGE_FCW(cpustate, fcw); /* check for user/system mode change */
+}
+
+/******************************************
+ halt
+ flags: ------
+ ******************************************/
+static void Z7A_0000_0000(z8000_state *cpustate)
+{
+ cpustate->irq_req |= Z8000_HALT;
+ if (cpustate->icount > 0) cpustate->icount = 0;
+}
+
+/******************************************
+ iret
+ flags: CZSVDH
+ ******************************************/
+static void Z7B_0000_0000(z8000_state *cpustate)
+{
+ UINT16 tag, fcw;
+ tag = POPW(cpustate, SP); /* get type tag */
+ fcw = POPW(cpustate, SP); /* get cpustate->fcw */
+ cpustate->pc = POPW(cpustate, SP); /* get cpustate->pc */
+ cpustate->irq_srv &= ~tag; /* remove IRQ serviced flag */
+ CHANGE_FCW(cpustate, fcw); /* check for user/system mode change */
+ LOG(("Z8K '%s' IRET tag $%04x, fcw $%04x, pc $%04x\n", cpustate->device->tag(), tag, fcw, cpustate->pc));
+}
+
+/******************************************
+ mset
+ flags: ------
+ ******************************************/
+static void Z7B_0000_1000(z8000_state *cpustate)
+{
+ /* set mu-0 line */
+}
+
+/******************************************
+ mres
+ flags: ------
+ ******************************************/
+static void Z7B_0000_1001(z8000_state *cpustate)
+{
+ /* reset mu-0 line */
+}
+
+/******************************************
+ mbit
+ flags: CZS---
+ ******************************************/
+static void Z7B_0000_1010(z8000_state *cpustate)
+{
+ /* test mu-I line */
+}
+
+/******************************************
+ mreq rd
+ flags: -ZS---
+ ******************************************/
+static void Z7B_dddd_1101(z8000_state *cpustate)
+{
+ /* test mu-I line, invert cascade to mu-0 */
+}
+
+/******************************************
+ di i2
+ flags: ------
+ ******************************************/
+static void Z7C_0000_00ii(z8000_state *cpustate)
+{
+ GET_IMM2(OP0,NIB3);
+ UINT16 fcw = cpustate->fcw;
+ fcw &= ~(imm2 << 11);
+ CHANGE_FCW(cpustate, fcw);
+}
+
+/******************************************
+ ei i2
+ flags: ------
+ ******************************************/
+static void Z7C_0000_01ii(z8000_state *cpustate)
+{
+ GET_IMM2(OP0,NIB3);
+ UINT16 fcw = cpustate->fcw;
+ fcw |= imm2 << 11;
+ CHANGE_FCW(cpustate, fcw);
+}
+
+/******************************************
+ ldctl rd,ctrl
+ flags: ------
+ ******************************************/
+static void Z7D_dddd_0ccc(z8000_state *cpustate)
+{
+ GET_IMM3(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ switch (imm3) {
+ case 0:
+ cpustate->RW(dst) = cpustate->fcw;
+ break;
+ case 3:
+ cpustate->RW(dst) = cpustate->refresh;
+ break;
+ case 5:
+ cpustate->RW(dst) = cpustate->psap;
+ break;
+ case 7:
+ cpustate->RW(dst) = cpustate->nsp;
+ break;
+ default:
+ LOG(("Z8K '%s' LDCTL R%d,%d\n", cpustate->device->tag(), dst, imm3));
+ }
+}
+
+/******************************************
+ ldctl ctrl,rs
+ flags: ------
+ ******************************************/
+static void Z7D_ssss_1ccc(z8000_state *cpustate)
+{
+ GET_IMM3(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ switch (imm3) {
+ case 0:
+ {
+ UINT16 fcw;
+ fcw = cpustate->RW(src);
+ CHANGE_FCW(cpustate, fcw); /* check for user/system mode change */
+ }
+ break;
+ case 3:
+ cpustate->refresh = cpustate->RW(src);
+ break;
+ case 5:
+ cpustate->psap = cpustate->RW(src);
+ break;
+ case 7:
+ cpustate->nsp = cpustate->RW(src);
+ break;
+ default:
+ LOG(("Z8K '%s' LDCTL %d,R%d\n", cpustate->device->tag(), imm3, src));
+ }
+}
+
+/******************************************
+ rsvd7e
+ flags: ------
+ ******************************************/
+static void Z7E_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvd7e $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ sc imm8
+ flags: CZSVDH
+ ******************************************/
+static void Z7F_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ /* execute system call via IRQ */
+ cpustate->irq_req = Z8000_SYSCALL | imm8;
+
+}
+
+/******************************************
+ addb rbd,rbs
+ flags: CZSVDH
+ ******************************************/
+static void Z80_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = ADDB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ add rd,rs
+ flags: CZSV--
+ ******************************************/
+static void Z81_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = ADDW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ subb rbd,rbs
+ flags: CZSVDH
+ ******************************************/
+static void Z82_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = SUBB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ sub rd,rs
+ flags: CZSV--
+ ******************************************/
+static void Z83_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = SUBW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ orb rbd,rbs
+ flags: CZSP--
+ ******************************************/
+static void Z84_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = ORB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ or rd,rs
+ flags: CZS---
+ ******************************************/
+static void Z85_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = ORW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ andb rbd,rbs
+ flags: -ZSP--
+ ******************************************/
+static void Z86_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = ANDB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ and rd,rs
+ flags: -ZS---
+ ******************************************/
+static void Z87_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = ANDW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ xorb rbd,rbs
+ flags: -ZSP--
+ ******************************************/
+static void Z88_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = XORB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ xor rd,rs
+ flags: -ZS---
+ ******************************************/
+static void Z89_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = XORW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ cpb rbd,rbs
+ flags: CZSV--
+ ******************************************/
+static void Z8A_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ CPB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ cp rd,rs
+ flags: CZSV--
+ ******************************************/
+static void Z8B_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ CPW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ comb rbd
+ flags: -ZSP--
+ ******************************************/
+static void Z8C_dddd_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RB(dst) = COMB(cpustate, cpustate->RB(dst));
+}
+
+/******************************************
+ negb rbd
+ flags: CZSV--
+ ******************************************/
+static void Z8C_dddd_0010(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RB(dst) = NEGB(cpustate, cpustate->RB(dst));
+}
+
+/******************************************
+ testb rbd
+ flags: -ZSP--
+ ******************************************/
+static void Z8C_dddd_0100(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ TESTB(cpustate, cpustate->RB(dst));
+}
+
+/******************************************
+ tsetb rbd
+ flags: --S---
+ ******************************************/
+static void Z8C_dddd_0110(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ if (cpustate->RB(dst) & S08) SET_S; else CLR_S;
+ cpustate->RB(dst) = 0xff;
+}
+
+/******************************************
+ clrb rbd
+ flags: ------
+ ******************************************/
+static void Z8C_dddd_1000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RB(dst) = 0;
+}
+
+/******************************************
+ nop
+ flags: ------
+ ******************************************/
+static void Z8D_0000_0111(z8000_state *cpustate)
+{
+ /* nothing */
+}
+
+/******************************************
+ com rd
+ flags: -ZS---
+ ******************************************/
+static void Z8D_dddd_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) = COMW(cpustate, cpustate->RW(dst));
+}
+
+/******************************************
+ neg rd
+ flags: CZSV--
+ ******************************************/
+static void Z8D_dddd_0010(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) = NEGW(cpustate, cpustate->RW(dst));
+}
+
+/******************************************
+ test rd
+ flags: ------
+ ******************************************/
+static void Z8D_dddd_0100(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ TESTW(cpustate, cpustate->RW(dst));
+}
+
+/******************************************
+ tset rd
+ flags: --S---
+ ******************************************/
+static void Z8D_dddd_0110(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ if (cpustate->RW(dst) & S16) SET_S; else CLR_S;
+ cpustate->RW(dst) = 0xffff;
+}
+
+/******************************************
+ clr rd
+ flags: ------
+ ******************************************/
+static void Z8D_dddd_1000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) = 0;
+}
+
+/******************************************
+ setflg imm4
+ flags: CZSV--
+ ******************************************/
+static void Z8D_imm4_0001(z8000_state *cpustate)
+{
+ cpustate->fcw |= cpustate->op[0] & 0x00f0;
+}
+
+/******************************************
+ resflg imm4
+ flags: CZSV--
+ ******************************************/
+static void Z8D_imm4_0011(z8000_state *cpustate)
+{
+ cpustate->fcw &= ~(cpustate->op[0] & 0x00f0);
+}
+
+/******************************************
+ comflg flags
+ flags: CZSP--
+ ******************************************/
+static void Z8D_imm4_0101(z8000_state *cpustate)
+{
+ cpustate->fcw ^= (cpustate->op[0] & 0x00f0);
+}
+
+/******************************************
+ ext8e imm8
+ flags: ------
+ ******************************************/
+static void Z8E_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: ext8e $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ ext8f imm8
+ flags: ------
+ ******************************************/
+static void Z8F_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: ext8f $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ cpl rrd,rrs
+ flags: CZSV--
+ ******************************************/
+static void Z90_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ CPL(cpustate, cpustate->RL(dst), cpustate->RL(src));
+}
+
+/******************************************
+ pushl @rd,rrs
+ flags: ------
+ ******************************************/
+static void Z91_ddN0_ssss(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ PUSHL(cpustate, dst, cpustate->RL(src));
+}
+
+/******************************************
+ subl rrd,rrs
+ flags: CZSV--
+ ******************************************/
+static void Z92_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = SUBL(cpustate, cpustate->RL(dst), cpustate->RL(src));
+}
+
+/******************************************
+ push @rd,rs
+ flags: ------
+ ******************************************/
+static void Z93_ddN0_ssss(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ PUSHW(cpustate, dst, cpustate->RW(src));
+}
+
+/******************************************
+ ldl rrd,rrs
+ flags: ------
+ ******************************************/
+static void Z94_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = cpustate->RL(src);
+}
+
+/******************************************
+ popl rrd,@rs
+ flags: ------
+ ******************************************/
+static void Z95_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = POPL(cpustate, src);
+}
+
+/******************************************
+ addl rrd,rrs
+ flags: CZSV--
+ ******************************************/
+static void Z96_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = ADDL(cpustate, cpustate->RL(dst), cpustate->RL(src));
+}
+
+/******************************************
+ pop rd,@rs
+ flags: ------
+ ******************************************/
+static void Z97_ssN0_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = POPW(cpustate, src);
+}
+
+/******************************************
+ multl rqd,rrs
+ flags: CZSV--
+ ******************************************/
+static void Z98_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RQ(dst) = MULTL(cpustate, cpustate->RQ(dst), cpustate->RL(src));
+}
+
+/******************************************
+ mult rrd,rs
+ flags: CZSV--
+ ******************************************/
+static void Z99_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = MULTW(cpustate, cpustate->RL(dst), cpustate->RW(src));
+}
+
+/******************************************
+ divl rqd,rrs
+ flags: CZSV--
+ ******************************************/
+static void Z9A_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RQ(dst) = DIVL(cpustate, cpustate->RQ(dst), cpustate->RL(src));
+}
+
+/******************************************
+ div rrd,rs
+ flags: CZSV--
+ ******************************************/
+static void Z9B_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RL(dst) = DIVW(cpustate, cpustate->RL(dst), cpustate->RW(src));
+}
+
+/******************************************
+ testl rrd
+ flags: -ZS---
+ ******************************************/
+static void Z9C_dddd_1000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ CLR_ZS;
+ if (!cpustate->RL(dst)) SET_Z;
+ else if (cpustate->RL(dst) & S32) SET_S;
+}
+
+/******************************************
+ rsvd9d
+ flags: ------
+ ******************************************/
+static void Z9D_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvd9d $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ ret cc
+ flags: ------
+ ******************************************/
+static void Z9E_0000_cccc(z8000_state *cpustate)
+{
+ GET_CCC(OP0,NIB3);
+ switch (cc) {
+ case 0: if (CC0) cpustate->pc = POPW(cpustate, SP); break;
+ case 1: if (CC1) cpustate->pc = POPW(cpustate, SP); break;
+ case 2: if (CC2) cpustate->pc = POPW(cpustate, SP); break;
+ case 3: if (CC3) cpustate->pc = POPW(cpustate, SP); break;
+ case 4: if (CC4) cpustate->pc = POPW(cpustate, SP); break;
+ case 5: if (CC5) cpustate->pc = POPW(cpustate, SP); break;
+ case 6: if (CC6) cpustate->pc = POPW(cpustate, SP); break;
+ case 7: if (CC7) cpustate->pc = POPW(cpustate, SP); break;
+ case 8: if (CC8) cpustate->pc = POPW(cpustate, SP); break;
+ case 9: if (CC9) cpustate->pc = POPW(cpustate, SP); break;
+ case 10: if (CCA) cpustate->pc = POPW(cpustate, SP); break;
+ case 11: if (CCB) cpustate->pc = POPW(cpustate, SP); break;
+ case 12: if (CCC) cpustate->pc = POPW(cpustate, SP); break;
+ case 13: if (CCD) cpustate->pc = POPW(cpustate, SP); break;
+ case 14: if (CCE) cpustate->pc = POPW(cpustate, SP); break;
+ case 15: if (CCF) cpustate->pc = POPW(cpustate, SP); break;
+ }
+}
+
+/******************************************
+ rsvd9f
+ flags: ------
+ ******************************************/
+static void Z9F_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvd9f $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+}
+
+/******************************************
+ ldb rbd,rbs
+ flags: ------
+ ******************************************/
+static void ZA0_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = cpustate->RB(src);
+}
+
+/******************************************
+ ld rd,rs
+ flags: ------
+ ******************************************/
+static void ZA1_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = cpustate->RW(src);
+}
+
+/******************************************
+ resb rbd,imm4
+ flags: ------
+ ******************************************/
+static void ZA2_dddd_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ cpustate->RB(dst) &= ~bit;
+}
+
+/******************************************
+ res rd,imm4
+ flags: ------
+ ******************************************/
+static void ZA3_dddd_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) &= ~bit;
+}
+
+/******************************************
+ setb rbd,imm4
+ flags: ------
+ ******************************************/
+static void ZA4_dddd_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ cpustate->RB(dst) |= bit;
+}
+
+/******************************************
+ set rd,imm4
+ flags: ------
+ ******************************************/
+static void ZA5_dddd_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) |= bit;
+}
+
+/******************************************
+ bitb rbd,imm4
+ flags: -Z----
+ ******************************************/
+static void ZA6_dddd_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ if (cpustate->RB(dst) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ bit rd,imm4
+ flags: -Z----
+ ******************************************/
+static void ZA7_dddd_imm4(z8000_state *cpustate)
+{
+ GET_BIT(OP0);
+ GET_DST(OP0,NIB2);
+ if (cpustate->RW(dst) & bit) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ incb rbd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void ZA8_dddd_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ cpustate->RB(dst) = INCB(cpustate, cpustate->RB(dst), i4p1);
+}
+
+/******************************************
+ inc rd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void ZA9_dddd_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) = INCW(cpustate, cpustate->RW(dst), i4p1);
+}
+
+/******************************************
+ decb rbd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void ZAA_dddd_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ cpustate->RB(dst) = DECB(cpustate, cpustate->RB(dst), i4p1);
+}
+
+/******************************************
+ dec rd,imm4m1
+ flags: -ZSV--
+ ******************************************/
+static void ZAB_dddd_imm4m1(z8000_state *cpustate)
+{
+ GET_I4M1(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) = DECW(cpustate, cpustate->RW(dst), i4p1);
+}
+
+/******************************************
+ exb rbd,rbs
+ flags: ------
+ ******************************************/
+static void ZAC_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ UINT8 tmp = cpustate->RB(src);
+ cpustate->RB(src) = cpustate->RB(dst);
+ cpustate->RB(dst) = tmp;
+}
+
+/******************************************
+ ex rd,rs
+ flags: ------
+ ******************************************/
+static void ZAD_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ UINT16 tmp = cpustate->RW(src);
+ cpustate->RW(src) = cpustate->RW(dst);
+ cpustate->RW(dst) = tmp;
+}
+
+/******************************************
+ tccb cc,rbd
+ flags: ------
+ ******************************************/
+static void ZAE_dddd_cccc(z8000_state *cpustate)
+{
+ GET_CCC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ UINT8 tmp = cpustate->RB(dst) & ~1;
+ switch (cc) {
+ case 0: if (CC0) tmp |= 1; break;
+ case 1: if (CC1) tmp |= 1; break;
+ case 2: if (CC2) tmp |= 1; break;
+ case 3: if (CC3) tmp |= 1; break;
+ case 4: if (CC4) tmp |= 1; break;
+ case 5: if (CC5) tmp |= 1; break;
+ case 6: if (CC6) tmp |= 1; break;
+ case 7: if (CC7) tmp |= 1; break;
+ case 8: if (CC8) tmp |= 1; break;
+ case 9: if (CC9) tmp |= 1; break;
+ case 10: if (CCA) tmp |= 1; break;
+ case 11: if (CCB) tmp |= 1; break;
+ case 12: if (CCC) tmp |= 1; break;
+ case 13: if (CCD) tmp |= 1; break;
+ case 14: if (CCE) tmp |= 1; break;
+ case 15: if (CCF) tmp |= 1; break;
+ }
+ cpustate->RB(dst) = tmp;
+}
+
+/******************************************
+ tcc cc,rd
+ flags: ------
+ ******************************************/
+static void ZAF_dddd_cccc(z8000_state *cpustate)
+{
+ GET_CCC(OP0,NIB3);
+ GET_DST(OP0,NIB2);
+ UINT16 tmp = cpustate->RW(dst) & ~1;
+ switch (cc) {
+ case 0: if (CC0) tmp |= 1; break;
+ case 1: if (CC1) tmp |= 1; break;
+ case 2: if (CC2) tmp |= 1; break;
+ case 3: if (CC3) tmp |= 1; break;
+ case 4: if (CC4) tmp |= 1; break;
+ case 5: if (CC5) tmp |= 1; break;
+ case 6: if (CC6) tmp |= 1; break;
+ case 7: if (CC7) tmp |= 1; break;
+ case 8: if (CC8) tmp |= 1; break;
+ case 9: if (CC9) tmp |= 1; break;
+ case 10: if (CCA) tmp |= 1; break;
+ case 11: if (CCB) tmp |= 1; break;
+ case 12: if (CCC) tmp |= 1; break;
+ case 13: if (CCD) tmp |= 1; break;
+ case 14: if (CCE) tmp |= 1; break;
+ case 15: if (CCF) tmp |= 1; break;
+ }
+ cpustate->RW(dst) = tmp;
+}
+
+/******************************************
+ dab rbd
+ flags: CZS---
+ ******************************************/
+static void ZB0_dddd_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ UINT8 result;
+ UINT16 idx = cpustate->RB(dst);
+ if (cpustate->fcw & F_C) idx |= 0x100;
+ if (cpustate->fcw & F_H) idx |= 0x200;
+ if (cpustate->fcw & F_DA) idx |= 0x400;
+ result = Z8000_dab[idx];
+ CLR_CZS;
+ CHK_XXXB_ZS;
+ if (Z8000_dab[idx] & 0x100) SET_C;
+ cpustate->RB(dst) = result;
+}
+
+/******************************************
+ extsb rd
+ flags: ------
+ ******************************************/
+static void ZB1_dddd_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RW(dst) = (cpustate->RW(dst) & 0xff) | ((cpustate->RW(dst) & S08) ? 0xff00 : 0x0000);
+}
+
+/******************************************
+ extsl rqd
+ flags: ------
+ ******************************************/
+static void ZB1_dddd_0111(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RQ(dst) = CONCAT_64((cpustate->RQ(dst) & S32) ?
+ 0xfffffffful : 0, EXTRACT_64LO(cpustate->RQ(dst)));
+}
+
+/******************************************
+ exts rrd
+ flags: ------
+ ******************************************/
+static void ZB1_dddd_1010(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ cpustate->RL(dst) = (cpustate->RL(dst) & 0xffff) | ((cpustate->RL(dst) & S16) ?
+ 0xffff0000ul : 0x00000000ul);
+}
+
+/******************************************
+ sllb rbd,imm8
+ flags: CZS---
+ srlb rbd,imm8
+ flags: CZSV--
+ ******************************************/
+static void ZB2_dddd_0001_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ if (imm16 & S16)
+ cpustate->RB(dst) = SRLB(cpustate, cpustate->RB(dst), -(INT16)imm16);
+ else
+ cpustate->RB(dst) = SLLB(cpustate, cpustate->RB(dst), imm16);
+}
+
+/******************************************
+ sdlb rbd,rs
+ flags: CZS---
+ ******************************************/
+static void ZB2_dddd_0011_0000_ssss_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB1);
+ cpustate->RB(dst) = SRLB(cpustate, cpustate->RB(dst), (INT8)cpustate->RW(src));
+}
+
+/******************************************
+ rlb rbd,imm1or2
+ flags: CZSV--
+ ******************************************/
+static void ZB2_dddd_00I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RB(dst) = RLB(cpustate, cpustate->RB(dst), imm1);
+}
+
+/******************************************
+ rrb rbd,imm1or2
+ flags: CZSV--
+ ******************************************/
+static void ZB2_dddd_01I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RB(dst) = RRB(cpustate, cpustate->RB(dst), imm1);
+}
+
+/******************************************
+ slab rbd,imm8
+ flags: CZSV--
+ srab rbd,imm8
+ flags: CZSV--
+ ******************************************/
+static void ZB2_dddd_1001_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ if (imm16 & S16)
+ cpustate->RB(dst) = SRAB(cpustate, cpustate->RB(dst), -(INT16)imm16);
+ else
+ cpustate->RB(dst) = SLAB(cpustate, cpustate->RB(dst), imm16);
+}
+
+/******************************************
+ sdab rbd,rs
+ flags: CZSV--
+ ******************************************/
+static void ZB2_dddd_1011_0000_ssss_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB1);
+ cpustate->RB(dst) = SDAB(cpustate, cpustate->RB(dst), (INT8) cpustate->RW(src));
+}
+
+/******************************************
+ rlcb rbd,imm1or2
+ flags: -Z----
+ ******************************************/
+static void ZB2_dddd_10I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RB(dst) = RLCB(cpustate, cpustate->RB(dst), imm1);
+}
+
+/******************************************
+ rrcb rbd,imm1or2
+ flags: -Z----
+ ******************************************/
+static void ZB2_dddd_11I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RB(dst) = RRCB(cpustate, cpustate->RB(dst), imm1);
+}
+
+/******************************************
+ sll rd,imm8
+ flags: CZS---
+ srl rd,imm8
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_0001_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ if (imm16 & S16)
+ cpustate->RW(dst) = SRLW(cpustate, cpustate->RW(dst), -(INT16)imm16);
+ else
+ cpustate->RW(dst) = SLLW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ sdl rd,rs
+ flags: CZS---
+ ******************************************/
+static void ZB3_dddd_0011_0000_ssss_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB1);
+ cpustate->RW(dst) = SDLW(cpustate, cpustate->RW(dst), (INT8)cpustate->RW(src));
+}
+
+/******************************************
+ rl rd,imm1or2
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_00I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RW(dst) = RLW(cpustate, cpustate->RW(dst), imm1);
+}
+
+/******************************************
+ slll rrd,imm8
+ flags: CZS---
+ srll rrd,imm8
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_0101_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ if (imm16 & S16)
+ cpustate->RL(dst) = SRLL(cpustate, cpustate->RL(dst), -(INT16)imm16);
+ else
+ cpustate->RL(dst) = SLLL(cpustate, cpustate->RL(dst), imm16);
+}
+
+/******************************************
+ sdll rrd,rs
+ flags: CZS---
+ ******************************************/
+static void ZB3_dddd_0111_0000_ssss_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB1);
+ cpustate->RL(dst) = SDLL(cpustate, cpustate->RL(dst), cpustate->RW(src) & 0xff);
+}
+
+/******************************************
+ rr rd,imm1or2
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_01I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RW(dst) = RRW(cpustate, cpustate->RW(dst), imm1);
+}
+
+/******************************************
+ sla rd,imm8
+ flags: CZSV--
+ sra rd,imm8
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_1001_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ if (imm16 & S16)
+ cpustate->RW(dst) = SRAW(cpustate, cpustate->RW(dst), -(INT16)imm16);
+ else
+ cpustate->RW(dst) = SLAW(cpustate, cpustate->RW(dst), imm16);
+}
+
+/******************************************
+ sda rd,rs
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_1011_0000_ssss_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB1);
+ cpustate->RW(dst) = SDAW(cpustate, cpustate->RW(dst), (INT8)cpustate->RW(src));
+}
+
+/******************************************
+ rlc rd,imm1or2
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_10I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RW(dst) = RLCW(cpustate, cpustate->RW(dst), imm1);
+}
+
+/******************************************
+ slal rrd,imm8
+ flags: CZSV--
+ sral rrd,imm8
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_1101_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM16(OP1);
+ if (imm16 & S16)
+ cpustate->RL(dst) = SRAL(cpustate, cpustate->RL(dst), -(INT16)imm16);
+ else
+ cpustate->RL(dst) = SLAL(cpustate, cpustate->RL(dst), imm16);
+}
+
+/******************************************
+ sdal rrd,rs
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_1111_0000_ssss_0000_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB1);
+ cpustate->RL(dst) = SDAL(cpustate, cpustate->RL(dst), cpustate->RW(src) & 0xff);
+}
+
+/******************************************
+ rrc rd,imm1or2
+ flags: CZSV--
+ ******************************************/
+static void ZB3_dddd_11I0(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM1(OP0,NIB3);
+ cpustate->RW(dst) = RRCW(cpustate, cpustate->RW(dst), imm1);
+}
+
+/******************************************
+ adcb rbd,rbs
+ flags: CZSVDH
+ ******************************************/
+static void ZB4_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = ADCB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ adc rd,rs
+ flags: CZSV--
+ ******************************************/
+static void ZB5_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = ADCW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ sbcb rbd,rbs
+ flags: CZSVDH
+ ******************************************/
+static void ZB6_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RB(dst) = SBCB(cpustate, cpustate->RB(dst), cpustate->RB(src));
+}
+
+/******************************************
+ sbc rd,rs
+ flags: CZSV--
+ ******************************************/
+static void ZB7_ssss_dddd(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB3);
+ GET_SRC(OP0,NIB2);
+ cpustate->RW(dst) = SBCW(cpustate, cpustate->RW(dst), cpustate->RW(src));
+}
+
+/******************************************
+ trtib @rd,@rs,rr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_0010_0000_rrrr_ssN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ cpustate->RB(2) = xlt;
+ if (xlt) CLR_Z; else SET_Z;
+ cpustate->RW(dst)++;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ trtirb @rd,@rs,rbr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_0110_0000_rrrr_ssN0_1110(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ cpustate->RB(2) = xlt;
+ if (xlt) CLR_Z; else SET_Z;
+ cpustate->RW(dst)++;
+ if (--cpustate->RW(cnt)) { CLR_V; cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ trtdb @rd,@rs,rbr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_1010_0000_rrrr_ssN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ cpustate->RB(2) = xlt;
+ if (xlt) CLR_Z; else SET_Z;
+ cpustate->RW(dst)--;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ trtdrb @rd,@rs,rbr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_1110_0000_rrrr_ssN0_1110(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ cpustate->RB(2) = xlt;
+ if (xlt) CLR_Z; else SET_Z;
+ cpustate->RW(dst)--;
+ if (--cpustate->RW(cnt)) { CLR_V; cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ trib @rd,@rs,rbr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_0000_0000_rrrr_ssN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ WRMEM_B(cpustate, cpustate->RW(dst), xlt);
+ cpustate->RW(dst)++;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ trirb @rd,@rs,rbr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_0100_0000_rrrr_ssN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ WRMEM_B(cpustate, cpustate->RW(dst), xlt);
+ cpustate->RW(dst)++;
+ if (--cpustate->RW(cnt)) { CLR_V; cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ trdb @rd,@rs,rbr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_1000_0000_rrrr_ssN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ WRMEM_B(cpustate, cpustate->RW(dst), xlt);
+ cpustate->RW(dst)--;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ trdrb @rd,@rs,rbr
+ flags: -ZSV--
+ ******************************************/
+static void ZB8_ddN0_1100_0000_rrrr_ssN0_0000(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_SRC(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ UINT8 xlt = RDMEM_B(cpustate, (UINT16)(cpustate->RW(src) + RDMEM_B(cpustate, cpustate->RW(dst))));
+ WRMEM_B(cpustate, cpustate->RW(dst), xlt);
+ cpustate->RW(dst)--;
+ if (--cpustate->RW(cnt)) { CLR_V; cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ rsvdb9
+ flags: ------
+ ******************************************/
+static void ZB9_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvdb9 $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+ (void)imm8;
+}
+
+/******************************************
+ cpib rbd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_0000_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ ldib @rd,@rs,rr
+ ldibr @rd,@rs,rr
+ flags: ---V--
+ ******************************************/
+static void ZBA_ssN0_0001_0000_rrrr_ddN0_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3); /* repeat? */
+ WRMEM_B(cpustate, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst)++;
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsib @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_0010_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst)), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst)++;
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpirb rbd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_0100_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsirb @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_0110_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst)), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst)++;
+ cpustate->RW(src)++;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpdb rbd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_1000_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ lddb @rs,@rd,rr
+ lddbr @rs,@rd,rr
+ flags: ---V--
+ ******************************************/
+static void ZBA_ssN0_1001_0000_rrrr_ddN0_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_B(cpustate, cpustate->RW(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst)--;
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsdb @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_1010_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst)), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst)--;
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ cpdrb rbd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_1100_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, cpustate->RB(dst), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsdrb @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBA_ssN0_1110_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPB(cpustate, RDMEM_B(cpustate, cpustate->RW(dst)), RDMEM_B(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst)--;
+ cpustate->RW(src)--;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpi rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_0000_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ ldi @rd,@rs,rr
+ ldir @rd,@rs,rr
+ flags: ---V--
+ ******************************************/
+static void ZBB_ssN0_0001_0000_rrrr_ddN0_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst) += 2;
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsi @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_0010_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst) += 2;
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ cpir rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_0100_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsir @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_0110_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst) += 2;
+ cpustate->RW(src) += 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpd rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_1000_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ ldd @rs,@rd,rr
+ lddr @rs,@rd,rr
+ flags: ---V--
+ ******************************************/
+static void ZBB_ssN0_1001_0000_rrrr_ddN0_x000(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CNT(OP1,NIB1);
+ GET_DST(OP1,NIB2);
+ GET_CCC(OP1,NIB3);
+ WRMEM_W(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ cpustate->RW(dst) -= 2;
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (cc == 0) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsd @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_1010_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst) -= 2;
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) CLR_V; else SET_V;
+}
+
+/******************************************
+ cpdr rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_1100_0000_rrrr_dddd_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, cpustate->RW(dst), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ cpsdr @rd,@rs,rr,cc
+ flags: CZSV--
+ ******************************************/
+static void ZBB_ssN0_1110_0000_rrrr_ddN0_cccc(z8000_state *cpustate)
+{
+ GET_SRC(OP0,NIB2);
+ GET_CCC(OP1,NIB3);
+ GET_DST(OP1,NIB2);
+ GET_CNT(OP1,NIB1);
+ CPW(cpustate, RDMEM_W(cpustate, cpustate->RW(dst)), RDMEM_W(cpustate, cpustate->RW(src)));
+ switch (cc) {
+ case 0: if (CC0) SET_Z; else CLR_Z; break;
+ case 1: if (CC1) SET_Z; else CLR_Z; break;
+ case 2: if (CC2) SET_Z; else CLR_Z; break;
+ case 3: if (CC3) SET_Z; else CLR_Z; break;
+ case 4: if (CC4) SET_Z; else CLR_Z; break;
+ case 5: if (CC5) SET_Z; else CLR_Z; break;
+ case 6: if (CC6) SET_Z; else CLR_Z; break;
+ case 7: if (CC7) SET_Z; else CLR_Z; break;
+ case 8: if (CC8) SET_Z; else CLR_Z; break;
+ case 9: if (CC9) SET_Z; else CLR_Z; break;
+ case 10: if (CCA) SET_Z; else CLR_Z; break;
+ case 11: if (CCB) SET_Z; else CLR_Z; break;
+ case 12: if (CCC) SET_Z; else CLR_Z; break;
+ case 13: if (CCD) SET_Z; else CLR_Z; break;
+ case 14: if (CCE) SET_Z; else CLR_Z; break;
+ case 15: if (CCF) SET_Z; else CLR_Z; break;
+ }
+ cpustate->RW(dst) -= 2;
+ cpustate->RW(src) -= 2;
+ if (--cpustate->RW(cnt)) { CLR_V; if (!(cpustate->fcw & F_Z)) cpustate->pc -= 4; } else SET_V;
+}
+
+/******************************************
+ rrdb rbb,rba
+ flags: -Z----
+ ******************************************/
+static void ZBC_aaaa_bbbb(z8000_state *cpustate)
+{
+ UINT8 b = cpustate->op[0] & 15;
+ UINT8 a = (cpustate->op[0] >> 4) & 15;
+ UINT8 tmp = cpustate->RB(b);
+ cpustate->RB(a) = (cpustate->RB(a) >> 4) | (cpustate->RB(b) << 4);
+ cpustate->RB(b) = (cpustate->RB(b) & 0xf0) | (tmp & 0x0f);
+ if (cpustate->RB(b)) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ ldk rd,imm4
+ flags: ------
+ ******************************************/
+static void ZBD_dddd_imm4(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB2);
+ GET_IMM4(OP0,NIB3);
+ cpustate->RW(dst) = imm4;
+}
+
+/******************************************
+ rldb rbb,rba
+ flags: -Z----
+ ******************************************/
+static void ZBE_aaaa_bbbb(z8000_state *cpustate)
+{
+ UINT8 b = cpustate->op[0] & 15;
+ UINT8 a = (cpustate->op[0] >> 4) & 15;
+ UINT8 tmp = cpustate->RB(a);
+ cpustate->RB(a) = (cpustate->RB(a) << 4) | (cpustate->RB(b) & 0x0f);
+ cpustate->RB(b) = (cpustate->RB(b) & 0xf0) | (tmp >> 4);
+ if (cpustate->RB(b)) CLR_Z; else SET_Z;
+}
+
+/******************************************
+ rsvdbf
+ flags: ------
+ ******************************************/
+static void ZBF_imm8(z8000_state *cpustate)
+{
+ GET_IMM8(0);
+ LOG(("Z8K '%s' %04x: rsvdbf $%02x\n", cpustate->device->tag(), cpustate->pc, imm8));
+ if (cpustate->fcw & F_EPU) {
+ /* Z8001 EPU code goes here */
+ (void)imm8;
+ }
+ (void)imm8;
+}
+
+/******************************************
+ ldb rbd,imm8
+ flags: ------
+ ******************************************/
+static void ZC_dddd_imm8(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB1);
+ GET_IMM8(0);
+ cpustate->RB(dst) = imm8;
+}
+
+/******************************************
+ calr dsp12
+ flags: ------
+ ******************************************/
+static void ZD_dsp12(z8000_state *cpustate)
+{
+ INT16 dsp12 = cpustate->op[0] & 0xfff;
+ PUSHW(cpustate, SP, cpustate->pc);
+ dsp12 = (dsp12 & 2048) ? 4096 -2 * (dsp12 & 2047) : -2 * (dsp12 & 2047);
+ cpustate->pc += dsp12;
+}
+
+/******************************************
+ jr cc,dsp8
+ flags: ------
+ ******************************************/
+static void ZE_cccc_dsp8(z8000_state *cpustate)
+{
+ GET_DSP8;
+ GET_CCC(OP0,NIB1);
+ switch (cc) {
+ case 0: if (CC0) cpustate->pc += dsp8 * 2; break;
+ case 1: if (CC1) cpustate->pc += dsp8 * 2; break;
+ case 2: if (CC2) cpustate->pc += dsp8 * 2; break;
+ case 3: if (CC3) cpustate->pc += dsp8 * 2; break;
+ case 4: if (CC4) cpustate->pc += dsp8 * 2; break;
+ case 5: if (CC5) cpustate->pc += dsp8 * 2; break;
+ case 6: if (CC6) cpustate->pc += dsp8 * 2; break;
+ case 7: if (CC7) cpustate->pc += dsp8 * 2; break;
+ case 8: if (CC8) cpustate->pc += dsp8 * 2; break;
+ case 9: if (CC9) cpustate->pc += dsp8 * 2; break;
+ case 10: if (CCA) cpustate->pc += dsp8 * 2; break;
+ case 11: if (CCB) cpustate->pc += dsp8 * 2; break;
+ case 12: if (CCC) cpustate->pc += dsp8 * 2; break;
+ case 13: if (CCD) cpustate->pc += dsp8 * 2; break;
+ case 14: if (CCE) cpustate->pc += dsp8 * 2; break;
+ case 15: if (CCF) cpustate->pc += dsp8 * 2; break;
+ }
+}
+
+/******************************************
+ dbjnz rbd,dsp7
+ flags: ------
+ ******************************************/
+static void ZF_dddd_0dsp7(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB1);
+ GET_DSP7;
+ cpustate->RB(dst) -= 1;
+ if (cpustate->RB(dst)) {
+ cpustate->pc = cpustate->pc - 2 * dsp7;
+ }
+}
+
+/******************************************
+ djnz rd,dsp7
+ flags: ------
+ ******************************************/
+static void ZF_dddd_1dsp7(z8000_state *cpustate)
+{
+ GET_DST(OP0,NIB1);
+ GET_DSP7;
+ cpustate->RW(dst) -= 1;
+ if (cpustate->RW(dst)) {
+ cpustate->pc = cpustate->pc - 2 * dsp7;
+ }
+}
+
+