summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/cpu/m6805/6805dasm.c
blob: 9471d976924bbc2898ec073144664937ca3d8ac3 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/*
 *   A quick-hack 68(7)05 disassembler
 *
 *   Note: this is not the good and proper way to disassemble anything, but it works
 *
 *   I'm afraid to put my name on it, but I feel obligated:
 *   This code written by Aaron Giles (agiles@sirius.com) for the MAME project
 *
 */

#include "emu.h"
#include "debugger.h"
#include "m6805.h"

enum addr_mode {
	_imp=0,     /* implicit */
	_btr,       /* bit test and relative */
	_bit,       /* bit set/clear */
	_rel,       /* relative */
	_imm,       /* immediate */
	_dir,       /* direct address */
	_ext,       /* extended address */
	_idx,       /* indexed */
	_ix1,       /* indexed + byte offset */
	_ix2        /* indexed + word offset */
};

enum op_names {
	adca=0, adda,   anda,   asl,    asla,   aslx,   asr,    asra,
	asrx,   bcc,    bclr,   bcs,    beq,    bhcc,   bhcs,   bhi,
	bih,    bil,    bita,   bls,    bmc,    bmi,    bms,    bne,
	bpl,    bra,    brclr,  brn,    brset,  bset,   bsr,    clc,
	cli,    clr,    clra,   clrx,   cmpa,   com,    coma,   comx,
	cpx,    dec,    deca,   decx,   eora,   ill,    inc,    inca,
	incx,   jmp,    jsr,    lda,    ldx,    lsr,    lsra,   lsrx,
	neg,    nega,   negx,   nop,    ora,    rol,    rola,   rolx,
	ror,    rora,   rorx,   rsp,    rti,    rts,    sbca,   sec,
	sei,    sta,    stx,    suba,   swi,    tax,    tst,    tsta,
	tstx,   txa
};

static const char *const op_name_str[] = {
	"adca", "adda", "anda", "asl",  "asla", "aslx", "asr",  "asra",
	"asrx", "bcc",  "bclr", "bcs",  "beq",  "bhcc", "bhcs", "bhi",
	"bih",  "bil",  "bita", "bls",  "bmc",  "bmi",  "bms",  "bne",
	"bpl",  "bra",  "brclr","brn",  "brset","bset", "bsr",  "clc",
	"cli",  "clr",  "clra", "clrx", "cmpa", "com",  "coma", "comx",
	"cpx",  "dec",  "deca", "decx", "eora", "*ill", "inc",  "inca",
	"incx", "jmp",  "jsr",  "lda",  "ldx",  "lsr",  "lsra", "lsrx",
	"neg",  "nega", "negx", "nop",  "ora",  "rol",  "rola", "rolx",
	"ror",  "rora", "rorx", "rsp",  "rti",  "rts",  "sbca", "sec",
	"sei",  "sta",  "stx",  "suba", "swi",  "tax",  "tst",  "tsta",
	"tstx", "txa"
};

