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