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