![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gencpu.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to gencpu.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * MC68000 emulation generator
5: *
6: * This is a fairly stupid program that generates a lot of case labels that
7: * can be #included in a switch statement.
8: * As an alternative, it can generate functions that handle specific
9: * MC68000 instructions, plus a prototype header file and a function pointer
10: * array to look up the function for an opcode.
11: * Error checking is bad, an illegal table68k file will cause the program to
12: * call abort().
13: * The generated code is sometimes sub-optimal, an optimizing compiler should
14: * take care of this.
15: *
16: * Copyright 1995, 1996 Bernd Schmidt
17: */
18:
19: #include "sysconfig.h"
20: #include "sysdeps.h"
21: #include <ctype.h>
22:
23: #include "config.h"
24: #include "options.h"
25: #include "readcpu.h"
26:
27: #define BOOL_TYPE "int"
28:
29: static long int counts[65536];
30:
31: static int isspecific(int opcode)
32: {
33: return counts[opcode]>5;
34: }
35:
36: static void read_counts(void)
37: {
38: FILE *file;
39: unsigned long opcode,count, total;
40: int trapcount=0;
41: int trap=0;
42: char name[20];
43: memset(counts, 0, sizeof counts);
44:
45: file=fopen("insncount","r");
46: if(file)
47: {
48: fscanf(file,"Total: %lu\n",&total);
49: while(fscanf(file,"%lx: %lu %s\n",&opcode,&count,name)==3)
50: {
51: counts[opcode]=10000.0*count/total;
52: if(isspecific(opcode))
53: {
54: trapcount+=count;
55: trap++;
56: }
57: }
58: fclose(file);
59: #if 0
60: fprintf(stderr,"trap %d function: %f%\n",trap,100.0*trapcount/total);
61: #endif
62: }
63: }
64:
65:
66: static int n_braces = 0;
67:
68: static void start_brace(void)
69: {
70: n_braces++;
71: printf("{");
72: }
73:
74: static void close_brace(void)
75: {
76: assert (n_braces > 0);
77: n_braces--;
78: printf("}");
79: }
80:
81: static void finish_braces(void)
82: {
83: while (n_braces > 0)
84: close_brace();
85: }
86:
87: static void pop_braces(int to)
88: {
89: while (n_braces > to)
90: close_brace();
91: }
92:
93: static int bit_size(int size)
94: {
95: switch(size) {
96: case sz_byte: return 8;
97: case sz_word: return 16;
98: case sz_long: return 32;
99: default:
100: abort();
101: }
102: return 0;
103: }
104:
105: static const char *bit_mask(int size)
106: {
107: switch(size) {
108: case sz_byte: return "0xff";
109: case sz_word: return "0xffff";
110: case sz_long: return "0xffffffff";
111: default:
112: abort();
113: }
114: return 0;
115: }
116:
117: static void genamode(amodes mode, char *reg, wordsizes size, char *name, int getv, int movem)
118: {
119: start_brace ();
120: switch(mode) {
121: case Dreg:
122: if (movem)
123: abort();
124: if (getv)
125: switch(size) {
126: case sz_byte:
127: printf("\tBYTE %s = regs.d[%s];\n", name, reg);
128: break;
129: case sz_word:
130: printf("\tWORD %s = regs.d[%s];\n", name, reg);
131: break;
132: case sz_long:
133: printf("\tLONG %s = regs.d[%s];\n", name, reg);
134: break;
135: default: abort();
136: }
137: break;
138: case Areg:
139: if (movem)
140: abort();
141: if (getv)
142: switch(size) {
143: case sz_word:
144: printf("\tWORD %s = regs.a[%s];\n", name, reg);
145: break;
146: case sz_long:
147: printf("\tLONG %s = regs.a[%s];\n", name, reg);
148: break;
149: default: abort();
150: }
151: break;
152: case Aind:
153: printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
154: if (getv)
155: switch(size) {
156: case sz_byte:
157: printf("\tBYTE %s = get_byte(%sa);\n", name, name);
158: break;
159: case sz_word:
160: printf("\tWORD %s = get_word(%sa);\n", name, name);
161: break;
162: case sz_long:
163: printf("\tLONG %s = get_long(%sa);\n", name, name);
164: break;
165: default: abort();
166: }
167: break;
168: case Aipi:
169: printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
170: switch(size) {
171: case sz_byte:
172: if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
173: if (!movem) {
174: start_brace();
175: printf("\tregs.a[%s] += areg_byteinc[%s];\n", reg, reg);
176: }
177: break;
178: case sz_word:
179: if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
180: if (!movem) {
181: start_brace();
182: printf("\tregs.a[%s] += 2;\n", reg);
183: }
184: break;
185: case sz_long:
186: if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
187: if (!movem) {
188: start_brace();
189: printf("\tregs.a[%s] += 4;\n", reg);
190: }
191: break;
192: default: abort();
193: }
194: break;
195: case Apdi:
196: switch(size) {
197: case sz_byte:
198: if (!movem) printf("\tregs.a[%s] -= areg_byteinc[%s];\n", reg, reg);
199: start_brace();
200: printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
201: if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
202: break;
203: case sz_word:
204: if (!movem) printf("\tregs.a[%s] -= 2;\n", reg);
205: start_brace();
206: printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
207: if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
208: break;
209: case sz_long:
210: if (!movem) printf("\tregs.a[%s] -= 4;\n", reg);
211: start_brace();
212: printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
213: if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
214: break;
215: default: abort();
216: }
217: break;
218: case Ad16:
219: printf("\tCPTR %sa = regs.a[%s] + (LONG)(WORD)nextiword();\n", name, reg);
220: if (getv)
221: switch(size) {
222: case sz_byte:
223: printf("\tBYTE %s = get_byte(%sa);\n", name, name);
224: break;
225: case sz_word:
226: printf("\tWORD %s = get_word(%sa);\n", name, name);
227: break;
228: case sz_long:
229: printf("\tLONG %s = get_long(%sa);\n", name, name);
230: break;
231: default: abort();
232: }
233: break;
234: case Ad8r:
235: printf("\tCPTR %sa = get_disp_ea(regs.a[%s]);\n", name, reg);
236: if (getv) {
237: start_brace();
238: switch(size) {
239: case sz_byte:
240: printf("\tBYTE %s = get_byte(%sa);\n", name, name);
241: break;
242: case sz_word:
243: printf("\tWORD %s = get_word(%sa);\n", name, name);
244: break;
245: case sz_long:
246: printf("\tLONG %s = get_long(%sa);\n", name, name);
247: break;
248: default: abort();
249: }
250: }
251: break;
252: case PC16:
253: printf("\tCPTR %sa = m68k_getpc();\n", name);
254: printf("\t%sa += (LONG)(WORD)nextiword();\n", name);
255: if (getv) {
256: start_brace();
257: switch(size) {
258: case sz_byte:
259: printf("\tBYTE %s = get_byte(%sa);\n", name, name);
260: break;
261: case sz_word:
262: printf("\tWORD %s = get_word(%sa);\n", name, name);
263: break;
264: case sz_long:
265: printf("\tLONG %s = get_long(%sa);\n", name, name);
266: break;
267: default: abort();
268: }
269: }
270: break;
271: case PC8r:
272: printf("\tCPTR %sa = get_disp_ea(m68k_getpc());\n",name);
273: if (getv) {
274: start_brace();
275: switch(size) {
276: case sz_byte:
277: printf("\tBYTE %s = get_byte(%sa);\n", name, name);
278: break;
279: case sz_word:
280: printf("\tWORD %s = get_word(%sa);\n", name, name);
281: break;
282: case sz_long:
283: printf("\tLONG %s = get_long(%sa);\n", name, name);
284: break;
285: default: abort();
286: }
287: }
288: break;
289: case absw:
290: printf("\tCPTR %sa = (LONG)(WORD)nextiword();\n", name);
291: if (getv)
292: switch(size) {
293: case sz_byte:
294: printf("\tBYTE %s = get_byte(%sa);\n", name, name);
295: break;
296: case sz_word:
297: printf("\tWORD %s = get_word(%sa);\n", name, name);
298: break;
299: case sz_long:
300: printf("\tLONG %s = get_long(%sa);\n", name, name);
301: break;
302: default: abort();
303: }
304: break;
305: case absl:
306: printf("\tCPTR %sa = nextilong();\n", name);
307: if (getv)
308: switch(size) {
309: case sz_byte:
310: printf("\tBYTE %s = get_byte(%sa);\n", name, name);
311: break;
312: case sz_word:
313: printf("\tWORD %s = get_word(%sa);\n", name, name);
314: break;
315: case sz_long:
316: printf("\tLONG %s = get_long(%sa);\n", name, name);
317: break;
318: default: abort();
319: }
320: break;
321: case imm:
322: if (getv)
323: switch(size) {
324: case sz_byte:
325: printf("\tBYTE %s = nextiword();\n", name);
326: break;
327: case sz_word:
328: printf("\tWORD %s = nextiword();\n", name);
329: break;
330: case sz_long:
331: printf("\tLONG %s = nextilong();\n", name);
332: break;
333: default: abort();
334: }
335: break;
336: case imm0:
337: if (!getv) abort();
338: printf("\tBYTE %s = nextiword();\n", name);
339: break;
340: case imm1:
341: if (!getv) abort();
342: printf("\tWORD %s = nextiword();\n", name);
343: break;
344: case imm2:
345: if (!getv) abort();
346: printf("\tLONG %s = nextilong();\n", name);
347: break;
348: case immi:
349: if (!getv) abort();
350: printf("\tULONG %s = %s;\n", name, reg);
351: break;
352: default:
353: abort();
354: }
355: }
356:
357: static void genastore(char *from, amodes mode, char *reg, wordsizes size, char *to)
358: {
359: switch(mode) {
360: case Dreg:
361: switch(size) {
362: case sz_byte:
363: printf("\tregs.d[%s] = (regs.d[%s] & ~0xff) | ((%s) & 0xff);\n", reg, reg, from);
364: break;
365: case sz_word:
366: printf("\tregs.d[%s] = (regs.d[%s] & ~0xffff) | ((%s) & 0xffff);\n", reg, reg, from);
367: break;
368: case sz_long:
369: printf("\tregs.d[%s] = (%s);\n", reg, from);
370: break;
371: default: abort();
372: }
373: break;
374: case Areg:
375: switch(size) {
376: case sz_word:
377: fprintf(stderr, "Foo\n");
378: printf("\tregs.a[%s] = (LONG)(WORD)(%s);\n", reg, from);
379: break;
380: case sz_long:
381: printf("\tregs.a[%s] = (%s);\n", reg, from);
382: break;
383: default: abort();
384: }
385: break;
386: case Aind:
387: case Aipi:
388: case Apdi:
389: case Ad16:
390: case Ad8r:
391: case absw:
392: case absl:
393: switch(size) {
394: case sz_byte:
395: printf("\tput_byte(%sa,%s);\n", to, from);
396: break;
397: case sz_word:
398: printf("\tput_word(%sa,%s);\n", to, from);
399: break;
400: case sz_long:
401: printf("\tput_long(%sa,%s);\n", to, from);
402: break;
403: default: abort();
404: }
405: break;
406: case PC16:
407: case PC8r:
408: switch(size) {
409: case sz_byte:
410: printf("\tput_byte(%sa,%s);\n", to, from);
411: break;
412: case sz_word:
413: if (CPU_LEVEL < 2)
414: abort();
415: printf("\tput_word(%sa,%s);\n", to, from);
416: break;
417: case sz_long:
418: if (CPU_LEVEL < 2)
419: abort();
420: printf("\tput_long(%sa,%s);\n", to, from);
421: break;
422: default: abort();
423: }
424: break;
425: case imm:
426: case imm0:
427: case imm1:
428: case imm2:
429: case immi:
430: abort();
431: break;
432: default:
433: abort();
434: }
435: }
436:
437: static void genmovemel(UWORD opcode)
438: {
439: char getcode[100];
440: int size = table68k[opcode].size == sz_long ? 4 : 2;
441:
442: if (table68k[opcode].size == sz_long) {
443: strcpy(getcode, "get_long(srca)");
444: } else {
445: strcpy(getcode, "(LONG)(WORD)get_word(srca)");
446: }
447:
448: printf("\tUWORD mask = nextiword(), dmask = mask & 0xff, amask = (mask >> 8) & 0xff;\n");
449: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 0, 1);
450: start_brace();
451: printf("\twhile (dmask) { regs.d[movem_index1[dmask]] = %s; srca += %d; dmask = movem_next[dmask]; }\n",
452: getcode, size);
453: printf("\twhile (amask) { regs.a[movem_index1[amask]] = %s; srca += %d; amask = movem_next[amask]; }\n",
454: getcode, size);
455:
456: if (table68k[opcode].dmode == Aipi)
457: printf("\tregs.a[dstreg] = srca;\n");
458: }
459:
460: static void genmovemle(UWORD opcode)
461: {
462: char putcode[100];
463: int size = table68k[opcode].size == sz_long ? 4 : 2;
464: if (table68k[opcode].size == sz_long) {
465: strcpy(putcode, "put_long(srca,");
466: } else {
467: strcpy(putcode, "put_word(srca,");
468: }
469:
470: printf("\tUWORD mask = nextiword();\n");
471: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 0, 1);
472: start_brace();
473: if (table68k[opcode].dmode == Apdi) {
474: printf("\tUWORD amask = mask & 0xff, dmask = (mask >> 8) & 0xff;\n");
475: printf("\twhile (amask) { srca -= %d; %s regs.a[movem_index2[amask]]); amask = movem_next[amask]; }\n",
476: size, putcode);
477: printf("\twhile (dmask) { srca -= %d; %s regs.d[movem_index2[dmask]]); dmask = movem_next[dmask]; }\n",
478: size, putcode);
479: printf("\tregs.a[dstreg] = srca;\n");
480: }
481: else {
482: printf("\tUWORD dmask = mask & 0xff, amask = (mask >> 8) & 0xff;\n");
483: printf("\twhile (dmask) { %s regs.d[movem_index1[dmask]]); srca += %d; dmask = movem_next[dmask]; }\n",
484: putcode, size);
485: printf("\twhile (amask) { %s regs.a[movem_index1[amask]]); srca += %d; amask = movem_next[amask]; }\n",
486: putcode, size);
487: }
488: }
489:
490: typedef enum {
491: flag_logical, flag_add, flag_sub, flag_cmp, flag_addx, flag_subx, flag_zn,
492: flag_av, flag_sv
493: } flagtypes;
494:
495: static void genflags_normal(flagtypes type, wordsizes size, char *value, char *src, char *dst)
496: {
497: char vstr[100],sstr[100],dstr[100];
498: char usstr[100],udstr[100];
499: char unsstr[100],undstr[100];
500:
501: switch(size) {
502: case sz_byte:
503: strcpy(vstr, "((BYTE)(");
504: strcpy(usstr, "((UBYTE)(");
505: break;
506: case sz_word:
507: strcpy(vstr, "((WORD)(");
508: strcpy(usstr, "((UWORD)(");
509: break;
510: case sz_long:
511: strcpy(vstr, "((LONG)(");
512: strcpy(usstr, "((ULONG)(");
513: break;
514: default:
515: abort();
516: }
517: strcpy(unsstr, usstr);
518:
519: strcpy(sstr, vstr);
520: strcpy(dstr, vstr);
521: strcat(vstr, value); strcat(vstr,"))");
522: strcat(dstr, dst); strcat(dstr,"))");
523: strcat(sstr, src); strcat(sstr,"))");
524:
525: strcpy(udstr, usstr);
526: strcat(udstr, dst); strcat(udstr,"))");
527: strcat(usstr, src); strcat(usstr,"))");
528:
529: strcpy(undstr, unsstr);
530: strcat(unsstr, "-");
531: strcat(undstr, "~");
532: strcat(undstr, dst); strcat(undstr,"))");
533: strcat(unsstr, src); strcat(unsstr,"))");
534:
535: switch (type) {
536: case flag_logical:
537: case flag_zn:
538: case flag_av:
539: case flag_sv:
540: case flag_addx:
541: case flag_subx:
542: break;
543:
544: case flag_add:
545: start_brace();
546: printf("ULONG %s = %s + %s;\n", value, dstr, sstr);
547: break;
548: case flag_sub:
549: case flag_cmp:
550: start_brace();
551: printf("ULONG %s = %s - %s;\n", value, dstr, sstr);
552: break;
553: }
554:
555:
556: switch (type) {
557: case flag_logical:
558: case flag_zn:
559: break;
560:
561: case flag_add:
562: case flag_sub:
563: case flag_addx:
564: case flag_subx:
565: case flag_cmp:
566: case flag_av:
567: case flag_sv:
568: start_brace();
569: printf("\t"BOOL_TYPE" flgs = %s < 0;\n", sstr);
570: printf("\t"BOOL_TYPE" flgo = %s < 0;\n", dstr);
571: printf("\t"BOOL_TYPE" flgn = %s < 0;\n", vstr);
572: break;
573: }
574:
575: switch(type) {
576: case flag_logical:
577: printf("\tVFLG = CFLG = 0;\n");
578: printf("\tZFLG = %s == 0;\n", vstr);
579: printf("\tNFLG = %s < 0;\n", vstr);
580: break;
581: case flag_av:
582: printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
583: break;
584: case flag_sv:
585: printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
586: break;
587: case flag_zn:
588: printf("\tif (%s != 0) ZFLG = 0;\n", vstr);
589: printf("\tNFLG = %s < 0;\n", vstr);
590: break;
591: case flag_add:
592: printf("\tZFLG = %s == 0;\n", vstr);
593: printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
594: printf("\tCFLG = XFLG = %s < %s;\n", undstr, usstr);
595: printf("\tNFLG = flgn != 0;\n");
596: break;
597: case flag_sub:
598: printf("\tZFLG = %s == 0;\n", vstr);
599: printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
600: printf("\tCFLG = XFLG = %s > %s;\n", usstr, udstr);
601: printf("\tNFLG = flgn != 0;\n");
602: break;
603: case flag_addx:
604: printf("\tVFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);\n");
605: printf("\tXFLG = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));\n");
606: break;
607: case flag_subx:
608: printf("\tVFLG = (!flgs && flgo && !flgn) || (flgs && !flgo && flgn);\n");
609: printf("\tXFLG = CFLG = (flgs && !flgo) || (flgn && (!flgo || flgs));\n");
610: break;
611: case flag_cmp:
612: printf("\tZFLG = %s == 0;\n", vstr);
613: printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
614: printf("\tCFLG = %s > %s;\n", usstr, udstr);
615: printf("\tNFLG = flgn != 0;\n");
616: break;
617: }
618: }
619:
620: static void genflags(flagtypes type, wordsizes size, char *value, char *src, char *dst)
621: {
622: #ifdef INTEL_FLAG_OPT
623: start_brace();
624: printf("\tULONG scratch = 0;\n");
625: switch (type) {
626: case flag_logical:
627: case flag_av:
628: case flag_sv:
629: case flag_zn:
630: case flag_addx:
631: case flag_subx:
632: case flag_cmp:
633: break;
634:
635: case flag_add:
636: case flag_sub:
637: start_brace();
638: printf("\tULONG %s;\n", value);
639: break;
640: }
641:
642: switch(type) {
643: case flag_av:
644: case flag_sv:
645: case flag_zn:
646: case flag_addx:
647: case flag_subx:
648: break;
649:
650: case flag_logical:
651: if (strcmp(value, "0") == 0) {
652: printf("\t*(UBYTE *)®flags = 64;\n");
653: } else {
654: switch(size) {
655: case sz_byte:
656: printf("\t__asm__ __volatile__(\"testb %%b1,%%b1\\n\\tpushfl\\n\\tpopl %%0\\n\\tmovw %%w0,regflags\\n\""
657: ": \"=r\" (scratch) : \"r\" (%s) :\"cc\");", value);
658: break;
659: case sz_word:
660: printf("\t__asm__ __volatile__(\"testw %%w1,%%w1\\n\\tpushfl\\n\\tpopl %%0\\n\\tmovw %%w0,regflags\\n\""
661: ": \"=r\" (scratch) : \"r\" (%s) : \"cc\");", value);
662: break;
663: case sz_long:
664: printf("\t__asm__ __volatile__(\"testl %%1,%%1\\n\\tpushfl\\n\\tpopl %%0\\n\\tmovw %%w0,regflags\\n\""
665: ": \"=r\" (scratch) : \"r\" (%s) : \"cc\");", value);
666:
667: break;
668: }
669: }
670: return;
671:
672: case flag_add:
673: switch (size) {
674: case sz_byte:
675: printf("\t__asm__ __volatile__(\"addb %%b3,%%b0\\n\\tpushfl\\n\\tpopl %%1\\n\\tmovw %%w1,regflags\\n\\tmovw %%w1,regflags+2\\n\""
676: ": \"=&q\" (%s) : \"r\" (scratch), "
677: " \"0\" ((BYTE)(%s)), \"qm\" ((BYTE)(%s)) : \"cc\");",
678: value, src, dst);
679: break;
680: case sz_word:
681: printf("\t__asm__ __volatile__(\"addw %%w3,%%w0\\n\\tpushfl\\n\\tpopl %%1\\n\\tmovw %%w1,regflags\\n\\tmovw %%w1,regflags+2\\n\""
682: ": \"=&r\" (%s) : \"r\" (scratch), "
683: " \"0\" ((WORD)(%s)), \"rmi\" ((WORD)(%s)) : \"cc\");",
684: value, src, dst);
685: break;
686: case sz_long:
687: printf("\t__asm__ __volatile__(\"addl %%3,%%0\\n\\tpushfl\\n\\tpopl %%1\\n\\tmovw %%w1,regflags\\n\\tmovw %%w1,regflags+2\\n\""
688: ": \"=&r\" (%s) : \"r\" (scratch), "
689: " \"0\" ((LONG)(%s)), \"rmi\" ((LONG)(%s)) : \"cc\");",
690: value, src, dst);
691: break;
692: }
693: return;
694:
695: case flag_sub:
696: switch (size) {
697: case sz_byte:
698: printf("\t__asm__ __volatile__(\"subb %%b2,%%b0\\n\\tpushfl\\n\\tpopl %%1\\n\\tmovw %%w1,regflags\\n\\tmovw %%w1,regflags+2\\n\""
699: ": \"=&q\" (%s) : \"r\" (scratch), "
700: " \"qmi\" ((BYTE)(%s)), \"0\" ((BYTE)(%s)) : \"cc\");",
701: value, src, dst);
702: break;
703: case sz_word:
704: printf("\t__asm__ __volatile__(\"subw %%w2,%%w0\\n\\tpushfl\\n\\tpopl %%1\\n\\tmovw %%w1,regflags\\n\\tmovw %%w1,regflags+2\\n\""
705: ": \"=&r\" (%s) : \"r\" (scratch), "
706: " \"rmi\" ((WORD)(%s)), \"0\" ((WORD)(%s)) : \"cc\");",
707: value, src, dst);
708: break;
709: case sz_long:
710: printf("\t__asm__ __volatile__(\"subl %%2,%%0\\n\\tpushfl\\n\\tpopl %%1\\n\\tmovw %%w1,regflags\\n\\tmovw %%w1,regflags+2\\n\""
711: ": \"=&r\" (%s) : \"r\" (scratch), "
712: " \"rmi\" ((LONG)(%s)), \"0\" ((LONG)(%s)) : \"cc\");",
713: value, src, dst);
714: break;
715: }
716: return;
717:
718: case flag_cmp:
719: switch (size) {
720: case sz_byte:
721: printf("\t__asm__ __volatile__(\"cmpb %%b1,%%b2\\n\\tpushfl\\n\\tpopl %%0\\n\\tmovw %%w0,regflags\\n\""
722: ": : \"r\" (scratch), "
723: " \"qmi\" ((BYTE)(%s)), \"q\" ((BYTE)(%s)) : \"cc\");",
724: src, dst);
725: break;
726: case sz_word:
727: printf("\t__asm__ __volatile__(\"cmpw %%w1,%%w2\\n\\tpushfl\\n\\tpopl %%0\\n\\tmovw %%w0,regflags\\n\""
728: ": : \"r\" (scratch), "
729: " \"rmi\" ((WORD)(%s)), \"r\" ((WORD)(%s)) : \"cc\");",
730: src, dst);
731: break;
732: case sz_long:
733: printf("\t__asm__ __volatile__(\"cmpl %%1,%%2\\n\\tpushfl\\n\\tpopl %%0\\n\\tmovw %%w0,regflags\\n\""
734: ": : \"r\" (scratch), "
735: " \"rmi\" ((LONG)(%s)), \"r\" ((LONG)(%s)) : \"cc\");",
736: src, dst);
737: break;
738: }
739: return;
740: }
741: #endif
742: genflags_normal(type, size, value, src, dst);
743: }
744: static void gen_opcode(unsigned long int opcode)
745: {
746: start_brace ();
747: switch (table68k[opcode].plev) {
748: case 0: /* not priviledged */
749: break;
750: case 1: /* unpriviledged only on 68000 */
751: if (CPU_LEVEL == 0)
752: break;
753: /* FALLTHROUGH */
754: case 2: /* priviledged */
755: #ifdef USE_POINTER
756: printf("if (!regs.s) { regs.pc_p -= 2; Exception(8,0); } else\n");
757: #else
758: printf("if (!regs.s) { regs.pc -= 2; Exception(8,0); } else\n");
759: #endif
760: start_brace();
761: break;
762: case 3: /* priviledged if size == word */
763: if (table68k[opcode].size == sz_byte)
764: break;
765: #ifdef USE_POINTER
766: printf("if (!regs.s) { regs.pc_p -= 2; Exception(8,0); } else\n");
767: #else
768: printf("if (!regs.s) { regs.pc -= 2; Exception(8,0); } else\n");
769: #endif
770: start_brace();
771: break;
772: }
773: switch(table68k[opcode].mnemo) {
774: case i_OR:
775: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
776: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
777: printf("\tsrc |= dst;\n");
778: genflags(flag_logical, table68k[opcode].size, "src", "", "");
779: genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
780: break;
781: case i_AND:
782: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
783: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
784: printf("\tsrc &= dst;\n");
785: genflags(flag_logical, table68k[opcode].size, "src", "", "");
786: genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
787: break;
788: case i_EOR:
789: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
790: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
791: printf("\tsrc ^= dst;\n");
792: genflags(flag_logical, table68k[opcode].size, "src", "", "");
793: genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
794: break;
795: case i_ORSR:
796: printf("\tMakeSR();\n");
797: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
798: if (table68k[opcode].size == sz_byte) {
799: printf("\tsrc &= 0xFF;\n");
800: }
801: printf("\tregs.sr |= src;\n");
802: printf("\tMakeFromSR();\n");
803: break;
804: case i_ANDSR:
805: printf("\tMakeSR();\n");
806: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
807: if (table68k[opcode].size == sz_byte) {
808: printf("\tsrc |= 0xFF00;\n");
809: }
810: printf("\tregs.sr &= src;\n");
811: printf("\tMakeFromSR();\n");
812: break;
813: case i_EORSR:
814: printf("\tMakeSR();\n");
815: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
816: if (table68k[opcode].size == sz_byte) {
817: printf("\tsrc &= 0xFF;\n");
818: }
819: printf("\tregs.sr ^= src;\n");
820: printf("\tMakeFromSR();\n");
821: break;
822: case i_SUB:
823: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
824: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
825: start_brace ();
826: genflags(flag_sub, table68k[opcode].size, "newv", "src", "dst");
827: genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
828: break;
829: case i_SUBA:
830: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
831: genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
832: start_brace ();
833: printf("\tULONG newv = dst - src;\n");
834: genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
835: break;
836: case i_SUBX:
837: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
838: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
839: start_brace ();
840: printf("\tULONG newv = dst - src - (XFLG ? 1 : 0);\n");
841: genflags(flag_subx, table68k[opcode].size, "newv", "src", "dst");
842: genflags(flag_zn, table68k[opcode].size, "newv", "", "");
843: genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
844: break;
845: case i_SBCD:
846: /* Let's hope this works... */
847: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
848: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
849: start_brace ();
850: printf("\tUWORD newv_lo = (dst & 0xF) - (src & 0xF) - (XFLG ? 1 : 0);\n");
851: printf("\tUWORD newv_hi = (dst & 0xF0) - (src & 0xF0);\n");
852: printf("\tUWORD newv;\n");
853: printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
854: printf("\tnewv = newv_hi + (newv_lo & 0xF);");
855: printf("\tCFLG = XFLG = (newv_hi & 0x1F0) > 0x90;\n");
856: printf("\tif (CFLG) newv -= 0x60;\n");
857: genflags(flag_zn, table68k[opcode].size, "newv", "", "");
858: genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");
859: genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
860: break;
861: case i_ADD:
862: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
863: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
864: start_brace ();
865: genflags(flag_add, table68k[opcode].size, "newv", "src", "dst");
866: genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
867: break;
868: case i_ADDA:
869: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
870: genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
871: start_brace ();
872: printf("\tULONG newv = dst + src;\n");
873: genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
874: break;
875: case i_ADDX:
876: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
877: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
878: start_brace ();
879: printf("\tULONG newv = dst + src + (XFLG ? 1 : 0);\n");
880: genflags(flag_addx, table68k[opcode].size, "newv", "src", "dst");
881: genflags(flag_zn, table68k[opcode].size, "newv", "", "");
882: genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
883: break;
884: case i_ABCD:
885: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
886: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
887: start_brace ();
888: printf("\tUWORD newv_lo = (src & 0xF) + (dst & 0xF) + (XFLG ? 1 : 0);\n");
889: printf("\tUWORD newv_hi = (src & 0xF0) + (dst & 0xF0);\n");
890: printf("\tUWORD newv;\n");
891: printf("\tif (newv_lo > 9) { newv_lo +=6; }\n");
892: printf("\tnewv = newv_hi + newv_lo;");
893: printf("\tCFLG = XFLG = (newv & 0x1F0) > 0x90;\n");
894: printf("\tif (CFLG) newv += 0x60;\n");
895: genflags(flag_zn, table68k[opcode].size, "newv", "", "");
896: genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");
897: genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
898: break;
899: case i_NEG:
900: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
901: start_brace ();
902: genflags(flag_sub, table68k[opcode].size, "dst", "src", "0");
903: genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
904: break;
905: case i_NEGX:
906: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
907: start_brace ();
908: printf("\tULONG newv = 0 - src - (XFLG ? 1 : 0);\n");
909: genflags(flag_subx, table68k[opcode].size, "newv", "src", "0");
910: genflags(flag_zn, table68k[opcode].size, "newv", "", "");
911: genastore("newv", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
912: break;
913: case i_NBCD:
914: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
915: start_brace ();
916: printf("\tUWORD newv_lo = - (src & 0xF) - (XFLG ? 1 : 0);\n");
917: printf("\tUWORD newv_hi = - (src & 0xF0);\n");
918: printf("\tUWORD newv;\n");
919: printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
920: printf("\tnewv = newv_hi + (newv_lo & 0xF);");
921: printf("\tCFLG = XFLG = (newv_hi & 0x1F0) > 0x90;\n");
922: printf("\tif (CFLG) newv -= 0x60;\n");
923: genflags(flag_zn, table68k[opcode].size, "newv", "", "");
924: genastore("newv", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
925: break;
926: case i_CLR:
927: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
928: genflags(flag_logical, table68k[opcode].size, "0", "", "");
929: genastore("0",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
930: break;
931: case i_NOT:
932: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
933: start_brace ();
934: printf("\tULONG dst = ~src;\n");
935: genflags(flag_logical, table68k[opcode].size, "dst", "", "");
936: genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
937: break;
938: case i_TST:
939: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
940: genflags(flag_logical, table68k[opcode].size, "src", "", "");
941: break;
942: case i_BTST:
943: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
944: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
945: if (table68k[opcode].size == sz_byte)
946: printf("\tsrc &= 7;\n");
947: else
948: printf("\tsrc &= 31;\n");
949: printf("\tZFLG = !(dst & (1 << src));\n");
950: break;
951: case i_BCHG:
952: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
953: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
954: if (table68k[opcode].size == sz_byte)
955: printf("\tsrc &= 7;\n");
956: else
957: printf("\tsrc &= 31;\n");
958: printf("\tZFLG = !(dst & (1 << src));\n");
959: printf("\tdst ^= (1 << src);\n");
960: genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
961: break;
962: case i_BCLR:
963: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
964: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
965: if (table68k[opcode].size == sz_byte)
966: printf("\tsrc &= 7;\n");
967: else
968: printf("\tsrc &= 31;\n");
969: printf("\tZFLG = !(dst & (1 << src));\n");
970: printf("\tdst &= ~(1 << src);\n");
971: genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
972: break;
973: case i_BSET:
974: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
975: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
976: if (table68k[opcode].size == sz_byte)
977: printf("\tsrc &= 7;\n");
978: else
979: printf("\tsrc &= 31;\n");
980: printf("\tZFLG = !(dst & (1 << src));\n");
981: printf("\tdst |= (1 << src);\n");
982: genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
983: break;
984: case i_CMPM:
985: case i_CMP:
986: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
987: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
988: start_brace ();
989: genflags(flag_cmp, table68k[opcode].size, "newv", "src", "dst");
990: break;
991: case i_CMPA:
992: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
993: genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
994: start_brace ();
995: genflags(flag_cmp, sz_long, "newv", "src", "dst");
996: break;
997: /* The next two are coded a little unconventional, but they are doing
998: * weird things... */
999: case i_MVPRM:
1000: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1001: printf("\tCPTR memp = regs.a[dstreg] + nextiword();\n");
1002: if (table68k[opcode].size == sz_word) {
1003: printf("\tput_byte(memp, src >> 8); put_byte(memp + 2, src);\n");
1004: } else {
1005: printf("\tput_byte(memp, src >> 24); put_byte(memp + 2, src >> 16);\n");
1006: printf("\tput_byte(memp + 4, src >> 8); put_byte(memp + 6, src);\n");
1007: }
1008: break;
1009: case i_MVPMR:
1010: printf("\tCPTR memp = regs.a[srcreg] + nextiword();\n");
1011: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
1012: if (table68k[opcode].size == sz_word) {
1013: printf("\tUWORD val = (get_byte(memp) << 8) + get_byte(memp + 2);\n");
1014: } else {
1015: printf("\tULONG val = (get_byte(memp) << 24) + (get_byte(memp + 2) << 16)\n");
1016: printf(" + (get_byte(memp + 4) << 8) + get_byte(memp + 6);\n");
1017: }
1018: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
1019: break;
1020: case i_MOVE:
1021: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1022: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
1023: genflags(flag_logical, table68k[opcode].size, "src", "", "");
1024: genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
1025: break;
1026: case i_MOVEA:
1027: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1028: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
1029: if (table68k[opcode].size == sz_word) {
1030: printf("\tULONG val = (LONG)(WORD)src;\n");
1031: } else {
1032: printf("\tULONG val = src;\n");
1033: }
1034: genastore("val", table68k[opcode].dmode, "dstreg", sz_long, "dst");
1035: break;
1036: case i_MVSR2:
1037: genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 0, 0);
1038: printf("\tMakeSR();\n");
1039: if (table68k[opcode].size == sz_byte)
1040: genastore("regs.sr & 0xff", table68k[opcode].smode, "srcreg", sz_word, "src");
1041: else
1042: genastore("regs.sr", table68k[opcode].smode, "srcreg", sz_word, "src");
1043: break;
1044: case i_MV2SR:
1045: genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
1046: if (table68k[opcode].size == sz_byte)
1047: printf("\tMakeSR();\n\tregs.sr &= 0xFF00;\n\tregs.sr |= src & 0xFF;\n");
1048: else {
1049: printf("\tregs.sr = src;\n");
1050: }
1051: printf("\tMakeFromSR();\n");
1052: break;
1053: case i_SWAP:
1054: genamode(table68k[opcode].smode, "srcreg", sz_long, "src", 1, 0);
1055: start_brace ();
1056: printf("\tULONG dst = ((src >> 16)&0xFFFF) | ((src&0xFFFF)<<16);\n");
1057: genflags(flag_logical, sz_long, "dst", "", "");
1058: genastore("dst",table68k[opcode].smode, "srcreg", sz_long, "src");
1059: break;
1060: case i_EXG:
1061: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1062: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
1063: genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
1064: genastore("src",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
1065: break;
1066: case i_EXT:
1067: genamode(table68k[opcode].smode, "srcreg", sz_long, "src", 1, 0);
1068: start_brace ();
1069: switch(table68k[opcode].size) {
1070: case sz_byte: printf("\tULONG dst = (LONG)(BYTE)src;\n"); break;
1071: case sz_word: printf("\tUWORD dst = (WORD)(BYTE)src;\n"); break;
1072: case sz_long: printf("\tULONG dst = (LONG)(WORD)src;\n"); break;
1073: default: abort();
1074: }
1075: genflags(flag_logical,
1076: table68k[opcode].size == sz_word ? sz_word : sz_long, "dst", "", "");
1077: genastore("dst",table68k[opcode].smode, "srcreg",
1078: table68k[opcode].size == sz_word ? sz_word : sz_long, "src");
1079: break;
1080: case i_MVMEL:
1081: genmovemel(opcode);
1082: break;
1083: case i_MVMLE:
1084: genmovemle(opcode);
1085: break;
1086: case i_TRAP:
1087: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1088: printf("\tException(src+32,0);\n");
1089: break;
1090: case i_MVR2USP:
1091: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1092: printf("\tregs.usp = src;\n");
1093: break;
1094: case i_MVUSP2R:
1095: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
1096: genastore("regs.usp", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
1097: break;
1098: case i_RESET:
1099: printf("\tcustomreset();\n");
1100: break;
1101: case i_NOP:
1102: break;
1103: case i_STOP:
1104: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1105: printf("\tregs.sr = src;\n");
1106: printf("\tMakeFromSR();\n");
1107: printf("\tm68k_setstopped(1);\n");
1108: break;
1109: case i_RTE:
1110: if (CPU_LEVEL == 0) {
1111: genamode(Aipi, "7", sz_word, "sr", 1, 0);
1112: genamode(Aipi, "7", sz_long, "pc", 1, 0);
1113: printf("\tregs.sr = sr; m68k_setpc_rte(pc);\n");
1114: printf("\tMakeFromSR();\n");
1115: }
1116: else {
1117: int old_brace_level = n_braces;
1118: printf("\tUWORD newsr; ULONG newpc; for (;;) {\n");
1119: genamode(Aipi, "7", sz_word, "sr", 1, 0);
1120: genamode(Aipi, "7", sz_long, "pc", 1, 0);
1121: genamode(Aipi, "7", sz_word, "format", 1, 0);
1122: printf("\tnewsr = sr; newpc = pc;\n");
1123: printf("\tif ((format & 0xF000) == 0x0000) { break; }\n");
1124: printf("\telse if ((format & 0xF000) == 0x1000) { ; }\n");
1125: printf("\telse if ((format & 0xF000) == 0x2000) { regs.a[7] += 4; break; }\n");
1126: printf("\telse if ((format & 0xF000) == 0x8000) { regs.a[7] += 50; break; }\n");
1127: printf("\telse if ((format & 0xF000) == 0x9000) { regs.a[7] += 12; break; }\n");
1128: printf("\telse if ((format & 0xF000) == 0xa000) { regs.a[7] += 24; break; }\n");
1129: printf("\telse if ((format & 0xF000) == 0xb000) { regs.a[7] += 84; break; }\n");
1130: printf("\telse { Exception(14,0); return; }\n");
1131: printf("\tregs.sr = newsr; MakeFromSR();\n}\n");
1132: pop_braces (old_brace_level);
1133: printf("\tregs.sr = newsr; MakeFromSR();\n");
1134: printf("\tm68k_setpc_rte(newpc);\n");
1135: }
1136: break;
1137: case i_RTD:
1138: genamode(Aipi, "7", sz_long, "pc", 1, 0);
1139: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "offs", 1, 0);
1140: printf("\tregs.a[7] += offs;\n");
1141: printf("\tm68k_setpc_rte(pc);\n");
1142: break;
1143: case i_LINK:
1144: genamode(Apdi, "7", sz_long, "old", 0, 0);
1145: genamode(table68k[opcode].smode, "srcreg", sz_long, "src", 1, 0);
1146: genastore("src", Apdi, "7", sz_long, "old");
1147: genastore("regs.a[7]", table68k[opcode].smode, "srcreg", sz_long, "src");
1148: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
1149: printf("\tregs.a[7] += offs;\n");
1150: break;
1151: case i_UNLK:
1152: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1153: printf("\tregs.a[7] = src;\n");
1154: genamode(Aipi, "7", sz_long, "old", 1, 0);
1155: genastore("old", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
1156: break;
1157: case i_RTS:
1158: genamode(Aipi, "7", sz_long, "pc", 1, 0);
1159: printf("\tm68k_setpc(pc);\n");
1160: break;
1161: case i_TRAPV:
1162: printf("\tif(VFLG) Exception(7,m68k_getpc()-2);\n");
1163: break;
1164: case i_RTR:
1165: printf("\tMakeSR();\n");
1166: genamode(Aipi, "7", sz_word, "sr", 1, 0);
1167: genamode(Aipi, "7", sz_long, "pc", 1, 0);
1168: printf("\tregs.sr &= 0xFF00; sr &= 0xFF;\n");
1169: printf("\tregs.sr |= sr; m68k_setpc(pc);\n");
1170: printf("\tMakeFromSR();\n");
1171: break;
1172: case i_JSR:
1173: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
1174: genamode(Apdi, "7", sz_long, "sp", 0, 0);
1175: genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
1176: printf("\tm68k_setpc(srca);\n");
1177: break;
1178: case i_JMP:
1179: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
1180: printf("\tm68k_setpc(srca);\n");
1181: break;
1182: /* Put on your cool #ifdef shades... */
1183: case i_BSR:
1184: #if defined(USE_POINTER) && !defined(USE_COMPILER)
1185: printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
1186: #else
1187: printf("\tULONG oldpc = m68k_getpc();\n");
1188: #endif
1189: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1190: genamode(Apdi, "7", sz_long, "sp", 0, 0);
1191: genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
1192: #ifdef USE_COMPILER
1193: printf("\tm68k_setpc(oldpc + (LONG)src);\n");
1194: #elif defined(USE_POINTER)
1195: printf("\tregs.pc_p = (UBYTE *)(oldpcp + (LONG)src);\n");
1196: #else
1197: printf("\tregs.pc = oldpc + (LONG)src;\n");
1198: #endif
1199: #ifndef NO_EXCEPTION_3
1200: printf("\tif (src & 1) Exception(3,0);\n");
1201: #endif
1202: break;
1203: case i_Bcc:
1204: #if defined(USE_POINTER) && !defined(USE_COMPILER)
1205: printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
1206: #else
1207: printf("\tULONG oldpc = m68k_getpc();\n");
1208: #endif
1209: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1210: printf("\tif (cctrue(%d)) {\n", table68k[opcode].cc);
1211: #ifdef USE_COMPILER
1212: printf("\tm68k_setpc_bcc(oldpc + (LONG)src);\n");
1213: #elif defined(USE_POINTER)
1214: printf("\tregs.pc_p = (UBYTE *)(oldpcp + (LONG)src);\n");
1215: #else
1216: printf("\tregs.pc = oldpc + (LONG)src;\n");
1217: #endif
1218: #ifndef NO_EXCEPTION_3
1219: printf("\tif (src & 1) Exception(3,0);\n");
1220: #endif
1221: printf("\t}\n");
1222: break;
1223: case i_LEA:
1224: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
1225: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
1226: genastore("srca", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
1227: break;
1228: case i_PEA:
1229: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
1230: genamode(Apdi, "7", sz_long, "dst", 0, 0);
1231: genastore("srca", Apdi, "7", sz_long, "dst");
1232: break;
1233: case i_DBcc:
1234: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1235: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
1236: printf("\tif (!cctrue(%d)) {\n", table68k[opcode].cc);
1237: printf("\t\tif (src-- & 0xFFFF)"); /* The & 0xFFFF is for making the broken BeBox compiler happy */
1238: #ifdef USE_COMPILER
1239: printf("m68k_setpc_bcc(m68k_getpc() + (LONG)offs - 2);\n");
1240: #elif defined(USE_POINTER)
1241: printf("regs.pc_p = (UBYTE *)((char *)regs.pc_p + (LONG)offs - 2);\n");
1242: #else
1243: printf("regs.pc += (LONG)offs - 2;\n");
1244: #endif
1245: genastore("src", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
1246: printf("\t}\n");
1247: break;
1248: case i_Scc:
1249: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
1250: start_brace ();
1251: printf("\tint val = cctrue(%d) ? 0xff : 0;\n", table68k[opcode].cc);
1252: genastore("val",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
1253: break;
1254: case i_DIVU:
1255: printf("\tCPTR oldpc = m68k_getpc();\n");
1256: genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
1257: genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
1258: printf("\tif(src == 0) Exception(5,oldpc-2); else {\n");
1259: printf("\tULONG newv = (ULONG)dst / (ULONG)(UWORD)src;\n");
1260: printf("\tULONG rem = (ULONG)dst %% (ULONG)(UWORD)src;\n");
1261: /* The N flag appears to be set each time there is an overflow.
1262: * Weird. */
1263: printf("\tif (newv > 0xffff) { VFLG = NFLG = 1; CFLG = 0; } else\n\t{\n");
1264: genflags(flag_logical, sz_word, "newv", "", "");
1265: printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
1266: genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
1267: printf("\t}\n");
1268: printf("\t}\n");
1269: break;
1270: case i_DIVS:
1271: printf("\tCPTR oldpc = m68k_getpc();\n");
1272: genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
1273: genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
1274: printf("\tif(src == 0) Exception(5,oldpc-2); else {\n");
1275: printf("\tLONG newv = (LONG)dst / (LONG)(WORD)src;\n");
1276: printf("\tUWORD rem = (LONG)dst %% (LONG)(WORD)src;\n");
1277: printf("\tif ((newv & 0xffff8000) != 0 && (newv & 0xffff8000) != 0xffff8000) { VFLG = NFLG = 1; CFLG = 0; } else\n\t{\n");
1278: printf("\tif (((WORD)rem < 0) != ((LONG)dst < 0)) rem = -rem;\n");
1279: genflags(flag_logical, sz_word, "newv", "", "");
1280: printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
1281: genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
1282: printf("\t}\n");
1283: printf("\t}\n");
1284: break;
1285: case i_MULU:
1286: genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
1287: genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
1288: start_brace ();
1289: printf("\tULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;\n");
1290: genflags(flag_logical, sz_long, "newv", "", "");
1291: genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
1292: #ifdef WANT_SLOW_MULTIPLY
1293: printf("\tregs.spcflags |= SPCFLAG_EXTRA_CYCLES;\n");
1294: #endif
1295: break;
1296: case i_MULS:
1297: genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
1298: genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
1299: start_brace ();
1300: printf("\tULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;\n");
1301: genflags(flag_logical, sz_long, "newv", "", "");
1302: genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
1303: #ifdef WANT_SLOW_MULTIPLY
1304: printf("\tregs.spcflags |= SPCFLAG_EXTRA_CYCLES;\n");
1305: #endif
1306: break;
1307: case i_CHK:
1308: printf("\tCPTR oldpc = m68k_getpc();\n");
1309: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1310: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
1311: printf("\tif ((LONG)dst < 0) { NFLG=1; Exception(6,oldpc-2); }\n");
1312: printf("\telse if (dst > src) { NFLG=0; Exception(6,oldpc-2); }\n");
1313: break;
1314:
1315: case i_CHK2:
1316: printf("\tCPTR oldpc = m68k_getpc();\n");
1317: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1318: genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
1319: printf("\t{LONG upper,lower,reg = extra & 0x8000 ? regs.a[(extra >> 12) & 7] : regs.d[(extra >> 12) & 7];\n");
1320: switch (table68k[opcode].size) {
1321: case sz_byte: printf("\tlower=(LONG)(BYTE)get_byte(dsta); upper = (LONG)(BYTE)get_byte(dsta+1);\n");
1322: printf("\tif ((extra & 0x8000) == 0) reg = (LONG)(BYTE)reg;\n");
1323: break;
1324: case sz_word: printf("\tlower=(LONG)(WORD)get_word(dsta); upper = (LONG)(WORD)get_word(dsta+2);\n");
1325: printf("\tif ((extra & 0x8000) == 0) reg = (LONG)(WORD)reg;\n");
1326: break;
1327: case sz_long: printf("\tlower=get_long(dsta); upper = get_long(dsta+4);\n");
1328: break;
1329: default:
1330: abort();
1331: }
1332: printf("\tZFLG=upper == reg || lower == reg;\n");
1333: printf("\tCFLG=lower <= upper ? reg < lower || reg > upper : reg > upper || reg < lower;\n");
1334: printf("\tif ((extra & 0x800) && CFLG) Exception(6,oldpc-2);\n}\n");
1335: break;
1336:
1337: case i_ASR:
1338: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1339: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1340: start_brace ();
1341: switch(table68k[opcode].size) {
1342: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1343: case sz_word: printf("\tUWORD val = data;\n"); break;
1344: case sz_long: printf("\tULONG val = data;\n"); break;
1345: default: abort();
1346: }
1347: switch(table68k[opcode].size) {
1348: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1349: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1350: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1351: default: abort();
1352: }
1353: printf("\tULONG sign = cmask & val;\n");
1354: printf("\tcnt &= 63;\n");
1355: printf("\tVFLG = 0;\n");
1356: printf("\tif (!cnt) { CFLG = 0; } else {\n");
1357: printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
1358: printf("\t\tval = sign ? %s : 0;\n",bit_mask(table68k[opcode].size));
1359: printf("\t\tCFLG=XFLG= sign ? 1 : 0;\n");
1360: printf("\t} else {\n");
1361: printf("\t\tCFLG=XFLG=(val >> (cnt-1)) & 1;\n");
1362: printf("\t\tval >>= cnt;\n");
1363: printf("\t\tif (sign) val |= %s << (%d - cnt);\n",
1364: bit_mask(table68k[opcode].size),
1365: bit_size(table68k[opcode].size));
1366: printf("\t}}\n");
1367: printf("\tNFLG = sign != 0;\n");
1368: printf("\tZFLG = val == 0;\n");
1369: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1370: break;
1371: case i_ASL:
1372: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1373: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1374: start_brace ();
1375: switch(table68k[opcode].size) {
1376: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1377: case sz_word: printf("\tUWORD val = data;\n"); break;
1378: case sz_long: printf("\tULONG val = data;\n"); break;
1379: default: abort();
1380: }
1381: switch(table68k[opcode].size) {
1382: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1383: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1384: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1385: default: abort();
1386: }
1387: printf("\tcnt &= 63;\n");
1388: printf("\tVFLG = 0;\n");
1389: printf("\tif (!cnt) { CFLG = 0; } else {\n");
1390: printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
1391: printf("\t\tVFLG = val != 0;\n");
1392: printf("\t\tCFLG=XFLG = cnt == %d ? val & 1 : 0;\n",
1393: bit_size(table68k[opcode].size));
1394: printf("\t\tval = 0;\n");
1395: printf("\t} else {\n");
1396: printf("\t\tULONG mask = (%s << (%d - cnt)) & %s;\n",
1397: bit_mask(table68k[opcode].size),
1398: bit_size(table68k[opcode].size)-1,
1399: bit_mask(table68k[opcode].size));
1400: printf("\t\tCFLG=XFLG=(val << (cnt-1)) & cmask ? 1 : 0;\n");
1401: printf("\t\tVFLG = (val & mask) != mask && (val & mask) != 0;\n");
1402: printf("\t\tval <<= cnt;\n");
1403: printf("\t}}\n");
1404: printf("\tNFLG = (val&cmask) != 0;\n");
1405: printf("\tZFLG = val == 0;\n");
1406: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1407: break;
1408: case i_LSR:
1409: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1410: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1411: start_brace ();
1412: switch(table68k[opcode].size) {
1413: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1414: case sz_word: printf("\tUWORD val = data;\n"); break;
1415: case sz_long: printf("\tULONG val = data;\n"); break;
1416: default: abort();
1417: }
1418: switch(table68k[opcode].size) {
1419: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1420: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1421: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1422: default: abort();
1423: }
1424: printf("\tcnt &= 63;\n");
1425: printf("\tif (!cnt) { CFLG = 0; } else {\n");
1426: printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
1427: printf("\t\tCFLG=XFLG = cnt == %d ? (val & cmask ? 1 : 0) : 0;\n",
1428: bit_size(table68k[opcode].size));
1429: printf("\t\tval = 0;\n");
1430: printf("\t} else {\n");
1431: printf("\t\tCFLG=XFLG=(val >> (cnt-1)) & 1;\n");
1432: printf("\t\tval >>= cnt;\n");
1433: printf("\t}}\n");
1434: printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
1435: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1436: break;
1437: case i_LSL:
1438: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1439: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1440: start_brace ();
1441: switch(table68k[opcode].size) {
1442: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1443: case sz_word: printf("\tUWORD val = data;\n"); break;
1444: case sz_long: printf("\tULONG val = data;\n"); break;
1445: default: abort();
1446: }
1447: switch(table68k[opcode].size) {
1448: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1449: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1450: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1451: default: abort();
1452: }
1453: printf("\tcnt &= 63;\n");
1454: printf("\tif (!cnt) { CFLG = 0; } else {\n");
1455: printf("\tif (cnt >= %d) {\n",bit_size(table68k[opcode].size));
1456: printf("\t\tCFLG=XFLG = cnt == %d ? val & 1 : 0;\n",
1457: bit_size(table68k[opcode].size));
1458: printf("\t\tval = 0;\n");
1459: printf("\t} else {\n");
1460: printf("\t\tCFLG=XFLG=(val << (cnt-1)) & cmask ? 1 : 0;\n");
1461: printf("\t\tval <<= cnt;\n");
1462: printf("\t}}\n");
1463: printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
1464: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1465: break;
1466: case i_ROL:
1467: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1468: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1469: start_brace ();
1470: switch(table68k[opcode].size) {
1471: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1472: case sz_word: printf("\tUWORD val = data;\n"); break;
1473: case sz_long: printf("\tULONG val = data;\n"); break;
1474: default: abort();
1475: }
1476: switch(table68k[opcode].size) {
1477: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1478: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1479: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1480: default: abort();
1481: }
1482: printf("\tcnt &= 63;\n");
1483: printf("\tif (!cnt) { CFLG = 0; } else {\n");
1484: printf("\tULONG carry;\n");
1485: printf("\tfor(;cnt;--cnt){\n");
1486: printf("\tcarry=val&cmask; val <<= 1;\n");
1487: printf("\tif(carry) val |= 1;\n");
1488: printf("\t}\n");
1489: printf("\tCFLG = carry!=0;\n}\n");
1490: printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
1491: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1492: break;
1493: case i_ROR:
1494: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1495: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1496: start_brace ();
1497: switch(table68k[opcode].size) {
1498: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1499: case sz_word: printf("\tUWORD val = data;\n"); break;
1500: case sz_long: printf("\tULONG val = data;\n"); break;
1501: default: abort();
1502: }
1503: switch(table68k[opcode].size) {
1504: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1505: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1506: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1507: default: abort();
1508: }
1509: printf("\tcnt &= 63;\n");
1510: printf("\tif (!cnt) { CFLG = 0; } else {");
1511: printf("\tULONG carry;\n");
1512: printf("\tfor(;cnt;--cnt){\n");
1513: printf("\tcarry=val&1; val = val >> 1;\n");
1514: printf("\tif(carry) val |= cmask;\n");
1515: printf("\t}\n");
1516: printf("\tCFLG = carry;\n}\n");
1517: printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
1518: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1519: break;
1520: case i_ROXL:
1521: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1522: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1523: start_brace ();
1524: switch(table68k[opcode].size) {
1525: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1526: case sz_word: printf("\tUWORD val = data;\n"); break;
1527: case sz_long: printf("\tULONG val = data;\n"); break;
1528: default: abort();
1529: }
1530: switch(table68k[opcode].size) {
1531: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1532: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1533: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1534: default: abort();
1535: }
1536: printf("\tULONG carry;\n");
1537: printf("\tcnt &= 63;\n");
1538: printf("\tfor(;cnt;--cnt){\n");
1539: printf("\tcarry=val&cmask; val <<= 1;\n");
1540: printf("\tif(XFLG) val |= 1;\n");
1541: printf("\tXFLG = carry != 0;\n");
1542: printf("\t}\n");
1543: printf("\tCFLG = XFLG;\n");
1544: printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
1545: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1546: break;
1547: case i_ROXR:
1548: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
1549: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
1550: start_brace ();
1551: switch(table68k[opcode].size) {
1552: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1553: case sz_word: printf("\tUWORD val = data;\n"); break;
1554: case sz_long: printf("\tULONG val = data;\n"); break;
1555: default: abort();
1556: }
1557: switch(table68k[opcode].size) {
1558: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1559: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1560: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1561: default: abort();
1562: }
1563: printf("\tULONG carry;\n");
1564: printf("\tcnt &= 63;\n");
1565: printf("\tfor(;cnt;--cnt){\n");
1566: printf("\tcarry=val&1; val >>= 1;\n");
1567: printf("\tif(XFLG) val |= cmask;\n");
1568: printf("\tXFLG = carry;\n");
1569: printf("\t}\n");
1570: printf("\tCFLG = XFLG;\n");
1571: printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
1572: genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
1573: break;
1574: case i_ASRW:
1575: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1576: printf("\tVFLG = 0;\n");
1577: start_brace ();
1578: switch(table68k[opcode].size) {
1579: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1580: case sz_word: printf("\tUWORD val = data;\n"); break;
1581: case sz_long: printf("\tULONG val = data;\n"); break;
1582: default: abort();
1583: }
1584: switch(table68k[opcode].size) {
1585: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1586: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1587: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1588: default: abort();
1589: }
1590: printf("\tULONG sign = cmask & val;\n");
1591: printf("\tCFLG=XFLG=val&1; val = (val >> 1) | sign;\n");
1592: printf("\tNFLG = sign != 0;\n");
1593: printf("\tZFLG = val == 0;\n");
1594: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1595: break;
1596: case i_ASLW:
1597: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1598: printf("\tVFLG = 0;\n");
1599: start_brace ();
1600: switch(table68k[opcode].size) {
1601: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1602: case sz_word: printf("\tUWORD val = data;\n"); break;
1603: case sz_long: printf("\tULONG val = data;\n"); break;
1604: default: abort();
1605: }
1606: switch(table68k[opcode].size) {
1607: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1608: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1609: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1610: default: abort();
1611: }
1612: printf("\tULONG sign = cmask & val;\n");
1613: printf("\tCFLG=XFLG=(val&cmask)!=0; val <<= 1;\n");
1614: printf("\tif ((val&cmask)!=sign) VFLG=1;\n");
1615: printf("\tNFLG = (val&cmask) != 0;\n");
1616: printf("\tZFLG = val == 0;\n");
1617: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1618: break;
1619: case i_LSRW:
1620: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1621: start_brace ();
1622: switch(table68k[opcode].size) {
1623: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1624: case sz_word: printf("\tUWORD val = data;\n"); break;
1625: case sz_long: printf("\tULONG val = data;\n"); break;
1626: default: abort();
1627: }
1628: printf("\tULONG carry = val&1;\n");
1629: printf("\tval >>= 1;\n");
1630: genflags(flag_logical, table68k[opcode].size, "val", "", "");
1631: printf("CFLG = XFLG = carry!=0;\n");
1632: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1633: break;
1634: case i_LSLW:
1635: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1636: start_brace ();
1637: switch(table68k[opcode].size) {
1638: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1639: case sz_word: printf("\tUWORD val = data;\n"); break;
1640: case sz_long: printf("\tULONG val = data;\n"); break;
1641: default: abort();
1642: }
1643: switch(table68k[opcode].size) {
1644: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1645: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1646: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1647: default: abort();
1648: }
1649: printf("\tULONG carry = val&cmask;\n");
1650: printf("\tval <<= 1;\n");
1651: genflags(flag_logical, table68k[opcode].size, "val", "", "");
1652: printf("CFLG = XFLG = carry!=0;\n");
1653: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1654: break;
1655: case i_ROLW:
1656: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1657: start_brace ();
1658: switch(table68k[opcode].size) {
1659: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1660: case sz_word: printf("\tUWORD val = data;\n"); break;
1661: case sz_long: printf("\tULONG val = data;\n"); break;
1662: default: abort();
1663: }
1664: switch(table68k[opcode].size) {
1665: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1666: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1667: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1668: default: abort();
1669: }
1670: printf("\tULONG carry = val&cmask;\n");
1671: printf("\tval <<= 1;\n");
1672: printf("\tif(carry) val |= 1;\n");
1673: genflags(flag_logical, table68k[opcode].size, "val", "", "");
1674: printf("CFLG = carry!=0;\n");
1675: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1676: break;
1677: case i_RORW:
1678: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1679: start_brace ();
1680: switch(table68k[opcode].size) {
1681: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1682: case sz_word: printf("\tUWORD val = data;\n"); break;
1683: case sz_long: printf("\tULONG val = data;\n"); break;
1684: default: abort();
1685: }
1686: printf("\tULONG carry = val&1;\n");
1687: switch(table68k[opcode].size) {
1688: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1689: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1690: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1691: default: abort();
1692: }
1693: printf("\tval >>= 1;\n");
1694: printf("\tif(carry) val |= cmask;\n");
1695: genflags(flag_logical, table68k[opcode].size, "val", "", "");
1696: printf("CFLG = carry!=0;\n");
1697: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1698: break;
1699: case i_ROXLW:
1700: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1701: start_brace ();
1702: switch(table68k[opcode].size) {
1703: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1704: case sz_word: printf("\tUWORD val = data;\n"); break;
1705: case sz_long: printf("\tULONG val = data;\n"); break;
1706: default: abort();
1707: }
1708: switch(table68k[opcode].size) {
1709: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1710: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1711: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1712: default: abort();
1713: }
1714: printf("\tULONG carry = val&cmask;\n");
1715: printf("\tval <<= 1;\n");
1716: printf("\tif(XFLG) val |= 1;\n");
1717: printf("\tXFLG = carry != 0;\n");
1718: genflags(flag_logical, table68k[opcode].size, "val", "", "");
1719: printf("XFLG = CFLG = carry!=0;\n");
1720: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1721: break;
1722: case i_ROXRW:
1723: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
1724: start_brace ();
1725: switch(table68k[opcode].size) {
1726: case sz_byte: printf("\tUBYTE val = data;\n"); break;
1727: case sz_word: printf("\tUWORD val = data;\n"); break;
1728: case sz_long: printf("\tULONG val = data;\n"); break;
1729: default: abort();
1730: }
1731: printf("\tULONG carry = val&1;\n");
1732: switch(table68k[opcode].size) {
1733: case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
1734: case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
1735: case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
1736: default: abort();
1737: }
1738: printf("\tval >>= 1;\n");
1739: printf("\tif(XFLG) val |= cmask;\n");
1740: printf("\tXFLG = carry != 0;\n");
1741: genflags(flag_logical, table68k[opcode].size, "val", "", "");
1742: printf("XFLG = CFLG = carry!=0;\n");
1743: genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
1744: break;
1745: case i_MOVEC2:
1746: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1747: start_brace();
1748: printf("\tint regno = (src >> 12) & 7;\n");
1749: printf("\tULONG *regp = src & 0x8000 ? regs.a + regno : regs.d + regno;\n");
1750: printf("\tm68k_movec2(src & 0xFFF, regp);\n");
1751: break;
1752: case i_MOVE2C:
1753: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1754: start_brace();
1755: printf("\tint regno = (src >> 12) & 7;\n");
1756: printf("\tULONG *regp = src & 0x8000 ? regs.a + regno : regs.d + regno;\n");
1757: printf("\tm68k_move2c(src & 0xFFF, regp);\n");
1758: break;
1759: case i_CAS:
1760: {
1761: int old_brace_level;
1762: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1763: genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
1764: start_brace();
1765: printf("\tint ru = (src >> 6) & 7;\n");
1766: printf("\tint rc = src & 7;\n");
1767: genflags(flag_cmp, table68k[opcode].size, "newv", "regs.d[rc]", "dst");
1768: printf("\tif (ZFLG)");
1769: old_brace_level = n_braces;
1770: start_brace ();
1771: genastore("(regs.d[ru])",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
1772: pop_braces (old_brace_level);
1773: printf("else");
1774: start_brace ();
1775: printf("regs.d[rc] = dst;\n");
1776: pop_braces (old_brace_level);
1777: }
1778: break;
1779: case i_CAS2:
1780: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1781: printf("\tULONG rn1 = extra & 0x80000000 ? regs.a[(extra >> 28) & 7] : regs.d[(extra >> 28) & 7];\n");
1782: printf("\tULONG rn2 = extra & 0x8000 ? regs.a[(extra >> 12) & 7] : regs.d[(extra >> 12) & 7];\n");
1783: if (table68k[opcode].size == sz_word) {
1784: int old_brace_level = n_braces;
1785: printf("\tUWORD dst1 = get_word(rn1), dst2 = get_word(rn2);\n");
1786: genflags(flag_cmp, table68k[opcode].size, "newv", "regs.d[(extra >> 16) & 7]", "dst1");
1787: printf("\tif (ZFLG) {\n");
1788: genflags(flag_cmp, table68k[opcode].size, "newv", "regs.d[extra & 7]", "dst2");
1789: printf("\tif (ZFLG) {\n");
1790: printf("\tput_word(rn1,regs.d[(extra >> 22) & 7]);\n");
1791: printf("\tput_word(rn1,regs.d[(extra >> 6) & 7]);\n");
1792: printf("\t}}\n");
1793: pop_braces (old_brace_level);
1794: printf("\tif (!ZFLG) {\n");
1795: printf("\tregs.d[(extra >> 22) & 7] = (regs.d[(extra >> 22) & 7] & ~0xffff) | (dst1 & 0xffff);\n");
1796: printf("\tregs.d[(extra >> 6) & 7] = (regs.d[(extra >> 6) & 7] & ~0xffff) | (dst2 & 0xffff);\n");
1797: printf("\t}\n");
1798: } else {
1799: int old_brace_level = n_braces;
1800: printf("\tULONG dst1 = get_long(rn1), dst2 = get_long(rn2);\n");
1801: genflags(flag_cmp, table68k[opcode].size, "newv", "regs.d[(extra >> 16) & 7]", "dst1");
1802: printf("\tif (ZFLG) {\n");
1803: genflags(flag_cmp, table68k[opcode].size, "newv", "regs.d[extra & 7]", "dst2");
1804: printf("\tif (ZFLG) {\n");
1805: printf("\tput_long(rn1,regs.d[(extra >> 22) & 7]);\n");
1806: printf("\tput_long(rn1,regs.d[(extra >> 6) & 7]);\n");
1807: printf("\t}}\n");
1808: pop_braces (old_brace_level);
1809: printf("\tif (!ZFLG) {\n");
1810: printf("\tregs.d[(extra >> 22) & 7] = dst1;\n");
1811: printf("\tregs.d[(extra >> 6) & 7] = dst2;\n");
1812: printf("\t}\n");
1813: }
1814: break;
1815: case i_MOVES: /* ignore DFC and SFC because we have no MMU */
1816: {
1817: int old_brace_level;
1818: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1819: printf("\tif (extra & 0x800)\n");
1820: old_brace_level = n_braces;
1821: start_brace ();
1822: printf("\tULONG src = (extra & 0x8000) ? regs.a[(extra >> 12) & 7] : regs.d[(extra >> 12) & 7];\n");
1823: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
1824: genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
1825: pop_braces (old_brace_level);
1826: printf("else");
1827: start_brace ();
1828: genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 1, 0);
1829: printf("\tif (extra & 0x8000) {\n");
1830: switch(table68k[opcode].size) {
1831: case sz_byte: printf("\tregs.a[(extra >> 12) & 7] = (LONG)(BYTE)src;\n"); break;
1832: case sz_word: printf("\tregs.a[(extra >> 12) & 7] = (LONG)(WORD)src;\n"); break;
1833: case sz_long: printf("\tregs.a[(extra >> 12) & 7] = src;\n"); break;
1834: default: abort();
1835: }
1836: printf("\t} else {\n");
1837: genastore("src", Dreg, "(extra >> 12) & 7", table68k[opcode].size, "");
1838: printf("\t}\n");
1839: pop_braces (old_brace_level);
1840: }
1841: break;
1842: case i_BKPT: /* only needed for hardware emulators */
1843: printf("\top_illg(opcode);\n");
1844: break;
1845: case i_CALLM: /* not present in 68030 */
1846: printf("\top_illg(opcode);\n");
1847: break;
1848: case i_RTM: /* not present in 68030 */
1849: printf("\top_illg(opcode);\n");
1850: break;
1851: case i_TRAPcc:
1852: printf("\tCPTR oldpc = m68k_getpc();\n");
1853: if (table68k[opcode].smode != am_unknown && table68k[opcode].smode != am_illg)
1854: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "dummy", 1, 0);
1855: printf("\tif (cctrue(%d)) Exception(7,oldpc-2);\n", table68k[opcode].cc);
1856: break;
1857: case i_DIVL:
1858: printf("\tCPTR oldpc = m68k_getpc();\n");
1859: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1860: genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
1861: printf("\tm68k_divl(opcode, dst, extra, oldpc);\n");
1862: break;
1863: case i_MULL:
1864: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1865: genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
1866: printf("\tm68k_mull(opcode, dst, extra);\n");
1867: break;
1868: case i_BFTST:
1869: case i_BFEXTU:
1870: case i_BFCHG:
1871: case i_BFEXTS:
1872: case i_BFCLR:
1873: case i_BFFFO:
1874: case i_BFSET:
1875: case i_BFINS:
1876: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1877: genamode (table68k[opcode].dmode, "dstreg", sz_long, "dst", 0, 0);
1878: start_brace();
1879: printf("\tLONG offset = extra & 0x800 ? regs.d[(extra >> 6) & 7] : (extra >> 6) & 0x1f;\n");
1880: printf("\tint width = (((extra & 0x20 ? regs.d[extra & 7] : extra) -1) & 0x1f) +1;\n");
1881: if (table68k[opcode].dmode == Dreg) {
1882: printf("\tULONG tmp = regs.d[dstreg] << (offset & 0x1f);\n");
1883: }
1884: else {
1885: printf("\tULONG tmp,bf0,bf1;\n");
1886: printf("\tdsta += (offset >> 3) | (offset & 0x80000000 ? ~0x1fffffff : 0);\n");
1887: printf("\tbf0 = get_long(dsta);bf1 = get_byte(dsta+4) & 0xff;\n");
1888: printf("\ttmp = (bf0 << (offset & 7)) | (bf1 >> (8 - (offset & 7)));\n");
1889: }
1890: printf("\ttmp >>= (32 - width);\n");
1891: printf("\tNFLG = tmp & (1 << (width-1)) ? 1 : 0;ZFLG = tmp == 0;VFLG = 0;CFLG = 0;\n");
1892: switch(table68k[opcode].mnemo) {
1893: case i_BFTST:
1894: break;
1895: case i_BFEXTU:
1896: printf("\tregs.d[(extra >> 12) & 7] = tmp;\n");
1897: break;
1898: case i_BFCHG:
1899: printf("\ttmp = ~tmp;\n");
1900: break;
1901: case i_BFEXTS:
1902: printf("\tif (NFLG) tmp |= width == 32 ? 0 : (-1 << width);\n");
1903: printf("\tregs.d[(extra >> 12) & 7] = tmp;\n");
1904: break;
1905: case i_BFCLR:
1906: printf("\ttmp = 0;\n");
1907: break;
1908: case i_BFFFO:
1909: printf("\t{ ULONG mask = 1 << (width-1);\n");
1910: printf("\twhile (mask) { if (tmp & mask) break; mask >>= 1; offset++; }}\n");
1911: printf("\tregs.d[(extra >> 12) & 7] = offset;\n");
1912: break;
1913: case i_BFSET:
1914: printf("\ttmp = 0xffffffff;\n");
1915: break;
1916: case i_BFINS:
1917: printf("\ttmp = regs.d[(extra >> 12) & 7];\n");
1918: break;
1919: default:
1920: break;
1921: }
1922: if (table68k[opcode].mnemo == i_BFCHG ||
1923: table68k[opcode].mnemo == i_BFCLR ||
1924: table68k[opcode].mnemo == i_BFSET ||
1925: table68k[opcode].mnemo == i_BFINS) {
1926: printf("\ttmp <<= (32 - width);\n");
1927: if (table68k[opcode].dmode == Dreg) {
1928: printf("\tregs.d[dstreg] = (regs.d[dstreg] & ((offset & 0x1f) == 0 ? 0 :\n");
1929: printf("\t\t(0xffffffff << (32 - (offset & 0x1f))))) |\n");
1930: printf("\t\t(tmp >> (offset & 0x1f)) |\n");
1931: printf("\t\t(((offset & 0x1f) + width) >= 32 ? 0 :\n");
1932: printf(" (regs.d[dstreg] & ((ULONG)0xffffffff >> ((offset & 0x1f) + width))));\n");
1933: }
1934: else {
1935: printf("\tbf0 = (bf0 & (0xff000000 << (8 - (offset & 7)))) |\n");
1936: printf("\t\t(tmp >> (offset & 7)) |\n");
1937: printf("\t\t(((offset & 7) + width) >= 32 ? 0 :\n");
1938: printf("\t\t (bf0 & ((ULONG)0xffffffff >> ((offset & 7) + width))));\n");
1939: printf("\tput_long(dsta,bf0 );\n");
1940: printf("\tif (((offset & 7) + width) > 32) {\n");
1941: printf("\t\tbf1 = (bf1 & (0xff >> (width - 32 + (offset & 7)))) |\n");
1942: printf("\t\t\t(tmp << (8 - (offset & 7)));\n");
1943: printf("\t\tput_byte(dsta+4,bf1);\n");
1944: printf("\t}\n");
1945: }
1946: }
1947: break;
1948: case i_PACK:
1949: if (table68k[opcode].smode == Dreg) {
1950: printf("\tUWORD val = regs.d[srcreg] + nextiword();\n");
1951: printf("\tregs.d[dstreg] = (regs.d[dstreg] & 0xffffff00) | ((val >> 4) & 0xf0) | (val & 0xf);\n");
1952: }
1953: else {
1954: printf("\tUWORD val;\n");
1955: printf("\tregs.a[srcreg] -= areg_byteinc[srcreg];\n");
1956: printf("\tval = (UWORD)get_byte(regs.a[srcreg]);\n");
1957: printf("\tregs.a[srcreg] -= areg_byteinc[srcreg];\n");
1958: printf("\tval = (val | ((UWORD)get_byte(regs.a[srcreg]) << 8)) + nextiword();\n");
1959: printf("\tregs.a[dstreg] -= areg_byteinc[dstreg];\n");
1960: printf("\tput_byte(regs.a[dstreg],((val >> 4) & 0xf0) | (val & 0xf));\n");
1961: }
1962: break;
1963: case i_UNPK:
1964: if (table68k[opcode].smode == Dreg) {
1965: printf("\tUWORD val = regs.d[srcreg];\n");
1966: printf("\tval = (((val << 4) & 0xf00) | (val & 0xf)) + nextiword();\n");
1967: printf("\tregs.d[dstreg] = (regs.d[dstreg] & 0xffff0000) | (val & 0xffff);\n");
1968: }
1969: else {
1970: printf("\tUWORD val;\n");
1971: printf("\tregs.a[srcreg] -= areg_byteinc[srcreg];\n");
1972: printf("\tval = (UWORD)get_byte(regs.a[srcreg]);\n");
1973: printf("\tval = (((val << 4) & 0xf00) | (val & 0xf)) + nextiword();\n");
1974: printf("\tregs.a[dstreg] -= areg_byteinc[dstreg];\n");
1975: printf("\tput_byte(regs.a[dstreg],val);\n");
1976: printf("\tregs.a[dstreg] -= areg_byteinc[dstreg];\n");
1977: printf("\tput_byte(regs.a[dstreg],val >> 8);\n");
1978: }
1979: break;
1980: case i_TAS:
1981: genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
1982: genflags(flag_logical, table68k[opcode].size, "src", "", "");
1983: printf("\tsrc |= 0x80;\n");
1984: genastore("src", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
1985: break;
1986: case i_FPP:
1987: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1988: printf("\tfpp_opp(opcode,extra);\n");
1989: break;
1990: case i_FDBcc:
1991: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1992: printf("\tfdbcc_opp(opcode,extra);\n");
1993: break;
1994: case i_FScc:
1995: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
1996: printf("\tfscc_opp(opcode,extra);\n");
1997: break;
1998: case i_FTRAPcc:
1999: printf("\tCPTR oldpc = m68k_getpc();\n");
2000: if (table68k[opcode].smode != am_unknown && table68k[opcode].smode != am_illg)
2001: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "dummy", 1, 0);
2002: printf("\tftrapcc_opp(opcode,oldpc);\n");
2003: break;
2004: case i_FBcc:
2005: printf("\tCPTR pc = m68k_getpc();\n");
2006: genamode (table68k[opcode].dmode, "srcreg", table68k[opcode].size, "extra", 1, 0);
2007: printf("\tfbcc_opp(opcode,pc,extra);\n");
2008: break;
2009: case i_FSAVE:
2010: printf("\tfsave_opp(opcode);\n");
2011: break;
2012: case i_FRESTORE:
2013: printf("\tfrestore_opp(opcode);\n");
2014: break;
2015: case i_MMUOP:
2016: genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
2017: printf("\tmmu_op(opcode,extra);\n");
2018: break;
2019: default:
2020: abort();
2021: break;
2022: };
2023: finish_braces ();
2024: }
2025:
2026: static void generate_func(long int from, long int to)
2027: {
2028: int illg = 0;
2029: long int opcode;
2030: int i;
2031: UWORD smsk;
2032: UWORD dmsk;
2033:
2034: printf("#include \"sysconfig.h\"\n");
2035: printf("#include \"sysdeps.h\"\n");
2036: printf("#include \"config.h\"\n");
2037: printf("#include \"options.h\"\n");
2038: printf("#include \"memory.h\"\n");
2039: printf("#include \"custom.h\"\n");
2040: printf("#include \"newcpu.h\"\n");
2041: printf("#include \"cputbl.h\"\n");
2042: for(opcode=from; opcode < to; opcode++) {
2043: if (table68k[opcode].mnemo == i_ILLG) {
2044: illg++;
2045: continue;
2046: }
2047: for (i = 0 ; lookuptab[i].name[0] ; i++) {
2048: if (table68k[opcode].mnemo == lookuptab[i].mnemo)
2049: break;
2050: }
2051: if (isspecific(opcode)) {
2052: printf("void op_%lx_s(ULONG opcode) /* %s */\n{\n", opcode, lookuptab[i].name);
2053: if (table68k[opcode].suse
2054: && table68k[opcode].smode != imm && table68k[opcode].smode != imm0
2055: && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2
2056: && table68k[opcode].smode != absw && table68k[opcode].smode != absl
2057: && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16)
2058: {
2059: if (((int)table68k[opcode].sreg) >= 128)
2060: printf("\tULONG srcreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].sreg);
2061: else
2062: printf("\tULONG srcreg = %d;\n", (int)table68k[opcode].sreg);
2063: }
2064: if (table68k[opcode].duse
2065: /* Yes, the dmode can be imm, in case of LINK or DBcc */
2066: && table68k[opcode].dmode != imm && table68k[opcode].dmode != imm0
2067: && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2
2068: && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl)
2069: {
2070: if (((int)table68k[opcode].dreg) >= 128)
2071: printf("\tULONG dstreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].dreg);
2072: else
2073: printf("\tULONG dstreg = %d;\n", (int)table68k[opcode].dreg);
2074: }
2075: gen_opcode(opcode);
2076: printf("}\n");
2077: }
2078:
2079: if (table68k[opcode].handler != -1)
2080: continue;
2081:
2082:
2083: switch (table68k[opcode].stype) {
2084: case 0:
2085: smsk = 7; break;
2086: case 1:
2087: smsk = 255; break;
2088: case 2:
2089: smsk = 15; break;
2090: case 3:
2091: smsk = 7; break;
2092: case 4:
2093: smsk = 7; break;
2094: case 5:
2095: smsk = 63; break;
2096: default:
2097: abort();
2098: }
2099: dmsk = 7;
2100:
2101: printf("void op_%lx(ULONG opcode) /* %s */\n{\n", opcode, lookuptab[i].name);
2102: if (table68k[opcode].suse
2103: && table68k[opcode].smode != imm && table68k[opcode].smode != imm0
2104: && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2
2105: && table68k[opcode].smode != absw && table68k[opcode].smode != absl
2106: && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16)
2107: {
2108: if (table68k[opcode].spos == -1) {
2109: if (((int)table68k[opcode].sreg) >= 128)
2110: printf("\tULONG srcreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].sreg);
2111: else
2112: printf("\tULONG srcreg = %d;\n", (int)table68k[opcode].sreg);
2113: } else {
2114: char source[100];
2115:
2116: if (table68k[opcode].spos)
2117: sprintf(source,"((opcode >> %d) & %d)",(int)table68k[opcode].spos,smsk);
2118: else
2119: sprintf(source,"(opcode & %d)",smsk);
2120:
2121: if (table68k[opcode].stype == 3)
2122: printf("\tULONG srcreg = imm8_table[%s];\n", source);
2123: else if (table68k[opcode].stype == 1)
2124: printf("\tULONG srcreg = (LONG)(BYTE)%s;\n", source);
2125: else
2126: printf("\tULONG srcreg = %s;\n", source);
2127: }
2128: }
2129: if (table68k[opcode].duse
2130: /* Yes, the dmode can be imm, in case of LINK or DBcc */
2131: && table68k[opcode].dmode != imm && table68k[opcode].dmode != imm0
2132: && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2
2133: && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl) {
2134: if (table68k[opcode].dpos == -1) {
2135: if (((int)table68k[opcode].dreg) >= 128)
2136: printf("\tULONG dstreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].dreg);
2137: else
2138: printf("\tULONG dstreg = %d;\n", (int)table68k[opcode].dreg);
2139: } else {
2140: if (table68k[opcode].dpos)
2141: printf("\tULONG dstreg = (opcode >> %d) & %d;\n",
2142: (int)table68k[opcode].dpos,dmsk);
2143: else
2144: printf("\tULONG dstreg = opcode & %d;\n", dmsk);
2145: }
2146: }
2147: gen_opcode(opcode);
2148: printf("}\n");
2149: }
2150:
2151: fprintf (stderr, "%d illegals generated.\n", illg);
2152: }
2153:
2154: static void generate_table(void)
2155: {
2156: int illg = 0;
2157: long int opcode;
2158:
2159: printf("#include \"sysconfig.h\"\n");
2160: printf("#include \"sysdeps.h\"\n");
2161: printf("#include \"config.h\"\n");
2162: printf("#include \"options.h\"\n");
2163: printf("#include \"memory.h\"\n");
2164: printf("#include \"custom.h\"\n");
2165: printf("#include \"newcpu.h\"\n");
2166: printf("#include \"cputbl.h\"\n");
2167:
2168: printf("cpuop_func *cpufunctbl[65536] = {\n");
2169: for(opcode=0; opcode < 65536; opcode++) {
2170: if (table68k[opcode].mnemo == i_ILLG) {
2171: printf("op_illg");
2172: illg++;
2173: } else if (isspecific(opcode))
2174: printf("op_%lx_s", opcode);
2175: else if (table68k[opcode].handler != -1)
2176: printf("op_%lx", table68k[opcode].handler);
2177: else
2178: printf("op_%lx", opcode);
2179:
2180: if (opcode < 65535) printf(",");
2181: if ((opcode & 7) == 7) printf("\n");
2182: }
2183: printf("\n};\n");
2184: fprintf (stderr, "%d illegals generated.\n", illg);
2185: if (get_no_mismatches())
2186: fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
2187: }
2188:
2189: static void generate_smalltable(void)
2190: {
2191: long int opcode;
2192: int i;
2193:
2194: printf("#include \"sysconfig.h\"\n");
2195: printf("#include \"sysdeps.h\"\n");
2196: printf("#include \"config.h\"\n");
2197: printf("#include \"options.h\"\n");
2198: printf("#include \"memory.h\"\n");
2199: printf("#include \"custom.h\"\n");
2200: printf("#include \"newcpu.h\"\n");
2201: printf("#include \"cputbl.h\"\n");
2202:
2203: printf("struct cputbl smallcputbl[] = {\n");
2204: for(opcode=0; opcode < 65536; opcode++) {
2205: if ((isspecific(opcode) || table68k[opcode].handler == -1)
2206: && table68k[opcode].mnemo != i_ILLG)
2207: {
2208: for (i = 0 ; lookuptab[i].name[0] ; i++) {
2209: if (table68k[opcode].mnemo == lookuptab[i].mnemo)
2210: break;
2211: }
2212: if (isspecific(opcode))
2213: printf("{ op_%lx_s, 1, %ld }, /* %s */\n", opcode, opcode, lookuptab[i].name);
2214: if (table68k[opcode].handler == -1)
2215: printf("{ op_%lx, 0, %ld }, /* %s */\n", opcode, opcode, lookuptab[i].name);
2216: }
2217: }
2218: printf("{ 0, 0, 0 }};\n");
2219: }
2220:
2221: static void generate_header(void)
2222: {
2223: int illg = 0;
2224: long int opcode;
2225:
2226: for(opcode=0; opcode < 65536; opcode++) {
2227: if (table68k[opcode].mnemo == i_ILLG) {
2228: illg++;
2229: continue;
2230: }
2231: if (isspecific(opcode))
2232: printf("extern cpuop_func op_%lx_s;\n", opcode);
2233: if (table68k[opcode].handler != -1)
2234: continue;
2235:
2236: printf("extern cpuop_func op_%lx;\n", opcode);
2237: }
2238:
2239: fprintf (stderr, "%d illegals generated.\n", illg);
2240: if (get_no_mismatches())
2241: fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
2242: }
2243:
2244: int main(int argc, char **argv)
2245: {
2246: long int range = -1;
2247: char mode = 'n';
2248:
2249: if (argc == 2)
2250: mode = *argv[1];
2251:
2252: if (argc == 3) {
2253: range = atoi(argv[2]);
2254: mode = *argv[1];
2255: }
2256:
2257: read_table68k ();
2258: read_counts();
2259: do_merges ();
2260:
2261: switch(mode) {
2262: case 'f':
2263: generate_func(range * 0x1000, (range + 1) * 0x1000);
2264: break;
2265: case 'h':
2266: generate_header();
2267: break;
2268: case 't':
2269: generate_table();
2270: break;
2271: case 's':
2272: generate_smalltable();
2273: break;
2274: default:
2275: abort();
2276: }
2277: free(table68k);
2278: return 0;
2279: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.