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