static const unsigned char disasm[0x100][2] = {
	{brset,_btr},{brclr,_btr},{brset,_btr},{brclr,_btr},/* 00 */
	{brset,_btr},{brclr,_btr},{brset,_btr},{brclr,_btr},
	{brset,_btr},{brclr,_btr},{brset,_btr},{brclr,_btr},
	{brset,_btr},{brclr,_btr},{brset,_btr},{brclr,_btr},
	{bset, _bit},{bclr, _bit},{bset, _bit},{bclr, _bit},/* 10 */
	{bset, _bit},{bclr, _bit},{bset, _bit},{bclr, _bit},
	{bset, _bit},{bclr, _bit},{bset, _bit},{bclr, _bit},
	{bset, _bit},{bclr, _bit},{bset, _bit},{bclr, _bit},
	{bra,  _rel},{brn,  _rel},{bhi,  _rel},{bls,  _rel},/* 20 */
	{bcc,  _rel},{bcs,  _rel},{bne,  _rel},{beq,  _rel},
	{bhcc, _rel},{bhcs, _rel},{bpl,  _rel},{bmi,  _rel},
	{bmc,  _rel},{bms,  _rel},{bil,  _rel},{bih,  _rel},
	{neg,  _dir},{ill,  _imp},{ill,  _imp},{com,  _dir},/* 30 */
	{lsr,  _dir},{ill,  _imp},{ror,  _dir},{asr,  _dir},
	{asl,  _dir},{rol,  _dir},{dec,  _dir},{ill,  _imp},
	{inc,  _dir},{tst,  _dir},{ill,  _imp},{clr,  _dir},
	{nega, _imp},{ill,  _imp},{ill,  _imp},{coma, _imp},/* 40 */
	{lsra, _imp},{ill,  _imp},{rora, _imp},{asra, _imp},
	{asla, _imp},{rola, _imp},{deca, _imp},{ill,  _imp},
	{inca, _imp},{tsta, _imp},{ill,  _imp},{clra, _imp},
	{negx, _imp},{ill,  _imp},{ill,  _imp},{comx, _imp},/* 50 */
	{lsrx, _imp},{ill,  _imp},{rorx, _imp},{asrx, _imp},
	{aslx, _imp},{rolx, _imp},{decx, _imp},{ill,  _imp},
	{incx, _imp},{tstx, _imp},{ill,  _imp},{clrx, _imp},
	{neg,  _ix1},{ill,  _imp},{ill,  _imp},{com,  _ix1},/* 60 */
	{lsr,  _ix1},{ill,  _imp},{ror,  _ix1},{asr,  _ix1},
	{asl,  _ix1},{rol,  _ix1},{dec,  _ix1},{ill,  _imp},
	{inc,  _ix1},{tst,  _ix1},{jmp,  _ix1},{clr,  _ix1},
	{neg,  _idx},{ill,  _imp},{ill,  _imp},{com,  _idx},/* 70 */
	{lsr,  _idx},{ill,  _imp},{ror,  _idx},{asr,  _idx},
	{asl,  _idx},{rol,  _idx},{dec,  _idx},{ill,  _imp},
	{inc,  _idx},{tst,  _idx},{jmp,  _idx},{clr,  _idx},
	{rti,  _imp},{rts,  _imp},{ill,  _imp},{swi,  _imp},/* 80 */
	{ill,  _imp},{ill,  _imp},{ill,  _imp},{ill,  _imp},
	{ill,  _imp},{ill,  _imp},{ill,  _imp},{ill,  _imp},
	{ill,  _imp},{ill,  _imp},{ill,  _imp},{ill,  _imp},
	{ill,  _imp},{ill,  _imp},{ill,  _imp},{ill,  _imp},/* 90 */
	{ill,  _imp},{ill,  _imp},{ill,  _imp},{tax,  _imp},
	{clc,  _imp},{sec,  _imp},{cli,  _imp},{sei,  _imp},
	{rsp,  _imp},{nop,  _imp},{ill,  _imp},{txa,  _imp},
	{suba, _imm},{cmpa, _imm},{sbca, _imm},{cpx,  _imm},/* a0 */
	{anda, _imm},{bita, _imm},{lda,  _imm},{ill,  _imp},
	{eora, _imm},{adca, _imm},{ora,  _imm},{adda, _imm},
	{ill,  _imp},{bsr,  _rel},{ldx,  _imm},{ill,  _imp},
	{suba, _dir},{cmpa, _dir},{sbca, _dir},{cpx,  _dir},/* b0 */
	{anda, _dir},{bita, _dir},{lda,  _dir},{sta,  _dir},
	{eora, _dir},{adca, _dir},{ora,  _dir},{adda, _dir},
	{jmp,  _dir},{jsr,  _dir},{ldx,  _dir},{stx,  _dir},
	{suba, _ext},{cmpa, _ext},{sbca, _ext},{cpx,  _ext},/* c0 */
	{anda, _ext},{bita, _ext},{lda,  _ext},{sta,  _ext},
	{eora, _ext},{adca, _ext},{ora,  _ext},{adda, _ext},
	{jmp,  _ext},{jsr,  _ext},{ldx,  _ext},{stx,  _ext},
	{suba, _ix2},{cmpa, _ix2},{sbca, _ix2},{cpx,  _ix2},/* d0 */
	{anda, _ix2},{bita, _ix2},{lda,  _ix2},{sta,  _ix2},
	{eora, _ix2},{adca, _ix2},{ora,  _ix2},{adda, _ix2},
	{jmp,  _ix2},{jsr,  _ix2},{ldx,  _ix2},{stx,  _ix2},
	{suba, _ix1},{cmpa, _ix1},{sbca, _ix1},{cpx,  _ix1},/* e0 */
	{anda, _ix1},{bita, _ix1},{lda,  _ix1},{sta,  _ix1},
	{eora, _ix1},{adca, _ix1},{ora,  _ix1},{adda, _ix1},
	{jmp,  _ix1},{jsr,  _ix1},{ldx,  _ix1},{stx,  _ix1},
	{suba, _idx},{cmpa, _idx},{sbca, _idx},{cpx,  _idx},/* f0 */
	{anda, _idx},{bita, _idx},{lda,  _idx},{sta,  _idx},
	{eora, _idx},{adca, _idx},{ora,  _idx},{adda, _idx},
	{jmp,  _idx},{jsr,  _idx},{ldx,  _idx},{stx,  _idx}
};

