![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpu3.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 cpu3.c CVS log | Up to [UNIX Amiga Emulator] / uae / CPU Sources |
1.1 root 1: #include "config.h"
2: #include "amiga.h"
3: #include "options.h"
4: #include <stdlib.h>
5: #include "memory.h"
6: #include "custom.h"
7: #include "newcpu.h"
8: #include "cputbl.h"
9: void op_3000(UWORD opcode)
10: {
11: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
12: ULONG dstreg = (opcode & 3584) >> 9;
13: {{ WORD src = regs.d[srcreg];
14: { regs.v = regs.c = 0;
15: regs.z = ((WORD)(src)) == 0;
16: regs.n = ((WORD)(src)) < 0;
17: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
18: }}}}
19: void op_3008(UWORD opcode)
20: {
21: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
22: ULONG dstreg = (opcode & 3584) >> 9;
23: {{ WORD src = regs.a[srcreg];
24: { regs.v = regs.c = 0;
25: regs.z = ((WORD)(src)) == 0;
26: regs.n = ((WORD)(src)) < 0;
27: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
28: }}}}
29: void op_3010(UWORD opcode)
30: {
31: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
32: ULONG dstreg = (opcode & 3584) >> 9;
33: {{ CPTR srca = regs.a[srcreg];
34: WORD src = get_word(srca);
35: { regs.v = regs.c = 0;
36: regs.z = ((WORD)(src)) == 0;
37: regs.n = ((WORD)(src)) < 0;
38: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
39: }}}}
40: void op_3018(UWORD opcode)
41: {
42: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
43: ULONG dstreg = (opcode & 3584) >> 9;
44: {{ CPTR srca = regs.a[srcreg];
45: WORD src = get_word(srca);
46: { regs.a[srcreg] += 2;
47: { regs.v = regs.c = 0;
48: regs.z = ((WORD)(src)) == 0;
49: regs.n = ((WORD)(src)) < 0;
50: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
51: }}}}}
52: void op_3020(UWORD opcode)
53: {
54: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
55: ULONG dstreg = (opcode & 3584) >> 9;
56: {{ regs.a[srcreg] -= 2;
57: { CPTR srca = regs.a[srcreg];
58: WORD src = get_word(srca);
59: { regs.v = regs.c = 0;
60: regs.z = ((WORD)(src)) == 0;
61: regs.n = ((WORD)(src)) < 0;
62: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
63: }}}}}
64: void op_3028(UWORD opcode)
65: {
66: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
67: ULONG dstreg = (opcode & 3584) >> 9;
68: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
69: WORD src = get_word(srca);
70: { regs.v = regs.c = 0;
71: regs.z = ((WORD)(src)) == 0;
72: regs.n = ((WORD)(src)) < 0;
73: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
74: }}}}
75: void op_3030(UWORD opcode)
76: {
77: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
78: ULONG dstreg = (opcode & 3584) >> 9;
79: {{ CPTR srca = regs.a[srcreg];
80: UWORD srcdp = nextiword();
81: srca += (LONG)(BYTE)(srcdp & 0xFF);
82: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
83: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
84: srca += srcdpr;
85: { WORD src = get_word(srca);
86: { regs.v = regs.c = 0;
87: regs.z = ((WORD)(src)) == 0;
88: regs.n = ((WORD)(src)) < 0;
89: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
90: }}}}}}
91: void op_3038(UWORD opcode)
92: {
93: ULONG dstreg = (opcode & 3584) >> 9;
94: {{ CPTR srca = (LONG)(WORD)nextiword();
95: WORD src = get_word(srca);
96: { regs.v = regs.c = 0;
97: regs.z = ((WORD)(src)) == 0;
98: regs.n = ((WORD)(src)) < 0;
99: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
100: }}}}
101: void op_3039(UWORD opcode)
102: {
103: ULONG dstreg = (opcode & 3584) >> 9;
104: {{ CPTR srca = nextilong();
105: WORD src = get_word(srca);
106: { regs.v = regs.c = 0;
107: regs.z = ((WORD)(src)) == 0;
108: regs.n = ((WORD)(src)) < 0;
109: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
110: }}}}
111: void op_303a(UWORD opcode)
112: {
113: ULONG dstreg = (opcode & 3584) >> 9;
114: {{ CPTR srca = m68k_getpc();
115: srca += (LONG)(WORD)nextiword();
116: { WORD src = get_word(srca);
117: { regs.v = regs.c = 0;
118: regs.z = ((WORD)(src)) == 0;
119: regs.n = ((WORD)(src)) < 0;
120: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
121: }}}}}
122: void op_303b(UWORD opcode)
123: {
124: ULONG dstreg = (opcode & 3584) >> 9;
125: {{ CPTR srca = m68k_getpc();
126: UWORD srcdp = nextiword();
127: srca += (LONG)(BYTE)(srcdp & 0xFF);
128: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
129: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
130: srca += srcdpr;
131: { WORD src = get_word(srca);
132: { regs.v = regs.c = 0;
133: regs.z = ((WORD)(src)) == 0;
134: regs.n = ((WORD)(src)) < 0;
135: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
136: }}}}}}
137: void op_303c(UWORD opcode)
138: {
139: ULONG dstreg = (opcode & 3584) >> 9;
140: {{ WORD src = nextiword();
141: { regs.v = regs.c = 0;
142: regs.z = ((WORD)(src)) == 0;
143: regs.n = ((WORD)(src)) < 0;
144: regs.d[dstreg] &= ~0xffff; regs.d[dstreg] |= (src) & 0xffff;
145: }}}}
146: void op_3040(UWORD opcode)
147: {
148: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
149: ULONG dstreg = (opcode & 3584) >> 9;
150: {{ WORD src = regs.d[srcreg];
151: { regs.a[dstreg] = (LONG)(WORD)(src);
152: }}}}
153: void op_3048(UWORD opcode)
154: {
155: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
156: ULONG dstreg = (opcode & 3584) >> 9;
157: {{ WORD src = regs.a[srcreg];
158: { regs.a[dstreg] = (LONG)(WORD)(src);
159: }}}}
160: void op_3050(UWORD opcode)
161: {
162: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
163: ULONG dstreg = (opcode & 3584) >> 9;
164: {{ CPTR srca = regs.a[srcreg];
165: WORD src = get_word(srca);
166: { regs.a[dstreg] = (LONG)(WORD)(src);
167: }}}}
168: void op_3058(UWORD opcode)
169: {
170: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
171: ULONG dstreg = (opcode & 3584) >> 9;
172: {{ CPTR srca = regs.a[srcreg];
173: WORD src = get_word(srca);
174: { regs.a[srcreg] += 2;
175: { regs.a[dstreg] = (LONG)(WORD)(src);
176: }}}}}
177: void op_3060(UWORD opcode)
178: {
179: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
180: ULONG dstreg = (opcode & 3584) >> 9;
181: {{ regs.a[srcreg] -= 2;
182: { CPTR srca = regs.a[srcreg];
183: WORD src = get_word(srca);
184: { regs.a[dstreg] = (LONG)(WORD)(src);
185: }}}}}
186: void op_3068(UWORD opcode)
187: {
188: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
189: ULONG dstreg = (opcode & 3584) >> 9;
190: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
191: WORD src = get_word(srca);
192: { regs.a[dstreg] = (LONG)(WORD)(src);
193: }}}}
194: void op_3070(UWORD opcode)
195: {
196: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
197: ULONG dstreg = (opcode & 3584) >> 9;
198: {{ CPTR srca = regs.a[srcreg];
199: UWORD srcdp = nextiword();
200: srca += (LONG)(BYTE)(srcdp & 0xFF);
201: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
202: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
203: srca += srcdpr;
204: { WORD src = get_word(srca);
205: { regs.a[dstreg] = (LONG)(WORD)(src);
206: }}}}}}
207: void op_3078(UWORD opcode)
208: {
209: ULONG dstreg = (opcode & 3584) >> 9;
210: {{ CPTR srca = (LONG)(WORD)nextiword();
211: WORD src = get_word(srca);
212: { regs.a[dstreg] = (LONG)(WORD)(src);
213: }}}}
214: void op_3079(UWORD opcode)
215: {
216: ULONG dstreg = (opcode & 3584) >> 9;
217: {{ CPTR srca = nextilong();
218: WORD src = get_word(srca);
219: { regs.a[dstreg] = (LONG)(WORD)(src);
220: }}}}
221: void op_307a(UWORD opcode)
222: {
223: ULONG dstreg = (opcode & 3584) >> 9;
224: {{ CPTR srca = m68k_getpc();
225: srca += (LONG)(WORD)nextiword();
226: { WORD src = get_word(srca);
227: { regs.a[dstreg] = (LONG)(WORD)(src);
228: }}}}}
229: void op_307b(UWORD opcode)
230: {
231: ULONG dstreg = (opcode & 3584) >> 9;
232: {{ CPTR srca = m68k_getpc();
233: UWORD srcdp = nextiword();
234: srca += (LONG)(BYTE)(srcdp & 0xFF);
235: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
236: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
237: srca += srcdpr;
238: { WORD src = get_word(srca);
239: { regs.a[dstreg] = (LONG)(WORD)(src);
240: }}}}}}
241: void op_307c(UWORD opcode)
242: {
243: ULONG dstreg = (opcode & 3584) >> 9;
244: {{ WORD src = nextiword();
245: { regs.a[dstreg] = (LONG)(WORD)(src);
246: }}}}
247: void op_3080(UWORD opcode)
248: {
249: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
250: ULONG dstreg = (opcode & 3584) >> 9;
251: {{ WORD src = regs.d[srcreg];
252: { CPTR dsta = regs.a[dstreg];
253: regs.v = regs.c = 0;
254: regs.z = ((WORD)(src)) == 0;
255: regs.n = ((WORD)(src)) < 0;
256: put_word(dsta,src);
257: }}}}
258: void op_3088(UWORD opcode)
259: {
260: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
261: ULONG dstreg = (opcode & 3584) >> 9;
262: {{ WORD src = regs.a[srcreg];
263: { CPTR dsta = regs.a[dstreg];
264: regs.v = regs.c = 0;
265: regs.z = ((WORD)(src)) == 0;
266: regs.n = ((WORD)(src)) < 0;
267: put_word(dsta,src);
268: }}}}
269: void op_3090(UWORD opcode)
270: {
271: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
272: ULONG dstreg = (opcode & 3584) >> 9;
273: {{ CPTR srca = regs.a[srcreg];
274: WORD src = get_word(srca);
275: { CPTR dsta = regs.a[dstreg];
276: regs.v = regs.c = 0;
277: regs.z = ((WORD)(src)) == 0;
278: regs.n = ((WORD)(src)) < 0;
279: put_word(dsta,src);
280: }}}}
281: void op_3098(UWORD opcode)
282: {
283: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
284: ULONG dstreg = (opcode & 3584) >> 9;
285: {{ CPTR srca = regs.a[srcreg];
286: WORD src = get_word(srca);
287: { regs.a[srcreg] += 2;
288: { CPTR dsta = regs.a[dstreg];
289: regs.v = regs.c = 0;
290: regs.z = ((WORD)(src)) == 0;
291: regs.n = ((WORD)(src)) < 0;
292: put_word(dsta,src);
293: }}}}}
294: void op_30a0(UWORD opcode)
295: {
296: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
297: ULONG dstreg = (opcode & 3584) >> 9;
298: {{ regs.a[srcreg] -= 2;
299: { CPTR srca = regs.a[srcreg];
300: WORD src = get_word(srca);
301: { CPTR dsta = regs.a[dstreg];
302: regs.v = regs.c = 0;
303: regs.z = ((WORD)(src)) == 0;
304: regs.n = ((WORD)(src)) < 0;
305: put_word(dsta,src);
306: }}}}}
307: void op_30a8(UWORD opcode)
308: {
309: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
310: ULONG dstreg = (opcode & 3584) >> 9;
311: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
312: WORD src = get_word(srca);
313: { CPTR dsta = regs.a[dstreg];
314: regs.v = regs.c = 0;
315: regs.z = ((WORD)(src)) == 0;
316: regs.n = ((WORD)(src)) < 0;
317: put_word(dsta,src);
318: }}}}
319: void op_30b0(UWORD opcode)
320: {
321: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
322: ULONG dstreg = (opcode & 3584) >> 9;
323: {{ CPTR srca = regs.a[srcreg];
324: UWORD srcdp = nextiword();
325: srca += (LONG)(BYTE)(srcdp & 0xFF);
326: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
327: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
328: srca += srcdpr;
329: { WORD src = get_word(srca);
330: { CPTR dsta = regs.a[dstreg];
331: regs.v = regs.c = 0;
332: regs.z = ((WORD)(src)) == 0;
333: regs.n = ((WORD)(src)) < 0;
334: put_word(dsta,src);
335: }}}}}}
336: void op_30b8(UWORD opcode)
337: {
338: ULONG dstreg = (opcode & 3584) >> 9;
339: {{ CPTR srca = (LONG)(WORD)nextiword();
340: WORD src = get_word(srca);
341: { CPTR dsta = regs.a[dstreg];
342: regs.v = regs.c = 0;
343: regs.z = ((WORD)(src)) == 0;
344: regs.n = ((WORD)(src)) < 0;
345: put_word(dsta,src);
346: }}}}
347: void op_30b9(UWORD opcode)
348: {
349: ULONG dstreg = (opcode & 3584) >> 9;
350: {{ CPTR srca = nextilong();
351: WORD src = get_word(srca);
352: { CPTR dsta = regs.a[dstreg];
353: regs.v = regs.c = 0;
354: regs.z = ((WORD)(src)) == 0;
355: regs.n = ((WORD)(src)) < 0;
356: put_word(dsta,src);
357: }}}}
358: void op_30ba(UWORD opcode)
359: {
360: ULONG dstreg = (opcode & 3584) >> 9;
361: {{ CPTR srca = m68k_getpc();
362: srca += (LONG)(WORD)nextiword();
363: { WORD src = get_word(srca);
364: { CPTR dsta = regs.a[dstreg];
365: regs.v = regs.c = 0;
366: regs.z = ((WORD)(src)) == 0;
367: regs.n = ((WORD)(src)) < 0;
368: put_word(dsta,src);
369: }}}}}
370: void op_30bb(UWORD opcode)
371: {
372: ULONG dstreg = (opcode & 3584) >> 9;
373: {{ CPTR srca = m68k_getpc();
374: UWORD srcdp = nextiword();
375: srca += (LONG)(BYTE)(srcdp & 0xFF);
376: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
377: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
378: srca += srcdpr;
379: { WORD src = get_word(srca);
380: { CPTR dsta = regs.a[dstreg];
381: regs.v = regs.c = 0;
382: regs.z = ((WORD)(src)) == 0;
383: regs.n = ((WORD)(src)) < 0;
384: put_word(dsta,src);
385: }}}}}}
386: void op_30bc(UWORD opcode)
387: {
388: ULONG dstreg = (opcode & 3584) >> 9;
389: {{ WORD src = nextiword();
390: { CPTR dsta = regs.a[dstreg];
391: regs.v = regs.c = 0;
392: regs.z = ((WORD)(src)) == 0;
393: regs.n = ((WORD)(src)) < 0;
394: put_word(dsta,src);
395: }}}}
396: void op_30c0(UWORD opcode)
397: {
398: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
399: ULONG dstreg = (opcode & 3584) >> 9;
400: {{ WORD src = regs.d[srcreg];
401: { CPTR dsta = regs.a[dstreg];
402: { regs.a[dstreg] += 2;
403: regs.v = regs.c = 0;
404: regs.z = ((WORD)(src)) == 0;
405: regs.n = ((WORD)(src)) < 0;
406: put_word(dsta,src);
407: }}}}}
408: void op_30c8(UWORD opcode)
409: {
410: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
411: ULONG dstreg = (opcode & 3584) >> 9;
412: {{ WORD src = regs.a[srcreg];
413: { CPTR dsta = regs.a[dstreg];
414: { regs.a[dstreg] += 2;
415: regs.v = regs.c = 0;
416: regs.z = ((WORD)(src)) == 0;
417: regs.n = ((WORD)(src)) < 0;
418: put_word(dsta,src);
419: }}}}}
420: void op_30d0(UWORD opcode)
421: {
422: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
423: ULONG dstreg = (opcode & 3584) >> 9;
424: {{ CPTR srca = regs.a[srcreg];
425: WORD src = get_word(srca);
426: { CPTR dsta = regs.a[dstreg];
427: { regs.a[dstreg] += 2;
428: regs.v = regs.c = 0;
429: regs.z = ((WORD)(src)) == 0;
430: regs.n = ((WORD)(src)) < 0;
431: put_word(dsta,src);
432: }}}}}
433: void op_30d8(UWORD opcode)
434: {
435: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
436: ULONG dstreg = (opcode & 3584) >> 9;
437: {{ CPTR srca = regs.a[srcreg];
438: WORD src = get_word(srca);
439: { regs.a[srcreg] += 2;
440: { CPTR dsta = regs.a[dstreg];
441: { regs.a[dstreg] += 2;
442: regs.v = regs.c = 0;
443: regs.z = ((WORD)(src)) == 0;
444: regs.n = ((WORD)(src)) < 0;
445: put_word(dsta,src);
446: }}}}}}
447: void op_30e0(UWORD opcode)
448: {
449: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
450: ULONG dstreg = (opcode & 3584) >> 9;
451: {{ regs.a[srcreg] -= 2;
452: { CPTR srca = regs.a[srcreg];
453: WORD src = get_word(srca);
454: { CPTR dsta = regs.a[dstreg];
455: { regs.a[dstreg] += 2;
456: regs.v = regs.c = 0;
457: regs.z = ((WORD)(src)) == 0;
458: regs.n = ((WORD)(src)) < 0;
459: put_word(dsta,src);
460: }}}}}}
461: void op_30e8(UWORD opcode)
462: {
463: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
464: ULONG dstreg = (opcode & 3584) >> 9;
465: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
466: WORD src = get_word(srca);
467: { CPTR dsta = regs.a[dstreg];
468: { regs.a[dstreg] += 2;
469: regs.v = regs.c = 0;
470: regs.z = ((WORD)(src)) == 0;
471: regs.n = ((WORD)(src)) < 0;
472: put_word(dsta,src);
473: }}}}}
474: void op_30f0(UWORD opcode)
475: {
476: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
477: ULONG dstreg = (opcode & 3584) >> 9;
478: {{ CPTR srca = regs.a[srcreg];
479: UWORD srcdp = nextiword();
480: srca += (LONG)(BYTE)(srcdp & 0xFF);
481: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
482: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
483: srca += srcdpr;
484: { WORD src = get_word(srca);
485: { CPTR dsta = regs.a[dstreg];
486: { regs.a[dstreg] += 2;
487: regs.v = regs.c = 0;
488: regs.z = ((WORD)(src)) == 0;
489: regs.n = ((WORD)(src)) < 0;
490: put_word(dsta,src);
491: }}}}}}}
492: void op_30f8(UWORD opcode)
493: {
494: ULONG dstreg = (opcode & 3584) >> 9;
495: {{ CPTR srca = (LONG)(WORD)nextiword();
496: WORD src = get_word(srca);
497: { CPTR dsta = regs.a[dstreg];
498: { regs.a[dstreg] += 2;
499: regs.v = regs.c = 0;
500: regs.z = ((WORD)(src)) == 0;
501: regs.n = ((WORD)(src)) < 0;
502: put_word(dsta,src);
503: }}}}}
504: void op_30f9(UWORD opcode)
505: {
506: ULONG dstreg = (opcode & 3584) >> 9;
507: {{ CPTR srca = nextilong();
508: WORD src = get_word(srca);
509: { CPTR dsta = regs.a[dstreg];
510: { regs.a[dstreg] += 2;
511: regs.v = regs.c = 0;
512: regs.z = ((WORD)(src)) == 0;
513: regs.n = ((WORD)(src)) < 0;
514: put_word(dsta,src);
515: }}}}}
516: void op_30fa(UWORD opcode)
517: {
518: ULONG dstreg = (opcode & 3584) >> 9;
519: {{ CPTR srca = m68k_getpc();
520: srca += (LONG)(WORD)nextiword();
521: { WORD src = get_word(srca);
522: { CPTR dsta = regs.a[dstreg];
523: { regs.a[dstreg] += 2;
524: regs.v = regs.c = 0;
525: regs.z = ((WORD)(src)) == 0;
526: regs.n = ((WORD)(src)) < 0;
527: put_word(dsta,src);
528: }}}}}}
529: void op_30fb(UWORD opcode)
530: {
531: ULONG dstreg = (opcode & 3584) >> 9;
532: {{ CPTR srca = m68k_getpc();
533: UWORD srcdp = nextiword();
534: srca += (LONG)(BYTE)(srcdp & 0xFF);
535: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
536: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
537: srca += srcdpr;
538: { WORD src = get_word(srca);
539: { CPTR dsta = regs.a[dstreg];
540: { regs.a[dstreg] += 2;
541: regs.v = regs.c = 0;
542: regs.z = ((WORD)(src)) == 0;
543: regs.n = ((WORD)(src)) < 0;
544: put_word(dsta,src);
545: }}}}}}}
546: void op_30fc(UWORD opcode)
547: {
548: ULONG dstreg = (opcode & 3584) >> 9;
549: {{ WORD src = nextiword();
550: { CPTR dsta = regs.a[dstreg];
551: { regs.a[dstreg] += 2;
552: regs.v = regs.c = 0;
553: regs.z = ((WORD)(src)) == 0;
554: regs.n = ((WORD)(src)) < 0;
555: put_word(dsta,src);
556: }}}}}
557: void op_3100(UWORD opcode)
558: {
559: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
560: ULONG dstreg = (opcode & 3584) >> 9;
561: {{ WORD src = regs.d[srcreg];
562: { regs.a[dstreg] -= 2;
563: { CPTR dsta = regs.a[dstreg];
564: regs.v = regs.c = 0;
565: regs.z = ((WORD)(src)) == 0;
566: regs.n = ((WORD)(src)) < 0;
567: put_word(dsta,src);
568: }}}}}
569: void op_3108(UWORD opcode)
570: {
571: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
572: ULONG dstreg = (opcode & 3584) >> 9;
573: {{ WORD src = regs.a[srcreg];
574: { regs.a[dstreg] -= 2;
575: { CPTR dsta = regs.a[dstreg];
576: regs.v = regs.c = 0;
577: regs.z = ((WORD)(src)) == 0;
578: regs.n = ((WORD)(src)) < 0;
579: put_word(dsta,src);
580: }}}}}
581: void op_3110(UWORD opcode)
582: {
583: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
584: ULONG dstreg = (opcode & 3584) >> 9;
585: {{ CPTR srca = regs.a[srcreg];
586: WORD src = get_word(srca);
587: { regs.a[dstreg] -= 2;
588: { CPTR dsta = regs.a[dstreg];
589: regs.v = regs.c = 0;
590: regs.z = ((WORD)(src)) == 0;
591: regs.n = ((WORD)(src)) < 0;
592: put_word(dsta,src);
593: }}}}}
594: void op_3118(UWORD opcode)
595: {
596: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
597: ULONG dstreg = (opcode & 3584) >> 9;
598: {{ CPTR srca = regs.a[srcreg];
599: WORD src = get_word(srca);
600: { regs.a[srcreg] += 2;
601: { regs.a[dstreg] -= 2;
602: { CPTR dsta = regs.a[dstreg];
603: regs.v = regs.c = 0;
604: regs.z = ((WORD)(src)) == 0;
605: regs.n = ((WORD)(src)) < 0;
606: put_word(dsta,src);
607: }}}}}}
608: void op_3120(UWORD opcode)
609: {
610: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
611: ULONG dstreg = (opcode & 3584) >> 9;
612: {{ regs.a[srcreg] -= 2;
613: { CPTR srca = regs.a[srcreg];
614: WORD src = get_word(srca);
615: { regs.a[dstreg] -= 2;
616: { CPTR dsta = regs.a[dstreg];
617: regs.v = regs.c = 0;
618: regs.z = ((WORD)(src)) == 0;
619: regs.n = ((WORD)(src)) < 0;
620: put_word(dsta,src);
621: }}}}}}
622: void op_3128(UWORD opcode)
623: {
624: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
625: ULONG dstreg = (opcode & 3584) >> 9;
626: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
627: WORD src = get_word(srca);
628: { regs.a[dstreg] -= 2;
629: { CPTR dsta = regs.a[dstreg];
630: regs.v = regs.c = 0;
631: regs.z = ((WORD)(src)) == 0;
632: regs.n = ((WORD)(src)) < 0;
633: put_word(dsta,src);
634: }}}}}
635: void op_3130(UWORD opcode)
636: {
637: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
638: ULONG dstreg = (opcode & 3584) >> 9;
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: { WORD src = get_word(srca);
646: { regs.a[dstreg] -= 2;
647: { CPTR dsta = regs.a[dstreg];
648: regs.v = regs.c = 0;
649: regs.z = ((WORD)(src)) == 0;
650: regs.n = ((WORD)(src)) < 0;
651: put_word(dsta,src);
652: }}}}}}}
653: void op_3138(UWORD opcode)
654: {
655: ULONG dstreg = (opcode & 3584) >> 9;
656: {{ CPTR srca = (LONG)(WORD)nextiword();
657: WORD src = get_word(srca);
658: { regs.a[dstreg] -= 2;
659: { CPTR dsta = regs.a[dstreg];
660: regs.v = regs.c = 0;
661: regs.z = ((WORD)(src)) == 0;
662: regs.n = ((WORD)(src)) < 0;
663: put_word(dsta,src);
664: }}}}}
665: void op_3139(UWORD opcode)
666: {
667: ULONG dstreg = (opcode & 3584) >> 9;
668: {{ CPTR srca = nextilong();
669: WORD src = get_word(srca);
670: { regs.a[dstreg] -= 2;
671: { CPTR dsta = regs.a[dstreg];
672: regs.v = regs.c = 0;
673: regs.z = ((WORD)(src)) == 0;
674: regs.n = ((WORD)(src)) < 0;
675: put_word(dsta,src);
676: }}}}}
677: void op_313a(UWORD opcode)
678: {
679: ULONG dstreg = (opcode & 3584) >> 9;
680: {{ CPTR srca = m68k_getpc();
681: srca += (LONG)(WORD)nextiword();
682: { WORD src = get_word(srca);
683: { regs.a[dstreg] -= 2;
684: { CPTR dsta = regs.a[dstreg];
685: regs.v = regs.c = 0;
686: regs.z = ((WORD)(src)) == 0;
687: regs.n = ((WORD)(src)) < 0;
688: put_word(dsta,src);
689: }}}}}}
690: void op_313b(UWORD opcode)
691: {
692: ULONG dstreg = (opcode & 3584) >> 9;
693: {{ CPTR srca = m68k_getpc();
694: UWORD srcdp = nextiword();
695: srca += (LONG)(BYTE)(srcdp & 0xFF);
696: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
697: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
698: srca += srcdpr;
699: { WORD src = get_word(srca);
700: { regs.a[dstreg] -= 2;
701: { CPTR dsta = regs.a[dstreg];
702: regs.v = regs.c = 0;
703: regs.z = ((WORD)(src)) == 0;
704: regs.n = ((WORD)(src)) < 0;
705: put_word(dsta,src);
706: }}}}}}}
707: void op_313c(UWORD opcode)
708: {
709: ULONG dstreg = (opcode & 3584) >> 9;
710: {{ WORD src = nextiword();
711: { regs.a[dstreg] -= 2;
712: { CPTR dsta = regs.a[dstreg];
713: regs.v = regs.c = 0;
714: regs.z = ((WORD)(src)) == 0;
715: regs.n = ((WORD)(src)) < 0;
716: put_word(dsta,src);
717: }}}}}
718: void op_3140(UWORD opcode)
719: {
720: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
721: ULONG dstreg = (opcode & 3584) >> 9;
722: {{ WORD src = regs.d[srcreg];
723: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
724: regs.v = regs.c = 0;
725: regs.z = ((WORD)(src)) == 0;
726: regs.n = ((WORD)(src)) < 0;
727: put_word(dsta,src);
728: }}}}
729: void op_3148(UWORD opcode)
730: {
731: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
732: ULONG dstreg = (opcode & 3584) >> 9;
733: {{ WORD src = regs.a[srcreg];
734: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
735: regs.v = regs.c = 0;
736: regs.z = ((WORD)(src)) == 0;
737: regs.n = ((WORD)(src)) < 0;
738: put_word(dsta,src);
739: }}}}
740: void op_3150(UWORD opcode)
741: {
742: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
743: ULONG dstreg = (opcode & 3584) >> 9;
744: {{ CPTR srca = regs.a[srcreg];
745: WORD src = get_word(srca);
746: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
747: regs.v = regs.c = 0;
748: regs.z = ((WORD)(src)) == 0;
749: regs.n = ((WORD)(src)) < 0;
750: put_word(dsta,src);
751: }}}}
752: void op_3158(UWORD opcode)
753: {
754: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
755: ULONG dstreg = (opcode & 3584) >> 9;
756: {{ CPTR srca = regs.a[srcreg];
757: WORD src = get_word(srca);
758: { regs.a[srcreg] += 2;
759: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
760: regs.v = regs.c = 0;
761: regs.z = ((WORD)(src)) == 0;
762: regs.n = ((WORD)(src)) < 0;
763: put_word(dsta,src);
764: }}}}}
765: void op_3160(UWORD opcode)
766: {
767: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
768: ULONG dstreg = (opcode & 3584) >> 9;
769: {{ regs.a[srcreg] -= 2;
770: { CPTR srca = regs.a[srcreg];
771: WORD src = get_word(srca);
772: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
773: regs.v = regs.c = 0;
774: regs.z = ((WORD)(src)) == 0;
775: regs.n = ((WORD)(src)) < 0;
776: put_word(dsta,src);
777: }}}}}
778: void op_3168(UWORD opcode)
779: {
780: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
781: ULONG dstreg = (opcode & 3584) >> 9;
782: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
783: WORD src = get_word(srca);
784: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
785: regs.v = regs.c = 0;
786: regs.z = ((WORD)(src)) == 0;
787: regs.n = ((WORD)(src)) < 0;
788: put_word(dsta,src);
789: }}}}
790: void op_3170(UWORD opcode)
791: {
792: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
793: ULONG dstreg = (opcode & 3584) >> 9;
794: {{ CPTR srca = regs.a[srcreg];
795: UWORD srcdp = nextiword();
796: srca += (LONG)(BYTE)(srcdp & 0xFF);
797: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
798: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
799: srca += srcdpr;
800: { WORD src = get_word(srca);
801: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
802: regs.v = regs.c = 0;
803: regs.z = ((WORD)(src)) == 0;
804: regs.n = ((WORD)(src)) < 0;
805: put_word(dsta,src);
806: }}}}}}
807: void op_3178(UWORD opcode)
808: {
809: ULONG dstreg = (opcode & 3584) >> 9;
810: {{ CPTR srca = (LONG)(WORD)nextiword();
811: WORD src = get_word(srca);
812: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
813: regs.v = regs.c = 0;
814: regs.z = ((WORD)(src)) == 0;
815: regs.n = ((WORD)(src)) < 0;
816: put_word(dsta,src);
817: }}}}
818: void op_3179(UWORD opcode)
819: {
820: ULONG dstreg = (opcode & 3584) >> 9;
821: {{ CPTR srca = nextilong();
822: WORD src = get_word(srca);
823: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
824: regs.v = regs.c = 0;
825: regs.z = ((WORD)(src)) == 0;
826: regs.n = ((WORD)(src)) < 0;
827: put_word(dsta,src);
828: }}}}
829: void op_317a(UWORD opcode)
830: {
831: ULONG dstreg = (opcode & 3584) >> 9;
832: {{ CPTR srca = m68k_getpc();
833: srca += (LONG)(WORD)nextiword();
834: { WORD src = get_word(srca);
835: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
836: regs.v = regs.c = 0;
837: regs.z = ((WORD)(src)) == 0;
838: regs.n = ((WORD)(src)) < 0;
839: put_word(dsta,src);
840: }}}}}
841: void op_317b(UWORD opcode)
842: {
843: ULONG dstreg = (opcode & 3584) >> 9;
844: {{ CPTR srca = m68k_getpc();
845: UWORD srcdp = nextiword();
846: srca += (LONG)(BYTE)(srcdp & 0xFF);
847: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
848: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
849: srca += srcdpr;
850: { WORD src = get_word(srca);
851: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
852: regs.v = regs.c = 0;
853: regs.z = ((WORD)(src)) == 0;
854: regs.n = ((WORD)(src)) < 0;
855: put_word(dsta,src);
856: }}}}}}
857: void op_317c(UWORD opcode)
858: {
859: ULONG dstreg = (opcode & 3584) >> 9;
860: {{ WORD src = nextiword();
861: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
862: regs.v = regs.c = 0;
863: regs.z = ((WORD)(src)) == 0;
864: regs.n = ((WORD)(src)) < 0;
865: put_word(dsta,src);
866: }}}}
867: void op_3180(UWORD opcode)
868: {
869: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
870: ULONG dstreg = (opcode & 3584) >> 9;
871: {{ WORD src = regs.d[srcreg];
872: { CPTR dsta = regs.a[dstreg];
873: UWORD dstdp = nextiword();
874: dsta += (LONG)(BYTE)(dstdp & 0xFF);
875: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
876: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
877: dsta += dstdpr;
878: regs.v = regs.c = 0;
879: regs.z = ((WORD)(src)) == 0;
880: regs.n = ((WORD)(src)) < 0;
881: put_word(dsta,src);
882: }}}}}
883: void op_3188(UWORD opcode)
884: {
885: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
886: ULONG dstreg = (opcode & 3584) >> 9;
887: {{ WORD src = regs.a[srcreg];
888: { CPTR dsta = regs.a[dstreg];
889: UWORD dstdp = nextiword();
890: dsta += (LONG)(BYTE)(dstdp & 0xFF);
891: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
892: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
893: dsta += dstdpr;
894: regs.v = regs.c = 0;
895: regs.z = ((WORD)(src)) == 0;
896: regs.n = ((WORD)(src)) < 0;
897: put_word(dsta,src);
898: }}}}}
899: void op_3190(UWORD opcode)
900: {
901: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
902: ULONG dstreg = (opcode & 3584) >> 9;
903: {{ CPTR srca = regs.a[srcreg];
904: WORD src = get_word(srca);
905: { CPTR dsta = regs.a[dstreg];
906: UWORD dstdp = nextiword();
907: dsta += (LONG)(BYTE)(dstdp & 0xFF);
908: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
909: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
910: dsta += dstdpr;
911: regs.v = regs.c = 0;
912: regs.z = ((WORD)(src)) == 0;
913: regs.n = ((WORD)(src)) < 0;
914: put_word(dsta,src);
915: }}}}}
916: void op_3198(UWORD opcode)
917: {
918: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
919: ULONG dstreg = (opcode & 3584) >> 9;
920: {{ CPTR srca = regs.a[srcreg];
921: WORD src = get_word(srca);
922: { regs.a[srcreg] += 2;
923: { CPTR dsta = regs.a[dstreg];
924: UWORD dstdp = nextiword();
925: dsta += (LONG)(BYTE)(dstdp & 0xFF);
926: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
927: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
928: dsta += dstdpr;
929: regs.v = regs.c = 0;
930: regs.z = ((WORD)(src)) == 0;
931: regs.n = ((WORD)(src)) < 0;
932: put_word(dsta,src);
933: }}}}}}
934: void op_31a0(UWORD opcode)
935: {
936: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
937: ULONG dstreg = (opcode & 3584) >> 9;
938: {{ regs.a[srcreg] -= 2;
939: { CPTR srca = regs.a[srcreg];
940: WORD src = get_word(srca);
941: { CPTR dsta = regs.a[dstreg];
942: UWORD dstdp = nextiword();
943: dsta += (LONG)(BYTE)(dstdp & 0xFF);
944: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
945: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
946: dsta += dstdpr;
947: regs.v = regs.c = 0;
948: regs.z = ((WORD)(src)) == 0;
949: regs.n = ((WORD)(src)) < 0;
950: put_word(dsta,src);
951: }}}}}}
952: void op_31a8(UWORD opcode)
953: {
954: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
955: ULONG dstreg = (opcode & 3584) >> 9;
956: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
957: WORD src = get_word(srca);
958: { CPTR dsta = regs.a[dstreg];
959: UWORD dstdp = nextiword();
960: dsta += (LONG)(BYTE)(dstdp & 0xFF);
961: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
962: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
963: dsta += dstdpr;
964: regs.v = regs.c = 0;
965: regs.z = ((WORD)(src)) == 0;
966: regs.n = ((WORD)(src)) < 0;
967: put_word(dsta,src);
968: }}}}}
969: void op_31b0(UWORD opcode)
970: {
971: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
972: ULONG dstreg = (opcode & 3584) >> 9;
973: {{ CPTR srca = regs.a[srcreg];
974: UWORD srcdp = nextiword();
975: srca += (LONG)(BYTE)(srcdp & 0xFF);
976: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
977: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
978: srca += srcdpr;
979: { WORD src = get_word(srca);
980: { CPTR dsta = regs.a[dstreg];
981: UWORD dstdp = nextiword();
982: dsta += (LONG)(BYTE)(dstdp & 0xFF);
983: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
984: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
985: dsta += dstdpr;
986: regs.v = regs.c = 0;
987: regs.z = ((WORD)(src)) == 0;
988: regs.n = ((WORD)(src)) < 0;
989: put_word(dsta,src);
990: }}}}}}}
991: void op_31b8(UWORD opcode)
992: {
993: ULONG dstreg = (opcode & 3584) >> 9;
994: {{ CPTR srca = (LONG)(WORD)nextiword();
995: WORD src = get_word(srca);
996: { CPTR dsta = regs.a[dstreg];
997: UWORD dstdp = nextiword();
998: dsta += (LONG)(BYTE)(dstdp & 0xFF);
999: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1000: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1001: dsta += dstdpr;
1002: regs.v = regs.c = 0;
1003: regs.z = ((WORD)(src)) == 0;
1004: regs.n = ((WORD)(src)) < 0;
1005: put_word(dsta,src);
1006: }}}}}
1007: void op_31b9(UWORD opcode)
1008: {
1009: ULONG dstreg = (opcode & 3584) >> 9;
1010: {{ CPTR srca = nextilong();
1011: WORD src = get_word(srca);
1012: { CPTR dsta = regs.a[dstreg];
1013: UWORD dstdp = nextiword();
1014: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1015: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1016: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1017: dsta += dstdpr;
1018: regs.v = regs.c = 0;
1019: regs.z = ((WORD)(src)) == 0;
1020: regs.n = ((WORD)(src)) < 0;
1021: put_word(dsta,src);
1022: }}}}}
1023: void op_31ba(UWORD opcode)
1024: {
1025: ULONG dstreg = (opcode & 3584) >> 9;
1026: {{ CPTR srca = m68k_getpc();
1027: srca += (LONG)(WORD)nextiword();
1028: { WORD src = get_word(srca);
1029: { CPTR dsta = regs.a[dstreg];
1030: UWORD dstdp = nextiword();
1031: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1032: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1033: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1034: dsta += dstdpr;
1035: regs.v = regs.c = 0;
1036: regs.z = ((WORD)(src)) == 0;
1037: regs.n = ((WORD)(src)) < 0;
1038: put_word(dsta,src);
1039: }}}}}}
1040: void op_31bb(UWORD opcode)
1041: {
1042: ULONG dstreg = (opcode & 3584) >> 9;
1043: {{ CPTR srca = m68k_getpc();
1044: UWORD srcdp = nextiword();
1045: srca += (LONG)(BYTE)(srcdp & 0xFF);
1046: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1047: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1048: srca += srcdpr;
1049: { WORD src = get_word(srca);
1050: { CPTR dsta = regs.a[dstreg];
1051: UWORD dstdp = nextiword();
1052: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1053: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1054: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1055: dsta += dstdpr;
1056: regs.v = regs.c = 0;
1057: regs.z = ((WORD)(src)) == 0;
1058: regs.n = ((WORD)(src)) < 0;
1059: put_word(dsta,src);
1060: }}}}}}}
1061: void op_31bc(UWORD opcode)
1062: {
1063: ULONG dstreg = (opcode & 3584) >> 9;
1064: {{ WORD src = nextiword();
1065: { CPTR dsta = regs.a[dstreg];
1066: UWORD dstdp = nextiword();
1067: dsta += (LONG)(BYTE)(dstdp & 0xFF);
1068: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
1069: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
1070: dsta += dstdpr;
1071: regs.v = regs.c = 0;
1072: regs.z = ((WORD)(src)) == 0;
1073: regs.n = ((WORD)(src)) < 0;
1074: put_word(dsta,src);
1075: }}}}}
1076: void op_31c0(UWORD opcode)
1077: {
1078: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1079: {{ WORD src = regs.d[srcreg];
1080: { CPTR dsta = (LONG)(WORD)nextiword();
1081: regs.v = regs.c = 0;
1082: regs.z = ((WORD)(src)) == 0;
1083: regs.n = ((WORD)(src)) < 0;
1084: put_word(dsta,src);
1085: }}}}
1086: void op_31c8(UWORD opcode)
1087: {
1088: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1089: {{ WORD src = regs.a[srcreg];
1090: { CPTR dsta = (LONG)(WORD)nextiword();
1091: regs.v = regs.c = 0;
1092: regs.z = ((WORD)(src)) == 0;
1093: regs.n = ((WORD)(src)) < 0;
1094: put_word(dsta,src);
1095: }}}}
1096: void op_31d0(UWORD opcode)
1097: {
1098: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1099: {{ CPTR srca = regs.a[srcreg];
1100: WORD src = get_word(srca);
1101: { CPTR dsta = (LONG)(WORD)nextiword();
1102: regs.v = regs.c = 0;
1103: regs.z = ((WORD)(src)) == 0;
1104: regs.n = ((WORD)(src)) < 0;
1105: put_word(dsta,src);
1106: }}}}
1107: void op_31d8(UWORD opcode)
1108: {
1109: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1110: {{ CPTR srca = regs.a[srcreg];
1111: WORD src = get_word(srca);
1112: { regs.a[srcreg] += 2;
1113: { CPTR dsta = (LONG)(WORD)nextiword();
1114: regs.v = regs.c = 0;
1115: regs.z = ((WORD)(src)) == 0;
1116: regs.n = ((WORD)(src)) < 0;
1117: put_word(dsta,src);
1118: }}}}}
1119: void op_31e0(UWORD opcode)
1120: {
1121: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1122: {{ regs.a[srcreg] -= 2;
1123: { CPTR srca = regs.a[srcreg];
1124: WORD src = get_word(srca);
1125: { CPTR dsta = (LONG)(WORD)nextiword();
1126: regs.v = regs.c = 0;
1127: regs.z = ((WORD)(src)) == 0;
1128: regs.n = ((WORD)(src)) < 0;
1129: put_word(dsta,src);
1130: }}}}}
1131: void op_31e8(UWORD opcode)
1132: {
1133: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1134: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
1135: WORD src = get_word(srca);
1136: { CPTR dsta = (LONG)(WORD)nextiword();
1137: regs.v = regs.c = 0;
1138: regs.z = ((WORD)(src)) == 0;
1139: regs.n = ((WORD)(src)) < 0;
1140: put_word(dsta,src);
1141: }}}}
1142: void op_31f0(UWORD opcode)
1143: {
1144: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1145: {{ CPTR srca = regs.a[srcreg];
1146: UWORD srcdp = nextiword();
1147: srca += (LONG)(BYTE)(srcdp & 0xFF);
1148: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1149: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1150: srca += srcdpr;
1151: { WORD src = get_word(srca);
1152: { CPTR dsta = (LONG)(WORD)nextiword();
1153: regs.v = regs.c = 0;
1154: regs.z = ((WORD)(src)) == 0;
1155: regs.n = ((WORD)(src)) < 0;
1156: put_word(dsta,src);
1157: }}}}}}
1158: void op_31f8(UWORD opcode)
1159: {
1160: {{ CPTR srca = (LONG)(WORD)nextiword();
1161: WORD src = get_word(srca);
1162: { CPTR dsta = (LONG)(WORD)nextiword();
1163: regs.v = regs.c = 0;
1164: regs.z = ((WORD)(src)) == 0;
1165: regs.n = ((WORD)(src)) < 0;
1166: put_word(dsta,src);
1167: }}}}
1168: void op_31f9(UWORD opcode)
1169: {
1170: {{ CPTR srca = nextilong();
1171: WORD src = get_word(srca);
1172: { CPTR dsta = (LONG)(WORD)nextiword();
1173: regs.v = regs.c = 0;
1174: regs.z = ((WORD)(src)) == 0;
1175: regs.n = ((WORD)(src)) < 0;
1176: put_word(dsta,src);
1177: }}}}
1178: void op_31fa(UWORD opcode)
1179: {
1180: {{ CPTR srca = m68k_getpc();
1181: srca += (LONG)(WORD)nextiword();
1182: { WORD src = get_word(srca);
1183: { CPTR dsta = (LONG)(WORD)nextiword();
1184: regs.v = regs.c = 0;
1185: regs.z = ((WORD)(src)) == 0;
1186: regs.n = ((WORD)(src)) < 0;
1187: put_word(dsta,src);
1188: }}}}}
1189: void op_31fb(UWORD opcode)
1190: {
1191: {{ CPTR srca = m68k_getpc();
1192: UWORD srcdp = nextiword();
1193: srca += (LONG)(BYTE)(srcdp & 0xFF);
1194: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1195: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1196: srca += srcdpr;
1197: { WORD src = get_word(srca);
1198: { CPTR dsta = (LONG)(WORD)nextiword();
1199: regs.v = regs.c = 0;
1200: regs.z = ((WORD)(src)) == 0;
1201: regs.n = ((WORD)(src)) < 0;
1202: put_word(dsta,src);
1203: }}}}}}
1204: void op_31fc(UWORD opcode)
1205: {
1206: {{ WORD src = nextiword();
1207: { CPTR dsta = (LONG)(WORD)nextiword();
1208: regs.v = regs.c = 0;
1209: regs.z = ((WORD)(src)) == 0;
1210: regs.n = ((WORD)(src)) < 0;
1211: put_word(dsta,src);
1212: }}}}
1213: void op_33c0(UWORD opcode)
1214: {
1215: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1216: {{ WORD src = regs.d[srcreg];
1217: { CPTR dsta = nextilong();
1218: regs.v = regs.c = 0;
1219: regs.z = ((WORD)(src)) == 0;
1220: regs.n = ((WORD)(src)) < 0;
1221: put_word(dsta,src);
1222: }}}}
1223: void op_33c8(UWORD opcode)
1224: {
1225: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1226: {{ WORD src = regs.a[srcreg];
1227: { CPTR dsta = nextilong();
1228: regs.v = regs.c = 0;
1229: regs.z = ((WORD)(src)) == 0;
1230: regs.n = ((WORD)(src)) < 0;
1231: put_word(dsta,src);
1232: }}}}
1233: void op_33d0(UWORD opcode)
1234: {
1235: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1236: {{ CPTR srca = regs.a[srcreg];
1237: WORD src = get_word(srca);
1238: { CPTR dsta = nextilong();
1239: regs.v = regs.c = 0;
1240: regs.z = ((WORD)(src)) == 0;
1241: regs.n = ((WORD)(src)) < 0;
1242: put_word(dsta,src);
1243: }}}}
1244: void op_33d8(UWORD opcode)
1245: {
1246: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1247: {{ CPTR srca = regs.a[srcreg];
1248: WORD src = get_word(srca);
1249: { regs.a[srcreg] += 2;
1250: { CPTR dsta = nextilong();
1251: regs.v = regs.c = 0;
1252: regs.z = ((WORD)(src)) == 0;
1253: regs.n = ((WORD)(src)) < 0;
1254: put_word(dsta,src);
1255: }}}}}
1256: void op_33e0(UWORD opcode)
1257: {
1258: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1259: {{ regs.a[srcreg] -= 2;
1260: { CPTR srca = regs.a[srcreg];
1261: WORD src = get_word(srca);
1262: { CPTR dsta = nextilong();
1263: regs.v = regs.c = 0;
1264: regs.z = ((WORD)(src)) == 0;
1265: regs.n = ((WORD)(src)) < 0;
1266: put_word(dsta,src);
1267: }}}}}
1268: void op_33e8(UWORD opcode)
1269: {
1270: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1271: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
1272: WORD src = get_word(srca);
1273: { CPTR dsta = nextilong();
1274: regs.v = regs.c = 0;
1275: regs.z = ((WORD)(src)) == 0;
1276: regs.n = ((WORD)(src)) < 0;
1277: put_word(dsta,src);
1278: }}}}
1279: void op_33f0(UWORD opcode)
1280: {
1281: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1282: {{ CPTR srca = regs.a[srcreg];
1283: UWORD srcdp = nextiword();
1284: srca += (LONG)(BYTE)(srcdp & 0xFF);
1285: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1286: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1287: srca += srcdpr;
1288: { WORD src = get_word(srca);
1289: { CPTR dsta = nextilong();
1290: regs.v = regs.c = 0;
1291: regs.z = ((WORD)(src)) == 0;
1292: regs.n = ((WORD)(src)) < 0;
1293: put_word(dsta,src);
1294: }}}}}}
1295: void op_33f8(UWORD opcode)
1296: {
1297: {{ CPTR srca = (LONG)(WORD)nextiword();
1298: WORD src = get_word(srca);
1299: { CPTR dsta = nextilong();
1300: regs.v = regs.c = 0;
1301: regs.z = ((WORD)(src)) == 0;
1302: regs.n = ((WORD)(src)) < 0;
1303: put_word(dsta,src);
1304: }}}}
1305: void op_33f9(UWORD opcode)
1306: {
1307: {{ CPTR srca = nextilong();
1308: WORD src = get_word(srca);
1309: { CPTR dsta = nextilong();
1310: regs.v = regs.c = 0;
1311: regs.z = ((WORD)(src)) == 0;
1312: regs.n = ((WORD)(src)) < 0;
1313: put_word(dsta,src);
1314: }}}}
1315: void op_33fa(UWORD opcode)
1316: {
1317: {{ CPTR srca = m68k_getpc();
1318: srca += (LONG)(WORD)nextiword();
1319: { WORD src = get_word(srca);
1320: { CPTR dsta = nextilong();
1321: regs.v = regs.c = 0;
1322: regs.z = ((WORD)(src)) == 0;
1323: regs.n = ((WORD)(src)) < 0;
1324: put_word(dsta,src);
1325: }}}}}
1326: void op_33fb(UWORD opcode)
1327: {
1328: {{ CPTR srca = m68k_getpc();
1329: UWORD srcdp = nextiword();
1330: srca += (LONG)(BYTE)(srcdp & 0xFF);
1331: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1332: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1333: srca += srcdpr;
1334: { WORD src = get_word(srca);
1335: { CPTR dsta = nextilong();
1336: regs.v = regs.c = 0;
1337: regs.z = ((WORD)(src)) == 0;
1338: regs.n = ((WORD)(src)) < 0;
1339: put_word(dsta,src);
1340: }}}}}}
1341: void op_33fc(UWORD opcode)
1342: {
1343: {{ WORD src = nextiword();
1344: { CPTR dsta = nextilong();
1345: regs.v = regs.c = 0;
1346: regs.z = ((WORD)(src)) == 0;
1347: regs.n = ((WORD)(src)) < 0;
1348: put_word(dsta,src);
1349: }}}}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.