diff options
Diffstat (limited to 'src/emu/cpu/dsp56k/dsp56dsm.c')
-rw-r--r-- | src/emu/cpu/dsp56k/dsp56dsm.c | 2210 |
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 + +*/ |