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