139 |
|
{ i_CPUSHA, "CPUSHA" }, |
140 |
|
{ i_MOVE16, "MOVE16" }, |
141 |
|
|
142 |
+ |
{ i_EMULOP_RETURN, "EMULOP_RETURN" }, |
143 |
+ |
{ i_EMULOP, "EMULOP" }, |
144 |
+ |
|
145 |
|
{ i_MMUOP, "MMUOP" }, |
146 |
|
{ i_ILLG, "" }, |
147 |
|
}; |
198 |
|
int variants; |
199 |
|
struct instr_def id; |
200 |
|
const char *opcstr; |
201 |
< |
int i; |
201 |
> |
int i, n; |
202 |
|
|
203 |
|
int flaglive = 0, flagdead = 0; |
204 |
+ |
int cflow = 0; |
205 |
|
|
206 |
|
id = defs68k[insn]; |
207 |
|
|
208 |
+ |
// Control flow information |
209 |
+ |
cflow = id.cflow; |
210 |
+ |
|
211 |
+ |
// Mask of flags set/used |
212 |
+ |
unsigned char flags_set(0), flags_used(0); |
213 |
+ |
|
214 |
+ |
for (i = 0, n = 4; i < 5; i++, n--) { |
215 |
+ |
switch (id.flaginfo[i].flagset) { |
216 |
+ |
case fa_unset: case fa_isjmp: break; |
217 |
+ |
default: flags_set |= (1 << n); |
218 |
+ |
} |
219 |
+ |
|
220 |
+ |
switch (id.flaginfo[i].flaguse) { |
221 |
+ |
case fu_unused: case fu_isjmp: break; |
222 |
+ |
default: flags_used |= (1 << n); |
223 |
+ |
} |
224 |
+ |
} |
225 |
+ |
|
226 |
|
for (i = 0; i < 5; i++) { |
227 |
|
switch (id.flaginfo[i].flagset){ |
228 |
|
case fa_unset: break; |
207 |
– |
case fa_isjmp: break; |
229 |
|
case fa_zero: flagdead |= 1 << i; break; |
230 |
|
case fa_one: flagdead |= 1 << i; break; |
231 |
|
case fa_dontcare: flagdead |= 1 << i; break; |
238 |
|
for (i = 0; i < 5; i++) { |
239 |
|
switch (id.flaginfo[i].flaguse) { |
240 |
|
case fu_unused: break; |
220 |
– |
case fu_isjmp: flaglive |= 1 << i; break; |
221 |
– |
case fu_maybecc: flaglive |= 1 << i; break; |
241 |
|
case fu_unknown: flaglive = -1; goto out2; |
242 |
|
case fu_used: flaglive |= 1 << i; break; |
243 |
|
} |
255 |
|
int pos = 0; |
256 |
|
int mnp = 0; |
257 |
|
int bitno = 0; |
258 |
< |
char mnemonic[10]; |
258 |
> |
char mnemonic[64]; |
259 |
|
|
260 |
|
wordsizes sz = sz_long; |
261 |
|
int srcgather = 0, dstgather = 0; |
292 |
|
continue; |
293 |
|
if (bitcnt[bitI] && (bitval[bitI] == 0x00 || bitval[bitI] == 0xff)) |
294 |
|
continue; |
295 |
+ |
if (bitcnt[bitE] && (bitval[bitE] == 0x00)) |
296 |
+ |
continue; |
297 |
|
|
298 |
|
/* bitI and bitC get copied to biti and bitc */ |
299 |
|
if (bitcnt[bitI]) { |
332 |
|
} |
333 |
|
} |
334 |
|
mnp++; |
335 |
+ |
if ((unsigned)mnp >= sizeof(mnemonic) - 1) { |
336 |
+ |
mnemonic[sizeof(mnemonic) - 1] = 0; |
337 |
+ |
fprintf(stderr, "Instruction %s overflow\n", mnemonic); |
338 |
+ |
abort(); |
339 |
+ |
} |
340 |
|
} |
341 |
|
pos++; |
342 |
|
} |
422 |
|
srcpos = bitpos[bitK]; |
423 |
|
} |
424 |
|
break; |
425 |
+ |
case 'E': srcmode = immi; srcreg = bitval[bitE]; |
426 |
+ |
if (CPU_EMU_SIZE < 5) { // gb-- what is CPU_EMU_SIZE used for ?? |
427 |
+ |
/* 1..255 */ |
428 |
+ |
srcgather = 1; |
429 |
+ |
srctype = 6; |
430 |
+ |
srcpos = bitpos[bitE]; |
431 |
+ |
} |
432 |
+ |
break; |
433 |
|
case 'p': srcmode = immi; srcreg = bitval[bitp]; |
434 |
|
if (CPU_EMU_SIZE < 5) { |
435 |
|
/* 0..3 */ |
753 |
|
table68k[opc].flaginfo[i].flaguse = id.flaginfo[i].flaguse; |
754 |
|
} |
755 |
|
#endif |
756 |
+ |
|
757 |
+ |
// Fix flags used information for Scc, Bcc, TRAPcc, DBcc instructions |
758 |
+ |
if ( table68k[opc].mnemo == i_Scc |
759 |
+ |
|| table68k[opc].mnemo == i_Bcc |
760 |
+ |
|| table68k[opc].mnemo == i_DBcc |
761 |
+ |
|| table68k[opc].mnemo == i_TRAPcc |
762 |
+ |
) { |
763 |
+ |
switch (table68k[opc].cc) { |
764 |
+ |
// CC mask: XNZVC |
765 |
+ |
// 8421 |
766 |
+ |
case 0: flags_used = 0x00; break; /* T */ |
767 |
+ |
case 1: flags_used = 0x00; break; /* F */ |
768 |
+ |
case 2: flags_used = 0x05; break; /* HI */ |
769 |
+ |
case 3: flags_used = 0x05; break; /* LS */ |
770 |
+ |
case 4: flags_used = 0x01; break; /* CC */ |
771 |
+ |
case 5: flags_used = 0x01; break; /* CS */ |
772 |
+ |
case 6: flags_used = 0x04; break; /* NE */ |
773 |
+ |
case 7: flags_used = 0x04; break; /* EQ */ |
774 |
+ |
case 8: flags_used = 0x02; break; /* VC */ |
775 |
+ |
case 9: flags_used = 0x02; break; /* VS */ |
776 |
+ |
case 10:flags_used = 0x08; break; /* PL */ |
777 |
+ |
case 11:flags_used = 0x08; break; /* MI */ |
778 |
+ |
case 12:flags_used = 0x0A; break; /* GE */ |
779 |
+ |
case 13:flags_used = 0x0A; break; /* LT */ |
780 |
+ |
case 14:flags_used = 0x0E; break; /* GT */ |
781 |
+ |
case 15:flags_used = 0x0E; break; /* LE */ |
782 |
+ |
} |
783 |
+ |
} |
784 |
+ |
|
785 |
+ |
#if 1 |
786 |
+ |
/* gb-- flagdead and flaglive would not have correct information */ |
787 |
+ |
table68k[opc].flagdead = flags_set; |
788 |
+ |
table68k[opc].flaglive = flags_used; |
789 |
+ |
#else |
790 |
|
table68k[opc].flagdead = flagdead; |
791 |
|
table68k[opc].flaglive = flaglive; |
792 |
+ |
#endif |
793 |
+ |
table68k[opc].cflow = cflow; |
794 |
|
nomatch: |
795 |
|
/* FOO! */; |
796 |
|
} |
836 |
|
smsk = 7; sbitdst = 8; break; |
837 |
|
case 5: |
838 |
|
smsk = 63; sbitdst = 64; break; |
839 |
+ |
case 6: |
840 |
+ |
smsk = 255; sbitdst = 256; break; |
841 |
|
case 7: |
842 |
|
smsk = 3; sbitdst = 4; break; |
843 |
|
default: |
908 |
|
{ |
909 |
|
return mismatch; |
910 |
|
} |
911 |
+ |
|
912 |
+ |
const char *get_instruction_name (unsigned int opcode) |
913 |
+ |
{ |
914 |
+ |
struct instr *ins = &table68k[opcode]; |
915 |
+ |
for (int i = 0; lookuptab[i].name[0]; i++) { |
916 |
+ |
if (ins->mnemo == lookuptab[i].mnemo) |
917 |
+ |
return lookuptab[i].name; |
918 |
+ |
} |
919 |
+ |
abort(); |
920 |
+ |
return NULL; |
921 |
+ |
} |
922 |
+ |
|
923 |
+ |
static char *get_ea_string (amodes mode, wordsizes size) |
924 |
+ |
{ |
925 |
+ |
static char buffer[80]; |
926 |
+ |
|
927 |
+ |
buffer[0] = 0; |
928 |
+ |
switch (mode){ |
929 |
+ |
case Dreg: |
930 |
+ |
strcpy (buffer,"Dn"); |
931 |
+ |
break; |
932 |
+ |
case Areg: |
933 |
+ |
strcpy (buffer,"An"); |
934 |
+ |
break; |
935 |
+ |
case Aind: |
936 |
+ |
strcpy (buffer,"(An)"); |
937 |
+ |
break; |
938 |
+ |
case Aipi: |
939 |
+ |
strcpy (buffer,"(An)+"); |
940 |
+ |
break; |
941 |
+ |
case Apdi: |
942 |
+ |
strcpy (buffer,"-(An)"); |
943 |
+ |
break; |
944 |
+ |
case Ad16: |
945 |
+ |
strcpy (buffer,"(d16,An)"); |
946 |
+ |
break; |
947 |
+ |
case Ad8r: |
948 |
+ |
strcpy (buffer,"(d8,An,Xn)"); |
949 |
+ |
break; |
950 |
+ |
case PC16: |
951 |
+ |
strcpy (buffer,"(d16,PC)"); |
952 |
+ |
break; |
953 |
+ |
case PC8r: |
954 |
+ |
strcpy (buffer,"(d8,PC,Xn)"); |
955 |
+ |
break; |
956 |
+ |
case absw: |
957 |
+ |
strcpy (buffer,"(xxx).W"); |
958 |
+ |
break; |
959 |
+ |
case absl: |
960 |
+ |
strcpy (buffer,"(xxx).L"); |
961 |
+ |
break; |
962 |
+ |
case imm: |
963 |
+ |
switch (size){ |
964 |
+ |
case sz_byte: |
965 |
+ |
strcpy (buffer,"#<data>.B"); |
966 |
+ |
break; |
967 |
+ |
case sz_word: |
968 |
+ |
strcpy (buffer,"#<data>.W"); |
969 |
+ |
break; |
970 |
+ |
case sz_long: |
971 |
+ |
strcpy (buffer,"#<data>.L"); |
972 |
+ |
break; |
973 |
+ |
default: |
974 |
+ |
break; |
975 |
+ |
} |
976 |
+ |
break; |
977 |
+ |
case imm0: |
978 |
+ |
strcpy (buffer,"#<data>.B"); |
979 |
+ |
break; |
980 |
+ |
case imm1: |
981 |
+ |
strcpy (buffer,"#<data>.W"); |
982 |
+ |
break; |
983 |
+ |
case imm2: |
984 |
+ |
strcpy (buffer,"#<data>.L"); |
985 |
+ |
break; |
986 |
+ |
case immi: |
987 |
+ |
strcpy (buffer,"#<data>"); |
988 |
+ |
break; |
989 |
+ |
|
990 |
+ |
default: |
991 |
+ |
break; |
992 |
+ |
} |
993 |
+ |
return buffer; |
994 |
+ |
} |
995 |
+ |
|
996 |
+ |
const char *get_instruction_string (unsigned int opcode) |
997 |
+ |
{ |
998 |
+ |
static char out[100]; |
999 |
+ |
struct instr *ins; |
1000 |
+ |
|
1001 |
+ |
strcpy (out, get_instruction_name (opcode)); |
1002 |
+ |
|
1003 |
+ |
ins = &table68k[opcode]; |
1004 |
+ |
if (ins->size == sz_byte) |
1005 |
+ |
strcat (out,".B"); |
1006 |
+ |
if (ins->size == sz_word) |
1007 |
+ |
strcat (out,".W"); |
1008 |
+ |
if (ins->size == sz_long) |
1009 |
+ |
strcat (out,".L"); |
1010 |
+ |
strcat (out," "); |
1011 |
+ |
if (ins->suse) |
1012 |
+ |
strcat (out, get_ea_string (ins->smode, ins->size)); |
1013 |
+ |
if (ins->duse) { |
1014 |
+ |
if (ins->suse) |
1015 |
+ |
strcat (out,","); |
1016 |
+ |
strcat (out, get_ea_string (ins->dmode, ins->size)); |
1017 |
+ |
} |
1018 |
+ |
return out; |
1019 |
+ |
} |