![[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) {
1.1.1.3 ! root 663: /* BTST is weirdo and you can do BTST Dx, #nnnn where Dx is the source
! 664: * of the bit-position and #nnnn is the immediate data to test */
! 665: if (e[ea_Imm] && mnemonic_num != i_BTST ) {
1.1 root 666: fprintf(stderr, "%d: Immediate data not allowed as dest\n", lineno);
667: exit(1);
668: }
669: }
670:
671: if (expand_d_ea_f) {
672: if (f[ea_Imm]) {
673: fprintf(stderr, "%d: Immediate data not allowed as dest\n", lineno);
674: exit(1);
675: }
676: }
677:
678: if ((num[bite] && !num[bitE]) || (num[bitE] && !num[bite])) {
679: fprintf(stderr, "%d: There must be both eee and EEE\n", lineno);
680: exit(1);
681: }
682:
683: if ((num[bitf] && !num[bitF]) || (num[bitF] && !num[bitf])) {
684: fprintf(stderr, "%d: There must be both fff and FFF\n", lineno);
685: exit(1);
686: }
687:
688: if (num[bitf] && !expand_d_ea_f) {
689: fprintf(stderr, "%d: EA 'f' found but not used in description!\n", lineno);
690: exit(1);
691: }
692:
693: if (num[bite] && expand_d_ea_e && expand_s_ea_e) {
694: fprintf(stderr, "%d: EA used as both source and destination!\n", lineno);
695: exit(1);
696: }
697:
698: /* ok, now write to the output a structure for each line we're going to
699: do a CPU emulation routine for - this means we will expand anything
700: that might require control flow statements, e.g. EA and size bit
701: sections but not registers and immediate data that can be done in a
702: single instruction-wide '&' (and) statement. */
703:
704: /* convert size/EA bits to static */
705:
706: {
707: t_size size;
708: t_datatype ea_e;
709: t_datatype ea_f;
710: int cc;
711: int wordlen, type;
712: int idx;
713:
714: /* loop through 3 different sizes or just once if no size to loop on */
715:
716: for (size = isize;
717: (size == isize) || (num[bitz] && (size <= sz_long)); size++) {
718:
719: /* loop through 'e' EA or just once if no EA 'e' to loop on */
720:
721: for (ea_e = ea_Dreg;
722: (ea_e == ea_Dreg) || (num[bite] && (ea_e <= ea_Imm)); ea_e++) {
723:
724: /* loop through 'f' EA or just once if no EA 'e' to loop on */
725:
726: for (ea_f = ea_Dreg;
727: (ea_f == ea_Dreg) || (num[bitf] && (ea_f <= ea_Imm)); ea_f++) {
728:
729: for (cc = 0; (cc == 0) || (num[bitc] && (cc < 16)); cc++) {
730:
731: if (cc == 1)
732: continue;
733:
734: if ((size == sz_none) && num[bitz])
735: continue;
736:
737: /* deal with size */
738:
739: if (num[bitz]) {
740: /* set mask where zz is */
741: mask |= (3<<start[bitz]);
742: /* clear bits where zz is */
743: bits &= ~(3<<start[bitz]);
744: /* set correct value into where zz is */
745: switch (size) {
746: case sz_byte: break;
747: case sz_word: bits |= (1<<start[bitz]); break;
748: case sz_long: bits |= (2<<start[bitz]); break;
749: default:
750: printf("%d: Invalid size\n", lineno);
751: continue;
752: }
753: if (expand_s_immsize) {
754: /* source immediate data depends on size of instruction */
755: switch (size) {
756: case sz_byte: stype = dt_ImmB; break;
757: case sz_word: stype = dt_ImmW; break;
758: case sz_long: stype = dt_ImmL; break;
759: default:
760: printf("%d: Invalid size\n", lineno);
761: exit(1);
762: }
763: }
764: }
765:
766: /* deal with cc */
767:
768: if (num[bitc]) {
769: /* set mask where cccc is */
770: mask |= (15<<start[bitc]);
771: /* clear bits where cccc is */
772: bits &= ~(15<<start[bitc]);
773: /* set correct value into where cccc is */
774: bits |= cc<<start[bitc];
775: }
776:
777: /* deal with EA 'e' when used as source */
778:
779: if (num[bite] && expand_s_ea_e) {
780: if (!e[ea_e]) {
781: /* this has been disabled using -Axyz */
782: continue;
783: }
784: /* clear everything */
785: mask |= (7<<start[bite]); /* set mask for eee */
786: mask &= ~(7<<start[bitE]); /* clear mask for EEE */
787: bits &= ~(7<<start[bite]); /* clear bits in eee */
788: bits &= ~(7<<start[bitE]); /* clear bits in EEE */
789: if (ea_e <= ea_Aidx) {
790: /* ea mode with register in second part */
791: bits |= (ea_e<<start[bite]);
792: switch (ea_e) {
793: case ea_Dreg: stype = dt_Dreg; sbitpos = start[bitE]; break;
794: case ea_Areg: stype = dt_Areg; sbitpos = start[bitE]; break;
795: case ea_Aind: stype = dt_Aind; sbitpos = start[bitE]; break;
796: case ea_Ainc: stype = dt_Ainc; sbitpos = start[bitE]; break;
797: case ea_Adec: stype = dt_Adec; sbitpos = start[bitE]; break;
798: case ea_Adis: stype = dt_Adis; sbitpos = start[bitE]; break;
799: case ea_Aidx: stype = dt_Aidx; sbitpos = start[bitE]; break;
800: default: abort();
801: }
802: } else {
803: bits |= (7<<start[bite]); /* eee should be 111 */
804: mask |= (7<<start[bitE]);
805: switch (ea_e) {
806: case ea_AbsW: stype = dt_AbsW; bits |= (0<<start[bitE]); break;
807: case ea_AbsL: stype = dt_AbsL; bits |= (1<<start[bitE]); break;
808: case ea_Pdis: stype = dt_Pdis; bits |= (2<<start[bitE]); break;
809: case ea_Pidx: stype = dt_Pidx; bits |= (3<<start[bitE]); break;
810: case ea_Imm:
811: bits |= (4<<start[bitE]);
812: switch (size) {
813: case sz_byte: stype = dt_ImmB; break;
814: case sz_word: stype = dt_ImmW; break;
815: case sz_long: stype = dt_ImmL; break;
816: default:
817: printf("%d: Invalid size\n", lineno);
818: exit(1);
819: }
820: break;
821: default: abort();
822: }
823: }
824: }
825:
826: /* deal with EA 'e' when used as destination */
827:
828: if (num[bite] && expand_d_ea_e) {
829: if (!e[ea_e]) {
830: /* this has been disabled using -Axyz */
831: continue;
832: }
833: /* clear everything */
834: mask |= (7<<start[bite]); /* set mask for eee */
835: mask &= ~(7<<start[bitE]); /* clear mask for EEE */
836: bits &= ~(7<<start[bite]); /* clear bits in eee */
837: bits &= ~(7<<start[bitE]); /* clear bits in EEE */
838: if (ea_e <= ea_Aidx) {
839: /* ea mode with register in second part */
840: bits |= (ea_e<<start[bite]);
841: switch (ea_e) {
842: case ea_Dreg: dtype = dt_Dreg; dbitpos = start[bitE]; break;
843: case ea_Areg: dtype = dt_Areg; dbitpos = start[bitE]; break;
844: case ea_Aind: dtype = dt_Aind; dbitpos = start[bitE]; break;
845: case ea_Ainc: dtype = dt_Ainc; dbitpos = start[bitE]; break;
846: case ea_Adec: dtype = dt_Adec; dbitpos = start[bitE]; break;
847: case ea_Adis: dtype = dt_Adis; dbitpos = start[bitE]; break;
848: case ea_Aidx: dtype = dt_Aidx; dbitpos = start[bitE]; break;
849: default: abort();
850: }
851: } else {
852: bits |= (7<<start[bite]); /* eee should be 111 */
853: mask |= (7<<start[bitE]);
854: switch (ea_e) {
855: case ea_AbsW: dtype = dt_AbsW; bits |= (0<<start[bitE]); break;
856: case ea_AbsL: dtype = dt_AbsL; bits |= (1<<start[bitE]); break;
857: case ea_Pdis: dtype = dt_Pdis; bits |= (2<<start[bitE]); break;
858: case ea_Pidx: dtype = dt_Pidx; bits |= (3<<start[bitE]); break;
859: case ea_Imm:
860: bits |= (4<<start[bitE]);
861: switch (size) {
862: case sz_byte: dtype = dt_ImmB; break;
863: case sz_word: dtype = dt_ImmW; break;
864: case sz_long: dtype = dt_ImmL; break;
865: default:
866: printf("%d: Invalid size\n", lineno);
867: exit(1);
868: }
869: break;
870: default: abort();
871: }
872: }
873: }
874:
875: /* deal with EA 'f' when used as destination */
876:
877: if (num[bitf] && expand_d_ea_f) {
878: if (!f[ea_f]) {
879: /* this has been disabled using -Axyz */
880: continue;
881: }
882: /* clear everything */
883: mask |= (7<<start[bitf]); /* set mask for fff */
884: mask &= ~(7<<start[bitF]); /* clear mask for FFF */
885: bits &= ~(7<<start[bitf]); /* clear bits in fff */
886: bits &= ~(7<<start[bitF]); /* clear bits in FFF */
887: if (ea_f <= ea_Aidx) {
888: /* ea mode with register in second part */
889: bits |= (ea_f<<start[bitf]);
890: switch (ea_f) {
891: case ea_Dreg: dtype = dt_Dreg; dbitpos = start[bitF]; break;
892: case ea_Areg: dtype = dt_Areg; dbitpos = start[bitF]; break;
893: case ea_Aind: dtype = dt_Aind; dbitpos = start[bitF]; break;
894: case ea_Ainc: dtype = dt_Ainc; dbitpos = start[bitF]; break;
895: case ea_Adec: dtype = dt_Adec; dbitpos = start[bitF]; break;
896: case ea_Adis: dtype = dt_Adis; dbitpos = start[bitF]; break;
897: case ea_Aidx: dtype = dt_Aidx; dbitpos = start[bitF]; break;
898: default: abort();
899: }
900: } else {
901: bits |= (7<<start[bitf]); /* eee should be 111 */
902: mask |= (7<<start[bitF]);
903: switch (ea_f) {
904: case ea_AbsW: dtype = dt_AbsW; bits |= (0<<start[bitF]); break;
905: case ea_AbsL: dtype = dt_AbsL; bits |= (1<<start[bitF]); break;
906: case ea_Pdis: dtype = dt_Pdis; bits |= (2<<start[bitF]); break;
907: case ea_Pidx: dtype = dt_Pidx; bits |= (3<<start[bitF]); break;
908: case ea_Imm:
909: bits |= (4<<start[bitF]);
910: switch (size) {
911: case sz_byte: dtype = dt_ImmB; break;
912: case sz_word: dtype = dt_ImmW; break;
913: case sz_long: dtype = dt_ImmL; break;
914: default:
915: printf("%d: Invalid size\n", lineno);
916: exit(1);
917: }
918: break;
919: default: abort();
920: }
921: }
922: }
923:
924: wordlen = 1;
925: for (type = 0; type < 2; type++) {
926: switch(type ? stype : dtype) {
927: case dt_Ill:
928: case dt_Dreg:
929: case dt_Areg:
930: case dt_Aind:
931: case dt_Ainc:
932: case dt_Adec:
933: break;
934: case dt_Adis:
935: case dt_Aidx:
936: case dt_AbsW:
937: case dt_Pdis:
938: case dt_Pidx:
939: case dt_ImmB:
940: case dt_ImmW:
941: wordlen++;
942: break;
943: case dt_AbsL:
944: case dt_ImmL:
945: wordlen+= 2;
946: break;
947: case dt_ImmS:
948: case dt_Imm3:
949: case dt_Imm4:
950: case dt_Imm8:
951: case dt_Imm8s:
952: case dt_ImmV:
953: break;
954: default:
955: printf("%d: Invalid type\n", lineno);
956: exit(1);
957: }
958: }
959:
960: /* BUG: The immediate instructions are probably not correct,
961: e.g. ADDI, ADDQ, ANDI, CMPI, EORI, MOVEQ, ORI, SUBI, SUBQ */
962:
963: clocks = -1;
964:
965: switch(mnemonic_num) {
966: case i_EOR:
967: if (dtype == dt_Dreg) {
968: clocks = size != sz_long ? 4 : 8;
969: clocks+= clocks_eacalc(stype, size);
970: } else if (stype == dt_Dreg) {
971: clocks = size != sz_long ? 8 : 12;
972: clocks+= clocks_eacalc(dtype, size);
973: } else {
974: clocks = size != sz_long ? 20 : 12;
975: clocks+= clocks_eacalc(dtype, size);
976: }
977: break;
978: case i_OR:
979: case i_AND:
980: if (dtype == dt_Dreg) {
981: clocks = size != sz_long ? 4 : clocks_6or8(stype);
982: clocks+= clocks_eacalc(stype, size);
983: } else if (stype == dt_Dreg) {
984: clocks = size != sz_long ? 8 : 12;
985: clocks+= clocks_eacalc(dtype, size);
986: } else {
987: clocks = size != sz_long ? 20 : 12;
988: clocks+= clocks_eacalc(dtype, size);
989: }
990: break;
991: case i_ADDA:
992: case i_SUBA:
993: if (dtype == dt_Areg) {
994: clocks = size != sz_long ? 8 : clocks_6or8(stype);
995: clocks+= clocks_eacalc(stype, size);
996: } else {
997: printf("%d: clock count invalid type\n", lineno);
998: exit(1);
999: }
1000: break;
1001: case i_ADD:
1002: case i_SUB:
1003: if (dtype == dt_Dreg) {
1004: clocks = size != sz_long ? 4 : clocks_6or8(stype);
1005: clocks+= clocks_eacalc(stype, size);
1006: } else if (stype == dt_Dreg) {
1007: clocks = size != sz_long ? 8 : 12;
1008: clocks+= clocks_eacalc(dtype, size);
1009: } else {
1010: clocks = size != sz_long ? 20 : 12;
1011: clocks+= clocks_eacalc(dtype, size);
1012: }
1013: break;
1014: case i_CMP:
1015: case i_CMPA:
1016: if (dtype == dt_Areg) {
1017: clocks = 6;
1018: clocks+= clocks_eacalc(stype, size);
1019: } else if (dtype == dt_Dreg) {
1020: clocks = size != sz_long ? 4 : 6;
1021: clocks+= clocks_eacalc(stype, size);
1022: } else { /* CMPM */
1023: clocks = 12 + clocks_eacalc(stype, size) +
1024: clocks_eacalc(dtype, size);
1025: }
1026: break;
1027: case i_DIVS:
1028: clocks = 158 - 8 + clocks_eacalc(stype, size);
1029: break;
1030: case i_DIVU:
1031: clocks = 140 - 8 + clocks_eacalc(stype, size);
1032: break;
1033: case i_MULS:
1034: clocks = 38 + clocks_eacalc(stype, size);
1035: break;
1036: case i_MULU:
1037: clocks = 38 + clocks_eacalc(stype, size);
1038: break;
1039: case i_MOVE:
1040: case i_MOVEA:
1041: if ((idx = clocks_typetoindex(dtype)) == -1) {
1042: printf("%d: clock count invalid MOVE type\n", lineno);
1043: exit(1);
1044: }
1045: clocks = clocks_movetable[clocks_typetoindex(stype)*9+idx];
1046: break;
1047: case i_CLR:
1048: case i_NEG:
1049: case i_NEGX:
1050: case i_NOT:
1051: if (stype == dt_Dreg || stype == dt_Areg) {
1052: clocks = size != sz_long ? 4 : 6;
1053: } else {
1054: clocks = size != sz_long ? 8 : 12;
1055: clocks+= clocks_eacalc(stype, size);
1056: }
1057: break;
1058: case i_NBCD:
1059: if (stype == dt_Dreg || stype == dt_Areg) {
1060: clocks = 6;
1061: } else {
1062: clocks = 8 + clocks_eacalc(stype, size);
1063: }
1064: break;
1065: case i_Scc:
1066: case i_SF:
1067: if (stype == dt_Dreg || stype == dt_Areg) {
1068: clocks = size != sz_long ? 4 : 6;
1069: } else {
1070: clocks = 8 + clocks_eacalc(stype, size);
1071: }
1072: break;
1073: case i_TAS:
1074: if (stype == dt_Dreg || stype == dt_Areg) {
1075: clocks = 4;
1076: } else {
1077: clocks = 10 + clocks_eacalc(stype, size);
1078: }
1079: break;
1080: case i_TST:
1081: if (stype == dt_Dreg || stype == dt_Areg) {
1082: clocks = 4;
1083: } else {
1084: clocks = 4 + clocks_eacalc(stype, size);
1085: }
1086: break;
1087: case i_ASR:
1088: case i_ASL:
1089: case i_LSR:
1090: case i_LSL:
1091: case i_ROR:
1092: case i_ROL:
1093: case i_ROXR:
1094: case i_ROXL:
1095: if (stype == dt_Dreg || stype == dt_Areg) {
1096: clocks = size != sz_long ? 8 : 10; /* minimums */
1097: } else {
1098: clocks = 8 + clocks_eacalc(stype, size);
1099: }
1100: break;
1101: case i_BCHG:
1102: case i_BSET:
1103: if (stype == dt_Dreg) { /* dynamic */
1104: clocks = (dtype == dt_Dreg) ? 8 : 8 +
1105: clocks_eacalc(stype, size);
1106: } else { /* static */
1107: clocks = (dtype == dt_Dreg) ? 14 : 12 +
1108: clocks_eacalc(stype, size);
1109: }
1110: case i_BCLR:
1111: if (stype == dt_Dreg) { /* dynamic */
1112: clocks = (dtype == dt_Dreg) ? 10 : 8 +
1113: clocks_eacalc(stype, size);
1114: } else { /* static */
1115: clocks = (dtype == dt_Dreg) ? 14 : 12 +
1116: clocks_eacalc(stype, size);
1117: }
1118: break;
1119: case i_BTST:
1120: if (stype == dt_Dreg) { /* dynamic */
1121: clocks = (dtype == dt_Dreg) ? 6 : 4 +
1122: clocks_eacalc(stype, size);
1123: } else { /* static */
1124: clocks = (dtype == dt_Dreg) ? 10 : 8 +
1125: clocks_eacalc(stype, size);
1126: }
1127: break;
1128: case i_JMP:
1129: switch(stype) {
1130: case dt_Aind: clocks = 8; break;
1131: case dt_Adis: clocks = 10; break;
1132: case dt_Aidx: clocks = 14; break;
1133: case dt_AbsW: clocks = 10; break;
1134: case dt_AbsL: clocks = 12; break;
1135: case dt_Pdis: clocks = 10; break;
1136: case dt_Pidx: clocks = 14; break;
1137: default:
1138: printf("%d: clock count invalid type\n", lineno);
1139: exit(1);
1140: }
1141: break;
1142: case i_JSR:
1143: switch(stype) {
1144: case dt_Aind: clocks = 16; break;
1145: case dt_Adis: clocks = 18; break;
1146: case dt_Aidx: clocks = 22; break;
1147: case dt_AbsW: clocks = 18; break;
1148: case dt_AbsL: clocks = 20; break;
1149: case dt_Pdis: clocks = 18; break;
1150: case dt_Pidx: clocks = 22; break;
1151: default:
1152: printf("%d: clock count invalid type\n", lineno);
1153: exit(1);
1154: }
1155: break;
1156: case i_LEA:
1157: switch(stype) {
1158: case dt_Aind: clocks = 4; break;
1159: case dt_Adis: clocks = 8; break;
1160: case dt_Aidx: clocks = 12; break;
1161: case dt_AbsW: clocks = 8; break;
1162: case dt_AbsL: clocks = 12; break;
1163: case dt_Pdis: clocks = 8; break;
1164: case dt_Pidx: clocks = 12; break;
1165: default:
1166: printf("%d: clock count invalid type\n", lineno);
1167: exit(1);
1168: }
1169: break;
1170: case i_PEA:
1171: switch(stype) {
1172: case dt_Aind: clocks = 12; break;
1173: case dt_Adis: clocks = 16; break;
1174: case dt_Aidx: clocks = 20; break;
1175: case dt_AbsW: clocks = 16; break;
1176: case dt_AbsL: clocks = 20; break;
1177: case dt_Pdis: clocks = 16; break;
1178: case dt_Pidx: clocks = 20; break;
1179: default:
1180: printf("%d: clock count invalid type\n", lineno);
1181: exit(1);
1182: }
1183: break;
1184: case i_MOVEMMR:
1185: clocks = 20;
1186: break;
1187: case i_MOVEMRM:
1188: clocks = 16;
1189: break;
1190: case i_SUBX:
1191: case i_ADDX:
1192: if (stype == dt_Dreg) {
1193: clocks = size != sz_long ? 4 : 8;
1194: } else {
1195: clocks = size != sz_long ? 18 : 30;
1196: }
1197: break;
1198: case i_ABCD:
1199: case i_SBCD:
1200: clocks = (stype == dt_Dreg) ? 6 : 18;
1201: break;
1202: case i_ORSR:
1203: case i_ANDSR:
1204: case i_EORSR:
1205: clocks = 20;
1206: break;
1207: case i_CHK:
1208: clocks = 10 + clocks_eacalc(stype, size);
1209: break;
1210: case i_EXG:
1211: clocks = 6;
1212: break;
1213: case i_EXT:
1214: clocks = 4;
1215: break;
1216: case i_LINK:
1217: clocks = 16;
1218: break;
1219: case i_MOVEFSR:
1220: clocks = (stype == dt_Dreg) ? 6 : 8 + clocks_eacalc(stype, size);
1221: break;
1222: case i_MOVETSR:
1223: clocks = (stype == dt_Dreg) ? 12 : 12 +
1224: clocks_eacalc(stype, size);
1225: break;
1226: case i_MOVETUSP:
1227: case i_MOVEFUSP:
1228: clocks = 4;
1229: break;
1230: case i_NOP:
1231: clocks = 4;
1232: break;
1233: case i_RESET:
1234: clocks = 132;
1235: break;
1236: case i_RTE:
1237: case i_RTR:
1238: clocks = 20;
1239: break;
1240: case i_RTS:
1241: clocks = 20;
1242: break;
1243: case i_STOP:
1244: clocks = 4;
1245: break;
1246: case i_SWAP:
1247: clocks = 4;
1248: break;
1249: case i_TRAPV:
1250: clocks = 4;
1251: break;
1252: case i_TRAP:
1253: clocks = 4; /* exception */
1254: break;
1255: case i_UNLK:
1256: clocks = 12;
1257: break;
1258: case i_DBcc:
1259: case i_DBRA:
1260: case i_Bcc:
1261: clocks = 10;
1262: break;
1263: case i_BSR:
1264: clocks = 18;
1265: break;
1266: case i_MOVEPRM:
1267: case i_MOVEPMR:
1268: clocks = (size != sz_long) ? 16 : 24;
1269: break;
1270: case i_ILLG:
1271: clocks = 0;
1272: break;
1273: case i_LINE10:
1274: case i_LINE15:
1275: clocks = 4; /* exception */
1276: break;
1277: default:
1278: printf("%d: Invalid mnemonic type\n", lineno);
1279: exit(1);
1280: }
1281:
1282: if (clocks == -1) {
1283: printf("%d: Clocks not found\n", lineno);
1284: exit(1);
1285: }
1286:
1287: /* write output lines */
1288:
1289: fprintf(outiibs, " { 0x%x, 0x%x, %d, { %d, %d, %d, %d, %d }, ",
1290: mask, bits, mnemonic_num, priv, endblk, imm_notzero, used,
1291: set);
1292: fprintf(outiibs, "%d, %d, %d, %d, %d, %d, %d, %d, %d, %d},\n",
1293: size, stype, dtype, sbitpos, dbitpos, immvalue,
1294: cc, total, wordlen, clocks);
1295: fprintf(outiibs, "%60s/* %s */\n", "", mnemonic);
1296: if (set == 0) {
1297: fprintf(outfuncs, " cpu_op_%ia, /* %s */\n", total, mnemonic);
1298: fprintf(outfuncs, " cpu_op_%ia, /* %s */\n", total, mnemonic);
1299: fprintf(outproto, "extern void cpu_op_%ia("
1300: "t_ipc *ipc); /* %s */\n", total, mnemonic);
1301: } else {
1302: fprintf(outfuncs, " cpu_op_%ia, /* %s - normal */\n", total,
1303: mnemonic);
1304: fprintf(outfuncs, " cpu_op_%ib, /* %s - no flags */\n", total,
1305: mnemonic);
1306: fprintf(outproto, "extern void cpu_op_%ia("
1307: "t_ipc *ipc); /* %s */\n", total, mnemonic);
1308: fprintf(outproto, "extern void cpu_op_%ib("
1309: "t_ipc *ipc); /* %s */\n", total, mnemonic);
1310: }
1311:
1312: total++;
1313:
1314: } /* cc */
1315: } /* ea_f */
1316: } /* ea_e */
1317: } /* size */
1318: } /* block */
1319: }
1320:
1321: int clocks_movetable[] = {
1322: 4, 4, 8, 8, 8, 12, 14, 12, 16,
1323: 4, 4, 8, 8, 8, 12, 14, 12, 16,
1324: 8, 8, 12, 12, 12, 16, 18, 16, 20,
1325: 8, 8, 12, 12, 12, 16, 18, 16, 20,
1326: 10, 10, 14, 14, 14, 18, 20, 18, 22,
1327: 12, 12, 16, 16, 16, 20, 22, 20, 24,
1328: 14, 14, 18, 18, 18, 22, 24, 22, 26,
1329: 12, 12, 16, 16, 16, 20, 22, 20, 24,
1330: 16, 16, 20, 20, 20, 24, 26, 24, 28,
1331: 12, 12, 16, 16, 16, 20, 22, 20, 24,
1332: 14, 14, 18, 18, 18, 22, 24, 22, 26,
1333: 8, 8, 12, 12, 12, 16, 18, 16, 20
1334: };
1335:
1336: int clocks_typetoindex(t_datatype type)
1337: {
1338: switch(type) {
1339: case dt_Dreg: return 0;
1340: case dt_Areg: return 1;
1341: case dt_Aind: return 2;
1342: case dt_Ainc: return 3;
1343: case dt_Adec: return 4;
1344: case dt_Adis: return 5;
1345: case dt_Aidx: return 6;
1346: case dt_AbsW: return 7;
1347: case dt_AbsL: return 8;
1348: case dt_Pdis: return 9;
1349: case dt_Pidx: return 10;
1350: case dt_ImmB:
1351: case dt_ImmW:
1352: case dt_ImmL:
1353: case dt_ImmS:
1354: case dt_Imm3:
1355: case dt_Imm4:
1356: case dt_Imm8:
1357: case dt_Imm8s: return 11;
1358: default:
1359: break;
1360: }
1361: printf("Invalid type for clocks\n");
1362: exit(1);
1363: }
1364:
1365: int clocks_eacalc(t_datatype type, t_size size)
1366: {
1367: switch(type) {
1368: case dt_Dreg:
1369: case dt_Areg: return 0;
1370: case dt_Aind: return (size != sz_long) ? 4 : 8;
1371: case dt_Ainc: return (size != sz_long) ? 6 : 10; /* should this be 4/8? */
1372: case dt_Adec: return (size != sz_long) ? 6 : 10;
1373: case dt_Adis: return (size != sz_long) ? 8 : 12;
1374: case dt_Aidx: return (size != sz_long) ? 10 : 14;
1375: case dt_AbsW: return (size != sz_long) ? 8 : 12;
1376: case dt_AbsL: return (size != sz_long) ? 12 : 16;
1377: case dt_Pdis: return (size != sz_long) ? 8 : 12;
1378: case dt_Pidx: return (size != sz_long) ? 10 : 14;
1379: case dt_ImmB:
1380: case dt_ImmW:
1381: case dt_ImmL: return (size != sz_long) ? 4 : 8;
1382: case dt_ImmS:
1383: case dt_Imm3:
1384: case dt_Imm4:
1385: case dt_Imm8:
1386: case dt_Imm8s:
1.1.1.3 ! root 1387: case dt_ImmV:
1.1 root 1388: case dt_Ill: return 0;
1389: }
1390: printf("Invalid type for clocks\n");
1391: exit(1);
1392: }
1393:
1394: int clocks_6or8(t_datatype type)
1395: {
1396: int type_imm = (type == dt_ImmB) || (type == dt_ImmW) ||
1397: (type == dt_ImmL) || (type == dt_Imm3) || (type == dt_Imm4) ||
1398: (type == dt_Imm8) || (type == dt_Imm8s) || (type == dt_ImmS);
1399:
1400: return (type_imm || type == dt_Dreg || type == dt_Areg) ? 8 : 6;
1401: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.