![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disasm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Tom Morton FrontierVM] / frontvm / hardware|
Return to disasm.c CVS log | Up to [Tom Morton FrontierVM] / frontvm / hardware |
1.1 root 1:
2: #include <stdio.h>
3: #include <stdlib.h>
4: #include <string.h>
5: #include <stdarg.h>
6:
7: #include <SDL_types.h>
8:
9: #include "main.h"
10: #include "decode.h"
11: #include "dialog.h"
12: #include "file.h"
13: #include "m68000.h"
14: #include "memAlloc.h"
15: #include "stMemory.h"
16:
17: static int buf_pos = 0;
18:
19: static void output (const char *format, ...)
20: {
21: va_list argptr;
22:
23: va_start (argptr, format);
24: vprintf (format, argptr);
25: va_end (argptr);
26: }
27:
28: static void output_lab (int addr)
29: {
30: printf ("$%x", addr);
31: }
32:
33: unsigned char rd_byte(void)
34: {
35: int val = STMemory_ReadByte (buf_pos);
36: buf_pos++;
37: return val;
38: }
39:
40: short rd_short(void)
41: {
42: short val = STMemory_ReadWord (buf_pos);
43: buf_pos+=2;
44: return val;
45: }
46:
47: int rd_int(void)
48: {
49: int val = STMemory_ReadLong (buf_pos);
50: buf_pos+=4;
51: return val;
52: }
53:
54: const char *size_str[4] = { ".b", ".w", ".l", ".?" };
55: /* to convert weird move sizes to standard sizes */
56: const int move_size[4] = { 3, 0, 2, 1 };
57: const char *Bcc_str[16] = {
58: NULL,NULL,"hi","ls","cc","cs","ne","eq",
59: "vc","vs","pl","mi","ge","lt","gt","le"
60: };
61:
62: const char *DBcc_str[16] = {
63: "t","ra","hi","ls","cc","cs","ne","eq",
64: "vc","vs","pl","mi","ge","lt","gt","le"
65: };
66:
67: typedef union Opcode {
68: unsigned short code;
69: struct move {
70: uint src_reg : 3;
71: uint src_mode : 3;
72: uint dest_mode : 3;
73: uint dest_reg : 3;
74: uint size : 2;
75: uint op : 2;
76: } move;
77: struct adr_index {
78: int displacement : 8;
79: uint zeros : 3;
80: uint ind_size : 1;
81: uint reg : 3;
82: uint reg_type : 1;
83: } adr_index;
84: struct addq {
85: uint dest_reg : 3;
86: uint dest_mode : 3;
87: uint size : 2;
88: uint issub : 1;
89: uint data : 3;
90: uint op : 4;
91: } addq;
92: struct jmp {
93: uint dest_reg : 3;
94: uint dest_mode : 3;
95: uint op : 10;
96: } jmp;
97: struct addi {
98: uint dest_reg : 3;
99: uint dest_mode : 3;
100: uint size : 2;
101: uint OP6 : 8;
102: } addi;
103: /* size and effective address */
104: struct type1 {
105: uint ea_reg : 3;
106: uint ea_mode : 3;
107: uint size : 2;
108: uint op : 8;
109: } type1;
110: /* reg, opmode, ea */
111: struct type2 {
112: uint ea_reg : 3;
113: uint ea_mode : 3;
114: uint op_mode : 3;
115: uint reg : 3;
116: uint op : 4;
117: } type2;
118: struct MemShift {
119: uint ea_reg : 3;
120: uint ea_mode : 3;
121: uint OP3 : 2;
122: uint dr : 1;
123: uint type : 2;
124: uint OP0x1c : 5;
125: } MemShift;
126: struct ASx {
127: uint reg : 3;
128: uint OP0 : 2;
129: uint ir : 1;
130: uint size : 2;
131: uint dr : 1;
132: uint count_reg : 3;
133: uint OP0xe : 4;
134: } ASx;
135: struct abcd {
136: uint src_reg : 3;
137: uint rm : 1;
138: uint OP16 : 5;
139: uint dest_reg : 3;
140: uint OP12 : 4;
141: } abcd;
142: struct addx {
143: uint src_reg : 3;
144: uint rm : 1;
145: uint OP0 : 2;
146: uint size : 2;
147: uint OP1 : 1;
148: uint dest_reg : 3;
149: uint op : 4;
150: } addx;
151: struct cmpm {
152: uint src_reg : 3;
153: uint OP1_1 : 3;
154: uint size : 2;
155: uint OP2_1 : 1;
156: uint dest_reg : 3;
157: uint OP0xb : 4;
158: } cmpm;
159: /* branches */
160: struct DBcc {
161: uint reg : 3;
162: uint OP25 : 5;
163: uint cond : 4;
164: uint OP5 : 4;
165: } DBcc;
166: struct Bcc {
167: int displacement : 8;
168: uint cond : 4;
169: uint op : 4;
170: } Bcc;
171: struct bra {
172: int displacement : 8;
173: uint op : 8;
174: } bra;
175: struct movem {
176: uint dest_reg : 3;
177: uint dest_mode : 3;
178: uint sz : 1;
179: uint ONE : 3;
180: uint dr : 1;
181: uint NINE : 5;
182: } movem;
183: struct lea {
184: uint dest_reg : 3;
185: uint dest_mode : 3;
186: uint SEVEN : 3;
187: uint reg : 3;
188: uint FOUR : 4;
189: } lea;
190: struct moveq {
191: int data : 8;
192: uint ZERO : 1;
193: uint reg : 3;
194: uint SEVEN : 4;
195: } moveq;
196: struct exg {
197: uint dest_reg : 3;
198: uint op_mode : 5;
199: uint OP1 : 1;
200: uint src_reg : 3;
201: uint OP0xc : 4;
202: } exg;
203: } Opcode;
204:
205: /*
206: * Skip size is used when there is immediate data, for addressing
207: * modes $addr(Ax,Dy.s), and the PC flavoured version of that.
208: * The immediate data comes first and must be skipped
209: */
210: int is_adrmod (int mode, int reg, int op_size, int skip_size)
211: {
212: Opcode ext;
213: switch (skip_size) {
214: case -1: skip_size = 0; break;
215: case 0: case 1: skip_size = 2; break;
216: default: skip_size = 4; break;
217: }
218: switch (mode) {
219: case 0: case 1: case 2: case 3: case 4:
220: return 1;
221: case 5: return 1;
222: case 6: buf_pos += skip_size;
223: ext.code = rd_short ();
224: buf_pos -= 2 + skip_size;
225: if (ext.adr_index.zeros != 0) return 0;
226: else return 1;
227: case 7:
228: switch (reg) {
229: case 0: return 1;
230: case 1: return 1;
231: case 4:
232: return 1;
233: case 2:
234: return 1;
235: case 3: buf_pos += skip_size;
236: ext.code = rd_short ();
237: buf_pos -= 2 + skip_size;
238: if (ext.adr_index.zeros != 0) return 0;
239: else return 1;
240: default:
241: return 0;
242: }
243: break;
244: default:
245: return 0;
246: }
247:
248: }
249:
250: /* returns abs address if possible or 0xdeadbeef if not */
251: uint put_adrmod (int mode, int reg, int op_size)
252: {
253: uint temp;
254: Opcode ext;
255: switch (mode) {
256: case 0: output ("d%d", reg); break;
257: case 1: output ("a%d", reg); break;
258: case 2: output ("(a%d)", reg); break;
259: case 3: output ("(a%d)+", reg); break;
260: case 4: output ("-(a%d)", reg); break;
261: case 5: output ("%hd(a%d)", rd_short(), reg); break;
262: case 6: ext.code = rd_short ();
263: if (ext.adr_index.zeros != 0) output ("???");
264: output ("%hd(a%d,", ext.adr_index.displacement, reg);
265: if (ext.adr_index.reg_type) {
266: output ("a%d", ext.adr_index.reg);
267: } else {
268: output ("d%d", ext.adr_index.reg);
269: }
270: if (ext.adr_index.ind_size) {
271: output (".l)");
272: } else {
273: output (".w)");
274: }
275: break;
276: case 7:
277: switch (reg) {
278: case 0: output ("$%hx.w", rd_short()); break;
279: case 1: temp = rd_int ();
280: output ("$%x.l", temp);
281: return temp;
282: case 4:
283: if (op_size == 0) {
284: if (rd_byte () != 0) output ("???");
285: output ("#$%x", rd_byte ());
286: } else if (op_size == 2) {
287: output ("#");
288: output ("$%x", rd_int ());
289: } else if (op_size == 1) {
290: output ("#$%hx", rd_short ());
291: } else {
292: output ("#???");
293: }
294: break;
295: case 2:
296: temp = buf_pos;
297: temp += rd_short ();
298: output ("$%x(pc)", temp);
299: return temp;
300: case 3: temp = buf_pos;
301: ext.code = rd_short ();
302: if (ext.adr_index.zeros != 0) output ("???");
303: output ("$%x", temp + ext.adr_index.displacement);
304: if (ext.adr_index.reg_type) {
305: output ("(pc,a%d", ext.adr_index.reg);
306: } else {
307: output ("(pc,d%d", ext.adr_index.reg);
308: }
309: if (ext.adr_index.ind_size) {
310: output (".l)");
311: } else {
312: output (".w)");
313: }
314: break;
315: default:
316: output ("???"); break;
317: }
318: break;
319: default:
320: output ("???"); break;
321: }
322: return 0xdeadbeef;
323: }
324:
325: void aux_put_movem_regs (int mode, int low, int high)
326: {
327: if (!mode) {
328: /* (Ax)+ and control modes */
329: if (low < 8) {
330: if (low == high) {
331: output ("d%d", low);
332: return;
333: }
334: if (high >7) {
335: if (low == 7) output ("d7/");
336: else output ("d%d-7/", low);
337: } else {
338: output ("d%d-%d", low, high);
339: return;
340: }
341: }
342: if (high > 7) {
343: if (low == high) {
344: output ("a%d", low-8);
345: return;
346: }
347: if (low > 7) {
348: output ("a%d-%d", low-8, high-8);
349: } else {
350: if (high == 8) output ("a0");
351: else output ("a0-%d", high-8);
352: }
353: }
354: } else {
355: /* -(Ax) mode */
356: if (high > 7) {
357: if (low == high) {
358: output ("d%d", 15-low);
359: return;
360: }
361: if (low > 7) {
362: output ("d%d-%d", 15-high, 15-low);
363: return;
364: } else {
365: if (high == 8) output ("d7/");
366: else output ("d%d-7/", 15-high);
367: }
368: }
369: if (low < 8) {
370: if (low == high) {
371: output ("a%d", 7-low);
372: return;
373: }
374: if (high >7) {
375: if (low == 7) output ("a0");
376: else output ("a0-%d", 7-low);
377: } else {
378: output ("a%d-%d", 7-high, 7-low);
379: }
380: }
381: }
382: }
383:
384: void put_movem_regs (int mask, int mode)
385: {
386: int start;
387: int pos;
388: int pixie = 0;
389:
390: start = -1;
391: for (pos=0; pos < 16; pos++) {
392: if ((mask & (1<<pos)) && (start == -1)) start = pos;
393: else if ((!(mask & (1<<pos))) && (start != -1)) {
394: if (pixie) output ("/");
395: else pixie = 1;
396: aux_put_movem_regs (mode, start, pos-1);
397: start = -1;
398: }
399: }
400: if (mask & (1<<15)) {
401: if (pixie) output ("/");
402: else pixie = 1;
403: aux_put_movem_regs (mode, start, pos-1);
404: start = -1;
405: }
406: }
407:
408: void put_imm (int size)
409: {
410: if (size == 0) {
411: rd_byte ();
412: output ("#$%x", (int)rd_byte ());
413: } else if (size == 1) {
414: output ("#$%hx", (int)rd_short ());
415: } else {
416: output ("#$%x", (int)rd_int ());
417: }
418: }
419:
420: /*
421: * Disassemble _count bytes from _start.
422: */
423: void dump_code (int _start, int _count)
424: {
425: Opcode op;
426: int size;
427: int temp;
428: const char *str;
429: int last_ip;
430: buf_pos = _start;
431:
432: while (buf_pos < _start+_count) {
433: output ("\r\n$%x\t", buf_pos);
434: last_ip = buf_pos;
435: op.code = rd_short ();
436: output ("($%hx)\t", op.code);
437: /* ABCD/SBCD */
438: while (op.abcd.OP16 == 16) {
439: if (op.abcd.OP12 == 12) output ("abcd\t");
440: else if (op.abcd.OP12 == 8) output ("sbcd\t");
441: else break;
442: if (op.abcd.rm) {
443: output ("-(a%d),-(a%d)", op.abcd.src_reg, op.abcd.dest_reg);
444: } else {
445: output ("d%d,d%d", op.abcd.src_reg, op.abcd.dest_reg);
446: }
447: goto done;
448: }
449: /* ADD/SUB */
450: while ((op.type2.op == 0xd) || (op.type2.op == 0x9)) {
451: if (op.type2.op == 0xd) str = "add";
452: else str = "sub";
453: if (op.type2.op_mode == 3) {
454: /* ADDA.W */
455: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1, -1)) break;
456: output ("%sa.w\t", str);
457: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1);
458: output (",a%d", op.type2.reg);
459: }
460: else if (op.type2.op_mode == 7) {
461: /* ADDA.L */
462: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, 2, -1)) break;
463: output ("%sa.l\t", str);
464: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, 2);
465: output (",a%d", op.type2.reg);
466: }
467: else if (op.type2.op_mode < 3) {
468: /* dest is reg */
469: /* no .b size Ax sources */
470: if ((op.type2.op_mode == 0) && (op.type2.ea_mode == 0x1)) break;
471: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode, -1)) break;
472: output ("%s%s\t", str, size_str[op.type2.op_mode]);
473: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode);
474: output (",d%d", op.type2.reg);
475: } else {
476: /* dest is ea */
477: if (op.type2.ea_mode == 0x0) break;
478: if (op.type2.ea_mode == 0x1) break;
479: if (op.type2.ea_mode == 0x7) {
480: if ((op.type2.ea_reg == 2) ||
481: (op.type2.ea_reg == 3) ||
482: (op.type2.ea_reg == 4)) break;
483: }
484: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode-4, -1)) break;
485: output ("%s%s\t", str, size_str[op.type2.op_mode-4]);
486: output ("d%d,", op.type2.reg);
487: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode-4);
488: }
489: goto done;
490: }
491: /* ADDI/SUBI */
492: while ((op.addi.OP6 == 6) || (op.addi.OP6 == 4)) {
493: if (op.addi.size == 3) break;
494: if (op.addi.dest_mode == 0x1) break;
495: if (op.addi.dest_mode == 0x7) {
496: if ((op.addi.dest_reg == 2) ||
497: (op.addi.dest_reg == 3) ||
498: (op.addi.dest_reg == 4)) break;
499: }
500: if (!is_adrmod (op.addi.dest_mode, op.addi.dest_reg, op.addi.size, op.addi.size)) break;
501: if (op.addi.OP6 == 6) output ("addi%s\t", size_str[op.addi.size]);
502: else output ("subi%s\t", size_str[op.addi.size]);
503: put_imm (op.addi.size);
504: output (",");
505: put_adrmod (op.addi.dest_mode, op.addi.dest_reg, op.addi.size);
506: goto done;
507: }
508: /* ADDQ/SUBQ */
509: while (op.addq.op == 0x5) {
510: if (op.addq.size == 3) break;
511: /* no immediate or pc relative dest */
512: if (op.addq.dest_mode == 0x7) {
513: if (op.addq.dest_reg > 0x1) break;
514: }
515: /* no addq.b to address registers */
516: if ((op.addq.size == 0) && (op.addq.dest_mode == 1)) break;
517: if (!is_adrmod (op.addq.dest_mode, op.addq.dest_reg, op.addq.size, -1)) break;
518: if (op.addq.issub) output ("subq%s\t", size_str[op.addq.size]);
519: else output ("addq%s\t", size_str[op.addq.size]);
520: output ("#%d,", (op.addq.data == 0 ? 8 : op.addq.data));
521: put_adrmod (op.addq.dest_mode, op.addq.dest_reg, op.addq.size);
522: goto done;
523: }
524: /* ADDX/SUBX */
525: while (((op.addx.op == 0xd) || (op.addx.op == 0x9)) && (op.addx.OP1 == 1) && (op.addx.OP0 == 0)) {
526: if (op.addx.size == 3) break;
527: if (op.addx.op == 0xd) output ("addx%s\t", size_str[op.addx.size]);
528: else output ("subx%s\t", size_str[op.addx.size]);
529: if (op.addx.rm) {
530: /* memory to memory */
531: output ("-(a%d),-(a%d)", op.addx.src_reg, op.addx.dest_reg);
532: } else {
533: output ("d%d,d%d", op.addx.src_reg, op.addx.dest_reg);
534: }
535:
536: goto done;
537: }
538: /* AND/OR */
539: while ((op.type2.op == 0xc) || (op.type2.op == 0x8)) {
540: if (op.type2.op_mode == 3) break;
541: if (op.type2.op_mode == 7) break;
542: if (op.type2.op == 0xc) str = "and";
543: else str = "or";
544: if (op.type2.op_mode < 3) {
545: /* dest is reg */
546: if (op.type2.ea_mode == 0x1) break;
547: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode, -1)) break;
548: output ("%s%s\t", str, size_str[op.type2.op_mode]);
549: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode);
550: output (",d%d", op.type2.reg);
551: } else {
552: /* dest is ea */
553: if (op.type2.ea_mode == 0x0) break;
554: if (op.type2.ea_mode == 0x1) break;
555: if (op.type2.ea_mode == 0x7) {
556: if (op.type2.ea_reg > 1) break;
557: }
558: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode-4, -1)) break;
559: output ("%s%s\t", str, size_str[op.type2.op_mode-4]);
560: output ("d%d,", op.type2.reg);
561: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode-4);
562: }
563: goto done;
564: }
565: /* ANDI/EORI/ORI */
566: while ((op.type1.op == 0x02) || (op.type1.op == 0xa) || (op.type1.op == 0x0)) {
567: if (op.type1.size == 3) break;
568: /* no address reg direct */
569: if (op.type1.ea_mode == 0x1) break;
570: /* no immediate or pc relative dest */
571: if (op.type1.ea_mode == 0x7) {
572: if (op.type1.ea_reg > 0x1) break;
573: }
574: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size, op.type1.size)) break;
575: if (op.type1.op == 0x2) output ("andi%s\t", size_str[op.type1.size]);
576: else if (op.type1.op == 0xa) output ("eori%s\t", size_str[op.type1.size]);
577: else output ("ori%s\t", size_str[op.type1.size]);
578: put_imm (op.addi.size);
579: output (",");
580: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size);
581: goto done;
582: }
583: /* ANDI to CCR */
584: while (op.code == 0x023c) {
585: rd_byte ();
586: output ("andi\t#$%x,ccr", rd_byte ());
587: goto done;
588: }
589: /* ANDI to SR */
590: while (op.code == 0x027c) {
591: output ("andi\t#$%hx,sr", rd_short ());
592: goto done;
593: }
594: /* ASx/LSx reg/imm */
595: while (op.ASx.OP0xe == 0xe) {
596: if (op.ASx.size == 3) break;
597: switch (op.ASx.OP0) {
598: case 0: str = "as"; break;
599: case 1: str = "ls"; break;
600: case 2: str = "rox"; break;
601: default: case 3: str = "ro"; break;
602: }
603: if (op.ASx.ir) {
604: /* data register shift */
605: output ("%s%c%s\td%d,d%d", str,
606: (op.ASx.dr ? 'l' : 'r'),
607: size_str[op.ASx.size],
608: op.ASx.count_reg, op.ASx.reg);
609: } else {
610: /* count shift thingy */
611: output ("%s%c%s\t#%d,d%d", str,
612: (op.ASx.dr ? 'l' : 'r'),
613: size_str[op.ASx.size],
614: (op.ASx.count_reg == 0 ? 8 : op.ASx.count_reg),
615: op.ASx.reg);
616: }
617: goto done;
618: }
619: /* ASx/LSx memory shift */
620: while ((op.MemShift.OP3 == 3) && (op.MemShift.OP0x1c == 0x1c)) {
621: if (op.type1.ea_mode < 0x2) break;
622: if ((op.type1.ea_mode == 0x7) && (op.type1.ea_reg > 0x1)) break;
623: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1, -1)) break;
624: switch (op.MemShift.type) {
625: case 0: str = "as"; break;
626: case 1: str = "ls"; break;
627: case 2: str = "rox"; break;
628: default: case 3: str = "ro"; break;
629: }
630: output ("%s%c.w\t", str, (op.ASx.dr ? 'l' : 'r'));
631: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1);
632: goto done;
633: }
634: /* Bcc */
635: while (op.Bcc.op == 0x6) {
636: if (Bcc_str [op.Bcc.cond] == NULL) break;
637: if (op.bra.displacement) {
638: temp = buf_pos + op.Bcc.displacement;
639: output ("b%s.s\t", Bcc_str[op.Bcc.cond]);
640: output_lab (temp);
641: } else {
642: temp = buf_pos;
643: temp += rd_short ();
644: output ("b%s.w\t", Bcc_str[op.Bcc.cond]);
645: output_lab (temp);
646: }
647: goto done;
648: }
649: /* BRA */
650: while (op.bra.op == 0x60) {
651: if (op.bra.displacement) {
652: temp = buf_pos + op.bra.displacement;
653: output ("bra.s\t");
654: output_lab (temp);
655: } else {
656: temp = buf_pos;
657: temp += rd_short ();
658: output ("bra.w\t");
659: output_lab (temp);
660: }
661: goto done;
662: }
663: /* BSR */
664: while ((op.code & 0xff00) == 0x6100) {
665: if (op.bra.displacement) {
666: temp = buf_pos + op.bra.displacement;
667: output ("bsr.s\t");
668: output_lab (temp);
669: } else {
670: temp = buf_pos;
671: temp += rd_short ();
672: output ("bsr.w\t");
673: output_lab (temp);
674: }
675: goto done;
676: }
677: /* BCHG/BCLR/BSET/BTST (Dn,ea) */
678: while ((op.type2.op == 0) && ((op.type2.op_mode == 0x4) || (op.type2.op_mode == 0x5) || (op.type2.op_mode == 0x6) || (op.type2.op_mode == 0x7))) {
679: if (op.type2.ea_mode == 0x1) break;
680: if ((op.type2.op_mode != 0x4) && (op.type2.ea_mode == 0x7)) {
681: if (op.type2.ea_reg > 1) break;
682: }
683: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, 2, -1)) break;
684:
685: if (op.type2.op_mode == 0x4) output ("btst\t");
686: else if (op.type2.op_mode == 0x5) output ("bchg\t");
687: else if (op.type2.op_mode == 0x6) output ("bclr\t");
688: else output ("bset\t");
689: output ("d%d,", op.type2.reg);
690: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, 2);
691: goto done;
692: }
693: /* BCHG/BCLR/BSET (#<data>,ea) */
694: while ((op.type2.op == 0) && (op.type2.reg == 4) &&
695: ((op.type2.op_mode == 0) || (op.type2.op_mode == 1) || (op.type2.op_mode == 2) || (op.type2.op_mode == 3))) {
696: if (op.type2.ea_mode == 0x1) break;
697: if ((op.type2.ea_mode == 0x7) && (op.type2.ea_reg > 1)) break;
698: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, 2, 1)) break;
699: temp = rd_byte ();
700: if (temp != 0) {
701: buf_pos--;
702: break;
703: }
704: if (op.type2.op_mode == 0) {
705: output ("btst\t");
706: } else if (op.type2.op_mode == 1) {
707: output ("bchg\t");
708: } else if (op.type2.op_mode == 2) {
709: output ("bclr\t");
710: } else {
711: output ("bset\t");
712: }
713: output ("#$%x,", (int)rd_byte ());
714: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, 2);
715: goto done;
716: }
717: /* BKPT */
718: /*while ((op.code & 0xfff8) == 0x4848) {
719: output ("bkpt\t#%d", op.code & 0x7);
720: goto done;
721: }*/
722: /* CHK */
723: while ((op.type2.op == 0x4) && (op.type2.op_mode == 0x6)) {
724: /* no address reg direct */
725: if (op.type2.ea_mode == 0x1) break;
726: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1, -1)) break;
727:
728: output ("chk\t");
729: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1);
730: output (",d%d", op.type2.reg);
731:
732: goto done;
733: }
734: /* CLR */
735: while (op.type1.op == 0x42) {
736: if (op.type1.size == 3) break;
737: /* no address reg direct */
738: if (op.type1.ea_mode == 0x1) break;
739: /* no immediate or pc relative dest */
740: if (op.type1.ea_mode == 0x7) {
741: if (op.type1.ea_reg > 0x1) break;
742: }
743: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size, -1)) break;
744: output ("clr%s\t", size_str[op.type1.size]);
745: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size);
746: goto done;
747: }
748: /* CMP */
749: while (op.type2.op == 11) {
750: if (op.type2.op_mode > 2) break;
751: /* no .b size for adr reg direct */
752: if ((op.type2.op_mode == 0) && (op.type2.ea_mode == 0x1)) break;
753: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode, -1)) break;
754: output ("cmp%s\t", size_str[op.type2.op_mode]);
755: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, op.type2.op_mode);
756: output (",d%d", op.type2.reg);
757: goto done;
758: }
759: /* CMPA */
760: while (op.type2.op == 11) {
761: if ((op.type2.op_mode != 0x3) && (op.type2.op_mode != 0x7)) break;
762: if (op.type2.op_mode == 0x3) size = 1;
763: else size = 2;
764: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, size, -1)) break;
765: output ("cmpa%s\t", size_str [size]);
766: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, size);
767: output (",a%d", op.type2.reg);
768: goto done;
769: }
770: /* CMPI */
771: while ((op.type1.op == 0x0c) && (op.type1.size != 0x3)) {
772: if (op.type1.ea_mode == 0x1) break;
773: if ((op.type1.ea_mode == 0x7) && (op.type1.ea_reg > 0x1)) break;
774: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size, op.type1.size)) break;
775: output ("cmpi%s\t", size_str [op.type1.size]);
776: put_imm (op.type1.size);
777: output (",");
778: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size);
779: goto done;
780: }
781: /* CMPM */
782: while ((op.cmpm.OP0xb == 0xb) && (op.cmpm.OP2_1 == 0x1) && (op.cmpm.OP1_1 == 0x1)) {
783: if (op.cmpm.size == 3) break;
784: output ("cmpm%s\t(a%d)+,(a%d)+", size_str [op.cmpm.size], op.cmpm.src_reg, op.cmpm.dest_reg);
785: goto done;
786: }
787: /* DBcc */
788: while ((op.DBcc.OP5 == 5) && (op.DBcc.OP25 == 25)) {
789: if (DBcc_str [op.DBcc.cond] == NULL) break;
790: temp = buf_pos;
791: temp += rd_short ();
792: output ("db%s\td%d,", DBcc_str[op.DBcc.cond],
793: op.DBcc.reg);
794: output_lab (temp);
795: goto done;
796: }
797: /* DIVS/DIVU */
798: while ((op.type2.op == 0x8) && ((op.type2.op_mode == 0x7) || (op.type2.op_mode == 0x3))) {
799: if (op.type2.ea_mode == 0x1) break;
800: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1, -1)) break;
801: if (op.type2.op_mode == 0x7) output ("divs\t");
802: else output ("divu\t");
803: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1);
804: output (",d%d", op.type2.reg);
805: goto done;
806: }
807: /* EOR */
808: while (op.type2.op == 0xb) {
809: if ((op.type2.op_mode < 4) || (op.type2.op_mode > 6)) break;
810: if (op.type2.ea_mode == 0x1) break;
811: if ((op.type2.ea_mode == 0x7) && (op.type2.ea_reg > 0x1)) break;
812: size = op.type2.op_mode - 4;
813: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, size, -1)) break;
814: output ("eor%s\t", size_str [size]);
815: output ("d%d,", op.type2.reg);
816: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, size);
817: goto done;
818: }
819: /* EORI to CCR */
820: while (op.code == 0x0a3c) {
821: rd_byte ();
822: output ("eori\t#$%x,ccr", rd_byte ());
823: goto done;
824: }
825: /* EORI to SR */
826: while (op.code == 0x0a7c) {
827: output ("eori\t#$%hx,sr", rd_short ());
828: goto done;
829: }
830: /* EXG */
831: while ((op.exg.OP0xc == 0xc) && (op.exg.OP1 == 1)) {
832: if (op.exg.op_mode == 0x8) {
833: /* data reg swap */
834: output ("exg\td%d,d%d", op.exg.src_reg, op.exg.dest_reg);
835: } else if (op.exg.op_mode == 0x9) {
836: /* address reg swap */
837: output ("exg\ta%d,a%d", op.exg.src_reg, op.exg.dest_reg);
838: } else if (op.exg.op_mode == 0x11) {
839: /* data & adr reg swap */
840: output ("exg\td%d,a%d", op.exg.src_reg, op.exg.dest_reg);
841: } else {
842: break;
843: }
844: goto done;
845: }
846: /* EXT */
847: while ((op.code & 0xfe38) == 0x4800) {
848: if (op.type2.op_mode == 0x2) {
849: output ("ext.w\td%d", op.type2.ea_reg);
850: } else if (op.type2.op_mode == 0x3) {
851: output ("ext.l\td%d", op.type2.ea_reg);
852: } else {
853: break;
854: }
855: goto done;
856: }
857: /* ILLEGAL */
858: while (op.code == 0x4afc) {
859: output ("illegal");
860: goto done;
861: }
862: /* JMP */
863: while ((op.code & 0xffc0) == 0x4ec0) {
864: if (op.jmp.dest_mode == 0) break;
865: if (op.jmp.dest_mode == 1) break;
866: if (op.jmp.dest_mode == 3) break;
867: if (op.jmp.dest_mode == 4) break;
868: if ((op.jmp.dest_mode == 7) &&
869: (op.jmp.dest_reg == 4)) break;
870: if (!is_adrmod (op.jmp.dest_mode, op.jmp.dest_reg, 2, -1)) break;
871: output ("jmp\t");
872: temp = put_adrmod (op.jmp.dest_mode, op.jmp.dest_reg, 2);
873: goto done;
874: }
875: /* JSR */
876: while ((op.code & 0xffc0) == 0x4e80) {
877: if (op.type1.ea_mode == 0) break;
878: if (op.type1.ea_mode == 1) break;
879: if (op.type1.ea_mode == 3) break;
880: if (op.type1.ea_mode == 4) break;
881: /* no immediate dest */
882: if ((op.type1.ea_mode == 7) && (op.type1.ea_reg == 4)) break;
883: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 2, -1)) break;
884: output ("jsr\t");
885: temp = put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 2);
886: goto done;
887: }
888: /* LEA */
889: while ((op.lea.SEVEN == 7) && (op.lea.FOUR == 4)) {
890: if (op.lea.dest_mode == 0) break;
891: if (op.lea.dest_mode == 1) break;
892: if (op.lea.dest_mode == 3) break;
893: if (op.lea.dest_mode == 4) break;
894: /* no immediate dest */
895: if ((op.lea.dest_mode == 7) && (op.lea.dest_reg == 4)) break;
896: if (!is_adrmod (op.lea.dest_mode, op.lea.dest_reg, 2, -1)) break;
897: output ("lea\t");
898: put_adrmod (op.lea.dest_mode, op.lea.dest_reg, 2);
899: output (",a%d", op.lea.reg);
900: goto done;
901: }
902: /* LINK */
903: while ((op.code & 0xfff8) == 0x4e50) {
904: output ("link\ta%d,", op.type1.ea_reg);
905: put_imm (1);
906: goto done;
907: }
908: /* MOVE/MOVEA */
909: while (op.move.op == 0) {
910: if (op.move.size == 0) break;
911: /* byte size and address reg direct is not allowed */
912: if ((op.move.size == 1) && (op.move.src_mode == 0x1)) break;
913: if ((op.move.size == 1) && (op.move.dest_mode == 0x1)) break;
914: if (op.move.dest_mode == 0x7) {
915: if (op.move.dest_reg > 1) break;
916: }
917: size = move_size [op.move.size];
918: if (!is_adrmod (op.move.src_mode, op.move.src_reg, size, -1)) break;
919: if ((op.move.src_mode == 0x7) && (op.move.src_reg == 0x4)) {
920: /* immediate crap in the source so we must skip it */
921: if (!is_adrmod (op.move.dest_mode, op.move.dest_reg, size, size)) break;
922: } else if ((op.move.src_mode == 0x7) && (op.move.src_reg > 0x1)) {
923: if (!is_adrmod (op.move.dest_mode, op.move.dest_reg, size, 1)) break;
924: } else if ((op.move.src_mode == 0x7) && (op.move.src_reg == 0x1)) {
925: if (!is_adrmod (op.move.dest_mode, op.move.dest_reg, size, 2)) break;
926: } else if ((op.move.src_mode == 0x7) && (op.move.src_reg == 0x0)) {
927: if (!is_adrmod (op.move.dest_mode, op.move.dest_reg, size, 1)) break;
928: } else if ((op.move.src_mode == 0x6) || (op.move.src_mode == 0x5)) {
929: /* PC with disp + Dx, (Ax) with disp + Dx */
930: if (!is_adrmod (op.move.dest_mode, op.move.dest_reg, size, 1)) break;
931: } else {
932: if (!is_adrmod (op.move.dest_mode, op.move.dest_reg, size, -1)) break;
933: }
934: if (op.move.dest_mode == 0x1) {
935: output ("movea%s\t", size_str[size]);
936: } else {
937: output ("move%s\t", size_str[size]);
938: }
939:
940: put_adrmod (op.move.src_mode, op.move.src_reg, size);
941: output (",");
942: put_adrmod (op.move.dest_mode, op.move.dest_reg, size);
943: goto done;
944: }
945: /* MOVE to CCR */
946: while ((op.code & 0xffc0) == 0x44c0) {
947: if (op.type1.ea_mode == 0x1) break;
948: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1, -1)) break;
949: output ("move.w\t");
950: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1);
951: output (",ccr");
952: goto done;
953: }
954: /* MOVE from SR */
955: while ((op.code & 0xffc0) == 0x40c0) {
956: if (op.type1.ea_mode == 0x1) break;
957: if ((op.type1.ea_mode == 0x7) && (op.type1.ea_reg > 0x1)) break;
958: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1, -1)) break;
959: output ("move.w\tsr,");
960: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1);
961: goto done;
962: }
963: /* MOVE to SR */
964: while ((op.code & 0xffc0) == 0x46c0) {
965: if (op.type1.ea_mode == 0x1) break;
966: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1, -1)) break;
967: output ("move.w\t");
968: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 1);
969: output (",sr");
970: goto done;
971: }
972: /* MOVE USP */
973: while ((op.code & 0xfff0) == 0x4e60) {
974: if (op.addx.rm) {
975: /* USP to Ax */
976: output ("move.l\tusp,a%d", op.addx.src_reg);
977: } else {
978: output ("move.l\ta%d,usp", op.addx.src_reg);
979: }
980: goto done;
981: }
982: /* TODO MOVEC */
983: /* TODO MOVEP */
984: /* MOVEM */
985: while ((op.movem.NINE == 9) && (op.movem.ONE == 1)) {
986: if (op.movem.dr) {
987: /* memory to register */
988: if (op.movem.dest_mode < 2) break;
989: if (op.movem.dest_mode == 4) break;
990: if ((op.movem.dest_mode == 7) && (op.movem.dest_reg == 4)) break;
991: if (!is_adrmod (op.movem.dest_mode, op.movem.dest_reg, op.movem.sz+1, 1)) break;
992: temp = rd_short ();
993: output ("movem%s\t", size_str [op.movem.sz+1]);
994: put_adrmod (op.movem.dest_mode, op.movem.dest_reg, op.movem.sz+1);
995: output (",");
996: put_movem_regs (temp, 0);
997: } else {
998: /* register to memory */
999: if (op.movem.dest_mode < 2) break;
1000: if (op.movem.dest_mode == 3) break;
1001: if ((op.movem.dest_mode == 7) && (op.movem.dest_reg > 1)) break;
1002: if (!is_adrmod (op.movem.dest_mode, op.movem.dest_reg, op.movem.sz+1, 1)) break;
1003: output ("movem%s\t", size_str [op.movem.sz+1]);
1004: put_movem_regs (rd_short (), (op.movem.dest_mode == 4));
1005: output (",");
1006: put_adrmod (op.movem.dest_mode, op.movem.dest_reg, op.movem.sz+1);
1007: }
1008: goto done;
1009: }
1010: /* MOVEQ */
1011: while ((op.moveq.SEVEN == 7) && (op.moveq.ZERO == 0)) {
1012: output ("moveq\t#%d,d%d", op.moveq.data, op.moveq.reg);
1013: goto done;
1014: }
1015: /* MULS/MULU */
1016: while ((op.type2.op == 0xc) && ((op.type2.op_mode == 0x7) || (op.type2.op_mode == 0x3))) {
1017: if (op.type2.ea_mode == 0x1) break;
1018: if (!is_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1, -1)) break;
1019: if (op.type2.op_mode == 0x7) output ("muls\t");
1020: else output ("mulu\t");
1021: put_adrmod (op.type2.ea_mode, op.type2.ea_reg, 1);
1022: output (",d%d", op.type2.reg);
1023: goto done;
1024: }
1025: /* NBCD */
1026: while ((op.code & 0xffc0) == 0x4800) {
1027: if (op.type1.ea_mode == 0x1) break;
1028: if ((op.type1.ea_mode == 0x7) && (op.type1.ea_reg > 1)) break;
1029: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 0, -1)) break;
1030: output ("nbcd\t");
1031: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 0);
1032: goto done;
1033: }
1034: /* NEG/NEGX/NOT */
1035: while ((op.type1.op == 0x44) || (op.type1.op == 0x40) || (op.type1.op == 0x46)) {
1036: if (op.type1.size == 3) break;
1037: if (op.type1.ea_mode == 0x1) break;
1038: if ((op.type1.ea_mode == 0x7) && (op.type1.ea_reg > 1)) break;
1039: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size, -1)) break;
1040: if (op.type1.op == 0x44) output ("neg%s\t", size_str [op.type1.size]);
1041: else if (op.type1.op == 0x40) output ("negx%s\t", size_str [op.type1.size]);
1042: else output ("not%s\t", size_str [op.type1.size]);
1043: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size);
1044: goto done;
1045: }
1046: /* NOP */
1047: while (op.code == 0x4e71) {
1048: output ("nop");
1049: goto done;
1050: }
1051: /* ORI to CCR */
1052: while (op.code == 0x003c) {
1053: rd_byte ();
1054: output ("ori\t#$%x,ccr", rd_byte ());
1055: goto done;
1056: }
1057: /* ORI to SR */
1058: while (op.code == 0x007c) {
1059: output ("ori\t#$%hx,sr", rd_short ());
1060: goto done;
1061: }
1062: /* PEA */
1063: while ((op.code & 0xffc0) == 0x4840) {
1064: if (op.type1.ea_mode < 2) break;
1065: if (op.type1.ea_mode == 3) break;
1066: if (op.type1.ea_mode == 4) break;
1067: if ((op.type1.ea_mode == 7) && (op.type1.ea_reg == 4)) break;
1068: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size, -1)) break;
1069: output ("pea\t");
1070: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 2);
1071: goto done;
1072: }
1073: /* RESET */
1074: while (op.code == 0x4e70) {
1075: output ("reset");
1076: goto done;
1077: }
1078: /* RTE */
1079: while (op.code == 0x4e73) {
1080: output ("rte");
1081: goto done;
1082: }
1083: /* RTR */
1084: while (op.code == 0x4e77) {
1085: output ("rtr");
1086: goto done;
1087: }
1088: /* RTS */
1089: while (op.code == 0x4e75) {
1090: output ("rts");
1091: goto done;
1092: }
1093: /* Scc */
1094: while ((op.code & 0xf0c0) == 0x50c0) {
1095: if (op.type1.ea_mode == 1) break;
1096: if ((op.type1.ea_mode == 7) && (op.type1.ea_reg > 1)) break;
1097: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 0, -1)) break;
1098: output ("s%s\t", DBcc_str[op.DBcc.cond]);
1099: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 0);
1100: goto done;
1101: }
1102: /* STOP */
1103: while (op.code == 0x4e72) {
1104: output ("stop\t");
1105: put_imm (1);
1106: goto done;
1107: }
1108: /* SWAP */
1109: while ((op.code & 0xfff8) == 0x4840) {
1110: output ("swap\td%d", op.code & 0x7);
1111: goto done;
1112: }
1113: /* TAS */
1114: while ((op.code & 0xffc0) == 0x4ac0) {
1115: if (op.type1.ea_mode == 0x1) break;
1116: if ((op.type1.ea_mode == 0x7) && (op.type1.ea_reg > 0x1)) break;
1117: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, 0, -1)) break;
1118: output ("tas\t");
1119: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, 0);
1120: goto done;
1121: }
1122: /* TRAP */
1123: while ((op.code & 0xfff0) == 0x4e40) {
1124: output ("trap\t#%d", op.code & 0xf);
1125: goto done;
1126: }
1127: /* TRAPV */
1128: while (op.code == 0x4e76) {
1129: output ("trapv");
1130: goto done;
1131: }
1132: /* TST */
1133: while (op.type1.op == 0x4a) {
1134: if (op.type1.size == 3) break;
1135: /* no address reg direct */
1136: if (op.type1.ea_mode == 0x1) break;
1137: /* no immediate or pc relative dest */
1138: if ((op.type1.ea_mode == 0x7) && (op.type1.ea_reg > 0x1)) break;
1139: if (!is_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size, -1)) break;
1140: output ("tst%s\t", size_str[op.type1.size]);
1141: put_adrmod (op.type1.ea_mode, op.type1.ea_reg, op.type1.size);
1142: goto done;
1143: }
1144: /* UNLK */
1145: while ((op.code & 0xfff8) == 0x4e58) {
1146: output ("unlk\ta%d", op.code & 0x7);
1147: goto done;
1148: }
1149: /* fuck knows */
1150: output ("dc.w\t$%hx", op.code);
1151: done:
1152: continue;
1153: }
1154: output ("\r\n");
1155: }
1156:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.