#if 0
static const char *const opcode_strings[0x0100] =
{
	"brset0",   "brclr0",   "brset1",   "brclr1",   "brset2",   "brclr2",   "brset3",   "brclr3",       /*00*/
	"brset4",   "brclr4",   "brset5",   "brclr5",   "brset6",   "brclr6",   "brset7",   "brclr7",
	"bset0",    "bclr0",    "bset1",    "bclr1",    "bset2",    "bclr2",    "bset3",    "bclr3",        /*10*/
	"bset4",    "bclr4",    "bset5",    "bclr5",    "bset6",    "bclr6",    "bset7",    "bclr7",
	"bra",      "brn",      "bhi",      "bls",      "bcc",      "bcs",      "bne",      "beq",          /*20*/
	"bhcc",     "bhcs",     "bpl",      "bmi",      "bmc",      "bms",      "bil",      "bih",
	"neg_di",   "illegal",  "illegal",  "com_di",   "lsr_di",   "illegal",  "ror_di",   "asr_di",       /*30*/
	"asl_di",   "rol_di",   "dec_di",   "illegal",  "inc_di",   "tst_di",   "illegal",  "clr_di",
	"nega",     "illegal",  "illegal",  "coma",     "lsra",     "illegal",  "rora",     "asra",         /*40*/
	"asla",     "rola",     "deca",     "illegal",  "inca",     "tsta",     "illegal",  "clra",
	"negx",     "illegal",  "illegal",  "comx",     "lsrx",     "illegal",  "rorx",     "asrx",         /*50*/
	"aslx",     "rolx",     "decx",     "illegal",  "incx",     "tstx",     "illegal",  "clrx",
	"neg_ix1",  "illegal",  "illegal",  "com_ix1",  "lsr_ix1",  "illegal",  "ror_ix1",  "asr_ix1",      /*60*/
	"asl_ix1",  "rol_ix1",  "dec_ix1",  "illegal",  "inc_ix1",  "tst_ix1",  "jmp_ix1",  "clr_ix1",
	"neg_ix",   "illegal",  "illegal",  "com_ix",   "lsr_ix",   "illegal",  "ror_ix",   "asr_ix",       /*70*/
	"asl_ix",   "rol_ix",   "dec_ix",   "illegal",  "inc_ix",   "tst_ix",   "jmp_ix",   "clr_ix",
	"rti",      "rts",      "illegal",  "swi",      "illegal",  "illegal",  "illegal",  "illegal",      /*80*/
	"illegal",  "illegal",  "illegal",  "illegal",  "illegal",  "illegal",  "illegal",  "illegal",
	"illegal",  "illegal",  "illegal",  "illegal",  "illegal",  "illegal",  "illegal",  "tax",          /*90*/
	"clc",      "sec",      "cli",      "sei",      "rsp",      "nop",      "illegal",  "txa",
	"suba_im",  "cmpa_im",  "sbca_im",  "cpx_im",   "anda_im",  "bita_im",  "lda_im",   "illegal",      /*A0*/
	"eora_im",  "adca_im",  "ora_im",   "adda_im",  "illegal",  "bsr",      "ldx_im",   "illegal",
	"suba_di",  "cmpa_di",  "sbca_di",  "cpx_di",   "anda_di",  "bita_di",  "lda_di",   "sta_di",       /*B0*/
	"eora_di",  "adca_di",  "ora_di",   "adda_di",  "jmp_di",   "jsr_di",   "ldx_di",   "stx_di",
	"suba_ex",  "cmpa_ex",  "sbca_ex",  "cpx_ex",   "anda_ex",  "bita_ex",  "lda_ex",   "sta_ex",       /*C0*/
	"eora_ex",  "adca_ex",  "ora_ex",   "adda_ex",  "jmp_ex",   "jsr_ex",   "ldx_ex",   "stx_ex",
	"suba_ix2", "cmpa_ix2", "sbca_ix2", "cpx_ix2",  "anda_ix2", "bita_ix2", "lda_ix2",  "sta_ix2",      /*D0*/
	"eora_ix2", "adca_ix2", "ora_ix2",  "adda_ix2", "jmp_ix2",  "jsr_ix2",  "ldx_ix2",  "stx_ix2",
	"suba_ix1", "cmpa_ix1", "sbca_ix1", "cpx_ix1",  "anda_ix1", "bita_ix1", "lda_ix1",  "sta_ix1",      /*E0*/
	"eora_ix1", "adca_ix1", "ora_ix1",  "adda_ix1", "jmp_ix1",  "jsr_ix1",  "ldx_ix1",  "stx_ix1",
	"suba_ix",  "cmpa_ix",  "sbca_ix",  "cpx_ix",   "anda_ix",  "bita_ix",  "lda_ix",   "sta_ix",       /*F0*/
	"eora_ix",  "adca_ix",  "ora_ix",   "adda_ix",  "jmp_ix",   "jsr_ix",   "ldx_ix",   "stx_ix"
};
#endif

