![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to def68k.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / src|
Return to def68k.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / src |
1.1 root 1: /*****************************************************************************/
2: /* Generator - Sega Genesis emulation - (c) James Ponder 1997-1998 */
3: /*****************************************************************************/
4: /* */
5: /* def68k.c */
6: /* */
7: /*****************************************************************************/
8:
9: #include <errno.h>
10: #include <stdio.h>
11: #include <string.h>
12: #include <ctype.h>
13: #include <stdlib.h>
14:
15: #include "generator.h"
16:
17: #define BUFLEN 1024
18: #define FNAME_CPUDEF "def68k.def"
19: #define FNAME_OUTIIBS "out/def68k-iibs.h"
20: #define FNAME_OUTFUNCS "out/def68k-funcs.h"
21: #define FNAME_OUTPROTO "out/def68k-proto.h"
22:
23: typedef enum {
24: bit0, bit1, bitz, bite, bitE, bitf, bitF, biti, bitn, bitN, bitc, bitv
25: } t_bit;
26:
27: /* file-scope global variables */
28:
29: static int total = 0;
30:
31: /* private functions for forward references */
32:
33: void procline(char *line, int lineno, FILE *outiibs, FILE *outfuncs,
34: FILE *outproto);
35: int clocks_ea(t_datatype type);
36: int clocks_eacalc(t_datatype type, t_size size);
37: int clocks_eafetch(t_datatype type, t_size size);
38: int clocks_standard(t_datatype stype, t_datatype dtype, t_size size);
39: int clocks_single(t_datatype type, t_size size);
40:
41: /* program entry routine */
42:
43: int main(int argc, char *argv[])
44: {
45: FILE *input, *outiibs, *outfuncs, *outproto;
46: char buf[BUFLEN], *p;
47: int lineno = 0;
48:
49: /* open output files and write headers */
50:
51: if ((outiibs = fopen(FNAME_OUTIIBS, "w")) == NULL) {
52: perror("fopen outiibs");
53: exit(1);
54: }
55: fprintf(outiibs, "/* automatically generated by def68k.c */\n\n");
56: fprintf(outiibs, "t_iib iibs[] = {\n");
57: fprintf(outiibs, " /* mask, bits, mnemonic, { priv, endblk, zero, ");
58: fprintf(outiibs, "used, set },\n");
59: fprintf(outiibs, " size, stype, dtype, sbitpos, dbitpos, immvalue, ");
60: fprintf(outiibs, "cc, funcnum */\n");
61:
62: if ((outfuncs = fopen(FNAME_OUTFUNCS, "w")) == NULL) {
63: perror("fopen outfuncs");
64: exit(1);
65: }
66: fprintf(outfuncs, "/* automatically generated by def68k.c */\n\n");
67: fprintf(outfuncs, "void (*cpu68k_funcindex[])(t_ipc *ipc) = {\n");
68: fprintf(outfuncs, " /* function */\n");
69:
70: if ((outproto = fopen(FNAME_OUTPROTO, "w")) == NULL) {
71: perror("fopen outproto");
72: exit(1);
73: }
74: fprintf(outproto, "/* automatically generated by def68k.c */\n\n");
75:
76: /* open input file */
77:
78: if ((input = fopen(FNAME_CPUDEF, "r")) == NULL) {
79: perror("fopen input");
80: exit(1);
81: }
82:
83: /* loop until end of file */
84:
85: printf("Writing CPU definitions... ");
86: fflush(stdout);
87:
88: while (!feof(input)) {
89: /* use unix line numbering from 1 */
90: lineno++;
91: /* read a line */
92: if (ferror(input)) {
93: break;
94: }
95: if (fgets(buf, BUFLEN, input) == NULL) {
96: break;
97: /* huh? why does this cause fgets to say 'Unknown error'?! */
98: perror("fgets");
99: exit(1);
100: }
101: /* remove newline */
102: buf[strlen(buf)-1] = '\0';
103: /* remove comment */
104: if ((p = strchr(buf, ';')) != NULL) {
105: *p = '\0';
106: }
107: /* remove leading spaces */
108: p = buf;
109: while (*p == ' ')
110: p++;
111: /* blank line? */
112: if (!*p)
113: continue;
114: /* process line */
115: procline(buf, lineno, outiibs, outfuncs, outproto);
116: }
117:
118: /* close input */
119:
120: if (fclose(input)) {
121: perror("fclose input");
122: exit(1);
123: }
124:
125: /* output footer */
126:
127: fprintf(outiibs, " { 0, 0, 0, { 0, 0, 0, 0, 0 }, "
128: "0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }\n");
129: fprintf(outiibs, "};\n");
130: fprintf(outiibs, "int iibs_num = %d;\n", total);
131:
132: fprintf(outfuncs, "};\n");
133:
134: /* close outputs */
135:
136: if (fclose(outiibs)) {
137: perror("fclose outiibs");
138: exit(1);
139: }
140: if (fclose(outfuncs)) {
141: perror("fclose outfuncs");
142: exit(1);
143: }
144: if (fclose(outproto)) {
145: perror("fclose outproto");
146: exit(1);
147: }
148:
149: printf("done.\n");
150: fflush(stdout);
151:
152: return(0);
153: }
154:
155: /* process a line */
156:
157: void procline(char *line, int lineno, FILE *outiibs, FILE *outfuncs,
158: FILE *outproto) {
159: int i;
160: char *p;
161: t_bit bit = bit0, lastbit = bit0;
162: int start[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
163: int num[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
164: char mnemonic[16], *m;
165: int setting;
166: int clocks;
167:
168: /* parameters to fill in about instruction */
169: int mnemonic_num;
170: uint16 mask = 0, bits = 0; /* see struct t_iib for details on */
171: int priv = 0, endblk = 0; /* these variables */
172: int imm_notzero = 0;
173: int used = 0, set = 0;
174: t_size isize = sz_none;
175: int expand_s_immsize = 0, expand_s_ea_e = 0;
176: int expand_d_ea_e = 0, expand_d_ea_f = 0;
177: t_datatype dtype = dt_Ill;
178: t_datatype stype = dt_Ill;
179: int e[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
180: int f[16] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
181: int immvalue = 0;
182: int sbitpos = 0, dbitpos = 0;
183:
184: p = line;
185:
186: /* bitpattern */
187:
188: for (i = 15; i >= 0; i--) {
189: while (*p == ' ')
190: p++;
191:
192: switch(*p) {
193: case '0': bit = bit0; mask |= 1<<i; break;
194: case '1': bit = bit1; mask |= 1<<i; bits |= 1<<i; break;
195: case 'z': bit = bitz; break;
196: case 'e': bit = bite; break;
197: case 'E': bit = bitE; break;
198: case 'f': bit = bitf; break;
199: case 'F': bit = bitF; break;
200: case 'n': bit = bitn; break;
201: case 'N': bit = bitN; break;
202: case 'i': bit = biti; break;
203: case 'c': bit = bitc; break;
204: case 'V': bit = bitv; break;
205: default:
206: fprintf(stderr, "%d: unknown char %c in bitpattern\n", lineno, *p);
207: exit(1);
208: }
209:
210: if (*p != '0' && *p != '1') {
211: if (num[bit]) {
212: /* we've seen this bit before, make sure the last bit was the same */
213: if (bit < 15 && bit != lastbit) {
214: fprintf(stderr, "%d: Non contiguous bits of %c\n", lineno, *p);
215: exit(1);
216: }
217: }
218: /* we're looping down, so the last time start[bit] is set is the start */
219: start[bit] = i;
220: /* record how many of these bits there are */
221: num[bit]++;
222: }
223: p++;
224: lastbit = bit;
225: }
226: /* skip spaces and skip tab to get to next field */
227: while (*p == ' ')
228: p++;
229: if (*p++ != '\t') {
230: fprintf(stderr, "%d: Tab not found at end of bitpattern\n", lineno);
231: exit(1);
232: }
233:
234: /* misc flags */
235:
236: if (*p == '0') {
237: priv = 0;
238: } else if (*p == '1') {
239: priv = 1;
240: } else {
241: fprintf(stderr, "%d: Priv flag not 0 or 1\n", lineno);
242: exit(1);
243: }
244: p++;
245: /* skip spaces to next field */
246: while (*p == ' ')
247: p++;
248: if (*p == '0') {
249: endblk = 0;
250: } else if (*p == '1') {
251: endblk = 1;
252: } else {
253: fprintf(stderr, "%d: End-block flag not 0 or 1\n", lineno);
254: exit(1);
255: }
256: p++;
257: /* skip spaces and skip tab to get to next field */
258: while (*p == ' ')
259: p++;
260: if (*p++ != '\t') {
261: fprintf(stderr, "%d: Tab not found at end of flags\n", lineno);
262: exit(1);
263: }
264:
265: /* used flags */
266:
267: for (i = 0; i < 5; i++) {
268: while (*p == ' ')
269: p++;
270: switch(*p++) {
271: case '-': break;
272: case 'x': break;
273: case 'X': used |= 1<<i; break;
274: case 'N': used |= 1<<i; break;
275: case 'Z': used |= 1<<i; break;
276: case 'V': used |= 1<<i; break;
277: case 'C': used |= 1<<i; break;
278: case '0': used |= 1<<i; break;
279: case '1': used |= 1<<i; break;
280: default:
281: fprintf(stderr, "%d: Did not understand used flag %d\n", lineno, i);
282: exit(1);
283: }
284: }
285: /* skip spaces and skip tab to get to next field */
286: while (*p == ' ')
287: p++;
288: if (*p++ != '\t') {
289: fprintf(stderr, "%d: Tab not found at end of used flags\n", lineno);
290: exit(1);
291: }
292:
293: /* set flags */
294:
295: for (i = 0; i < 5; i++) {
296: while (*p == ' ')
297: p++;
298: switch(*p++) {
299: case '-': break;
300: case 'x': break;
301: case 'X': set |= 1<<i; break;
302: case 'N': set |= 1<<i; break;
303: case 'Z': set |= 1<<i; break;
304: case 'V': set |= 1<<i; break;
305: case 'C': set |= 1<<i; break;
306: case '0': set |= 1<<i; break;
307: case '1': set |= 1<<i; break;
308: default:
309: fprintf(stderr, "%d: Did not understand set flag %d\n", lineno, i);
310: exit(1);
311: }
312: }
313: /* skip spaces and skip tab to get to next field */
314: while (*p == ' ')
315: p++;
316: if (*p++ != '\t') {
317: fprintf(stderr, "%d: Tab not found at end of set flags\n", lineno);
318: exit(1);
319: }
320:
321: /* mnemonic */
322:
323: m = mnemonic;
324: while (*p && (*p != '.') && (*p != ' ') && (*p != '\t')) {
325: *m++ = *p++;
326: }
327: if (*p == '\t') {
328: fprintf(stderr, "%d: Incorrect number of fields - extra tab found\n",
329: lineno);
330: exit(1);
331: }
332: *m = '\0';
333: for (mnemonic_num = 0; *mnemonic_table[mnemonic_num].name; mnemonic_num++)
334: if (!strcmp(mnemonic_table[mnemonic_num].name, mnemonic))
335: break;
336: if (!*mnemonic_table[mnemonic_num].name) {
337: fprintf(stderr, "%d: Unknown mnemonic '%s'\n", lineno, mnemonic);
338: exit(1);
339: }
340: /* set defaults for isize */
341: isize = sz_none;
342: if (*p == '.') {
343: switch(*++p) {
344: case 'B': isize = sz_byte; break;
345: case 'W': isize = sz_word; break;
346: case 'L': isize = sz_long; break;
347: case 'z':
348: if (!num[bitz]) {
349: fprintf(stderr, "%d: 'z' given as size but no 'z' in bit pattern\n",
350: lineno);
351: exit(1);
352: }
353: /* size will be set automatically later */
354: break;
355: default:
356: fprintf(stderr, "%d: Unknown size '%c' after mnemonic\n",
357: lineno, *p);
358: exit(1);
359: }
360: p++;
361: } else {
362: /* instruction is not sized */
363: if (num[bitz]) {
364: /* oh, perhaps it is but it's a mistake */
365: fprintf(stderr, "%d: 'z's in bit pattern but no .z after mnemonic\n",
366: lineno);
367: exit(1);
368: }
369: }
370: while (*p == ' ')
371: p++;
372: if (*p == '\0') {
373: /* no source and destination information given */
374: if (num[bite] || num[bitE] || num[bitf] || num[bitF] ||
375: num[biti] || num[bitn] || num[bitN] || num[bitv]) {
376: fprintf(stderr, "%d: No information given after mnemonic\n", lineno);
377: exit(1);
378: }
379: } else {
380: switch(*p++) {
381: case 'n':
382: case 'N':
383: if (*(p-1) == 'n') {
384: sbitpos = start[bitn];
385: } else {
386: sbitpos = start[bitN];
387: }
388: if (*p++ != '(') {
389: fprintf(stderr, "%d: missing qualifier for n()\n", lineno);
390: exit(1);
391: }
392: if (!strncmp(p, "Dreg", 4)) { stype = dt_Dreg; p = p+4;
393: } else if (!strncmp(p, "Areg", 4)) { stype = dt_Areg; p = p+4;
394: } else if (!strncmp(p, "Aind", 4)) { stype = dt_Aind; p = p+4;
395: } else if (!strncmp(p, "Ainc", 4)) { stype = dt_Ainc; p = p+4;
396: } else if (!strncmp(p, "Adec", 4)) { stype = dt_Adec; p = p+4;
397: } else if (!strncmp(p, "Adis", 4)) { stype = dt_Adis; p = p+4;
398: } else if (!strncmp(p, "Aidx", 4)) { stype = dt_Aidx; p = p+4;
399: } else if (!strncmp(p, "AbsW", 4)) { stype = dt_AbsW; p = p+4;
400: } else if (!strncmp(p, "AbsL", 4)) { stype = dt_AbsL; p = p+4;
401: } else if (!strncmp(p, "Pdis", 4)) { stype = dt_Pdis; p = p+4;
402: } else if (!strncmp(p, "Pidx", 4)) { stype = dt_Pidx; p = p+4;
403: } else {
404: fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
405: exit(1);
406: }
407: if (*p++ != ')') {
408: fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
409: exit(1);
410: }
411: break;
412: case '#':
413: switch(*p++) {
414: case 'B': stype = dt_ImmB; break;
415: case 'W': stype = dt_ImmW; break;
416: case 'L': stype = dt_ImmL; break;
417: case 'z': expand_s_immsize = 1; break;
418: case 's':
419: if (num[biti] != 8) {
420: fprintf(stderr, "%d: sign extend not from 8 bits\n", lineno);
421: exit(1);
422: }
423: stype = dt_Imm8s;
424: break;
425: case 'i':
426: switch (num[biti]) {
427: case 3: stype = dt_Imm3; break;
428: case 4: stype = dt_Imm4; break;
429: case 8: stype = dt_Imm8; break;
430: default:
431: fprintf(stderr, "%d: unknown immediate data size or bad dimension\n",
432: lineno);
433: exit(1);
434: }
435: sbitpos = start[biti];
436: break;
437: case 'I':
438: imm_notzero = 1;
439: switch (num[biti]) {
440: case 3: stype = dt_Imm3; break;
441: case 4: stype = dt_Imm4; break;
442: case 8: stype = dt_Imm8; break;
443: default:
444: fprintf(stderr, "%d: unknown immediate data size or bad dimension\n",
445: lineno);
446: exit(1);
447: }
448: sbitpos = start[biti];
449: break;
450: case 'V':
451: stype = dt_ImmV;
452: sbitpos = start[bitv];
453: break;
454: default:
455: p--;
456: if (isdigit((int)*p)) {
457: immvalue = strtol(p, &p, 10);
458: stype = dt_ImmS;
459: } else {
460: fprintf(stderr, "%d: unknown source immediate type #%c\n",
461: lineno, *(p-1));
462: exit(1);
463: }
464: }
465: break;
466: case 'e':
467: expand_s_ea_e = 1;
468:
469: if (*p++ != '(') {
470: fprintf(stderr, "%d: missing qualifier for EA\n", lineno);
471: exit(1);
472: }
473: do {
474: setting = 1;
475: if (*p == '-') {
476: p++;
477: setting = 0;
478: }
479: if (!strncmp(p, "*", 1)) {
480: e[ea_Dreg] = e[ea_Areg] = e[ea_Aind] = e[ea_Ainc] = setting;
481: e[ea_Adec] = e[ea_Adis] = e[ea_Aidx] = e[ea_AbsW] = setting;
482: e[ea_AbsL] = e[ea_Pdis] = e[ea_Pidx] = e[ea_Imm] = setting;
483: p = p+1;
484: } else if (!strncmp(p, "Regs", 4)) {
485: e[ea_Dreg] = e[ea_Areg] = setting;
486: p = p+4;
487: } else if (!strncmp(p, "PC", 2)) {
488: e[ea_Pdis] = e[ea_Pidx] = setting;
489: p = p+2;
490: } else if (!strncmp(p, "Amod", 4)) {
491: e[ea_Ainc] = e[ea_Adec] = setting;
492: p = p+4;
493: } else if (!strncmp(p, "Dreg", 4)) { e[ea_Dreg] = setting; p = p+4;
494: } else if (!strncmp(p, "Areg", 4)) { e[ea_Areg] = setting; p = p+4;
495: } else if (!strncmp(p, "Aind", 4)) { e[ea_Aind] = setting; p = p+4;
496: } else if (!strncmp(p, "Ainc", 4)) { e[ea_Ainc] = setting; p = p+4;
497: } else if (!strncmp(p, "Adec", 4)) { e[ea_Adec] = setting; p = p+4;
498: } else if (!strncmp(p, "Adis", 4)) { e[ea_Adis] = setting; p = p+4;
499: } else if (!strncmp(p, "Aidx", 4)) { e[ea_Aidx] = setting; p = p+4;
500: } else if (!strncmp(p, "AbsW", 4)) { e[ea_AbsW] = setting; p = p+4;
501: } else if (!strncmp(p, "AbsL", 4)) { e[ea_AbsL] = setting; p = p+4;
502: } else if (!strncmp(p, "Pdis", 4)) { e[ea_Pdis] = setting; p = p+4;
503: } else if (!strncmp(p, "Pidx", 4)) { e[ea_Pidx] = setting; p = p+4;
504: } else if (!strncmp(p, "Imm", 3)) { e[ea_Imm] = setting; p = p+3;
505: } else {
506: fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
507: exit(1);
508: }
509: } while (*p++ == ',');
510: if (*(p-1) != ')') {
511: fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
512: exit(1);
513: }
514: break;
515: default:
516: fprintf(stderr, "%d: did not understand source operand\n", lineno);
517: exit(1);
518: }
519: if (*p == ',') {
520: /* there is a destination part */
521: p++;
522: switch(*p++) {
523: case 'n':
524: case 'N':
525: if (*(p-1) == 'n') {
526: dbitpos = start[bitn];
527: } else {
528: dbitpos = start[bitN];
529: }
530: if (*p++ != '(') {
531: fprintf(stderr, "%d: missing qualifier for n()\n", lineno);
532: exit(1);
533: }
534: if (!strncmp(p, "Dreg", 4)) { dtype = dt_Dreg; p = p+4;
535: } else if (!strncmp(p, "Areg", 4)) { dtype = dt_Areg; p = p+4;
536: } else if (!strncmp(p, "Aind", 4)) { dtype = dt_Aind; p = p+4;
537: } else if (!strncmp(p, "Ainc", 4)) { dtype = dt_Ainc; p = p+4;
538: } else if (!strncmp(p, "Adec", 4)) { dtype = dt_Adec; p = p+4;
539: } else if (!strncmp(p, "Adis", 4)) { dtype = dt_Adis; p = p+4;
540: } else if (!strncmp(p, "Aidx", 4)) { dtype = dt_Aidx; p = p+4;
541: } else if (!strncmp(p, "AbsW", 4)) { dtype = dt_AbsW; p = p+4;
542: } else if (!strncmp(p, "AbsL", 4)) { dtype = dt_AbsL; p = p+4;
543: } else if (!strncmp(p, "Pdis", 4)) { dtype = dt_Pdis; p = p+4;
544: } else if (!strncmp(p, "Pidx", 4)) { dtype = dt_Pidx; p = p+4;
545: } else {
546: fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
547: exit(1);
548: }
549: if (*p++ != ')') {
550: fprintf(stderr, "%d: unknown qualifier for n()\n", lineno);
551: exit(1);
552: }
553: break;
554: case 'e':
555: expand_d_ea_e = 1;
556:
557: if (*p++ != '(') {
558: fprintf(stderr, "%d: missing qualifier for EA\n", lineno);
559: exit(1);
560: }
561: do {
562: setting = 1;
563: if (*p == '-') {
564: p++;
565: setting = 0;
566: }
567: if (!strncmp(p, "*", 1)) {
568: e[ea_Dreg] = e[ea_Areg] = e[ea_Aind] = e[ea_Ainc] = setting;
569: e[ea_Adec] = e[ea_Adis] = e[ea_Aidx] = e[ea_AbsW] = setting;
570: e[ea_AbsL] = e[ea_Pdis] = e[ea_Pidx] = e[ea_Imm] = setting;
571: p = p+1;
572: } else if (!strncmp(p, "Regs", 4)) {
573: e[ea_Dreg] = e[ea_Areg] = setting;
574: p = p+4;
575: } else if (!strncmp(p, "PC", 2)) {
576: e[ea_Pdis] = e[ea_Pidx] = setting;
577: p = p+2;
578: } else if (!strncmp(p, "Amod", 4)) {
579: e[ea_Ainc] = e[ea_Adec] = setting;
580: p = p+4;
581: } else if (!strncmp(p, "Dreg", 4)) { e[ea_Dreg] = setting; p = p+4;
582: } else if (!strncmp(p, "Areg", 4)) { e[ea_Areg] = setting; p = p+4;
583: } else if (!strncmp(p, "Aind", 4)) { e[ea_Aind] = setting; p = p+4;
584: } else if (!strncmp(p, "Ainc", 4)) { e[ea_Ainc] = setting; p = p+4;
585: } else if (!strncmp(p, "Adec", 4)) { e[ea_Adec] = setting; p = p+4;
586: } else if (!strncmp(p, "Adis", 4)) { e[ea_Adis] = setting; p = p+4;
587: } else if (!strncmp(p, "Aidx", 4)) { e[ea_Aidx] = setting; p = p+4;
588: } else if (!strncmp(p, "AbsW", 4)) { e[ea_AbsW] = setting; p = p+4;
589: } else if (!strncmp(p, "AbsL", 4)) { e[ea_AbsL] = setting; p = p+4;
590: } else if (!strncmp(p, "Pdis", 4)) { e[ea_Pdis] = setting; p = p+4;
591: } else if (!strncmp(p, "Pidx", 4)) { e[ea_Pidx] = setting; p = p+4;
592: } else if (!strncmp(p, "Imm", 3)) { e[ea_Imm] = setting; p = p+3;
593: } else {
594: fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
595: exit(1);
596: }
597: } while (*p++ == ',');
598: if (*(p-1) != ')') {
599: fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
600: exit(1);
601: }
602: break;
603: case 'f':
604: expand_d_ea_f = 1;
605:
606: if (*p++ != '(') {
607: fprintf(stderr, "%d: missing qualifier for EA\n", lineno);
608: exit(1);
609: }
610: do {
611: setting = 1;
612: if (*p == '-') {
613: p++;
614: setting = 0;
615: }
616: if (!strncmp(p, "*", 1)) {
617: f[ea_Dreg] = f[ea_Areg] = f[ea_Aind] = f[ea_Ainc] = setting;
618: f[ea_Adec] = f[ea_Adis] = f[ea_Aidx] = f[ea_AbsW] = setting;
619: f[ea_AbsL] = f[ea_Pdis] = f[ea_Pidx] = f[ea_Imm] = setting;
620: p = p+1;
621: } else if (!strncmp(p, "Regs", 4)) {
622: f[ea_Dreg] = f[ea_Areg] = setting;
623: p = p+4;
624: } else if (!strncmp(p, "PC", 2)) {
625: f[ea_Pdis] = f[ea_Pidx] = setting;
626: p = p+2;
627: } else if (!strncmp(p, "Amod", 4)) {
628: f[ea_Ainc] = f[ea_Adec] = setting;
629: p = p+4;
630: } else if (!strncmp(p, "Dreg", 4)) { f[ea_Dreg] = setting; p = p+4;
631: } else if (!strncmp(p, "Areg", 4)) { f[ea_Areg] = setting; p = p+4;
632: } else if (!strncmp(p, "Aind", 4)) { f[ea_Aind] = setting; p = p+4;
633: } else if (!strncmp(p, "Ainc", 4)) { f[ea_Ainc] = setting; p = p+4;
634: } else if (!strncmp(p, "Adec", 4)) { f[ea_Adec] = setting; p = p+4;
635: } else if (!strncmp(p, "Adis", 4)) { f[ea_Adis] = setting; p = p+4;
636: } else if (!strncmp(p, "Aidx", 4)) { f[ea_Aidx] = setting; p = p+4;
637: } else if (!strncmp(p, "AbsW", 4)) { f[ea_AbsW] = setting; p = p+4;
638: } else if (!strncmp(p, "AbsL", 4)) { f[ea_AbsL] = setting; p = p+4;
639: } else if (!strncmp(p, "Pdis", 4)) { f[ea_Pdis] = setting; p = p+4;
640: } else if (!strncmp(p, "Pidx", 4)) { f[ea_Pidx] = setting; p = p+4;
641: } else if (!strncmp(p, "Imm", 3)) { f[ea_Imm] = setting; p = p+3;
642: } else {
643: fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
644: exit(1);
645: }
646: } while (*p++ == ',');
647: if (*(p-1) != ')') {
648: fprintf(stderr, "%d: unknown qualifier for EA\n", lineno);
649: exit(1);
650: }
651: break;
652: default:
653: fprintf(stderr, "%d: did not understand dest operand\n", lineno);
654: exit(1);
655: }
656: }
657: }
658: if (*p != '\0') {
659: fprintf(stderr, "%d: no end-of-line found at end of line\n", lineno);
660: exit(1);
661: }
662:
663: /* checks */
664:
665: if (expand_d_ea_e) {
666: if (e[ea_Imm]) {
667: fprintf(stderr, "%d: Immediate data not allowed as dest\n", lineno);
668: exit(1);
669: }
670: }
671:
672: if (expand_d_ea_f) {
673: if (f[ea_Imm]) {
674: fprintf(stderr, "%d: Immediate data not allowed as dest\n", lineno);
675: exit(1);
676: }
677: }
678:
679: if ((num[bite] && !num[bitE]) || (num[bitE] && !num[bite])) {
680: fprintf(stderr, "%d: There must be both eee and EEE\n", lineno);
681: exit(1);
682: }
683:
684: if ((num[bitf] && !num[bitF]) || (num[bitF] && !num[bitf])) {
685: fprintf(stderr, "%d: There must be both fff and FFF\n", lineno);
686: exit(1);
687: }
688:
689: if (num[bitf] && !expand_d_ea_f) {
690: fprintf(stderr, "%d: EA 'f' found but not used in description!\n", lineno);
691: exit(1);
692: }
693:
694: if (num[bite] && expand_d_ea_e && expand_s_ea_e) {
695: fprintf(stderr, "%d: EA used as both source and destination!\n", lineno);
696: exit(1);
697: }
698:
699: /* ok, now write to the output a structure for each line we're going to
700: do a CPU emulation routine for - this means we will expand anything
701: that might require control flow statements, e.g. EA and size bit
702: sections but not registers and immediate data that can be done in a
703: single instruction-wide '&' (and) statement. */
704:
705: /* convert size/EA bits to static */
706:
707: {
708: t_size size;
709: t_datatype ea_e;
710: t_datatype ea_f;
711: int skip;
712: int cc;
713: int wordlen, type;
714:
715: /* loop through 3 different sizes or just once if no size to loop on */
716:
717: for (size = isize;
718: (size == isize) || (num[bitz] && (size <= sz_long)); size++) {
719:
720: /* loop through 'e' EA or just once if no EA 'e' to loop on */
721:
722: for (ea_e = ea_Dreg;
723: (ea_e == ea_Dreg) || (num[bite] && (ea_e <= ea_Imm)); ea_e++) {
724:
725: /* loop through 'f' EA or just once if no EA 'e' to loop on */
726:
727: for (ea_f = ea_Dreg;
728: (ea_f == ea_Dreg) || (num[bitf] && (ea_f <= ea_Imm)); ea_f++) {
729:
730: for (cc = 0; (cc == 0) || (num[bitc] && (cc < 16)); cc++) {
731:
732: if (cc == 1)
733: continue;
734:
735: if ((size == sz_none) && num[bitz])
736: continue;
737:
738: /* deal with size */
739:
740: if (num[bitz]) {
741: /* set mask where zz is */
742: mask |= (3<<start[bitz]);
743: /* clear bits where zz is */
744: bits &= ~(3<<start[bitz]);
745: /* set correct value into where zz is */
746: switch (size) {
747: case sz_byte: break;
748: case sz_word: bits |= (1<<start[bitz]); break;
749: case sz_long: bits |= (2<<start[bitz]); break;
750: default:
751: printf("%d: Invalid size\n", lineno);
752: continue;
753: }
754: if (expand_s_immsize) {
755: /* source immediate data depends on size of instruction */
756: switch (size) {
757: case sz_byte: stype = dt_ImmB; break;
758: case sz_word: stype = dt_ImmW; break;
759: case sz_long: stype = dt_ImmL; break;
760: default:
761: printf("%d: Invalid size\n", lineno);
762: exit(1);
763: }
764: }
765: }
766:
767: /* deal with cc */
768:
769: if (num[bitc]) {
770: /* set mask where cccc is */
771: mask |= (15<<start[bitc]);
772: /* clear bits where cccc is */
773: bits &= ~(15<<start[bitc]);
774: /* set correct value into where cccc is */
775: bits |= cc<<start[bitc];
776: }
777:
778: /* deal with EA 'e' when used as source */
779:
780: if (num[bite] && expand_s_ea_e) {
781: if (!e[ea_e]) {
782: /* this has been disabled using -Axyz */
783: continue;
784: }
785: /* clear everything */
786: mask |= (7<<start[bite]); /* set mask for eee */
787: mask &= ~(7<<start[bitE]); /* clear mask for EEE */
788: bits &= ~(7<<start[bite]); /* clear bits in eee */
789: bits &= ~(7<<start[bitE]); /* clear bits in EEE */
790: if (ea_e <= ea_Aidx) {
791: /* ea mode with register in second part */
792: bits |= (ea_e<<start[bite]);
793: switch (ea_e) {
794: case ea_Dreg: stype = dt_Dreg; sbitpos = start[bitE]; break;
795: case ea_Areg: stype = dt_Areg; sbitpos = start[bitE]; break;
796: case ea_Aind: stype = dt_Aind; sbitpos = start[bitE]; break;
797: case ea_Ainc: stype = dt_Ainc; sbitpos = start[bitE]; break;
798: case ea_Adec: stype = dt_Adec; sbitpos = start[bitE]; break;
799: case ea_Adis: stype = dt_Adis; sbitpos = start[bitE]; break;
800: case ea_Aidx: stype = dt_Aidx; sbitpos = start[bitE]; break;
801: default: abort();
802: }
803: } else {
804: bits |= (7<<start[bite]); /* eee should be 111 */
805: mask |= (7<<start[bitE]);
806: switch (ea_e) {
807: case ea_AbsW: stype = dt_AbsW; bits |= (0<<start[bitE]); break;
808: case ea_AbsL: stype = dt_AbsL; bits |= (1<<start[bitE]); break;
809: case ea_Pdis: stype = dt_Pdis; bits |= (2<<start[bitE]); break;
810: case ea_Pidx: stype = dt_Pidx; bits |= (3<<start[bitE]); break;
811: case ea_Imm:
812: bits |= (4<<start[bitE]);
813: switch (size) {
814: case sz_byte: stype = dt_ImmB; break;
815: case sz_word: stype = dt_ImmW; break;
816: case sz_long: stype = dt_ImmL; break;
817: default:
818: printf("%d: Invalid size\n", lineno);
819: exit(1);
820: }
821: break;
822: default: abort();
823: }
824: }
825: }
826:
827: /* deal with EA 'e' when used as destination */
828:
829: if (num[bite] && expand_d_ea_e) {
830: if (!e[ea_e]) {
831: /* this has been disabled using -Axyz */
832: continue;
833: }
834: /* clear everything */
835: mask |= (7<<start[bite]); /* set mask for eee */
836: mask &= ~(7<<start[bitE]); /* clear mask for EEE */
837: bits &= ~(7<<start[bite]); /* clear bits in eee */
838: bits &= ~(7<<start[bitE]); /* clear bits in EEE */
839: if (ea_e <= ea_Aidx) {
840: /* ea mode with register in second part */
841: bits |= (ea_e<<start[bite]);
842: switch (ea_e) {
843: case ea_Dreg: dtype = dt_Dreg; dbitpos = start[bitE]; break;
844: case ea_Areg: dtype = dt_Areg; dbitpos = start[bitE]; break;
845: case ea_Aind: dtype = dt_Aind; dbitpos = start[bitE]; break;
846: case ea_Ainc: dtype = dt_Ainc; dbitpos = start[bitE]; break;
847: case ea_Adec: dtype = dt_Adec; dbitpos = start[bitE]; break;
848: case ea_Adis: dtype = dt_Adis; dbitpos = start[bitE]; break;
849: case ea_Aidx: dtype = dt_Aidx; dbitpos = start[bitE]; break;
850: default: abort();
851: }
852: } else {
853: bits |= (7<<start[bite]); /* eee should be 111 */
854: mask |= (7<<start[bitE]);
855: switch (ea_e) {
856: case ea_AbsW: dtype = dt_AbsW; bits |= (0<<start[bitE]); break;
857: case ea_AbsL: dtype = dt_AbsL; bits |= (1<<start[bitE]); break;
858: case ea_Pdis: dtype = dt_Pdis; bits |= (2<<start[bitE]); break;
859: case ea_Pidx: dtype = dt_Pidx; bits |= (3<<start[bitE]); break;
860: case ea_Imm:
861: bits |= (4<<start[bitE]);
862: switch (size) {
863: case sz_byte: dtype = dt_ImmB; break;
864: case sz_word: dtype = dt_ImmW; break;
865: case sz_long: dtype = dt_ImmL; break;
866: default:
867: printf("%d: Invalid size\n", lineno);
868: exit(1);
869: }
870: break;
871: default: abort();
872: }
873: }
874: }
875:
876: /* deal with EA 'f' when used as destination */
877:
878: if (num[bitf] && expand_d_ea_f) {
879: if (!f[ea_f]) {
880: /* this has been disabled using -Axyz */
881: continue;
882: }
883: /* clear everything */
884: mask |= (7<<start[bitf]); /* set mask for fff */
885: mask &= ~(7<<start[bitF]); /* clear mask for FFF */
886: bits &= ~(7<<start[bitf]); /* clear bits in fff */
887: bits &= ~(7<<start[bitF]); /* clear bits in FFF */
888: if (ea_f <= ea_Aidx) {
889: /* ea mode with register in second part */
890: bits |= (ea_f<<start[bitf]);
891: switch (ea_f) {
892: case ea_Dreg: dtype = dt_Dreg; dbitpos = start[bitF]; break;
893: case ea_Areg: dtype = dt_Areg; dbitpos = start[bitF]; break;
894: case ea_Aind: dtype = dt_Aind; dbitpos = start[bitF]; break;
895: case ea_Ainc: dtype = dt_Ainc; dbitpos = start[bitF]; break;
896: case ea_Adec: dtype = dt_Adec; dbitpos = start[bitF]; break;
897: case ea_Adis: dtype = dt_Adis; dbitpos = start[bitF]; break;
898: case ea_Aidx: dtype = dt_Aidx; dbitpos = start[bitF]; break;
899: default: abort();
900: }
901: } else {
902: bits |= (7<<start[bitf]); /* eee should be 111 */
903: mask |= (7<<start[bitF]);
904: switch (ea_f) {
905: case ea_AbsW: dtype = dt_AbsW; bits |= (0<<start[bitF]); break;
906: case ea_AbsL: dtype = dt_AbsL; bits |= (1<<start[bitF]); break;
907: case ea_Pdis: dtype = dt_Pdis; bits |= (2<<start[bitF]); break;
908: case ea_Pidx: dtype = dt_Pidx; bits |= (3<<start[bitF]); break;
909: case ea_Imm:
910: bits |= (4<<start[bitF]);
911: switch (size) {
912: case sz_byte: dtype = dt_ImmB; break;
913: case sz_word: dtype = dt_ImmW; break;
914: case sz_long: dtype = dt_ImmL; break;
915: default:
916: printf("%d: Invalid size\n", lineno);
917: exit(1);
918: }
919: break;
920: default: abort();
921: }
922: }
923: }
924:
925: wordlen = 1;
926: for (type = 0; type < 2; type++) {
927: switch(type ? stype : dtype) {
928: case dt_Ill:
929: case dt_Dreg:
930: case dt_Areg:
931: case dt_Aind:
932: case dt_Ainc:
933: case dt_Adec:
934: break;
935: case dt_Adis:
936: case dt_Aidx:
937: case dt_AbsW:
938: case dt_Pdis:
939: case dt_Pidx:
940: case dt_ImmB:
941: case dt_ImmW:
942: wordlen++;
943: break;
944: case dt_AbsL:
945: case dt_ImmL:
946: wordlen+= 2;
947: break;
948: case dt_ImmS:
949: case dt_Imm3:
950: case dt_Imm4:
951: case dt_Imm8:
952: case dt_Imm8s:
953: case dt_ImmV:
954: break;
955: default:
956: printf("%d: Invalid type\n", lineno);
957: exit(1);
958: }
959: }
960:
961: clocks = -1;
962:
963: switch(mnemonic_num) {
964: case i_OR:
965: case i_AND:
966: case i_EOR:
967: clocks = 4;
968: clocks+= clocks_eacalc(stype, size);
969: clocks+= clocks_eafetch(stype, size);
970: clocks+= clocks_eacalc(dtype, size);
971: clocks+= clocks_eafetch(dtype, size);
972: clocks+= clocks_standard(stype, dtype, size);
973: break;
974: case i_ORSR:
975: case i_ANDSR:
976: case i_EORSR:
977: clocks = 20;
978: break;
979: case i_SUB:
980: case i_SUBA:
981: case i_ADD:
982: case i_ADDA:
983: clocks = 4;
984: clocks+= clocks_eacalc(stype, size);
985: clocks+= clocks_eafetch(stype, size);
986: clocks+= clocks_eacalc(dtype, size);
987: clocks+= clocks_eafetch(dtype, size);
988: clocks+= clocks_standard(stype, dtype, size);
989: break;
990: case i_SUBX:
991: case i_ADDX:
992: if (stype == dt_Dreg) {
993: if (size != sz_long) {
994: clocks = 4;
995: } else {
996: clocks = 8;
997: }
998: } else {
999: if (size != sz_long) {
1000: clocks = 18;
1001: } else {
1002: clocks = 30;
1003: }
1004: }
1005: break;
1006: case i_MULU:
1007: case i_MULS:
1008: clocks = 54;
1009: clocks+= clocks_eacalc(stype, size);
1010: clocks+= clocks_eafetch(stype, size);
1011: break;
1012: case i_CMP:
1013: case i_CMPA:
1014: if (dtype == dt_Areg) {
1015: clocks = 6;
1016: } else {
1017: if (size != sz_long) {
1018: clocks = 4;
1019: } else {
1020: clocks = 6;
1021: }
1022: }
1023: clocks+= clocks_eacalc(stype, size);
1024: clocks+= clocks_eafetch(stype, size);
1025: break;
1026: case i_BTST:
1027: if (stype == dt_Dreg) {
1028: /* dynamic */
1029: if (dtype == dt_Dreg) {
1030: clocks = 6;
1031: } else {
1032: clocks = 4;
1033: }
1034: } else {
1035: /* static */
1036: if (dtype == dt_Dreg) {
1037: clocks = 10;
1038: } else {
1039: clocks = 8;
1040: }
1041: }
1042: clocks+= clocks_eacalc(dtype, size);
1043: clocks+= clocks_eafetch(dtype, size);
1044: break;
1045: case i_BCHG:
1046: case i_BSET:
1047: if (stype == dt_Dreg) {
1048: /* dynamic */
1049: clocks = 8;
1050: } else {
1051: /* static */
1052: clocks = 12;
1053: }
1054: clocks+= clocks_eacalc(dtype, size);
1055: clocks+= clocks_eafetch(dtype, size);
1056: break;
1057: case i_BCLR:
1058: if (stype == dt_Dreg) {
1059: /* dynamic */
1060: if (dtype == dt_Dreg) {
1061: clocks = 10;
1062: } else {
1063: clocks = 8;
1064: }
1065: } else {
1066: /* static */
1067: if (dtype == dt_Dreg) {
1068: clocks = 14;
1069: } else {
1070: clocks = 12;
1071: }
1072: }
1073: clocks+= clocks_eacalc(dtype, size);
1074: clocks+= clocks_eafetch(dtype, size);
1075: break;
1076: case i_MOVE:
1077: case i_MOVEA:
1078: clocks = 4;
1079: clocks+= clocks_eacalc(stype, size);
1080: clocks+= clocks_eafetch(stype, size);
1081: clocks+= clocks_eacalc(dtype, size);
1082: clocks+= clocks_eafetch(dtype, size);
1083: break;
1084: case i_MOVEPRM:
1085: case i_MOVEPMR:
1086: if (size == sz_long) {
1087: clocks = 24;
1088: } else {
1089: clocks = 16;
1090: }
1091: break;
1092: case i_MOVEFSR:
1093: if (stype == dt_Dreg) {
1094: clocks = 6;
1095: } else {
1096: clocks = 8;
1097: }
1098: clocks+= clocks_eacalc(stype, size);
1099: clocks+= clocks_eafetch(stype, size);
1100: break;
1101: case i_MOVETSR:
1102: clocks = 12;
1103: clocks+= clocks_eacalc(stype, size);
1104: clocks+= clocks_eafetch(stype, size);
1105: break;
1106: case i_MOVEMMR:
1107: clocks = 20;
1108: break;
1109: case i_MOVEMRM:
1110: clocks = 16;
1111: break;
1112: case i_MOVETUSP:
1113: case i_MOVEFUSP:
1114: clocks = 4;
1115: case i_NEG:
1116: case i_NEGX:
1117: case i_CLR:
1118: case i_NOT:
1119: clocks = clocks_single(stype, size);
1120: clocks+= clocks_eacalc(stype, size);
1121: clocks+= clocks_eafetch(stype, size);
1122: break;
1123: case i_ABCD:
1124: case i_SBCD:
1125: if (stype == dt_Dreg) {
1126: clocks = 6;
1127: } else {
1128: clocks = 18;
1129: }
1130: break;
1131: case i_NBCD:
1132: if (stype == dt_Dreg || stype == dt_Areg) {
1133: clocks = 6;
1134: } else {
1135: clocks = 8;
1136: clocks+= clocks_eacalc(stype, size);
1137: clocks+= clocks_eafetch(stype, size);
1138: }
1139: break;
1140: case i_SWAP:
1141: clocks = 4;
1142: break;
1143: case i_PEA:
1144: clocks = 8;
1145: clocks+= clocks_eacalc(stype, size);
1146: clocks+= clocks_eafetch(stype, size);
1147: break;
1148: case i_LEA:
1149: clocks = 4;
1150: clocks+= clocks_eacalc(stype, size);
1151: break;
1152: case i_EXT:
1153: clocks = 4;
1154: break;
1155: case i_EXG:
1156: clocks = 6;
1157: break;
1158: case i_TST:
1159: clocks = 4;
1160: clocks+= clocks_eacalc(stype, size);
1161: clocks+= clocks_eafetch(stype, size);
1162: break;
1163: case i_TAS:
1164: if (stype == dt_Dreg || stype == dt_Areg) {
1165: clocks = 4;
1166: } else {
1167: clocks = 10;
1168: }
1169: break;
1170: case i_CHK:
1171: clocks = 10;
1172: clocks+= clocks_eacalc(stype, size);
1173: clocks+= clocks_eafetch(stype, size);
1174: break;
1175: case i_TRAPV:
1176: clocks = 4;
1177: break;
1178: case i_TRAP:
1179: clocks = 4; /* exception */
1180: break;
1181: case i_RESET:
1182: clocks = 132;
1183: break;
1184: case i_NOP:
1185: clocks = 4;
1186: break;
1187: case i_STOP:
1188: clocks = 4;
1189: break;
1190: case i_LINK:
1191: clocks = 16;
1192: break;
1193: case i_UNLK:
1194: clocks = 12;
1195: break;
1196: case i_RTE:
1197: clocks = 20;
1198: break;
1199: case i_RTS:
1200: clocks = 16;
1201: break;
1202: case i_RTR:
1203: clocks = 20;
1204: break;
1205: case i_JSR:
1206: clocks = 16;
1207: clocks+= clocks_eacalc(stype, size);
1208: break;
1209: case i_JMP:
1210: clocks = 8;
1211: clocks+= clocks_eacalc(stype, size);
1212: break;
1213: case i_Scc:
1214: if (stype == dt_Dreg || stype == dt_Areg) {
1215: clocks = 4;
1216: } else {
1217: clocks = 8;
1218: clocks+= clocks_eacalc(stype, size);
1219: clocks+= clocks_eafetch(stype, size);
1220: }
1221: break;
1222: case i_SF:
1223: if (stype == dt_Dreg || stype == dt_Areg) {
1224: clocks = 4;
1225: } else {
1226: clocks = 8;
1227: clocks+= clocks_eacalc(stype, size);
1228: clocks+= clocks_eafetch(stype, size);
1229: }
1230: break;
1231: case i_DBcc:
1232: case i_DBRA:
1233: clocks = 10;
1234: break;
1235: case i_Bcc:
1236: if (size == sz_byte) {
1237: clocks = 8;
1238: } else {
1239: clocks = 10;
1240: }
1241: break;
1242: case i_BSR:
1243: clocks = 18;
1244: break;
1245: case i_DIVU:
1246: clocks = 140;
1247: clocks+= clocks_eacalc(stype, size);
1248: clocks+= clocks_eafetch(stype, size);
1249: break;
1250: case i_DIVS:
1251: clocks = 128;
1252: clocks+= clocks_eacalc(stype, size);
1253: clocks+= clocks_eafetch(stype, size);
1254: break;
1255: case i_ASR:
1256: case i_LSR:
1257: case i_ROXR:
1258: case i_ROR:
1259: case i_ASL:
1260: case i_LSL:
1261: case i_ROXL:
1262: case i_ROL:
1263: clocks = 8;
1264: clocks+= clocks_eacalc(dtype, size);
1265: clocks+= clocks_eafetch(dtype, size);
1266: break;
1267: case i_ILLG:
1268: clocks = 0;
1269: break;
1270: case i_LINE10:
1271: case i_LINE15:
1272: clocks = 4; /* exception */
1273: break;
1274: default:
1275: printf("%d: Invalid mnemonic type\n", lineno);
1276: exit(1);
1277: }
1278:
1279: if (clocks == -1) {
1280: printf("%d: Clocks not found\n", lineno);
1281: exit(1);
1282: }
1283:
1284: /* write output lines */
1285:
1286: fprintf(outiibs, " { 0x%x, 0x%x, %d, { %d, %d, %d, %d, %d }, ",
1287: mask, bits, mnemonic_num, priv, endblk, imm_notzero, used,
1288: set);
1289: fprintf(outiibs, "%d, %d, %d, %d, %d, %d, %d, %d, %d, %d},\n",
1290: size, stype, dtype, sbitpos, dbitpos, immvalue,
1291: cc, total, wordlen, clocks);
1292: fprintf(outiibs, "%60s/* %s */\n", "", mnemonic);
1293: if (set == 0) {
1294: fprintf(outfuncs, " cpu_op_%ia, /* %s */\n", total, mnemonic);
1295: fprintf(outfuncs, " cpu_op_%ia, /* %s */\n", total, mnemonic);
1296: fprintf(outproto, "extern void cpu_op_%ia("
1297: "t_ipc *ipc); /* %s */\n", total, mnemonic);
1298: } else {
1299: fprintf(outfuncs, " cpu_op_%ia, /* %s - normal */\n", total,
1300: mnemonic);
1301: fprintf(outfuncs, " cpu_op_%ib, /* %s - no flags */\n", total,
1302: mnemonic);
1303: fprintf(outproto, "extern void cpu_op_%ia("
1304: "t_ipc *ipc); /* %s */\n", total, mnemonic);
1305: fprintf(outproto, "extern void cpu_op_%ib("
1306: "t_ipc *ipc); /* %s */\n", total, mnemonic);
1307: }
1308:
1309: total++;
1310:
1311: } /* cc */
1312: } /* ea_f */
1313: } /* ea_e */
1314: } /* size */
1315: } /* block */
1316: }
1317:
1318: int clocks_eacalc(t_datatype type, t_size size)
1319: {
1320: switch(type) {
1321: case dt_Dreg:
1322: case dt_Areg:
1323: break;
1324: case dt_Aind:
1325: case dt_Ainc:
1326: break;
1327: case dt_Adec:
1328: return 2;
1329: case dt_Adis:
1330: return 4;
1331: case dt_Aidx:
1332: return 6;
1333: case dt_AbsW:
1334: return 4;
1335: case dt_AbsL:
1336: return 8;
1337: case dt_Pdis:
1338: return 4;
1339: case dt_Pidx:
1340: return 6;
1341: case dt_ImmB:
1342: case dt_ImmW:
1343: case dt_ImmL:
1344: break;
1345: case dt_ImmS:
1346: case dt_Imm3:
1347: case dt_Imm4:
1348: case dt_Imm8:
1349: case dt_Imm8s:
1350: case dt_Ill:
1351: break;
1352: default:
1353: printf("Invalid type for clocks\n");
1354: exit(1);
1355: }
1356: return 0;
1357: }
1358:
1359: int clocks_eafetch(t_datatype type, t_size size)
1360: {
1361: switch(type) {
1362: case dt_Dreg:
1363: case dt_Areg:
1364: break;
1365: case dt_Aind:
1366: case dt_Ainc:
1367: case dt_Adec:
1368: case dt_Adis:
1369: case dt_Aidx:
1370: case dt_AbsW:
1371: case dt_AbsL:
1372: case dt_Pdis:
1373: case dt_Pidx:
1374: case dt_ImmB:
1375: case dt_ImmW:
1376: case dt_ImmL:
1377: if (size == sz_long)
1378: return 8;
1379: else
1380: return 4;
1381: break;
1382: case dt_ImmS:
1383: case dt_Imm3:
1384: case dt_Imm4:
1385: case dt_Imm8:
1386: case dt_Imm8s:
1387: case dt_Ill:
1388: break;
1389: default:
1390: printf("Invalid type for clocks\n");
1391: exit(1);
1392: }
1393: return 0;
1394: }
1395:
1396: int clocks_standard(t_datatype stype, t_datatype dtype, t_size size)
1397: {
1398: int stype_imm = (stype == dt_ImmB) || (stype == dt_ImmW) ||
1399: (stype == dt_ImmL) || (stype == dt_Imm3) || (stype == dt_Imm4) ||
1400: (stype == dt_Imm8) || (stype == dt_Imm8s) || (stype == dt_ImmS);
1401:
1402: if (stype_imm) {
1403: if (dtype == dt_Areg) {
1404: return 4;
1405: } else if (dtype == dt_Dreg) {
1406: if (size != sz_long) {
1407: return 0;
1408: } else {
1409: return 4;
1410: }
1411: } else {
1412: if (size != sz_long) {
1413: return 4;
1414: } else {
1415: return 8;
1416: }
1417: }
1418: }
1419:
1420: if (dtype == dt_Areg) {
1421: if (size != sz_long) {
1422: return 4;
1423: } else {
1424: if (stype == dt_Dreg || stype_imm) {
1425: return 4;
1426: } else {
1427: return 2;
1428: }
1429: }
1430: } else if (dtype == dt_Dreg) {
1431: if (size != sz_long) {
1432: return 0;
1433: } else {
1434: if (stype == dt_Dreg || stype_imm) {
1435: return 4;
1436: } else {
1437: return 2;
1438: }
1439: }
1440: } else if (stype == dt_Dreg) {
1441: if (size != sz_long) {
1442: return 4;
1443: } else {
1444: return 8;
1445: }
1446: } else {
1447: printf("Error %d %d.\n", stype, dtype);
1448: exit(1);
1449: }
1450: }
1451:
1452: int clocks_single(t_datatype type, t_size size)
1453: {
1454: if (type == dt_Dreg || type == dt_Areg) {
1455: if (size != sz_long) {
1456: return 4;
1457: } else {
1458: return 6;
1459: }
1460: } else {
1461: if (size != sz_long) {
1462: return 8;
1463: } else {
1464: return 12;
1465: }
1466: }
1467: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.