summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/cpu/dsp56k/dsp56dsm.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/cpu/dsp56k/dsp56dsm.c')
-rw-r--r--src/emu/cpu/dsp56k/dsp56dsm.c2210
1 files changed, 2210 insertions, 0 deletions
diff --git a/src/emu/cpu/dsp56k/dsp56dsm.c b/src/emu/cpu/dsp56k/dsp56dsm.c
new file mode 100644
index 00000000000..a2f5c00b5b1
--- /dev/null
+++ b/src/emu/cpu/dsp56k/dsp56dsm.c
@@ -0,0 +1,2210 @@
+/***************************************************************************
+
+ dsp56kdasm.c
+ Disassembler for the portable Motorola/Freescale dsp56k emulator.
+ Written by Andrew Gardner
+
+***************************************************************************/
+
+#include "dsp56k.h"
+
+/* todo: fix the syntax for many opcodes to be true DSP56k assembly
+ *
+ *
+*/
+
+
+// Main opcode categories
+static unsigned DecodeDataALUOpcode(char *buffer, UINT16 op, unsigned pc, int parallelType) ;
+//static unsigned DecodeDXMDROpcode(char *buffer, UINT16 op, unsigned pc) ;
+static unsigned DecodeNPMOpcode(char *buffer, UINT16 op, unsigned pc, const UINT8 *oprom) ;
+static unsigned DecodeMisfitOpcode(char *buffer, UINT16 op, unsigned pc, const UINT8 *oprom) ;
+static unsigned DecodeSpecialOpcode(char *buffer, UINT16 op, unsigned pc, const UINT8 *oprom) ;
+
+
+// Parallel memory operation decoding
+static void AppendXMDM(char *buffer, UINT16 op) ;
+static void AppendXMDMSpecial(char *buffer, UINT16 op, char *working) ;
+static void AppendARU(char *buffer, UINT16 op) ;
+static void AppendRRDM(char *buffer, UINT16 op, char *working) ;
+
+//static void AppendDXMDR(char *buffer, UINT16 op) ;
+
+
+// Helper functions
+#define BITS(CUR,MASK) (Dsp56kOpMask(CUR,MASK))
+static UINT16 Dsp56kOpMask(UINT16 op, UINT16 mask) ;
+
+
+enum bbbType { BBB_UPPER, BBB_MIDDLE, BBB_LOWER } ;
+
+// Table decoder functions...
+static int DecodeBBBTable (UINT16 BBB ) ;
+static void DecodeccccTable (UINT16 cccc, char *mnemonic) ;
+static void DecodeDDDDDTable(UINT16 DDDDD, char *SD) ;
+static void DecodeDDTable (UINT16 DD, char *SD) ;
+//static void DecodeDDFTable (UINT16 DD, UINT16 F, char *S, char *D) ;
+static void DecodeEETable (UINT16 EE, char *D) ;
+static void DecodeFTable (UINT16 F, char *SD) ;
+static void Decodeh0hFTable (UINT16 h0h, UINT16 F, char *S, char *D) ;
+static void DecodeHHTable (UINT16 HH, char *SD) ;
+static void DecodeHHHTable (UINT16 HHH, char *SD) ;
+static void DecodeIIIITable (UINT16 IIII, char *S, char *D) ;
+static void DecodeJJJFTable (UINT16 JJJ, UINT16 F, char *S, char *D) ;
+static void DecodeJJFTable (UINT16 JJ, UINT16 F, char *S, char *D) ;
+//static void DecodeJFTable (UINT16 J, UINT16 F, char *S, char *D) ;
+//static void DecodekTable (UINT16 k, char *Dnot) ;
+//static void DecodekSignTable(UINT16 k, char *plusMinus) ;
+//static void DecodeKKKTable (UINT16 KKK, char *D1, char *D2) ;
+//static int DecodeNNTable (UINT16 NN) ;
+//static void DecodeQQFTable (UINT16 QQ, UINT16 F, char *S1, char *S2, char *D) ;
+static void DecodeQQFTableSp(UINT16 QQ, UINT16 F, char *S1, char *S2, char *D) ;
+//static void DecodeQQQFTable (UINT16 QQQ, UINT16 F, char *S1, char *S2, char *D) ;
+static int DecodeRRTable (UINT16 RR) ;
+static void DecodesTable (UINT16 s, char *arithmetic) ;
+//static void DecodessTable (UINT16 ss, char *arithmetic) ;
+//static void DecodeuuuuFTable(UINT16 uuuu, UINT16 F, char *arg, char *S, char *D) ;
+static void DecodeZTable (UINT16 Z, char *ea) ;
+
+
+static void AssembleeaFrommTable (UINT16 m, int n, char *ea) ;
+//static void AssembleeaFrommmTable(UINT16 mm, int n1, int n2, char *ea1, char *ea2) ;
+static void AssembleeaFromMMTable(UINT16 MM, int n, char *ea) ;
+static void AssembleeaFromtTable (UINT16 t, UINT16 val, char *ea) ;
+static void AssembleeaFromqTable (UINT16 q, int n, char *ea) ;
+static void AssembleeaFromzTable (UINT16 z, int n, char *ea) ;
+
+static void AssembleDFromPTable(UINT16 P, UINT16 ppppp, char *D) ;
+static void AssembleArgumentsFromWTable(UINT16 W, char *args, char ma, char *SD, char *ea) ;
+static void AssembleRegFromWTable(UINT16 W, char *args, char ma, char *SD, UINT8 xx) ;
+
+static void AssembleAddressFromIOShortAddress(UINT16 pp, char *ea) ;
+static void AssembleAddressFrom6BitSignedRelativeShortAddress(UINT16 srs, char *ea) ;
+
+// Main disassembly function
+offs_t dsp56k_dasm(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram)
+{
+ UINT16 op = oprom[0] | (oprom[1] << 8);
+ unsigned size = 0 ;
+
+ pc <<= 1 ;
+
+ if (BITS(op,0x8000)) // First, the parallel data move instructions
+ {
+ size = DecodeDataALUOpcode(buffer, op, pc, PARALLEL_TYPE_XMDM) ;
+ }
+ else if (BITS(op,0xf000) == 0x5)
+ {
+ size = DecodeDataALUOpcode(buffer, op, pc, PARALLEL_TYPE_XMDM_SPECIAL) ;
+ }
+ else if (BITS(op,0xff00) == 0x4a)
+ {
+ size = DecodeDataALUOpcode(buffer, op, pc, PARALLEL_TYPE_NODM) ;
+ }
+ else if (BITS(op,0xf000) == 0x04)
+ {
+ size = DecodeDataALUOpcode(buffer, op, pc, PARALLEL_TYPE_RRDM) ;
+ }
+ else if (BITS(op,0xf800) == 0x06)
+ {
+ size = DecodeDataALUOpcode(buffer, op, pc, PARALLEL_TYPE_ARU) ;
+ }
+
+ else if (BITS(op,0x4000))
+ {
+ // size = DecodeDXMDROpcode(buffer, op, pc) ;
+ sprintf(buffer, "unknown") ;
+ size = 1 ;
+ }
+ else if (BITS(op,0xf000) == 0x1)
+ {
+ size = DecodeNPMOpcode(buffer, op, pc, oprom) ;
+ }
+ else if (BITS(op,0x2000))
+ {
+ size = DecodeMisfitOpcode(buffer, op, pc, oprom) ;
+ }
+ else if (BITS(op,0xf000) == 0x0)
+ {
+ size = DecodeSpecialOpcode(buffer, op, pc, oprom) ;
+ }
+
+ if (size == 0)
+ {
+ sprintf(buffer, "unknown") ;
+ size = 1 ; // Just to get the debugger past the bad opcode
+ }
+
+ return size | DASMFLAG_SUPPORTED;
+}
+
+
+static unsigned DecodeDataALUOpcode(char *buffer, UINT16 op, unsigned pc, int parallelType)
+{
+ unsigned retSize = 0 ;
+
+ char S1[32] ;
+ char D[32] ;
+
+ switch(BITS(op,0x0070))
+ {
+ case 0x0:
+ if (BITS(op,0x0007) == 0x1)
+ {
+ // CLR - 1mRR HHHW 0000 F001
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "clr %s", D) ;
+ retSize = 1 ;
+ }
+ else
+ {
+ // ADD - 1mRR HHHW 0000 FJJJ
+ DecodeJJJFTable(BITS(op,0x0007), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "add %s,%s", S1, D) ;
+ retSize = 1 ;
+ }
+ break ;
+
+ case 0x1:
+ if (BITS(op,0x000f) == 0x1)
+ {
+ // MOVE - 1mRR HHHW 0001 0001
+ // Funny operation :)
+ sprintf(buffer, "move ") ;
+ retSize = 1 ;
+ }
+ else
+ {
+ // TFR - 1mRR HHHW 0001 FJJJ
+ DecodeJJJFTable(BITS(op,0x0007), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "tfr %s,%s", S1, D) ;
+ retSize = 1 ;
+ }
+ break ;
+
+ case 0x2:
+ if (BITS(op,0x0007) == 0x0)
+ {
+ // RND - 1mRR HHHW 0010 F000
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "rnd %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0007) == 0x1)
+ {
+ // TST - 1mRR HHHW 0010 F001
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "tst %s", D) ;
+ retSize = 1 ;
+ }
+ else if (BITS(op,0x0007) == 0x2)
+ {
+ // INC - 1mRR HHHW 0010 F010
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "inc %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0007) == 0x3)
+ {
+ // INC24 - 1mRR HHHW 0010 F011
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "inc24 %s", D) ;
+ retSize = 1 ;
+*/ }
+ else
+ {
+ // OR - 1mRR HHHW 0010 F1JJ
+ DecodeJJFTable(BITS(op,0x0003),BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "or %s,%s", S1, D) ;
+ retSize = 1 ;
+ }
+ break ;
+
+ case 0x3:
+ if (BITS(op,0x0007) == 0x0)
+ {
+ // ASR - 1mRR HHHW 0011 F000
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "asr %s", D) ;
+ retSize = 1 ;
+ }
+ else if (BITS(op,0x0007) == 0x1)
+ {
+/*
+ // ASL - 1mRR HHHW 0011 F001
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "asl %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0007) == 0x2)
+ {
+ // LSR - 1mRR HHHW 0011 F010
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "lsr %s", D) ;
+ retSize = 1 ;
+ }
+ else if (BITS(op,0x0007) == 0x3)
+ {
+/*
+ // LSL - 1mRR HHHW 0011 F011
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "lsl %s", D) ;
+ retSize = 1 ;
+*/ }
+ else
+ {
+ // EOR - 1mRR HHHW 0011 F1JJ
+ DecodeJJFTable(BITS(op,0x0003),BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "eor %s,%s", S1, D) ;
+ retSize = 1 ;
+ }
+ break ;
+
+ case 0x4:
+ if (BITS(op,0x0007) == 0x1)
+ {
+ // SUBL - 1mRR HHHW 0100 F001
+ // There's something strange about this opcode - there's only one option for F!
+/* if (!BITS(op,0x0008))
+ sprintf(buffer, "subl B,A") ;
+ else
+ sprintf(buffer, "subl (other!)") ;
+ retSize = 1 ;
+*/ }
+ else
+ {
+ // SUB - 1mRR HHHW 0100 FJJJ
+/* DecodeJJJFTable(BITS(op,0x0007), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "sub %s,%s", S1, D) ;
+ retSize = 1 ;
+*/ }
+ break ;
+
+ case 0x5:
+ if (BITS(op,0x0007) == 0x1)
+ {
+ // CLR24 - 1mRR HHHW 0101 F001
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "clr24 %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0006) == 0x1)
+ {
+ // SBC - 1mRR HHHW 0101 F01J
+/* DecodeJFTable(BITS(op,0x0001), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "sbc %s,%s", S1, D) ;
+ retSize = 1 ;
+*/ }
+ else
+ {
+ // CMP - 1mRR HHHW 0101 FJJJ
+ DecodeJJJFTable(BITS(op,0x0007), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "cmp %s,%s", S1,D) ;
+ retSize = 1 ;
+ }
+ break ;
+
+ case 0x6:
+ if (BITS(op,0x0007) == 0x0)
+ {
+ // NEG - 1mRR HHHW 0110 F000
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "neg %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0007) == 0x1)
+ {
+ // NOT - 1mRR HHHW 0110 F001
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "not %s", D) ;
+ retSize = 1 ;
+ }
+ else if (BITS(op,0x0007) == 0x2)
+ {
+ // DEC - 1mRR HHHW 0110 F010
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "dec %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0007) == 0x3)
+ {
+ // DEC24 - 1mRR HHHW 0110 F011
+ DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "dec24 %s", D) ;
+ retSize = 1 ;
+ }
+ else
+ {
+ // AND - 1mRR HHHW 0110 F1JJ
+ DecodeJJFTable(BITS(op,0x0003),BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "and %s,%s", S1, D) ;
+ retSize = 1 ;
+ }
+ break ;
+
+ case 0x7:
+ if (BITS(op,0x0007) == 0x1)
+ {
+ // ABS - 1mRR HHHW 0111 F001
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "abs %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0007) == 0x2)
+ {
+ // ROR - 1mRR HHHW 0111 F010
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "ror %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0007) == 0x3)
+ {
+ // ROL - 1mRR HHHW 0111 F011
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "rol %s", D) ;
+ retSize = 1 ;
+*/ }
+ else
+ {
+ // CMPM - 1mRR HHHW 0111 FJJJ
+/* DecodeJJJFTable(BITS(op,0x0007), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "cmpm %s,%s", S1,D) ;
+ retSize = 1 ;
+*/ }
+
+ break ;
+ }
+
+/*
+ // Otherwise you're looking at a MPY/MAC operation...
+ if (BITS(op,0x0080)) // Maybe i should un-consolidate here?
+ {
+ DecodeQQQFTable(BITS(op,0x0007), BITS(op,0x0008), S1, S2, D) ;
+ DecodekSignTable(BITS(op,0x0040), sign) ;
+
+ switch(BITS(op,0x00b0))
+ {
+ // MPY - 1mRR HHHH 1k00 FQQQ
+ case 0x4: sprintf(buffer, "mpy (%s)%s,%s,%s", sign, S2, S1, D) ; break ;
+
+ // MPYR - 1mRR HHHH 1k01 FQQQ
+ case 0x5: sprintf(buffer, "mpyr (%s)%s,%s,%s", sign, S2, S1, D) ; break ;
+
+ // MAC - 1mRR HHHH 1k10 FQQQ
+ case 0x6: sprintf(buffer, "mac (%s)%s,%s,%s", sign, S2, S1, D) ; break ;
+
+ // MACR - 1mRR HHHH 1k11 FQQQ
+ case 0x7: sprintf(buffer, "macr (%s)%s,%s,%s", sign, S1, S2, D) ; break ;
+ // !! It's a little odd that macr is S1,S2 while everyone else is S2,S1 !!
+ }
+
+ retSize = 1 ;
+ }
+*/
+
+// mame_printf_debug("op : %04x parallelType : %d\n", op, parallelType) ;
+
+ switch (parallelType)
+ {
+ case PARALLEL_TYPE_XMDM:
+ AppendXMDM(buffer, op) ;
+ break ;
+
+ case PARALLEL_TYPE_XMDM_SPECIAL:
+ AppendXMDMSpecial(buffer, op, D) ;
+ break ;
+
+ case PARALLEL_TYPE_NODM:
+ // Do Nothing :)...
+ break ;
+
+ case PARALLEL_TYPE_ARU:
+ AppendARU(buffer, op) ;
+ break ;
+
+ case PARALLEL_TYPE_RRDM:
+ AppendRRDM(buffer, op, D) ;
+ break ;
+ }
+
+ return retSize ;
+}
+
+
+#ifdef UNUSED_FUNCTION
+static unsigned DecodeDXMDROpcode(char *buffer, UINT16 op, unsigned pc)
+{
+ unsigned retSize = 0 ;
+
+ char S1[32] ;
+ char S2[32] ;
+ char D[32] ;
+ char arg[32] ;
+
+ if (!BITS(op,0x0080))
+ {
+ if (BITS(op,0x0014) != 0x2)
+ {
+ // ADD - 011m mKKK 0rru Fuuu
+ // SUB - 011m mKKK 0rru Fuuu
+ DecodeuuuuFTable(BITS(op,0x0013), BITS(op,0x0008), arg, S1, D) ;
+ sprintf(buffer, "%s %s,%s", arg, S1, D) ;
+ retSize = 1 ;
+ }
+ else if (BITS(op,0x0014) == 0x2)
+ {
+ // TFR - 011m mKKK 0rr1 F0DD
+ DecodeDDFTable(BITS(op,0x0003), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "tfr %s,%s", S1, D) ;
+ retSize = 1 ;
+
+ // MOVE - 011m mKKK 0rr1 0000
+ // !!! What? The opcode is .identical. to the TFR one. Wait, that makes sense, right?
+ }
+ }
+ else
+ {
+ switch (BITS(op,0x0014))
+ {
+ case 0x0:
+ // MPY - 011m mKKK 1xx0 F0QQ
+ // What the hell are those two x's : i bet they're supposed to be -'s?
+ DecodeQQFTable(BITS(op,0x0003), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "mpy %s,%s,%s", S1, S2, D) ;
+ retSize = 1 ;
+ break ;
+
+ case 0x1:
+ // MAC - 011m mKKK 1xx0 F1QQ
+ // What the hell are those two x's : i bet they're supposed to be -'s?
+ DecodeQQFTable(BITS(op,0x0003), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "mac %s,%s,%s", S1, S2, D) ;
+ retSize = 1 ;
+ break ;
+
+ case 0x2:
+ // MPYR - 011m mKKK 1--1 F0QQ
+ DecodeQQFTable(BITS(op,0x0003), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "mpyr %s,%s,%s", S1, S2, D) ;
+ retSize = 1 ;
+ break ;
+
+ case 0x3:
+ // MACR - 011m mKKK 1--1 F1QQ
+ DecodeQQFTable(BITS(op,0x0003), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "macr %s,%s,%s", S1, S2, D) ;
+ retSize = 1 ;
+ break ;
+ }
+ }
+
+ AppendDXMDR(buffer, op) ;
+
+ return retSize ;
+}
+#endif
+
+
+static unsigned DecodeNPMOpcode(char *buffer, UINT16 op, unsigned pc, const UINT8 *oprom)
+{
+ unsigned retSize = 0 ;
+
+ char S1[32] ;
+ char S2[32] ;
+ char SD[32] ;
+ char D[32] ;
+ char A[32] ;
+ char M[32] ;
+ char args[32] ;
+ int Rnum ;
+
+
+ if (BITS(op,0x0f00) == 0x4)
+ {
+ // Bitfield Immediate
+ int upperMiddleLower = -1 ;
+ UINT16 iVal = 0x0000 ;
+ UINT16 rVal = 0x0000 ;
+ char D[32] ;
+
+ UINT32 op2 = oprom[2] | (oprom[3] << 8);
+
+ // Decode the common parts
+ upperMiddleLower = DecodeBBBTable(BITS(op2,0xe000)) ;
+ iVal = BITS(op2,0x00ff) ;
+
+ switch(upperMiddleLower)
+ {
+ case BBB_UPPER: iVal <<= 8; break ;
+ case BBB_MIDDLE: iVal <<= 4; break ;
+ case BBB_LOWER: iVal <<= 0; break ;
+ }
+
+ switch(BITS(op,0x00e0))
+ {
+ case 0x6: case 0x7: case 0x2: case 0x3:
+ AssembleDFromPTable(BITS(op,0x0020), BITS(op,0x001f), D) ;
+ break ;
+
+ case 0x5: case 0x1:
+ // !! Probably want to combine this into something that returns a 'string'... !!
+ rVal = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(D, "X:(R%d)", rVal) ;
+ break ;
+
+ case 0x4: case 0x0:
+ DecodeDDDDDTable(BITS(op,0x001f), D) ;
+ break ;
+ }
+
+ switch(BITS(op2,0x1f00))
+ {
+ // !!! retsize = 2 put here for debugging help - put it at the end eventually...
+ case 0x12: sprintf(buffer, "bfchg #%04x,%s", iVal, D) ; retSize = 2 ; break ;
+ case 0x04: sprintf(buffer, "bfclr #%04x,%s", iVal, D) ; retSize = 2 ; break ;
+ case 0x18: sprintf(buffer, "bfset #%04x,%s", iVal, D) ; retSize = 2 ; break ;
+// case 0x10: sprintf(buffer, "bftsth #%04x,%s", iVal, D) ; retSize = 2 ; break ;
+ case 0x00: sprintf(buffer, "bftstl #%04x,%s", iVal, D) ; retSize = 2 ; break ;
+ }
+
+ // uncomment me someday
+// retSize = 2 ;
+ }
+ else if (BITS(op,0x0f00) == 0x5)
+ {
+ switch(BITS(op,0x0074))
+ {
+ case 0x0:
+ if (BITS(op,0x0006) == 0x0)
+ {
+ // TFR(2) - 0001 0101 0000 F00J
+/* DecodeJFTable(BITS(op,0x0001),BITS(op,0x0008), D, S1) ;
+ sprintf(buffer, "tfr2 %s,%s", S1, D) ;
+ retSize = 1 ;
+*/ // !?! Documentation bug !?!
+ // !!! the source and destination are backwards for TFR(2), and no mention of it is made !!!
+ }
+ else if (BITS(op,0x0006) == 0x1)
+ {
+ // ADC - 0001 0101 0000 F01J
+/* DecodeJFTable(BITS(op,0x0001),BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "adc %s,%s", S1, D) ;
+ retSize = 1 ;
+*/ }
+ break ;
+
+ case 0x3:
+ // TST(2) - 0001 0101 0001 -1DD
+ DecodeDDTable(BITS(op,0x0003), S1) ;
+ sprintf(buffer, "tst(2) %s", S1) ;
+ retSize = 1 ;
+ break ;
+
+ case 0x4:
+ // NORM - 0001 0101 0010 F0RR
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(buffer, "norm %s,R%d", S1, Rnum) ;
+ retSize = 1 ;
+*/ break ;
+
+ case 0x6:
+ if (BITS(op,0x0003) == 0x0)
+ {
+ // ASR4 - 0001 0101 0011 F000
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "asr4 %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0003) == 0x1)
+ {
+ // ASL4 - 0001 0101 0011 F001
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "asl4 %s", D) ;
+ retSize = 1 ;
+*/ }
+ break ;
+
+ case 0x1: case 0x5: case 0x9: case 0xd:
+ // DIV - 0001 0101 0--0 F1DD
+/* DecodeDDFTable(BITS(op,0x0003), BITS(op,0x0008), S1, D) ;
+ sprintf(buffer, "div %s,%s", S1, D) ;
+ retSize = 1 ;
+*/ break ;
+
+ case 0xa:
+ if (BITS(op,0x0003) == 0x0)
+ {
+ // ZERO - 0001 0101 0101 F000
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "zero %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0003) == 0x2)
+ {
+ // EXT - 0001 0101 0101 F010
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "ext %s", D) ;
+ retSize = 1 ;
+*/ }
+ break ;
+
+ case 0xc:
+ if (BITS(op,0x0003) == 0x0)
+ {
+ // NEGC - 0001 0101 0110 F000
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "negc %s", D) ;
+ retSize = 1 ;
+*/ }
+ break ;
+
+ case 0xe:
+ if (BITS(op,0x0003) == 0x0)
+ {
+ // ASR16 - 0001 0101 0111 F000
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "asr16 %s", D) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x0003) == 0x1)
+ {
+ // SWAP - 0001 0101 0111 F001
+/* DecodeFTable(BITS(op,0x0008), D) ;
+ sprintf(buffer, "swap %s", D) ;
+ retSize = 1 ;
+*/ }
+ break ;
+ }
+
+ switch(BITS(op,0x00f0))
+ {
+ case 0x8:
+ // IMPY - 0001 0101 1000 FQQQ
+/* DecodeQQQFTable(BITS(op,0x0007), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "impy %s,%s,%s", S1, S2, D) ;
+ retSize = 1 ;
+*/ break ;
+ case 0xa:
+ // IMAC - 0001 0101 1010 FQQQ
+/* DecodeQQQFTable(BITS(op,0x0007), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "imac %s,%s,%s", S1, S2, D) ;
+ retSize = 1 ;
+*/ break ;
+ case 0x9: case 0xb:
+ // DMAC(ss,su,uu) - 0001 0101 10s1 FsQQ
+/* DecodessTable(BITS(op,0x0024), A) ;
+ DecodeQQFTableSp(BITS(op,0x0003), BITS(op,0x0008), S2, S1, D) ; // Special QQF
+ sprintf(buffer, "dmac(%s) %s,%s,%s", A, S1, S2, D) ;
+ retSize = 1 ;
+*/ break ;
+ case 0xc:
+ // MPY(su,uu) - 0001 0101 1100 FsQQ
+/* DecodesTable(BITS(op,0x0004), A) ;
+ DecodeQQFTableSp(BITS(op,0x0003), BITS(op,0x0008), S2, S1, D) ; // Special QQF
+ sprintf(buffer, "mpy(%s) %s,%s,%s", A, S1, S2, D) ;
+ retSize = 1 ;
+*/ break ;
+ case 0xe:
+ // MAC(su,uu) - 0001 0101 1110 FsQQ
+ DecodesTable(BITS(op,0x0004), A) ;
+ DecodeQQFTableSp(BITS(op,0x0003), BITS(op,0x0008), S2, S1, D) ; // Special QQF
+ sprintf(buffer, "mac(%s) %s,%s,%s", A, S1, S2, D) ;
+ retSize = 1 ;
+ break ;
+ }
+ }
+ else if ((BITS(op,0x0f00) == 0x6))
+ {
+/*
+ char S[32] ;
+
+ // MPY - 0001 0110 RRDD FQQQ
+ DecodekTable(BITS(op,0x0100), Dnot) ;
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ DecodeDDTable(BITS(op,0x0030), S) ;
+ DecodeQQQFTable(BITS(op,0x0007), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "mpy %s,%s,%s %s,(R%d)+N%d %s,%s", S1, S2, D, Dnot, Rnum, Rnum, S, Dnot) ;
+ // Strange, but not entirely out of the question - this 'k' parameter is hardcoded
+ // I cheat here and do the parallel memory data move above - this specific one is only used twice
+ retSize = 1 ;
+*/ }
+ else if ((BITS(op,0x0f00) == 0x7))
+ {
+/*
+ char S[32] ;
+
+ // MAC - 0001 0111 RRDD FQQQ
+ DecodekTable(BITS(op,0x0100), Dnot) ;
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ DecodeDDTable(BITS(op,0x0030), S) ;
+ DecodeQQQFTable(BITS(op,0x0007), BITS(op,0x0008), S1, S2, D) ;
+ sprintf(buffer, "mac %s,%s,%s %s,(R%d)+N%d %s,%s", S1, S2, D, Dnot, Rnum, Rnum, S, Dnot) ;
+ // Strange, but not entirely out of the question - this 'k' parameter is hardcoded
+ // I cheat here and do the parallel memory data move above - this specific one is only used twice
+ retSize = 1 ;
+*/ }
+ else if ((BITS(op,0x0800) == 0x1))
+ {
+ if (BITS(op,0x0600))
+ {
+ if (!BITS(op,0x0100))
+ {
+ // ANDI - 0001 1EE0 iiii iiii
+ DecodeEETable(BITS(op,0x0600), D) ;
+ sprintf(buffer, "and(i) #%02x,%s", BITS(op,0x00ff), D) ;
+ retSize = 1 ;
+ }
+ else
+ {
+ // ORI - 0001 1EE1 iiii iiii
+/* DecodeEETable(BITS(op,0x0600), D) ;
+ sprintf(buffer, "or(i) #%02x,%s", BITS(op,0x00ff), D) ;
+ retSize = 1 ;
+*/ }
+ }
+ else
+ {
+ if (!BITS(op,0x0020))
+ {
+ // MOVE(S) - 0001 100W HH0a aaaa
+/*
+ DecodeHHTable(BITS(op,0x00c0), SD) ;
+ sprintf(A, "X:%02x", BITS(op,0x001f)) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'X', SD, A) ;
+ sprintf(buffer, "move(s) %s", args) ;
+ retSize = 1 ;
+*/ }
+ else
+ {
+ char fullAddy[128] ; // Convert Short Absolute Address to full 16-bit
+
+ // MOVE(P) - 0001 100W HH1p pppp
+ DecodeHHTable(BITS(op,0x00c0), SD) ;
+
+ AssembleAddressFromIOShortAddress(BITS(op,0x001f), fullAddy) ;
+
+ sprintf(A, "%02x (%s)", BITS(op,0x001f), fullAddy) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'X', SD, A) ;
+ sprintf(buffer, "move(p) %s", args) ;
+ retSize = 1 ;
+ }
+ }
+ }
+ else if ((BITS(op,0x0c00) == 0x0))
+ {
+ // T.cc - 0001 00cc ccTT Fh0h
+ DecodeccccTable(BITS(op,0x03c0), M) ;
+ Rnum = DecodeRRTable(BITS(op,0x0030)) ;
+ Decodeh0hFTable(BITS(op,0x0007),BITS(op,0x0008), S1, D) ;
+ if (S1[0] == D[0] && D[0] == 'A')
+ sprintf(buffer, "t.%s %s,%s", M, S1, D) ;
+ else
+ sprintf(buffer, "t.%s %s,%s R0,R%d", M, S1, D, Rnum) ;
+ // !! Might not be right - gotta' double-check !!
+ retSize = 1 ;
+ }
+
+ return retSize ;
+}
+
+
+unsigned DecodeMisfitOpcode(char *buffer, UINT16 op, unsigned pc, const UINT8 *oprom)
+{
+ unsigned retSize = 0 ;
+
+ char S1[32] ;
+ char D1[32] ;
+ char SD[32] ;
+ char M[32] ;
+ char ea[32] ;
+ char args[32] ;
+ int Rnum ;
+
+ if (BITS(op,0x1000)== 0x0)
+ {
+ switch(BITS(op,0x0c00))
+ {
+ // MOVE(I) - 0010 00DD BBBB BBBB
+ case 0x0:
+ DecodeDDTable(BITS(op,0x0300), D1) ;
+ sprintf(buffer, "move(i) #%02x,%s", BITS(op,0x00ff), D1) ;
+ retSize = 1 ;
+ break ;
+
+ // TFR(3) - 0010 01mW RRDD FHHH
+ case 0x1:
+/* DecodeDDFTable(BITS(op,0x0030), BITS(op,0x0008), D1, S1) ; // Intentionally switched
+ DecodeHHHTable(BITS(op,0x0007), SD) ;
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ AssembleeaFrommTable(BITS(op,0x0200), Rnum, ea) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'X', SD, ea) ;
+ sprintf(buffer, "tfr3 %s,%s %s", S1, D1, args) ;
+ retSize = 1 ;
+*/ break ;
+
+ // MOVE(C) - 0010 10dd dddD DDDD
+ case 0x2:
+ DecodeDDDDDTable(BITS(op,0x03e0), S1) ;
+ DecodeDDDDDTable(BITS(op,0x001f), D1) ;
+ sprintf(buffer, "move(c) %s,%s", S1, D1) ;
+ retSize = 1 ;
+ break ;
+
+ // B.cc - 0010 11cc ccee eeee
+ case 0x3:
+ DecodeccccTable(BITS(op,0x3c0), M) ;
+ AssembleAddressFrom6BitSignedRelativeShortAddress(BITS(op,0x003f), ea) ;
+ sprintf(buffer, "b.%s %s (%02x)", M, ea, BITS(op,0x003f)) ;
+ retSize = 1 ;
+ break ;
+ }
+ }
+ else
+ {
+ if (BITS(op,0x0010) == 0x0)
+ {
+ // MOVE(C) - 0011 1WDD DDD0 MMRR
+ DecodeDDDDDTable(BITS(op,0x03e0), SD) ;
+ Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ AssembleeaFromMMTable(BITS(op,0x000c), Rnum, ea) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0400), args, 'X', SD, ea) ;
+ sprintf(buffer, "move(c) %s", args) ;
+ retSize = 1 ;
+ }
+ else
+ {
+ if (BITS(op,0x0004) == 0x0)
+ {
+ // MOVE(C) - 0011 1WDD DDD1 q0RR
+ DecodeDDDDDTable(BITS(op,0x03e0), SD) ;
+ Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ AssembleeaFromqTable(BITS(op,0x0008), Rnum, ea) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0400), args, 'X', SD, ea) ;
+ sprintf(buffer, "move(c) %s", args) ;
+ retSize = 1 ;
+ }
+ else
+ {
+ switch(BITS(op,0x0006))
+ {
+ // MOVE(C) - 0011 1WDD DDD1 t10- xxxx xxxx xxxx xxxx
+ case 0x2:
+ DecodeDDDDDTable(BITS(op,0x03e0), SD) ;
+ AssembleeaFromtTable(BITS(op,0x0008), oprom[2] | (oprom[3] << 8), ea) ;
+ // !!! I'm pretty sure this is in the right order - same issue as the WTables !!!
+ if (BITS(op,0x0400)) // fixed - 02/03/05
+ sprintf(args, "%s,%s", ea, SD) ;
+ else
+ sprintf(args, "%s,%s", SD, ea) ;
+ sprintf(buffer, "move(c) %s", args) ;
+ retSize = 2 ;
+ break ;
+
+ // MOVE(C) - 0011 1WDD DDD1 Z11-
+ case 0x3:
+ DecodeDDDDDTable(BITS(op,0x03e0), SD) ;
+ DecodeZTable(BITS(op,0x0008), ea) ; // Fixed - 11/26/06
+ AssembleArgumentsFromWTable(BITS(op,0x0400), args, 'X', SD, ea) ;
+ sprintf(buffer, "move(c) %s", args) ;
+ retSize = 1 ;
+ break ;
+ }
+ }
+ }
+ }
+
+ return retSize ;
+}
+
+
+static unsigned DecodeSpecialOpcode(char *buffer, UINT16 op, unsigned pc, const UINT8 *oprom)
+{
+ unsigned retSize = 0 ;
+
+ char S1[32] ;
+ char SD[32] ;
+ char M[32] ;
+ char args[32] ;
+ char ea[32] ;
+ int Rnum ;
+
+ if (BITS(op,0x0ff0) == 0x0)
+ {
+ switch (BITS(op,0x000f))
+ {
+ // NOP - 0000 0000 0000 0000
+ case 0x0:
+ sprintf(buffer, "nop") ;
+ retSize = 1 ;
+ break ;
+
+ // Debug - 0000 0000 0000 0001
+ case 0x1:
+/* sprintf(buffer, "debug") ;
+ retSize = 1 ;
+*/ break ;
+
+ // DO FOREVER - 0000 0000 0000 0010 xxxx xxxx xxxx xxxx
+ case 0x2:
+ sprintf(buffer, "doForever %04x", oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+ break ;
+
+ // chkaau - 0000 0000 0000 0100
+ case 0x4:
+/* sprintf(buffer, "chkaau") ;
+ retSize = 1 ;
+*/ break ;
+
+ // SWI - 0000 0000 0000 0101
+ case 0x5:
+/* sprintf(buffer, "swi") ;
+ retSize = 1 ;
+*/ break ;
+
+ // RTS - 0000 0000 0000 0110
+ case 0x6:
+ sprintf(buffer, "rts") ;
+ retSize = 1 | DASMFLAG_STEP_OUT;
+ break ;
+
+ // RTI - 0000 0000 0000 0111
+ case 0x7:
+ sprintf(buffer, "rti") ;
+ retSize = 1 | DASMFLAG_STEP_OUT;
+ break ;
+
+ // RESET - 0000 0000 0000 1000
+ case 0x8:
+/* sprintf(buffer, "reset") ;
+ retSize = 1 ;
+*/ break ;
+
+ // Enddo - 0000 0000 0000 1001
+ case 0x9:
+/* sprintf(buffer, "endDo") ;
+ retSize = 1 ;
+*/ break ;
+
+ // STOP - 0000 0000 0000 1010
+ case 0xa:
+/* sprintf(buffer, "stop") ;
+ retSize = 1 ;
+*/ break ;
+
+ // WAIT - 0000 0000 0000 1011
+ case 0xb:
+/* sprintf(buffer, "wait") ;
+ retSize = 1 ;
+*/ break ;
+
+ // ILLEGAL - 0000 0000 0000 1111
+ case 0xf:
+/* sprintf(buffer, "illegal") ;
+ retSize = 1 ;
+*/ break ;
+
+ }
+ }
+ else if (BITS(op,0x0f00) == 0x0)
+ {
+ switch(BITS(op,0x00e0))
+ {
+ case 0x2:
+ // DEBUG.cc - 0000 0000 0101 cccc
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ sprintf(buffer, "debug.%s", M) ;
+ retSize = 1 ;
+*/ break ;
+
+ case 0x6:
+ // DO - 0000 0000 110- --RR xxxx xxxx xxxx xxxx
+/* Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(buffer, "do X:(R%d),%02x", Rnum, oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+*/ break ;
+
+ case 0x7:
+ // REP - 0000 0000 111- --RR
+/* Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(buffer, "rep X:(R%d)", Rnum) ;
+ retSize = 1 ;
+*/ break ;
+ }
+ }
+ else if (BITS(op,0x0f00) == 0x1)
+ {
+ if (BITS(op,0x00f0) == 0x1)
+ {
+ // BRK.cc - 0000 0001 0001 cccc
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ sprintf(buffer, "brk.%s", M) ;
+ retSize = 1 ;
+*/ }
+ else if (BITS(op,0x00f0) == 0x2)
+ {
+ switch(BITS(op,0x000c)) // Consolidation can happen here
+ {
+ // JSR - 0000 0001 0010 00RR
+ case 0x0:
+/* Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(buffer, "jsr R%d", Rnum) ;
+ retSize = 1 ; // I think aaron guessed incorrectly? | DASMFLAG_STEP_OVER;
+*/ break ;
+
+ // JMP - 0000 0001 0010 01RR
+ case 0x1:
+ Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(buffer, "jmp R%d", Rnum) ;
+ retSize = 1 ;
+ break ;
+
+ // BSR - 0000 0001 0010 10RR
+ case 0x2:
+/* Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(buffer, "bsr R%d", Rnum) ;
+ retSize = 1 | DASMFLAG_STEP_OVER;
+*/ break ;
+
+ // BRA - 0000 0001 0010 11RR
+ case 0x3:
+/* Rnum = DecodeRRTable(BITS(op,0x0003)) ;
+ sprintf(buffer, "bra R%d", Rnum) ;
+ retSize = 1 ;
+*/ break ;
+ }
+ }
+ else if (BITS(op,0x00f0) == 0x3)
+ {
+ switch(BITS(op,0x000c))
+ {
+ // JSR - 0000 0001 0011 00-- xxxx xxxx xxxx xxxx
+ case 0x0:
+ sprintf(buffer, "jsr %04x", oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 | DASMFLAG_STEP_OVER;
+ break ;
+
+ // JMP - 0000 0001 0011 01-- xxxx xxxx xxxx xxxx
+ case 0x1:
+ sprintf(buffer, "jmp %04x", oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+ break ;
+
+ // BSR - 0000 0001 0011 10-- xxxx xxxx xxxx xxxx
+ case 0x2:
+ sprintf(buffer, "bsr %d (0x%04x)", oprom[2] | (oprom[3] << 8), oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 | DASMFLAG_STEP_OVER;
+ break ;
+
+ // BRA - 0000 0001 0011 11-- xxxx xxxx xxxx xxxx
+ case 0x3:
+/* sprintf(buffer, "bra %d (%04x)", oprom[2] | (oprom[3] << 8), oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+*/ break ;
+ }
+ }
+ else if (BITS(op,0x00f0) == 0x5)
+ {
+ // REP.cc - 0000 0001 0101 cccc
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ sprintf(buffer, "rep.%s", M) ;
+ retSize = 1 ;
+*/ // !!! Should I decode the next instruction and put it here ??? probably...
+ }
+ else if (BITS(op,0x0080) == 0x1)
+ {
+ // LEA - 0000 0001 10TT MMRR - 0000 0001 11NN MMRR
+/* Rnum = DecodeRRTable(BITS(op,0x0030)) ;
+ AssembleeaFromMMTable(BITS(op,0x000c), BITS(op,0x0003), ea) ;
+ if (BITS(op,0x0040))
+ sprintf(buffer, "lea %s,R%d", ea, Rnum) ;
+ else
+ sprintf(buffer, "lea %s,N%d", ea, Rnum) ;
+ retSize = 1 ;
+*/ }
+ }
+ else if (BITS(op,0x0e00) == 0x1)
+ {
+
+ if (BITS(op,0x0020) == 0x0)
+ {
+ // MOVE(M) - 0000 001W RR0M MHHH
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ DecodeHHHTable(BITS(op,0x0007), SD) ;
+ AssembleeaFromMMTable(BITS(op,0x0018), Rnum, ea) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'P', SD, ea) ;
+ sprintf(buffer, "move(m) %s", args) ;
+ // !!! The docs list the read/write order backwards for all move(m)'s - crackbabies ???
+ retSize = 1 ;
+ }
+ else
+ {
+ // MOVE(M) - 0000 001W RR11 mmRR
+/* AssembleeaFrommmTable(BITS(op,0x000c), BITS(op,0x00c0), BITS(op,0x0003), ea, ea2) ;
+ sprintf(SD, "P:%s", ea) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'X', SD, ea2) ;
+ // !!! The docs list the read/write order backwards for all move(m)'s - crackbabies ???
+ sprintf(buffer, "move(m) %s", args) ;
+ retSize = 1 ;
+*/ }
+ }
+ else if (BITS(op,0x0f00) == 0x4)
+ {
+ if (BITS(op,0x0020) == 0x0)
+ {
+ // DO - 0000 0100 000D DDDD xxxx xxxx xxxx xxxx
+ DecodeDDDDDTable(BITS(op,0x001f), S1) ;
+ sprintf(buffer, "do %s,%04x", S1, oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+ }
+ else
+ {
+ // REP - 0000 0100 001D DDDD
+ DecodeDDDDDTable(BITS(op,0x001f), S1) ;
+ sprintf(buffer, "rep %s", S1) ;
+ retSize = 1 ;
+ }
+ }
+ else if (BITS(op,0x0f00) == 0x5)
+ {
+ UINT8 B ;
+ UINT16 op2 = oprom[2] | (oprom[3] << 8) ;
+
+ if (BITS(op2,0xfe20) == 0x02)
+ {
+ // MOVE(M) - 0000 0101 BBBB BBBB | 0000 001W --0- -HHH
+ B = BITS(op,0x00ff) ;
+ DecodeHHHTable(BITS(op2,0x0007), SD) ;
+ AssembleRegFromWTable(BITS(op2,0x0100), args, 'P', SD, B) ;
+ sprintf(buffer, "move(m) %s", args) ;
+ // !!! The docs list the read/write order backwards for all move(m)'s - crackbabies ???
+ retSize = 2 ;
+ }
+ else if (BITS(op2,0xf810) == 0x0e)
+ {
+ // MOVE(C) - 0000 0101 BBBB BBBB | 0011 1WDD DDD0 ----
+/* B = BITS(op,0x00ff) ;
+ DecodeDDDDDTable(BITS(op2,0x03e0), SD) ;
+ AssembleRegFromWTable(BITS(op2,0x0400), args, 'X', SD, B) ;
+ sprintf(buffer, "move(c) %s", args) ;
+ retSize = 2 ;
+*/ }
+ else if (BITS(op2,0x00ff) == 0x11)
+ {
+ // MOVE - 0000 0101 BBBB BBBB | ---- HHHW 0001 0001
+/* B = BITS(op,0x00ff) ;
+ DecodeHHHTable(BITS(op2,0x0e00), SD) ;
+ AssembleRegFromWTable(BITS(op2,0x0100), args, 'X', SD, B) ;
+ sprintf(buffer, "move %s", args) ;
+ retSize = 2 ;
+*/ }
+ }
+ else if (BITS(op,0x0f00) == 0x6)
+ {
+ switch(BITS(op,0x0030))
+ {
+ case 0x0:
+ // JS.cc - 0000 0110 RR00 cccc
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ sprintf(buffer, "js.%s R%d\n", M, Rnum) ;
+ retSize = 1 ;
+*/ break ;
+
+ case 0x1:
+ // JS.cc - 0000 0110 --01 cccc xxxx xxxx xxxx xxxx
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ sprintf(buffer, "js.%s %04x", M, oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+*/ break ;
+
+ case 0x2:
+ // J.cc - 0000 0110 RR10 cccc
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ sprintf(buffer, "j.%s R%d", M, Rnum) ;
+ retSize = 1 ;
+*/ break ;
+
+ case 0x3:
+ // J.cc - 0000 0110 --11 cccc xxxx xxxx xxxx xxxx
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ sprintf(buffer, "j.%s %04x", M, oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+*/ break ;
+ }
+ }
+ else if (BITS(op,0x0f00) == 0x7)
+ {
+ switch(BITS(op,0x0030))
+ {
+ case 0x0:
+ // BS.cc - 0000 0111 RR00 cccc
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ sprintf(buffer, "bs.%s R%d\n", M, Rnum) ;
+ retSize = 1 ;
+*/ break ;
+
+ case 0x1:
+ // BS.cc - 0000 0111 --01 cccc xxxx xxxx xxxx xxxx
+ DecodeccccTable(BITS(op,0x000f), M) ;
+ sprintf(buffer, "bs.%s %d (0x%04x)", M, (INT16)(oprom[2] | (oprom[3] << 8)), oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+ break ;
+
+ case 0x2:
+ // B.cc - 0000 0111 RR10 cccc
+/* DecodeccccTable(BITS(op,0x000f), M) ;
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ sprintf(buffer, "b.%s R%d", M, Rnum) ;
+ retSize = 1 ;
+*/ break ;
+
+ case 0x3:
+ // B.cc - 0000 0111 --11 cccc xxxx xxxx xxxx xxxx
+ DecodeccccTable(BITS(op,0x000f), M) ;
+ sprintf(buffer, "b.%s %04x (%d)", M, oprom[2] | (oprom[3] << 8), oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+ break ;
+ }
+ }
+ else if (BITS(op,0x0800))
+ {
+ switch (BITS(op,0x0700))
+ {
+ // JSR - 0000 1010 AAAA AAAA
+ case 0x2:
+/* sprintf(buffer, "jsr %02x", BITS(op,0x00ff)) ;
+ retSize = 1 ;
+*/ break ;
+
+ // BRA - 0000 1011 aaaa aaaa
+ case 0x3:
+ sprintf(buffer, "bra %d (0x%02x)", (INT8)BITS(op,0x00ff), BITS(op,0x00ff)) ;
+ retSize = 1 ;
+ break ;
+
+ // MOVE(P) - 0000 110W RRmp pppp
+ case 0x4: case 0x5:
+ {
+ char fullAddy[128] ; // Convert Short Absolute Address to full 16-bit
+ Rnum = DecodeRRTable(BITS(op,0x00c0)) ;
+ AssembleeaFrommTable(BITS(op,0x0020), Rnum, ea) ;
+
+ AssembleAddressFromIOShortAddress(BITS(op,0x001f), fullAddy) ;
+
+ sprintf(SD, "X:%02x (%s)", BITS(op,0x001f), fullAddy) ;
+
+ // !! order (pretty sure pp is S/D in the docs) !!
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'X', SD, ea) ;
+ sprintf(buffer, "move(p) %s", args) ;
+ retSize = 1 ;
+ break ;
+ }
+
+ // DO - 0000 1110 iiii iiii xxxx xxxx xxxx xxxx
+ case 0x6:
+ sprintf(buffer, "do #%02x,%04x", BITS(op,0x00ff), oprom[2] | (oprom[3] << 8)) ;
+ retSize = 2 ;
+ break ;
+
+ // REP - 0000 1111 iiii iiii
+ case 0x7:
+ sprintf(buffer, "rep #%02x", BITS(op,0x00ff)) ;
+ retSize = 1 ;
+ break ;
+ }
+ }
+
+ return retSize ;
+}
+
+
+
+
+
+////////////////////////////////////////
+// PARALLEL MEMORY OPERATION DECODING //
+////////////////////////////////////////
+
+static void AppendXMDM(char *buffer, UINT16 op)
+{
+ int Rnum ;
+ char SD[32] ;
+ char ea[32] ;
+ char args[32] ;
+
+ // 1mRR HHHW ---- ----
+ Rnum = DecodeRRTable(BITS(op,0x3000)) ;
+ DecodeHHHTable(BITS(op,0x0e00), SD) ;
+ AssembleeaFrommTable(BITS(op,0x4000), Rnum, ea) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'X', SD, ea) ;
+
+ strcat(buffer, " ") ;
+ strcat(buffer, args) ;
+}
+
+// !!! NOT FULLY IMPLEMENTED !!!
+static void AppendXMDMSpecial(char *buffer, UINT16 op, char *working)
+{
+ // This is actually a little tricky 'cuz X:(F1) comes from the 'Data ALU' operation...
+ // (page 326 of the family manual)
+
+ // !! Also, p326 mentions 'F1' is the upper word of the accumulator which is not used by the parallel data ALU operation
+ // (in case of no Data ALU operation, A1 is chosen as F)
+ // my question is : when is there .not. a Data ALU operation ??
+
+ char SD[32] ;
+ char args[32] ;
+ char dest[32] ;
+
+ if (working[0] == 'B')
+ sprintf(dest, "(A1)") ;
+ else if (working[0] == 'A')
+ sprintf(dest, "(B1)") ;
+ else
+ sprintf(dest, "(wtf)") ;
+
+ DecodeHHHTable(BITS(op,0x0e00), SD) ;
+ AssembleArgumentsFromWTable(BITS(op,0x0100), args, 'X', SD, dest) ;
+
+ strcat(buffer, " ") ;
+ strcat(buffer, args) ;
+}
+
+static void AppendARU(char *buffer, UINT16 op)
+{
+ char ea[32] ;
+ int rr = DecodeRRTable(BITS(op,0x0300)) ;
+
+ AssembleeaFromzTable(BITS(op,0x0400), rr, ea) ;
+
+ strcat(buffer, ea) ;
+}
+
+static void AppendRRDM(char *buffer, UINT16 op, char *working)
+{
+ char S[32], D[32] ;
+ char final[128] ;
+
+ DecodeIIIITable(BITS(op,0x0f00), S, D) ;
+
+ if (D[0] == '^')
+ {
+ if (working[0] == 'B')
+ sprintf(D, "A") ;
+ else if (working[0] == 'A')
+ sprintf(D, "B") ;
+ else
+ sprintf(D, "(wtf)") ;
+ }
+
+ if (S[0] == 'F')
+ {
+ sprintf(S, "%s", working) ;
+ }
+
+ sprintf(final, "%s,%s", S, D) ;
+
+ strcat(buffer, " ") ;
+ strcat(buffer, final) ;
+}
+
+#ifdef UNUSED_FUNCTION
+static void AppendDXMDR(char *buffer, UINT16 op)
+{
+ char D1[32] ;
+ char D2[32] ;
+ char ea1[32] ;
+ char ea2[32] ;
+ int Rnum ;
+
+ char temp[128] ;
+
+ // 011m mKKK -rr- ----
+ Rnum = BITS(op,0x0060) ;
+ DecodeKKKTable(BITS(op,0x0700), D1, D2) ;
+ AssembleeaFrommmTable(BITS(op,0x1800), Rnum, 3, ea1, ea2) ;
+
+ sprintf(temp, " X:%s,%s X:%s,%s", ea1, D1, ea2, D2) ;
+ strcat(buffer, temp) ;
+}
+#endif
+
+
+
+/////////////////////////////
+// TABLE DECODER FUNCTIONS //
+/////////////////////////////
+
+static int DecodeBBBTable(UINT16 BBB)
+{
+ switch(BBB)
+ {
+ case 0x4: return BBB_UPPER ; break ;
+ case 0x2: return BBB_MIDDLE ; break ;
+ case 0x1: return BBB_LOWER ; break ;
+ }
+
+ return BBB_LOWER ; // Not really safe...
+}
+
+static void DecodeccccTable(UINT16 cccc, char *mnemonic)
+{
+ switch (cccc)
+ {
+ case 0x0: sprintf(mnemonic, "cc(hs)") ; break ;
+ case 0x1: sprintf(mnemonic, "ge ") ; break ;
+ case 0x2: sprintf(mnemonic, "ne ") ; break ;
+ case 0x3: sprintf(mnemonic, "pl ") ; break ;
+ case 0x4: sprintf(mnemonic, "nn ") ; break ;
+ case 0x5: sprintf(mnemonic, "ec ") ; break ;
+ case 0x6: sprintf(mnemonic, "lc ") ; break ;
+ case 0x7: sprintf(mnemonic, "gt ") ; break ;
+ case 0x8: sprintf(mnemonic, "cs(lo)") ; break ;
+ case 0x9: sprintf(mnemonic, "lt ") ; break ;
+ case 0xa: sprintf(mnemonic, "eq ") ; break ;
+ case 0xb: sprintf(mnemonic, "mi ") ; break ;
+ case 0xc: sprintf(mnemonic, "nr ") ; break ;
+ case 0xd: sprintf(mnemonic, "es ") ; break ;
+ case 0xe: sprintf(mnemonic, "ls ") ; break ;
+ case 0xf: sprintf(mnemonic, "le ") ; break ;
+ }
+}
+
+static void DecodeDDDDDTable(UINT16 DDDDD, char *SD)
+{
+ switch(DDDDD)
+ {
+ case 0x00: sprintf(SD, "X0") ; break ;
+ case 0x01: sprintf(SD, "Y0") ; break ;
+ case 0x02: sprintf(SD, "X1") ; break ;
+ case 0x03: sprintf(SD, "Y1") ; break ;
+ case 0x04: sprintf(SD, "A") ; break ;
+ case 0x05: sprintf(SD, "B") ; break ;
+ case 0x06: sprintf(SD, "A0") ; break ;
+ case 0x07: sprintf(SD, "B0") ; break ;
+ case 0x08: sprintf(SD, "LC") ; break ;
+ case 0x09: sprintf(SD, "SR") ; break ;
+ case 0x0a: sprintf(SD, "OMR") ; break ;
+ case 0x0b: sprintf(SD, "SP") ; break ;
+ case 0x0c: sprintf(SD, "A1") ; break ;
+ case 0x0d: sprintf(SD, "B1") ; break ;
+ case 0x0e: sprintf(SD, "A2") ; break ;
+ case 0x0f: sprintf(SD, "B2") ; break ;
+
+ case 0x10: sprintf(SD, "R0") ; break ;
+ case 0x11: sprintf(SD, "R1") ; break ;
+ case 0x12: sprintf(SD, "R2") ; break ;
+ case 0x13: sprintf(SD, "R3") ; break ;
+ case 0x14: sprintf(SD, "M0") ; break ;
+ case 0x15: sprintf(SD, "M1") ; break ;
+ case 0x16: sprintf(SD, "M2") ; break ;
+ case 0x17: sprintf(SD, "M3") ; break ;
+ case 0x18: sprintf(SD, "SSH") ; break ;
+ case 0x19: sprintf(SD, "SSL") ; break ;
+ case 0x1a: sprintf(SD, "LA") ; break ;
+ //no 0x1b
+ case 0x1c: sprintf(SD, "N0") ; break ;
+ case 0x1d: sprintf(SD, "N1") ; break ;
+ case 0x1e: sprintf(SD, "N2") ; break ;
+ case 0x1f: sprintf(SD, "N3") ; break ;
+ }
+}
+
+static void DecodeDDTable(UINT16 DD, char *SD)
+{
+ switch (DD)
+ {
+ case 0x0: sprintf(SD, "X0") ; break ;
+ case 0x1: sprintf(SD, "Y0") ; break ;
+ case 0x2: sprintf(SD, "X1") ; break ;
+ case 0x3: sprintf(SD, "Y1") ; break ;
+ }
+}
+
+#ifdef UNUSED_FUNCTION
+static void DecodeDDFTable(UINT16 DD, UINT16 F, char *S, char *D)
+{
+ UINT16 switchVal = (DD << 1) | F ;
+
+ switch (switchVal)
+ {
+ case 0x0: sprintf(S, "X0") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S, "X0") ; sprintf(D, "B") ; break ;
+ case 0x2: sprintf(S, "Y0") ; sprintf(D, "A") ; break ;
+ case 0x3: sprintf(S, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x4: sprintf(S, "X1") ; sprintf(D, "A") ; break ;
+ case 0x5: sprintf(S, "X1") ; sprintf(D, "B") ; break ;
+ case 0x6: sprintf(S, "Y1") ; sprintf(D, "A") ; break ;
+ case 0x7: sprintf(S, "Y1") ; sprintf(D, "B") ; break ;
+ }
+}
+#endif
+
+static void DecodeEETable(UINT16 EE, char *D)
+{
+ switch(EE)
+ {
+ case 0x1: sprintf(D, "MR") ; break ;
+ case 0x3: sprintf(D, "CCR") ; break ;
+ case 0x2: sprintf(D, "OMR") ; break ;
+ }
+}
+
+static void DecodeFTable(UINT16 F, char *SD)
+{
+ switch(F)
+ {
+ case 0x0: sprintf(SD, "A") ; break ;
+ case 0x1: sprintf(SD, "B") ; break ;
+ }
+}
+
+static void Decodeh0hFTable(UINT16 h0h, UINT16 F, char *S, char *D)
+{
+ UINT16 switchVal = (h0h << 1) | F ;
+
+ switch (switchVal)
+ {
+ case 0x8: sprintf(S, "X0") ; sprintf(D, "A") ; break ;
+ case 0x9: sprintf(S, "X0") ; sprintf(D, "B") ; break ;
+ case 0xa: sprintf(S, "Y0") ; sprintf(D, "A") ; break ;
+ case 0xb: sprintf(S, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x2: sprintf(S, "A") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S, "A") ; sprintf(D, "B") ; break ;
+ case 0x0: sprintf(S, "B") ; sprintf(D, "A") ; break ;
+ case 0x3: sprintf(S, "B") ; sprintf(D, "B") ; break ;
+ }
+}
+
+static void DecodeHHTable(UINT16 HH, char *SD)
+{
+ switch(HH)
+ {
+ case 0x0: sprintf(SD, "X0") ; break ;
+ case 0x1: sprintf(SD, "Y0") ; break ;
+ case 0x2: sprintf(SD, "A") ; break ;
+ case 0x3: sprintf(SD, "B") ; break ;
+ }
+}
+
+static void DecodeHHHTable(UINT16 HHH, char *SD)
+{
+ switch(HHH)
+ {
+ case 0x0: sprintf(SD, "X0") ; break ;
+ case 0x1: sprintf(SD, "Y0") ; break ;
+ case 0x2: sprintf(SD, "X1") ; break ;
+ case 0x3: sprintf(SD, "Y1") ; break ;
+ case 0x4: sprintf(SD, "A") ; break ;
+ case 0x5: sprintf(SD, "B") ; break ;
+ case 0x6: sprintf(SD, "A0") ; break ;
+ case 0x7: sprintf(SD, "B0") ; break ;
+ }
+}
+
+// I don't know if this is ever used?
+static void DecodeIIIITable(UINT16 IIII, char *S, char *D)
+{
+ switch(IIII)
+ {
+ case 0x0: sprintf(S, "X0") ; sprintf(D, "^F^") ; break ;
+ case 0x1: sprintf(S, "Y0") ; sprintf(D, "^F^") ; break ;
+ case 0x2: sprintf(S, "X1") ; sprintf(D, "^F^") ; break ;
+ case 0x3: sprintf(S, "Y1") ; sprintf(D, "^F^") ; break ;
+ case 0x4: sprintf(S, "A") ; sprintf(D, "X0") ; break ;
+ case 0x5: sprintf(S, "B") ; sprintf(D, "Y0") ; break ;
+ case 0x6: sprintf(S, "A0") ; sprintf(D, "X0") ; break ;
+ case 0x7: sprintf(S, "B0") ; sprintf(D, "Y0") ; break ;
+ case 0x8: sprintf(S, "F") ; sprintf(D, "^F^") ; break ;
+ case 0x9: sprintf(S, "F") ; sprintf(D, "^F^") ; break ;
+ case 0xc: sprintf(S, "A") ; sprintf(D, "X1") ; break ;
+ case 0xd: sprintf(S, "B") ; sprintf(D, "Y1") ; break ;
+ case 0xe: sprintf(S, "A0") ; sprintf(D, "X1") ; break ;
+ case 0xf: sprintf(S, "B0") ; sprintf(D, "Y1") ; break ;
+ }
+}
+
+static void DecodeJJJFTable(UINT16 JJJ, UINT16 F, char *S, char *D)
+{
+ UINT16 switchVal = (JJJ << 1) | F ;
+
+ switch(switchVal)
+ {
+ case 0x0: sprintf(S, "B") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S, "A") ; sprintf(D, "B") ; break ;
+ case 0x4: sprintf(S, "X") ; sprintf(D, "A") ; break ;
+ case 0x5: sprintf(S, "X") ; sprintf(D, "B") ; break ;
+ case 0x6: sprintf(S, "Y") ; sprintf(D, "A") ; break ;
+ case 0x7: sprintf(S, "Y") ; sprintf(D, "B") ; break ;
+ case 0x8: sprintf(S, "X0") ; sprintf(D, "A") ; break ;
+ case 0x9: sprintf(S, "X0") ; sprintf(D, "B") ; break ;
+ case 0xa: sprintf(S, "Y0") ; sprintf(D, "A") ; break ;
+ case 0xb: sprintf(S, "Y0") ; sprintf(D, "B") ; break ;
+ case 0xc: sprintf(S, "X1") ; sprintf(D, "A") ; break ;
+ case 0xd: sprintf(S, "X1") ; sprintf(D, "B") ; break ;
+ case 0xe: sprintf(S, "Y1") ; sprintf(D, "A") ; break ;
+ case 0xf: sprintf(S, "Y1") ; sprintf(D, "B") ; break ;
+ }
+}
+
+static void DecodeJJFTable(UINT16 JJ, UINT16 F, char *S, char *D)
+{
+ UINT16 switchVal = (JJ << 1) | F ;
+
+ switch (switchVal)
+ {
+ case 0x0: sprintf(S, "X0") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S, "X0") ; sprintf(D, "B") ; break ;
+ case 0x2: sprintf(S, "Y0") ; sprintf(D, "A") ; break ;
+ case 0x3: sprintf(S, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x4: sprintf(S, "X1") ; sprintf(D, "A") ; break ;
+ case 0x5: sprintf(S, "X1") ; sprintf(D, "B") ; break ;
+ case 0x6: sprintf(S, "Y1") ; sprintf(D, "A") ; break ;
+ case 0x7: sprintf(S, "Y1") ; sprintf(D, "B") ; break ;
+ }
+}
+
+#ifdef UNUSED_FUNCTION
+static void DecodeJFTable(UINT16 J, UINT16 F, char *S, char *D)
+{
+ UINT16 switchVal = (J << 1) | F ;
+
+ switch(switchVal)
+ {
+ case 0x0: sprintf(S, "X") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S, "X") ; sprintf(D, "B") ; break ;
+ case 0x2: sprintf(S, "Y") ; sprintf(D, "A") ; break ;
+ case 0x3: sprintf(S, "Y") ; sprintf(D, "B") ; break ;
+ }
+}
+
+static void DecodekTable(UINT16 k, char *Dnot)
+{
+ switch(k)
+ {
+ case 0x0: sprintf(Dnot, "B") ; break ;
+ case 0x1: sprintf(Dnot, "A") ; break ;
+ }
+}
+
+static void DecodekSignTable(UINT16 k, char *plusMinus)
+{
+ switch(k)
+ {
+ case 0x0: sprintf(plusMinus, "+") ; break ;
+ case 0x1: sprintf(plusMinus, "-") ; break ;
+ }
+}
+
+static void DecodeKKKTable (UINT16 KKK, char *D1, char *D2)
+{
+ switch(KKK)
+ {
+ case 0x0: sprintf(D1, "^F^") ; sprintf(D2, "X0") ; break ;
+ case 0x1: sprintf(D1, "Y0") ; sprintf(D2, "X0") ; break ;
+ case 0x2: sprintf(D1, "X1") ; sprintf(D2, "X0") ; break ;
+ case 0x3: sprintf(D1, "Y1") ; sprintf(D2, "X0") ; break ;
+ case 0x4: sprintf(D1, "X0") ; sprintf(D2, "X1") ; break ;
+ case 0x5: sprintf(D1, "Y0") ; sprintf(D2, "X1") ; break ;
+ case 0x6: sprintf(D1, "^F^") ; sprintf(D2, "Y0") ; break ;
+ case 0x7: sprintf(D1, "Y1") ; sprintf(D2, "X1") ; break ;
+ }
+}
+
+static int DecodeNNTable(UINT16 NN)
+{
+ return NN ;
+}
+
+static void DecodeQQFTable(UINT16 QQ, UINT16 F, char *S1, char *S2, char *D)
+{
+ UINT16 switchVal = (QQ << 1) | F ;
+
+ switch(switchVal)
+ {
+ case 0x0: sprintf(S1, "X0") ; sprintf(S2, "Y0") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S1, "X0") ; sprintf(S2, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x2: sprintf(S1, "X0") ; sprintf(S2, "Y1") ; sprintf(D, "A") ; break ;
+ case 0x3: sprintf(S1, "X0") ; sprintf(S2, "Y1") ; sprintf(D, "B") ; break ;
+ case 0x4: sprintf(S1, "X1") ; sprintf(S2, "Y0") ; sprintf(D, "A") ; break ;
+ case 0x5: sprintf(S1, "X1") ; sprintf(S2, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x6: sprintf(S1, "X1") ; sprintf(S2, "Y1") ; sprintf(D, "A") ; break ;
+ case 0x7: sprintf(S1, "X1") ; sprintf(S2, "Y1") ; sprintf(D, "B") ; break ;
+ }
+}
+#endif
+
+static void DecodeQQFTableSp(UINT16 QQ, UINT16 F, char *S1, char *S2, char *D)
+{
+ UINT16 switchVal = (QQ << 1) | F ;
+
+ switch(switchVal)
+ {
+ case 0x0: sprintf(S1, "Y0") ; sprintf(S2, "X0") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S1, "Y0") ; sprintf(S2, "X0") ; sprintf(D, "B") ; break ;
+ case 0x2: sprintf(S1, "Y1") ; sprintf(S2, "X0") ; sprintf(D, "A") ; break ;
+ case 0x3: sprintf(S1, "Y1") ; sprintf(S2, "X0") ; sprintf(D, "B") ; break ;
+ case 0x4: sprintf(S1, "X1") ; sprintf(S2, "Y0") ; sprintf(D, "A") ; break ;
+ case 0x5: sprintf(S1, "X1") ; sprintf(S2, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x6: sprintf(S1, "X1") ; sprintf(S2, "Y1") ; sprintf(D, "A") ; break ;
+ case 0x7: sprintf(S1, "X1") ; sprintf(S2, "Y1") ; sprintf(D, "B") ; break ;
+ }
+}
+
+#ifdef UNUSED_FUNCTION
+static void DecodeQQQFTable(UINT16 QQQ, UINT16 F, char *S1, char *S2, char *D)
+{
+ UINT16 switchVal = (QQQ << 1) | F ;
+
+ switch(switchVal)
+ {
+ case 0x0: sprintf(S1, "X0") ; sprintf(S2, "X0") ; sprintf(D, "A") ; break ;
+ case 0x1: sprintf(S1, "X0") ; sprintf(S2, "X0") ; sprintf(D, "B") ; break ;
+ case 0x2: sprintf(S1, "X1") ; sprintf(S2, "X0") ; sprintf(D, "A") ; break ;
+ case 0x3: sprintf(S1, "X1") ; sprintf(S2, "X0") ; sprintf(D, "B") ; break ;
+ case 0x4: sprintf(S1, "A1") ; sprintf(S2, "Y0") ; sprintf(D, "A") ; break ;
+ case 0x5: sprintf(S1, "A1") ; sprintf(S2, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x6: sprintf(S1, "B1") ; sprintf(S2, "X0") ; sprintf(D, "A") ; break ;
+ case 0x7: sprintf(S1, "B1") ; sprintf(S2, "X0") ; sprintf(D, "B") ; break ;
+ case 0x8: sprintf(S1, "Y0") ; sprintf(S2, "X0") ; sprintf(D, "A") ; break ;
+ case 0x9: sprintf(S1, "Y0") ; sprintf(S2, "X0") ; sprintf(D, "B") ; break ;
+ case 0xa: sprintf(S1, "Y1") ; sprintf(S2, "X0") ; sprintf(D, "A") ; break ;
+ case 0xb: sprintf(S1, "Y1") ; sprintf(S2, "X0") ; sprintf(D, "B") ; break ;
+ case 0xc: sprintf(S1, "Y0") ; sprintf(S2, "X1") ; sprintf(D, "A") ; break ;
+ case 0xd: sprintf(S1, "Y0") ; sprintf(S2, "X1") ; sprintf(D, "B") ; break ;
+ case 0xe: sprintf(S1, "Y1") ; sprintf(S2, "X1") ; sprintf(D, "A") ; break ;
+ case 0xf: sprintf(S1, "Y1") ; sprintf(S2, "X1") ; sprintf(D, "B") ; break ;
+ }
+}
+#endif
+
+static int DecodeRRTable(UINT16 RR)
+{
+ return RR ;
+}
+
+static void DecodesTable(UINT16 s, char *arithmetic)
+{
+ switch(s)
+ {
+ case 0x0: sprintf(arithmetic, "su") ; break ;
+ case 0x1: sprintf(arithmetic, "uu") ; break ;
+ }
+}
+
+#ifdef UNUSED_FUNCTION
+static void DecodessTable(UINT16 ss, char *arithmetic)
+{
+ switch(ss)
+ {
+ case 0x0: sprintf(arithmetic, "ss") ; break ;
+ case 0x1: sprintf(arithmetic, "ss") ; break ;
+ case 0x2: sprintf(arithmetic, "su") ; break ;
+ case 0x3: sprintf(arithmetic, "uu") ; break ;
+ }
+}
+
+static void DecodeuuuuFTable(UINT16 uuuu, UINT16 F, char *arg, char *S, char *D)
+{
+ UINT16 switchVal = (uuuu << 1) | F ;
+
+ switch(switchVal)
+ {
+ // The add and sub cases are piled on top of one another
+ case 0x00: sprintf(arg, "add") ; case 0x08: sprintf(arg, "sub") ; sprintf(S, "X0") ; sprintf(D, "A") ; break ;
+ case 0x01: sprintf(arg, "add") ; case 0x09: sprintf(arg, "sub") ; sprintf(S, "X0") ; sprintf(D, "B") ; break ;
+ case 0x02: sprintf(arg, "add") ; case 0x0a: sprintf(arg, "sub") ; sprintf(S, "Y0") ; sprintf(D, "A") ; break ;
+ case 0x03: sprintf(arg, "add") ; case 0x0b: sprintf(arg, "sub") ; sprintf(S, "Y0") ; sprintf(D, "B") ; break ;
+ case 0x04: sprintf(arg, "add") ; case 0x0c: sprintf(arg, "sub") ; sprintf(S, "X1") ; sprintf(D, "A") ; break ;
+ case 0x05: sprintf(arg, "add") ; case 0x0d: sprintf(arg, "sub") ; sprintf(S, "X1") ; sprintf(D, "B") ; break ;
+ case 0x06: sprintf(arg, "add") ; case 0x0e: sprintf(arg, "sub") ; sprintf(S, "Y1") ; sprintf(D, "A") ; break ;
+ case 0x07: sprintf(arg, "add") ; case 0x0f: sprintf(arg, "sub") ; sprintf(S, "Y1") ; sprintf(D, "B") ; break ;
+ case 0x18: sprintf(arg, "add") ; case 0x1a: sprintf(arg, "sub") ; sprintf(S, "B") ; sprintf(D, "A") ; break ;
+ case 0x19: sprintf(arg, "add") ; case 0x1b: sprintf(arg, "sub") ; sprintf(S, "A") ; sprintf(D, "B") ; break ;
+ }
+}
+#endif
+
+static void DecodeZTable(UINT16 Z, char *ea)
+{
+ // This is fixed as per the Family Manual addendum
+ switch(Z)
+ {
+ case 0x1: sprintf(ea, "(A1)") ; break ;
+ case 0x0: sprintf(ea, "(B1)") ; break ;
+ }
+}
+
+
+static void AssembleeaFrommTable(UINT16 m, int n, char *ea)
+{
+ switch(m)
+ {
+ case 0x0: sprintf(ea, "(R%d)+",n) ; break ;
+ case 0x1: sprintf(ea, "(R%d)+N%d", n, n) ; break ;
+ }
+}
+
+#ifdef UNUSED_FUNCTION
+static void AssembleeaFrommmTable(UINT16 mm, int n1, int n2, char *ea1, char *ea2)
+{
+ switch(mm)
+ {
+ case 0x0: sprintf(ea1, "(R%d)+", n1) ;
+ sprintf(ea2, "(R%d)+", n2) ; break ;
+ case 0x1: sprintf(ea1, "(R%d)+", n1) ;
+ sprintf(ea2, "(R%d)+N%d", n2, n2) ; break ;
+ case 0x2: sprintf(ea1, "(R%d)+N%d", n1, n1) ;
+ sprintf(ea2, "(R%d)+", n2) ; break ;
+ case 0x3: sprintf(ea1, "(R%d)+N%d", n1, n1) ;
+ sprintf(ea2, "(R%d)+N%d", n2, n2) ; break ;
+ }
+}
+#endif
+
+static void AssembleeaFromMMTable(UINT16 MM, int n, char *ea)
+{
+ switch(MM)
+ {
+ case 0x0: sprintf(ea, "(R%d)", n) ; break ;
+ case 0x1: sprintf(ea, "(R%d)+", n) ; break ;
+ case 0x2: sprintf(ea, "(R%d)-", n) ; break ;
+ case 0x3: sprintf(ea, "(R%d)+N%d", n, n) ; break ;
+ }
+}
+
+static void AssembleeaFromqTable(UINT16 q, int n, char *ea)
+{
+ switch(q)
+ {
+ case 0x0: sprintf(ea, "(R%d+N%d)", n, n) ; break ;
+ case 0x1: sprintf(ea, "-(R%d)", n) ; break ;
+ }
+}
+
+static void AssembleeaFromtTable(UINT16 t, UINT16 val, char *ea)
+{
+ switch(t)
+ {
+ // !!! Looking at page 336 of UM, I'm not sure if 0 is X: or if 0 is just # !!!
+ case 0x0: sprintf(ea, "X:%04x", val) ; break ;
+ case 0x1: sprintf(ea, "#%04x", val) ; break ;
+ }
+}
+
+// Not sure if this one is even used?
+static void AssembleeaFromzTable(UINT16 z, int n, char *ea)
+{
+ switch(z)
+ {
+ case 0x0: sprintf(ea, "(R%d)-", n) ; break ;
+ case 0x1: sprintf(ea, "(R%d)+N%d", n, n) ; break ;
+ }
+}
+
+static void AssembleDFromPTable(UINT16 P, UINT16 ppppp, char *D)
+{
+ char fullAddy[128] ; // Convert Short Absolute Address to full 16-bit
+
+ switch(P)
+ {
+ case 0x0: sprintf(D, "X:%02x", ppppp) ; break ;
+ case 0x1:
+ AssembleAddressFromIOShortAddress(ppppp, fullAddy) ;
+ sprintf(D, "X:%02x (%s)", ppppp, fullAddy) ;
+ break ;
+ }
+}
+
+static void AssembleArgumentsFromWTable(UINT16 W, char *args, char ma, char *SD, char *ea)
+{
+ switch(W)
+ {
+ case 0x0: sprintf(args, "%s,%c:%s", SD, ma, ea) ; break ;
+ case 0x1: sprintf(args, "%c:%s,%s", ma, ea, SD) ; break ;
+ }
+}
+
+static void AssembleRegFromWTable(UINT16 W, char *args, char ma, char *SD, UINT8 xx)
+{
+ switch(W)
+ {
+ case 0x0: sprintf(args, "%s,%c:(R2+%02x)", SD, ma, xx) ; break ;
+ case 0x1: sprintf(args, "%c:(R2+%02x),%s", ma, xx, SD) ; break ;
+ }
+}
+
+static void AssembleAddressFromIOShortAddress(UINT16 pp, char *ea)
+{
+ UINT16 fullAddy = 0xffe0 ;
+ fullAddy |= pp ;
+
+ sprintf(ea, "%.04x", fullAddy) ;
+}
+
+static void AssembleAddressFrom6BitSignedRelativeShortAddress(UINT16 srs, char *ea)
+{
+ UINT16 fullAddy = srs ;
+ if (fullAddy & 0x0020) fullAddy |= 0xffc0 ;
+
+ sprintf(ea, "%d", (INT16)fullAddy) ;
+}
+
+
+
+//////////////////////
+// HELPER FUNCTIONS //
+//////////////////////
+
+static UINT16 Dsp56kOpMask(UINT16 cur, UINT16 mask)
+{
+ int i ;
+
+ UINT16 retVal = (cur & mask) ;
+ UINT16 temp = 0x0000 ;
+ int offsetCount = 0 ;
+
+ // Shift everything right, eliminating 'whitespace'...
+ for (i = 0; i < 16; i++)
+ {
+ if (mask & (0x1<<i)) // If mask bit is non-zero
+ {
+ temp |= (((retVal >> i) & 0x1) << offsetCount) ;
+ offsetCount++ ;
+ }
+ }
+
+ return temp ;
+}
+
+
+
+/*
+
+Data ALU Ops
+--------------------
+
+CLR X 1xxx xxxx 0000 x001
+ADD X 1xxx xxxx 0000 xxxx
+
+MOVE X 1xxx xxxx 0001 0001
+TFR X 1xxx xxxx 0001 xxxx
+
+RND X 1xxx xxxx 0010 x000
+TST X 1xxx xxxx 0010 x001
+INC X 1xxx xxxx 0010 x010
+INC24 X 1xxx xxxx 0010 x011
+OR X 1xxx xxxx 0010 x1xx
+
+ASR X 1xxx xxxx 0011 x000
+ASL X 1xxx xxxx 0011 x001
+LSR X 1xxx xxxx 0011 x010
+LSL X 1xxx xxxx 0011 x011
+EOR X 1xxx xxxx 0011 x1xx
+
+SUBL X 1xxx xxxx 0100 x001
+SUB X 1xxx xxxx 0100 xxxx
+
+CLR24 X 1xxx xxxx 0101 x001
+SBC X 1xxx xxxx 0101 x01x
+CMP X 1xxx xxxx 0101 xxxx
+
+NEG X 1xxx xxxx 0110 x000
+NOT X 1xxx xxxx 0110 x001
+DEC X 1xxx xxxx 0110 x010
+DEC24 X 1xxx xxxx 0110 x011
+AND X 1xxx xxxx 0110 x1xx
+
+ABS X 1xxx xxxx 0111 x001
+ROR X 1xxx xxxx 0111 x010
+ROL X 1xxx xxxx 0111 x011
+CMPM X 1xxx xxxx 0111 xxxx
+
+MPY X 1xxx xxxx 1x00 xxxx
+MPYR X 1xxx xxxx 1x01 xxxx
+MAC X 1xxx xxxx 1x10 xxxx
+MACR X 1xxx xxxx 1x11 xxxx
+
+
+VERY STRANGE XMDM! 0101 HHHW xxxx xxxx
+
+
+DXMDR
+-----------------
+
+ADD X 011x xxxx 0xxx xxxx
+SUB X 011x xxxx 0xxx xxxx
+TFR X 011x xxxx 0xx1 x0xx
+MOVE X 011x xxxx 0xx1 0000
+
+MPY X 011x xxxx 1xx0 x0xx
+MAC X 011x xxxx 1xx0 x1xx
+MPYR X 011x xxxx 1XX1 x0xx
+MACR X 011x xxxx 1XX1 x1xx
+
+
+BITFIELD
+-----------------
+
+BFTSTL X 0001 0100 000x xxxx . xxx0 0000 xxxx xxxx
+BFTSTH X 0001 0100 000x xxxx . xxx1 0000 xxxx xxxx
+BFTSTL X 0001 0100 001X XXxx . xxx0 0000 xxxx xxxx
+BFTSTH X 0001 0100 001X XXxx . xxx1 0000 xxxx xxxx
+BFTSTL X 0001 0100 01xx xxxx . xxx0 0000 xxxx xxxx
+BFTSTH X 0001 0100 01xx xxxx . xxx1 0000 xxxx xxxx
+BFCLR X 0001 0100 100x xxxx . xxx0 0100 xxxx xxxx
+BFCHG X 0001 0100 100x xxxx . xxx1 0010 xxxx xxxx
+BFSET X 0001 0100 100x xxxx . xxx1 1000 xxxx xxxx
+BFCLR X 0001 0100 101X XXxx . xxx0 0100 xxxx xxxx
+BFCHG X 0001 0100 101X XXxx . xxx1 0010 xxxx xxxx
+BFSET X 0001 0100 101X XXxx . xxx1 1000 xxxx xxxx
+BFCHG X 0001 0100 11xx xxxx . xxx1 0010 xxxx xxxx
+BFCLR X 0001 0100 11xx xxxx . xxx0 0100 xxxx xxxx
+BFSET X 0001 0100 11xx xxxx . xxx1 1000 xxxx xxxx
+
+
+NPM
+-----------------
+
+TFR2 X 0001 0101 0000 x00x
+ADC X 0001 0101 0000 x01x
+
+TST2 X 0001 0101 0001 X1xx
+
+NORM X 0001 0101 0010 x0xx
+
+ASR4 X 0001 0101 0011 x000
+ASL4 X 0001 0101 0011 x001
+
+DIV X 0001 0101 0XX0 x1xx
+
+ZERO X 0001 0101 0101 x000
+EXT X 0001 0101 0101 x010
+
+NEGC X 0001 0101 0110 x000
+
+ASR16 X 0001 0101 0111 x000
+SWAP X 0001 0101 0111 x001
+
+IMPY X 0001 0101 1000 xxxx
+IMAC X 0001 0101 1010 xxxx
+DMAC(ss,su,uu) X 0001 0101 10x1 xxxx
+MPY(su,uu) X 0001 0101 1100 xxxx
+MAC(su,uu) X 0001 0101 1110 xxxx
+
+
+XMDWRDM
+-----------------
+
+MPY X 0001 0110 xxxx xxxx
+MAC X 0001 0111 xxxx xxxx
+
+
+IMMEDIATE
+-----------------
+
+ANDI X 0001 1xx0 xxxx xxxx
+ORI X 0001 1xx1 xxxx xxxx
+
+
+SPECIAL
+-----------------
+
+MOVE(S) X 0001 100x xx0x xxxx
+MOVE(P) X 0001 100x xx1x xxxx
+
+-----------------
+
+Tcc X 0001 00xx xxxx xx0x
+
+-----------------
+
+MOVE(I) X 0010 00xx xxxx xxxx
+TFR3 X 0010 01xx xxxx xxxx
+MOVE(C) X 0010 10xx xxxx xxxx
+Bcc X 0010 11xx xxxx xxxx
+
+-----------------
+
+MOVE(C) X 0011 1xxx xxx0 xxxx
+MOVE(C) X 0011 1xxx xxx1 x0xx
+MOVE(C) X 0011 1xxx xxx1 x10X xxxx xxxx xxxx xxxx
+MOVE(C) X 0011 1xxx xxx1 x11X
+
+-----------------
+
+NOP X 0000 0000 0000 0000
+DEBUG X 0000 0000 0000 0001
+DO FOREVER X 0000 0000 0000 0010 xxxx xxxx xxxx xxxx
+CHKAAU X 0000 0000 0000 0100
+SWI X 0000 0000 0000 0101
+RTS X 0000 0000 0000 0110
+RTI X 0000 0000 0000 0111
+RESET X 0000 0000 0000 1000
+ENDDO X 0000 0000 0000 1001
+STOP X 0000 0000 0000 1010
+WAIT X 0000 0000 0000 1011
+ILLEGAL X 0000 0000 0000 1111
+
+DEBUGcc X 0000 0000 0101 xxxx
+DOLoop X 0000 0000 110X XXxx xxxx xxxx xxxx xxxx
+REP X 0000 0000 111X XXxx
+
+BRKcc X 0000 0001 0001 xxxx
+
+JSR X 0000 0001 0010 00xx
+JMP X 0000 0001 0010 01xx
+BSR X 0000 0001 0010 10xx
+BRA X 0000 0001 0010 11xx
+
+JSR X 0000 0001 0011 00XX xxxx xxxx xxxx xxxx
+JMP X 0000 0001 0011 01XX xxxx xxxx xxxx xxxx
+BSR X 0000 0001 0011 10XX xxxx xxxx xxxx xxxx
+BRA X 0000 0001 0011 11XX xxxx xxxx xxxx xxxx
+
+REPcc X 0000 0001 0101 xxxx
+
+LEA X 0000 0001 10xx xxxx
+LEA X 0000 0001 11xx xxxx
+
+-----------------
+
+MOVE(M) X 0000 001x xx0x xxxx
+MOVE(M) X 0000 001x xx11 xxxx
+
+-----------------
+
+DOLoop X 0000 0100 000x xxxx xxxx xxxx xxxx xxxx
+REP X 0000 0100 001x xxxx
+
+-----------------
+
+MOVE(M) X 0000 0101 xxxx xxxx 0000 001x XX0X Xxxx
+MOVE(C) X 0000 0101 xxxx xxxx 0011 1xxx xxx0 XXXX
+MOVE X 0000 0101 xxxx xxxx XXXX xxxx 0001 0001
+
+-----------------
+
+JScc X 0000 0110 xx00 xxxx
+JScc X 0000 0110 XX01 xxxx xxxx xxxx xxxx xxxx
+Jcc X 0000 0110 xx10 xxxx
+Jcc X 0000 0110 XX11 xxxx xxxx xxxx xxxx xxxx
+
+BScc X 0000 0111 xx00 xxxx
+BScc X 0000 0111 XX01 xxxx xxxx xxxx xxxx xxxx
+Bcc X 0000 0111 xx10 xxxx
+Bcc X 0000 0111 XX11 xxxx xxxx xxxx xxxx xxxx
+
+-----------------
+
+JSR X 0000 1010 xxxx xxxx
+BRA X 0000 1011 xxxx xxxx
+MOVE(P) X 0000 110x xxxx xxxx
+DOLoop X 0000 1110 xxxx xxxx xxxx xxxx xxxx xxxx
+REP X 0000 1111 xxxx xxxx
+
+*/