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