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