![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disass.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|
Return to disass.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
2: Hatari
3:
4: Disassemble 'OpCode' into text string for use with debugger
5:
6: This works in a similar way to the decoding of instructions, which while produces
7: more complicated code is very handy for debugging in the early stages of development.
8: (Anyhow, none of this is included in the final executable!)
9: Note the 'rprintf' functions; these do a sprintf but the variables are in reverse order
10: as I use function calls as parameters which 'C' puts them on stack in the opposite order.
11: These functions are also used when writing out a history of the last 'x' instructions
12: ran, which is used for debugging.
13: */
14:
15: #include "main.h"
16: //#include "debugger.h"
17: #include "decode.h"
18: #include "disass.h"
19: #include "m68000.h"
20: #include "misc.h"
21: #include "stMemory.h"
22:
23: #ifdef USE_DEBUGGER
24:
25: char szSizeString[4]; /* Size B,W or L */
26: char szParamString[256]; /* Data */
27: char szConditionString[256]; /* Condition code */
28: char szImmString[256]; /* Immediate */
29: char szEffAddrString[256]; /* Effective address */
30: char szUpperEffAddrString[256]; /* Effective address, upper bits in OpCode (for MOVE instruction) */
31: char szRegString[256]; /* MoveM register list */
32: char szOpString[256]; /* Final disassembly */
33: char szOpData[256]; /* Final disassembly */
34:
35: unsigned short int OpCode; /* Opcode of instruction */
36: unsigned long DisPC; /* Disassembly Program Counter */
37:
38: char *pszCC_Strings[] = {
39: "T", // 0000 (Not used in Bcc)
40: "F", // 0001 (Not used in Bcc)
41: "HI", // 0010
42: "LS", // 0011
43: "CC", // 0100
44: "CS", // 0101
45: "NE", // 0110
46: "EQ", // 0111
47: "VC", // 1000
48: "VS", // 1001
49: "PL", // 1010
50: "MI", // 1011
51: "GE", // 1100
52: "LT", // 1101
53: "GT", // 1110
54: "LE" // 1111
55: };
56:
57: //-----------------------------------------------------------------------
58: /*
59: As 'C' functions parameters are in 'reverse' order, have set of functions
60: which pass parameters in correct order and swap in function.
61: Uses 'C++' overloads to get correct types!
62: */
63: void rprintf0(char *pSrcString)
64: {
65: sprintf(szOpString,pSrcString);
66: }
67: //-----------------------------------------------------------------------
68: // %s
69: void rprintf1(char *pSrcString, char *pString1)
70: {
71: sprintf(szOpString,pSrcString,pString1);
72: }
73: // %d
74: void rprintf1(char *pSrcString, int Var1)
75: {
76: sprintf(szOpString,pSrcString,Var1);
77: }
78: //-----------------------------------------------------------------------
79: // %s %s
80: void rprintf2(char *pSrcString, char *pString1, char *pString2)
81: {
82: sprintf(szOpString,pSrcString,pString2,pString1);
83: }
84: // %d %s
85: void rprintf2(char *pSrcString, char *pString1, int Var2)
86: {
87: sprintf(szOpString,pSrcString,Var2,pString1);
88: }
89: // %s %d
90: void rprintf2(char *pSrcString, int Var1, char *pString2)
91: {
92: sprintf(szOpString,pSrcString,pString2,Var1);
93: }
94: // %d %d
95: void rprintf2(char *pSrcString, int Var1, int Var2)
96: {
97: sprintf(szOpString,pSrcString,Var2,Var1);
98: }
99: //-----------------------------------------------------------------------
100: // %s %s %s
101: void rprintf3(char *pSrcString, char *pString1, char *pString2, char *pString3)
102: {
103: sprintf(szOpString,pSrcString,pString3,pString2,pString1);
104: }
105: // %s %s %d
106: void rprintf3(char *pSrcString, int Var1, char *pString2, char *pString3)
107: {
108: sprintf(szOpString,pSrcString,pString3,pString2,Var1);
109: }
110: // %s %d %s
111: void rprintf3(char *pSrcString, char *pString1, int Var2, char *pString3)
112: {
113: sprintf(szOpString,pSrcString,pString3,Var2,pString1);
114: }
115: // %s %d %d
116: void rprintf3(char *pSrcString, int Var1, int Var2, char *pString3)
117: {
118: sprintf(szOpString,pSrcString,pString3,Var2,Var1);
119: }
120: //-----------------------------------------------------------------------
121: // %s %d %s %d
122: void rprintf4(char *pSrcString, int Var1, char *pString2, int Var3, char *pString4)
123: {
124: sprintf(szOpString,pSrcString,pString4,Var3,pString2,Var1);
125: }
126: // %s %s %d %d
127: void rprintf4(char *pSrcString, int Var1, int Var2, char *pString3, char *pString4)
128: {
129: sprintf(szOpString,pSrcString,pString4,pString3,Var2,Var1);
130: }
131:
132:
133: //-----------------------------------------------------------------------
134: /*
135: Read byte,byte(odd address),word and long from memory
136: */
137: unsigned char Disass_ReadByte(void)
138: {
139: char szString[256];
140: unsigned char Var;
141:
142: Var = *(unsigned char *)((unsigned long)STRam+(DisPC&0xffffff));
143: DisPC += SIZE_BYTE;
144:
145: // Add to szOpString
146: sprintf(szString,"%2.2X",Var);
147: strcat(szOpData,szString);
148:
149: return(Var);
150: }
151: unsigned char Disass_ReadByte_OddAddr(void)
152: {
153: char szString[256];
154: unsigned char Var;
155:
156: Var = *(unsigned char *)((unsigned long)STRam+(DisPC&0xffffff)+1);
157: DisPC += SIZE_WORD;
158:
159: // Add to szOpString
160: sprintf(szString,"%4.4X",Var);
161: strcat(szOpData,szString);
162:
163: return(Var);
164: }
165: unsigned short int Disass_ReadWord(void)
166: {
167: char szString[256];
168: unsigned short int Var;
169:
170: Var = *(unsigned short int *)((unsigned long)STRam+(DisPC&0xffffff));
171: DisPC += SIZE_WORD;
172:
173: // Add to szOpString
174: sprintf(szString,"%4.4X",STMemory_Swap68000Int(Var));
175: strcat(szOpData,szString);
176:
177: return(STMemory_Swap68000Int(Var));
178: }
179: unsigned long Diass_ReadLong(void)
180: {
181: char szString[256];
182: unsigned long Var;
183:
184: Var = *(unsigned long *)((unsigned long)STRam+(DisPC&0xffffff));
185: DisPC += SIZE_LONG;
186:
187: // Add to szOpString
188: sprintf(szString,"%8.8X",STMemory_Swap68000Long(Var));
189: strcat(szOpData,szString);
190:
191: return(STMemory_Swap68000Long(Var));
192: }
193:
194: //-----------------------------------------------------------------------
195: /*
196: Convert unsigned values to strings
197: */
198: char *Disass_ByteToString(unsigned char DataB)
199: {
200: if (DataB<=9)
201: sprintf(szParamString,"%d",DataB);
202: else
203: sprintf(szParamString,"$%X",DataB);
204:
205: return(szParamString);
206: }
207: char *Disass_WordToString(unsigned short int DataW)
208: {
209: if (DataW<=9)
210: sprintf(szParamString,"%d",DataW);
211: else
212: sprintf(szParamString,"$%X",DataW);
213:
214: return(szParamString);
215: }
216: char *Disass_LongToString(unsigned long DataL)
217: {
218: if (DataL<=9)
219: sprintf(szParamString,"%d",DataL);
220: else
221: sprintf(szParamString,"$%X",DataL);
222:
223: return(szParamString);
224: }
225:
226: //-----------------------------------------------------------------------
227: /*
228: Convert signed values to strings, pass NULL as String to write to 'szParamString' (default)
229: */
230: char *Disass_SignedByteToString(char DataB,char *pString=NULL)
231: {
232: if (pString==NULL)
233: pString = szParamString;
234:
235: if (abs(DataB)<=9) {
236: if (DataB>=0)
237: sprintf(pString,"%d",DataB);
238: else
239: sprintf(pString,"-%d",-DataB);
240: }
241: else {
242: if (DataB>=0)
243: sprintf(pString,"$%X",DataB);
244: else
245: sprintf(pString,"$%X",(unsigned char)DataB);
246: }
247:
248: return(pString);
249: }
250: char *Disass_SignedWordToString(short int DataW,char *pString=NULL)
251: {
252: if (pString==NULL)
253: pString = szParamString;
254:
255: if (abs(DataW)<=9) {
256: if (DataW>=0)
257: sprintf(pString,"%d",DataW);
258: else
259: sprintf(pString,"-%d",-DataW);
260: }
261: else {
262: if (DataW>=0)
263: sprintf(pString,"$%X",DataW);
264: else
265: sprintf(pString,"$%X",(unsigned short int)DataW);
266: }
267:
268: return(pString);
269: }
270: char *Disass_SignedLongToString(long DataL,char *pString=NULL)
271: {
272: if (pString==NULL)
273: pString = szParamString;
274:
275: if (abs(DataL)<=9) {
276: if (DataL>=0)
277: sprintf(pString,"%d",DataL);
278: else
279: sprintf(pString,"-%d",-DataL);
280: }
281: else {
282: if (DataL>=0)
283: sprintf(pString,"$%X",DataL);
284: else
285: sprintf(pString,"$%X",(unsigned long)DataL);
286: }
287:
288: return(pString);
289: }
290:
291: //-----------------------------------------------------------------------
292: /*
293: Create 'Effective Address' string from OpCode and size, 'asserts' on error
294: */
295: char *Disass_CalcEffAddr(int Size,unsigned short int Mode,unsigned short int Reg, char *pString)
296: {
297: unsigned long OffsetL;
298: unsigned short int OffsetW,EReg,OffsetSize;
299: unsigned char OffsetB;
300:
301: // Clear string, allows easy error check when complete
302: strcpy(pString,"");
303:
304: switch(Mode) {
305: case BIN3(0,0,0): // Dn
306: sprintf(pString,"D%d",Reg);
307: break;
308: case BIN3(0,0,1): // An
309: sprintf(pString,"A%d",Reg);
310: break;
311:
312: case BIN3(0,1,0): // (An)
313: sprintf(pString,"(A%d)",Reg);
314: break;
315: case BIN3(0,1,1): // (An)+
316: sprintf(pString,"(A%d)+",Reg);
317: break;
318: case BIN3(1,0,0): // -(An)
319: sprintf(pString,"-(A%d)",Reg);
320: break;
321:
322: case BIN3(1,0,1): // (d16,An)
323: OffsetW = Disass_ReadWord();
324: sprintf(pString,"%s(A%d)",Disass_SignedWordToString(OffsetW),Reg);
325: break;
326:
327: case BIN3(1,1,0): // (d8,An,Xn)
328: OffsetW = Disass_ReadWord();
329: EReg = OffsetW>>12; // d0-d7,a0-a7
330: OffsetSize = (OffsetW>>11)&0x1; // 0-Sign extended word, 1-long
331: if (EReg<REG_A0) {
332: if (OffsetSize==0)
333: sprintf(pString,"%s(A%d,D%d.W)",Disass_SignedByteToString((char)OffsetW),Reg,EReg);
334: else
335: sprintf(pString,"%s(A%d,D%d.L)",Disass_SignedByteToString((char)OffsetW),Reg,EReg);
336: }
337: else {
338: if (OffsetSize==0)
339: sprintf(pString,"%s(A%d,A%d.W)",Disass_SignedByteToString((char)OffsetW),Reg,EReg-REG_A0);
340: else
341: sprintf(pString,"%s(A%d,A%d.L)",Disass_SignedByteToString((char)OffsetW),Reg,EReg-REG_A0);
342: }
343: break;
344:
345: case BIN3(1,1,1): // 0x111
346: switch(Reg) {
347: case BIN3(0,0,0): // xxx.W
348: OffsetW = Disass_ReadWord();
349: sprintf(pString,"%s",Disass_WordToString(OffsetW));
350: break;
351: case BIN3(0,0,1): // xxx.L
352: OffsetL = Diass_ReadLong();
353: sprintf(pString,"%s",Disass_LongToString(OffsetL));
354: break;
355: case BIN3(0,1,0): // (d16,PC)
356: OffsetW = Disass_ReadWord();
357: sprintf(pString,"%s(PC)",Disass_LongToString((long)DisPC+(short int)OffsetW-SIZE_WORD));
358: break;
359: case BIN3(0,1,1): // (d8,PC,Xn)
360: OffsetW = Disass_ReadWord();
361: EReg = OffsetW>>12; // d0-d7,a0-a7
362: OffsetSize = (OffsetW>>11)&0x1; // 0-Sign extended word, 1-long
363: if (EReg<REG_A0) {
364: if (OffsetSize==0)
365: sprintf(pString,"%s(PC,D%d.W)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg);
366: else
367: sprintf(pString,"%s(PC,D%d.L)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg);
368: }
369: else {
370: if (OffsetSize==0)
371: sprintf(pString,"%s(PC,A%d.W)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg-REG_A0);
372: else
373: sprintf(pString,"%s(PC,A%d.L)",Disass_LongToString((long)DisPC+(char)OffsetW-SIZE_WORD),EReg-REG_A0);
374: }
375: break;
376: case BIN3(1,0,0): // 0x100 // # data
377: switch(Size) {
378: case SIZE_BYTE:
379: OffsetB = Disass_ReadByte_OddAddr();
380: sprintf(pString,"#%s",Disass_SignedByteToString(OffsetB));
381: break;
382: case SIZE_WORD:
383: OffsetW = Disass_ReadWord();
384: sprintf(pString,"#%s",Disass_SignedWordToString(OffsetW));
385: break;
386: case SIZE_LONG:
387: OffsetL = Diass_ReadLong();
388: sprintf(pString,"#%s",Disass_SignedLongToString(OffsetL));
389: break;
390: }
391: break;
392: }
393: break;
394: }
395:
396: // Check for errors!
397: if (strlen(pString)==0) {
398: assert(0);
399: }
400:
401: return(pString);
402: }
403:
404: //-----------------------------------------------------------------------
405: /*
406: Use these two functions to find Effective Address, use 'upper' version for MOVE instruction
407: */
408: char *Disass_FindEffAddr(int Size)
409: {
410: unsigned short int Mode,Reg;
411:
412: // Find effective address Mode and Register
413: Mode = (OpCode>>3)&0x7;
414: Reg = OpCode&0x7;
415:
416: return(Disass_CalcEffAddr(Size,Mode,Reg,szEffAddrString));
417: }
418: char *Disass_FindUpperEffAddr(int Size)
419: {
420: unsigned short int Mode,Reg;
421:
422: // Find effective address Mode and Register in upper bits in OpCode
423: Mode = (OpCode>>6)&0x7;
424: Reg = (OpCode>>9)&0x7;
425:
426: return(Disass_CalcEffAddr(Size,Mode,Reg,szUpperEffAddrString));
427: }
428:
429: //-----------------------------------------------------------------------
430: /*
431: Find size .B,.W,.L
432: Do as string and as SIZE_xxxx
433: */
434: char *Disass_FindSize_00_01_10(void)
435: {
436: unsigned short int Size;
437:
438: Size = (OpCode>>6)&0x3;
439: switch(Size) {
440: case BIN2(0,0): strcpy(szSizeString,"B"); break;
441: case BIN2(0,1): strcpy(szSizeString,"W"); break;
442: case BIN2(1,0): strcpy(szSizeString,"L"); break;
443: }
444:
445: return(szSizeString);
446: }
447: int Disass_EffAddrSize_00_01_10(void)
448: {
449: unsigned short int Size;
450:
451: Size = (OpCode>>6)&0x3;
452: switch(Size) {
453: case BIN2(0,0): return(SIZE_BYTE);
454: case BIN2(0,1): return(SIZE_WORD);
455: case BIN2(1,0): return(SIZE_LONG);
456: }
457:
458: // Error
459: assert(0);
460: return(0);
461: }
462:
463: //-----------------------------------------------------------------------
464: char *Disass_FindSize_000_001_010(void)
465: {
466: unsigned short int Size;
467:
468: Size = (OpCode>>6)&0x7;
469: switch(Size) {
470: case BIN3(0,0,0): strcpy(szSizeString,"B"); break;
471: case BIN3(0,0,1): strcpy(szSizeString,"W"); break;
472: case BIN3(0,1,0): strcpy(szSizeString,"L"); break;
473: }
474:
475: return(szSizeString);
476: }
477: int Disass_EffAddrSize_000_001_010(void)
478: {
479: unsigned short int Size;
480:
481: Size = (OpCode>>6)&0x7;
482: switch(Size) {
483: case BIN3(0,0,0): return(SIZE_BYTE);
484: case BIN3(0,0,1): return(SIZE_WORD);
485: case BIN3(0,1,0): return(SIZE_LONG);
486: }
487:
488: // Error
489: assert(0);
490: return(0);
491: }
492:
493: //-----------------------------------------------------------------------
494: char *Disass_FindSize_011_111(void)
495: {
496: unsigned short int Size;
497:
498: Size = (OpCode>>6)&0x7;
499: switch(Size) {
500: case BIN3(0,1,1): strcpy(szSizeString,"W"); break;
501: case BIN3(1,1,1): strcpy(szSizeString,"L"); break;
502: }
503:
504: return(szSizeString);
505: }
506: int Disass_EffAddrSize_011_111(void)
507: {
508: unsigned short int Size;
509:
510: Size = (OpCode>>6)&0x7;
511: switch(Size) {
512: case BIN3(0,1,1): return(SIZE_WORD);
513: case BIN3(1,1,1): return(SIZE_LONG);
514: }
515:
516: // Error
517: assert(0);
518: return(0);
519: }
520:
521: //-----------------------------------------------------------------------
522: char *Disass_FindSize_100_101_110(void)
523: {
524: unsigned short int Size;
525:
526: Size = (OpCode>>6)&0x7;
527: switch(Size) {
528: case BIN3(1,0,0): strcpy(szSizeString,"B"); break;
529: case BIN3(1,0,1): strcpy(szSizeString,"W"); break;
530: case BIN3(1,1,0): strcpy(szSizeString,"L"); break;
531: }
532:
533: return(szSizeString);
534: }
535: int Disass_EffAddrSize_100_101_110(void)
536: {
537: unsigned short int Size;
538:
539: Size = (OpCode>>6)&0x7;
540: switch(Size) {
541: case BIN3(1,0,0): return(SIZE_BYTE);
542: case BIN3(1,0,1): return(SIZE_WORD);
543: case BIN3(1,1,0): return(SIZE_LONG);
544: }
545:
546: // Error
547: assert(0);
548: return(0);
549: }
550:
551: //-----------------------------------------------------------------------
552: char *Disass_FindSize_010_011(void)
553: {
554: unsigned short int Size;
555:
556: Size = (OpCode>>6)&0x7;
557: switch(Size) {
558: case BIN3(0,1,0): strcpy(szSizeString,"W"); break;
559: case BIN3(0,1,1): strcpy(szSizeString,"L"); break;
560: }
561:
562: return(szSizeString);
563: }
564: int Disass_EffAddrSize_010_011(void)
565: {
566: unsigned short int Size;
567:
568: Size = (OpCode>>6)&0x7;
569: switch(Size) {
570: case BIN3(0,1,0): return(SIZE_WORD);
571: case BIN3(0,1,1): return(SIZE_LONG);
572: }
573:
574: // Error
575: assert(0);
576: return(0);
577: }
578:
579: //-----------------------------------------------------------------------
580: char *Disass_FindSize_110_111(void)
581: {
582: unsigned short int Size;
583:
584: Size = (OpCode>>6)&0x7;
585: switch(Size) {
586: case BIN3(1,1,0): strcpy(szSizeString,"W"); break;
587: case BIN3(1,1,1): strcpy(szSizeString,"L"); break;
588: }
589:
590: return(szSizeString);
591: }
592:
593: //-----------------------------------------------------------------------
594: char *Disass_FindSize_100_101(void)
595: {
596: unsigned short int Size;
597:
598: Size = (OpCode>>6)&0x7;
599: switch(Size) {
600: case BIN3(1,0,0): strcpy(szSizeString,"W"); break;
601: case BIN3(1,0,1): strcpy(szSizeString,"L"); break;
602: }
603:
604: return(szSizeString);
605: }
606:
607: //-----------------------------------------------------------------------
608: /*
609: NOTE This is ONLY to be used with MOVE instruction, as Size bits are 12,13
610: */
611: char *Disass_FindSize_01_11_10(void)
612: {
613: unsigned short int Size;
614:
615: Size = (OpCode>>12)&0x3;
616: switch(Size) {
617: case BIN2(0,1): strcpy(szSizeString,"B"); break;
618: case BIN2(1,1): strcpy(szSizeString,"W"); break;
619: case BIN2(1,0): strcpy(szSizeString,"L"); break;
620: }
621:
622: return(szSizeString);
623: }
624: int Disass_EffAddrSize_01_11_10(void)
625: {
626: unsigned short int Size;
627:
628: Size = (OpCode>>12)&0x3;
629: switch(Size) {
630: case BIN2(0,1): return(SIZE_BYTE);
631: case BIN2(1,1): return(SIZE_WORD);
632: case BIN2(1,0): return(SIZE_LONG);
633: }
634:
635: // Error
636: assert(0);
637: return(0);
638: }
639:
640: //-----------------------------------------------------------------------
641: /*
642: NOTE This is ONLY to be used with MOVE instruction, as Size bits are 12,13
643: */
644: char *Disass_FindSize_11_10(void)
645: {
646: unsigned short int Size;
647:
648: Size = (OpCode>>12)&0x3;
649: switch(Size) {
650: case BIN2(1,1): strcpy(szSizeString,"W"); break;
651: case BIN2(1,0): strcpy(szSizeString,"L"); break;
652: }
653:
654: return(szSizeString);
655: }
656: int Disass_EffAddrSize_11_10(void)
657: {
658: unsigned short int Size;
659:
660: Size = (OpCode>>12)&0x3;
661: switch(Size) {
662: case BIN2(1,1): return(SIZE_WORD);
663: case BIN2(1,0): return(SIZE_LONG);
664: }
665:
666: // Error
667: assert(0);
668: return(0);
669: }
670:
671: //-----------------------------------------------------------------------
672: /*
673: Find size of MOVEM instruction operands
674: */
675: char *Disass_FindSize_MoveM(void)
676: {
677: if ((OpCode&BIN7(1,0,0,0,0,0,0))==0)
678: sprintf(szSizeString,"W");
679: else
680: sprintf(szSizeString,"L");
681:
682: return(szSizeString);
683: }
684: int Disass_EffAddrSize_MoveM(void)
685: {
686: if ((OpCode&BIN7(1,0,0,0,0,0,0))==0)
687: return(SIZE_WORD);
688: else
689: return(SIZE_LONG);
690: }
691:
692: //-----------------------------------------------------------------------
693: /*
694: Find if access BYTE or LONG according to 'Dn' or other effective address (see BTST etc...)
695: */
696: char *Disass_FindSize_WordOrLong(void)
697: {
698: if (((OpCode>>3)&0x7)==BIN3(0,0,0)) // Dn
699: sprintf(szSizeString,"L");
700: else
701: sprintf(szSizeString,"B");
702:
703: return(szSizeString);
704: }
705: int Disass_EffAddrSize_WordOrLong(void)
706: {
707: if (((OpCode>>3)&0x7)==BIN3(0,0,0)) // Dn
708: return(SIZE_LONG);
709: else
710: return(SIZE_BYTE);
711: }
712:
713: //-----------------------------------------------------------------------
714: /*
715: Read Immediate data after OpCode
716: */
717: char *Disass_ReadImmediate(int Size)
718: {
719: // Clear string, allows easy error check when complete
720: strcpy(szImmString,"");
721:
722: switch(Size) {
723: case SIZE_BYTE:
724: Disass_SignedByteToString(Disass_ReadByte_OddAddr(),szImmString);
725: break;
726: case SIZE_WORD:
727: Disass_SignedWordToString(Disass_ReadWord(),szImmString);
728: break;
729: case SIZE_LONG:
730: Disass_SignedLongToString(Diass_ReadLong(),szImmString);
731: break;
732: }
733:
734: // Check for errors!
735: if (strlen(szImmString)==0) {
736: assert(0);
737: }
738:
739: return(szImmString);
740: }
741:
742: //-----------------------------------------------------------------------
743: /*
744: Find conditon codes using in Bcc,Scc,DBcc etc...
745: */
746: char *Disass_FindCondition(void)
747: {
748: strcpy(szConditionString,pszCC_Strings[(OpCode>>8)&0xf]);
749:
750: return(szConditionString);
751: }
752:
753: //-----------------------------------------------------------------------
754: /*
755: Find register index using bits 9,10,11
756: */
757: int Disass_FindRegister(void)
758: {
759: return((OpCode>>9)&0x7);
760: }
761:
762: // And using bits 0,1,2
763: int Disass_FindRegisterLower(void)
764: {
765: return(OpCode&0x7);
766: }
767:
768: //-----------------------------------------------------------------------
769: /*
770: Find shift count 1,2,3,4...8 from data 0,1,2,3...7
771: */
772: #define Disass_FindQuickData Disass_FindShiftCount // 'Quick' data ie ADDQ uses same process
773: int Disass_FindShiftCount(void)
774: {
775: unsigned short int Count;
776:
777: Count = (OpCode>>9)&0x7;
778: if (Count==0)
779: Count = 8;
780:
781: return(Count);
782: }
783:
784: //-----------------------------------------------------------------------
785: /*
786: Return TRUE is displacement is a signed 8-bit number
787: Used in BRA,BSR,Bcc etc...
788: */
789: BOOL Disass_ShortDisplacement(void)
790: {
791: if ((OpCode&0xff)==0)
792: return(FALSE); // 16-bit offset
793: else
794: return(TRUE); // 8-bit offset
795: }
796:
797: //-----------------------------------------------------------------------
798: /*
799: Convert register mask for MOVEM into string, eg D0123/A167 (D0-D3/A1/A6-A7)
800: */
801: char *Disass_FindMoveMRegisters(unsigned short int MaskW)
802: {
803: char szString[256];
804: int i;
805:
806: // Set 'Dx-Dy/Ax-Ay' string
807: strcpy(szRegString,"");
808: // Is pre-decrement? -(An)
809: if (((OpCode>>3)&0x7)==BIN3(1,0,0)) { // D0..D7/A0..A7
810: if (MaskW&0xff00) { // Any 'D' registers?
811: strcat(szRegString,"D");
812: for(i=0; i<8; i++) {
813: if (MaskW&(0x8000>>i)) {
814: sprintf(szString,"%d",i);
815: strcat(szRegString,szString);
816: }
817: }
818: }
819: if (MaskW&0x00ff) { // Any 'A' registers?
820: // Separate by '/'
821: if (strlen(szRegString)>0)
822: strcat(szRegString,"/");
823:
824: strcat(szRegString,"A");
825: for(i=0; i<8; i++) {
826: if (MaskW&(0x0080>>i)) {
827: sprintf(szString,"%d",i);
828: strcat(szRegString,szString);
829: }
830: }
831: }
832: }
833: else { // A7..A0/D7..D0
834: if (MaskW&0x00ff) { // Any 'D' registers?
835: strcat(szRegString,"D");
836: for(i=0; i<8; i++) {
837: if (MaskW&(0x0001<<i)) {
838: sprintf(szString,"%d",i);
839: strcat(szRegString,szString);
840: }
841: }
842: }
843: if (MaskW&0xff00) { // Any 'A' registers?
844: // Separate by '/'
845: if (strlen(szRegString)>0)
846: strcat(szRegString,"/");
847:
848: strcat(szRegString,"A");
849: for(i=0; i<8; i++) {
850: if (MaskW&(0x0100<<i)) {
851: sprintf(szString,"%d",i);
852: strcat(szRegString,szString);
853: }
854: }
855: }
856: }
857:
858: return(szRegString);
859: }
860:
861:
862:
863: //-----------------------------------------------------------------------
864: /*
865: List of disassembly instruction functions
866: */
867:
868: //-----------------------------------------------------------------------
869: // ABCD Dy,Dx
870: void Disass_ABCD_Dy_Dx(void)
871: {
872: rprintf2( "ABCD.B\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower() );
873: }
874:
875: // ABCD -(Ay),-(Ax)
876: void Disass_ABCD_Ay_Ax(void)
877: {
878: rprintf2( "ABCD.B\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower() );
879: }
880:
881: //-----------------------------------------------------------------------
882: // ADD <ea>,Dn
883: void Disass_ADD_ea_Dn(void)
884: {
885: rprintf3( "ADD.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
886: }
887:
888: // ADD Dn,<ea>
889: void Disass_ADD_Dn_ea(void)
890: {
891: rprintf3( "ADD.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
892: }
893:
894: //-----------------------------------------------------------------------
895: // ADDA <ea>,An
896: void Disass_ADDA(void)
897: {
898: rprintf3( "ADDA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_011_111()),Disass_FindSize_011_111() );
899: }
900:
901: //-----------------------------------------------------------------------
902: // ADDI #<data>,<ea>
903: void Disass_ADDI(void)
904: {
905: rprintf3( "ADDI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
906: }
907:
908: //-----------------------------------------------------------------------
909: // ADDQ #<data>,<ea>
910: void Disass_ADDQ(void)
911: {
912: rprintf3( "ADDQ.%s\t#%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindQuickData(),Disass_FindSize_00_01_10() );
913: }
914:
915: //-----------------------------------------------------------------------
916: // ADDX Dy,Dx
917: void Disass_ADDX_Dy_Dx(void)
918: {
919: rprintf3( "ADDX.%s\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
920: }
921:
922: // ADDX -(Ay),-(Ax)
923: void Disass_ADDX_Ay_Ax(void)
924: {
925: rprintf3( "ADDX.%s\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
926: }
927:
928: //-----------------------------------------------------------------------
929: // AND <ea>,Dn
930: void Disass_AND_ea_Dn(void)
931: {
932: rprintf3( "AND.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
933: }
934:
935: // AND Dn,<ea>
936: void Disass_AND_Dn_ea(void)
937: {
938: rprintf3( "AND.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
939: }
940:
941: //-----------------------------------------------------------------------
942: // ANDI #<data>,<ea>
943: void Disass_ANDI(void)
944: {
945: rprintf3( "ANDI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
946: }
947:
948: //-----------------------------------------------------------------------
949: // AND to CCR #<data>,CCR
950: void Disass_ANDI_to_CCR(void)
951: {
952: rprintf1( "ANDI.B\t#%s,CCR",Disass_ReadImmediate(SIZE_BYTE) );
953: }
954:
955: //-----------------------------------------------------------------------
956: // AND to SR #<data>,SR
957: void Disass_ANDI_to_SR(void)
958: {
959: rprintf1( "ANDI.W\t#%s,SR",Disass_ReadImmediate(SIZE_WORD) );
960: }
961:
962: //-----------------------------------------------------------------------
963: // ASL Dx,Dy
964: void Disass_ASL_Dx_Dy(void)
965: {
966: rprintf3( "ASL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
967: }
968:
969: // ASL #<data>,Dy
970: void Disass_ASL_data_Dy(void)
971: {
972: rprintf3( "ASL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
973: }
974:
975: // ASL <ea>
976: void Disass_ASL(void)
977: {
978: rprintf1( "ASL.W\t%s",Disass_FindEffAddr(NULL) );
979: }
980:
981: //-----------------------------------------------------------------------
982: // ASR Dx,Dy
983: void Disass_ASR_Dx_Dy(void)
984: {
985: rprintf3( "ASR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
986: }
987:
988: // ASR #<data>,Dy
989: void Disass_ASR_data_Dy(void)
990: {
991: rprintf3( "ASR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
992: }
993:
994: // ASR <ea>
995: void Disass_ASR(void)
996: {
997: rprintf1( "ASR.W\t%s",Disass_FindEffAddr(NULL) );
998: }
999:
1000: //-----------------------------------------------------------------------
1001: // Bcc <label>
1002: void Disass_Bcc(void)
1003: {
1004: short int OffsetW;
1005:
1006: if (Disass_ShortDisplacement())
1007: rprintf2( "B%s.S\t$%X",DisPC+(char)OpCode,Disass_FindCondition() );
1008: else {
1009: OffsetW = Disass_ReadWord();
1010: rprintf2( "B%s.W\t$%X",(DisPC-SIZE_WORD)+OffsetW,Disass_FindCondition() );
1011: }
1012: }
1013:
1014: //-----------------------------------------------------------------------
1015: // BCHG Dn,<ea>
1016: void Disass_BCHG(void)
1017: {
1018: rprintf3( "BCHG.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
1019: }
1020:
1021: // BCHG #<data>,<ea>
1022: void Disass_BCHG_imm(void)
1023: {
1024: rprintf3( "BCHG.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
1025: }
1026:
1027: //-----------------------------------------------------------------------
1028: // BCLR Dn,<ea>
1029: void Disass_BCLR(void)
1030: {
1031: rprintf3( "BCLR.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
1032: }
1033:
1034: // BCLR #<data>,<ea>
1035: void Disass_BCLR_imm(void)
1036: {
1037: rprintf3( "BCLR.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
1038: }
1039:
1040: //-----------------------------------------------------------------------
1041: // BRA <label>
1042: void Disass_BRA(void)
1043: {
1044: short int OffsetW;
1045:
1046: if (Disass_ShortDisplacement())
1047: rprintf1( "BRA.S\t$%X",DisPC+(char)OpCode );
1048: else {
1049: OffsetW = Disass_ReadWord();
1050: rprintf1( "BRA.W\t$%X",(DisPC-SIZE_WORD)+OffsetW );
1051: }
1052: }
1053:
1054: //-----------------------------------------------------------------------
1055: // BSET Dn,<ea>
1056: void Disass_BSET(void)
1057: {
1058: rprintf3( "BSET.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
1059: }
1060:
1061: // BSET #<data>,<ea>
1062: void Disass_BSET_imm(void)
1063: {
1064: rprintf3( "BSET.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
1065: }
1066:
1067: //-----------------------------------------------------------------------
1068: // BSR <label>
1069: void Disass_BSR(void)
1070: {
1071: short int OffsetW;
1072:
1073: if (Disass_ShortDisplacement())
1074: rprintf1( "BSR.S\t$%X",DisPC+(char)OpCode );
1075: else {
1076: OffsetW = Disass_ReadWord();
1077: rprintf1( "BSR.W\t$%X",(DisPC-SIZE_WORD)+OffsetW );
1078: }
1079: }
1080:
1081: //-----------------------------------------------------------------------
1082: // BTST Dn,<ea>
1083: void Disass_BTST(void)
1084: {
1085: rprintf3( "BTST.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_FindRegister(),Disass_FindSize_WordOrLong() );
1086: }
1087:
1088: // BTST #<data>,<ea>
1089: void Disass_BTST_imm(void)
1090: {
1091: rprintf3( "BTST.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_WordOrLong()),Disass_ReadImmediate(SIZE_BYTE),Disass_FindSize_WordOrLong() );
1092: }
1093:
1094: //-----------------------------------------------------------------------
1095: // CHK <ea>,Dn
1096: void Disass_CHK(void)
1097: {
1098: rprintf2( "CHK.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
1099: }
1100:
1101: //-----------------------------------------------------------------------
1102: // CLR <ea>
1103: void Disass_CLR(void)
1104: {
1105: rprintf2( "CLR.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1106: }
1107:
1108: //-----------------------------------------------------------------------
1109: // CMP <ea>,Dn
1110: void Disass_CMP(void)
1111: {
1112: rprintf3( "CMP.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
1113: }
1114:
1115: //-----------------------------------------------------------------------
1116: // CMPA <ea>,An
1117: void Disass_CMPA(void)
1118: {
1119: rprintf3( "CMPA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_011_111()),Disass_FindSize_011_111() );
1120: }
1121:
1122: //-----------------------------------------------------------------------
1123: // CMPI #<data>,<ea>
1124: void Disass_CMPI(void)
1125: {
1126: rprintf3( "CMPI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1127: }
1128:
1129: //-----------------------------------------------------------------------
1130: // CMPM (Ay)+,(Ax)+
1131: void Disass_CMPM(void)
1132: {
1133: rprintf3( "CMPM.%s\t(A%d)+,(A%d)+",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
1134: }
1135:
1136: //-----------------------------------------------------------------------
1137: // DBcc Dn,<label>
1138: void Disass_DBcc(void)
1139: {
1140: short int OffsetW;
1141:
1142: OffsetW = Disass_ReadWord();
1143: rprintf3( "DB%s.W\tD%d,$%X",(DisPC-SIZE_WORD)+OffsetW,Disass_FindRegisterLower(),Disass_FindCondition() );
1144: }
1145:
1146: //-----------------------------------------------------------------------
1147: // DIVS <ea>,Dn
1148: void Disass_DIVS(void)
1149: {
1150: rprintf2( "DIVS.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
1151: }
1152:
1153: //-----------------------------------------------------------------------
1154: // DIVU <ea>,Dn
1155: void Disass_DIVU(void)
1156: {
1157: rprintf2( "DIVU.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
1158: }
1159:
1160: //-----------------------------------------------------------------------
1161: // EOR Dn,<ea>
1162: void Disass_EOR(void)
1163: {
1164: rprintf3( "EOR.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindSize_100_101_110() );
1165: }
1166:
1167: //-----------------------------------------------------------------------
1168: // EORI #<data>,Dn
1169: void Disass_EORI(void)
1170: {
1171: rprintf3( "EORI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1172: }
1173:
1174: //-----------------------------------------------------------------------
1175: // EOR to CCR #<data>,CCR
1176: void Disass_EORI_to_CCR(void)
1177: {
1178: rprintf1( "EORI.B\t#%s,CCR",Disass_ReadImmediate(SIZE_BYTE) );
1179: }
1180:
1181: //-----------------------------------------------------------------------
1182: // EOR to SR #<data>,SR
1183: void Disass_EORI_to_SR(void)
1184: {
1185: rprintf1( "EORI.W\t#%s,SR",Disass_ReadImmediate(SIZE_WORD) );
1186: }
1187:
1188: //-----------------------------------------------------------------------
1189: // EXG Dx,Dy
1190: void Disass_EXG_Dx_Dy(void)
1191: {
1192: rprintf2( "EXG.L\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister() );
1193: }
1194:
1195: // EXG Ax,Ay
1196: void Disass_EXG_Ax_Ay(void)
1197: {
1198: rprintf2( "EXG.L\tA%d,A%d",Disass_FindRegisterLower(),Disass_FindRegister() );
1199: }
1200:
1201: // EXG Dx,Ay
1202: void Disass_EXG_Dx_Ay(void)
1203: {
1204: rprintf2( "EXG.L\tD%d,A%d",Disass_FindRegisterLower(),Disass_FindRegister() );
1205: }
1206:
1207: //-----------------------------------------------------------------------
1208: // EXT Dn
1209: void Disass_EXT(void)
1210: {
1211: rprintf2( "EXT.%s\tD%d",Disass_FindRegisterLower(),Disass_FindSize_010_011() );
1212: }
1213:
1214: //-----------------------------------------------------------------------
1215: // ILLEGAL
1216: void Disass_ILLEGAL(void)
1217: {
1218: rprintf0( "ILLEGAL" );
1219: }
1220:
1221: //-----------------------------------------------------------------------
1222: // JMP <ea>
1223: void Disass_JMP(void)
1224: {
1225: rprintf1( "JMP\t%s",Disass_FindEffAddr(NULL) );
1226: }
1227:
1228: //-----------------------------------------------------------------------
1229: // JSR <ea>
1230: void Disass_JSR(void)
1231: {
1232: rprintf1( "JSR\t%s",Disass_FindEffAddr(NULL) );
1233: }
1234:
1235: //-----------------------------------------------------------------------
1236: // LEA <ea>,An
1237: void Disass_LEA(void)
1238: {
1239: rprintf2( "LEA\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_LONG) );
1240: }
1241:
1242: //-----------------------------------------------------------------------
1243: // LINK An,#<displacement>
1244: void Disass_LINK(void)
1245: {
1246: unsigned short int OffsetW;
1247:
1248: OffsetW = Disass_ReadWord();
1249: rprintf2( "LINK\tA%d,#%s",Disass_WordToString(OffsetW),Disass_FindRegisterLower() );
1250: }
1251:
1252: //-----------------------------------------------------------------------
1253: // LSL Dx,Dy
1254: void Disass_LSL_Dx_Dy(void)
1255: {
1256: rprintf3( "LSL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
1257: }
1258:
1259: // LSL #<data>,Dy
1260: void Disass_LSL_data_Dy(void)
1261: {
1262: rprintf3( "LSL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
1263: }
1264:
1265: // LSL <ea>
1266: void Disass_LSL(void)
1267: {
1268: rprintf1( "LSL.W\t%s",Disass_FindEffAddr(NULL) );
1269: }
1270:
1271: //-----------------------------------------------------------------------
1272: // LSR Dx,Dy
1273: void Disass_LSR_Dx_Dy(void)
1274: {
1275: rprintf3( "LSR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
1276: }
1277:
1278: // LSR #<data>,Dy
1279: void Disass_LSR_data_Dy(void)
1280: {
1281: rprintf3( "LSR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
1282: }
1283:
1284: // LSR <ea>
1285: void Disass_LSR(void)
1286: {
1287: rprintf1( "LSR.W\t%s",Disass_FindEffAddr(NULL) );
1288: }
1289:
1290: //-----------------------------------------------------------------------
1291: // MOVE <ea>,<ea>
1292: void Disass_MOVE(void)
1293: {
1294: rprintf3( "MOVE.%s\t%s,%s",Disass_FindUpperEffAddr(Disass_EffAddrSize_01_11_10()),Disass_FindEffAddr(Disass_EffAddrSize_01_11_10()),Disass_FindSize_01_11_10() );
1295: }
1296:
1297: //-----------------------------------------------------------------------
1298: // MOVEA <ea>,An
1299: void Disass_MOVEA(void)
1300: {
1301: rprintf3( "MOVEA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_11_10()),Disass_FindSize_11_10() );
1302: }
1303:
1304: //-----------------------------------------------------------------------
1305: // MOVE CCR,<ea>
1306: void Disass_MOVE_from_CCR(void)
1307: {
1308: rprintf1( "MOVE.W\tCCR,%s",Disass_FindEffAddr(SIZE_WORD) );
1309: }
1310:
1311: //-----------------------------------------------------------------------
1312: // MOVE <ea>,CCR
1313: void Disass_MOVE_to_CCR(void)
1314: {
1315: rprintf1( "MOVE.W\t%s,CCR",Disass_FindEffAddr(SIZE_WORD) );
1316: }
1317:
1318: //-----------------------------------------------------------------------
1319: // MOVE SR,<ea>
1320: void Disass_MOVE_from_SR(void)
1321: {
1322: rprintf1( "MOVE.W\tSR,%s",Disass_FindEffAddr(SIZE_WORD) );
1323: }
1324:
1325: //-----------------------------------------------------------------------
1326: // MOVE <ea>,SR
1327: void Disass_MOVE_to_SR(void)
1328: {
1329: rprintf1( "MOVE.W\t%s,SR",Disass_FindEffAddr(SIZE_WORD) );
1330: }
1331:
1332: //-----------------------------------------------------------------------
1333: // MOVE USP,An
1334: void Disass_MOVE_USP_An(void)
1335: {
1336: rprintf1( "MOVE.L\tUSP,A%d",Disass_FindRegisterLower() );
1337: }
1338:
1339: // MOVE An,USP
1340: void Disass_MOVE_An_USP(void)
1341: {
1342: rprintf1( "MOVE.L\tA%d,USP",Disass_FindRegisterLower() );
1343: }
1344:
1345: //-----------------------------------------------------------------------
1346: // MOVEM regs,<ea>
1347: void Disass_MOVEM_regs_ea(void)
1348: {
1349: unsigned short int MaskW;
1350:
1351: MaskW = Disass_ReadWord();
1352: rprintf3( "MOVEM.%s\t%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_MoveM()),Disass_FindMoveMRegisters(MaskW),Disass_FindSize_MoveM() );
1353: }
1354:
1355: // MOVEM <ea>,regs
1356: void Disass_MOVEM_ea_regs(void)
1357: {
1358: unsigned short int MaskW;
1359:
1360: MaskW = Disass_ReadWord();
1361: rprintf3( "MOVEM.%s\t%s,%s",Disass_FindMoveMRegisters(MaskW),Disass_FindEffAddr(Disass_EffAddrSize_MoveM()),Disass_FindSize_MoveM() );
1362: }
1363:
1364: //-----------------------------------------------------------------------
1365: // MOVEP Dx,(d,Ay)
1366: void Disass_MOVEP_Dn_An(void)
1367: {
1368: rprintf4( "MOVEP.%s\tD%d,%s(A%d)",Disass_FindRegisterLower(),Disass_ReadImmediate(SIZE_WORD),Disass_FindRegister(),Disass_FindSize_110_111() );
1369: }
1370:
1371: // MOVEP (d,Ay),Dx
1372: void Disass_MOVEP_An_Dn(void)
1373: {
1374: rprintf4( "MOVEP.%s\t%s(A%d),D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_ReadImmediate(SIZE_WORD),Disass_FindSize_100_101() );
1375: }
1376:
1377: //-----------------------------------------------------------------------
1378: // MOVEQ #<data>,Dn
1379: void Disass_MOVEQ(void)
1380: {
1381: rprintf2( "MOVEQ.L\t#%d,D%d",Disass_FindRegister(),(char)OpCode );
1382: }
1383:
1384: //-----------------------------------------------------------------------
1385: // MULS <ea>,Dn
1386: void Disass_MULS(void)
1387: {
1388: rprintf2( "MULS.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
1389: }
1390:
1391: //-----------------------------------------------------------------------
1392: // MULU <ea>,Dn
1393: void Disass_MULU(void)
1394: {
1395: rprintf2( "MULU.W\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(SIZE_WORD) );
1396: }
1397:
1398: //-----------------------------------------------------------------------
1399: // NBCD <ea>
1400: void Disass_NBCD(void)
1401: {
1402: rprintf1( "NBCD.B\t%s",Disass_FindEffAddr(SIZE_BYTE) );
1403: }
1404:
1405: //-----------------------------------------------------------------------
1406: // NEG <ea>
1407: void Disass_NEG(void)
1408: {
1409: rprintf2( "NEG.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1410: }
1411:
1412: //-----------------------------------------------------------------------
1413: // NEGX <ea>
1414: void Disass_NEGX(void)
1415: {
1416: rprintf2( "NEGX.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1417: }
1418:
1419: //-----------------------------------------------------------------------
1420: // NOP
1421: void Disass_NOP(void)
1422: {
1423: rprintf0( "NOP" );
1424: }
1425:
1426: //-----------------------------------------------------------------------
1427: // NOT <ea>
1428: void Disass_NOT(void)
1429: {
1430: rprintf2( "NOT.%s\t%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1431: }
1432:
1433: //-----------------------------------------------------------------------
1434: // OR <ea>,Dn
1435: void Disass_OR_ea_Dn(void)
1436: {
1437: rprintf3( "OR.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
1438: }
1439:
1440: // OR Dn,<ea>
1441: void Disass_OR_Dn_ea(void)
1442: {
1443: rprintf3( "OR.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
1444: }
1445:
1446: //-----------------------------------------------------------------------
1447: // ORI #<data>,<ea>
1448: void Disass_ORI(void)
1449: {
1450: rprintf3( "ORI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1451: }
1452:
1453: //-----------------------------------------------------------------------
1454: // OR to CCR #<data>,CCR
1455: void Disass_ORI_to_CCR(void)
1456: {
1457: rprintf1( "ORI.B\t#%s,CCR",Disass_ReadImmediate(SIZE_BYTE) );
1458: }
1459:
1460: //-----------------------------------------------------------------------
1461: // OR to SR #<data>,SR
1462: void Disass_ORI_to_SR(void)
1463: {
1464: rprintf1( "ORI.W\t#%s,SR",Disass_ReadImmediate(SIZE_WORD) );
1465: }
1466:
1467: //-----------------------------------------------------------------------
1468: // PEA <ea>
1469: void Disass_PEA(void)
1470: {
1471: rprintf1( "PEA.L\t%s",Disass_FindEffAddr(SIZE_LONG) );
1472: }
1473:
1474: //-----------------------------------------------------------------------
1475: // RESET
1476: void Disass_RESET(void)
1477: {
1478: rprintf0( "RESET" );
1479: }
1480:
1481: //-----------------------------------------------------------------------
1482: // ROL Dx,Dy
1483: void Disass_ROL_Dx_Dy(void)
1484: {
1485: rprintf3( "ROL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
1486: }
1487:
1488: // ROL #<data>,Dy
1489: void Disass_ROL_data_Dy(void)
1490: {
1491: rprintf3( "ROL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
1492: }
1493:
1494: // ROL <ea>
1495: void Disass_ROL(void)
1496: {
1497: rprintf1( "ROL.W\t%s",Disass_FindEffAddr(NULL) );
1498: }
1499:
1500: //-----------------------------------------------------------------------
1501: // ROR Dx,Dy
1502: void Disass_ROR_Dx_Dy(void)
1503: {
1504: rprintf3( "ROR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
1505: }
1506:
1507: // ROR #<data>,Dy
1508: void Disass_ROR_data_Dy(void)
1509: {
1510: rprintf3( "ROR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
1511: }
1512:
1513: // ROR <ea>
1514: void Disass_ROR(void)
1515: {
1516: rprintf1( "ROR.W\t%s",Disass_FindEffAddr(NULL) );
1517: }
1518:
1519: //-----------------------------------------------------------------------
1520: // ROXL Dx,Dy
1521: void Disass_ROXL_Dx_Dy(void)
1522: {
1523: rprintf3( "ROXL.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
1524: }
1525:
1526: // ROXL #<data>,Dy
1527: void Disass_ROXL_data_Dy(void)
1528: {
1529: rprintf3( "ROXL.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
1530: }
1531:
1532: // ROXL <ea>
1533: void Disass_ROXL(void)
1534: {
1535: rprintf1( "ROXL.W\t%s",Disass_FindEffAddr(NULL) );
1536: }
1537:
1538: //-----------------------------------------------------------------------
1539: // ROXR Dx,Dy
1540: void Disass_ROXR_Dx_Dy(void)
1541: {
1542: rprintf3( "ROXR.%s\tD%d,D%d",Disass_FindRegisterLower(),Disass_FindRegister(),Disass_FindSize_00_01_10() );
1543: }
1544:
1545: // ROXR #<data>,Dy
1546: void Disass_ROXR_data_Dy(void)
1547: {
1548: rprintf3( "ROXR.%s\t#%s,D%d",Disass_FindRegisterLower(),Disass_WordToString(Disass_FindShiftCount()),Disass_FindSize_00_01_10() );
1549: }
1550:
1551: // ROXR <ea>
1552: void Disass_ROXR(void)
1553: {
1554: rprintf1( "ROXR.W\t%s",Disass_FindEffAddr(NULL) );
1555: }
1556:
1557: //-----------------------------------------------------------------------
1558: // RTE
1559: void Disass_RTE(void)
1560: {
1561: rprintf0( "RTE" );
1562: }
1563:
1564: //-----------------------------------------------------------------------
1565: // RTR
1566: void Disass_RTR(void)
1567: {
1568: rprintf0( "RTR" );
1569: }
1570:
1571: //-----------------------------------------------------------------------
1572: // RTS
1573: void Disass_RTS(void)
1574: {
1575: rprintf0( "RTS" );
1576: }
1577:
1578: //-----------------------------------------------------------------------
1579: // SBCD Dy,Dx
1580: void Disass_SBCD_Dy_Dx(void)
1581: {
1582: rprintf2( "SBCD.B\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower() );
1583: }
1584:
1585: // SBCD -(Ay),-(Ax)
1586: void Disass_SBCD_Ay_Ax(void)
1587: {
1588: rprintf2( "SBCD.B\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower() );
1589: }
1590:
1591: //-----------------------------------------------------------------------
1592: // Scc <ea>
1593: void Disass_Scc(void)
1594: {
1595: rprintf2( "S%s.B\t%s",Disass_FindEffAddr(SIZE_BYTE),Disass_FindCondition() );
1596: }
1597:
1598: //-----------------------------------------------------------------------
1599: // STOP #<data>
1600: void Disass_STOP(void)
1601: {
1602: rprintf1( "STOP\t#%s",Disass_ReadImmediate(SIZE_WORD) );
1603: }
1604:
1605: //-----------------------------------------------------------------------
1606: // SUB <ea>,Dn
1607: void Disass_SUB_ea_Dn(void)
1608: {
1609: rprintf3( "SUB.%s\t%s,D%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_000_001_010()),Disass_FindSize_000_001_010() );
1610: }
1611:
1612: // SUB Dn,<ea>
1613: void Disass_SUB_Dn_ea(void)
1614: {
1615: rprintf3( "SUB.%s\tD%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_100_101_110()),Disass_FindRegister(),Disass_FindSize_100_101_110() );
1616: }
1617:
1618: //-----------------------------------------------------------------------
1619: // SUBA <ea>,An
1620: void Disass_SUBA(void)
1621: {
1622: rprintf3( "SUBA.%s\t%s,A%d",Disass_FindRegister(),Disass_FindEffAddr(Disass_EffAddrSize_011_111()),Disass_FindSize_011_111() );
1623: }
1624:
1625: //-----------------------------------------------------------------------
1626: // SUBI #<data>,<ea>
1627: void Disass_SUBI(void)
1628: {
1629: rprintf3( "SUBI.%s\t#%s,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_ReadImmediate(Disass_EffAddrSize_00_01_10()),Disass_FindSize_00_01_10() );
1630: }
1631:
1632: //-----------------------------------------------------------------------
1633: // SUBQ #<data>,<ea>
1634: void Disass_SUBQ(void)
1635: {
1636: rprintf3( "SUBQ.%s\t#%d,%s",Disass_FindEffAddr(Disass_EffAddrSize_00_01_10()),Disass_FindQuickData(),Disass_FindSize_00_01_10() );
1637: }
1638:
1639: //-----------------------------------------------------------------------
1640: // SUBX Dy,Dx
1641: void Disass_SUBX_Dy_Dx(void)
1642: {
1643: rprintf3( "SUBX.%s\tD%d,D%d",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
1644: }
1645:
1646: // SUBX -(Ay),-(Ax)
1647: void Disass_SUBX_Ay_Ax(void)
1648: {
1649: rprintf3( "SUBX.%s\t-(A%d),-(A%d)",Disass_FindRegister(),Disass_FindRegisterLower(),Disass_FindSize_00_01_10() );
1650: }
1651:
1652: //-----------------------------------------------------------------------
1653: // SWAP Dn
1654: void Disass_SWAP(void)
1655: {
1656: rprintf1( "SWAP.W\tD%d",Disass_FindRegisterLower() );
1657: }
1658:
1659: //-----------------------------------------------------------------------
1660: // TAS <ea>
1661: void Disass_TAS(void)
1662: {
1663: rprintf1( "TAS.B\t%s",Disass_FindEffAddr(SIZE_BYTE) );
1664: }
1665:
1666: //-----------------------------------------------------------------------
1667: // TRAP #<vector>
1668: void Disass_TRAP(void)
1669: {
1670: rprintf1( "TRAP\t#%d",OpCode&0xf );
1671: }
1672:
1673: //-----------------------------------------------------------------------
1674: // TRAPV
1675: void Disass_TRAPV(void)
1676: {
1677: rprintf0( "TRAPV" );
1678: }
1679:
1680: //-----------------------------------------------------------------------
1681: // TST <ea>
1682: void Disass_TST(void)
1683: {
1684: rprintf2( "TST.%s\t%s",Disass_FindEffAddr(SIZE_BYTE),Disass_FindSize_00_01_10() );
1685: }
1686:
1687: //-----------------------------------------------------------------------
1688: // UNLK An
1689: void Disass_UNLK(void)
1690: {
1691: rprintf1( "UNLK\tA%d",Disass_FindRegisterLower() );
1692: }
1693:
1694:
1695:
1696: //-----------------------------------------------------------------------
1697: /*
1698: Disassemble from 'DisPC' program counter to 'szOpData', update DisPC
1699: Return TRUE if instruction was valid
1700: */
1701: BOOL Disass_DiassembleLine(void)
1702: {
1703: void *pFunc;
1704: int OpCodeIndex;
1705:
1706: // Clear OpCode data
1707: strcpy(szOpData,"");
1708:
1709: // Read 'Opcode'
1710: OpCode = Disass_ReadWord();
1711:
1712: // Look up disassembly function
1713: OpCodeIndex = STMemory_Swap68000Int(OpCode)*SIZEOF_DECODE;
1714: pFunc = (void *)DecodeTable[OpCodeIndex+(DECODE_DISASS/sizeof(long))];
1715: if (pFunc) {
1716: CALL_VAR(pFunc); // Disassemble
1717: return(TRUE);
1718: }
1719: else {
1720: strcpy(szOpString,"----"); // Not an instruction
1721: return(FALSE);
1722: }
1723: }
1724:
1725: #endif //USE_DEBUGGER
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.