![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to output_c.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Tom Morton FrontierVM] / frontvm / as68k|
Return to output_c.c CVS log | Up to [Tom Morton FrontierVM] / frontvm / as68k |
1.1 root 1:
2: #include <assert.h>
3: #include <stdio.h>
4: #include <stdlib.h>
5: #include <string.h>
6: #include <ctype.h>
7: #include <stdarg.h>
8: #include "dict.h"
9: #include "as68k.h"
10: #include "output.h"
11:
12: //#define DUMP_LOADS_OF_CRAP
13:
14: static op_t pending;
15: static char pending_func_name[LAB_LEN];
16: static enum M68K_OPS next_op_type;
17:
18: #define GEN_CALL 0
19: #define GEN_BODY 1
20: static int gen_mode;
21: static int return_target;
22:
23: /* which flags an M68K_OP thingy may set */
24: #define fN (1<<0)
25: #define fZ (1<<1)
26: #define fV (1<<2)
27: #define fC (1<<3)
28: #define fX (1<<4)
29: #define fNZVCX (fN | fZ | fV | fC | fX)
30: #define fNZVC (fN | fZ | fV | fC)
31: #define _fSafe 0
32: /* _fSafe are ones i haven't got round to doing yet. */
33:
34: static int sets_flags[OP_MAX+1] = {
35: _fSafe, /* OP_NONE */
36: 0, // OP_JMP
37: fZ, // OP_BCHG
38: fZ, // OP_BCLR
39: fZ, // OP_BSET
40: fZ, // OP_BTST
41: fNZVC, // OP_MULS
42: fNZVC, // OP_MULU,
43: fNZVC, // OP_AND
44: fNZVC, // OP_OR
45: fNZVC, // OP_XOR
46: fNZVC, // OP_NOT
47: fNZVCX, // OP_NEGX
48: fNZVCX, // OP_NEG
49: fNZVC, // OP_DIVU
50: fNZVC, // OP_DIVS
51: fNZVCX, // OP_ASL,
52: fNZVCX, // OP_LSL
53: fNZVCX, // OP_ROXR
54: fNZVCX, // OP_ROXL
55: fNZVC, // OP_ROL
56: fNZVC, // OP_ROR
57: fNZVCX, // OP_ASR
58: fNZVCX, // OP_LSR,
59: 0, // OP_MOVEM
60: fNZVCX, // OP_SUBX
61: fNZVCX, // OP_ADDX
62: fNZVCX, // OP_ADD
63: fNZVC, // OP_CMPA
64: fNZVC, // OP_CMP
65: fNZVCX, // OP_SUB,
66: _fSafe, // OP_ADDA
67: _fSafe, // OP_SUBA
68: fNZVC, // OP_SWAP
69: _fSafe, // OP_JSR
70: 0, // OP_BCC
71: 0, // OP_DBCC
72: fNZVC, // OP_CLR,
73: 0, // OP_EXG
74: fNZVC, // OP_EXT
75: 0, // OP_RTE
76: 0, // OP_RTS
77: 0, // OP_ILLEGAL
78: 0, // OP_HCALL
79: 0, // OP_LINK,
80: 0, // OP_UNLK
81: fNZVC, // OP_MOVE
82: _fSafe, // OP_MOVEA
83: fNZVC, // OP_TST
84: 0, // OP_PEA
85: 0, // OP_LEA
86: 0, // OP_SCC
87: _fSafe, // OP_MAX.....
88: };
89:
90: /* does the flag need to be set? if the next instruction will
91: * set the flag then no. */
92: #define ifZ if(!(sets_flags[next_op_type] & fZ))
93: #define ifN if(!(sets_flags[next_op_type] & fN))
94: #define ifV if(!(sets_flags[next_op_type] & fV))
95: #define ifC if(!(sets_flags[next_op_type] & fC))
96: //#define ifCX if((!(sets_flags[next_op_type] & fC)) && (!(sets_flags[next_op_type] & fX)))
97: //#define ifX if(!(sets_flags[next_op_type] & fX))
98: #define ifVoN if((!(sets_flags[next_op_type] & fV)) || (!(sets_flags[next_op_type] & fN)))
99:
100: FILE *f_temp;
101: FILE *c_out;
102: FILE *c_out2; /* writing functions here */
103:
104: /* useless stats */
105: static int num_funcs;
106:
107: #define SWAP_COUT { f_temp = c_out; c_out = c_out2; c_out2 = f_temp; }
108:
109: static void output_op (op_t *op, op_t *next);
110:
111: static void cout (const char *format, ...)
112: {
113: va_list argptr;
114:
115: va_start (argptr, format);
116: vfprintf (c_out, format, argptr);
117: va_end (argptr);
118: }
119: static void cln (const char *format, ...)
120: {
121: va_list argptr;
122:
123: fputc ('\t', c_out);
124: va_start (argptr, format);
125: vfprintf (c_out, format, argptr);
126: va_end (argptr);
127: fputc ('\n', c_out);
128: }
129: /* C code generation shit */
130: const char *c_usizes[] = { "u8", "u16", "u32" };
131: const char *c_ssizes[] = { "s8", "s16", "s32" };
132: const char *mem_read_funcs[] = { "rdbyte", "rdword", "rdlong" };
133: const char *mem_write_funcs[] = { "wrbyte", "wrword", "wrlong" };
134:
135: void c_label (const char *lab)
136: {
137: cout ("__N%s:\n", lab);
138: add_fixup (0, C_ADDR, lab);
139: }
140:
141: void c_addr_label (int labelled)
142: {
143: if (labelled || return_target || (get_bitpos () == 0x1c)) {
144: cout ("\tcase (0x%x):\n", get_bitpos ());
145: }
146: cln ("#ifdef M68K_DEBUG");
147: cln (" line_no = %d;", line_no);
148: #ifdef DUMP_LOADS_OF_CRAP
149: cln (" DumpRegsChanged ();");
150: #endif /* DUMP_LOADS_OF_CRAP */
151: cln ("#endif");
152: }
153:
154: void c_begin (const char *src_filename, const char *bin_filename)
155: {
156: char buf[128];
157: snprintf (buf, sizeof (buf), ".%s.c", src_filename);
158: if ((c_out = fopen (buf, "w"))==NULL) {
159: fprintf (stderr, "Error: Cannot open %s for writing.\n", buf);
160: exit (-1);
161: }
162: snprintf (buf, sizeof (buf), ".%s.fn.c", src_filename);
163: if ((c_out2 = fopen (buf, "w"))==NULL) {
164: fprintf (stderr, "Error: Cannot open %s for writing.\n", buf);
165: exit (-1);
166: }
167:
168: cout ("void Init680x0 () {\n");
169: cln ("STRam = &m68kram[0];");
170: cln ("load_binfile (\"%s\");", bin_filename);
171: cout ("}\n");
172:
173: cout ("void Start680x0 ()\n{\n");
174: cout ("\ts32 i, jdest = 0x1c;\n");
175: cout ("\tRegs[15]._u32 = MEM_SIZE;\n\n");
176: cout ("jumptable:\n\tswitch (jdest) {\n");
177: }
178:
179: void c_end (const char *src_filename)
180: {
181: /* some more crap needs to be added to the top */
182: char c, buf[128];
183: FILE *f;
184: struct Fixup *fix;
185: struct Label *lab;
186:
187: /* remember to do last pending instruction */
188: next_op_type = OP_NONE;
189: if (pending.optype) {
190: gen_mode = GEN_BODY;
191: output_op (&pending, NULL);
192: gen_mode = GEN_CALL;
193: }
194:
195: fclose (c_out);
196: fclose (c_out2);
197:
198: snprintf (buf, sizeof (buf), "%s.c", src_filename);
199: if ((c_out = fopen (buf, "w"))==NULL) {
200: fprintf (stderr, "Error: Cannot open %s for writing.\n", buf);
201: exit (-1);
202: }
203:
204: /* _host.c contains much necessary boilerplate code. include it */
205: cout ("#include \"_host.c\"\n");
206:
207: /* call prototype turds */
208: cout ("#ifdef PART1\n");
209: fix = fix_first;
210: for (; fix != NULL; fix = fix->next) {
211: if (fix->size == C_FUNC) {
212: cout ("extern void %s ();\n", fix->label);
213: continue;
214: }
215: }
216: cout ("#endif /* PART1 */\n");
217: /* address 'fixups' */
218: fix = fix_first;
219: for (; fix != NULL; fix = fix->next) {
220: if (fix->size != C_ADDR) continue;
221:
222: lab = get_label (fix->label);
223: if (!lab) {
224: /* ignore. let pass2 throw the error. */
225: continue;
226: }
227: cout ("#define __D%s (0x%x)\n", lab->name, lab->val+BASE);
228: }
229:
230: /* the code we made */
231: snprintf (buf, sizeof (buf), ".%s.fn.c", src_filename);
232: if ((f = fopen (buf, "r"))==NULL) {
233: fprintf (stderr, "Error: Cannot open %s for writing.\n", buf);
234: exit (-1);
235: }
236: cout ("#ifdef PART2\n");
237: while ((c = fgetc (f)) != EOF) fputc (c, c_out);
238: fclose (f);
239: remove (buf);
240: cout ("#endif /* PART2 */\n");
241:
242: snprintf (buf, sizeof (buf), ".%s.c", src_filename);
243: if ((f = fopen (buf, "r"))==NULL) {
244: fprintf (stderr, "Error: Cannot open %s for writing.\n", buf);
245: exit (-1);
246: }
247: cout ("#ifdef PART1\n");
248: while ((c = fgetc (f)) != EOF) fputc (c, c_out);
249: fclose (f);
250: remove (buf);
251:
252: /* and then computed jump table */
253: cln ("goto end_;");
254: cout ("\t\tdefault: \n");
255: cln ("#ifdef M68K_DEBUG");
256: cln (" printf (\"Bad jump target at line %%d: $%%x (rdest=$%%x).\\n\", line_no, jdest, rdest);");
257: cln ("#else");
258: cln (" printf (\"Bad jump target: $%%x (rdest=$%%x).\\n\", jdest, rdest);");
259: cln ("#endif");
260: cln ("abort ();");
261: cout (" }\n\n");
262:
263: cout ("handle_exception:\n");
264: cln ("for (i=0; i<32; i++) {");
265: cln (" if (exceptions_pending & ((1<<i))) {");
266: cln (" jdest = exception_handlers[i];");
267: cln (" if (!--exceptions_pending_nums[i]) {");
268: cln (" exceptions_pending ^= 1<<i;");
269: cln (" }");
270: /* save flags */
271: cln (" bN=N; bnZ=nZ; bV=V; bC=C; bX=X;");
272: cln (" goto jumptable;");
273: cln (" }");
274: cln ("}");
275: cln ("/* shouldn't get here... */");
276: cln ("jdest = rdest;");
277: cln ("goto jumptable;\n");
278:
279: cout ("end_:\treturn;\n}\n");
280: cout ("#endif /* PART1 */\n");
281:
282: fclose (c_out);
283:
284: printf ("%d functions generated.\n", num_funcs);
285: }
286:
287: static int is_immediate (ea_t *ea)
288: {
289: return ((ea->mode == 7) && (ea->reg == 4));
290: }
291:
292: static void c_postea (ea_t *ea)
293: {
294: int inc;
295:
296: inc = 1<<ea->op_size;
297: if ((ea->reg == 15) && (inc == 1)) inc = 2;
298:
299: switch (ea->mode) {
300: /* areg postinc */
301: case 3: cln ("Regs[%d]._s32 += %d;", ea->reg, inc); break;
302: /* areg predec */
303: case 4: cln ("Regs[%d]._s32 -= %d;", ea->reg, inc); break;
304: default: break;
305: }
306: }
307: static void c_ea_get_address (ea_t *ea, char *buf)
308: {
309: int inc;
310: switch (ea->mode) {
311: /* dreg, areg */
312: case 0: case 1: assert (0);
313: /* areg indirect, postinc */
314: case 2: case 3:
315: sprintf (buf, "(Regs[%d]._s32)", ea->reg); break;
316: /* areg predec */
317: case 4:
318: inc = 1<<ea->op_size;
319: /* stack pointer always by 2 */
320: if ((ea->reg == 15) && (inc == 1)) inc = 2;
321:
322: sprintf (buf, "(Regs[%d]._s32-%d)", ea->reg, inc);
323: break;
324: /* areg offset */
325: case 5:
326: sprintf (buf, "(Regs[%d]._s32%+d)", ea->reg, ea->imm.val);
327: break;
328: /* areg offset + reg */
329: case 6:
330: sprintf (buf, "(Regs[%d]._s32+((%s)Regs[%d]._s32)%+d)", ea->reg, (ea->ext._.size ? "s32" : "s16"), ea->ext._.reg + (ea->ext._.d_or_a ? 8 : 0), ea->ext._.displacement);
331: break;
332: /* yes */
333: case 7:
334: /* $xxx.w */
335: if (ea->reg == 0) {
336: sprintf (buf, "(%d)", ea->imm.val);
337: }
338: /* $xxx.l */
339: else if (ea->reg == 1) {
340: if (ea->imm.has_label) {
341: sprintf (buf, "(__D%s)", ea->imm.label);
342: } else {
343: sprintf (buf, "(%d)", ea->imm.val);
344: }
345: }
346: /* immediate */
347: else if (ea->reg == 4) {
348: assert (0);
349: }
350: /* PC + offset */
351: else if (ea->reg == 2) {
352: if (ea->imm.has_label)
353: sprintf (buf, "__D%s", ea->imm.label);
354: else
355: error ("Absolute value not allowed.");
356: }
357: /* PC + INDEX + OFFSET */
358: else if (ea->reg == 3) {
359: if (!ea->imm.has_label) error ("Absolute value not allowed.");
360: sprintf (buf, "(__D%s + Regs[%d]._%s)",
361: ea->imm.label,
362: ea->ext._.reg + (ea->ext._.d_or_a ? 8 : 0),
363: (ea->ext._.size ? "s32" : "s16"));
364: }
365: break;
366: default:
367: assert (0);
368: }
369: }
370: static void c_readea (ea_t *ea, char *buf)
371: {
372: int inc;
373: switch (ea->mode) {
374: /* dreg, areg */
375: case 0:
376: case 1:
377: sprintf (buf, "Regs[%d]._%s", ea->reg, c_ssizes[ea->op_size]);
378: break;
379: /* areg indirect */
380: case 2:
381: sprintf (buf, "%s(Regs[%d]._s32)", mem_read_funcs[ea->op_size], ea->reg);
382: break;
383: /* areg postinc */
384: case 3:
385: sprintf (buf, "%s(Regs[%d]._s32)", mem_read_funcs[ea->op_size], ea->reg);
386: break;
387: /* areg predec */
388: case 4:
389: inc = 1<<ea->op_size;
390: /* stack pointer always by 2 */
391: if ((ea->reg == 15) && (inc == 1)) inc = 2;
392:
393: sprintf (buf, "%s(Regs[%d]._s32-%d)", mem_read_funcs[ea->op_size], ea->reg, inc);
394: break;
395: /* areg offset */
396: case 5:
397: sprintf (buf, "%s(Regs[%d]._s32%+d)", mem_read_funcs[ea->op_size], ea->reg, ea->imm.val);
398: break;
399: /* areg offset + reg */
400: case 6:
401: sprintf (buf, "%s(Regs[%d]._s32+((%s)Regs[%d]._s32)%+d)", mem_read_funcs[ea->op_size], ea->reg, (ea->ext._.size ? "s32" : "s16"), ea->ext._.reg + (ea->ext._.d_or_a ? 8 : 0), ea->ext._.displacement);
402: break;
403: /* yes */
404: case 7:
405: /* $xxx.w */
406: if (ea->reg == 0) {
407: sprintf (buf, "%s(%d)", mem_read_funcs[ea->op_size], ea->imm.val);
408: }
409: /* $xxx.l */
410: else if (ea->reg == 1) {
411: if (ea->imm.has_label) {
412: sprintf (buf, "%s(__D%s)", mem_read_funcs[ea->op_size], ea->imm.label);
413: } else {
414: sprintf (buf, "%s(%d)", mem_read_funcs[ea->op_size], ea->imm.val);
415: }
416: }
417: /* immediate */
418: else if (ea->reg == 4) {
419: if (ea->imm.has_label) {
420: sprintf (buf, "__D%s", ea->imm.label);
421: } else {
422: sprintf (buf, "%d", ea->imm.val);
423: }
424: }
425: /* PC + offset */
426: else if (ea->reg == 2) {
427: if (ea->imm.has_label)
428: sprintf (buf, "%s(__D%s)", mem_read_funcs[ea->op_size], ea->imm.label);
429: else
430: error ("Absolute value not allowed.");
431: }
432: /* PC + INDEX + OFFSET */
433: else if (ea->reg == 3) {
434: if (!ea->imm.has_label) error ("Absolute value not allowed.");
435: sprintf (buf, "%s(__D%s + Regs[%d]._%s)",
436: mem_read_funcs[ea->op_size],
437: ea->imm.label,
438: ea->ext._.reg + (ea->ext._.d_or_a ? 8 : 0),
439: (ea->ext._.size ? "s32" : "s16"));
440: }
441: break;
442: default:
443: error ("nasty error in c_readea()");
444: }
445: }
446: static void c_writeea (ea_t *ea, int size, const char *val)
447: {
448: int inc;
449: switch (ea->mode) {
450: /* dreg, areg */
451: case 0: case 1:
452: cln ("Regs[%d]._%s = %s;", ea->reg, (size==BYTE ? "s8" : (size==WORD ? "s16" : "s32")), val);
453: break;
454: /* areg indirect */
455: case 2:
456: cln ("%s(Regs[%d]._s32, %s);", mem_write_funcs[size], ea->reg, val);
457: break;
458: /* areg postinc */
459: case 3:
460: cln ("%s(Regs[%d]._s32, %s);", mem_write_funcs[size], ea->reg, val);
461: break;
462: /* areg predec */
463: case 4:
464: inc = 1<<size;
465: /* stack pointer always by 2 */
466: if ((ea->reg == 15) && (inc == 1)) inc = 2;
467:
468: cln ("%s(Regs[%d]._s32-%d, %s);", mem_write_funcs[size], ea->reg, inc, val);
469: break;
470: /* areg offset */
471: case 5:
472: cln ("%s(Regs[%d]._s32%+d, %s);", mem_write_funcs[size], ea->reg, ea->imm.val, val);
473: break;
474: /* areg offset + reg */
475: case 6:
476: cln ("%s(Regs[%d]._s32+(Regs[%d]._%s)%+d, %s);", mem_write_funcs[size], ea->reg, ea->ext._.reg + (ea->ext._.d_or_a ? 8 : 0), (ea->ext._.size ? "s32" : "s16"), ea->ext._.displacement, val);
477: break;
478: /* yes */
479: case 7:
480: /* $xxx.w */
481: if (ea->reg == 0) {
482: cln ("%s(%d, %s);", mem_write_funcs[size], ea->imm.val, val);
483: }
484: /* $xxx.l */
485: else if (ea->reg == 1) {
486: if (ea->imm.has_label) {
487: cln ("%s(__D%s, %s);", mem_write_funcs[size], ea->imm.label, val);
488: } else {
489: cln ("%s(%d, %s);", mem_write_funcs[size], ea->imm.val, val);
490: }
491: }
492: /* immediate */
493: else if (ea->reg == 4) {
494: if (ea->imm.has_label) {
495: cln ("%s(__D%s, %s);", mem_write_funcs[size], ea->imm.label, val);
496: } else {
497: cln ("%s(%d, %s);", mem_write_funcs[size], ea->imm.val, val);
498: }
499: }
500: /* PC + offset */
501: else if (ea->reg == 2) {
502: if (ea->imm.has_label)
503: cln ("%s(__D%s, %s);", mem_write_funcs[size], ea->imm.label, val);
504: else
505: error ("Absolute value not allowed.");
506: }
507: /* PC + INDEX + OFFSET */
508: else if (ea->reg == 3) {
509: if (!ea->imm.has_label) error ("Absolute value not allowed.");
510: cln ("%s(__D%s + Regs[%d]._%s, %s);", mem_write_funcs[size], ea->imm.label, ea->ext._.reg + (ea->ext._.d_or_a ? 8 : 0), (ea->ext._.size ? "s32" : "s16"), val);
511: }
512: else {
513: error ("wtf in c_writeea ()");
514: }
515: break;
516: default:
517: error ("nasty error in c_writeea()");
518: }
519: }
520:
521: static void c_eval_cond (int cond)
522: {
523: switch (cond) {
524: /* ra */
525: case 0: cout ("1"); break;
526: /* f */
527: case 1: cout ("0"); break;
528: /* hi */
529: case 2: cout ("((!C) && nZ)"); break;
530: /* ls */
531: case 3: cout ("(C || (!nZ))"); break;
532: /* cc */
533: case 4: cout ("(!C)"); break;
534: /* cs */
535: case 5: cout ("C"); break;
536: /* ne */
537: case 6: cout ("nZ"); break;
538: /* eq */
539: case 7: cout ("(!nZ)"); break;
540: /* vc */
541: case 8: cout ("(!V)"); break;
542: /* vs */
543: case 9: cout ("V"); break;
544: /* pl */
545: case 10: cout ("(!N)"); break;
546: /* mi */
547: case 11: cout ("N"); break;
548: /* ge */
549: case 12: cout ("(!(N ^ V))"); break;
550: /* lt */
551: case 13: cout ("(!(N ^ (!V)))"); break;
552: /* gt */
553: case 14: cout ("(nZ && (!(N ^ V)))"); break;
554: /* le */
555: case 15: cout ("((!nZ) || (!(N ^ (!V))))"); break;
556: }
557: }
558:
559: static void make_funcname (char *buf, int len)
560: {
561: snprintf (buf, len, "__F%x", get_bitpos ());
562: }
563:
564: static void c_fnbegin ()
565: {
566: add_fixup (0, C_FUNC, pending_func_name);
567: SWAP_COUT;
568: num_funcs++;
569: cout ("void %s ()\n", pending_func_name);
570: cout ("{\n");
571: }
572:
573: static void c_fnend ()
574: {
575: cout ("}\n");
576: SWAP_COUT;
577: }
578:
579: #define c_fncall() \
580: {if (gen_mode == GEN_CALL) { \
581: make_funcname (pending_func_name, sizeof (pending_func_name)); \
582: cln ("%s ();", pending_func_name); \
583: return; \
584: }}
585:
586: /* Check for pending exceptions also */
587: void c_jump_e (ea_t *ea)
588: {
589: char buf[256];
590: if (gen_mode != GEN_CALL) return;
591: c_ea_get_address (ea, buf);
592: cln ("{");
593: cln ("if ((exceptions_pending) && (rdest == 0)) {");
594:
595: if (((ea->mode == 7) && (ea->reg == 1)) ||
596: ((ea->mode == 7) && (ea->reg == 2))) {
597: cln (" rdest = __D%s;", ea->imm.label);
598: } else {
599: cln (" rdest = %s;", buf);
600: }
601: c_postea (ea);
602: cln (" goto handle_exception;", buf);
603: cln ("} else {");
604:
605: if (((ea->mode == 7) && (ea->reg == 1)) ||
606: ((ea->mode == 7) && (ea->reg == 2))) {
607: cln (" goto __N%s;", ea->imm.label);
608: } else {
609: cln (" jdest = %s;", buf);
610: c_postea (ea);
611: cln (" goto jumptable;");
612: }
613: cln ("}}");
614: }
615:
616: void c_jump (ea_t *ea)
617: {
618: char buf[256];
619: if (gen_mode != GEN_CALL) return;
620: c_ea_get_address (ea, buf);
621:
622: cln ("{");
623: if (((ea->mode == 7) && (ea->reg == 1)) ||
624: ((ea->mode == 7) && (ea->reg == 2))) {
625: cln (" goto __N%s;", ea->imm.label);
626: } else {
627: cln (" jdest = %s;", buf);
628: c_postea (ea);
629: cln (" goto jumptable;");
630: }
631: cln ("}");
632: }
633:
634: void c_func_bchg (ea_t *src, ea_t *dest, int size)
635: {
636: int len;
637: const char *sz;
638: char buf[256];
639: c_fncall ();
640:
641: c_fnbegin ();
642: sz = c_usizes[size];
643: if (size == BYTE) len = 8;
644: else if (size == WORD) len = 16;
645: else len = 32;
646:
647: c_readea (src, buf);
648: cln ("%s src = %s;", sz, buf);
649: c_readea (dest, buf);
650: cln ("%s dest = %s;", sz, buf);
651: cln ("src &= %d;", len-1);
652: cln ("dest ^= (1 << src);");
653: ifZ { cln ("nZ = !(((%s)dest & (1 << src)) >> src);", sz); }
654: c_writeea (dest, size, "dest");
655: c_postea (src);
656: c_postea (dest);
657: c_fnend ();
658: }
659:
660: void c_func_bclr (ea_t *src, ea_t *dest, int size)
661: {
662: int len;
663: const char *sz;
664: char buf[256];
665:
666: c_fncall ();
667:
668: c_fnbegin ();
669: sz = c_usizes[size];
670: if (size == BYTE) len = 8;
671: else if (size == WORD) len = 16;
672: else len = 32;
673:
674: c_readea (src, buf);
675: cln ("%s src = %s;", sz, buf);
676: c_readea (dest, buf);
677: cln ("%s dest = %s;", sz, buf);
678: cln ("src &= %d;", len-1);
679: ifZ { cln ("nZ = !(1 ^ ((dest >> src) & 1));"); }
680: cln ("dest &= ~(1 << src);");
681: c_writeea (dest, size, "dest");
682: c_postea (src);
683: c_postea (dest);
684: c_fnend ();
685: }
686:
687: void c_func_bset (ea_t *src, ea_t *dest, int size)
688: {
689: int len;
690: const char *sz;
691: char buf[256];
692:
693: c_fncall ();
694:
695: c_fnbegin ();
696: sz = c_usizes[size];
697: if (size == BYTE) len = 8;
698: else if (size == WORD) len = 16;
699: else len = 32;
700:
701: c_readea (src, buf);
702: cln ("%s src = %s;", sz, buf);
703: c_readea (dest, buf);
704: cln ("%s dest = %s;", sz, buf);
705: cln ("src &= %d;", len-1);
706: ifZ { cln ("nZ = !(1 ^ ((dest >> src) & 1));"); }
707: cln ("dest |= (1 << src);");
708: c_writeea (dest, size, "dest");
709: c_postea (src);
710: c_postea (dest);
711: c_fnend ();
712: }
713:
714: void c_func_btst (ea_t *src, ea_t *dest, int size)
715: {
716: int len;
717: const char *sz;
718: char buf[256];
719:
720: c_fncall ();
721:
722: c_fnbegin ();
723: sz = c_usizes[size];
724: if (size == BYTE) len = 8;
725: else if (size == WORD) len = 16;
726: else len = 32;
727:
728: c_readea (src, buf);
729: cln ("%s src = %s;", sz, buf);
730: c_readea (dest, buf);
731: cln ("%s dest = %s;", sz, buf);
732: cln ("src &= %d;", len-1);
733: ifZ { cln ("nZ = !(1 ^ ((dest >> src) & 1));"); }
734: c_postea (src);
735: c_postea (dest);
736: c_fnend ();
737: }
738:
739: void c_func_muls (ea_t *src, ea_t *dest)
740: {
741: char buf[256];
742: c_fncall ();
743:
744: c_fnbegin ();
745: c_readea (src, buf);
746: cln ("s16 src = %s;", buf);
747: c_readea (dest, buf);
748: cln ("s32 dest = (s16)%s;", buf);
749: cln ("dest *= (s32)src;");
750: ifZ { cln ("nZ = dest;"); }
751: ifN { cln ("N = ((s32)dest) < 0;"); }
752: ifC { cln ("C = 0;"); }
753: ifV { cln ("V = 0;"); }
754: c_writeea (dest, LONG, "dest");
755: c_postea (dest);
756: c_postea (src);
757: c_fnend ();
758: }
759: void c_func_mulu (ea_t *src, ea_t *dest)
760: {
761: char buf[256];
762: c_fncall ();
763:
764: c_fnbegin ();
765: c_readea (src, buf);
766: cln ("u16 src = %s;", buf);
767: c_readea (dest, buf);
768: cln ("u32 dest = (u16)%s;", buf);
769: cln ("dest *= (u32)src;");
770: ifZ { cln ("nZ = dest;"); }
771: ifN { cln ("N = ((s32)dest) < 0;"); }
772: ifC { cln ("C = 0;"); }
773: ifV { cln ("V = 0;"); }
774: c_writeea (dest, LONG, "dest");
775: c_postea (dest);
776: c_postea (src);
777: c_fnend ();
778: }
779:
780: void c_func_logop (ea_t *src, ea_t *dest, int size, char op)
781: {
782: const char *sz;
783: char buf[256];
784: sz = c_ssizes[size];
785:
786: c_fncall ();
787:
788: c_fnbegin ();
789: c_readea (src, buf);
790: cln ("%s src = %s;", sz, buf);
791: c_readea (dest, buf);
792: cln ("%s dest = %s;", sz, buf);
793: cln ("dest %c= src;", op);
794: ifC { cln ("C = 0;"); }
795: ifV { cln ("V = 0;"); }
796: ifZ { cln ("nZ = dest;"); }
797: ifN { cln ("N = (dest < 0);"); }
798: c_writeea (dest, size, "dest");
799: c_postea (src);
800: c_postea (dest);
801: c_fnend ();
802: }
803:
804: void c_func_not (ea_t *ea, int size)
805: {
806: char buf[256];
807: c_fncall ();
808:
809: c_fnbegin ();
810: c_readea (ea, buf);
811: cln ("%s val = %s;", c_usizes[size], buf);
812: cln ("val = ~val;");
813: ifN { cln ("N = ((%s)val) < 0;", c_ssizes[size]); }
814: ifZ { cln ("nZ = val;"); }
815: ifV { cln ("V = 0;"); }
816: ifC { cln ("C = 0;"); }
817: c_writeea (ea, size, "val");
818: c_postea (ea);
819: c_fnend ();
820: }
821:
822: void c_func_negx (ea_t *ea, int size)
823: {
824: char buf[256];
825: c_fncall ();
826:
827: c_fnbegin ();
828: c_readea (ea, buf);
829: /* XXX is nZ flag correct here? */
830: cln ("%s src = %s;", c_ssizes[size], buf);
831: cln ("u32 dest = (0 - src) - (X ? 1 : 0);");
832: cln ("int flgs, flgn;");
833: cln ("flgs = ((%s)src) < 0;", c_ssizes[size]);
834: cln ("flgn = ((%s)dest) < 0;", c_ssizes[size]);
835: ifZ { cln ("nZ = !((!nZ) & (((%s)(dest)) == 0));", c_ssizes[size]); }
836: ifV { cln ("V = (flgs & flgn);"); }
837: cln ("X = flgs ^ ((flgs ^ flgn) & (flgn));");
838: ifC { cln ("C = X;"); }
839: ifN { cln ("N = ((%s)dest) < 0;", c_ssizes[size]); }
840: c_writeea (ea, size, "dest");
841: c_postea (ea);
842: c_fnend ();
843: }
844: void c_func_neg (ea_t *ea, int size)
845: {
846: char buf[256];
847: c_fncall ();
848:
849: c_fnbegin ();
850: c_readea (ea, buf);
851: cln ("%s src = %s;", c_ssizes[size], buf);
852: cln ("%s dest = ((%s)0) - ((%s)src);", c_usizes[size], c_ssizes[size], c_ssizes[size]);
853: cln ("int flgs, flgn;");
854: cln ("flgs = ((%s)src) < 0;", c_ssizes[size]);
855: cln ("flgn = ((%s)dest) < 0;", c_ssizes[size]);
856: ifZ { cln ("nZ = dest;"); }
857: ifV { cln ("V = (flgs & flgn);"); }
858: cln ("X = (dest != 0);");
859: ifC { cln ("C = X;"); }
860: ifN { cln ("N = (flgn != 0);"); }
861: c_writeea (ea, size, "dest");
862: c_postea (ea);
863: c_fnend ();
864: }
865:
866: void c_func_divu (ea_t *ea, int reg)
867: {
868: char buf[256];
869: c_fncall ();
870:
871: c_fnbegin ();
872: c_readea (ea, buf);
873: cln ("s16 src = %s;\n", buf);
874: cln ("s32 dest = Regs[%d]._s32;", reg);
875: cln ("if (src == 0) {");
876: ifV { cln (" V = 0;"); }
877: cln (" assert (src != 0);");
878: cln ("} else {");
879: cln (" u32 newv = (u32)dest / (u32)(u16)src;");
1.1.1.2 ! root 880: cln (" u32 rem = (u32)dest %% (u32)(u16)src;");
1.1 root 881: cln (" if (newv > 0xffff) {");
882: ifV { cln (" V = 1;"); }
883: ifN { cln (" N = 1;"); }
884: ifC { cln (" C = 0;"); }
885: cln (" } else {");
886: ifC { cln (" C = 0;"); }
887: ifV { cln (" V = 0;"); }
888: ifZ { cln (" nZ = newv;"); }
889: ifN { cln (" N = (newv < 0);"); }
890: cln (" Regs[%d]._u32 = (newv & 0xffff) | ((u32)rem << 16);", reg);
891: cln ("}}");
892: c_postea (ea);
893: c_fnend ();
894: }
895:
896: void c_func_divs (ea_t *ea, int reg)
897: {
898: char buf[256];
899: c_fncall ();
900:
901: c_fnbegin ();
902: c_readea (ea, buf);
903: cln ("s16 src = %s;\n", buf);
904: cln ("s32 dest = Regs[%d]._s32;", reg);
905: cln ("if (src == 0) {");
906: ifV { cln (" V = 0;"); }
907: cln (" assert (src != 0);");
908: cln ("} else {");
909: cln (" s32 newv = (s32)dest / (s32)(s16)src;");
1.1.1.2 ! root 910: cln (" u16 rem = (s32)dest %% (s32)(s16)src;");
1.1 root 911: cln (" if ((newv & 0xffff8000) != 0 && (newv & 0xffff8000) != 0xffff8000) {");
912: ifV { cln (" V = 1;"); }
913: ifN { cln (" N = 1;"); }
914: ifC { cln (" C = 0;"); }
915: cln (" } else {");
916: ifC { cln (" C = 0;"); }
917: ifV { cln (" V = 0;"); }
918: ifZ { cln (" nZ = newv;"); }
919: ifN { cln (" N = (newv < 0);"); }
920: cln (" Regs[%d]._u32 = (newv & 0xffff) | ((u32)rem << 16);", reg);
921: cln ("}}");
922: c_postea (ea);
923: c_fnend ();
924: }
925:
926: /* src is the shift */
927: void c_func_asl (ea_t *src, ea_t *dest, int size)
928: {
929: char buf[256];
930: unsigned int mask;
931: int shift, len;
932:
933: c_fncall ();
934:
935: c_fnbegin ();
936: if (size == BYTE) {
937: mask = 0xff;
938: len = 8;
939: } else if (size == WORD) {
940: mask = 0xffff;
941: len = 16;
942: } else {
943: mask = 0xffffffff;
944: len = 32;
945: }
946:
947: c_readea (dest, buf);
948: cln ("u32 val = %s;\n", buf);
949:
950: if (is_immediate (src)) {
951: /* mostly for the sake of -O0 compiles... */
952: shift = src->imm.val;
953:
954: if (shift >= len) {
955: ifV cln ("V = (val != 0);");
956: cln ("X = %s;", (shift == len ? "val & 1" : "0"));
957: ifC cln ("C = X;");
958: cln ("val = 0;");
959: } else {
960: ifV cln ("u32 mask = (0x%x << (%d - %d)) & 0x%x;", mask, len-1, shift, mask);
961: ifV cln ("V = (val & mask) != mask && (val & mask) != 0;");
962: cln ("val <<= %d;", shift-1);
963: cln ("X = (val & 0x%x);", 1<<(len-1));
964: ifC cln ("C = (val & 0x%x);", 1<<(len-1));
965: cln ("val <<= 1;");
966: }
967: } else {
968: c_readea (src, buf);
969: cln ("s32 src = %s & 63;", buf);
970: cln ("if (src >= %d) {", len);
971: ifV cln (" V = (val != 0);");
972: cln (" X = (src == %d ? val & 1 : 0);", len);
973: ifC cln ("C = X;");
974: cln (" val = 0;");
975: cln ("} else if (src == 0) {");
976: ifC cln (" C = 0;");
977: ifV cln (" V = 0;");
978: cln ("} else {");
979: ifV cln (" u32 mask = (0x%x << (%d - src)) & 0x%x;", mask, len-1, mask);
980: ifV cln (" V = (val & mask) != mask && (val & mask) != 0;");
981: cln (" val <<= src-1;");
982: cln (" X = (val & 0x%x);", 1<<(len-1));
983: ifC cln (" C = (val & 0x%x);", 1<<(len-1));
984: cln (" val <<= 1;");
985: //cln (" val &= 0x%x;", mask);
986: cln ("}");
987: }
988: ifZ cln ("nZ = ((%s)(val)) != 0;", c_ssizes[size]);
989: ifN cln ("N = ((%s)(val)) < 0;", c_ssizes[size]);
990:
991: c_writeea (dest, size, "val");
992: c_postea (dest);
993: c_postea (src);
994: c_fnend ();
995: }
996:
997: void c_func_lsl (ea_t *src, ea_t *dest, int size)
998: {
999: char buf[256];
1000: unsigned int mask;
1001: int shift, len;
1002:
1003: c_fncall ();
1004:
1005: c_fnbegin ();
1006: if (size == BYTE) {
1007: mask = 0xff;
1008: len = 8;
1009: } else if (size == WORD) {
1010: mask = 0xffff;
1011: len = 16;
1012: } else {
1013: mask = 0xffffffff;
1014: len = 32;
1015: }
1016:
1017: c_readea (dest, buf);
1018: cln ("u32 val = (%s)%s;\n", c_usizes[size], buf);
1019:
1020: if (is_immediate (src)) {
1021: shift = src->imm.val;
1022:
1023: if (shift >= len) {
1024: cln ("X = %s;", (shift == len ? "val & 1" : "0"));
1025: ifC cln ("C = X;");
1026: cln ("val = 0;");
1027: } else {
1028: cln ("val <<= %d;", shift-1);
1029: cln ("X = (val & 0x%x);", 1<<(len-1));
1030: ifC cln ("C = X;");
1031: cln ("val <<= 1;");
1032: cln ("val &= 0x%x;", mask);
1033: }
1034: } else {
1035: c_readea (src, buf);
1036: cln ("s32 shift = %s & 63;", buf);
1037: cln ("if (shift >= %d) {", len);
1038: cln (" X = (shift == %d ? val & 1 : 0);", len);
1039: ifC cln (" C = X;");
1040: cln (" val = 0;");
1041: cln ("} else if (shift == 0) {");
1042: ifC cln (" C = 0;");
1043: cln ("} else {");
1044: cln (" val <<= shift-1;");
1045: cln (" X = (val & 0x%x);", 1<<(len-1));
1046: ifC cln (" C = X;");
1047: cln (" val <<= 1;");
1048: cln (" val &= 0x%x;", mask);
1049: cln ("}");
1050: }
1051:
1052: ifZ cln ("nZ = ((%s)(val)) != 0;", c_ssizes[size]);
1053: ifN cln ("N = ((%s)(val)) < 0;", c_ssizes[size]);
1054: ifV cln ("V = 0;");
1055:
1056: c_writeea (dest, size, "val");
1057: c_postea (dest);
1058: c_postea (src);
1059: c_fnend ();
1060: }
1061:
1062: void c_func_roxr (ea_t *src, ea_t *dest, int size)
1063: {
1064: char buf[256];
1065: unsigned int mask;
1066: int len;
1067:
1068: c_fncall ();
1069:
1070: c_fnbegin ();
1071: if (size == BYTE) {
1072: mask = 0xff;
1073: len = 8;
1074: } else if (size == WORD) {
1075: mask = 0xffff;
1076: len = 16;
1077: } else {
1078: mask = 0xffffffff;
1079: len = 32;
1080: }
1081:
1082: c_readea (dest, buf);
1083: cln ("u32 carry;");
1084: cln ("u32 val = (%s)%s;\n", c_usizes[size], buf);
1085:
1086: c_readea (src, buf);
1087: cln ("s32 cnt = (%s & 63) - 1;", buf);
1088:
1089: cln ("u32 hival = (val << 1) | (X ? 1 : 0);");
1090: cln ("hival <<= (%d - cnt);", len-1);
1091: cln ("val >>= cnt;");
1092: cln ("carry = val & 1;");
1093: cln ("val >>= 1;");
1094: cln ("val |= hival;");
1095: cln ("X = carry;");
1096: cln ("val &= 0x%x;", mask);
1097: ifC cln ("C = X;");
1098: ifZ cln ("nZ = val;");
1099: ifN cln ("N = ((%s)val) < 0;", c_ssizes[size]);
1100: ifV cln ("V = 0;");
1101:
1102: c_writeea (dest, size, "val");
1103: c_postea (dest);
1104: c_postea (src);
1105: c_fnend ();
1106: }
1107: void c_func_roxl (ea_t *src, ea_t *dest, int size)
1108: {
1109: char buf[256];
1110: unsigned int mask;
1111: int len;
1112:
1113: c_fncall ();
1114:
1115: c_fnbegin ();
1116: if (size == BYTE) {
1117: mask = 0xff;
1118: len = 8;
1119: } else if (size == WORD) {
1120: mask = 0xffff;
1121: len = 16;
1122: } else {
1123: mask = 0xffffffff;
1124: len = 32;
1125: }
1126:
1127: c_readea (dest, buf);
1128: cln ("u32 val = (%s)%s;\n", c_usizes[size], buf);
1129:
1130: c_readea (src, buf);
1131: cln ("s32 cnt = (%s & 63) - 1;", buf);
1132:
1133: cln ("u32 loval = val >> (%d - cnt);", len-1);
1134: cln ("u32 carry = loval & 1;");
1135: cln ("val = (((val << 1) | (X ? 1 : 0)) << cnt) | (loval >> 1);");
1136: cln ("X = carry;");
1137: cln ("val &= 0x%x;", mask);
1138: ifC cln ("C = X;");
1139: ifZ cln ("nZ = val;");
1140: ifN cln ("N = ((%s)val) < 0;", c_ssizes[size]);
1141: ifV cln ("V = 0;");
1142:
1143: c_writeea (dest, size, "val");
1144: c_postea (dest);
1145: c_postea (src);
1146: c_fnend ();
1147: }
1148: void c_func_rol (ea_t *src, ea_t *dest, int size)
1149: {
1150: char buf[256];
1151: unsigned int mask;
1152: int len;
1153:
1154: c_fncall ();
1155:
1156: c_fnbegin ();
1157: if (size == BYTE) {
1158: mask = 0xff;
1159: len = 8;
1160: } else if (size == WORD) {
1161: mask = 0xffff;
1162: len = 16;
1163: } else {
1164: mask = 0xffffffff;
1165: len = 32;
1166: }
1167:
1168: c_readea (dest, buf);
1169: cln ("u32 val = (%s)%s;\n", c_usizes[size], buf);
1170:
1171: c_readea (src, buf);
1172: cln ("s32 cnt = %s & 63;", buf);
1173:
1174: cln ("u32 loval;");
1175: cln ("cnt &= %d;", len-1);
1176: cln ("loval = val >> (%d - cnt);", len);
1177: cln ("val <<= cnt;");
1178: cln ("val |= loval;");
1179: cln ("val &= 0x%x;", mask);
1180: ifC cln ("C = val & 1;");
1181: ifZ cln ("nZ = val;");
1182: ifN cln ("N = ((%s)val) < 0;", c_ssizes[size]);
1183: ifV cln ("V = 0;");
1184:
1185: c_writeea (dest, size, "val");
1186: c_postea (dest);
1187: c_postea (src);
1188: c_fnend ();
1189: }
1190:
1191: void c_func_ror (ea_t *src, ea_t *dest, int size)
1192: {
1193: char buf[256];
1194: unsigned int mask;
1195: int len;
1196:
1197: c_fncall ();
1198:
1199: c_fnbegin ();
1200: if (size == BYTE) {
1201: mask = 0xff;
1202: len = 8;
1203: } else if (size == WORD) {
1204: mask = 0xffff;
1205: len = 16;
1206: } else {
1207: mask = 0xffffffff;
1208: len = 32;
1209: }
1210:
1211: c_readea (dest, buf);
1212: cln ("u32 val = (%s)%s;\n", c_usizes[size], buf);
1213:
1214: c_readea (src, buf);
1215: cln ("s32 cnt = %s & 63;", buf);
1216:
1217: cln ("u32 hival;");
1218: cln ("cnt &= %d;", len-1);
1219: cln ("hival = val << (%d - cnt);", len);
1220: cln ("val >>= cnt;");
1221: cln ("val |= hival;");
1222: cln ("val &= 0x%x;", mask);
1223: ifC cln ("C = (val & 0x%x) >> %d;", 1<<(len-1), len-1);
1224: ifZ cln ("nZ = val;");
1225: ifN cln ("N = ((%s)val) < 0;", c_ssizes[size]);
1226: ifV cln ("V = 0;");
1227:
1228: c_writeea (dest, size, "val");
1229: c_postea (dest);
1230: c_postea (src);
1231: c_fnend ();
1232: }
1233:
1234: void c_func_asr (ea_t *src, ea_t *dest, int size)
1235: {
1236: char buf[256];
1237: unsigned int mask;
1238: int shift, len;
1239:
1240: c_fncall ();
1241:
1242: c_fnbegin ();
1243: if (size == BYTE) {
1244: mask = 0xff;
1245: len = 8;
1246: } else if (size == WORD) {
1247: mask = 0xffff;
1248: len = 16;
1249: } else {
1250: mask = 0xffffffff;
1251: len = 32;
1252: }
1253:
1254: c_readea (dest, buf);
1255: cln ("u32 val = (%s)%s;\n", c_usizes[size], buf);
1256: cln ("u32 sign = (0x%x & val) >> %d;", 1<<(len-1), len-1);
1257:
1258: if (is_immediate (src)) {
1259: shift = src->imm.val;
1260:
1261: if (shift >= len) {
1262: cln ("val = 0x%x & (u32)-sign;", mask);
1263: cln ("X = sign;");
1264: ifC cln ("C = X;");
1265: } else {
1266: cln ("val >>= %d;", shift-1);
1267: cln ("X = val & 1;");
1268: ifC cln ("C = X;");
1269: cln ("val >>= 1;");
1270: cln ("val |= (0x%x << %d) & (u32)-sign;", mask, len - shift);
1271: }
1272: } else {
1273: c_readea (src, buf);
1274: cln ("s32 src = %s & 63;", buf);
1275:
1276: cln ("if (src >= %d) {", len);
1277: cln (" val = 0x%x & (u32)-sign;", mask);
1278: cln (" X = sign;");
1279: ifC cln (" C = X;");
1280: cln ("} else if (src == 0) {");
1281: ifC cln (" C = 0;");
1282: cln ("} else {");
1283: cln (" val >>= src - 1;");
1284: cln (" X = val & 1;");
1285: ifC cln (" C = X;");
1286: cln (" val >>= 1;");
1287: cln (" val |= (0x%x << (%d - src)) & (u32)-sign;", mask, len);
1288: //cln (" val &= 0x%x;", mask);
1289: cln ("}");
1290: }
1291: ifZ cln ("nZ = ((%s)(val)) != 0;", c_ssizes[size]);
1292: ifN cln ("N = ((%s)(val)) < 0;", c_ssizes[size]);
1293: ifV cln ("V = 0;");
1294:
1295: c_writeea (dest, size, "val");
1296: c_postea (dest);
1297: c_postea (src);
1298: c_fnend ();
1299: }
1300: void c_func_lsr (ea_t *src, ea_t *dest, int size)
1301: {
1302: char buf[256];
1303: unsigned int mask;
1304: int shift, len;
1305:
1306: c_fncall ();
1307:
1308: c_fnbegin ();
1309: if (size == BYTE) {
1310: mask = 0xff;
1311: len = 8;
1312: } else if (size == WORD) {
1313: mask = 0xffff;
1314: len = 16;
1315: } else {
1316: mask = 0xffffffff;
1317: len = 32;
1318: }
1319:
1320: c_readea (dest, buf);
1321: cln ("u32 val = (%s)%s;\n", c_usizes[size], buf);
1322:
1323: if (is_immediate (src)) {
1324: shift = src->imm.val;
1325:
1326: if (shift >= len) {
1327: cln ("val = 0;");
1328: cln ("X = %d && (val >> %d);", (shift == len), len-1);
1329: ifC cln ("C = X;");
1330: } else {
1331: cln ("val >>= %d;", shift-1);
1332: cln ("X = val & 1;");
1333: ifC cln ("C = X;");
1334: cln ("val >>= 1;");
1335: }
1336: } else {
1337: c_readea (src, buf);
1338: cln ("u32 shift = %s & 63;", buf);
1339:
1340: cln ("if (shift >= %d) {", len);
1341: cln (" val = 0;");
1342: cln (" X = (shift == %d) && (val >> %d);", len, len-1);
1343: ifC cln (" C = X;");
1344: cln ("} else if (shift == 0) {");
1345: ifC cln (" C = 0;");
1346: cln ("} else {");
1347: cln (" val >>= shift - 1;");
1348: cln (" X = val & 1;");
1349: ifC cln (" C = X;");
1350: cln (" val >>= 1;");
1351: cln ("}");
1352: }
1353:
1354: ifZ cln ("nZ = ((%s)(val)) != 0;", c_ssizes[size]);
1355: ifN cln ("N = ((%s)(val)) < 0;", c_ssizes[size]);
1356: ifV cln ("V = 0;");
1357:
1358: c_writeea (dest, size, "val");
1359: c_postea (dest);
1360: c_postea (src);
1361: c_fnend ();
1362: }
1363:
1364: void c_func_movem (ea_t *ea, int sz, int dr, int reg_mask)
1365: {
1366: int i, offset;
1367: char buf[256];
1368: const char *read_func;
1369: const char *write_func;
1370:
1371: c_fncall ();
1372:
1373: c_fnbegin ();
1374:
1375: sz++;
1376: read_func = mem_read_funcs[sz];
1377: write_func = mem_write_funcs[sz];
1378:
1379: c_ea_get_address (ea, buf);
1380:
1381: if (dr == 0) {
1382: /* reg to memory */
1383: cln ("s32 dest = %s;", buf);
1384:
1385: if (ea->mode == 4) {
1386: /* pre-decrement mode */
1387: offset = 0;
1388: for (i=0; i<16; i++) {
1389: if (reg_mask & (1<<i)) {
1390: cln ("%s (dest, Regs[%d]._%s);", write_func, 15-i, c_usizes[sz]);
1391: cln ("dest -= %d;", 1<<sz);
1392: offset += 1<<sz;
1393: }
1394: }
1395: cln ("Regs[%d]._s32 -= %d;", ea->reg, offset);
1396: } else {
1397: for (i=0; i<16; i++) {
1398: if (reg_mask & (1<<i)) {
1399: cln ("%s (dest, Regs[%d]._%s);", write_func, i, c_usizes[sz]);
1400: cln ("dest += %d;", 1<<sz);
1401: }
1402: }
1403: }
1404: } else {
1405: /* mem to reg */
1406: cln ("s32 src = %s;", buf);
1407:
1408: offset = 0;
1409: for (i=0; i<16; i++) {
1410: if (reg_mask & (1<<i)) {
1411: cln ("Regs[%d]._s32 = %s (src);", i, read_func);
1412: cln ("src += %d;", 1<<sz);
1413: offset += 1<<sz;
1414: }
1415: }
1416: /* post-inc mode */
1417: if (ea->mode == 3)
1418: cln ("Regs[%d]._s32 += %d;", ea->reg, offset);
1419: }
1420: c_fnend ();
1421: }
1422:
1423: void c_func_subx (ea_t *src, ea_t *dest, int size)
1424: {
1425: char buf[256];
1426: const char *sz = c_ssizes[size];
1427: c_fncall ();
1428:
1429: c_fnbegin ();
1430: /* XXX nZ correct? */
1431: c_readea (dest, buf);
1432: cln ("int flgs, flgo, flgn;");
1433: cln ("%s dest = %s;", sz, buf);
1434:
1435: c_readea (src, buf);
1436: cln ("%s src = %s;", sz, buf);
1437:
1438: cln ("s32 newv = dest - src - (X ? 1 : 0);");
1439:
1440: cln ("flgs = src < 0;", sz);
1441: cln ("flgo = dest < 0;", sz);
1442: cln ("flgn = ((%s)newv) < 0;", sz);
1443: ifV cln ("V = (flgs ^ flgo) & (flgo ^ flgn);");
1444: cln ("X = (flgs ^ ((flgs ^ flgn) & (flgo ^ flgn)));");
1445: ifC cln ("C = X;");
1446: ifZ cln ("nZ = !((!nZ) & (((%s)(newv)) == 0));", sz);
1447: ifN cln ("N = ((%s)newv) < 0;", sz);
1448: c_writeea (dest, size, "newv");
1449: c_postea (dest);
1450: c_postea (src);
1451: c_fnend ();
1452: }
1453:
1454: void c_func_addx (ea_t *src, ea_t *dest, int size)
1455: {
1456: char buf[256];
1457: const char *sz = c_ssizes[size];
1458: c_fncall ();
1459:
1460: c_fnbegin ();
1461: /* XXX nZ correct? */
1462: c_readea (dest, buf);
1463: cln ("int flgs, flgo, flgn;");
1464: cln ("%s dest = %s;", sz, buf);
1465:
1466: c_readea (src, buf);
1467: cln ("%s src = %s;", sz, buf);
1468:
1469: cln ("s32 newv = dest + src + (X ? 1 : 0);");
1470:
1471: cln ("flgs = src < 0;", sz);
1472: cln ("flgo = dest < 0;", sz);
1473: cln ("flgn = ((%s)newv) < 0;", sz);
1474: ifV cln ("V = (flgs ^ flgn) & (flgo ^ flgn);");
1475: cln ("X = (flgs ^ ((flgs ^ flgo) & (flgo ^ flgn)));");
1476: ifC cln ("C = X;");
1477: ifZ cln ("nZ = !((!nZ) & (((%s)(newv)) == 0));", sz);
1478: ifN cln ("N = ((%s)newv) < 0;", sz);
1479: c_writeea (dest, size, "newv");
1480: c_postea (dest);
1481: c_postea (src);
1482: c_fnend ();
1483: }
1484:
1485: void c_func_add (ea_t *src, ea_t *dest, int size)
1486: {
1487: char buf[256];
1488: const char *sz = c_ssizes[size];
1489: const char *usz = c_usizes[size];
1490:
1491: c_fncall ();
1492:
1493: c_fnbegin ();
1494: c_readea (dest, buf);
1495: cln ("s32 dest = %s;\n", buf);
1496:
1497: c_readea (src, buf);
1498: cln ("s32 src = %s;\n", buf);
1499:
1500: cln ("s32 val = (%s)dest + (%s)src;", sz, sz);
1501:
1502: ifV cln ("s32 flgs = ((%s)src) < 0;", sz);
1503: ifV cln ("s32 flgo = ((%s)dest) < 0;", sz);
1504: ifVoN cln ("s32 flgn = ((%s)val) < 0;", sz);
1505: ifZ cln ("nZ = val;");
1506: ifV cln ("V = (flgs ^ flgn) & (flgo ^ flgn);");
1507: cln ("X = ((%s)(~src)) < ((%s)dest);", usz, usz);
1508: ifC cln ("C = X;");
1509: ifN cln ("N = (flgn != 0);");
1510: c_writeea (dest, size, "val");
1511: c_postea (dest);
1512: c_postea (src);
1513: c_fnend ();
1514: }
1515:
1516: void c_func_cmpa (ea_t *src, ea_t *dest, int size)
1517: {
1518: char buf[256];
1519: const char *sz = c_ssizes[size];
1520: c_fncall ();
1521:
1522: c_fnbegin ();
1523:
1524: cln ("s32 dest = Regs[%d]._s32;\n", dest->reg);
1525:
1526: c_readea (src, buf);
1527: cln ("%s src = %s;\n", sz, buf);
1528:
1529: cln ("s32 val = (s32)dest - (s32)src;");
1530: ifV cln ("s32 flgs = ((s32)src) < 0;");
1531: ifV cln ("s32 flgo = ((s32)dest) < 0;");
1532: ifVoN cln ("s32 flgn = ((s32)val) < 0;");
1533: ifZ cln ("nZ = val;");
1534: ifV cln ("V = ((flgs != flgo) && (flgn != flgo));");
1535: ifC cln ("C = ((u32)src) > ((u32)dest);");
1536: ifN cln ("N = (flgn != 0);");
1537: c_postea (dest);
1538: c_postea (src);
1539: c_fnend ();
1540: }
1541:
1542: void c_func_cmp (ea_t *src, ea_t *dest, int size)
1543: {
1544: char buf[256];
1545: const char *sz = c_ssizes[size];
1546: const char *usz = c_usizes[size];
1547: c_fncall ();
1548:
1549: c_fnbegin ();
1550:
1551: c_readea (dest, buf);
1552: cln ("s32 dest = %s;\n", buf);
1553:
1554: c_readea (src, buf);
1555: cln ("s32 src = %s;\n", buf);
1556:
1557: cln ("s32 val = (%s)dest - (%s)src;", sz, sz);
1558:
1559: ifV cln ("s32 flgs = ((%s)src) < 0;", sz);
1560: ifV cln ("s32 flgo = ((%s)dest) < 0;", sz);
1561: ifVoN cln ("s32 flgn = ((%s)val) < 0;", sz);
1562: ifV cln ("V = ((flgs != flgo) && (flgn != flgo));");
1563: ifC cln ("C = ((%s)src) > ((%s)dest);", usz, usz);
1564: ifN cln ("N = (flgn != 0);");
1565: ifZ cln ("nZ = val;");
1566: c_postea (dest);
1567: c_postea (src);
1568: c_fnend ();
1569: }
1570:
1571: void c_func_sub (ea_t *src, ea_t *dest, int size)
1572: {
1573: char buf[256];
1574: const char *sz = c_ssizes[size];
1575: const char *usz = c_usizes[size];
1576:
1577: c_fncall ();
1578:
1579: c_fnbegin ();
1580: c_readea (dest, buf);
1581: cln ("s32 dest = %s;\n", buf);
1582:
1583: c_readea (src, buf);
1584: cln ("s32 src = %s;\n", buf);
1585:
1586: cln ("u32 newv = (%s)dest - (%s)src;", sz, sz);
1587:
1588: ifV cln ("s32 flgs = ((%s)src) < 0;", sz);
1589: ifV cln ("s32 flgo = ((%s)dest) < 0;", sz);
1590: ifVoN cln ("s32 flgn = ((%s)newv) < 0;", sz);
1591: ifZ cln ("nZ = newv;");
1592: ifV cln ("V = (flgs ^ flgo) & (flgn ^ flgo);");
1593: cln ("X = ((%s)src) > ((%s)dest);", usz, usz);
1594: ifC cln ("C = X;");
1595: ifN cln ("N = (flgn != 0);");
1596: c_writeea (dest, size, "newv");
1597: c_postea (dest);
1598: c_postea (src);
1599: c_fnend ();
1600: }
1601:
1602: void c_func_adda (ea_t *src, int dest_reg, int size)
1603: {
1604: char buf[256];
1605: if (gen_mode != GEN_CALL) return;
1606: c_readea (src, buf);
1607: cln ("Regs[%d]._u32 = Regs[%d]._s32 + (%s)%s;", dest_reg, dest_reg, c_ssizes[size], buf);
1608: c_postea (src);
1609: }
1610:
1611: void c_func_suba (ea_t *src, int dest_reg, int size)
1612: {
1613: char buf[256];
1614: if (gen_mode != GEN_CALL) return;
1615: c_readea (src, buf);
1616: cln ("Regs[%d]._u32 = Regs[%d]._s32 - (%s)%s;", dest_reg, dest_reg, c_ssizes[size], buf);
1617: c_postea (src);
1618: }
1619:
1620: void c_func_swap (int reg)
1621: {
1622: c_fncall ();
1623:
1624: c_fnbegin ();
1625: cln ("s32 temp = Regs[%d].word[0];", reg);
1626: cln ("Regs[%d].word[0] = Regs[%d].word[1];", reg, reg);
1627: cln ("Regs[%d].word[1] = temp;", reg);
1628: ifZ cln ("nZ = Regs[%d]._s32;", reg);
1629: ifN cln ("N = (Regs[%d]._s32 < 0);", reg);
1630: ifV cln ("V = 0;");
1631: ifC cln ("C = 0;");
1632: c_fnend ();
1633: }
1634:
1635: void c_func_jsr (ea_t *dest)
1636: {
1637: char buf[256];
1638: if (gen_mode != GEN_CALL) return;
1639: snprintf (buf, sizeof (buf), "%x", get_bitpos ());
1640: add_label (buf, C_ADDR, get_bitpos () - BASE);
1641: add_fixup (0, C_ADDR, buf);
1642:
1643: snprintf (buf, sizeof (buf), "__D%x", get_bitpos ());
1644: cln ("Regs[15]._s32 -= 4;");
1645: cln ("wrlong (Regs[15]._s32, %s);", buf);
1646:
1647: c_jump (dest);
1648: }
1649:
1650: void c_func_bcc (ea_t *dest, int cond)
1651: {
1652: if (gen_mode != GEN_CALL) return;
1653: if (cond == 0) {
1654: c_jump (dest);
1655: } else {
1656: cout ("\tif (");
1657: c_eval_cond (cond);
1658: cout (")\n");
1659: c_jump_e (dest);
1660: }
1661: }
1662:
1663: /* XXX note: this does not call c_jump and therefore does not
1664: * check for pending exceptions. an infinite DBcc loop will not
1665: * allow exceptions to occur.
1666: * does it matter? */
1667: void c_func_dbcc (const char *label, int cond, int reg)
1668: {
1669: if (gen_mode != GEN_CALL) return;
1670: if (cond == 0) {
1671: cln ("if (--Regs[%d]._s16 != -1) goto __N%s;\n", reg, label);
1672: } else {
1673: cout ("\tif ((!");
1674: c_eval_cond (cond);
1675: cout (") && (--Regs[%d]._s16 != -1)) goto __N%s;\n", reg, label);
1676: }
1677: }
1678:
1679: void c_func_clr (ea_t *dest)
1680: {
1681: c_fncall ();
1682:
1683: c_fnbegin ();
1684: c_writeea (dest, dest->op_size, "0");
1685: c_postea (dest);
1686: ifN cln ("N = 0;");
1687: ifZ cln ("nZ = 0;");
1688: ifV cln ("V = 0;");
1689: ifC cln ("C = 0;");
1690: c_fnend ();
1691: }
1692:
1693: void c_func_exg (int reg1, int reg2)
1694: {
1695: c_fncall ();
1696:
1697: c_fnbegin ();
1698: cln ("u32 temp = Regs[%d]._u32;", reg1);
1699: cln ("Regs[%d]._u32 = Regs[%d]._u32;", reg1, reg2);
1700: cln ("Regs[%d]._u32 = temp;", reg2);
1701: c_fnend ();
1702: }
1703:
1704: void c_func_ext (int reg, int size)
1705: {
1706: c_fncall ();
1707:
1708: c_fnbegin ();
1709: cln ("%s val = Regs[%d]._%s;", c_ssizes[size], reg, c_ssizes[size-1]);
1710: cln ("Regs[%d]._%s = val;", reg, c_ssizes[size]);
1711: ifZ cln ("nZ = val;");
1712: ifN cln ("N = (val < 0);");
1713: ifV cln ("V = 0;");
1714: ifC cln ("C = 0;");
1715: c_fnend ();
1716: }
1717:
1718: void c_func_rte ()
1719: {
1720: if (gen_mode != GEN_CALL) return;
1721: cln ("N=bN; nZ=bnZ; V=bV; C=bC; X=bX;");
1722: cln ("jdest = rdest;");
1723: cln ("rdest = 0;");
1724: cln ("goto jumptable;");
1725: }
1726:
1727: void c_func_rts ()
1728: {
1729: if (gen_mode != GEN_CALL) return;
1730: cln ("jdest = rdlong (Regs[15]._u32);");
1731: cln ("Regs[15]._s32 += 4;");
1732: cln ("goto jumptable;");
1733: }
1734:
1735: void c_func_illegal ()
1736: {
1737: if (gen_mode != GEN_CALL) return;
1738: cln ("printf (\"Illegal instruction at line %d.\\n\");", line_no);
1739: cln ("abort ();");
1740: }
1741:
1742: void c_func_hcall (int val)
1743: {
1744: if (gen_mode != GEN_CALL) return;
1745: cln ("(* hcalls[%d]) ();", val);
1746: }
1747:
1748: void c_func_link (int reg, int val)
1749: {
1750: c_fncall ();
1751:
1752: c_fnbegin ();
1753: cln ("Regs[15]._u32 -= 4;");
1754: cln ("wrlong (Regs[15]._u32, Regs[%d]._u32);", reg);
1755: cln ("Regs[%d]._u32 = Regs[15]._u32;", reg);
1756: cln ("Regs[15]._u32 += 0x%x;", val);
1757: c_fnend ();
1758: }
1759:
1760: void c_func_unlk (int reg)
1761: {
1762: c_fncall ();
1763:
1764: c_fnbegin ();
1765: cln ("Regs[15]._u32 = Regs[%d]._u32;", reg);
1766: cln ("Regs[%d]._u32 = rdlong (Regs[15]._u32);", reg);
1767: cln ("Regs[15]._u32 += 4;");
1768: c_fnend ();
1769: }
1770:
1771: void c_func_move (ea_t *src, ea_t *dest, int size)
1772: {
1773: char buf[256];
1774: c_fncall ();
1775:
1776: c_fnbegin ();
1777: c_readea (src, buf);
1778: cln ("s32 val = %s;", buf);
1779: c_writeea (dest, size, "val");
1780: c_postea (src);
1781: c_postea (dest);
1782: ifZ cln ("nZ = val;");
1783: ifN cln ("N = val < 0;");
1784: ifV cln ("V = 0;");
1785: ifC cln ("C = 0;");
1786: c_fnend ();
1787: }
1788:
1789: void c_func_movea (ea_t *src, int reg_dest)
1790: {
1791: char buf[256];
1792: if (gen_mode != GEN_CALL) return;
1793: assert (reg_dest > 7);
1794: c_readea (src, buf);
1795: cln ("Regs[%d]._s32 = %s;", reg_dest, buf);
1796: c_postea (src);
1797: }
1798:
1799: void c_func_tst (ea_t *ea)
1800: {
1801: char buf[256];
1802: c_fncall ();
1803:
1804: c_fnbegin ();
1805: c_readea (ea, buf);
1806: cln ("nZ = %s;", buf);
1807: c_postea (ea);
1808: ifN cln ("N = nZ < 0;");
1809: ifV cln ("V = 0;");
1810: ifC cln ("C = 0;");
1811: c_fnend ();
1812: }
1813:
1814: void c_func_pea (ea_t *ea)
1815: {
1816: char buf[256];
1817: if (gen_mode != GEN_CALL) return;
1818: c_ea_get_address (ea, buf);
1819:
1820: cln ("Regs[15]._u32 -= 4;");
1821: cln ("wrlong (Regs[15]._u32, %s);", buf);
1822: }
1823:
1824: void c_func_lea (ea_t *ea, int reg)
1825: {
1826: char buf[256];
1827: if (gen_mode != GEN_CALL) return;
1828: c_ea_get_address (ea, buf);
1829:
1830: cln ("Regs[%d]._u32 = %s;", reg, buf);
1831: }
1832:
1833: void c_func_scc (ea_t *dest, int cond)
1834: {
1835: c_fncall ();
1836:
1837: c_fnbegin ();
1838: cout ("\tif (");
1839: c_eval_cond (cond);
1840: cout (") {\n");
1841: c_writeea (dest, BYTE, "0xff");
1842: cln ("} else {");
1843: c_writeea (dest, BYTE, "0");
1844: cln ("}");
1845: c_postea (dest);
1846: c_fnend ();
1847: }
1848:
1849: static void output_op (op_t *op, op_t *next)
1850: {
1851: switch (op->optype) {
1852: case OP_MULS: c_func_muls (&op->src, &op->dest); break;
1853: case OP_MULU: c_func_mulu (&op->src, &op->dest); break;
1854: case OP_ADDA: c_func_adda (&op->src, op->dest.reg, op->size); break;
1855: case OP_SUBA: c_func_suba (&op->src, op->dest.reg, op->size); break;
1856: case OP_ADD: c_func_add (&op->src, &op->dest, op->size); break;
1857: case OP_SUB: c_func_sub (&op->src, &op->dest, op->size); break;
1858: case OP_NOT: c_func_not (&op->src, op->size); break;
1859: case OP_NEGX: c_func_negx (&op->src, op->size); break;
1860: case OP_NEG: c_func_neg (&op->src, op->size); break;
1861: case OP_DIVS: c_func_divs (&op->src, op->dest.reg); break;
1862: case OP_DIVU: c_func_divu (&op->src, op->dest.reg); break;
1863: case OP_ADDX: c_func_addx (&op->src, &op->dest, op->size); break;
1864: case OP_SUBX: c_func_subx (&op->src, &op->dest, op->size); break;
1865: case OP_BCHG: c_func_bchg (&op->src, &op->dest, op->size); break;
1866: case OP_BCLR: c_func_bclr (&op->src, &op->dest, op->size); break;
1867: case OP_BSET: c_func_bset (&op->src, &op->dest, op->size); break;
1868: case OP_BTST: c_func_btst (&op->src, &op->dest, op->size); break;
1869: case OP_ASL: c_func_asl (&op->src, &op->dest, op->size); break;
1870: case OP_ASR: c_func_asr (&op->src, &op->dest, op->size); break;
1871: case OP_LSL: c_func_lsl (&op->src, &op->dest, op->size); break;
1872: case OP_LSR: c_func_lsr (&op->src, &op->dest, op->size); break;
1873: case OP_ROL: c_func_rol (&op->src, &op->dest, op->size); break;
1874: case OP_ROR: c_func_ror (&op->src, &op->dest, op->size); break;
1875: case OP_ROXL: c_func_roxl (&op->src, &op->dest, op->size); break;
1876: case OP_ROXR: c_func_roxr (&op->src, &op->dest, op->size); break;
1877: case OP_OR: c_func_logop (&op->src, &op->dest, op->size, '|'); break;
1878: case OP_AND: c_func_logop (&op->src, &op->dest, op->size, '&'); break;
1879: case OP_XOR: c_func_logop (&op->src, &op->dest, op->size, '^'); break;
1880: case OP_SWAP: c_func_swap (op->src.reg); break;
1881: case OP_JSR: c_func_jsr (&op->src); break;
1882: case OP_BCC: c_func_bcc (&op->src, op->opcode.Bcc.cond); break;
1883: case OP_DBCC: c_func_dbcc (op->dest.imm.label, op->opcode.Bcc.cond, op->src.reg); break;
1884: case OP_CLR: c_func_clr (&op->src); break;
1885: case OP_CMP: c_func_cmp (&op->src, &op->dest, op->size); break;
1886: case OP_CMPA: c_func_cmpa (&op->src, &op->dest, op->size); break;
1887: case OP_EXG: c_func_exg (op->src.reg, op->dest.reg); break;
1888: case OP_EXT: c_func_ext (op->src.reg, op->size); break;
1889: case OP_MOVEM: c_func_movem (&op->src, op->opcode.movem.sz, op->opcode.movem.dr, op->dest.reg); break;
1890: case OP_RTE: c_func_rte (); break;
1891: case OP_RTS: c_func_rts (); break;
1892: case OP_ILLEGAL: c_func_illegal (); break;
1893: case OP_HCALL: c_func_hcall (op->src.imm.val); break;
1894: case OP_LINK: c_func_link (op->src.reg, op->dest.imm.val); break;
1895: case OP_UNLK: c_func_unlk (op->src.reg); break;
1896: case OP_MOVE: c_func_move (&op->src, &op->dest, op->size); break;
1897: case OP_MOVEA: c_func_movea (&op->src, op->dest.reg); break;
1898: case OP_TST: c_func_tst (&op->src); break;
1899: case OP_PEA: c_func_pea (&op->src); break;
1900: case OP_LEA: c_func_lea (&op->src, op->dest.reg); break;
1901: case OP_JMP: c_jump (&op->src); break;
1902: case OP_SCC: c_func_scc (&op->src, op->opcode.DBcc.cond); break;
1903:
1904: default:
1905: printf ("type %d\n", op->optype);
1906: assert (0);
1907: }
1908: }
1909:
1910: void c_push_op (enum M68K_OPS type, ea_t *src, ea_t *dest, int size)
1911: {
1912: c_push_op2 (type, src, dest, size, 0);
1913: }
1914: void c_push_op2 (enum M68K_OPS type, ea_t *src, ea_t *dest, int size, int opcode)
1915: {
1916: next_op_type = type;
1917:
1918: if (pending.optype) {
1919: gen_mode = GEN_BODY;
1920: output_op (&pending, NULL);
1921: gen_mode = GEN_CALL;
1922: }
1923:
1924: pending.size = size;
1925: pending.opcode.code = opcode;
1926: pending.optype = type;
1927:
1928: if (type == OP_JSR)
1929: return_target = 1;
1930: else
1931: return_target = 0;
1932:
1933: if (src) {
1934: pending.src = *src;
1935: }
1936: if (dest) {
1937: pending.dest = *dest;
1938: }
1939: output_op (&pending, NULL);
1940: }
1941: void c_push_op_basic (enum M68K_OPS type)
1942: {
1943: c_push_op2 (type, NULL, NULL, 0, 0);
1944: }
1945:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.