summaryrefslogtreecommitdiffstatshomepage
path: root/src/devices/cpu/tms32025
diff options
context:
space:
mode:
Diffstat (limited to 'src/devices/cpu/tms32025')
-rw-r--r--src/devices/cpu/tms32025/32025dsm.cpp576
-rw-r--r--src/devices/cpu/tms32025/32025dsm.h66
-rw-r--r--src/devices/cpu/tms32025/dis32025.cpp137
-rw-r--r--src/devices/cpu/tms32025/tms32025.cpp103
-rw-r--r--src/devices/cpu/tms32025/tms32025.h10
5 files changed, 394 insertions, 498 deletions
diff --git a/src/devices/cpu/tms32025/32025dsm.cpp b/src/devices/cpu/tms32025/32025dsm.cpp
index cf9a61571b5..b8ad14415c3 100644
--- a/src/devices/cpu/tms32025/32025dsm.cpp
+++ b/src/devices/cpu/tms32025/32025dsm.cpp
@@ -31,309 +31,286 @@
\**************************************************************************/
#include "emu.h"
-#include "debugger.h"
+#include "32025dsm.h"
#include <ctype.h>
-#include "tms32025.h"
+const char *const tms32025_disassembler::arith[8] = { "*", "*-", "*+", "??", "BR0-", "*0-", "*0+", "*BR0+" } ;
+const char *const tms32025_disassembler::nextar[16] = { "", "", "", "", "", "", "", "", ",AR0", ",AR1", ",AR2", ",AR3", ",AR4", ",AR5", ",AR6", ",AR7" } ;
+const char *const tms32025_disassembler::cmpmode[4] = { "0 (ARx = AR0)" , "1 (ARx < AR0)" , "2 (ARx > AR0)" , "3 (ARx <> AR0)" } ;
+const char *const tms32025_disassembler::TMS32025Formats[] = {
+ "0000tttt0aaaaaaa", "add %A,%T", /* 0xxx */
+ "0000tttt1mmmnnnn", "add %M,%T%N",
+ "0001tttt0aaaaaaa", "sub %A,%T", /* 1xxx */
+ "0001tttt1mmmnnnn", "sub %M,%T%N",
+ "0010tttt0aaaaaaa", "lac %A,%T", /* 2xxx */
+ "0010tttt1mmmnnnn", "lac %M,%T%N",
+ "00110rrr0aaaaaaa", "lar %R,%A", /* 3xxx */
+ "00110rrr1mmmnnnn", "lar %R%M%N",
+ "001110000aaaaaaa", "mpy %A", /* 38xx */
+ "001110001mmmnnnn", "mpy %M%N",
+ "001110010aaaaaaa", "sqra %A", /* 39xx */
+ "001110011mmmnnnn", "sqra %M%N",
+ "001110100aaaaaaa", "mpya %A", /* 3Axx */
+ "001110101mmmnnnn", "mpya %M%N",
+ "001110110aaaaaaa", "mpys %A", /* 3Bxx */
+ "001110111mmmnnnn", "mpys %M%N",
+ "001111000aaaaaaa", "lt %A", /* 3Cxx */
+ "001111001mmmnnnn", "lt %M%N",
+ "001111010aaaaaaa", "lta %A", /* 3Dxx */
+ "001111011mmmnnnn", "lta %M%N",
+ "001111100aaaaaaa", "ltp %A", /* 3Exx */
+ "001111101mmmnnnn", "ltp %M%N",
+ "001111110aaaaaaa", "ltd %A", /* 3Fxx */
+ "001111111mmmnnnn", "ltd %M%N",
+ "010000000aaaaaaa", "zalh %A", /* 40xx */
+ "010000001mmmnnnn", "zalh %M%N",
+ "010000010aaaaaaa", "zals %A", /* 41xx */
+ "010000011mmmnnnn", "zals %M%N",
+ "010000100aaaaaaa", "lact %A", /* 42xx */
+ "010000101mmmnnnn", "lact %M%N",
+ "010000110aaaaaaa", "addc %A%S", /* 43xx */
+ "010000111mmmnnnn", "addc %M%S%N",
+ "010001000aaaaaaa", "subh %A", /* 44xx */
+ "010001001mmmnnnn", "subh %M%N",
+ "010001010aaaaaaa", "subs %A", /* 45xx */
+ "010001011mmmnnnn", "subs %M%N",
+ "010001100aaaaaaa", "subt %A", /* 46xx */
+ "010001101mmmnnnn", "subt %M%N",
+ "010001110aaaaaaa", "subc %A", /* 47xx */
+ "010001111mmmnnnn", "subc %M%N",
+ "010010000aaaaaaa", "addh %A", /* 48xx */
+ "010010001mmmnnnn", "addh %M%N",
+ "010010010aaaaaaa", "adds %A", /* 49xx */
+ "010010011mmmnnnn", "adds %M%N",
+ "010010100aaaaaaa", "addt %A", /* 4Axx */
+ "010010101mmmnnnn", "addt %M%N",
+ "010010110aaaaaaa", "rpt %A", /* 4Bxx */
+ "010010111mmmnnnn", "rpt %M%N",
+ "010011000aaaaaaa", "xor %A", /* 4Cxx */
+ "010011001mmmnnnn", "xor %M%N",
+ "010011010aaaaaaa", "or %A", /* 4Dxx */
+ "010011011mmmnnnn", "or %M%N",
+ "010011100aaaaaaa", "and %A", /* 4Exx */
+ "010011101mmmnnnn", "and %M%N",
+ "010011110aaaaaaa", "subb %A", /* 4Fxx */
+ "010011111mmmnnnn", "subb %M%N",
+ "010100000aaaaaaa", "lst %A", /* 50xx */
+ "010100001mmmnnnn", "lst %M%N",
+ "010100010aaaaaaa", "lst1 %A", /* 51xx */
+ "010100011mmmnnnn", "lst1 %M%N",
+ "010100100aaaaaaa", "ldp %A", /* 52xx */
+ "010100101mmmnnnn", "ldp %M%N",
+ "010100110aaaaaaa", "lph %A", /* 53xx */
+ "010100111mmmnnnn", "lph %M%N",
+ "010101000aaaaaaa", "pshd %A", /* 54xx */
+ "010101001mmmnnnn", "pshd %M%N",
-typedef unsigned char byte;
-typedef unsigned short int word;
-
-#define FMT(a,b) a, b
-#define PTRS_PER_FORMAT 2
-
-static const char *const arith[8] = { "*", "*-", "*+", "??", "BR0-", "*0-", "*0+", "*BR0+" } ;
-static const char *const nextar[16] = { "", "", "", "", "", "", "", "", ",AR0", ",AR1", ",AR2", ",AR3", ",AR4", ",AR5", ",AR6", ",AR7" } ;
-static const char *const cmpmode[4] = { "0 (ARx = AR0)" , "1 (ARx < AR0)" , "2 (ARx > AR0)" , "3 (ARx <> AR0)" } ;
-
-
-static const char *const TMS32025Formats[] = {
- FMT("0000tttt0aaaaaaa", "add %A,%T"), /* 0xxx */
- FMT("0000tttt1mmmnnnn", "add %M,%T%N"),
- FMT("0001tttt0aaaaaaa", "sub %A,%T"), /* 1xxx */
- FMT("0001tttt1mmmnnnn", "sub %M,%T%N"),
- FMT("0010tttt0aaaaaaa", "lac %A,%T"), /* 2xxx */
- FMT("0010tttt1mmmnnnn", "lac %M,%T%N"),
- FMT("00110rrr0aaaaaaa", "lar %R,%A"), /* 3xxx */
- FMT("00110rrr1mmmnnnn", "lar %R%M%N"),
- FMT("001110000aaaaaaa", "mpy %A"), /* 38xx */
- FMT("001110001mmmnnnn", "mpy %M%N"),
- FMT("001110010aaaaaaa", "sqra %A"), /* 39xx */
- FMT("001110011mmmnnnn", "sqra %M%N"),
- FMT("001110100aaaaaaa", "mpya %A"), /* 3Axx */
- FMT("001110101mmmnnnn", "mpya %M%N"),
- FMT("001110110aaaaaaa", "mpys %A"), /* 3Bxx */
- FMT("001110111mmmnnnn", "mpys %M%N"),
- FMT("001111000aaaaaaa", "lt %A"), /* 3Cxx */
- FMT("001111001mmmnnnn", "lt %M%N"),
- FMT("001111010aaaaaaa", "lta %A"), /* 3Dxx */
- FMT("001111011mmmnnnn", "lta %M%N"),
- FMT("001111100aaaaaaa", "ltp %A"), /* 3Exx */
- FMT("001111101mmmnnnn", "ltp %M%N"),
- FMT("001111110aaaaaaa", "ltd %A"), /* 3Fxx */
- FMT("001111111mmmnnnn", "ltd %M%N"),
- FMT("010000000aaaaaaa", "zalh %A"), /* 40xx */
- FMT("010000001mmmnnnn", "zalh %M%N"),
- FMT("010000010aaaaaaa", "zals %A"), /* 41xx */
- FMT("010000011mmmnnnn", "zals %M%N"),
- FMT("010000100aaaaaaa", "lact %A"), /* 42xx */
- FMT("010000101mmmnnnn", "lact %M%N"),
- FMT("010000110aaaaaaa", "addc %A%S"), /* 43xx */
- FMT("010000111mmmnnnn", "addc %M%S%N"),
- FMT("010001000aaaaaaa", "subh %A"), /* 44xx */
- FMT("010001001mmmnnnn", "subh %M%N"),
- FMT("010001010aaaaaaa", "subs %A"), /* 45xx */
- FMT("010001011mmmnnnn", "subs %M%N"),
- FMT("010001100aaaaaaa", "subt %A"), /* 46xx */
- FMT("010001101mmmnnnn", "subt %M%N"),
- FMT("010001110aaaaaaa", "subc %A"), /* 47xx */
- FMT("010001111mmmnnnn", "subc %M%N"),
- FMT("010010000aaaaaaa", "addh %A"), /* 48xx */
- FMT("010010001mmmnnnn", "addh %M%N"),
- FMT("010010010aaaaaaa", "adds %A"), /* 49xx */
- FMT("010010011mmmnnnn", "adds %M%N"),
- FMT("010010100aaaaaaa", "addt %A"), /* 4Axx */
- FMT("010010101mmmnnnn", "addt %M%N"),
- FMT("010010110aaaaaaa", "rpt %A"), /* 4Bxx */
- FMT("010010111mmmnnnn", "rpt %M%N"),
- FMT("010011000aaaaaaa", "xor %A"), /* 4Cxx */
- FMT("010011001mmmnnnn", "xor %M%N"),
- FMT("010011010aaaaaaa", "or %A"), /* 4Dxx */
- FMT("010011011mmmnnnn", "or %M%N"),
- FMT("010011100aaaaaaa", "and %A"), /* 4Exx */
- FMT("010011101mmmnnnn", "and %M%N"),
- FMT("010011110aaaaaaa", "subb %A"), /* 4Fxx */
- FMT("010011111mmmnnnn", "subb %M%N"),
- FMT("010100000aaaaaaa", "lst %A"), /* 50xx */
- FMT("010100001mmmnnnn", "lst %M%N"),
- FMT("010100010aaaaaaa", "lst1 %A"), /* 51xx */
- FMT("010100011mmmnnnn", "lst1 %M%N"),
- FMT("010100100aaaaaaa", "ldp %A"), /* 52xx */
- FMT("010100101mmmnnnn", "ldp %M%N"),
- FMT("010100110aaaaaaa", "lph %A"), /* 53xx */
- FMT("010100111mmmnnnn", "lph %M%N"),
- FMT("010101000aaaaaaa", "pshd %A"), /* 54xx */
- FMT("010101001mmmnnnn", "pshd %M%N"),
-
-/* FMT("010101010aaaaaaa", "mar %A"), 55xx */
+/* "010101010aaaaaaa", "mar %A", 55xx */
/* MAR direct has been expanded out to all its variations because one of its */
/* its opcodes is the same as NOP. Actually MAR direct just performs a NOP */
- FMT("0101010100000000", "nop"), /* 5500 */
- FMT("0101010100000001", "mar $01"),
- FMT("0101010100000010", "mar $02"),
- FMT("0101010100000011", "mar $03"),
- FMT("0101010100000100", "mar $04"),
- FMT("0101010100000101", "mar $05"),
- FMT("0101010100000110", "mar $06"),
- FMT("0101010100000111", "mar $07"),
- FMT("0101010100001000", "mar $08"),
- FMT("0101010100001001", "mar $09"),
- FMT("0101010100001010", "mar $0A"),
- FMT("0101010100001011", "mar $0B"),
- FMT("0101010100001100", "mar $0C"),
- FMT("0101010100001101", "mar $0D"),
- FMT("0101010100001110", "mar $0E"),
- FMT("0101010100001111", "mar $0F"),
- FMT("010101010001tttt", "mar $1%T"),
- FMT("010101010010tttt", "mar $2%T"),
- FMT("010101010011tttt", "mar $3%T"),
- FMT("010101010100tttt", "mar $4%T"),
- FMT("010101010101tttt", "mar $5%T"),
- FMT("010101010110tttt", "mar $6%T"),
- FMT("010101010111tttt", "mar $7%T"),
+ "0101010100000000", "nop", /* 5500 */
+ "0101010100000001", "mar $01",
+ "0101010100000010", "mar $02",
+ "0101010100000011", "mar $03",
+ "0101010100000100", "mar $04",
+ "0101010100000101", "mar $05",
+ "0101010100000110", "mar $06",
+ "0101010100000111", "mar $07",
+ "0101010100001000", "mar $08",
+ "0101010100001001", "mar $09",
+ "0101010100001010", "mar $0A",
+ "0101010100001011", "mar $0B",
+ "0101010100001100", "mar $0C",
+ "0101010100001101", "mar $0D",
+ "0101010100001110", "mar $0E",
+ "0101010100001111", "mar $0F",
+ "010101010001tttt", "mar $1%T",
+ "010101010010tttt", "mar $2%T",
+ "010101010011tttt", "mar $3%T",
+ "010101010100tttt", "mar $4%T",
+ "010101010101tttt", "mar $5%T",
+ "010101010110tttt", "mar $6%T",
+ "010101010111tttt", "mar $7%T",
-/* FMT("010101011mmmnnnn", "mar %M%N"), 55xx */
+/* "010101011mmmnnnn", "mar %M%N", 55xx */
/* MAR indirect has been expanded out to all its variations because one of */
/* its opcodes, is the same as LARP (actually performs the same function) */
- FMT("0101010110000xxx", "mar *"), /* 558x */
- FMT("0101010110001kkk", "larp %K"), /* 558x */
- FMT("010101011001nnnn", "mar *-%N"), /* 558x */
- FMT("010101011010nnnn", "mar *+%N"),
- FMT("010101011011nnnn", "mar ??%N"),
- FMT("010101011100nnnn", "mar *BR0-%N"),
- FMT("010101011101nnnn", "mar *0-%N"),
- FMT("010101011110nnnn", "mar *0+%N"),
- FMT("010101011111nnnn", "mar *BR0+%N"),
+ "0101010110000xxx", "mar *", /* 558x */
+ "0101010110001kkk", "larp %K", /* 558x */
+ "010101011001nnnn", "mar *-%N", /* 558x */
+ "010101011010nnnn", "mar *+%N",
+ "010101011011nnnn", "mar ??%N",
+ "010101011100nnnn", "mar *BR0-%N",
+ "010101011101nnnn", "mar *0-%N",
+ "010101011110nnnn", "mar *0+%N",
+ "010101011111nnnn", "mar *BR0+%N",
- FMT("010101100aaaaaaa", "dmov %A"), /* 56xx */
- FMT("010101101mmmnnnn", "dmov %M%N"),
- FMT("010101110aaaaaaa", "bitt %A"), /* 57xx */
- FMT("010101111mmmnnnn", "bitt %M%N"),
- FMT("010110000aaaaaaa", "tblr %A"), /* 58xx */
- FMT("010110001mmmnnnn", "tblr %M%N"),
- FMT("010110010aaaaaaa", "tblw %A"), /* 59xx */
- FMT("010110011mmmnnnn", "tblw %M%N"),
- FMT("010110100aaaaaaa", "sqrs %A"), /* 5Axx */
- FMT("010110101mmmnnnn", "sqrs %M%N"),
- FMT("010110110aaaaaaa", "lts %A"), /* 5Bxx */
- FMT("010110111mmmnnnn", "lts %M%N"),
- FMT("010111000aaaaaaabbbbbbbbbbbbbbbb", "macd %B,%A"), /* 5Cxx */
- FMT("010111001mmmnnnnbbbbbbbbbbbbbbbb", "macd %B,%M%N"),
- FMT("010111010aaaaaaabbbbbbbbbbbbbbbb", "mac %B,%A"), /* 5Dxx */
- FMT("010111011mmmnnnnbbbbbbbbbbbbbbbb", "mac %B,%M%N"),
- FMT("010111101mmmnnnnbbbbbbbbbbbbbbbb", "bc %B %M%N"), /* 5Exx */
- FMT("010111111mmmnnnnbbbbbbbbbbbbbbbb", "bnc %B %M%N"), /* 5Fxx */
- FMT("01100sss0aaaaaaa", "sacl %A%S"), /* 6xxx */
- FMT("01100sss1mmmnnnn", "sacl %M%S%N"),
- FMT("01101sss0aaaaaaa", "sach %A%S"), /* 6Xxx */
- FMT("01101sss1mmmnnnn", "sach %M%S%N"),
- FMT("01110rrr0aaaaaaa", "sar %R,%A"), /* 7xxx */
- FMT("01110rrr1mmmnnnn", "sar %R%M%N"),
- FMT("011110000aaaaaaa", "sst %A"), /* 78xx */
- FMT("011110001mmmnnnn", "sst %M%N"),
- FMT("011110010aaaaaaa", "sst1 %A"), /* 79xx */
- FMT("011110011mmmnnnn", "sst1 %M%N"),
- FMT("011110100aaaaaaa", "popd %A"), /* 7Axx */
- FMT("011110101mmmnnnn", "popd %M%N"),
- FMT("011110110aaaaaaa", "zalr %A"), /* 7Bxx */
- FMT("011110111mmmnnnn", "zalr %M%N"),
- FMT("011111000aaaaaaa", "spl %A"), /* 7Cxx */
- FMT("011111001mmmnnnn", "spl %M%N"),
- FMT("011111010aaaaaaa", "sph %A"), /* 7Dxx */
- FMT("011111011mmmnnnn", "sph %M%N"),
- FMT("011111100aaaaaaa", "adrk %A"), /* 7Exx */
- FMT("011111101mmmnnnn", "adrk %M%N"),
- FMT("011111110aaaaaaa", "sbrk %A"), /* 7Fxx */
- FMT("011111111mmmnnnn", "sbrk %M%N"),
- FMT("1000pppp0aaaaaaa", "in %A,%P"), /* 8xxx */
- FMT("1000pppp1mmmnnnn", "in %M,%P%N"),
- FMT("1001tttt0aaaaaaa", "bit %A,%T"), /* 9xxx */
- FMT("1001tttt1mmmnnnn", "bit %M,%T%N"),
- FMT("101wwwwwwwwwwwww", "mpyk %W"), /* Axxx-Bxxx */
- FMT("11000rrrdddddddd", "lark %R,%D"), /* Cxxx */
- FMT("1100100kdddddddd", "ldpk %K%D"), /* Cxxx */
-/* FMT("11001010dddddddd", "lack %D"), CAxx */
+ "010101100aaaaaaa", "dmov %A", /* 56xx */
+ "010101101mmmnnnn", "dmov %M%N",
+ "010101110aaaaaaa", "bitt %A", /* 57xx */
+ "010101111mmmnnnn", "bitt %M%N",
+ "010110000aaaaaaa", "tblr %A", /* 58xx */
+ "010110001mmmnnnn", "tblr %M%N",
+ "010110010aaaaaaa", "tblw %A", /* 59xx */
+ "010110011mmmnnnn", "tblw %M%N",
+ "010110100aaaaaaa", "sqrs %A", /* 5Axx */
+ "010110101mmmnnnn", "sqrs %M%N",
+ "010110110aaaaaaa", "lts %A", /* 5Bxx */
+ "010110111mmmnnnn", "lts %M%N",
+ "010111000aaaaaaabbbbbbbbbbbbbbbb", "macd %B,%A", /* 5Cxx */
+ "010111001mmmnnnnbbbbbbbbbbbbbbbb", "macd %B,%M%N",
+ "010111010aaaaaaabbbbbbbbbbbbbbbb", "mac %B,%A", /* 5Dxx */
+ "010111011mmmnnnnbbbbbbbbbbbbbbbb", "mac %B,%M%N",
+ "010111101mmmnnnnbbbbbbbbbbbbbbbb", "bc %B %M%N", /* 5Exx */
+ "010111111mmmnnnnbbbbbbbbbbbbbbbb", "bnc %B %M%N", /* 5Fxx */
+ "01100sss0aaaaaaa", "sacl %A%S", /* 6xxx */
+ "01100sss1mmmnnnn", "sacl %M%S%N",
+ "01101sss0aaaaaaa", "sach %A%S", /* 6Xxx */
+ "01101sss1mmmnnnn", "sach %M%S%N",
+ "01110rrr0aaaaaaa", "sar %R,%A", /* 7xxx */
+ "01110rrr1mmmnnnn", "sar %R%M%N",
+ "011110000aaaaaaa", "sst %A", /* 78xx */
+ "011110001mmmnnnn", "sst %M%N",
+ "011110010aaaaaaa", "sst1 %A", /* 79xx */
+ "011110011mmmnnnn", "sst1 %M%N",
+ "011110100aaaaaaa", "popd %A", /* 7Axx */
+ "011110101mmmnnnn", "popd %M%N",
+ "011110110aaaaaaa", "zalr %A", /* 7Bxx */
+ "011110111mmmnnnn", "zalr %M%N",
+ "011111000aaaaaaa", "spl %A", /* 7Cxx */
+ "011111001mmmnnnn", "spl %M%N",
+ "011111010aaaaaaa", "sph %A", /* 7Dxx */
+ "011111011mmmnnnn", "sph %M%N",
+ "011111100aaaaaaa", "adrk %A", /* 7Exx */
+ "011111101mmmnnnn", "adrk %M%N",
+ "011111110aaaaaaa", "sbrk %A", /* 7Fxx */
+ "011111111mmmnnnn", "sbrk %M%N",
+ "1000pppp0aaaaaaa", "in %A,%P", /* 8xxx */
+ "1000pppp1mmmnnnn", "in %M,%P%N",
+ "1001tttt0aaaaaaa", "bit %A,%T", /* 9xxx */
+ "1001tttt1mmmnnnn", "bit %M,%T%N",
+ "101wwwwwwwwwwwww", "mpyk %W", /* Axxx-Bxxx */
+ "11000rrrdddddddd", "lark %R,%D", /* Cxxx */
+ "1100100kdddddddd", "ldpk %K%D", /* Cxxx */
+/* "11001010dddddddd", "lack %D", CAxx */
/* LACK has been expanded out to all its variations because one of its */
/* its opcodes is the same as ZAC. Actually, it performs the same function */
- FMT("1100101000000000", "zac"), /* CA00 */
- FMT("1100101000000001", "lack 01h"), /* CAxx */
- FMT("1100101000000010", "lack 02h"),
- FMT("1100101000000011", "lack 03h"),
- FMT("1100101000000100", "lack 04h"),
- FMT("1100101000000101", "lack 05h"),
- FMT("1100101000000110", "lack 06h"),
- FMT("1100101000000111", "lack 07h"),
- FMT("1100101000001000", "lack 08h"),
- FMT("1100101000001001", "lack 09h"),
- FMT("1100101000001010", "lack 0Ah"),
- FMT("1100101000001011", "lack 0Bh"),
- FMT("1100101000001100", "lack 0Ch"),
- FMT("1100101000001101", "lack 0Dh"),
- FMT("1100101000001110", "lack 0Eh"),
- FMT("1100101000001111", "lack 0Fh"),
- FMT("110010100001tttt", "lack 1%T"),
- FMT("110010100010tttt", "lack 2%T"),
- FMT("110010100011tttt", "lack 3%T"),
- FMT("110010100100tttt", "lack 4%T"),
- FMT("110010100101tttt", "lack 5%T"),
- FMT("110010100110tttt", "lack 6%T"),
- FMT("110010100111tttt", "lack 7%T"),
- FMT("110010101000tttt", "lack 8%T"),
- FMT("110010101001tttt", "lack 9%T"),
- FMT("110010101010tttt", "lack A%T"),
- FMT("110010101011tttt", "lack B%T"),
- FMT("110010101100tttt", "lack C%T"),
- FMT("110010101101tttt", "lack D%T"),
- FMT("110010101110tttt", "lack E%T"),
- FMT("110010101111tttt", "lack F%T"),
+ "1100101000000000", "zac", /* CA00 */
+ "1100101000000001", "lack 01h", /* CAxx */
+ "1100101000000010", "lack 02h",
+ "1100101000000011", "lack 03h",
+ "1100101000000100", "lack 04h",
+ "1100101000000101", "lack 05h",
+ "1100101000000110", "lack 06h",
+ "1100101000000111", "lack 07h",
+ "1100101000001000", "lack 08h",
+ "1100101000001001", "lack 09h",
+ "1100101000001010", "lack 0Ah",
+ "1100101000001011", "lack 0Bh",
+ "1100101000001100", "lack 0Ch",
+ "1100101000001101", "lack 0Dh",
+ "1100101000001110", "lack 0Eh",
+ "1100101000001111", "lack 0Fh",
+ "110010100001tttt", "lack 1%T",
+ "110010100010tttt", "lack 2%T",
+ "110010100011tttt", "lack 3%T",
+ "110010100100tttt", "lack 4%T",
+ "110010100101tttt", "lack 5%T",
+ "110010100110tttt", "lack 6%T",
+ "110010100111tttt", "lack 7%T",
+ "110010101000tttt", "lack 8%T",
+ "110010101001tttt", "lack 9%T",
+ "110010101010tttt", "lack A%T",
+ "110010101011tttt", "lack B%T",
+ "110010101100tttt", "lack C%T",
+ "110010101101tttt", "lack D%T",
+ "110010101110tttt", "lack E%T",
+ "110010101111tttt", "lack F%T",
- FMT("11001011dddddddd", "rptk %D"), /* CBxx */
- FMT("11001100dddddddd", "addk %D"), /* CCxx */
- FMT("11001101dddddddd", "subk %D"), /* CDxx */
- FMT("1100111000000000", "eint"), /* CE00 */
- FMT("1100111000000001", "dint"), /* CE01 */
- FMT("1100111000000010", "rovm"), /* CE02 */
- FMT("1100111000000011", "sovm"), /* CE03 */
- FMT("1100111000000100", "cnfd"), /* CE04 */
- FMT("1100111000000101", "cnfp"), /* CE05 */
- FMT("1100111000000110", "rsxm"), /* CE06 */
- FMT("1100111000000111", "ssxm"), /* CE07 */
- FMT("11001110000010kk", "spm %K"), /* CE0x */
- FMT("1100111000001100", "rxf"), /* CE0C */
- FMT("1100111000001101", "sxf"), /* CE0D */
- FMT("110011100000111k", "fort %K"), /* CE0x */
- FMT("1100111000010100", "pac"), /* CE14 */
- FMT("1100111000010101", "apac"), /* CE15 */
- FMT("1100111000010110", "spac"), /* CE16 */
- FMT("1100111000011000", "sfl"), /* CE18 */
- FMT("1100111000011001", "sfr"), /* CE19 */
- FMT("1100111000011011", "abs"), /* CE1B */
- FMT("1100111000011100", "push"), /* CE1C */
- FMT("1100111000011101", "pop"), /* CE1D */
- FMT("1100111000011110", "trap"), /* CE1E */
- FMT("1100111000011111", "idle"), /* CE1F */
- FMT("1100111000100000", "rtxm"), /* CE20 */
- FMT("1100111000100001", "stxm"), /* CE21 */
- FMT("1100111000100011", "neg"), /* CE23 */
- FMT("1100111000100100", "cala"), /* CE24 */
- FMT("1100111000100101", "bacc"), /* CE25 */
- FMT("1100111000100110", "ret"), /* CE26 */
- FMT("1100111000100111", "cmpl"), /* CE27 */
- FMT("1100111000110000", "rc"), /* CE30 */
- FMT("1100111000110001", "sc"), /* CE31 */
- FMT("1100111000110010", "rtc"), /* CE32 */
- FMT("1100111000110011", "stc"), /* CE33 */
- FMT("1100111000110100", "rol"), /* CE34 */
- FMT("1100111000110101", "ror"), /* CE35 */
- FMT("1100111000110110", "rfsm"), /* CE36 */
- FMT("1100111000110111", "sfsm"), /* CE37 */
- FMT("1100111000111000", "rhm"), /* CE38 */
- FMT("1100111000111001", "shm"), /* CE39 */
- FMT("11001110001111kk", "conf %K"), /* CE3x */
- FMT("11001110010100cc", "cmpr %C"), /* CE5x */
- FMT("110011101mmm0010", "norm %M"), /* CEx2 */
- FMT("110011110aaaaaaa", "mpys %A"), /* CFxx */
- FMT("110011111mmmnnnn", "mpys %M%N"),
- FMT("11010rrr00000000wwwwwwwwwwwwwwww", "lrlk %R,%W"), /* Dx00 */
- FMT("1101tttt00000001wwwwwwwwwwwwwwww", "lalk %W,%T"), /* Dx01 */
- FMT("1101tttt00000010wwwwwwwwwwwwwwww", "adlk %W,%T"), /* Dx02 */
- FMT("1101tttt00000011wwwwwwwwwwwwwwww", "sblk %W,%T"), /* Dx03 */
- FMT("1101tttt00000100wwwwwwwwwwwwwwww", "andk %W,%T"), /* Dx04 */
- FMT("1101tttt00000101wwwwwwwwwwwwwwww", "ork %W,%T"), /* Dx05 */
- FMT("1101tttt00000110wwwwwwwwwwwwwwww", "xork %W,%T"), /* Dx06 */
- FMT("1110pppp0aaaaaaa", "out %A,%P"), /* Exxx */
- FMT("1110pppp1mmmnnnn", "out %M,%P%N"),
- FMT("111100001mmmnnnnbbbbbbbbbbbbbbbb", "bv %B %M%N"), /* F0xx */
- FMT("111100011mmmnnnnbbbbbbbbbbbbbbbb", "bgz %B %M%N"), /* F1xx */
- FMT("111100101mmmnnnnbbbbbbbbbbbbbbbb", "blez %B %M%N"), /* F2xx */
- FMT("111100111mmmnnnnbbbbbbbbbbbbbbbb", "blz %B %M%N"), /* F3xx */
- FMT("111101001mmmnnnnbbbbbbbbbbbbbbbb", "bgez %B %M%N"), /* F4xx */
- FMT("111101011mmmnnnnbbbbbbbbbbbbbbbb", "bnz %B %M%N"), /* F5xx */
- FMT("111101101mmmnnnnbbbbbbbbbbbbbbbb", "bz %B %M%N"), /* F6xx */
- FMT("111101111mmmnnnnbbbbbbbbbbbbbbbb", "bnv %B %M%N"), /* F7xx */
- FMT("111110001mmmnnnnbbbbbbbbbbbbbbbb", "bbz %B %M%N"), /* F8xx */
- FMT("111110011mmmnnnnbbbbbbbbbbbbbbbb", "bbnz %B %M%N"), /* F9xx */
- FMT("111110101mmmnnnnbbbbbbbbbbbbbbbb", "bioz %B %M%N"), /* FAxx */
- FMT("111110111mmmnnnnbbbbbbbbbbbbbbbb", "banz %B %M%N"), /* FBxx */
- FMT("111111000aaaaaaabbbbbbbbbbbbbbbb", "blkp %B,%A"), /* FCxx */
- FMT("111111001mmmnnnnbbbbbbbbbbbbbbbb", "blkp %B,%M%N"),
- FMT("111111010aaaaaaabbbbbbbbbbbbbbbb", "blkd %B,%A"), /* FDxx */
- FMT("111111011mmmnnnnbbbbbbbbbbbbbbbb", "blkd %B,%M%N"),
- FMT("111111101mmmnnnnbbbbbbbbbbbbbbbb", "call %B %M%N"), /* FExx */
- FMT("111111111mmmnnnnbbbbbbbbbbbbbbbb", "b %B %M%N"), /* FFxx */
+ "11001011dddddddd", "rptk %D", /* CBxx */
+ "11001100dddddddd", "addk %D", /* CCxx */
+ "11001101dddddddd", "subk %D", /* CDxx */
+ "1100111000000000", "eint", /* CE00 */
+ "1100111000000001", "dint", /* CE01 */
+ "1100111000000010", "rovm", /* CE02 */
+ "1100111000000011", "sovm", /* CE03 */
+ "1100111000000100", "cnfd", /* CE04 */
+ "1100111000000101", "cnfp", /* CE05 */
+ "1100111000000110", "rsxm", /* CE06 */
+ "1100111000000111", "ssxm", /* CE07 */
+ "11001110000010kk", "spm %K", /* CE0x */
+ "1100111000001100", "rxf", /* CE0C */
+ "1100111000001101", "sxf", /* CE0D */
+ "110011100000111k", "fort %K", /* CE0x */
+ "1100111000010100", "pac", /* CE14 */
+ "1100111000010101", "apac", /* CE15 */
+ "1100111000010110", "spac", /* CE16 */
+ "1100111000011000", "sfl", /* CE18 */
+ "1100111000011001", "sfr", /* CE19 */
+ "1100111000011011", "abs", /* CE1B */
+ "1100111000011100", "push", /* CE1C */
+ "1100111000011101", "pop", /* CE1D */
+ "1100111000011110", "trap", /* CE1E */
+ "1100111000011111", "idle", /* CE1F */
+ "1100111000100000", "rtxm", /* CE20 */
+ "1100111000100001", "stxm", /* CE21 */
+ "1100111000100011", "neg", /* CE23 */
+ "1100111000100100", "cala", /* CE24 */
+ "1100111000100101", "bacc", /* CE25 */
+ "1100111000100110", "ret", /* CE26 */
+ "1100111000100111", "cmpl", /* CE27 */
+ "1100111000110000", "rc", /* CE30 */
+ "1100111000110001", "sc", /* CE31 */
+ "1100111000110010", "rtc", /* CE32 */
+ "1100111000110011", "stc", /* CE33 */
+ "1100111000110100", "rol", /* CE34 */
+ "1100111000110101", "ror", /* CE35 */
+ "1100111000110110", "rfsm", /* CE36 */
+ "1100111000110111", "sfsm", /* CE37 */
+ "1100111000111000", "rhm", /* CE38 */
+ "1100111000111001", "shm", /* CE39 */
+ "11001110001111kk", "conf %K", /* CE3x */
+ "11001110010100cc", "cmpr %C", /* CE5x */
+ "110011101mmm0010", "norm %M", /* CEx2 */
+ "110011110aaaaaaa", "mpys %A", /* CFxx */
+ "110011111mmmnnnn", "mpys %M%N",
+ "11010rrr00000000wwwwwwwwwwwwwwww", "lrlk %R,%W", /* Dx00 */
+ "1101tttt00000001wwwwwwwwwwwwwwww", "lalk %W,%T", /* Dx01 */
+ "1101tttt00000010wwwwwwwwwwwwwwww", "adlk %W,%T", /* Dx02 */
+ "1101tttt00000011wwwwwwwwwwwwwwww", "sblk %W,%T", /* Dx03 */
+ "1101tttt00000100wwwwwwwwwwwwwwww", "andk %W,%T", /* Dx04 */
+ "1101tttt00000101wwwwwwwwwwwwwwww", "ork %W,%T", /* Dx05 */
+ "1101tttt00000110wwwwwwwwwwwwwwww", "xork %W,%T", /* Dx06 */
+ "1110pppp0aaaaaaa", "out %A,%P", /* Exxx */
+ "1110pppp1mmmnnnn", "out %M,%P%N",
+ "111100001mmmnnnnbbbbbbbbbbbbbbbb", "bv %B %M%N", /* F0xx */
+ "111100011mmmnnnnbbbbbbbbbbbbbbbb", "bgz %B %M%N", /* F1xx */
+ "111100101mmmnnnnbbbbbbbbbbbbbbbb", "blez %B %M%N", /* F2xx */
+ "111100111mmmnnnnbbbbbbbbbbbbbbbb", "blz %B %M%N", /* F3xx */
+ "111101001mmmnnnnbbbbbbbbbbbbbbbb", "bgez %B %M%N", /* F4xx */
+ "111101011mmmnnnnbbbbbbbbbbbbbbbb", "bnz %B %M%N", /* F5xx */
+ "111101101mmmnnnnbbbbbbbbbbbbbbbb", "bz %B %M%N", /* F6xx */
+ "111101111mmmnnnnbbbbbbbbbbbbbbbb", "bnv %B %M%N", /* F7xx */
+ "111110001mmmnnnnbbbbbbbbbbbbbbbb", "bbz %B %M%N", /* F8xx */
+ "111110011mmmnnnnbbbbbbbbbbbbbbbb", "bbnz %B %M%N", /* F9xx */
+ "111110101mmmnnnnbbbbbbbbbbbbbbbb", "bioz %B %M%N", /* FAxx */
+ "111110111mmmnnnnbbbbbbbbbbbbbbbb", "banz %B %M%N", /* FBxx */
+ "111111000aaaaaaabbbbbbbbbbbbbbbb", "blkp %B,%A", /* FCxx */
+ "111111001mmmnnnnbbbbbbbbbbbbbbbb", "blkp %B,%M%N",
+ "111111010aaaaaaabbbbbbbbbbbbbbbb", "blkd %B,%A", /* FDxx */
+ "111111011mmmnnnnbbbbbbbbbbbbbbbb", "blkd %B,%M%N",
+ "111111101mmmnnnnbbbbbbbbbbbbbbbb", "call %B %M%N", /* FExx */
+ "111111111mmmnnnnbbbbbbbbbbbbbbbb", "b %B %M%N", /* FFxx */
nullptr
};
-#define MAX_OPS ((ARRAY_LENGTH(TMS32025Formats) - 1) / PTRS_PER_FORMAT)
-
-struct TMS32025Opcode {
- word mask; /* instruction mask */
- word bits; /* constant bits */
- word extcode; /* value that gets extension code */
- const char *parse; /* how to parse bits */
- const char *fmt; /* instruction format */
-};
-
-static TMS32025Opcode Op[MAX_OPS+1];
-static int OpInizialized = 0;
-
-static void InitDasm32025(void)
+tms32025_disassembler::tms32025_disassembler()
{
const char *p;
const char *const *ops;
- word mask, bits;
+ u16 mask, bits;
int bit;
int i;
@@ -374,20 +351,14 @@ static void InitDasm32025(void)
ops[0],ops[1],bit);
}
while (isspace((uint8_t)*p)) p++;
- if (*p) Op[i].extcode = *p;
- Op[i].bits = bits;
- Op[i].mask = mask;
- Op[i].fmt = ops[1];
- Op[i].parse = ops[0];
+ Op.emplace_back(mask, bits, *p, ops[0], ops[1]);
- ops += PTRS_PER_FORMAT;
+ ops += 2;
i++;
}
-
- OpInizialized = 1;
}
-CPU_DISASSEMBLE(tms32025)
+offs_t tms32025_disassembler::disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer &params)
{
uint32_t flags = 0;
int a, b, c, d, k, m, n, p, r, s, t, w; /* these can all be filled in by parsing an instruction */
@@ -399,11 +370,9 @@ CPU_DISASSEMBLE(tms32025)
//char *buffertmp;
const char *cp; /* character pointer in OpFormats */
- if (!OpInizialized) InitDasm32025();
-
op = -1; /* no matching opcode */
- code = (oprom[0] << 8) | oprom[1];
- for ( i = 0; i < MAX_OPS; i++)
+ code = opcodes.r16(pc);
+ for ( i = 0; i < int(Op.size()); i++)
{
if ((code & Op[i].mask) == Op[i].bits)
{
@@ -418,14 +387,14 @@ CPU_DISASSEMBLE(tms32025)
if (op == -1)
{
util::stream_format(stream, "???? dw %04Xh",code);
- return cnt | DASMFLAG_SUPPORTED;
+ return cnt | SUPPORTED;
}
//buffertmp = buffer;
if (Op[op].extcode)
{
bit = 31;
code <<= 16;
- code |= (opram[2] << 8) | opram[3];
+ code |= opcodes.r16(pc+1);
cnt++;
}
else
@@ -466,9 +435,9 @@ CPU_DISASSEMBLE(tms32025)
cp = Op[op].fmt;
if (!strncmp(cp, "cal", 3))
- flags = DASMFLAG_STEP_OVER;
+ flags = STEP_OVER;
else if (!strncmp(cp, "ret", 3))
- flags = DASMFLAG_STEP_OUT;
+ flags = STEP_OUT;
while (*cp)
{
@@ -501,5 +470,10 @@ CPU_DISASSEMBLE(tms32025)
stream << *cp++;
}
}
- return cnt | flags | DASMFLAG_SUPPORTED;
+ return cnt | flags | SUPPORTED;
+}
+
+u32 tms32025_disassembler::opcode_alignment() const
+{
+ return 1;
}
diff --git a/src/devices/cpu/tms32025/32025dsm.h b/src/devices/cpu/tms32025/32025dsm.h
new file mode 100644
index 00000000000..187628b09de
--- /dev/null
+++ b/src/devices/cpu/tms32025/32025dsm.h
@@ -0,0 +1,66 @@
+// license:BSD-3-Clause
+// copyright-holders:Tony La Porta, hap
+ /**************************************************************************\
+ * Texas Instruments TMS320x25 DSP Disassembler *
+ * *
+ * Copyright Tony La Porta *
+ * To be used with TMS320x25 DSP Emulator engine. *
+ * Written for the MAME project. *
+ * *
+ * Many thanks to those involved in the i8039 Disassembler *
+ * as the structure here was borrowed from it. *
+ * *
+ * Note : This is a word based microcontroller, with addressing *
+ * architecture based on the Harvard addressing scheme. *
+ * *
+ * *
+ * A Memory Address *
+ * B Opcode Address Argument (Requires next opcode read) *
+ * C Compare mode *
+ * D Immediate byte load *
+ * K Immediate bit load *
+ * W Immediate word load *
+ * M AR[x] register modification type (for indirect addressing) *
+ * N ARP register to change ARP pointer to (for indirect addressing) *
+ * P I/O port address number *
+ * R AR[R] register to use *
+ * S Shift ALU left *
+ * T Shift ALU left (Hex) / Nibble data *
+ * X Don't care bit *
+ * *
+ \**************************************************************************/
+
+#ifndef MAME_CPU_TMS32025_32025DSM_H
+#define MAME_CPU_TMS32025_32025DSM_H
+
+#pragma once
+
+class tms32025_disassembler : public util::disasm_interface
+{
+public:
+ tms32025_disassembler();
+ virtual ~tms32025_disassembler() = default;
+
+ virtual u32 opcode_alignment() const override;
+ virtual offs_t disassemble(std::ostream &stream, offs_t pc, const data_buffer &opcodes, const data_buffer &params) override;
+
+private:
+ struct TMS32025Opcode {
+ u16 mask; /* instruction mask */
+ u16 bits; /* constant bits */
+ u16 extcode; /* value that gets extension code */
+ const char *parse; /* how to parse bits */
+ const char *fmt; /* instruction format */
+
+ TMS32025Opcode(u16 m, u16 b, u16 e, const char *p, const char *f) : mask(m), bits(b), extcode(e), parse(p), fmt(f) {}
+ };
+
+ static const char *const arith[8];
+ static const char *const nextar[16];
+ static const char *const cmpmode[4];
+ static const char *const TMS32025Formats[];
+
+ std::vector<TMS32025Opcode> Op;
+};
+
+#endif
diff --git a/src/devices/cpu/tms32025/dis32025.cpp b/src/devices/cpu/tms32025/dis32025.cpp
deleted file mode 100644
index 6df4b92707a..00000000000
--- a/src/devices/cpu/tms32025/dis32025.cpp
+++ /dev/null
@@ -1,137 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:Tony La Porta, hap
- /**************************************************************************\
- * Texas Instruments TMS320x25 DSP Disassembler *
- * *
- * Copyright Tony La Porta *
- * Written for the MAME project. *
- * *
- * Notes : Data is expected to be read from source file as MSB first. *
- * This is a word based microcontroller, with addressing *
- * architecture based on the Harvard addressing scheme. *
- * *
- \**************************************************************************/
-
-#include <stdio.h>
-#include <string.h>
-
-#include "32025dsm.c"
-
-
-unsigned char *Buffer;
-
-
-int main(int argc,char *argv[])
-{
- int length=0, length_to_dump=0, offset=0, disasm_words=0;
- int filelength=0, bytes_read;
- int Counter=0;
-
- FILE *F;
- char *String_Output;
-
- if(argc<2)
- {
- printf("\n");
- printf("TMS32025 Disassembler 1.1 by Tony La Porta (C)2001-2002+\n\n");
- printf("Usage: dis32025 <input-file> [ <start-addr> [ <num-of-addr> ] ]\n");
- printf(" <input-file> source file data must be MSB first\n");
- printf(" <start-addr> starting address to disassemble from (decimal)\n");
- printf(" <num-of-addr> number of addresses to disassemble (decimal)\n");
- printf(" Precede values with 0x if HEX values preffered\n");
- exit(1);
- }
-
- if(!(F=fopen(argv[1],"rb")))
- {
- printf("\n%s: Can't open file %s\n",argv[0],argv[1]);
- exit(2);
- }
- argv++; argc--;
- if (argv[1])
- {
- offset = strtol(argv[1],nullptr,0);
- argv++; argc--;
- }
- if (argv[1])
- {
- length = strtol(argv[1],nullptr,0);
- argv++; argc--;
- }
-
- fseek(F,0, SEEK_END);
- filelength = ftell(F);
-
- length *= 2;
-
- if ((length > (filelength - (offset*2))) || (length == 0)) length = filelength - (offset*2);
- printf("Length=%04Xh(words) Offset=$%04Xh filelength=%04Xh(words) %04Xh(bytes)\n",length/2,offset,filelength/2,filelength);
- length_to_dump = length;
- printf("Starting from %d, dumping %d opcodes (word size)\n",offset,length/2);
- Buffer = calloc((filelength+1),sizeof(char));
- if (Buffer==nullptr)
- {
- printf("Out of Memory !!!");
- fclose(F);
- exit(3);
- }
- String_Output = calloc(80,sizeof(char));
- if (String_Output==nullptr)
- {
- printf("Out of Memory !!!");
- free(Buffer);
- fclose(F);
- exit(4);
- }
-
- if (fseek(F,0,SEEK_SET) != 0)
- {
- printf("Error seeking to beginning of file\n");
- free(String_Output);
- free(Buffer);
- fclose(F);
- exit(5);
- }
-
- Counter = offset;
- bytes_read = fread(Buffer,sizeof(char),filelength,F);
- if (bytes_read >= length)
- {
- for (; length > 0; length -= (disasm_words*2))
- {
- int ii;
- disasm_words = Dasm32025(String_Output,Counter);
- printf("$%04lX: ",Counter);
- for (ii = 0; ii < disasm_words; ii++)
- {
- if (((Counter*2) + ii) > filelength) /* Past end of length to dump ? */
- {
- sprintf(String_Output,"???? dw %02.2X%02.2Xh (Past end of disassembly !)",Buffer[((Counter-1)*2)],Buffer[((Counter-1)*2)+1]);
- }
- else
- {
- printf("%02.2x%02.2x ",Buffer[(Counter*2)],Buffer[(Counter*2) + 1]);
- }
- Counter++ ;
- }
- for (; ii < 4; ii++)
- {
- printf(" ");
- }
- printf("\t%s\n",String_Output);
- }
- }
- else
- {
- printf("ERROR length to dump was %d ", length_to_dump/2);
- printf(", but bytes read from file were %d\n", bytes_read/2);
- free(String_Output);
- free(Buffer);
- fclose(F);
- exit(7);
- }
- free(String_Output);
- free(Buffer);
- fclose(F);
- return(0);
-}
diff --git a/src/devices/cpu/tms32025/tms32025.cpp b/src/devices/cpu/tms32025/tms32025.cpp
index a9405d72f3d..74529d79894 100644
--- a/src/devices/cpu/tms32025/tms32025.cpp
+++ b/src/devices/cpu/tms32025/tms32025.cpp
@@ -120,6 +120,7 @@ Table 3-2. TMS32025/26 Memory Blocks
#include "emu.h"
#include "tms32025.h"
+#include "32025dsm.h"
#include "debugger.h"
@@ -253,11 +254,9 @@ device_memory_interface::space_config_vector tms32025_device::memory_space_confi
};
}
-
-offs_t tms32025_device::disasm_disassemble(std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, uint32_t options)
+util::disasm_interface *tms32025_device::create_disassembler()
{
- extern CPU_DISASSEMBLE( tms32025 );
- return CPU_DISASSEMBLE_NAME(tms32025)(this, stream, pc, oprom, opram, options);
+ return new tms32025_disassembler;
}
READ16_MEMBER( tms32025_device::drr_r)
@@ -514,7 +513,7 @@ void tms32025_device::GETDATA(int shift,int signext)
m_external_mem_access = 0;
}
- m_ALU.d = (uint16_t)m_data->read_word(m_memaccess << 1);
+ m_ALU.d = (uint16_t)m_data->read_word(m_memaccess);
if (signext) m_ALU.d = (int16_t)m_ALU.d;
m_ALU.d <<= shift;
@@ -528,14 +527,14 @@ void tms32025_device::PUTDATA(uint16_t data)
if (m_memaccess >= 0x800) m_external_mem_access = 1; /* Pause if hold pin is active */
else m_external_mem_access = 0;
- m_data->write_word(IND << 1, data);
+ m_data->write_word(IND, data);
MODIFY_AR_ARP();
}
else {
if (m_memaccess >= 0x800) m_external_mem_access = 1; /* Pause if hold pin is active */
else m_external_mem_access = 0;
- m_data->write_word(DMA << 1, data);
+ m_data->write_word(DMA, data);
}
}
void tms32025_device::PUTDATA_SST(uint16_t data)
@@ -550,7 +549,7 @@ void tms32025_device::PUTDATA_SST(uint16_t data)
m_opcode.b.l &= 0xf7; /* Stop ARP changes */
MODIFY_AR_ARP();
}
- m_data->write_word(m_memaccess << 1, data);
+ m_data->write_word(m_memaccess, data);
}
@@ -638,8 +637,8 @@ void tms32025_device::addt()
void tms32025_device::adlk()
{
m_oldacc.d = m_ACC.d;
- if (SXM) m_ALU.d = (int16_t)m_direct->read_word(m_PC << 1);
- else m_ALU.d = (uint16_t)m_direct->read_word(m_PC << 1);
+ if (SXM) m_ALU.d = (int16_t)m_direct->read_word(m_PC);
+ else m_ALU.d = (uint16_t)m_direct->read_word(m_PC);
m_PC++;
m_ALU.d <<= (m_opcode.b.h & 0xf);
m_ACC.d += m_ALU.d;
@@ -658,7 +657,7 @@ void tms32025_device::and_()
void tms32025_device::andk()
{
m_oldacc.d = m_ACC.d;
- m_ALU.d = (uint16_t)m_direct->read_word(m_PC << 1);
+ m_ALU.d = (uint16_t)m_direct->read_word(m_PC);
m_PC++;
m_ALU.d <<= (m_opcode.b.h & 0xf);
m_ACC.d &= m_ALU.d;
@@ -673,7 +672,7 @@ void tms32025_device::apac()
}
void tms32025_device::br()
{
- m_PC = m_direct->read_word(m_PC << 1);
+ m_PC = m_direct->read_word(m_PC);
MODIFY_AR_ARP();
}
void tms32025_device::bacc()
@@ -682,43 +681,43 @@ void tms32025_device::bacc()
}
void tms32025_device::banz()
{
- if (m_AR[ARP]) m_PC = m_direct->read_word(m_PC << 1);
+ if (m_AR[ARP]) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bbnz()
{
- if (TC) m_PC = m_direct->read_word(m_PC << 1);
+ if (TC) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bbz()
{
- if (TC == 0) m_PC = m_direct->read_word(m_PC << 1);
+ if (TC == 0) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bc()
{
- if (CARRY) m_PC = m_direct->read_word(m_PC << 1);
+ if (CARRY) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bgez()
{
- if ( (int32_t)(m_ACC.d) >= 0 ) m_PC = m_direct->read_word(m_PC << 1);
+ if ( (int32_t)(m_ACC.d) >= 0 ) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bgz()
{
- if ( (int32_t)(m_ACC.d) > 0 ) m_PC = m_direct->read_word(m_PC << 1);
+ if ( (int32_t)(m_ACC.d) > 0 ) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bioz()
{
- if (m_bio_in() != CLEAR_LINE) m_PC = m_direct->read_word(m_PC << 1);
+ if (m_bio_in() != CLEAR_LINE) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
@@ -736,17 +735,17 @@ void tms32025_device::bitt()
}
void tms32025_device::blez()
{
- if ( (int32_t)(m_ACC.d) <= 0 ) m_PC = m_direct->read_word(m_PC << 1);
+ if ( (int32_t)(m_ACC.d) <= 0 ) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::blkd()
{ /** Fix cycle timing **/
if (m_init_load_addr) {
- m_PFC = m_direct->read_word(m_PC << 1);
+ m_PFC = m_direct->read_word(m_PC);
m_PC++;
}
- m_ALU.d = m_data->read_word(m_PFC << 1);
+ m_ALU.d = m_data->read_word(m_PFC);
PUTDATA(m_ALU.d);
m_PFC++;
m_tms32025_dec_cycles += (1*CLK);
@@ -754,29 +753,29 @@ void tms32025_device::blkd()
void tms32025_device::blkp()
{ /** Fix cycle timing **/
if (m_init_load_addr) {
- m_PFC = m_direct->read_word(m_PC << 1);
+ m_PFC = m_direct->read_word(m_PC);
m_PC++;
}
- m_ALU.d = m_direct->read_word(m_PFC << 1);
+ m_ALU.d = m_direct->read_word(m_PFC);
PUTDATA(m_ALU.d);
m_PFC++;
m_tms32025_dec_cycles += (2*CLK);
}
void tms32025_device::blz()
{
- if ( (int32_t)(m_ACC.d) < 0 ) m_PC = m_direct->read_word(m_PC << 1);
+ if ( (int32_t)(m_ACC.d) < 0 ) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bnc()
{
- if (CARRY == 0) m_PC = m_direct->read_word(m_PC << 1);
+ if (CARRY == 0) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bnv()
{
- if (OV == 0) m_PC = m_direct->read_word(m_PC << 1);
+ if (OV == 0) m_PC = m_direct->read_word(m_PC);
else {
m_PC++ ;
CLR0(OV_FLAG);
@@ -785,14 +784,14 @@ void tms32025_device::bnv()
}
void tms32025_device::bnz()
{
- if (m_ACC.d != 0) m_PC = m_direct->read_word(m_PC << 1);
+ if (m_ACC.d != 0) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
void tms32025_device::bv()
{
if (OV) {
- m_PC = m_direct->read_word(m_PC << 1);
+ m_PC = m_direct->read_word(m_PC);
CLR0(OV_FLAG);
}
else m_PC++ ;
@@ -800,7 +799,7 @@ void tms32025_device::bv()
}
void tms32025_device::bz()
{
- if (m_ACC.d == 0) m_PC = m_direct->read_word(m_PC << 1);
+ if (m_ACC.d == 0) m_PC = m_direct->read_word(m_PC);
else m_PC++ ;
MODIFY_AR_ARP();
}
@@ -813,7 +812,7 @@ void tms32025_device::call()
{
m_PC++ ;
PUSH_STACK(m_PC);
- m_PC = m_direct->read_word((m_PC - 1) << 1);
+ m_PC = m_direct->read_word(m_PC - 1);
MODIFY_AR_ARP();
}
void tms32025_device::cmpl()
@@ -916,7 +915,7 @@ void tms32025_device::dint()
void tms32025_device::dmov() /** Careful with how memory is configured !! */
{
GETDATA(0, 0);
- m_data->write_word((m_memaccess + 1) << 1, m_ALU.w.l);
+ m_data->write_word(m_memaccess + 1, m_ALU.w.l);
}
void tms32025_device::eint()
{
@@ -934,7 +933,7 @@ void tms32025_device::idle()
}
void tms32025_device::in()
{
- m_ALU.w.l = m_io->read_word( (m_opcode.b.h & 0xf) << 1 );
+ m_ALU.w.l = m_io->read_word(m_opcode.b.h & 0xf);
PUTDATA(m_ALU.w.l);
}
void tms32025_device::lac()
@@ -953,8 +952,8 @@ void tms32025_device::lact()
}
void tms32025_device::lalk()
{
- if (SXM) m_ALU.d = (int16_t)m_direct->read_word(m_PC << 1);
- else m_ALU.d = (uint16_t)m_direct->read_word(m_PC << 1);
+ if (SXM) m_ALU.d = (int16_t)m_direct->read_word(m_PC);
+ else m_ALU.d = (uint16_t)m_direct->read_word(m_PC);
m_PC++;
m_ALU.d <<= (m_opcode.b.h & 0xf);
m_ACC.d = m_ALU.d;
@@ -991,7 +990,7 @@ void tms32025_device::lph()
}
void tms32025_device::lrlk()
{
- m_ALU.d = (uint16_t)m_direct->read_word(m_PC << 1);
+ m_ALU.d = (uint16_t)m_direct->read_word(m_PC);
m_PC++;
m_AR[m_opcode.b.h & 7] = m_ALU.w.l;
}
@@ -1036,7 +1035,7 @@ void tms32025_device::ltd() /** Careful with how memory is configured !! */
m_oldacc.d = m_ACC.d;
GETDATA(0, 0);
m_Treg = m_ALU.w.l;
- m_data->write_word((m_memaccess+1) << 1, m_ALU.w.l);
+ m_data->write_word(m_memaccess+1, m_ALU.w.l);
SHIFT_Preg_TO_ALU();
m_ACC.d += m_ALU.d;
CALCULATE_ADD_OVERFLOW(m_ALU.d);
@@ -1064,7 +1063,7 @@ void tms32025_device::mac() /** RAM blocks B0,B1,B2 may be important !
{ /** Fix cycle timing **/
m_oldacc.d = m_ACC.d;
if (m_init_load_addr) {
- m_PFC = m_direct->read_word(m_PC << 1);
+ m_PFC = m_direct->read_word(m_PC);
m_PC++;
}
SHIFT_Preg_TO_ALU();
@@ -1073,7 +1072,7 @@ void tms32025_device::mac() /** RAM blocks B0,B1,B2 may be important !
CALCULATE_ADD_CARRY();
GETDATA(0, 0);
m_Treg = m_ALU.w.l;
- m_Preg.d = ( (int16_t)m_ALU.w.l * (int16_t)m_direct->read_word(m_PFC << 1) );
+ m_Preg.d = ( (int16_t)m_ALU.w.l * (int16_t)m_direct->read_word(m_PFC) );
m_PFC++;
m_tms32025_dec_cycles += (2*CLK);
}
@@ -1081,7 +1080,7 @@ void tms32025_device::macd() /** RAM blocks B0,B1,B2 may be important !
{ /** Fix cycle timing **/
m_oldacc.d = m_ACC.d;
if (m_init_load_addr) {
- m_PFC = m_direct->read_word(m_PC << 1);
+ m_PFC = m_direct->read_word(m_PC);
m_PC++;
}
SHIFT_Preg_TO_ALU();
@@ -1090,10 +1089,10 @@ void tms32025_device::macd() /** RAM blocks B0,B1,B2 may be important !
CALCULATE_ADD_CARRY();
GETDATA(0, 0);
if ( (m_opcode.b.l & 0x80) || m_init_load_addr ) { /* No writing during repetition, or DMA mode */
- m_data->write_word((m_memaccess+1) << 1, m_ALU.w.l);
+ m_data->write_word(m_memaccess+1, m_ALU.w.l);
}
m_Treg = m_ALU.w.l;
- m_Preg.d = ( (int16_t)m_ALU.w.l * (int16_t)m_direct->read_word(m_PFC << 1) );
+ m_Preg.d = ( (int16_t)m_ALU.w.l * (int16_t)m_direct->read_word(m_PFC) );
m_PFC++;
m_tms32025_dec_cycles += (2*CLK);
}
@@ -1166,7 +1165,7 @@ void tms32025_device::or_()
}
void tms32025_device::ork()
{
- m_ALU.d = (uint16_t)m_direct->read_word(m_PC << 1);
+ m_ALU.d = (uint16_t)m_direct->read_word(m_PC);
m_PC++;
m_ALU.d <<= (m_opcode.b.h & 0xf);
m_ACC.d |= (m_ALU.d);
@@ -1174,7 +1173,7 @@ void tms32025_device::ork()
void tms32025_device::out()
{
GETDATA(0, 0);
- m_io->write_word( (m_opcode.b.h & 0xf) << 1, m_ALU.w.l );
+ m_io->write_word(m_opcode.b.h & 0xf, m_ALU.w.l );
}
void tms32025_device::pac()
{
@@ -1285,8 +1284,8 @@ void tms32025_device::sar_ar7() { PUTDATA(m_AR[7]); }
void tms32025_device::sblk()
{
m_oldacc.d = m_ACC.d;
- if (SXM) m_ALU.d = (int16_t)m_direct->read_word(m_PC << 1);
- else m_ALU.d = (uint16_t)m_direct->read_word(m_PC << 1);
+ if (SXM) m_ALU.d = (int16_t)m_direct->read_word(m_PC);
+ else m_ALU.d = (uint16_t)m_direct->read_word(m_PC);
m_PC++;
m_ALU.d <<= (m_opcode.b.h & 0xf);
m_ACC.d -= m_ALU.d;
@@ -1477,7 +1476,7 @@ void tms32025_device::tblr()
if (m_init_load_addr) {
m_PFC = m_ACC.w.l;
}
- m_ALU.w.l = m_direct->read_word(m_PFC << 1);
+ m_ALU.w.l = m_direct->read_word(m_PFC);
if ( (CNF0) && ( (uint16_t)(m_PFC) >= 0xff00 ) ) {} /** TMS32025 only */
else m_tms32025_dec_cycles += (1*CLK);
PUTDATA(m_ALU.w.l);
@@ -1491,7 +1490,7 @@ void tms32025_device::tblw()
m_tms32025_dec_cycles += (1*CLK);
GETDATA(0, 0);
if (m_external_mem_access) m_tms32025_dec_cycles += (1*CLK);
- m_program->write_word(m_PFC << 1, m_ALU.w.l);
+ m_program->write_word(m_PFC, m_ALU.w.l);
m_PFC++;
}
void tms32025_device::trap()
@@ -1506,7 +1505,7 @@ void tms32025_device::xor_()
}
void tms32025_device::xork()
{
- m_ALU.d = m_direct->read_word(m_PC << 1);
+ m_ALU.d = m_direct->read_word(m_PC);
m_PC++;
m_ALU.d <<= (m_opcode.b.h & 0xf);
m_ACC.d ^= m_ALU.d;
@@ -1620,7 +1619,7 @@ const tms32025_device::tms32025_opcode tms32025_device::s_opcode_Dx_subset[8]=
void tms32025_device::device_start()
{
m_program = &space(AS_PROGRAM);
- m_direct = &m_program->direct();
+ m_direct = m_program->direct<-1>();
m_data = &space(AS_DATA);
m_io = &space(AS_IO);
@@ -1968,7 +1967,7 @@ void tms32025_device::execute_run()
debugger_instruction_hook(this, m_PC);
- m_opcode.d = m_direct->read_word(m_PC << 1);
+ m_opcode.d = m_direct->read_word(m_PC);
m_PC++;
if (m_opcode.b.h == 0xCE) /* Opcode 0xCExx has many sub-opcodes in its minor byte */
@@ -2002,7 +2001,7 @@ void tms32025_device::execute_run()
debugger_instruction_hook(this, m_PC);
- m_opcode.d = m_direct->read_word(m_PC << 1);
+ m_opcode.d = m_direct->read_word(m_PC);
m_PC++;
m_tms32025_dec_cycles += (1*CLK);
diff --git a/src/devices/cpu/tms32025/tms32025.h b/src/devices/cpu/tms32025/tms32025.h
index a9ae17576c4..66c76bc001b 100644
--- a/src/devices/cpu/tms32025/tms32025.h
+++ b/src/devices/cpu/tms32025/tms32025.h
@@ -125,9 +125,7 @@ protected:
virtual void state_string_export(const device_state_entry &entry, std::string &str) const override;
// device_disasm_interface overrides
- virtual uint32_t disasm_min_opcode_bytes() const override { return 2; }
- virtual uint32_t disasm_max_opcode_bytes() const override { return 4; }
- virtual offs_t disasm_disassemble(std::ostream &stream, offs_t pc, const uint8_t *oprom, const uint8_t *opram, uint32_t options) override;
+ virtual util::disasm_interface *create_disassembler() override;
void common_reset();
@@ -141,7 +139,7 @@ protected:
optional_shared_ptr<uint16_t> m_b3;
address_space *m_program;
- direct_read_data *m_direct;
+ direct_read_data<-1> *m_direct;
address_space *m_data;
address_space *m_io;
@@ -204,10 +202,6 @@ protected:
inline void MODIFY_DP(int data);
inline void MODIFY_PM(int data);
inline void MODIFY_ARP(int data);
- inline uint16_t M_RDROM(offs_t addr);
- inline void M_WRTROM(offs_t addr, uint16_t data);
- inline uint16_t M_RDRAM(offs_t addr);
- inline void M_WRTRAM(offs_t addr, uint16_t data);
uint16_t reverse_carry_add(uint16_t arg0, uint16_t arg1 );
inline void MODIFY_AR_ARP();
inline void CALCULATE_ADD_CARRY();