CPU_DISASSEMBLE( m6805 )
{
	int code, bit;
	UINT16 ea;
	UINT32 flags = 0;

	code = oprom[0];

	if (disasm[code][0] == bsr || disasm[code][0] == jsr)
		flags = DASMFLAG_STEP_OVER;
	else if (disasm[code][0] == rts || disasm[code][0] == rti)
		flags = DASMFLAG_STEP_OUT;

	buffer += sprintf(buffer, "%-6s", op_name_str[disasm[code][0]]);

	switch( disasm[code][1] )
	{
	case _btr:  /* bit test and relative branch */
		bit = (code >> 1) & 7;
		sprintf (buffer, "%d,$%02X,$%03X", bit, opram[1], pc + 3 + (INT8)opram[2]);
		return 3 | flags | DASMFLAG_SUPPORTED;
	case _bit:  /* bit test */
		bit = (code >> 1) & 7;
		sprintf (buffer, "%d,$%03X", bit, opram[1]);
		return 2 | flags | DASMFLAG_SUPPORTED;
	case _rel:  /* relative */
		sprintf (buffer, "$%03X", pc + 2 + (INT8)opram[1]);
		return 2 | flags | DASMFLAG_SUPPORTED;
	case _imm:  /* immediate */
		sprintf (buffer, "#$%02X", opram[1]);
		return 2 | flags | DASMFLAG_SUPPORTED;
	case _dir:  /* direct (zero page address) */
		sprintf (buffer, "$%02X", opram[1]);
		return 2 | flags | DASMFLAG_SUPPORTED;
	case _ext:  /* extended (16 bit address) */
		ea = (opram[1] << 8) + opram[2];
		sprintf (buffer, "$%04X", ea);
		return 3 | flags | DASMFLAG_SUPPORTED;
	case _idx:  /* indexed */
		sprintf (buffer, "(x)");
		return 1 | flags | DASMFLAG_SUPPORTED;
	case _ix1:  /* indexed + byte (zero page) */
		sprintf (buffer, "(x+$%02X)", opram[1]);
		return 2 | flags | DASMFLAG_SUPPORTED;
	case _ix2:  /* indexed + word (16 bit address) */
		ea = (opram[1] << 8) + opram[2];
		sprintf (buffer, "(x+$%04X)", ea);
		return 3 | flags | DASMFLAG_SUPPORTED;
	default:    /* implicit */
		return 1 | flags | DASMFLAG_SUPPORTED;
	}
}