![[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: /*
2: * Dsp56K disassembler
3: *
4: * ARAnyM (C) 2003 Patrice Mandin
5: * Adaption to Hatari (C) 2006 by Thomas Huth
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: #include "main.h"
23: #include "sysdeps.h"
24: #include "ioMem.h"
25: #include "dsp.h"
26: #include "dsp_cpu.h"
27: #include "dsp_disasm.h"
28:
29: #if DEBUG
30: #define D(x) x
31: #else
32: #define D(x)
33: #endif
34:
35: /* More disasm infos, if wanted */
36: #define DSP_DISASM_REG_PC 0
37:
38: /**********************************
39: * Defines
40: **********************************/
41:
42: #define BITMASK(x) ((1<<(x))-1)
43:
44: /**********************************
45: * Variables
46: **********************************/
47:
48: /* Current instruction */
49: static uint32 cur_inst;
50:
51: /**********************************
52: * Register change
53: **********************************/
54:
55: static uint32 registers_save[64];
56: static uint32 registers_changed[64];
57: #if DSP_DISASM_REG_PC
58: static uint32 pc_save;
59: #endif
60:
61: static const char *registers_name[64]={
62: "","","","",
63: "x0","x1","y0","y1",
64: "a0","b0","a2","b2",
65: "a1","b1","a","b",
66:
67: "r0","r1","r2","r3",
68: "r4","r5","r6","r7",
69: "n0","n1","n2","n3",
70: "n4","n5","n6","n7",
71:
72: "m0","m1","m2","m3",
73: "m4","m5","m6","m7",
74: "","","","",
75: "","","","",
76:
77: "","","","",
78: "","","","",
79: "","sr","omr","sp",
80: "ssh","ssl","la","lc"
81: };
82:
83: void dsp56k_disasm_reg_read(void)
84: {
85: memcpy(registers_save, dsp_registers , sizeof(registers_save));
86: memset(registers_changed, 0, sizeof(registers_changed));
87: #if DSP_DISASM_REG_PC
88: pc_save = dsp_pc;
89: #endif
90: }
91:
92: void dsp56k_disasm_reg_compare(void)
93: {
94: int i;
95:
96: for (i=0;i<64;i++) {
97: if (!registers_changed[i]) {
98: continue;
99: }
100:
101: switch(i) {
102: case DSP_REG_X0:
103: case DSP_REG_X1:
104: case DSP_REG_Y0:
105: case DSP_REG_Y1:
106: case DSP_REG_A0:
107: case DSP_REG_A1:
108: case DSP_REG_B0:
109: case DSP_REG_B1:
110: fprintf(stderr,"Dsp: Reg: %s: 0x%06x -> 0x%06x\n", registers_name[i], registers_save[i] & BITMASK(24), dsp_registers[i] & BITMASK(24));
111: break;
112: case DSP_REG_R0:
113: case DSP_REG_R1:
114: case DSP_REG_R2:
115: case DSP_REG_R3:
116: case DSP_REG_R4:
117: case DSP_REG_R5:
118: case DSP_REG_R6:
119: case DSP_REG_R7:
120: case DSP_REG_M0:
121: case DSP_REG_M1:
122: case DSP_REG_M2:
123: case DSP_REG_M3:
124: case DSP_REG_M4:
125: case DSP_REG_M5:
126: case DSP_REG_M6:
127: case DSP_REG_M7:
128: case DSP_REG_N0:
129: case DSP_REG_N1:
130: case DSP_REG_N2:
131: case DSP_REG_N3:
132: case DSP_REG_N4:
133: case DSP_REG_N5:
134: case DSP_REG_N6:
135: case DSP_REG_N7:
136: case DSP_REG_SR:
137: case DSP_REG_LA:
138: case DSP_REG_LC:
139: fprintf(stderr,"Dsp: Reg: %s: 0x%04x -> 0x%04x\n", registers_name[i], registers_save[i] & BITMASK(16), dsp_registers[i] & BITMASK(16));
140: break;
141: case DSP_REG_A2:
142: case DSP_REG_B2:
143: case DSP_REG_OMR:
144: case DSP_REG_SP:
145: case DSP_REG_SSH:
146: case DSP_REG_SSL:
147: fprintf(stderr,"Dsp: Reg: %s: 0x%02x -> 0x%02x\n", registers_name[i], registers_save[i] & BITMASK(8), dsp_registers[i] & BITMASK(8));
148: break;
149: case DSP_REG_A:
150: case DSP_REG_B:
151: {
152: fprintf(stderr,"Dsp: Reg: %s: 0x%02x:%06x:%06x -> 0x%02x:%06x:%06x\n",
153: registers_name[i],
154: registers_save[DSP_REG_A2+(i & 1)] & BITMASK(8),
155: registers_save[DSP_REG_A1+(i & 1)] & BITMASK(24),
156: registers_save[DSP_REG_A0+(i & 1)] & BITMASK(24),
157: dsp_registers[DSP_REG_A2+(i & 1)] & BITMASK(8),
158: dsp_registers[DSP_REG_A1+(i & 1)] & BITMASK(24),
159: dsp_registers[DSP_REG_A0+(i & 1)] & BITMASK(24)
160: );
161: }
162: break;
163: }
164: }
165: #if DSP_DISASM_REG_PC
166: if (pc_save != dsp_pc) {
167: fprintf(stderr,"Dsp: Reg: pc: 0x%04x -> 0x%04x\n", pc_save, dsp_pc);
168: }
169: #endif
170: }
171:
172: /**********************************
173: * Opcode disassembler
174: **********************************/
175:
176: typedef void (*dsp_emul_t)(void);
177:
178: static void opcode8h_0(void);
179: static void opcode8h_1(void);
180: static void opcode8h_4(void);
181: static void opcode8h_6(void);
182: static void opcode8h_8(void);
183: static void opcode8h_a(void);
184: static void opcode8h_b(void);
185:
186: static int dsp_calc_ea(uint32 ea_mode, char *dest);
187: static void dsp_calc_cc(uint32 cc_mode, char *dest);
188: static void dsp_undefined(void);
189:
190: /* Instructions without parallel moves */
191: static void dsp_andi(void);
192: static void dsp_bchg(void);
193: static void dsp_bclr(void);
194: static void dsp_bset(void);
195: static void dsp_btst(void);
196: static void dsp_div(void);
197: static void dsp_do(void);
198: static void dsp_enddo(void);
199: static void dsp_illegal(void);
200: static void dsp_jcc(void);
201: static void dsp_jclr(void);
202: static void dsp_jmp(void);
203: static void dsp_jscc(void);
204: static void dsp_jsclr(void);
205: static void dsp_jset(void);
206: static void dsp_jsr(void);
207: static void dsp_jsset(void);
208: static void dsp_lua(void);
209: static void dsp_movec(void);
210: static void dsp_movem(void);
211: static void dsp_movep(void);
212: static void dsp_nop(void);
213: static void dsp_norm(void);
214: static void dsp_ori(void);
215: static void dsp_rep(void);
216: static void dsp_reset(void);
217: static void dsp_rti(void);
218: static void dsp_rts(void);
219: static void dsp_stop(void);
220: static void dsp_swi(void);
221: static void dsp_tcc(void);
222: static void dsp_wait(void);
223:
224: static void dsp_do_0(void);
225: static void dsp_do_2(void);
226: static void dsp_do_4(void);
227: static void dsp_do_c(void);
228: static void dsp_movec_7(void);
229: static void dsp_movec_9(void);
230: static void dsp_movec_b(void);
231: static void dsp_movec_d(void);
232: static void dsp_movep_0(void);
233: static void dsp_movep_1(void);
234: static void dsp_movep_2(void);
235: static void dsp_rep_1(void);
236: static void dsp_rep_3(void);
237: static void dsp_rep_5(void);
238: static void dsp_rep_d(void);
239:
240: /* Parallel moves */
241: static void dsp_pm(void);
242: static void dsp_pm_0(void);
243: static void dsp_pm_1(void);
244: static void dsp_pm_2(void);
245: static void dsp_pm_4(void);
246: static void dsp_pm_8(void);
247:
248: /* Instructions with parallel moves */
249: static void dsp_abs(void);
250: static void dsp_adc(void);
251: static void dsp_add(void);
252: static void dsp_addl(void);
253: static void dsp_addr(void);
254: static void dsp_and(void);
255: static void dsp_asl(void);
256: static void dsp_asr(void);
257: static void dsp_clr(void);
258: static void dsp_cmp(void);
259: static void dsp_cmpm(void);
260: static void dsp_eor(void);
261: static void dsp_lsl(void);
262: static void dsp_lsr(void);
263: static void dsp_mac(void);
264: static void dsp_macr(void);
265: static void dsp_move(void);
266: static void dsp_move_nopm(void);
267: static void dsp_mpy(void);
268: static void dsp_mpyr(void);
269: static void dsp_neg(void);
270: static void dsp_not(void);
271: static void dsp_or(void);
272: static void dsp_rnd(void);
273: static void dsp_rol(void);
274: static void dsp_ror(void);
275: static void dsp_sbc(void);
276: static void dsp_sub(void);
277: static void dsp_subl(void);
278: static void dsp_subr(void);
279: static void dsp_tfr(void);
280: static void dsp_tst(void);
281:
282: static dsp_emul_t opcodes8h[16]={
283: opcode8h_0,
284: opcode8h_1,
285: dsp_tcc,
286: dsp_tcc,
287: opcode8h_4,
288: dsp_movec,
289: opcode8h_6,
290: dsp_movem,
291: opcode8h_8,
292: opcode8h_8,
293: opcode8h_a,
294: opcode8h_b,
295: dsp_jmp,
296: dsp_jsr,
297: dsp_jcc,
298: dsp_jscc
299: };
300:
301: static dsp_emul_t opcodes_0809[16]={
302: dsp_move_nopm,
303: dsp_move_nopm,
304: dsp_move_nopm,
305: dsp_move_nopm,
306:
307: dsp_movep,
308: dsp_movep,
309: dsp_movep,
310: dsp_movep,
311:
312: dsp_move_nopm,
313: dsp_move_nopm,
314: dsp_move_nopm,
315: dsp_move_nopm,
316:
317: dsp_movep,
318: dsp_movep,
319: dsp_movep,
320: dsp_movep
321: };
322:
323: static dsp_emul_t opcodes_0a[32]={
324: dsp_bclr,
325: dsp_bset,
326: dsp_bclr,
327: dsp_bset,
328: dsp_jclr,
329: dsp_jset,
330: dsp_jclr,
331: dsp_jset,
332:
333: dsp_bclr,
334: dsp_bset,
335: dsp_bclr,
336: dsp_bset,
337: dsp_jclr,
338: dsp_jset,
339: dsp_jclr,
340: dsp_jset,
341:
342: dsp_bclr,
343: dsp_bset,
344: dsp_bclr,
345: dsp_bset,
346: dsp_jclr,
347: dsp_jset,
348: dsp_jclr,
349: dsp_jset,
350:
351: dsp_jclr,
352: dsp_jset,
353: dsp_bclr,
354: dsp_bset,
355: dsp_jmp,
356: dsp_jcc,
357: dsp_undefined,
358: dsp_undefined
359: };
360:
361: static dsp_emul_t opcodes_0b[32]={
362: dsp_bchg,
363: dsp_btst,
364: dsp_bchg,
365: dsp_btst,
366: dsp_jsclr,
367: dsp_jsset,
368: dsp_jsclr,
369: dsp_jsset,
370:
371: dsp_bchg,
372: dsp_btst,
373: dsp_bchg,
374: dsp_btst,
375: dsp_jsclr,
376: dsp_jsset,
377: dsp_jsclr,
378: dsp_jsset,
379:
380: dsp_bchg,
381: dsp_btst,
382: dsp_bchg,
383: dsp_btst,
384: dsp_jsclr,
385: dsp_jsset,
386: dsp_jsclr,
387: dsp_jsset,
388:
389: dsp_jsclr,
390: dsp_jsclr,
391: dsp_bchg,
392: dsp_btst,
393: dsp_jsr,
394: dsp_jscc,
395: dsp_undefined,
396: dsp_undefined
397: };
398:
399: static dsp_emul_t opcodes_alu003f[64]={
400: /* 0x00 - 0x0f */
401: dsp_move,
402: dsp_tfr,
403: dsp_addr,
404: dsp_tst,
405: dsp_undefined,
406: dsp_cmp,
407: dsp_subr,
408: dsp_cmpm,
409: dsp_undefined,
410: dsp_tfr,
411: dsp_addr,
412: dsp_tst,
413: dsp_undefined,
414: dsp_cmp,
415: dsp_subr,
416: dsp_cmpm,
417:
418: /* 0x10 - 0x1f */
419: dsp_add,
420: dsp_rnd,
421: dsp_addl,
422: dsp_clr,
423: dsp_sub,
424: dsp_undefined,
425: dsp_subl,
426: dsp_not,
427: dsp_add,
428: dsp_rnd,
429: dsp_addl,
430: dsp_clr,
431: dsp_sub,
432: dsp_undefined,
433: dsp_subl,
434: dsp_not,
435:
436: /* 0x20 - 0x2f */
437: dsp_add,
438: dsp_adc,
439: dsp_asr,
440: dsp_lsr,
441: dsp_sub,
442: dsp_sbc,
443: dsp_abs,
444: dsp_ror,
445: dsp_add,
446: dsp_adc,
447: dsp_asr,
448: dsp_lsr,
449: dsp_sub,
450: dsp_sbc,
451: dsp_abs,
452: dsp_ror,
453:
454: /* 0x30 - 0x3f */
455: dsp_add,
456: dsp_adc,
457: dsp_asl,
458: dsp_lsl,
459: dsp_sub,
460: dsp_sbc,
461: dsp_neg,
462: dsp_rol,
463: dsp_add,
464: dsp_adc,
465: dsp_asl,
466: dsp_lsl,
467: dsp_sub,
468: dsp_sbc,
469: dsp_neg,
470: dsp_rol
471: };
472:
473: static dsp_emul_t opcodes_alu407f[16]={
474: dsp_add,
475: dsp_tfr,
476: dsp_or,
477: dsp_eor,
478: dsp_sub,
479: dsp_cmp,
480: dsp_and,
481: dsp_cmpm,
482: dsp_add,
483: dsp_tfr,
484: dsp_or,
485: dsp_eor,
486: dsp_sub,
487: dsp_cmp,
488: dsp_and,
489: dsp_cmpm
490: };
491:
492: static dsp_emul_t opcodes_alu80ff[4]={
493: dsp_mpy,
494: dsp_mpyr,
495: dsp_mac,
496: dsp_macr
497: };
498:
499: static dsp_emul_t opcodes_do[16]={
500: dsp_do_0,
501: dsp_undefined,
502: dsp_do_2,
503: dsp_undefined,
504:
505: dsp_do_4,
506: dsp_undefined,
507: dsp_do_2,
508: dsp_undefined,
509:
510: dsp_undefined,
511: dsp_undefined,
512: dsp_do_2,
513: dsp_undefined,
514:
515: dsp_do_c,
516: dsp_undefined,
517: dsp_do_2,
518: dsp_undefined
519: };
520:
521: static dsp_emul_t opcodes_movec[16]={
522: dsp_undefined,
523: dsp_undefined,
524: dsp_undefined,
525: dsp_undefined,
526:
527: dsp_undefined,
528: dsp_undefined,
529: dsp_undefined,
530: dsp_movec_7,
531:
532: dsp_undefined,
533: dsp_movec_9,
534: dsp_undefined,
535: dsp_movec_b,
536:
537: dsp_undefined,
538: dsp_movec_d,
539: dsp_undefined,
540: dsp_movec_b
541: };
542:
543: static dsp_emul_t opcodes_movep[4]={
544: dsp_movep_0,
545: dsp_movep_1,
546: dsp_movep_2,
547: dsp_movep_2
548: };
549:
550: static dsp_emul_t opcodes_rep[16]={
551: dsp_undefined,
552: dsp_rep_1,
553: dsp_undefined,
554: dsp_rep_3,
555:
556: dsp_undefined,
557: dsp_rep_5,
558: dsp_undefined,
559: dsp_rep_3,
560:
561: dsp_undefined,
562: dsp_undefined,
563: dsp_undefined,
564: dsp_rep_3,
565:
566: dsp_undefined,
567: dsp_rep_d,
568: dsp_undefined,
569: dsp_rep_3
570: };
571:
572: static dsp_emul_t opcodes_parmove[16]={
573: dsp_pm_0,
574: dsp_pm_1,
575: dsp_pm_2,
576: dsp_pm_2,
577: dsp_pm_4,
578: dsp_pm_4,
579: dsp_pm_4,
580: dsp_pm_4,
581:
582: dsp_pm_8,
583: dsp_pm_8,
584: dsp_pm_8,
585: dsp_pm_8,
586: dsp_pm_8,
587: dsp_pm_8,
588: dsp_pm_8,
589: dsp_pm_8
590: };
591:
592: static int registers_tcc[16][2]={
593: {DSP_REG_B,DSP_REG_A},
594: {DSP_REG_A,DSP_REG_B},
595: {DSP_REG_NULL,DSP_REG_NULL},
596: {DSP_REG_NULL,DSP_REG_NULL},
597:
598: {DSP_REG_NULL,DSP_REG_NULL},
599: {DSP_REG_NULL,DSP_REG_NULL},
600: {DSP_REG_NULL,DSP_REG_NULL},
601: {DSP_REG_NULL,DSP_REG_NULL},
602:
603: {DSP_REG_X0,DSP_REG_A},
604: {DSP_REG_X0,DSP_REG_B},
605: {DSP_REG_X1,DSP_REG_A},
606: {DSP_REG_X1,DSP_REG_B},
607:
608: {DSP_REG_Y0,DSP_REG_A},
609: {DSP_REG_Y0,DSP_REG_B},
610: {DSP_REG_Y1,DSP_REG_A},
611: {DSP_REG_Y1,DSP_REG_B}
612: };
613:
614: static const char *registers_lmove[8]={
615: "a10",
616: "b10",
617: "x",
618: "y",
619: "a",
620: "b",
621: "ab",
622: "ba"
623: };
624:
625: static const char *ea_names[9]={
626: "(r%d)-n%d", /* 000xxx */
627: "(r%d)+n%d", /* 001xxx */
628: "(r%d)-", /* 010xxx */
629: "(r%d)+", /* 011xxx */
630: "(r%d)", /* 100xxx */
631: "(r%d+n%d)", /* 101xxx */
632: "0x%04x", /* 110000 */
633: "-(r%d)", /* 111xxx */
634: "0x%06x" /* 110100 */
635: };
636:
637: static const char *cc_name[16]={
638: "cc",
639: "ge",
640: "ne",
641: "pl",
642: "nn",
643: "ec",
644: "lc",
645: "gt",
646:
647: "cs",
648: "lt",
649: "eq",
650: "mi",
651: "nr",
652: "es",
653: "ls",
654: "le"
655: };
656:
657: static char parallelmove_name[64];
658:
659: void dsp56k_disasm(void)
660: {
661: uint32 value;
662:
663: cur_inst = dsp_ram[DSP_SPACE_P][dsp_pc];
664:
665: #if 0
666: if (dsp_pc == 0x728) {
667: D(bug("Dsp: Disasm: instruction = 0x%06x",cur_inst));
668: }
669: #endif
670:
671: strcpy(parallelmove_name, "");
672:
673: value = (cur_inst >> 16) & BITMASK(8);
674: if (value< 0x10) {
675: opcodes8h[value]();
676: } else {
677: dsp_pm();
678: value = cur_inst & BITMASK(8);
679: if (value < 0x40) {
680: opcodes_alu003f[value]();
681: } else if (value < 0x80) {
682: value &= BITMASK(4);
683: opcodes_alu407f[value]();
684: } else {
685: value &= BITMASK(2);
686: opcodes_alu80ff[value]();
687: }
688: }
689: }
690:
691: /**********************************
692: * Conditions code calculation
693: **********************************/
694:
695: static void dsp_calc_cc(uint32 cc_mode, char *dest)
696: {
697: strcpy(dest, cc_name[cc_mode & BITMASK(4)]);
698: }
699:
700: /**********************************
701: * Effective address calculation
702: **********************************/
703:
704: static int dsp_calc_ea(uint32 ea_mode, char *dest)
705: {
706: int value, retour, numreg;
707:
708: value = (ea_mode >> 3) & BITMASK(3);
709: numreg = ea_mode & BITMASK(3);
710: retour = 0;
711: switch (value) {
712: case 0:
713: /* (Rx)-Nx */
714: sprintf(dest, ea_names[value], numreg, numreg);
715: registers_changed[DSP_REG_R0+numreg]=1;
716: break;
717: case 1:
718: /* (Rx)+Nx */
719: sprintf(dest, ea_names[value], numreg, numreg);
720: registers_changed[DSP_REG_R0+numreg]=1;
721: break;
722: case 5:
723: /* (Rx+Nx) */
724: sprintf(dest, ea_names[value], numreg, numreg);
725: break;
726: case 2:
727: /* (Rx)- */
728: sprintf(dest, ea_names[value], numreg);
729: registers_changed[DSP_REG_R0+numreg]=1;
730: break;
731: case 3:
732: /* (Rx)+ */
733: sprintf(dest, ea_names[value], numreg);
734: registers_changed[DSP_REG_R0+numreg]=1;
735: break;
736: case 4:
737: /* (Rx) */
738: sprintf(dest, ea_names[value], numreg);
739: break;
740: case 7:
741: /* -(Rx) */
742: sprintf(dest, ea_names[value], numreg);
743: registers_changed[DSP_REG_R0+numreg]=1;
744: break;
745: case 6:
746: switch ((ea_mode >> 2) & 1) {
747: case 0:
748: /* Absolute address */
749: sprintf(dest, ea_names[value], dsp_ram[DSP_SPACE_P][dsp_pc+1]);
750: break;
751: case 1:
752: /* Immediate value */
753: sprintf(dest, ea_names[8], dsp_ram[DSP_SPACE_P][dsp_pc+1]);
754: retour = 1;
755: break;
756: }
757: break;
758: }
759: return retour;
760: }
761:
762: static void opcode8h_0(void)
763: {
764: uint32 value;
765:
766: if (cur_inst <= 0x00008c) {
767: switch(cur_inst) {
768: case 0x000000:
769: dsp_nop();
770: break;
771: case 0x000004:
772: dsp_rti();
773: break;
774: case 0x000005:
775: dsp_illegal();
776: break;
777: case 0x000006:
778: dsp_swi();
779: break;
780: case 0x00000c:
781: dsp_rts();
782: break;
783: case 0x000084:
784: dsp_reset();
785: break;
786: case 0x000086:
787: dsp_wait();
788: break;
789: case 0x000087:
790: dsp_stop();
791: break;
792: case 0x00008c:
793: dsp_enddo();
794: break;
795: }
796: } else {
797: value = cur_inst & 0xf8;
798: switch (value) {
799: case 0x0000b8:
800: dsp_andi();
801: break;
802: case 0x0000f8:
803: dsp_ori();
804: break;
805: }
806: }
807: }
808:
809: static void opcode8h_1(void)
810: {
811: switch(cur_inst & 0xfff8c7) {
812: case 0x018040:
813: dsp_div();
814: break;
815: case 0x01c805:
816: dsp_norm();
817: break;
818: }
819: }
820:
821: static void opcode8h_4(void)
822: {
823: switch((cur_inst>>5) & BITMASK(3)) {
824: case 0:
825: dsp_lua();
826: break;
827: case 5:
828: dsp_movec();
829: break;
830: }
831: }
832:
833: static void opcode8h_6(void)
834: {
835: if (cur_inst & (1<<5)) {
836: dsp_rep();
837: } else {
838: dsp_do();
839: }
840: }
841:
842: static void opcode8h_8(void)
843: {
844: uint32 value;
845:
846: value = (cur_inst >> 12) & BITMASK(4);
847: opcodes_0809[value]();
848: }
849:
850: static void opcode8h_a(void)
851: {
852: uint32 value;
853:
854: value = (cur_inst >> 11) & (BITMASK(2)<<3);
855: value |= (cur_inst >> 5) & BITMASK(3);
856:
857: opcodes_0a[value]();
858: }
859:
860: static void opcode8h_b(void)
861: {
862: uint32 value;
863:
864: value = (cur_inst >> 11) & (BITMASK(2)<<3);
865: value |= (cur_inst >> 5) & BITMASK(3);
866:
867: opcodes_0b[value]();
868: }
869:
870: /**********************************
871: * Non-parallel moves instructions
872: **********************************/
873:
874: static void dsp_undefined(void)
875: {
876: fprintf(stderr,"Dsp: 0x%04x: 0x%06x unknown instruction\n",dsp_pc, cur_inst);
877: }
878:
879: static void dsp_andi(void)
880: {
881: const char *regname;
882:
883: switch(cur_inst & BITMASK(2)) {
884: case 0:
885: regname="mr";
886: registers_changed[DSP_REG_SR]=1;
887: break;
888: case 1:
889: regname="ccr";
890: registers_changed[DSP_REG_SR]=1;
891: break;
892: case 2:
893: regname="omr";
894: registers_changed[DSP_REG_OMR]=1;
895: break;
896: default:
897: regname="";
898: break;
899: }
900:
901: fprintf(stderr,"Dsp: 0x%04x: andi #0x%02x,%s\n",
902: dsp_pc,
903: (cur_inst>>8) & BITMASK(8),
904: regname
905: );
906: }
907:
908: static void dsp_bchg(void)
909: {
910: char name[16], addr_name[16];
911: uint32 memspace, value, numbit;
912:
913: memspace = (cur_inst>>6) & 1;
914: value = (cur_inst>>8) & BITMASK(6);
915: numbit = cur_inst & BITMASK(5);
916:
917: switch((cur_inst>>14) & BITMASK(2)) {
918: case 0:
919: /* bchg #n,x:aa */
920: /* bchg #n,y:aa */
921: if (memspace) {
922: sprintf(name,"y:0x%04x",value);
923: } else {
924: sprintf(name,"x:0x%04x",value);
925: }
926: break;
927: case 1:
928: /* bchg #n,x:ea */
929: /* bchg #n,y:ea */
930: dsp_calc_ea(value, addr_name);
931: if (memspace) {
932: sprintf(name,"y:%s",addr_name);
933: } else {
934: sprintf(name,"x:%s",addr_name);
935: }
936: break;
937: case 2:
938: /* bchg #n,x:pp */
939: /* bchg #n,y:pp */
940: if (memspace) {
941: sprintf(name,"y:0x%04x",value+0xffc0);
942: } else {
943: sprintf(name,"x:0x%04x",value+0xffc0);
944: }
945: break;
946: case 3:
947: /* bchg #n,R */
948: sprintf(name,"%s",registers_name[value]);
949: registers_changed[value]=1;
950: break;
951: }
952:
953: fprintf(stderr,"Dsp: 0x%04x: bchg #%d,%s\n",dsp_pc, numbit, name);
954: }
955:
956: static void dsp_bclr(void)
957: {
958: char name[16], addr_name[16];
959: uint32 memspace, value, numbit;
960:
961: memspace = (cur_inst>>6) & 1;
962: value = (cur_inst>>8) & BITMASK(6);
963: numbit = cur_inst & BITMASK(5);
964:
965: switch((cur_inst>>14) & BITMASK(2)) {
966: case 0:
967: /* bclr #n,x:aa */
968: /* bclr #n,y:aa */
969: if (memspace) {
970: sprintf(name,"y:0x%04x",value);
971: } else {
972: sprintf(name,"x:0x%04x",value);
973: }
974: break;
975: case 1:
976: /* bclr #n,x:ea */
977: /* bclr #n,y:ea */
978: dsp_calc_ea(value, addr_name);
979: if (memspace) {
980: sprintf(name,"y:%s",addr_name);
981: } else {
982: sprintf(name,"x:%s",addr_name);
983: }
984: break;
985: case 2:
986: /* bclr #n,x:pp */
987: /* bclr #n,y:pp */
988: if (memspace) {
989: sprintf(name,"y:0x%04x",value+0xffc0);
990: } else {
991: sprintf(name,"x:0x%04x",value+0xffc0);
992: }
993: break;
994: case 3:
995: /* bclr #n,R */
996: sprintf(name,"%s",registers_name[value]);
997: registers_changed[value]=1;
998: break;
999: }
1000:
1001: fprintf(stderr,"Dsp: 0x%04x: bclr #%d,%s\n",dsp_pc, numbit, name);
1002: }
1003:
1004: static void dsp_bset(void)
1005: {
1006: char name[16], addr_name[16];
1007: uint32 memspace, value, numbit;
1008:
1009: memspace = (cur_inst>>6) & 1;
1010: value = (cur_inst>>8) & BITMASK(6);
1011: numbit = cur_inst & BITMASK(5);
1012:
1013: switch((cur_inst>>14) & BITMASK(2)) {
1014: case 0:
1015: /* bset #n,x:aa */
1016: /* bset #n,y:aa */
1017: if (memspace) {
1018: sprintf(name,"y:0x%04x",value);
1019: } else {
1020: sprintf(name,"x:0x%04x",value);
1021: }
1022: break;
1023: case 1:
1024: /* bset #n,x:ea */
1025: /* bset #n,y:ea */
1026: dsp_calc_ea(value, addr_name);
1027: if (memspace) {
1028: sprintf(name,"y:%s",addr_name);
1029: } else {
1030: sprintf(name,"x:%s",addr_name);
1031: }
1032: break;
1033: case 2:
1034: /* bset #n,x:pp */
1035: /* bset #n,y:pp */
1036: if (memspace) {
1037: sprintf(name,"y:0x%04x",value+0xffc0);
1038: } else {
1039: sprintf(name,"x:0x%04x",value+0xffc0);
1040: }
1041: break;
1042: case 3:
1043: /* bset #n,R */
1044: sprintf(name,"%s",registers_name[value]);
1045: registers_changed[value]=1;
1046: break;
1047: }
1048:
1049: fprintf(stderr,"Dsp: 0x%04x: bset #%d,%s\n",dsp_pc, numbit, name);
1050: }
1051:
1052: static void dsp_btst(void)
1053: {
1054: char name[16], addr_name[16];
1055: uint32 memspace, value, numbit;
1056:
1057: memspace = (cur_inst>>6) & 1;
1058: value = (cur_inst>>8) & BITMASK(6);
1059: numbit = cur_inst & BITMASK(5);
1060:
1061: switch((cur_inst>>14) & BITMASK(2)) {
1062: case 0:
1063: /* btst #n,x:aa */
1064: /* btst #n,y:aa */
1065: if (memspace) {
1066: sprintf(name,"y:0x%04x",value);
1067: } else {
1068: sprintf(name,"x:0x%04x",value);
1069: }
1070: break;
1071: case 1:
1072: /* btst #n,x:ea */
1073: /* btst #n,y:ea */
1074: dsp_calc_ea(value, addr_name);
1075: if (memspace) {
1076: sprintf(name,"y:%s",addr_name);
1077: } else {
1078: sprintf(name,"x:%s",addr_name);
1079: }
1080: break;
1081: case 2:
1082: /* btst #n,x:pp */
1083: /* btst #n,y:pp */
1084: if (memspace) {
1085: sprintf(name,"y:0x%04x",value+0xffc0);
1086: } else {
1087: sprintf(name,"x:0x%04x",value+0xffc0);
1088: }
1089: break;
1090: case 3:
1091: /* btst #n,R */
1092: sprintf(name,"%s",registers_name[value]);
1093: registers_changed[value]=1;
1094: break;
1095: }
1096:
1097: fprintf(stderr,"Dsp: 0x%04x: btst #%d,%s\n",dsp_pc, numbit, name);
1098: }
1099:
1100: static void dsp_div(void)
1101: {
1102: uint32 srcreg=DSP_REG_NULL, destreg;
1103:
1104: switch((cur_inst>>4) & BITMASK(2)) {
1105: case 0:
1106: srcreg = DSP_REG_X0;
1107: break;
1108: case 1:
1109: srcreg = DSP_REG_Y0;
1110: break;
1111: case 2:
1112: srcreg = DSP_REG_X1;
1113: break;
1114: case 3:
1115: srcreg = DSP_REG_Y1;
1116: break;
1117: }
1118: destreg = DSP_REG_A+((cur_inst>>3) & 1);
1119: registers_changed[destreg]=1;
1120:
1121: fprintf(stderr,"Dsp: 0x%04x: div %s,%s\n",dsp_pc, registers_name[srcreg],registers_name[destreg]);
1122: }
1123:
1124: static void dsp_do(void)
1125: {
1126: uint32 value;
1127:
1128: value = (cur_inst>>12) & (BITMASK(2)<<2);
1129: value |= (cur_inst>>6) & 1<<1;
1130: value |= (cur_inst>>5) & 1;
1131:
1132: opcodes_do[value]();
1133:
1134: registers_changed[DSP_REG_LA]=1;
1135: registers_changed[DSP_REG_LC]=1;
1136: }
1137:
1138: static void dsp_do_0(void)
1139: {
1140: char name[16];
1141:
1142: if (cur_inst & (1<<6)) {
1143: sprintf(name, "y:0x%04x", (cur_inst>>8) & BITMASK(6));
1144: } else {
1145: sprintf(name, "x:0x%04x", (cur_inst>>8) & BITMASK(6));
1146: }
1147:
1148: fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n",
1149: dsp_pc,
1150: name,
1151: dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
1152: );
1153: }
1154:
1155: static void dsp_do_2(void)
1156: {
1157: fprintf(stderr,"Dsp: 0x%04x: do #0x%04x,p:0x%04x\n",
1158: dsp_pc,
1159: ((cur_inst>>8) & BITMASK(8))|((cur_inst & BITMASK(4))<<8),
1160: dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
1161: );
1162: }
1163:
1164: static void dsp_do_4(void)
1165: {
1166: char addr_name[16], name[16];
1167: uint32 ea_mode;
1168:
1169: ea_mode = (cur_inst>>8) & BITMASK(6);
1170: dsp_calc_ea(ea_mode, addr_name);
1171:
1172: if (cur_inst & (1<<6)) {
1173: sprintf(name, "y:%s", addr_name);
1174: } else {
1175: sprintf(name, "x:%s", addr_name);
1176: }
1177:
1178: fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n",
1179: dsp_pc,
1180: name,
1181: dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
1182: );
1183: }
1184:
1185: static void dsp_do_c(void)
1186: {
1187: fprintf(stderr,"Dsp: 0x%04x: do %s,p:0x%04x\n",
1188: dsp_pc,
1189: registers_name[(cur_inst>>8) & BITMASK(6)],
1190: dsp_ram[DSP_SPACE_P][dsp_pc+1] & BITMASK(16)
1191: );
1192: }
1193:
1194: static void dsp_enddo(void)
1195: {
1196: fprintf(stderr,"Dsp: 0x%04x: enddo\n",dsp_pc);
1197: }
1198:
1199: static void dsp_illegal(void)
1200: {
1201: fprintf(stderr,"Dsp: 0x%04x: illegal\n",dsp_pc);
1202: }
1203:
1204: static void dsp_jcc(void)
1205: {
1206: char cond_name[16], addr_name[16];
1207: uint32 cc_code=0;
1208:
1209: switch((cur_inst >> 16) & BITMASK(8)) {
1210: case 0x0a:
1211: dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name);
1212: cc_code=cur_inst & BITMASK(4);
1213: break;
1214: case 0x0e:
1215: sprintf(addr_name, "0x%04x", cur_inst & BITMASK(12));
1216: cc_code=(cur_inst>>12) & BITMASK(4);
1217: break;
1218: }
1219: dsp_calc_cc(cc_code, cond_name);
1220:
1221: fprintf(stderr,"Dsp: 0x%04x: j%s p:%s\n",dsp_pc, cond_name, addr_name);
1222: }
1223:
1224: static void dsp_jclr(void)
1225: {
1226: char srcname[16], addr_name[16];
1227: uint32 memspace, value, numbit;
1228:
1229: memspace = (cur_inst>>6) & 1;
1230: value = (cur_inst>>8) & BITMASK(6);
1231: numbit = cur_inst & BITMASK(5);
1232:
1233: switch((cur_inst>>14) & BITMASK(2)) {
1234: case 0:
1235: /* jclr #n,x:aa,p:xx */
1236: /* jclr #n,y:aa,p:xx */
1237: if (memspace) {
1238: sprintf(srcname, "y:0x%04x", value);
1239: } else {
1240: sprintf(srcname, "x:0x%04x", value);
1241: }
1242: break;
1243: case 1:
1244: /* jclr #n,x:ea,p:xx */
1245: /* jclr #n,y:ea,p:xx */
1246: dsp_calc_ea(value, addr_name);
1247: if (memspace) {
1248: sprintf(srcname, "y:%s", addr_name);
1249: } else {
1250: sprintf(srcname, "x:%s", addr_name);
1251: }
1252: break;
1253: case 2:
1254: /* jclr #n,x:pp,p:xx */
1255: /* jclr #n,y:pp,p:xx */
1256: value += 0xffc0;
1257: if (memspace) {
1258: sprintf(srcname, "y:0x%04x", value);
1259: } else {
1260: sprintf(srcname, "x:0x%04x", value);
1261: }
1262: break;
1263: case 3:
1264: /* jclr #n,R,p:xx */
1265: sprintf(srcname, registers_name[value]);
1266: break;
1267: }
1268:
1269: fprintf(stderr,"Dsp: 0x%04x: jclr #%d,%s,p:0x%04x\n",
1270: dsp_pc,
1271: numbit,
1272: srcname,
1273: dsp_ram[DSP_SPACE_P][dsp_pc+1]
1274: );
1275: }
1276:
1277: static void dsp_jmp(void)
1278: {
1279: char dstname[16];
1280:
1281: switch((cur_inst >> 16) & BITMASK(8)) {
1282: case 0x0a:
1283: dsp_calc_ea((cur_inst >>8) & BITMASK(6), dstname);
1284: break;
1285: case 0x0c:
1286: sprintf(dstname, "0x%04x", cur_inst & BITMASK(12));
1287: break;
1288: }
1289:
1290: fprintf(stderr,"Dsp: 0x%04x: jmp p:%s\n",dsp_pc, dstname);
1291: }
1292:
1293: static void dsp_jscc(void)
1294: {
1295: char cond_name[16], addr_name[16];
1296: uint32 cc_code=0;
1297:
1298: switch((cur_inst >> 16) & BITMASK(8)) {
1299: case 0x0b:
1300: dsp_calc_ea((cur_inst >>8) & BITMASK(6), addr_name);
1301: cc_code=cur_inst & BITMASK(4);
1302: break;
1303: case 0x0f:
1304: sprintf(addr_name, "0x%04x", cur_inst & BITMASK(12));
1305: cc_code=(cur_inst>>12) & BITMASK(4);
1306: break;
1307: }
1308: dsp_calc_cc(cc_code, cond_name);
1309:
1310: fprintf(stderr,"Dsp: 0x%04x: js%s p:%s\n",dsp_pc, cond_name, addr_name);
1311: }
1312:
1313: static void dsp_jsclr(void)
1314: {
1315: char srcname[16], addr_name[16];
1316: uint32 memspace, value, numbit;
1317:
1318: memspace = (cur_inst>>6) & 1;
1319: value = (cur_inst>>8) & BITMASK(6);
1320: numbit = cur_inst & BITMASK(5);
1321:
1322: switch((cur_inst>>14) & BITMASK(2)) {
1323: case 0:
1324: /* jsclr #n,x:aa,p:xx */
1325: /* jsclr #n,y:aa,p:xx */
1326: if (memspace) {
1327: sprintf(srcname, "y:0x%04x", value);
1328: } else {
1329: sprintf(srcname, "x:0x%04x", value);
1330: }
1331: break;
1332: case 1:
1333: /* jsclr #n,x:ea,p:xx */
1334: /* jsclr #n,y:ea,p:xx */
1335: dsp_calc_ea(value, addr_name);
1336: if (memspace) {
1337: sprintf(srcname, "y:%s", addr_name);
1338: } else {
1339: sprintf(srcname, "x:%s", addr_name);
1340: }
1341: break;
1342: case 2:
1343: /* jsclr #n,x:pp,p:xx */
1344: /* jsclr #n,y:pp,p:xx */
1345: value += 0xffc0;
1346: if (memspace) {
1347: sprintf(srcname, "y:0x%04x", value);
1348: } else {
1349: sprintf(srcname, "x:0x%04x", value);
1350: }
1351: break;
1352: case 3:
1353: /* jsclr #n,R,p:xx */
1354: sprintf(srcname, registers_name[value]);
1355: break;
1356: }
1357:
1358: fprintf(stderr,"Dsp: 0x%04x: jsclr #%d,%s,p:0x%04x\n",
1359: dsp_pc,
1360: numbit,
1361: srcname,
1362: dsp_ram[DSP_SPACE_P][dsp_pc+1]
1363: );
1364: }
1365:
1366: static void dsp_jset(void)
1367: {
1368: char srcname[16], addr_name[16];
1369: uint32 memspace, value, numbit;
1370:
1371: memspace = (cur_inst>>6) & 1;
1372: value = (cur_inst>>8) & BITMASK(6);
1373: numbit = cur_inst & BITMASK(5);
1374:
1375: switch((cur_inst>>14) & BITMASK(2)) {
1376: case 0:
1377: /* jset #n,x:aa,p:xx */
1378: /* jset #n,y:aa,p:xx */
1379: if (memspace) {
1380: sprintf(srcname, "y:0x%04x", value);
1381: } else {
1382: sprintf(srcname, "x:0x%04x", value);
1383: }
1384: break;
1385: case 1:
1386: /* jset #n,x:ea,p:xx */
1387: /* jset #n,y:ea,p:xx */
1388: dsp_calc_ea(value, addr_name);
1389: if (memspace) {
1390: sprintf(srcname, "y:%s", addr_name);
1391: } else {
1392: sprintf(srcname, "x:%s", addr_name);
1393: }
1394: break;
1395: case 2:
1396: /* jset #n,x:pp,p:xx */
1397: /* jset #n,y:pp,p:xx */
1398: value += 0xffc0;
1399: if (memspace) {
1400: sprintf(srcname, "y:0x%04x", value);
1401: } else {
1402: sprintf(srcname, "x:0x%04x", value);
1403: }
1404: break;
1405: case 3:
1406: /* jset #n,R,p:xx */
1407: sprintf(srcname, registers_name[value]);
1408: break;
1409: }
1410:
1411: fprintf(stderr,"Dsp: 0x%04x: jset #%d,%s,p:0x%04x\n",
1412: dsp_pc,
1413: numbit,
1414: srcname,
1415: dsp_ram[DSP_SPACE_P][dsp_pc+1]
1416: );
1417: }
1418:
1419: static void dsp_jsr(void)
1420: {
1421: char dstname[16];
1422:
1423: if (((cur_inst>>12) & BITMASK(4))==0) {
1424: sprintf(dstname, "0x%04x", cur_inst & BITMASK(12));
1425: } else {
1426: dsp_calc_ea((cur_inst>>8) & BITMASK(6),dstname);
1427: }
1428:
1429: fprintf(stderr,"Dsp: 0x%04x: jsr p:%s\n",dsp_pc, dstname);
1430: }
1431:
1432: static void dsp_jsset(void)
1433: {
1434: char srcname[16], addr_name[16];
1435: uint32 memspace, value, numbit;
1436:
1437: memspace = (cur_inst>>6) & 1;
1438: value = (cur_inst>>8) & BITMASK(6);
1439: numbit = cur_inst & BITMASK(5);
1440:
1441: switch((cur_inst>>14) & BITMASK(2)) {
1442: case 0:
1443: /* jsset #n,x:aa,p:xx */
1444: /* jsset #n,y:aa,p:xx */
1445: if (memspace) {
1446: sprintf(srcname, "y:0x%04x", value);
1447: } else {
1448: sprintf(srcname, "x:0x%04x", value);
1449: }
1450: break;
1451: case 1:
1452: /* jsset #n,x:ea,p:xx */
1453: /* jsset #n,y:ea,p:xx */
1454: dsp_calc_ea(value, addr_name);
1455: if (memspace) {
1456: sprintf(srcname, "y:%s", addr_name);
1457: } else {
1458: sprintf(srcname, "x:%s", addr_name);
1459: }
1460: break;
1461: case 2:
1462: /* jsset #n,x:pp,p:xx */
1463: /* jsset #n,y:pp,p:xx */
1464: value += 0xffc0;
1465: if (memspace) {
1466: sprintf(srcname, "y:0x%04x", value);
1467: } else {
1468: sprintf(srcname, "x:0x%04x", value);
1469: }
1470: break;
1471: case 3:
1472: /* jsset #n,R,p:xx */
1473: sprintf(srcname, registers_name[value]);
1474: break;
1475: }
1476:
1477: fprintf(stderr,"Dsp: 0x%04x: jsset #%d,%s,p:0x%04x\n",
1478: dsp_pc,
1479: numbit,
1480: srcname,
1481: dsp_ram[DSP_SPACE_P][dsp_pc+1]
1482: );
1483: }
1484:
1485: static void dsp_lua(void)
1486: {
1487: char addr_name[16], numreg;
1488:
1489: dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name);
1490: numreg = cur_inst & BITMASK(3);
1491: registers_changed[DSP_REG_R0+numreg]=1;
1492:
1493: fprintf(stderr,"Dsp: 0x%04x: lua %s,r%d\n",dsp_pc, addr_name, numreg);
1494: }
1495:
1496: static void dsp_movec(void)
1497: {
1498: uint32 value;
1499:
1500: value = (cur_inst>>13) & (1<<3);
1501: value |= (cur_inst>>12) & (1<<2);
1502: value |= (cur_inst>>6) & (1<<1);
1503: value |= (cur_inst>>5) & 1;
1504:
1505: opcodes_movec[value]();
1506: }
1507:
1508: static void dsp_movec_7(void)
1509: {
1510: uint32 numreg1, numreg2;
1511:
1512: /* S1,D2 */
1513: /* S2,D1 */
1514:
1515: numreg2 = (cur_inst>>8) & BITMASK(6);
1516: numreg1 = (cur_inst & BITMASK(5))|0x20;
1517:
1518: if (cur_inst & (1<<15)) {
1519: /* Write D1 */
1520: fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, registers_name[numreg2], registers_name[numreg1]);
1521: registers_changed[numreg1]=1;
1522: } else {
1523: /* Read S1 */
1524: fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, registers_name[numreg1], registers_name[numreg2]);
1525: registers_changed[numreg2]=1;
1526: }
1527: }
1528:
1529: static void dsp_movec_9(void)
1530: {
1531: const char *spacename;
1532: char srcname[16],dstname[16];
1533: uint32 numreg, addr;
1534:
1535: /* x:aa,D1 */
1536: /* S1,x:aa */
1537: /* y:aa,D1 */
1538: /* S1,y:aa */
1539:
1540: numreg = (cur_inst & BITMASK(5))|0x20;
1541: addr = (cur_inst>>8) & BITMASK(6);
1542:
1543: if (cur_inst & (1<<6)) {
1544: spacename="y";
1545: } else {
1546: spacename="x";
1547: }
1548:
1549: if (cur_inst & (1<<15)) {
1550: /* Write D1 */
1551: sprintf(srcname, "%s:0x%04x", spacename, addr);
1552: strcpy(dstname, registers_name[numreg]);
1553: } else {
1554: /* Read S1 */
1555: strcpy(srcname, registers_name[numreg]);
1556: sprintf(dstname, "%s:0x%04x", spacename, addr);
1557: }
1558:
1559: fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, srcname, dstname);
1560: }
1561:
1562: static void dsp_movec_b(void)
1563: {
1564: uint32 numreg;
1565:
1566: /* #xx,D1 */
1567:
1568: numreg = (cur_inst & BITMASK(5))|0x20;
1569:
1570: registers_changed[numreg]=1;
1571: fprintf(stderr,"Dsp: 0x%04x: movec #0x%02x,%s\n",dsp_pc, (cur_inst>>8) & BITMASK(8), registers_name[numreg]);
1572: }
1573:
1574: static void dsp_movec_d(void)
1575: {
1576: const char *spacename;
1577: char srcname[16], dstname[16], addr_name[16];
1578: uint32 numreg, ea_mode;
1579: int retour;
1580:
1581: /* x:ea,D1 */
1582: /* S1,x:ea */
1583: /* y:ea,D1 */
1584: /* S1,y:ea */
1585: /* #xxxx,D1 */
1586:
1587: numreg = (cur_inst & BITMASK(5))|0x20;
1588: ea_mode = (cur_inst>>8) & BITMASK(6);
1589: retour = dsp_calc_ea(ea_mode, addr_name);
1590:
1591: if (cur_inst & (1<<6)) {
1592: spacename="y";
1593: } else {
1594: spacename="x";
1595: }
1596:
1597: if (cur_inst & (1<<15)) {
1598: /* Write D1 */
1599: if (retour) {
1600: sprintf(srcname, "#%s", addr_name);
1601: } else {
1602: sprintf(srcname, "%s:%s", spacename, addr_name);
1603: }
1604: registers_changed[numreg]=1;
1605: strcpy(dstname, registers_name[numreg]);
1606: } else {
1607: /* Read S1 */
1608: strcpy(srcname, registers_name[numreg]);
1609: sprintf(dstname, "%s:%s", spacename, addr_name);
1610: }
1611:
1612: fprintf(stderr,"Dsp: 0x%04x: movec %s,%s\n",dsp_pc, srcname, dstname);
1613: }
1614:
1615: static void dsp_movem(void)
1616: {
1617: char addr_name[16], srcname[16], dstname[16];
1618: uint32 ea_mode, numreg;
1619:
1620: if (cur_inst & (1<<14)) {
1621: /* S,p:ea */
1622: /* p:ea,D */
1623:
1624: ea_mode = (cur_inst>>8) & BITMASK(6);
1625: dsp_calc_ea(ea_mode, addr_name);
1626: } else {
1627: /* S,p:aa */
1628: /* p:aa,D */
1629:
1630: sprintf(addr_name, "0x%04x",(cur_inst>>8) & BITMASK(6));
1631: }
1632:
1633: numreg = cur_inst & BITMASK(6);
1634: if (cur_inst & (1<<15)) {
1635: /* Write D */
1636: registers_changed[numreg]=1;
1637: sprintf(srcname, "p:%s", addr_name);
1638: strcpy(dstname, registers_name[numreg]);
1639: } else {
1640: /* Read S */
1641: strcpy(srcname, registers_name[numreg]);
1642: sprintf(dstname, "p:%s", addr_name);
1643: }
1644:
1645: fprintf(stderr,"Dsp: 0x%04x: movem %s,%s\n",dsp_pc, srcname, dstname);
1646: }
1647:
1648: static void dsp_movep(void)
1649: {
1650: uint32 value;
1651:
1652: value = (cur_inst>>6) & BITMASK(2);
1653:
1654: opcodes_movep[value]();
1655: }
1656:
1657: static void dsp_movep_0(void)
1658: {
1659: char srcname[16]="",dstname[16]="";
1660: uint32 addr, memspace, numreg;
1661:
1662: /* S,x:pp */
1663: /* x:pp,D */
1664: /* S,y:pp */
1665: /* y:pp,D */
1666:
1667: addr = 0xffc0 + (cur_inst & BITMASK(6));
1668: memspace = (cur_inst>>16) & 1;
1669: numreg = (cur_inst>>8) & BITMASK(6);
1670:
1671: if (cur_inst & (1<<15)) {
1672: /* Write pp */
1673:
1674: strcpy(srcname, registers_name[numreg]);
1675:
1676: if (memspace) {
1677: sprintf(dstname, "y:0x%04x", addr);
1678: } else {
1679: sprintf(dstname, "x:0x%04x", addr);
1680: }
1681: } else {
1682: /* Read pp */
1683:
1684: if (memspace) {
1685: sprintf(srcname, "y:0x%04x", addr);
1686: } else {
1687: sprintf(srcname, "x:0x%04x", addr);
1688: }
1689:
1690: registers_changed[numreg]=1;
1691: strcpy(dstname, registers_name[numreg]);
1692: }
1693:
1694: fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
1695: }
1696:
1697: static void dsp_movep_1(void)
1698: {
1699: char srcname[16]="",dstname[16]="",name[16]="";
1700: uint32 addr, memspace;
1701:
1702: /* p:ea,x:pp */
1703: /* x:pp,p:ea */
1704: /* p:ea,y:pp */
1705: /* y:pp,p:ea */
1706:
1707: addr = 0xffc0 + (cur_inst & BITMASK(6));
1708: dsp_calc_ea((cur_inst>>8) & BITMASK(6), name);
1709: memspace = (cur_inst>>16) & 1;
1710:
1711: if (cur_inst & (1<<15)) {
1712: /* Write pp */
1713:
1714: sprintf(srcname, "p:%s", name);
1715:
1716: if (memspace) {
1717: sprintf(dstname, "y:0x%04x", addr);
1718: } else {
1719: sprintf(dstname, "x:0x%04x", addr);
1720: }
1721: } else {
1722: /* Read pp */
1723:
1724: if (memspace) {
1725: sprintf(srcname, "y:0x%04x", addr);
1726: } else {
1727: sprintf(srcname, "x:0x%04x", addr);
1728: }
1729:
1730: sprintf(dstname, "p:%s", name);
1731: }
1732:
1733: fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
1734: }
1735:
1736: static void dsp_movep_2(void)
1737: {
1738: char srcname[16]="",dstname[16]="",name[16]="";
1739: uint32 addr, memspace, easpace, retour;
1740:
1741: /* x:ea,x:pp */
1742: /* y:ea,x:pp */
1743: /* #xxxxxx,x:pp */
1744: /* x:pp,x:ea */
1745: /* x:pp,y:ea */
1746:
1747: /* x:ea,y:pp */
1748: /* y:ea,y:pp */
1749: /* #xxxxxx,y:pp */
1750: /* y:pp,y:ea */
1751: /* y:pp,x:ea */
1752:
1753: addr = 0xffc0 + (cur_inst & BITMASK(6));
1754: retour = dsp_calc_ea((cur_inst>>8) & BITMASK(6), name);
1755: memspace = (cur_inst>>16) & 1;
1756: easpace = (cur_inst>>6) & 1;
1757:
1758: if (cur_inst & (1<<15)) {
1759: /* Write pp */
1760:
1761: if (retour) {
1762: sprintf(srcname, "#%s", name);
1763: } else {
1764: if (easpace) {
1765: sprintf(srcname, "y:%s", name);
1766: } else {
1767: sprintf(srcname, "x:%s", name);
1768: }
1769: }
1770:
1771: if (memspace) {
1772: sprintf(dstname, "y:0x%04x", addr);
1773: } else {
1774: sprintf(dstname, "x:0x%04x", addr);
1775: }
1776: } else {
1777: /* Read pp */
1778:
1779: if (memspace) {
1780: sprintf(srcname, "y:0x%04x", addr);
1781: } else {
1782: sprintf(srcname, "x:0x%04x", addr);
1783: }
1784:
1785: if (easpace) {
1786: sprintf(dstname, "y:%s", name);
1787: } else {
1788: sprintf(dstname, "x:%s", name);
1789: }
1790: }
1791:
1792: fprintf(stderr,"Dsp: 0x%04x: movep %s,%s\n",dsp_pc, srcname, dstname);
1793: }
1794:
1795: static void dsp_nop(void)
1796: {
1797: fprintf(stderr,"Dsp: 0x%04x: nop\n",dsp_pc);
1798: }
1799:
1800: static void dsp_norm(void)
1801: {
1802: uint32 srcreg, destreg;
1803:
1804: srcreg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3));
1805: destreg = DSP_REG_A+((cur_inst>>3) & 1);
1806:
1807: registers_changed[srcreg]=1;
1808: registers_changed[destreg]=1;
1809:
1810: fprintf(stderr,"Dsp: 0x%04x: norm %s,%s\n",dsp_pc, registers_name[srcreg], registers_name[destreg]);
1811: }
1812:
1813: static void dsp_ori(void)
1814: {
1815: const char *regname;
1816:
1817: switch(cur_inst & BITMASK(2)) {
1818: case 0:
1819: regname="mr";
1820: registers_changed[DSP_REG_SR]=1;
1821: break;
1822: case 1:
1823: regname="ccr";
1824: registers_changed[DSP_REG_SR]=1;
1825: break;
1826: case 2:
1827: regname="omr";
1828: registers_changed[DSP_REG_OMR]=1;
1829: break;
1830: default:
1831: regname="";
1832: break;
1833: }
1834:
1835: fprintf(stderr,"Dsp: 0x%04x: ori #0x%02x,%s\n",
1836: dsp_pc,
1837: (cur_inst>>8) & BITMASK(8),
1838: regname
1839: );
1840: }
1841:
1842: static void dsp_rep(void)
1843: {
1844: uint32 value;
1845:
1846: value = (cur_inst>>12) & (BITMASK(2)<<2);
1847: value |= (cur_inst>>6) & (1<<1);
1848: value |= (cur_inst>>5) & 1;
1849:
1850: opcodes_rep[value]();
1851:
1852: registers_changed[DSP_REG_LA]=1;
1853: registers_changed[DSP_REG_LC]=1;
1854: }
1855:
1856: static void dsp_rep_1(void)
1857: {
1858: char name[16];
1859:
1860: /* x:aa */
1861: /* y:aa */
1862:
1863: if (cur_inst & (1<<6)) {
1864: sprintf(name, "y:0x%04x",(cur_inst>>8) & BITMASK(6));
1865: } else {
1866: sprintf(name, "x:0x%04x",(cur_inst>>8) & BITMASK(6));
1867: }
1868:
1869: fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, name);
1870: }
1871:
1872: static void dsp_rep_3(void)
1873: {
1874: /* #xxx */
1875: fprintf(stderr,"Dsp: 0x%04x: rep #0x%02x\n",dsp_pc, (cur_inst>>8) & BITMASK(8));
1876: }
1877:
1878: static void dsp_rep_5(void)
1879: {
1880: char name[16],addr_name[16];
1881:
1882: /* x:ea */
1883: /* y:ea */
1884:
1885: dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
1886: if (cur_inst & (1<<6)) {
1887: sprintf(name, "y:%s",addr_name);
1888: } else {
1889: sprintf(name, "x:%s",addr_name);
1890: }
1891:
1892: fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, name);
1893: }
1894:
1895: static void dsp_rep_d(void)
1896: {
1897: /* R */
1898:
1899: fprintf(stderr,"Dsp: 0x%04x: rep %s\n",dsp_pc, registers_name[(cur_inst>>8) & BITMASK(6)]);
1900: }
1901:
1902: static void dsp_reset(void)
1903: {
1904: fprintf(stderr,"Dsp: 0x%04x: reset\n",dsp_pc);
1905: }
1906:
1907: static void dsp_rti(void)
1908: {
1909: fprintf(stderr,"Dsp: 0x%04x: rti\n",dsp_pc);
1910: }
1911:
1912: static void dsp_rts(void)
1913: {
1914: fprintf(stderr,"Dsp: 0x%04x: rts\n",dsp_pc);
1915: }
1916:
1917: static void dsp_stop(void)
1918: {
1919: fprintf(stderr,"Dsp: 0x%04x: stop\n",dsp_pc);
1920: }
1921:
1922: static void dsp_swi(void)
1923: {
1924: fprintf(stderr,"Dsp: 0x%04x: swi\n",dsp_pc);
1925: }
1926:
1927: static void dsp_tcc(void)
1928: {
1929: char ccname[16];
1930: uint32 src1reg, dst1reg, src2reg, dst2reg;
1931:
1932: dsp_calc_cc((cur_inst>>12) & BITMASK(4), ccname);
1933: src1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0];
1934: dst1reg = registers_tcc[(cur_inst>>3) & BITMASK(4)][0];
1935:
1936: registers_changed[dst1reg]=1;
1937: if (cur_inst & (1<<16)) {
1938: src2reg = DSP_REG_R0+(cur_inst & BITMASK(3));
1939: dst2reg = DSP_REG_R0+((cur_inst>>8) & BITMASK(3));
1940:
1941: registers_changed[dst2reg]=1;
1942: fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s %s,%s\n",
1943: dsp_pc,
1944: ccname,
1945: registers_name[src1reg],
1946: registers_name[dst1reg],
1947: registers_name[src2reg],
1948: registers_name[dst2reg]
1949: );
1950: } else {
1951: fprintf(stderr,"Dsp: 0x%04x: t%s %s,%s\n",
1952: dsp_pc,
1953: ccname,
1954: registers_name[src1reg],
1955: registers_name[dst1reg]
1956: );
1957: }
1958: }
1959:
1960: static void dsp_wait(void)
1961: {
1962: fprintf(stderr,"Dsp: 0x%04x: wait\n",dsp_pc);
1963: }
1964:
1965: /**********************************
1966: * Parallel moves
1967: **********************************/
1968:
1969: static void dsp_pm(void)
1970: {
1971: uint32 value;
1972:
1973: value = (cur_inst >> 20) & BITMASK(4);
1974:
1975: opcodes_parmove[value]();
1976: }
1977:
1978: static void dsp_pm_0(void)
1979: {
1980: char space_name[16], addr_name[16];
1981: uint32 memspace, numreg1, numreg2;
1982: /*
1983: 0000 100d 00mm mrrr S,x:ea x0,D
1984: 0000 100d 10mm mrrr S,y:ea y0,D
1985: */
1986: memspace = (cur_inst>>15) & 1;
1987: numreg1 = DSP_REG_A+((cur_inst>>16) & 1);
1988: dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
1989:
1990: if (memspace) {
1991: strcpy(space_name,"y");
1992: numreg2 = DSP_REG_Y0;
1993: } else {
1994: strcpy(space_name,"x");
1995: numreg2 = DSP_REG_X0;
1996: }
1997:
1998: registers_changed[numreg1]=1;
1999:
2000: sprintf(parallelmove_name,
2001: "%s,%s:%s %s,%s",
2002: registers_name[numreg1],
2003: space_name,
2004: addr_name,
2005: registers_name[numreg2],
2006: registers_name[numreg1]
2007: );
2008: }
2009:
2010: static void dsp_pm_1(void)
2011: {
2012: /*
2013: 0001 ffdf w0mm mrrr x:ea,D1 S2,D2
2014: S1,x:ea S2,D2
2015: #xxxxxx,D1 S2,D2
2016: 0001 deff w1mm mrrr S1,D1 y:ea,D2
2017: S1,D1 S2,y:ea
2018: S1,D1 #xxxxxx,D2
2019: */
2020:
2021: char addr_name[16];
2022: uint32 memspace, write_flag, retour, s1reg, s2reg, d1reg, d2reg;
2023:
2024: memspace = (cur_inst>>14) & 1;
2025: write_flag = (cur_inst>>15) & 1;
2026: retour = dsp_calc_ea((cur_inst>>8) & BITMASK(6), addr_name);
2027:
2028: if (memspace==DSP_SPACE_Y) {
2029: s2reg = d2reg = DSP_REG_Y0;
2030: switch((cur_inst>>16) & BITMASK(2)) {
2031: case 0: s2reg = d2reg = DSP_REG_Y0; break;
2032: case 1: s2reg = d2reg = DSP_REG_Y1; break;
2033: case 2: s2reg = d2reg = DSP_REG_A; break;
2034: case 3: s2reg = d2reg = DSP_REG_B; break;
2035: }
2036:
2037: s1reg = DSP_REG_A+((cur_inst>>19) & 1);
2038: d1reg = DSP_REG_X0+((cur_inst>>18) & 1);
2039:
2040: registers_changed[d1reg]=1;
2041:
2042: if (write_flag) {
2043: /* Write D2 */
2044:
2045: registers_changed[d2reg]=1;
2046:
2047: if (retour) {
2048: sprintf(parallelmove_name,"%s,%s #%s,%s",
2049: registers_name[s1reg],
2050: registers_name[d1reg],
2051: addr_name,
2052: registers_name[d2reg]
2053: );
2054: } else {
2055: sprintf(parallelmove_name,"%s,%s y:%s,%s",
2056: registers_name[s1reg],
2057: registers_name[d1reg],
2058: addr_name,
2059: registers_name[d2reg]
2060: );
2061: }
2062: } else {
2063: /* Read S2 */
2064: sprintf(parallelmove_name,"%s,%s %s,y:%s",
2065: registers_name[s1reg],
2066: registers_name[d1reg],
2067: registers_name[s2reg],
2068: addr_name
2069: );
2070: }
2071:
2072: } else {
2073: s1reg = d1reg = DSP_REG_X0;
2074: switch((cur_inst>>18) & BITMASK(2)) {
2075: case 0: s1reg = d1reg = DSP_REG_X0; break;
2076: case 1: s1reg = d1reg = DSP_REG_X1; break;
2077: case 2: s1reg = d1reg = DSP_REG_A; break;
2078: case 3: s1reg = d1reg = DSP_REG_B; break;
2079: }
2080:
2081: s2reg = DSP_REG_A+((cur_inst>>17) & 1);
2082: d2reg = DSP_REG_Y0+((cur_inst>>16) & 1);
2083:
2084: registers_changed[d2reg]=1;
2085:
2086: if (write_flag) {
2087: /* Write D1 */
2088:
2089: registers_changed[d1reg]=1;
2090:
2091: if (retour) {
2092: sprintf(parallelmove_name,"#%s,%s %s,%s",
2093: addr_name,
2094: registers_name[d1reg],
2095: registers_name[s2reg],
2096: registers_name[d2reg]
2097: );
2098: } else {
2099: sprintf(parallelmove_name,"x:%s,%s %s,%s",
2100: addr_name,
2101: registers_name[d1reg],
2102: registers_name[s2reg],
2103: registers_name[d2reg]
2104: );
2105: }
2106: } else {
2107: /* Read S1 */
2108: sprintf(parallelmove_name,"%s,x:%s %s,%s",
2109: registers_name[s1reg],
2110: addr_name,
2111: registers_name[s2reg],
2112: registers_name[d2reg]
2113: );
2114: }
2115:
2116: }
2117: }
2118:
2119: static void dsp_pm_2(void)
2120: {
2121: char addr_name[16];
2122: uint32 numreg1, numreg2;
2123: /*
2124: 0010 0000 0000 0000 nop
2125: 0010 0000 010m mrrr R update
2126: 0010 00ee eeed dddd S,D
2127: 001d dddd iiii iiii #xx,D
2128: */
2129: if (((cur_inst >> 8) & 0xffff) == 0x2000) {
2130: return;
2131: }
2132:
2133: if (((cur_inst >> 8) & 0xffe0) == 0x2040) {
2134: dsp_calc_ea((cur_inst>>8) & BITMASK(5), addr_name);
2135: registers_changed[DSP_REG_R0+((cur_inst>>8) & BITMASK(3))]=1;
2136: sprintf(parallelmove_name, "%s,r%d",addr_name, (cur_inst>>8) & BITMASK(3));
2137: return;
2138: }
2139:
2140: if (((cur_inst >> 8) & 0xfc00) == 0x2000) {
2141: numreg1 = (cur_inst>>13) & BITMASK(5);
2142: numreg2 = (cur_inst>>8) & BITMASK(5);
2143: registers_changed[numreg2]=1;
2144: sprintf(parallelmove_name, "%s,%s", registers_name[numreg1], registers_name[numreg2]);
2145: return;
2146: }
2147:
2148: numreg1 = (cur_inst>>16) & BITMASK(5);
2149: registers_changed[numreg1]=1;
2150: sprintf(parallelmove_name, "#0x%02x,%s", (cur_inst >> 8) & BITMASK(8), registers_name[numreg1]);
2151: }
2152:
2153: static void dsp_pm_4(void)
2154: {
2155: char addr_name[16];
2156: uint32 value, retour, ea_mode, memspace;
2157: /*
2158: 0100 l0ll w0aa aaaa l:aa,D
2159: S,l:aa
2160: 0100 l0ll w1mm mrrr l:ea,D
2161: S,l:ea
2162: 01dd 0ddd w0aa aaaa x:aa,D
2163: S,x:aa
2164: 01dd 0ddd w1mm mrrr x:ea,D
2165: S,x:ea
2166: #xxxxxx,D
2167: 01dd 1ddd w0aa aaaa y:aa,D
2168: S,y:aa
2169: 01dd 1ddd w1mm mrrr y:ea,D
2170: S,y:ea
2171: #xxxxxx,D
2172: */
2173: value = (cur_inst>>16) & BITMASK(3);
2174: value |= (cur_inst>>17) & (BITMASK(2)<<3);
2175:
2176: ea_mode = (cur_inst>>8) & BITMASK(6);
2177:
2178: if ((value>>2)==0) {
2179: /* L: memory move */
2180: if (cur_inst & (1<<14)) {
2181: retour = dsp_calc_ea(ea_mode, addr_name);
2182: } else {
2183: sprintf(addr_name,"0x%04x", value);
2184: retour = 0;
2185: }
2186:
2187: value = (cur_inst>>16) & BITMASK(2);
2188: value |= (cur_inst>>17) & (1<<2);
2189:
2190: if (cur_inst & (1<<15)) {
2191: /* Write D */
2192:
2193: registers_changed[value]=1;
2194: if (retour) {
2195: sprintf(parallelmove_name, "#%s,%s", addr_name, registers_lmove[value]);
2196: } else {
2197: sprintf(parallelmove_name, "l:%s,%s", addr_name, registers_lmove[value]);
2198: }
2199: } else {
2200: /* Read S */
2201: sprintf(parallelmove_name, "%s,l:%s", registers_lmove[value], addr_name);
2202: }
2203:
2204: return;
2205: }
2206:
2207: memspace = (cur_inst>>19) & 1;
2208: if (cur_inst & (1<<14)) {
2209: retour = dsp_calc_ea(ea_mode, addr_name);
2210: } else {
2211: sprintf(addr_name,"0x%04x", ea_mode);
2212: retour = 0;
2213: }
2214:
2215: if (memspace) {
2216: /* Y: */
2217:
2218: if (cur_inst & (1<<15)) {
2219: /* Write D */
2220:
2221: registers_changed[value]=1;
2222: if (retour) {
2223: sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]);
2224: } else {
2225: sprintf(parallelmove_name, "y:%s,%s", addr_name, registers_name[value]);
2226: }
2227:
2228: } else {
2229: /* Read S */
2230: sprintf(parallelmove_name, "%s,y:%s", registers_name[value], addr_name);
2231: }
2232: } else {
2233: /* X: */
2234:
2235: if (cur_inst & (1<<15)) {
2236: /* Write D */
2237:
2238: registers_changed[value]=1;
2239:
2240: if (retour) {
2241: sprintf(parallelmove_name, "#%s,%s", addr_name, registers_name[value]);
2242: } else {
2243: sprintf(parallelmove_name, "x:%s,%s", addr_name, registers_name[value]);
2244: }
2245: } else {
2246: /* Read S */
2247: sprintf(parallelmove_name, "%s,x:%s", registers_name[value], addr_name);
2248: }
2249: }
2250: }
2251:
2252: static void dsp_pm_8(void)
2253: {
2254: char addr1_name[16], addr2_name[16];
2255: uint32 ea_mode1, ea_mode2, numreg1, numreg2;
2256: /*
2257: 1wmm eeff WrrM MRRR x:ea,D1 y:ea,D2
2258: x:ea,D1 S2,y:ea
2259: S1,x:ea y:ea,D2
2260: S1,x:ea S2,y:ea
2261: */
2262: numreg1 = DSP_REG_X0;
2263: switch((cur_inst>>18) & BITMASK(2)) {
2264: case 0: numreg1 = DSP_REG_X0; break;
2265: case 1: numreg1 = DSP_REG_X1; break;
2266: case 2: numreg1 = DSP_REG_A; break;
2267: case 3: numreg1 = DSP_REG_B; break;
2268: }
2269:
2270: numreg2 = DSP_REG_Y0;
2271: switch((cur_inst>>16) & BITMASK(2)) {
2272: case 0: numreg2 = DSP_REG_Y0; break;
2273: case 1: numreg2 = DSP_REG_Y1; break;
2274: case 2: numreg2 = DSP_REG_A; break;
2275: case 3: numreg2 = DSP_REG_B; break;
2276: }
2277:
2278: ea_mode1 = (cur_inst>>8) & BITMASK(5);
2279: if ((ea_mode1>>3) == 0) {
2280: ea_mode1 |= (1<<5);
2281: }
2282: ea_mode2 = (cur_inst>>13) & BITMASK(2);
2283: ea_mode2 |= ((cur_inst>>20) & BITMASK(2))<<3;
2284: if ((ea_mode1 & (1<<2))==0) {
2285: ea_mode2 |= 1<<2;
2286: }
2287: if ((ea_mode2>>3) == 0) {
2288: ea_mode2 |= (1<<5);
2289: }
2290:
2291: dsp_calc_ea(ea_mode1, addr1_name);
2292: dsp_calc_ea(ea_mode2, addr2_name);
2293:
2294: if (cur_inst & (1<<15)) {
2295: registers_changed[numreg1]=1;
2296: if (cur_inst & (1<<22)) {
2297: registers_changed[numreg2]=1;
2298: sprintf(parallelmove_name, "x:%s,%s y:%s,%s",
2299: addr1_name,
2300: registers_name[numreg1],
2301: addr2_name,
2302: registers_name[numreg2]
2303: );
2304: } else {
2305: sprintf(parallelmove_name, "x:%s,%s %s,y:%s",
2306: addr1_name,
2307: registers_name[numreg1],
2308: registers_name[numreg2],
2309: addr2_name
2310: );
2311: }
2312: } else {
2313: if (cur_inst & (1<<22)) {
2314: registers_changed[numreg2]=1;
2315: sprintf(parallelmove_name, "%s,x:%s y:%s,%s",
2316: registers_name[numreg1],
2317: addr1_name,
2318: addr2_name,
2319: registers_name[numreg2]
2320: );
2321: } else {
2322: sprintf(parallelmove_name, "%s,x:%s %s,y:%s",
2323: registers_name[numreg1],
2324: addr1_name,
2325: registers_name[numreg2],
2326: addr2_name
2327: );
2328: }
2329: }
2330: }
2331:
2332:
2333: /**********************************
2334: * Parallel moves ALU instructions
2335: **********************************/
2336:
2337: static void dsp_abs(void)
2338: {
2339: uint32 numreg;
2340:
2341: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2342:
2343: registers_changed[numreg]=1;
2344: fprintf(stderr,"Dsp: 0x%04x: abs %s %s\n",
2345: dsp_pc,
2346: registers_name[numreg],
2347: parallelmove_name
2348: );
2349: }
2350:
2351: static void dsp_adc(void)
2352: {
2353: const char *srcname;
2354: uint32 numreg;
2355:
2356: if (cur_inst & (1<<4)) {
2357: srcname="y";
2358: } else {
2359: srcname="x";
2360: }
2361:
2362: numreg=DSP_REG_A+((cur_inst>>3) & 1);
2363: registers_changed[numreg]=1;
2364:
2365: fprintf(stderr,"Dsp: 0x%04x: adc %s,%s %s\n",
2366: dsp_pc,
2367: srcname,
2368: registers_name[numreg],
2369: parallelmove_name
2370: );
2371: }
2372:
2373: static void dsp_add(void)
2374: {
2375: const char *srcname;
2376: uint32 srcreg, dstreg;
2377:
2378: srcreg = (cur_inst>>4) & BITMASK(3);
2379: dstreg = (cur_inst>>3) & 1;
2380:
2381: switch(srcreg) {
2382: case 1:
2383: srcreg = dstreg ^ 1;
2384: srcname = registers_name[DSP_REG_A+srcreg];
2385: break;
2386: case 2:
2387: srcname="x";
2388: break;
2389: case 3:
2390: srcname="y";
2391: break;
2392: case DSP_REG_X0:
2393: case DSP_REG_X1:
2394: case DSP_REG_Y0:
2395: case DSP_REG_Y1:
2396: srcname=registers_name[srcreg];
2397: break;
2398: default:
2399: srcname="";
2400: break;
2401: }
2402:
2403: registers_changed[DSP_REG_A+dstreg]=1;
2404: fprintf(stderr,"Dsp: 0x%04x: add %s,%s %s\n",
2405: dsp_pc,
2406: srcname,
2407: registers_name[DSP_REG_A+dstreg],
2408: parallelmove_name
2409: );
2410: }
2411:
2412: static void dsp_addl(void)
2413: {
2414: uint32 numreg;
2415:
2416: numreg = (cur_inst>>3) & 1;
2417:
2418: registers_changed[DSP_REG_A+numreg]=1;
2419: fprintf(stderr,"Dsp: 0x%04x: addl %s,%s %s\n",
2420: dsp_pc,
2421: registers_name[DSP_REG_A+(numreg ^ 1)],
2422: registers_name[DSP_REG_A+numreg],
2423: parallelmove_name
2424: );
2425: }
2426:
2427: static void dsp_addr(void)
2428: {
2429: uint32 numreg;
2430:
2431: numreg = (cur_inst>>3) & 1;
2432:
2433: registers_changed[DSP_REG_A+numreg]=1;
2434: fprintf(stderr,"Dsp: 0x%04x: addr %s,%s %s\n",
2435: dsp_pc,
2436: registers_name[DSP_REG_A+(numreg ^ 1)],
2437: registers_name[DSP_REG_A+numreg],
2438: parallelmove_name
2439: );
2440: }
2441:
2442: static void dsp_and(void)
2443: {
2444: uint32 numreg;
2445:
2446: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2447:
2448: registers_changed[numreg]=1;
2449:
2450: fprintf(stderr,"Dsp: 0x%04x: and %s,%s %s\n",
2451: dsp_pc,
2452: registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
2453: registers_name[numreg],
2454: parallelmove_name
2455: );
2456: }
2457:
2458: static void dsp_asl(void)
2459: {
2460: uint32 numreg;
2461:
2462: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2463:
2464: registers_changed[numreg]=1;
2465:
2466: fprintf(stderr,"Dsp: 0x%04x: asl %s %s\n",
2467: dsp_pc,
2468: registers_name[numreg],
2469: parallelmove_name
2470: );
2471: }
2472:
2473: static void dsp_asr(void)
2474: {
2475: uint32 numreg;
2476:
2477: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2478:
2479: registers_changed[numreg]=1;
2480:
2481: fprintf(stderr,"Dsp: 0x%04x: asr %s %s\n",
2482: dsp_pc,
2483: registers_name[numreg],
2484: parallelmove_name
2485: );
2486: }
2487:
2488: static void dsp_clr(void)
2489: {
2490: uint32 numreg;
2491:
2492: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2493:
2494: registers_changed[numreg]=1;
2495:
2496: fprintf(stderr,"Dsp: 0x%04x: clr %s %s\n",
2497: dsp_pc,
2498: registers_name[numreg],
2499: parallelmove_name
2500: );
2501: }
2502:
2503: static void dsp_cmp(void)
2504: {
2505: uint32 srcreg, dstreg;
2506:
2507: srcreg = (cur_inst>>4) & BITMASK(3);
2508: dstreg = (cur_inst>>3) & 1;
2509:
2510: switch(srcreg) {
2511: case 0:
2512: srcreg = DSP_REG_A+(dstreg ^ 1);
2513: break;
2514: case 4:
2515: srcreg = DSP_REG_X0;
2516: break;
2517: case 5:
2518: srcreg = DSP_REG_Y0;
2519: break;
2520: case 6:
2521: srcreg = DSP_REG_X1;
2522: break;
2523: case 7:
2524: srcreg = DSP_REG_Y1;
2525: break;
2526: }
2527:
2528: fprintf(stderr,"Dsp: 0x%04x: cmp %s,%s %s\n",
2529: dsp_pc,
2530: registers_name[srcreg],
2531: registers_name[DSP_REG_A+dstreg],
2532: parallelmove_name
2533: );
2534: }
2535:
2536: static void dsp_cmpm(void)
2537: {
2538: uint32 srcreg, dstreg;
2539:
2540: srcreg = (cur_inst>>4) & BITMASK(3);
2541: dstreg = (cur_inst>>3) & 1;
2542:
2543: switch(srcreg) {
2544: case 0:
2545: srcreg = DSP_REG_A+(dstreg ^ 1);
2546: break;
2547: case 4:
2548: srcreg = DSP_REG_X0;
2549: break;
2550: case 5:
2551: srcreg = DSP_REG_Y0;
2552: break;
2553: case 6:
2554: srcreg = DSP_REG_X1;
2555: break;
2556: case 7:
2557: srcreg = DSP_REG_Y1;
2558: break;
2559: }
2560:
2561: fprintf(stderr,"Dsp: 0x%04x: cmpm %s,%s %s\n",
2562: dsp_pc,
2563: registers_name[srcreg],
2564: registers_name[DSP_REG_A+dstreg],
2565: parallelmove_name
2566: );
2567: }
2568:
2569: static void dsp_eor(void)
2570: {
2571: uint32 numreg;
2572:
2573: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2574:
2575: registers_changed[numreg]=1;
2576:
2577: fprintf(stderr,"Dsp: 0x%04x: eor %s,%s %s\n",
2578: dsp_pc,
2579: registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
2580: registers_name[numreg],
2581: parallelmove_name
2582: );
2583: }
2584:
2585: static void dsp_lsl(void)
2586: {
2587: uint32 numreg;
2588:
2589: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2590:
2591: registers_changed[numreg]=1;
2592:
2593: fprintf(stderr,"Dsp: 0x%04x: lsl %s %s\n",
2594: dsp_pc,
2595: registers_name[numreg],
2596: parallelmove_name
2597: );
2598: }
2599:
2600: static void dsp_lsr(void)
2601: {
2602: uint32 numreg;
2603:
2604: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2605:
2606: registers_changed[numreg]=1;
2607:
2608: fprintf(stderr,"Dsp: 0x%04x: lsr %s %s\n",
2609: dsp_pc,
2610: registers_name[numreg],
2611: parallelmove_name
2612: );
2613: }
2614:
2615: static void dsp_mac(void)
2616: {
2617: const char *sign_name;
2618: uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
2619:
2620: if (cur_inst & (1<<2)) {
2621: sign_name="-";
2622: } else {
2623: sign_name="";
2624: }
2625:
2626: switch((cur_inst>>4) & BITMASK(3)) {
2627: case 0:
2628: src1reg = DSP_REG_X0;
2629: src2reg = DSP_REG_X0;
2630: break;
2631: case 1:
2632: src1reg = DSP_REG_Y0;
2633: src2reg = DSP_REG_Y0;
2634: break;
2635: case 2:
2636: src1reg = DSP_REG_X1;
2637: src2reg = DSP_REG_X0;
2638: break;
2639: case 3:
2640: src1reg = DSP_REG_Y1;
2641: src2reg = DSP_REG_Y0;
2642: break;
2643: case 4:
2644: src1reg = DSP_REG_X0;
2645: src2reg = DSP_REG_Y1;
2646: break;
2647: case 5:
2648: src1reg = DSP_REG_Y0;
2649: src2reg = DSP_REG_X0;
2650: break;
2651: case 6:
2652: src1reg = DSP_REG_X1;
2653: src2reg = DSP_REG_Y0;
2654: break;
2655: case 7:
2656: src1reg = DSP_REG_Y1;
2657: src2reg = DSP_REG_X1;
2658: break;
2659: }
2660: dstreg = (cur_inst>>3) & 1;
2661:
2662: registers_changed[DSP_REG_A+dstreg]=1;
2663: fprintf(stderr,"Dsp: 0x%04x: mac %s%s,%s,%s %s\n",
2664: dsp_pc,
2665: sign_name,
2666: registers_name[src1reg],
2667: registers_name[src2reg],
2668: registers_name[DSP_REG_A+dstreg],
2669: parallelmove_name
2670: );
2671: }
2672:
2673: static void dsp_macr(void)
2674: {
2675: const char *sign_name;
2676: uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
2677:
2678: if (cur_inst & (1<<2)) {
2679: sign_name="-";
2680: } else {
2681: sign_name="";
2682: }
2683:
2684: switch((cur_inst>>4) & BITMASK(3)) {
2685: case 0:
2686: src1reg = DSP_REG_X0;
2687: src2reg = DSP_REG_X0;
2688: break;
2689: case 1:
2690: src1reg = DSP_REG_Y0;
2691: src2reg = DSP_REG_Y0;
2692: break;
2693: case 2:
2694: src1reg = DSP_REG_X1;
2695: src2reg = DSP_REG_X0;
2696: break;
2697: case 3:
2698: src1reg = DSP_REG_Y1;
2699: src2reg = DSP_REG_Y0;
2700: break;
2701: case 4:
2702: src1reg = DSP_REG_X0;
2703: src2reg = DSP_REG_Y1;
2704: break;
2705: case 5:
2706: src1reg = DSP_REG_Y0;
2707: src2reg = DSP_REG_X0;
2708: break;
2709: case 6:
2710: src1reg = DSP_REG_X1;
2711: src2reg = DSP_REG_Y0;
2712: break;
2713: case 7:
2714: src1reg = DSP_REG_Y1;
2715: src2reg = DSP_REG_X1;
2716: break;
2717: }
2718: dstreg = (cur_inst>>3) & 1;
2719:
2720: registers_changed[DSP_REG_A+dstreg]=1;
2721: fprintf(stderr,"Dsp: 0x%04x: macr %s%s,%s,%s %s\n",
2722: dsp_pc,
2723: sign_name,
2724: registers_name[src1reg],
2725: registers_name[src2reg],
2726: registers_name[DSP_REG_A+dstreg],
2727: parallelmove_name
2728: );
2729: }
2730:
2731: static void dsp_move(void)
2732: {
2733: fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_pc, parallelmove_name);
2734: }
2735:
2736: static void dsp_move_nopm(void)
2737: {
2738: dsp_pm();
2739: fprintf(stderr,"Dsp: 0x%04x: move %s\n",dsp_pc, parallelmove_name);
2740: }
2741:
2742: static void dsp_mpy(void)
2743: {
2744: const char *sign_name;
2745: uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
2746:
2747: if (cur_inst & (1<<2)) {
2748: sign_name="-";
2749: } else {
2750: sign_name="";
2751: }
2752:
2753: switch((cur_inst>>4) & BITMASK(3)) {
2754: case 0:
2755: src1reg = DSP_REG_X0;
2756: src2reg = DSP_REG_X0;
2757: break;
2758: case 1:
2759: src1reg = DSP_REG_Y0;
2760: src2reg = DSP_REG_Y0;
2761: break;
2762: case 2:
2763: src1reg = DSP_REG_X1;
2764: src2reg = DSP_REG_X0;
2765: break;
2766: case 3:
2767: src1reg = DSP_REG_Y1;
2768: src2reg = DSP_REG_Y0;
2769: break;
2770: case 4:
2771: src1reg = DSP_REG_X0;
2772: src2reg = DSP_REG_Y1;
2773: break;
2774: case 5:
2775: src1reg = DSP_REG_Y0;
2776: src2reg = DSP_REG_X0;
2777: break;
2778: case 6:
2779: src1reg = DSP_REG_X1;
2780: src2reg = DSP_REG_Y0;
2781: break;
2782: case 7:
2783: src1reg = DSP_REG_Y1;
2784: src2reg = DSP_REG_X1;
2785: break;
2786: }
2787: dstreg = (cur_inst>>3) & 1;
2788:
2789: registers_changed[DSP_REG_A+dstreg]=1;
2790: fprintf(stderr,"Dsp: 0x%04x: mpy %s%s,%s,%s %s\n",
2791: dsp_pc,
2792: sign_name,
2793: registers_name[src1reg],
2794: registers_name[src2reg],
2795: registers_name[DSP_REG_A+dstreg],
2796: parallelmove_name
2797: );
2798: }
2799:
2800: static void dsp_mpyr(void)
2801: {
2802: const char *sign_name;
2803: uint32 src1reg=DSP_REG_NULL, src2reg=DSP_REG_NULL, dstreg;
2804:
2805: if (cur_inst & (1<<2)) {
2806: sign_name="-";
2807: } else {
2808: sign_name="";
2809: }
2810:
2811: switch((cur_inst>>4) & BITMASK(3)) {
2812: case 0:
2813: src1reg = DSP_REG_X0;
2814: src2reg = DSP_REG_X0;
2815: break;
2816: case 1:
2817: src1reg = DSP_REG_Y0;
2818: src2reg = DSP_REG_Y0;
2819: break;
2820: case 2:
2821: src1reg = DSP_REG_X1;
2822: src2reg = DSP_REG_X0;
2823: break;
2824: case 3:
2825: src1reg = DSP_REG_Y1;
2826: src2reg = DSP_REG_Y0;
2827: break;
2828: case 4:
2829: src1reg = DSP_REG_X0;
2830: src2reg = DSP_REG_Y1;
2831: break;
2832: case 5:
2833: src1reg = DSP_REG_Y0;
2834: src2reg = DSP_REG_X0;
2835: break;
2836: case 6:
2837: src1reg = DSP_REG_X1;
2838: src2reg = DSP_REG_Y0;
2839: break;
2840: case 7:
2841: src1reg = DSP_REG_Y1;
2842: src2reg = DSP_REG_X1;
2843: break;
2844: }
2845: dstreg = (cur_inst>>3) & 1;
2846:
2847: registers_changed[DSP_REG_A+dstreg]=1;
2848: fprintf(stderr,"Dsp: 0x%04x: mpyr %s%s,%s,%s %s\n",
2849: dsp_pc,
2850: sign_name,
2851: registers_name[src1reg],
2852: registers_name[src2reg],
2853: registers_name[DSP_REG_A+dstreg],
2854: parallelmove_name
2855: );
2856: }
2857:
2858: static void dsp_neg(void)
2859: {
2860: uint32 numreg;
2861:
2862: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2863:
2864: registers_changed[numreg]=1;
2865:
2866: fprintf(stderr,"Dsp: 0x%04x: neg %s %s\n",
2867: dsp_pc,
2868: registers_name[numreg],
2869: parallelmove_name
2870: );
2871: }
2872:
2873: static void dsp_not(void)
2874: {
2875: uint32 numreg;
2876:
2877: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2878:
2879: registers_changed[numreg]=1;
2880:
2881: fprintf(stderr,"Dsp: 0x%04x: not %s %s\n",
2882: dsp_pc,
2883: registers_name[numreg],
2884: parallelmove_name
2885: );
2886: }
2887:
2888: static void dsp_or(void)
2889: {
2890: uint32 numreg;
2891:
2892: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2893:
2894: registers_changed[numreg]=1;
2895:
2896: fprintf(stderr,"Dsp: 0x%04x: or %s,%s %s\n",
2897: dsp_pc,
2898: registers_name[DSP_REG_X0+((cur_inst>>4) & BITMASK(2))],
2899: registers_name[numreg],
2900: parallelmove_name
2901: );
2902: }
2903:
2904: static void dsp_rnd(void)
2905: {
2906: uint32 numreg;
2907:
2908: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2909:
2910: registers_changed[numreg]=1;
2911:
2912: fprintf(stderr,"Dsp: 0x%04x: rnd %s %s\n",
2913: dsp_pc,
2914: registers_name[numreg],
2915: parallelmove_name
2916: );
2917: }
2918:
2919: static void dsp_rol(void)
2920: {
2921: uint32 numreg;
2922:
2923: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2924:
2925: registers_changed[numreg]=1;
2926:
2927: fprintf(stderr,"Dsp: 0x%04x: rol %s %s\n",
2928: dsp_pc,
2929: registers_name[numreg],
2930: parallelmove_name
2931: );
2932: }
2933:
2934: static void dsp_ror(void)
2935: {
2936: uint32 numreg;
2937:
2938: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2939:
2940: registers_changed[numreg]=1;
2941:
2942: fprintf(stderr,"Dsp: 0x%04x: ror %s %s\n",
2943: dsp_pc,
2944: registers_name[numreg],
2945: parallelmove_name
2946: );
2947: }
2948:
2949: static void dsp_sbc(void)
2950: {
2951: const char *srcname;
2952: uint32 numreg;
2953:
2954: if (cur_inst & (1<<4)) {
2955: srcname="y";
2956: } else {
2957: srcname="x";
2958: }
2959:
2960: numreg = DSP_REG_A+((cur_inst>>3) & 1);
2961:
2962: registers_changed[numreg]=1;
2963:
2964: fprintf(stderr,"Dsp: 0x%04x: sbc %s,%s %s\n",
2965: dsp_pc,
2966: srcname,
2967: registers_name[numreg],
2968: parallelmove_name
2969: );
2970: }
2971:
2972: static void dsp_sub(void)
2973: {
2974: const char *srcname;
2975: uint32 srcreg, dstreg;
2976:
2977: srcreg = (cur_inst>>4) & BITMASK(3);
2978: dstreg = (cur_inst>>3) & 1;
2979:
2980: switch(srcreg) {
2981: case 1:
2982: srcreg = dstreg ^ 1;
2983: srcname = registers_name[DSP_REG_A+srcreg];
2984: break;
2985: case 2:
2986: srcname="x";
2987: break;
2988: case 3:
2989: srcname="y";
2990: break;
2991: case DSP_REG_X0:
2992: case DSP_REG_X1:
2993: case DSP_REG_Y0:
2994: case DSP_REG_Y1:
2995: srcname=registers_name[srcreg];
2996: break;
2997: default:
2998: srcname="";
2999: break;
3000: }
3001:
3002: registers_changed[DSP_REG_A+dstreg]=1;
3003: fprintf(stderr,"Dsp: 0x%04x: sub %s,%s %s\n",
3004: dsp_pc,
3005: srcname,
3006: registers_name[DSP_REG_A+dstreg],
3007: parallelmove_name
3008: );
3009: }
3010:
3011: static void dsp_subl(void)
3012: {
3013: uint32 numreg;
3014:
3015: numreg = (cur_inst>>3) & 1;
3016:
3017: registers_changed[DSP_REG_A+numreg]=1;
3018: fprintf(stderr,"Dsp: 0x%04x: subl %s,%s %s\n",
3019: dsp_pc,
3020: registers_name[DSP_REG_A+(numreg ^ 1)],
3021: registers_name[DSP_REG_A+numreg],
3022: parallelmove_name
3023: );
3024: }
3025:
3026: static void dsp_subr(void)
3027: {
3028: uint32 numreg;
3029:
3030: numreg = (cur_inst>>3) & 1;
3031:
3032: registers_changed[DSP_REG_A+numreg]=1;
3033: fprintf(stderr,"Dsp: 0x%04x: subr %s,%s %s\n",
3034: dsp_pc,
3035: registers_name[DSP_REG_A+(numreg ^ 1)],
3036: registers_name[DSP_REG_A+numreg],
3037: parallelmove_name
3038: );
3039: }
3040:
3041: static void dsp_tfr(void)
3042: {
3043: uint32 srcreg, dstreg;
3044:
3045: srcreg = (cur_inst>>4) & BITMASK(3);
3046: dstreg = (cur_inst>>3) & 1;
3047:
3048: if (srcreg==0) {
3049: srcreg = DSP_REG_A+(dstreg ^ 1);
3050: }
3051:
3052: registers_changed[DSP_REG_A+dstreg]=1;
3053: fprintf(stderr,"Dsp: 0x%04x: tfr %s,%s %s\n",
3054: dsp_pc,
3055: registers_name[srcreg],
3056: registers_name[DSP_REG_A+dstreg],
3057: parallelmove_name
3058: );
3059: }
3060:
3061: static void dsp_tst(void)
3062: {
3063: fprintf(stderr,"Dsp: 0x%04x: tst %s %s\n",
3064: dsp_pc,
3065: registers_name[DSP_REG_A+((cur_inst>>3) & 1)],
3066: parallelmove_name
3067: );
3068: }
3069:
3070: /*
3071: 2002-07-31:PM
3072: BUG:pm_2 (register update) wrong calc of eamode
3073: 2002-07-30:PM
3074: FIX:output registers that have been written to
3075: 2002-07-26:PM
3076: BUG:added missing '\n' to disasm output
3077: 2002-07-22:PM
3078: FIX:disasm output changed from D(bug()) to fprintf()
3079: 2002-07-19:PM
3080: BUG:movec_b and movec_d operations permuted
3081: BUG:pm_5: bad calc of address in [x|y]:aa addressing
3082: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.