![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dsp_disasm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src / dsp|
Return to dsp_disasm.c CVS log | Up to [Previous NeXT emulator] / previous_trunk / src / dsp |
1.1 root 1: /*
2: DSP M56001 emulation
3: Disassembler
4:
5: (C) 2003-2008 ARAnyM developer team
6:
7: This program is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2 of the License, or
10: (at your option) any later version.
11:
12: This program is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with this program; if not, write to the Free Software
19: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20: */
21:
22: #ifdef HAVE_CONFIG_H
23: #include "config.h"
24: #endif
25:
26: #include <string.h>
27: #include <stdlib.h>
28: #include <inttypes.h>
29: #include <stdbool.h>
30: #include <stdio.h>
31:
32: #include "dsp_core.h"
33: #include "dsp_cpu.h"
34: #include "dsp_disasm.h"
35: #include "profile.h"
36:
37:
38: /* More disasm infos, if wanted */
39: #define DSP_DISASM_REG_PC 0
40:
41: /**********************************
42: * Defines
43: **********************************/
44:
45: /**********************************
46: * Variables
47: **********************************/
48:
49: /* Current instruction */
50: static Uint32 cur_inst;
51: static Uint16 disasm_cur_inst_len;
52: static char str_instr[50];
53: static char str_instr2[120];
54: static char parallelmove_name[64];
55:
56: /* Previous instruction */
57: static Uint32 prev_inst_pc;
58: static bool isLooping;
59:
60: /* Used to display dc instead of unknown instruction for illegal opcodes */
61: static bool isInDisasmMode;
62:
63: void dsp56k_disasm_init(void)
64: {
65: prev_inst_pc = 0x10000; /* Init to an invalid value */
66: isLooping = false;
67: isInDisasmMode = false;
68: }
69:
70: /**********************************
71: * Register change
72: **********************************/
73:
74: static Uint32 registers_save[64];
75: #if DSP_DISASM_REG_PC
76: static Uint32 pc_save;
77: #endif
78:
79: static const char *registers_name[64]={
80: "","","","",
81: "x0","x1","y0","y1",
82: "a0","b0","a2","b2",
83: "a1","b1","a","b",
84:
85: "r0","r1","r2","r3",
86: "r4","r5","r6","r7",
87: "n0","n1","n2","n3",
88: "n4","n5","n6","n7",
89:
90: "m0","m1","m2","m3",
91: "m4","m5","m6","m7",
92: "","","","",
93: "","","","",
94:
95: "","","","",
96: "","","","",
97: "","sr","omr","sp",
98: "ssh","ssl","la","lc"
99: };
100:
101: /**********************************
102: * Opcode disassembler
103: **********************************/
104:
105: static Uint32 read_memory(Uint32 currPc);
106:
107: typedef void (*dsp_emul_t)(void);
108:
109: static void opcode8h_0(void);
110:
111: static int dsp_calc_ea(Uint32 ea_mode, char *dest);
112: static void dsp_calc_cc(Uint32 cc_mode, char *dest);
113: static void dsp_undefined(void);
114:
115: /* Instructions without parallel moves */
116: static void dsp_andi(void);
117: static void dsp_bchg_aa(void);
118: static void dsp_bchg_ea(void);
119: static void dsp_bchg_pp(void);
120: static void dsp_bchg_reg(void);
121: static void dsp_bclr_aa(void);
122: static void dsp_bclr_ea(void);
123: static void dsp_bclr_pp(void);
124: static void dsp_bclr_reg(void);
125: static void dsp_bset_aa(void);
126: static void dsp_bset_ea(void);
127: static void dsp_bset_pp(void);
128: static void dsp_bset_reg(void);
129: static void dsp_btst_aa(void);
130: static void dsp_btst_ea(void);
131: static void dsp_btst_pp(void);
132: static void dsp_btst_reg(void);
133: static void dsp_div(void);
134: static void dsp_enddo(void);
135: static void dsp_illegal(void);
136: static void dsp_jcc_imm(void);
137: static void dsp_jcc_ea(void);
138: static void dsp_jclr_aa(void);
139: static void dsp_jclr_ea(void);
140: static void dsp_jclr_pp(void);
141: static void dsp_jclr_reg(void);
142: static void dsp_jmp_ea(void);
143: static void dsp_jmp_imm(void);
144: static void dsp_jscc_ea(void);
145: static void dsp_jscc_imm(void);
146: static void dsp_jsclr_aa(void);
147: static void dsp_jsclr_ea(void);
148: static void dsp_jsclr_pp(void);
149: static void dsp_jsclr_reg(void);
150: static void dsp_jset_aa(void);
151: static void dsp_jset_ea(void);
152: static void dsp_jset_pp(void);
153: static void dsp_jset_reg(void);
154: static void dsp_jsr_ea(void);
155: static void dsp_jsr_imm(void);
156: static void dsp_jsset_aa(void);
157: static void dsp_jsset_ea(void);
158: static void dsp_jsset_pp(void);
159: static void dsp_jsset_reg(void);
160: static void dsp_lua(void);
161: static void dsp_movem_ea(void);
162: static void dsp_movem_aa(void);
163: static void dsp_nop(void);
164: static void dsp_norm(void);
165: static void dsp_ori(void);
166: static void dsp_reset(void);
167: static void dsp_rti(void);
168: static void dsp_rts(void);
169: static void dsp_stop(void);
170: static void dsp_swi(void);
171: static void dsp_tcc(void);
172: static void dsp_wait(void);
173: static void dsp_do_ea(void);
174: static void dsp_do_aa(void);
175: static void dsp_do_imm(void);
176: static void dsp_do_reg(void);
177: static void dsp_rep_aa(void);
178: static void dsp_rep_ea(void);
179: static void dsp_rep_imm(void);
180: static void dsp_rep_reg(void);
181: static void dsp_movec_aa(void);
182: static void dsp_movec_ea(void);
183: static void dsp_movec_imm(void);
184: static void dsp_movec_reg(void);
185: static void dsp_movep_0(void);
186: static void dsp_movep_1(void);
187: static void dsp_movep_23(void);
188:
189: /* Parallel moves */
190: static void dsp_pm_class2(void);
191: static void dsp_pm(void);
192: static void dsp_pm_0(void);
193: static void dsp_pm_1(void);
194: static void dsp_pm_2(void);
195: static void dsp_pm_4(void);
196: static void dsp_pm_8(void);
197:
198:
199: static const dsp_emul_t opcodes8h[512] = {
200: /* 0x00 - 0x3f */
201: opcode8h_0, dsp_undefined, dsp_undefined, dsp_undefined, opcode8h_0, dsp_andi, dsp_undefined, dsp_ori,
202: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_andi, dsp_undefined, dsp_ori,
203: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_andi, dsp_undefined, dsp_ori,
204: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_andi, dsp_undefined, dsp_ori,
205: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
206: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
207: dsp_undefined, dsp_undefined, dsp_div, dsp_div, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
208: dsp_norm, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
209:
210: /* 0x40 - 0x7f */
211: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
212: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
213: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
214: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
215: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
216: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
217: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
218: dsp_tcc, dsp_tcc, dsp_tcc, dsp_tcc, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
219:
220: /* 0x80 - 0xbf */
221: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
222: dsp_lua, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movec_reg, dsp_undefined, dsp_undefined,
223: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
224: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movec_reg, dsp_undefined, dsp_undefined,
225: dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined,
226: dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined,
227: dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_aa, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined,
228: dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_ea, dsp_undefined, dsp_movec_imm, dsp_undefined, dsp_undefined,
229:
230: /* 0xc0 - 0xff */
231: dsp_do_aa, dsp_rep_aa, dsp_do_aa, dsp_rep_aa, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined,
232: dsp_do_ea, dsp_rep_ea, dsp_do_ea, dsp_rep_ea, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined,
233: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined,
234: dsp_do_reg, dsp_rep_reg, dsp_undefined, dsp_undefined, dsp_do_imm, dsp_rep_imm, dsp_undefined, dsp_undefined,
235: dsp_movem_aa, dsp_movem_aa, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
236: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movem_ea, dsp_movem_ea, dsp_undefined, dsp_undefined,
237: dsp_movem_aa, dsp_movem_aa, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
238: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_movem_ea, dsp_movem_ea, dsp_undefined, dsp_undefined,
239:
240: /* 0x100 - 0x13f */
241: dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2,
242: dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23,
243: dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2,
244: dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23,
245: dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2,
246: dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23,
247: dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2, dsp_pm_class2,
248: dsp_movep_0, dsp_movep_0, dsp_movep_1, dsp_movep_1, dsp_movep_23, dsp_movep_23, dsp_movep_23, dsp_movep_23,
249:
250: /* 0x140 - 0x17f */
251: dsp_bclr_aa, dsp_bset_aa, dsp_bclr_aa, dsp_bset_aa, dsp_jclr_aa, dsp_jset_aa, dsp_jclr_aa, dsp_jset_aa,
252: dsp_bclr_ea, dsp_bset_ea, dsp_bclr_ea, dsp_bset_ea, dsp_jclr_ea, dsp_jset_ea, dsp_jclr_ea, dsp_jset_ea,
253: dsp_bclr_pp, dsp_bset_pp, dsp_bclr_pp, dsp_bset_pp, dsp_jclr_pp, dsp_jset_pp, dsp_jclr_pp, dsp_jset_pp,
254: dsp_jclr_reg, dsp_jset_reg, dsp_bclr_reg, dsp_bset_reg, dsp_jmp_ea, dsp_jcc_ea, dsp_undefined, dsp_undefined,
255: dsp_bchg_aa, dsp_btst_aa, dsp_bchg_aa, dsp_btst_aa, dsp_jsclr_aa, dsp_jsset_aa, dsp_jsclr_aa, dsp_jsset_aa,
256: dsp_bchg_ea, dsp_btst_ea, dsp_bchg_ea, dsp_btst_ea, dsp_jsclr_ea, dsp_jsset_ea, dsp_jsclr_ea, dsp_jsset_ea,
257: dsp_bchg_pp, dsp_btst_pp, dsp_bchg_pp, dsp_btst_pp, dsp_jsclr_pp, dsp_jsset_pp, dsp_jsclr_pp, dsp_jsset_pp,
258: dsp_jsclr_reg, dsp_jsset_reg, dsp_bchg_reg, dsp_btst_reg, dsp_jsr_ea, dsp_jscc_ea, dsp_undefined, dsp_undefined,
259:
260: /* 0x180 - 0x1bf */
261: dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm, dsp_jmp_imm,
262: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
263: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
264: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
265: dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm, dsp_jsr_imm,
266: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
267: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
268: dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined, dsp_undefined,
269:
270: /* 0x1c0 - 0x1ff */
271: dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm,
272: dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm,
273: dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm,
274: dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm, dsp_jcc_imm,
275: dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm,
276: dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm,
277: dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm,
278: dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm, dsp_jscc_imm,
279: };
280:
281: static const char* opcodes_alu[256] = {
282: /* 0x00 - 0x3f */
283: "move" , "tfr b,a", "addr b,a", "tst a", "undefined", "cmp b,a" , "subr b,a", "cmpm b,a",
284: "undefined", "tfr a,b", "addr a,b", "tst b", "undefined", "cmp a,b" , "subr a,b", "cmpm a,b",
285: "add b,a" , "rnd a" , "addl b,a", "clr a", "sub b,a" , "undefined", "subl b,a", "not a",
286: "add a,b" , "rnd b" , "addl a,b", "clr b", "sub a,b" , "undefined", "subl a,b", "not b",
287: "add x,a" , "adc x,a", "asr a" , "lsr a", "sub x,a" , "sbc x,a" , "abs a" , "ror a",
288: "add x,b" , "adc x,b", "asr b" , "lsr b", "sub x,b" , "sbc x,b" , "abs b" , "ror b",
289: "add y,a" , "adc y,a", "asl a" , "lsl a", "sub y,a" , "sbc y,a" , "neg a" , "rol a",
290: "add y,b" , "adc y,b", "asl b" , "lsl b", "sub y,b" , "sbc y,b" , "neg b" , "rol b",
291:
292: /* 0x40 - 0x7f */
293: "add x0,a", "tfr x0,a", "or x0,a", "eor x0,a", "sub x0,a", "cmp x0,a", "and x0,a", "cmpm x0,a",
294: "add x0,b", "tfr x0,b", "or x0,b", "eor x0,b", "sub x0,b", "cmp x0,b", "and x0,b", "cmpm x0,b",
295: "add y0,a", "tfr y0,a", "or y0,a", "eor y0,a", "sub y0,a", "cmp y0,a", "and y0,a", "cmpm y0,a",
296: "add y0,b", "tfr y0,b", "or y0,b", "eor y0,b", "sub y0,b", "cmp y0,b", "and y0,b", "cmpm y0,b",
297: "add x1,a", "tfr x1,a", "or x1,a", "eor x1,a", "sub x1,a", "cmp x1,a", "and x1,a", "cmpm x1,a",
298: "add x1,b", "tfr x1,b", "or x1,b", "eor x1,b", "sub x1,b", "cmp x1,b", "and x1,b", "cmpm x1,b",
299: "add y1,a", "tfr y1,a", "or y1,a", "eor y1,a", "sub y1,a", "cmp y1,a", "and y1,a", "cmpm y1,a",
300: "add y1,b", "tfr y1,b", "or y1,b", "eor y1,b", "sub y1,b", "cmp y1,b", "and y1,b", "cmpm y1,b",
301:
302: /* 0x80 - 0xbf */
303: "mpy +x0,x0,a", "mpyr +x0,x0,a", "mac +x0,x0,a", "macr +x0,x0,a", "mpy -x0,x0,a", "mpyr -x0,x0,a", "mac -x0,x0,a", "macr -x0,x0,a",
304: "mpy +x0,x0,b", "mpyr +x0,x0,b", "mac +x0,x0,b", "macr +x0,x0,b", "mpy -x0,x0,b", "mpyr -x0,x0,b", "mac -x0,x0,b", "macr -x0,x0,b",
305: "mpy +y0,y0,a", "mpyr +y0,y0,a", "mac +y0,y0,a", "macr +y0,y0,a", "mpy -y0,y0,a", "mpyr -y0,y0,a", "mac -y0,y0,a", "macr -y0,y0,a",
306: "mpy +y0,y0,b", "mpyr +y0,y0,b", "mac +y0,y0,b", "macr +y0,y0,b", "mpy -y0,y0,b", "mpyr -y0,y0,b", "mac -y0,y0,b", "macr -y0,y0,b",
307: "mpy +x1,x0,a", "mpyr +x1,x0,a", "mac +x1,x0,a", "macr +x1,x0,a", "mpy -x1,x0,a", "mpyr -x1,x0,a", "mac -x1,x0,a", "macr -x1,x0,a",
308: "mpy +x1,x0,b", "mpyr +x1,x0,b", "mac +x1,x0,b", "macr +x1,x0,b", "mpy -x1,x0,b", "mpyr -x1,x0,b", "mac -x1,x0,b", "macr -x1,x0,b",
309: "mpy +y1,y0,a", "mpyr +y1,y0,a", "mac +y1,y0,a", "macr +y1,y0,a", "mpy -y1,y0,a", "mpyr -y1,y0,a", "mac -y1,y0,a", "macr -y1,y0,a",
310: "mpy +y1,y0,b", "mpyr +y1,y0,b", "mac +y1,y0,b", "macr +y1,y0,b", "mpy -y1,y0,b", "mpyr -y1,y0,b", "mac -y1,y0,b", "macr -y1,y0,b",
311:
312: /* 0xc0 - 0xff */
313: "mpy +x0,y1,a", "mpyr +x0,y1,a", "mac +x0,y1,a", "macr +x0,y1,a", "mpy -x0,y1,a", "mpyr -x0,y1,a", "mac -x0,y1,a", "macr -x0,y1,a",
314: "mpy +x0,y1,b", "mpyr +x0,y1,b", "mac +x0,y1,b", "macr +x0,y1,b", "mpy -x0,y1,b", "mpyr -x0,y1,b", "mac -x0,y1,b", "macr -x0,y1,b",
315: "mpy +y0,x0,a", "mpyr +y0,x0,a", "mac +y0,x0,a", "macr +y0,x0,a", "mpy -y0,x0,a", "mpyr -y0,x0,a", "mac -y0,x0,a", "macr -y0,x0,a",
316: "mpy +y0,x0,b", "mpyr +y0,x0,b", "mac +y0,x0,b", "macr +y0,x0,b", "mpy -y0,x0,b", "mpyr -y0,x0,b", "mac -y0,x0,b", "macr -y0,x0,b",
317: "mpy +x1,y0,a", "mpyr +x1,y0,a", "mac +x1,y0,a", "macr +x1,y0,a", "mpy -x1,y0,a", "mpyr -x1,y0,a", "mac -x1,y0,a", "macr -x1,y0,a",
318: "mpy +x1,y0,b", "mpyr +x1,y0,b", "mac +x1,y0,b", "macr +x1,y0,b", "mpy -x1,y0,b", "mpyr -x1,y0,b", "mac -x1,y0,b", "macr -x1,y0,b",
319: "mpy +y1,x1,a", "mpyr +y1,x1,a", "mac +y1,x1,a", "macr +y1,x1,a", "mpy -y1,x1,a", "mpyr -y1,x1,a", "mac -y1,x1,a", "macr -y1,x1,a",
320: "mpy +y1,x1,b", "mpyr +y1,x1,b", "mac +y1,x1,b", "macr +y1,x1,b", "mpy -y1,x1,b", "mpyr -y1,x1,b", "mac -y1,x1,b", "macr -y1,x1,b"
321: };
322:
323:
324:
325: static const dsp_emul_t opcodes_parmove[16] = {
326: dsp_pm_0,
327: dsp_pm_1,
328: dsp_pm_2,
329: dsp_pm_2,
330: dsp_pm_4,
331: dsp_pm_4,
332: dsp_pm_4,
333: dsp_pm_4,
334:
335: dsp_pm_8,
336: dsp_pm_8,
337: dsp_pm_8,
338: dsp_pm_8,
339: dsp_pm_8,
340: dsp_pm_8,
341: dsp_pm_8,
342: dsp_pm_8
343: };
344:
345: static const int registers_tcc[16][2] = {
346: {DSP_REG_B,DSP_REG_A},
347: {DSP_REG_A,DSP_REG_B},
348: {DSP_REG_NULL,DSP_REG_NULL},
349: {DSP_REG_NULL,DSP_REG_NULL},
350:
351: {DSP_REG_NULL,DSP_REG_NULL},
352: {DSP_REG_NULL,DSP_REG_NULL},
353: {DSP_REG_NULL,DSP_REG_NULL},
354: {DSP_REG_NULL,DSP_REG_NULL},
355:
356: {DSP_REG_X0,DSP_REG_A},
357: {DSP_REG_X0,DSP_REG_B},
358: {DSP_REG_Y0,DSP_REG_A},
359: {DSP_REG_Y0,DSP_REG_B},
360:
361: {DSP_REG_X1,DSP_REG_A},
362: {DSP_REG_X1,DSP_REG_B},
363: {DSP_REG_Y1,DSP_REG_A},
364: {DSP_REG_Y1,DSP_REG_B}
365: };
366:
367: static const char *registers_lmove[8] = {
368: "a10",
369: "b10",
370: "x",
371: "y",
372: "a",
373: "b",
374: "ab",
375: "ba"
376: };
377:
378: static const char *ea_names[9] = {
379: "(r%d)-n%d", /* 000xxx */
380: "(r%d)+n%d", /* 001xxx */
381: "(r%d)-", /* 010xxx */
382: "(r%d)+", /* 011xxx */
383: "(r%d)", /* 100xxx */
384: "(r%d+n%d)", /* 101xxx */
385: "$%04x", /* 110000 */
386: "-(r%d)", /* 111xxx */
387: "$%06x" /* 110100 */
388: };
389:
390: static const char *cc_name[16] = {
391: "cc",
392: "ge",
393: "ne",
394: "pl",
395: "nn",
396: "ec",
397: "lc",
398: "gt",
399:
400: "cs",
401: "lt",
402: "eq",
403: "mi",
404: "nr",
405: "es",
406: "ls",
407: "le"
408: };
409:
410: void dsp56k_disasm_reg_save(void)
411: {
412: memcpy(registers_save, dsp_core.registers , sizeof(registers_save));
413: #if DSP_DISASM_REG_PC
414: pc_save = dsp_core.pc;
415: #endif
416: }
417:
418: void dsp56k_disasm_reg_compare(void)
419: {
420: int i;
421: bool bRegA = false;
422: bool bRegB = false;
423:
424: for (i=4; i<64; i++) {
425: if (registers_save[i] == dsp_core.registers[i]) {
426: continue;
427: }
428:
429: switch(i) {
430: case DSP_REG_X0:
431: case DSP_REG_X1:
432: case DSP_REG_Y0:
433: case DSP_REG_Y1:
434: fprintf(stderr,"\tReg: %s $%06x -> $%06x\n", registers_name[i], registers_save[i], dsp_core.registers[i]);
435: break;
436: case DSP_REG_R0:
437: case DSP_REG_R1:
438: case DSP_REG_R2:
439: case DSP_REG_R3:
440: case DSP_REG_R4:
441: case DSP_REG_R5:
442: case DSP_REG_R6:
443: case DSP_REG_R7:
444: case DSP_REG_M0:
445: case DSP_REG_M1:
446: case DSP_REG_M2:
447: case DSP_REG_M3:
448: case DSP_REG_M4:
449: case DSP_REG_M5:
450: case DSP_REG_M6:
451: case DSP_REG_M7:
452: case DSP_REG_N0:
453: case DSP_REG_N1:
454: case DSP_REG_N2:
455: case DSP_REG_N3:
456: case DSP_REG_N4:
457: case DSP_REG_N5:
458: case DSP_REG_N6:
459: case DSP_REG_N7:
460: case DSP_REG_SR:
461: case DSP_REG_LA:
462: case DSP_REG_LC:
463: fprintf(stderr,"\tReg: %s $%04x -> $%04x\n", registers_name[i], registers_save[i], dsp_core.registers[i]);
464: break;
465: case DSP_REG_OMR:
466: case DSP_REG_SP:
467: case DSP_REG_SSH:
468: case DSP_REG_SSL:
469: fprintf(stderr,"\tReg: %s $%02x -> $%02x\n", registers_name[i], registers_save[i], dsp_core.registers[i]);
470: break;
471: case DSP_REG_A0:
472: case DSP_REG_A1:
473: case DSP_REG_A2:
474: if (bRegA == false) {
475: fprintf(stderr,"\tReg: a $%02x:%06x:%06x -> $%02x:%06x:%06x\n",
476: registers_save[DSP_REG_A2], registers_save[DSP_REG_A1], registers_save[DSP_REG_A0],
477: dsp_core.registers[DSP_REG_A2], dsp_core.registers[DSP_REG_A1], dsp_core.registers[DSP_REG_A0]
478: );
479: bRegA = true;
480: }
481: break;
482: case DSP_REG_B0:
483: case DSP_REG_B1:
484: case DSP_REG_B2:
485: if (bRegB == false) {
486: fprintf(stderr,"\tReg: b $%02x:%06x:%06x -> $%02x:%06x:%06x\n",
487: registers_save[DSP_REG_B2], registers_save[DSP_REG_B1], registers_save[DSP_REG_B0],
488: dsp_core.registers[DSP_REG_B2], dsp_core.registers[DSP_REG_B1], dsp_core.registers[DSP_REG_B0]
489: );
490: bRegB = true;
491: }
492: break;
493: }
494: }
495:
496: #if DSP_DISASM_REG_PC
497: if (pc_save != dsp_core.pc) {
498: fprintf(stderr,"\tReg: pc $%04x -> $%04x\n", pc_save, dsp_core.pc);
499: }
500: #endif
501: }
502:
503: Uint16 dsp56k_disasm(dsp_trace_disasm_t mode)
504: {
505: Uint32 value;
506:
507: if (mode == DSP_TRACE_MODE) {
508: isInDisasmMode = false;
509: if (prev_inst_pc == dsp_core.pc) {
510: if (!isLooping) {
511: fprintf(stderr, "Looping on DSP instruction at PC = $%04x\n", prev_inst_pc);
512: isLooping = true;
513: }
514: return 0;
515: }
516: }
517: else {
518: isInDisasmMode = true;
519: }
520:
521: prev_inst_pc = dsp_core.pc;
522: isLooping = false;
523:
524: cur_inst = read_memory(dsp_core.pc);
525: disasm_cur_inst_len = 1;
526:
527: strcpy(parallelmove_name, "");
528:
529: if (cur_inst < 0x100000) {
530: value = (cur_inst >> 11) & (BITMASK(6) << 3);
531: value += (cur_inst >> 5) & BITMASK(3);
532: opcodes8h[value]();
533: } else {
534: dsp_pm();
535: sprintf(str_instr, "%s %s", opcodes_alu[cur_inst & BITMASK(8)], parallelmove_name);
536: }
537: return disasm_cur_inst_len;
538: }
539:
540: /**
541: * dsp56k_getInstrText : return the disasembled instructions
542: */
543: const char* dsp56k_getInstructionText(void)
544: {
545: const int len = sizeof(str_instr);
546: Uint64 count, cycles = 0;
547: Uint16 cycle_diff = 0;
548: float percentage;
549: int offset;
550:
551: if (isLooping) {
552: *str_instr2 = 0;
553: }
554: if (disasm_cur_inst_len == 1) {
555: offset = sprintf(str_instr2, "p:%04x %06x (%02d cyc) %-*s\n", prev_inst_pc, cur_inst, dsp_core.instr_cycle, len, str_instr);
556: } else {
557: offset = sprintf(str_instr2, "p:%04x %06x %06x (%02d cyc) %-*s\n", prev_inst_pc, cur_inst, read_memory(prev_inst_pc + 1), dsp_core.instr_cycle, len, str_instr);
558: }
559: if (offset > 2 && Profile_DspAddressData(prev_inst_pc, (Uint32*)&percentage, (Uint32*)&count/*, &cycles, &cycle_diff*/)) {
560: offset -= 2;
561: sprintf(str_instr2+offset, "%5.2f%% (%"PRId64", %"PRId64", %d)\n",
562: percentage, count, cycles, cycle_diff);
563: }
564: return str_instr2;
565: }
566:
567: static void dsp_pm_class2(void) {
568: dsp_pm();
569: sprintf(str_instr, "%s %s", opcodes_alu[cur_inst & BITMASK(8)], parallelmove_name);
570: }
571:
572: static Uint32 read_memory(Uint32 currPc)
573: {
574: Uint32 value;
575:
576: if (currPc<0x200) {
577: value = dsp_core.ramint[DSP_SPACE_P][currPc];
578: } else {
579: value = dsp_core.ramext[currPc & (DSP_RAMSIZE-1)];
580: }
581:
582: return value & BITMASK(24);
583: }
584:
585: /**********************************
586: * Conditions code calculation
587: **********************************/
588:
589: static void dsp_calc_cc(Uint32 cc_mode, char *dest)
590: {
591: strcpy(dest, cc_name[cc_mode & BITMASK(4)]);
592: }
593:
594: /**********************************
595: * Effective address calculation
596: **********************************/
597:
598: static int dsp_calc_ea(Uint32 ea_mode, char *dest)
599: {
600: int value, retour, numreg;
601:
602: value = (ea_mode >> 3) & BITMASK(3);
603: numreg = ea_mode & BITMASK(3);
604: retour = 0;
605: switch (value) {
606: case 0:
607: /* (Rx)-Nx */
608: sprintf(dest, ea_names[value], numreg, numreg);
609: break;
610: case 1:
611: /* (Rx)+Nx */
612: sprintf(dest, ea_names[value], numreg, numreg);
613: break;
614: case 5:
615: /* (Rx+Nx) */
616: sprintf(dest, ea_names[value], numreg, numreg);
617: break;
618: case 2:
619: /* (Rx)- */
620: sprintf(dest, ea_names[value], numreg);
621: break;
622: case 3:
623: /* (Rx)+ */
624: sprintf(dest, ea_names[value], numreg);
625: break;
626: case 4:
627: /* (Rx) */
628: sprintf(dest, ea_names[value], numreg);
629: break;
630: case 7:
631: /* -(Rx) */
632: sprintf(dest, ea_names[value], numreg);
633: break;
634: case 6:
635: disasm_cur_inst_len++;
636: switch ((ea_mode >> 2) & 1) {
637: case 0:
638: /* Absolute address */
639: sprintf(dest, ea_names[value], read_memory(dsp_core.pc+1));
640: break;
641: case 1:
642: /* Immediate value */
643: sprintf(dest, ea_names[8], read_memory(dsp_core.pc+1));
644: retour = 1;
645: break;
646: }
647: break;
648: }
649: return retour;
650: }
651:
652: static void opcode8h_0(void)
653: {
654: switch(cur_inst) {
655: case 0x000000:
656: dsp_nop();
657: break;
658: case 0x000004:
659: dsp_rti();
660: break;
661: case 0x000005:
662: dsp_illegal();
663: break;
664: case 0x000006:
665: dsp_swi();
666: break;
667: case 0x00000c:
668: dsp_rts();
669: break;
670: case 0x000084:
671: dsp_reset();
672: break;
673: case 0x000086:
674: dsp_wait();
675: break;
676: case 0x000087:
677: dsp_stop();
678: break;
679: case 0x00008c:
680: dsp_enddo();
681: break;
682: default:
683: dsp_undefined();
684: break;
685: }
686: }
687:
688: /**********************************
689: * Non-parallel moves instructions
690: **********************************/
691:
692: static void dsp_undefined(void)
693: {
694: /* In Disasm mode, display dc instruction_opcode */
695: if (isInDisasmMode)
696: sprintf(str_instr, "dc $%06x", cur_inst);
697: /* In trace mode, display unknown instruction */
698: else
699: sprintf(str_instr, "$%06x unknown instruction", cur_inst);
700: }
701:
702: static void dsp_andi(void)
703: {
704: switch(cur_inst & BITMASK(2)) {
705: case 0:
706: sprintf(str_instr, "andi #$%02x,mr", (cur_inst>>8) & BITMASK(8));
707: break;
708: case 1:
709: sprintf(str_instr, "andi #$%02x,ccr", (cur_inst>>8) & BITMASK(8));
710: break;
711: case 2:
712: sprintf(str_instr, "andi #$%02x,omr", (cur_inst>>8) & BITMASK(8));
713: break;
714: default:
715: break;
716: }
717: }
718:
719: static void dsp_bchg_aa(void)
720: {
721: /* bchg #n,x:aa */
722: /* bchg #n,y:aa */
723: char name[16];
724: Uint32 memspace, value, numbit;
725:
726: memspace = (cur_inst>>6) & 1;
727: value = (cur_inst>>8) & BITMASK(6);
728: numbit = cur_inst & BITMASK(5);
729:
730: if (memspace) {
731: sprintf(name,"y:$%04x",value);
732: } else {
733: sprintf(name,"x:$%04x",value);
734: }
735:
736: sprintf(str_instr,"bchg #%d,%s", numbit, name);
737: }
738:
739: static void dsp_bchg_ea(void)
740: {
741: /* bchg #n,x:ea */
742: /* bchg #n,y:ea */
743: char name[16], addr_name[16];
744: Uint32 memspace, value, numbit;
745:
746: memspace = (cur_inst>>6) & 1;
747: value = (cur_inst>>8) & BITMASK(6);
748: numbit = cur_inst & BITMASK(5);
749:
750: dsp_calc_ea(value, addr_name);
751: if (memspace) {
752: sprintf(name,"y:%s",addr_name);
753: } else {
754: sprintf(name,"x:%s",addr_name);
755: }
756:
757: sprintf(str_instr,"bchg #%d,%s", numbit, name);
758: }
759:
760: static void dsp_bchg_pp(void)
761: {
762: /* bchg #n,x:pp */
763: /* bchg #n,y:pp */
764: char name[16];
765: Uint32 memspace, value, numbit;
766:
767: memspace = (cur_inst>>6) & 1;
768: value = (cur_inst>>8) & BITMASK(6);
769: numbit = cur_inst & BITMASK(5);
770:
771: if (memspace) {
772: sprintf(name,"y:$%04x",value+0xffc0);
773: } else {
774: sprintf(name,"x:$%04x",value+0xffc0);
775: }
776:
777: sprintf(str_instr,"bchg #%d,%s", numbit, name);
778: }
779:
780: static void dsp_bchg_reg(void)
781: {
782: /* bchg #n,R */
783: Uint32 value, numbit;
784:
785: value = (cur_inst>>8) & BITMASK(6);
786: numbit = cur_inst & BITMASK(5);
787:
788: sprintf(str_instr,"bchg #%d,%s", numbit, registers_name[value]);
789: }
790:
791: static void dsp_bclr_aa(void)
792: {
793: /* bclr #n,x:aa */
794: /* bclr #n,y:aa */
795: char name[16];
796: Uint32 memspace, value, numbit;
797:
798: memspace = (cur_inst>>6) & 1;
799: value = (cur_inst>>8) & BITMASK(6);
800: numbit = cur_inst & BITMASK(5);
801:
802: if (memspace) {
803: sprintf(name,"y:$%04x",value);
804: } else {
805: sprintf(name,"x:$%04x",value);
806: }
807:
808: sprintf(str_instr,"bclr #%d,%s", numbit, name);
809: }
810:
811: static void dsp_bclr_ea(void)
812: {
813: /* bclr #n,x:ea */
814: /* bclr #n,y:ea */
815: char name[16], addr_name[16];
816: Uint32 memspace, value, numbit;
817:
818: memspace = (cur_inst>>6) & 1;
819: value = (cur_inst>>8) & BITMASK(6);
820: numbit = cur_inst & BITMASK(5);
821:
822: dsp_calc_ea(value, addr_name);
823: if (memspace) {
824: sprintf(name,"y:%s",addr_name);
825: } else {
826: sprintf(name,"x:%s",addr_name);
827: }
828:
829: sprintf(str_instr,"bclr #%d,%s", numbit, name);
830: }
831:
832: static void dsp_bclr_pp(void)
833: {
834: /* bclr #n,x:pp */
835: /* bclr #n,y:pp */
836: char name[16];
837: Uint32 memspace, value, numbit;
838:
839: memspace = (cur_inst>>6) & 1;
840: value = (cur_inst>>8) & BITMASK(6);
841: numbit = cur_inst & BITMASK(5);
842:
843: if (memspace) {
844: sprintf(name,"y:$%04x",value+0xffc0);
845: } else {
846: sprintf(name,"x:$%04x",value+0xffc0);
847: }
848:
849: sprintf(str_instr,"bclr #%d,%s", numbit, name);
850: }
851:
852: static void dsp_bclr_reg(void)
853: {
854: /* bclr #n,R */
855: Uint32 value, numbit;
856:
857: value = (cur_inst>>8) & BITMASK(6);
858: numbit = cur_inst & BITMASK(5);
859:
860: sprintf(str_instr,"bclr #%d,%s", numbit, registers_name[value]);
861: }
862:
863: static void dsp_bset_aa(void)
864: {
865: /* bset #n,x:aa */
866: /* bset #n,y:aa */
867: char name[16];
868: Uint32 memspace, value, numbit;
869:
870: memspace = (cur_inst>>6) & 1;
871: value = (cur_inst>>8) & BITMASK(6);
872: numbit = cur_inst & BITMASK(5);
873:
874: if (memspace) {
875: sprintf(name,"y:$%04x",value);
876: } else {
877: sprintf(name,"x:$%04x",value);
878: }
879:
880: sprintf(str_instr,"bset #%d,%s", numbit, name);
881: }
882:
883: static void dsp_bset_ea(void)
884: {
885: /* bset #n,x:ea */
886: /* bset #n,y:ea */
887: char name[16], addr_name[16];
888: Uint32 memspace, value, numbit;
889:
890: memspace = (cur_inst>>6) & 1;
891: value = (cur_inst>>8) & BITMASK(6);
892: numbit = cur_inst & BITMASK(5);
893:
894: dsp_calc_ea(value, addr_name);
895: if (memspace) {
896: sprintf(name,"y:%s",addr_name);
897: } else {
898: sprintf(name,"x:%s",addr_name);
899: }
900:
901: sprintf(str_instr,"bset #%d,%s", numbit, name);
902: }
903:
904: static void dsp_bset_pp(void)
905: {
906: /* bset #n,x:pp */
907: /* bset #n,y:pp */
908: char name[16];
909: Uint32 memspace, value, numbit;
910:
911: memspace = (cur_inst>>6) & 1;
912: value = (cur_inst>>8) & BITMASK(6);
913: numbit = cur_inst & BITMASK(5);
914:
915: if (memspace) {
916: sprintf(name,"y:$%04x",value+0xffc0);
917: } else {
918: sprintf(name,"x:$%04x",value+0xffc0);
919: }
920:
921: sprintf(str_instr,"bset #%d,%s", numbit, name);
922: }
923:
924: static void dsp_bset_reg(void)
925: {
926: /* bset #n,R */
927: Uint32 value, numbit;
928:
929: value = (cur_inst>>8) & BITMASK(6);
930: numbit = cur_inst & BITMASK(5);
931:
932: sprintf(str_instr,"bset #%d,%s", numbit, registers_name[value]);
933: }
934:
935: static void dsp_btst_aa(void)
936: {
937: /* btst #n,x:aa */
938: /* btst #n,y:aa */
939: char name[16];
940: Uint32 memspace, value, numbit;
941:
942: memspace = (cur_inst>>6) & 1;
943: value = (cur_inst>>8) & BITMASK(6);
944: numbit = cur_inst & BITMASK(5);
945:
946: if (memspace) {
947: sprintf(name,"y:$%04x",value);
948: } else {
949: sprintf(name,"x:$%04x",value);
950: }
951:
952: sprintf(str_instr,"btst #%d,%s", numbit, name);
953: }
954:
955: static void dsp_btst_ea(void)
956: {
957: /* btst #n,x:ea */
958: /* btst #n,y:ea */
959: char name[16], addr_name[16];
960: Uint32 memspace, value, numbit;
961:
962: memspace = (cur_inst>>6) & 1;
963: value = (cur_inst>>8) & BITMASK(6);
964: numbit = cur_inst & BITMASK(5);
965:
966: dsp_calc_ea(value, addr_name);
967: if (memspace) {
968: sprintf(name,"y:%s",addr_name);
969: } else {
970: sprintf(name,"x:%s",addr_name);
971: }
972:
973: sprintf(str_instr,"btst #%d,%s", numbit, name);
974: }
975:
976: static void dsp_btst_pp(void)
977: {
978: /* btst #n,x:pp */
979: /* btst #n,y:pp */
980: char name[16];
981: Uint32 memspace, value, numbit;
982:
983: memspace = (cur_inst>>6) & 1;
984: value = (cur_inst>>8) & BITMASK(6);
985: numbit = cur_inst & BITMASK(5);
986:
987: if (memspace) {
988: sprintf(name,"y:$%04x",value+0xffc0);
989: } else {
990: sprintf(name,"x:$%04x",value+0xffc0);
991: }
992:
993: sprintf(str_instr,"btst #%d,%s", numbit, name);
994: }
995:
996: static void dsp_btst_reg(void)
997: {
998: /* btst #n,R */
999: Uint32 value, numbit;
1000:
1001: value = (cur_inst>>8) & BITMASK(6);
1002: numbit = cur_inst & BITMASK(5);
1003:
1004: sprintf(str_instr,"btst #%d,%s", numbit, registers_name[value]);
1005: }
1006:
1007: static void dsp_div(void)
1008: {
1009: Uint32 srcreg=DSP_REG_NULL, destreg;
1010:
1011: switch((cur_inst>>4) & BITMASK(2)) {
1012: case 0:
1013: srcreg = DSP_REG_X0;
1014: break;
1015: case 1:
1016: srcreg = DSP_REG_Y0;
1017: break;
1018: case 2:
1019: srcreg = DSP_REG_X1;
1020: break;
1021: case 3:
1022: srcreg = DSP_REG_Y1;
1023: break;
1024: }
1025: destreg = DSP_REG_A+((cur_inst>>3) & 1);
1026:
1027: sprintf(str_instr,"div %s,%s", registers_name[srcreg],registers_name[destreg]);
1028: }
1029:
1030: static void dsp_do_aa(void)
1031: {
1032: char name[16];
1033:
1034: disasm_cur_inst_len++;
1035:
1036: if (cur_inst & (1<<6)) {
1037: sprintf(name, "y:$%04x", (cur_inst>>8) & BITMASK(6));
1038: } else {
1039: sprintf(name, "x:$%04x", (cur_inst>>8) & BITMASK(6));
1040: }
1041:
1042: sprintf(str_instr,"do %s,p:$%04x",
1043: name,
1044: read_memory(dsp_core.pc+1)
1045: );
1046: }
1047:
1048: static void dsp_do_imm(void)
1049: {
1050: disasm_cur_inst_len++;
1051:
1052: sprintf(str_instr,"do #$%04x,p:$%04x",
1053: ((cur_inst>>8) & BITMASK(8))|((cur_inst & BITMASK(4))<<8),
1054: read_memory(dsp_core.pc+1)
1055: );
1056: }
1057:
1058: static void dsp_do_ea(void)
1059: {
1060: char addr_name[16], name[16];
1061: Uint32 ea_mode;
1062:
1063: disasm_cur_inst_len++;
1064:
1065: ea_mode = (cur_inst>>8) & BITMASK(6);
1066: dsp_calc_ea(ea_mode, addr_name);
1067:
1068: if (cur_inst & (1<<6)) {
1069: sprintf(name, "y:%s", addr_name);
1070: } else {
1071: sprintf(name, "x:%s", addr_name);
1072: }
1073:
1074: sprintf(str_instr,"do %s,p:$%04x",
1075: name,
1076: read_memory(dsp_core.pc+1)
1077: );
1078: }
1079:
1080: static void dsp_do_reg(void)
1081: {
1082: disasm_cur_inst_len++;
1083:
1084: sprintf(str_instr,"do %s,p:$%04x",
1085: registers_name[(cur_inst>>8) & BITMASK(6)],
1086: read_memory(dsp_core.pc+1)
1087: );
1088: }
1089:
1090: static void dsp_enddo(void)
1091: {
1092: sprintf(str_instr,"enddo");
1093: }
1094:
1095: static void dsp_illegal(void)
1096: {
1097: sprintf(str_instr,"illegal");
1098: }
1099:
1100: static void dsp_jcc_ea(void)
1101: {
1102: char cond_name[16], addr_name[16];
1103: Uint32 cc_code=0;
1104:
1105: dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name);
1106: cc_code=cur_inst & BITMASK(4);
1107: dsp_calc_cc(cc_code, cond_name);
1108:
1109: sprintf(str_instr,"j%s p:%s", cond_name, addr_name);
1110: }
1111:
1112: static void dsp_jcc_imm(void)
1113: {
1114: char cond_name[16], addr_name[16];
1115: Uint32 cc_code=0;
1116:
1117: sprintf(addr_name, "$%04x", cur_inst & BITMASK(12));
1118: cc_code=(cur_inst>>12) & BITMASK(4);
1119: dsp_calc_cc(cc_code, cond_name);
1120:
1121: sprintf(str_instr,"j%s p:%s", cond_name, addr_name);
1122: }
1123:
1124: static void dsp_jclr_aa(void)
1125: {
1126: /* jclr #n,x:aa,p:xx */
1127: /* jclr #n,y:aa,p:xx */
1128: char srcname[16];
1129: Uint32 memspace, value, numbit;
1130:
1131: disasm_cur_inst_len++;
1132:
1133: memspace = (cur_inst>>6) & 1;
1134: value = (cur_inst>>8) & BITMASK(6);
1135: numbit = cur_inst & BITMASK(5);
1136:
1137: if (memspace) {
1138: sprintf(srcname, "y:$%04x", value);
1139: } else {
1140: sprintf(srcname, "x:$%04x", value);
1141: }
1142:
1143: sprintf(str_instr,"jclr #%d,%s,p:$%04x",
1144: numbit,
1145: srcname,
1146: read_memory(dsp_core.pc+1)
1147: );
1148: }
1149:
1150: static void dsp_jclr_ea(void)
1151: {
1152: /* jclr #n,x:ea,p:xx */
1153: /* jclr #n,y:ea,p:xx */
1154: char srcname[16], addr_name[16];
1155: Uint32 memspace, value, numbit;
1156:
1157: disasm_cur_inst_len++;
1158:
1159: memspace = (cur_inst>>6) & 1;
1160: value = (cur_inst>>8) & BITMASK(6);
1161: numbit = cur_inst & BITMASK(5);
1162:
1163: dsp_calc_ea(value, addr_name);
1164: if (memspace) {
1165: sprintf(srcname, "y:%s", addr_name);
1166: } else {
1167: sprintf(srcname, "x:%s", addr_name);
1168: }
1169:
1170: sprintf(str_instr,"jclr #%d,%s,p:$%04x",
1171: numbit,
1172: srcname,
1173: read_memory(dsp_core.pc+1)
1174: );
1175: }
1176:
1177: static void dsp_jclr_pp(void)
1178: {
1179: /* jclr #n,x:pp,p:xx */
1180: /* jclr #n,y:pp,p:xx */
1181: char srcname[16];
1182: Uint32 memspace, value, numbit;
1183:
1184: disasm_cur_inst_len++;
1185:
1186: memspace = (cur_inst>>6) & 1;
1187: value = (cur_inst>>8) & BITMASK(6);
1188: numbit = cur_inst & BITMASK(5);
1189:
1190: value += 0xffc0;
1191: if (memspace) {
1192: sprintf(srcname, "y:$%04x", value);
1193: } else {
1194: sprintf(srcname, "x:$%04x", value);
1195: }
1196:
1197: sprintf(str_instr,"jclr #%d,%s,p:$%04x",
1198: numbit,
1199: srcname,
1200: read_memory(dsp_core.pc+1)
1201: );
1202: }
1203:
1204: static void dsp_jclr_reg(void)
1205: {
1206: /* jclr #n,R,p:xx */
1207: Uint32 value, numbit;
1208:
1209: disasm_cur_inst_len++;
1210:
1211: value = (cur_inst>>8) & BITMASK(6);
1212: numbit = cur_inst & BITMASK(5);
1213:
1214: sprintf(str_instr,"jclr #%d,%s,p:$%04x",
1215: numbit,
1216: registers_name[value],
1217: read_memory(dsp_core.pc+1)
1218: );
1219: }
1220:
1221: static void dsp_jmp_imm(void)
1222: {
1223: sprintf(str_instr,"jmp p:$%04x", cur_inst & BITMASK(12));
1224: }
1225:
1226: static void dsp_jmp_ea(void)
1227: {
1228: char dstname[16];
1229:
1230: dsp_calc_ea((cur_inst >>8) & BITMASK(6), dstname);
1231:
1232: sprintf(str_instr,"jmp p:%s", dstname);
1233: }
1234:
1235: static void dsp_jscc_ea(void)
1236: {
1237: char cond_name[16], addr_name[16];
1238: Uint32 cc_code=0;
1239:
1240: dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
1241: cc_code=cur_inst & BITMASK(4);
1242: dsp_calc_cc(cc_code, cond_name);
1243:
1244: sprintf(str_instr,"js%s p:%s", cond_name, addr_name);
1245: }
1246:
1247: static void dsp_jscc_imm(void)
1248: {
1249: char cond_name[16], addr_name[16];
1250: Uint32 cc_code=0;
1251:
1252: sprintf(addr_name, "$%04x", cur_inst & BITMASK(12));
1253: cc_code=(cur_inst>>12) & BITMASK(4);
1254: dsp_calc_cc(cc_code, cond_name);
1255:
1256: sprintf(str_instr,"js%s p:%s", cond_name, addr_name);
1257: }
1258:
1259: static void dsp_jsclr_aa(void)
1260: {
1261: /* jsclr #n,x:aa,p:xx */
1262: /* jsclr #n,y:aa,p:xx */
1263: char srcname[16];
1264: Uint32 memspace, value, numbit;
1265:
1266: disasm_cur_inst_len++;
1267:
1268: memspace = (cur_inst>>6) & 1;
1269: value = (cur_inst>>8) & BITMASK(6);
1270: numbit = cur_inst & BITMASK(5);
1271:
1272: if (memspace) {
1273: sprintf(srcname, "y:$%04x", value);
1274: } else {
1275: sprintf(srcname, "x:$%04x", value);
1276: }
1277:
1278: sprintf(str_instr,"jsclr #%d,%s,p:$%04x",
1279: numbit,
1280: srcname,
1281: read_memory(dsp_core.pc+1)
1282: );
1283: }
1284:
1285: static void dsp_jsclr_ea(void)
1286: {
1287: /* jsclr #n,x:ea,p:xx */
1288: /* jsclr #n,y:ea,p:xx */
1289: char srcname[16], addr_name[16];
1290: Uint32 memspace, value, numbit;
1291:
1292: disasm_cur_inst_len++;
1293:
1294: memspace = (cur_inst>>6) & 1;
1295: value = (cur_inst>>8) & BITMASK(6);
1296: numbit = cur_inst & BITMASK(5);
1297:
1298: dsp_calc_ea(value, addr_name);
1299: if (memspace) {
1300: sprintf(srcname, "y:%s", addr_name);
1301: } else {
1302: sprintf(srcname, "x:%s", addr_name);
1303: }
1304:
1305: sprintf(str_instr,"jsclr #%d,%s,p:$%04x",
1306: numbit,
1307: srcname,
1308: read_memory(dsp_core.pc+1)
1309: );
1310: }
1311:
1312: static void dsp_jsclr_pp(void)
1313: {
1314: /* jsclr #n,x:pp,p:xx */
1315: /* jsclr #n,y:pp,p:xx */
1316: char srcname[16];
1317: Uint32 memspace, value, numbit;
1318:
1319: disasm_cur_inst_len++;
1320:
1321: memspace = (cur_inst>>6) & 1;
1322: value = (cur_inst>>8) & BITMASK(6);
1323: numbit = cur_inst & BITMASK(5);
1324:
1325: value += 0xffc0;
1326: if (memspace) {
1327: sprintf(srcname, "y:$%04x", value);
1328: } else {
1329: sprintf(srcname, "x:$%04x", value);
1330: }
1331:
1332: sprintf(str_instr,"jsclr #%d,%s,p:$%04x",
1333: numbit,
1334: srcname,
1335: read_memory(dsp_core.pc+1)
1336: );
1337: }
1338:
1339: static void dsp_jsclr_reg(void)
1340: {
1341: /* jsclr #n,R,p:xx */
1342: Uint32 value, numbit;
1343:
1344: disasm_cur_inst_len++;
1345:
1346: value = (cur_inst>>8) & BITMASK(6);
1347: numbit = cur_inst & BITMASK(5);
1348:
1349: sprintf(str_instr,"jsclr #%d,%s,p:$%04x",
1350: numbit,
1351: registers_name[value],
1352: read_memory(dsp_core.pc+1)
1353: );
1354: }
1355:
1356: static void dsp_jset_aa(void)
1357: {
1358: /* jset #n,x:aa,p:xx */
1359: /* jset #n,y:aa,p:xx */
1360: char srcname[16];
1361: Uint32 memspace, value, numbit;
1362:
1363: disasm_cur_inst_len++;
1364:
1365: memspace = (cur_inst>>6) & 1;
1366: value = (cur_inst>>8) & BITMASK(6);
1367: numbit = cur_inst & BITMASK(5);
1368:
1369: if (memspace) {
1370: sprintf(srcname, "y:$%04x", value);
1371: } else {
1372: sprintf(srcname, "x:$%04x", value);
1373: }
1374:
1375: sprintf(str_instr,"jset #%d,%s,p:$%04x",
1376: numbit,
1377: srcname,
1378: read_memory(dsp_core.pc+1)
1379: );
1380: }
1381:
1382: static void dsp_jset_ea(void)
1383: {
1384: /* jset #n,x:ea,p:xx */
1385: /* jset #n,y:ea,p:xx */
1386: char srcname[16], addr_name[16];
1387: Uint32 memspace, value, numbit;
1388:
1389: disasm_cur_inst_len++;
1390:
1391: memspace = (cur_inst>>6) & 1;
1392: value = (cur_inst>>8) & BITMASK(6);
1393: numbit = cur_inst & BITMASK(5);
1394:
1395: dsp_calc_ea(value, addr_name);
1396: if (memspace) {
1397: sprintf(srcname, "y:%s", addr_name);
1398: } else {
1399: sprintf(srcname, "x:%s", addr_name);
1400: }
1401:
1402: sprintf(str_instr,"jset #%d,%s,p:$%04x",
1403: numbit,
1404: srcname,
1405: read_memory(dsp_core.pc+1)
1406: );
1407: }
1408:
1409: static void dsp_jset_pp(void)
1410: {
1411: /* jset #n,x:pp,p:xx */
1412: /* jset #n,y:pp,p:xx */
1413: char srcname[16];
1414: Uint32 memspace, value, numbit;
1415:
1416: disasm_cur_inst_len++;
1417:
1418: memspace = (cur_inst>>6) & 1;
1419: value = (cur_inst>>8) & BITMASK(6);
1420: numbit = cur_inst & BITMASK(5);
1421:
1422: value += 0xffc0;
1423: if (memspace) {
1424: sprintf(srcname, "y:$%04x", value);
1425: } else {
1426: sprintf(srcname, "x:$%04x", value);
1427: }
1428:
1429: sprintf(str_instr,"jset #%d,%s,p:$%04x",
1430: numbit,
1431: srcname,
1432: read_memory(dsp_core.pc+1)
1433: );
1434: }
1435:
1436: static void dsp_jset_reg(void)
1437: {
1438: /* jset #n,R,p:xx */
1439: Uint32 value, numbit;
1440:
1441: disasm_cur_inst_len++;
1442:
1443: value = (cur_inst>>8) & BITMASK(6);
1444: numbit = cur_inst & BITMASK(5);
1445:
1446: sprintf(str_instr,"jset #%d,%s,p:$%04x",
1447: numbit,
1448: registers_name[value],
1449: read_memory(dsp_core.pc+1)
1450: );
1451: }
1452:
1453: static void dsp_jsr_imm(void)
1454: {
1455: sprintf(str_instr,"jsr p:$%04x", cur_inst & BITMASK(12));
1456: }
1457:
1458: static void dsp_jsr_ea(void)
1459: {
1460: char dstname[16];
1461:
1462: dsp_calc_ea((cur_inst>>8) & BITMASK(6),dstname);
1463:
1464: sprintf(str_instr,"jsr p:%s", dstname);
1465: }
1466:
1467: static void dsp_jsset_aa(void)
1468: {
1469: /* jsset #n,x:aa,p:xx */
1470: /* jsset #n,y:aa,p:xx */
1471: char srcname[16];
1472: Uint32 memspace, value, numbit;
1473:
1474: disasm_cur_inst_len++;
1475:
1476: memspace = (cur_inst>>6) & 1;
1477: value = (cur_inst>>8) & BITMASK(6);
1478: numbit = cur_inst & BITMASK(5);
1479:
1480: if (memspace) {
1481: sprintf(srcname, "y:$%04x", value);
1482: } else {
1483: sprintf(srcname, "x:$%04x", value);
1484: }
1485:
1486: sprintf(str_instr,"jsset #%d,%s,p:$%04x",
1487: numbit,
1488: srcname,
1489: read_memory(dsp_core.pc+1)
1490: );
1491: }
1492:
1493: static void dsp_jsset_ea(void)
1494: {
1495: /* jsset #n,x:ea,p:xx */
1496: /* jsset #n,y:ea,p:xx */
1497: char srcname[16], addr_name[16];
1498: Uint32 memspace, value, numbit;
1499:
1500: disasm_cur_inst_len++;
1501:
1502: memspace = (cur_inst>>6) & 1;
1503: value = (cur_inst>>8) & BITMASK(6);
1504: numbit = cur_inst & BITMASK(5);
1505:
1506: dsp_calc_ea(value, addr_name);
1507: if (memspace) {
1508: sprintf(srcname, "y:%s", addr_name);
1509: } else {
1510: sprintf(srcname, "x:%s", addr_name);
1511: }
1512:
1513: sprintf(str_instr,"jsset #%d,%s,p:$%04x",
1514: numbit,
1515: srcname,
1516: read_memory(dsp_core.pc+1)
1517: );
1518: }
1519:
1520: static void dsp_jsset_pp(void)
1521: {
1522: /* jsset #n,x:pp,p:xx */
1523: /* jsset #n,y:pp,p:xx */
1524: char srcname[16];
1525: Uint32 memspace, value, numbit;
1526:
1527: disasm_cur_inst_len++;
1528:
1529: memspace = (cur_inst>>6) & 1;
1530: value = (cur_inst>>8) & BITMASK(6);
1531: numbit = cur_inst & BITMASK(5);
1532:
1533: value += 0xffc0;
1534: if (memspace) {
1535: sprintf(srcname, "y:$%04x", value);
1536: } else {
1537: sprintf(srcname, "x:$%04x", value);
1538: }
1539:
1540: sprintf(str_instr,"jsset #%d,%s,p:$%04x",
1541: numbit,
1542: srcname,
1543: read_memory(dsp_core.pc+1)
1544: );
1545: }
1546:
1547: static void dsp_jsset_reg(void)
1548: {
1549: /* jsset #n,r,p:xx */
1550: Uint32 value, numbit;
1551:
1552: disasm_cur_inst_len++;
1553:
1554: value = (cur_inst>>8) & BITMASK(6);
1555: numbit = cur_inst & BITMASK(5);
1556:
1557: sprintf(str_instr,"jsset #%d,%s,p:$%04x",
1558: numbit,
1559: registers_name[value],
1560: read_memory(dsp_core.pc+1)
1561: );
1562: }
1563:
1564: static void dsp_lua(void)
1565: {
1566: char addr_name[16], numreg;
1567:
1568: dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name);
1569: numreg = cur_inst & BITMASK(3);
1570:
1571: if (cur_inst & (1<<3))
1572: sprintf(str_instr,"lua %s,n%d", addr_name, numreg);
1573: else
1574: sprintf(str_instr,"lua %s,r%d", addr_name, numreg);
1575: }
1576:
1577: static void dsp_movec_reg(void)
1578: {
1579: Uint32 numreg1, numreg2;
1580:
1581: /* S1,D2 */
1582: /* S2,D1 */
1583:
1584: numreg2 = (cur_inst>>8) & BITMASK(6);
1585: numreg1 = cur_inst & BITMASK(6);
1586:
1587: if (cur_inst & (1<<15)) {
1588: /* Write D1 */
1589: sprintf(str_instr,"movec %s,%s", registers_name[numreg2], registers_name[numreg1]);
1590: } else {
1591: /* Read S1 */
1592: sprintf(str_instr,"movec %s,%s", registers_name[numreg1], registers_name[numreg2]);
1593: }
1594: }
1595:
1596: static void dsp_movec_aa(void)
1597: {
1598: const char *spacename;
1599: char srcname[16],dstname[16];
1600: Uint32 numreg, addr;
1601:
1602: /* x:aa,D1 */
1603: /* S1,x:aa */
1604: /* y:aa,D1 */
1605: /* S1,y:aa */
1606:
1607: numreg = cur_inst & BITMASK(6);
1608: addr = (cur_inst>>8) & BITMASK(6);
1609:
1610: if (cur_inst & (1<<6)) {
1611: spacename="y";
1612: } else {
1613: spacename="x";
1614: }
1615:
1616: if (cur_inst & (1<<15)) {
1617: /* Write D1 */
1618: sprintf(srcname, "%s:$%04x", spacename, addr);
1619: strcpy(dstname, registers_name[numreg]);
1620: } else {
1621: /* Read S1 */
1622: strcpy(srcname, registers_name[numreg]);
1623: sprintf(dstname, "%s:$%04x", spacename, addr);
1624: }
1625:
1626: sprintf(str_instr,"movec %s,%s", srcname, dstname);
1627: }
1628:
1629: static void dsp_movec_imm(void)
1630: {
1631: Uint32 numreg;
1632:
1633: /* #xx,D1 */
1634:
1635: numreg = cur_inst & BITMASK(6);
1636:
1637: sprintf(str_instr,"movec #$%02x,%s", (cur_inst>>8) & BITMASK(8), registers_name[numreg]);
1638: }
1639:
1640: static void dsp_movec_ea(void)
1641: {
1642: const char *spacename;
1643: char srcname[16], dstname[16], addr_name[16];
1644: Uint32 numreg, ea_mode;
1645: int retour;
1646:
1647: /* x:ea,D1 */
1648: /* S1,x:ea */
1649: /* y:ea,D1 */
1650: /* S1,y:ea */
1651: /* #xxxx,D1 */
1652:
1653: numreg = cur_inst & BITMASK(6);
1654: ea_mode = (cur_inst>>8) & BITMASK(6);
1655: retour = dsp_calc_ea(ea_mode, addr_name);
1656:
1657: if (cur_inst & (1<<6)) {
1658: spacename="y";
1659: } else {
1660: spacename="x";
1661: }
1662:
1663: if (cur_inst & (1<<15)) {
1664: /* Write D1 */
1665: if (retour) {
1666: sprintf(srcname, "#%s", addr_name);
1667: } else {
1668: sprintf(srcname, "%s:%s", spacename, addr_name);
1669: }
1670: strcpy(dstname, registers_name[numreg]);
1671: } else {
1672: /* Read S1 */
1673: strcpy(srcname, registers_name[numreg]);
1674: sprintf(dstname, "%s:%s", spacename, addr_name);
1675: }
1676:
1677: sprintf(str_instr,"movec %s,%s", srcname, dstname);
1678: }
1679:
1680: static void dsp_movem_aa(void)
1681: {
1682: /* S,p:aa */
1683: /* p:aa,D */
1684: char addr_name[16], srcname[16], dstname[16];
1685: Uint32 numreg;
1686:
1687: sprintf(addr_name, "$%04x",(cur_inst>>8) & BITMASK(6));
1688: numreg = cur_inst & BITMASK(6);
1689: if (cur_inst & (1<<15)) {
1690: /* Write D */
1691: sprintf(srcname, "p:%s", addr_name);
1692: strcpy(dstname, registers_name[numreg]);
1693: } else {
1694: /* Read S */
1695: strcpy(srcname, registers_name[numreg]);
1696: sprintf(dstname, "p:%s", addr_name);
1697: }
1698:
1699: sprintf(str_instr,"movem %s,%s", srcname, dstname);
1700: }
1701:
1702: static void dsp_movem_ea(void)
1703: {
1704: /* S,p:ea */
1705: /* p:ea,D */
1706: char addr_name[16], srcname[16], dstname[16];
1707: Uint32 ea_mode, numreg;
1708:
1709: ea_mode = (cur_inst>>8) & BITMASK(6);
1710: dsp_calc_ea(ea_mode, addr_name);
1711: numreg = cur_inst & BITMASK(6);
1712: if (cur_inst & (1<<15)) {
1713: /* Write D */
1714: sprintf(srcname, "p:%s", addr_name);
1715: strcpy(dstname, registers_name[numreg]);
1716: } else {
1717: /* Read S */
1718: strcpy(srcname, registers_name[numreg]);
1719: sprintf(dstname, "p:%s", addr_name);
1720: }
1721:
1722: sprintf(str_instr,"movem %s,%s", srcname, dstname);
1723: }
1724:
1725: static void dsp_movep_0(void)
1726: {
1727: char srcname[16]="",dstname[16]="";
1728: Uint32 addr, memspace, numreg;
1729:
1730: /* S,x:pp */
1731: /* x:pp,D */
1732: /* S,y:pp */
1733: /* y:pp,D */
1734:
1735: addr = 0xffc0 + (cur_inst & BITMASK(6));
1736: memspace = (cur_inst>>16) & 1;
1737: numreg = (cur_inst>>8) & BITMASK(6);
1738:
1739: if (cur_inst & (1<<15)) {
1740: /* Write pp */
1741:
1742: strcpy(srcname, registers_name[numreg]);
1743:
1744: if (memspace) {
1745: sprintf(dstname, "y:$%04x", addr);
1746: } else {
1747: sprintf(dstname, "x:$%04x", addr);
1748: }
1749: } else {
1750: /* Read pp */
1751:
1752: if (memspace) {
1753: sprintf(srcname, "y:$%04x", addr);
1754: } else {
1755: sprintf(srcname, "x:$%04x", addr);
1756: }
1757:
1758: strcpy(dstname, registers_name[numreg]);
1759: }
1760:
1761: sprintf(str_instr,"movep %s,%s", srcname, dstname);
1762: }
1763:
1764: static void dsp_movep_1(void)
1765: {
1766: char srcname[16]="",dstname[16]="",name[16]="";
1767: Uint32 addr, memspace;
1768:
1769: /* p:ea,x:pp */
1770: /* x:pp,p:ea */
1771: /* p:ea,y:pp */
1772: /* y:pp,p:ea */
1773:
1774: addr = 0xffc0 + (cur_inst & BITMASK(6));
1775: dsp_calc_ea((cur_inst>>8) & BITMASK(6), name);
1776: memspace = (cur_inst>>16) & 1;
1777:
1778: if (cur_inst & (1<<15)) {
1779: /* Write pp */
1780:
1781: sprintf(srcname, "p:%s", name);
1782:
1783: if (memspace) {
1784: sprintf(dstname, "y:$%04x", addr);
1785: } else {
1786: sprintf(dstname, "x:$%04x", addr);
1787: }
1788: } else {
1789: /* Read pp */
1790:
1791: if (memspace) {
1792: sprintf(srcname, "y:$%04x", addr);
1793: } else {
1794: sprintf(srcname, "x:$%04x", addr);
1795: }
1796:
1797: sprintf(dstname, "p:%s", name);
1798: }
1799:
1800: sprintf(str_instr,"movep %s,%s", srcname, dstname);
1801: }
1802:
1803: static void dsp_movep_23(void)
1804: {
1805: char srcname[16]="",dstname[16]="",name[16]="";
1806: Uint32 addr, memspace, easpace, retour;
1807:
1808: /* x:ea,x:pp */
1809: /* y:ea,x:pp */
1810: /* #xxxxxx,x:pp */
1811: /* x:pp,x:ea */
1812: /* x:pp,y:ea */
1813:
1814: /* x:ea,y:pp */
1815: /* y:ea,y:pp */
1816: /* #xxxxxx,y:pp */
1817: /* y:pp,y:ea */
1818: /* y:pp,x:ea */
1819:
1820: addr = 0xffc0 + (cur_inst & BITMASK(6));
1821: retour = dsp_calc_ea((cur_inst>>8) & BITMASK(6), name);
1822: memspace = (cur_inst>>16) & 1;
1823: easpace = (cur_inst>>6) & 1;
1824:
1825: if (cur_inst & (1<<15)) {
1826: /* Write pp */
1827:
1828: if (retour) {
1829: sprintf(srcname, "#%s", name);
1830: } else {
1831: if (easpace) {
1832: sprintf(srcname, "y:%s", name);
1833: } else {
1834: sprintf(srcname, "x:%s", name);
1835: }
1836: }
1837:
1838: if (memspace) {
1839: sprintf(dstname, "y:$%04x", addr);
1840: } else {
1841: sprintf(dstname, "x:$%04x", addr);
1842: }
1843: } else {
1844: /* Read pp */
1845:
1846: if (memspace) {
1847: sprintf(srcname, "y:$%04x", addr);
1848: } else {
1849: sprintf(srcname, "x:$%04x", addr);
1850: }
1851:
1852: if (easpace) {
1853: sprintf(dstname, "y:%s", name);
1854: } else {
1855: sprintf(dstname, "x:%s", name);
1856: }
1857: }
1858:
1859: sprintf(str_instr,"movep %s,%s", srcname, dstname);
1860: }
1861:
1862: static void dsp_nop(void)
1863: {
1864: sprintf(str_instr,"nop");
1865: }
1866:
1867: static void dsp_norm(void)
1868: {
1869: Uint32 srcreg, destreg;
1870:
1871: srcreg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3));
1872: destreg = DSP_REG_A+((cur_inst>>3) & 1);
1873:
1874: sprintf(str_instr,"norm %s,%s", registers_name[srcreg], registers_name[destreg]);
1875: }
1876:
1877: static void dsp_ori(void)
1878: {
1879: switch(cur_inst & BITMASK(2)) {
1880: case 0:
1881: sprintf(str_instr,"ori #$%02x,mr", (cur_inst>>8) & BITMASK(8));
1882: break;
1883: case 1:
1884: sprintf(str_instr,"ori #$%02x,ccr", (cur_inst>>8) & BITMASK(8));
1885: break;
1886: case 2:
1887: sprintf(str_instr,"ori #$%02x,omr", (cur_inst>>8) & BITMASK(8));
1888: break;
1889: default:
1890: break;
1891: }
1892:
1893: }
1894:
1895: static void dsp_rep_aa(void)
1896: {
1897: char name[16];
1898:
1899: /* x:aa */
1900: /* y:aa */
1901:
1902: if (cur_inst & (1<<6)) {
1903: sprintf(name, "y:$%04x",(cur_inst>>8) & BITMASK(6));
1904: } else {
1905: sprintf(name, "x:$%04x",(cur_inst>>8) & BITMASK(6));
1906: }
1907:
1908: sprintf(str_instr,"rep %s", name);
1909: }
1910:
1911: static void dsp_rep_imm(void)
1912: {
1913: /* #xxx */
1914: sprintf(str_instr,"rep #$%02x", ((cur_inst>>8) & BITMASK(8))
1915: + ((cur_inst & BITMASK(4))<<8));
1916: }
1917:
1918: static void dsp_rep_ea(void)
1919: {
1920: char name[16],addr_name[16];
1921:
1922: /* x:ea */
1923: /* y:ea */
1924:
1925: dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
1926: if (cur_inst & (1<<6)) {
1927: sprintf(name, "y:%s",addr_name);
1928: } else {
1929: sprintf(name, "x:%s",addr_name);
1930: }
1931:
1932: sprintf(str_instr,"rep %s", name);
1933: }
1934:
1935: static void dsp_rep_reg(void)
1936: {
1937: /* R */
1938:
1939: sprintf(str_instr,"rep %s", registers_name[(cur_inst>>8) & BITMASK(6)]);
1940: }
1941:
1942: static void dsp_reset(void)
1943: {
1944: sprintf(str_instr,"reset");
1945: }
1946:
1947: static void dsp_rti(void)
1948: {
1949: sprintf(str_instr,"rti");
1950: }
1951:
1952: static void dsp_rts(void)
1953: {
1954: sprintf(str_instr,"rts");
1955: }
1956:
1957: static void dsp_stop(void)
1958: {
1959: sprintf(str_instr,"stop");
1960: }
1961:
1962: static void dsp_swi(void)
1963: {
1964: sprintf(str_instr,"swi");
1965: }
1966:
1967: static void dsp_tcc(void)
1968: {
1969: char ccname[16];
1970: Uint32 src1reg, dst1reg, src2reg, dst2reg;
1971:
1972: dsp_calc_cc((cur_inst>>12) & BITMASK(4), ccname);
1973: src1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0];
1974: dst1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][1];
1975:
1976: if (cur_inst & (1<<16)) {
1977: src2reg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3));
1978: dst2reg = DSP_REG_R0+(cur_inst & BITMASK(3));
1979:
1980: sprintf(str_instr,"t%s %s,%s %s,%s",
1981: ccname,
1982: registers_name[src1reg],
1983: registers_name[dst1reg],
1984: registers_name[src2reg],
1985: registers_name[dst2reg]
1986: );
1987: } else {
1988: sprintf(str_instr,"t%s %s,%s",
1989: ccname,
1990: registers_name[src1reg],
1991: registers_name[dst1reg]
1992: );
1993: }
1994: }
1995:
1996: static void dsp_wait(void)
1997: {
1998: sprintf(str_instr,"wait");
1999: }
2000:
2001: /**********************************
2002: * Parallel moves
2003: **********************************/
2004:
2005: static void dsp_pm(void)
2006: {
2007: Uint32 value;
2008:
2009: value = (cur_inst >> 20) & BITMASK(4);
2010: opcodes_parmove[value]();
2011: }
2012:
2013: static void dsp_pm_0(void)
2014: {
2015: char space_name[16], addr_name[16];
2016: Uint32 memspace, numreg1, numreg2;
2017: /*
2018: 0000 100d 00mm mrrr S,x:ea x0,D
2019: 0000 100d 10mm mrrr S,y:ea y0,D
2020: */
2021: memspace = (cur_inst>>15) & 1;
2022: numreg1 = DSP_REG_A+((cur_inst>>16) & 1);
2023: dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
2024:
2025: if (memspace) {
2026: strcpy(space_name,"y");
2027: numreg2 = DSP_REG_Y0;
2028: } else {
2029: strcpy(space_name,"x");
2030: numreg2 = DSP_REG_X0;
2031: }
2032:
2033: sprintf(parallelmove_name,
2034: "%s,%s:%s %s,%s",
2035: registers_name[numreg1],
2036: space_name,
2037: addr_name,
2038: registers_name[numreg2],
2039: registers_name[numreg1]
2040: );
2041: }
2042:
2043: static void dsp_pm_1(void)
2044: {
2045: /*
2046: 0001 ffdf w0mm mrrr x:ea,D1 S2,D2
2047: S1,x:ea S2,D2
2048: #xxxxxx,D1 S2,D2
2049: 0001 deff w1mm mrrr S1,D1 y:ea,D2
2050: S1,D1 S2,y:ea
2051: S1,D1 #xxxxxx,D2
2052: */
2053:
2054: char addr_name[16];
2055: Uint32 memspace, write_flag, retour, s1reg, s2reg, d1reg, d2reg;
2056:
2057: memspace = (cur_inst>>14) & 1;
2058: write_flag = (cur_inst>>15) & 1;
2059: retour = dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
2060:
2061: if (memspace==DSP_SPACE_Y) {
2062: s2reg = d2reg = DSP_REG_Y0;
2063: switch((cur_inst>>16) & BITMASK(2)) {
2064: case 0: s2reg = d2reg = DSP_REG_Y0; break;
2065: case 1: s2reg = d2reg = DSP_REG_Y1; break;
2066: case 2: s2reg = d2reg = DSP_REG_A; break;
2067: case 3: s2reg = d2reg = DSP_REG_B; break;
2068: }
2069:
2070: s1reg = DSP_REG_A+((cur_inst>>19) & 1);
2071: d1reg = DSP_REG_X0+((cur_inst>>18) & 1);
2072:
2073: if (write_flag) {
2074: /* Write D2 */
2075:
2076: if (retour) {
2077: sprintf(parallelmove_name,"%s,%s #%s,%s",
2078: registers_name[s1reg],
2079: registers_name[d1reg],
2080: addr_name,
2081: registers_name[d2reg]
2082: );
2083: } else {
2084: sprintf(parallelmove_name,"%s,%s y:%s,%s",
2085: registers_name[s1reg],
2086: registers_name[d1reg],
2087: addr_name,
2088: registers_name[d2reg]
2089: );
2090: }
2091: } else {
2092: /* Read S2 */
2093: sprintf(parallelmove_name,"%s,%s %s,y:%s",
2094: registers_name[s1reg],
2095: registers_name[d1reg],
2096: registers_name[s2reg],
2097: addr_name
2098: );
2099: }
2100:
2101: } else {
2102: s1reg = d1reg = DSP_REG_X0;
2103: switch((cur_inst>>18) & BITMASK(2)) {
2104: case 0: s1reg = d1reg = DSP_REG_X0; break;
2105: case 1: s1reg = d1reg = DSP_REG_X1; break;
2106: case 2: s1reg = d1reg = DSP_REG_A; break;
2107: case 3: s1reg = d1reg = DSP_REG_B; break;
2108: }
2109:
2110: s2reg = DSP_REG_A+((cur_inst>>17) & 1);
2111: d2reg = DSP_REG_Y0+((cur_inst>>16) & 1);
2112:
2113: if (write_flag) {
2114: /* Write D1 */
2115:
2116: if (retour) {
2117: sprintf(parallelmove_name,"#%s,%s %s,%s",
2118: addr_name,
2119: registers_name[d1reg],
2120: registers_name[s2reg],
2121: registers_name[d2reg]
2122: );
2123: } else {
2124: sprintf(parallelmove_name,"x:%s,%s %s,%s",
2125: addr_name,
2126: registers_name[d1reg],
2127: registers_name[s2reg],
2128: registers_name[d2reg]
2129: );
2130: }
2131: } else {
2132: /* Read S1 */
2133: sprintf(parallelmove_name,"%s,x:%s %s,%s",
2134: registers_name[s1reg],
2135: addr_name,
2136: registers_name[s2reg],
2137: registers_name[d2reg]
2138: );
2139: }
2140:
2141: }
2142: }
2143:
2144: static void dsp_pm_2(void)
2145: {
2146: char addr_name[16];
2147: Uint32 numreg1, numreg2;
2148: /*
2149: 0010 0000 0000 0000 nop
2150: 0010 0000 010m mrrr R update
2151: 0010 00ee eeed dddd S,D
2152: 001d dddd iiii iiii #xx,D
2153: */
2154: if (((cur_inst >> 8) & 0xffff) == 0x2000) {
2155: return;
2156: }
2157:
2158: if (((cur_inst >> 8) & 0xffe0) == 0x2040) {
2159: dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name);
2160: sprintf(parallelmove_name, "%s,r%d",addr_name, (cur_inst>>8) & BITMASK(3));
2161: return;
2162: }
2163:
2164: if (((cur_inst >> 8) & 0xfc00) == 0x2000) {
2165: numreg1 = (cur_inst>>13) & BITMASK(5);
2166: numreg2 = (cur_inst>>8) & BITMASK(5);
2167: sprintf(parallelmove_name, "%s,%s", registers_name[numreg1], registers_name[numreg2]);
2168: return;
2169: }
2170:
2171: numreg1 = (cur_inst>>16) & BITMASK(5);
2172: sprintf(parallelmove_name, "#$%02x,%s", (cur_inst >> 8) & BITMASK(8), registers_name[numreg1]);
2173: }
2174:
2175: static void dsp_pm_4(void)
2176: {
2177: char addr_name[16];
2178: Uint32 value, retour, ea_mode, memspace;
2179: /*
2180: 0100 l0ll w0aa aaaa l:aa,D
2181: S,l:aa
2182: 0100 l0ll w1mm mrrr l:ea,D
2183: S,l:ea
2184: 01dd 0ddd w0aa aaaa x:aa,D
2185: S,x:aa
2186: 01dd 0ddd w1mm mrrr x:ea,D
2187: S,x:ea
2188: #xxxxxx,D
2189: 01dd 1ddd w0aa aaaa y:aa,D
2190: S,y:aa
2191: 01dd 1ddd w1mm mrrr y:ea,D
2192: S,y:ea
2193: #xxxxxx,D
2194: */
2195: value = (cur_inst>>16) & BITMASK(3);
2196: value |= (cur_inst>>17) & (BITMASK(2)<<3);
2197:
2198: ea_mode = (cur_inst>>8) & BITMASK(6);
2199:
2200: if ((value>>2)==0) {
2201: /* L: memory move */
2202: if (cur_inst & (1<<14)) {
2203: retour = dsp_calc_ea(ea_mode, addr_name);
2204: } else {
2205: sprintf(addr_name,"$%04x", ea_mode);
2206: retour = 0;
2207: }
2208:
2209: value = (cur_inst>>16) & BITMASK(2);
2210: value |= (cur_inst>>17) & (1<<2);
2211:
2212: if (cur_inst & (1<<15)) {
2213: /* Write D */
2214:
2215: if (retour) {
2216: sprintf(parallelmove_name, "#%s,%s", addr_name, registers_lmove[value]);
2217: } else {
2218: sprintf(parallelmove_name, "l:%s,%s", addr_name, registers_lmove[value]);
2219: }
2220: } else {
2221: /* Read S */
2222: sprintf(parallelmove_name, "%s,l:%s", registers_lmove[value], addr_name);
2223: }
2224:
2225: return;
2226: }
2227:
2228: memspace = (cur_inst>>19) & 1;
2229: if (cur_inst & (1<<14)) {
2230: retour = dsp_calc_ea(ea_mode, addr_name);
2231: } else {
2232: sprintf(addr_name,"$%04x", ea_mode);
2233: retour = 0;
2234: }
2235:
2236: if (memspace) {
2237: /* Y: */
2238:
2239: if (cur_inst & (1<<15)) {
2240: /* Write D */
2241:
2242: if (retour) {
2243: sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]);
2244: } else {
2245: sprintf(parallelmove_name, "y:%s,%s", addr_name, registers_name[value]);
2246: }
2247:
2248: } else {
2249: /* Read S */
2250: sprintf(parallelmove_name, "%s,y:%s", registers_name[value], addr_name);
2251: }
2252: } else {
2253: /* X: */
2254:
2255: if (cur_inst & (1<<15)) {
2256: /* Write D */
2257:
2258: if (retour) {
2259: sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]);
2260: } else {
2261: sprintf(parallelmove_name, "x:%s,%s", addr_name, registers_name[value]);
2262: }
2263: } else {
2264: /* Read S */
2265: sprintf(parallelmove_name, "%s,x:%s", registers_name[value], addr_name);
2266: }
2267: }
2268: }
2269:
2270: static void dsp_pm_8(void)
2271: {
2272: char addr1_name[16], addr2_name[16];
2273: Uint32 ea_mode1, ea_mode2, numreg1, numreg2;
2274: /*
2275: 1wmm eeff WrrM MRRR x:ea,D1 y:ea,D2
2276: x:ea,D1 S2,y:ea
2277: S1,x:ea y:ea,D2
2278: S1,x:ea S2,y:ea
2279: */
2280: numreg1 = DSP_REG_X0;
2281: switch((cur_inst>>18) & BITMASK(2)) {
2282: case 0: numreg1 = DSP_REG_X0; break;
2283: case 1: numreg1 = DSP_REG_X1; break;
2284: case 2: numreg1 = DSP_REG_A; break;
2285: case 3: numreg1 = DSP_REG_B; break;
2286: }
2287:
2288: numreg2 = DSP_REG_Y0;
2289: switch((cur_inst>>16) & BITMASK(2)) {
2290: case 0: numreg2 = DSP_REG_Y0; break;
2291: case 1: numreg2 = DSP_REG_Y1; break;
2292: case 2: numreg2 = DSP_REG_A; break;
2293: case 3: numreg2 = DSP_REG_B; break;
2294: }
2295:
2296: ea_mode1 = (cur_inst>>8) & BITMASK(5);
2297: if ((ea_mode1>>3) == 0) {
2298: ea_mode1 |= (1<<5);
2299: }
2300: ea_mode2 = (cur_inst>>13) & BITMASK(2);
2301: ea_mode2 |= ((cur_inst>>20) & BITMASK(2))<<3;
2302: if ((ea_mode1 & (1<<2))==0) {
2303: ea_mode2 |= 1<<2;
2304: }
2305: if ((ea_mode2>>3) == 0) {
2306: ea_mode2 |= (1<<5);
2307: }
2308:
2309: dsp_calc_ea(ea_mode1, addr1_name);
2310: dsp_calc_ea(ea_mode2, addr2_name);
2311:
2312: if (cur_inst & (1<<15)) {
2313: if (cur_inst & (1<<22)) {
2314: sprintf(parallelmove_name, "x:%s,%s y:%s,%s",
2315: addr1_name,
2316: registers_name[numreg1],
2317: addr2_name,
2318: registers_name[numreg2]
2319: );
2320: } else {
2321: sprintf(parallelmove_name, "x:%s,%s %s,y:%s",
2322: addr1_name,
2323: registers_name[numreg1],
2324: registers_name[numreg2],
2325: addr2_name
2326: );
2327: }
2328: } else {
2329: if (cur_inst & (1<<22)) {
2330: sprintf(parallelmove_name, "%s,x:%s y:%s,%s",
2331: registers_name[numreg1],
2332: addr1_name,
2333: addr2_name,
2334: registers_name[numreg2]
2335: );
2336: } else {
2337: sprintf(parallelmove_name, "%s,x:%s %s,y:%s",
2338: registers_name[numreg1],
2339: addr1_name,
2340: registers_name[numreg2],
2341: addr2_name
2342: );
2343: }
2344: }
2345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.