![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpu0.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / CPU Sources|
Return to cpu0.c CVS log | Up to [UNIX Amiga Emulator] / uae / CPU Sources |
1.1 root 1: #include "config.h"
2: #include "amiga.h"
3: #include "options.h"
4: #include <stdlib.h>
5: #include "memory.h"
6: #include "custom.h"
7: #include "newcpu.h"
8: #include "cputbl.h"
9:
10: void op_0(UWORD opcode)
11: {
12: ULONG dstreg = (opcode & 7) >> 0;
13: {{ BYTE src = nextiword();
14: { BYTE dst = regs.d[dstreg];
15: src |= dst;
16: regs.v = regs.c = 0;
17: regs.z = ((BYTE)(src)) == 0;
18: regs.n = ((BYTE)(src)) < 0;
19: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
20: }}}}
21: void op_10(UWORD opcode)
22: {
23: ULONG dstreg = (opcode & 7) >> 0;
24: {{ BYTE src = nextiword();
25: { CPTR dsta = regs.a[dstreg];
26: BYTE dst = get_byte(dsta);
27: src |= dst;
28: regs.v = regs.c = 0;
29: regs.z = ((BYTE)(src)) == 0;
30: regs.n = ((BYTE)(src)) < 0;
31: put_byte(dsta,src);
32: }}}}
33: void op_18(UWORD opcode)
34: {
35: ULONG dstreg = (opcode & 7) >> 0;
36: {{ BYTE src = nextiword();
37: { CPTR dsta = regs.a[dstreg];
38: BYTE dst = get_byte(dsta);
39: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
40: src |= dst;
41: regs.v = regs.c = 0;
42: regs.z = ((BYTE)(src)) == 0;
43: regs.n = ((BYTE)(src)) < 0;
44: put_byte(dsta,src);
45: }}}}}
46: void op_20(UWORD opcode)
47: {
48: ULONG dstreg = (opcode & 7) >> 0;
49: {{ BYTE src = nextiword();
50: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
51: { CPTR dsta = regs.a[dstreg];
52: BYTE dst = get_byte(dsta);
53: src |= dst;
54: regs.v = regs.c = 0;
55: regs.z = ((BYTE)(src)) == 0;
56: regs.n = ((BYTE)(src)) < 0;
57: put_byte(dsta,src);
58: }}}}}
59: void op_28(UWORD opcode)
60: {
61: ULONG dstreg = (opcode & 7) >> 0;
62: {{ BYTE src = nextiword();
63: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
64: BYTE dst = get_byte(dsta);
65: src |= dst;
66: regs.v = regs.c = 0;
67: regs.z = ((BYTE)(src)) == 0;
68: regs.n = ((BYTE)(src)) < 0;
69: put_byte(dsta,src);
70: }}}}
71: void op_30(UWORD opcode)
72: {
73: ULONG dstreg = (opcode & 7) >> 0;
74: {{ BYTE src = nextiword();
75: { CPTR dsta = regs.a[dstreg];
76: UWORD dstdp = nextiword();
77: dsta += (LONG)(BYTE)(dstdp & 0xFF);
78: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
79: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
80: dsta += dstdpr;
81: { BYTE dst = get_byte(dsta);
82: src |= dst;
83: regs.v = regs.c = 0;
84: regs.z = ((BYTE)(src)) == 0;
85: regs.n = ((BYTE)(src)) < 0;
86: put_byte(dsta,src);
87: }}}}}}
88: void op_38(UWORD opcode)
89: {
90: {{ BYTE src = nextiword();
91: { CPTR dsta = (LONG)(WORD)nextiword();
92: BYTE dst = get_byte(dsta);
93: src |= dst;
94: regs.v = regs.c = 0;
95: regs.z = ((BYTE)(src)) == 0;
96: regs.n = ((BYTE)(src)) < 0;
97: put_byte(dsta,src);
98: }}}}
99: void op_39(UWORD opcode)
100: {
101: {{ BYTE src = nextiword();
102: { CPTR dsta = nextilong();
103: BYTE dst = get_byte(dsta);
104: src |= dst;
105: regs.v = regs.c = 0;
106: regs.z = ((BYTE)(src)) == 0;
107: regs.n = ((BYTE)(src)) < 0;
108: put_byte(dsta,src);
109: }}}}
110: void op_3c(UWORD opcode)
111: {
112: {{ MakeSR();
113: { WORD src = nextiword();
114: src &= 0xFF;
115: regs.sr |= src;
116: MakeFromSR();
117: }}}}
118: void op_40(UWORD opcode)
119: {
120: ULONG dstreg = (opcode & 7) >> 0;
121: {{ WORD src = nextiword();
122: { WORD dst = regs.d[dstreg];
123: src |= dst;
124: regs.v = regs.c = 0;
125: regs.z = ((WORD)(src)) == 0;
126: regs.n = ((WORD)(src)) < 0;
127: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
128: }}}}
129: void op_50(UWORD opcode)
130: {
131: ULONG dstreg = (opcode & 7) >> 0;
132: {{ WORD src = nextiword();
133: { CPTR dsta = regs.a[dstreg];
134: WORD dst = get_word(dsta);
135: src |= dst;
136: regs.v = regs.c = 0;
137: regs.z = ((WORD)(src)) == 0;
138: regs.n = ((WORD)(src)) < 0;
139: put_word(dsta,src);
140: }}}}
141: void op_58(UWORD opcode)
142: {
143: ULONG dstreg = (opcode & 7) >> 0;
144: {{ WORD src = nextiword();
145: { CPTR dsta = regs.a[dstreg];
146: WORD dst = get_word(dsta);
147: { regs.a[dstreg] += 2;
148: src |= dst;
149: regs.v = regs.c = 0;
150: regs.z = ((WORD)(src)) == 0;
151: regs.n = ((WORD)(src)) < 0;
152: put_word(dsta,src);
153: }}}}}
154: void op_60(UWORD opcode)
155: {
156: ULONG dstreg = (opcode & 7) >> 0;
157: {{ WORD src = nextiword();
158: { regs.a[dstreg] -= 2;
159: { CPTR dsta = regs.a[dstreg];
160: WORD dst = get_word(dsta);
161: src |= dst;
162: regs.v = regs.c = 0;
163: regs.z = ((WORD)(src)) == 0;
164: regs.n = ((WORD)(src)) < 0;
165: put_word(dsta,src);
166: }}}}}
167: void op_68(UWORD opcode)
168: {
169: ULONG dstreg = (opcode & 7) >> 0;
170: {{ WORD src = nextiword();
171: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
172: WORD dst = get_word(dsta);
173: src |= dst;
174: regs.v = regs.c = 0;
175: regs.z = ((WORD)(src)) == 0;
176: regs.n = ((WORD)(src)) < 0;
177: put_word(dsta,src);
178: }}}}
179: void op_70(UWORD opcode)
180: {
181: ULONG dstreg = (opcode & 7) >> 0;
182: {{ WORD src = nextiword();
183: { CPTR dsta = regs.a[dstreg];
184: UWORD dstdp = nextiword();
185: dsta += (LONG)(BYTE)(dstdp & 0xFF);
186: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
187: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
188: dsta += dstdpr;
189: { WORD dst = get_word(dsta);
190: src |= dst;
191: regs.v = regs.c = 0;
192: regs.z = ((WORD)(src)) == 0;
193: regs.n = ((WORD)(src)) < 0;
194: put_word(dsta,src);
195: }}}}}}
196: void op_78(UWORD opcode)
197: {
198: {{ WORD src = nextiword();
199: { CPTR dsta = (LONG)(WORD)nextiword();
200: WORD dst = get_word(dsta);
201: src |= dst;
202: regs.v = regs.c = 0;
203: regs.z = ((WORD)(src)) == 0;
204: regs.n = ((WORD)(src)) < 0;
205: put_word(dsta,src);
206: }}}}
207: void op_79(UWORD opcode)
208: {
209: {{ WORD src = nextiword();
210: { CPTR dsta = nextilong();
211: WORD dst = get_word(dsta);
212: src |= dst;
213: regs.v = regs.c = 0;
214: regs.z = ((WORD)(src)) == 0;
215: regs.n = ((WORD)(src)) < 0;
216: put_word(dsta,src);
217: }}}}
218: void op_7c(UWORD opcode)
219: {
220: { if (!regs.s) { regs.pc_p--; Exception(8); } else
221: { MakeSR();
222: { WORD src = nextiword();
223: regs.sr |= src;
224: MakeFromSR();
225: }}}}
226: void op_80(UWORD opcode)
227: {
228: ULONG dstreg = (opcode & 7) >> 0;
229: {{ LONG src = nextilong();
230: { LONG dst = regs.d[dstreg];
231: src |= dst;
232: regs.v = regs.c = 0;
233: regs.z = ((LONG)(src)) == 0;
234: regs.n = ((LONG)(src)) < 0;
235: regs.d[dstreg] = (src);
236: }}}}
237: void op_90(UWORD opcode)
238: {
239: ULONG dstreg = (opcode & 7) >> 0;
240: {{ LONG src = nextilong();
241: { CPTR dsta = regs.a[dstreg];
242: LONG dst = get_long(dsta);
243: src |= dst;
244: regs.v = regs.c = 0;
245: regs.z = ((LONG)(src)) == 0;
246: regs.n = ((LONG)(src)) < 0;
247: put_long(dsta,src);
248: }}}}
249: void op_98(UWORD opcode)
250: {
251: ULONG dstreg = (opcode & 7) >> 0;
252: {{ LONG src = nextilong();
253: { CPTR dsta = regs.a[dstreg];
254: LONG dst = get_long(dsta);
255: { regs.a[dstreg] += 4;
256: src |= dst;
257: regs.v = regs.c = 0;
258: regs.z = ((LONG)(src)) == 0;
259: regs.n = ((LONG)(src)) < 0;
260: put_long(dsta,src);
261: }}}}}
262: void op_a0(UWORD opcode)
263: {
264: ULONG dstreg = (opcode & 7) >> 0;
265: {{ LONG src = nextilong();
266: { regs.a[dstreg] -= 4;
267: { CPTR dsta = regs.a[dstreg];
268: LONG dst = get_long(dsta);
269: src |= dst;
270: regs.v = regs.c = 0;
271: regs.z = ((LONG)(src)) == 0;
272: regs.n = ((LONG)(src)) < 0;
273: put_long(dsta,src);
274: }}}}}
275: void op_a8(UWORD opcode)
276: {
277: ULONG dstreg = (opcode & 7) >> 0;
278: {{ LONG src = nextilong();
279: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
280: LONG dst = get_long(dsta);
281: src |= dst;
282: regs.v = regs.c = 0;
283: regs.z = ((LONG)(src)) == 0;
284: regs.n = ((LONG)(src)) < 0;
285: put_long(dsta,src);
286: }}}}
287: void op_b0(UWORD opcode)
288: {
289: ULONG dstreg = (opcode & 7) >> 0;
290: {{ LONG src = nextilong();
291: { CPTR dsta = regs.a[dstreg];
292: UWORD dstdp = nextiword();
293: dsta += (LONG)(BYTE)(dstdp & 0xFF);
294: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
295: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
296: dsta += dstdpr;
297: { LONG dst = get_long(dsta);
298: src |= dst;
299: regs.v = regs.c = 0;
300: regs.z = ((LONG)(src)) == 0;
301: regs.n = ((LONG)(src)) < 0;
302: put_long(dsta,src);
303: }}}}}}
304: void op_b8(UWORD opcode)
305: {
306: {{ LONG src = nextilong();
307: { CPTR dsta = (LONG)(WORD)nextiword();
308: LONG dst = get_long(dsta);
309: src |= dst;
310: regs.v = regs.c = 0;
311: regs.z = ((LONG)(src)) == 0;
312: regs.n = ((LONG)(src)) < 0;
313: put_long(dsta,src);
314: }}}}
315: void op_b9(UWORD opcode)
316: {
317: {{ LONG src = nextilong();
318: { CPTR dsta = nextilong();
319: LONG dst = get_long(dsta);
320: src |= dst;
321: regs.v = regs.c = 0;
322: regs.z = ((LONG)(src)) == 0;
323: regs.n = ((LONG)(src)) < 0;
324: put_long(dsta,src);
325: }}}}
326: void op_100(UWORD opcode)
327: {
328: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
329: ULONG dstreg = (opcode & 7) >> 0;
330: {{ LONG src = regs.d[srcreg];
331: { LONG dst = regs.d[dstreg];
332: src &= 31;
333: regs.z = !(dst & (1 << src));
334: }}}}
335: void op_110(UWORD opcode)
336: {
337: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
338: ULONG dstreg = (opcode & 7) >> 0;
339: {{ BYTE src = regs.d[srcreg];
340: { CPTR dsta = regs.a[dstreg];
341: BYTE dst = get_byte(dsta);
342: src &= 7;
343: regs.z = !(dst & (1 << src));
344: }}}}
345: void op_118(UWORD opcode)
346: {
347: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
348: ULONG dstreg = (opcode & 7) >> 0;
349: {{ BYTE src = regs.d[srcreg];
350: { CPTR dsta = regs.a[dstreg];
351: BYTE dst = get_byte(dsta);
352: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
353: src &= 7;
354: regs.z = !(dst & (1 << src));
355: }}}}}
356: void op_120(UWORD opcode)
357: {
358: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
359: ULONG dstreg = (opcode & 7) >> 0;
360: {{ BYTE src = regs.d[srcreg];
361: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
362: { CPTR dsta = regs.a[dstreg];
363: BYTE dst = get_byte(dsta);
364: src &= 7;
365: regs.z = !(dst & (1 << src));
366: }}}}}
367: void op_128(UWORD opcode)
368: {
369: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
370: ULONG dstreg = (opcode & 7) >> 0;
371: {{ BYTE src = regs.d[srcreg];
372: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
373: BYTE dst = get_byte(dsta);
374: src &= 7;
375: regs.z = !(dst & (1 << src));
376: }}}}
377: void op_130(UWORD opcode)
378: {
379: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
380: ULONG dstreg = (opcode & 7) >> 0;
381: {{ BYTE src = regs.d[srcreg];
382: { CPTR dsta = regs.a[dstreg];
383: UWORD dstdp = nextiword();
384: dsta += (LONG)(BYTE)(dstdp & 0xFF);
385: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
386: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
387: dsta += dstdpr;
388: { BYTE dst = get_byte(dsta);
389: src &= 7;
390: regs.z = !(dst & (1 << src));
391: }}}}}}
392: void op_138(UWORD opcode)
393: {
394: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
395: {{ BYTE src = regs.d[srcreg];
396: { CPTR dsta = (LONG)(WORD)nextiword();
397: BYTE dst = get_byte(dsta);
398: src &= 7;
399: regs.z = !(dst & (1 << src));
400: }}}}
401: void op_139(UWORD opcode)
402: {
403: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
404: {{ BYTE src = regs.d[srcreg];
405: { CPTR dsta = nextilong();
406: BYTE dst = get_byte(dsta);
407: src &= 7;
408: regs.z = !(dst & (1 << src));
409: }}}}
410: void op_140(UWORD opcode)
411: {
412: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
413: ULONG dstreg = (opcode & 7) >> 0;
414: {{ LONG src = regs.d[srcreg];
415: { LONG dst = regs.d[dstreg];
416: src &= 31;
417: regs.z = !(dst & (1 << src));
418: dst ^= (1 << src);
419: regs.d[dstreg] = (dst);
420: }}}}
421: void op_150(UWORD opcode)
422: {
423: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
424: ULONG dstreg = (opcode & 7) >> 0;
425: {{ BYTE src = regs.d[srcreg];
426: { CPTR dsta = regs.a[dstreg];
427: BYTE dst = get_byte(dsta);
428: src &= 7;
429: regs.z = !(dst & (1 << src));
430: dst ^= (1 << src);
431: put_byte(dsta,dst);
432: }}}}
433: void op_158(UWORD opcode)
434: {
435: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
436: ULONG dstreg = (opcode & 7) >> 0;
437: {{ BYTE src = regs.d[srcreg];
438: { CPTR dsta = regs.a[dstreg];
439: BYTE dst = get_byte(dsta);
440: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
441: src &= 7;
442: regs.z = !(dst & (1 << src));
443: dst ^= (1 << src);
444: put_byte(dsta,dst);
445: }}}}}
446: void op_160(UWORD opcode)
447: {
448: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
449: ULONG dstreg = (opcode & 7) >> 0;
450: {{ BYTE src = regs.d[srcreg];
451: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
452: { CPTR dsta = regs.a[dstreg];
453: BYTE dst = get_byte(dsta);
454: src &= 7;
455: regs.z = !(dst & (1 << src));
456: dst ^= (1 << src);
457: put_byte(dsta,dst);
458: }}}}}
459: void op_168(UWORD opcode)
460: {
461: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
462: ULONG dstreg = (opcode & 7) >> 0;
463: {{ BYTE src = regs.d[srcreg];
464: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
465: BYTE dst = get_byte(dsta);
466: src &= 7;
467: regs.z = !(dst & (1 << src));
468: dst ^= (1 << src);
469: put_byte(dsta,dst);
470: }}}}
471: void op_170(UWORD opcode)
472: {
473: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
474: ULONG dstreg = (opcode & 7) >> 0;
475: {{ BYTE src = regs.d[srcreg];
476: { CPTR dsta = regs.a[dstreg];
477: UWORD dstdp = nextiword();
478: dsta += (LONG)(BYTE)(dstdp & 0xFF);
479: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
480: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
481: dsta += dstdpr;
482: { BYTE dst = get_byte(dsta);
483: src &= 7;
484: regs.z = !(dst & (1 << src));
485: dst ^= (1 << src);
486: put_byte(dsta,dst);
487: }}}}}}
488: void op_178(UWORD opcode)
489: {
490: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
491: {{ BYTE src = regs.d[srcreg];
492: { CPTR dsta = (LONG)(WORD)nextiword();
493: BYTE dst = get_byte(dsta);
494: src &= 7;
495: regs.z = !(dst & (1 << src));
496: dst ^= (1 << src);
497: put_byte(dsta,dst);
498: }}}}
499: void op_179(UWORD opcode)
500: {
501: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
502: {{ BYTE src = regs.d[srcreg];
503: { CPTR dsta = nextilong();
504: BYTE dst = get_byte(dsta);
505: src &= 7;
506: regs.z = !(dst & (1 << src));
507: dst ^= (1 << src);
508: put_byte(dsta,dst);
509: }}}}
510: void op_180(UWORD opcode)
511: {
512: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
513: ULONG dstreg = (opcode & 7) >> 0;
514: {{ LONG src = regs.d[srcreg];
515: { LONG dst = regs.d[dstreg];
516: src &= 31;
517: regs.z = !(dst & (1 << src));
518: dst &= ~(1 << src);
519: regs.d[dstreg] = (dst);
520: }}}}
521: void op_190(UWORD opcode)
522: {
523: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
524: ULONG dstreg = (opcode & 7) >> 0;
525: {{ BYTE src = regs.d[srcreg];
526: { CPTR dsta = regs.a[dstreg];
527: BYTE dst = get_byte(dsta);
528: src &= 7;
529: regs.z = !(dst & (1 << src));
530: dst &= ~(1 << src);
531: put_byte(dsta,dst);
532: }}}}
533: void op_198(UWORD opcode)
534: {
535: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
536: ULONG dstreg = (opcode & 7) >> 0;
537: {{ BYTE src = regs.d[srcreg];
538: { CPTR dsta = regs.a[dstreg];
539: BYTE dst = get_byte(dsta);
540: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
541: src &= 7;
542: regs.z = !(dst & (1 << src));
543: dst &= ~(1 << src);
544: put_byte(dsta,dst);
545: }}}}}
546: void op_1a0(UWORD opcode)
547: {
548: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
549: ULONG dstreg = (opcode & 7) >> 0;
550: {{ BYTE src = regs.d[srcreg];
551: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
552: { CPTR dsta = regs.a[dstreg];
553: BYTE dst = get_byte(dsta);
554: src &= 7;
555: regs.z = !(dst & (1 << src));
556: dst &= ~(1 << src);
557: put_byte(dsta,dst);
558: }}}}}
559: void op_1a8(UWORD opcode)
560: {
561: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
562: ULONG dstreg = (opcode & 7) >> 0;
563: {{ BYTE src = regs.d[srcreg];
564: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
565: BYTE dst = get_byte(dsta);
566: src &= 7;
567: regs.z = !(dst & (1 << src));
568: dst &= ~(1 << src);
569: put_byte(dsta,dst);
570: }}}}
571: void op_1b0(UWORD opcode)
572: {
573: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
574: ULONG dstreg = (opcode & 7) >> 0;
575: {{ BYTE src = regs.d[srcreg];
576: { CPTR dsta = regs.a[dstreg];
577: UWORD dstdp = nextiword();
578: dsta += (LONG)(BYTE)(dstdp & 0xFF);
579: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
580: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
581: dsta += dstdpr;
582: { BYTE dst = get_byte(dsta);
583: src &= 7;
584: regs.z = !(dst & (1 << src));
585: dst &= ~(1 << src);
586: put_byte(dsta,dst);
587: }}}}}}
588: void op_1b8(UWORD opcode)
589: {
590: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
591: {{ BYTE src = regs.d[srcreg];
592: { CPTR dsta = (LONG)(WORD)nextiword();
593: BYTE dst = get_byte(dsta);
594: src &= 7;
595: regs.z = !(dst & (1 << src));
596: dst &= ~(1 << src);
597: put_byte(dsta,dst);
598: }}}}
599: void op_1b9(UWORD opcode)
600: {
601: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
602: {{ BYTE src = regs.d[srcreg];
603: { CPTR dsta = nextilong();
604: BYTE dst = get_byte(dsta);
605: src &= 7;
606: regs.z = !(dst & (1 << src));
607: dst &= ~(1 << src);
608: put_byte(dsta,dst);
609: }}}}
610: void op_1c0(UWORD opcode)
611: {
612: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
613: ULONG dstreg = (opcode & 7) >> 0;
614: {{ LONG src = regs.d[srcreg];
615: { LONG dst = regs.d[dstreg];
616: src &= 31;
617: regs.z = !(dst & (1 << src));
618: dst |= (1 << src);
619: regs.d[dstreg] = (dst);
620: }}}}
621: void op_1d0(UWORD opcode)
622: {
623: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
624: ULONG dstreg = (opcode & 7) >> 0;
625: {{ BYTE src = regs.d[srcreg];
626: { CPTR dsta = regs.a[dstreg];
627: BYTE dst = get_byte(dsta);
628: src &= 7;
629: regs.z = !(dst & (1 << src));
630: dst |= (1 << src);
631: put_byte(dsta,dst);
632: }}}}
633: void op_1d8(UWORD opcode)
634: {
635: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
636: ULONG dstreg = (opcode & 7) >> 0;
637: {{ BYTE src = regs.d[srcreg];
638: { CPTR dsta = regs.a[dstreg];
639: BYTE dst = get_byte(dsta);
640: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
641: src &= 7;
642: regs.z = !(dst & (1 << src));
643: dst |= (1 << src);
644: put_byte(dsta,dst);
645: }}}}}
646: void op_1e0(UWORD opcode)
647: {
648: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
649: ULONG dstreg = (opcode & 7) >> 0;
650: {{ BYTE src = regs.d[srcreg];
651: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
652: { CPTR dsta = regs.a[dstreg];
653: BYTE dst = get_byte(dsta);
654: src &= 7;
655: regs.z = !(dst & (1 << src));
656: dst |= (1 << src);
657: put_byte(dsta,dst);
658: }}}}}
659: void op_1e8(UWORD opcode)
660: {
661: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
662: ULONG dstreg = (opcode & 7) >> 0;
663: {{ BYTE src = regs.d[srcreg];
664: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
665: BYTE dst = get_byte(dsta);
666: src &= 7;
667: regs.z = !(dst & (1 << src));
668: dst |= (1 << src);
669: put_byte(dsta,dst);
670: }}}}
671: void op_1f0(UWORD opcode)
672: {
673: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
674: ULONG dstreg = (opcode & 7) >> 0;
675: {{ BYTE src = regs.d[srcreg];
676: { CPTR dsta = regs.a[dstreg];
677: UWORD dstdp = nextiword();
678: dsta += (LONG)(BYTE)(dstdp & 0xFF);
679: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
680: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
681: dsta += dstdpr;
682: { BYTE dst = get_byte(dsta);
683: src &= 7;
684: regs.z = !(dst & (1 << src));
685: dst |= (1 << src);
686: put_byte(dsta,dst);
687: }}}}}}
688: void op_1f8(UWORD opcode)
689: {
690: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
691: {{ BYTE src = regs.d[srcreg];
692: { CPTR dsta = (LONG)(WORD)nextiword();
693: BYTE dst = get_byte(dsta);
694: src &= 7;
695: regs.z = !(dst & (1 << src));
696: dst |= (1 << src);
697: put_byte(dsta,dst);
698: }}}}
699: void op_1f9(UWORD opcode)
700: {
701: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
702: {{ BYTE src = regs.d[srcreg];
703: { CPTR dsta = nextilong();
704: BYTE dst = get_byte(dsta);
705: src &= 7;
706: regs.z = !(dst & (1 << src));
707: dst |= (1 << src);
708: put_byte(dsta,dst);
709: }}}}
710: void op_200(UWORD opcode)
711: {
712: ULONG dstreg = (opcode & 7) >> 0;
713: {{ BYTE src = nextiword();
714: { BYTE dst = regs.d[dstreg];
715: src &= dst;
716: regs.v = regs.c = 0;
717: regs.z = ((BYTE)(src)) == 0;
718: regs.n = ((BYTE)(src)) < 0;
719: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
720: }}}}
721: void op_210(UWORD opcode)
722: {
723: ULONG dstreg = (opcode & 7) >> 0;
724: {{ BYTE src = nextiword();
725: { CPTR dsta = regs.a[dstreg];
726: BYTE dst = get_byte(dsta);
727: src &= dst;
728: regs.v = regs.c = 0;
729: regs.z = ((BYTE)(src)) == 0;
730: regs.n = ((BYTE)(src)) < 0;
731: put_byte(dsta,src);
732: }}}}
733: void op_218(UWORD opcode)
734: {
735: ULONG dstreg = (opcode & 7) >> 0;
736: {{ BYTE src = nextiword();
737: { CPTR dsta = regs.a[dstreg];
738: BYTE dst = get_byte(dsta);
739: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
740: src &= dst;
741: regs.v = regs.c = 0;
742: regs.z = ((BYTE)(src)) == 0;
743: regs.n = ((BYTE)(src)) < 0;
744: put_byte(dsta,src);
745: }}}}}
746: void op_220(UWORD opcode)
747: {
748: ULONG dstreg = (opcode & 7) >> 0;
749: {{ BYTE src = nextiword();
750: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
751: { CPTR dsta = regs.a[dstreg];
752: BYTE dst = get_byte(dsta);
753: src &= dst;
754: regs.v = regs.c = 0;
755: regs.z = ((BYTE)(src)) == 0;
756: regs.n = ((BYTE)(src)) < 0;
757: put_byte(dsta,src);
758: }}}}}
759: void op_228(UWORD opcode)
760: {
761: ULONG dstreg = (opcode & 7) >> 0;
762: {{ BYTE src = nextiword();
763: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
764: BYTE dst = get_byte(dsta);
765: src &= dst;
766: regs.v = regs.c = 0;
767: regs.z = ((BYTE)(src)) == 0;
768: regs.n = ((BYTE)(src)) < 0;
769: put_byte(dsta,src);
770: }}}}
771: void op_230(UWORD opcode)
772: {
773: ULONG dstreg = (opcode & 7) >> 0;
774: {{ BYTE src = nextiword();
775: { CPTR dsta = regs.a[dstreg];
776: UWORD dstdp = nextiword();
777: dsta += (LONG)(BYTE)(dstdp & 0xFF);
778: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
779: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
780: dsta += dstdpr;
781: { BYTE dst = get_byte(dsta);
782: src &= dst;
783: regs.v = regs.c = 0;
784: regs.z = ((BYTE)(src)) == 0;
785: regs.n = ((BYTE)(src)) < 0;
786: put_byte(dsta,src);
787: }}}}}}
788: void op_238(UWORD opcode)
789: {
790: {{ BYTE src = nextiword();
791: { CPTR dsta = (LONG)(WORD)nextiword();
792: BYTE dst = get_byte(dsta);
793: src &= dst;
794: regs.v = regs.c = 0;
795: regs.z = ((BYTE)(src)) == 0;
796: regs.n = ((BYTE)(src)) < 0;
797: put_byte(dsta,src);
798: }}}}
799: void op_239(UWORD opcode)
800: {
801: {{ BYTE src = nextiword();
802: { CPTR dsta = nextilong();
803: BYTE dst = get_byte(dsta);
804: src &= dst;
805: regs.v = regs.c = 0;
806: regs.z = ((BYTE)(src)) == 0;
807: regs.n = ((BYTE)(src)) < 0;
808: put_byte(dsta,src);
809: }}}}
810: void op_23c(UWORD opcode)
811: {
812: {{ MakeSR();
813: { WORD src = nextiword();
814: src |= 0xFF00;
815: regs.sr &= src;
816: MakeFromSR();
817: }}}}
818: void op_240(UWORD opcode)
819: {
820: ULONG dstreg = (opcode & 7) >> 0;
821: {{ WORD src = nextiword();
822: { WORD dst = regs.d[dstreg];
823: src &= dst;
824: regs.v = regs.c = 0;
825: regs.z = ((WORD)(src)) == 0;
826: regs.n = ((WORD)(src)) < 0;
827: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
828: }}}}
829: void op_250(UWORD opcode)
830: {
831: ULONG dstreg = (opcode & 7) >> 0;
832: {{ WORD src = nextiword();
833: { CPTR dsta = regs.a[dstreg];
834: WORD dst = get_word(dsta);
835: src &= dst;
836: regs.v = regs.c = 0;
837: regs.z = ((WORD)(src)) == 0;
838: regs.n = ((WORD)(src)) < 0;
839: put_word(dsta,src);
840: }}}}
841: void op_258(UWORD opcode)
842: {
843: ULONG dstreg = (opcode & 7) >> 0;
844: {{ WORD src = nextiword();
845: { CPTR dsta = regs.a[dstreg];
846: WORD dst = get_word(dsta);
847: { regs.a[dstreg] += 2;
848: src &= dst;
849: regs.v = regs.c = 0;
850: regs.z = ((WORD)(src)) == 0;
851: regs.n = ((WORD)(src)) < 0;
852: put_word(dsta,src);
853: }}}}}
854: void op_260(UWORD opcode)
855: {
856: ULONG dstreg = (opcode & 7) >> 0;
857: {{ WORD src = nextiword();
858: { regs.a[dstreg] -= 2;
859: { CPTR dsta = regs.a[dstreg];
860: WORD dst = get_word(dsta);
861: src &= dst;
862: regs.v = regs.c = 0;
863: regs.z = ((WORD)(src)) == 0;
864: regs.n = ((WORD)(src)) < 0;
865: put_word(dsta,src);
866: }}}}}
867: void op_268(UWORD opcode)
868: {
869: ULONG dstreg = (opcode & 7) >> 0;
870: {{ WORD src = nextiword();
871: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
872: WORD dst = get_word(dsta);
873: src &= dst;
874: regs.v = regs.c = 0;
875: regs.z = ((WORD)(src)) == 0;
876: regs.n = ((WORD)(src)) < 0;
877: put_word(dsta,src);
878: }}}}
879: void op_270(UWORD opcode)
880: {
881: ULONG dstreg = (opcode & 7) >> 0;
882: {{ WORD src = nextiword();
883: { CPTR dsta = regs.a[dstreg];
884: UWORD dstdp = nextiword();
885: dsta += (LONG)(BYTE)(dstdp & 0xFF);
886: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
887: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
888: dsta += dstdpr;
889: { WORD dst = get_word(dsta);
890: src &= dst;
891: regs.v = regs.c = 0;
892: regs.z = ((WORD)(src)) == 0;
893: regs.n = ((WORD)(src)) < 0;
894: put_word(dsta,src);
895: }}}}}}
896: void op_278(UWORD opcode)
897: {
898: {{ WORD src = nextiword();
899: { CPTR dsta = (LONG)(WORD)nextiword();
900: WORD dst = get_word(dsta);
901: src &= dst;
902: regs.v = regs.c = 0;
903: regs.z = ((WORD)(src)) == 0;
904: regs.n = ((WORD)(src)) < 0;
905: put_word(dsta,src);
906: }}}}
907: void op_279(UWORD opcode)
908: {
909: {{ WORD src = nextiword();
910: { CPTR dsta = nextilong();
911: WORD dst = get_word(dsta);
912: src &= dst;
913: regs.v = regs.c = 0;
914: regs.z = ((WORD)(src)) == 0;
915: regs.n = ((WORD)(src)) < 0;
916: put_word(dsta,src);
917: }}}}
918: void op_27c(UWORD opcode)
919: {
920: { if (!regs.s) { regs.pc_p--; Exception(8); } else
921: { MakeSR();
922: { WORD src = nextiword();
923: regs.sr &= src;
924: MakeFromSR();
925: }}}}
926: void op_280(UWORD opcode)
927: {
928: ULONG dstreg = (opcode & 7) >> 0;
929: {{ LONG src = nextilong();
930: { LONG dst = regs.d[dstreg];
931: src &= dst;
932: regs.v = regs.c = 0;
933: regs.z = ((LONG)(src)) == 0;
934: regs.n = ((LONG)(src)) < 0;
935: regs.d[dstreg] = (src);
936: }}}}
937: void op_290(UWORD opcode)
938: {
939: ULONG dstreg = (opcode & 7) >> 0;
940: {{ LONG src = nextilong();
941: { CPTR dsta = regs.a[dstreg];
942: LONG dst = get_long(dsta);
943: src &= dst;
944: regs.v = regs.c = 0;
945: regs.z = ((LONG)(src)) == 0;
946: regs.n = ((LONG)(src)) < 0;
947: put_long(dsta,src);
948: }}}}
949: void op_298(UWORD opcode)
950: {
951: ULONG dstreg = (opcode & 7) >> 0;
952: {{ LONG src = nextilong();
953: { CPTR dsta = regs.a[dstreg];
954: LONG dst = get_long(dsta);
955: { regs.a[dstreg] += 4;
956: src &= dst;
957: regs.v = regs.c = 0;
958: regs.z = ((LONG)(src)) == 0;
959: regs.n = ((LONG)(src)) < 0;
960: put_long(dsta,src);
961: }}}}}
962: void op_2a0(UWORD opcode)
963: {
964: ULONG dstreg = (opcode & 7) >> 0;
965: {{ LONG src = nextilong();
966: { regs.a[dstreg] -= 4;
967: { CPTR dsta = regs.a[dstreg];
968: LONG dst = get_long(dsta);
969: src &= dst;
970: regs.v = regs.c = 0;
971: regs.z = ((LONG)(src)) == 0;
972: regs.n = ((LONG)(src)) < 0;
973: put_long(dsta,src);
974: }}}}}
975: void op_2a8(UWORD opcode)
976: {
977: ULONG dstreg = (opcode & 7) >> 0;
978: {{ LONG src = nextilong();
979: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
980: LONG dst = get_long(dsta);
981: src &= dst;
982: regs.v = regs.c = 0;
983: regs.z = ((LONG)(src)) == 0;
984: regs.n = ((LONG)(src)) < 0;
985: put_long(dsta,src);
986: }}}}
987: void op_2b0(UWORD opcode)
988: {
989: ULONG dstreg = (opcode & 7) >> 0;
990: {{ LONG src = nextilong();
991: { CPTR dsta = regs.a[dstreg];
992: UWORD dstdp = nextiword();
993: dsta += (LONG)(BYTE)(dstdp & 0xFF);
994: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
995: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
996: dsta += dstdpr;
997: { LONG dst = get_long(dsta);
998: src &= dst;
999: regs.v = regs.c = 0;
1000: regs.z = ((LONG)(src)) == 0;
1001: regs.n = ((LONG)(src)) < 0;
1002: put_long(dsta,src);
1003: }}}}}}
1004: void op_2b8(UWORD opcode)
1005: {
1006: {{ LONG src = nextilong();
1007: { CPTR dsta = (LONG)(WORD)nextiword();
1008: LONG dst = get_long(dsta);
1009: src &= dst;
1010: regs.v = regs.c = 0;
1011: regs.z = ((LONG)(src)) == 0;
1012: regs.n = ((LONG)(src)) < 0;
1013: put_long(dsta,src);
1014: }}}}
1015: void op_2b9(UWORD opcode)
1016: {
1017: {{ LONG src = nextilong();
1018: { CPTR dsta = nextilong();
1019: LONG dst = get_long(dsta);
1020: src &= dst;
1021: regs.v = regs.c = 0;
1022: regs.z = ((LONG)(src)) == 0;
1023: regs.n = ((LONG)(src)) < 0;
1024: put_long(dsta,src);
1025: }}}}
1026: void op_400(UWORD opcode)
1027: {
1028: ULONG dstreg = (opcode & 7) >> 0;
1029: {{ BYTE src = nextiword();
1030: { BYTE dst = regs.d[dstreg];
1031: { ULONG newv = dst - src;
1032: { bool flgs = ((BYTE)(src)) < 0;
1033: bool flgo = ((BYTE)(dst)) < 0;
1034: bool flgn = ((BYTE)(newv)) < 0;
1035: regs.z = ((BYTE)(newv)) == 0;
1036: regs.v = (flgs != flgo) && (flgn != flgo);
1037: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1038: regs.n = flgn != 0;
1039: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
1040: }}}}}}
1041: void op_410(UWORD opcode)
1042: {
1043: ULONG dstreg = (opcode & 7) >> 0;
1044: {{ BYTE src = nextiword();
1045: { CPTR dsta = regs.a[dstreg];
1046: BYTE dst = get_byte(dsta);
1047: { ULONG newv = dst - src;
1048: { bool flgs = ((BYTE)(src)) < 0;
1049: bool flgo = ((BYTE)(dst)) < 0;
1050: bool flgn = ((BYTE)(newv)) < 0;
1051: regs.z = ((BYTE)(newv)) == 0;
1052: regs.v = (flgs != flgo) && (flgn != flgo);
1053: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1054: regs.n = flgn != 0;
1055: put_byte(dsta,newv);
1056: }}}}}}
1057: void op_418(UWORD opcode)
1058: {
1059: ULONG dstreg = (opcode & 7) >> 0;
1060: {{ BYTE src = nextiword();
1061: { CPTR dsta = regs.a[dstreg];
1062: BYTE dst = get_byte(dsta);
1063: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
1064: { ULONG newv = dst - src;
1065: { bool flgs = ((BYTE)(src)) < 0;
1066: bool flgo = ((BYTE)(dst)) < 0;
1067: bool flgn = ((BYTE)(newv)) < 0;
1068: regs.z = ((BYTE)(newv)) == 0;
1069: regs.v = (flgs != flgo) && (flgn != flgo);
1070: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1071: regs.n = flgn != 0;
1072: put_byte(dsta,newv);
1073: }}}}}}}
1074: void op_420(UWORD opcode)
1075: {
1076: ULONG dstreg = (opcode & 7) >> 0;
1077: {{ BYTE src = nextiword();
1078: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
1079: { CPTR dsta = regs.a[dstreg];
1080: BYTE dst = get_byte(dsta);
1081: { ULONG newv = dst - src;
1082: { bool flgs = ((BYTE)(src)) < 0;
1083: bool flgo = ((BYTE)(dst)) < 0;
1084: bool flgn = ((BYTE)(newv)) < 0;
1085: regs.z = ((BYTE)(newv)) == 0;
1086: regs.v = (flgs != flgo) && (flgn != flgo);
1087: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1088: regs.n = flgn != 0;
1089: put_byte(dsta,newv);
1090: }}}}}}}
1091: void op_428(UWORD opcode)
1092: {
1093: ULONG dstreg = (opcode & 7) >> 0;
1094: {{ BYTE src = nextiword();
1095: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1096: BYTE dst = get_byte(dsta);
1097: { ULONG newv = dst - src;
1098: { bool flgs = ((BYTE)(src)) < 0;
1099: bool flgo = ((BYTE)(dst)) < 0;
1100: bool flgn = ((BYTE)(newv)) < 0;
1101: regs.z = ((BYTE)(newv)) == 0;
1102: regs.v = (flgs != flgo) && (flgn != flgo);
1103: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1104: regs.n = flgn != 0;
1105: put_byte(dsta,newv);
1106: }}}}}}
1107: void op_430(UWORD opcode)
1108: {
1109: ULONG dstreg = (opcode & 7) >> 0;
1110: {{ BYTE src = nextiword();
1111: { CPTR dsta = regs.a[dstreg];
1112: UWORD dstdp = nextiword();
1113: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1114: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1115: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1116: dsta += dstdpr;
1117: { BYTE dst = get_byte(dsta);
1118: { ULONG newv = dst - src;
1119: { bool flgs = ((BYTE)(src)) < 0;
1120: bool flgo = ((BYTE)(dst)) < 0;
1121: bool flgn = ((BYTE)(newv)) < 0;
1122: regs.z = ((BYTE)(newv)) == 0;
1123: regs.v = (flgs != flgo) && (flgn != flgo);
1124: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1125: regs.n = flgn != 0;
1126: put_byte(dsta,newv);
1127: }}}}}}}}
1128: void op_438(UWORD opcode)
1129: {
1130: {{ BYTE src = nextiword();
1131: { CPTR dsta = (LONG)(WORD)nextiword();
1132: BYTE dst = get_byte(dsta);
1133: { ULONG newv = dst - src;
1134: { bool flgs = ((BYTE)(src)) < 0;
1135: bool flgo = ((BYTE)(dst)) < 0;
1136: bool flgn = ((BYTE)(newv)) < 0;
1137: regs.z = ((BYTE)(newv)) == 0;
1138: regs.v = (flgs != flgo) && (flgn != flgo);
1139: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1140: regs.n = flgn != 0;
1141: put_byte(dsta,newv);
1142: }}}}}}
1143: void op_439(UWORD opcode)
1144: {
1145: {{ BYTE src = nextiword();
1146: { CPTR dsta = nextilong();
1147: BYTE dst = get_byte(dsta);
1148: { ULONG newv = dst - src;
1149: { bool flgs = ((BYTE)(src)) < 0;
1150: bool flgo = ((BYTE)(dst)) < 0;
1151: bool flgn = ((BYTE)(newv)) < 0;
1152: regs.z = ((BYTE)(newv)) == 0;
1153: regs.v = (flgs != flgo) && (flgn != flgo);
1154: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1155: regs.n = flgn != 0;
1156: put_byte(dsta,newv);
1157: }}}}}}
1158: void op_440(UWORD opcode)
1159: {
1160: ULONG dstreg = (opcode & 7) >> 0;
1161: {{ WORD src = nextiword();
1162: { WORD dst = regs.d[dstreg];
1163: { ULONG newv = dst - src;
1164: { bool flgs = ((WORD)(src)) < 0;
1165: bool flgo = ((WORD)(dst)) < 0;
1166: bool flgn = ((WORD)(newv)) < 0;
1167: regs.z = ((WORD)(newv)) == 0;
1168: regs.v = (flgs != flgo) && (flgn != flgo);
1169: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1170: regs.n = flgn != 0;
1171: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
1172: }}}}}}
1173: void op_450(UWORD opcode)
1174: {
1175: ULONG dstreg = (opcode & 7) >> 0;
1176: {{ WORD src = nextiword();
1177: { CPTR dsta = regs.a[dstreg];
1178: WORD dst = get_word(dsta);
1179: { ULONG newv = dst - src;
1180: { bool flgs = ((WORD)(src)) < 0;
1181: bool flgo = ((WORD)(dst)) < 0;
1182: bool flgn = ((WORD)(newv)) < 0;
1183: regs.z = ((WORD)(newv)) == 0;
1184: regs.v = (flgs != flgo) && (flgn != flgo);
1185: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1186: regs.n = flgn != 0;
1187: put_word(dsta,newv);
1188: }}}}}}
1189: void op_458(UWORD opcode)
1190: {
1191: ULONG dstreg = (opcode & 7) >> 0;
1192: {{ WORD src = nextiword();
1193: { CPTR dsta = regs.a[dstreg];
1194: WORD dst = get_word(dsta);
1195: { regs.a[dstreg] += 2;
1196: { ULONG newv = dst - src;
1197: { bool flgs = ((WORD)(src)) < 0;
1198: bool flgo = ((WORD)(dst)) < 0;
1199: bool flgn = ((WORD)(newv)) < 0;
1200: regs.z = ((WORD)(newv)) == 0;
1201: regs.v = (flgs != flgo) && (flgn != flgo);
1202: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1203: regs.n = flgn != 0;
1204: put_word(dsta,newv);
1205: }}}}}}}
1206: void op_460(UWORD opcode)
1207: {
1208: ULONG dstreg = (opcode & 7) >> 0;
1209: {{ WORD src = nextiword();
1210: { regs.a[dstreg] -= 2;
1211: { CPTR dsta = regs.a[dstreg];
1212: WORD dst = get_word(dsta);
1213: { ULONG newv = dst - src;
1214: { bool flgs = ((WORD)(src)) < 0;
1215: bool flgo = ((WORD)(dst)) < 0;
1216: bool flgn = ((WORD)(newv)) < 0;
1217: regs.z = ((WORD)(newv)) == 0;
1218: regs.v = (flgs != flgo) && (flgn != flgo);
1219: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1220: regs.n = flgn != 0;
1221: put_word(dsta,newv);
1222: }}}}}}}
1223: void op_468(UWORD opcode)
1224: {
1225: ULONG dstreg = (opcode & 7) >> 0;
1226: {{ WORD src = nextiword();
1227: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1228: WORD dst = get_word(dsta);
1229: { ULONG newv = dst - src;
1230: { bool flgs = ((WORD)(src)) < 0;
1231: bool flgo = ((WORD)(dst)) < 0;
1232: bool flgn = ((WORD)(newv)) < 0;
1233: regs.z = ((WORD)(newv)) == 0;
1234: regs.v = (flgs != flgo) && (flgn != flgo);
1235: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1236: regs.n = flgn != 0;
1237: put_word(dsta,newv);
1238: }}}}}}
1239: void op_470(UWORD opcode)
1240: {
1241: ULONG dstreg = (opcode & 7) >> 0;
1242: {{ WORD src = nextiword();
1243: { CPTR dsta = regs.a[dstreg];
1244: UWORD dstdp = nextiword();
1245: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1246: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1247: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1248: dsta += dstdpr;
1249: { WORD dst = get_word(dsta);
1250: { ULONG newv = dst - src;
1251: { bool flgs = ((WORD)(src)) < 0;
1252: bool flgo = ((WORD)(dst)) < 0;
1253: bool flgn = ((WORD)(newv)) < 0;
1254: regs.z = ((WORD)(newv)) == 0;
1255: regs.v = (flgs != flgo) && (flgn != flgo);
1256: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1257: regs.n = flgn != 0;
1258: put_word(dsta,newv);
1259: }}}}}}}}
1260: void op_478(UWORD opcode)
1261: {
1262: {{ WORD src = nextiword();
1263: { CPTR dsta = (LONG)(WORD)nextiword();
1264: WORD dst = get_word(dsta);
1265: { ULONG newv = dst - src;
1266: { bool flgs = ((WORD)(src)) < 0;
1267: bool flgo = ((WORD)(dst)) < 0;
1268: bool flgn = ((WORD)(newv)) < 0;
1269: regs.z = ((WORD)(newv)) == 0;
1270: regs.v = (flgs != flgo) && (flgn != flgo);
1271: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1272: regs.n = flgn != 0;
1273: put_word(dsta,newv);
1274: }}}}}}
1275: void op_479(UWORD opcode)
1276: {
1277: {{ WORD src = nextiword();
1278: { CPTR dsta = nextilong();
1279: WORD dst = get_word(dsta);
1280: { ULONG newv = dst - src;
1281: { bool flgs = ((WORD)(src)) < 0;
1282: bool flgo = ((WORD)(dst)) < 0;
1283: bool flgn = ((WORD)(newv)) < 0;
1284: regs.z = ((WORD)(newv)) == 0;
1285: regs.v = (flgs != flgo) && (flgn != flgo);
1286: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1287: regs.n = flgn != 0;
1288: put_word(dsta,newv);
1289: }}}}}}
1290: void op_480(UWORD opcode)
1291: {
1292: ULONG dstreg = (opcode & 7) >> 0;
1293: {{ LONG src = nextilong();
1294: { LONG dst = regs.d[dstreg];
1295: { ULONG newv = dst - src;
1296: { bool flgs = ((LONG)(src)) < 0;
1297: bool flgo = ((LONG)(dst)) < 0;
1298: bool flgn = ((LONG)(newv)) < 0;
1299: regs.z = ((LONG)(newv)) == 0;
1300: regs.v = (flgs != flgo) && (flgn != flgo);
1301: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1302: regs.n = flgn != 0;
1303: regs.d[dstreg] = (newv);
1304: }}}}}}
1305: void op_490(UWORD opcode)
1306: {
1307: ULONG dstreg = (opcode & 7) >> 0;
1308: {{ LONG src = nextilong();
1309: { CPTR dsta = regs.a[dstreg];
1310: LONG dst = get_long(dsta);
1311: { ULONG newv = dst - src;
1312: { bool flgs = ((LONG)(src)) < 0;
1313: bool flgo = ((LONG)(dst)) < 0;
1314: bool flgn = ((LONG)(newv)) < 0;
1315: regs.z = ((LONG)(newv)) == 0;
1316: regs.v = (flgs != flgo) && (flgn != flgo);
1317: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1318: regs.n = flgn != 0;
1319: put_long(dsta,newv);
1320: }}}}}}
1321: void op_498(UWORD opcode)
1322: {
1323: ULONG dstreg = (opcode & 7) >> 0;
1324: {{ LONG src = nextilong();
1325: { CPTR dsta = regs.a[dstreg];
1326: LONG dst = get_long(dsta);
1327: { regs.a[dstreg] += 4;
1328: { ULONG newv = dst - src;
1329: { bool flgs = ((LONG)(src)) < 0;
1330: bool flgo = ((LONG)(dst)) < 0;
1331: bool flgn = ((LONG)(newv)) < 0;
1332: regs.z = ((LONG)(newv)) == 0;
1333: regs.v = (flgs != flgo) && (flgn != flgo);
1334: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1335: regs.n = flgn != 0;
1336: put_long(dsta,newv);
1337: }}}}}}}
1338: void op_4a0(UWORD opcode)
1339: {
1340: ULONG dstreg = (opcode & 7) >> 0;
1341: {{ LONG src = nextilong();
1342: { regs.a[dstreg] -= 4;
1343: { CPTR dsta = regs.a[dstreg];
1344: LONG dst = get_long(dsta);
1345: { ULONG newv = dst - src;
1346: { bool flgs = ((LONG)(src)) < 0;
1347: bool flgo = ((LONG)(dst)) < 0;
1348: bool flgn = ((LONG)(newv)) < 0;
1349: regs.z = ((LONG)(newv)) == 0;
1350: regs.v = (flgs != flgo) && (flgn != flgo);
1351: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1352: regs.n = flgn != 0;
1353: put_long(dsta,newv);
1354: }}}}}}}
1355: void op_4a8(UWORD opcode)
1356: {
1357: ULONG dstreg = (opcode & 7) >> 0;
1358: {{ LONG src = nextilong();
1359: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1360: LONG dst = get_long(dsta);
1361: { ULONG newv = dst - src;
1362: { bool flgs = ((LONG)(src)) < 0;
1363: bool flgo = ((LONG)(dst)) < 0;
1364: bool flgn = ((LONG)(newv)) < 0;
1365: regs.z = ((LONG)(newv)) == 0;
1366: regs.v = (flgs != flgo) && (flgn != flgo);
1367: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1368: regs.n = flgn != 0;
1369: put_long(dsta,newv);
1370: }}}}}}
1371: void op_4b0(UWORD opcode)
1372: {
1373: ULONG dstreg = (opcode & 7) >> 0;
1374: {{ LONG src = nextilong();
1375: { CPTR dsta = regs.a[dstreg];
1376: UWORD dstdp = nextiword();
1377: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1378: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1379: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1380: dsta += dstdpr;
1381: { LONG dst = get_long(dsta);
1382: { ULONG newv = dst - src;
1383: { bool flgs = ((LONG)(src)) < 0;
1384: bool flgo = ((LONG)(dst)) < 0;
1385: bool flgn = ((LONG)(newv)) < 0;
1386: regs.z = ((LONG)(newv)) == 0;
1387: regs.v = (flgs != flgo) && (flgn != flgo);
1388: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1389: regs.n = flgn != 0;
1390: put_long(dsta,newv);
1391: }}}}}}}}
1392: void op_4b8(UWORD opcode)
1393: {
1394: {{ LONG src = nextilong();
1395: { CPTR dsta = (LONG)(WORD)nextiword();
1396: LONG dst = get_long(dsta);
1397: { ULONG newv = dst - src;
1398: { bool flgs = ((LONG)(src)) < 0;
1399: bool flgo = ((LONG)(dst)) < 0;
1400: bool flgn = ((LONG)(newv)) < 0;
1401: regs.z = ((LONG)(newv)) == 0;
1402: regs.v = (flgs != flgo) && (flgn != flgo);
1403: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1404: regs.n = flgn != 0;
1405: put_long(dsta,newv);
1406: }}}}}}
1407: void op_4b9(UWORD opcode)
1408: {
1409: {{ LONG src = nextilong();
1410: { CPTR dsta = nextilong();
1411: LONG dst = get_long(dsta);
1412: { ULONG newv = dst - src;
1413: { bool flgs = ((LONG)(src)) < 0;
1414: bool flgo = ((LONG)(dst)) < 0;
1415: bool flgn = ((LONG)(newv)) < 0;
1416: regs.z = ((LONG)(newv)) == 0;
1417: regs.v = (flgs != flgo) && (flgn != flgo);
1418: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1419: regs.n = flgn != 0;
1420: put_long(dsta,newv);
1421: }}}}}}
1422: void op_600(UWORD opcode)
1423: {
1424: ULONG dstreg = (opcode & 7) >> 0;
1425: {{ BYTE src = nextiword();
1426: { BYTE dst = regs.d[dstreg];
1427: { ULONG newv = dst + src;
1428: { bool flgs = ((BYTE)(src)) < 0;
1429: bool flgo = ((BYTE)(dst)) < 0;
1430: bool flgn = ((BYTE)(newv)) < 0;
1431: regs.z = ((BYTE)(newv)) == 0;
1432: regs.v = (flgs == flgo) && (flgn != flgo);
1433: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1434: regs.n = flgn != 0;
1435: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
1436: }}}}}}
1437: void op_610(UWORD opcode)
1438: {
1439: ULONG dstreg = (opcode & 7) >> 0;
1440: {{ BYTE src = nextiword();
1441: { CPTR dsta = regs.a[dstreg];
1442: BYTE dst = get_byte(dsta);
1443: { ULONG newv = dst + src;
1444: { bool flgs = ((BYTE)(src)) < 0;
1445: bool flgo = ((BYTE)(dst)) < 0;
1446: bool flgn = ((BYTE)(newv)) < 0;
1447: regs.z = ((BYTE)(newv)) == 0;
1448: regs.v = (flgs == flgo) && (flgn != flgo);
1449: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1450: regs.n = flgn != 0;
1451: put_byte(dsta,newv);
1452: }}}}}}
1453: void op_618(UWORD opcode)
1454: {
1455: ULONG dstreg = (opcode & 7) >> 0;
1456: {{ BYTE src = nextiword();
1457: { CPTR dsta = regs.a[dstreg];
1458: BYTE dst = get_byte(dsta);
1459: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
1460: { ULONG newv = dst + src;
1461: { bool flgs = ((BYTE)(src)) < 0;
1462: bool flgo = ((BYTE)(dst)) < 0;
1463: bool flgn = ((BYTE)(newv)) < 0;
1464: regs.z = ((BYTE)(newv)) == 0;
1465: regs.v = (flgs == flgo) && (flgn != flgo);
1466: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1467: regs.n = flgn != 0;
1468: put_byte(dsta,newv);
1469: }}}}}}}
1470: void op_620(UWORD opcode)
1471: {
1472: ULONG dstreg = (opcode & 7) >> 0;
1473: {{ BYTE src = nextiword();
1474: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
1475: { CPTR dsta = regs.a[dstreg];
1476: BYTE dst = get_byte(dsta);
1477: { ULONG newv = dst + src;
1478: { bool flgs = ((BYTE)(src)) < 0;
1479: bool flgo = ((BYTE)(dst)) < 0;
1480: bool flgn = ((BYTE)(newv)) < 0;
1481: regs.z = ((BYTE)(newv)) == 0;
1482: regs.v = (flgs == flgo) && (flgn != flgo);
1483: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1484: regs.n = flgn != 0;
1485: put_byte(dsta,newv);
1486: }}}}}}}
1487: void op_628(UWORD opcode)
1488: {
1489: ULONG dstreg = (opcode & 7) >> 0;
1490: {{ BYTE src = nextiword();
1491: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1492: BYTE dst = get_byte(dsta);
1493: { ULONG newv = dst + src;
1494: { bool flgs = ((BYTE)(src)) < 0;
1495: bool flgo = ((BYTE)(dst)) < 0;
1496: bool flgn = ((BYTE)(newv)) < 0;
1497: regs.z = ((BYTE)(newv)) == 0;
1498: regs.v = (flgs == flgo) && (flgn != flgo);
1499: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1500: regs.n = flgn != 0;
1501: put_byte(dsta,newv);
1502: }}}}}}
1503: void op_630(UWORD opcode)
1504: {
1505: ULONG dstreg = (opcode & 7) >> 0;
1506: {{ BYTE src = nextiword();
1507: { CPTR dsta = regs.a[dstreg];
1508: UWORD dstdp = nextiword();
1509: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1510: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1511: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1512: dsta += dstdpr;
1513: { BYTE dst = get_byte(dsta);
1514: { ULONG newv = dst + src;
1515: { bool flgs = ((BYTE)(src)) < 0;
1516: bool flgo = ((BYTE)(dst)) < 0;
1517: bool flgn = ((BYTE)(newv)) < 0;
1518: regs.z = ((BYTE)(newv)) == 0;
1519: regs.v = (flgs == flgo) && (flgn != flgo);
1520: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1521: regs.n = flgn != 0;
1522: put_byte(dsta,newv);
1523: }}}}}}}}
1524: void op_638(UWORD opcode)
1525: {
1526: {{ BYTE src = nextiword();
1527: { CPTR dsta = (LONG)(WORD)nextiword();
1528: BYTE dst = get_byte(dsta);
1529: { ULONG newv = dst + src;
1530: { bool flgs = ((BYTE)(src)) < 0;
1531: bool flgo = ((BYTE)(dst)) < 0;
1532: bool flgn = ((BYTE)(newv)) < 0;
1533: regs.z = ((BYTE)(newv)) == 0;
1534: regs.v = (flgs == flgo) && (flgn != flgo);
1535: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1536: regs.n = flgn != 0;
1537: put_byte(dsta,newv);
1538: }}}}}}
1539: void op_639(UWORD opcode)
1540: {
1541: {{ BYTE src = nextiword();
1542: { CPTR dsta = nextilong();
1543: BYTE dst = get_byte(dsta);
1544: { ULONG newv = dst + src;
1545: { bool flgs = ((BYTE)(src)) < 0;
1546: bool flgo = ((BYTE)(dst)) < 0;
1547: bool flgn = ((BYTE)(newv)) < 0;
1548: regs.z = ((BYTE)(newv)) == 0;
1549: regs.v = (flgs == flgo) && (flgn != flgo);
1550: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1551: regs.n = flgn != 0;
1552: put_byte(dsta,newv);
1553: }}}}}}
1554: void op_640(UWORD opcode)
1555: {
1556: ULONG dstreg = (opcode & 7) >> 0;
1557: {{ WORD src = nextiword();
1558: { WORD dst = regs.d[dstreg];
1559: { ULONG newv = dst + src;
1560: { bool flgs = ((WORD)(src)) < 0;
1561: bool flgo = ((WORD)(dst)) < 0;
1562: bool flgn = ((WORD)(newv)) < 0;
1563: regs.z = ((WORD)(newv)) == 0;
1564: regs.v = (flgs == flgo) && (flgn != flgo);
1565: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1566: regs.n = flgn != 0;
1567: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
1568: }}}}}}
1569: void op_650(UWORD opcode)
1570: {
1571: ULONG dstreg = (opcode & 7) >> 0;
1572: {{ WORD src = nextiword();
1573: { CPTR dsta = regs.a[dstreg];
1574: WORD dst = get_word(dsta);
1575: { ULONG newv = dst + src;
1576: { bool flgs = ((WORD)(src)) < 0;
1577: bool flgo = ((WORD)(dst)) < 0;
1578: bool flgn = ((WORD)(newv)) < 0;
1579: regs.z = ((WORD)(newv)) == 0;
1580: regs.v = (flgs == flgo) && (flgn != flgo);
1581: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1582: regs.n = flgn != 0;
1583: put_word(dsta,newv);
1584: }}}}}}
1585: void op_658(UWORD opcode)
1586: {
1587: ULONG dstreg = (opcode & 7) >> 0;
1588: {{ WORD src = nextiword();
1589: { CPTR dsta = regs.a[dstreg];
1590: WORD dst = get_word(dsta);
1591: { regs.a[dstreg] += 2;
1592: { ULONG newv = dst + src;
1593: { bool flgs = ((WORD)(src)) < 0;
1594: bool flgo = ((WORD)(dst)) < 0;
1595: bool flgn = ((WORD)(newv)) < 0;
1596: regs.z = ((WORD)(newv)) == 0;
1597: regs.v = (flgs == flgo) && (flgn != flgo);
1598: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1599: regs.n = flgn != 0;
1600: put_word(dsta,newv);
1601: }}}}}}}
1602: void op_660(UWORD opcode)
1603: {
1604: ULONG dstreg = (opcode & 7) >> 0;
1605: {{ WORD src = nextiword();
1606: { regs.a[dstreg] -= 2;
1607: { CPTR dsta = regs.a[dstreg];
1608: WORD dst = get_word(dsta);
1609: { ULONG newv = dst + src;
1610: { bool flgs = ((WORD)(src)) < 0;
1611: bool flgo = ((WORD)(dst)) < 0;
1612: bool flgn = ((WORD)(newv)) < 0;
1613: regs.z = ((WORD)(newv)) == 0;
1614: regs.v = (flgs == flgo) && (flgn != flgo);
1615: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1616: regs.n = flgn != 0;
1617: put_word(dsta,newv);
1618: }}}}}}}
1619: void op_668(UWORD opcode)
1620: {
1621: ULONG dstreg = (opcode & 7) >> 0;
1622: {{ WORD src = nextiword();
1623: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1624: WORD dst = get_word(dsta);
1625: { ULONG newv = dst + src;
1626: { bool flgs = ((WORD)(src)) < 0;
1627: bool flgo = ((WORD)(dst)) < 0;
1628: bool flgn = ((WORD)(newv)) < 0;
1629: regs.z = ((WORD)(newv)) == 0;
1630: regs.v = (flgs == flgo) && (flgn != flgo);
1631: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1632: regs.n = flgn != 0;
1633: put_word(dsta,newv);
1634: }}}}}}
1635: void op_670(UWORD opcode)
1636: {
1637: ULONG dstreg = (opcode & 7) >> 0;
1638: {{ WORD src = nextiword();
1639: { CPTR dsta = regs.a[dstreg];
1640: UWORD dstdp = nextiword();
1641: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1642: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1643: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1644: dsta += dstdpr;
1645: { WORD dst = get_word(dsta);
1646: { ULONG newv = dst + src;
1647: { bool flgs = ((WORD)(src)) < 0;
1648: bool flgo = ((WORD)(dst)) < 0;
1649: bool flgn = ((WORD)(newv)) < 0;
1650: regs.z = ((WORD)(newv)) == 0;
1651: regs.v = (flgs == flgo) && (flgn != flgo);
1652: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1653: regs.n = flgn != 0;
1654: put_word(dsta,newv);
1655: }}}}}}}}
1656: void op_678(UWORD opcode)
1657: {
1658: {{ WORD src = nextiword();
1659: { CPTR dsta = (LONG)(WORD)nextiword();
1660: WORD dst = get_word(dsta);
1661: { ULONG newv = dst + src;
1662: { bool flgs = ((WORD)(src)) < 0;
1663: bool flgo = ((WORD)(dst)) < 0;
1664: bool flgn = ((WORD)(newv)) < 0;
1665: regs.z = ((WORD)(newv)) == 0;
1666: regs.v = (flgs == flgo) && (flgn != flgo);
1667: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1668: regs.n = flgn != 0;
1669: put_word(dsta,newv);
1670: }}}}}}
1671: void op_679(UWORD opcode)
1672: {
1673: {{ WORD src = nextiword();
1674: { CPTR dsta = nextilong();
1675: WORD dst = get_word(dsta);
1676: { ULONG newv = dst + src;
1677: { bool flgs = ((WORD)(src)) < 0;
1678: bool flgo = ((WORD)(dst)) < 0;
1679: bool flgn = ((WORD)(newv)) < 0;
1680: regs.z = ((WORD)(newv)) == 0;
1681: regs.v = (flgs == flgo) && (flgn != flgo);
1682: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1683: regs.n = flgn != 0;
1684: put_word(dsta,newv);
1685: }}}}}}
1686: void op_680(UWORD opcode)
1687: {
1688: ULONG dstreg = (opcode & 7) >> 0;
1689: {{ LONG src = nextilong();
1690: { LONG dst = regs.d[dstreg];
1691: { ULONG newv = dst + src;
1692: { bool flgs = ((LONG)(src)) < 0;
1693: bool flgo = ((LONG)(dst)) < 0;
1694: bool flgn = ((LONG)(newv)) < 0;
1695: regs.z = ((LONG)(newv)) == 0;
1696: regs.v = (flgs == flgo) && (flgn != flgo);
1697: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1698: regs.n = flgn != 0;
1699: regs.d[dstreg] = (newv);
1700: }}}}}}
1701: void op_690(UWORD opcode)
1702: {
1703: ULONG dstreg = (opcode & 7) >> 0;
1704: {{ LONG src = nextilong();
1705: { CPTR dsta = regs.a[dstreg];
1706: LONG dst = get_long(dsta);
1707: { ULONG newv = dst + src;
1708: { bool flgs = ((LONG)(src)) < 0;
1709: bool flgo = ((LONG)(dst)) < 0;
1710: bool flgn = ((LONG)(newv)) < 0;
1711: regs.z = ((LONG)(newv)) == 0;
1712: regs.v = (flgs == flgo) && (flgn != flgo);
1713: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1714: regs.n = flgn != 0;
1715: put_long(dsta,newv);
1716: }}}}}}
1717: void op_698(UWORD opcode)
1718: {
1719: ULONG dstreg = (opcode & 7) >> 0;
1720: {{ LONG src = nextilong();
1721: { CPTR dsta = regs.a[dstreg];
1722: LONG dst = get_long(dsta);
1723: { regs.a[dstreg] += 4;
1724: { ULONG newv = dst + src;
1725: { bool flgs = ((LONG)(src)) < 0;
1726: bool flgo = ((LONG)(dst)) < 0;
1727: bool flgn = ((LONG)(newv)) < 0;
1728: regs.z = ((LONG)(newv)) == 0;
1729: regs.v = (flgs == flgo) && (flgn != flgo);
1730: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1731: regs.n = flgn != 0;
1732: put_long(dsta,newv);
1733: }}}}}}}
1734: void op_6a0(UWORD opcode)
1735: {
1736: ULONG dstreg = (opcode & 7) >> 0;
1737: {{ LONG src = nextilong();
1738: { regs.a[dstreg] -= 4;
1739: { CPTR dsta = regs.a[dstreg];
1740: LONG dst = get_long(dsta);
1741: { ULONG newv = dst + src;
1742: { bool flgs = ((LONG)(src)) < 0;
1743: bool flgo = ((LONG)(dst)) < 0;
1744: bool flgn = ((LONG)(newv)) < 0;
1745: regs.z = ((LONG)(newv)) == 0;
1746: regs.v = (flgs == flgo) && (flgn != flgo);
1747: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1748: regs.n = flgn != 0;
1749: put_long(dsta,newv);
1750: }}}}}}}
1751: void op_6a8(UWORD opcode)
1752: {
1753: ULONG dstreg = (opcode & 7) >> 0;
1754: {{ LONG src = nextilong();
1755: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1756: LONG dst = get_long(dsta);
1757: { ULONG newv = dst + src;
1758: { bool flgs = ((LONG)(src)) < 0;
1759: bool flgo = ((LONG)(dst)) < 0;
1760: bool flgn = ((LONG)(newv)) < 0;
1761: regs.z = ((LONG)(newv)) == 0;
1762: regs.v = (flgs == flgo) && (flgn != flgo);
1763: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1764: regs.n = flgn != 0;
1765: put_long(dsta,newv);
1766: }}}}}}
1767: void op_6b0(UWORD opcode)
1768: {
1769: ULONG dstreg = (opcode & 7) >> 0;
1770: {{ LONG src = nextilong();
1771: { CPTR dsta = regs.a[dstreg];
1772: UWORD dstdp = nextiword();
1773: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1774: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1775: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1776: dsta += dstdpr;
1777: { LONG dst = get_long(dsta);
1778: { ULONG newv = dst + src;
1779: { bool flgs = ((LONG)(src)) < 0;
1780: bool flgo = ((LONG)(dst)) < 0;
1781: bool flgn = ((LONG)(newv)) < 0;
1782: regs.z = ((LONG)(newv)) == 0;
1783: regs.v = (flgs == flgo) && (flgn != flgo);
1784: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1785: regs.n = flgn != 0;
1786: put_long(dsta,newv);
1787: }}}}}}}}
1788: void op_6b8(UWORD opcode)
1789: {
1790: {{ LONG src = nextilong();
1791: { CPTR dsta = (LONG)(WORD)nextiword();
1792: LONG dst = get_long(dsta);
1793: { ULONG newv = dst + src;
1794: { bool flgs = ((LONG)(src)) < 0;
1795: bool flgo = ((LONG)(dst)) < 0;
1796: bool flgn = ((LONG)(newv)) < 0;
1797: regs.z = ((LONG)(newv)) == 0;
1798: regs.v = (flgs == flgo) && (flgn != flgo);
1799: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1800: regs.n = flgn != 0;
1801: put_long(dsta,newv);
1802: }}}}}}
1803: void op_6b9(UWORD opcode)
1804: {
1805: {{ LONG src = nextilong();
1806: { CPTR dsta = nextilong();
1807: LONG dst = get_long(dsta);
1808: { ULONG newv = dst + src;
1809: { bool flgs = ((LONG)(src)) < 0;
1810: bool flgo = ((LONG)(dst)) < 0;
1811: bool flgn = ((LONG)(newv)) < 0;
1812: regs.z = ((LONG)(newv)) == 0;
1813: regs.v = (flgs == flgo) && (flgn != flgo);
1814: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1815: regs.n = flgn != 0;
1816: put_long(dsta,newv);
1817: }}}}}}
1818: void op_800(UWORD opcode)
1819: {
1820: ULONG dstreg = (opcode & 7) >> 0;
1821: {{ WORD src = nextiword();
1822: { LONG dst = regs.d[dstreg];
1823: src &= 31;
1824: regs.z = !(dst & (1 << src));
1825: }}}}
1826: void op_810(UWORD opcode)
1827: {
1828: ULONG dstreg = (opcode & 7) >> 0;
1829: {{ WORD src = nextiword();
1830: { CPTR dsta = regs.a[dstreg];
1831: BYTE dst = get_byte(dsta);
1832: src &= 7;
1833: regs.z = !(dst & (1 << src));
1834: }}}}
1835: void op_818(UWORD opcode)
1836: {
1837: ULONG dstreg = (opcode & 7) >> 0;
1838: {{ WORD src = nextiword();
1839: { CPTR dsta = regs.a[dstreg];
1840: BYTE dst = get_byte(dsta);
1841: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
1842: src &= 7;
1843: regs.z = !(dst & (1 << src));
1844: }}}}}
1845: void op_820(UWORD opcode)
1846: {
1847: ULONG dstreg = (opcode & 7) >> 0;
1848: {{ WORD src = nextiword();
1849: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
1850: { CPTR dsta = regs.a[dstreg];
1851: BYTE dst = get_byte(dsta);
1852: src &= 7;
1853: regs.z = !(dst & (1 << src));
1854: }}}}}
1855: void op_828(UWORD opcode)
1856: {
1857: ULONG dstreg = (opcode & 7) >> 0;
1858: {{ WORD src = nextiword();
1859: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1860: BYTE dst = get_byte(dsta);
1861: src &= 7;
1862: regs.z = !(dst & (1 << src));
1863: }}}}
1864: void op_830(UWORD opcode)
1865: {
1866: ULONG dstreg = (opcode & 7) >> 0;
1867: {{ WORD src = nextiword();
1868: { CPTR dsta = regs.a[dstreg];
1869: UWORD dstdp = nextiword();
1870: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1871: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1872: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1873: dsta += dstdpr;
1874: { BYTE dst = get_byte(dsta);
1875: src &= 7;
1876: regs.z = !(dst & (1 << src));
1877: }}}}}}
1878: void op_838(UWORD opcode)
1879: {
1880: {{ WORD src = nextiword();
1881: { CPTR dsta = (LONG)(WORD)nextiword();
1882: BYTE dst = get_byte(dsta);
1883: src &= 7;
1884: regs.z = !(dst & (1 << src));
1885: }}}}
1886: void op_839(UWORD opcode)
1887: {
1888: {{ WORD src = nextiword();
1889: { CPTR dsta = nextilong();
1890: BYTE dst = get_byte(dsta);
1891: src &= 7;
1892: regs.z = !(dst & (1 << src));
1893: }}}}
1894: void op_83a(UWORD opcode)
1895: {
1896: ULONG dstreg = 2;
1897: {{ WORD src = nextiword();
1898: { CPTR dsta = m68k_getpc();
1899: dsta += (LONG)(WORD)nextiword();
1900: { BYTE dst = get_byte(dsta);
1901: src &= 7;
1902: regs.z = !(dst & (1 << src));
1903: }}}}}
1904: void op_83b(UWORD opcode)
1905: {
1906: ULONG dstreg = 3;
1907: {{ WORD src = nextiword();
1908: { CPTR dsta = m68k_getpc();
1909: UWORD dstdp = nextiword();
1910: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1911: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1912: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1913: dsta += dstdpr;
1914: { BYTE dst = get_byte(dsta);
1915: src &= 7;
1916: regs.z = !(dst & (1 << src));
1917: }}}}}}
1918: void op_840(UWORD opcode)
1919: {
1920: ULONG dstreg = (opcode & 7) >> 0;
1921: {{ WORD src = nextiword();
1922: { LONG dst = regs.d[dstreg];
1923: src &= 31;
1924: regs.z = !(dst & (1 << src));
1925: dst ^= (1 << src);
1926: regs.d[dstreg] = (dst);
1927: }}}}
1928: void op_850(UWORD opcode)
1929: {
1930: ULONG dstreg = (opcode & 7) >> 0;
1931: {{ WORD src = nextiword();
1932: { CPTR dsta = regs.a[dstreg];
1933: BYTE dst = get_byte(dsta);
1934: src &= 7;
1935: regs.z = !(dst & (1 << src));
1936: dst ^= (1 << src);
1937: put_byte(dsta,dst);
1938: }}}}
1939: void op_858(UWORD opcode)
1940: {
1941: ULONG dstreg = (opcode & 7) >> 0;
1942: {{ WORD src = nextiword();
1943: { CPTR dsta = regs.a[dstreg];
1944: BYTE dst = get_byte(dsta);
1945: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
1946: src &= 7;
1947: regs.z = !(dst & (1 << src));
1948: dst ^= (1 << src);
1949: put_byte(dsta,dst);
1950: }}}}}
1951: void op_860(UWORD opcode)
1952: {
1953: ULONG dstreg = (opcode & 7) >> 0;
1954: {{ WORD src = nextiword();
1955: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
1956: { CPTR dsta = regs.a[dstreg];
1957: BYTE dst = get_byte(dsta);
1958: src &= 7;
1959: regs.z = !(dst & (1 << src));
1960: dst ^= (1 << src);
1961: put_byte(dsta,dst);
1962: }}}}}
1963: void op_868(UWORD opcode)
1964: {
1965: ULONG dstreg = (opcode & 7) >> 0;
1966: {{ WORD src = nextiword();
1967: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1968: BYTE dst = get_byte(dsta);
1969: src &= 7;
1970: regs.z = !(dst & (1 << src));
1971: dst ^= (1 << src);
1972: put_byte(dsta,dst);
1973: }}}}
1974: void op_870(UWORD opcode)
1975: {
1976: ULONG dstreg = (opcode & 7) >> 0;
1977: {{ WORD src = nextiword();
1978: { CPTR dsta = regs.a[dstreg];
1979: UWORD dstdp = nextiword();
1980: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1981: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1982: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1983: dsta += dstdpr;
1984: { BYTE dst = get_byte(dsta);
1985: src &= 7;
1986: regs.z = !(dst & (1 << src));
1987: dst ^= (1 << src);
1988: put_byte(dsta,dst);
1989: }}}}}}
1990: void op_878(UWORD opcode)
1991: {
1992: {{ WORD src = nextiword();
1993: { CPTR dsta = (LONG)(WORD)nextiword();
1994: BYTE dst = get_byte(dsta);
1995: src &= 7;
1996: regs.z = !(dst & (1 << src));
1997: dst ^= (1 << src);
1998: put_byte(dsta,dst);
1999: }}}}
2000: void op_879(UWORD opcode)
2001: {
2002: {{ WORD src = nextiword();
2003: { CPTR dsta = nextilong();
2004: BYTE dst = get_byte(dsta);
2005: src &= 7;
2006: regs.z = !(dst & (1 << src));
2007: dst ^= (1 << src);
2008: put_byte(dsta,dst);
2009: }}}}
2010: void op_87a(UWORD opcode)
2011: {
2012: ULONG dstreg = 2;
2013: {{ WORD src = nextiword();
2014: { CPTR dsta = m68k_getpc();
2015: dsta += (LONG)(WORD)nextiword();
2016: { BYTE dst = get_byte(dsta);
2017: src &= 7;
2018: regs.z = !(dst & (1 << src));
2019: dst ^= (1 << src);
2020: put_byte(dsta,dst);
2021: }}}}}
2022: void op_87b(UWORD opcode)
2023: {
2024: ULONG dstreg = 3;
2025: {{ WORD src = nextiword();
2026: { CPTR dsta = m68k_getpc();
2027: UWORD dstdp = nextiword();
2028: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2029: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2030: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2031: dsta += dstdpr;
2032: { BYTE dst = get_byte(dsta);
2033: src &= 7;
2034: regs.z = !(dst & (1 << src));
2035: dst ^= (1 << src);
2036: put_byte(dsta,dst);
2037: }}}}}}
2038: void op_880(UWORD opcode)
2039: {
2040: ULONG dstreg = (opcode & 7) >> 0;
2041: {{ WORD src = nextiword();
2042: { LONG dst = regs.d[dstreg];
2043: src &= 31;
2044: regs.z = !(dst & (1 << src));
2045: dst &= ~(1 << src);
2046: regs.d[dstreg] = (dst);
2047: }}}}
2048: void op_890(UWORD opcode)
2049: {
2050: ULONG dstreg = (opcode & 7) >> 0;
2051: {{ WORD src = nextiword();
2052: { CPTR dsta = regs.a[dstreg];
2053: BYTE dst = get_byte(dsta);
2054: src &= 7;
2055: regs.z = !(dst & (1 << src));
2056: dst &= ~(1 << src);
2057: put_byte(dsta,dst);
2058: }}}}
2059: void op_898(UWORD opcode)
2060: {
2061: ULONG dstreg = (opcode & 7) >> 0;
2062: {{ WORD src = nextiword();
2063: { CPTR dsta = regs.a[dstreg];
2064: BYTE dst = get_byte(dsta);
2065: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
2066: src &= 7;
2067: regs.z = !(dst & (1 << src));
2068: dst &= ~(1 << src);
2069: put_byte(dsta,dst);
2070: }}}}}
2071: void op_8a0(UWORD opcode)
2072: {
2073: ULONG dstreg = (opcode & 7) >> 0;
2074: {{ WORD src = nextiword();
2075: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
2076: { CPTR dsta = regs.a[dstreg];
2077: BYTE dst = get_byte(dsta);
2078: src &= 7;
2079: regs.z = !(dst & (1 << src));
2080: dst &= ~(1 << src);
2081: put_byte(dsta,dst);
2082: }}}}}
2083: void op_8a8(UWORD opcode)
2084: {
2085: ULONG dstreg = (opcode & 7) >> 0;
2086: {{ WORD src = nextiword();
2087: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2088: BYTE dst = get_byte(dsta);
2089: src &= 7;
2090: regs.z = !(dst & (1 << src));
2091: dst &= ~(1 << src);
2092: put_byte(dsta,dst);
2093: }}}}
2094: void op_8b0(UWORD opcode)
2095: {
2096: ULONG dstreg = (opcode & 7) >> 0;
2097: {{ WORD src = nextiword();
2098: { CPTR dsta = regs.a[dstreg];
2099: UWORD dstdp = nextiword();
2100: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2101: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2102: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2103: dsta += dstdpr;
2104: { BYTE dst = get_byte(dsta);
2105: src &= 7;
2106: regs.z = !(dst & (1 << src));
2107: dst &= ~(1 << src);
2108: put_byte(dsta,dst);
2109: }}}}}}
2110: void op_8b8(UWORD opcode)
2111: {
2112: {{ WORD src = nextiword();
2113: { CPTR dsta = (LONG)(WORD)nextiword();
2114: BYTE dst = get_byte(dsta);
2115: src &= 7;
2116: regs.z = !(dst & (1 << src));
2117: dst &= ~(1 << src);
2118: put_byte(dsta,dst);
2119: }}}}
2120: void op_8b9(UWORD opcode)
2121: {
2122: {{ WORD src = nextiword();
2123: { CPTR dsta = nextilong();
2124: BYTE dst = get_byte(dsta);
2125: src &= 7;
2126: regs.z = !(dst & (1 << src));
2127: dst &= ~(1 << src);
2128: put_byte(dsta,dst);
2129: }}}}
2130: void op_8ba(UWORD opcode)
2131: {
2132: ULONG dstreg = 2;
2133: {{ WORD src = nextiword();
2134: { CPTR dsta = m68k_getpc();
2135: dsta += (LONG)(WORD)nextiword();
2136: { BYTE dst = get_byte(dsta);
2137: src &= 7;
2138: regs.z = !(dst & (1 << src));
2139: dst &= ~(1 << src);
2140: put_byte(dsta,dst);
2141: }}}}}
2142: void op_8bb(UWORD opcode)
2143: {
2144: ULONG dstreg = 3;
2145: {{ WORD src = nextiword();
2146: { CPTR dsta = m68k_getpc();
2147: UWORD dstdp = nextiword();
2148: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2149: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2150: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2151: dsta += dstdpr;
2152: { BYTE dst = get_byte(dsta);
2153: src &= 7;
2154: regs.z = !(dst & (1 << src));
2155: dst &= ~(1 << src);
2156: put_byte(dsta,dst);
2157: }}}}}}
2158: void op_8c0(UWORD opcode)
2159: {
2160: ULONG dstreg = (opcode & 7) >> 0;
2161: {{ WORD src = nextiword();
2162: { LONG dst = regs.d[dstreg];
2163: src &= 31;
2164: regs.z = !(dst & (1 << src));
2165: dst |= (1 << src);
2166: regs.d[dstreg] = (dst);
2167: }}}}
2168: void op_8d0(UWORD opcode)
2169: {
2170: ULONG dstreg = (opcode & 7) >> 0;
2171: {{ WORD src = nextiword();
2172: { CPTR dsta = regs.a[dstreg];
2173: BYTE dst = get_byte(dsta);
2174: src &= 7;
2175: regs.z = !(dst & (1 << src));
2176: dst |= (1 << src);
2177: put_byte(dsta,dst);
2178: }}}}
2179: void op_8d8(UWORD opcode)
2180: {
2181: ULONG dstreg = (opcode & 7) >> 0;
2182: {{ WORD src = nextiword();
2183: { CPTR dsta = regs.a[dstreg];
2184: BYTE dst = get_byte(dsta);
2185: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
2186: src &= 7;
2187: regs.z = !(dst & (1 << src));
2188: dst |= (1 << src);
2189: put_byte(dsta,dst);
2190: }}}}}
2191: void op_8e0(UWORD opcode)
2192: {
2193: ULONG dstreg = (opcode & 7) >> 0;
2194: {{ WORD src = nextiword();
2195: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
2196: { CPTR dsta = regs.a[dstreg];
2197: BYTE dst = get_byte(dsta);
2198: src &= 7;
2199: regs.z = !(dst & (1 << src));
2200: dst |= (1 << src);
2201: put_byte(dsta,dst);
2202: }}}}}
2203: void op_8e8(UWORD opcode)
2204: {
2205: ULONG dstreg = (opcode & 7) >> 0;
2206: {{ WORD src = nextiword();
2207: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2208: BYTE dst = get_byte(dsta);
2209: src &= 7;
2210: regs.z = !(dst & (1 << src));
2211: dst |= (1 << src);
2212: put_byte(dsta,dst);
2213: }}}}
2214: void op_8f0(UWORD opcode)
2215: {
2216: ULONG dstreg = (opcode & 7) >> 0;
2217: {{ WORD src = nextiword();
2218: { CPTR dsta = regs.a[dstreg];
2219: UWORD dstdp = nextiword();
2220: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2221: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2222: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2223: dsta += dstdpr;
2224: { BYTE dst = get_byte(dsta);
2225: src &= 7;
2226: regs.z = !(dst & (1 << src));
2227: dst |= (1 << src);
2228: put_byte(dsta,dst);
2229: }}}}}}
2230: void op_8f8(UWORD opcode)
2231: {
2232: {{ WORD src = nextiword();
2233: { CPTR dsta = (LONG)(WORD)nextiword();
2234: BYTE dst = get_byte(dsta);
2235: src &= 7;
2236: regs.z = !(dst & (1 << src));
2237: dst |= (1 << src);
2238: put_byte(dsta,dst);
2239: }}}}
2240: void op_8f9(UWORD opcode)
2241: {
2242: {{ WORD src = nextiword();
2243: { CPTR dsta = nextilong();
2244: BYTE dst = get_byte(dsta);
2245: src &= 7;
2246: regs.z = !(dst & (1 << src));
2247: dst |= (1 << src);
2248: put_byte(dsta,dst);
2249: }}}}
2250: void op_8fa(UWORD opcode)
2251: {
2252: ULONG dstreg = 2;
2253: {{ WORD src = nextiword();
2254: { CPTR dsta = m68k_getpc();
2255: dsta += (LONG)(WORD)nextiword();
2256: { BYTE dst = get_byte(dsta);
2257: src &= 7;
2258: regs.z = !(dst & (1 << src));
2259: dst |= (1 << src);
2260: put_byte(dsta,dst);
2261: }}}}}
2262: void op_8fb(UWORD opcode)
2263: {
2264: ULONG dstreg = 3;
2265: {{ WORD src = nextiword();
2266: { CPTR dsta = m68k_getpc();
2267: UWORD dstdp = nextiword();
2268: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2269: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2270: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2271: dsta += dstdpr;
2272: { BYTE dst = get_byte(dsta);
2273: src &= 7;
2274: regs.z = !(dst & (1 << src));
2275: dst |= (1 << src);
2276: put_byte(dsta,dst);
2277: }}}}}}
2278: void op_a00(UWORD opcode)
2279: {
2280: ULONG dstreg = (opcode & 7) >> 0;
2281: {{ BYTE src = nextiword();
2282: { BYTE dst = regs.d[dstreg];
2283: src ^= dst;
2284: regs.v = regs.c = 0;
2285: regs.z = ((BYTE)(src)) == 0;
2286: regs.n = ((BYTE)(src)) < 0;
2287: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (src) & 0xff;
2288: }}}}
2289: void op_a10(UWORD opcode)
2290: {
2291: ULONG dstreg = (opcode & 7) >> 0;
2292: {{ BYTE src = nextiword();
2293: { CPTR dsta = regs.a[dstreg];
2294: BYTE dst = get_byte(dsta);
2295: src ^= dst;
2296: regs.v = regs.c = 0;
2297: regs.z = ((BYTE)(src)) == 0;
2298: regs.n = ((BYTE)(src)) < 0;
2299: put_byte(dsta,src);
2300: }}}}
2301: void op_a18(UWORD opcode)
2302: {
2303: ULONG dstreg = (opcode & 7) >> 0;
2304: {{ BYTE src = nextiword();
2305: { CPTR dsta = regs.a[dstreg];
2306: BYTE dst = get_byte(dsta);
2307: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
2308: src ^= dst;
2309: regs.v = regs.c = 0;
2310: regs.z = ((BYTE)(src)) == 0;
2311: regs.n = ((BYTE)(src)) < 0;
2312: put_byte(dsta,src);
2313: }}}}}
2314: void op_a20(UWORD opcode)
2315: {
2316: ULONG dstreg = (opcode & 7) >> 0;
2317: {{ BYTE src = nextiword();
2318: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
2319: { CPTR dsta = regs.a[dstreg];
2320: BYTE dst = get_byte(dsta);
2321: src ^= dst;
2322: regs.v = regs.c = 0;
2323: regs.z = ((BYTE)(src)) == 0;
2324: regs.n = ((BYTE)(src)) < 0;
2325: put_byte(dsta,src);
2326: }}}}}
2327: void op_a28(UWORD opcode)
2328: {
2329: ULONG dstreg = (opcode & 7) >> 0;
2330: {{ BYTE src = nextiword();
2331: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2332: BYTE dst = get_byte(dsta);
2333: src ^= dst;
2334: regs.v = regs.c = 0;
2335: regs.z = ((BYTE)(src)) == 0;
2336: regs.n = ((BYTE)(src)) < 0;
2337: put_byte(dsta,src);
2338: }}}}
2339: void op_a30(UWORD opcode)
2340: {
2341: ULONG dstreg = (opcode & 7) >> 0;
2342: {{ BYTE src = nextiword();
2343: { CPTR dsta = regs.a[dstreg];
2344: UWORD dstdp = nextiword();
2345: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2346: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2347: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2348: dsta += dstdpr;
2349: { BYTE dst = get_byte(dsta);
2350: src ^= dst;
2351: regs.v = regs.c = 0;
2352: regs.z = ((BYTE)(src)) == 0;
2353: regs.n = ((BYTE)(src)) < 0;
2354: put_byte(dsta,src);
2355: }}}}}}
2356: void op_a38(UWORD opcode)
2357: {
2358: {{ BYTE src = nextiword();
2359: { CPTR dsta = (LONG)(WORD)nextiword();
2360: BYTE dst = get_byte(dsta);
2361: src ^= dst;
2362: regs.v = regs.c = 0;
2363: regs.z = ((BYTE)(src)) == 0;
2364: regs.n = ((BYTE)(src)) < 0;
2365: put_byte(dsta,src);
2366: }}}}
2367: void op_a39(UWORD opcode)
2368: {
2369: {{ BYTE src = nextiword();
2370: { CPTR dsta = nextilong();
2371: BYTE dst = get_byte(dsta);
2372: src ^= dst;
2373: regs.v = regs.c = 0;
2374: regs.z = ((BYTE)(src)) == 0;
2375: regs.n = ((BYTE)(src)) < 0;
2376: put_byte(dsta,src);
2377: }}}}
2378: void op_a3c(UWORD opcode)
2379: {
2380: {{ MakeSR();
2381: { WORD src = nextiword();
2382: src &= 0xFF;
2383: regs.sr ^= src;
2384: MakeFromSR();
2385: }}}}
2386: void op_a40(UWORD opcode)
2387: {
2388: ULONG dstreg = (opcode & 7) >> 0;
2389: {{ WORD src = nextiword();
2390: { WORD dst = regs.d[dstreg];
2391: src ^= dst;
2392: regs.v = regs.c = 0;
2393: regs.z = ((WORD)(src)) == 0;
2394: regs.n = ((WORD)(src)) < 0;
2395: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
2396: }}}}
2397: void op_a50(UWORD opcode)
2398: {
2399: ULONG dstreg = (opcode & 7) >> 0;
2400: {{ WORD src = nextiword();
2401: { CPTR dsta = regs.a[dstreg];
2402: WORD dst = get_word(dsta);
2403: src ^= dst;
2404: regs.v = regs.c = 0;
2405: regs.z = ((WORD)(src)) == 0;
2406: regs.n = ((WORD)(src)) < 0;
2407: put_word(dsta,src);
2408: }}}}
2409: void op_a58(UWORD opcode)
2410: {
2411: ULONG dstreg = (opcode & 7) >> 0;
2412: {{ WORD src = nextiword();
2413: { CPTR dsta = regs.a[dstreg];
2414: WORD dst = get_word(dsta);
2415: { regs.a[dstreg] += 2;
2416: src ^= dst;
2417: regs.v = regs.c = 0;
2418: regs.z = ((WORD)(src)) == 0;
2419: regs.n = ((WORD)(src)) < 0;
2420: put_word(dsta,src);
2421: }}}}}
2422: void op_a60(UWORD opcode)
2423: {
2424: ULONG dstreg = (opcode & 7) >> 0;
2425: {{ WORD src = nextiword();
2426: { regs.a[dstreg] -= 2;
2427: { CPTR dsta = regs.a[dstreg];
2428: WORD dst = get_word(dsta);
2429: src ^= dst;
2430: regs.v = regs.c = 0;
2431: regs.z = ((WORD)(src)) == 0;
2432: regs.n = ((WORD)(src)) < 0;
2433: put_word(dsta,src);
2434: }}}}}
2435: void op_a68(UWORD opcode)
2436: {
2437: ULONG dstreg = (opcode & 7) >> 0;
2438: {{ WORD src = nextiword();
2439: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2440: WORD dst = get_word(dsta);
2441: src ^= dst;
2442: regs.v = regs.c = 0;
2443: regs.z = ((WORD)(src)) == 0;
2444: regs.n = ((WORD)(src)) < 0;
2445: put_word(dsta,src);
2446: }}}}
2447: void op_a70(UWORD opcode)
2448: {
2449: ULONG dstreg = (opcode & 7) >> 0;
2450: {{ WORD src = nextiword();
2451: { CPTR dsta = regs.a[dstreg];
2452: UWORD dstdp = nextiword();
2453: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2454: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2455: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2456: dsta += dstdpr;
2457: { WORD dst = get_word(dsta);
2458: src ^= dst;
2459: regs.v = regs.c = 0;
2460: regs.z = ((WORD)(src)) == 0;
2461: regs.n = ((WORD)(src)) < 0;
2462: put_word(dsta,src);
2463: }}}}}}
2464: void op_a78(UWORD opcode)
2465: {
2466: {{ WORD src = nextiword();
2467: { CPTR dsta = (LONG)(WORD)nextiword();
2468: WORD dst = get_word(dsta);
2469: src ^= dst;
2470: regs.v = regs.c = 0;
2471: regs.z = ((WORD)(src)) == 0;
2472: regs.n = ((WORD)(src)) < 0;
2473: put_word(dsta,src);
2474: }}}}
2475: void op_a79(UWORD opcode)
2476: {
2477: {{ WORD src = nextiword();
2478: { CPTR dsta = nextilong();
2479: WORD dst = get_word(dsta);
2480: src ^= dst;
2481: regs.v = regs.c = 0;
2482: regs.z = ((WORD)(src)) == 0;
2483: regs.n = ((WORD)(src)) < 0;
2484: put_word(dsta,src);
2485: }}}}
2486: void op_a7c(UWORD opcode)
2487: {
2488: { if (!regs.s) { regs.pc_p--; Exception(8); } else
2489: { MakeSR();
2490: { WORD src = nextiword();
2491: regs.sr ^= src;
2492: MakeFromSR();
2493: }}}}
2494: void op_a80(UWORD opcode)
2495: {
2496: ULONG dstreg = (opcode & 7) >> 0;
2497: {{ LONG src = nextilong();
2498: { LONG dst = regs.d[dstreg];
2499: src ^= dst;
2500: regs.v = regs.c = 0;
2501: regs.z = ((LONG)(src)) == 0;
2502: regs.n = ((LONG)(src)) < 0;
2503: regs.d[dstreg] = (src);
2504: }}}}
2505: void op_a90(UWORD opcode)
2506: {
2507: ULONG dstreg = (opcode & 7) >> 0;
2508: {{ LONG src = nextilong();
2509: { CPTR dsta = regs.a[dstreg];
2510: LONG dst = get_long(dsta);
2511: src ^= dst;
2512: regs.v = regs.c = 0;
2513: regs.z = ((LONG)(src)) == 0;
2514: regs.n = ((LONG)(src)) < 0;
2515: put_long(dsta,src);
2516: }}}}
2517: void op_a98(UWORD opcode)
2518: {
2519: ULONG dstreg = (opcode & 7) >> 0;
2520: {{ LONG src = nextilong();
2521: { CPTR dsta = regs.a[dstreg];
2522: LONG dst = get_long(dsta);
2523: { regs.a[dstreg] += 4;
2524: src ^= dst;
2525: regs.v = regs.c = 0;
2526: regs.z = ((LONG)(src)) == 0;
2527: regs.n = ((LONG)(src)) < 0;
2528: put_long(dsta,src);
2529: }}}}}
2530: void op_aa0(UWORD opcode)
2531: {
2532: ULONG dstreg = (opcode & 7) >> 0;
2533: {{ LONG src = nextilong();
2534: { regs.a[dstreg] -= 4;
2535: { CPTR dsta = regs.a[dstreg];
2536: LONG dst = get_long(dsta);
2537: src ^= dst;
2538: regs.v = regs.c = 0;
2539: regs.z = ((LONG)(src)) == 0;
2540: regs.n = ((LONG)(src)) < 0;
2541: put_long(dsta,src);
2542: }}}}}
2543: void op_aa8(UWORD opcode)
2544: {
2545: ULONG dstreg = (opcode & 7) >> 0;
2546: {{ LONG src = nextilong();
2547: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2548: LONG dst = get_long(dsta);
2549: src ^= dst;
2550: regs.v = regs.c = 0;
2551: regs.z = ((LONG)(src)) == 0;
2552: regs.n = ((LONG)(src)) < 0;
2553: put_long(dsta,src);
2554: }}}}
2555: void op_ab0(UWORD opcode)
2556: {
2557: ULONG dstreg = (opcode & 7) >> 0;
2558: {{ LONG src = nextilong();
2559: { CPTR dsta = regs.a[dstreg];
2560: UWORD dstdp = nextiword();
2561: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2562: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2563: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2564: dsta += dstdpr;
2565: { LONG dst = get_long(dsta);
2566: src ^= dst;
2567: regs.v = regs.c = 0;
2568: regs.z = ((LONG)(src)) == 0;
2569: regs.n = ((LONG)(src)) < 0;
2570: put_long(dsta,src);
2571: }}}}}}
2572: void op_ab8(UWORD opcode)
2573: {
2574: {{ LONG src = nextilong();
2575: { CPTR dsta = (LONG)(WORD)nextiword();
2576: LONG dst = get_long(dsta);
2577: src ^= dst;
2578: regs.v = regs.c = 0;
2579: regs.z = ((LONG)(src)) == 0;
2580: regs.n = ((LONG)(src)) < 0;
2581: put_long(dsta,src);
2582: }}}}
2583: void op_ab9(UWORD opcode)
2584: {
2585: {{ LONG src = nextilong();
2586: { CPTR dsta = nextilong();
2587: LONG dst = get_long(dsta);
2588: src ^= dst;
2589: regs.v = regs.c = 0;
2590: regs.z = ((LONG)(src)) == 0;
2591: regs.n = ((LONG)(src)) < 0;
2592: put_long(dsta,src);
2593: }}}}
2594: void op_c00(UWORD opcode)
2595: {
2596: ULONG dstreg = (opcode & 7) >> 0;
2597: {{ BYTE src = nextiword();
2598: { BYTE dst = regs.d[dstreg];
2599: { ULONG newv = dst - src;
2600: { bool flgs = ((BYTE)(src)) < 0;
2601: bool flgo = ((BYTE)(dst)) < 0;
2602: bool flgn = ((BYTE)(newv)) < 0;
2603: regs.z = ((BYTE)(newv)) == 0;
2604: regs.v = (flgs != flgo) && (flgn != flgo);
2605: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2606: regs.n = flgn != 0;
2607: }}}}}}
2608: void op_c10(UWORD opcode)
2609: {
2610: ULONG dstreg = (opcode & 7) >> 0;
2611: {{ BYTE src = nextiword();
2612: { CPTR dsta = regs.a[dstreg];
2613: BYTE dst = get_byte(dsta);
2614: { ULONG newv = dst - src;
2615: { bool flgs = ((BYTE)(src)) < 0;
2616: bool flgo = ((BYTE)(dst)) < 0;
2617: bool flgn = ((BYTE)(newv)) < 0;
2618: regs.z = ((BYTE)(newv)) == 0;
2619: regs.v = (flgs != flgo) && (flgn != flgo);
2620: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2621: regs.n = flgn != 0;
2622: }}}}}}
2623: void op_c18(UWORD opcode)
2624: {
2625: ULONG dstreg = (opcode & 7) >> 0;
2626: {{ BYTE src = nextiword();
2627: { CPTR dsta = regs.a[dstreg];
2628: BYTE dst = get_byte(dsta);
2629: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
2630: { ULONG newv = dst - src;
2631: { bool flgs = ((BYTE)(src)) < 0;
2632: bool flgo = ((BYTE)(dst)) < 0;
2633: bool flgn = ((BYTE)(newv)) < 0;
2634: regs.z = ((BYTE)(newv)) == 0;
2635: regs.v = (flgs != flgo) && (flgn != flgo);
2636: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2637: regs.n = flgn != 0;
2638: }}}}}}}
2639: void op_c20(UWORD opcode)
2640: {
2641: ULONG dstreg = (opcode & 7) >> 0;
2642: {{ BYTE src = nextiword();
2643: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
2644: { CPTR dsta = regs.a[dstreg];
2645: BYTE dst = get_byte(dsta);
2646: { ULONG newv = dst - src;
2647: { bool flgs = ((BYTE)(src)) < 0;
2648: bool flgo = ((BYTE)(dst)) < 0;
2649: bool flgn = ((BYTE)(newv)) < 0;
2650: regs.z = ((BYTE)(newv)) == 0;
2651: regs.v = (flgs != flgo) && (flgn != flgo);
2652: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2653: regs.n = flgn != 0;
2654: }}}}}}}
2655: void op_c28(UWORD opcode)
2656: {
2657: ULONG dstreg = (opcode & 7) >> 0;
2658: {{ BYTE src = nextiword();
2659: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2660: BYTE dst = get_byte(dsta);
2661: { ULONG newv = dst - src;
2662: { bool flgs = ((BYTE)(src)) < 0;
2663: bool flgo = ((BYTE)(dst)) < 0;
2664: bool flgn = ((BYTE)(newv)) < 0;
2665: regs.z = ((BYTE)(newv)) == 0;
2666: regs.v = (flgs != flgo) && (flgn != flgo);
2667: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2668: regs.n = flgn != 0;
2669: }}}}}}
2670: void op_c30(UWORD opcode)
2671: {
2672: ULONG dstreg = (opcode & 7) >> 0;
2673: {{ BYTE src = nextiword();
2674: { CPTR dsta = regs.a[dstreg];
2675: UWORD dstdp = nextiword();
2676: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2677: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2678: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2679: dsta += dstdpr;
2680: { BYTE dst = get_byte(dsta);
2681: { ULONG newv = dst - src;
2682: { bool flgs = ((BYTE)(src)) < 0;
2683: bool flgo = ((BYTE)(dst)) < 0;
2684: bool flgn = ((BYTE)(newv)) < 0;
2685: regs.z = ((BYTE)(newv)) == 0;
2686: regs.v = (flgs != flgo) && (flgn != flgo);
2687: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2688: regs.n = flgn != 0;
2689: }}}}}}}}
2690: void op_c38(UWORD opcode)
2691: {
2692: {{ BYTE src = nextiword();
2693: { CPTR dsta = (LONG)(WORD)nextiword();
2694: BYTE dst = get_byte(dsta);
2695: { ULONG newv = dst - src;
2696: { bool flgs = ((BYTE)(src)) < 0;
2697: bool flgo = ((BYTE)(dst)) < 0;
2698: bool flgn = ((BYTE)(newv)) < 0;
2699: regs.z = ((BYTE)(newv)) == 0;
2700: regs.v = (flgs != flgo) && (flgn != flgo);
2701: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2702: regs.n = flgn != 0;
2703: }}}}}}
2704: void op_c39(UWORD opcode)
2705: {
2706: {{ BYTE src = nextiword();
2707: { CPTR dsta = nextilong();
2708: BYTE dst = get_byte(dsta);
2709: { ULONG newv = dst - src;
2710: { bool flgs = ((BYTE)(src)) < 0;
2711: bool flgo = ((BYTE)(dst)) < 0;
2712: bool flgn = ((BYTE)(newv)) < 0;
2713: regs.z = ((BYTE)(newv)) == 0;
2714: regs.v = (flgs != flgo) && (flgn != flgo);
2715: regs.c = ((UBYTE)(src)) > ((UBYTE)(dst));
2716: regs.n = flgn != 0;
2717: }}}}}}
2718: void op_c40(UWORD opcode)
2719: {
2720: ULONG dstreg = (opcode & 7) >> 0;
2721: {{ WORD src = nextiword();
2722: { WORD dst = regs.d[dstreg];
2723: { ULONG newv = dst - src;
2724: { bool flgs = ((WORD)(src)) < 0;
2725: bool flgo = ((WORD)(dst)) < 0;
2726: bool flgn = ((WORD)(newv)) < 0;
2727: regs.z = ((WORD)(newv)) == 0;
2728: regs.v = (flgs != flgo) && (flgn != flgo);
2729: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2730: regs.n = flgn != 0;
2731: }}}}}}
2732: void op_c50(UWORD opcode)
2733: {
2734: ULONG dstreg = (opcode & 7) >> 0;
2735: {{ WORD src = nextiword();
2736: { CPTR dsta = regs.a[dstreg];
2737: WORD dst = get_word(dsta);
2738: { ULONG newv = dst - src;
2739: { bool flgs = ((WORD)(src)) < 0;
2740: bool flgo = ((WORD)(dst)) < 0;
2741: bool flgn = ((WORD)(newv)) < 0;
2742: regs.z = ((WORD)(newv)) == 0;
2743: regs.v = (flgs != flgo) && (flgn != flgo);
2744: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2745: regs.n = flgn != 0;
2746: }}}}}}
2747: void op_c58(UWORD opcode)
2748: {
2749: ULONG dstreg = (opcode & 7) >> 0;
2750: {{ WORD src = nextiword();
2751: { CPTR dsta = regs.a[dstreg];
2752: WORD dst = get_word(dsta);
2753: { regs.a[dstreg] += 2;
2754: { ULONG newv = dst - src;
2755: { bool flgs = ((WORD)(src)) < 0;
2756: bool flgo = ((WORD)(dst)) < 0;
2757: bool flgn = ((WORD)(newv)) < 0;
2758: regs.z = ((WORD)(newv)) == 0;
2759: regs.v = (flgs != flgo) && (flgn != flgo);
2760: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2761: regs.n = flgn != 0;
2762: }}}}}}}
2763: void op_c60(UWORD opcode)
2764: {
2765: ULONG dstreg = (opcode & 7) >> 0;
2766: {{ WORD src = nextiword();
2767: { regs.a[dstreg] -= 2;
2768: { CPTR dsta = regs.a[dstreg];
2769: WORD dst = get_word(dsta);
2770: { ULONG newv = dst - src;
2771: { bool flgs = ((WORD)(src)) < 0;
2772: bool flgo = ((WORD)(dst)) < 0;
2773: bool flgn = ((WORD)(newv)) < 0;
2774: regs.z = ((WORD)(newv)) == 0;
2775: regs.v = (flgs != flgo) && (flgn != flgo);
2776: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2777: regs.n = flgn != 0;
2778: }}}}}}}
2779: void op_c68(UWORD opcode)
2780: {
2781: ULONG dstreg = (opcode & 7) >> 0;
2782: {{ WORD src = nextiword();
2783: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2784: WORD dst = get_word(dsta);
2785: { ULONG newv = dst - src;
2786: { bool flgs = ((WORD)(src)) < 0;
2787: bool flgo = ((WORD)(dst)) < 0;
2788: bool flgn = ((WORD)(newv)) < 0;
2789: regs.z = ((WORD)(newv)) == 0;
2790: regs.v = (flgs != flgo) && (flgn != flgo);
2791: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2792: regs.n = flgn != 0;
2793: }}}}}}
2794: void op_c70(UWORD opcode)
2795: {
2796: ULONG dstreg = (opcode & 7) >> 0;
2797: {{ WORD src = nextiword();
2798: { CPTR dsta = regs.a[dstreg];
2799: UWORD dstdp = nextiword();
2800: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2801: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2802: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2803: dsta += dstdpr;
2804: { WORD dst = get_word(dsta);
2805: { ULONG newv = dst - src;
2806: { bool flgs = ((WORD)(src)) < 0;
2807: bool flgo = ((WORD)(dst)) < 0;
2808: bool flgn = ((WORD)(newv)) < 0;
2809: regs.z = ((WORD)(newv)) == 0;
2810: regs.v = (flgs != flgo) && (flgn != flgo);
2811: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2812: regs.n = flgn != 0;
2813: }}}}}}}}
2814: void op_c78(UWORD opcode)
2815: {
2816: {{ WORD src = nextiword();
2817: { CPTR dsta = (LONG)(WORD)nextiword();
2818: WORD dst = get_word(dsta);
2819: { ULONG newv = dst - src;
2820: { bool flgs = ((WORD)(src)) < 0;
2821: bool flgo = ((WORD)(dst)) < 0;
2822: bool flgn = ((WORD)(newv)) < 0;
2823: regs.z = ((WORD)(newv)) == 0;
2824: regs.v = (flgs != flgo) && (flgn != flgo);
2825: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2826: regs.n = flgn != 0;
2827: }}}}}}
2828: void op_c79(UWORD opcode)
2829: {
2830: {{ WORD src = nextiword();
2831: { CPTR dsta = nextilong();
2832: WORD dst = get_word(dsta);
2833: { ULONG newv = dst - src;
2834: { bool flgs = ((WORD)(src)) < 0;
2835: bool flgo = ((WORD)(dst)) < 0;
2836: bool flgn = ((WORD)(newv)) < 0;
2837: regs.z = ((WORD)(newv)) == 0;
2838: regs.v = (flgs != flgo) && (flgn != flgo);
2839: regs.c = ((UWORD)(src)) > ((UWORD)(dst));
2840: regs.n = flgn != 0;
2841: }}}}}}
2842: void op_c80(UWORD opcode)
2843: {
2844: ULONG dstreg = (opcode & 7) >> 0;
2845: {{ LONG src = nextilong();
2846: { LONG dst = regs.d[dstreg];
2847: { ULONG newv = dst - src;
2848: { bool flgs = ((LONG)(src)) < 0;
2849: bool flgo = ((LONG)(dst)) < 0;
2850: bool flgn = ((LONG)(newv)) < 0;
2851: regs.z = ((LONG)(newv)) == 0;
2852: regs.v = (flgs != flgo) && (flgn != flgo);
2853: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2854: regs.n = flgn != 0;
2855: }}}}}}
2856: void op_c90(UWORD opcode)
2857: {
2858: ULONG dstreg = (opcode & 7) >> 0;
2859: {{ LONG src = nextilong();
2860: { CPTR dsta = regs.a[dstreg];
2861: LONG dst = get_long(dsta);
2862: { ULONG newv = dst - src;
2863: { bool flgs = ((LONG)(src)) < 0;
2864: bool flgo = ((LONG)(dst)) < 0;
2865: bool flgn = ((LONG)(newv)) < 0;
2866: regs.z = ((LONG)(newv)) == 0;
2867: regs.v = (flgs != flgo) && (flgn != flgo);
2868: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2869: regs.n = flgn != 0;
2870: }}}}}}
2871: void op_c98(UWORD opcode)
2872: {
2873: ULONG dstreg = (opcode & 7) >> 0;
2874: {{ LONG src = nextilong();
2875: { CPTR dsta = regs.a[dstreg];
2876: LONG dst = get_long(dsta);
2877: { regs.a[dstreg] += 4;
2878: { ULONG newv = dst - src;
2879: { bool flgs = ((LONG)(src)) < 0;
2880: bool flgo = ((LONG)(dst)) < 0;
2881: bool flgn = ((LONG)(newv)) < 0;
2882: regs.z = ((LONG)(newv)) == 0;
2883: regs.v = (flgs != flgo) && (flgn != flgo);
2884: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2885: regs.n = flgn != 0;
2886: }}}}}}}
2887: void op_ca0(UWORD opcode)
2888: {
2889: ULONG dstreg = (opcode & 7) >> 0;
2890: {{ LONG src = nextilong();
2891: { regs.a[dstreg] -= 4;
2892: { CPTR dsta = regs.a[dstreg];
2893: LONG dst = get_long(dsta);
2894: { ULONG newv = dst - src;
2895: { bool flgs = ((LONG)(src)) < 0;
2896: bool flgo = ((LONG)(dst)) < 0;
2897: bool flgn = ((LONG)(newv)) < 0;
2898: regs.z = ((LONG)(newv)) == 0;
2899: regs.v = (flgs != flgo) && (flgn != flgo);
2900: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2901: regs.n = flgn != 0;
2902: }}}}}}}
2903: void op_ca8(UWORD opcode)
2904: {
2905: ULONG dstreg = (opcode & 7) >> 0;
2906: {{ LONG src = nextilong();
2907: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2908: LONG dst = get_long(dsta);
2909: { ULONG newv = dst - src;
2910: { bool flgs = ((LONG)(src)) < 0;
2911: bool flgo = ((LONG)(dst)) < 0;
2912: bool flgn = ((LONG)(newv)) < 0;
2913: regs.z = ((LONG)(newv)) == 0;
2914: regs.v = (flgs != flgo) && (flgn != flgo);
2915: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2916: regs.n = flgn != 0;
2917: }}}}}}
2918: void op_cb0(UWORD opcode)
2919: {
2920: ULONG dstreg = (opcode & 7) >> 0;
2921: {{ LONG src = nextilong();
2922: { CPTR dsta = regs.a[dstreg];
2923: UWORD dstdp = nextiword();
2924: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2925: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2926: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2927: dsta += dstdpr;
2928: { LONG dst = get_long(dsta);
2929: { ULONG newv = dst - src;
2930: { bool flgs = ((LONG)(src)) < 0;
2931: bool flgo = ((LONG)(dst)) < 0;
2932: bool flgn = ((LONG)(newv)) < 0;
2933: regs.z = ((LONG)(newv)) == 0;
2934: regs.v = (flgs != flgo) && (flgn != flgo);
2935: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2936: regs.n = flgn != 0;
2937: }}}}}}}}
2938: void op_cb8(UWORD opcode)
2939: {
2940: {{ LONG src = nextilong();
2941: { CPTR dsta = (LONG)(WORD)nextiword();
2942: LONG dst = get_long(dsta);
2943: { ULONG newv = dst - src;
2944: { bool flgs = ((LONG)(src)) < 0;
2945: bool flgo = ((LONG)(dst)) < 0;
2946: bool flgn = ((LONG)(newv)) < 0;
2947: regs.z = ((LONG)(newv)) == 0;
2948: regs.v = (flgs != flgo) && (flgn != flgo);
2949: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2950: regs.n = flgn != 0;
2951: }}}}}}
2952: void op_cb9(UWORD opcode)
2953: {
2954: {{ LONG src = nextilong();
2955: { CPTR dsta = nextilong();
2956: LONG dst = get_long(dsta);
2957: { ULONG newv = dst - src;
2958: { bool flgs = ((LONG)(src)) < 0;
2959: bool flgo = ((LONG)(dst)) < 0;
2960: bool flgn = ((LONG)(newv)) < 0;
2961: regs.z = ((LONG)(newv)) == 0;
2962: regs.v = (flgs != flgo) && (flgn != flgo);
2963: regs.c = ((ULONG)(src)) > ((ULONG)(dst));
2964: regs.n = flgn != 0;
2965: }}}}}}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.