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