![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gen68k.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 gen68k.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: /* gen68k.c */
6: /* */
7: /*****************************************************************************/
8:
9: #include <stdio.h>
10:
11: #include "generator.h"
12:
13: #include "out/def68k-iibs.h"
14:
15: /* forward references */
16:
17: void generate(FILE *output, int topnibble);
18: void generate_ea(FILE *o, t_iib *iib, t_type type, int update);
19: void generate_eaval(FILE *o, t_iib *iib, t_type type);
20: void generate_eastore(FILE *o, t_iib *iib, t_type type);
21: void generate_outdata(FILE *o, t_iib *iib, const char *init);
22: void generate_cc(FILE *o, t_iib *iib);
23: void generate_stdflag_n(FILE *o, t_iib *iib);
24: void generate_stdflag_z(FILE *o, t_iib *iib);
25: void generate_clrflag_v(FILE *o, t_iib *iib);
26: void generate_clrflag_c(FILE *o, t_iib *iib);
27: void generate_clrflag_n(FILE *o, t_iib *iib);
28: void generate_setflag_z(FILE *o, t_iib *iib);
29: void generate_subflag_c(FILE *o, t_iib *iib);
30: void generate_subflag_cx(FILE *o, t_iib *iib);
31: void generate_subxflag_cx(FILE *o, t_iib *iib);
32: void generate_subflag_v(FILE *o, t_iib *iib);
33: void generate_cmpaflag_c(FILE *o, t_iib *iib);
34: void generate_cmpaflag_v(FILE *o, t_iib *iib);
35: void generate_addflag_cx(FILE *o, t_iib *iib);
36: void generate_addflag_v(FILE *o, t_iib *iib);
37: void generate_addxflag_cx(FILE *o, t_iib *iib);
38: void generate_stdxflag_z(FILE *o, t_iib *iib);
39: void generate_negflag_cx(FILE *o, t_iib *iib);
40: void generate_negflag_v(FILE *o, t_iib *iib);
41: void generate_negxflag_cx(FILE *o, t_iib *iib);
42: void generate_negxflag_v(FILE *o, t_iib *iib);
43: void generate_bits(FILE *o, t_iib *iib);
44:
45: /* defines */
46:
47: #define HEADER "/*****************************************************************************/\n/* Generator - Sega Genesis emulation - (c) James Ponder 1997-1998 */\n/*****************************************************************************/\n/* */\n/* cpu68k-%x.c */\n/* */\n/*****************************************************************************/\n\n"
48:
49: #define OUT(x) fputs(x,output);
50:
51: /* program entry routine */
52:
53: int main(int argc, char *argv[])
54: {
55: FILE *output;
56: int i;
57: char tmp[256];
58:
59: printf("Writing C files... ");
60: fflush(stdout);
61:
62: for (i = 0; i < 16; i++) {
63:
64: printf("%d. ", i);
65: fflush(stdout);
66:
67: /* make filename */
68: sprintf(tmp, FNAME_GEN68K_CPU_OUT, i);
69:
70: /* open output file */
71: if ((output = fopen(tmp, "w")) == NULL) {
72: perror("fopen output");
73: exit(1);
74: }
75:
76: /* output header */
77: fprintf(output, HEADER, i);
78: fprintf(output, "#include \"generator.h\"\n");
79: fprintf(output, "#include \"cpu68k.h\"\n");
80: fprintf(output, "#include \"mem68k.h\"\n");
81: fprintf(output, "#include \"reg68k.h\"\n\n");
82: fprintf(output, "#include \"cpu68k-inline.h\"\n\n");
83: fprintf(output, "#include <stdio.h>\n\n");
84:
85: generate(output, i);
86:
87: /* close output */
88: if (fclose(output)) {
89: perror("fclose output");
90: exit(1);
91: }
92:
93: }
94:
95: printf("done.\n");
96: fflush(stdout);
97:
98: /* normal program termination */
99: return(0);
100: }
101:
102: void generate(FILE *output, int topnibble)
103: {
104: t_iib *iib;
105: int i, flags, pcinc;
106: int DEBUG_BRANCH = 0;
107: int DEBUG_SR = 0;
108: int DEBUG_RTE = 0;
109:
110: for (i = 0; i < iibs_num; i++) {
111: iib = &iibs[i];
112:
113: if ((iib->mask & 0xF000) != 0xF000) {
114: fprintf(stderr, "error: Strange mask %x\n", iib->mask);
115: exit(1);
116: }
117: if (((iib->bits & 0xF000)>>12) != topnibble) {
118: continue;
119: }
120:
121: for (flags = 0; flags < 2; flags++) {
122:
123: if (flags == 1 && iib->flags.set == 0) {
124: /* there is no non-flags version, functable will already go
125: straight to the normal version anyway, so lets just skip it */
126: continue;
127: }
128:
129: fprintf(output, "void cpu_op_%i%s(t_ipc *ipc) /* %s */ {\n",
130: i, flags ? "b" : "a", mnemonic_table[iib->mnemonic].name);
131: fprintf(output, " /* mask %0.4x, bits %0.4x, mnemonic %d, priv %d, ",
132: iib->mask, iib->bits, iib->mnemonic, iib->flags.priv);
133: fprintf(output, "endblk %d, imm_notzero %d, used %d",
134: iib->flags.endblk, iib->flags.imm_notzero, iib->flags.used);
135: fprintf(output, " set %d, size %d, stype %d, dtype %d, sbitpos %d, ",
136: iib->flags.set, iib->size, iib->stype, iib->dtype, iib->sbitpos);
137: fprintf(output, "dbitpos %d, immvalue %d */\n", iib->dbitpos,
138: iib->immvalue);
139:
140: pcinc = 1;
141:
142: switch(iib->mnemonic) {
143:
144: case i_OR:
145: case i_AND:
146: case i_EOR:
147: generate_ea(output, iib, tp_src, 1);
148: generate_eaval(output, iib, tp_src);
149: generate_ea(output, iib, tp_dst, 1);
150: generate_eaval(output, iib, tp_dst);
151: generate_outdata(output, iib, "dstdata");
152: OUT("\n");
153: switch(iib->mnemonic) {
154: case i_OR:
155: OUT(" outdata|= srcdata;\n");
156: break;
157: case i_AND:
158: OUT(" outdata&= srcdata;\n");
159: break;
160: case i_EOR:
161: OUT(" outdata^= srcdata;\n");
162: break;
163: default:
164: OUT("ERROR\n");
165: break;
166: }
167: generate_eastore(output, iib, tp_dst);
168: if (flags)
169: OUT("\n");
170: if (flags && iib->flags.set & IIB_FLAG_N)
171: generate_stdflag_n(output, iib);
172: if (flags && iib->flags.set & IIB_FLAG_Z)
173: generate_stdflag_z(output, iib);
174: if (flags && iib->flags.set & IIB_FLAG_V)
175: generate_clrflag_v(output, iib);
176: if (flags && iib->flags.set & IIB_FLAG_C)
177: generate_clrflag_c(output, iib);
178: break;
179:
180: case i_ORSR:
181: case i_ANDSR:
182: case i_EORSR:
183: generate_ea(output, iib, tp_src, 1);
184: generate_eaval(output, iib, tp_src);
185: OUT(" unsigned int sr = reg68k_sr.sr_struct.s;\n");
186: OUT("\n");
187: if (DEBUG_SR)
188: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
189: output);
190: if (iib->size == sz_word) {
191: OUT(" if (!SFLAG)\n");
192: fprintf(output, " reg68k_vector(V_PRIVILEGE, PC+%d);\n",
193: (iib->wordlen)*2);
194: OUT("\n");
195: }
196: switch(iib->mnemonic) {
197: case i_ORSR:
198: OUT(" SR|= srcdata;\n");
199: break;
200: case i_ANDSR:
201: if (iib->size == sz_byte) {
202: OUT(" SR = (SR & 0xFF00) | (SR & srcdata);\n");
203: } else {
204: OUT(" SR&= srcdata;\n");
205: }
206: break;
207: case i_EORSR:
208: OUT(" SR^= srcdata;\n");
209: break;
210: default:
211: OUT("ERROR\n");
212: break;
213: }
214: OUT(" if (sr != (uint8)reg68k_sr.sr_struct.s) {\n");
215: OUT(" /* mode change, swap SP and A7 */\n");
216: OUT(" ADDRREG(7)^= SP; SP^= ADDRREG(7); ADDRREG(7)^= SP;\n");
217: OUT(" }\n");
218: if (DEBUG_SR)
219: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
220: output);
221: break;
222:
223: case i_SUB:
224: generate_ea(output, iib, tp_src, 1);
225: generate_eaval(output, iib, tp_src);
226: generate_ea(output, iib, tp_dst, 1);
227: generate_eaval(output, iib, tp_dst);
228: switch (iib->size) {
229: case sz_byte:
230: generate_outdata(output, iib, "(sint8)dstdata - (sint8)srcdata");
231: break;
232: case sz_word:
233: generate_outdata(output, iib, "(sint16)dstdata - (sint16)srcdata");
234: break;
235: case sz_long:
236: generate_outdata(output, iib, "(sint32)dstdata - (sint32)srcdata");
237: break;
238: default:
239: OUT("ERROR size\n");
240: break;
241: }
242: OUT("\n");
243: generate_eastore(output, iib, tp_dst);
244: if (flags)
245: OUT("\n");
246: if (flags && iib->flags.set & IIB_FLAG_V)
247: generate_subflag_v(output, iib);
248: if (flags && ((iib->flags.set & IIB_FLAG_C) ||
249: (iib->flags.set & IIB_FLAG_X)))
250: generate_subflag_cx(output, iib);
251: if (flags && iib->flags.set & IIB_FLAG_N)
252: generate_stdflag_n(output, iib);
253: if (flags && iib->flags.set & IIB_FLAG_Z)
254: generate_stdflag_z(output, iib);
255: break;
256:
257: case i_SUBA:
258: if (iib->dtype != dt_Areg)
259: OUT("Error\n");
260: generate_ea(output, iib, tp_src, 1);
261: generate_eaval(output, iib, tp_src);
262: generate_ea(output, iib, tp_dst, 1);
263: OUT(" uint32 dstdata = ADDRREG(dstreg);\n");
264: switch (iib->size) {
265: case sz_byte:
266: OUT(" uint32 outdata = (sint32)dstdata - (sint8)srcdata;\n");
267: break;
268: case sz_word:
269: OUT(" uint32 outdata = (sint32)dstdata - (sint16)srcdata;\n");
270: break;
271: case sz_long:
272: OUT(" uint32 outdata = (sint32)dstdata - (sint32)srcdata;\n");
273: break;
274: default:
275: OUT("ERROR size\n");
276: break;
277: }
278: OUT("\n");
279: OUT(" ADDRREG(dstreg) = outdata;\n");
280: break;
281:
282: case i_SUBX:
283: generate_ea(output, iib, tp_src, 1);
284: generate_eaval(output, iib, tp_src);
285: generate_ea(output, iib, tp_dst, 1);
286: generate_eaval(output, iib, tp_dst);
287: switch (iib->size) {
288: case sz_byte:
289: generate_outdata(output, iib, "(sint8)dstdata - (sint8)srcdata "
290: "- XFLAG");
291: break;
292: case sz_word:
293: generate_outdata(output, iib, "(sint16)dstdata - (sint16)srcdata"
294: "- XFLAG");
295: break;
296: case sz_long:
297: generate_outdata(output, iib, "(sint32)dstdata - (sint32)srcdata"
298: "- XFLAG");
299: break;
300: default:
301: OUT("ERROR size\n");
302: break;
303: }
304: OUT("\n");
305: generate_eastore(output, iib, tp_dst);
306: if (flags)
307: OUT("\n");
308: if (flags && iib->flags.set & IIB_FLAG_V)
309: generate_subflag_v(output, iib);
310: if (flags && ((iib->flags.set & IIB_FLAG_C) ||
311: (iib->flags.set & IIB_FLAG_X)))
312: generate_subxflag_cx(output, iib);
313: if (flags && iib->flags.set & IIB_FLAG_N)
314: generate_stdflag_n(output, iib);
315: if (flags && iib->flags.set & IIB_FLAG_Z)
316: generate_stdxflag_z(output, iib);
317: break;
318:
319: case i_ADD:
320: generate_ea(output, iib, tp_src, 1);
321: generate_eaval(output, iib, tp_src);
322: generate_ea(output, iib, tp_dst, 1);
323: generate_eaval(output, iib, tp_dst);
324: switch (iib->size) {
325: case sz_byte:
326: generate_outdata(output, iib, "(sint8)dstdata + (sint8)srcdata");
327: break;
328: case sz_word:
329: generate_outdata(output, iib, "(sint16)dstdata + (sint16)srcdata");
330: break;
331: case sz_long:
332: generate_outdata(output, iib, "(sint32)dstdata + (sint32)srcdata");
333: break;
334: default:
335: OUT("ERROR size\n");
336: break;
337: }
338: OUT("\n");
339: generate_eastore(output, iib, tp_dst);
340: if (flags)
341: OUT("\n");
342: if (flags && iib->flags.set & IIB_FLAG_V)
343: generate_addflag_v(output, iib);
344: if (flags && ((iib->flags.set & IIB_FLAG_C) ||
345: (iib->flags.set & IIB_FLAG_X)))
346: generate_addflag_cx(output, iib);
347: if (flags && iib->flags.set & IIB_FLAG_N)
348: generate_stdflag_n(output, iib);
349: if (flags && iib->flags.set & IIB_FLAG_Z)
350: generate_stdflag_z(output, iib);
351: break;
352:
353: case i_ADDA:
354: if (iib->dtype != dt_Areg)
355: OUT("Error\n");
356: generate_ea(output, iib, tp_src, 1);
357: generate_eaval(output, iib, tp_src);
358: generate_ea(output, iib, tp_dst, 1);
359: OUT(" uint32 dstdata = ADDRREG(dstreg);\n");
360: switch (iib->size) {
361: case sz_byte:
362: OUT(" uint32 outdata = (sint32)dstdata + (sint8)srcdata;\n");
363: break;
364: case sz_word:
365: OUT(" uint32 outdata = (sint32)dstdata + (sint16)srcdata;\n");
366: break;
367: case sz_long:
368: OUT(" uint32 outdata = (sint32)dstdata + (sint32)srcdata;\n");
369: break;
370: default:
371: OUT("ERROR size\n");
372: break;
373: }
374: OUT("\n");
375: OUT(" ADDRREG(dstreg) = outdata;\n");
376: break;
377:
378: case i_ADDX:
379: generate_ea(output, iib, tp_src, 1);
380: generate_eaval(output, iib, tp_src);
381: generate_ea(output, iib, tp_dst, 1);
382: generate_eaval(output, iib, tp_dst);
383: switch (iib->size) {
384: case sz_byte:
385: generate_outdata(output, iib, "(sint8)dstdata + (sint8)srcdata "
386: "+ XFLAG");
387: break;
388: case sz_word:
389: generate_outdata(output, iib, "(sint16)dstdata + (sint16)srcdata"
390: "+ XFLAG");
391: break;
392: case sz_long:
393: generate_outdata(output, iib, "(sint32)dstdata + (sint32)srcdata"
394: "+ XFLAG");
395: break;
396: default:
397: OUT("ERROR size\n");
398: break;
399: }
400: OUT("\n");
401: generate_eastore(output, iib, tp_dst);
402: if (flags)
403: OUT("\n");
404: if (flags && iib->flags.set & IIB_FLAG_V)
405: generate_addflag_v(output, iib);
406: if (flags && ((iib->flags.set & IIB_FLAG_C) ||
407: (iib->flags.set & IIB_FLAG_X)))
408: generate_addxflag_cx(output, iib);
409: if (flags && iib->flags.set & IIB_FLAG_N)
410: generate_stdflag_n(output, iib);
411: if (flags && iib->flags.set & IIB_FLAG_Z)
412: generate_stdxflag_z(output, iib);
413: break;
414:
415: case i_MULU:
416: generate_ea(output, iib, tp_src, 1);
417: generate_eaval(output, iib, tp_src);
418: generate_ea(output, iib, tp_dst, 1);
419: generate_eaval(output, iib, tp_dst);
420: OUT("\n");
421: OUT(" uint32 outdata = (uint32)srcdata * (uint32)dstdata;\n");
422: if (iib->dtype != dt_Dreg)
423: OUT("ERROR dtype\n");
424: OUT(" DATAREG(dstreg) = outdata;\n");
425: if (flags)
426: OUT("\n");
427: if (flags && iib->flags.set & IIB_FLAG_N)
428: OUT(" NFLAG = ((sint32)outdata) < 0;\n");
429: if (flags && iib->flags.set & IIB_FLAG_Z)
430: generate_stdflag_z(output, iib);
431: if (flags && iib->flags.set & IIB_FLAG_V)
432: generate_clrflag_v(output, iib);
433: if (flags && iib->flags.set & IIB_FLAG_C)
434: generate_clrflag_c(output, iib);
435: break;
436:
437: case i_MULS:
438: generate_ea(output, iib, tp_src, 1);
439: generate_eaval(output, iib, tp_src);
440: generate_ea(output, iib, tp_dst, 1);
441: generate_eaval(output, iib, tp_dst);
442: OUT("\n");
443: OUT(" uint32 outdata = (sint32)(sint16)srcdata * "
444: "(sint32)(sint16)dstdata;\n");
445: if (iib->dtype != dt_Dreg)
446: OUT("ERROR dtype\n");
447: OUT(" DATAREG(dstreg) = outdata;\n");
448: if (flags)
449: OUT("\n");
450: if (flags && iib->flags.set & IIB_FLAG_N)
451: OUT(" NFLAG = ((sint32)outdata) < 0;\n");
452: if (flags && iib->flags.set & IIB_FLAG_Z)
453: generate_stdflag_z(output, iib);
454: if (flags && iib->flags.set & IIB_FLAG_V)
455: generate_clrflag_v(output, iib);
456: if (flags && iib->flags.set & IIB_FLAG_C)
457: generate_clrflag_c(output, iib);
458: break;
459:
460: case i_CMP:
461: generate_ea(output, iib, tp_src, 1);
462: generate_eaval(output, iib, tp_src);
463: generate_ea(output, iib, tp_dst, 1);
464: generate_eaval(output, iib, tp_dst);
465: switch (iib->size) {
466: case sz_byte:
467: generate_outdata(output, iib, "(sint8)dstdata - (sint8)srcdata");
468: break;
469: case sz_word:
470: generate_outdata(output, iib, "(sint16)dstdata - (sint16)srcdata");
471: break;
472: case sz_long:
473: generate_outdata(output, iib, "(sint32)dstdata - (sint32)srcdata");
474: break;
475: default:
476: OUT("ERROR size\n");
477: break;
478: }
479: if (flags)
480: OUT("\n");
481: if (flags && iib->flags.set & IIB_FLAG_V)
482: generate_subflag_v(output, iib);
483: if (flags && iib->flags.set & IIB_FLAG_C)
484: generate_subflag_c(output, iib);
485: if (flags && iib->flags.set & IIB_FLAG_N)
486: generate_stdflag_n(output, iib);
487: if (flags && iib->flags.set & IIB_FLAG_Z)
488: generate_stdflag_z(output, iib);
489: break;
490:
491: case i_CMPA:
492: if (iib->dtype != dt_Areg || iib->size != sz_word)
493: OUT("Error\n");
494: generate_ea(output, iib, tp_src, 1);
495: generate_eaval(output, iib, tp_src);
496: iib->size = sz_long;
497: generate_ea(output, iib, tp_dst, 1);
498: generate_eaval(output, iib, tp_dst);
499: OUT(" uint32 outdata = (sint32)dstdata - (sint32)(sint16)srcdata;\n");
500: if (flags)
501: OUT("\n");
502: if (flags && iib->flags.set & IIB_FLAG_V)
503: generate_cmpaflag_v(output, iib);
504: if (flags && iib->flags.set & IIB_FLAG_C)
505: generate_cmpaflag_c(output, iib);
506: if (flags && iib->flags.set & IIB_FLAG_N)
507: generate_stdflag_n(output, iib);
508: if (flags && iib->flags.set & IIB_FLAG_Z)
509: generate_stdflag_z(output, iib);
510: iib->size = sz_word;
511: break;
512:
513: case i_BTST:
514: case i_BCHG:
515: case i_BCLR:
516: case i_BSET:
517: generate_ea(output, iib, tp_src, 1);
518: generate_eaval(output, iib, tp_src);
519: generate_ea(output, iib, tp_dst, 1);
520: generate_eaval(output, iib, tp_dst);
521: switch (iib->size) {
522: case sz_byte:
523: OUT(" uint32 bitpos = 1<<(srcdata & 7);");
524: break;
525: case sz_long:
526: OUT(" uint32 bitpos = 1<<(srcdata & 31);");
527: break;
528: default:
529: OUT("ERROR size\n");
530: break;
531: }
532: OUT("\n");
533: switch(iib->mnemonic) {
534: case i_BTST:
535: break;
536: case i_BCHG:
537: generate_outdata(output, iib, "dstdata ^ bitpos");
538: generate_eastore(output, iib, tp_dst);
539: break;
540: case i_BCLR:
541: generate_outdata(output, iib, "dstdata & ~bitpos");
542: generate_eastore(output, iib, tp_dst);
543: break;
544: case i_BSET:
545: generate_outdata(output, iib, "dstdata | bitpos");
546: generate_eastore(output, iib, tp_dst);
547: break;
548: default:
549: OUT("ERROR\n");
550: break;
551: }
552: OUT("\n");
553: OUT(" ZFLAG = !(dstdata & bitpos);\n");
554: break;
555:
556: case i_MOVE:
557: generate_ea(output, iib, tp_src, 1);
558: generate_eaval(output, iib, tp_src);
559: generate_ea(output, iib, tp_dst, 1);
560: generate_outdata(output, iib, "srcdata");
561: OUT("\n");
562: generate_eastore(output, iib, tp_dst);
563: if (flags)
564: OUT("\n");
565: if (flags && iib->flags.set & IIB_FLAG_V)
566: generate_clrflag_v(output, iib);
567: if (flags && iib->flags.set & IIB_FLAG_C)
568: generate_clrflag_c(output, iib);
569: if (flags && iib->flags.set & IIB_FLAG_N)
570: generate_stdflag_n(output, iib);
571: if (flags && iib->flags.set & IIB_FLAG_Z)
572: generate_stdflag_z(output, iib);
573: break;
574:
575: case i_MOVEA:
576: generate_ea(output, iib, tp_src, 1);
577: generate_eaval(output, iib, tp_src);
578: generate_ea(output, iib, tp_dst, 1);
579: if (iib->dtype != dt_Areg || iib->size != sz_word)
580: OUT("Error\n");
581: OUT("\n");
582: OUT(" ADDRREG(dstreg) = (sint32)(sint16)srcdata;\n");
583: break;
584:
585: case i_MOVEPMR:
586: generate_ea(output, iib, tp_src, 1);
587: generate_ea(output, iib, tp_dst, 1);
588: generate_eaval(output, iib, tp_dst);
589: switch(iib->size) {
590: case sz_word:
591: generate_outdata(output, iib, "(fetchbyte(srcaddr) << 8) + "
592: "fetchbyte(srcaddr+2)");
593: break;
594: case sz_long:
595: generate_outdata(output, iib, "(fetchbyte(srcaddr) << 24) | "
596: "(fetchbyte(srcaddr+2) << 16) | "
597: "\n (fetchbyte(srcaddr+4) << 8) | "
598: "fetchbyte(srcaddr+6)");
599: break;
600: default:
601: OUT("ERROR size\n");
602: break;
603: }
604: OUT("\n");
605: generate_eastore(output, iib, tp_dst);
606: break;
607:
608: case i_MOVEPRM:
609: generate_ea(output, iib, tp_src, 1);
610: generate_eaval(output, iib, tp_src);
611: generate_ea(output, iib, tp_dst, 1);
612: OUT("\n");
613: switch(iib->size) {
614: case sz_word:
615: OUT(" storebyte(dstaddr, (srcdata >> 8) & 0xFF);\n");
616: OUT(" storebyte(dstaddr+2, srcdata & 0xFF);\n");
617: break;
618: case sz_long:
619: OUT(" storebyte(dstaddr, (srcdata >> 24) & 0xFF);\n");
620: OUT(" storebyte(dstaddr+2, (srcdata >> 16) & 0xFF);\n");
621: OUT(" storebyte(dstaddr+4, (srcdata >> 8) & 0xFF);\n");
622: OUT(" storebyte(dstaddr+6, srcdata & 0xFF);\n");
623: break;
624: default:
625: OUT("ERROR size\n");
626: break;
627: }
628: break;
629:
630: case i_MOVEFSR:
631: generate_ea(output, iib, tp_src, 1);
632: generate_outdata(output, iib, NULL);
633: OUT("\n");
634: OUT(" outdata = SR;\n");
635: generate_eastore(output, iib, tp_src);
636: break;
637:
638: case i_MOVETSR:
639: generate_ea(output, iib, tp_src, 1);
640: generate_eaval(output, iib, tp_src);
641: OUT(" unsigned int sr = reg68k_sr.sr_struct.s;\n");
642: OUT("\n");
643: if (DEBUG_SR)
644: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
645: output);
646: switch (iib->size) {
647: case sz_byte:
648: OUT(" SR = (SR & ~0xFF) | srcdata;\n");
649: break;
650: case sz_word:
651: OUT(" if (!SFLAG)\n");
652: fprintf(output, " reg68k_vector(V_PRIVILEGE, PC+%d);\n",
653: (iib->wordlen)*2);
654: OUT("\n");
655: OUT(" SR = srcdata;\n");
656: break;
657: default:
658: OUT("ERROR size\n");
659: break;
660: }
661: OUT(" if (sr != (uint8)reg68k_sr.sr_struct.s) {\n");
662: OUT(" /* mode change, swap SP and A7 */\n");
663: OUT(" ADDRREG(7)^= SP; SP^= ADDRREG(7); ADDRREG(7)^= SP;\n");
664: OUT(" }\n");
665: if (DEBUG_SR)
666: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
667: output);
668: break;
669:
670: case i_MOVEMRM:
671: generate_ea(output, iib, tp_src, 1);
672: generate_eaval(output, iib, tp_src);
673: generate_ea(output, iib, tp_dst, 0);
674: if (iib->dtype == dt_Adec) {
675: OUT(" uint8 datamask = (srcdata & 0xFF00) >> 8;\n");
676: OUT(" uint8 addrmask = srcdata & 0xFF;");
677: OUT("\n");
678: switch(iib->size) {
679: case sz_word:
680: OUT(" while (addrmask) {\n");
681: OUT(" dstaddr-= 2;\n");
682: OUT(" storeword(dstaddr, ADDRREG((7-movem_bit[addrmask])));\n");
683: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n");
684: OUT(" }\n");
685: OUT(" while (datamask) {\n");
686: OUT(" dstaddr-= 2;\n");
687: OUT(" storeword(dstaddr, DATAREG((7-movem_bit[datamask])));\n");
688: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n");
689: OUT(" }\n");
690: break;
691: case sz_long:
692: OUT(" while (addrmask) {\n");
693: OUT(" dstaddr-= 4;\n");
694: OUT(" storelong(dstaddr, ADDRREG((7-movem_bit[addrmask])));\n");
695: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n");
696: OUT(" }\n");
697: OUT(" while (datamask) {\n");
698: OUT(" dstaddr-= 4;\n");
699: OUT(" storelong(dstaddr, ");
700: OUT("DATAREG((7-movem_bit[datamask])));\n");
701: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n");
702: OUT(" }\n");
703: break;
704: default:
705: OUT("ERROR\n");
706: break;
707: }
708: OUT(" ADDRREG(dstreg) = dstaddr;");
709: } else {
710: OUT(" uint8 addrmask = (srcdata & 0xFF00) >> 8;\n");
711: OUT(" uint8 datamask = srcdata & 0xFF;");
712: OUT("\n");
713: switch(iib->size) {
714: case sz_word:
715: OUT(" while (datamask) {\n");
716: OUT(" storeword(dstaddr, DATAREG(movem_bit[datamask]));\n");
717: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n");
718: OUT(" dstaddr+= 2;\n");
719: OUT(" }\n");
720: OUT(" while (addrmask) {\n");
721: OUT(" storeword(dstaddr, ADDRREG(movem_bit[addrmask]));\n");
722: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n");
723: OUT(" dstaddr+= 2;\n");
724: OUT(" }\n");
725: break;
726: case sz_long:
727: OUT(" while (datamask) {\n");
728: OUT(" storelong(dstaddr, DATAREG(movem_bit[datamask]));\n");
729: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n");
730: OUT(" dstaddr+= 4;\n");
731: OUT(" }\n");
732: OUT(" while (addrmask) {\n");
733: OUT(" storelong(dstaddr, ADDRREG(movem_bit[addrmask]));\n");
734: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n");
735: OUT(" dstaddr+= 4;\n");
736: OUT(" }\n");
737: break;
738: default:
739: OUT("ERROR\n");
740: break;
741: }
742: if (iib->dtype == dt_Ainc) {
743: /* not supported */
744: OUT("ERROR\n");
745: }
746: }
747: break;
748:
749: case i_MOVEMMR:
750: generate_ea(output, iib, tp_src, 1);
751: generate_eaval(output, iib, tp_src);
752: generate_ea(output, iib, tp_dst, 0);
753: OUT(" uint8 addrmask = (srcdata & 0xFF00) >> 8;\n");
754: OUT(" uint8 datamask = srcdata & 0xFF;");
755: OUT("\n");
756: switch(iib->size) {
757: case sz_word:
758: OUT(" while (datamask) {\n");
759: OUT(" DATAREG(movem_bit[datamask]) = ");
760: OUT("(sint32)(sint16)fetchword(dstaddr);\n");
761: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n");
762: OUT(" dstaddr+= 2;\n");
763: OUT(" }\n");
764: OUT(" while (addrmask) {\n");
765: OUT(" ADDRREG(movem_bit[addrmask]) = ");
766: OUT("(sint32)(sint16)fetchword(dstaddr);\n");
767: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n");
768: OUT(" dstaddr+= 2;\n");
769: OUT(" }\n");
770: break;
771: case sz_long:
772: OUT(" while (datamask) {\n");
773: OUT(" DATAREG(movem_bit[datamask]) = fetchlong(dstaddr);\n");
774: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n");
775: OUT(" dstaddr+= 4;\n");
776: OUT(" }\n");
777: OUT(" while (addrmask) {\n");
778: OUT(" ADDRREG(movem_bit[addrmask]) = fetchlong(dstaddr);\n");
779: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n");
780: OUT(" dstaddr+= 4;\n");
781: OUT(" }\n");
782: break;
783: default:
784: OUT("ERROR\n");
785: break;
786: }
787: if (iib->dtype == dt_Ainc) {
788: OUT(" ADDRREG(dstreg) = dstaddr;\n");
789: } else if (iib->dtype == dt_Adec) {
790: /* not supported */
791: OUT("ERROR\n");
792: }
793: break;
794:
795: case i_MOVETUSP:
796: generate_ea(output, iib, tp_src, 1);
797: generate_eaval(output, iib, tp_src);
798: OUT("\n");
799: OUT(" if (!SFLAG)\n");
800: fprintf(output, " reg68k_vector(V_PRIVILEGE, PC+%d);\n",
801: (iib->wordlen)*2);
802: OUT("\n");
803: OUT(" SP = srcdata;\n");
804: break;
805:
806: case i_MOVEFUSP:
807: generate_ea(output, iib, tp_src, 1);
808: OUT(" uint32 outdata;\n");
809: OUT("\n");
810: OUT(" if (!SFLAG)\n");
811: fprintf(output, " reg68k_vector(V_PRIVILEGE, PC+%d);\n",
812: (iib->wordlen)*2);
813: OUT("\n");
814: OUT(" outdata = SP;\n");
815: generate_eastore(output, iib, tp_src);
816: break;
817:
818: case i_NEG:
819: generate_ea(output, iib, tp_src, 1);
820: generate_eaval(output, iib, tp_src);
821: switch (iib->size) {
822: case sz_byte:
823: generate_outdata(output, iib, "0 - (sint8)srcdata");
824: break;
825: case sz_word:
826: generate_outdata(output, iib, "0 - (sint16)srcdata");
827: break;
828: case sz_long:
829: generate_outdata(output, iib, "0 - (sint32)srcdata");
830: break;
831: default:
832: OUT("ERROR size\n");
833: break;
834: }
835: OUT("\n");
836: generate_eastore(output, iib, tp_src);
837: if (flags)
838: OUT("\n");
839: if (flags && iib->flags.set & IIB_FLAG_V)
840: generate_negflag_v(output, iib);
841: if (flags && ((iib->flags.set & IIB_FLAG_C) ||
842: (iib->flags.set & IIB_FLAG_X)))
843: generate_negflag_cx(output, iib);
844: if (flags && iib->flags.set & IIB_FLAG_N)
845: generate_stdflag_n(output, iib);
846: if (flags && iib->flags.set & IIB_FLAG_Z)
847: generate_stdflag_z(output, iib);
848: break;
849:
850: case i_NEGX:
851: generate_ea(output, iib, tp_src, 1);
852: generate_eaval(output, iib, tp_src);
853: switch (iib->size) {
854: case sz_byte:
855: generate_outdata(output, iib, "0 - (sint8)srcdata - XFLAG");
856: break;
857: case sz_word:
858: generate_outdata(output, iib, "0 - (sint16)srcdata - XFLAG");
859: break;
860: case sz_long:
861: generate_outdata(output, iib, "0 - (sint32)srcdata - XFLAG");
862: break;
863: default:
864: OUT("ERROR size\n");
865: break;
866: }
867: OUT("\n");
868: generate_eastore(output, iib, tp_src);
869: if (flags)
870: OUT("\n");
871: if (flags && iib->flags.set & IIB_FLAG_V)
872: generate_negxflag_v(output, iib);
873: if (flags && ((iib->flags.set & IIB_FLAG_C) ||
874: (iib->flags.set & IIB_FLAG_X)))
875: generate_negxflag_cx(output, iib);
876: if (flags && iib->flags.set & IIB_FLAG_N)
877: generate_stdflag_n(output, iib);
878: if (flags && iib->flags.set & IIB_FLAG_Z)
879: generate_stdxflag_z(output, iib);
880: break;
881:
882: case i_CLR:
883: generate_ea(output, iib, tp_src, 1);
884: generate_eaval(output, iib, tp_src); /* read before write */
885: generate_outdata(output, iib, "0");
886: OUT("\n");
887: generate_eastore(output, iib, tp_src);
888: if (flags)
889: OUT("\n");
890: if (flags && iib->flags.set & IIB_FLAG_V)
891: generate_clrflag_v(output, iib);
892: if (flags && iib->flags.set & IIB_FLAG_C)
893: generate_clrflag_c(output, iib);
894: if (flags && iib->flags.set & IIB_FLAG_N)
895: generate_clrflag_n(output, iib);
896: if (flags && iib->flags.set & IIB_FLAG_Z)
897: generate_setflag_z(output, iib);
898: break;
899:
900: case i_NOT:
901: generate_ea(output, iib, tp_src, 1);
902: generate_eaval(output, iib, tp_src); /* read before write */
903: generate_outdata(output, iib, "~srcdata");
904: OUT("\n");
905: generate_eastore(output, iib, tp_src);
906: if (flags)
907: OUT("\n");
908: if (flags && iib->flags.set & IIB_FLAG_V)
909: generate_clrflag_v(output, iib);
910: if (flags && iib->flags.set & IIB_FLAG_C)
911: generate_clrflag_c(output, iib);
912: if (flags && iib->flags.set & IIB_FLAG_N)
913: generate_stdflag_n(output, iib);
914: if (flags && iib->flags.set & IIB_FLAG_Z)
915: generate_stdflag_z(output, iib);
916: break;
917:
918: case i_ABCD:
919: generate_ea(output, iib, tp_src, 1);
920: generate_eaval(output, iib, tp_src);
921: generate_ea(output, iib, tp_dst, 1);
922: generate_eaval(output, iib, tp_dst);
923: generate_outdata(output, iib, NULL);
924: OUT("\n");
925: OUT(" uint8 outdata_low = (dstdata & 0xF) + (srcdata & 0xF) ");
926: OUT("+ XFLAG;\n");
927: OUT(" uint8 outdata_high = (dstdata>>4) + (srcdata>>4);\n");
928: OUT("\n");
929: OUT(" if (outdata_low > 9) {\n");
930: OUT(" outdata_low-=10; outdata_high++;\n");
931: OUT(" }\n");
932: OUT(" if (outdata_high > 9) {\n");
933: OUT(" outdata_high-=10;\n");
934: if (flags && iib->flags.set & IIB_FLAG_C)
935: OUT(" CFLAG = 1;\n");
936: if (flags && iib->flags.set & IIB_FLAG_X)
937: OUT(" XFLAG = 1;\n");
938: OUT(" } else {\n");
939: if (flags && iib->flags.set & IIB_FLAG_C)
940: OUT(" CFLAG = 0;\n");
941: if (flags && iib->flags.set & IIB_FLAG_X)
942: OUT(" XFLAG = 0;\n");
943: OUT(" }\n");
944: OUT(" outdata = outdata_low | (outdata_high << 4);\n");
945: if (flags && iib->flags.set & IIB_FLAG_Z)
946: OUT(" if (outdata) ZFLAG = 0;\n");
947: generate_eastore(output, iib, tp_dst);
948: break;
949:
950: case i_SBCD:
951: generate_ea(output, iib, tp_src, 1);
952: generate_eaval(output, iib, tp_src);
953: generate_ea(output, iib, tp_dst, 1);
954: generate_eaval(output, iib, tp_dst);
955: generate_outdata(output, iib, NULL);
956: OUT("\n");
957: OUT(" sint8 outdata_low = (sint8)(dstdata & 0xF) -");
958: OUT("(sint8)(srcdata & 0xF) - XFLAG;\n");
959: OUT(" sint8 outdata_high = (sint8)(dstdata>>4) - ");
960: OUT("(sint8)(srcdata>>4);\n");
961: OUT("\n");
962: OUT(" if (outdata_low < 0) {\n");
963: OUT(" outdata_low+=10; outdata_high--;\n");
964: OUT(" }\n");
965: OUT(" if (outdata_high < 0) {\n");
966: OUT(" outdata_high+=10;\n");
967: if (flags && iib->flags.set & IIB_FLAG_C)
968: OUT(" CFLAG = 1;\n");
969: if (flags && iib->flags.set & IIB_FLAG_X)
970: OUT(" XFLAG = 1;\n");
971: OUT(" } else {\n");
972: if (flags && iib->flags.set & IIB_FLAG_C)
973: OUT(" CFLAG = 0;\n");
974: if (flags && iib->flags.set & IIB_FLAG_X)
975: OUT(" XFLAG = 0;\n");
976: OUT(" }\n");
977: OUT(" outdata = (uint8)outdata_low | ");
978: OUT("((uint8)outdata_high << 4);\n");
979: if (flags && iib->flags.set & IIB_FLAG_Z)
980: OUT(" if (outdata) ZFLAG = 0;\n");
981: generate_eastore(output, iib, tp_dst);
982: break;
983:
984: case i_NBCD:
985: generate_ea(output, iib, tp_src, 1);
986: generate_eaval(output, iib, tp_src);
987: generate_outdata(output, iib, NULL);
988: OUT("\n");
989: OUT(" sint8 outdata_low = 0 - (sint8)(srcdata & 0xF) - XFLAG;\n");
990: OUT(" sint8 outdata_high = 0 - (sint8)(srcdata>>4);\n");
991: OUT("\n");
992: OUT(" if ((sint8)outdata_low < 0) {\n");
993: OUT(" outdata_low+=10; outdata_high--;\n");
994: OUT(" }\n");
995: OUT(" if ((sint8)outdata_high < 0) {\n");
996: OUT(" outdata_high+=10;\n");
997: if (flags && iib->flags.set & IIB_FLAG_C)
998: OUT(" CFLAG = 1;\n");
999: if (flags && iib->flags.set & IIB_FLAG_X)
1000: OUT(" XFLAG = 1;\n");
1001: OUT(" } else {\n");
1002: if (flags && iib->flags.set & IIB_FLAG_C)
1003: OUT(" CFLAG = 0;\n");
1004: if (flags && iib->flags.set & IIB_FLAG_X)
1005: OUT(" XFLAG = 0;\n");
1006: OUT(" }\n");
1007: OUT(" outdata = (uint8)outdata_low |");
1008: OUT("((uint8)outdata_high << 4);\n");
1009: if (flags && iib->flags.set & IIB_FLAG_Z)
1010: OUT(" if (outdata) ZFLAG = 0;\n");
1011: generate_eastore(output, iib, tp_src);
1012: break;
1013:
1014: case i_SWAP:
1015: generate_ea(output, iib, tp_src, 1);
1016: generate_eaval(output, iib, tp_src);
1017: generate_outdata(output, iib, "(srcdata>>16) | (srcdata<<16)");
1018: OUT("\n");
1019: generate_eastore(output, iib, tp_src);
1020: if (flags)
1021: OUT("\n");
1022: if (flags && iib->flags.set & IIB_FLAG_V)
1023: generate_clrflag_v(output, iib);
1024: if (flags && iib->flags.set & IIB_FLAG_C)
1025: generate_clrflag_c(output, iib);
1026: if (flags && iib->flags.set & IIB_FLAG_N)
1027: generate_stdflag_n(output, iib);
1028: if (flags && iib->flags.set & IIB_FLAG_Z)
1029: generate_stdflag_z(output, iib);
1030: break;
1031:
1032: case i_PEA:
1033: generate_ea(output, iib, tp_src, 1);
1034: OUT("\n");
1035: OUT(" ADDRREG(7)-= 4;\n");
1036: OUT(" storelong(ADDRREG(7), srcaddr);\n");
1037: break;
1038:
1039: case i_LEA:
1040: generate_ea(output, iib, tp_src, 1);
1041: generate_ea(output, iib, tp_dst, 1);
1042: generate_outdata(output, iib, "srcaddr");
1043: OUT("\n");
1044: generate_eastore(output, iib, tp_dst);
1045: break;
1046:
1047: case i_EXT:
1048: generate_ea(output, iib, tp_src, 1);
1049: generate_eaval(output, iib, tp_src);
1050: OUT("\n");
1051: switch(iib->size) {
1052: case sz_word:
1053: generate_outdata(output, iib, "(sint16)(sint8)(srcdata)");
1054: break;
1055: case sz_long:
1056: generate_outdata(output, iib, "(sint32)(sint16)(srcdata)");
1057: break;
1058: default:
1059: fprintf(output, "ERROR size\n");
1060: break;
1061: }
1062: generate_eastore(output, iib, tp_src);
1063: if (flags)
1064: OUT("\n");
1065: if (flags && iib->flags.set & IIB_FLAG_V)
1066: generate_clrflag_v(output, iib);
1067: if (flags && iib->flags.set & IIB_FLAG_C)
1068: generate_clrflag_c(output, iib);
1069: if (flags && iib->flags.set & IIB_FLAG_N)
1070: generate_stdflag_n(output, iib);
1071: if (flags && iib->flags.set & IIB_FLAG_Z)
1072: generate_stdflag_z(output, iib);
1073: break;
1074:
1075: case i_EXG:
1076: generate_ea(output, iib, tp_src, 1);
1077: generate_eaval(output, iib, tp_src);
1078: generate_ea(output, iib, tp_dst, 1);
1079: generate_eaval(output, iib, tp_dst);
1080: OUT("\n");
1081: switch (iib->dtype) {
1082: case dt_Dreg:
1083: OUT(" DATAREG(dstreg) = srcdata;\n");
1084: break;
1085: case dt_Areg:
1086: OUT(" ADDRREG(dstreg) = srcdata;\n");
1087: break;
1088: default:
1089: OUT("ERROR size\n");
1090: break;
1091: }
1092: switch (iib->stype) {
1093: case dt_Dreg:
1094: OUT(" DATAREG(srcreg) = dstdata;\n");
1095: break;
1096: case dt_Areg:
1097: OUT(" ADDRREG(srcreg) = dstdata;\n");
1098: break;
1099: default:
1100: OUT("ERROR size\n");
1101: break;
1102: }
1103: break;
1104:
1105: case i_TST:
1106: generate_ea(output, iib, tp_src, 1);
1107: generate_eaval(output, iib, tp_src);
1108: generate_outdata(output, iib, "srcdata");
1109: if (flags)
1110: OUT("\n");
1111: if (flags && iib->flags.set & IIB_FLAG_V)
1112: generate_clrflag_v(output, iib);
1113: if (flags && iib->flags.set & IIB_FLAG_C)
1114: generate_clrflag_c(output, iib);
1115: if (flags && iib->flags.set & IIB_FLAG_N)
1116: generate_stdflag_n(output, iib);
1117: if (flags && iib->flags.set & IIB_FLAG_Z)
1118: generate_stdflag_z(output, iib);
1119: break;
1120:
1121: case i_TAS:
1122: generate_ea(output, iib, tp_src, 1);
1123: generate_eaval(output, iib, tp_src);
1124: generate_outdata(output, iib, "srcdata");
1125: if (flags)
1126: OUT("\n");
1127: if (flags && iib->flags.set & IIB_FLAG_V)
1128: generate_clrflag_v(output, iib);
1129: if (flags && iib->flags.set & IIB_FLAG_C)
1130: generate_clrflag_c(output, iib);
1131: if (flags && iib->flags.set & IIB_FLAG_N)
1132: generate_stdflag_n(output, iib);
1133: if (flags && iib->flags.set & IIB_FLAG_Z)
1134: generate_stdflag_z(output, iib);
1135: switch(iib->size) {
1136: case sz_byte:
1137: OUT(" outdata|= 1<<7;\n");
1138: break;
1139: case sz_word:
1140: OUT(" outdata|= 1<<15;\n");
1141: break;
1142: case sz_long:
1143: OUT(" outdata|= 1<<31;\n");
1144: break;
1145: default:
1146: OUT("ERROR size\n");
1147: break;
1148: }
1149: generate_eastore(output, iib, tp_src);
1150: break;
1151:
1152: case i_CHK:
1153: generate_ea(output, iib, tp_src, 1);
1154: generate_eaval(output, iib, tp_src);
1155: generate_ea(output, iib, tp_dst, 1);
1156: generate_eaval(output, iib, tp_dst);
1157: fprintf(output, "\n");
1158: if (iib->size != sz_word)
1159: OUT("ERROR size\n");
1160: fprintf(output, " if ((sint16)srcdata < 0) {\n");
1161: if (flags)
1162: OUT(" NFLAG = 1;\n");
1163: fprintf(output, " reg68k_vector(V_CHK, PC+%d);\n",
1164: (iib->wordlen)*2);
1165: OUT(" } else if (dstdata > srcdata) {\n");
1166: if (flags)
1167: OUT(" NFLAG = 0;\n");
1168: fprintf(output, " reg68k_vector(V_CHK, PC+%d);\n",
1169: (iib->wordlen)*2);
1170: OUT(" }\n");
1171: break;
1172:
1173: case i_TRAPV:
1174: OUT(" if (VFLAG) {\n");
1175: fprintf(output, " reg68k_vector(V_TRAPV, PC+%d);\n",
1176: (iib->wordlen)*2);
1177: OUT(" }\n");
1178: break;
1179:
1180: case i_TRAP:
1181: generate_ea(output, iib, tp_src, 1);
1182: generate_eaval(output, iib, tp_src);
1183: OUT("\n");
1184: fprintf(output, " reg68k_vector(V_TRAP+srcdata, PC+%d);\n",
1185: (iib->wordlen)*2);
1186: pcinc = 0;
1187: break;
1188:
1189: case i_RESET:
1190: OUT(" printf(\"RESET @ %x\\n\", PC);\n");
1191: OUT(" exit(1);\n");
1192: break;
1193:
1194: case i_NOP:
1195: /* NOP */
1196: break;
1197:
1198: case i_STOP:
1199: generate_ea(output, iib, tp_src, 1);
1200: generate_eaval(output, iib, tp_src);
1201: OUT("\n");
1202: OUT(" switch(regs.stop) {\n");
1203: OUT(" case 1:\n");
1204: OUT(" break;\n");
1205: OUT(" case 2:\n");
1206: OUT(" PC+= 2;\n");
1207: OUT(" break;\n");
1208: OUT(" default:\n");
1209: OUT(" if (!(SFLAG && (srcdata & 1<<13)))\n");
1210: fprintf(output, " reg68k_vector(V_PRIVILEGE, PC+%d);\n",
1211: (iib->wordlen)*2);
1212: OUT(" SR = srcdata;\n");
1213: OUT(" STOP = 1;\n");
1214: OUT(" printf(\"STOP @ %%x\\n\", PC);\n");
1215: OUT(" exit(1);\n");
1216: OUT(" }\n");
1217: break;
1218:
1219: case i_LINK:
1220: generate_ea(output, iib, tp_src, 1);
1221: generate_eaval(output, iib, tp_src);
1222: generate_ea(output, iib, tp_dst, 1);
1223: generate_eaval(output, iib, tp_dst);
1224: if (iib->stype != dt_ImmW)
1225: OUT("ERROR stype\n");
1226: OUT("\n");
1227: OUT(" ADDRREG(7)-= 4;\n");
1228: OUT(" storelong(ADDRREG(7), dstdata);\n");
1229: OUT(" ADDRREG(dstreg) = ADDRREG(7);\n");
1230: OUT(" ADDRREG(7)+= (sint16)srcdata;\n");
1231: break;
1232:
1233: case i_UNLK:
1234: generate_ea(output, iib, tp_src, 1);
1235: generate_eaval(output, iib, tp_src);
1236: OUT("\n");
1237: OUT(" ADDRREG(srcreg) = fetchlong(srcdata);\n");
1238: OUT(" ADDRREG(7) = srcdata+4;\n");
1239: break;
1240:
1241: case i_RTE:
1242: if (DEBUG_RTE)
1243: fputs(" printf(\"RTE: 0x%X\\n\", PC);\n", output);
1244: if (DEBUG_SR)
1245: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
1246: output);
1247: OUT(" if (!SFLAG)\n");
1248: fprintf(output, " reg68k_vector(V_PRIVILEGE, PC+%d);\n",
1249: (iib->wordlen)*2);
1250: OUT("\n");
1251: OUT(" SR = fetchword(ADDRREG(7));\n");
1252: OUT(" PC = fetchlong(ADDRREG(7)+2);\n");
1253: OUT(" ADDRREG(7)+= 6;\n");
1254: OUT(" if (!reg68k_sr.sr_struct.s) {\n");
1255: OUT(" /* mode change, swap SP and A7 */\n");
1256: OUT(" ADDRREG(7)^= SP; SP^= ADDRREG(7); ADDRREG(7)^= SP;\n");
1257: OUT(" }\n");
1258: if (DEBUG_RTE)
1259: fputs(" printf(\"RTE: ->0x%X\\n\", PC);\n", output);
1260: if (DEBUG_SR)
1261: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
1262: output);
1263: pcinc = 0;
1264: break;
1265:
1266: case i_RTS:
1267: if (DEBUG_BRANCH)
1268: fputs(" printf(\"RTS: 0x%X\\n\", PC);", output);
1269: OUT(" PC = fetchlong(ADDRREG(7));\n");
1270: OUT(" ADDRREG(7)+= 4;\n");
1271: if (DEBUG_BRANCH)
1272: fputs(" printf(\"RTS: ->0x%X\\n\", PC);", output);
1273: pcinc = 0;
1274: break;
1275:
1276: case i_RTR:
1277: if (DEBUG_BRANCH)
1278: fputs(" printf(\"RTR: 0x%X\\n\", PC);\n", output);
1279: if (DEBUG_SR)
1280: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
1281: output);
1282: OUT(" SR = (SR & ~0xFF) | (fetchword(ADDRREG(7)) & 0xFF);\n");
1283: OUT(" PC = fetchlong(ADDRREG(7)+2);\n");
1284: OUT(" ADDRREG(7)+= 6;\n");
1285: if (DEBUG_BRANCH)
1286: fputs(" printf(\"RTR: ->0x%X\\n\", PC);\n", output);
1287: if (DEBUG_SR)
1288: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n",
1289: output);
1290: pcinc = 0;
1291: break;
1292:
1293: case i_JSR:
1294: generate_ea(output, iib, tp_src, 1);
1295: OUT("\n");
1296: if (DEBUG_BRANCH)
1297: fputs(" printf(\"JSR: 0x%X\\n\", PC);\n", output);
1298: OUT(" ADDRREG(7)-= 4;\n");
1299: fprintf(output, " storelong(ADDRREG(7), PC+%d);\n", (iib->wordlen)*2);
1300: OUT(" PC = srcaddr;\n");
1301: if (DEBUG_BRANCH)
1302: fputs(" printf(\"JSR: ->0x%X\\n\", PC);", output);
1303: pcinc = 0;
1304: break;
1305:
1306: case i_JMP:
1307: generate_ea(output, iib, tp_src, 1);
1308: OUT("\n");
1309: if (DEBUG_BRANCH)
1310: fputs(" printf(\"JMP: 0x%X\\n\", PC);", output);
1311: OUT(" PC = srcaddr;\n");
1312: if (DEBUG_BRANCH)
1313: fputs(" printf(\"JMP: ->0x%X\\n\", PC);\n", output);
1314: pcinc = 0;
1315: break;
1316:
1317: case i_Scc:
1318: generate_ea(output, iib, tp_src, 1);
1319: generate_cc(output, iib);
1320: generate_outdata(output, iib, "cc ? (uint8)(-1) : 0");
1321: OUT("\n");
1322: generate_eastore(output, iib, tp_src);
1323: break;
1324:
1325: case i_SF:
1326: generate_ea(output, iib, tp_src, 1);
1327: generate_outdata(output, iib, "0");
1328: OUT("\n");
1329: generate_eastore(output, iib, tp_src);
1330: break;
1331:
1332: case i_DBcc:
1333: /* special case where ipc holds the already PC-relative value */
1334: fprintf(output, " uint32 srcdata = ipc->src;\n");
1335: generate_ea(output, iib, tp_dst, 1);
1336: generate_eaval(output, iib, tp_dst);
1337: generate_cc(output, iib);
1338: fprintf(output, "\n");
1339: if (iib->size != sz_word) {
1340: OUT("ERROR size\n");
1341: }
1342: OUT(" if (!cc) {\n");
1343: OUT(" dstdata-= 1;\n");
1344: OUT(" DATAREG(dstreg) = (DATAREG(dstreg) & ~0xFFFF)\n");
1345: OUT("| (dstdata & 0xFFFF);\n");
1346: OUT(" if ((sint16)dstdata != -1)\n");
1347: OUT(" PC = srcdata;\n");
1348: OUT(" else\n");
1349: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2);
1350: OUT(" } else\n");
1351: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2);
1352: pcinc = 0;
1353: break;
1354:
1355: case i_DBRA:
1356: /* special case where ipc holds the already PC-relative value */
1357: fprintf(output, " uint32 srcdata = ipc->src;\n");
1358: generate_ea(output, iib, tp_dst, 1);
1359: generate_eaval(output, iib, tp_dst);
1360: OUT("\n");
1361: if (iib->size != sz_word) {
1362: OUT("ERROR size\n");
1363: }
1364: OUT(" dstdata-= 1;\n");
1365: OUT(" DATAREG(dstreg) = (DATAREG(dstreg) & ~0xFFFF) | ");
1366: OUT("(dstdata & 0xFFFF);\n");
1367: OUT(" if ((sint16)dstdata != -1)\n");
1368: OUT(" PC = srcdata;\n");
1369: OUT(" else\n");
1370: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2);
1371: pcinc = 0;
1372: break;
1373:
1374: case i_Bcc:
1375: /* special case where ipc holds the already PC-relative value */
1376: OUT(" uint32 srcdata = ipc->src;\n");
1377: generate_cc(output, iib);
1378: OUT("\n");
1379: if (DEBUG_BRANCH)
1380: fputs(" printf(\"Bcc: 0x%X\\n\", PC);\n", output);
1381: OUT(" if (cc)\n");
1382: OUT(" PC = srcdata;\n");
1383: OUT(" else\n");
1384: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2);
1385: if (DEBUG_BRANCH)
1386: fputs(" printf(\"Bcc: ->0x%X\\n\", PC);\n", output);
1387: pcinc = 0;
1388: break;
1389:
1390: case i_BSR:
1391: /* special case where ipc holds the already PC-relative value */
1392: OUT(" uint32 srcdata = ipc->src;\n");
1393: OUT("\n");
1394: if (DEBUG_BRANCH)
1395: fputs(" printf(\"BSR: 0x%X\\n\", PC);\n", output);
1396: OUT(" ADDRREG(7)-= 4;\n");
1397: fprintf(output, " storelong(ADDRREG(7), PC+%d);\n", (iib->wordlen)*2);
1398: OUT(" PC = srcdata;\n");
1399: if (DEBUG_BRANCH)
1400: fputs(" printf(\"BSR: ->0x%X\\n\", PC);\n", output);
1401: pcinc = 0;
1402: break;
1403:
1404: case i_DIVU:
1405: /* DIVx is the only instruction that has different sizes for the
1406: source and destination! */
1407: if (iib->dtype != dt_Dreg)
1408: OUT("ERROR dtype\n");
1409: generate_ea(output, iib, tp_src, 1);
1410: generate_eaval(output, iib, tp_src); /* 16bit EA */
1411: generate_ea(output, iib, tp_dst, 1); /* 32bit Dn */
1412: OUT(" uint32 dstdata = DATAREG(dstreg);\n");
1413: OUT(" uint32 quotient;\n");
1414: OUT("\n");
1415: OUT(" if (srcdata == 0) {\n");
1416: fprintf(output, " reg68k_vector(V_ZERO, PC+%d);\n",
1417: (iib->wordlen)*2);
1418: OUT(" return;\n");
1419: OUT(" }\n");
1420: OUT(" quotient = dstdata / srcdata;\n");
1421: OUT(" if ((quotient & 0xffff0000) == 0) {\n");
1422: OUT(" DATAREG(dstreg) = quotient | ");
1423: OUT("(((uint16)(dstdata % srcdata))<<16);\n");
1424: if (flags && iib->flags.set & IIB_FLAG_V)
1425: OUT(" VFLAG = 0;\n");
1426: if (flags && iib->flags.set & IIB_FLAG_N)
1427: OUT(" NFLAG = ((sint16)quotient) < 0;\n");
1428: if (flags && iib->flags.set & IIB_FLAG_Z)
1429: OUT(" ZFLAG = !((uint16)quotient);\n");
1430: if (flags && (iib->flags.set & IIB_FLAG_V ||
1431: iib->flags.set & IIB_FLAG_N)) {
1432: OUT(" } else {\n");
1433: if (flags && iib->flags.set & IIB_FLAG_V)
1434: OUT(" VFLAG = 1;\n");
1435: if (flags && iib->flags.set & IIB_FLAG_N)
1436: OUT(" NFLAG = 1;\n");
1437: }
1438: OUT(" }\n");
1439: if (flags && iib->flags.set & IIB_FLAG_C)
1440: OUT(" CFLAG = 0;\n");
1441: break;
1442:
1443: case i_DIVS:
1444: /* DIVx is the only instruction that has different sizes for the
1445: source and destination! */
1446: if (iib->dtype != dt_Dreg)
1447: OUT("ERROR dtype\n");
1448: generate_ea(output, iib, tp_src, 1);
1449: generate_eaval(output, iib, tp_src); /* 16bit EA */
1450: generate_ea(output, iib, tp_dst, 1); /* 32bit Dn */
1451: OUT(" sint32 dstdata = DATAREG(dstreg);\n");
1452: OUT(" sint32 quotient;\n");
1453: OUT(" sint16 remainder;\n");
1454: OUT("\n");
1455: OUT(" if (srcdata == 0) {\n");
1456: fprintf(output, " reg68k_vector(V_ZERO, PC+%d);\n",
1457: (iib->wordlen)*2);
1458: OUT(" return;\n");
1459: OUT(" }\n");
1460: OUT(" quotient = dstdata / (sint16)srcdata;\n");
1461: OUT(" remainder = dstdata % (sint16)srcdata;\n");
1462: OUT(" if (((quotient & 0xffff8000) == 0) ||\n");
1463: OUT(" ((quotient & 0xffff8000) == 0xffff8000)) {\n");
1464: OUT(" if ((quotient < 0) != (remainder < 0))\n");
1465: OUT(" remainder = -remainder;\n");
1466: OUT(" DATAREG(dstreg) = ((uint16)quotient) | ");
1467: OUT("(((uint16)(remainder))<<16);\n");
1468: if (flags && iib->flags.set & IIB_FLAG_V)
1469: OUT(" VFLAG = 0;\n");
1470: if (flags && iib->flags.set & IIB_FLAG_N)
1471: OUT(" NFLAG = ((sint16)quotient) < 0;\n");
1472: if (flags && iib->flags.set & IIB_FLAG_Z)
1473: OUT(" ZFLAG = !((uint16)quotient);\n");
1474: if (flags && (iib->flags.set & IIB_FLAG_V ||
1475: iib->flags.set & IIB_FLAG_N)) {
1476: OUT(" } else {\n");
1477: if (flags && iib->flags.set & IIB_FLAG_V)
1478: OUT(" VFLAG = 1;\n");
1479: if (flags && iib->flags.set & IIB_FLAG_N)
1480: OUT(" NFLAG = 1;\n");
1481: }
1482: OUT(" }\n");
1483: if (flags && iib->flags.set & IIB_FLAG_C)
1484: OUT(" CFLAG = 0;\n");
1485: break;
1486:
1487: case i_ASR:
1488: generate_ea(output, iib, tp_src, 1);
1489: generate_eaval(output, iib, tp_src);
1490: generate_ea(output, iib, tp_dst, 1);
1491: generate_eaval(output, iib, tp_dst);
1492: generate_bits(output, iib);
1493: OUT(" uint8 count = srcdata & 63;\n");
1494: switch (iib->size) {
1495: case sz_byte:
1496: generate_outdata(output, iib, "((sint8)dstdata) >> "
1497: "(count > 7 ? 7 : count)");
1498: break;
1499: case sz_word:
1500: generate_outdata(output, iib, "((sint16)dstdata) >> "
1501: "(count > 15 ? 15 : count)");
1502: break;
1503: case sz_long:
1504: generate_outdata(output, iib, "((sint32)dstdata) >> "
1505: "(count > 31 ? 31 : count)");
1506: break;
1507: default:
1508: OUT("ERROR size\n");
1509: break;
1510: }
1511: OUT("\n");
1512: generate_eastore(output, iib, tp_dst);
1513: if (flags) {
1514: OUT("\n");
1515: OUT(" if (!srcdata)\n");
1516: if (iib->flags.set & IIB_FLAG_C)
1517: OUT(" CFLAG = 0;\n");
1518: OUT(" else if (srcdata >= bits) {\n");
1519: if (iib->flags.set & IIB_FLAG_C)
1520: OUT(" CFLAG = dstdata>>(bits-1);\n");
1521: if (iib->flags.set & IIB_FLAG_X)
1522: OUT(" XFLAG = dstdata>>(bits-1);\n");
1523: OUT(" } else {\n");
1524: if (iib->flags.set & IIB_FLAG_C)
1525: OUT(" CFLAG = dstdata>>(count-1) & 1;\n");
1526: if (iib->flags.set & IIB_FLAG_X)
1527: OUT(" XFLAG = dstdata>>(count-1) & 1;\n");
1528: OUT(" }\n");
1529: if (iib->flags.set & IIB_FLAG_V)
1530: generate_clrflag_v(output, iib);
1531: if (iib->flags.set & IIB_FLAG_N)
1532: generate_stdflag_n(output, iib);
1533: if (iib->flags.set & IIB_FLAG_Z)
1534: generate_stdflag_z(output, iib);
1535: }
1536: break;
1537:
1538: case i_LSR:
1539: generate_ea(output, iib, tp_src, 1);
1540: generate_eaval(output, iib, tp_src);
1541: generate_ea(output, iib, tp_dst, 1);
1542: generate_eaval(output, iib, tp_dst);
1543: generate_bits(output, iib);
1544: OUT(" uint8 count = srcdata & 63;\n");
1545: generate_outdata(output, iib,
1546: "dstdata >> (count > (bits-1) ? (bits-1) : count)");
1547: OUT("\n");
1548: generate_eastore(output, iib, tp_dst);
1549: if (flags) {
1550: OUT("\n");
1551: OUT(" if (!count)\n");
1552: if (iib->flags.set & IIB_FLAG_C)
1553: OUT(" CFLAG = 0;\n");
1554: OUT(" else if (count >= bits) {\n");
1555: if (iib->flags.set & IIB_FLAG_C)
1556: OUT(" CFLAG = (count == bits) ? dstdata>>(bits-1) : 0;\n");
1557: if (iib->flags.set & IIB_FLAG_X)
1558: OUT(" XFLAG = (count == bits) ? dstdata>>(bits-1) : 0;\n");
1559: OUT(" } else {\n");
1560: if (iib->flags.set & IIB_FLAG_C)
1561: OUT(" CFLAG = dstdata>>(count-1) & 1;\n");
1562: if (iib->flags.set & IIB_FLAG_X)
1563: OUT(" XFLAG = dstdata>>(count-1) & 1;\n");
1564: OUT(" }\n");
1565: if (iib->flags.set & IIB_FLAG_V)
1566: generate_clrflag_v(output, iib);
1567: if (iib->flags.set & IIB_FLAG_N)
1568: generate_stdflag_n(output, iib);
1569: if (iib->flags.set & IIB_FLAG_Z)
1570: generate_stdflag_z(output, iib);
1571: }
1572: break;
1573:
1574: case i_ASL:
1575: generate_ea(output, iib, tp_src, 1);
1576: generate_eaval(output, iib, tp_src);
1577: generate_ea(output, iib, tp_dst, 1);
1578: generate_eaval(output, iib, tp_dst);
1579: generate_bits(output, iib);
1580: OUT(" uint8 count = srcdata & 63;\n");
1581: generate_outdata(output, iib,
1582: "count >= bits ? 0 : (dstdata << count)");
1583: OUT("\n");
1584: generate_eastore(output, iib, tp_dst);
1585: if (flags) {
1586: OUT("\n");
1587: OUT(" if (!count)\n");
1588: if (iib->flags.set & IIB_FLAG_C)
1589: OUT(" CFLAG = 0;\n");
1590: OUT(" else if (count >= bits) {\n");
1591: if (iib->flags.set & IIB_FLAG_C)
1592: OUT(" CFLAG = (count == bits) ? dstdata & 1 : 0;\n");
1593: if (iib->flags.set & IIB_FLAG_X)
1594: OUT(" XFLAG = (count == bits) ? dstdata & 1 : 0;\n");
1595: if (iib->flags.set & IIB_FLAG_V)
1596: OUT(" VFLAG = !dstdata;\n");
1597: OUT(" } else {\n");
1598: if (iib->flags.set & IIB_FLAG_C)
1599: OUT(" CFLAG = dstdata>>(bits-count) & 1;\n");
1600: if (iib->flags.set & IIB_FLAG_X)
1601: OUT(" XFLAG = dstdata>>(bits-count) & 1;\n");
1602: if (iib->flags.set & IIB_FLAG_V) {
1603: OUT(" {\n");
1604: switch (iib->size) {
1605: case sz_byte:
1606: OUT(" uint8 mask = 0xff << (7-count);\n")
1607: break;
1608: case sz_word:
1609: OUT(" uint16 mask = 0xffff << (15-count);\n");
1610: break;
1611: case sz_long:
1612: OUT(" uint32 mask = 0xffffffff <<(31-count);\n");
1613: break;
1614: default:
1615: OUT("ERROR size\n");
1616: break;
1617: }
1618: OUT(" VFLAG = ((dstdata & mask) != mask) && ");
1619: OUT("((dstdata & mask) != 0);\n");
1620: OUT(" }\n");
1621: OUT(" }\n");
1622: }
1623: if (iib->flags.set & IIB_FLAG_N)
1624: generate_stdflag_n(output, iib);
1625: if (iib->flags.set & IIB_FLAG_Z)
1626: generate_stdflag_z(output, iib);
1627: }
1628: break;
1629:
1630: case i_LSL:
1631: generate_ea(output, iib, tp_src, 1);
1632: generate_eaval(output, iib, tp_src);
1633: generate_ea(output, iib, tp_dst, 1);
1634: generate_eaval(output, iib, tp_dst);
1635: generate_bits(output, iib);
1636: OUT(" uint8 count = srcdata & 63;\n");
1637: generate_outdata(output, iib,
1638: "count >= bits ? 0 : (dstdata << count)");
1639: OUT("\n");
1640: generate_eastore(output, iib, tp_dst);
1641: if (flags) {
1642: OUT("\n");
1643: OUT(" if (!count)\n");
1644: if (iib->flags.set & IIB_FLAG_C)
1645: OUT(" CFLAG = 0;\n");
1646: OUT(" else if (count >= bits) {\n");
1647: if (iib->flags.set & IIB_FLAG_C)
1648: OUT(" CFLAG = (count == bits) ? dstdata & 1 : 0;\n");
1649: if (iib->flags.set & IIB_FLAG_X)
1650: OUT(" XFLAG = (count == bits) ? dstdata & 1 : 0;\n");
1651: OUT(" } else {\n");
1652: if (iib->flags.set & IIB_FLAG_C)
1653: OUT(" CFLAG = dstdata>>(bits-count) & 1;\n");
1654: if (iib->flags.set & IIB_FLAG_X)
1655: OUT(" XFLAG = dstdata>>(bits-count) & 1;\n");
1656: OUT(" }\n");
1657: if (iib->flags.set & IIB_FLAG_V)
1658: generate_clrflag_v(output, iib);
1659: if (iib->flags.set & IIB_FLAG_N)
1660: generate_stdflag_n(output, iib);
1661: if (iib->flags.set & IIB_FLAG_Z)
1662: generate_stdflag_z(output, iib);
1663: }
1664: break;
1665:
1666: /* 64 */
1667:
1668: case i_ROXR:
1669: case i_ROXL:
1670: generate_ea(output, iib, tp_src, 1);
1671: generate_eaval(output, iib, tp_src);
1672: generate_ea(output, iib, tp_dst, 1);
1673: generate_eaval(output, iib, tp_dst);
1674: generate_bits(output, iib);
1675: OUT(" uint8 loop = srcdata & 63;\n");
1676: OUT(" uint8 cflag = CFLAG;\n");
1677: OUT(" uint8 xflag = XFLAG;\n");
1678: generate_outdata(output, iib, "dstdata");
1679: OUT("\n");
1680: if (iib->mnemonic == i_ROXR) {
1681: OUT(" while(loop) {\n");
1682: OUT(" cflag = outdata & 1;\n");
1683: OUT(" outdata>>= 1;\n");
1684: OUT(" if (xflag)\n");
1685: OUT(" outdata |= 1<<(bits-1);\n");
1686: OUT(" xflag = cflag;\n");
1687: OUT(" loop--;\n");
1688: OUT(" }\n");
1689: } else {
1690: OUT(" while(loop) {\n");
1691: OUT(" cflag = outdata & 1<<(bits-1) ? 1 : 0;\n");
1692: OUT(" outdata<<= 1;\n");
1693: OUT(" outdata |= xflag;\n");
1694: OUT(" xflag = cflag;\n");
1695: OUT(" loop--;\n");
1696: OUT(" }\n");
1697: }
1698: generate_eastore(output, iib, tp_dst);
1699: if (flags)
1700: OUT("\n");
1701: if (flags && iib->flags.set & IIB_FLAG_X)
1702: OUT(" XFLAG = xflag;\n");
1703: if (flags && iib->flags.set & IIB_FLAG_C)
1704: OUT(" CFLAG = xflag;\n");
1705: if (flags && iib->flags.set & IIB_FLAG_N)
1706: generate_stdflag_n(output, iib);
1707: if (flags && iib->flags.set & IIB_FLAG_Z)
1708: generate_stdflag_z(output, iib);
1709: if (flags && iib->flags.set & IIB_FLAG_V)
1710: generate_clrflag_v(output, iib);
1711: break;
1712:
1713: case i_ROR:
1714: case i_ROL:
1715: generate_ea(output, iib, tp_src, 1);
1716: generate_eaval(output, iib, tp_src);
1717: generate_ea(output, iib, tp_dst, 1);
1718: generate_eaval(output, iib, tp_dst);
1719: generate_bits(output, iib);
1720: OUT(" uint8 loop = srcdata & 63;\n");
1721: OUT(" uint8 cflag = 0;\n");
1722: generate_outdata(output, iib, "dstdata");
1723: OUT("\n");
1724: if (iib->mnemonic == i_ROR) {
1725: OUT(" while(loop) {\n");
1726: OUT(" cflag = outdata & 1;\n");
1727: OUT(" outdata>>= 1;\n");
1728: OUT(" if (cflag)\n");
1729: OUT(" outdata |= 1<<(bits-1);\n");
1730: OUT(" loop--;\n");
1731: OUT(" }\n");
1732: } else {
1733: OUT(" while(loop) {\n");
1734: OUT(" cflag = outdata & 1<<(bits-1) ? 1 : 0;\n");
1735: OUT(" outdata<<= 1;\n");
1736: OUT(" if (cflag)\n");
1737: OUT(" outdata |= 1;\n");
1738: OUT(" loop--;\n");
1739: OUT(" }\n");
1740: }
1741: generate_eastore(output, iib, tp_dst);
1742: if (flags)
1743: OUT("\n");
1744: if (flags && iib->flags.set & IIB_FLAG_C)
1745: OUT(" CFLAG = cflag;\n");
1746: if (flags && iib->flags.set & IIB_FLAG_N)
1747: generate_stdflag_n(output, iib);
1748: if (flags && iib->flags.set & IIB_FLAG_Z)
1749: generate_stdflag_z(output, iib);
1750: if (flags && iib->flags.set & IIB_FLAG_V)
1751: generate_clrflag_v(output, iib);
1752: break;
1753:
1754: case i_LINE10:
1755: OUT("\n");
1756: fprintf(output, " reg68k_vector(V_LINE10, PC);\n");
1757: pcinc = 0;
1758: break;
1759:
1760: case i_LINE15:
1761: OUT("\n");
1762: fprintf(output, " reg68k_vector(V_LINE15, PC);\n");
1763: pcinc = 0;
1764: break;
1765:
1766: case i_ILLG:
1767: OUT(" printf(\"Illegal instruction @ %x\\n\", PC);\n");
1768: OUT(" exit(1);\n");
1769: break;
1770:
1771: } /* switch */
1772:
1773: if (pcinc) {
1774: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2);
1775: }
1776:
1777: OUT("}\n\n");
1778: }
1779:
1780: }
1781: }
1782:
1783: void generate_ea(FILE *o, t_iib *iib, t_type type, int update)
1784: {
1785: t_datatype datatype = type ? iib->dtype : iib->stype;
1786:
1787: /* generate information about EA to be used in calculations */
1788:
1789: switch(datatype) {
1790: case dt_Dreg:
1791: case dt_Areg:
1792: case dt_Aind:
1793: case dt_Ainc:
1794: case dt_Adec:
1795: case dt_Adis:
1796: case dt_Aidx:
1797: if (type == tp_src)
1798: fprintf(o, " int srcreg = (ipc->opcode >> %d) & 7;\n", iib->sbitpos);
1799: else
1800: fprintf(o, " int dstreg = (ipc->opcode >> %d) & 7;\n", iib->dbitpos);
1801: break;
1802: default:
1803: break;
1804: }
1805:
1806: if (datatype == dt_Ainc && update) {
1807:
1808: /* Ainc and update */
1809:
1810: switch(iib->size) {
1811: case sz_byte:
1812: if (type == tp_src) {
1813: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg);\n");
1814: fprintf(o, " uint32 srcaddr_tmp = (ADDRREG(srcreg)+= "
1815: "(srcreg == 7 ? 2 : 1), 0);\n");
1816: } else {
1817: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg);\n");
1818: fprintf(o, " uint32 dstaddr_tmp = (ADDRREG(dstreg)+= "
1819: "(dstreg == 7 ? 2 : 1), 0);\n");
1820: }
1821: break;
1822: case sz_word:
1823: if (type == tp_src)
1824: fprintf(o, " uint32 srcaddr = (ADDRREG(srcreg)+=2, "
1825: "ADDRREG(srcreg)-2);\n");
1826: else
1827: fprintf(o, " uint32 dstaddr = (ADDRREG(dstreg)+=2, "
1828: "ADDRREG(dstreg)-2);\n");
1829: break;
1830: case sz_long:
1831: if (type == tp_src)
1832: fprintf(o, " uint32 srcaddr = (ADDRREG(srcreg)+=4, "
1833: "ADDRREG(srcreg)-4);\n");
1834: else
1835: fprintf(o, " uint32 dstaddr = (ADDRREG(dstreg)+=4, "
1836: "ADDRREG(dstreg)-4);\n");
1837: break;
1838: default:
1839: fprintf(o, "ERROR size\n");
1840: break;
1841: }
1842:
1843: } else if (datatype == dt_Adec && update) {
1844:
1845: /* Adec and update */
1846:
1847: switch(iib->size) {
1848: case sz_byte:
1849: if (type == tp_src) {
1850: fprintf(o, " uint32 srcaddr = (ADDRREG(srcreg)-= "
1851: "(srcreg == 7 ? 2 : 1));\n");
1852: } else {
1853: fprintf(o, " uint32 dstaddr = (ADDRREG(dstreg)-= "
1854: "(dstreg == 7 ? 2 : 1));\n");
1855: }
1856: break;
1857: case sz_word:
1858: if (type == tp_src)
1859: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg)-=2;\n");
1860: else
1861: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg)-=2;\n");
1862: break;
1863: case sz_long:
1864: if (type == tp_src)
1865: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg)-=4;\n");
1866: else
1867: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg)-=4;\n");
1868: break;
1869: default:
1870: fprintf(o, "ERROR size\n");
1871: break;
1872: }
1873:
1874: } else {
1875:
1876: /* no update required */
1877:
1878: switch(datatype) {
1879: case dt_Dreg:
1880: case dt_Areg:
1881: break;
1882: case dt_Aind:
1883: case dt_Adec:
1884: case dt_Ainc:
1885: if (type == tp_src)
1886: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg);\n");
1887: else
1888: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg);\n");
1889: break;
1890: case dt_Adis:
1891: if (type == tp_src)
1892: fprintf(o, " uint32 srcaddr = (sint32)ADDRREG(srcreg) + "
1893: "(sint32)(sint16)ipc->src;\n");
1894: else
1895: fprintf(o, " uint32 dstaddr = (sint32)ADDRREG(dstreg) + "
1896: "(sint32)(sint16)ipc->dst;\n");
1897: break;
1898: case dt_Aidx:
1899: if (type == tp_src) {
1900: fprintf(o, " uint32 srcaddr = (sint32)ADDRREG(srcreg) + "
1901: "idxval_src(ipc);\n");
1902: } else {
1903: fprintf(o, " uint32 dstaddr = (sint32)ADDRREG(dstreg) + "
1904: "idxval_dst(ipc);\n");
1905: }
1906: break;
1907: case dt_AbsW:
1908: case dt_AbsL:
1909: case dt_Pdis:
1910: if (type == tp_src)
1911: fprintf(o, " uint32 srcaddr = ipc->src;\n");
1912: else
1913: fprintf(o, " uint32 dstaddr = ipc->dst;\n");
1914: break;
1915: case dt_Pidx:
1916: if (type == tp_src) {
1917: fprintf(o, " uint32 srcaddr = idxval_src(ipc);\n");
1918: } else {
1919: fprintf(o, " uint32 dstaddr = idxval_dst(ipc);\n");
1920: }
1921: break;
1922: case dt_ImmB:
1923: case dt_ImmW:
1924: case dt_ImmL:
1925: case dt_ImmS:
1926: case dt_Imm3:
1927: case dt_Imm4:
1928: case dt_Imm8:
1929: case dt_Imm8s:
1930: /* no address - it is immediate */
1931: break;
1932: default:
1933: fprintf(o, "ERROR\n");
1934: break;
1935: }
1936: }
1937: }
1938:
1939: void generate_eaval(FILE *o, t_iib *iib, t_type type)
1940: {
1941: t_datatype datatype = type ? iib->dtype : iib->stype;
1942:
1943: /* get value in EA */
1944:
1945: switch(datatype) {
1946: case dt_Dreg:
1947: switch(iib->size) {
1948: case sz_byte:
1949: if (type == tp_src)
1950: fprintf(o, " uint8 srcdata = DATAREG(srcreg);\n");
1951: else
1952: fprintf(o, " uint8 dstdata = DATAREG(dstreg);\n");
1953: break;
1954: case sz_word:
1955: if (type == tp_src)
1956: fprintf(o, " uint16 srcdata = DATAREG(srcreg);\n");
1957: else
1958: fprintf(o, " uint16 dstdata = DATAREG(dstreg);\n");
1959: break;
1960: case sz_long:
1961: if (type == tp_src)
1962: fprintf(o, " uint32 srcdata = DATAREG(srcreg);\n");
1963: else
1964: fprintf(o, " uint32 dstdata = DATAREG(dstreg);\n");
1965: break;
1966: default:
1967: fprintf(o, "ERROR size\n");
1968: break;
1969: }
1970: break;
1971: case dt_Areg:
1972: switch(iib->size) {
1973: case sz_byte:
1974: if (type == tp_src)
1975: fprintf(o, " uint8 srcdata = ADDRREG(srcreg);\n");
1976: else
1977: fprintf(o, " uint8 dstdata = ADDRREG(dstreg);\n");
1978: break;
1979: case sz_word:
1980: if (type == tp_src)
1981: fprintf(o, " uint16 srcdata = ADDRREG(srcreg);\n");
1982: else
1983: fprintf(o, " uint16 dstdata = ADDRREG(dstreg);\n");
1984: break;
1985: case sz_long:
1986: if (type == tp_src)
1987: fprintf(o, " uint32 srcdata = ADDRREG(srcreg);\n");
1988: else
1989: fprintf(o, " uint32 dstdata = ADDRREG(dstreg);\n");
1990: break;
1991: default:
1992: fprintf(o, "ERROR size\n");
1993: break;
1994: }
1995: break;
1996: case dt_Aind:
1997: case dt_Adec:
1998: case dt_Ainc:
1999: case dt_Adis:
2000: case dt_Aidx:
2001: case dt_AbsW:
2002: case dt_AbsL:
2003: case dt_Pdis:
2004: case dt_Pidx:
2005: switch(iib->size) {
2006: case sz_byte:
2007: if (type == tp_src)
2008: fprintf(o, " uint8 srcdata = fetchbyte(srcaddr);\n");
2009: else
2010: fprintf(o, " uint8 dstdata = fetchbyte(dstaddr);\n");
2011: break;
2012: case sz_word:
2013: if (type == tp_src)
2014: fprintf(o, " uint16 srcdata = fetchword(srcaddr);\n");
2015: else
2016: fprintf(o, " uint16 dstdata = fetchword(dstaddr);\n");
2017: break;
2018: case sz_long:
2019: if (type == tp_src)
2020: fprintf(o, " uint32 srcdata = fetchlong(srcaddr);\n");
2021: else
2022: fprintf(o, " uint32 dstdata = fetchlong(dstaddr);\n");
2023: break;
2024: default:
2025: fprintf(o, "ERROR size\n");
2026: break;
2027: }
2028: break;
2029: case dt_ImmB:
2030: if (type == tp_src)
2031: fprintf(o, " uint8 srcdata = ipc->src;\n");
2032: else
2033: fprintf(o, " uint8 dstdata = ipc->dst;\n");
2034: break;
2035: case dt_ImmW:
2036: if (type == tp_src)
2037: fprintf(o, " uint16 srcdata = ipc->src;\n");
2038: else
2039: fprintf(o, " uint16 dstdata = ipc->dst;\n");
2040: break;
2041: case dt_ImmL:
2042: if (type == tp_src)
2043: fprintf(o, " uint32 srcdata = ipc->src;\n");
2044: else
2045: fprintf(o, " uint32 dstdata = ipc->dst;\n");
2046: break;
2047: case dt_ImmS:
2048: if (type == tp_src)
2049: fprintf(o, " unsigned int srcdata = %d;\n", iib->immvalue);
2050: else
2051: fprintf(o, " unsigned int dstdata = %d;\n", iib->immvalue);
2052: break;
2053: case dt_Imm3:
2054: case dt_Imm4:
2055: case dt_Imm8:
2056: if (type == tp_src)
2057: fprintf(o, " unsigned int srcdata = ipc->src;\n");
2058: else
2059: fprintf(o, " unsigned int dstdata = ipc->dst;\n");
2060: break;
2061: case dt_Imm8s:
2062: if (type == tp_src)
2063: fprintf(o, " signed int srcdata = ipc->src;\n");
2064: else
2065: fprintf(o, " signed int dstdata = ipc->dst;\n");
2066: break;
2067: default:
2068: fprintf(o, "ERROR\n");
2069: }
2070: }
2071:
2072: void generate_eastore(FILE *o, t_iib *iib, t_type type)
2073: {
2074: /* get value in EA */
2075:
2076: switch(type == tp_dst ? iib->dtype : iib->stype) {
2077: case dt_Dreg:
2078: switch (iib->size) {
2079: case sz_byte:
2080: if (type == tp_src)
2081: fprintf(o, " DATAREG(srcreg) = (DATAREG(srcreg) & ~0xff) | "
2082: "outdata;\n");
2083: else
2084: fprintf(o, " DATAREG(dstreg) = (DATAREG(dstreg) & ~0xff) | "
2085: "outdata;\n");
2086: break;
2087: case sz_word:
2088: if (type == tp_src)
2089: fprintf(o, " DATAREG(srcreg) = (DATAREG(srcreg) & ~0xffff) | "
2090: "outdata;\n");
2091: else
2092: fprintf(o, " DATAREG(dstreg) = (DATAREG(dstreg) & ~0xffff) | "
2093: "outdata;\n");
2094: break;
2095: case sz_long:
2096: if (type == tp_src)
2097: fprintf(o, " DATAREG(srcreg) = outdata;\n");
2098: else
2099: fprintf(o, " DATAREG(dstreg) = outdata;\n");
2100: break;
2101: default:
2102: fprintf(o, "ERROR size\n");
2103: break;
2104: }
2105: break;
2106: case dt_Areg:
2107: switch(iib->size) {
2108: case sz_byte:
2109: if (type == tp_src)
2110: fprintf(o, " ADDRREG(srcreg) = (ADDRREG(srcreg) & ~0xff) | "
2111: "outdata;\n");
2112: else
2113: fprintf(o, " ADDRREG(dstreg) = (ADDRREG(dstreg) & ~0xff) | "
2114: "outdata;\n");
2115: break;
2116: case sz_word:
2117: if (type == tp_src)
2118: fprintf(o, " ADDRREG(srcreg) = (ADDRREG(srcreg) & ~0xffff) | "
2119: "outdata;\n");
2120: else
2121: fprintf(o, " ADDRREG(dstreg) = (ADDRREG(dstreg) & ~0xffff) | "
2122: "outdata;\n");
2123: break;
2124: case sz_long:
2125: if (type == tp_src)
2126: fprintf(o, " ADDRREG(srcreg) = outdata;\n");
2127: else
2128: fprintf(o, " ADDRREG(dstreg) = outdata;\n");
2129: break;
2130: default:
2131: fprintf(o, "ERROR size\n");
2132: break;
2133: }
2134: break;
2135: case dt_Aind:
2136: case dt_Ainc:
2137: case dt_Adec:
2138: case dt_Adis:
2139: case dt_Aidx:
2140: case dt_AbsW:
2141: case dt_AbsL:
2142: case dt_Pdis:
2143: case dt_Pidx:
2144: switch(iib->size) {
2145: case sz_byte:
2146: if (type == tp_src)
2147: fprintf(o, " storebyte(srcaddr, outdata);\n");
2148: else
2149: fprintf(o, " storebyte(dstaddr, outdata);\n");
2150: break;
2151: case sz_word:
2152: if (type == tp_src)
2153: fprintf(o, " storeword(srcaddr, outdata);\n");
2154: else
2155: fprintf(o, " storeword(dstaddr, outdata);\n");
2156: break;
2157: case sz_long:
2158: if (type == tp_src)
2159: fprintf(o, " storelong(srcaddr, outdata);\n");
2160: else
2161: fprintf(o, " storelong(dstaddr, outdata);\n");
2162: break;
2163: default:
2164: fprintf(o, "ERROR size\n");
2165: }
2166: break;
2167: default:
2168: fprintf(o, "ERROR type\n");
2169: }
2170: }
2171:
2172: void generate_outdata(FILE *o, t_iib *iib, const char *init)
2173: {
2174: switch(iib->size) {
2175: case sz_byte:
2176: fprintf(o, " uint8 ");
2177: break;
2178: case sz_word:
2179: fprintf(o, " uint16 ");
2180: break;
2181: case sz_long:
2182: fprintf(o, " uint32 ");
2183: break;
2184: default:
2185: fprintf(o, "ERROR size\n");
2186: break;
2187: }
2188: fprintf(o, "outdata%s%s;\n", (init && init[0]) ? " = " : "",
2189: init ? init : "");
2190: }
2191:
2192: void generate_cc(FILE *o, t_iib *iib)
2193: {
2194: switch(iib->cc) {
2195: case 0: /* T */
2196: fprintf(o, " uint8 cc = 1;\n");
2197: break;
2198: case 1: /* F */
2199: fprintf(o, " uint8 cc = 0;\n");
2200: break;
2201: case 2: /* HI */
2202: fprintf(o, " uint8 cc = !(CFLAG || ZFLAG);\n");
2203: break;
2204: case 3: /* LS */
2205: fprintf(o, " uint8 cc = CFLAG || ZFLAG;\n");
2206: break;
2207: case 4: /* CC */
2208: fprintf(o, " uint8 cc = !CFLAG;\n");
2209: break;
2210: case 5: /* CS */
2211: fprintf(o, " uint8 cc = CFLAG;\n");
2212: break;
2213: case 6: /* NE */
2214: fprintf(o, " uint8 cc = !ZFLAG;\n");
2215: break;
2216: case 7: /* EQ */
2217: fprintf(o, " uint8 cc = ZFLAG;\n");
2218: break;
2219: case 8: /* VC */
2220: fprintf(o, " uint8 cc = !VFLAG;\n");
2221: break;
2222: case 9: /* VS */
2223: fprintf(o, " uint8 cc = VFLAG;\n");
2224: break;
2225: case 10: /* PL */
2226: fprintf(o, " uint8 cc = !NFLAG;\n");
2227: break;
2228: case 11: /* MI */
2229: fprintf(o, " uint8 cc = NFLAG;\n");
2230: break;
2231: case 12: /* GE */
2232: fprintf(o, " uint8 cc = (NFLAG == VFLAG);\n");
2233: break;
2234: case 13: /* LT */
2235: fprintf(o, " uint8 cc = (NFLAG != VFLAG);\n");
2236: break;
2237: case 14: /* GT */
2238: fprintf(o, " uint8 cc = !ZFLAG && (NFLAG == VFLAG);\n");
2239: break;
2240: case 15: /* LE */
2241: fprintf(o, " uint8 cc = ZFLAG || (NFLAG != VFLAG);\n");
2242: break;
2243: default:
2244: fprintf(o, "ERROR cc\n");
2245: break;
2246: }
2247: }
2248:
2249: void generate_stdflag_n(FILE *o, t_iib *iib)
2250: {
2251: switch(iib->size) {
2252: case sz_byte:
2253: fprintf(o, " NFLAG = ((sint8)outdata) < 0;\n");
2254: break;
2255: case sz_word:
2256: fprintf(o, " NFLAG = ((sint16)outdata) < 0;\n");
2257: break;
2258: case sz_long:
2259: fprintf(o, " NFLAG = ((sint32)outdata) < 0;\n");
2260: break;
2261: default:
2262: fprintf(o, "ERROR size\n");
2263: break;
2264: }
2265: }
2266:
2267: void generate_stdflag_z(FILE *o, t_iib *iib)
2268: {
2269: fprintf(o, " ZFLAG = !outdata;\n");
2270: }
2271:
2272: void generate_clrflag_v(FILE *o, t_iib *iib)
2273: {
2274: fprintf(o, " VFLAG = 0;\n");
2275: }
2276:
2277: void generate_clrflag_c(FILE *o, t_iib *iib)
2278: {
2279: fprintf(o, " CFLAG = 0;\n");
2280: }
2281:
2282: void generate_clrflag_n(FILE *o, t_iib *iib)
2283: {
2284: fprintf(o, " NFLAG = 0;\n");
2285: }
2286:
2287: void generate_setflag_z(FILE *o, t_iib *iib)
2288: {
2289: fprintf(o, " ZFLAG = 1;\n");
2290: }
2291:
2292: void generate_subflag_c(FILE *o, t_iib *iib)
2293: {
2294: /* C = (Sm && !Dm) || (Rm && !Dm) || (Sm && Rm)
2295: carry is performed as if both source and destination are unsigned,
2296: so this is simply if the source is greater than the destination - I
2297: have proven this to be the case using a truth table and the above
2298: motorola definition */
2299: fprintf(o, " CFLAG = srcdata > dstdata;\n");
2300: }
2301:
2302: void generate_subflag_cx(FILE *o, t_iib *iib)
2303: {
2304: /* C = (Sm && !Dm) || (Rm && !Dm) || (Sm && Rm)
2305: carry is performed as if both source and destination are unsigned,
2306: so this is simply if the source is greater than the destination - I
2307: have proven this to be the case using a truth table and the above
2308: motorola definition */
2309: fprintf(o, " XFLAG = CFLAG = srcdata > dstdata;\n");
2310: }
2311:
2312: void generate_subxflag_cx(FILE *o, t_iib *iib)
2313: {
2314: /* V = (Sm && !Dm) || (Rm && (!Dm || Sm)) */
2315: fprintf(o, " {\n");
2316: switch(iib->size) {
2317: case sz_byte:
2318: fprintf(o, " int Sm = (sint8)srcdata < 0;\n");
2319: fprintf(o, " int Dm = (sint8)dstdata < 0;\n");
2320: fprintf(o, " int Rm = (sint8)outdata < 0;\n");
2321: break;
2322: case sz_word:
2323: fprintf(o, " int Sm = (sint16)srcdata < 0;\n");
2324: fprintf(o, " int Dm = (sint16)dstdata < 0;\n");
2325: fprintf(o, " int Rm = (sint16)outdata < 0;\n");
2326: break;
2327: case sz_long:
2328: fprintf(o, " int Sm = (sint32)srcdata < 0;\n");
2329: fprintf(o, " int Dm = (sint32)dstdata < 0;\n");
2330: fprintf(o, " int Rm = (sint32)outdata < 0;\n");
2331: break;
2332: default:
2333: fprintf(o, "ERROR size\n");
2334: break;
2335: }
2336: fprintf(o, " XFLAG = CFLAG = (Sm && !Dm) || (Rm && (!Dm || Sm));\n");
2337: fprintf(o, " }\n");
2338: }
2339:
2340: void generate_cmpaflag_c(FILE *o, t_iib *iib)
2341: {
2342: /* see generate_subflag_c - this is just the same but with a sign extend
2343: on the source */
2344: fprintf(o, " CFLAG = (uint32)(sint32)(sint16)srcdata > dstdata;\n");
2345: }
2346:
2347: void generate_subflag_v(FILE *o, t_iib *iib)
2348: {
2349: /* V = (!Sm && Dm && !Rm) || (Sm && !Dm && Rm)
2350: overflow is performed as if both source and destination are signed,
2351: the only two condtions are if we've added too much to a +ve number
2352: or we've subtracted too much from a -ve number - I have proven the
2353: this to be the case using a truth table and the above motorola
2354: definition */
2355: /* the technique to implement the above formula is to make sure the sign
2356: of Sm != the sign of Dm, and the sign of Dm != the sign of Rm. */
2357: switch(iib->size) {
2358: case sz_byte:
2359: fprintf(o, " VFLAG = (((sint8)srcdata < 0) != ((sint8)dstdata < 0)) ");
2360: fprintf(o, "&&\n (((sint8)dstdata < 0) != ((sint8)outdata < 0));\n");
2361: break;
2362: case sz_word:
2363: fprintf(o, " VFLAG = (((sint16)srcdata < 0) != ((sint16)dstdata < 0)) ");
2364: fprintf(o, "&&\n (((sint16)dstdata < 0) != ((sint16)outdata < 0));\n");
2365: break;
2366: case sz_long:
2367: fprintf(o, " VFLAG = (((sint32)srcdata < 0) != ((sint32)dstdata < 0)) ");
2368: fprintf(o, "&&\n (((sint32)dstdata < 0) != ((sint32)outdata < 0));\n");
2369: break;
2370: default:
2371: fprintf(o, "ERROR size\n");
2372: break;
2373: }
2374: }
2375:
2376: void generate_cmpaflag_v(FILE *o, t_iib *iib)
2377: {
2378: /* see generate_subflag_v - this is just the sz_long version with a sign
2379: extend on the source */
2380: fprintf(o, " VFLAG = (((sint32)(sint16)srcdata < 0) != ");
2381: fprintf(o, "((sint32)dstdata < 0)) ");
2382: fprintf(o, "&&\n (((sint32)dstdata < 0) != ((sint32)outdata < 0));\n");
2383: }
2384:
2385: void generate_stdxflag_z(FILE *o, t_iib *iib)
2386: {
2387: fprintf(o, " if (outdata) ZFLAG = 0;\n");
2388: }
2389:
2390: void generate_addflag_cx(FILE *o, t_iib *iib)
2391: {
2392: /* C = (Sm && Dm) || (!Rm && Dm) || (Sm && !Rm)
2393: carry is performed as if both source and destination are unsigned,
2394: so this is simply if the source is bigger than how much can be added
2395: to the destination without wrapping - this is of course just the bit
2396: inverse of the destination. */
2397: /* 0xFFFF - dstdata is obviously just ~dstdata, but try and get the
2398: compiler to do that without producing a warning, go on... */
2399: switch (iib->size) {
2400: case sz_byte:
2401: fprintf(o, " XFLAG = CFLAG = srcdata > (0xFFu - (uint8)dstdata);\n");
2402: break;
2403: case sz_word:
2404: fprintf(o, " XFLAG = CFLAG = srcdata > (0xFFFFu - (uint16)dstdata);\n");
2405: break;
2406: case sz_long:
2407: fprintf(o, " XFLAG = CFLAG = srcdata > (uint32)~(uint32)dstdata;\n");
2408: break;
2409: default:
2410: fprintf(o, "ERROR size\n");
2411: break;
2412: }
2413: /* gcc doesn't like a one's compliment of an unsigned - take out the
2414: casts in the above and it will warn you incorrectly */
2415: }
2416:
2417: void generate_addxflag_cx(FILE *o, t_iib *iib)
2418: {
2419: /* V = (Sm && Dm) || (!Rm && (Dm || Sm)) */
2420: fprintf(o, " {\n");
2421: switch(iib->size) {
2422: case sz_byte:
2423: fprintf(o, " int Sm = (sint8)srcdata < 0;\n");
2424: fprintf(o, " int Dm = (sint8)dstdata < 0;\n");
2425: fprintf(o, " int Rm = (sint8)outdata < 0;\n");
2426: break;
2427: case sz_word:
2428: fprintf(o, " int Sm = (sint16)srcdata < 0;\n");
2429: fprintf(o, " int Dm = (sint16)dstdata < 0;\n");
2430: fprintf(o, " int Rm = (sint16)outdata < 0;\n");
2431: break;
2432: case sz_long:
2433: fprintf(o, " int Sm = (sint32)srcdata < 0;\n");
2434: fprintf(o, " int Dm = (sint32)dstdata < 0;\n");
2435: fprintf(o, " int Rm = (sint32)outdata < 0;\n");
2436: break;
2437: default:
2438: fprintf(o, "ERROR size\n");
2439: break;
2440: }
2441: fprintf(o, " XFLAG = CFLAG = (Sm && Dm) || (!Rm && (Dm || Sm));\n");
2442: fprintf(o, " }\n");
2443: }
2444:
2445: void generate_addflag_v(FILE *o, t_iib *iib)
2446: {
2447: /* V = (Sm && Dm && !Rm) || (!Sm && !Dm && Rm)
2448: overflow is performed as if both source and destination are signed,
2449: the only two condtions are if we've added too much to a +ve number
2450: or we've subtracted too much from a -ve number */
2451: /* the technique to implement the above formula is to make sure the sign
2452: of Sm == the sign of Dm, and the sign of Dm != the sign of Rm. */
2453: switch(iib->size) {
2454: case sz_byte:
2455: fprintf(o, " VFLAG = (((sint8)srcdata < 0) == ((sint8)dstdata < 0)) ");
2456: fprintf(o, "&&\n (((sint8)dstdata < 0) != ((sint8)outdata < 0));\n");
2457: break;
2458: case sz_word:
2459: fprintf(o, " VFLAG = (((sint16)srcdata < 0) == ((sint16)dstdata < 0)) ");
2460: fprintf(o, "&&\n (((sint16)dstdata < 0) != ((sint16)outdata < 0));\n");
2461: break;
2462: case sz_long:
2463: fprintf(o, " VFLAG = (((sint32)srcdata < 0) == ((sint32)dstdata < 0)) ");
2464: fprintf(o, "&&\n (((sint32)dstdata < 0) != ((sint32)outdata < 0));\n");
2465: break;
2466: default:
2467: fprintf(o, "ERROR size\n");
2468: break;
2469: }
2470: }
2471:
2472: void generate_negflag_cx(FILE *o, t_iib *iib)
2473: {
2474: /* C = (Dm || Rm) */
2475: fprintf(o, " XFLAG = CFLAG = srcdata ? 1 : 0;\n");
2476: }
2477:
2478: void generate_negflag_v(FILE *o, t_iib *iib)
2479: {
2480: /* V = (Dm && Rm)
2481: which is the same as V = src == 1<<15 as the only case where both the
2482: data and the result are both negative is in the case of the extreme
2483: negative number (1<<15 in the case of 16 bit) since 0 - 1<<15 = 1<<15. */
2484: switch(iib->size) {
2485: case sz_byte:
2486: fprintf(o, " VFLAG = (srcdata == (1u<<7));\n");
2487: break;
2488: case sz_word:
2489: fprintf(o, " VFLAG = (srcdata == (1u<<15));\n");
2490: break;
2491: case sz_long:
2492: fprintf(o, " VFLAG = (srcdata == (1u<<31));\n");
2493: break;
2494: default:
2495: fprintf(o, "ERROR size\n");
2496: break;
2497: }
2498: }
2499:
2500: void generate_negxflag_cx(FILE *o, t_iib *iib)
2501: {
2502: /* C = (Dm || Rm)
2503: unlike NEG, NEGX is done properly */
2504: fprintf(o, " XFLAG = CFLAG ");
2505: switch(iib->size) {
2506: case sz_byte:
2507: fprintf(o, "= ((sint8)srcdata < 0) || ((sint8)outdata < 0);\n");
2508: break;
2509: case sz_word:
2510: fprintf(o, "= ((sint16)srcdata < 0) || ((sint16)outdata < 0);\n");
2511: break;
2512: case sz_long:
2513: fprintf(o, "= ((sint32)srcdata < 0) || ((sint32)outdata < 0);\n");
2514: break;
2515: default:
2516: fprintf(o, "ERROR size\n");
2517: break;
2518: }
2519: }
2520:
2521: void generate_negxflag_v(FILE *o, t_iib *iib)
2522: {
2523: /* V = (Dm && Rm)
2524: unlike NEG, NEGX is done properly */
2525: switch(iib->size) {
2526: case sz_byte:
2527: fprintf(o, " VFLAG = ((sint8)srcdata < 0) && ((sint8)outdata < 0);\n");
2528: break;
2529: case sz_word:
2530: fprintf(o, " VFLAG = ((sint16)srcdata < 0) && ((sint16)outdata < 0);\n");
2531: break;
2532: case sz_long:
2533: fprintf(o, " VFLAG = ((sint32)srcdata < 0) && ((sint32)outdata < 0);\n");
2534: break;
2535: default:
2536: fprintf(o, "ERROR size\n");
2537: break;
2538: }
2539: }
2540:
2541: void generate_bits(FILE *o, t_iib *iib)
2542: {
2543: switch (iib->size) {
2544: case sz_byte:
2545: fprintf(o, " uint8 bits = 8;\n");
2546: break;
2547: case sz_word:
2548: fprintf(o, " uint8 bits = 16;\n");
2549: break;
2550: case sz_long:
2551: fprintf(o, " uint8 bits = 32;\n");
2552: break;
2553: default:
2554: fprintf(o, "ERROR size\n");
2555: break;
2556: }
2557: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.