![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpuC.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 cpuC.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_c000(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_c010(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_c018(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_c020(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_c028(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_c030(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_c038(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_c039(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_c03a(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_c03b(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_c03c(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_c040(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_c050(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_c058(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_c060(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_c068(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_c070(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_c078(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_c079(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_c07a(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_c07b(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_c07c(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_c080(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_c090(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_c098(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_c0a0(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_c0a8(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_c0b0(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_c0b8(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_c0b9(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_c0ba(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_c0bb(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_c0bc(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_c0c0(UWORD opcode)
457: {
458: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
459: ULONG dstreg = (opcode & 3584) >> 9;
460: {{ WORD src = regs.d[srcreg];
461: { WORD dst = regs.d[dstreg];
462: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
463: regs.v = regs.c = 0;
464: regs.z = ((LONG)(newv)) == 0;
465: regs.n = ((LONG)(newv)) < 0;
466: regs.d[dstreg] = (newv);
467: }}}}}
468: void op_c0d0(UWORD opcode)
469: {
470: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
471: ULONG dstreg = (opcode & 3584) >> 9;
472: {{ CPTR srca = regs.a[srcreg];
473: WORD src = get_word(srca);
474: { WORD dst = regs.d[dstreg];
475: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
476: regs.v = regs.c = 0;
477: regs.z = ((LONG)(newv)) == 0;
478: regs.n = ((LONG)(newv)) < 0;
479: regs.d[dstreg] = (newv);
480: }}}}}
481: void op_c0d8(UWORD opcode)
482: {
483: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
484: ULONG dstreg = (opcode & 3584) >> 9;
485: {{ CPTR srca = regs.a[srcreg];
486: WORD src = get_word(srca);
487: { regs.a[srcreg] += 2;
488: { WORD dst = regs.d[dstreg];
489: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
490: regs.v = regs.c = 0;
491: regs.z = ((LONG)(newv)) == 0;
492: regs.n = ((LONG)(newv)) < 0;
493: regs.d[dstreg] = (newv);
494: }}}}}}
495: void op_c0e0(UWORD opcode)
496: {
497: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
498: ULONG dstreg = (opcode & 3584) >> 9;
499: {{ regs.a[srcreg] -= 2;
500: { CPTR srca = regs.a[srcreg];
501: WORD src = get_word(srca);
502: { WORD dst = regs.d[dstreg];
503: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
504: regs.v = regs.c = 0;
505: regs.z = ((LONG)(newv)) == 0;
506: regs.n = ((LONG)(newv)) < 0;
507: regs.d[dstreg] = (newv);
508: }}}}}}
509: void op_c0e8(UWORD opcode)
510: {
511: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
512: ULONG dstreg = (opcode & 3584) >> 9;
513: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
514: WORD src = get_word(srca);
515: { WORD dst = regs.d[dstreg];
516: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
517: regs.v = regs.c = 0;
518: regs.z = ((LONG)(newv)) == 0;
519: regs.n = ((LONG)(newv)) < 0;
520: regs.d[dstreg] = (newv);
521: }}}}}
522: void op_c0f0(UWORD opcode)
523: {
524: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
525: ULONG dstreg = (opcode & 3584) >> 9;
526: {{ CPTR srca = regs.a[srcreg];
527: UWORD srcdp = nextiword();
528: srca += (LONG)(BYTE)(srcdp & 0xFF);
529: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
530: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
531: srca += srcdpr;
532: { WORD src = get_word(srca);
533: { WORD dst = regs.d[dstreg];
534: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
535: regs.v = regs.c = 0;
536: regs.z = ((LONG)(newv)) == 0;
537: regs.n = ((LONG)(newv)) < 0;
538: regs.d[dstreg] = (newv);
539: }}}}}}}
540: void op_c0f8(UWORD opcode)
541: {
542: ULONG dstreg = (opcode & 3584) >> 9;
543: {{ CPTR srca = (LONG)(WORD)nextiword();
544: WORD src = get_word(srca);
545: { WORD dst = regs.d[dstreg];
546: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
547: regs.v = regs.c = 0;
548: regs.z = ((LONG)(newv)) == 0;
549: regs.n = ((LONG)(newv)) < 0;
550: regs.d[dstreg] = (newv);
551: }}}}}
552: void op_c0f9(UWORD opcode)
553: {
554: ULONG dstreg = (opcode & 3584) >> 9;
555: {{ CPTR srca = nextilong();
556: WORD src = get_word(srca);
557: { WORD dst = regs.d[dstreg];
558: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
559: regs.v = regs.c = 0;
560: regs.z = ((LONG)(newv)) == 0;
561: regs.n = ((LONG)(newv)) < 0;
562: regs.d[dstreg] = (newv);
563: }}}}}
564: void op_c0fa(UWORD opcode)
565: {
566: ULONG dstreg = (opcode & 3584) >> 9;
567: {{ CPTR srca = m68k_getpc();
568: srca += (LONG)(WORD)nextiword();
569: { WORD src = get_word(srca);
570: { WORD dst = regs.d[dstreg];
571: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
572: regs.v = regs.c = 0;
573: regs.z = ((LONG)(newv)) == 0;
574: regs.n = ((LONG)(newv)) < 0;
575: regs.d[dstreg] = (newv);
576: }}}}}}
577: void op_c0fb(UWORD opcode)
578: {
579: ULONG dstreg = (opcode & 3584) >> 9;
580: {{ CPTR srca = m68k_getpc();
581: UWORD srcdp = nextiword();
582: srca += (LONG)(BYTE)(srcdp & 0xFF);
583: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
584: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
585: srca += srcdpr;
586: { WORD src = get_word(srca);
587: { WORD dst = regs.d[dstreg];
588: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
589: regs.v = regs.c = 0;
590: regs.z = ((LONG)(newv)) == 0;
591: regs.n = ((LONG)(newv)) < 0;
592: regs.d[dstreg] = (newv);
593: }}}}}}}
594: void op_c0fc(UWORD opcode)
595: {
596: ULONG dstreg = (opcode & 3584) >> 9;
597: {{ WORD src = nextiword();
598: { WORD dst = regs.d[dstreg];
599: { ULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;
600: regs.v = regs.c = 0;
601: regs.z = ((LONG)(newv)) == 0;
602: regs.n = ((LONG)(newv)) < 0;
603: regs.d[dstreg] = (newv);
604: }}}}}
605: void op_c100(UWORD opcode)
606: {
607: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
608: ULONG dstreg = (opcode & 3584) >> 9;
609: {{ BYTE src = regs.d[srcreg];
610: { BYTE dst = regs.d[dstreg];
611: { UWORD newv = src + dst + regs.x;
612: if ((newv & 0xF) > 9) newv+=6;
613: regs.c = regs.x = (newv & 0x1F0) > 0x90;
614: if (regs.c) newv += 0x60;
615: if (newv != 0) regs.z = 0;
616: regs.d[dstreg] &= ~0xff; regs.d[dstreg] |= (newv) & 0xff;
617: }}}}}
618: void op_c108(UWORD opcode)
619: {
620: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
621: ULONG dstreg = (opcode & 3584) >> 9;
622: {{ regs.a[srcreg] -= (srcreg == 7) ? 2 : 1;
623: { CPTR srca = regs.a[srcreg];
624: BYTE src = get_byte(srca);
625: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
626: { CPTR dsta = regs.a[dstreg];
627: BYTE dst = get_byte(dsta);
628: { UWORD newv = src + dst + regs.x;
629: if ((newv & 0xF) > 9) newv+=6;
630: regs.c = regs.x = (newv & 0x1F0) > 0x90;
631: if (regs.c) newv += 0x60;
632: if (newv != 0) regs.z = 0;
633: put_byte(dsta,newv);
634: }}}}}}}
635: void op_c110(UWORD opcode)
636: {
637: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
638: ULONG dstreg = (opcode & 7) >> 0;
639: {{ BYTE src = regs.d[srcreg];
640: { CPTR dsta = regs.a[dstreg];
641: BYTE dst = get_byte(dsta);
642: src &= dst;
643: regs.v = regs.c = 0;
644: regs.z = ((BYTE)(src)) == 0;
645: regs.n = ((BYTE)(src)) < 0;
646: put_byte(dsta,src);
647: }}}}
648: void op_c118(UWORD opcode)
649: {
650: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
651: ULONG dstreg = (opcode & 7) >> 0;
652: {{ BYTE src = regs.d[srcreg];
653: { CPTR dsta = regs.a[dstreg];
654: BYTE dst = get_byte(dsta);
655: { regs.a[dstreg] += (dstreg == 7) ? 2 : 1;
656: src &= dst;
657: regs.v = regs.c = 0;
658: regs.z = ((BYTE)(src)) == 0;
659: regs.n = ((BYTE)(src)) < 0;
660: put_byte(dsta,src);
661: }}}}}
662: void op_c120(UWORD opcode)
663: {
664: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
665: ULONG dstreg = (opcode & 7) >> 0;
666: {{ BYTE src = regs.d[srcreg];
667: { regs.a[dstreg] -= (dstreg == 7) ? 2 : 1;
668: { CPTR dsta = regs.a[dstreg];
669: BYTE dst = get_byte(dsta);
670: src &= dst;
671: regs.v = regs.c = 0;
672: regs.z = ((BYTE)(src)) == 0;
673: regs.n = ((BYTE)(src)) < 0;
674: put_byte(dsta,src);
675: }}}}}
676: void op_c128(UWORD opcode)
677: {
678: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
679: ULONG dstreg = (opcode & 7) >> 0;
680: {{ BYTE src = regs.d[srcreg];
681: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
682: BYTE dst = get_byte(dsta);
683: src &= dst;
684: regs.v = regs.c = 0;
685: regs.z = ((BYTE)(src)) == 0;
686: regs.n = ((BYTE)(src)) < 0;
687: put_byte(dsta,src);
688: }}}}
689: void op_c130(UWORD opcode)
690: {
691: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
692: ULONG dstreg = (opcode & 7) >> 0;
693: {{ BYTE src = regs.d[srcreg];
694: { CPTR dsta = regs.a[dstreg];
695: UWORD dstdp = nextiword();
696: dsta += (LONG)(BYTE)(dstdp & 0xFF);
697: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
698: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
699: dsta += dstdpr;
700: { BYTE dst = get_byte(dsta);
701: src &= dst;
702: regs.v = regs.c = 0;
703: regs.z = ((BYTE)(src)) == 0;
704: regs.n = ((BYTE)(src)) < 0;
705: put_byte(dsta,src);
706: }}}}}}
707: void op_c138(UWORD opcode)
708: {
709: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
710: {{ BYTE src = regs.d[srcreg];
711: { CPTR dsta = (LONG)(WORD)nextiword();
712: BYTE dst = get_byte(dsta);
713: src &= dst;
714: regs.v = regs.c = 0;
715: regs.z = ((BYTE)(src)) == 0;
716: regs.n = ((BYTE)(src)) < 0;
717: put_byte(dsta,src);
718: }}}}
719: void op_c139(UWORD opcode)
720: {
721: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
722: {{ BYTE src = regs.d[srcreg];
723: { CPTR dsta = nextilong();
724: BYTE dst = get_byte(dsta);
725: src &= dst;
726: regs.v = regs.c = 0;
727: regs.z = ((BYTE)(src)) == 0;
728: regs.n = ((BYTE)(src)) < 0;
729: put_byte(dsta,src);
730: }}}}
731: void op_c140(UWORD opcode)
732: {
733: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
734: ULONG dstreg = (opcode & 7) >> 0;
735: {{ LONG src = regs.d[srcreg];
736: { LONG dst = regs.d[dstreg];
737: regs.d[srcreg] = (dst);
738: regs.d[dstreg] = (src);
739: }}}}
740: void op_c148(UWORD opcode)
741: {
742: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
743: ULONG dstreg = (opcode & 7) >> 0;
744: {{ LONG src = regs.a[srcreg];
745: { LONG dst = regs.a[dstreg];
746: regs.a[srcreg] = (dst);
747: regs.a[dstreg] = (src);
748: }}}}
749: void op_c150(UWORD opcode)
750: {
751: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
752: ULONG dstreg = (opcode & 7) >> 0;
753: {{ WORD src = regs.d[srcreg];
754: { CPTR dsta = regs.a[dstreg];
755: WORD dst = get_word(dsta);
756: src &= dst;
757: regs.v = regs.c = 0;
758: regs.z = ((WORD)(src)) == 0;
759: regs.n = ((WORD)(src)) < 0;
760: put_word(dsta,src);
761: }}}}
762: void op_c158(UWORD opcode)
763: {
764: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
765: ULONG dstreg = (opcode & 7) >> 0;
766: {{ WORD src = regs.d[srcreg];
767: { CPTR dsta = regs.a[dstreg];
768: WORD dst = get_word(dsta);
769: { regs.a[dstreg] += 2;
770: src &= dst;
771: regs.v = regs.c = 0;
772: regs.z = ((WORD)(src)) == 0;
773: regs.n = ((WORD)(src)) < 0;
774: put_word(dsta,src);
775: }}}}}
776: void op_c160(UWORD opcode)
777: {
778: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
779: ULONG dstreg = (opcode & 7) >> 0;
780: {{ WORD src = regs.d[srcreg];
781: { regs.a[dstreg] -= 2;
782: { CPTR dsta = regs.a[dstreg];
783: WORD dst = get_word(dsta);
784: src &= dst;
785: regs.v = regs.c = 0;
786: regs.z = ((WORD)(src)) == 0;
787: regs.n = ((WORD)(src)) < 0;
788: put_word(dsta,src);
789: }}}}}
790: void op_c168(UWORD opcode)
791: {
792: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
793: ULONG dstreg = (opcode & 7) >> 0;
794: {{ WORD src = regs.d[srcreg];
795: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
796: WORD dst = get_word(dsta);
797: src &= dst;
798: regs.v = regs.c = 0;
799: regs.z = ((WORD)(src)) == 0;
800: regs.n = ((WORD)(src)) < 0;
801: put_word(dsta,src);
802: }}}}
803: void op_c170(UWORD opcode)
804: {
805: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
806: ULONG dstreg = (opcode & 7) >> 0;
807: {{ WORD src = regs.d[srcreg];
808: { CPTR dsta = regs.a[dstreg];
809: UWORD dstdp = nextiword();
810: dsta += (LONG)(BYTE)(dstdp & 0xFF);
811: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
812: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
813: dsta += dstdpr;
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_c178(UWORD opcode)
822: {
823: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
824: {{ WORD src = regs.d[srcreg];
825: { CPTR dsta = (LONG)(WORD)nextiword();
826: WORD dst = get_word(dsta);
827: src &= dst;
828: regs.v = regs.c = 0;
829: regs.z = ((WORD)(src)) == 0;
830: regs.n = ((WORD)(src)) < 0;
831: put_word(dsta,src);
832: }}}}
833: void op_c179(UWORD opcode)
834: {
835: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
836: {{ WORD src = regs.d[srcreg];
837: { CPTR dsta = nextilong();
838: WORD dst = get_word(dsta);
839: src &= dst;
840: regs.v = regs.c = 0;
841: regs.z = ((WORD)(src)) == 0;
842: regs.n = ((WORD)(src)) < 0;
843: put_word(dsta,src);
844: }}}}
845: void op_c188(UWORD opcode)
846: {
847: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
848: ULONG dstreg = (opcode & 7) >> 0;
849: {{ LONG src = regs.d[srcreg];
850: { LONG dst = regs.a[dstreg];
851: regs.d[srcreg] = (dst);
852: regs.a[dstreg] = (src);
853: }}}}
854: void op_c190(UWORD opcode)
855: {
856: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
857: ULONG dstreg = (opcode & 7) >> 0;
858: {{ LONG src = regs.d[srcreg];
859: { CPTR dsta = regs.a[dstreg];
860: LONG dst = get_long(dsta);
861: src &= dst;
862: regs.v = regs.c = 0;
863: regs.z = ((LONG)(src)) == 0;
864: regs.n = ((LONG)(src)) < 0;
865: put_long(dsta,src);
866: }}}}
867: void op_c198(UWORD opcode)
868: {
869: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
870: ULONG dstreg = (opcode & 7) >> 0;
871: {{ LONG src = regs.d[srcreg];
872: { CPTR dsta = regs.a[dstreg];
873: LONG dst = get_long(dsta);
874: { regs.a[dstreg] += 4;
875: src &= dst;
876: regs.v = regs.c = 0;
877: regs.z = ((LONG)(src)) == 0;
878: regs.n = ((LONG)(src)) < 0;
879: put_long(dsta,src);
880: }}}}}
881: void op_c1a0(UWORD opcode)
882: {
883: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
884: ULONG dstreg = (opcode & 7) >> 0;
885: {{ LONG src = regs.d[srcreg];
886: { regs.a[dstreg] -= 4;
887: { CPTR dsta = regs.a[dstreg];
888: LONG dst = get_long(dsta);
889: src &= dst;
890: regs.v = regs.c = 0;
891: regs.z = ((LONG)(src)) == 0;
892: regs.n = ((LONG)(src)) < 0;
893: put_long(dsta,src);
894: }}}}}
895: void op_c1a8(UWORD opcode)
896: {
897: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
898: ULONG dstreg = (opcode & 7) >> 0;
899: {{ LONG src = regs.d[srcreg];
900: { CPTR dsta = regs.a[dstreg] + (LONG)(WORD)nextiword();
901: LONG dst = get_long(dsta);
902: src &= dst;
903: regs.v = regs.c = 0;
904: regs.z = ((LONG)(src)) == 0;
905: regs.n = ((LONG)(src)) < 0;
906: put_long(dsta,src);
907: }}}}
908: void op_c1b0(UWORD opcode)
909: {
910: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
911: ULONG dstreg = (opcode & 7) >> 0;
912: {{ LONG src = regs.d[srcreg];
913: { CPTR dsta = regs.a[dstreg];
914: UWORD dstdp = nextiword();
915: dsta += (LONG)(BYTE)(dstdp & 0xFF);
916: { ULONG dstdpr = dstdp & 0x8000 ? regs.a[(dstdp & 0x7000) >> 12] : regs.d[(dstdp & 0x7000) >> 12];
917: if (!(dstdp & 0x800)) dstdpr = (LONG)(WORD)dstdpr;
918: dsta += dstdpr;
919: { LONG dst = get_long(dsta);
920: src &= dst;
921: regs.v = regs.c = 0;
922: regs.z = ((LONG)(src)) == 0;
923: regs.n = ((LONG)(src)) < 0;
924: put_long(dsta,src);
925: }}}}}}
926: void op_c1b8(UWORD opcode)
927: {
928: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
929: {{ LONG src = regs.d[srcreg];
930: { CPTR dsta = (LONG)(WORD)nextiword();
931: LONG dst = get_long(dsta);
932: src &= dst;
933: regs.v = regs.c = 0;
934: regs.z = ((LONG)(src)) == 0;
935: regs.n = ((LONG)(src)) < 0;
936: put_long(dsta,src);
937: }}}}
938: void op_c1b9(UWORD opcode)
939: {
940: ULONG srcreg = (LONG)(BYTE)((opcode & 3584) >> 9);
941: {{ LONG src = regs.d[srcreg];
942: { CPTR dsta = nextilong();
943: LONG dst = get_long(dsta);
944: src &= dst;
945: regs.v = regs.c = 0;
946: regs.z = ((LONG)(src)) == 0;
947: regs.n = ((LONG)(src)) < 0;
948: put_long(dsta,src);
949: }}}}
950: void op_c1c0(UWORD opcode)
951: {
952: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
953: ULONG dstreg = (opcode & 3584) >> 9;
954: {{ WORD src = regs.d[srcreg];
955: { WORD dst = regs.d[dstreg];
956: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
957: regs.v = regs.c = 0;
958: regs.z = ((LONG)(newv)) == 0;
959: regs.n = ((LONG)(newv)) < 0;
960: regs.d[dstreg] = (newv);
961: }}}}}
962: void op_c1d0(UWORD opcode)
963: {
964: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
965: ULONG dstreg = (opcode & 3584) >> 9;
966: {{ CPTR srca = regs.a[srcreg];
967: WORD src = get_word(srca);
968: { WORD dst = regs.d[dstreg];
969: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
970: regs.v = regs.c = 0;
971: regs.z = ((LONG)(newv)) == 0;
972: regs.n = ((LONG)(newv)) < 0;
973: regs.d[dstreg] = (newv);
974: }}}}}
975: void op_c1d8(UWORD opcode)
976: {
977: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
978: ULONG dstreg = (opcode & 3584) >> 9;
979: {{ CPTR srca = regs.a[srcreg];
980: WORD src = get_word(srca);
981: { regs.a[srcreg] += 2;
982: { WORD dst = regs.d[dstreg];
983: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
984: regs.v = regs.c = 0;
985: regs.z = ((LONG)(newv)) == 0;
986: regs.n = ((LONG)(newv)) < 0;
987: regs.d[dstreg] = (newv);
988: }}}}}}
989: void op_c1e0(UWORD opcode)
990: {
991: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
992: ULONG dstreg = (opcode & 3584) >> 9;
993: {{ regs.a[srcreg] -= 2;
994: { CPTR srca = regs.a[srcreg];
995: WORD src = get_word(srca);
996: { WORD dst = regs.d[dstreg];
997: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
998: regs.v = regs.c = 0;
999: regs.z = ((LONG)(newv)) == 0;
1000: regs.n = ((LONG)(newv)) < 0;
1001: regs.d[dstreg] = (newv);
1002: }}}}}}
1003: void op_c1e8(UWORD opcode)
1004: {
1005: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1006: ULONG dstreg = (opcode & 3584) >> 9;
1007: {{ CPTR srca = regs.a[srcreg] + (LONG)(WORD)nextiword();
1008: WORD src = get_word(srca);
1009: { WORD dst = regs.d[dstreg];
1010: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
1011: regs.v = regs.c = 0;
1012: regs.z = ((LONG)(newv)) == 0;
1013: regs.n = ((LONG)(newv)) < 0;
1014: regs.d[dstreg] = (newv);
1015: }}}}}
1016: void op_c1f0(UWORD opcode)
1017: {
1018: ULONG srcreg = (LONG)(BYTE)((opcode & 7) >> 0);
1019: ULONG dstreg = (opcode & 3584) >> 9;
1020: {{ CPTR srca = regs.a[srcreg];
1021: UWORD srcdp = nextiword();
1022: srca += (LONG)(BYTE)(srcdp & 0xFF);
1023: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1024: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1025: srca += srcdpr;
1026: { WORD src = get_word(srca);
1027: { WORD dst = regs.d[dstreg];
1028: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
1029: regs.v = regs.c = 0;
1030: regs.z = ((LONG)(newv)) == 0;
1031: regs.n = ((LONG)(newv)) < 0;
1032: regs.d[dstreg] = (newv);
1033: }}}}}}}
1034: void op_c1f8(UWORD opcode)
1035: {
1036: ULONG dstreg = (opcode & 3584) >> 9;
1037: {{ CPTR srca = (LONG)(WORD)nextiword();
1038: WORD src = get_word(srca);
1039: { WORD dst = regs.d[dstreg];
1040: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
1041: regs.v = regs.c = 0;
1042: regs.z = ((LONG)(newv)) == 0;
1043: regs.n = ((LONG)(newv)) < 0;
1044: regs.d[dstreg] = (newv);
1045: }}}}}
1046: void op_c1f9(UWORD opcode)
1047: {
1048: ULONG dstreg = (opcode & 3584) >> 9;
1049: {{ CPTR srca = nextilong();
1050: WORD src = get_word(srca);
1051: { WORD dst = regs.d[dstreg];
1052: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
1053: regs.v = regs.c = 0;
1054: regs.z = ((LONG)(newv)) == 0;
1055: regs.n = ((LONG)(newv)) < 0;
1056: regs.d[dstreg] = (newv);
1057: }}}}}
1058: void op_c1fa(UWORD opcode)
1059: {
1060: ULONG dstreg = (opcode & 3584) >> 9;
1061: {{ CPTR srca = m68k_getpc();
1062: srca += (LONG)(WORD)nextiword();
1063: { WORD src = get_word(srca);
1064: { WORD dst = regs.d[dstreg];
1065: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
1066: regs.v = regs.c = 0;
1067: regs.z = ((LONG)(newv)) == 0;
1068: regs.n = ((LONG)(newv)) < 0;
1069: regs.d[dstreg] = (newv);
1070: }}}}}}
1071: void op_c1fb(UWORD opcode)
1072: {
1073: ULONG dstreg = (opcode & 3584) >> 9;
1074: {{ CPTR srca = m68k_getpc();
1075: UWORD srcdp = nextiword();
1076: srca += (LONG)(BYTE)(srcdp & 0xFF);
1077: { ULONG srcdpr = srcdp & 0x8000 ? regs.a[(srcdp & 0x7000) >> 12] : regs.d[(srcdp & 0x7000) >> 12];
1078: if (!(srcdp & 0x800)) srcdpr = (LONG)(WORD)srcdpr;
1079: srca += srcdpr;
1080: { WORD src = get_word(srca);
1081: { WORD dst = regs.d[dstreg];
1082: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
1083: regs.v = regs.c = 0;
1084: regs.z = ((LONG)(newv)) == 0;
1085: regs.n = ((LONG)(newv)) < 0;
1086: regs.d[dstreg] = (newv);
1087: }}}}}}}
1088: void op_c1fc(UWORD opcode)
1089: {
1090: ULONG dstreg = (opcode & 3584) >> 9;
1091: {{ WORD src = nextiword();
1092: { WORD dst = regs.d[dstreg];
1093: { ULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;
1094: regs.v = regs.c = 0;
1095: regs.z = ((LONG)(newv)) == 0;
1096: regs.n = ((LONG)(newv)) < 0;
1097: regs.d[dstreg] = (newv);
1098: }}}}}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.