![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpu5.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 cpu5.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: void op_5000(UWORD opcode)
10: {
11: ULONG srcreg = 8;
12: ULONG dstreg = (opcode & 7) >> 0;
13: {{ ULONG src = srcreg;
14: { BYTE dst = regs.d[dstreg];
15: { ULONG newv = dst + src;
16: { bool flgs = ((BYTE)(src)) < 0;
17: bool flgo = ((BYTE)(dst)) < 0;
18: bool flgn = ((BYTE)(newv)) < 0;
19: regs.z = ((BYTE)(newv)) == 0;
20: regs.v = (flgs == flgo) && (flgn != flgo);
21: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
22: regs.n = flgn != 0;
23: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
24: }}}}}}
25: void op_5010(UWORD opcode)
26: {
27: ULONG srcreg = 8;
28: ULONG dstreg = (opcode & 7) >> 0;
29: {{ ULONG src = srcreg;
30: { CPTR dsta = regs.a[dstreg];
31: BYTE dst = get_byte(dsta);
32: { ULONG newv = dst + src;
33: { bool flgs = ((BYTE)(src)) < 0;
34: bool flgo = ((BYTE)(dst)) < 0;
35: bool flgn = ((BYTE)(newv)) < 0;
36: regs.z = ((BYTE)(newv)) == 0;
37: regs.v = (flgs == flgo) && (flgn != flgo);
38: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
39: regs.n = flgn != 0;
40: put_byte(dsta,newv);
41: }}}}}}
42: void op_5018(UWORD opcode)
43: {
44: ULONG srcreg = 8;
45: ULONG dstreg = (opcode & 7) >> 0;
46: {{ ULONG src = srcreg;
47: { CPTR dsta = regs.a[dstreg];
48: BYTE dst = get_byte(dsta);
49: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
50: { ULONG newv = dst + src;
51: { bool flgs = ((BYTE)(src)) < 0;
52: bool flgo = ((BYTE)(dst)) < 0;
53: bool flgn = ((BYTE)(newv)) < 0;
54: regs.z = ((BYTE)(newv)) == 0;
55: regs.v = (flgs == flgo) && (flgn != flgo);
56: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
57: regs.n = flgn != 0;
58: put_byte(dsta,newv);
59: }}}}}}}
60: void op_5020(UWORD opcode)
61: {
62: ULONG srcreg = 8;
63: ULONG dstreg = (opcode & 7) >> 0;
64: {{ ULONG src = srcreg;
65: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
66: { CPTR dsta = regs.a[dstreg];
67: BYTE dst = get_byte(dsta);
68: { ULONG newv = dst + src;
69: { bool flgs = ((BYTE)(src)) < 0;
70: bool flgo = ((BYTE)(dst)) < 0;
71: bool flgn = ((BYTE)(newv)) < 0;
72: regs.z = ((BYTE)(newv)) == 0;
73: regs.v = (flgs == flgo) && (flgn != flgo);
74: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
75: regs.n = flgn != 0;
76: put_byte(dsta,newv);
77: }}}}}}}
78: void op_5028(UWORD opcode)
79: {
80: ULONG srcreg = 8;
81: ULONG dstreg = (opcode & 7) >> 0;
82: {{ ULONG src = srcreg;
83: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
84: BYTE dst = get_byte(dsta);
85: { ULONG newv = dst + src;
86: { bool flgs = ((BYTE)(src)) < 0;
87: bool flgo = ((BYTE)(dst)) < 0;
88: bool flgn = ((BYTE)(newv)) < 0;
89: regs.z = ((BYTE)(newv)) == 0;
90: regs.v = (flgs == flgo) && (flgn != flgo);
91: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
92: regs.n = flgn != 0;
93: put_byte(dsta,newv);
94: }}}}}}
95: void op_5030(UWORD opcode)
96: {
97: ULONG srcreg = 8;
98: ULONG dstreg = (opcode & 7) >> 0;
99: {{ ULONG src = srcreg;
100: { CPTR dsta = regs.a[dstreg];
101: UWORD dstdp = nextiword();
102: dsta += (LONG)(BYTE)(dstdp & 0xFF);
103: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
104: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
105: dsta += dstdpr;
106: { BYTE dst = get_byte(dsta);
107: { ULONG newv = dst + src;
108: { bool flgs = ((BYTE)(src)) < 0;
109: bool flgo = ((BYTE)(dst)) < 0;
110: bool flgn = ((BYTE)(newv)) < 0;
111: regs.z = ((BYTE)(newv)) == 0;
112: regs.v = (flgs == flgo) && (flgn != flgo);
113: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
114: regs.n = flgn != 0;
115: put_byte(dsta,newv);
116: }}}}}}}}
117: void op_5038(UWORD opcode)
118: {
119: ULONG srcreg = 8;
120: {{ ULONG src = srcreg;
121: { CPTR dsta = (LONG)(WORD)nextiword();
122: BYTE dst = get_byte(dsta);
123: { ULONG newv = dst + src;
124: { bool flgs = ((BYTE)(src)) < 0;
125: bool flgo = ((BYTE)(dst)) < 0;
126: bool flgn = ((BYTE)(newv)) < 0;
127: regs.z = ((BYTE)(newv)) == 0;
128: regs.v = (flgs == flgo) && (flgn != flgo);
129: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
130: regs.n = flgn != 0;
131: put_byte(dsta,newv);
132: }}}}}}
133: void op_5039(UWORD opcode)
134: {
135: ULONG srcreg = 8;
136: {{ ULONG src = srcreg;
137: { CPTR dsta = nextilong();
138: BYTE dst = get_byte(dsta);
139: { ULONG newv = dst + src;
140: { bool flgs = ((BYTE)(src)) < 0;
141: bool flgo = ((BYTE)(dst)) < 0;
142: bool flgn = ((BYTE)(newv)) < 0;
143: regs.z = ((BYTE)(newv)) == 0;
144: regs.v = (flgs == flgo) && (flgn != flgo);
145: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
146: regs.n = flgn != 0;
147: put_byte(dsta,newv);
148: }}}}}}
149: void op_5040(UWORD opcode)
150: {
151: ULONG srcreg = 8;
152: ULONG dstreg = (opcode & 7) >> 0;
153: {{ ULONG src = srcreg;
154: { WORD dst = regs.d[dstreg];
155: { ULONG newv = dst + src;
156: { bool flgs = ((WORD)(src)) < 0;
157: bool flgo = ((WORD)(dst)) < 0;
158: bool flgn = ((WORD)(newv)) < 0;
159: regs.z = ((WORD)(newv)) == 0;
160: regs.v = (flgs == flgo) && (flgn != flgo);
161: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
162: regs.n = flgn != 0;
163: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
164: }}}}}}
165: void op_5048(UWORD opcode)
166: {
167: ULONG srcreg = 8;
168: ULONG dstreg = (opcode & 7) >> 0;
169: {{ ULONG src = srcreg;
170: { LONG dst = regs.a[dstreg];
171: { ULONG newv = dst + src;
172: regs.a[dstreg] = (newv);
173: }}}}}
174: void op_5050(UWORD opcode)
175: {
176: ULONG srcreg = 8;
177: ULONG dstreg = (opcode & 7) >> 0;
178: {{ ULONG src = srcreg;
179: { CPTR dsta = regs.a[dstreg];
180: WORD dst = get_word(dsta);
181: { ULONG newv = dst + src;
182: { bool flgs = ((WORD)(src)) < 0;
183: bool flgo = ((WORD)(dst)) < 0;
184: bool flgn = ((WORD)(newv)) < 0;
185: regs.z = ((WORD)(newv)) == 0;
186: regs.v = (flgs == flgo) && (flgn != flgo);
187: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
188: regs.n = flgn != 0;
189: put_word(dsta,newv);
190: }}}}}}
191: void op_5058(UWORD opcode)
192: {
193: ULONG srcreg = 8;
194: ULONG dstreg = (opcode & 7) >> 0;
195: {{ ULONG src = srcreg;
196: { CPTR dsta = regs.a[dstreg];
197: WORD dst = get_word(dsta);
198: { regs.a[dstreg] += 2;
199: { ULONG newv = dst + src;
200: { bool flgs = ((WORD)(src)) < 0;
201: bool flgo = ((WORD)(dst)) < 0;
202: bool flgn = ((WORD)(newv)) < 0;
203: regs.z = ((WORD)(newv)) == 0;
204: regs.v = (flgs == flgo) && (flgn != flgo);
205: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
206: regs.n = flgn != 0;
207: put_word(dsta,newv);
208: }}}}}}}
209: void op_5060(UWORD opcode)
210: {
211: ULONG srcreg = 8;
212: ULONG dstreg = (opcode & 7) >> 0;
213: {{ ULONG src = srcreg;
214: { regs.a[dstreg] -= 2;
215: { CPTR dsta = regs.a[dstreg];
216: WORD dst = get_word(dsta);
217: { ULONG newv = dst + src;
218: { bool flgs = ((WORD)(src)) < 0;
219: bool flgo = ((WORD)(dst)) < 0;
220: bool flgn = ((WORD)(newv)) < 0;
221: regs.z = ((WORD)(newv)) == 0;
222: regs.v = (flgs == flgo) && (flgn != flgo);
223: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
224: regs.n = flgn != 0;
225: put_word(dsta,newv);
226: }}}}}}}
227: void op_5068(UWORD opcode)
228: {
229: ULONG srcreg = 8;
230: ULONG dstreg = (opcode & 7) >> 0;
231: {{ ULONG src = srcreg;
232: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
233: WORD dst = get_word(dsta);
234: { ULONG newv = dst + src;
235: { bool flgs = ((WORD)(src)) < 0;
236: bool flgo = ((WORD)(dst)) < 0;
237: bool flgn = ((WORD)(newv)) < 0;
238: regs.z = ((WORD)(newv)) == 0;
239: regs.v = (flgs == flgo) && (flgn != flgo);
240: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
241: regs.n = flgn != 0;
242: put_word(dsta,newv);
243: }}}}}}
244: void op_5070(UWORD opcode)
245: {
246: ULONG srcreg = 8;
247: ULONG dstreg = (opcode & 7) >> 0;
248: {{ ULONG src = srcreg;
249: { CPTR dsta = regs.a[dstreg];
250: UWORD dstdp = nextiword();
251: dsta += (LONG)(BYTE)(dstdp & 0xFF);
252: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
253: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
254: dsta += dstdpr;
255: { WORD dst = get_word(dsta);
256: { ULONG newv = dst + src;
257: { bool flgs = ((WORD)(src)) < 0;
258: bool flgo = ((WORD)(dst)) < 0;
259: bool flgn = ((WORD)(newv)) < 0;
260: regs.z = ((WORD)(newv)) == 0;
261: regs.v = (flgs == flgo) && (flgn != flgo);
262: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
263: regs.n = flgn != 0;
264: put_word(dsta,newv);
265: }}}}}}}}
266: void op_5078(UWORD opcode)
267: {
268: ULONG srcreg = 8;
269: {{ ULONG src = srcreg;
270: { CPTR dsta = (LONG)(WORD)nextiword();
271: WORD dst = get_word(dsta);
272: { ULONG newv = dst + src;
273: { bool flgs = ((WORD)(src)) < 0;
274: bool flgo = ((WORD)(dst)) < 0;
275: bool flgn = ((WORD)(newv)) < 0;
276: regs.z = ((WORD)(newv)) == 0;
277: regs.v = (flgs == flgo) && (flgn != flgo);
278: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
279: regs.n = flgn != 0;
280: put_word(dsta,newv);
281: }}}}}}
282: void op_5079(UWORD opcode)
283: {
284: ULONG srcreg = 8;
285: {{ ULONG src = srcreg;
286: { CPTR dsta = nextilong();
287: WORD dst = get_word(dsta);
288: { ULONG newv = dst + src;
289: { bool flgs = ((WORD)(src)) < 0;
290: bool flgo = ((WORD)(dst)) < 0;
291: bool flgn = ((WORD)(newv)) < 0;
292: regs.z = ((WORD)(newv)) == 0;
293: regs.v = (flgs == flgo) && (flgn != flgo);
294: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
295: regs.n = flgn != 0;
296: put_word(dsta,newv);
297: }}}}}}
298: void op_5080(UWORD opcode)
299: {
300: ULONG srcreg = 8;
301: ULONG dstreg = (opcode & 7) >> 0;
302: {{ ULONG src = srcreg;
303: { LONG dst = regs.d[dstreg];
304: { ULONG newv = dst + src;
305: { bool flgs = ((LONG)(src)) < 0;
306: bool flgo = ((LONG)(dst)) < 0;
307: bool flgn = ((LONG)(newv)) < 0;
308: regs.z = ((LONG)(newv)) == 0;
309: regs.v = (flgs == flgo) && (flgn != flgo);
310: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
311: regs.n = flgn != 0;
312: regs.d[dstreg] = (newv);
313: }}}}}}
314: void op_5088(UWORD opcode)
315: {
316: ULONG srcreg = 8;
317: ULONG dstreg = (opcode & 7) >> 0;
318: {{ ULONG src = srcreg;
319: { LONG dst = regs.a[dstreg];
320: { ULONG newv = dst + src;
321: regs.a[dstreg] = (newv);
322: }}}}}
323: void op_5090(UWORD opcode)
324: {
325: ULONG srcreg = 8;
326: ULONG dstreg = (opcode & 7) >> 0;
327: {{ ULONG src = srcreg;
328: { CPTR dsta = regs.a[dstreg];
329: LONG dst = get_long(dsta);
330: { ULONG newv = dst + src;
331: { bool flgs = ((LONG)(src)) < 0;
332: bool flgo = ((LONG)(dst)) < 0;
333: bool flgn = ((LONG)(newv)) < 0;
334: regs.z = ((LONG)(newv)) == 0;
335: regs.v = (flgs == flgo) && (flgn != flgo);
336: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
337: regs.n = flgn != 0;
338: put_long(dsta,newv);
339: }}}}}}
340: void op_5098(UWORD opcode)
341: {
342: ULONG srcreg = 8;
343: ULONG dstreg = (opcode & 7) >> 0;
344: {{ ULONG src = srcreg;
345: { CPTR dsta = regs.a[dstreg];
346: LONG dst = get_long(dsta);
347: { regs.a[dstreg] += 4;
348: { ULONG newv = dst + src;
349: { bool flgs = ((LONG)(src)) < 0;
350: bool flgo = ((LONG)(dst)) < 0;
351: bool flgn = ((LONG)(newv)) < 0;
352: regs.z = ((LONG)(newv)) == 0;
353: regs.v = (flgs == flgo) && (flgn != flgo);
354: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
355: regs.n = flgn != 0;
356: put_long(dsta,newv);
357: }}}}}}}
358: void op_50a0(UWORD opcode)
359: {
360: ULONG srcreg = 8;
361: ULONG dstreg = (opcode & 7) >> 0;
362: {{ ULONG src = srcreg;
363: { regs.a[dstreg] -= 4;
364: { CPTR dsta = regs.a[dstreg];
365: LONG dst = get_long(dsta);
366: { ULONG newv = dst + src;
367: { bool flgs = ((LONG)(src)) < 0;
368: bool flgo = ((LONG)(dst)) < 0;
369: bool flgn = ((LONG)(newv)) < 0;
370: regs.z = ((LONG)(newv)) == 0;
371: regs.v = (flgs == flgo) && (flgn != flgo);
372: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
373: regs.n = flgn != 0;
374: put_long(dsta,newv);
375: }}}}}}}
376: void op_50a8(UWORD opcode)
377: {
378: ULONG srcreg = 8;
379: ULONG dstreg = (opcode & 7) >> 0;
380: {{ ULONG src = srcreg;
381: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
382: LONG dst = get_long(dsta);
383: { ULONG newv = dst + src;
384: { bool flgs = ((LONG)(src)) < 0;
385: bool flgo = ((LONG)(dst)) < 0;
386: bool flgn = ((LONG)(newv)) < 0;
387: regs.z = ((LONG)(newv)) == 0;
388: regs.v = (flgs == flgo) && (flgn != flgo);
389: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
390: regs.n = flgn != 0;
391: put_long(dsta,newv);
392: }}}}}}
393: void op_50b0(UWORD opcode)
394: {
395: ULONG srcreg = 8;
396: ULONG dstreg = (opcode & 7) >> 0;
397: {{ ULONG src = srcreg;
398: { CPTR dsta = regs.a[dstreg];
399: UWORD dstdp = nextiword();
400: dsta += (LONG)(BYTE)(dstdp & 0xFF);
401: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
402: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
403: dsta += dstdpr;
404: { LONG dst = get_long(dsta);
405: { ULONG newv = dst + src;
406: { bool flgs = ((LONG)(src)) < 0;
407: bool flgo = ((LONG)(dst)) < 0;
408: bool flgn = ((LONG)(newv)) < 0;
409: regs.z = ((LONG)(newv)) == 0;
410: regs.v = (flgs == flgo) && (flgn != flgo);
411: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
412: regs.n = flgn != 0;
413: put_long(dsta,newv);
414: }}}}}}}}
415: void op_50b8(UWORD opcode)
416: {
417: ULONG srcreg = 8;
418: {{ ULONG src = srcreg;
419: { CPTR dsta = (LONG)(WORD)nextiword();
420: LONG dst = get_long(dsta);
421: { ULONG newv = dst + src;
422: { bool flgs = ((LONG)(src)) < 0;
423: bool flgo = ((LONG)(dst)) < 0;
424: bool flgn = ((LONG)(newv)) < 0;
425: regs.z = ((LONG)(newv)) == 0;
426: regs.v = (flgs == flgo) && (flgn != flgo);
427: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
428: regs.n = flgn != 0;
429: put_long(dsta,newv);
430: }}}}}}
431: void op_50b9(UWORD opcode)
432: {
433: ULONG srcreg = 8;
434: {{ ULONG src = srcreg;
435: { CPTR dsta = nextilong();
436: LONG dst = get_long(dsta);
437: { ULONG newv = dst + src;
438: { bool flgs = ((LONG)(src)) < 0;
439: bool flgo = ((LONG)(dst)) < 0;
440: bool flgn = ((LONG)(newv)) < 0;
441: regs.z = ((LONG)(newv)) == 0;
442: regs.v = (flgs == flgo) && (flgn != flgo);
443: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
444: regs.n = flgn != 0;
445: put_long(dsta,newv);
446: }}}}}}
447: void op_50c0(UWORD opcode)
448: {
449: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
450: {{{ int val = cctrue(0) ? 0xff : 0;
451: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
452: }}}}
453: void op_50c8(UWORD opcode)
454: {
455: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
456: {{ WORD src = regs.d[srcreg];
457: { WORD offs = nextiword();
458: if (!cctrue(0)) {
459: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
460: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
461: }
462: }}}}
463: void op_50d0(UWORD opcode)
464: {
465: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
466: {{ CPTR srca = regs.a[srcreg];
467: { int val = cctrue(0) ? 0xff : 0;
468: put_byte(srca,val);
469: }}}}
470: void op_50d8(UWORD opcode)
471: {
472: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
473: {{ CPTR srca = regs.a[srcreg];
474: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
475: { int val = cctrue(0) ? 0xff : 0;
476: put_byte(srca,val);
477: }}}}}
478: void op_50e0(UWORD opcode)
479: {
480: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
481: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
482: { CPTR srca = regs.a[srcreg];
483: { int val = cctrue(0) ? 0xff : 0;
484: put_byte(srca,val);
485: }}}}}
486: void op_50e8(UWORD opcode)
487: {
488: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
489: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
490: { int val = cctrue(0) ? 0xff : 0;
491: put_byte(srca,val);
492: }}}}
493: void op_50f0(UWORD opcode)
494: {
495: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
496: {{ CPTR srca = regs.a[srcreg];
497: UWORD srcdp = nextiword();
498: srca += (LONG)(BYTE)(srcdp & 0xFF);
499: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
500: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
501: srca += srcdpr;
502: { int val = cctrue(0) ? 0xff : 0;
503: put_byte(srca,val);
504: }}}}}
505: void op_50f8(UWORD opcode)
506: {
507: {{ CPTR srca = (LONG)(WORD)nextiword();
508: { int val = cctrue(0) ? 0xff : 0;
509: put_byte(srca,val);
510: }}}}
511: void op_50f9(UWORD opcode)
512: {
513: {{ CPTR srca = nextilong();
514: { int val = cctrue(0) ? 0xff : 0;
515: put_byte(srca,val);
516: }}}}
517: void op_5100(UWORD opcode)
518: {
519: ULONG srcreg = 8;
520: ULONG dstreg = (opcode & 7) >> 0;
521: {{ ULONG src = srcreg;
522: { BYTE dst = regs.d[dstreg];
523: { ULONG newv = dst - src;
524: { bool flgs = ((BYTE)(src)) < 0;
525: bool flgo = ((BYTE)(dst)) < 0;
526: bool flgn = ((BYTE)(newv)) < 0;
527: regs.z = ((BYTE)(newv)) == 0;
528: regs.v = (flgs != flgo) && (flgn != flgo);
529: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
530: regs.n = flgn != 0;
531: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
532: }}}}}}
533: void op_5110(UWORD opcode)
534: {
535: ULONG srcreg = 8;
536: ULONG dstreg = (opcode & 7) >> 0;
537: {{ ULONG src = srcreg;
538: { CPTR dsta = regs.a[dstreg];
539: BYTE dst = get_byte(dsta);
540: { ULONG newv = dst - src;
541: { bool flgs = ((BYTE)(src)) < 0;
542: bool flgo = ((BYTE)(dst)) < 0;
543: bool flgn = ((BYTE)(newv)) < 0;
544: regs.z = ((BYTE)(newv)) == 0;
545: regs.v = (flgs != flgo) && (flgn != flgo);
546: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
547: regs.n = flgn != 0;
548: put_byte(dsta,newv);
549: }}}}}}
550: void op_5118(UWORD opcode)
551: {
552: ULONG srcreg = 8;
553: ULONG dstreg = (opcode & 7) >> 0;
554: {{ ULONG src = srcreg;
555: { CPTR dsta = regs.a[dstreg];
556: BYTE dst = get_byte(dsta);
557: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
558: { ULONG newv = dst - src;
559: { bool flgs = ((BYTE)(src)) < 0;
560: bool flgo = ((BYTE)(dst)) < 0;
561: bool flgn = ((BYTE)(newv)) < 0;
562: regs.z = ((BYTE)(newv)) == 0;
563: regs.v = (flgs != flgo) && (flgn != flgo);
564: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
565: regs.n = flgn != 0;
566: put_byte(dsta,newv);
567: }}}}}}}
568: void op_5120(UWORD opcode)
569: {
570: ULONG srcreg = 8;
571: ULONG dstreg = (opcode & 7) >> 0;
572: {{ ULONG src = srcreg;
573: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
574: { CPTR dsta = regs.a[dstreg];
575: BYTE dst = get_byte(dsta);
576: { ULONG newv = dst - src;
577: { bool flgs = ((BYTE)(src)) < 0;
578: bool flgo = ((BYTE)(dst)) < 0;
579: bool flgn = ((BYTE)(newv)) < 0;
580: regs.z = ((BYTE)(newv)) == 0;
581: regs.v = (flgs != flgo) && (flgn != flgo);
582: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
583: regs.n = flgn != 0;
584: put_byte(dsta,newv);
585: }}}}}}}
586: void op_5128(UWORD opcode)
587: {
588: ULONG srcreg = 8;
589: ULONG dstreg = (opcode & 7) >> 0;
590: {{ ULONG src = srcreg;
591: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
592: BYTE dst = get_byte(dsta);
593: { ULONG newv = dst - src;
594: { bool flgs = ((BYTE)(src)) < 0;
595: bool flgo = ((BYTE)(dst)) < 0;
596: bool flgn = ((BYTE)(newv)) < 0;
597: regs.z = ((BYTE)(newv)) == 0;
598: regs.v = (flgs != flgo) && (flgn != flgo);
599: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
600: regs.n = flgn != 0;
601: put_byte(dsta,newv);
602: }}}}}}
603: void op_5130(UWORD opcode)
604: {
605: ULONG srcreg = 8;
606: ULONG dstreg = (opcode & 7) >> 0;
607: {{ ULONG src = srcreg;
608: { CPTR dsta = regs.a[dstreg];
609: UWORD dstdp = nextiword();
610: dsta += (LONG)(BYTE)(dstdp & 0xFF);
611: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
612: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
613: dsta += dstdpr;
614: { BYTE dst = get_byte(dsta);
615: { ULONG newv = dst - src;
616: { bool flgs = ((BYTE)(src)) < 0;
617: bool flgo = ((BYTE)(dst)) < 0;
618: bool flgn = ((BYTE)(newv)) < 0;
619: regs.z = ((BYTE)(newv)) == 0;
620: regs.v = (flgs != flgo) && (flgn != flgo);
621: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
622: regs.n = flgn != 0;
623: put_byte(dsta,newv);
624: }}}}}}}}
625: void op_5138(UWORD opcode)
626: {
627: ULONG srcreg = 8;
628: {{ ULONG src = srcreg;
629: { CPTR dsta = (LONG)(WORD)nextiword();
630: BYTE dst = get_byte(dsta);
631: { ULONG newv = dst - src;
632: { bool flgs = ((BYTE)(src)) < 0;
633: bool flgo = ((BYTE)(dst)) < 0;
634: bool flgn = ((BYTE)(newv)) < 0;
635: regs.z = ((BYTE)(newv)) == 0;
636: regs.v = (flgs != flgo) && (flgn != flgo);
637: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
638: regs.n = flgn != 0;
639: put_byte(dsta,newv);
640: }}}}}}
641: void op_5139(UWORD opcode)
642: {
643: ULONG srcreg = 8;
644: {{ ULONG src = srcreg;
645: { CPTR dsta = nextilong();
646: BYTE dst = get_byte(dsta);
647: { ULONG newv = dst - src;
648: { bool flgs = ((BYTE)(src)) < 0;
649: bool flgo = ((BYTE)(dst)) < 0;
650: bool flgn = ((BYTE)(newv)) < 0;
651: regs.z = ((BYTE)(newv)) == 0;
652: regs.v = (flgs != flgo) && (flgn != flgo);
653: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
654: regs.n = flgn != 0;
655: put_byte(dsta,newv);
656: }}}}}}
657: void op_5140(UWORD opcode)
658: {
659: ULONG srcreg = 8;
660: ULONG dstreg = (opcode & 7) >> 0;
661: {{ ULONG src = srcreg;
662: { WORD dst = regs.d[dstreg];
663: { ULONG newv = dst - src;
664: { bool flgs = ((WORD)(src)) < 0;
665: bool flgo = ((WORD)(dst)) < 0;
666: bool flgn = ((WORD)(newv)) < 0;
667: regs.z = ((WORD)(newv)) == 0;
668: regs.v = (flgs != flgo) && (flgn != flgo);
669: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
670: regs.n = flgn != 0;
671: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
672: }}}}}}
673: void op_5148(UWORD opcode)
674: {
675: ULONG srcreg = 8;
676: ULONG dstreg = (opcode & 7) >> 0;
677: {{ ULONG src = srcreg;
678: { LONG dst = regs.a[dstreg];
679: { ULONG newv = dst - src;
680: regs.a[dstreg] = (newv);
681: }}}}}
682: void op_5150(UWORD opcode)
683: {
684: ULONG srcreg = 8;
685: ULONG dstreg = (opcode & 7) >> 0;
686: {{ ULONG src = srcreg;
687: { CPTR dsta = regs.a[dstreg];
688: WORD dst = get_word(dsta);
689: { ULONG newv = dst - src;
690: { bool flgs = ((WORD)(src)) < 0;
691: bool flgo = ((WORD)(dst)) < 0;
692: bool flgn = ((WORD)(newv)) < 0;
693: regs.z = ((WORD)(newv)) == 0;
694: regs.v = (flgs != flgo) && (flgn != flgo);
695: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
696: regs.n = flgn != 0;
697: put_word(dsta,newv);
698: }}}}}}
699: void op_5158(UWORD opcode)
700: {
701: ULONG srcreg = 8;
702: ULONG dstreg = (opcode & 7) >> 0;
703: {{ ULONG src = srcreg;
704: { CPTR dsta = regs.a[dstreg];
705: WORD dst = get_word(dsta);
706: { regs.a[dstreg] += 2;
707: { ULONG newv = dst - src;
708: { bool flgs = ((WORD)(src)) < 0;
709: bool flgo = ((WORD)(dst)) < 0;
710: bool flgn = ((WORD)(newv)) < 0;
711: regs.z = ((WORD)(newv)) == 0;
712: regs.v = (flgs != flgo) && (flgn != flgo);
713: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
714: regs.n = flgn != 0;
715: put_word(dsta,newv);
716: }}}}}}}
717: void op_5160(UWORD opcode)
718: {
719: ULONG srcreg = 8;
720: ULONG dstreg = (opcode & 7) >> 0;
721: {{ ULONG src = srcreg;
722: { regs.a[dstreg] -= 2;
723: { CPTR dsta = regs.a[dstreg];
724: WORD dst = get_word(dsta);
725: { ULONG newv = dst - src;
726: { bool flgs = ((WORD)(src)) < 0;
727: bool flgo = ((WORD)(dst)) < 0;
728: bool flgn = ((WORD)(newv)) < 0;
729: regs.z = ((WORD)(newv)) == 0;
730: regs.v = (flgs != flgo) && (flgn != flgo);
731: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
732: regs.n = flgn != 0;
733: put_word(dsta,newv);
734: }}}}}}}
735: void op_5168(UWORD opcode)
736: {
737: ULONG srcreg = 8;
738: ULONG dstreg = (opcode & 7) >> 0;
739: {{ ULONG src = srcreg;
740: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
741: WORD dst = get_word(dsta);
742: { ULONG newv = dst - src;
743: { bool flgs = ((WORD)(src)) < 0;
744: bool flgo = ((WORD)(dst)) < 0;
745: bool flgn = ((WORD)(newv)) < 0;
746: regs.z = ((WORD)(newv)) == 0;
747: regs.v = (flgs != flgo) && (flgn != flgo);
748: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
749: regs.n = flgn != 0;
750: put_word(dsta,newv);
751: }}}}}}
752: void op_5170(UWORD opcode)
753: {
754: ULONG srcreg = 8;
755: ULONG dstreg = (opcode & 7) >> 0;
756: {{ ULONG src = srcreg;
757: { CPTR dsta = regs.a[dstreg];
758: UWORD dstdp = nextiword();
759: dsta += (LONG)(BYTE)(dstdp & 0xFF);
760: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
761: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
762: dsta += dstdpr;
763: { WORD dst = get_word(dsta);
764: { ULONG newv = dst - src;
765: { bool flgs = ((WORD)(src)) < 0;
766: bool flgo = ((WORD)(dst)) < 0;
767: bool flgn = ((WORD)(newv)) < 0;
768: regs.z = ((WORD)(newv)) == 0;
769: regs.v = (flgs != flgo) && (flgn != flgo);
770: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
771: regs.n = flgn != 0;
772: put_word(dsta,newv);
773: }}}}}}}}
774: void op_5178(UWORD opcode)
775: {
776: ULONG srcreg = 8;
777: {{ ULONG src = srcreg;
778: { CPTR dsta = (LONG)(WORD)nextiword();
779: WORD dst = get_word(dsta);
780: { ULONG newv = dst - src;
781: { bool flgs = ((WORD)(src)) < 0;
782: bool flgo = ((WORD)(dst)) < 0;
783: bool flgn = ((WORD)(newv)) < 0;
784: regs.z = ((WORD)(newv)) == 0;
785: regs.v = (flgs != flgo) && (flgn != flgo);
786: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
787: regs.n = flgn != 0;
788: put_word(dsta,newv);
789: }}}}}}
790: void op_5179(UWORD opcode)
791: {
792: ULONG srcreg = 8;
793: {{ ULONG src = srcreg;
794: { CPTR dsta = nextilong();
795: WORD dst = get_word(dsta);
796: { ULONG newv = dst - src;
797: { bool flgs = ((WORD)(src)) < 0;
798: bool flgo = ((WORD)(dst)) < 0;
799: bool flgn = ((WORD)(newv)) < 0;
800: regs.z = ((WORD)(newv)) == 0;
801: regs.v = (flgs != flgo) && (flgn != flgo);
802: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
803: regs.n = flgn != 0;
804: put_word(dsta,newv);
805: }}}}}}
806: void op_5180(UWORD opcode)
807: {
808: ULONG srcreg = 8;
809: ULONG dstreg = (opcode & 7) >> 0;
810: {{ ULONG src = srcreg;
811: { LONG dst = regs.d[dstreg];
812: { ULONG newv = dst - src;
813: { bool flgs = ((LONG)(src)) < 0;
814: bool flgo = ((LONG)(dst)) < 0;
815: bool flgn = ((LONG)(newv)) < 0;
816: regs.z = ((LONG)(newv)) == 0;
817: regs.v = (flgs != flgo) && (flgn != flgo);
818: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
819: regs.n = flgn != 0;
820: regs.d[dstreg] = (newv);
821: }}}}}}
822: void op_5188(UWORD opcode)
823: {
824: ULONG srcreg = 8;
825: ULONG dstreg = (opcode & 7) >> 0;
826: {{ ULONG src = srcreg;
827: { LONG dst = regs.a[dstreg];
828: { ULONG newv = dst - src;
829: regs.a[dstreg] = (newv);
830: }}}}}
831: void op_5190(UWORD opcode)
832: {
833: ULONG srcreg = 8;
834: ULONG dstreg = (opcode & 7) >> 0;
835: {{ ULONG src = srcreg;
836: { CPTR dsta = regs.a[dstreg];
837: LONG dst = get_long(dsta);
838: { ULONG newv = dst - src;
839: { bool flgs = ((LONG)(src)) < 0;
840: bool flgo = ((LONG)(dst)) < 0;
841: bool flgn = ((LONG)(newv)) < 0;
842: regs.z = ((LONG)(newv)) == 0;
843: regs.v = (flgs != flgo) && (flgn != flgo);
844: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
845: regs.n = flgn != 0;
846: put_long(dsta,newv);
847: }}}}}}
848: void op_5198(UWORD opcode)
849: {
850: ULONG srcreg = 8;
851: ULONG dstreg = (opcode & 7) >> 0;
852: {{ ULONG src = srcreg;
853: { CPTR dsta = regs.a[dstreg];
854: LONG dst = get_long(dsta);
855: { regs.a[dstreg] += 4;
856: { ULONG newv = dst - src;
857: { bool flgs = ((LONG)(src)) < 0;
858: bool flgo = ((LONG)(dst)) < 0;
859: bool flgn = ((LONG)(newv)) < 0;
860: regs.z = ((LONG)(newv)) == 0;
861: regs.v = (flgs != flgo) && (flgn != flgo);
862: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
863: regs.n = flgn != 0;
864: put_long(dsta,newv);
865: }}}}}}}
866: void op_51a0(UWORD opcode)
867: {
868: ULONG srcreg = 8;
869: ULONG dstreg = (opcode & 7) >> 0;
870: {{ ULONG src = srcreg;
871: { regs.a[dstreg] -= 4;
872: { CPTR dsta = regs.a[dstreg];
873: LONG dst = get_long(dsta);
874: { ULONG newv = dst - src;
875: { bool flgs = ((LONG)(src)) < 0;
876: bool flgo = ((LONG)(dst)) < 0;
877: bool flgn = ((LONG)(newv)) < 0;
878: regs.z = ((LONG)(newv)) == 0;
879: regs.v = (flgs != flgo) && (flgn != flgo);
880: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
881: regs.n = flgn != 0;
882: put_long(dsta,newv);
883: }}}}}}}
884: void op_51a8(UWORD opcode)
885: {
886: ULONG srcreg = 8;
887: ULONG dstreg = (opcode & 7) >> 0;
888: {{ ULONG src = srcreg;
889: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
890: LONG dst = get_long(dsta);
891: { ULONG newv = dst - src;
892: { bool flgs = ((LONG)(src)) < 0;
893: bool flgo = ((LONG)(dst)) < 0;
894: bool flgn = ((LONG)(newv)) < 0;
895: regs.z = ((LONG)(newv)) == 0;
896: regs.v = (flgs != flgo) && (flgn != flgo);
897: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
898: regs.n = flgn != 0;
899: put_long(dsta,newv);
900: }}}}}}
901: void op_51b0(UWORD opcode)
902: {
903: ULONG srcreg = 8;
904: ULONG dstreg = (opcode & 7) >> 0;
905: {{ ULONG src = srcreg;
906: { CPTR dsta = regs.a[dstreg];
907: UWORD dstdp = nextiword();
908: dsta += (LONG)(BYTE)(dstdp & 0xFF);
909: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
910: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
911: dsta += dstdpr;
912: { LONG dst = get_long(dsta);
913: { ULONG newv = dst - src;
914: { bool flgs = ((LONG)(src)) < 0;
915: bool flgo = ((LONG)(dst)) < 0;
916: bool flgn = ((LONG)(newv)) < 0;
917: regs.z = ((LONG)(newv)) == 0;
918: regs.v = (flgs != flgo) && (flgn != flgo);
919: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
920: regs.n = flgn != 0;
921: put_long(dsta,newv);
922: }}}}}}}}
923: void op_51b8(UWORD opcode)
924: {
925: ULONG srcreg = 8;
926: {{ ULONG src = srcreg;
927: { CPTR dsta = (LONG)(WORD)nextiword();
928: LONG dst = get_long(dsta);
929: { ULONG newv = dst - src;
930: { bool flgs = ((LONG)(src)) < 0;
931: bool flgo = ((LONG)(dst)) < 0;
932: bool flgn = ((LONG)(newv)) < 0;
933: regs.z = ((LONG)(newv)) == 0;
934: regs.v = (flgs != flgo) && (flgn != flgo);
935: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
936: regs.n = flgn != 0;
937: put_long(dsta,newv);
938: }}}}}}
939: void op_51b9(UWORD opcode)
940: {
941: ULONG srcreg = 8;
942: {{ ULONG src = srcreg;
943: { CPTR dsta = nextilong();
944: LONG dst = get_long(dsta);
945: { ULONG newv = dst - src;
946: { bool flgs = ((LONG)(src)) < 0;
947: bool flgo = ((LONG)(dst)) < 0;
948: bool flgn = ((LONG)(newv)) < 0;
949: regs.z = ((LONG)(newv)) == 0;
950: regs.v = (flgs != flgo) && (flgn != flgo);
951: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
952: regs.n = flgn != 0;
953: put_long(dsta,newv);
954: }}}}}}
955: void op_51c0(UWORD opcode)
956: {
957: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
958: {{{ int val = cctrue(1) ? 0xff : 0;
959: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
960: }}}}
961: void op_51c8(UWORD opcode)
962: {
963: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
964: {{ WORD src = regs.d[srcreg];
965: { WORD offs = nextiword();
966: if (!cctrue(1)) {
967: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
968: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
969: }
970: }}}}
971: void op_51d0(UWORD opcode)
972: {
973: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
974: {{ CPTR srca = regs.a[srcreg];
975: { int val = cctrue(1) ? 0xff : 0;
976: put_byte(srca,val);
977: }}}}
978: void op_51d8(UWORD opcode)
979: {
980: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
981: {{ CPTR srca = regs.a[srcreg];
982: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
983: { int val = cctrue(1) ? 0xff : 0;
984: put_byte(srca,val);
985: }}}}}
986: void op_51e0(UWORD opcode)
987: {
988: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
989: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
990: { CPTR srca = regs.a[srcreg];
991: { int val = cctrue(1) ? 0xff : 0;
992: put_byte(srca,val);
993: }}}}}
994: void op_51e8(UWORD opcode)
995: {
996: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
997: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
998: { int val = cctrue(1) ? 0xff : 0;
999: put_byte(srca,val);
1000: }}}}
1001: void op_51f0(UWORD opcode)
1002: {
1003: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1004: {{ CPTR srca = regs.a[srcreg];
1005: UWORD srcdp = nextiword();
1006: srca += (LONG)(BYTE)(srcdp & 0xFF);
1007: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1008: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1009: srca += srcdpr;
1010: { int val = cctrue(1) ? 0xff : 0;
1011: put_byte(srca,val);
1012: }}}}}
1013: void op_51f8(UWORD opcode)
1014: {
1015: {{ CPTR srca = (LONG)(WORD)nextiword();
1016: { int val = cctrue(1) ? 0xff : 0;
1017: put_byte(srca,val);
1018: }}}}
1019: void op_51f9(UWORD opcode)
1020: {
1021: {{ CPTR srca = nextilong();
1022: { int val = cctrue(1) ? 0xff : 0;
1023: put_byte(srca,val);
1024: }}}}
1025: void op_5200(UWORD opcode)
1026: {
1027: ULONG srcreg = 1;
1028: ULONG dstreg = (opcode & 7) >> 0;
1029: {{ ULONG src = srcreg;
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)(~dst)) < ((UBYTE)(src));
1038: regs.n = flgn != 0;
1039: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
1040: }}}}}}
1041: void op_5210(UWORD opcode)
1042: {
1043: ULONG srcreg = 1;
1044: ULONG dstreg = (opcode & 7) >> 0;
1045: {{ ULONG src = srcreg;
1046: { CPTR dsta = regs.a[dstreg];
1047: BYTE dst = get_byte(dsta);
1048: { ULONG newv = dst + src;
1049: { bool flgs = ((BYTE)(src)) < 0;
1050: bool flgo = ((BYTE)(dst)) < 0;
1051: bool flgn = ((BYTE)(newv)) < 0;
1052: regs.z = ((BYTE)(newv)) == 0;
1053: regs.v = (flgs == flgo) && (flgn != flgo);
1054: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1055: regs.n = flgn != 0;
1056: put_byte(dsta,newv);
1057: }}}}}}
1058: void op_5218(UWORD opcode)
1059: {
1060: ULONG srcreg = 1;
1061: ULONG dstreg = (opcode & 7) >> 0;
1062: {{ ULONG src = srcreg;
1063: { CPTR dsta = regs.a[dstreg];
1064: BYTE dst = get_byte(dsta);
1065: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
1066: { ULONG newv = dst + src;
1067: { bool flgs = ((BYTE)(src)) < 0;
1068: bool flgo = ((BYTE)(dst)) < 0;
1069: bool flgn = ((BYTE)(newv)) < 0;
1070: regs.z = ((BYTE)(newv)) == 0;
1071: regs.v = (flgs == flgo) && (flgn != flgo);
1072: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1073: regs.n = flgn != 0;
1074: put_byte(dsta,newv);
1075: }}}}}}}
1076: void op_5220(UWORD opcode)
1077: {
1078: ULONG srcreg = 1;
1079: ULONG dstreg = (opcode & 7) >> 0;
1080: {{ ULONG src = srcreg;
1081: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
1082: { CPTR dsta = regs.a[dstreg];
1083: BYTE dst = get_byte(dsta);
1084: { ULONG newv = dst + src;
1085: { bool flgs = ((BYTE)(src)) < 0;
1086: bool flgo = ((BYTE)(dst)) < 0;
1087: bool flgn = ((BYTE)(newv)) < 0;
1088: regs.z = ((BYTE)(newv)) == 0;
1089: regs.v = (flgs == flgo) && (flgn != flgo);
1090: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1091: regs.n = flgn != 0;
1092: put_byte(dsta,newv);
1093: }}}}}}}
1094: void op_5228(UWORD opcode)
1095: {
1096: ULONG srcreg = 1;
1097: ULONG dstreg = (opcode & 7) >> 0;
1098: {{ ULONG src = srcreg;
1099: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1100: BYTE dst = get_byte(dsta);
1101: { ULONG newv = dst + src;
1102: { bool flgs = ((BYTE)(src)) < 0;
1103: bool flgo = ((BYTE)(dst)) < 0;
1104: bool flgn = ((BYTE)(newv)) < 0;
1105: regs.z = ((BYTE)(newv)) == 0;
1106: regs.v = (flgs == flgo) && (flgn != flgo);
1107: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1108: regs.n = flgn != 0;
1109: put_byte(dsta,newv);
1110: }}}}}}
1111: void op_5230(UWORD opcode)
1112: {
1113: ULONG srcreg = 1;
1114: ULONG dstreg = (opcode & 7) >> 0;
1115: {{ ULONG src = srcreg;
1116: { CPTR dsta = regs.a[dstreg];
1117: UWORD dstdp = nextiword();
1118: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1119: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1120: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1121: dsta += dstdpr;
1122: { BYTE dst = get_byte(dsta);
1123: { ULONG newv = dst + src;
1124: { bool flgs = ((BYTE)(src)) < 0;
1125: bool flgo = ((BYTE)(dst)) < 0;
1126: bool flgn = ((BYTE)(newv)) < 0;
1127: regs.z = ((BYTE)(newv)) == 0;
1128: regs.v = (flgs == flgo) && (flgn != flgo);
1129: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1130: regs.n = flgn != 0;
1131: put_byte(dsta,newv);
1132: }}}}}}}}
1133: void op_5238(UWORD opcode)
1134: {
1135: ULONG srcreg = 1;
1136: {{ ULONG src = srcreg;
1137: { CPTR dsta = (LONG)(WORD)nextiword();
1138: BYTE dst = get_byte(dsta);
1139: { ULONG newv = dst + src;
1140: { bool flgs = ((BYTE)(src)) < 0;
1141: bool flgo = ((BYTE)(dst)) < 0;
1142: bool flgn = ((BYTE)(newv)) < 0;
1143: regs.z = ((BYTE)(newv)) == 0;
1144: regs.v = (flgs == flgo) && (flgn != flgo);
1145: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1146: regs.n = flgn != 0;
1147: put_byte(dsta,newv);
1148: }}}}}}
1149: void op_5239(UWORD opcode)
1150: {
1151: ULONG srcreg = 1;
1152: {{ ULONG src = srcreg;
1153: { CPTR dsta = nextilong();
1154: BYTE dst = get_byte(dsta);
1155: { ULONG newv = dst + src;
1156: { bool flgs = ((BYTE)(src)) < 0;
1157: bool flgo = ((BYTE)(dst)) < 0;
1158: bool flgn = ((BYTE)(newv)) < 0;
1159: regs.z = ((BYTE)(newv)) == 0;
1160: regs.v = (flgs == flgo) && (flgn != flgo);
1161: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
1162: regs.n = flgn != 0;
1163: put_byte(dsta,newv);
1164: }}}}}}
1165: void op_5240(UWORD opcode)
1166: {
1167: ULONG srcreg = 1;
1168: ULONG dstreg = (opcode & 7) >> 0;
1169: {{ ULONG src = srcreg;
1170: { WORD dst = regs.d[dstreg];
1171: { ULONG newv = dst + src;
1172: { bool flgs = ((WORD)(src)) < 0;
1173: bool flgo = ((WORD)(dst)) < 0;
1174: bool flgn = ((WORD)(newv)) < 0;
1175: regs.z = ((WORD)(newv)) == 0;
1176: regs.v = (flgs == flgo) && (flgn != flgo);
1177: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1178: regs.n = flgn != 0;
1179: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
1180: }}}}}}
1181: void op_5248(UWORD opcode)
1182: {
1183: ULONG srcreg = 1;
1184: ULONG dstreg = (opcode & 7) >> 0;
1185: {{ ULONG src = srcreg;
1186: { LONG dst = regs.a[dstreg];
1187: { ULONG newv = dst + src;
1188: regs.a[dstreg] = (newv);
1189: }}}}}
1190: void op_5250(UWORD opcode)
1191: {
1192: ULONG srcreg = 1;
1193: ULONG dstreg = (opcode & 7) >> 0;
1194: {{ ULONG src = srcreg;
1195: { CPTR dsta = regs.a[dstreg];
1196: WORD dst = get_word(dsta);
1197: { ULONG newv = dst + src;
1198: { bool flgs = ((WORD)(src)) < 0;
1199: bool flgo = ((WORD)(dst)) < 0;
1200: bool flgn = ((WORD)(newv)) < 0;
1201: regs.z = ((WORD)(newv)) == 0;
1202: regs.v = (flgs == flgo) && (flgn != flgo);
1203: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1204: regs.n = flgn != 0;
1205: put_word(dsta,newv);
1206: }}}}}}
1207: void op_5258(UWORD opcode)
1208: {
1209: ULONG srcreg = 1;
1210: ULONG dstreg = (opcode & 7) >> 0;
1211: {{ ULONG src = srcreg;
1212: { CPTR dsta = regs.a[dstreg];
1213: WORD dst = get_word(dsta);
1214: { regs.a[dstreg] += 2;
1215: { ULONG newv = dst + src;
1216: { bool flgs = ((WORD)(src)) < 0;
1217: bool flgo = ((WORD)(dst)) < 0;
1218: bool flgn = ((WORD)(newv)) < 0;
1219: regs.z = ((WORD)(newv)) == 0;
1220: regs.v = (flgs == flgo) && (flgn != flgo);
1221: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1222: regs.n = flgn != 0;
1223: put_word(dsta,newv);
1224: }}}}}}}
1225: void op_5260(UWORD opcode)
1226: {
1227: ULONG srcreg = 1;
1228: ULONG dstreg = (opcode & 7) >> 0;
1229: {{ ULONG src = srcreg;
1230: { regs.a[dstreg] -= 2;
1231: { CPTR dsta = regs.a[dstreg];
1232: WORD dst = get_word(dsta);
1233: { ULONG newv = dst + src;
1234: { bool flgs = ((WORD)(src)) < 0;
1235: bool flgo = ((WORD)(dst)) < 0;
1236: bool flgn = ((WORD)(newv)) < 0;
1237: regs.z = ((WORD)(newv)) == 0;
1238: regs.v = (flgs == flgo) && (flgn != flgo);
1239: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1240: regs.n = flgn != 0;
1241: put_word(dsta,newv);
1242: }}}}}}}
1243: void op_5268(UWORD opcode)
1244: {
1245: ULONG srcreg = 1;
1246: ULONG dstreg = (opcode & 7) >> 0;
1247: {{ ULONG src = srcreg;
1248: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
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)(~dst)) < ((UWORD)(src));
1257: regs.n = flgn != 0;
1258: put_word(dsta,newv);
1259: }}}}}}
1260: void op_5270(UWORD opcode)
1261: {
1262: ULONG srcreg = 1;
1263: ULONG dstreg = (opcode & 7) >> 0;
1264: {{ ULONG src = srcreg;
1265: { CPTR dsta = regs.a[dstreg];
1266: UWORD dstdp = nextiword();
1267: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1268: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1269: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1270: dsta += dstdpr;
1271: { WORD dst = get_word(dsta);
1272: { ULONG newv = dst + src;
1273: { bool flgs = ((WORD)(src)) < 0;
1274: bool flgo = ((WORD)(dst)) < 0;
1275: bool flgn = ((WORD)(newv)) < 0;
1276: regs.z = ((WORD)(newv)) == 0;
1277: regs.v = (flgs == flgo) && (flgn != flgo);
1278: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1279: regs.n = flgn != 0;
1280: put_word(dsta,newv);
1281: }}}}}}}}
1282: void op_5278(UWORD opcode)
1283: {
1284: ULONG srcreg = 1;
1285: {{ ULONG src = srcreg;
1286: { CPTR dsta = (LONG)(WORD)nextiword();
1287: WORD dst = get_word(dsta);
1288: { ULONG newv = dst + src;
1289: { bool flgs = ((WORD)(src)) < 0;
1290: bool flgo = ((WORD)(dst)) < 0;
1291: bool flgn = ((WORD)(newv)) < 0;
1292: regs.z = ((WORD)(newv)) == 0;
1293: regs.v = (flgs == flgo) && (flgn != flgo);
1294: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1295: regs.n = flgn != 0;
1296: put_word(dsta,newv);
1297: }}}}}}
1298: void op_5279(UWORD opcode)
1299: {
1300: ULONG srcreg = 1;
1301: {{ ULONG src = srcreg;
1302: { CPTR dsta = nextilong();
1303: WORD dst = get_word(dsta);
1304: { ULONG newv = dst + src;
1305: { bool flgs = ((WORD)(src)) < 0;
1306: bool flgo = ((WORD)(dst)) < 0;
1307: bool flgn = ((WORD)(newv)) < 0;
1308: regs.z = ((WORD)(newv)) == 0;
1309: regs.v = (flgs == flgo) && (flgn != flgo);
1310: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
1311: regs.n = flgn != 0;
1312: put_word(dsta,newv);
1313: }}}}}}
1314: void op_5280(UWORD opcode)
1315: {
1316: ULONG srcreg = 1;
1317: ULONG dstreg = (opcode & 7) >> 0;
1318: {{ ULONG src = srcreg;
1319: { LONG dst = regs.d[dstreg];
1320: { ULONG newv = dst + src;
1321: { bool flgs = ((LONG)(src)) < 0;
1322: bool flgo = ((LONG)(dst)) < 0;
1323: bool flgn = ((LONG)(newv)) < 0;
1324: regs.z = ((LONG)(newv)) == 0;
1325: regs.v = (flgs == flgo) && (flgn != flgo);
1326: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1327: regs.n = flgn != 0;
1328: regs.d[dstreg] = (newv);
1329: }}}}}}
1330: void op_5288(UWORD opcode)
1331: {
1332: ULONG srcreg = 1;
1333: ULONG dstreg = (opcode & 7) >> 0;
1334: {{ ULONG src = srcreg;
1335: { LONG dst = regs.a[dstreg];
1336: { ULONG newv = dst + src;
1337: regs.a[dstreg] = (newv);
1338: }}}}}
1339: void op_5290(UWORD opcode)
1340: {
1341: ULONG srcreg = 1;
1342: ULONG dstreg = (opcode & 7) >> 0;
1343: {{ ULONG src = srcreg;
1344: { CPTR dsta = regs.a[dstreg];
1345: LONG dst = get_long(dsta);
1346: { ULONG newv = dst + src;
1347: { bool flgs = ((LONG)(src)) < 0;
1348: bool flgo = ((LONG)(dst)) < 0;
1349: bool flgn = ((LONG)(newv)) < 0;
1350: regs.z = ((LONG)(newv)) == 0;
1351: regs.v = (flgs == flgo) && (flgn != flgo);
1352: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1353: regs.n = flgn != 0;
1354: put_long(dsta,newv);
1355: }}}}}}
1356: void op_5298(UWORD opcode)
1357: {
1358: ULONG srcreg = 1;
1359: ULONG dstreg = (opcode & 7) >> 0;
1360: {{ ULONG src = srcreg;
1361: { CPTR dsta = regs.a[dstreg];
1362: LONG dst = get_long(dsta);
1363: { regs.a[dstreg] += 4;
1364: { ULONG newv = dst + src;
1365: { bool flgs = ((LONG)(src)) < 0;
1366: bool flgo = ((LONG)(dst)) < 0;
1367: bool flgn = ((LONG)(newv)) < 0;
1368: regs.z = ((LONG)(newv)) == 0;
1369: regs.v = (flgs == flgo) && (flgn != flgo);
1370: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1371: regs.n = flgn != 0;
1372: put_long(dsta,newv);
1373: }}}}}}}
1374: void op_52a0(UWORD opcode)
1375: {
1376: ULONG srcreg = 1;
1377: ULONG dstreg = (opcode & 7) >> 0;
1378: {{ ULONG src = srcreg;
1379: { regs.a[dstreg] -= 4;
1380: { CPTR dsta = regs.a[dstreg];
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)(~dst)) < ((ULONG)(src));
1389: regs.n = flgn != 0;
1390: put_long(dsta,newv);
1391: }}}}}}}
1392: void op_52a8(UWORD opcode)
1393: {
1394: ULONG srcreg = 1;
1395: ULONG dstreg = (opcode & 7) >> 0;
1396: {{ ULONG src = srcreg;
1397: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1398: LONG dst = get_long(dsta);
1399: { ULONG newv = dst + src;
1400: { bool flgs = ((LONG)(src)) < 0;
1401: bool flgo = ((LONG)(dst)) < 0;
1402: bool flgn = ((LONG)(newv)) < 0;
1403: regs.z = ((LONG)(newv)) == 0;
1404: regs.v = (flgs == flgo) && (flgn != flgo);
1405: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1406: regs.n = flgn != 0;
1407: put_long(dsta,newv);
1408: }}}}}}
1409: void op_52b0(UWORD opcode)
1410: {
1411: ULONG srcreg = 1;
1412: ULONG dstreg = (opcode & 7) >> 0;
1413: {{ ULONG src = srcreg;
1414: { CPTR dsta = regs.a[dstreg];
1415: UWORD dstdp = nextiword();
1416: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1417: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1418: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1419: dsta += dstdpr;
1420: { LONG dst = get_long(dsta);
1421: { ULONG newv = dst + src;
1422: { bool flgs = ((LONG)(src)) < 0;
1423: bool flgo = ((LONG)(dst)) < 0;
1424: bool flgn = ((LONG)(newv)) < 0;
1425: regs.z = ((LONG)(newv)) == 0;
1426: regs.v = (flgs == flgo) && (flgn != flgo);
1427: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1428: regs.n = flgn != 0;
1429: put_long(dsta,newv);
1430: }}}}}}}}
1431: void op_52b8(UWORD opcode)
1432: {
1433: ULONG srcreg = 1;
1434: {{ ULONG src = srcreg;
1435: { CPTR dsta = (LONG)(WORD)nextiword();
1436: LONG dst = get_long(dsta);
1437: { ULONG newv = dst + src;
1438: { bool flgs = ((LONG)(src)) < 0;
1439: bool flgo = ((LONG)(dst)) < 0;
1440: bool flgn = ((LONG)(newv)) < 0;
1441: regs.z = ((LONG)(newv)) == 0;
1442: regs.v = (flgs == flgo) && (flgn != flgo);
1443: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1444: regs.n = flgn != 0;
1445: put_long(dsta,newv);
1446: }}}}}}
1447: void op_52b9(UWORD opcode)
1448: {
1449: ULONG srcreg = 1;
1450: {{ ULONG src = srcreg;
1451: { CPTR dsta = nextilong();
1452: LONG dst = get_long(dsta);
1453: { ULONG newv = dst + src;
1454: { bool flgs = ((LONG)(src)) < 0;
1455: bool flgo = ((LONG)(dst)) < 0;
1456: bool flgn = ((LONG)(newv)) < 0;
1457: regs.z = ((LONG)(newv)) == 0;
1458: regs.v = (flgs == flgo) && (flgn != flgo);
1459: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
1460: regs.n = flgn != 0;
1461: put_long(dsta,newv);
1462: }}}}}}
1463: void op_52c0(UWORD opcode)
1464: {
1465: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1466: {{{ int val = cctrue(2) ? 0xff : 0;
1467: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
1468: }}}}
1469: void op_52c8(UWORD opcode)
1470: {
1471: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1472: {{ WORD src = regs.d[srcreg];
1473: { WORD offs = nextiword();
1474: if (!cctrue(2)) {
1475: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
1476: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
1477: }
1478: }}}}
1479: void op_52d0(UWORD opcode)
1480: {
1481: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1482: {{ CPTR srca = regs.a[srcreg];
1483: { int val = cctrue(2) ? 0xff : 0;
1484: put_byte(srca,val);
1485: }}}}
1486: void op_52d8(UWORD opcode)
1487: {
1488: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1489: {{ CPTR srca = regs.a[srcreg];
1490: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
1491: { int val = cctrue(2) ? 0xff : 0;
1492: put_byte(srca,val);
1493: }}}}}
1494: void op_52e0(UWORD opcode)
1495: {
1496: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1497: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
1498: { CPTR srca = regs.a[srcreg];
1499: { int val = cctrue(2) ? 0xff : 0;
1500: put_byte(srca,val);
1501: }}}}}
1502: void op_52e8(UWORD opcode)
1503: {
1504: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1505: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
1506: { int val = cctrue(2) ? 0xff : 0;
1507: put_byte(srca,val);
1508: }}}}
1509: void op_52f0(UWORD opcode)
1510: {
1511: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1512: {{ CPTR srca = regs.a[srcreg];
1513: UWORD srcdp = nextiword();
1514: srca += (LONG)(BYTE)(srcdp & 0xFF);
1515: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1516: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1517: srca += srcdpr;
1518: { int val = cctrue(2) ? 0xff : 0;
1519: put_byte(srca,val);
1520: }}}}}
1521: void op_52f8(UWORD opcode)
1522: {
1523: {{ CPTR srca = (LONG)(WORD)nextiword();
1524: { int val = cctrue(2) ? 0xff : 0;
1525: put_byte(srca,val);
1526: }}}}
1527: void op_52f9(UWORD opcode)
1528: {
1529: {{ CPTR srca = nextilong();
1530: { int val = cctrue(2) ? 0xff : 0;
1531: put_byte(srca,val);
1532: }}}}
1533: void op_5300(UWORD opcode)
1534: {
1535: ULONG srcreg = 1;
1536: ULONG dstreg = (opcode & 7) >> 0;
1537: {{ ULONG src = srcreg;
1538: { BYTE dst = regs.d[dstreg];
1539: { ULONG newv = dst - src;
1540: { bool flgs = ((BYTE)(src)) < 0;
1541: bool flgo = ((BYTE)(dst)) < 0;
1542: bool flgn = ((BYTE)(newv)) < 0;
1543: regs.z = ((BYTE)(newv)) == 0;
1544: regs.v = (flgs != flgo) && (flgn != flgo);
1545: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1546: regs.n = flgn != 0;
1547: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
1548: }}}}}}
1549: void op_5310(UWORD opcode)
1550: {
1551: ULONG srcreg = 1;
1552: ULONG dstreg = (opcode & 7) >> 0;
1553: {{ ULONG src = srcreg;
1554: { CPTR dsta = regs.a[dstreg];
1555: BYTE dst = get_byte(dsta);
1556: { ULONG newv = dst - src;
1557: { bool flgs = ((BYTE)(src)) < 0;
1558: bool flgo = ((BYTE)(dst)) < 0;
1559: bool flgn = ((BYTE)(newv)) < 0;
1560: regs.z = ((BYTE)(newv)) == 0;
1561: regs.v = (flgs != flgo) && (flgn != flgo);
1562: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1563: regs.n = flgn != 0;
1564: put_byte(dsta,newv);
1565: }}}}}}
1566: void op_5318(UWORD opcode)
1567: {
1568: ULONG srcreg = 1;
1569: ULONG dstreg = (opcode & 7) >> 0;
1570: {{ ULONG src = srcreg;
1571: { CPTR dsta = regs.a[dstreg];
1572: BYTE dst = get_byte(dsta);
1573: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
1574: { ULONG newv = dst - src;
1575: { bool flgs = ((BYTE)(src)) < 0;
1576: bool flgo = ((BYTE)(dst)) < 0;
1577: bool flgn = ((BYTE)(newv)) < 0;
1578: regs.z = ((BYTE)(newv)) == 0;
1579: regs.v = (flgs != flgo) && (flgn != flgo);
1580: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1581: regs.n = flgn != 0;
1582: put_byte(dsta,newv);
1583: }}}}}}}
1584: void op_5320(UWORD opcode)
1585: {
1586: ULONG srcreg = 1;
1587: ULONG dstreg = (opcode & 7) >> 0;
1588: {{ ULONG src = srcreg;
1589: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
1590: { CPTR dsta = regs.a[dstreg];
1591: BYTE dst = get_byte(dsta);
1592: { ULONG newv = dst - src;
1593: { bool flgs = ((BYTE)(src)) < 0;
1594: bool flgo = ((BYTE)(dst)) < 0;
1595: bool flgn = ((BYTE)(newv)) < 0;
1596: regs.z = ((BYTE)(newv)) == 0;
1597: regs.v = (flgs != flgo) && (flgn != flgo);
1598: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1599: regs.n = flgn != 0;
1600: put_byte(dsta,newv);
1601: }}}}}}}
1602: void op_5328(UWORD opcode)
1603: {
1604: ULONG srcreg = 1;
1605: ULONG dstreg = (opcode & 7) >> 0;
1606: {{ ULONG src = srcreg;
1607: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1608: BYTE dst = get_byte(dsta);
1609: { ULONG newv = dst - src;
1610: { bool flgs = ((BYTE)(src)) < 0;
1611: bool flgo = ((BYTE)(dst)) < 0;
1612: bool flgn = ((BYTE)(newv)) < 0;
1613: regs.z = ((BYTE)(newv)) == 0;
1614: regs.v = (flgs != flgo) && (flgn != flgo);
1615: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1616: regs.n = flgn != 0;
1617: put_byte(dsta,newv);
1618: }}}}}}
1619: void op_5330(UWORD opcode)
1620: {
1621: ULONG srcreg = 1;
1622: ULONG dstreg = (opcode & 7) >> 0;
1623: {{ ULONG src = srcreg;
1624: { CPTR dsta = regs.a[dstreg];
1625: UWORD dstdp = nextiword();
1626: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1627: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1628: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1629: dsta += dstdpr;
1630: { BYTE dst = get_byte(dsta);
1631: { ULONG newv = dst - src;
1632: { bool flgs = ((BYTE)(src)) < 0;
1633: bool flgo = ((BYTE)(dst)) < 0;
1634: bool flgn = ((BYTE)(newv)) < 0;
1635: regs.z = ((BYTE)(newv)) == 0;
1636: regs.v = (flgs != flgo) && (flgn != flgo);
1637: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1638: regs.n = flgn != 0;
1639: put_byte(dsta,newv);
1640: }}}}}}}}
1641: void op_5338(UWORD opcode)
1642: {
1643: ULONG srcreg = 1;
1644: {{ ULONG src = srcreg;
1645: { CPTR dsta = (LONG)(WORD)nextiword();
1646: BYTE dst = get_byte(dsta);
1647: { ULONG newv = dst - src;
1648: { bool flgs = ((BYTE)(src)) < 0;
1649: bool flgo = ((BYTE)(dst)) < 0;
1650: bool flgn = ((BYTE)(newv)) < 0;
1651: regs.z = ((BYTE)(newv)) == 0;
1652: regs.v = (flgs != flgo) && (flgn != flgo);
1653: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1654: regs.n = flgn != 0;
1655: put_byte(dsta,newv);
1656: }}}}}}
1657: void op_5339(UWORD opcode)
1658: {
1659: ULONG srcreg = 1;
1660: {{ ULONG src = srcreg;
1661: { CPTR dsta = nextilong();
1662: BYTE dst = get_byte(dsta);
1663: { ULONG newv = dst - src;
1664: { bool flgs = ((BYTE)(src)) < 0;
1665: bool flgo = ((BYTE)(dst)) < 0;
1666: bool flgn = ((BYTE)(newv)) < 0;
1667: regs.z = ((BYTE)(newv)) == 0;
1668: regs.v = (flgs != flgo) && (flgn != flgo);
1669: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
1670: regs.n = flgn != 0;
1671: put_byte(dsta,newv);
1672: }}}}}}
1673: void op_5340(UWORD opcode)
1674: {
1675: ULONG srcreg = 1;
1676: ULONG dstreg = (opcode & 7) >> 0;
1677: {{ ULONG src = srcreg;
1678: { WORD dst = regs.d[dstreg];
1679: { ULONG newv = dst - src;
1680: { bool flgs = ((WORD)(src)) < 0;
1681: bool flgo = ((WORD)(dst)) < 0;
1682: bool flgn = ((WORD)(newv)) < 0;
1683: regs.z = ((WORD)(newv)) == 0;
1684: regs.v = (flgs != flgo) && (flgn != flgo);
1685: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1686: regs.n = flgn != 0;
1687: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
1688: }}}}}}
1689: void op_5348(UWORD opcode)
1690: {
1691: ULONG srcreg = 1;
1692: ULONG dstreg = (opcode & 7) >> 0;
1693: {{ ULONG src = srcreg;
1694: { LONG dst = regs.a[dstreg];
1695: { ULONG newv = dst - src;
1696: regs.a[dstreg] = (newv);
1697: }}}}}
1698: void op_5350(UWORD opcode)
1699: {
1700: ULONG srcreg = 1;
1701: ULONG dstreg = (opcode & 7) >> 0;
1702: {{ ULONG src = srcreg;
1703: { CPTR dsta = regs.a[dstreg];
1704: WORD dst = get_word(dsta);
1705: { ULONG newv = dst - src;
1706: { bool flgs = ((WORD)(src)) < 0;
1707: bool flgo = ((WORD)(dst)) < 0;
1708: bool flgn = ((WORD)(newv)) < 0;
1709: regs.z = ((WORD)(newv)) == 0;
1710: regs.v = (flgs != flgo) && (flgn != flgo);
1711: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1712: regs.n = flgn != 0;
1713: put_word(dsta,newv);
1714: }}}}}}
1715: void op_5358(UWORD opcode)
1716: {
1717: ULONG srcreg = 1;
1718: ULONG dstreg = (opcode & 7) >> 0;
1719: {{ ULONG src = srcreg;
1720: { CPTR dsta = regs.a[dstreg];
1721: WORD dst = get_word(dsta);
1722: { regs.a[dstreg] += 2;
1723: { ULONG newv = dst - src;
1724: { bool flgs = ((WORD)(src)) < 0;
1725: bool flgo = ((WORD)(dst)) < 0;
1726: bool flgn = ((WORD)(newv)) < 0;
1727: regs.z = ((WORD)(newv)) == 0;
1728: regs.v = (flgs != flgo) && (flgn != flgo);
1729: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1730: regs.n = flgn != 0;
1731: put_word(dsta,newv);
1732: }}}}}}}
1733: void op_5360(UWORD opcode)
1734: {
1735: ULONG srcreg = 1;
1736: ULONG dstreg = (opcode & 7) >> 0;
1737: {{ ULONG src = srcreg;
1738: { regs.a[dstreg] -= 2;
1739: { CPTR dsta = regs.a[dstreg];
1740: WORD dst = get_word(dsta);
1741: { ULONG newv = dst - src;
1742: { bool flgs = ((WORD)(src)) < 0;
1743: bool flgo = ((WORD)(dst)) < 0;
1744: bool flgn = ((WORD)(newv)) < 0;
1745: regs.z = ((WORD)(newv)) == 0;
1746: regs.v = (flgs != flgo) && (flgn != flgo);
1747: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1748: regs.n = flgn != 0;
1749: put_word(dsta,newv);
1750: }}}}}}}
1751: void op_5368(UWORD opcode)
1752: {
1753: ULONG srcreg = 1;
1754: ULONG dstreg = (opcode & 7) >> 0;
1755: {{ ULONG src = srcreg;
1756: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1757: WORD dst = get_word(dsta);
1758: { ULONG newv = dst - src;
1759: { bool flgs = ((WORD)(src)) < 0;
1760: bool flgo = ((WORD)(dst)) < 0;
1761: bool flgn = ((WORD)(newv)) < 0;
1762: regs.z = ((WORD)(newv)) == 0;
1763: regs.v = (flgs != flgo) && (flgn != flgo);
1764: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1765: regs.n = flgn != 0;
1766: put_word(dsta,newv);
1767: }}}}}}
1768: void op_5370(UWORD opcode)
1769: {
1770: ULONG srcreg = 1;
1771: ULONG dstreg = (opcode & 7) >> 0;
1772: {{ ULONG src = srcreg;
1773: { CPTR dsta = regs.a[dstreg];
1774: UWORD dstdp = nextiword();
1775: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1776: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1777: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1778: dsta += dstdpr;
1779: { WORD dst = get_word(dsta);
1780: { ULONG newv = dst - src;
1781: { bool flgs = ((WORD)(src)) < 0;
1782: bool flgo = ((WORD)(dst)) < 0;
1783: bool flgn = ((WORD)(newv)) < 0;
1784: regs.z = ((WORD)(newv)) == 0;
1785: regs.v = (flgs != flgo) && (flgn != flgo);
1786: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1787: regs.n = flgn != 0;
1788: put_word(dsta,newv);
1789: }}}}}}}}
1790: void op_5378(UWORD opcode)
1791: {
1792: ULONG srcreg = 1;
1793: {{ ULONG src = srcreg;
1794: { CPTR dsta = (LONG)(WORD)nextiword();
1795: WORD dst = get_word(dsta);
1796: { ULONG newv = dst - src;
1797: { bool flgs = ((WORD)(src)) < 0;
1798: bool flgo = ((WORD)(dst)) < 0;
1799: bool flgn = ((WORD)(newv)) < 0;
1800: regs.z = ((WORD)(newv)) == 0;
1801: regs.v = (flgs != flgo) && (flgn != flgo);
1802: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1803: regs.n = flgn != 0;
1804: put_word(dsta,newv);
1805: }}}}}}
1806: void op_5379(UWORD opcode)
1807: {
1808: ULONG srcreg = 1;
1809: {{ ULONG src = srcreg;
1810: { CPTR dsta = nextilong();
1811: WORD dst = get_word(dsta);
1812: { ULONG newv = dst - src;
1813: { bool flgs = ((WORD)(src)) < 0;
1814: bool flgo = ((WORD)(dst)) < 0;
1815: bool flgn = ((WORD)(newv)) < 0;
1816: regs.z = ((WORD)(newv)) == 0;
1817: regs.v = (flgs != flgo) && (flgn != flgo);
1818: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
1819: regs.n = flgn != 0;
1820: put_word(dsta,newv);
1821: }}}}}}
1822: void op_5380(UWORD opcode)
1823: {
1824: ULONG srcreg = 1;
1825: ULONG dstreg = (opcode & 7) >> 0;
1826: {{ ULONG src = srcreg;
1827: { LONG dst = regs.d[dstreg];
1828: { ULONG newv = dst - src;
1829: { bool flgs = ((LONG)(src)) < 0;
1830: bool flgo = ((LONG)(dst)) < 0;
1831: bool flgn = ((LONG)(newv)) < 0;
1832: regs.z = ((LONG)(newv)) == 0;
1833: regs.v = (flgs != flgo) && (flgn != flgo);
1834: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1835: regs.n = flgn != 0;
1836: regs.d[dstreg] = (newv);
1837: }}}}}}
1838: void op_5388(UWORD opcode)
1839: {
1840: ULONG srcreg = 1;
1841: ULONG dstreg = (opcode & 7) >> 0;
1842: {{ ULONG src = srcreg;
1843: { LONG dst = regs.a[dstreg];
1844: { ULONG newv = dst - src;
1845: regs.a[dstreg] = (newv);
1846: }}}}}
1847: void op_5390(UWORD opcode)
1848: {
1849: ULONG srcreg = 1;
1850: ULONG dstreg = (opcode & 7) >> 0;
1851: {{ ULONG src = srcreg;
1852: { CPTR dsta = regs.a[dstreg];
1853: LONG dst = get_long(dsta);
1854: { ULONG newv = dst - src;
1855: { bool flgs = ((LONG)(src)) < 0;
1856: bool flgo = ((LONG)(dst)) < 0;
1857: bool flgn = ((LONG)(newv)) < 0;
1858: regs.z = ((LONG)(newv)) == 0;
1859: regs.v = (flgs != flgo) && (flgn != flgo);
1860: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1861: regs.n = flgn != 0;
1862: put_long(dsta,newv);
1863: }}}}}}
1864: void op_5398(UWORD opcode)
1865: {
1866: ULONG srcreg = 1;
1867: ULONG dstreg = (opcode & 7) >> 0;
1868: {{ ULONG src = srcreg;
1869: { CPTR dsta = regs.a[dstreg];
1870: LONG dst = get_long(dsta);
1871: { regs.a[dstreg] += 4;
1872: { ULONG newv = dst - src;
1873: { bool flgs = ((LONG)(src)) < 0;
1874: bool flgo = ((LONG)(dst)) < 0;
1875: bool flgn = ((LONG)(newv)) < 0;
1876: regs.z = ((LONG)(newv)) == 0;
1877: regs.v = (flgs != flgo) && (flgn != flgo);
1878: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1879: regs.n = flgn != 0;
1880: put_long(dsta,newv);
1881: }}}}}}}
1882: void op_53a0(UWORD opcode)
1883: {
1884: ULONG srcreg = 1;
1885: ULONG dstreg = (opcode & 7) >> 0;
1886: {{ ULONG src = srcreg;
1887: { regs.a[dstreg] -= 4;
1888: { CPTR dsta = regs.a[dstreg];
1889: LONG dst = get_long(dsta);
1890: { ULONG newv = dst - src;
1891: { bool flgs = ((LONG)(src)) < 0;
1892: bool flgo = ((LONG)(dst)) < 0;
1893: bool flgn = ((LONG)(newv)) < 0;
1894: regs.z = ((LONG)(newv)) == 0;
1895: regs.v = (flgs != flgo) && (flgn != flgo);
1896: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1897: regs.n = flgn != 0;
1898: put_long(dsta,newv);
1899: }}}}}}}
1900: void op_53a8(UWORD opcode)
1901: {
1902: ULONG srcreg = 1;
1903: ULONG dstreg = (opcode & 7) >> 0;
1904: {{ ULONG src = srcreg;
1905: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
1906: LONG dst = get_long(dsta);
1907: { ULONG newv = dst - src;
1908: { bool flgs = ((LONG)(src)) < 0;
1909: bool flgo = ((LONG)(dst)) < 0;
1910: bool flgn = ((LONG)(newv)) < 0;
1911: regs.z = ((LONG)(newv)) == 0;
1912: regs.v = (flgs != flgo) && (flgn != flgo);
1913: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1914: regs.n = flgn != 0;
1915: put_long(dsta,newv);
1916: }}}}}}
1917: void op_53b0(UWORD opcode)
1918: {
1919: ULONG srcreg = 1;
1920: ULONG dstreg = (opcode & 7) >> 0;
1921: {{ ULONG src = srcreg;
1922: { CPTR dsta = regs.a[dstreg];
1923: UWORD dstdp = nextiword();
1924: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1925: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1926: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1927: dsta += dstdpr;
1928: { LONG dst = get_long(dsta);
1929: { ULONG newv = dst - src;
1930: { bool flgs = ((LONG)(src)) < 0;
1931: bool flgo = ((LONG)(dst)) < 0;
1932: bool flgn = ((LONG)(newv)) < 0;
1933: regs.z = ((LONG)(newv)) == 0;
1934: regs.v = (flgs != flgo) && (flgn != flgo);
1935: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1936: regs.n = flgn != 0;
1937: put_long(dsta,newv);
1938: }}}}}}}}
1939: void op_53b8(UWORD opcode)
1940: {
1941: ULONG srcreg = 1;
1942: {{ ULONG src = srcreg;
1943: { CPTR dsta = (LONG)(WORD)nextiword();
1944: LONG dst = get_long(dsta);
1945: { ULONG newv = dst - src;
1946: { bool flgs = ((LONG)(src)) < 0;
1947: bool flgo = ((LONG)(dst)) < 0;
1948: bool flgn = ((LONG)(newv)) < 0;
1949: regs.z = ((LONG)(newv)) == 0;
1950: regs.v = (flgs != flgo) && (flgn != flgo);
1951: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1952: regs.n = flgn != 0;
1953: put_long(dsta,newv);
1954: }}}}}}
1955: void op_53b9(UWORD opcode)
1956: {
1957: ULONG srcreg = 1;
1958: {{ ULONG src = srcreg;
1959: { CPTR dsta = nextilong();
1960: LONG dst = get_long(dsta);
1961: { ULONG newv = dst - src;
1962: { bool flgs = ((LONG)(src)) < 0;
1963: bool flgo = ((LONG)(dst)) < 0;
1964: bool flgn = ((LONG)(newv)) < 0;
1965: regs.z = ((LONG)(newv)) == 0;
1966: regs.v = (flgs != flgo) && (flgn != flgo);
1967: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
1968: regs.n = flgn != 0;
1969: put_long(dsta,newv);
1970: }}}}}}
1971: void op_53c0(UWORD opcode)
1972: {
1973: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1974: {{{ int val = cctrue(3) ? 0xff : 0;
1975: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
1976: }}}}
1977: void op_53c8(UWORD opcode)
1978: {
1979: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1980: {{ WORD src = regs.d[srcreg];
1981: { WORD offs = nextiword();
1982: if (!cctrue(3)) {
1983: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
1984: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
1985: }
1986: }}}}
1987: void op_53d0(UWORD opcode)
1988: {
1989: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1990: {{ CPTR srca = regs.a[srcreg];
1991: { int val = cctrue(3) ? 0xff : 0;
1992: put_byte(srca,val);
1993: }}}}
1994: void op_53d8(UWORD opcode)
1995: {
1996: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1997: {{ CPTR srca = regs.a[srcreg];
1998: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
1999: { int val = cctrue(3) ? 0xff : 0;
2000: put_byte(srca,val);
2001: }}}}}
2002: void op_53e0(UWORD opcode)
2003: {
2004: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2005: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
2006: { CPTR srca = regs.a[srcreg];
2007: { int val = cctrue(3) ? 0xff : 0;
2008: put_byte(srca,val);
2009: }}}}}
2010: void op_53e8(UWORD opcode)
2011: {
2012: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2013: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
2014: { int val = cctrue(3) ? 0xff : 0;
2015: put_byte(srca,val);
2016: }}}}
2017: void op_53f0(UWORD opcode)
2018: {
2019: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2020: {{ CPTR srca = regs.a[srcreg];
2021: UWORD srcdp = nextiword();
2022: srca += (LONG)(BYTE)(srcdp & 0xFF);
2023: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
2024: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
2025: srca += srcdpr;
2026: { int val = cctrue(3) ? 0xff : 0;
2027: put_byte(srca,val);
2028: }}}}}
2029: void op_53f8(UWORD opcode)
2030: {
2031: {{ CPTR srca = (LONG)(WORD)nextiword();
2032: { int val = cctrue(3) ? 0xff : 0;
2033: put_byte(srca,val);
2034: }}}}
2035: void op_53f9(UWORD opcode)
2036: {
2037: {{ CPTR srca = nextilong();
2038: { int val = cctrue(3) ? 0xff : 0;
2039: put_byte(srca,val);
2040: }}}}
2041: void op_5400(UWORD opcode)
2042: {
2043: ULONG srcreg = 2;
2044: ULONG dstreg = (opcode & 7) >> 0;
2045: {{ ULONG src = srcreg;
2046: { BYTE dst = regs.d[dstreg];
2047: { ULONG newv = dst + src;
2048: { bool flgs = ((BYTE)(src)) < 0;
2049: bool flgo = ((BYTE)(dst)) < 0;
2050: bool flgn = ((BYTE)(newv)) < 0;
2051: regs.z = ((BYTE)(newv)) == 0;
2052: regs.v = (flgs == flgo) && (flgn != flgo);
2053: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2054: regs.n = flgn != 0;
2055: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
2056: }}}}}}
2057: void op_5410(UWORD opcode)
2058: {
2059: ULONG srcreg = 2;
2060: ULONG dstreg = (opcode & 7) >> 0;
2061: {{ ULONG src = srcreg;
2062: { CPTR dsta = regs.a[dstreg];
2063: BYTE dst = get_byte(dsta);
2064: { ULONG newv = dst + src;
2065: { bool flgs = ((BYTE)(src)) < 0;
2066: bool flgo = ((BYTE)(dst)) < 0;
2067: bool flgn = ((BYTE)(newv)) < 0;
2068: regs.z = ((BYTE)(newv)) == 0;
2069: regs.v = (flgs == flgo) && (flgn != flgo);
2070: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2071: regs.n = flgn != 0;
2072: put_byte(dsta,newv);
2073: }}}}}}
2074: void op_5418(UWORD opcode)
2075: {
2076: ULONG srcreg = 2;
2077: ULONG dstreg = (opcode & 7) >> 0;
2078: {{ ULONG src = srcreg;
2079: { CPTR dsta = regs.a[dstreg];
2080: BYTE dst = get_byte(dsta);
2081: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
2082: { ULONG newv = dst + src;
2083: { bool flgs = ((BYTE)(src)) < 0;
2084: bool flgo = ((BYTE)(dst)) < 0;
2085: bool flgn = ((BYTE)(newv)) < 0;
2086: regs.z = ((BYTE)(newv)) == 0;
2087: regs.v = (flgs == flgo) && (flgn != flgo);
2088: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2089: regs.n = flgn != 0;
2090: put_byte(dsta,newv);
2091: }}}}}}}
2092: void op_5420(UWORD opcode)
2093: {
2094: ULONG srcreg = 2;
2095: ULONG dstreg = (opcode & 7) >> 0;
2096: {{ ULONG src = srcreg;
2097: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
2098: { CPTR dsta = regs.a[dstreg];
2099: BYTE dst = get_byte(dsta);
2100: { ULONG newv = dst + src;
2101: { bool flgs = ((BYTE)(src)) < 0;
2102: bool flgo = ((BYTE)(dst)) < 0;
2103: bool flgn = ((BYTE)(newv)) < 0;
2104: regs.z = ((BYTE)(newv)) == 0;
2105: regs.v = (flgs == flgo) && (flgn != flgo);
2106: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2107: regs.n = flgn != 0;
2108: put_byte(dsta,newv);
2109: }}}}}}}
2110: void op_5428(UWORD opcode)
2111: {
2112: ULONG srcreg = 2;
2113: ULONG dstreg = (opcode & 7) >> 0;
2114: {{ ULONG src = srcreg;
2115: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2116: BYTE dst = get_byte(dsta);
2117: { ULONG newv = dst + src;
2118: { bool flgs = ((BYTE)(src)) < 0;
2119: bool flgo = ((BYTE)(dst)) < 0;
2120: bool flgn = ((BYTE)(newv)) < 0;
2121: regs.z = ((BYTE)(newv)) == 0;
2122: regs.v = (flgs == flgo) && (flgn != flgo);
2123: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2124: regs.n = flgn != 0;
2125: put_byte(dsta,newv);
2126: }}}}}}
2127: void op_5430(UWORD opcode)
2128: {
2129: ULONG srcreg = 2;
2130: ULONG dstreg = (opcode & 7) >> 0;
2131: {{ ULONG src = srcreg;
2132: { CPTR dsta = regs.a[dstreg];
2133: UWORD dstdp = nextiword();
2134: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2135: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2136: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2137: dsta += dstdpr;
2138: { BYTE dst = get_byte(dsta);
2139: { ULONG newv = dst + src;
2140: { bool flgs = ((BYTE)(src)) < 0;
2141: bool flgo = ((BYTE)(dst)) < 0;
2142: bool flgn = ((BYTE)(newv)) < 0;
2143: regs.z = ((BYTE)(newv)) == 0;
2144: regs.v = (flgs == flgo) && (flgn != flgo);
2145: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2146: regs.n = flgn != 0;
2147: put_byte(dsta,newv);
2148: }}}}}}}}
2149: void op_5438(UWORD opcode)
2150: {
2151: ULONG srcreg = 2;
2152: {{ ULONG src = srcreg;
2153: { CPTR dsta = (LONG)(WORD)nextiword();
2154: BYTE dst = get_byte(dsta);
2155: { ULONG newv = dst + src;
2156: { bool flgs = ((BYTE)(src)) < 0;
2157: bool flgo = ((BYTE)(dst)) < 0;
2158: bool flgn = ((BYTE)(newv)) < 0;
2159: regs.z = ((BYTE)(newv)) == 0;
2160: regs.v = (flgs == flgo) && (flgn != flgo);
2161: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2162: regs.n = flgn != 0;
2163: put_byte(dsta,newv);
2164: }}}}}}
2165: void op_5439(UWORD opcode)
2166: {
2167: ULONG srcreg = 2;
2168: {{ ULONG src = srcreg;
2169: { CPTR dsta = nextilong();
2170: BYTE dst = get_byte(dsta);
2171: { ULONG newv = dst + src;
2172: { bool flgs = ((BYTE)(src)) < 0;
2173: bool flgo = ((BYTE)(dst)) < 0;
2174: bool flgn = ((BYTE)(newv)) < 0;
2175: regs.z = ((BYTE)(newv)) == 0;
2176: regs.v = (flgs == flgo) && (flgn != flgo);
2177: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
2178: regs.n = flgn != 0;
2179: put_byte(dsta,newv);
2180: }}}}}}
2181: void op_5440(UWORD opcode)
2182: {
2183: ULONG srcreg = 2;
2184: ULONG dstreg = (opcode & 7) >> 0;
2185: {{ ULONG src = srcreg;
2186: { WORD dst = regs.d[dstreg];
2187: { ULONG newv = dst + src;
2188: { bool flgs = ((WORD)(src)) < 0;
2189: bool flgo = ((WORD)(dst)) < 0;
2190: bool flgn = ((WORD)(newv)) < 0;
2191: regs.z = ((WORD)(newv)) == 0;
2192: regs.v = (flgs == flgo) && (flgn != flgo);
2193: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2194: regs.n = flgn != 0;
2195: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
2196: }}}}}}
2197: void op_5448(UWORD opcode)
2198: {
2199: ULONG srcreg = 2;
2200: ULONG dstreg = (opcode & 7) >> 0;
2201: {{ ULONG src = srcreg;
2202: { LONG dst = regs.a[dstreg];
2203: { ULONG newv = dst + src;
2204: regs.a[dstreg] = (newv);
2205: }}}}}
2206: void op_5450(UWORD opcode)
2207: {
2208: ULONG srcreg = 2;
2209: ULONG dstreg = (opcode & 7) >> 0;
2210: {{ ULONG src = srcreg;
2211: { CPTR dsta = regs.a[dstreg];
2212: WORD dst = get_word(dsta);
2213: { ULONG newv = dst + src;
2214: { bool flgs = ((WORD)(src)) < 0;
2215: bool flgo = ((WORD)(dst)) < 0;
2216: bool flgn = ((WORD)(newv)) < 0;
2217: regs.z = ((WORD)(newv)) == 0;
2218: regs.v = (flgs == flgo) && (flgn != flgo);
2219: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2220: regs.n = flgn != 0;
2221: put_word(dsta,newv);
2222: }}}}}}
2223: void op_5458(UWORD opcode)
2224: {
2225: ULONG srcreg = 2;
2226: ULONG dstreg = (opcode & 7) >> 0;
2227: {{ ULONG src = srcreg;
2228: { CPTR dsta = regs.a[dstreg];
2229: WORD dst = get_word(dsta);
2230: { regs.a[dstreg] += 2;
2231: { ULONG newv = dst + src;
2232: { bool flgs = ((WORD)(src)) < 0;
2233: bool flgo = ((WORD)(dst)) < 0;
2234: bool flgn = ((WORD)(newv)) < 0;
2235: regs.z = ((WORD)(newv)) == 0;
2236: regs.v = (flgs == flgo) && (flgn != flgo);
2237: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2238: regs.n = flgn != 0;
2239: put_word(dsta,newv);
2240: }}}}}}}
2241: void op_5460(UWORD opcode)
2242: {
2243: ULONG srcreg = 2;
2244: ULONG dstreg = (opcode & 7) >> 0;
2245: {{ ULONG src = srcreg;
2246: { regs.a[dstreg] -= 2;
2247: { CPTR dsta = regs.a[dstreg];
2248: WORD dst = get_word(dsta);
2249: { ULONG newv = dst + src;
2250: { bool flgs = ((WORD)(src)) < 0;
2251: bool flgo = ((WORD)(dst)) < 0;
2252: bool flgn = ((WORD)(newv)) < 0;
2253: regs.z = ((WORD)(newv)) == 0;
2254: regs.v = (flgs == flgo) && (flgn != flgo);
2255: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2256: regs.n = flgn != 0;
2257: put_word(dsta,newv);
2258: }}}}}}}
2259: void op_5468(UWORD opcode)
2260: {
2261: ULONG srcreg = 2;
2262: ULONG dstreg = (opcode & 7) >> 0;
2263: {{ ULONG src = srcreg;
2264: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2265: WORD dst = get_word(dsta);
2266: { ULONG newv = dst + src;
2267: { bool flgs = ((WORD)(src)) < 0;
2268: bool flgo = ((WORD)(dst)) < 0;
2269: bool flgn = ((WORD)(newv)) < 0;
2270: regs.z = ((WORD)(newv)) == 0;
2271: regs.v = (flgs == flgo) && (flgn != flgo);
2272: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2273: regs.n = flgn != 0;
2274: put_word(dsta,newv);
2275: }}}}}}
2276: void op_5470(UWORD opcode)
2277: {
2278: ULONG srcreg = 2;
2279: ULONG dstreg = (opcode & 7) >> 0;
2280: {{ ULONG src = srcreg;
2281: { CPTR dsta = regs.a[dstreg];
2282: UWORD dstdp = nextiword();
2283: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2284: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2285: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2286: dsta += dstdpr;
2287: { WORD dst = get_word(dsta);
2288: { ULONG newv = dst + src;
2289: { bool flgs = ((WORD)(src)) < 0;
2290: bool flgo = ((WORD)(dst)) < 0;
2291: bool flgn = ((WORD)(newv)) < 0;
2292: regs.z = ((WORD)(newv)) == 0;
2293: regs.v = (flgs == flgo) && (flgn != flgo);
2294: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2295: regs.n = flgn != 0;
2296: put_word(dsta,newv);
2297: }}}}}}}}
2298: void op_5478(UWORD opcode)
2299: {
2300: ULONG srcreg = 2;
2301: {{ ULONG src = srcreg;
2302: { CPTR dsta = (LONG)(WORD)nextiword();
2303: WORD dst = get_word(dsta);
2304: { ULONG newv = dst + src;
2305: { bool flgs = ((WORD)(src)) < 0;
2306: bool flgo = ((WORD)(dst)) < 0;
2307: bool flgn = ((WORD)(newv)) < 0;
2308: regs.z = ((WORD)(newv)) == 0;
2309: regs.v = (flgs == flgo) && (flgn != flgo);
2310: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2311: regs.n = flgn != 0;
2312: put_word(dsta,newv);
2313: }}}}}}
2314: void op_5479(UWORD opcode)
2315: {
2316: ULONG srcreg = 2;
2317: {{ ULONG src = srcreg;
2318: { CPTR dsta = nextilong();
2319: WORD dst = get_word(dsta);
2320: { ULONG newv = dst + src;
2321: { bool flgs = ((WORD)(src)) < 0;
2322: bool flgo = ((WORD)(dst)) < 0;
2323: bool flgn = ((WORD)(newv)) < 0;
2324: regs.z = ((WORD)(newv)) == 0;
2325: regs.v = (flgs == flgo) && (flgn != flgo);
2326: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
2327: regs.n = flgn != 0;
2328: put_word(dsta,newv);
2329: }}}}}}
2330: void op_5480(UWORD opcode)
2331: {
2332: ULONG srcreg = 2;
2333: ULONG dstreg = (opcode & 7) >> 0;
2334: {{ ULONG src = srcreg;
2335: { LONG dst = regs.d[dstreg];
2336: { ULONG newv = dst + src;
2337: { bool flgs = ((LONG)(src)) < 0;
2338: bool flgo = ((LONG)(dst)) < 0;
2339: bool flgn = ((LONG)(newv)) < 0;
2340: regs.z = ((LONG)(newv)) == 0;
2341: regs.v = (flgs == flgo) && (flgn != flgo);
2342: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2343: regs.n = flgn != 0;
2344: regs.d[dstreg] = (newv);
2345: }}}}}}
2346: void op_5488(UWORD opcode)
2347: {
2348: ULONG srcreg = 2;
2349: ULONG dstreg = (opcode & 7) >> 0;
2350: {{ ULONG src = srcreg;
2351: { LONG dst = regs.a[dstreg];
2352: { ULONG newv = dst + src;
2353: regs.a[dstreg] = (newv);
2354: }}}}}
2355: void op_5490(UWORD opcode)
2356: {
2357: ULONG srcreg = 2;
2358: ULONG dstreg = (opcode & 7) >> 0;
2359: {{ ULONG src = srcreg;
2360: { CPTR dsta = regs.a[dstreg];
2361: LONG dst = get_long(dsta);
2362: { ULONG newv = dst + src;
2363: { bool flgs = ((LONG)(src)) < 0;
2364: bool flgo = ((LONG)(dst)) < 0;
2365: bool flgn = ((LONG)(newv)) < 0;
2366: regs.z = ((LONG)(newv)) == 0;
2367: regs.v = (flgs == flgo) && (flgn != flgo);
2368: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2369: regs.n = flgn != 0;
2370: put_long(dsta,newv);
2371: }}}}}}
2372: void op_5498(UWORD opcode)
2373: {
2374: ULONG srcreg = 2;
2375: ULONG dstreg = (opcode & 7) >> 0;
2376: {{ ULONG src = srcreg;
2377: { CPTR dsta = regs.a[dstreg];
2378: LONG dst = get_long(dsta);
2379: { regs.a[dstreg] += 4;
2380: { ULONG newv = dst + src;
2381: { bool flgs = ((LONG)(src)) < 0;
2382: bool flgo = ((LONG)(dst)) < 0;
2383: bool flgn = ((LONG)(newv)) < 0;
2384: regs.z = ((LONG)(newv)) == 0;
2385: regs.v = (flgs == flgo) && (flgn != flgo);
2386: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2387: regs.n = flgn != 0;
2388: put_long(dsta,newv);
2389: }}}}}}}
2390: void op_54a0(UWORD opcode)
2391: {
2392: ULONG srcreg = 2;
2393: ULONG dstreg = (opcode & 7) >> 0;
2394: {{ ULONG src = srcreg;
2395: { regs.a[dstreg] -= 4;
2396: { CPTR dsta = regs.a[dstreg];
2397: LONG dst = get_long(dsta);
2398: { ULONG newv = dst + src;
2399: { bool flgs = ((LONG)(src)) < 0;
2400: bool flgo = ((LONG)(dst)) < 0;
2401: bool flgn = ((LONG)(newv)) < 0;
2402: regs.z = ((LONG)(newv)) == 0;
2403: regs.v = (flgs == flgo) && (flgn != flgo);
2404: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2405: regs.n = flgn != 0;
2406: put_long(dsta,newv);
2407: }}}}}}}
2408: void op_54a8(UWORD opcode)
2409: {
2410: ULONG srcreg = 2;
2411: ULONG dstreg = (opcode & 7) >> 0;
2412: {{ ULONG src = srcreg;
2413: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2414: LONG dst = get_long(dsta);
2415: { ULONG newv = dst + src;
2416: { bool flgs = ((LONG)(src)) < 0;
2417: bool flgo = ((LONG)(dst)) < 0;
2418: bool flgn = ((LONG)(newv)) < 0;
2419: regs.z = ((LONG)(newv)) == 0;
2420: regs.v = (flgs == flgo) && (flgn != flgo);
2421: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2422: regs.n = flgn != 0;
2423: put_long(dsta,newv);
2424: }}}}}}
2425: void op_54b0(UWORD opcode)
2426: {
2427: ULONG srcreg = 2;
2428: ULONG dstreg = (opcode & 7) >> 0;
2429: {{ ULONG src = srcreg;
2430: { CPTR dsta = regs.a[dstreg];
2431: UWORD dstdp = nextiword();
2432: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2433: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2434: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2435: dsta += dstdpr;
2436: { LONG dst = get_long(dsta);
2437: { ULONG newv = dst + src;
2438: { bool flgs = ((LONG)(src)) < 0;
2439: bool flgo = ((LONG)(dst)) < 0;
2440: bool flgn = ((LONG)(newv)) < 0;
2441: regs.z = ((LONG)(newv)) == 0;
2442: regs.v = (flgs == flgo) && (flgn != flgo);
2443: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2444: regs.n = flgn != 0;
2445: put_long(dsta,newv);
2446: }}}}}}}}
2447: void op_54b8(UWORD opcode)
2448: {
2449: ULONG srcreg = 2;
2450: {{ ULONG src = srcreg;
2451: { CPTR dsta = (LONG)(WORD)nextiword();
2452: LONG dst = get_long(dsta);
2453: { ULONG newv = dst + src;
2454: { bool flgs = ((LONG)(src)) < 0;
2455: bool flgo = ((LONG)(dst)) < 0;
2456: bool flgn = ((LONG)(newv)) < 0;
2457: regs.z = ((LONG)(newv)) == 0;
2458: regs.v = (flgs == flgo) && (flgn != flgo);
2459: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2460: regs.n = flgn != 0;
2461: put_long(dsta,newv);
2462: }}}}}}
2463: void op_54b9(UWORD opcode)
2464: {
2465: ULONG srcreg = 2;
2466: {{ ULONG src = srcreg;
2467: { CPTR dsta = nextilong();
2468: LONG dst = get_long(dsta);
2469: { ULONG newv = dst + src;
2470: { bool flgs = ((LONG)(src)) < 0;
2471: bool flgo = ((LONG)(dst)) < 0;
2472: bool flgn = ((LONG)(newv)) < 0;
2473: regs.z = ((LONG)(newv)) == 0;
2474: regs.v = (flgs == flgo) && (flgn != flgo);
2475: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
2476: regs.n = flgn != 0;
2477: put_long(dsta,newv);
2478: }}}}}}
2479: void op_54c0(UWORD opcode)
2480: {
2481: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2482: {{{ int val = cctrue(4) ? 0xff : 0;
2483: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
2484: }}}}
2485: void op_54c8(UWORD opcode)
2486: {
2487: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2488: {{ WORD src = regs.d[srcreg];
2489: { WORD offs = nextiword();
2490: if (!cctrue(4)) {
2491: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
2492: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
2493: }
2494: }}}}
2495: void op_54d0(UWORD opcode)
2496: {
2497: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2498: {{ CPTR srca = regs.a[srcreg];
2499: { int val = cctrue(4) ? 0xff : 0;
2500: put_byte(srca,val);
2501: }}}}
2502: void op_54d8(UWORD opcode)
2503: {
2504: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2505: {{ CPTR srca = regs.a[srcreg];
2506: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
2507: { int val = cctrue(4) ? 0xff : 0;
2508: put_byte(srca,val);
2509: }}}}}
2510: void op_54e0(UWORD opcode)
2511: {
2512: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2513: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
2514: { CPTR srca = regs.a[srcreg];
2515: { int val = cctrue(4) ? 0xff : 0;
2516: put_byte(srca,val);
2517: }}}}}
2518: void op_54e8(UWORD opcode)
2519: {
2520: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2521: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
2522: { int val = cctrue(4) ? 0xff : 0;
2523: put_byte(srca,val);
2524: }}}}
2525: void op_54f0(UWORD opcode)
2526: {
2527: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2528: {{ CPTR srca = regs.a[srcreg];
2529: UWORD srcdp = nextiword();
2530: srca += (LONG)(BYTE)(srcdp & 0xFF);
2531: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
2532: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
2533: srca += srcdpr;
2534: { int val = cctrue(4) ? 0xff : 0;
2535: put_byte(srca,val);
2536: }}}}}
2537: void op_54f8(UWORD opcode)
2538: {
2539: {{ CPTR srca = (LONG)(WORD)nextiword();
2540: { int val = cctrue(4) ? 0xff : 0;
2541: put_byte(srca,val);
2542: }}}}
2543: void op_54f9(UWORD opcode)
2544: {
2545: {{ CPTR srca = nextilong();
2546: { int val = cctrue(4) ? 0xff : 0;
2547: put_byte(srca,val);
2548: }}}}
2549: void op_5500(UWORD opcode)
2550: {
2551: ULONG srcreg = 2;
2552: ULONG dstreg = (opcode & 7) >> 0;
2553: {{ ULONG src = srcreg;
2554: { BYTE dst = regs.d[dstreg];
2555: { ULONG newv = dst - src;
2556: { bool flgs = ((BYTE)(src)) < 0;
2557: bool flgo = ((BYTE)(dst)) < 0;
2558: bool flgn = ((BYTE)(newv)) < 0;
2559: regs.z = ((BYTE)(newv)) == 0;
2560: regs.v = (flgs != flgo) && (flgn != flgo);
2561: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2562: regs.n = flgn != 0;
2563: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
2564: }}}}}}
2565: void op_5510(UWORD opcode)
2566: {
2567: ULONG srcreg = 2;
2568: ULONG dstreg = (opcode & 7) >> 0;
2569: {{ ULONG src = srcreg;
2570: { CPTR dsta = regs.a[dstreg];
2571: BYTE dst = get_byte(dsta);
2572: { ULONG newv = dst - src;
2573: { bool flgs = ((BYTE)(src)) < 0;
2574: bool flgo = ((BYTE)(dst)) < 0;
2575: bool flgn = ((BYTE)(newv)) < 0;
2576: regs.z = ((BYTE)(newv)) == 0;
2577: regs.v = (flgs != flgo) && (flgn != flgo);
2578: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2579: regs.n = flgn != 0;
2580: put_byte(dsta,newv);
2581: }}}}}}
2582: void op_5518(UWORD opcode)
2583: {
2584: ULONG srcreg = 2;
2585: ULONG dstreg = (opcode & 7) >> 0;
2586: {{ ULONG src = srcreg;
2587: { CPTR dsta = regs.a[dstreg];
2588: BYTE dst = get_byte(dsta);
2589: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
2590: { ULONG newv = dst - src;
2591: { bool flgs = ((BYTE)(src)) < 0;
2592: bool flgo = ((BYTE)(dst)) < 0;
2593: bool flgn = ((BYTE)(newv)) < 0;
2594: regs.z = ((BYTE)(newv)) == 0;
2595: regs.v = (flgs != flgo) && (flgn != flgo);
2596: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2597: regs.n = flgn != 0;
2598: put_byte(dsta,newv);
2599: }}}}}}}
2600: void op_5520(UWORD opcode)
2601: {
2602: ULONG srcreg = 2;
2603: ULONG dstreg = (opcode & 7) >> 0;
2604: {{ ULONG src = srcreg;
2605: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
2606: { CPTR dsta = regs.a[dstreg];
2607: BYTE dst = get_byte(dsta);
2608: { ULONG newv = dst - src;
2609: { bool flgs = ((BYTE)(src)) < 0;
2610: bool flgo = ((BYTE)(dst)) < 0;
2611: bool flgn = ((BYTE)(newv)) < 0;
2612: regs.z = ((BYTE)(newv)) == 0;
2613: regs.v = (flgs != flgo) && (flgn != flgo);
2614: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2615: regs.n = flgn != 0;
2616: put_byte(dsta,newv);
2617: }}}}}}}
2618: void op_5528(UWORD opcode)
2619: {
2620: ULONG srcreg = 2;
2621: ULONG dstreg = (opcode & 7) >> 0;
2622: {{ ULONG src = srcreg;
2623: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2624: BYTE dst = get_byte(dsta);
2625: { ULONG newv = dst - src;
2626: { bool flgs = ((BYTE)(src)) < 0;
2627: bool flgo = ((BYTE)(dst)) < 0;
2628: bool flgn = ((BYTE)(newv)) < 0;
2629: regs.z = ((BYTE)(newv)) == 0;
2630: regs.v = (flgs != flgo) && (flgn != flgo);
2631: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2632: regs.n = flgn != 0;
2633: put_byte(dsta,newv);
2634: }}}}}}
2635: void op_5530(UWORD opcode)
2636: {
2637: ULONG srcreg = 2;
2638: ULONG dstreg = (opcode & 7) >> 0;
2639: {{ ULONG src = srcreg;
2640: { CPTR dsta = regs.a[dstreg];
2641: UWORD dstdp = nextiword();
2642: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2643: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2644: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2645: dsta += dstdpr;
2646: { BYTE dst = get_byte(dsta);
2647: { ULONG newv = dst - src;
2648: { bool flgs = ((BYTE)(src)) < 0;
2649: bool flgo = ((BYTE)(dst)) < 0;
2650: bool flgn = ((BYTE)(newv)) < 0;
2651: regs.z = ((BYTE)(newv)) == 0;
2652: regs.v = (flgs != flgo) && (flgn != flgo);
2653: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2654: regs.n = flgn != 0;
2655: put_byte(dsta,newv);
2656: }}}}}}}}
2657: void op_5538(UWORD opcode)
2658: {
2659: ULONG srcreg = 2;
2660: {{ ULONG src = srcreg;
2661: { CPTR dsta = (LONG)(WORD)nextiword();
2662: BYTE dst = get_byte(dsta);
2663: { ULONG newv = dst - src;
2664: { bool flgs = ((BYTE)(src)) < 0;
2665: bool flgo = ((BYTE)(dst)) < 0;
2666: bool flgn = ((BYTE)(newv)) < 0;
2667: regs.z = ((BYTE)(newv)) == 0;
2668: regs.v = (flgs != flgo) && (flgn != flgo);
2669: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2670: regs.n = flgn != 0;
2671: put_byte(dsta,newv);
2672: }}}}}}
2673: void op_5539(UWORD opcode)
2674: {
2675: ULONG srcreg = 2;
2676: {{ ULONG src = srcreg;
2677: { CPTR dsta = nextilong();
2678: BYTE dst = get_byte(dsta);
2679: { ULONG newv = dst - src;
2680: { bool flgs = ((BYTE)(src)) < 0;
2681: bool flgo = ((BYTE)(dst)) < 0;
2682: bool flgn = ((BYTE)(newv)) < 0;
2683: regs.z = ((BYTE)(newv)) == 0;
2684: regs.v = (flgs != flgo) && (flgn != flgo);
2685: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
2686: regs.n = flgn != 0;
2687: put_byte(dsta,newv);
2688: }}}}}}
2689: void op_5540(UWORD opcode)
2690: {
2691: ULONG srcreg = 2;
2692: ULONG dstreg = (opcode & 7) >> 0;
2693: {{ ULONG src = srcreg;
2694: { WORD dst = regs.d[dstreg];
2695: { ULONG newv = dst - src;
2696: { bool flgs = ((WORD)(src)) < 0;
2697: bool flgo = ((WORD)(dst)) < 0;
2698: bool flgn = ((WORD)(newv)) < 0;
2699: regs.z = ((WORD)(newv)) == 0;
2700: regs.v = (flgs != flgo) && (flgn != flgo);
2701: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2702: regs.n = flgn != 0;
2703: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
2704: }}}}}}
2705: void op_5548(UWORD opcode)
2706: {
2707: ULONG srcreg = 2;
2708: ULONG dstreg = (opcode & 7) >> 0;
2709: {{ ULONG src = srcreg;
2710: { LONG dst = regs.a[dstreg];
2711: { ULONG newv = dst - src;
2712: regs.a[dstreg] = (newv);
2713: }}}}}
2714: void op_5550(UWORD opcode)
2715: {
2716: ULONG srcreg = 2;
2717: ULONG dstreg = (opcode & 7) >> 0;
2718: {{ ULONG src = srcreg;
2719: { CPTR dsta = regs.a[dstreg];
2720: WORD dst = get_word(dsta);
2721: { ULONG newv = dst - src;
2722: { bool flgs = ((WORD)(src)) < 0;
2723: bool flgo = ((WORD)(dst)) < 0;
2724: bool flgn = ((WORD)(newv)) < 0;
2725: regs.z = ((WORD)(newv)) == 0;
2726: regs.v = (flgs != flgo) && (flgn != flgo);
2727: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2728: regs.n = flgn != 0;
2729: put_word(dsta,newv);
2730: }}}}}}
2731: void op_5558(UWORD opcode)
2732: {
2733: ULONG srcreg = 2;
2734: ULONG dstreg = (opcode & 7) >> 0;
2735: {{ ULONG src = srcreg;
2736: { CPTR dsta = regs.a[dstreg];
2737: WORD dst = get_word(dsta);
2738: { regs.a[dstreg] += 2;
2739: { ULONG newv = dst - src;
2740: { bool flgs = ((WORD)(src)) < 0;
2741: bool flgo = ((WORD)(dst)) < 0;
2742: bool flgn = ((WORD)(newv)) < 0;
2743: regs.z = ((WORD)(newv)) == 0;
2744: regs.v = (flgs != flgo) && (flgn != flgo);
2745: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2746: regs.n = flgn != 0;
2747: put_word(dsta,newv);
2748: }}}}}}}
2749: void op_5560(UWORD opcode)
2750: {
2751: ULONG srcreg = 2;
2752: ULONG dstreg = (opcode & 7) >> 0;
2753: {{ ULONG src = srcreg;
2754: { regs.a[dstreg] -= 2;
2755: { CPTR dsta = regs.a[dstreg];
2756: WORD dst = get_word(dsta);
2757: { ULONG newv = dst - src;
2758: { bool flgs = ((WORD)(src)) < 0;
2759: bool flgo = ((WORD)(dst)) < 0;
2760: bool flgn = ((WORD)(newv)) < 0;
2761: regs.z = ((WORD)(newv)) == 0;
2762: regs.v = (flgs != flgo) && (flgn != flgo);
2763: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2764: regs.n = flgn != 0;
2765: put_word(dsta,newv);
2766: }}}}}}}
2767: void op_5568(UWORD opcode)
2768: {
2769: ULONG srcreg = 2;
2770: ULONG dstreg = (opcode & 7) >> 0;
2771: {{ ULONG src = srcreg;
2772: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2773: WORD dst = get_word(dsta);
2774: { ULONG newv = dst - src;
2775: { bool flgs = ((WORD)(src)) < 0;
2776: bool flgo = ((WORD)(dst)) < 0;
2777: bool flgn = ((WORD)(newv)) < 0;
2778: regs.z = ((WORD)(newv)) == 0;
2779: regs.v = (flgs != flgo) && (flgn != flgo);
2780: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2781: regs.n = flgn != 0;
2782: put_word(dsta,newv);
2783: }}}}}}
2784: void op_5570(UWORD opcode)
2785: {
2786: ULONG srcreg = 2;
2787: ULONG dstreg = (opcode & 7) >> 0;
2788: {{ ULONG src = srcreg;
2789: { CPTR dsta = regs.a[dstreg];
2790: UWORD dstdp = nextiword();
2791: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2792: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2793: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2794: dsta += dstdpr;
2795: { WORD dst = get_word(dsta);
2796: { ULONG newv = dst - src;
2797: { bool flgs = ((WORD)(src)) < 0;
2798: bool flgo = ((WORD)(dst)) < 0;
2799: bool flgn = ((WORD)(newv)) < 0;
2800: regs.z = ((WORD)(newv)) == 0;
2801: regs.v = (flgs != flgo) && (flgn != flgo);
2802: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2803: regs.n = flgn != 0;
2804: put_word(dsta,newv);
2805: }}}}}}}}
2806: void op_5578(UWORD opcode)
2807: {
2808: ULONG srcreg = 2;
2809: {{ ULONG src = srcreg;
2810: { CPTR dsta = (LONG)(WORD)nextiword();
2811: WORD dst = get_word(dsta);
2812: { ULONG newv = dst - src;
2813: { bool flgs = ((WORD)(src)) < 0;
2814: bool flgo = ((WORD)(dst)) < 0;
2815: bool flgn = ((WORD)(newv)) < 0;
2816: regs.z = ((WORD)(newv)) == 0;
2817: regs.v = (flgs != flgo) && (flgn != flgo);
2818: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2819: regs.n = flgn != 0;
2820: put_word(dsta,newv);
2821: }}}}}}
2822: void op_5579(UWORD opcode)
2823: {
2824: ULONG srcreg = 2;
2825: {{ ULONG src = srcreg;
2826: { CPTR dsta = nextilong();
2827: WORD dst = get_word(dsta);
2828: { ULONG newv = dst - src;
2829: { bool flgs = ((WORD)(src)) < 0;
2830: bool flgo = ((WORD)(dst)) < 0;
2831: bool flgn = ((WORD)(newv)) < 0;
2832: regs.z = ((WORD)(newv)) == 0;
2833: regs.v = (flgs != flgo) && (flgn != flgo);
2834: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
2835: regs.n = flgn != 0;
2836: put_word(dsta,newv);
2837: }}}}}}
2838: void op_5580(UWORD opcode)
2839: {
2840: ULONG srcreg = 2;
2841: ULONG dstreg = (opcode & 7) >> 0;
2842: {{ ULONG src = srcreg;
2843: { LONG dst = regs.d[dstreg];
2844: { ULONG newv = dst - src;
2845: { bool flgs = ((LONG)(src)) < 0;
2846: bool flgo = ((LONG)(dst)) < 0;
2847: bool flgn = ((LONG)(newv)) < 0;
2848: regs.z = ((LONG)(newv)) == 0;
2849: regs.v = (flgs != flgo) && (flgn != flgo);
2850: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2851: regs.n = flgn != 0;
2852: regs.d[dstreg] = (newv);
2853: }}}}}}
2854: void op_5588(UWORD opcode)
2855: {
2856: ULONG srcreg = 2;
2857: ULONG dstreg = (opcode & 7) >> 0;
2858: {{ ULONG src = srcreg;
2859: { LONG dst = regs.a[dstreg];
2860: { ULONG newv = dst - src;
2861: regs.a[dstreg] = (newv);
2862: }}}}}
2863: void op_5590(UWORD opcode)
2864: {
2865: ULONG srcreg = 2;
2866: ULONG dstreg = (opcode & 7) >> 0;
2867: {{ ULONG src = srcreg;
2868: { CPTR dsta = regs.a[dstreg];
2869: LONG dst = get_long(dsta);
2870: { ULONG newv = dst - src;
2871: { bool flgs = ((LONG)(src)) < 0;
2872: bool flgo = ((LONG)(dst)) < 0;
2873: bool flgn = ((LONG)(newv)) < 0;
2874: regs.z = ((LONG)(newv)) == 0;
2875: regs.v = (flgs != flgo) && (flgn != flgo);
2876: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2877: regs.n = flgn != 0;
2878: put_long(dsta,newv);
2879: }}}}}}
2880: void op_5598(UWORD opcode)
2881: {
2882: ULONG srcreg = 2;
2883: ULONG dstreg = (opcode & 7) >> 0;
2884: {{ ULONG src = srcreg;
2885: { CPTR dsta = regs.a[dstreg];
2886: LONG dst = get_long(dsta);
2887: { regs.a[dstreg] += 4;
2888: { ULONG newv = dst - src;
2889: { bool flgs = ((LONG)(src)) < 0;
2890: bool flgo = ((LONG)(dst)) < 0;
2891: bool flgn = ((LONG)(newv)) < 0;
2892: regs.z = ((LONG)(newv)) == 0;
2893: regs.v = (flgs != flgo) && (flgn != flgo);
2894: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2895: regs.n = flgn != 0;
2896: put_long(dsta,newv);
2897: }}}}}}}
2898: void op_55a0(UWORD opcode)
2899: {
2900: ULONG srcreg = 2;
2901: ULONG dstreg = (opcode & 7) >> 0;
2902: {{ ULONG src = srcreg;
2903: { regs.a[dstreg] -= 4;
2904: { CPTR dsta = regs.a[dstreg];
2905: LONG dst = get_long(dsta);
2906: { ULONG newv = dst - src;
2907: { bool flgs = ((LONG)(src)) < 0;
2908: bool flgo = ((LONG)(dst)) < 0;
2909: bool flgn = ((LONG)(newv)) < 0;
2910: regs.z = ((LONG)(newv)) == 0;
2911: regs.v = (flgs != flgo) && (flgn != flgo);
2912: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2913: regs.n = flgn != 0;
2914: put_long(dsta,newv);
2915: }}}}}}}
2916: void op_55a8(UWORD opcode)
2917: {
2918: ULONG srcreg = 2;
2919: ULONG dstreg = (opcode & 7) >> 0;
2920: {{ ULONG src = srcreg;
2921: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
2922: LONG dst = get_long(dsta);
2923: { ULONG newv = dst - src;
2924: { bool flgs = ((LONG)(src)) < 0;
2925: bool flgo = ((LONG)(dst)) < 0;
2926: bool flgn = ((LONG)(newv)) < 0;
2927: regs.z = ((LONG)(newv)) == 0;
2928: regs.v = (flgs != flgo) && (flgn != flgo);
2929: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2930: regs.n = flgn != 0;
2931: put_long(dsta,newv);
2932: }}}}}}
2933: void op_55b0(UWORD opcode)
2934: {
2935: ULONG srcreg = 2;
2936: ULONG dstreg = (opcode & 7) >> 0;
2937: {{ ULONG src = srcreg;
2938: { CPTR dsta = regs.a[dstreg];
2939: UWORD dstdp = nextiword();
2940: dsta += (LONG)(BYTE)(dstdp & 0xFF);
2941: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
2942: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
2943: dsta += dstdpr;
2944: { LONG dst = get_long(dsta);
2945: { ULONG newv = dst - src;
2946: { bool flgs = ((LONG)(src)) < 0;
2947: bool flgo = ((LONG)(dst)) < 0;
2948: bool flgn = ((LONG)(newv)) < 0;
2949: regs.z = ((LONG)(newv)) == 0;
2950: regs.v = (flgs != flgo) && (flgn != flgo);
2951: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2952: regs.n = flgn != 0;
2953: put_long(dsta,newv);
2954: }}}}}}}}
2955: void op_55b8(UWORD opcode)
2956: {
2957: ULONG srcreg = 2;
2958: {{ ULONG src = srcreg;
2959: { CPTR dsta = (LONG)(WORD)nextiword();
2960: LONG dst = get_long(dsta);
2961: { ULONG newv = dst - src;
2962: { bool flgs = ((LONG)(src)) < 0;
2963: bool flgo = ((LONG)(dst)) < 0;
2964: bool flgn = ((LONG)(newv)) < 0;
2965: regs.z = ((LONG)(newv)) == 0;
2966: regs.v = (flgs != flgo) && (flgn != flgo);
2967: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2968: regs.n = flgn != 0;
2969: put_long(dsta,newv);
2970: }}}}}}
2971: void op_55b9(UWORD opcode)
2972: {
2973: ULONG srcreg = 2;
2974: {{ ULONG src = srcreg;
2975: { CPTR dsta = nextilong();
2976: LONG dst = get_long(dsta);
2977: { ULONG newv = dst - src;
2978: { bool flgs = ((LONG)(src)) < 0;
2979: bool flgo = ((LONG)(dst)) < 0;
2980: bool flgn = ((LONG)(newv)) < 0;
2981: regs.z = ((LONG)(newv)) == 0;
2982: regs.v = (flgs != flgo) && (flgn != flgo);
2983: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
2984: regs.n = flgn != 0;
2985: put_long(dsta,newv);
2986: }}}}}}
2987: void op_55c0(UWORD opcode)
2988: {
2989: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2990: {{{ int val = cctrue(5) ? 0xff : 0;
2991: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
2992: }}}}
2993: void op_55c8(UWORD opcode)
2994: {
2995: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
2996: {{ WORD src = regs.d[srcreg];
2997: { WORD offs = nextiword();
2998: if (!cctrue(5)) {
2999: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
3000: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
3001: }
3002: }}}}
3003: void op_55d0(UWORD opcode)
3004: {
3005: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3006: {{ CPTR srca = regs.a[srcreg];
3007: { int val = cctrue(5) ? 0xff : 0;
3008: put_byte(srca,val);
3009: }}}}
3010: void op_55d8(UWORD opcode)
3011: {
3012: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3013: {{ CPTR srca = regs.a[srcreg];
3014: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
3015: { int val = cctrue(5) ? 0xff : 0;
3016: put_byte(srca,val);
3017: }}}}}
3018: void op_55e0(UWORD opcode)
3019: {
3020: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3021: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
3022: { CPTR srca = regs.a[srcreg];
3023: { int val = cctrue(5) ? 0xff : 0;
3024: put_byte(srca,val);
3025: }}}}}
3026: void op_55e8(UWORD opcode)
3027: {
3028: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3029: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
3030: { int val = cctrue(5) ? 0xff : 0;
3031: put_byte(srca,val);
3032: }}}}
3033: void op_55f0(UWORD opcode)
3034: {
3035: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3036: {{ CPTR srca = regs.a[srcreg];
3037: UWORD srcdp = nextiword();
3038: srca += (LONG)(BYTE)(srcdp & 0xFF);
3039: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
3040: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
3041: srca += srcdpr;
3042: { int val = cctrue(5) ? 0xff : 0;
3043: put_byte(srca,val);
3044: }}}}}
3045: void op_55f8(UWORD opcode)
3046: {
3047: {{ CPTR srca = (LONG)(WORD)nextiword();
3048: { int val = cctrue(5) ? 0xff : 0;
3049: put_byte(srca,val);
3050: }}}}
3051: void op_55f9(UWORD opcode)
3052: {
3053: {{ CPTR srca = nextilong();
3054: { int val = cctrue(5) ? 0xff : 0;
3055: put_byte(srca,val);
3056: }}}}
3057: void op_5600(UWORD opcode)
3058: {
3059: ULONG srcreg = 3;
3060: ULONG dstreg = (opcode & 7) >> 0;
3061: {{ ULONG src = srcreg;
3062: { BYTE dst = regs.d[dstreg];
3063: { ULONG newv = dst + src;
3064: { bool flgs = ((BYTE)(src)) < 0;
3065: bool flgo = ((BYTE)(dst)) < 0;
3066: bool flgn = ((BYTE)(newv)) < 0;
3067: regs.z = ((BYTE)(newv)) == 0;
3068: regs.v = (flgs == flgo) && (flgn != flgo);
3069: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3070: regs.n = flgn != 0;
3071: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
3072: }}}}}}
3073: void op_5610(UWORD opcode)
3074: {
3075: ULONG srcreg = 3;
3076: ULONG dstreg = (opcode & 7) >> 0;
3077: {{ ULONG src = srcreg;
3078: { CPTR dsta = regs.a[dstreg];
3079: BYTE dst = get_byte(dsta);
3080: { ULONG newv = dst + src;
3081: { bool flgs = ((BYTE)(src)) < 0;
3082: bool flgo = ((BYTE)(dst)) < 0;
3083: bool flgn = ((BYTE)(newv)) < 0;
3084: regs.z = ((BYTE)(newv)) == 0;
3085: regs.v = (flgs == flgo) && (flgn != flgo);
3086: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3087: regs.n = flgn != 0;
3088: put_byte(dsta,newv);
3089: }}}}}}
3090: void op_5618(UWORD opcode)
3091: {
3092: ULONG srcreg = 3;
3093: ULONG dstreg = (opcode & 7) >> 0;
3094: {{ ULONG src = srcreg;
3095: { CPTR dsta = regs.a[dstreg];
3096: BYTE dst = get_byte(dsta);
3097: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
3098: { ULONG newv = dst + src;
3099: { bool flgs = ((BYTE)(src)) < 0;
3100: bool flgo = ((BYTE)(dst)) < 0;
3101: bool flgn = ((BYTE)(newv)) < 0;
3102: regs.z = ((BYTE)(newv)) == 0;
3103: regs.v = (flgs == flgo) && (flgn != flgo);
3104: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3105: regs.n = flgn != 0;
3106: put_byte(dsta,newv);
3107: }}}}}}}
3108: void op_5620(UWORD opcode)
3109: {
3110: ULONG srcreg = 3;
3111: ULONG dstreg = (opcode & 7) >> 0;
3112: {{ ULONG src = srcreg;
3113: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
3114: { CPTR dsta = regs.a[dstreg];
3115: BYTE dst = get_byte(dsta);
3116: { ULONG newv = dst + src;
3117: { bool flgs = ((BYTE)(src)) < 0;
3118: bool flgo = ((BYTE)(dst)) < 0;
3119: bool flgn = ((BYTE)(newv)) < 0;
3120: regs.z = ((BYTE)(newv)) == 0;
3121: regs.v = (flgs == flgo) && (flgn != flgo);
3122: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3123: regs.n = flgn != 0;
3124: put_byte(dsta,newv);
3125: }}}}}}}
3126: void op_5628(UWORD opcode)
3127: {
3128: ULONG srcreg = 3;
3129: ULONG dstreg = (opcode & 7) >> 0;
3130: {{ ULONG src = srcreg;
3131: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
3132: BYTE dst = get_byte(dsta);
3133: { ULONG newv = dst + src;
3134: { bool flgs = ((BYTE)(src)) < 0;
3135: bool flgo = ((BYTE)(dst)) < 0;
3136: bool flgn = ((BYTE)(newv)) < 0;
3137: regs.z = ((BYTE)(newv)) == 0;
3138: regs.v = (flgs == flgo) && (flgn != flgo);
3139: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3140: regs.n = flgn != 0;
3141: put_byte(dsta,newv);
3142: }}}}}}
3143: void op_5630(UWORD opcode)
3144: {
3145: ULONG srcreg = 3;
3146: ULONG dstreg = (opcode & 7) >> 0;
3147: {{ ULONG src = srcreg;
3148: { CPTR dsta = regs.a[dstreg];
3149: UWORD dstdp = nextiword();
3150: dsta += (LONG)(BYTE)(dstdp & 0xFF);
3151: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
3152: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
3153: dsta += dstdpr;
3154: { BYTE dst = get_byte(dsta);
3155: { ULONG newv = dst + src;
3156: { bool flgs = ((BYTE)(src)) < 0;
3157: bool flgo = ((BYTE)(dst)) < 0;
3158: bool flgn = ((BYTE)(newv)) < 0;
3159: regs.z = ((BYTE)(newv)) == 0;
3160: regs.v = (flgs == flgo) && (flgn != flgo);
3161: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3162: regs.n = flgn != 0;
3163: put_byte(dsta,newv);
3164: }}}}}}}}
3165: void op_5638(UWORD opcode)
3166: {
3167: ULONG srcreg = 3;
3168: {{ ULONG src = srcreg;
3169: { CPTR dsta = (LONG)(WORD)nextiword();
3170: BYTE dst = get_byte(dsta);
3171: { ULONG newv = dst + src;
3172: { bool flgs = ((BYTE)(src)) < 0;
3173: bool flgo = ((BYTE)(dst)) < 0;
3174: bool flgn = ((BYTE)(newv)) < 0;
3175: regs.z = ((BYTE)(newv)) == 0;
3176: regs.v = (flgs == flgo) && (flgn != flgo);
3177: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3178: regs.n = flgn != 0;
3179: put_byte(dsta,newv);
3180: }}}}}}
3181: void op_5639(UWORD opcode)
3182: {
3183: ULONG srcreg = 3;
3184: {{ ULONG src = srcreg;
3185: { CPTR dsta = nextilong();
3186: BYTE dst = get_byte(dsta);
3187: { ULONG newv = dst + src;
3188: { bool flgs = ((BYTE)(src)) < 0;
3189: bool flgo = ((BYTE)(dst)) < 0;
3190: bool flgn = ((BYTE)(newv)) < 0;
3191: regs.z = ((BYTE)(newv)) == 0;
3192: regs.v = (flgs == flgo) && (flgn != flgo);
3193: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
3194: regs.n = flgn != 0;
3195: put_byte(dsta,newv);
3196: }}}}}}
3197: void op_5640(UWORD opcode)
3198: {
3199: ULONG srcreg = 3;
3200: ULONG dstreg = (opcode & 7) >> 0;
3201: {{ ULONG src = srcreg;
3202: { WORD dst = regs.d[dstreg];
3203: { ULONG newv = dst + src;
3204: { bool flgs = ((WORD)(src)) < 0;
3205: bool flgo = ((WORD)(dst)) < 0;
3206: bool flgn = ((WORD)(newv)) < 0;
3207: regs.z = ((WORD)(newv)) == 0;
3208: regs.v = (flgs == flgo) && (flgn != flgo);
3209: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3210: regs.n = flgn != 0;
3211: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
3212: }}}}}}
3213: void op_5648(UWORD opcode)
3214: {
3215: ULONG srcreg = 3;
3216: ULONG dstreg = (opcode & 7) >> 0;
3217: {{ ULONG src = srcreg;
3218: { LONG dst = regs.a[dstreg];
3219: { ULONG newv = dst + src;
3220: regs.a[dstreg] = (newv);
3221: }}}}}
3222: void op_5650(UWORD opcode)
3223: {
3224: ULONG srcreg = 3;
3225: ULONG dstreg = (opcode & 7) >> 0;
3226: {{ ULONG src = srcreg;
3227: { CPTR dsta = regs.a[dstreg];
3228: WORD dst = get_word(dsta);
3229: { ULONG newv = dst + src;
3230: { bool flgs = ((WORD)(src)) < 0;
3231: bool flgo = ((WORD)(dst)) < 0;
3232: bool flgn = ((WORD)(newv)) < 0;
3233: regs.z = ((WORD)(newv)) == 0;
3234: regs.v = (flgs == flgo) && (flgn != flgo);
3235: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3236: regs.n = flgn != 0;
3237: put_word(dsta,newv);
3238: }}}}}}
3239: void op_5658(UWORD opcode)
3240: {
3241: ULONG srcreg = 3;
3242: ULONG dstreg = (opcode & 7) >> 0;
3243: {{ ULONG src = srcreg;
3244: { CPTR dsta = regs.a[dstreg];
3245: WORD dst = get_word(dsta);
3246: { regs.a[dstreg] += 2;
3247: { ULONG newv = dst + src;
3248: { bool flgs = ((WORD)(src)) < 0;
3249: bool flgo = ((WORD)(dst)) < 0;
3250: bool flgn = ((WORD)(newv)) < 0;
3251: regs.z = ((WORD)(newv)) == 0;
3252: regs.v = (flgs == flgo) && (flgn != flgo);
3253: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3254: regs.n = flgn != 0;
3255: put_word(dsta,newv);
3256: }}}}}}}
3257: void op_5660(UWORD opcode)
3258: {
3259: ULONG srcreg = 3;
3260: ULONG dstreg = (opcode & 7) >> 0;
3261: {{ ULONG src = srcreg;
3262: { regs.a[dstreg] -= 2;
3263: { CPTR dsta = regs.a[dstreg];
3264: WORD dst = get_word(dsta);
3265: { ULONG newv = dst + src;
3266: { bool flgs = ((WORD)(src)) < 0;
3267: bool flgo = ((WORD)(dst)) < 0;
3268: bool flgn = ((WORD)(newv)) < 0;
3269: regs.z = ((WORD)(newv)) == 0;
3270: regs.v = (flgs == flgo) && (flgn != flgo);
3271: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3272: regs.n = flgn != 0;
3273: put_word(dsta,newv);
3274: }}}}}}}
3275: void op_5668(UWORD opcode)
3276: {
3277: ULONG srcreg = 3;
3278: ULONG dstreg = (opcode & 7) >> 0;
3279: {{ ULONG src = srcreg;
3280: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
3281: WORD dst = get_word(dsta);
3282: { ULONG newv = dst + src;
3283: { bool flgs = ((WORD)(src)) < 0;
3284: bool flgo = ((WORD)(dst)) < 0;
3285: bool flgn = ((WORD)(newv)) < 0;
3286: regs.z = ((WORD)(newv)) == 0;
3287: regs.v = (flgs == flgo) && (flgn != flgo);
3288: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3289: regs.n = flgn != 0;
3290: put_word(dsta,newv);
3291: }}}}}}
3292: void op_5670(UWORD opcode)
3293: {
3294: ULONG srcreg = 3;
3295: ULONG dstreg = (opcode & 7) >> 0;
3296: {{ ULONG src = srcreg;
3297: { CPTR dsta = regs.a[dstreg];
3298: UWORD dstdp = nextiword();
3299: dsta += (LONG)(BYTE)(dstdp & 0xFF);
3300: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
3301: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
3302: dsta += dstdpr;
3303: { WORD dst = get_word(dsta);
3304: { ULONG newv = dst + src;
3305: { bool flgs = ((WORD)(src)) < 0;
3306: bool flgo = ((WORD)(dst)) < 0;
3307: bool flgn = ((WORD)(newv)) < 0;
3308: regs.z = ((WORD)(newv)) == 0;
3309: regs.v = (flgs == flgo) && (flgn != flgo);
3310: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3311: regs.n = flgn != 0;
3312: put_word(dsta,newv);
3313: }}}}}}}}
3314: void op_5678(UWORD opcode)
3315: {
3316: ULONG srcreg = 3;
3317: {{ ULONG src = srcreg;
3318: { CPTR dsta = (LONG)(WORD)nextiword();
3319: WORD dst = get_word(dsta);
3320: { ULONG newv = dst + src;
3321: { bool flgs = ((WORD)(src)) < 0;
3322: bool flgo = ((WORD)(dst)) < 0;
3323: bool flgn = ((WORD)(newv)) < 0;
3324: regs.z = ((WORD)(newv)) == 0;
3325: regs.v = (flgs == flgo) && (flgn != flgo);
3326: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3327: regs.n = flgn != 0;
3328: put_word(dsta,newv);
3329: }}}}}}
3330: void op_5679(UWORD opcode)
3331: {
3332: ULONG srcreg = 3;
3333: {{ ULONG src = srcreg;
3334: { CPTR dsta = nextilong();
3335: WORD dst = get_word(dsta);
3336: { ULONG newv = dst + src;
3337: { bool flgs = ((WORD)(src)) < 0;
3338: bool flgo = ((WORD)(dst)) < 0;
3339: bool flgn = ((WORD)(newv)) < 0;
3340: regs.z = ((WORD)(newv)) == 0;
3341: regs.v = (flgs == flgo) && (flgn != flgo);
3342: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
3343: regs.n = flgn != 0;
3344: put_word(dsta,newv);
3345: }}}}}}
3346: void op_5680(UWORD opcode)
3347: {
3348: ULONG srcreg = 3;
3349: ULONG dstreg = (opcode & 7) >> 0;
3350: {{ ULONG src = srcreg;
3351: { LONG dst = regs.d[dstreg];
3352: { ULONG newv = dst + src;
3353: { bool flgs = ((LONG)(src)) < 0;
3354: bool flgo = ((LONG)(dst)) < 0;
3355: bool flgn = ((LONG)(newv)) < 0;
3356: regs.z = ((LONG)(newv)) == 0;
3357: regs.v = (flgs == flgo) && (flgn != flgo);
3358: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3359: regs.n = flgn != 0;
3360: regs.d[dstreg] = (newv);
3361: }}}}}}
3362: void op_5688(UWORD opcode)
3363: {
3364: ULONG srcreg = 3;
3365: ULONG dstreg = (opcode & 7) >> 0;
3366: {{ ULONG src = srcreg;
3367: { LONG dst = regs.a[dstreg];
3368: { ULONG newv = dst + src;
3369: regs.a[dstreg] = (newv);
3370: }}}}}
3371: void op_5690(UWORD opcode)
3372: {
3373: ULONG srcreg = 3;
3374: ULONG dstreg = (opcode & 7) >> 0;
3375: {{ ULONG src = srcreg;
3376: { CPTR dsta = regs.a[dstreg];
3377: LONG dst = get_long(dsta);
3378: { ULONG newv = dst + src;
3379: { bool flgs = ((LONG)(src)) < 0;
3380: bool flgo = ((LONG)(dst)) < 0;
3381: bool flgn = ((LONG)(newv)) < 0;
3382: regs.z = ((LONG)(newv)) == 0;
3383: regs.v = (flgs == flgo) && (flgn != flgo);
3384: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3385: regs.n = flgn != 0;
3386: put_long(dsta,newv);
3387: }}}}}}
3388: void op_5698(UWORD opcode)
3389: {
3390: ULONG srcreg = 3;
3391: ULONG dstreg = (opcode & 7) >> 0;
3392: {{ ULONG src = srcreg;
3393: { CPTR dsta = regs.a[dstreg];
3394: LONG dst = get_long(dsta);
3395: { regs.a[dstreg] += 4;
3396: { ULONG newv = dst + src;
3397: { bool flgs = ((LONG)(src)) < 0;
3398: bool flgo = ((LONG)(dst)) < 0;
3399: bool flgn = ((LONG)(newv)) < 0;
3400: regs.z = ((LONG)(newv)) == 0;
3401: regs.v = (flgs == flgo) && (flgn != flgo);
3402: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3403: regs.n = flgn != 0;
3404: put_long(dsta,newv);
3405: }}}}}}}
3406: void op_56a0(UWORD opcode)
3407: {
3408: ULONG srcreg = 3;
3409: ULONG dstreg = (opcode & 7) >> 0;
3410: {{ ULONG src = srcreg;
3411: { regs.a[dstreg] -= 4;
3412: { CPTR dsta = regs.a[dstreg];
3413: LONG dst = get_long(dsta);
3414: { ULONG newv = dst + src;
3415: { bool flgs = ((LONG)(src)) < 0;
3416: bool flgo = ((LONG)(dst)) < 0;
3417: bool flgn = ((LONG)(newv)) < 0;
3418: regs.z = ((LONG)(newv)) == 0;
3419: regs.v = (flgs == flgo) && (flgn != flgo);
3420: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3421: regs.n = flgn != 0;
3422: put_long(dsta,newv);
3423: }}}}}}}
3424: void op_56a8(UWORD opcode)
3425: {
3426: ULONG srcreg = 3;
3427: ULONG dstreg = (opcode & 7) >> 0;
3428: {{ ULONG src = srcreg;
3429: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
3430: LONG dst = get_long(dsta);
3431: { ULONG newv = dst + src;
3432: { bool flgs = ((LONG)(src)) < 0;
3433: bool flgo = ((LONG)(dst)) < 0;
3434: bool flgn = ((LONG)(newv)) < 0;
3435: regs.z = ((LONG)(newv)) == 0;
3436: regs.v = (flgs == flgo) && (flgn != flgo);
3437: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3438: regs.n = flgn != 0;
3439: put_long(dsta,newv);
3440: }}}}}}
3441: void op_56b0(UWORD opcode)
3442: {
3443: ULONG srcreg = 3;
3444: ULONG dstreg = (opcode & 7) >> 0;
3445: {{ ULONG src = srcreg;
3446: { CPTR dsta = regs.a[dstreg];
3447: UWORD dstdp = nextiword();
3448: dsta += (LONG)(BYTE)(dstdp & 0xFF);
3449: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
3450: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
3451: dsta += dstdpr;
3452: { LONG dst = get_long(dsta);
3453: { ULONG newv = dst + src;
3454: { bool flgs = ((LONG)(src)) < 0;
3455: bool flgo = ((LONG)(dst)) < 0;
3456: bool flgn = ((LONG)(newv)) < 0;
3457: regs.z = ((LONG)(newv)) == 0;
3458: regs.v = (flgs == flgo) && (flgn != flgo);
3459: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3460: regs.n = flgn != 0;
3461: put_long(dsta,newv);
3462: }}}}}}}}
3463: void op_56b8(UWORD opcode)
3464: {
3465: ULONG srcreg = 3;
3466: {{ ULONG src = srcreg;
3467: { CPTR dsta = (LONG)(WORD)nextiword();
3468: LONG dst = get_long(dsta);
3469: { ULONG newv = dst + src;
3470: { bool flgs = ((LONG)(src)) < 0;
3471: bool flgo = ((LONG)(dst)) < 0;
3472: bool flgn = ((LONG)(newv)) < 0;
3473: regs.z = ((LONG)(newv)) == 0;
3474: regs.v = (flgs == flgo) && (flgn != flgo);
3475: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3476: regs.n = flgn != 0;
3477: put_long(dsta,newv);
3478: }}}}}}
3479: void op_56b9(UWORD opcode)
3480: {
3481: ULONG srcreg = 3;
3482: {{ ULONG src = srcreg;
3483: { CPTR dsta = nextilong();
3484: LONG dst = get_long(dsta);
3485: { ULONG newv = dst + src;
3486: { bool flgs = ((LONG)(src)) < 0;
3487: bool flgo = ((LONG)(dst)) < 0;
3488: bool flgn = ((LONG)(newv)) < 0;
3489: regs.z = ((LONG)(newv)) == 0;
3490: regs.v = (flgs == flgo) && (flgn != flgo);
3491: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
3492: regs.n = flgn != 0;
3493: put_long(dsta,newv);
3494: }}}}}}
3495: void op_56c0(UWORD opcode)
3496: {
3497: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3498: {{{ int val = cctrue(6) ? 0xff : 0;
3499: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
3500: }}}}
3501: void op_56c8(UWORD opcode)
3502: {
3503: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3504: {{ WORD src = regs.d[srcreg];
3505: { WORD offs = nextiword();
3506: if (!cctrue(6)) {
3507: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
3508: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
3509: }
3510: }}}}
3511: void op_56d0(UWORD opcode)
3512: {
3513: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3514: {{ CPTR srca = regs.a[srcreg];
3515: { int val = cctrue(6) ? 0xff : 0;
3516: put_byte(srca,val);
3517: }}}}
3518: void op_56d8(UWORD opcode)
3519: {
3520: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3521: {{ CPTR srca = regs.a[srcreg];
3522: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
3523: { int val = cctrue(6) ? 0xff : 0;
3524: put_byte(srca,val);
3525: }}}}}
3526: void op_56e0(UWORD opcode)
3527: {
3528: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3529: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
3530: { CPTR srca = regs.a[srcreg];
3531: { int val = cctrue(6) ? 0xff : 0;
3532: put_byte(srca,val);
3533: }}}}}
3534: void op_56e8(UWORD opcode)
3535: {
3536: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3537: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
3538: { int val = cctrue(6) ? 0xff : 0;
3539: put_byte(srca,val);
3540: }}}}
3541: void op_56f0(UWORD opcode)
3542: {
3543: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
3544: {{ CPTR srca = regs.a[srcreg];
3545: UWORD srcdp = nextiword();
3546: srca += (LONG)(BYTE)(srcdp & 0xFF);
3547: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
3548: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
3549: srca += srcdpr;
3550: { int val = cctrue(6) ? 0xff : 0;
3551: put_byte(srca,val);
3552: }}}}}
3553: void op_56f8(UWORD opcode)
3554: {
3555: {{ CPTR srca = (LONG)(WORD)nextiword();
3556: { int val = cctrue(6) ? 0xff : 0;
3557: put_byte(srca,val);
3558: }}}}
3559: void op_56f9(UWORD opcode)
3560: {
3561: {{ CPTR srca = nextilong();
3562: { int val = cctrue(6) ? 0xff : 0;
3563: put_byte(srca,val);
3564: }}}}
3565: void op_5700(UWORD opcode)
3566: {
3567: ULONG srcreg = 3;
3568: ULONG dstreg = (opcode & 7) >> 0;
3569: {{ ULONG src = srcreg;
3570: { BYTE dst = regs.d[dstreg];
3571: { ULONG newv = dst - src;
3572: { bool flgs = ((BYTE)(src)) < 0;
3573: bool flgo = ((BYTE)(dst)) < 0;
3574: bool flgn = ((BYTE)(newv)) < 0;
3575: regs.z = ((BYTE)(newv)) == 0;
3576: regs.v = (flgs != flgo) && (flgn != flgo);
3577: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3578: regs.n = flgn != 0;
3579: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
3580: }}}}}}
3581: void op_5710(UWORD opcode)
3582: {
3583: ULONG srcreg = 3;
3584: ULONG dstreg = (opcode & 7) >> 0;
3585: {{ ULONG src = srcreg;
3586: { CPTR dsta = regs.a[dstreg];
3587: BYTE dst = get_byte(dsta);
3588: { ULONG newv = dst - src;
3589: { bool flgs = ((BYTE)(src)) < 0;
3590: bool flgo = ((BYTE)(dst)) < 0;
3591: bool flgn = ((BYTE)(newv)) < 0;
3592: regs.z = ((BYTE)(newv)) == 0;
3593: regs.v = (flgs != flgo) && (flgn != flgo);
3594: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3595: regs.n = flgn != 0;
3596: put_byte(dsta,newv);
3597: }}}}}}
3598: void op_5718(UWORD opcode)
3599: {
3600: ULONG srcreg = 3;
3601: ULONG dstreg = (opcode & 7) >> 0;
3602: {{ ULONG src = srcreg;
3603: { CPTR dsta = regs.a[dstreg];
3604: BYTE dst = get_byte(dsta);
3605: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
3606: { ULONG newv = dst - src;
3607: { bool flgs = ((BYTE)(src)) < 0;
3608: bool flgo = ((BYTE)(dst)) < 0;
3609: bool flgn = ((BYTE)(newv)) < 0;
3610: regs.z = ((BYTE)(newv)) == 0;
3611: regs.v = (flgs != flgo) && (flgn != flgo);
3612: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3613: regs.n = flgn != 0;
3614: put_byte(dsta,newv);
3615: }}}}}}}
3616: void op_5720(UWORD opcode)
3617: {
3618: ULONG srcreg = 3;
3619: ULONG dstreg = (opcode & 7) >> 0;
3620: {{ ULONG src = srcreg;
3621: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
3622: { CPTR dsta = regs.a[dstreg];
3623: BYTE dst = get_byte(dsta);
3624: { ULONG newv = dst - src;
3625: { bool flgs = ((BYTE)(src)) < 0;
3626: bool flgo = ((BYTE)(dst)) < 0;
3627: bool flgn = ((BYTE)(newv)) < 0;
3628: regs.z = ((BYTE)(newv)) == 0;
3629: regs.v = (flgs != flgo) && (flgn != flgo);
3630: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3631: regs.n = flgn != 0;
3632: put_byte(dsta,newv);
3633: }}}}}}}
3634: void op_5728(UWORD opcode)
3635: {
3636: ULONG srcreg = 3;
3637: ULONG dstreg = (opcode & 7) >> 0;
3638: {{ ULONG src = srcreg;
3639: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
3640: BYTE dst = get_byte(dsta);
3641: { ULONG newv = dst - src;
3642: { bool flgs = ((BYTE)(src)) < 0;
3643: bool flgo = ((BYTE)(dst)) < 0;
3644: bool flgn = ((BYTE)(newv)) < 0;
3645: regs.z = ((BYTE)(newv)) == 0;
3646: regs.v = (flgs != flgo) && (flgn != flgo);
3647: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3648: regs.n = flgn != 0;
3649: put_byte(dsta,newv);
3650: }}}}}}
3651: void op_5730(UWORD opcode)
3652: {
3653: ULONG srcreg = 3;
3654: ULONG dstreg = (opcode & 7) >> 0;
3655: {{ ULONG src = srcreg;
3656: { CPTR dsta = regs.a[dstreg];
3657: UWORD dstdp = nextiword();
3658: dsta += (LONG)(BYTE)(dstdp & 0xFF);
3659: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
3660: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
3661: dsta += dstdpr;
3662: { BYTE dst = get_byte(dsta);
3663: { ULONG newv = dst - src;
3664: { bool flgs = ((BYTE)(src)) < 0;
3665: bool flgo = ((BYTE)(dst)) < 0;
3666: bool flgn = ((BYTE)(newv)) < 0;
3667: regs.z = ((BYTE)(newv)) == 0;
3668: regs.v = (flgs != flgo) && (flgn != flgo);
3669: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3670: regs.n = flgn != 0;
3671: put_byte(dsta,newv);
3672: }}}}}}}}
3673: void op_5738(UWORD opcode)
3674: {
3675: ULONG srcreg = 3;
3676: {{ ULONG src = srcreg;
3677: { CPTR dsta = (LONG)(WORD)nextiword();
3678: BYTE dst = get_byte(dsta);
3679: { ULONG newv = dst - src;
3680: { bool flgs = ((BYTE)(src)) < 0;
3681: bool flgo = ((BYTE)(dst)) < 0;
3682: bool flgn = ((BYTE)(newv)) < 0;
3683: regs.z = ((BYTE)(newv)) == 0;
3684: regs.v = (flgs != flgo) && (flgn != flgo);
3685: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3686: regs.n = flgn != 0;
3687: put_byte(dsta,newv);
3688: }}}}}}
3689: void op_5739(UWORD opcode)
3690: {
3691: ULONG srcreg = 3;
3692: {{ ULONG src = srcreg;
3693: { CPTR dsta = nextilong();
3694: BYTE dst = get_byte(dsta);
3695: { ULONG newv = dst - src;
3696: { bool flgs = ((BYTE)(src)) < 0;
3697: bool flgo = ((BYTE)(dst)) < 0;
3698: bool flgn = ((BYTE)(newv)) < 0;
3699: regs.z = ((BYTE)(newv)) == 0;
3700: regs.v = (flgs != flgo) && (flgn != flgo);
3701: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
3702: regs.n = flgn != 0;
3703: put_byte(dsta,newv);
3704: }}}}}}
3705: void op_5740(UWORD opcode)
3706: {
3707: ULONG srcreg = 3;
3708: ULONG dstreg = (opcode & 7) >> 0;
3709: {{ ULONG src = srcreg;
3710: { WORD dst = regs.d[dstreg];
3711: { ULONG newv = dst - src;
3712: { bool flgs = ((WORD)(src)) < 0;
3713: bool flgo = ((WORD)(dst)) < 0;
3714: bool flgn = ((WORD)(newv)) < 0;
3715: regs.z = ((WORD)(newv)) == 0;
3716: regs.v = (flgs != flgo) && (flgn != flgo);
3717: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3718: regs.n = flgn != 0;
3719: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
3720: }}}}}}
3721: void op_5748(UWORD opcode)
3722: {
3723: ULONG srcreg = 3;
3724: ULONG dstreg = (opcode & 7) >> 0;
3725: {{ ULONG src = srcreg;
3726: { LONG dst = regs.a[dstreg];
3727: { ULONG newv = dst - src;
3728: regs.a[dstreg] = (newv);
3729: }}}}}
3730: void op_5750(UWORD opcode)
3731: {
3732: ULONG srcreg = 3;
3733: ULONG dstreg = (opcode & 7) >> 0;
3734: {{ ULONG src = srcreg;
3735: { CPTR dsta = regs.a[dstreg];
3736: WORD dst = get_word(dsta);
3737: { ULONG newv = dst - src;
3738: { bool flgs = ((WORD)(src)) < 0;
3739: bool flgo = ((WORD)(dst)) < 0;
3740: bool flgn = ((WORD)(newv)) < 0;
3741: regs.z = ((WORD)(newv)) == 0;
3742: regs.v = (flgs != flgo) && (flgn != flgo);
3743: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3744: regs.n = flgn != 0;
3745: put_word(dsta,newv);
3746: }}}}}}
3747: void op_5758(UWORD opcode)
3748: {
3749: ULONG srcreg = 3;
3750: ULONG dstreg = (opcode & 7) >> 0;
3751: {{ ULONG src = srcreg;
3752: { CPTR dsta = regs.a[dstreg];
3753: WORD dst = get_word(dsta);
3754: { regs.a[dstreg] += 2;
3755: { ULONG newv = dst - src;
3756: { bool flgs = ((WORD)(src)) < 0;
3757: bool flgo = ((WORD)(dst)) < 0;
3758: bool flgn = ((WORD)(newv)) < 0;
3759: regs.z = ((WORD)(newv)) == 0;
3760: regs.v = (flgs != flgo) && (flgn != flgo);
3761: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3762: regs.n = flgn != 0;
3763: put_word(dsta,newv);
3764: }}}}}}}
3765: void op_5760(UWORD opcode)
3766: {
3767: ULONG srcreg = 3;
3768: ULONG dstreg = (opcode & 7) >> 0;
3769: {{ ULONG src = srcreg;
3770: { regs.a[dstreg] -= 2;
3771: { CPTR dsta = regs.a[dstreg];
3772: WORD dst = get_word(dsta);
3773: { ULONG newv = dst - src;
3774: { bool flgs = ((WORD)(src)) < 0;
3775: bool flgo = ((WORD)(dst)) < 0;
3776: bool flgn = ((WORD)(newv)) < 0;
3777: regs.z = ((WORD)(newv)) == 0;
3778: regs.v = (flgs != flgo) && (flgn != flgo);
3779: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3780: regs.n = flgn != 0;
3781: put_word(dsta,newv);
3782: }}}}}}}
3783: void op_5768(UWORD opcode)
3784: {
3785: ULONG srcreg = 3;
3786: ULONG dstreg = (opcode & 7) >> 0;
3787: {{ ULONG src = srcreg;
3788: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
3789: WORD dst = get_word(dsta);
3790: { ULONG newv = dst - src;
3791: { bool flgs = ((WORD)(src)) < 0;
3792: bool flgo = ((WORD)(dst)) < 0;
3793: bool flgn = ((WORD)(newv)) < 0;
3794: regs.z = ((WORD)(newv)) == 0;
3795: regs.v = (flgs != flgo) && (flgn != flgo);
3796: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3797: regs.n = flgn != 0;
3798: put_word(dsta,newv);
3799: }}}}}}
3800: void op_5770(UWORD opcode)
3801: {
3802: ULONG srcreg = 3;
3803: ULONG dstreg = (opcode & 7) >> 0;
3804: {{ ULONG src = srcreg;
3805: { CPTR dsta = regs.a[dstreg];
3806: UWORD dstdp = nextiword();
3807: dsta += (LONG)(BYTE)(dstdp & 0xFF);
3808: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
3809: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
3810: dsta += dstdpr;
3811: { WORD dst = get_word(dsta);
3812: { ULONG newv = dst - src;
3813: { bool flgs = ((WORD)(src)) < 0;
3814: bool flgo = ((WORD)(dst)) < 0;
3815: bool flgn = ((WORD)(newv)) < 0;
3816: regs.z = ((WORD)(newv)) == 0;
3817: regs.v = (flgs != flgo) && (flgn != flgo);
3818: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3819: regs.n = flgn != 0;
3820: put_word(dsta,newv);
3821: }}}}}}}}
3822: void op_5778(UWORD opcode)
3823: {
3824: ULONG srcreg = 3;
3825: {{ ULONG src = srcreg;
3826: { CPTR dsta = (LONG)(WORD)nextiword();
3827: WORD dst = get_word(dsta);
3828: { ULONG newv = dst - src;
3829: { bool flgs = ((WORD)(src)) < 0;
3830: bool flgo = ((WORD)(dst)) < 0;
3831: bool flgn = ((WORD)(newv)) < 0;
3832: regs.z = ((WORD)(newv)) == 0;
3833: regs.v = (flgs != flgo) && (flgn != flgo);
3834: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3835: regs.n = flgn != 0;
3836: put_word(dsta,newv);
3837: }}}}}}
3838: void op_5779(UWORD opcode)
3839: {
3840: ULONG srcreg = 3;
3841: {{ ULONG src = srcreg;
3842: { CPTR dsta = nextilong();
3843: WORD dst = get_word(dsta);
3844: { ULONG newv = dst - src;
3845: { bool flgs = ((WORD)(src)) < 0;
3846: bool flgo = ((WORD)(dst)) < 0;
3847: bool flgn = ((WORD)(newv)) < 0;
3848: regs.z = ((WORD)(newv)) == 0;
3849: regs.v = (flgs != flgo) && (flgn != flgo);
3850: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
3851: regs.n = flgn != 0;
3852: put_word(dsta,newv);
3853: }}}}}}
3854: void op_5780(UWORD opcode)
3855: {
3856: ULONG srcreg = 3;
3857: ULONG dstreg = (opcode & 7) >> 0;
3858: {{ ULONG src = srcreg;
3859: { LONG dst = regs.d[dstreg];
3860: { ULONG newv = dst - src;
3861: { bool flgs = ((LONG)(src)) < 0;
3862: bool flgo = ((LONG)(dst)) < 0;
3863: bool flgn = ((LONG)(newv)) < 0;
3864: regs.z = ((LONG)(newv)) == 0;
3865: regs.v = (flgs != flgo) && (flgn != flgo);
3866: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
3867: regs.n = flgn != 0;
3868: regs.d[dstreg] = (newv);
3869: }}}}}}
3870: void op_5788(UWORD opcode)
3871: {
3872: ULONG srcreg = 3;
3873: ULONG dstreg = (opcode & 7) >> 0;
3874: {{ ULONG src = srcreg;
3875: { LONG dst = regs.a[dstreg];
3876: { ULONG newv = dst - src;
3877: regs.a[dstreg] = (newv);
3878: }}}}}
3879: void op_5790(UWORD opcode)
3880: {
3881: ULONG srcreg = 3;
3882: ULONG dstreg = (opcode & 7) >> 0;
3883: {{ ULONG src = srcreg;
3884: { CPTR dsta = regs.a[dstreg];
3885: LONG dst = get_long(dsta);
3886: { ULONG newv = dst - src;
3887: { bool flgs = ((LONG)(src)) < 0;
3888: bool flgo = ((LONG)(dst)) < 0;
3889: bool flgn = ((LONG)(newv)) < 0;
3890: regs.z = ((LONG)(newv)) == 0;
3891: regs.v = (flgs != flgo) && (flgn != flgo);
3892: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
3893: regs.n = flgn != 0;
3894: put_long(dsta,newv);
3895: }}}}}}
3896: void op_5798(UWORD opcode)
3897: {
3898: ULONG srcreg = 3;
3899: ULONG dstreg = (opcode & 7) >> 0;
3900: {{ ULONG src = srcreg;
3901: { CPTR dsta = regs.a[dstreg];
3902: LONG dst = get_long(dsta);
3903: { regs.a[dstreg] += 4;
3904: { ULONG newv = dst - src;
3905: { bool flgs = ((LONG)(src)) < 0;
3906: bool flgo = ((LONG)(dst)) < 0;
3907: bool flgn = ((LONG)(newv)) < 0;
3908: regs.z = ((LONG)(newv)) == 0;
3909: regs.v = (flgs != flgo) && (flgn != flgo);
3910: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
3911: regs.n = flgn != 0;
3912: put_long(dsta,newv);
3913: }}}}}}}
3914: void op_57a0(UWORD opcode)
3915: {
3916: ULONG srcreg = 3;
3917: ULONG dstreg = (opcode & 7) >> 0;
3918: {{ ULONG src = srcreg;
3919: { regs.a[dstreg] -= 4;
3920: { CPTR dsta = regs.a[dstreg];
3921: LONG dst = get_long(dsta);
3922: { ULONG newv = dst - src;
3923: { bool flgs = ((LONG)(src)) < 0;
3924: bool flgo = ((LONG)(dst)) < 0;
3925: bool flgn = ((LONG)(newv)) < 0;
3926: regs.z = ((LONG)(newv)) == 0;
3927: regs.v = (flgs != flgo) && (flgn != flgo);
3928: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
3929: regs.n = flgn != 0;
3930: put_long(dsta,newv);
3931: }}}}}}}
3932: void op_57a8(UWORD opcode)
3933: {
3934: ULONG srcreg = 3;
3935: ULONG dstreg = (opcode & 7) >> 0;
3936: {{ ULONG src = srcreg;
3937: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
3938: LONG dst = get_long(dsta);
3939: { ULONG newv = dst - src;
3940: { bool flgs = ((LONG)(src)) < 0;
3941: bool flgo = ((LONG)(dst)) < 0;
3942: bool flgn = ((LONG)(newv)) < 0;
3943: regs.z = ((LONG)(newv)) == 0;
3944: regs.v = (flgs != flgo) && (flgn != flgo);
3945: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
3946: regs.n = flgn != 0;
3947: put_long(dsta,newv);
3948: }}}}}}
3949: void op_57b0(UWORD opcode)
3950: {
3951: ULONG srcreg = 3;
3952: ULONG dstreg = (opcode & 7) >> 0;
3953: {{ ULONG src = srcreg;
3954: { CPTR dsta = regs.a[dstreg];
3955: UWORD dstdp = nextiword();
3956: dsta += (LONG)(BYTE)(dstdp & 0xFF);
3957: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
3958: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
3959: dsta += dstdpr;
3960: { LONG dst = get_long(dsta);
3961: { ULONG newv = dst - src;
3962: { bool flgs = ((LONG)(src)) < 0;
3963: bool flgo = ((LONG)(dst)) < 0;
3964: bool flgn = ((LONG)(newv)) < 0;
3965: regs.z = ((LONG)(newv)) == 0;
3966: regs.v = (flgs != flgo) && (flgn != flgo);
3967: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
3968: regs.n = flgn != 0;
3969: put_long(dsta,newv);
3970: }}}}}}}}
3971: void op_57b8(UWORD opcode)
3972: {
3973: ULONG srcreg = 3;
3974: {{ ULONG src = srcreg;
3975: { CPTR dsta = (LONG)(WORD)nextiword();
3976: LONG dst = get_long(dsta);
3977: { ULONG newv = dst - src;
3978: { bool flgs = ((LONG)(src)) < 0;
3979: bool flgo = ((LONG)(dst)) < 0;
3980: bool flgn = ((LONG)(newv)) < 0;
3981: regs.z = ((LONG)(newv)) == 0;
3982: regs.v = (flgs != flgo) && (flgn != flgo);
3983: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
3984: regs.n = flgn != 0;
3985: put_long(dsta,newv);
3986: }}}}}}
3987: void op_57b9(UWORD opcode)
3988: {
3989: ULONG srcreg = 3;
3990: {{ ULONG src = srcreg;
3991: { CPTR dsta = nextilong();
3992: LONG dst = get_long(dsta);
3993: { ULONG newv = dst - src;
3994: { bool flgs = ((LONG)(src)) < 0;
3995: bool flgo = ((LONG)(dst)) < 0;
3996: bool flgn = ((LONG)(newv)) < 0;
3997: regs.z = ((LONG)(newv)) == 0;
3998: regs.v = (flgs != flgo) && (flgn != flgo);
3999: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
4000: regs.n = flgn != 0;
4001: put_long(dsta,newv);
4002: }}}}}}
4003: void op_57c0(UWORD opcode)
4004: {
4005: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4006: {{{ int val = cctrue(7) ? 0xff : 0;
4007: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
4008: }}}}
4009: void op_57c8(UWORD opcode)
4010: {
4011: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4012: {{ WORD src = regs.d[srcreg];
4013: { WORD offs = nextiword();
4014: if (!cctrue(7)) {
4015: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
4016: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
4017: }
4018: }}}}
4019: void op_57d0(UWORD opcode)
4020: {
4021: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4022: {{ CPTR srca = regs.a[srcreg];
4023: { int val = cctrue(7) ? 0xff : 0;
4024: put_byte(srca,val);
4025: }}}}
4026: void op_57d8(UWORD opcode)
4027: {
4028: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4029: {{ CPTR srca = regs.a[srcreg];
4030: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
4031: { int val = cctrue(7) ? 0xff : 0;
4032: put_byte(srca,val);
4033: }}}}}
4034: void op_57e0(UWORD opcode)
4035: {
4036: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4037: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
4038: { CPTR srca = regs.a[srcreg];
4039: { int val = cctrue(7) ? 0xff : 0;
4040: put_byte(srca,val);
4041: }}}}}
4042: void op_57e8(UWORD opcode)
4043: {
4044: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4045: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
4046: { int val = cctrue(7) ? 0xff : 0;
4047: put_byte(srca,val);
4048: }}}}
4049: void op_57f0(UWORD opcode)
4050: {
4051: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4052: {{ CPTR srca = regs.a[srcreg];
4053: UWORD srcdp = nextiword();
4054: srca += (LONG)(BYTE)(srcdp & 0xFF);
4055: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
4056: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
4057: srca += srcdpr;
4058: { int val = cctrue(7) ? 0xff : 0;
4059: put_byte(srca,val);
4060: }}}}}
4061: void op_57f8(UWORD opcode)
4062: {
4063: {{ CPTR srca = (LONG)(WORD)nextiword();
4064: { int val = cctrue(7) ? 0xff : 0;
4065: put_byte(srca,val);
4066: }}}}
4067: void op_57f9(UWORD opcode)
4068: {
4069: {{ CPTR srca = nextilong();
4070: { int val = cctrue(7) ? 0xff : 0;
4071: put_byte(srca,val);
4072: }}}}
4073: void op_5800(UWORD opcode)
4074: {
4075: ULONG srcreg = 4;
4076: ULONG dstreg = (opcode & 7) >> 0;
4077: {{ ULONG src = srcreg;
4078: { BYTE dst = regs.d[dstreg];
4079: { ULONG newv = dst + src;
4080: { bool flgs = ((BYTE)(src)) < 0;
4081: bool flgo = ((BYTE)(dst)) < 0;
4082: bool flgn = ((BYTE)(newv)) < 0;
4083: regs.z = ((BYTE)(newv)) == 0;
4084: regs.v = (flgs == flgo) && (flgn != flgo);
4085: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4086: regs.n = flgn != 0;
4087: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
4088: }}}}}}
4089: void op_5810(UWORD opcode)
4090: {
4091: ULONG srcreg = 4;
4092: ULONG dstreg = (opcode & 7) >> 0;
4093: {{ ULONG src = srcreg;
4094: { CPTR dsta = regs.a[dstreg];
4095: BYTE dst = get_byte(dsta);
4096: { ULONG newv = dst + src;
4097: { bool flgs = ((BYTE)(src)) < 0;
4098: bool flgo = ((BYTE)(dst)) < 0;
4099: bool flgn = ((BYTE)(newv)) < 0;
4100: regs.z = ((BYTE)(newv)) == 0;
4101: regs.v = (flgs == flgo) && (flgn != flgo);
4102: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4103: regs.n = flgn != 0;
4104: put_byte(dsta,newv);
4105: }}}}}}
4106: void op_5818(UWORD opcode)
4107: {
4108: ULONG srcreg = 4;
4109: ULONG dstreg = (opcode & 7) >> 0;
4110: {{ ULONG src = srcreg;
4111: { CPTR dsta = regs.a[dstreg];
4112: BYTE dst = get_byte(dsta);
4113: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
4114: { ULONG newv = dst + src;
4115: { bool flgs = ((BYTE)(src)) < 0;
4116: bool flgo = ((BYTE)(dst)) < 0;
4117: bool flgn = ((BYTE)(newv)) < 0;
4118: regs.z = ((BYTE)(newv)) == 0;
4119: regs.v = (flgs == flgo) && (flgn != flgo);
4120: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4121: regs.n = flgn != 0;
4122: put_byte(dsta,newv);
4123: }}}}}}}
4124: void op_5820(UWORD opcode)
4125: {
4126: ULONG srcreg = 4;
4127: ULONG dstreg = (opcode & 7) >> 0;
4128: {{ ULONG src = srcreg;
4129: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
4130: { CPTR dsta = regs.a[dstreg];
4131: BYTE dst = get_byte(dsta);
4132: { ULONG newv = dst + src;
4133: { bool flgs = ((BYTE)(src)) < 0;
4134: bool flgo = ((BYTE)(dst)) < 0;
4135: bool flgn = ((BYTE)(newv)) < 0;
4136: regs.z = ((BYTE)(newv)) == 0;
4137: regs.v = (flgs == flgo) && (flgn != flgo);
4138: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4139: regs.n = flgn != 0;
4140: put_byte(dsta,newv);
4141: }}}}}}}
4142: void op_5828(UWORD opcode)
4143: {
4144: ULONG srcreg = 4;
4145: ULONG dstreg = (opcode & 7) >> 0;
4146: {{ ULONG src = srcreg;
4147: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
4148: BYTE dst = get_byte(dsta);
4149: { ULONG newv = dst + src;
4150: { bool flgs = ((BYTE)(src)) < 0;
4151: bool flgo = ((BYTE)(dst)) < 0;
4152: bool flgn = ((BYTE)(newv)) < 0;
4153: regs.z = ((BYTE)(newv)) == 0;
4154: regs.v = (flgs == flgo) && (flgn != flgo);
4155: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4156: regs.n = flgn != 0;
4157: put_byte(dsta,newv);
4158: }}}}}}
4159: void op_5830(UWORD opcode)
4160: {
4161: ULONG srcreg = 4;
4162: ULONG dstreg = (opcode & 7) >> 0;
4163: {{ ULONG src = srcreg;
4164: { CPTR dsta = regs.a[dstreg];
4165: UWORD dstdp = nextiword();
4166: dsta += (LONG)(BYTE)(dstdp & 0xFF);
4167: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
4168: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
4169: dsta += dstdpr;
4170: { BYTE dst = get_byte(dsta);
4171: { ULONG newv = dst + src;
4172: { bool flgs = ((BYTE)(src)) < 0;
4173: bool flgo = ((BYTE)(dst)) < 0;
4174: bool flgn = ((BYTE)(newv)) < 0;
4175: regs.z = ((BYTE)(newv)) == 0;
4176: regs.v = (flgs == flgo) && (flgn != flgo);
4177: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4178: regs.n = flgn != 0;
4179: put_byte(dsta,newv);
4180: }}}}}}}}
4181: void op_5838(UWORD opcode)
4182: {
4183: ULONG srcreg = 4;
4184: {{ ULONG src = srcreg;
4185: { CPTR dsta = (LONG)(WORD)nextiword();
4186: BYTE dst = get_byte(dsta);
4187: { ULONG newv = dst + src;
4188: { bool flgs = ((BYTE)(src)) < 0;
4189: bool flgo = ((BYTE)(dst)) < 0;
4190: bool flgn = ((BYTE)(newv)) < 0;
4191: regs.z = ((BYTE)(newv)) == 0;
4192: regs.v = (flgs == flgo) && (flgn != flgo);
4193: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4194: regs.n = flgn != 0;
4195: put_byte(dsta,newv);
4196: }}}}}}
4197: void op_5839(UWORD opcode)
4198: {
4199: ULONG srcreg = 4;
4200: {{ ULONG src = srcreg;
4201: { CPTR dsta = nextilong();
4202: BYTE dst = get_byte(dsta);
4203: { ULONG newv = dst + src;
4204: { bool flgs = ((BYTE)(src)) < 0;
4205: bool flgo = ((BYTE)(dst)) < 0;
4206: bool flgn = ((BYTE)(newv)) < 0;
4207: regs.z = ((BYTE)(newv)) == 0;
4208: regs.v = (flgs == flgo) && (flgn != flgo);
4209: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
4210: regs.n = flgn != 0;
4211: put_byte(dsta,newv);
4212: }}}}}}
4213: void op_5840(UWORD opcode)
4214: {
4215: ULONG srcreg = 4;
4216: ULONG dstreg = (opcode & 7) >> 0;
4217: {{ ULONG src = srcreg;
4218: { WORD dst = regs.d[dstreg];
4219: { ULONG newv = dst + src;
4220: { bool flgs = ((WORD)(src)) < 0;
4221: bool flgo = ((WORD)(dst)) < 0;
4222: bool flgn = ((WORD)(newv)) < 0;
4223: regs.z = ((WORD)(newv)) == 0;
4224: regs.v = (flgs == flgo) && (flgn != flgo);
4225: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4226: regs.n = flgn != 0;
4227: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
4228: }}}}}}
4229: void op_5848(UWORD opcode)
4230: {
4231: ULONG srcreg = 4;
4232: ULONG dstreg = (opcode & 7) >> 0;
4233: {{ ULONG src = srcreg;
4234: { LONG dst = regs.a[dstreg];
4235: { ULONG newv = dst + src;
4236: regs.a[dstreg] = (newv);
4237: }}}}}
4238: void op_5850(UWORD opcode)
4239: {
4240: ULONG srcreg = 4;
4241: ULONG dstreg = (opcode & 7) >> 0;
4242: {{ ULONG src = srcreg;
4243: { CPTR dsta = regs.a[dstreg];
4244: WORD dst = get_word(dsta);
4245: { ULONG newv = dst + src;
4246: { bool flgs = ((WORD)(src)) < 0;
4247: bool flgo = ((WORD)(dst)) < 0;
4248: bool flgn = ((WORD)(newv)) < 0;
4249: regs.z = ((WORD)(newv)) == 0;
4250: regs.v = (flgs == flgo) && (flgn != flgo);
4251: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4252: regs.n = flgn != 0;
4253: put_word(dsta,newv);
4254: }}}}}}
4255: void op_5858(UWORD opcode)
4256: {
4257: ULONG srcreg = 4;
4258: ULONG dstreg = (opcode & 7) >> 0;
4259: {{ ULONG src = srcreg;
4260: { CPTR dsta = regs.a[dstreg];
4261: WORD dst = get_word(dsta);
4262: { regs.a[dstreg] += 2;
4263: { ULONG newv = dst + src;
4264: { bool flgs = ((WORD)(src)) < 0;
4265: bool flgo = ((WORD)(dst)) < 0;
4266: bool flgn = ((WORD)(newv)) < 0;
4267: regs.z = ((WORD)(newv)) == 0;
4268: regs.v = (flgs == flgo) && (flgn != flgo);
4269: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4270: regs.n = flgn != 0;
4271: put_word(dsta,newv);
4272: }}}}}}}
4273: void op_5860(UWORD opcode)
4274: {
4275: ULONG srcreg = 4;
4276: ULONG dstreg = (opcode & 7) >> 0;
4277: {{ ULONG src = srcreg;
4278: { regs.a[dstreg] -= 2;
4279: { CPTR dsta = regs.a[dstreg];
4280: WORD dst = get_word(dsta);
4281: { ULONG newv = dst + src;
4282: { bool flgs = ((WORD)(src)) < 0;
4283: bool flgo = ((WORD)(dst)) < 0;
4284: bool flgn = ((WORD)(newv)) < 0;
4285: regs.z = ((WORD)(newv)) == 0;
4286: regs.v = (flgs == flgo) && (flgn != flgo);
4287: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4288: regs.n = flgn != 0;
4289: put_word(dsta,newv);
4290: }}}}}}}
4291: void op_5868(UWORD opcode)
4292: {
4293: ULONG srcreg = 4;
4294: ULONG dstreg = (opcode & 7) >> 0;
4295: {{ ULONG src = srcreg;
4296: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
4297: WORD dst = get_word(dsta);
4298: { ULONG newv = dst + src;
4299: { bool flgs = ((WORD)(src)) < 0;
4300: bool flgo = ((WORD)(dst)) < 0;
4301: bool flgn = ((WORD)(newv)) < 0;
4302: regs.z = ((WORD)(newv)) == 0;
4303: regs.v = (flgs == flgo) && (flgn != flgo);
4304: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4305: regs.n = flgn != 0;
4306: put_word(dsta,newv);
4307: }}}}}}
4308: void op_5870(UWORD opcode)
4309: {
4310: ULONG srcreg = 4;
4311: ULONG dstreg = (opcode & 7) >> 0;
4312: {{ ULONG src = srcreg;
4313: { CPTR dsta = regs.a[dstreg];
4314: UWORD dstdp = nextiword();
4315: dsta += (LONG)(BYTE)(dstdp & 0xFF);
4316: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
4317: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
4318: dsta += dstdpr;
4319: { WORD dst = get_word(dsta);
4320: { ULONG newv = dst + src;
4321: { bool flgs = ((WORD)(src)) < 0;
4322: bool flgo = ((WORD)(dst)) < 0;
4323: bool flgn = ((WORD)(newv)) < 0;
4324: regs.z = ((WORD)(newv)) == 0;
4325: regs.v = (flgs == flgo) && (flgn != flgo);
4326: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4327: regs.n = flgn != 0;
4328: put_word(dsta,newv);
4329: }}}}}}}}
4330: void op_5878(UWORD opcode)
4331: {
4332: ULONG srcreg = 4;
4333: {{ ULONG src = srcreg;
4334: { CPTR dsta = (LONG)(WORD)nextiword();
4335: WORD dst = get_word(dsta);
4336: { ULONG newv = dst + src;
4337: { bool flgs = ((WORD)(src)) < 0;
4338: bool flgo = ((WORD)(dst)) < 0;
4339: bool flgn = ((WORD)(newv)) < 0;
4340: regs.z = ((WORD)(newv)) == 0;
4341: regs.v = (flgs == flgo) && (flgn != flgo);
4342: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4343: regs.n = flgn != 0;
4344: put_word(dsta,newv);
4345: }}}}}}
4346: void op_5879(UWORD opcode)
4347: {
4348: ULONG srcreg = 4;
4349: {{ ULONG src = srcreg;
4350: { CPTR dsta = nextilong();
4351: WORD dst = get_word(dsta);
4352: { ULONG newv = dst + src;
4353: { bool flgs = ((WORD)(src)) < 0;
4354: bool flgo = ((WORD)(dst)) < 0;
4355: bool flgn = ((WORD)(newv)) < 0;
4356: regs.z = ((WORD)(newv)) == 0;
4357: regs.v = (flgs == flgo) && (flgn != flgo);
4358: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
4359: regs.n = flgn != 0;
4360: put_word(dsta,newv);
4361: }}}}}}
4362: void op_5880(UWORD opcode)
4363: {
4364: ULONG srcreg = 4;
4365: ULONG dstreg = (opcode & 7) >> 0;
4366: {{ ULONG src = srcreg;
4367: { LONG dst = regs.d[dstreg];
4368: { ULONG newv = dst + src;
4369: { bool flgs = ((LONG)(src)) < 0;
4370: bool flgo = ((LONG)(dst)) < 0;
4371: bool flgn = ((LONG)(newv)) < 0;
4372: regs.z = ((LONG)(newv)) == 0;
4373: regs.v = (flgs == flgo) && (flgn != flgo);
4374: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4375: regs.n = flgn != 0;
4376: regs.d[dstreg] = (newv);
4377: }}}}}}
4378: void op_5888(UWORD opcode)
4379: {
4380: ULONG srcreg = 4;
4381: ULONG dstreg = (opcode & 7) >> 0;
4382: {{ ULONG src = srcreg;
4383: { LONG dst = regs.a[dstreg];
4384: { ULONG newv = dst + src;
4385: regs.a[dstreg] = (newv);
4386: }}}}}
4387: void op_5890(UWORD opcode)
4388: {
4389: ULONG srcreg = 4;
4390: ULONG dstreg = (opcode & 7) >> 0;
4391: {{ ULONG src = srcreg;
4392: { CPTR dsta = regs.a[dstreg];
4393: LONG dst = get_long(dsta);
4394: { ULONG newv = dst + src;
4395: { bool flgs = ((LONG)(src)) < 0;
4396: bool flgo = ((LONG)(dst)) < 0;
4397: bool flgn = ((LONG)(newv)) < 0;
4398: regs.z = ((LONG)(newv)) == 0;
4399: regs.v = (flgs == flgo) && (flgn != flgo);
4400: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4401: regs.n = flgn != 0;
4402: put_long(dsta,newv);
4403: }}}}}}
4404: void op_5898(UWORD opcode)
4405: {
4406: ULONG srcreg = 4;
4407: ULONG dstreg = (opcode & 7) >> 0;
4408: {{ ULONG src = srcreg;
4409: { CPTR dsta = regs.a[dstreg];
4410: LONG dst = get_long(dsta);
4411: { regs.a[dstreg] += 4;
4412: { ULONG newv = dst + src;
4413: { bool flgs = ((LONG)(src)) < 0;
4414: bool flgo = ((LONG)(dst)) < 0;
4415: bool flgn = ((LONG)(newv)) < 0;
4416: regs.z = ((LONG)(newv)) == 0;
4417: regs.v = (flgs == flgo) && (flgn != flgo);
4418: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4419: regs.n = flgn != 0;
4420: put_long(dsta,newv);
4421: }}}}}}}
4422: void op_58a0(UWORD opcode)
4423: {
4424: ULONG srcreg = 4;
4425: ULONG dstreg = (opcode & 7) >> 0;
4426: {{ ULONG src = srcreg;
4427: { regs.a[dstreg] -= 4;
4428: { CPTR dsta = regs.a[dstreg];
4429: LONG dst = get_long(dsta);
4430: { ULONG newv = dst + src;
4431: { bool flgs = ((LONG)(src)) < 0;
4432: bool flgo = ((LONG)(dst)) < 0;
4433: bool flgn = ((LONG)(newv)) < 0;
4434: regs.z = ((LONG)(newv)) == 0;
4435: regs.v = (flgs == flgo) && (flgn != flgo);
4436: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4437: regs.n = flgn != 0;
4438: put_long(dsta,newv);
4439: }}}}}}}
4440: void op_58a8(UWORD opcode)
4441: {
4442: ULONG srcreg = 4;
4443: ULONG dstreg = (opcode & 7) >> 0;
4444: {{ ULONG src = srcreg;
4445: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
4446: LONG dst = get_long(dsta);
4447: { ULONG newv = dst + src;
4448: { bool flgs = ((LONG)(src)) < 0;
4449: bool flgo = ((LONG)(dst)) < 0;
4450: bool flgn = ((LONG)(newv)) < 0;
4451: regs.z = ((LONG)(newv)) == 0;
4452: regs.v = (flgs == flgo) && (flgn != flgo);
4453: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4454: regs.n = flgn != 0;
4455: put_long(dsta,newv);
4456: }}}}}}
4457: void op_58b0(UWORD opcode)
4458: {
4459: ULONG srcreg = 4;
4460: ULONG dstreg = (opcode & 7) >> 0;
4461: {{ ULONG src = srcreg;
4462: { CPTR dsta = regs.a[dstreg];
4463: UWORD dstdp = nextiword();
4464: dsta += (LONG)(BYTE)(dstdp & 0xFF);
4465: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
4466: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
4467: dsta += dstdpr;
4468: { LONG dst = get_long(dsta);
4469: { ULONG newv = dst + src;
4470: { bool flgs = ((LONG)(src)) < 0;
4471: bool flgo = ((LONG)(dst)) < 0;
4472: bool flgn = ((LONG)(newv)) < 0;
4473: regs.z = ((LONG)(newv)) == 0;
4474: regs.v = (flgs == flgo) && (flgn != flgo);
4475: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4476: regs.n = flgn != 0;
4477: put_long(dsta,newv);
4478: }}}}}}}}
4479: void op_58b8(UWORD opcode)
4480: {
4481: ULONG srcreg = 4;
4482: {{ ULONG src = srcreg;
4483: { CPTR dsta = (LONG)(WORD)nextiword();
4484: LONG dst = get_long(dsta);
4485: { ULONG newv = dst + src;
4486: { bool flgs = ((LONG)(src)) < 0;
4487: bool flgo = ((LONG)(dst)) < 0;
4488: bool flgn = ((LONG)(newv)) < 0;
4489: regs.z = ((LONG)(newv)) == 0;
4490: regs.v = (flgs == flgo) && (flgn != flgo);
4491: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4492: regs.n = flgn != 0;
4493: put_long(dsta,newv);
4494: }}}}}}
4495: void op_58b9(UWORD opcode)
4496: {
4497: ULONG srcreg = 4;
4498: {{ ULONG src = srcreg;
4499: { CPTR dsta = nextilong();
4500: LONG dst = get_long(dsta);
4501: { ULONG newv = dst + src;
4502: { bool flgs = ((LONG)(src)) < 0;
4503: bool flgo = ((LONG)(dst)) < 0;
4504: bool flgn = ((LONG)(newv)) < 0;
4505: regs.z = ((LONG)(newv)) == 0;
4506: regs.v = (flgs == flgo) && (flgn != flgo);
4507: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
4508: regs.n = flgn != 0;
4509: put_long(dsta,newv);
4510: }}}}}}
4511: void op_58c0(UWORD opcode)
4512: {
4513: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4514: {{{ int val = cctrue(8) ? 0xff : 0;
4515: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
4516: }}}}
4517: void op_58c8(UWORD opcode)
4518: {
4519: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4520: {{ WORD src = regs.d[srcreg];
4521: { WORD offs = nextiword();
4522: if (!cctrue(8)) {
4523: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
4524: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
4525: }
4526: }}}}
4527: void op_58d0(UWORD opcode)
4528: {
4529: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4530: {{ CPTR srca = regs.a[srcreg];
4531: { int val = cctrue(8) ? 0xff : 0;
4532: put_byte(srca,val);
4533: }}}}
4534: void op_58d8(UWORD opcode)
4535: {
4536: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4537: {{ CPTR srca = regs.a[srcreg];
4538: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
4539: { int val = cctrue(8) ? 0xff : 0;
4540: put_byte(srca,val);
4541: }}}}}
4542: void op_58e0(UWORD opcode)
4543: {
4544: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4545: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
4546: { CPTR srca = regs.a[srcreg];
4547: { int val = cctrue(8) ? 0xff : 0;
4548: put_byte(srca,val);
4549: }}}}}
4550: void op_58e8(UWORD opcode)
4551: {
4552: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4553: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
4554: { int val = cctrue(8) ? 0xff : 0;
4555: put_byte(srca,val);
4556: }}}}
4557: void op_58f0(UWORD opcode)
4558: {
4559: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
4560: {{ CPTR srca = regs.a[srcreg];
4561: UWORD srcdp = nextiword();
4562: srca += (LONG)(BYTE)(srcdp & 0xFF);
4563: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
4564: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
4565: srca += srcdpr;
4566: { int val = cctrue(8) ? 0xff : 0;
4567: put_byte(srca,val);
4568: }}}}}
4569: void op_58f8(UWORD opcode)
4570: {
4571: {{ CPTR srca = (LONG)(WORD)nextiword();
4572: { int val = cctrue(8) ? 0xff : 0;
4573: put_byte(srca,val);
4574: }}}}
4575: void op_58f9(UWORD opcode)
4576: {
4577: {{ CPTR srca = nextilong();
4578: { int val = cctrue(8) ? 0xff : 0;
4579: put_byte(srca,val);
4580: }}}}
4581: void op_5900(UWORD opcode)
4582: {
4583: ULONG srcreg = 4;
4584: ULONG dstreg = (opcode & 7) >> 0;
4585: {{ ULONG src = srcreg;
4586: { BYTE dst = regs.d[dstreg];
4587: { ULONG newv = dst - src;
4588: { bool flgs = ((BYTE)(src)) < 0;
4589: bool flgo = ((BYTE)(dst)) < 0;
4590: bool flgn = ((BYTE)(newv)) < 0;
4591: regs.z = ((BYTE)(newv)) == 0;
4592: regs.v = (flgs != flgo) && (flgn != flgo);
4593: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4594: regs.n = flgn != 0;
4595: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
4596: }}}}}}
4597: void op_5910(UWORD opcode)
4598: {
4599: ULONG srcreg = 4;
4600: ULONG dstreg = (opcode & 7) >> 0;
4601: {{ ULONG src = srcreg;
4602: { CPTR dsta = regs.a[dstreg];
4603: BYTE dst = get_byte(dsta);
4604: { ULONG newv = dst - src;
4605: { bool flgs = ((BYTE)(src)) < 0;
4606: bool flgo = ((BYTE)(dst)) < 0;
4607: bool flgn = ((BYTE)(newv)) < 0;
4608: regs.z = ((BYTE)(newv)) == 0;
4609: regs.v = (flgs != flgo) && (flgn != flgo);
4610: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4611: regs.n = flgn != 0;
4612: put_byte(dsta,newv);
4613: }}}}}}
4614: void op_5918(UWORD opcode)
4615: {
4616: ULONG srcreg = 4;
4617: ULONG dstreg = (opcode & 7) >> 0;
4618: {{ ULONG src = srcreg;
4619: { CPTR dsta = regs.a[dstreg];
4620: BYTE dst = get_byte(dsta);
4621: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
4622: { ULONG newv = dst - src;
4623: { bool flgs = ((BYTE)(src)) < 0;
4624: bool flgo = ((BYTE)(dst)) < 0;
4625: bool flgn = ((BYTE)(newv)) < 0;
4626: regs.z = ((BYTE)(newv)) == 0;
4627: regs.v = (flgs != flgo) && (flgn != flgo);
4628: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4629: regs.n = flgn != 0;
4630: put_byte(dsta,newv);
4631: }}}}}}}
4632: void op_5920(UWORD opcode)
4633: {
4634: ULONG srcreg = 4;
4635: ULONG dstreg = (opcode & 7) >> 0;
4636: {{ ULONG src = srcreg;
4637: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
4638: { CPTR dsta = regs.a[dstreg];
4639: BYTE dst = get_byte(dsta);
4640: { ULONG newv = dst - src;
4641: { bool flgs = ((BYTE)(src)) < 0;
4642: bool flgo = ((BYTE)(dst)) < 0;
4643: bool flgn = ((BYTE)(newv)) < 0;
4644: regs.z = ((BYTE)(newv)) == 0;
4645: regs.v = (flgs != flgo) && (flgn != flgo);
4646: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4647: regs.n = flgn != 0;
4648: put_byte(dsta,newv);
4649: }}}}}}}
4650: void op_5928(UWORD opcode)
4651: {
4652: ULONG srcreg = 4;
4653: ULONG dstreg = (opcode & 7) >> 0;
4654: {{ ULONG src = srcreg;
4655: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
4656: BYTE dst = get_byte(dsta);
4657: { ULONG newv = dst - src;
4658: { bool flgs = ((BYTE)(src)) < 0;
4659: bool flgo = ((BYTE)(dst)) < 0;
4660: bool flgn = ((BYTE)(newv)) < 0;
4661: regs.z = ((BYTE)(newv)) == 0;
4662: regs.v = (flgs != flgo) && (flgn != flgo);
4663: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4664: regs.n = flgn != 0;
4665: put_byte(dsta,newv);
4666: }}}}}}
4667: void op_5930(UWORD opcode)
4668: {
4669: ULONG srcreg = 4;
4670: ULONG dstreg = (opcode & 7) >> 0;
4671: {{ ULONG src = srcreg;
4672: { CPTR dsta = regs.a[dstreg];
4673: UWORD dstdp = nextiword();
4674: dsta += (LONG)(BYTE)(dstdp & 0xFF);
4675: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
4676: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
4677: dsta += dstdpr;
4678: { BYTE dst = get_byte(dsta);
4679: { ULONG newv = dst - src;
4680: { bool flgs = ((BYTE)(src)) < 0;
4681: bool flgo = ((BYTE)(dst)) < 0;
4682: bool flgn = ((BYTE)(newv)) < 0;
4683: regs.z = ((BYTE)(newv)) == 0;
4684: regs.v = (flgs != flgo) && (flgn != flgo);
4685: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4686: regs.n = flgn != 0;
4687: put_byte(dsta,newv);
4688: }}}}}}}}
4689: void op_5938(UWORD opcode)
4690: {
4691: ULONG srcreg = 4;
4692: {{ ULONG src = srcreg;
4693: { CPTR dsta = (LONG)(WORD)nextiword();
4694: BYTE dst = get_byte(dsta);
4695: { ULONG newv = dst - src;
4696: { bool flgs = ((BYTE)(src)) < 0;
4697: bool flgo = ((BYTE)(dst)) < 0;
4698: bool flgn = ((BYTE)(newv)) < 0;
4699: regs.z = ((BYTE)(newv)) == 0;
4700: regs.v = (flgs != flgo) && (flgn != flgo);
4701: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4702: regs.n = flgn != 0;
4703: put_byte(dsta,newv);
4704: }}}}}}
4705: void op_5939(UWORD opcode)
4706: {
4707: ULONG srcreg = 4;
4708: {{ ULONG src = srcreg;
4709: { CPTR dsta = nextilong();
4710: BYTE dst = get_byte(dsta);
4711: { ULONG newv = dst - src;
4712: { bool flgs = ((BYTE)(src)) < 0;
4713: bool flgo = ((BYTE)(dst)) < 0;
4714: bool flgn = ((BYTE)(newv)) < 0;
4715: regs.z = ((BYTE)(newv)) == 0;
4716: regs.v = (flgs != flgo) && (flgn != flgo);
4717: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
4718: regs.n = flgn != 0;
4719: put_byte(dsta,newv);
4720: }}}}}}
4721: void op_5940(UWORD opcode)
4722: {
4723: ULONG srcreg = 4;
4724: ULONG dstreg = (opcode & 7) >> 0;
4725: {{ ULONG src = srcreg;
4726: { WORD dst = regs.d[dstreg];
4727: { ULONG newv = dst - src;
4728: { bool flgs = ((WORD)(src)) < 0;
4729: bool flgo = ((WORD)(dst)) < 0;
4730: bool flgn = ((WORD)(newv)) < 0;
4731: regs.z = ((WORD)(newv)) == 0;
4732: regs.v = (flgs != flgo) && (flgn != flgo);
4733: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4734: regs.n = flgn != 0;
4735: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
4736: }}}}}}
4737: void op_5948(UWORD opcode)
4738: {
4739: ULONG srcreg = 4;
4740: ULONG dstreg = (opcode & 7) >> 0;
4741: {{ ULONG src = srcreg;
4742: { LONG dst = regs.a[dstreg];
4743: { ULONG newv = dst - src;
4744: regs.a[dstreg] = (newv);
4745: }}}}}
4746: void op_5950(UWORD opcode)
4747: {
4748: ULONG srcreg = 4;
4749: ULONG dstreg = (opcode & 7) >> 0;
4750: {{ ULONG src = srcreg;
4751: { CPTR dsta = regs.a[dstreg];
4752: WORD dst = get_word(dsta);
4753: { ULONG newv = dst - src;
4754: { bool flgs = ((WORD)(src)) < 0;
4755: bool flgo = ((WORD)(dst)) < 0;
4756: bool flgn = ((WORD)(newv)) < 0;
4757: regs.z = ((WORD)(newv)) == 0;
4758: regs.v = (flgs != flgo) && (flgn != flgo);
4759: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4760: regs.n = flgn != 0;
4761: put_word(dsta,newv);
4762: }}}}}}
4763: void op_5958(UWORD opcode)
4764: {
4765: ULONG srcreg = 4;
4766: ULONG dstreg = (opcode & 7) >> 0;
4767: {{ ULONG src = srcreg;
4768: { CPTR dsta = regs.a[dstreg];
4769: WORD dst = get_word(dsta);
4770: { regs.a[dstreg] += 2;
4771: { ULONG newv = dst - src;
4772: { bool flgs = ((WORD)(src)) < 0;
4773: bool flgo = ((WORD)(dst)) < 0;
4774: bool flgn = ((WORD)(newv)) < 0;
4775: regs.z = ((WORD)(newv)) == 0;
4776: regs.v = (flgs != flgo) && (flgn != flgo);
4777: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4778: regs.n = flgn != 0;
4779: put_word(dsta,newv);
4780: }}}}}}}
4781: void op_5960(UWORD opcode)
4782: {
4783: ULONG srcreg = 4;
4784: ULONG dstreg = (opcode & 7) >> 0;
4785: {{ ULONG src = srcreg;
4786: { regs.a[dstreg] -= 2;
4787: { CPTR dsta = regs.a[dstreg];
4788: WORD dst = get_word(dsta);
4789: { ULONG newv = dst - src;
4790: { bool flgs = ((WORD)(src)) < 0;
4791: bool flgo = ((WORD)(dst)) < 0;
4792: bool flgn = ((WORD)(newv)) < 0;
4793: regs.z = ((WORD)(newv)) == 0;
4794: regs.v = (flgs != flgo) && (flgn != flgo);
4795: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4796: regs.n = flgn != 0;
4797: put_word(dsta,newv);
4798: }}}}}}}
4799: void op_5968(UWORD opcode)
4800: {
4801: ULONG srcreg = 4;
4802: ULONG dstreg = (opcode & 7) >> 0;
4803: {{ ULONG src = srcreg;
4804: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
4805: WORD dst = get_word(dsta);
4806: { ULONG newv = dst - src;
4807: { bool flgs = ((WORD)(src)) < 0;
4808: bool flgo = ((WORD)(dst)) < 0;
4809: bool flgn = ((WORD)(newv)) < 0;
4810: regs.z = ((WORD)(newv)) == 0;
4811: regs.v = (flgs != flgo) && (flgn != flgo);
4812: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4813: regs.n = flgn != 0;
4814: put_word(dsta,newv);
4815: }}}}}}
4816: void op_5970(UWORD opcode)
4817: {
4818: ULONG srcreg = 4;
4819: ULONG dstreg = (opcode & 7) >> 0;
4820: {{ ULONG src = srcreg;
4821: { CPTR dsta = regs.a[dstreg];
4822: UWORD dstdp = nextiword();
4823: dsta += (LONG)(BYTE)(dstdp & 0xFF);
4824: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
4825: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
4826: dsta += dstdpr;
4827: { WORD dst = get_word(dsta);
4828: { ULONG newv = dst - src;
4829: { bool flgs = ((WORD)(src)) < 0;
4830: bool flgo = ((WORD)(dst)) < 0;
4831: bool flgn = ((WORD)(newv)) < 0;
4832: regs.z = ((WORD)(newv)) == 0;
4833: regs.v = (flgs != flgo) && (flgn != flgo);
4834: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4835: regs.n = flgn != 0;
4836: put_word(dsta,newv);
4837: }}}}}}}}
4838: void op_5978(UWORD opcode)
4839: {
4840: ULONG srcreg = 4;
4841: {{ ULONG src = srcreg;
4842: { CPTR dsta = (LONG)(WORD)nextiword();
4843: WORD dst = get_word(dsta);
4844: { ULONG newv = dst - src;
4845: { bool flgs = ((WORD)(src)) < 0;
4846: bool flgo = ((WORD)(dst)) < 0;
4847: bool flgn = ((WORD)(newv)) < 0;
4848: regs.z = ((WORD)(newv)) == 0;
4849: regs.v = (flgs != flgo) && (flgn != flgo);
4850: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4851: regs.n = flgn != 0;
4852: put_word(dsta,newv);
4853: }}}}}}
4854: void op_5979(UWORD opcode)
4855: {
4856: ULONG srcreg = 4;
4857: {{ ULONG src = srcreg;
4858: { CPTR dsta = nextilong();
4859: WORD dst = get_word(dsta);
4860: { ULONG newv = dst - src;
4861: { bool flgs = ((WORD)(src)) < 0;
4862: bool flgo = ((WORD)(dst)) < 0;
4863: bool flgn = ((WORD)(newv)) < 0;
4864: regs.z = ((WORD)(newv)) == 0;
4865: regs.v = (flgs != flgo) && (flgn != flgo);
4866: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
4867: regs.n = flgn != 0;
4868: put_word(dsta,newv);
4869: }}}}}}
4870: void op_5980(UWORD opcode)
4871: {
4872: ULONG srcreg = 4;
4873: ULONG dstreg = (opcode & 7) >> 0;
4874: {{ ULONG src = srcreg;
4875: { LONG dst = regs.d[dstreg];
4876: { ULONG newv = dst - src;
4877: { bool flgs = ((LONG)(src)) < 0;
4878: bool flgo = ((LONG)(dst)) < 0;
4879: bool flgn = ((LONG)(newv)) < 0;
4880: regs.z = ((LONG)(newv)) == 0;
4881: regs.v = (flgs != flgo) && (flgn != flgo);
4882: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
4883: regs.n = flgn != 0;
4884: regs.d[dstreg] = (newv);
4885: }}}}}}
4886: void op_5988(UWORD opcode)
4887: {
4888: ULONG srcreg = 4;
4889: ULONG dstreg = (opcode & 7) >> 0;
4890: {{ ULONG src = srcreg;
4891: { LONG dst = regs.a[dstreg];
4892: { ULONG newv = dst - src;
4893: regs.a[dstreg] = (newv);
4894: }}}}}
4895: void op_5990(UWORD opcode)
4896: {
4897: ULONG srcreg = 4;
4898: ULONG dstreg = (opcode & 7) >> 0;
4899: {{ ULONG src = srcreg;
4900: { CPTR dsta = regs.a[dstreg];
4901: LONG dst = get_long(dsta);
4902: { ULONG newv = dst - src;
4903: { bool flgs = ((LONG)(src)) < 0;
4904: bool flgo = ((LONG)(dst)) < 0;
4905: bool flgn = ((LONG)(newv)) < 0;
4906: regs.z = ((LONG)(newv)) == 0;
4907: regs.v = (flgs != flgo) && (flgn != flgo);
4908: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
4909: regs.n = flgn != 0;
4910: put_long(dsta,newv);
4911: }}}}}}
4912: void op_5998(UWORD opcode)
4913: {
4914: ULONG srcreg = 4;
4915: ULONG dstreg = (opcode & 7) >> 0;
4916: {{ ULONG src = srcreg;
4917: { CPTR dsta = regs.a[dstreg];
4918: LONG dst = get_long(dsta);
4919: { regs.a[dstreg] += 4;
4920: { ULONG newv = dst - src;
4921: { bool flgs = ((LONG)(src)) < 0;
4922: bool flgo = ((LONG)(dst)) < 0;
4923: bool flgn = ((LONG)(newv)) < 0;
4924: regs.z = ((LONG)(newv)) == 0;
4925: regs.v = (flgs != flgo) && (flgn != flgo);
4926: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
4927: regs.n = flgn != 0;
4928: put_long(dsta,newv);
4929: }}}}}}}
4930: void op_59a0(UWORD opcode)
4931: {
4932: ULONG srcreg = 4;
4933: ULONG dstreg = (opcode & 7) >> 0;
4934: {{ ULONG src = srcreg;
4935: { regs.a[dstreg] -= 4;
4936: { CPTR dsta = regs.a[dstreg];
4937: LONG dst = get_long(dsta);
4938: { ULONG newv = dst - src;
4939: { bool flgs = ((LONG)(src)) < 0;
4940: bool flgo = ((LONG)(dst)) < 0;
4941: bool flgn = ((LONG)(newv)) < 0;
4942: regs.z = ((LONG)(newv)) == 0;
4943: regs.v = (flgs != flgo) && (flgn != flgo);
4944: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
4945: regs.n = flgn != 0;
4946: put_long(dsta,newv);
4947: }}}}}}}
4948: void op_59a8(UWORD opcode)
4949: {
4950: ULONG srcreg = 4;
4951: ULONG dstreg = (opcode & 7) >> 0;
4952: {{ ULONG src = srcreg;
4953: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
4954: LONG dst = get_long(dsta);
4955: { ULONG newv = dst - src;
4956: { bool flgs = ((LONG)(src)) < 0;
4957: bool flgo = ((LONG)(dst)) < 0;
4958: bool flgn = ((LONG)(newv)) < 0;
4959: regs.z = ((LONG)(newv)) == 0;
4960: regs.v = (flgs != flgo) && (flgn != flgo);
4961: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
4962: regs.n = flgn != 0;
4963: put_long(dsta,newv);
4964: }}}}}}
4965: void op_59b0(UWORD opcode)
4966: {
4967: ULONG srcreg = 4;
4968: ULONG dstreg = (opcode & 7) >> 0;
4969: {{ ULONG src = srcreg;
4970: { CPTR dsta = regs.a[dstreg];
4971: UWORD dstdp = nextiword();
4972: dsta += (LONG)(BYTE)(dstdp & 0xFF);
4973: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
4974: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
4975: dsta += dstdpr;
4976: { LONG dst = get_long(dsta);
4977: { ULONG newv = dst - src;
4978: { bool flgs = ((LONG)(src)) < 0;
4979: bool flgo = ((LONG)(dst)) < 0;
4980: bool flgn = ((LONG)(newv)) < 0;
4981: regs.z = ((LONG)(newv)) == 0;
4982: regs.v = (flgs != flgo) && (flgn != flgo);
4983: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
4984: regs.n = flgn != 0;
4985: put_long(dsta,newv);
4986: }}}}}}}}
4987: void op_59b8(UWORD opcode)
4988: {
4989: ULONG srcreg = 4;
4990: {{ ULONG src = srcreg;
4991: { CPTR dsta = (LONG)(WORD)nextiword();
4992: LONG dst = get_long(dsta);
4993: { ULONG newv = dst - src;
4994: { bool flgs = ((LONG)(src)) < 0;
4995: bool flgo = ((LONG)(dst)) < 0;
4996: bool flgn = ((LONG)(newv)) < 0;
4997: regs.z = ((LONG)(newv)) == 0;
4998: regs.v = (flgs != flgo) && (flgn != flgo);
4999: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
5000: regs.n = flgn != 0;
5001: put_long(dsta,newv);
5002: }}}}}}
5003: void op_59b9(UWORD opcode)
5004: {
5005: ULONG srcreg = 4;
5006: {{ ULONG src = srcreg;
5007: { CPTR dsta = nextilong();
5008: LONG dst = get_long(dsta);
5009: { ULONG newv = dst - src;
5010: { bool flgs = ((LONG)(src)) < 0;
5011: bool flgo = ((LONG)(dst)) < 0;
5012: bool flgn = ((LONG)(newv)) < 0;
5013: regs.z = ((LONG)(newv)) == 0;
5014: regs.v = (flgs != flgo) && (flgn != flgo);
5015: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
5016: regs.n = flgn != 0;
5017: put_long(dsta,newv);
5018: }}}}}}
5019: void op_59c0(UWORD opcode)
5020: {
5021: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5022: {{{ int val = cctrue(9) ? 0xff : 0;
5023: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
5024: }}}}
5025: void op_59c8(UWORD opcode)
5026: {
5027: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5028: {{ WORD src = regs.d[srcreg];
5029: { WORD offs = nextiword();
5030: if (!cctrue(9)) {
5031: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
5032: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
5033: }
5034: }}}}
5035: void op_59d0(UWORD opcode)
5036: {
5037: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5038: {{ CPTR srca = regs.a[srcreg];
5039: { int val = cctrue(9) ? 0xff : 0;
5040: put_byte(srca,val);
5041: }}}}
5042: void op_59d8(UWORD opcode)
5043: {
5044: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5045: {{ CPTR srca = regs.a[srcreg];
5046: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
5047: { int val = cctrue(9) ? 0xff : 0;
5048: put_byte(srca,val);
5049: }}}}}
5050: void op_59e0(UWORD opcode)
5051: {
5052: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5053: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
5054: { CPTR srca = regs.a[srcreg];
5055: { int val = cctrue(9) ? 0xff : 0;
5056: put_byte(srca,val);
5057: }}}}}
5058: void op_59e8(UWORD opcode)
5059: {
5060: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5061: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
5062: { int val = cctrue(9) ? 0xff : 0;
5063: put_byte(srca,val);
5064: }}}}
5065: void op_59f0(UWORD opcode)
5066: {
5067: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5068: {{ CPTR srca = regs.a[srcreg];
5069: UWORD srcdp = nextiword();
5070: srca += (LONG)(BYTE)(srcdp & 0xFF);
5071: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
5072: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
5073: srca += srcdpr;
5074: { int val = cctrue(9) ? 0xff : 0;
5075: put_byte(srca,val);
5076: }}}}}
5077: void op_59f8(UWORD opcode)
5078: {
5079: {{ CPTR srca = (LONG)(WORD)nextiword();
5080: { int val = cctrue(9) ? 0xff : 0;
5081: put_byte(srca,val);
5082: }}}}
5083: void op_59f9(UWORD opcode)
5084: {
5085: {{ CPTR srca = nextilong();
5086: { int val = cctrue(9) ? 0xff : 0;
5087: put_byte(srca,val);
5088: }}}}
5089: void op_5a00(UWORD opcode)
5090: {
5091: ULONG srcreg = 5;
5092: ULONG dstreg = (opcode & 7) >> 0;
5093: {{ ULONG src = srcreg;
5094: { BYTE dst = regs.d[dstreg];
5095: { ULONG newv = dst + src;
5096: { bool flgs = ((BYTE)(src)) < 0;
5097: bool flgo = ((BYTE)(dst)) < 0;
5098: bool flgn = ((BYTE)(newv)) < 0;
5099: regs.z = ((BYTE)(newv)) == 0;
5100: regs.v = (flgs == flgo) && (flgn != flgo);
5101: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5102: regs.n = flgn != 0;
5103: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
5104: }}}}}}
5105: void op_5a10(UWORD opcode)
5106: {
5107: ULONG srcreg = 5;
5108: ULONG dstreg = (opcode & 7) >> 0;
5109: {{ ULONG src = srcreg;
5110: { CPTR dsta = regs.a[dstreg];
5111: BYTE dst = get_byte(dsta);
5112: { ULONG newv = dst + src;
5113: { bool flgs = ((BYTE)(src)) < 0;
5114: bool flgo = ((BYTE)(dst)) < 0;
5115: bool flgn = ((BYTE)(newv)) < 0;
5116: regs.z = ((BYTE)(newv)) == 0;
5117: regs.v = (flgs == flgo) && (flgn != flgo);
5118: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5119: regs.n = flgn != 0;
5120: put_byte(dsta,newv);
5121: }}}}}}
5122: void op_5a18(UWORD opcode)
5123: {
5124: ULONG srcreg = 5;
5125: ULONG dstreg = (opcode & 7) >> 0;
5126: {{ ULONG src = srcreg;
5127: { CPTR dsta = regs.a[dstreg];
5128: BYTE dst = get_byte(dsta);
5129: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
5130: { ULONG newv = dst + src;
5131: { bool flgs = ((BYTE)(src)) < 0;
5132: bool flgo = ((BYTE)(dst)) < 0;
5133: bool flgn = ((BYTE)(newv)) < 0;
5134: regs.z = ((BYTE)(newv)) == 0;
5135: regs.v = (flgs == flgo) && (flgn != flgo);
5136: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5137: regs.n = flgn != 0;
5138: put_byte(dsta,newv);
5139: }}}}}}}
5140: void op_5a20(UWORD opcode)
5141: {
5142: ULONG srcreg = 5;
5143: ULONG dstreg = (opcode & 7) >> 0;
5144: {{ ULONG src = srcreg;
5145: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
5146: { CPTR dsta = regs.a[dstreg];
5147: BYTE dst = get_byte(dsta);
5148: { ULONG newv = dst + src;
5149: { bool flgs = ((BYTE)(src)) < 0;
5150: bool flgo = ((BYTE)(dst)) < 0;
5151: bool flgn = ((BYTE)(newv)) < 0;
5152: regs.z = ((BYTE)(newv)) == 0;
5153: regs.v = (flgs == flgo) && (flgn != flgo);
5154: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5155: regs.n = flgn != 0;
5156: put_byte(dsta,newv);
5157: }}}}}}}
5158: void op_5a28(UWORD opcode)
5159: {
5160: ULONG srcreg = 5;
5161: ULONG dstreg = (opcode & 7) >> 0;
5162: {{ ULONG src = srcreg;
5163: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
5164: BYTE dst = get_byte(dsta);
5165: { ULONG newv = dst + src;
5166: { bool flgs = ((BYTE)(src)) < 0;
5167: bool flgo = ((BYTE)(dst)) < 0;
5168: bool flgn = ((BYTE)(newv)) < 0;
5169: regs.z = ((BYTE)(newv)) == 0;
5170: regs.v = (flgs == flgo) && (flgn != flgo);
5171: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5172: regs.n = flgn != 0;
5173: put_byte(dsta,newv);
5174: }}}}}}
5175: void op_5a30(UWORD opcode)
5176: {
5177: ULONG srcreg = 5;
5178: ULONG dstreg = (opcode & 7) >> 0;
5179: {{ ULONG src = srcreg;
5180: { CPTR dsta = regs.a[dstreg];
5181: UWORD dstdp = nextiword();
5182: dsta += (LONG)(BYTE)(dstdp & 0xFF);
5183: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
5184: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
5185: dsta += dstdpr;
5186: { BYTE dst = get_byte(dsta);
5187: { ULONG newv = dst + src;
5188: { bool flgs = ((BYTE)(src)) < 0;
5189: bool flgo = ((BYTE)(dst)) < 0;
5190: bool flgn = ((BYTE)(newv)) < 0;
5191: regs.z = ((BYTE)(newv)) == 0;
5192: regs.v = (flgs == flgo) && (flgn != flgo);
5193: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5194: regs.n = flgn != 0;
5195: put_byte(dsta,newv);
5196: }}}}}}}}
5197: void op_5a38(UWORD opcode)
5198: {
5199: ULONG srcreg = 5;
5200: {{ ULONG src = srcreg;
5201: { CPTR dsta = (LONG)(WORD)nextiword();
5202: BYTE dst = get_byte(dsta);
5203: { ULONG newv = dst + src;
5204: { bool flgs = ((BYTE)(src)) < 0;
5205: bool flgo = ((BYTE)(dst)) < 0;
5206: bool flgn = ((BYTE)(newv)) < 0;
5207: regs.z = ((BYTE)(newv)) == 0;
5208: regs.v = (flgs == flgo) && (flgn != flgo);
5209: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5210: regs.n = flgn != 0;
5211: put_byte(dsta,newv);
5212: }}}}}}
5213: void op_5a39(UWORD opcode)
5214: {
5215: ULONG srcreg = 5;
5216: {{ ULONG src = srcreg;
5217: { CPTR dsta = nextilong();
5218: BYTE dst = get_byte(dsta);
5219: { ULONG newv = dst + src;
5220: { bool flgs = ((BYTE)(src)) < 0;
5221: bool flgo = ((BYTE)(dst)) < 0;
5222: bool flgn = ((BYTE)(newv)) < 0;
5223: regs.z = ((BYTE)(newv)) == 0;
5224: regs.v = (flgs == flgo) && (flgn != flgo);
5225: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
5226: regs.n = flgn != 0;
5227: put_byte(dsta,newv);
5228: }}}}}}
5229: void op_5a40(UWORD opcode)
5230: {
5231: ULONG srcreg = 5;
5232: ULONG dstreg = (opcode & 7) >> 0;
5233: {{ ULONG src = srcreg;
5234: { WORD dst = regs.d[dstreg];
5235: { ULONG newv = dst + src;
5236: { bool flgs = ((WORD)(src)) < 0;
5237: bool flgo = ((WORD)(dst)) < 0;
5238: bool flgn = ((WORD)(newv)) < 0;
5239: regs.z = ((WORD)(newv)) == 0;
5240: regs.v = (flgs == flgo) && (flgn != flgo);
5241: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5242: regs.n = flgn != 0;
5243: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
5244: }}}}}}
5245: void op_5a48(UWORD opcode)
5246: {
5247: ULONG srcreg = 5;
5248: ULONG dstreg = (opcode & 7) >> 0;
5249: {{ ULONG src = srcreg;
5250: { LONG dst = regs.a[dstreg];
5251: { ULONG newv = dst + src;
5252: regs.a[dstreg] = (newv);
5253: }}}}}
5254: void op_5a50(UWORD opcode)
5255: {
5256: ULONG srcreg = 5;
5257: ULONG dstreg = (opcode & 7) >> 0;
5258: {{ ULONG src = srcreg;
5259: { CPTR dsta = regs.a[dstreg];
5260: WORD dst = get_word(dsta);
5261: { ULONG newv = dst + src;
5262: { bool flgs = ((WORD)(src)) < 0;
5263: bool flgo = ((WORD)(dst)) < 0;
5264: bool flgn = ((WORD)(newv)) < 0;
5265: regs.z = ((WORD)(newv)) == 0;
5266: regs.v = (flgs == flgo) && (flgn != flgo);
5267: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5268: regs.n = flgn != 0;
5269: put_word(dsta,newv);
5270: }}}}}}
5271: void op_5a58(UWORD opcode)
5272: {
5273: ULONG srcreg = 5;
5274: ULONG dstreg = (opcode & 7) >> 0;
5275: {{ ULONG src = srcreg;
5276: { CPTR dsta = regs.a[dstreg];
5277: WORD dst = get_word(dsta);
5278: { regs.a[dstreg] += 2;
5279: { ULONG newv = dst + src;
5280: { bool flgs = ((WORD)(src)) < 0;
5281: bool flgo = ((WORD)(dst)) < 0;
5282: bool flgn = ((WORD)(newv)) < 0;
5283: regs.z = ((WORD)(newv)) == 0;
5284: regs.v = (flgs == flgo) && (flgn != flgo);
5285: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5286: regs.n = flgn != 0;
5287: put_word(dsta,newv);
5288: }}}}}}}
5289: void op_5a60(UWORD opcode)
5290: {
5291: ULONG srcreg = 5;
5292: ULONG dstreg = (opcode & 7) >> 0;
5293: {{ ULONG src = srcreg;
5294: { regs.a[dstreg] -= 2;
5295: { CPTR dsta = regs.a[dstreg];
5296: WORD dst = get_word(dsta);
5297: { ULONG newv = dst + src;
5298: { bool flgs = ((WORD)(src)) < 0;
5299: bool flgo = ((WORD)(dst)) < 0;
5300: bool flgn = ((WORD)(newv)) < 0;
5301: regs.z = ((WORD)(newv)) == 0;
5302: regs.v = (flgs == flgo) && (flgn != flgo);
5303: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5304: regs.n = flgn != 0;
5305: put_word(dsta,newv);
5306: }}}}}}}
5307: void op_5a68(UWORD opcode)
5308: {
5309: ULONG srcreg = 5;
5310: ULONG dstreg = (opcode & 7) >> 0;
5311: {{ ULONG src = srcreg;
5312: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
5313: WORD dst = get_word(dsta);
5314: { ULONG newv = dst + src;
5315: { bool flgs = ((WORD)(src)) < 0;
5316: bool flgo = ((WORD)(dst)) < 0;
5317: bool flgn = ((WORD)(newv)) < 0;
5318: regs.z = ((WORD)(newv)) == 0;
5319: regs.v = (flgs == flgo) && (flgn != flgo);
5320: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5321: regs.n = flgn != 0;
5322: put_word(dsta,newv);
5323: }}}}}}
5324: void op_5a70(UWORD opcode)
5325: {
5326: ULONG srcreg = 5;
5327: ULONG dstreg = (opcode & 7) >> 0;
5328: {{ ULONG src = srcreg;
5329: { CPTR dsta = regs.a[dstreg];
5330: UWORD dstdp = nextiword();
5331: dsta += (LONG)(BYTE)(dstdp & 0xFF);
5332: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
5333: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
5334: dsta += dstdpr;
5335: { WORD dst = get_word(dsta);
5336: { ULONG newv = dst + src;
5337: { bool flgs = ((WORD)(src)) < 0;
5338: bool flgo = ((WORD)(dst)) < 0;
5339: bool flgn = ((WORD)(newv)) < 0;
5340: regs.z = ((WORD)(newv)) == 0;
5341: regs.v = (flgs == flgo) && (flgn != flgo);
5342: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5343: regs.n = flgn != 0;
5344: put_word(dsta,newv);
5345: }}}}}}}}
5346: void op_5a78(UWORD opcode)
5347: {
5348: ULONG srcreg = 5;
5349: {{ ULONG src = srcreg;
5350: { CPTR dsta = (LONG)(WORD)nextiword();
5351: WORD dst = get_word(dsta);
5352: { ULONG newv = dst + src;
5353: { bool flgs = ((WORD)(src)) < 0;
5354: bool flgo = ((WORD)(dst)) < 0;
5355: bool flgn = ((WORD)(newv)) < 0;
5356: regs.z = ((WORD)(newv)) == 0;
5357: regs.v = (flgs == flgo) && (flgn != flgo);
5358: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5359: regs.n = flgn != 0;
5360: put_word(dsta,newv);
5361: }}}}}}
5362: void op_5a79(UWORD opcode)
5363: {
5364: ULONG srcreg = 5;
5365: {{ ULONG src = srcreg;
5366: { CPTR dsta = nextilong();
5367: WORD dst = get_word(dsta);
5368: { ULONG newv = dst + src;
5369: { bool flgs = ((WORD)(src)) < 0;
5370: bool flgo = ((WORD)(dst)) < 0;
5371: bool flgn = ((WORD)(newv)) < 0;
5372: regs.z = ((WORD)(newv)) == 0;
5373: regs.v = (flgs == flgo) && (flgn != flgo);
5374: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
5375: regs.n = flgn != 0;
5376: put_word(dsta,newv);
5377: }}}}}}
5378: void op_5a80(UWORD opcode)
5379: {
5380: ULONG srcreg = 5;
5381: ULONG dstreg = (opcode & 7) >> 0;
5382: {{ ULONG src = srcreg;
5383: { LONG dst = regs.d[dstreg];
5384: { ULONG newv = dst + src;
5385: { bool flgs = ((LONG)(src)) < 0;
5386: bool flgo = ((LONG)(dst)) < 0;
5387: bool flgn = ((LONG)(newv)) < 0;
5388: regs.z = ((LONG)(newv)) == 0;
5389: regs.v = (flgs == flgo) && (flgn != flgo);
5390: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5391: regs.n = flgn != 0;
5392: regs.d[dstreg] = (newv);
5393: }}}}}}
5394: void op_5a88(UWORD opcode)
5395: {
5396: ULONG srcreg = 5;
5397: ULONG dstreg = (opcode & 7) >> 0;
5398: {{ ULONG src = srcreg;
5399: { LONG dst = regs.a[dstreg];
5400: { ULONG newv = dst + src;
5401: regs.a[dstreg] = (newv);
5402: }}}}}
5403: void op_5a90(UWORD opcode)
5404: {
5405: ULONG srcreg = 5;
5406: ULONG dstreg = (opcode & 7) >> 0;
5407: {{ ULONG src = srcreg;
5408: { CPTR dsta = regs.a[dstreg];
5409: LONG dst = get_long(dsta);
5410: { ULONG newv = dst + src;
5411: { bool flgs = ((LONG)(src)) < 0;
5412: bool flgo = ((LONG)(dst)) < 0;
5413: bool flgn = ((LONG)(newv)) < 0;
5414: regs.z = ((LONG)(newv)) == 0;
5415: regs.v = (flgs == flgo) && (flgn != flgo);
5416: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5417: regs.n = flgn != 0;
5418: put_long(dsta,newv);
5419: }}}}}}
5420: void op_5a98(UWORD opcode)
5421: {
5422: ULONG srcreg = 5;
5423: ULONG dstreg = (opcode & 7) >> 0;
5424: {{ ULONG src = srcreg;
5425: { CPTR dsta = regs.a[dstreg];
5426: LONG dst = get_long(dsta);
5427: { regs.a[dstreg] += 4;
5428: { ULONG newv = dst + src;
5429: { bool flgs = ((LONG)(src)) < 0;
5430: bool flgo = ((LONG)(dst)) < 0;
5431: bool flgn = ((LONG)(newv)) < 0;
5432: regs.z = ((LONG)(newv)) == 0;
5433: regs.v = (flgs == flgo) && (flgn != flgo);
5434: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5435: regs.n = flgn != 0;
5436: put_long(dsta,newv);
5437: }}}}}}}
5438: void op_5aa0(UWORD opcode)
5439: {
5440: ULONG srcreg = 5;
5441: ULONG dstreg = (opcode & 7) >> 0;
5442: {{ ULONG src = srcreg;
5443: { regs.a[dstreg] -= 4;
5444: { CPTR dsta = regs.a[dstreg];
5445: LONG dst = get_long(dsta);
5446: { ULONG newv = dst + src;
5447: { bool flgs = ((LONG)(src)) < 0;
5448: bool flgo = ((LONG)(dst)) < 0;
5449: bool flgn = ((LONG)(newv)) < 0;
5450: regs.z = ((LONG)(newv)) == 0;
5451: regs.v = (flgs == flgo) && (flgn != flgo);
5452: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5453: regs.n = flgn != 0;
5454: put_long(dsta,newv);
5455: }}}}}}}
5456: void op_5aa8(UWORD opcode)
5457: {
5458: ULONG srcreg = 5;
5459: ULONG dstreg = (opcode & 7) >> 0;
5460: {{ ULONG src = srcreg;
5461: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
5462: LONG dst = get_long(dsta);
5463: { ULONG newv = dst + src;
5464: { bool flgs = ((LONG)(src)) < 0;
5465: bool flgo = ((LONG)(dst)) < 0;
5466: bool flgn = ((LONG)(newv)) < 0;
5467: regs.z = ((LONG)(newv)) == 0;
5468: regs.v = (flgs == flgo) && (flgn != flgo);
5469: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5470: regs.n = flgn != 0;
5471: put_long(dsta,newv);
5472: }}}}}}
5473: void op_5ab0(UWORD opcode)
5474: {
5475: ULONG srcreg = 5;
5476: ULONG dstreg = (opcode & 7) >> 0;
5477: {{ ULONG src = srcreg;
5478: { CPTR dsta = regs.a[dstreg];
5479: UWORD dstdp = nextiword();
5480: dsta += (LONG)(BYTE)(dstdp & 0xFF);
5481: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
5482: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
5483: dsta += dstdpr;
5484: { LONG dst = get_long(dsta);
5485: { ULONG newv = dst + src;
5486: { bool flgs = ((LONG)(src)) < 0;
5487: bool flgo = ((LONG)(dst)) < 0;
5488: bool flgn = ((LONG)(newv)) < 0;
5489: regs.z = ((LONG)(newv)) == 0;
5490: regs.v = (flgs == flgo) && (flgn != flgo);
5491: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5492: regs.n = flgn != 0;
5493: put_long(dsta,newv);
5494: }}}}}}}}
5495: void op_5ab8(UWORD opcode)
5496: {
5497: ULONG srcreg = 5;
5498: {{ ULONG src = srcreg;
5499: { CPTR dsta = (LONG)(WORD)nextiword();
5500: LONG dst = get_long(dsta);
5501: { ULONG newv = dst + src;
5502: { bool flgs = ((LONG)(src)) < 0;
5503: bool flgo = ((LONG)(dst)) < 0;
5504: bool flgn = ((LONG)(newv)) < 0;
5505: regs.z = ((LONG)(newv)) == 0;
5506: regs.v = (flgs == flgo) && (flgn != flgo);
5507: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5508: regs.n = flgn != 0;
5509: put_long(dsta,newv);
5510: }}}}}}
5511: void op_5ab9(UWORD opcode)
5512: {
5513: ULONG srcreg = 5;
5514: {{ ULONG src = srcreg;
5515: { CPTR dsta = nextilong();
5516: LONG dst = get_long(dsta);
5517: { ULONG newv = dst + src;
5518: { bool flgs = ((LONG)(src)) < 0;
5519: bool flgo = ((LONG)(dst)) < 0;
5520: bool flgn = ((LONG)(newv)) < 0;
5521: regs.z = ((LONG)(newv)) == 0;
5522: regs.v = (flgs == flgo) && (flgn != flgo);
5523: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
5524: regs.n = flgn != 0;
5525: put_long(dsta,newv);
5526: }}}}}}
5527: void op_5ac0(UWORD opcode)
5528: {
5529: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5530: {{{ int val = cctrue(10) ? 0xff : 0;
5531: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
5532: }}}}
5533: void op_5ac8(UWORD opcode)
5534: {
5535: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5536: {{ WORD src = regs.d[srcreg];
5537: { WORD offs = nextiword();
5538: if (!cctrue(10)) {
5539: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
5540: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
5541: }
5542: }}}}
5543: void op_5ad0(UWORD opcode)
5544: {
5545: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5546: {{ CPTR srca = regs.a[srcreg];
5547: { int val = cctrue(10) ? 0xff : 0;
5548: put_byte(srca,val);
5549: }}}}
5550: void op_5ad8(UWORD opcode)
5551: {
5552: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5553: {{ CPTR srca = regs.a[srcreg];
5554: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
5555: { int val = cctrue(10) ? 0xff : 0;
5556: put_byte(srca,val);
5557: }}}}}
5558: void op_5ae0(UWORD opcode)
5559: {
5560: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5561: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
5562: { CPTR srca = regs.a[srcreg];
5563: { int val = cctrue(10) ? 0xff : 0;
5564: put_byte(srca,val);
5565: }}}}}
5566: void op_5ae8(UWORD opcode)
5567: {
5568: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5569: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
5570: { int val = cctrue(10) ? 0xff : 0;
5571: put_byte(srca,val);
5572: }}}}
5573: void op_5af0(UWORD opcode)
5574: {
5575: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
5576: {{ CPTR srca = regs.a[srcreg];
5577: UWORD srcdp = nextiword();
5578: srca += (LONG)(BYTE)(srcdp & 0xFF);
5579: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
5580: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
5581: srca += srcdpr;
5582: { int val = cctrue(10) ? 0xff : 0;
5583: put_byte(srca,val);
5584: }}}}}
5585: void op_5af8(UWORD opcode)
5586: {
5587: {{ CPTR srca = (LONG)(WORD)nextiword();
5588: { int val = cctrue(10) ? 0xff : 0;
5589: put_byte(srca,val);
5590: }}}}
5591: void op_5af9(UWORD opcode)
5592: {
5593: {{ CPTR srca = nextilong();
5594: { int val = cctrue(10) ? 0xff : 0;
5595: put_byte(srca,val);
5596: }}}}
5597: void op_5b00(UWORD opcode)
5598: {
5599: ULONG srcreg = 5;
5600: ULONG dstreg = (opcode & 7) >> 0;
5601: {{ ULONG src = srcreg;
5602: { BYTE dst = regs.d[dstreg];
5603: { ULONG newv = dst - src;
5604: { bool flgs = ((BYTE)(src)) < 0;
5605: bool flgo = ((BYTE)(dst)) < 0;
5606: bool flgn = ((BYTE)(newv)) < 0;
5607: regs.z = ((BYTE)(newv)) == 0;
5608: regs.v = (flgs != flgo) && (flgn != flgo);
5609: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5610: regs.n = flgn != 0;
5611: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
5612: }}}}}}
5613: void op_5b10(UWORD opcode)
5614: {
5615: ULONG srcreg = 5;
5616: ULONG dstreg = (opcode & 7) >> 0;
5617: {{ ULONG src = srcreg;
5618: { CPTR dsta = regs.a[dstreg];
5619: BYTE dst = get_byte(dsta);
5620: { ULONG newv = dst - src;
5621: { bool flgs = ((BYTE)(src)) < 0;
5622: bool flgo = ((BYTE)(dst)) < 0;
5623: bool flgn = ((BYTE)(newv)) < 0;
5624: regs.z = ((BYTE)(newv)) == 0;
5625: regs.v = (flgs != flgo) && (flgn != flgo);
5626: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5627: regs.n = flgn != 0;
5628: put_byte(dsta,newv);
5629: }}}}}}
5630: void op_5b18(UWORD opcode)
5631: {
5632: ULONG srcreg = 5;
5633: ULONG dstreg = (opcode & 7) >> 0;
5634: {{ ULONG src = srcreg;
5635: { CPTR dsta = regs.a[dstreg];
5636: BYTE dst = get_byte(dsta);
5637: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
5638: { ULONG newv = dst - src;
5639: { bool flgs = ((BYTE)(src)) < 0;
5640: bool flgo = ((BYTE)(dst)) < 0;
5641: bool flgn = ((BYTE)(newv)) < 0;
5642: regs.z = ((BYTE)(newv)) == 0;
5643: regs.v = (flgs != flgo) && (flgn != flgo);
5644: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5645: regs.n = flgn != 0;
5646: put_byte(dsta,newv);
5647: }}}}}}}
5648: void op_5b20(UWORD opcode)
5649: {
5650: ULONG srcreg = 5;
5651: ULONG dstreg = (opcode & 7) >> 0;
5652: {{ ULONG src = srcreg;
5653: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
5654: { CPTR dsta = regs.a[dstreg];
5655: BYTE dst = get_byte(dsta);
5656: { ULONG newv = dst - src;
5657: { bool flgs = ((BYTE)(src)) < 0;
5658: bool flgo = ((BYTE)(dst)) < 0;
5659: bool flgn = ((BYTE)(newv)) < 0;
5660: regs.z = ((BYTE)(newv)) == 0;
5661: regs.v = (flgs != flgo) && (flgn != flgo);
5662: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5663: regs.n = flgn != 0;
5664: put_byte(dsta,newv);
5665: }}}}}}}
5666: void op_5b28(UWORD opcode)
5667: {
5668: ULONG srcreg = 5;
5669: ULONG dstreg = (opcode & 7) >> 0;
5670: {{ ULONG src = srcreg;
5671: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
5672: BYTE dst = get_byte(dsta);
5673: { ULONG newv = dst - src;
5674: { bool flgs = ((BYTE)(src)) < 0;
5675: bool flgo = ((BYTE)(dst)) < 0;
5676: bool flgn = ((BYTE)(newv)) < 0;
5677: regs.z = ((BYTE)(newv)) == 0;
5678: regs.v = (flgs != flgo) && (flgn != flgo);
5679: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5680: regs.n = flgn != 0;
5681: put_byte(dsta,newv);
5682: }}}}}}
5683: void op_5b30(UWORD opcode)
5684: {
5685: ULONG srcreg = 5;
5686: ULONG dstreg = (opcode & 7) >> 0;
5687: {{ ULONG src = srcreg;
5688: { CPTR dsta = regs.a[dstreg];
5689: UWORD dstdp = nextiword();
5690: dsta += (LONG)(BYTE)(dstdp & 0xFF);
5691: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
5692: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
5693: dsta += dstdpr;
5694: { BYTE dst = get_byte(dsta);
5695: { ULONG newv = dst - src;
5696: { bool flgs = ((BYTE)(src)) < 0;
5697: bool flgo = ((BYTE)(dst)) < 0;
5698: bool flgn = ((BYTE)(newv)) < 0;
5699: regs.z = ((BYTE)(newv)) == 0;
5700: regs.v = (flgs != flgo) && (flgn != flgo);
5701: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5702: regs.n = flgn != 0;
5703: put_byte(dsta,newv);
5704: }}}}}}}}
5705: void op_5b38(UWORD opcode)
5706: {
5707: ULONG srcreg = 5;
5708: {{ ULONG src = srcreg;
5709: { CPTR dsta = (LONG)(WORD)nextiword();
5710: BYTE dst = get_byte(dsta);
5711: { ULONG newv = dst - src;
5712: { bool flgs = ((BYTE)(src)) < 0;
5713: bool flgo = ((BYTE)(dst)) < 0;
5714: bool flgn = ((BYTE)(newv)) < 0;
5715: regs.z = ((BYTE)(newv)) == 0;
5716: regs.v = (flgs != flgo) && (flgn != flgo);
5717: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5718: regs.n = flgn != 0;
5719: put_byte(dsta,newv);
5720: }}}}}}
5721: void op_5b39(UWORD opcode)
5722: {
5723: ULONG srcreg = 5;
5724: {{ ULONG src = srcreg;
5725: { CPTR dsta = nextilong();
5726: BYTE dst = get_byte(dsta);
5727: { ULONG newv = dst - src;
5728: { bool flgs = ((BYTE)(src)) < 0;
5729: bool flgo = ((BYTE)(dst)) < 0;
5730: bool flgn = ((BYTE)(newv)) < 0;
5731: regs.z = ((BYTE)(newv)) == 0;
5732: regs.v = (flgs != flgo) && (flgn != flgo);
5733: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
5734: regs.n = flgn != 0;
5735: put_byte(dsta,newv);
5736: }}}}}}
5737: void op_5b40(UWORD opcode)
5738: {
5739: ULONG srcreg = 5;
5740: ULONG dstreg = (opcode & 7) >> 0;
5741: {{ ULONG src = srcreg;
5742: { WORD dst = regs.d[dstreg];
5743: { ULONG newv = dst - src;
5744: { bool flgs = ((WORD)(src)) < 0;
5745: bool flgo = ((WORD)(dst)) < 0;
5746: bool flgn = ((WORD)(newv)) < 0;
5747: regs.z = ((WORD)(newv)) == 0;
5748: regs.v = (flgs != flgo) && (flgn != flgo);
5749: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5750: regs.n = flgn != 0;
5751: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
5752: }}}}}}
5753: void op_5b48(UWORD opcode)
5754: {
5755: ULONG srcreg = 5;
5756: ULONG dstreg = (opcode & 7) >> 0;
5757: {{ ULONG src = srcreg;
5758: { LONG dst = regs.a[dstreg];
5759: { ULONG newv = dst - src;
5760: regs.a[dstreg] = (newv);
5761: }}}}}
5762: void op_5b50(UWORD opcode)
5763: {
5764: ULONG srcreg = 5;
5765: ULONG dstreg = (opcode & 7) >> 0;
5766: {{ ULONG src = srcreg;
5767: { CPTR dsta = regs.a[dstreg];
5768: WORD dst = get_word(dsta);
5769: { ULONG newv = dst - src;
5770: { bool flgs = ((WORD)(src)) < 0;
5771: bool flgo = ((WORD)(dst)) < 0;
5772: bool flgn = ((WORD)(newv)) < 0;
5773: regs.z = ((WORD)(newv)) == 0;
5774: regs.v = (flgs != flgo) && (flgn != flgo);
5775: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5776: regs.n = flgn != 0;
5777: put_word(dsta,newv);
5778: }}}}}}
5779: void op_5b58(UWORD opcode)
5780: {
5781: ULONG srcreg = 5;
5782: ULONG dstreg = (opcode & 7) >> 0;
5783: {{ ULONG src = srcreg;
5784: { CPTR dsta = regs.a[dstreg];
5785: WORD dst = get_word(dsta);
5786: { regs.a[dstreg] += 2;
5787: { ULONG newv = dst - src;
5788: { bool flgs = ((WORD)(src)) < 0;
5789: bool flgo = ((WORD)(dst)) < 0;
5790: bool flgn = ((WORD)(newv)) < 0;
5791: regs.z = ((WORD)(newv)) == 0;
5792: regs.v = (flgs != flgo) && (flgn != flgo);
5793: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5794: regs.n = flgn != 0;
5795: put_word(dsta,newv);
5796: }}}}}}}
5797: void op_5b60(UWORD opcode)
5798: {
5799: ULONG srcreg = 5;
5800: ULONG dstreg = (opcode & 7) >> 0;
5801: {{ ULONG src = srcreg;
5802: { regs.a[dstreg] -= 2;
5803: { CPTR dsta = regs.a[dstreg];
5804: WORD dst = get_word(dsta);
5805: { ULONG newv = dst - src;
5806: { bool flgs = ((WORD)(src)) < 0;
5807: bool flgo = ((WORD)(dst)) < 0;
5808: bool flgn = ((WORD)(newv)) < 0;
5809: regs.z = ((WORD)(newv)) == 0;
5810: regs.v = (flgs != flgo) && (flgn != flgo);
5811: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5812: regs.n = flgn != 0;
5813: put_word(dsta,newv);
5814: }}}}}}}
5815: void op_5b68(UWORD opcode)
5816: {
5817: ULONG srcreg = 5;
5818: ULONG dstreg = (opcode & 7) >> 0;
5819: {{ ULONG src = srcreg;
5820: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
5821: WORD dst = get_word(dsta);
5822: { ULONG newv = dst - src;
5823: { bool flgs = ((WORD)(src)) < 0;
5824: bool flgo = ((WORD)(dst)) < 0;
5825: bool flgn = ((WORD)(newv)) < 0;
5826: regs.z = ((WORD)(newv)) == 0;
5827: regs.v = (flgs != flgo) && (flgn != flgo);
5828: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5829: regs.n = flgn != 0;
5830: put_word(dsta,newv);
5831: }}}}}}
5832: void op_5b70(UWORD opcode)
5833: {
5834: ULONG srcreg = 5;
5835: ULONG dstreg = (opcode & 7) >> 0;
5836: {{ ULONG src = srcreg;
5837: { CPTR dsta = regs.a[dstreg];
5838: UWORD dstdp = nextiword();
5839: dsta += (LONG)(BYTE)(dstdp & 0xFF);
5840: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
5841: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
5842: dsta += dstdpr;
5843: { WORD dst = get_word(dsta);
5844: { ULONG newv = dst - src;
5845: { bool flgs = ((WORD)(src)) < 0;
5846: bool flgo = ((WORD)(dst)) < 0;
5847: bool flgn = ((WORD)(newv)) < 0;
5848: regs.z = ((WORD)(newv)) == 0;
5849: regs.v = (flgs != flgo) && (flgn != flgo);
5850: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5851: regs.n = flgn != 0;
5852: put_word(dsta,newv);
5853: }}}}}}}}
5854: void op_5b78(UWORD opcode)
5855: {
5856: ULONG srcreg = 5;
5857: {{ ULONG src = srcreg;
5858: { CPTR dsta = (LONG)(WORD)nextiword();
5859: WORD dst = get_word(dsta);
5860: { ULONG newv = dst - src;
5861: { bool flgs = ((WORD)(src)) < 0;
5862: bool flgo = ((WORD)(dst)) < 0;
5863: bool flgn = ((WORD)(newv)) < 0;
5864: regs.z = ((WORD)(newv)) == 0;
5865: regs.v = (flgs != flgo) && (flgn != flgo);
5866: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5867: regs.n = flgn != 0;
5868: put_word(dsta,newv);
5869: }}}}}}
5870: void op_5b79(UWORD opcode)
5871: {
5872: ULONG srcreg = 5;
5873: {{ ULONG src = srcreg;
5874: { CPTR dsta = nextilong();
5875: WORD dst = get_word(dsta);
5876: { ULONG newv = dst - src;
5877: { bool flgs = ((WORD)(src)) < 0;
5878: bool flgo = ((WORD)(dst)) < 0;
5879: bool flgn = ((WORD)(newv)) < 0;
5880: regs.z = ((WORD)(newv)) == 0;
5881: regs.v = (flgs != flgo) && (flgn != flgo);
5882: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
5883: regs.n = flgn != 0;
5884: put_word(dsta,newv);
5885: }}}}}}
5886: void op_5b80(UWORD opcode)
5887: {
5888: ULONG srcreg = 5;
5889: ULONG dstreg = (opcode & 7) >> 0;
5890: {{ ULONG src = srcreg;
5891: { LONG dst = regs.d[dstreg];
5892: { ULONG newv = dst - src;
5893: { bool flgs = ((LONG)(src)) < 0;
5894: bool flgo = ((LONG)(dst)) < 0;
5895: bool flgn = ((LONG)(newv)) < 0;
5896: regs.z = ((LONG)(newv)) == 0;
5897: regs.v = (flgs != flgo) && (flgn != flgo);
5898: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
5899: regs.n = flgn != 0;
5900: regs.d[dstreg] = (newv);
5901: }}}}}}
5902: void op_5b88(UWORD opcode)
5903: {
5904: ULONG srcreg = 5;
5905: ULONG dstreg = (opcode & 7) >> 0;
5906: {{ ULONG src = srcreg;
5907: { LONG dst = regs.a[dstreg];
5908: { ULONG newv = dst - src;
5909: regs.a[dstreg] = (newv);
5910: }}}}}
5911: void op_5b90(UWORD opcode)
5912: {
5913: ULONG srcreg = 5;
5914: ULONG dstreg = (opcode & 7) >> 0;
5915: {{ ULONG src = srcreg;
5916: { CPTR dsta = regs.a[dstreg];
5917: LONG dst = get_long(dsta);
5918: { ULONG newv = dst - src;
5919: { bool flgs = ((LONG)(src)) < 0;
5920: bool flgo = ((LONG)(dst)) < 0;
5921: bool flgn = ((LONG)(newv)) < 0;
5922: regs.z = ((LONG)(newv)) == 0;
5923: regs.v = (flgs != flgo) && (flgn != flgo);
5924: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
5925: regs.n = flgn != 0;
5926: put_long(dsta,newv);
5927: }}}}}}
5928: void op_5b98(UWORD opcode)
5929: {
5930: ULONG srcreg = 5;
5931: ULONG dstreg = (opcode & 7) >> 0;
5932: {{ ULONG src = srcreg;
5933: { CPTR dsta = regs.a[dstreg];
5934: LONG dst = get_long(dsta);
5935: { regs.a[dstreg] += 4;
5936: { ULONG newv = dst - src;
5937: { bool flgs = ((LONG)(src)) < 0;
5938: bool flgo = ((LONG)(dst)) < 0;
5939: bool flgn = ((LONG)(newv)) < 0;
5940: regs.z = ((LONG)(newv)) == 0;
5941: regs.v = (flgs != flgo) && (flgn != flgo);
5942: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
5943: regs.n = flgn != 0;
5944: put_long(dsta,newv);
5945: }}}}}}}
5946: void op_5ba0(UWORD opcode)
5947: {
5948: ULONG srcreg = 5;
5949: ULONG dstreg = (opcode & 7) >> 0;
5950: {{ ULONG src = srcreg;
5951: { regs.a[dstreg] -= 4;
5952: { CPTR dsta = regs.a[dstreg];
5953: LONG dst = get_long(dsta);
5954: { ULONG newv = dst - src;
5955: { bool flgs = ((LONG)(src)) < 0;
5956: bool flgo = ((LONG)(dst)) < 0;
5957: bool flgn = ((LONG)(newv)) < 0;
5958: regs.z = ((LONG)(newv)) == 0;
5959: regs.v = (flgs != flgo) && (flgn != flgo);
5960: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
5961: regs.n = flgn != 0;
5962: put_long(dsta,newv);
5963: }}}}}}}
5964: void op_5ba8(UWORD opcode)
5965: {
5966: ULONG srcreg = 5;
5967: ULONG dstreg = (opcode & 7) >> 0;
5968: {{ ULONG src = srcreg;
5969: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
5970: LONG dst = get_long(dsta);
5971: { ULONG newv = dst - src;
5972: { bool flgs = ((LONG)(src)) < 0;
5973: bool flgo = ((LONG)(dst)) < 0;
5974: bool flgn = ((LONG)(newv)) < 0;
5975: regs.z = ((LONG)(newv)) == 0;
5976: regs.v = (flgs != flgo) && (flgn != flgo);
5977: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
5978: regs.n = flgn != 0;
5979: put_long(dsta,newv);
5980: }}}}}}
5981: void op_5bb0(UWORD opcode)
5982: {
5983: ULONG srcreg = 5;
5984: ULONG dstreg = (opcode & 7) >> 0;
5985: {{ ULONG src = srcreg;
5986: { CPTR dsta = regs.a[dstreg];
5987: UWORD dstdp = nextiword();
5988: dsta += (LONG)(BYTE)(dstdp & 0xFF);
5989: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
5990: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
5991: dsta += dstdpr;
5992: { LONG dst = get_long(dsta);
5993: { ULONG newv = dst - src;
5994: { bool flgs = ((LONG)(src)) < 0;
5995: bool flgo = ((LONG)(dst)) < 0;
5996: bool flgn = ((LONG)(newv)) < 0;
5997: regs.z = ((LONG)(newv)) == 0;
5998: regs.v = (flgs != flgo) && (flgn != flgo);
5999: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6000: regs.n = flgn != 0;
6001: put_long(dsta,newv);
6002: }}}}}}}}
6003: void op_5bb8(UWORD opcode)
6004: {
6005: ULONG srcreg = 5;
6006: {{ ULONG src = srcreg;
6007: { CPTR dsta = (LONG)(WORD)nextiword();
6008: LONG dst = get_long(dsta);
6009: { ULONG newv = dst - src;
6010: { bool flgs = ((LONG)(src)) < 0;
6011: bool flgo = ((LONG)(dst)) < 0;
6012: bool flgn = ((LONG)(newv)) < 0;
6013: regs.z = ((LONG)(newv)) == 0;
6014: regs.v = (flgs != flgo) && (flgn != flgo);
6015: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6016: regs.n = flgn != 0;
6017: put_long(dsta,newv);
6018: }}}}}}
6019: void op_5bb9(UWORD opcode)
6020: {
6021: ULONG srcreg = 5;
6022: {{ ULONG src = srcreg;
6023: { CPTR dsta = nextilong();
6024: LONG dst = get_long(dsta);
6025: { ULONG newv = dst - src;
6026: { bool flgs = ((LONG)(src)) < 0;
6027: bool flgo = ((LONG)(dst)) < 0;
6028: bool flgn = ((LONG)(newv)) < 0;
6029: regs.z = ((LONG)(newv)) == 0;
6030: regs.v = (flgs != flgo) && (flgn != flgo);
6031: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6032: regs.n = flgn != 0;
6033: put_long(dsta,newv);
6034: }}}}}}
6035: void op_5bc0(UWORD opcode)
6036: {
6037: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6038: {{{ int val = cctrue(11) ? 0xff : 0;
6039: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
6040: }}}}
6041: void op_5bc8(UWORD opcode)
6042: {
6043: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6044: {{ WORD src = regs.d[srcreg];
6045: { WORD offs = nextiword();
6046: if (!cctrue(11)) {
6047: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
6048: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
6049: }
6050: }}}}
6051: void op_5bd0(UWORD opcode)
6052: {
6053: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6054: {{ CPTR srca = regs.a[srcreg];
6055: { int val = cctrue(11) ? 0xff : 0;
6056: put_byte(srca,val);
6057: }}}}
6058: void op_5bd8(UWORD opcode)
6059: {
6060: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6061: {{ CPTR srca = regs.a[srcreg];
6062: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
6063: { int val = cctrue(11) ? 0xff : 0;
6064: put_byte(srca,val);
6065: }}}}}
6066: void op_5be0(UWORD opcode)
6067: {
6068: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6069: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
6070: { CPTR srca = regs.a[srcreg];
6071: { int val = cctrue(11) ? 0xff : 0;
6072: put_byte(srca,val);
6073: }}}}}
6074: void op_5be8(UWORD opcode)
6075: {
6076: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6077: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
6078: { int val = cctrue(11) ? 0xff : 0;
6079: put_byte(srca,val);
6080: }}}}
6081: void op_5bf0(UWORD opcode)
6082: {
6083: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6084: {{ CPTR srca = regs.a[srcreg];
6085: UWORD srcdp = nextiword();
6086: srca += (LONG)(BYTE)(srcdp & 0xFF);
6087: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
6088: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
6089: srca += srcdpr;
6090: { int val = cctrue(11) ? 0xff : 0;
6091: put_byte(srca,val);
6092: }}}}}
6093: void op_5bf8(UWORD opcode)
6094: {
6095: {{ CPTR srca = (LONG)(WORD)nextiword();
6096: { int val = cctrue(11) ? 0xff : 0;
6097: put_byte(srca,val);
6098: }}}}
6099: void op_5bf9(UWORD opcode)
6100: {
6101: {{ CPTR srca = nextilong();
6102: { int val = cctrue(11) ? 0xff : 0;
6103: put_byte(srca,val);
6104: }}}}
6105: void op_5c00(UWORD opcode)
6106: {
6107: ULONG srcreg = 6;
6108: ULONG dstreg = (opcode & 7) >> 0;
6109: {{ ULONG src = srcreg;
6110: { BYTE dst = regs.d[dstreg];
6111: { ULONG newv = dst + src;
6112: { bool flgs = ((BYTE)(src)) < 0;
6113: bool flgo = ((BYTE)(dst)) < 0;
6114: bool flgn = ((BYTE)(newv)) < 0;
6115: regs.z = ((BYTE)(newv)) == 0;
6116: regs.v = (flgs == flgo) && (flgn != flgo);
6117: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6118: regs.n = flgn != 0;
6119: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
6120: }}}}}}
6121: void op_5c10(UWORD opcode)
6122: {
6123: ULONG srcreg = 6;
6124: ULONG dstreg = (opcode & 7) >> 0;
6125: {{ ULONG src = srcreg;
6126: { CPTR dsta = regs.a[dstreg];
6127: BYTE dst = get_byte(dsta);
6128: { ULONG newv = dst + src;
6129: { bool flgs = ((BYTE)(src)) < 0;
6130: bool flgo = ((BYTE)(dst)) < 0;
6131: bool flgn = ((BYTE)(newv)) < 0;
6132: regs.z = ((BYTE)(newv)) == 0;
6133: regs.v = (flgs == flgo) && (flgn != flgo);
6134: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6135: regs.n = flgn != 0;
6136: put_byte(dsta,newv);
6137: }}}}}}
6138: void op_5c18(UWORD opcode)
6139: {
6140: ULONG srcreg = 6;
6141: ULONG dstreg = (opcode & 7) >> 0;
6142: {{ ULONG src = srcreg;
6143: { CPTR dsta = regs.a[dstreg];
6144: BYTE dst = get_byte(dsta);
6145: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
6146: { ULONG newv = dst + src;
6147: { bool flgs = ((BYTE)(src)) < 0;
6148: bool flgo = ((BYTE)(dst)) < 0;
6149: bool flgn = ((BYTE)(newv)) < 0;
6150: regs.z = ((BYTE)(newv)) == 0;
6151: regs.v = (flgs == flgo) && (flgn != flgo);
6152: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6153: regs.n = flgn != 0;
6154: put_byte(dsta,newv);
6155: }}}}}}}
6156: void op_5c20(UWORD opcode)
6157: {
6158: ULONG srcreg = 6;
6159: ULONG dstreg = (opcode & 7) >> 0;
6160: {{ ULONG src = srcreg;
6161: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
6162: { CPTR dsta = regs.a[dstreg];
6163: BYTE dst = get_byte(dsta);
6164: { ULONG newv = dst + src;
6165: { bool flgs = ((BYTE)(src)) < 0;
6166: bool flgo = ((BYTE)(dst)) < 0;
6167: bool flgn = ((BYTE)(newv)) < 0;
6168: regs.z = ((BYTE)(newv)) == 0;
6169: regs.v = (flgs == flgo) && (flgn != flgo);
6170: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6171: regs.n = flgn != 0;
6172: put_byte(dsta,newv);
6173: }}}}}}}
6174: void op_5c28(UWORD opcode)
6175: {
6176: ULONG srcreg = 6;
6177: ULONG dstreg = (opcode & 7) >> 0;
6178: {{ ULONG src = srcreg;
6179: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
6180: BYTE dst = get_byte(dsta);
6181: { ULONG newv = dst + src;
6182: { bool flgs = ((BYTE)(src)) < 0;
6183: bool flgo = ((BYTE)(dst)) < 0;
6184: bool flgn = ((BYTE)(newv)) < 0;
6185: regs.z = ((BYTE)(newv)) == 0;
6186: regs.v = (flgs == flgo) && (flgn != flgo);
6187: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6188: regs.n = flgn != 0;
6189: put_byte(dsta,newv);
6190: }}}}}}
6191: void op_5c30(UWORD opcode)
6192: {
6193: ULONG srcreg = 6;
6194: ULONG dstreg = (opcode & 7) >> 0;
6195: {{ ULONG src = srcreg;
6196: { CPTR dsta = regs.a[dstreg];
6197: UWORD dstdp = nextiword();
6198: dsta += (LONG)(BYTE)(dstdp & 0xFF);
6199: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
6200: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
6201: dsta += dstdpr;
6202: { BYTE dst = get_byte(dsta);
6203: { ULONG newv = dst + src;
6204: { bool flgs = ((BYTE)(src)) < 0;
6205: bool flgo = ((BYTE)(dst)) < 0;
6206: bool flgn = ((BYTE)(newv)) < 0;
6207: regs.z = ((BYTE)(newv)) == 0;
6208: regs.v = (flgs == flgo) && (flgn != flgo);
6209: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6210: regs.n = flgn != 0;
6211: put_byte(dsta,newv);
6212: }}}}}}}}
6213: void op_5c38(UWORD opcode)
6214: {
6215: ULONG srcreg = 6;
6216: {{ ULONG src = srcreg;
6217: { CPTR dsta = (LONG)(WORD)nextiword();
6218: BYTE dst = get_byte(dsta);
6219: { ULONG newv = dst + src;
6220: { bool flgs = ((BYTE)(src)) < 0;
6221: bool flgo = ((BYTE)(dst)) < 0;
6222: bool flgn = ((BYTE)(newv)) < 0;
6223: regs.z = ((BYTE)(newv)) == 0;
6224: regs.v = (flgs == flgo) && (flgn != flgo);
6225: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6226: regs.n = flgn != 0;
6227: put_byte(dsta,newv);
6228: }}}}}}
6229: void op_5c39(UWORD opcode)
6230: {
6231: ULONG srcreg = 6;
6232: {{ ULONG src = srcreg;
6233: { CPTR dsta = nextilong();
6234: BYTE dst = get_byte(dsta);
6235: { ULONG newv = dst + src;
6236: { bool flgs = ((BYTE)(src)) < 0;
6237: bool flgo = ((BYTE)(dst)) < 0;
6238: bool flgn = ((BYTE)(newv)) < 0;
6239: regs.z = ((BYTE)(newv)) == 0;
6240: regs.v = (flgs == flgo) && (flgn != flgo);
6241: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
6242: regs.n = flgn != 0;
6243: put_byte(dsta,newv);
6244: }}}}}}
6245: void op_5c40(UWORD opcode)
6246: {
6247: ULONG srcreg = 6;
6248: ULONG dstreg = (opcode & 7) >> 0;
6249: {{ ULONG src = srcreg;
6250: { WORD dst = regs.d[dstreg];
6251: { ULONG newv = dst + src;
6252: { bool flgs = ((WORD)(src)) < 0;
6253: bool flgo = ((WORD)(dst)) < 0;
6254: bool flgn = ((WORD)(newv)) < 0;
6255: regs.z = ((WORD)(newv)) == 0;
6256: regs.v = (flgs == flgo) && (flgn != flgo);
6257: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6258: regs.n = flgn != 0;
6259: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
6260: }}}}}}
6261: void op_5c48(UWORD opcode)
6262: {
6263: ULONG srcreg = 6;
6264: ULONG dstreg = (opcode & 7) >> 0;
6265: {{ ULONG src = srcreg;
6266: { LONG dst = regs.a[dstreg];
6267: { ULONG newv = dst + src;
6268: regs.a[dstreg] = (newv);
6269: }}}}}
6270: void op_5c50(UWORD opcode)
6271: {
6272: ULONG srcreg = 6;
6273: ULONG dstreg = (opcode & 7) >> 0;
6274: {{ ULONG src = srcreg;
6275: { CPTR dsta = regs.a[dstreg];
6276: WORD dst = get_word(dsta);
6277: { ULONG newv = dst + src;
6278: { bool flgs = ((WORD)(src)) < 0;
6279: bool flgo = ((WORD)(dst)) < 0;
6280: bool flgn = ((WORD)(newv)) < 0;
6281: regs.z = ((WORD)(newv)) == 0;
6282: regs.v = (flgs == flgo) && (flgn != flgo);
6283: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6284: regs.n = flgn != 0;
6285: put_word(dsta,newv);
6286: }}}}}}
6287: void op_5c58(UWORD opcode)
6288: {
6289: ULONG srcreg = 6;
6290: ULONG dstreg = (opcode & 7) >> 0;
6291: {{ ULONG src = srcreg;
6292: { CPTR dsta = regs.a[dstreg];
6293: WORD dst = get_word(dsta);
6294: { regs.a[dstreg] += 2;
6295: { ULONG newv = dst + src;
6296: { bool flgs = ((WORD)(src)) < 0;
6297: bool flgo = ((WORD)(dst)) < 0;
6298: bool flgn = ((WORD)(newv)) < 0;
6299: regs.z = ((WORD)(newv)) == 0;
6300: regs.v = (flgs == flgo) && (flgn != flgo);
6301: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6302: regs.n = flgn != 0;
6303: put_word(dsta,newv);
6304: }}}}}}}
6305: void op_5c60(UWORD opcode)
6306: {
6307: ULONG srcreg = 6;
6308: ULONG dstreg = (opcode & 7) >> 0;
6309: {{ ULONG src = srcreg;
6310: { regs.a[dstreg] -= 2;
6311: { CPTR dsta = regs.a[dstreg];
6312: WORD dst = get_word(dsta);
6313: { ULONG newv = dst + src;
6314: { bool flgs = ((WORD)(src)) < 0;
6315: bool flgo = ((WORD)(dst)) < 0;
6316: bool flgn = ((WORD)(newv)) < 0;
6317: regs.z = ((WORD)(newv)) == 0;
6318: regs.v = (flgs == flgo) && (flgn != flgo);
6319: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6320: regs.n = flgn != 0;
6321: put_word(dsta,newv);
6322: }}}}}}}
6323: void op_5c68(UWORD opcode)
6324: {
6325: ULONG srcreg = 6;
6326: ULONG dstreg = (opcode & 7) >> 0;
6327: {{ ULONG src = srcreg;
6328: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
6329: WORD dst = get_word(dsta);
6330: { ULONG newv = dst + src;
6331: { bool flgs = ((WORD)(src)) < 0;
6332: bool flgo = ((WORD)(dst)) < 0;
6333: bool flgn = ((WORD)(newv)) < 0;
6334: regs.z = ((WORD)(newv)) == 0;
6335: regs.v = (flgs == flgo) && (flgn != flgo);
6336: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6337: regs.n = flgn != 0;
6338: put_word(dsta,newv);
6339: }}}}}}
6340: void op_5c70(UWORD opcode)
6341: {
6342: ULONG srcreg = 6;
6343: ULONG dstreg = (opcode & 7) >> 0;
6344: {{ ULONG src = srcreg;
6345: { CPTR dsta = regs.a[dstreg];
6346: UWORD dstdp = nextiword();
6347: dsta += (LONG)(BYTE)(dstdp & 0xFF);
6348: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
6349: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
6350: dsta += dstdpr;
6351: { WORD dst = get_word(dsta);
6352: { ULONG newv = dst + src;
6353: { bool flgs = ((WORD)(src)) < 0;
6354: bool flgo = ((WORD)(dst)) < 0;
6355: bool flgn = ((WORD)(newv)) < 0;
6356: regs.z = ((WORD)(newv)) == 0;
6357: regs.v = (flgs == flgo) && (flgn != flgo);
6358: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6359: regs.n = flgn != 0;
6360: put_word(dsta,newv);
6361: }}}}}}}}
6362: void op_5c78(UWORD opcode)
6363: {
6364: ULONG srcreg = 6;
6365: {{ ULONG src = srcreg;
6366: { CPTR dsta = (LONG)(WORD)nextiword();
6367: WORD dst = get_word(dsta);
6368: { ULONG newv = dst + src;
6369: { bool flgs = ((WORD)(src)) < 0;
6370: bool flgo = ((WORD)(dst)) < 0;
6371: bool flgn = ((WORD)(newv)) < 0;
6372: regs.z = ((WORD)(newv)) == 0;
6373: regs.v = (flgs == flgo) && (flgn != flgo);
6374: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6375: regs.n = flgn != 0;
6376: put_word(dsta,newv);
6377: }}}}}}
6378: void op_5c79(UWORD opcode)
6379: {
6380: ULONG srcreg = 6;
6381: {{ ULONG src = srcreg;
6382: { CPTR dsta = nextilong();
6383: WORD dst = get_word(dsta);
6384: { ULONG newv = dst + src;
6385: { bool flgs = ((WORD)(src)) < 0;
6386: bool flgo = ((WORD)(dst)) < 0;
6387: bool flgn = ((WORD)(newv)) < 0;
6388: regs.z = ((WORD)(newv)) == 0;
6389: regs.v = (flgs == flgo) && (flgn != flgo);
6390: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
6391: regs.n = flgn != 0;
6392: put_word(dsta,newv);
6393: }}}}}}
6394: void op_5c80(UWORD opcode)
6395: {
6396: ULONG srcreg = 6;
6397: ULONG dstreg = (opcode & 7) >> 0;
6398: {{ ULONG src = srcreg;
6399: { LONG dst = regs.d[dstreg];
6400: { ULONG newv = dst + src;
6401: { bool flgs = ((LONG)(src)) < 0;
6402: bool flgo = ((LONG)(dst)) < 0;
6403: bool flgn = ((LONG)(newv)) < 0;
6404: regs.z = ((LONG)(newv)) == 0;
6405: regs.v = (flgs == flgo) && (flgn != flgo);
6406: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6407: regs.n = flgn != 0;
6408: regs.d[dstreg] = (newv);
6409: }}}}}}
6410: void op_5c88(UWORD opcode)
6411: {
6412: ULONG srcreg = 6;
6413: ULONG dstreg = (opcode & 7) >> 0;
6414: {{ ULONG src = srcreg;
6415: { LONG dst = regs.a[dstreg];
6416: { ULONG newv = dst + src;
6417: regs.a[dstreg] = (newv);
6418: }}}}}
6419: void op_5c90(UWORD opcode)
6420: {
6421: ULONG srcreg = 6;
6422: ULONG dstreg = (opcode & 7) >> 0;
6423: {{ ULONG src = srcreg;
6424: { CPTR dsta = regs.a[dstreg];
6425: LONG dst = get_long(dsta);
6426: { ULONG newv = dst + src;
6427: { bool flgs = ((LONG)(src)) < 0;
6428: bool flgo = ((LONG)(dst)) < 0;
6429: bool flgn = ((LONG)(newv)) < 0;
6430: regs.z = ((LONG)(newv)) == 0;
6431: regs.v = (flgs == flgo) && (flgn != flgo);
6432: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6433: regs.n = flgn != 0;
6434: put_long(dsta,newv);
6435: }}}}}}
6436: void op_5c98(UWORD opcode)
6437: {
6438: ULONG srcreg = 6;
6439: ULONG dstreg = (opcode & 7) >> 0;
6440: {{ ULONG src = srcreg;
6441: { CPTR dsta = regs.a[dstreg];
6442: LONG dst = get_long(dsta);
6443: { regs.a[dstreg] += 4;
6444: { ULONG newv = dst + src;
6445: { bool flgs = ((LONG)(src)) < 0;
6446: bool flgo = ((LONG)(dst)) < 0;
6447: bool flgn = ((LONG)(newv)) < 0;
6448: regs.z = ((LONG)(newv)) == 0;
6449: regs.v = (flgs == flgo) && (flgn != flgo);
6450: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6451: regs.n = flgn != 0;
6452: put_long(dsta,newv);
6453: }}}}}}}
6454: void op_5ca0(UWORD opcode)
6455: {
6456: ULONG srcreg = 6;
6457: ULONG dstreg = (opcode & 7) >> 0;
6458: {{ ULONG src = srcreg;
6459: { regs.a[dstreg] -= 4;
6460: { CPTR dsta = regs.a[dstreg];
6461: LONG dst = get_long(dsta);
6462: { ULONG newv = dst + src;
6463: { bool flgs = ((LONG)(src)) < 0;
6464: bool flgo = ((LONG)(dst)) < 0;
6465: bool flgn = ((LONG)(newv)) < 0;
6466: regs.z = ((LONG)(newv)) == 0;
6467: regs.v = (flgs == flgo) && (flgn != flgo);
6468: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6469: regs.n = flgn != 0;
6470: put_long(dsta,newv);
6471: }}}}}}}
6472: void op_5ca8(UWORD opcode)
6473: {
6474: ULONG srcreg = 6;
6475: ULONG dstreg = (opcode & 7) >> 0;
6476: {{ ULONG src = srcreg;
6477: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
6478: LONG dst = get_long(dsta);
6479: { ULONG newv = dst + src;
6480: { bool flgs = ((LONG)(src)) < 0;
6481: bool flgo = ((LONG)(dst)) < 0;
6482: bool flgn = ((LONG)(newv)) < 0;
6483: regs.z = ((LONG)(newv)) == 0;
6484: regs.v = (flgs == flgo) && (flgn != flgo);
6485: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6486: regs.n = flgn != 0;
6487: put_long(dsta,newv);
6488: }}}}}}
6489: void op_5cb0(UWORD opcode)
6490: {
6491: ULONG srcreg = 6;
6492: ULONG dstreg = (opcode & 7) >> 0;
6493: {{ ULONG src = srcreg;
6494: { CPTR dsta = regs.a[dstreg];
6495: UWORD dstdp = nextiword();
6496: dsta += (LONG)(BYTE)(dstdp & 0xFF);
6497: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
6498: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
6499: dsta += dstdpr;
6500: { LONG dst = get_long(dsta);
6501: { ULONG newv = dst + src;
6502: { bool flgs = ((LONG)(src)) < 0;
6503: bool flgo = ((LONG)(dst)) < 0;
6504: bool flgn = ((LONG)(newv)) < 0;
6505: regs.z = ((LONG)(newv)) == 0;
6506: regs.v = (flgs == flgo) && (flgn != flgo);
6507: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6508: regs.n = flgn != 0;
6509: put_long(dsta,newv);
6510: }}}}}}}}
6511: void op_5cb8(UWORD opcode)
6512: {
6513: ULONG srcreg = 6;
6514: {{ ULONG src = srcreg;
6515: { CPTR dsta = (LONG)(WORD)nextiword();
6516: LONG dst = get_long(dsta);
6517: { ULONG newv = dst + src;
6518: { bool flgs = ((LONG)(src)) < 0;
6519: bool flgo = ((LONG)(dst)) < 0;
6520: bool flgn = ((LONG)(newv)) < 0;
6521: regs.z = ((LONG)(newv)) == 0;
6522: regs.v = (flgs == flgo) && (flgn != flgo);
6523: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6524: regs.n = flgn != 0;
6525: put_long(dsta,newv);
6526: }}}}}}
6527: void op_5cb9(UWORD opcode)
6528: {
6529: ULONG srcreg = 6;
6530: {{ ULONG src = srcreg;
6531: { CPTR dsta = nextilong();
6532: LONG dst = get_long(dsta);
6533: { ULONG newv = dst + src;
6534: { bool flgs = ((LONG)(src)) < 0;
6535: bool flgo = ((LONG)(dst)) < 0;
6536: bool flgn = ((LONG)(newv)) < 0;
6537: regs.z = ((LONG)(newv)) == 0;
6538: regs.v = (flgs == flgo) && (flgn != flgo);
6539: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
6540: regs.n = flgn != 0;
6541: put_long(dsta,newv);
6542: }}}}}}
6543: void op_5cc0(UWORD opcode)
6544: {
6545: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6546: {{{ int val = cctrue(12) ? 0xff : 0;
6547: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
6548: }}}}
6549: void op_5cc8(UWORD opcode)
6550: {
6551: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6552: {{ WORD src = regs.d[srcreg];
6553: { WORD offs = nextiword();
6554: if (!cctrue(12)) {
6555: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
6556: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
6557: }
6558: }}}}
6559: void op_5cd0(UWORD opcode)
6560: {
6561: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6562: {{ CPTR srca = regs.a[srcreg];
6563: { int val = cctrue(12) ? 0xff : 0;
6564: put_byte(srca,val);
6565: }}}}
6566: void op_5cd8(UWORD opcode)
6567: {
6568: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6569: {{ CPTR srca = regs.a[srcreg];
6570: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
6571: { int val = cctrue(12) ? 0xff : 0;
6572: put_byte(srca,val);
6573: }}}}}
6574: void op_5ce0(UWORD opcode)
6575: {
6576: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6577: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
6578: { CPTR srca = regs.a[srcreg];
6579: { int val = cctrue(12) ? 0xff : 0;
6580: put_byte(srca,val);
6581: }}}}}
6582: void op_5ce8(UWORD opcode)
6583: {
6584: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6585: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
6586: { int val = cctrue(12) ? 0xff : 0;
6587: put_byte(srca,val);
6588: }}}}
6589: void op_5cf0(UWORD opcode)
6590: {
6591: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
6592: {{ CPTR srca = regs.a[srcreg];
6593: UWORD srcdp = nextiword();
6594: srca += (LONG)(BYTE)(srcdp & 0xFF);
6595: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
6596: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
6597: srca += srcdpr;
6598: { int val = cctrue(12) ? 0xff : 0;
6599: put_byte(srca,val);
6600: }}}}}
6601: void op_5cf8(UWORD opcode)
6602: {
6603: {{ CPTR srca = (LONG)(WORD)nextiword();
6604: { int val = cctrue(12) ? 0xff : 0;
6605: put_byte(srca,val);
6606: }}}}
6607: void op_5cf9(UWORD opcode)
6608: {
6609: {{ CPTR srca = nextilong();
6610: { int val = cctrue(12) ? 0xff : 0;
6611: put_byte(srca,val);
6612: }}}}
6613: void op_5d00(UWORD opcode)
6614: {
6615: ULONG srcreg = 6;
6616: ULONG dstreg = (opcode & 7) >> 0;
6617: {{ ULONG src = srcreg;
6618: { BYTE dst = regs.d[dstreg];
6619: { ULONG newv = dst - src;
6620: { bool flgs = ((BYTE)(src)) < 0;
6621: bool flgo = ((BYTE)(dst)) < 0;
6622: bool flgn = ((BYTE)(newv)) < 0;
6623: regs.z = ((BYTE)(newv)) == 0;
6624: regs.v = (flgs != flgo) && (flgn != flgo);
6625: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6626: regs.n = flgn != 0;
6627: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
6628: }}}}}}
6629: void op_5d10(UWORD opcode)
6630: {
6631: ULONG srcreg = 6;
6632: ULONG dstreg = (opcode & 7) >> 0;
6633: {{ ULONG src = srcreg;
6634: { CPTR dsta = regs.a[dstreg];
6635: BYTE dst = get_byte(dsta);
6636: { ULONG newv = dst - src;
6637: { bool flgs = ((BYTE)(src)) < 0;
6638: bool flgo = ((BYTE)(dst)) < 0;
6639: bool flgn = ((BYTE)(newv)) < 0;
6640: regs.z = ((BYTE)(newv)) == 0;
6641: regs.v = (flgs != flgo) && (flgn != flgo);
6642: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6643: regs.n = flgn != 0;
6644: put_byte(dsta,newv);
6645: }}}}}}
6646: void op_5d18(UWORD opcode)
6647: {
6648: ULONG srcreg = 6;
6649: ULONG dstreg = (opcode & 7) >> 0;
6650: {{ ULONG src = srcreg;
6651: { CPTR dsta = regs.a[dstreg];
6652: BYTE dst = get_byte(dsta);
6653: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
6654: { ULONG newv = dst - src;
6655: { bool flgs = ((BYTE)(src)) < 0;
6656: bool flgo = ((BYTE)(dst)) < 0;
6657: bool flgn = ((BYTE)(newv)) < 0;
6658: regs.z = ((BYTE)(newv)) == 0;
6659: regs.v = (flgs != flgo) && (flgn != flgo);
6660: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6661: regs.n = flgn != 0;
6662: put_byte(dsta,newv);
6663: }}}}}}}
6664: void op_5d20(UWORD opcode)
6665: {
6666: ULONG srcreg = 6;
6667: ULONG dstreg = (opcode & 7) >> 0;
6668: {{ ULONG src = srcreg;
6669: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
6670: { CPTR dsta = regs.a[dstreg];
6671: BYTE dst = get_byte(dsta);
6672: { ULONG newv = dst - src;
6673: { bool flgs = ((BYTE)(src)) < 0;
6674: bool flgo = ((BYTE)(dst)) < 0;
6675: bool flgn = ((BYTE)(newv)) < 0;
6676: regs.z = ((BYTE)(newv)) == 0;
6677: regs.v = (flgs != flgo) && (flgn != flgo);
6678: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6679: regs.n = flgn != 0;
6680: put_byte(dsta,newv);
6681: }}}}}}}
6682: void op_5d28(UWORD opcode)
6683: {
6684: ULONG srcreg = 6;
6685: ULONG dstreg = (opcode & 7) >> 0;
6686: {{ ULONG src = srcreg;
6687: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
6688: BYTE dst = get_byte(dsta);
6689: { ULONG newv = dst - src;
6690: { bool flgs = ((BYTE)(src)) < 0;
6691: bool flgo = ((BYTE)(dst)) < 0;
6692: bool flgn = ((BYTE)(newv)) < 0;
6693: regs.z = ((BYTE)(newv)) == 0;
6694: regs.v = (flgs != flgo) && (flgn != flgo);
6695: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6696: regs.n = flgn != 0;
6697: put_byte(dsta,newv);
6698: }}}}}}
6699: void op_5d30(UWORD opcode)
6700: {
6701: ULONG srcreg = 6;
6702: ULONG dstreg = (opcode & 7) >> 0;
6703: {{ ULONG src = srcreg;
6704: { CPTR dsta = regs.a[dstreg];
6705: UWORD dstdp = nextiword();
6706: dsta += (LONG)(BYTE)(dstdp & 0xFF);
6707: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
6708: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
6709: dsta += dstdpr;
6710: { BYTE dst = get_byte(dsta);
6711: { ULONG newv = dst - src;
6712: { bool flgs = ((BYTE)(src)) < 0;
6713: bool flgo = ((BYTE)(dst)) < 0;
6714: bool flgn = ((BYTE)(newv)) < 0;
6715: regs.z = ((BYTE)(newv)) == 0;
6716: regs.v = (flgs != flgo) && (flgn != flgo);
6717: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6718: regs.n = flgn != 0;
6719: put_byte(dsta,newv);
6720: }}}}}}}}
6721: void op_5d38(UWORD opcode)
6722: {
6723: ULONG srcreg = 6;
6724: {{ ULONG src = srcreg;
6725: { CPTR dsta = (LONG)(WORD)nextiword();
6726: BYTE dst = get_byte(dsta);
6727: { ULONG newv = dst - src;
6728: { bool flgs = ((BYTE)(src)) < 0;
6729: bool flgo = ((BYTE)(dst)) < 0;
6730: bool flgn = ((BYTE)(newv)) < 0;
6731: regs.z = ((BYTE)(newv)) == 0;
6732: regs.v = (flgs != flgo) && (flgn != flgo);
6733: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6734: regs.n = flgn != 0;
6735: put_byte(dsta,newv);
6736: }}}}}}
6737: void op_5d39(UWORD opcode)
6738: {
6739: ULONG srcreg = 6;
6740: {{ ULONG src = srcreg;
6741: { CPTR dsta = nextilong();
6742: BYTE dst = get_byte(dsta);
6743: { ULONG newv = dst - src;
6744: { bool flgs = ((BYTE)(src)) < 0;
6745: bool flgo = ((BYTE)(dst)) < 0;
6746: bool flgn = ((BYTE)(newv)) < 0;
6747: regs.z = ((BYTE)(newv)) == 0;
6748: regs.v = (flgs != flgo) && (flgn != flgo);
6749: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
6750: regs.n = flgn != 0;
6751: put_byte(dsta,newv);
6752: }}}}}}
6753: void op_5d40(UWORD opcode)
6754: {
6755: ULONG srcreg = 6;
6756: ULONG dstreg = (opcode & 7) >> 0;
6757: {{ ULONG src = srcreg;
6758: { WORD dst = regs.d[dstreg];
6759: { ULONG newv = dst - src;
6760: { bool flgs = ((WORD)(src)) < 0;
6761: bool flgo = ((WORD)(dst)) < 0;
6762: bool flgn = ((WORD)(newv)) < 0;
6763: regs.z = ((WORD)(newv)) == 0;
6764: regs.v = (flgs != flgo) && (flgn != flgo);
6765: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6766: regs.n = flgn != 0;
6767: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
6768: }}}}}}
6769: void op_5d48(UWORD opcode)
6770: {
6771: ULONG srcreg = 6;
6772: ULONG dstreg = (opcode & 7) >> 0;
6773: {{ ULONG src = srcreg;
6774: { LONG dst = regs.a[dstreg];
6775: { ULONG newv = dst - src;
6776: regs.a[dstreg] = (newv);
6777: }}}}}
6778: void op_5d50(UWORD opcode)
6779: {
6780: ULONG srcreg = 6;
6781: ULONG dstreg = (opcode & 7) >> 0;
6782: {{ ULONG src = srcreg;
6783: { CPTR dsta = regs.a[dstreg];
6784: WORD dst = get_word(dsta);
6785: { ULONG newv = dst - src;
6786: { bool flgs = ((WORD)(src)) < 0;
6787: bool flgo = ((WORD)(dst)) < 0;
6788: bool flgn = ((WORD)(newv)) < 0;
6789: regs.z = ((WORD)(newv)) == 0;
6790: regs.v = (flgs != flgo) && (flgn != flgo);
6791: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6792: regs.n = flgn != 0;
6793: put_word(dsta,newv);
6794: }}}}}}
6795: void op_5d58(UWORD opcode)
6796: {
6797: ULONG srcreg = 6;
6798: ULONG dstreg = (opcode & 7) >> 0;
6799: {{ ULONG src = srcreg;
6800: { CPTR dsta = regs.a[dstreg];
6801: WORD dst = get_word(dsta);
6802: { regs.a[dstreg] += 2;
6803: { ULONG newv = dst - src;
6804: { bool flgs = ((WORD)(src)) < 0;
6805: bool flgo = ((WORD)(dst)) < 0;
6806: bool flgn = ((WORD)(newv)) < 0;
6807: regs.z = ((WORD)(newv)) == 0;
6808: regs.v = (flgs != flgo) && (flgn != flgo);
6809: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6810: regs.n = flgn != 0;
6811: put_word(dsta,newv);
6812: }}}}}}}
6813: void op_5d60(UWORD opcode)
6814: {
6815: ULONG srcreg = 6;
6816: ULONG dstreg = (opcode & 7) >> 0;
6817: {{ ULONG src = srcreg;
6818: { regs.a[dstreg] -= 2;
6819: { CPTR dsta = regs.a[dstreg];
6820: WORD dst = get_word(dsta);
6821: { ULONG newv = dst - src;
6822: { bool flgs = ((WORD)(src)) < 0;
6823: bool flgo = ((WORD)(dst)) < 0;
6824: bool flgn = ((WORD)(newv)) < 0;
6825: regs.z = ((WORD)(newv)) == 0;
6826: regs.v = (flgs != flgo) && (flgn != flgo);
6827: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6828: regs.n = flgn != 0;
6829: put_word(dsta,newv);
6830: }}}}}}}
6831: void op_5d68(UWORD opcode)
6832: {
6833: ULONG srcreg = 6;
6834: ULONG dstreg = (opcode & 7) >> 0;
6835: {{ ULONG src = srcreg;
6836: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
6837: WORD dst = get_word(dsta);
6838: { ULONG newv = dst - src;
6839: { bool flgs = ((WORD)(src)) < 0;
6840: bool flgo = ((WORD)(dst)) < 0;
6841: bool flgn = ((WORD)(newv)) < 0;
6842: regs.z = ((WORD)(newv)) == 0;
6843: regs.v = (flgs != flgo) && (flgn != flgo);
6844: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6845: regs.n = flgn != 0;
6846: put_word(dsta,newv);
6847: }}}}}}
6848: void op_5d70(UWORD opcode)
6849: {
6850: ULONG srcreg = 6;
6851: ULONG dstreg = (opcode & 7) >> 0;
6852: {{ ULONG src = srcreg;
6853: { CPTR dsta = regs.a[dstreg];
6854: UWORD dstdp = nextiword();
6855: dsta += (LONG)(BYTE)(dstdp & 0xFF);
6856: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
6857: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
6858: dsta += dstdpr;
6859: { WORD dst = get_word(dsta);
6860: { ULONG newv = dst - src;
6861: { bool flgs = ((WORD)(src)) < 0;
6862: bool flgo = ((WORD)(dst)) < 0;
6863: bool flgn = ((WORD)(newv)) < 0;
6864: regs.z = ((WORD)(newv)) == 0;
6865: regs.v = (flgs != flgo) && (flgn != flgo);
6866: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6867: regs.n = flgn != 0;
6868: put_word(dsta,newv);
6869: }}}}}}}}
6870: void op_5d78(UWORD opcode)
6871: {
6872: ULONG srcreg = 6;
6873: {{ ULONG src = srcreg;
6874: { CPTR dsta = (LONG)(WORD)nextiword();
6875: WORD dst = get_word(dsta);
6876: { ULONG newv = dst - src;
6877: { bool flgs = ((WORD)(src)) < 0;
6878: bool flgo = ((WORD)(dst)) < 0;
6879: bool flgn = ((WORD)(newv)) < 0;
6880: regs.z = ((WORD)(newv)) == 0;
6881: regs.v = (flgs != flgo) && (flgn != flgo);
6882: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6883: regs.n = flgn != 0;
6884: put_word(dsta,newv);
6885: }}}}}}
6886: void op_5d79(UWORD opcode)
6887: {
6888: ULONG srcreg = 6;
6889: {{ ULONG src = srcreg;
6890: { CPTR dsta = nextilong();
6891: WORD dst = get_word(dsta);
6892: { ULONG newv = dst - src;
6893: { bool flgs = ((WORD)(src)) < 0;
6894: bool flgo = ((WORD)(dst)) < 0;
6895: bool flgn = ((WORD)(newv)) < 0;
6896: regs.z = ((WORD)(newv)) == 0;
6897: regs.v = (flgs != flgo) && (flgn != flgo);
6898: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
6899: regs.n = flgn != 0;
6900: put_word(dsta,newv);
6901: }}}}}}
6902: void op_5d80(UWORD opcode)
6903: {
6904: ULONG srcreg = 6;
6905: ULONG dstreg = (opcode & 7) >> 0;
6906: {{ ULONG src = srcreg;
6907: { LONG dst = regs.d[dstreg];
6908: { ULONG newv = dst - src;
6909: { bool flgs = ((LONG)(src)) < 0;
6910: bool flgo = ((LONG)(dst)) < 0;
6911: bool flgn = ((LONG)(newv)) < 0;
6912: regs.z = ((LONG)(newv)) == 0;
6913: regs.v = (flgs != flgo) && (flgn != flgo);
6914: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6915: regs.n = flgn != 0;
6916: regs.d[dstreg] = (newv);
6917: }}}}}}
6918: void op_5d88(UWORD opcode)
6919: {
6920: ULONG srcreg = 6;
6921: ULONG dstreg = (opcode & 7) >> 0;
6922: {{ ULONG src = srcreg;
6923: { LONG dst = regs.a[dstreg];
6924: { ULONG newv = dst - src;
6925: regs.a[dstreg] = (newv);
6926: }}}}}
6927: void op_5d90(UWORD opcode)
6928: {
6929: ULONG srcreg = 6;
6930: ULONG dstreg = (opcode & 7) >> 0;
6931: {{ ULONG src = srcreg;
6932: { CPTR dsta = regs.a[dstreg];
6933: LONG dst = get_long(dsta);
6934: { ULONG newv = dst - src;
6935: { bool flgs = ((LONG)(src)) < 0;
6936: bool flgo = ((LONG)(dst)) < 0;
6937: bool flgn = ((LONG)(newv)) < 0;
6938: regs.z = ((LONG)(newv)) == 0;
6939: regs.v = (flgs != flgo) && (flgn != flgo);
6940: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6941: regs.n = flgn != 0;
6942: put_long(dsta,newv);
6943: }}}}}}
6944: void op_5d98(UWORD opcode)
6945: {
6946: ULONG srcreg = 6;
6947: ULONG dstreg = (opcode & 7) >> 0;
6948: {{ ULONG src = srcreg;
6949: { CPTR dsta = regs.a[dstreg];
6950: LONG dst = get_long(dsta);
6951: { regs.a[dstreg] += 4;
6952: { ULONG newv = dst - src;
6953: { bool flgs = ((LONG)(src)) < 0;
6954: bool flgo = ((LONG)(dst)) < 0;
6955: bool flgn = ((LONG)(newv)) < 0;
6956: regs.z = ((LONG)(newv)) == 0;
6957: regs.v = (flgs != flgo) && (flgn != flgo);
6958: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6959: regs.n = flgn != 0;
6960: put_long(dsta,newv);
6961: }}}}}}}
6962: void op_5da0(UWORD opcode)
6963: {
6964: ULONG srcreg = 6;
6965: ULONG dstreg = (opcode & 7) >> 0;
6966: {{ ULONG src = srcreg;
6967: { regs.a[dstreg] -= 4;
6968: { CPTR dsta = regs.a[dstreg];
6969: LONG dst = get_long(dsta);
6970: { ULONG newv = dst - src;
6971: { bool flgs = ((LONG)(src)) < 0;
6972: bool flgo = ((LONG)(dst)) < 0;
6973: bool flgn = ((LONG)(newv)) < 0;
6974: regs.z = ((LONG)(newv)) == 0;
6975: regs.v = (flgs != flgo) && (flgn != flgo);
6976: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6977: regs.n = flgn != 0;
6978: put_long(dsta,newv);
6979: }}}}}}}
6980: void op_5da8(UWORD opcode)
6981: {
6982: ULONG srcreg = 6;
6983: ULONG dstreg = (opcode & 7) >> 0;
6984: {{ ULONG src = srcreg;
6985: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
6986: LONG dst = get_long(dsta);
6987: { ULONG newv = dst - src;
6988: { bool flgs = ((LONG)(src)) < 0;
6989: bool flgo = ((LONG)(dst)) < 0;
6990: bool flgn = ((LONG)(newv)) < 0;
6991: regs.z = ((LONG)(newv)) == 0;
6992: regs.v = (flgs != flgo) && (flgn != flgo);
6993: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
6994: regs.n = flgn != 0;
6995: put_long(dsta,newv);
6996: }}}}}}
6997: void op_5db0(UWORD opcode)
6998: {
6999: ULONG srcreg = 6;
7000: ULONG dstreg = (opcode & 7) >> 0;
7001: {{ ULONG src = srcreg;
7002: { CPTR dsta = regs.a[dstreg];
7003: UWORD dstdp = nextiword();
7004: dsta += (LONG)(BYTE)(dstdp & 0xFF);
7005: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
7006: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
7007: dsta += dstdpr;
7008: { LONG dst = get_long(dsta);
7009: { ULONG newv = dst - src;
7010: { bool flgs = ((LONG)(src)) < 0;
7011: bool flgo = ((LONG)(dst)) < 0;
7012: bool flgn = ((LONG)(newv)) < 0;
7013: regs.z = ((LONG)(newv)) == 0;
7014: regs.v = (flgs != flgo) && (flgn != flgo);
7015: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
7016: regs.n = flgn != 0;
7017: put_long(dsta,newv);
7018: }}}}}}}}
7019: void op_5db8(UWORD opcode)
7020: {
7021: ULONG srcreg = 6;
7022: {{ ULONG src = srcreg;
7023: { CPTR dsta = (LONG)(WORD)nextiword();
7024: LONG dst = get_long(dsta);
7025: { ULONG newv = dst - src;
7026: { bool flgs = ((LONG)(src)) < 0;
7027: bool flgo = ((LONG)(dst)) < 0;
7028: bool flgn = ((LONG)(newv)) < 0;
7029: regs.z = ((LONG)(newv)) == 0;
7030: regs.v = (flgs != flgo) && (flgn != flgo);
7031: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
7032: regs.n = flgn != 0;
7033: put_long(dsta,newv);
7034: }}}}}}
7035: void op_5db9(UWORD opcode)
7036: {
7037: ULONG srcreg = 6;
7038: {{ ULONG src = srcreg;
7039: { CPTR dsta = nextilong();
7040: LONG dst = get_long(dsta);
7041: { ULONG newv = dst - src;
7042: { bool flgs = ((LONG)(src)) < 0;
7043: bool flgo = ((LONG)(dst)) < 0;
7044: bool flgn = ((LONG)(newv)) < 0;
7045: regs.z = ((LONG)(newv)) == 0;
7046: regs.v = (flgs != flgo) && (flgn != flgo);
7047: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
7048: regs.n = flgn != 0;
7049: put_long(dsta,newv);
7050: }}}}}}
7051: void op_5dc0(UWORD opcode)
7052: {
7053: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7054: {{{ int val = cctrue(13) ? 0xff : 0;
7055: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
7056: }}}}
7057: void op_5dc8(UWORD opcode)
7058: {
7059: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7060: {{ WORD src = regs.d[srcreg];
7061: { WORD offs = nextiword();
7062: if (!cctrue(13)) {
7063: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
7064: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
7065: }
7066: }}}}
7067: void op_5dd0(UWORD opcode)
7068: {
7069: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7070: {{ CPTR srca = regs.a[srcreg];
7071: { int val = cctrue(13) ? 0xff : 0;
7072: put_byte(srca,val);
7073: }}}}
7074: void op_5dd8(UWORD opcode)
7075: {
7076: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7077: {{ CPTR srca = regs.a[srcreg];
7078: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
7079: { int val = cctrue(13) ? 0xff : 0;
7080: put_byte(srca,val);
7081: }}}}}
7082: void op_5de0(UWORD opcode)
7083: {
7084: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7085: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
7086: { CPTR srca = regs.a[srcreg];
7087: { int val = cctrue(13) ? 0xff : 0;
7088: put_byte(srca,val);
7089: }}}}}
7090: void op_5de8(UWORD opcode)
7091: {
7092: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7093: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
7094: { int val = cctrue(13) ? 0xff : 0;
7095: put_byte(srca,val);
7096: }}}}
7097: void op_5df0(UWORD opcode)
7098: {
7099: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7100: {{ CPTR srca = regs.a[srcreg];
7101: UWORD srcdp = nextiword();
7102: srca += (LONG)(BYTE)(srcdp & 0xFF);
7103: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
7104: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
7105: srca += srcdpr;
7106: { int val = cctrue(13) ? 0xff : 0;
7107: put_byte(srca,val);
7108: }}}}}
7109: void op_5df8(UWORD opcode)
7110: {
7111: {{ CPTR srca = (LONG)(WORD)nextiword();
7112: { int val = cctrue(13) ? 0xff : 0;
7113: put_byte(srca,val);
7114: }}}}
7115: void op_5df9(UWORD opcode)
7116: {
7117: {{ CPTR srca = nextilong();
7118: { int val = cctrue(13) ? 0xff : 0;
7119: put_byte(srca,val);
7120: }}}}
7121: void op_5e00(UWORD opcode)
7122: {
7123: ULONG srcreg = 7;
7124: ULONG dstreg = (opcode & 7) >> 0;
7125: {{ ULONG src = srcreg;
7126: { BYTE dst = regs.d[dstreg];
7127: { ULONG newv = dst + src;
7128: { bool flgs = ((BYTE)(src)) < 0;
7129: bool flgo = ((BYTE)(dst)) < 0;
7130: bool flgn = ((BYTE)(newv)) < 0;
7131: regs.z = ((BYTE)(newv)) == 0;
7132: regs.v = (flgs == flgo) && (flgn != flgo);
7133: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7134: regs.n = flgn != 0;
7135: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
7136: }}}}}}
7137: void op_5e10(UWORD opcode)
7138: {
7139: ULONG srcreg = 7;
7140: ULONG dstreg = (opcode & 7) >> 0;
7141: {{ ULONG src = srcreg;
7142: { CPTR dsta = regs.a[dstreg];
7143: BYTE dst = get_byte(dsta);
7144: { ULONG newv = dst + src;
7145: { bool flgs = ((BYTE)(src)) < 0;
7146: bool flgo = ((BYTE)(dst)) < 0;
7147: bool flgn = ((BYTE)(newv)) < 0;
7148: regs.z = ((BYTE)(newv)) == 0;
7149: regs.v = (flgs == flgo) && (flgn != flgo);
7150: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7151: regs.n = flgn != 0;
7152: put_byte(dsta,newv);
7153: }}}}}}
7154: void op_5e18(UWORD opcode)
7155: {
7156: ULONG srcreg = 7;
7157: ULONG dstreg = (opcode & 7) >> 0;
7158: {{ ULONG src = srcreg;
7159: { CPTR dsta = regs.a[dstreg];
7160: BYTE dst = get_byte(dsta);
7161: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
7162: { ULONG newv = dst + src;
7163: { bool flgs = ((BYTE)(src)) < 0;
7164: bool flgo = ((BYTE)(dst)) < 0;
7165: bool flgn = ((BYTE)(newv)) < 0;
7166: regs.z = ((BYTE)(newv)) == 0;
7167: regs.v = (flgs == flgo) && (flgn != flgo);
7168: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7169: regs.n = flgn != 0;
7170: put_byte(dsta,newv);
7171: }}}}}}}
7172: void op_5e20(UWORD opcode)
7173: {
7174: ULONG srcreg = 7;
7175: ULONG dstreg = (opcode & 7) >> 0;
7176: {{ ULONG src = srcreg;
7177: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
7178: { CPTR dsta = regs.a[dstreg];
7179: BYTE dst = get_byte(dsta);
7180: { ULONG newv = dst + src;
7181: { bool flgs = ((BYTE)(src)) < 0;
7182: bool flgo = ((BYTE)(dst)) < 0;
7183: bool flgn = ((BYTE)(newv)) < 0;
7184: regs.z = ((BYTE)(newv)) == 0;
7185: regs.v = (flgs == flgo) && (flgn != flgo);
7186: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7187: regs.n = flgn != 0;
7188: put_byte(dsta,newv);
7189: }}}}}}}
7190: void op_5e28(UWORD opcode)
7191: {
7192: ULONG srcreg = 7;
7193: ULONG dstreg = (opcode & 7) >> 0;
7194: {{ ULONG src = srcreg;
7195: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
7196: BYTE dst = get_byte(dsta);
7197: { ULONG newv = dst + src;
7198: { bool flgs = ((BYTE)(src)) < 0;
7199: bool flgo = ((BYTE)(dst)) < 0;
7200: bool flgn = ((BYTE)(newv)) < 0;
7201: regs.z = ((BYTE)(newv)) == 0;
7202: regs.v = (flgs == flgo) && (flgn != flgo);
7203: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7204: regs.n = flgn != 0;
7205: put_byte(dsta,newv);
7206: }}}}}}
7207: void op_5e30(UWORD opcode)
7208: {
7209: ULONG srcreg = 7;
7210: ULONG dstreg = (opcode & 7) >> 0;
7211: {{ ULONG src = srcreg;
7212: { CPTR dsta = regs.a[dstreg];
7213: UWORD dstdp = nextiword();
7214: dsta += (LONG)(BYTE)(dstdp & 0xFF);
7215: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
7216: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
7217: dsta += dstdpr;
7218: { BYTE dst = get_byte(dsta);
7219: { ULONG newv = dst + src;
7220: { bool flgs = ((BYTE)(src)) < 0;
7221: bool flgo = ((BYTE)(dst)) < 0;
7222: bool flgn = ((BYTE)(newv)) < 0;
7223: regs.z = ((BYTE)(newv)) == 0;
7224: regs.v = (flgs == flgo) && (flgn != flgo);
7225: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7226: regs.n = flgn != 0;
7227: put_byte(dsta,newv);
7228: }}}}}}}}
7229: void op_5e38(UWORD opcode)
7230: {
7231: ULONG srcreg = 7;
7232: {{ ULONG src = srcreg;
7233: { CPTR dsta = (LONG)(WORD)nextiword();
7234: BYTE dst = get_byte(dsta);
7235: { ULONG newv = dst + src;
7236: { bool flgs = ((BYTE)(src)) < 0;
7237: bool flgo = ((BYTE)(dst)) < 0;
7238: bool flgn = ((BYTE)(newv)) < 0;
7239: regs.z = ((BYTE)(newv)) == 0;
7240: regs.v = (flgs == flgo) && (flgn != flgo);
7241: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7242: regs.n = flgn != 0;
7243: put_byte(dsta,newv);
7244: }}}}}}
7245: void op_5e39(UWORD opcode)
7246: {
7247: ULONG srcreg = 7;
7248: {{ ULONG src = srcreg;
7249: { CPTR dsta = nextilong();
7250: BYTE dst = get_byte(dsta);
7251: { ULONG newv = dst + src;
7252: { bool flgs = ((BYTE)(src)) < 0;
7253: bool flgo = ((BYTE)(dst)) < 0;
7254: bool flgn = ((BYTE)(newv)) < 0;
7255: regs.z = ((BYTE)(newv)) == 0;
7256: regs.v = (flgs == flgo) && (flgn != flgo);
7257: regs.c = regs.x = ((UBYTE)(~dst)) < ((UBYTE)(src));
7258: regs.n = flgn != 0;
7259: put_byte(dsta,newv);
7260: }}}}}}
7261: void op_5e40(UWORD opcode)
7262: {
7263: ULONG srcreg = 7;
7264: ULONG dstreg = (opcode & 7) >> 0;
7265: {{ ULONG src = srcreg;
7266: { WORD dst = regs.d[dstreg];
7267: { ULONG newv = dst + src;
7268: { bool flgs = ((WORD)(src)) < 0;
7269: bool flgo = ((WORD)(dst)) < 0;
7270: bool flgn = ((WORD)(newv)) < 0;
7271: regs.z = ((WORD)(newv)) == 0;
7272: regs.v = (flgs == flgo) && (flgn != flgo);
7273: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7274: regs.n = flgn != 0;
7275: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
7276: }}}}}}
7277: void op_5e48(UWORD opcode)
7278: {
7279: ULONG srcreg = 7;
7280: ULONG dstreg = (opcode & 7) >> 0;
7281: {{ ULONG src = srcreg;
7282: { LONG dst = regs.a[dstreg];
7283: { ULONG newv = dst + src;
7284: regs.a[dstreg] = (newv);
7285: }}}}}
7286: void op_5e50(UWORD opcode)
7287: {
7288: ULONG srcreg = 7;
7289: ULONG dstreg = (opcode & 7) >> 0;
7290: {{ ULONG src = srcreg;
7291: { CPTR dsta = regs.a[dstreg];
7292: WORD dst = get_word(dsta);
7293: { ULONG newv = dst + src;
7294: { bool flgs = ((WORD)(src)) < 0;
7295: bool flgo = ((WORD)(dst)) < 0;
7296: bool flgn = ((WORD)(newv)) < 0;
7297: regs.z = ((WORD)(newv)) == 0;
7298: regs.v = (flgs == flgo) && (flgn != flgo);
7299: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7300: regs.n = flgn != 0;
7301: put_word(dsta,newv);
7302: }}}}}}
7303: void op_5e58(UWORD opcode)
7304: {
7305: ULONG srcreg = 7;
7306: ULONG dstreg = (opcode & 7) >> 0;
7307: {{ ULONG src = srcreg;
7308: { CPTR dsta = regs.a[dstreg];
7309: WORD dst = get_word(dsta);
7310: { regs.a[dstreg] += 2;
7311: { ULONG newv = dst + src;
7312: { bool flgs = ((WORD)(src)) < 0;
7313: bool flgo = ((WORD)(dst)) < 0;
7314: bool flgn = ((WORD)(newv)) < 0;
7315: regs.z = ((WORD)(newv)) == 0;
7316: regs.v = (flgs == flgo) && (flgn != flgo);
7317: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7318: regs.n = flgn != 0;
7319: put_word(dsta,newv);
7320: }}}}}}}
7321: void op_5e60(UWORD opcode)
7322: {
7323: ULONG srcreg = 7;
7324: ULONG dstreg = (opcode & 7) >> 0;
7325: {{ ULONG src = srcreg;
7326: { regs.a[dstreg] -= 2;
7327: { CPTR dsta = regs.a[dstreg];
7328: WORD dst = get_word(dsta);
7329: { ULONG newv = dst + src;
7330: { bool flgs = ((WORD)(src)) < 0;
7331: bool flgo = ((WORD)(dst)) < 0;
7332: bool flgn = ((WORD)(newv)) < 0;
7333: regs.z = ((WORD)(newv)) == 0;
7334: regs.v = (flgs == flgo) && (flgn != flgo);
7335: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7336: regs.n = flgn != 0;
7337: put_word(dsta,newv);
7338: }}}}}}}
7339: void op_5e68(UWORD opcode)
7340: {
7341: ULONG srcreg = 7;
7342: ULONG dstreg = (opcode & 7) >> 0;
7343: {{ ULONG src = srcreg;
7344: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
7345: WORD dst = get_word(dsta);
7346: { ULONG newv = dst + src;
7347: { bool flgs = ((WORD)(src)) < 0;
7348: bool flgo = ((WORD)(dst)) < 0;
7349: bool flgn = ((WORD)(newv)) < 0;
7350: regs.z = ((WORD)(newv)) == 0;
7351: regs.v = (flgs == flgo) && (flgn != flgo);
7352: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7353: regs.n = flgn != 0;
7354: put_word(dsta,newv);
7355: }}}}}}
7356: void op_5e70(UWORD opcode)
7357: {
7358: ULONG srcreg = 7;
7359: ULONG dstreg = (opcode & 7) >> 0;
7360: {{ ULONG src = srcreg;
7361: { CPTR dsta = regs.a[dstreg];
7362: UWORD dstdp = nextiword();
7363: dsta += (LONG)(BYTE)(dstdp & 0xFF);
7364: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
7365: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
7366: dsta += dstdpr;
7367: { WORD dst = get_word(dsta);
7368: { ULONG newv = dst + src;
7369: { bool flgs = ((WORD)(src)) < 0;
7370: bool flgo = ((WORD)(dst)) < 0;
7371: bool flgn = ((WORD)(newv)) < 0;
7372: regs.z = ((WORD)(newv)) == 0;
7373: regs.v = (flgs == flgo) && (flgn != flgo);
7374: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7375: regs.n = flgn != 0;
7376: put_word(dsta,newv);
7377: }}}}}}}}
7378: void op_5e78(UWORD opcode)
7379: {
7380: ULONG srcreg = 7;
7381: {{ ULONG src = srcreg;
7382: { CPTR dsta = (LONG)(WORD)nextiword();
7383: WORD dst = get_word(dsta);
7384: { ULONG newv = dst + src;
7385: { bool flgs = ((WORD)(src)) < 0;
7386: bool flgo = ((WORD)(dst)) < 0;
7387: bool flgn = ((WORD)(newv)) < 0;
7388: regs.z = ((WORD)(newv)) == 0;
7389: regs.v = (flgs == flgo) && (flgn != flgo);
7390: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7391: regs.n = flgn != 0;
7392: put_word(dsta,newv);
7393: }}}}}}
7394: void op_5e79(UWORD opcode)
7395: {
7396: ULONG srcreg = 7;
7397: {{ ULONG src = srcreg;
7398: { CPTR dsta = nextilong();
7399: WORD dst = get_word(dsta);
7400: { ULONG newv = dst + src;
7401: { bool flgs = ((WORD)(src)) < 0;
7402: bool flgo = ((WORD)(dst)) < 0;
7403: bool flgn = ((WORD)(newv)) < 0;
7404: regs.z = ((WORD)(newv)) == 0;
7405: regs.v = (flgs == flgo) && (flgn != flgo);
7406: regs.c = regs.x = ((UWORD)(~dst)) < ((UWORD)(src));
7407: regs.n = flgn != 0;
7408: put_word(dsta,newv);
7409: }}}}}}
7410: void op_5e80(UWORD opcode)
7411: {
7412: ULONG srcreg = 7;
7413: ULONG dstreg = (opcode & 7) >> 0;
7414: {{ ULONG src = srcreg;
7415: { LONG dst = regs.d[dstreg];
7416: { ULONG newv = dst + src;
7417: { bool flgs = ((LONG)(src)) < 0;
7418: bool flgo = ((LONG)(dst)) < 0;
7419: bool flgn = ((LONG)(newv)) < 0;
7420: regs.z = ((LONG)(newv)) == 0;
7421: regs.v = (flgs == flgo) && (flgn != flgo);
7422: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7423: regs.n = flgn != 0;
7424: regs.d[dstreg] = (newv);
7425: }}}}}}
7426: void op_5e88(UWORD opcode)
7427: {
7428: ULONG srcreg = 7;
7429: ULONG dstreg = (opcode & 7) >> 0;
7430: {{ ULONG src = srcreg;
7431: { LONG dst = regs.a[dstreg];
7432: { ULONG newv = dst + src;
7433: regs.a[dstreg] = (newv);
7434: }}}}}
7435: void op_5e90(UWORD opcode)
7436: {
7437: ULONG srcreg = 7;
7438: ULONG dstreg = (opcode & 7) >> 0;
7439: {{ ULONG src = srcreg;
7440: { CPTR dsta = regs.a[dstreg];
7441: LONG dst = get_long(dsta);
7442: { ULONG newv = dst + src;
7443: { bool flgs = ((LONG)(src)) < 0;
7444: bool flgo = ((LONG)(dst)) < 0;
7445: bool flgn = ((LONG)(newv)) < 0;
7446: regs.z = ((LONG)(newv)) == 0;
7447: regs.v = (flgs == flgo) && (flgn != flgo);
7448: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7449: regs.n = flgn != 0;
7450: put_long(dsta,newv);
7451: }}}}}}
7452: void op_5e98(UWORD opcode)
7453: {
7454: ULONG srcreg = 7;
7455: ULONG dstreg = (opcode & 7) >> 0;
7456: {{ ULONG src = srcreg;
7457: { CPTR dsta = regs.a[dstreg];
7458: LONG dst = get_long(dsta);
7459: { regs.a[dstreg] += 4;
7460: { ULONG newv = dst + src;
7461: { bool flgs = ((LONG)(src)) < 0;
7462: bool flgo = ((LONG)(dst)) < 0;
7463: bool flgn = ((LONG)(newv)) < 0;
7464: regs.z = ((LONG)(newv)) == 0;
7465: regs.v = (flgs == flgo) && (flgn != flgo);
7466: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7467: regs.n = flgn != 0;
7468: put_long(dsta,newv);
7469: }}}}}}}
7470: void op_5ea0(UWORD opcode)
7471: {
7472: ULONG srcreg = 7;
7473: ULONG dstreg = (opcode & 7) >> 0;
7474: {{ ULONG src = srcreg;
7475: { regs.a[dstreg] -= 4;
7476: { CPTR dsta = regs.a[dstreg];
7477: LONG dst = get_long(dsta);
7478: { ULONG newv = dst + src;
7479: { bool flgs = ((LONG)(src)) < 0;
7480: bool flgo = ((LONG)(dst)) < 0;
7481: bool flgn = ((LONG)(newv)) < 0;
7482: regs.z = ((LONG)(newv)) == 0;
7483: regs.v = (flgs == flgo) && (flgn != flgo);
7484: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7485: regs.n = flgn != 0;
7486: put_long(dsta,newv);
7487: }}}}}}}
7488: void op_5ea8(UWORD opcode)
7489: {
7490: ULONG srcreg = 7;
7491: ULONG dstreg = (opcode & 7) >> 0;
7492: {{ ULONG src = srcreg;
7493: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
7494: LONG dst = get_long(dsta);
7495: { ULONG newv = dst + src;
7496: { bool flgs = ((LONG)(src)) < 0;
7497: bool flgo = ((LONG)(dst)) < 0;
7498: bool flgn = ((LONG)(newv)) < 0;
7499: regs.z = ((LONG)(newv)) == 0;
7500: regs.v = (flgs == flgo) && (flgn != flgo);
7501: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7502: regs.n = flgn != 0;
7503: put_long(dsta,newv);
7504: }}}}}}
7505: void op_5eb0(UWORD opcode)
7506: {
7507: ULONG srcreg = 7;
7508: ULONG dstreg = (opcode & 7) >> 0;
7509: {{ ULONG src = srcreg;
7510: { CPTR dsta = regs.a[dstreg];
7511: UWORD dstdp = nextiword();
7512: dsta += (LONG)(BYTE)(dstdp & 0xFF);
7513: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
7514: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
7515: dsta += dstdpr;
7516: { LONG dst = get_long(dsta);
7517: { ULONG newv = dst + src;
7518: { bool flgs = ((LONG)(src)) < 0;
7519: bool flgo = ((LONG)(dst)) < 0;
7520: bool flgn = ((LONG)(newv)) < 0;
7521: regs.z = ((LONG)(newv)) == 0;
7522: regs.v = (flgs == flgo) && (flgn != flgo);
7523: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7524: regs.n = flgn != 0;
7525: put_long(dsta,newv);
7526: }}}}}}}}
7527: void op_5eb8(UWORD opcode)
7528: {
7529: ULONG srcreg = 7;
7530: {{ ULONG src = srcreg;
7531: { CPTR dsta = (LONG)(WORD)nextiword();
7532: LONG dst = get_long(dsta);
7533: { ULONG newv = dst + src;
7534: { bool flgs = ((LONG)(src)) < 0;
7535: bool flgo = ((LONG)(dst)) < 0;
7536: bool flgn = ((LONG)(newv)) < 0;
7537: regs.z = ((LONG)(newv)) == 0;
7538: regs.v = (flgs == flgo) && (flgn != flgo);
7539: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7540: regs.n = flgn != 0;
7541: put_long(dsta,newv);
7542: }}}}}}
7543: void op_5eb9(UWORD opcode)
7544: {
7545: ULONG srcreg = 7;
7546: {{ ULONG src = srcreg;
7547: { CPTR dsta = nextilong();
7548: LONG dst = get_long(dsta);
7549: { ULONG newv = dst + src;
7550: { bool flgs = ((LONG)(src)) < 0;
7551: bool flgo = ((LONG)(dst)) < 0;
7552: bool flgn = ((LONG)(newv)) < 0;
7553: regs.z = ((LONG)(newv)) == 0;
7554: regs.v = (flgs == flgo) && (flgn != flgo);
7555: regs.c = regs.x = ((ULONG)(~dst)) < ((ULONG)(src));
7556: regs.n = flgn != 0;
7557: put_long(dsta,newv);
7558: }}}}}}
7559: void op_5ec0(UWORD opcode)
7560: {
7561: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7562: {{{ int val = cctrue(14) ? 0xff : 0;
7563: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
7564: }}}}
7565: void op_5ec8(UWORD opcode)
7566: {
7567: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7568: {{ WORD src = regs.d[srcreg];
7569: { WORD offs = nextiword();
7570: if (!cctrue(14)) {
7571: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
7572: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
7573: }
7574: }}}}
7575: void op_5ed0(UWORD opcode)
7576: {
7577: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7578: {{ CPTR srca = regs.a[srcreg];
7579: { int val = cctrue(14) ? 0xff : 0;
7580: put_byte(srca,val);
7581: }}}}
7582: void op_5ed8(UWORD opcode)
7583: {
7584: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7585: {{ CPTR srca = regs.a[srcreg];
7586: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
7587: { int val = cctrue(14) ? 0xff : 0;
7588: put_byte(srca,val);
7589: }}}}}
7590: void op_5ee0(UWORD opcode)
7591: {
7592: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7593: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
7594: { CPTR srca = regs.a[srcreg];
7595: { int val = cctrue(14) ? 0xff : 0;
7596: put_byte(srca,val);
7597: }}}}}
7598: void op_5ee8(UWORD opcode)
7599: {
7600: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7601: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
7602: { int val = cctrue(14) ? 0xff : 0;
7603: put_byte(srca,val);
7604: }}}}
7605: void op_5ef0(UWORD opcode)
7606: {
7607: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
7608: {{ CPTR srca = regs.a[srcreg];
7609: UWORD srcdp = nextiword();
7610: srca += (LONG)(BYTE)(srcdp & 0xFF);
7611: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
7612: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
7613: srca += srcdpr;
7614: { int val = cctrue(14) ? 0xff : 0;
7615: put_byte(srca,val);
7616: }}}}}
7617: void op_5ef8(UWORD opcode)
7618: {
7619: {{ CPTR srca = (LONG)(WORD)nextiword();
7620: { int val = cctrue(14) ? 0xff : 0;
7621: put_byte(srca,val);
7622: }}}}
7623: void op_5ef9(UWORD opcode)
7624: {
7625: {{ CPTR srca = nextilong();
7626: { int val = cctrue(14) ? 0xff : 0;
7627: put_byte(srca,val);
7628: }}}}
7629: void op_5f00(UWORD opcode)
7630: {
7631: ULONG srcreg = 7;
7632: ULONG dstreg = (opcode & 7) >> 0;
7633: {{ ULONG src = srcreg;
7634: { BYTE dst = regs.d[dstreg];
7635: { ULONG newv = dst - src;
7636: { bool flgs = ((BYTE)(src)) < 0;
7637: bool flgo = ((BYTE)(dst)) < 0;
7638: bool flgn = ((BYTE)(newv)) < 0;
7639: regs.z = ((BYTE)(newv)) == 0;
7640: regs.v = (flgs != flgo) && (flgn != flgo);
7641: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7642: regs.n = flgn != 0;
7643: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
7644: }}}}}}
7645: void op_5f10(UWORD opcode)
7646: {
7647: ULONG srcreg = 7;
7648: ULONG dstreg = (opcode & 7) >> 0;
7649: {{ ULONG src = srcreg;
7650: { CPTR dsta = regs.a[dstreg];
7651: BYTE dst = get_byte(dsta);
7652: { ULONG newv = dst - src;
7653: { bool flgs = ((BYTE)(src)) < 0;
7654: bool flgo = ((BYTE)(dst)) < 0;
7655: bool flgn = ((BYTE)(newv)) < 0;
7656: regs.z = ((BYTE)(newv)) == 0;
7657: regs.v = (flgs != flgo) && (flgn != flgo);
7658: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7659: regs.n = flgn != 0;
7660: put_byte(dsta,newv);
7661: }}}}}}
7662: void op_5f18(UWORD opcode)
7663: {
7664: ULONG srcreg = 7;
7665: ULONG dstreg = (opcode & 7) >> 0;
7666: {{ ULONG src = srcreg;
7667: { CPTR dsta = regs.a[dstreg];
7668: BYTE dst = get_byte(dsta);
7669: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
7670: { ULONG newv = dst - src;
7671: { bool flgs = ((BYTE)(src)) < 0;
7672: bool flgo = ((BYTE)(dst)) < 0;
7673: bool flgn = ((BYTE)(newv)) < 0;
7674: regs.z = ((BYTE)(newv)) == 0;
7675: regs.v = (flgs != flgo) && (flgn != flgo);
7676: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7677: regs.n = flgn != 0;
7678: put_byte(dsta,newv);
7679: }}}}}}}
7680: void op_5f20(UWORD opcode)
7681: {
7682: ULONG srcreg = 7;
7683: ULONG dstreg = (opcode & 7) >> 0;
7684: {{ ULONG src = srcreg;
7685: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
7686: { CPTR dsta = regs.a[dstreg];
7687: BYTE dst = get_byte(dsta);
7688: { ULONG newv = dst - src;
7689: { bool flgs = ((BYTE)(src)) < 0;
7690: bool flgo = ((BYTE)(dst)) < 0;
7691: bool flgn = ((BYTE)(newv)) < 0;
7692: regs.z = ((BYTE)(newv)) == 0;
7693: regs.v = (flgs != flgo) && (flgn != flgo);
7694: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7695: regs.n = flgn != 0;
7696: put_byte(dsta,newv);
7697: }}}}}}}
7698: void op_5f28(UWORD opcode)
7699: {
7700: ULONG srcreg = 7;
7701: ULONG dstreg = (opcode & 7) >> 0;
7702: {{ ULONG src = srcreg;
7703: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
7704: BYTE dst = get_byte(dsta);
7705: { ULONG newv = dst - src;
7706: { bool flgs = ((BYTE)(src)) < 0;
7707: bool flgo = ((BYTE)(dst)) < 0;
7708: bool flgn = ((BYTE)(newv)) < 0;
7709: regs.z = ((BYTE)(newv)) == 0;
7710: regs.v = (flgs != flgo) && (flgn != flgo);
7711: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7712: regs.n = flgn != 0;
7713: put_byte(dsta,newv);
7714: }}}}}}
7715: void op_5f30(UWORD opcode)
7716: {
7717: ULONG srcreg = 7;
7718: ULONG dstreg = (opcode & 7) >> 0;
7719: {{ ULONG src = srcreg;
7720: { CPTR dsta = regs.a[dstreg];
7721: UWORD dstdp = nextiword();
7722: dsta += (LONG)(BYTE)(dstdp & 0xFF);
7723: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
7724: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
7725: dsta += dstdpr;
7726: { BYTE dst = get_byte(dsta);
7727: { ULONG newv = dst - src;
7728: { bool flgs = ((BYTE)(src)) < 0;
7729: bool flgo = ((BYTE)(dst)) < 0;
7730: bool flgn = ((BYTE)(newv)) < 0;
7731: regs.z = ((BYTE)(newv)) == 0;
7732: regs.v = (flgs != flgo) && (flgn != flgo);
7733: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7734: regs.n = flgn != 0;
7735: put_byte(dsta,newv);
7736: }}}}}}}}
7737: void op_5f38(UWORD opcode)
7738: {
7739: ULONG srcreg = 7;
7740: {{ ULONG src = srcreg;
7741: { CPTR dsta = (LONG)(WORD)nextiword();
7742: BYTE dst = get_byte(dsta);
7743: { ULONG newv = dst - src;
7744: { bool flgs = ((BYTE)(src)) < 0;
7745: bool flgo = ((BYTE)(dst)) < 0;
7746: bool flgn = ((BYTE)(newv)) < 0;
7747: regs.z = ((BYTE)(newv)) == 0;
7748: regs.v = (flgs != flgo) && (flgn != flgo);
7749: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7750: regs.n = flgn != 0;
7751: put_byte(dsta,newv);
7752: }}}}}}
7753: void op_5f39(UWORD opcode)
7754: {
7755: ULONG srcreg = 7;
7756: {{ ULONG src = srcreg;
7757: { CPTR dsta = nextilong();
7758: BYTE dst = get_byte(dsta);
7759: { ULONG newv = dst - src;
7760: { bool flgs = ((BYTE)(src)) < 0;
7761: bool flgo = ((BYTE)(dst)) < 0;
7762: bool flgn = ((BYTE)(newv)) < 0;
7763: regs.z = ((BYTE)(newv)) == 0;
7764: regs.v = (flgs != flgo) && (flgn != flgo);
7765: regs.c = regs.x = ((UBYTE)(src)) > ((UBYTE)(dst));
7766: regs.n = flgn != 0;
7767: put_byte(dsta,newv);
7768: }}}}}}
7769: void op_5f40(UWORD opcode)
7770: {
7771: ULONG srcreg = 7;
7772: ULONG dstreg = (opcode & 7) >> 0;
7773: {{ ULONG src = srcreg;
7774: { WORD dst = regs.d[dstreg];
7775: { ULONG newv = dst - src;
7776: { bool flgs = ((WORD)(src)) < 0;
7777: bool flgo = ((WORD)(dst)) < 0;
7778: bool flgn = ((WORD)(newv)) < 0;
7779: regs.z = ((WORD)(newv)) == 0;
7780: regs.v = (flgs != flgo) && (flgn != flgo);
7781: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7782: regs.n = flgn != 0;
7783: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (newv) & 0xffff;
7784: }}}}}}
7785: void op_5f48(UWORD opcode)
7786: {
7787: ULONG srcreg = 7;
7788: ULONG dstreg = (opcode & 7) >> 0;
7789: {{ ULONG src = srcreg;
7790: { LONG dst = regs.a[dstreg];
7791: { ULONG newv = dst - src;
7792: regs.a[dstreg] = (newv);
7793: }}}}}
7794: void op_5f50(UWORD opcode)
7795: {
7796: ULONG srcreg = 7;
7797: ULONG dstreg = (opcode & 7) >> 0;
7798: {{ ULONG src = srcreg;
7799: { CPTR dsta = regs.a[dstreg];
7800: WORD dst = get_word(dsta);
7801: { ULONG newv = dst - src;
7802: { bool flgs = ((WORD)(src)) < 0;
7803: bool flgo = ((WORD)(dst)) < 0;
7804: bool flgn = ((WORD)(newv)) < 0;
7805: regs.z = ((WORD)(newv)) == 0;
7806: regs.v = (flgs != flgo) && (flgn != flgo);
7807: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7808: regs.n = flgn != 0;
7809: put_word(dsta,newv);
7810: }}}}}}
7811: void op_5f58(UWORD opcode)
7812: {
7813: ULONG srcreg = 7;
7814: ULONG dstreg = (opcode & 7) >> 0;
7815: {{ ULONG src = srcreg;
7816: { CPTR dsta = regs.a[dstreg];
7817: WORD dst = get_word(dsta);
7818: { regs.a[dstreg] += 2;
7819: { ULONG newv = dst - src;
7820: { bool flgs = ((WORD)(src)) < 0;
7821: bool flgo = ((WORD)(dst)) < 0;
7822: bool flgn = ((WORD)(newv)) < 0;
7823: regs.z = ((WORD)(newv)) == 0;
7824: regs.v = (flgs != flgo) && (flgn != flgo);
7825: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7826: regs.n = flgn != 0;
7827: put_word(dsta,newv);
7828: }}}}}}}
7829: void op_5f60(UWORD opcode)
7830: {
7831: ULONG srcreg = 7;
7832: ULONG dstreg = (opcode & 7) >> 0;
7833: {{ ULONG src = srcreg;
7834: { regs.a[dstreg] -= 2;
7835: { CPTR dsta = regs.a[dstreg];
7836: WORD dst = get_word(dsta);
7837: { ULONG newv = dst - src;
7838: { bool flgs = ((WORD)(src)) < 0;
7839: bool flgo = ((WORD)(dst)) < 0;
7840: bool flgn = ((WORD)(newv)) < 0;
7841: regs.z = ((WORD)(newv)) == 0;
7842: regs.v = (flgs != flgo) && (flgn != flgo);
7843: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7844: regs.n = flgn != 0;
7845: put_word(dsta,newv);
7846: }}}}}}}
7847: void op_5f68(UWORD opcode)
7848: {
7849: ULONG srcreg = 7;
7850: ULONG dstreg = (opcode & 7) >> 0;
7851: {{ ULONG src = srcreg;
7852: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
7853: WORD dst = get_word(dsta);
7854: { ULONG newv = dst - src;
7855: { bool flgs = ((WORD)(src)) < 0;
7856: bool flgo = ((WORD)(dst)) < 0;
7857: bool flgn = ((WORD)(newv)) < 0;
7858: regs.z = ((WORD)(newv)) == 0;
7859: regs.v = (flgs != flgo) && (flgn != flgo);
7860: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7861: regs.n = flgn != 0;
7862: put_word(dsta,newv);
7863: }}}}}}
7864: void op_5f70(UWORD opcode)
7865: {
7866: ULONG srcreg = 7;
7867: ULONG dstreg = (opcode & 7) >> 0;
7868: {{ ULONG src = srcreg;
7869: { CPTR dsta = regs.a[dstreg];
7870: UWORD dstdp = nextiword();
7871: dsta += (LONG)(BYTE)(dstdp & 0xFF);
7872: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
7873: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
7874: dsta += dstdpr;
7875: { WORD dst = get_word(dsta);
7876: { ULONG newv = dst - src;
7877: { bool flgs = ((WORD)(src)) < 0;
7878: bool flgo = ((WORD)(dst)) < 0;
7879: bool flgn = ((WORD)(newv)) < 0;
7880: regs.z = ((WORD)(newv)) == 0;
7881: regs.v = (flgs != flgo) && (flgn != flgo);
7882: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7883: regs.n = flgn != 0;
7884: put_word(dsta,newv);
7885: }}}}}}}}
7886: void op_5f78(UWORD opcode)
7887: {
7888: ULONG srcreg = 7;
7889: {{ ULONG src = srcreg;
7890: { CPTR dsta = (LONG)(WORD)nextiword();
7891: WORD dst = get_word(dsta);
7892: { ULONG newv = dst - src;
7893: { bool flgs = ((WORD)(src)) < 0;
7894: bool flgo = ((WORD)(dst)) < 0;
7895: bool flgn = ((WORD)(newv)) < 0;
7896: regs.z = ((WORD)(newv)) == 0;
7897: regs.v = (flgs != flgo) && (flgn != flgo);
7898: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7899: regs.n = flgn != 0;
7900: put_word(dsta,newv);
7901: }}}}}}
7902: void op_5f79(UWORD opcode)
7903: {
7904: ULONG srcreg = 7;
7905: {{ ULONG src = srcreg;
7906: { CPTR dsta = nextilong();
7907: WORD dst = get_word(dsta);
7908: { ULONG newv = dst - src;
7909: { bool flgs = ((WORD)(src)) < 0;
7910: bool flgo = ((WORD)(dst)) < 0;
7911: bool flgn = ((WORD)(newv)) < 0;
7912: regs.z = ((WORD)(newv)) == 0;
7913: regs.v = (flgs != flgo) && (flgn != flgo);
7914: regs.c = regs.x = ((UWORD)(src)) > ((UWORD)(dst));
7915: regs.n = flgn != 0;
7916: put_word(dsta,newv);
7917: }}}}}}
7918: void op_5f80(UWORD opcode)
7919: {
7920: ULONG srcreg = 7;
7921: ULONG dstreg = (opcode & 7) >> 0;
7922: {{ ULONG src = srcreg;
7923: { LONG dst = regs.d[dstreg];
7924: { ULONG newv = dst - src;
7925: { bool flgs = ((LONG)(src)) < 0;
7926: bool flgo = ((LONG)(dst)) < 0;
7927: bool flgn = ((LONG)(newv)) < 0;
7928: regs.z = ((LONG)(newv)) == 0;
7929: regs.v = (flgs != flgo) && (flgn != flgo);
7930: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
7931: regs.n = flgn != 0;
7932: regs.d[dstreg] = (newv);
7933: }}}}}}
7934: void op_5f88(UWORD opcode)
7935: {
7936: ULONG srcreg = 7;
7937: ULONG dstreg = (opcode & 7) >> 0;
7938: {{ ULONG src = srcreg;
7939: { LONG dst = regs.a[dstreg];
7940: { ULONG newv = dst - src;
7941: regs.a[dstreg] = (newv);
7942: }}}}}
7943: void op_5f90(UWORD opcode)
7944: {
7945: ULONG srcreg = 7;
7946: ULONG dstreg = (opcode & 7) >> 0;
7947: {{ ULONG src = srcreg;
7948: { CPTR dsta = regs.a[dstreg];
7949: LONG dst = get_long(dsta);
7950: { ULONG newv = dst - src;
7951: { bool flgs = ((LONG)(src)) < 0;
7952: bool flgo = ((LONG)(dst)) < 0;
7953: bool flgn = ((LONG)(newv)) < 0;
7954: regs.z = ((LONG)(newv)) == 0;
7955: regs.v = (flgs != flgo) && (flgn != flgo);
7956: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
7957: regs.n = flgn != 0;
7958: put_long(dsta,newv);
7959: }}}}}}
7960: void op_5f98(UWORD opcode)
7961: {
7962: ULONG srcreg = 7;
7963: ULONG dstreg = (opcode & 7) >> 0;
7964: {{ ULONG src = srcreg;
7965: { CPTR dsta = regs.a[dstreg];
7966: LONG dst = get_long(dsta);
7967: { regs.a[dstreg] += 4;
7968: { ULONG newv = dst - src;
7969: { bool flgs = ((LONG)(src)) < 0;
7970: bool flgo = ((LONG)(dst)) < 0;
7971: bool flgn = ((LONG)(newv)) < 0;
7972: regs.z = ((LONG)(newv)) == 0;
7973: regs.v = (flgs != flgo) && (flgn != flgo);
7974: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
7975: regs.n = flgn != 0;
7976: put_long(dsta,newv);
7977: }}}}}}}
7978: void op_5fa0(UWORD opcode)
7979: {
7980: ULONG srcreg = 7;
7981: ULONG dstreg = (opcode & 7) >> 0;
7982: {{ ULONG src = srcreg;
7983: { regs.a[dstreg] -= 4;
7984: { CPTR dsta = regs.a[dstreg];
7985: LONG dst = get_long(dsta);
7986: { ULONG newv = dst - src;
7987: { bool flgs = ((LONG)(src)) < 0;
7988: bool flgo = ((LONG)(dst)) < 0;
7989: bool flgn = ((LONG)(newv)) < 0;
7990: regs.z = ((LONG)(newv)) == 0;
7991: regs.v = (flgs != flgo) && (flgn != flgo);
7992: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
7993: regs.n = flgn != 0;
7994: put_long(dsta,newv);
7995: }}}}}}}
7996: void op_5fa8(UWORD opcode)
7997: {
7998: ULONG srcreg = 7;
7999: ULONG dstreg = (opcode & 7) >> 0;
8000: {{ ULONG src = srcreg;
8001: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
8002: LONG dst = get_long(dsta);
8003: { ULONG newv = dst - src;
8004: { bool flgs = ((LONG)(src)) < 0;
8005: bool flgo = ((LONG)(dst)) < 0;
8006: bool flgn = ((LONG)(newv)) < 0;
8007: regs.z = ((LONG)(newv)) == 0;
8008: regs.v = (flgs != flgo) && (flgn != flgo);
8009: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
8010: regs.n = flgn != 0;
8011: put_long(dsta,newv);
8012: }}}}}}
8013: void op_5fb0(UWORD opcode)
8014: {
8015: ULONG srcreg = 7;
8016: ULONG dstreg = (opcode & 7) >> 0;
8017: {{ ULONG src = srcreg;
8018: { CPTR dsta = regs.a[dstreg];
8019: UWORD dstdp = nextiword();
8020: dsta += (LONG)(BYTE)(dstdp & 0xFF);
8021: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
8022: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
8023: dsta += dstdpr;
8024: { LONG dst = get_long(dsta);
8025: { ULONG newv = dst - src;
8026: { bool flgs = ((LONG)(src)) < 0;
8027: bool flgo = ((LONG)(dst)) < 0;
8028: bool flgn = ((LONG)(newv)) < 0;
8029: regs.z = ((LONG)(newv)) == 0;
8030: regs.v = (flgs != flgo) && (flgn != flgo);
8031: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
8032: regs.n = flgn != 0;
8033: put_long(dsta,newv);
8034: }}}}}}}}
8035: void op_5fb8(UWORD opcode)
8036: {
8037: ULONG srcreg = 7;
8038: {{ ULONG src = srcreg;
8039: { CPTR dsta = (LONG)(WORD)nextiword();
8040: LONG dst = get_long(dsta);
8041: { ULONG newv = dst - src;
8042: { bool flgs = ((LONG)(src)) < 0;
8043: bool flgo = ((LONG)(dst)) < 0;
8044: bool flgn = ((LONG)(newv)) < 0;
8045: regs.z = ((LONG)(newv)) == 0;
8046: regs.v = (flgs != flgo) && (flgn != flgo);
8047: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
8048: regs.n = flgn != 0;
8049: put_long(dsta,newv);
8050: }}}}}}
8051: void op_5fb9(UWORD opcode)
8052: {
8053: ULONG srcreg = 7;
8054: {{ ULONG src = srcreg;
8055: { CPTR dsta = nextilong();
8056: LONG dst = get_long(dsta);
8057: { ULONG newv = dst - src;
8058: { bool flgs = ((LONG)(src)) < 0;
8059: bool flgo = ((LONG)(dst)) < 0;
8060: bool flgn = ((LONG)(newv)) < 0;
8061: regs.z = ((LONG)(newv)) == 0;
8062: regs.v = (flgs != flgo) && (flgn != flgo);
8063: regs.c = regs.x = ((ULONG)(src)) > ((ULONG)(dst));
8064: regs.n = flgn != 0;
8065: put_long(dsta,newv);
8066: }}}}}}
8067: void op_5fc0(UWORD opcode)
8068: {
8069: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
8070: {{{ int val = cctrue(15) ? 0xff : 0;
8071: regs.d[srcreg] &= ~0xff; regs.d[srcreg] |= (val) & 0xff;
8072: }}}}
8073: void op_5fc8(UWORD opcode)
8074: {
8075: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
8076: {{ WORD src = regs.d[srcreg];
8077: { WORD offs = nextiword();
8078: if (!cctrue(15)) {
8079: if (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + offs - 2);
8080: regs.d[srcreg] &= ~0xffff; regs.d[srcreg] |= (src) & 0xffff;
8081: }
8082: }}}}
8083: void op_5fd0(UWORD opcode)
8084: {
8085: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
8086: {{ CPTR srca = regs.a[srcreg];
8087: { int val = cctrue(15) ? 0xff : 0;
8088: put_byte(srca,val);
8089: }}}}
8090: void op_5fd8(UWORD opcode)
8091: {
8092: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
8093: {{ CPTR srca = regs.a[srcreg];
8094: { regs.a[srcreg] += (srcreg == 7) ? 2 : 1;
8095: { int val = cctrue(15) ? 0xff : 0;
8096: put_byte(srca,val);
8097: }}}}}
8098: void op_5fe0(UWORD opcode)
8099: {
8100: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
8101: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
8102: { CPTR srca = regs.a[srcreg];
8103: { int val = cctrue(15) ? 0xff : 0;
8104: put_byte(srca,val);
8105: }}}}}
8106: void op_5fe8(UWORD opcode)
8107: {
8108: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
8109: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
8110: { int val = cctrue(15) ? 0xff : 0;
8111: put_byte(srca,val);
8112: }}}}
8113: void op_5ff0(UWORD opcode)
8114: {
8115: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
8116: {{ CPTR srca = regs.a[srcreg];
8117: UWORD srcdp = nextiword();
8118: srca += (LONG)(BYTE)(srcdp & 0xFF);
8119: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
8120: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
8121: srca += srcdpr;
8122: { int val = cctrue(15) ? 0xff : 0;
8123: put_byte(srca,val);
8124: }}}}}
8125: void op_5ff8(UWORD opcode)
8126: {
8127: {{ CPTR srca = (LONG)(WORD)nextiword();
8128: { int val = cctrue(15) ? 0xff : 0;
8129: put_byte(srca,val);
8130: }}}}
8131: void op_5ff9(UWORD opcode)
8132: {
8133: {{ CPTR srca = nextilong();
8134: { int val = cctrue(15) ? 0xff : 0;
8135: put_byte(srca,val);
8136: }}}}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.