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