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