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