1 #include "m68kcpu.h"
2
3 /* ======================================================================== */
4 /* ========================= INSTRUCTION HANDLERS ========================= */
5 /* ======================================================================== */
6
7
m68k_op_1010(void)8 void m68k_op_1010(void)
9 {
10 m68ki_exception_1010();
11 }
12
13
m68k_op_1111(void)14 void m68k_op_1111(void)
15 {
16 m68ki_exception_1111();
17 }
18
19
m68k_op_abcd_8_rr(void)20 void m68k_op_abcd_8_rr(void)
21 {
22 uint* r_dst = &DX;
23 uint src = DY;
24 uint dst = *r_dst;
25 uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
26
27 FLAG_V = ~res; /* Undefined V behavior */
28
29 if(res > 9)
30 res += 6;
31 res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
32 FLAG_X = FLAG_C = (res > 0x99) << 8;
33 if(FLAG_C)
34 res -= 0xa0;
35
36 FLAG_V &= res; /* Undefined V behavior part II */
37 FLAG_N = NFLAG_8(res); /* Undefined N behavior */
38
39 res = MASK_OUT_ABOVE_8(res);
40 FLAG_Z |= res;
41
42 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
43 }
44
45
m68k_op_abcd_8_mm_ax7(void)46 void m68k_op_abcd_8_mm_ax7(void)
47 {
48 uint src = OPER_AY_PD_8();
49 uint ea = EA_A7_PD_8();
50 uint dst = m68ki_read_8(ea);
51 uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
52
53 FLAG_V = ~res; /* Undefined V behavior */
54
55 if(res > 9)
56 res += 6;
57 res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
58 FLAG_X = FLAG_C = (res > 0x99) << 8;
59 if(FLAG_C)
60 res -= 0xa0;
61
62 FLAG_V &= res; /* Undefined V behavior part II */
63 FLAG_N = NFLAG_8(res); /* Undefined N behavior */
64
65 res = MASK_OUT_ABOVE_8(res);
66 FLAG_Z |= res;
67
68 m68ki_write_8(ea, res);
69 }
70
71
m68k_op_abcd_8_mm_ay7(void)72 void m68k_op_abcd_8_mm_ay7(void)
73 {
74 uint src = OPER_A7_PD_8();
75 uint ea = EA_AX_PD_8();
76 uint dst = m68ki_read_8(ea);
77 uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
78
79 FLAG_V = ~res; /* Undefined V behavior */
80
81 if(res > 9)
82 res += 6;
83 res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
84 FLAG_X = FLAG_C = (res > 0x99) << 8;
85 if(FLAG_C)
86 res -= 0xa0;
87
88 FLAG_V &= res; /* Undefined V behavior part II */
89 FLAG_N = NFLAG_8(res); /* Undefined N behavior */
90
91 res = MASK_OUT_ABOVE_8(res);
92 FLAG_Z |= res;
93
94 m68ki_write_8(ea, res);
95 }
96
97
m68k_op_abcd_8_mm_axy7(void)98 void m68k_op_abcd_8_mm_axy7(void)
99 {
100 uint src = OPER_A7_PD_8();
101 uint ea = EA_A7_PD_8();
102 uint dst = m68ki_read_8(ea);
103 uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
104
105 FLAG_V = ~res; /* Undefined V behavior */
106
107 if(res > 9)
108 res += 6;
109 res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
110 FLAG_X = FLAG_C = (res > 0x99) << 8;
111 if(FLAG_C)
112 res -= 0xa0;
113
114 FLAG_V &= res; /* Undefined V behavior part II */
115 FLAG_N = NFLAG_8(res); /* Undefined N behavior */
116
117 res = MASK_OUT_ABOVE_8(res);
118 FLAG_Z |= res;
119
120 m68ki_write_8(ea, res);
121 }
122
123
m68k_op_abcd_8_mm(void)124 void m68k_op_abcd_8_mm(void)
125 {
126 uint src = OPER_AY_PD_8();
127 uint ea = EA_AX_PD_8();
128 uint dst = m68ki_read_8(ea);
129 uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
130
131 FLAG_V = ~res; /* Undefined V behavior */
132
133 if(res > 9)
134 res += 6;
135 res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
136 FLAG_X = FLAG_C = (res > 0x99) << 8;
137 if(FLAG_C)
138 res -= 0xa0;
139
140 FLAG_V &= res; /* Undefined V behavior part II */
141 FLAG_N = NFLAG_8(res); /* Undefined N behavior */
142
143 res = MASK_OUT_ABOVE_8(res);
144 FLAG_Z |= res;
145
146 m68ki_write_8(ea, res);
147 }
148
149
m68k_op_add_8_er_d(void)150 void m68k_op_add_8_er_d(void)
151 {
152 uint* r_dst = &DX;
153 uint src = MASK_OUT_ABOVE_8(DY);
154 uint dst = MASK_OUT_ABOVE_8(*r_dst);
155 uint res = src + dst;
156
157 FLAG_N = NFLAG_8(res);
158 FLAG_V = VFLAG_ADD_8(src, dst, res);
159 FLAG_X = FLAG_C = CFLAG_8(res);
160 FLAG_Z = MASK_OUT_ABOVE_8(res);
161
162 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
163 }
164
165
m68k_op_add_8_er_ai(void)166 void m68k_op_add_8_er_ai(void)
167 {
168 uint* r_dst = &DX;
169 uint src = OPER_AY_AI_8();
170 uint dst = MASK_OUT_ABOVE_8(*r_dst);
171 uint res = src + dst;
172
173 FLAG_N = NFLAG_8(res);
174 FLAG_V = VFLAG_ADD_8(src, dst, res);
175 FLAG_X = FLAG_C = CFLAG_8(res);
176 FLAG_Z = MASK_OUT_ABOVE_8(res);
177
178 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
179 }
180
181
m68k_op_add_8_er_pi(void)182 void m68k_op_add_8_er_pi(void)
183 {
184 uint* r_dst = &DX;
185 uint src = OPER_AY_PI_8();
186 uint dst = MASK_OUT_ABOVE_8(*r_dst);
187 uint res = src + dst;
188
189 FLAG_N = NFLAG_8(res);
190 FLAG_V = VFLAG_ADD_8(src, dst, res);
191 FLAG_X = FLAG_C = CFLAG_8(res);
192 FLAG_Z = MASK_OUT_ABOVE_8(res);
193
194 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
195 }
196
197
m68k_op_add_8_er_pi7(void)198 void m68k_op_add_8_er_pi7(void)
199 {
200 uint* r_dst = &DX;
201 uint src = OPER_A7_PI_8();
202 uint dst = MASK_OUT_ABOVE_8(*r_dst);
203 uint res = src + dst;
204
205 FLAG_N = NFLAG_8(res);
206 FLAG_V = VFLAG_ADD_8(src, dst, res);
207 FLAG_X = FLAG_C = CFLAG_8(res);
208 FLAG_Z = MASK_OUT_ABOVE_8(res);
209
210 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
211 }
212
213
m68k_op_add_8_er_pd(void)214 void m68k_op_add_8_er_pd(void)
215 {
216 uint* r_dst = &DX;
217 uint src = OPER_AY_PD_8();
218 uint dst = MASK_OUT_ABOVE_8(*r_dst);
219 uint res = src + dst;
220
221 FLAG_N = NFLAG_8(res);
222 FLAG_V = VFLAG_ADD_8(src, dst, res);
223 FLAG_X = FLAG_C = CFLAG_8(res);
224 FLAG_Z = MASK_OUT_ABOVE_8(res);
225
226 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
227 }
228
229
m68k_op_add_8_er_pd7(void)230 void m68k_op_add_8_er_pd7(void)
231 {
232 uint* r_dst = &DX;
233 uint src = OPER_A7_PD_8();
234 uint dst = MASK_OUT_ABOVE_8(*r_dst);
235 uint res = src + dst;
236
237 FLAG_N = NFLAG_8(res);
238 FLAG_V = VFLAG_ADD_8(src, dst, res);
239 FLAG_X = FLAG_C = CFLAG_8(res);
240 FLAG_Z = MASK_OUT_ABOVE_8(res);
241
242 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
243 }
244
245
m68k_op_add_8_er_di(void)246 void m68k_op_add_8_er_di(void)
247 {
248 uint* r_dst = &DX;
249 uint src = OPER_AY_DI_8();
250 uint dst = MASK_OUT_ABOVE_8(*r_dst);
251 uint res = src + dst;
252
253 FLAG_N = NFLAG_8(res);
254 FLAG_V = VFLAG_ADD_8(src, dst, res);
255 FLAG_X = FLAG_C = CFLAG_8(res);
256 FLAG_Z = MASK_OUT_ABOVE_8(res);
257
258 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
259 }
260
261
m68k_op_add_8_er_ix(void)262 void m68k_op_add_8_er_ix(void)
263 {
264 uint* r_dst = &DX;
265 uint src = OPER_AY_IX_8();
266 uint dst = MASK_OUT_ABOVE_8(*r_dst);
267 uint res = src + dst;
268
269 FLAG_N = NFLAG_8(res);
270 FLAG_V = VFLAG_ADD_8(src, dst, res);
271 FLAG_X = FLAG_C = CFLAG_8(res);
272 FLAG_Z = MASK_OUT_ABOVE_8(res);
273
274 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
275 }
276
277
m68k_op_add_8_er_aw(void)278 void m68k_op_add_8_er_aw(void)
279 {
280 uint* r_dst = &DX;
281 uint src = OPER_AW_8();
282 uint dst = MASK_OUT_ABOVE_8(*r_dst);
283 uint res = src + dst;
284
285 FLAG_N = NFLAG_8(res);
286 FLAG_V = VFLAG_ADD_8(src, dst, res);
287 FLAG_X = FLAG_C = CFLAG_8(res);
288 FLAG_Z = MASK_OUT_ABOVE_8(res);
289
290 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
291 }
292
293
m68k_op_add_8_er_al(void)294 void m68k_op_add_8_er_al(void)
295 {
296 uint* r_dst = &DX;
297 uint src = OPER_AL_8();
298 uint dst = MASK_OUT_ABOVE_8(*r_dst);
299 uint res = src + dst;
300
301 FLAG_N = NFLAG_8(res);
302 FLAG_V = VFLAG_ADD_8(src, dst, res);
303 FLAG_X = FLAG_C = CFLAG_8(res);
304 FLAG_Z = MASK_OUT_ABOVE_8(res);
305
306 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
307 }
308
309
m68k_op_add_8_er_pcdi(void)310 void m68k_op_add_8_er_pcdi(void)
311 {
312 uint* r_dst = &DX;
313 uint src = OPER_PCDI_8();
314 uint dst = MASK_OUT_ABOVE_8(*r_dst);
315 uint res = src + dst;
316
317 FLAG_N = NFLAG_8(res);
318 FLAG_V = VFLAG_ADD_8(src, dst, res);
319 FLAG_X = FLAG_C = CFLAG_8(res);
320 FLAG_Z = MASK_OUT_ABOVE_8(res);
321
322 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
323 }
324
325
m68k_op_add_8_er_pcix(void)326 void m68k_op_add_8_er_pcix(void)
327 {
328 uint* r_dst = &DX;
329 uint src = OPER_PCIX_8();
330 uint dst = MASK_OUT_ABOVE_8(*r_dst);
331 uint res = src + dst;
332
333 FLAG_N = NFLAG_8(res);
334 FLAG_V = VFLAG_ADD_8(src, dst, res);
335 FLAG_X = FLAG_C = CFLAG_8(res);
336 FLAG_Z = MASK_OUT_ABOVE_8(res);
337
338 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
339 }
340
341
m68k_op_add_8_er_i(void)342 void m68k_op_add_8_er_i(void)
343 {
344 uint* r_dst = &DX;
345 uint src = OPER_I_8();
346 uint dst = MASK_OUT_ABOVE_8(*r_dst);
347 uint res = src + dst;
348
349 FLAG_N = NFLAG_8(res);
350 FLAG_V = VFLAG_ADD_8(src, dst, res);
351 FLAG_X = FLAG_C = CFLAG_8(res);
352 FLAG_Z = MASK_OUT_ABOVE_8(res);
353
354 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
355 }
356
357
m68k_op_add_16_er_d(void)358 void m68k_op_add_16_er_d(void)
359 {
360 uint* r_dst = &DX;
361 uint src = MASK_OUT_ABOVE_16(DY);
362 uint dst = MASK_OUT_ABOVE_16(*r_dst);
363 uint res = src + dst;
364
365 FLAG_N = NFLAG_16(res);
366 FLAG_V = VFLAG_ADD_16(src, dst, res);
367 FLAG_X = FLAG_C = CFLAG_16(res);
368 FLAG_Z = MASK_OUT_ABOVE_16(res);
369
370 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
371 }
372
373
m68k_op_add_16_er_a(void)374 void m68k_op_add_16_er_a(void)
375 {
376 uint* r_dst = &DX;
377 uint src = MASK_OUT_ABOVE_16(AY);
378 uint dst = MASK_OUT_ABOVE_16(*r_dst);
379 uint res = src + dst;
380
381 FLAG_N = NFLAG_16(res);
382 FLAG_V = VFLAG_ADD_16(src, dst, res);
383 FLAG_X = FLAG_C = CFLAG_16(res);
384 FLAG_Z = MASK_OUT_ABOVE_16(res);
385
386 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
387 }
388
389
m68k_op_add_16_er_ai(void)390 void m68k_op_add_16_er_ai(void)
391 {
392 uint* r_dst = &DX;
393 uint src = OPER_AY_AI_16();
394 uint dst = MASK_OUT_ABOVE_16(*r_dst);
395 uint res = src + dst;
396
397 FLAG_N = NFLAG_16(res);
398 FLAG_V = VFLAG_ADD_16(src, dst, res);
399 FLAG_X = FLAG_C = CFLAG_16(res);
400 FLAG_Z = MASK_OUT_ABOVE_16(res);
401
402 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
403 }
404
405
m68k_op_add_16_er_pi(void)406 void m68k_op_add_16_er_pi(void)
407 {
408 uint* r_dst = &DX;
409 uint src = OPER_AY_PI_16();
410 uint dst = MASK_OUT_ABOVE_16(*r_dst);
411 uint res = src + dst;
412
413 FLAG_N = NFLAG_16(res);
414 FLAG_V = VFLAG_ADD_16(src, dst, res);
415 FLAG_X = FLAG_C = CFLAG_16(res);
416 FLAG_Z = MASK_OUT_ABOVE_16(res);
417
418 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
419 }
420
421
m68k_op_add_16_er_pd(void)422 void m68k_op_add_16_er_pd(void)
423 {
424 uint* r_dst = &DX;
425 uint src = OPER_AY_PD_16();
426 uint dst = MASK_OUT_ABOVE_16(*r_dst);
427 uint res = src + dst;
428
429 FLAG_N = NFLAG_16(res);
430 FLAG_V = VFLAG_ADD_16(src, dst, res);
431 FLAG_X = FLAG_C = CFLAG_16(res);
432 FLAG_Z = MASK_OUT_ABOVE_16(res);
433
434 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
435 }
436
437
m68k_op_add_16_er_di(void)438 void m68k_op_add_16_er_di(void)
439 {
440 uint* r_dst = &DX;
441 uint src = OPER_AY_DI_16();
442 uint dst = MASK_OUT_ABOVE_16(*r_dst);
443 uint res = src + dst;
444
445 FLAG_N = NFLAG_16(res);
446 FLAG_V = VFLAG_ADD_16(src, dst, res);
447 FLAG_X = FLAG_C = CFLAG_16(res);
448 FLAG_Z = MASK_OUT_ABOVE_16(res);
449
450 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
451 }
452
453
m68k_op_add_16_er_ix(void)454 void m68k_op_add_16_er_ix(void)
455 {
456 uint* r_dst = &DX;
457 uint src = OPER_AY_IX_16();
458 uint dst = MASK_OUT_ABOVE_16(*r_dst);
459 uint res = src + dst;
460
461 FLAG_N = NFLAG_16(res);
462 FLAG_V = VFLAG_ADD_16(src, dst, res);
463 FLAG_X = FLAG_C = CFLAG_16(res);
464 FLAG_Z = MASK_OUT_ABOVE_16(res);
465
466 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
467 }
468
469
m68k_op_add_16_er_aw(void)470 void m68k_op_add_16_er_aw(void)
471 {
472 uint* r_dst = &DX;
473 uint src = OPER_AW_16();
474 uint dst = MASK_OUT_ABOVE_16(*r_dst);
475 uint res = src + dst;
476
477 FLAG_N = NFLAG_16(res);
478 FLAG_V = VFLAG_ADD_16(src, dst, res);
479 FLAG_X = FLAG_C = CFLAG_16(res);
480 FLAG_Z = MASK_OUT_ABOVE_16(res);
481
482 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
483 }
484
485
m68k_op_add_16_er_al(void)486 void m68k_op_add_16_er_al(void)
487 {
488 uint* r_dst = &DX;
489 uint src = OPER_AL_16();
490 uint dst = MASK_OUT_ABOVE_16(*r_dst);
491 uint res = src + dst;
492
493 FLAG_N = NFLAG_16(res);
494 FLAG_V = VFLAG_ADD_16(src, dst, res);
495 FLAG_X = FLAG_C = CFLAG_16(res);
496 FLAG_Z = MASK_OUT_ABOVE_16(res);
497
498 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
499 }
500
501
m68k_op_add_16_er_pcdi(void)502 void m68k_op_add_16_er_pcdi(void)
503 {
504 uint* r_dst = &DX;
505 uint src = OPER_PCDI_16();
506 uint dst = MASK_OUT_ABOVE_16(*r_dst);
507 uint res = src + dst;
508
509 FLAG_N = NFLAG_16(res);
510 FLAG_V = VFLAG_ADD_16(src, dst, res);
511 FLAG_X = FLAG_C = CFLAG_16(res);
512 FLAG_Z = MASK_OUT_ABOVE_16(res);
513
514 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
515 }
516
517
m68k_op_add_16_er_pcix(void)518 void m68k_op_add_16_er_pcix(void)
519 {
520 uint* r_dst = &DX;
521 uint src = OPER_PCIX_16();
522 uint dst = MASK_OUT_ABOVE_16(*r_dst);
523 uint res = src + dst;
524
525 FLAG_N = NFLAG_16(res);
526 FLAG_V = VFLAG_ADD_16(src, dst, res);
527 FLAG_X = FLAG_C = CFLAG_16(res);
528 FLAG_Z = MASK_OUT_ABOVE_16(res);
529
530 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
531 }
532
533
m68k_op_add_16_er_i(void)534 void m68k_op_add_16_er_i(void)
535 {
536 uint* r_dst = &DX;
537 uint src = OPER_I_16();
538 uint dst = MASK_OUT_ABOVE_16(*r_dst);
539 uint res = src + dst;
540
541 FLAG_N = NFLAG_16(res);
542 FLAG_V = VFLAG_ADD_16(src, dst, res);
543 FLAG_X = FLAG_C = CFLAG_16(res);
544 FLAG_Z = MASK_OUT_ABOVE_16(res);
545
546 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
547 }
548
549
m68k_op_add_32_er_d(void)550 void m68k_op_add_32_er_d(void)
551 {
552 uint* r_dst = &DX;
553 uint src = DY;
554 uint dst = *r_dst;
555 uint res = src + dst;
556
557 FLAG_N = NFLAG_32(res);
558 FLAG_V = VFLAG_ADD_32(src, dst, res);
559 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
560 FLAG_Z = MASK_OUT_ABOVE_32(res);
561
562 *r_dst = FLAG_Z;
563 }
564
565
m68k_op_add_32_er_a(void)566 void m68k_op_add_32_er_a(void)
567 {
568 uint* r_dst = &DX;
569 uint src = AY;
570 uint dst = *r_dst;
571 uint res = src + dst;
572
573 FLAG_N = NFLAG_32(res);
574 FLAG_V = VFLAG_ADD_32(src, dst, res);
575 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
576 FLAG_Z = MASK_OUT_ABOVE_32(res);
577
578 *r_dst = FLAG_Z;
579 }
580
581
m68k_op_add_32_er_ai(void)582 void m68k_op_add_32_er_ai(void)
583 {
584 uint* r_dst = &DX;
585 uint src = OPER_AY_AI_32();
586 uint dst = *r_dst;
587 uint res = src + dst;
588
589 FLAG_N = NFLAG_32(res);
590 FLAG_V = VFLAG_ADD_32(src, dst, res);
591 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
592 FLAG_Z = MASK_OUT_ABOVE_32(res);
593
594 *r_dst = FLAG_Z;
595 }
596
597
m68k_op_add_32_er_pi(void)598 void m68k_op_add_32_er_pi(void)
599 {
600 uint* r_dst = &DX;
601 uint src = OPER_AY_PI_32();
602 uint dst = *r_dst;
603 uint res = src + dst;
604
605 FLAG_N = NFLAG_32(res);
606 FLAG_V = VFLAG_ADD_32(src, dst, res);
607 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
608 FLAG_Z = MASK_OUT_ABOVE_32(res);
609
610 *r_dst = FLAG_Z;
611 }
612
613
m68k_op_add_32_er_pd(void)614 void m68k_op_add_32_er_pd(void)
615 {
616 uint* r_dst = &DX;
617 uint src = OPER_AY_PD_32();
618 uint dst = *r_dst;
619 uint res = src + dst;
620
621 FLAG_N = NFLAG_32(res);
622 FLAG_V = VFLAG_ADD_32(src, dst, res);
623 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
624 FLAG_Z = MASK_OUT_ABOVE_32(res);
625
626 *r_dst = FLAG_Z;
627 }
628
629
m68k_op_add_32_er_di(void)630 void m68k_op_add_32_er_di(void)
631 {
632 uint* r_dst = &DX;
633 uint src = OPER_AY_DI_32();
634 uint dst = *r_dst;
635 uint res = src + dst;
636
637 FLAG_N = NFLAG_32(res);
638 FLAG_V = VFLAG_ADD_32(src, dst, res);
639 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
640 FLAG_Z = MASK_OUT_ABOVE_32(res);
641
642 *r_dst = FLAG_Z;
643 }
644
645
m68k_op_add_32_er_ix(void)646 void m68k_op_add_32_er_ix(void)
647 {
648 uint* r_dst = &DX;
649 uint src = OPER_AY_IX_32();
650 uint dst = *r_dst;
651 uint res = src + dst;
652
653 FLAG_N = NFLAG_32(res);
654 FLAG_V = VFLAG_ADD_32(src, dst, res);
655 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
656 FLAG_Z = MASK_OUT_ABOVE_32(res);
657
658 *r_dst = FLAG_Z;
659 }
660
661
m68k_op_add_32_er_aw(void)662 void m68k_op_add_32_er_aw(void)
663 {
664 uint* r_dst = &DX;
665 uint src = OPER_AW_32();
666 uint dst = *r_dst;
667 uint res = src + dst;
668
669 FLAG_N = NFLAG_32(res);
670 FLAG_V = VFLAG_ADD_32(src, dst, res);
671 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
672 FLAG_Z = MASK_OUT_ABOVE_32(res);
673
674 *r_dst = FLAG_Z;
675 }
676
677
m68k_op_add_32_er_al(void)678 void m68k_op_add_32_er_al(void)
679 {
680 uint* r_dst = &DX;
681 uint src = OPER_AL_32();
682 uint dst = *r_dst;
683 uint res = src + dst;
684
685 FLAG_N = NFLAG_32(res);
686 FLAG_V = VFLAG_ADD_32(src, dst, res);
687 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
688 FLAG_Z = MASK_OUT_ABOVE_32(res);
689
690 *r_dst = FLAG_Z;
691 }
692
693
m68k_op_add_32_er_pcdi(void)694 void m68k_op_add_32_er_pcdi(void)
695 {
696 uint* r_dst = &DX;
697 uint src = OPER_PCDI_32();
698 uint dst = *r_dst;
699 uint res = src + dst;
700
701 FLAG_N = NFLAG_32(res);
702 FLAG_V = VFLAG_ADD_32(src, dst, res);
703 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
704 FLAG_Z = MASK_OUT_ABOVE_32(res);
705
706 *r_dst = FLAG_Z;
707 }
708
709
m68k_op_add_32_er_pcix(void)710 void m68k_op_add_32_er_pcix(void)
711 {
712 uint* r_dst = &DX;
713 uint src = OPER_PCIX_32();
714 uint dst = *r_dst;
715 uint res = src + dst;
716
717 FLAG_N = NFLAG_32(res);
718 FLAG_V = VFLAG_ADD_32(src, dst, res);
719 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
720 FLAG_Z = MASK_OUT_ABOVE_32(res);
721
722 *r_dst = FLAG_Z;
723 }
724
725
m68k_op_add_32_er_i(void)726 void m68k_op_add_32_er_i(void)
727 {
728 uint* r_dst = &DX;
729 uint src = OPER_I_32();
730 uint dst = *r_dst;
731 uint res = src + dst;
732
733 FLAG_N = NFLAG_32(res);
734 FLAG_V = VFLAG_ADD_32(src, dst, res);
735 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
736 FLAG_Z = MASK_OUT_ABOVE_32(res);
737
738 *r_dst = FLAG_Z;
739 }
740
741
m68k_op_add_8_re_ai(void)742 void m68k_op_add_8_re_ai(void)
743 {
744 uint ea = EA_AY_AI_8();
745 uint src = MASK_OUT_ABOVE_8(DX);
746 uint dst = m68ki_read_8(ea);
747 uint res = src + dst;
748
749 FLAG_N = NFLAG_8(res);
750 FLAG_V = VFLAG_ADD_8(src, dst, res);
751 FLAG_X = FLAG_C = CFLAG_8(res);
752 FLAG_Z = MASK_OUT_ABOVE_8(res);
753
754 m68ki_write_8(ea, FLAG_Z);
755 }
756
757
m68k_op_add_8_re_pi(void)758 void m68k_op_add_8_re_pi(void)
759 {
760 uint ea = EA_AY_PI_8();
761 uint src = MASK_OUT_ABOVE_8(DX);
762 uint dst = m68ki_read_8(ea);
763 uint res = src + dst;
764
765 FLAG_N = NFLAG_8(res);
766 FLAG_V = VFLAG_ADD_8(src, dst, res);
767 FLAG_X = FLAG_C = CFLAG_8(res);
768 FLAG_Z = MASK_OUT_ABOVE_8(res);
769
770 m68ki_write_8(ea, FLAG_Z);
771 }
772
773
m68k_op_add_8_re_pi7(void)774 void m68k_op_add_8_re_pi7(void)
775 {
776 uint ea = EA_A7_PI_8();
777 uint src = MASK_OUT_ABOVE_8(DX);
778 uint dst = m68ki_read_8(ea);
779 uint res = src + dst;
780
781 FLAG_N = NFLAG_8(res);
782 FLAG_V = VFLAG_ADD_8(src, dst, res);
783 FLAG_X = FLAG_C = CFLAG_8(res);
784 FLAG_Z = MASK_OUT_ABOVE_8(res);
785
786 m68ki_write_8(ea, FLAG_Z);
787 }
788
789
m68k_op_add_8_re_pd(void)790 void m68k_op_add_8_re_pd(void)
791 {
792 uint ea = EA_AY_PD_8();
793 uint src = MASK_OUT_ABOVE_8(DX);
794 uint dst = m68ki_read_8(ea);
795 uint res = src + dst;
796
797 FLAG_N = NFLAG_8(res);
798 FLAG_V = VFLAG_ADD_8(src, dst, res);
799 FLAG_X = FLAG_C = CFLAG_8(res);
800 FLAG_Z = MASK_OUT_ABOVE_8(res);
801
802 m68ki_write_8(ea, FLAG_Z);
803 }
804
805
m68k_op_add_8_re_pd7(void)806 void m68k_op_add_8_re_pd7(void)
807 {
808 uint ea = EA_A7_PD_8();
809 uint src = MASK_OUT_ABOVE_8(DX);
810 uint dst = m68ki_read_8(ea);
811 uint res = src + dst;
812
813 FLAG_N = NFLAG_8(res);
814 FLAG_V = VFLAG_ADD_8(src, dst, res);
815 FLAG_X = FLAG_C = CFLAG_8(res);
816 FLAG_Z = MASK_OUT_ABOVE_8(res);
817
818 m68ki_write_8(ea, FLAG_Z);
819 }
820
821
m68k_op_add_8_re_di(void)822 void m68k_op_add_8_re_di(void)
823 {
824 uint ea = EA_AY_DI_8();
825 uint src = MASK_OUT_ABOVE_8(DX);
826 uint dst = m68ki_read_8(ea);
827 uint res = src + dst;
828
829 FLAG_N = NFLAG_8(res);
830 FLAG_V = VFLAG_ADD_8(src, dst, res);
831 FLAG_X = FLAG_C = CFLAG_8(res);
832 FLAG_Z = MASK_OUT_ABOVE_8(res);
833
834 m68ki_write_8(ea, FLAG_Z);
835 }
836
837
m68k_op_add_8_re_ix(void)838 void m68k_op_add_8_re_ix(void)
839 {
840 uint ea = EA_AY_IX_8();
841 uint src = MASK_OUT_ABOVE_8(DX);
842 uint dst = m68ki_read_8(ea);
843 uint res = src + dst;
844
845 FLAG_N = NFLAG_8(res);
846 FLAG_V = VFLAG_ADD_8(src, dst, res);
847 FLAG_X = FLAG_C = CFLAG_8(res);
848 FLAG_Z = MASK_OUT_ABOVE_8(res);
849
850 m68ki_write_8(ea, FLAG_Z);
851 }
852
853
m68k_op_add_8_re_aw(void)854 void m68k_op_add_8_re_aw(void)
855 {
856 uint ea = EA_AW_8();
857 uint src = MASK_OUT_ABOVE_8(DX);
858 uint dst = m68ki_read_8(ea);
859 uint res = src + dst;
860
861 FLAG_N = NFLAG_8(res);
862 FLAG_V = VFLAG_ADD_8(src, dst, res);
863 FLAG_X = FLAG_C = CFLAG_8(res);
864 FLAG_Z = MASK_OUT_ABOVE_8(res);
865
866 m68ki_write_8(ea, FLAG_Z);
867 }
868
869
m68k_op_add_8_re_al(void)870 void m68k_op_add_8_re_al(void)
871 {
872 uint ea = EA_AL_8();
873 uint src = MASK_OUT_ABOVE_8(DX);
874 uint dst = m68ki_read_8(ea);
875 uint res = src + dst;
876
877 FLAG_N = NFLAG_8(res);
878 FLAG_V = VFLAG_ADD_8(src, dst, res);
879 FLAG_X = FLAG_C = CFLAG_8(res);
880 FLAG_Z = MASK_OUT_ABOVE_8(res);
881
882 m68ki_write_8(ea, FLAG_Z);
883 }
884
885
m68k_op_add_16_re_ai(void)886 void m68k_op_add_16_re_ai(void)
887 {
888 uint ea = EA_AY_AI_16();
889 uint src = MASK_OUT_ABOVE_16(DX);
890 uint dst = m68ki_read_16(ea);
891 uint res = src + dst;
892
893 FLAG_N = NFLAG_16(res);
894 FLAG_V = VFLAG_ADD_16(src, dst, res);
895 FLAG_X = FLAG_C = CFLAG_16(res);
896 FLAG_Z = MASK_OUT_ABOVE_16(res);
897
898 m68ki_write_16(ea, FLAG_Z);
899 }
900
901
m68k_op_add_16_re_pi(void)902 void m68k_op_add_16_re_pi(void)
903 {
904 uint ea = EA_AY_PI_16();
905 uint src = MASK_OUT_ABOVE_16(DX);
906 uint dst = m68ki_read_16(ea);
907 uint res = src + dst;
908
909 FLAG_N = NFLAG_16(res);
910 FLAG_V = VFLAG_ADD_16(src, dst, res);
911 FLAG_X = FLAG_C = CFLAG_16(res);
912 FLAG_Z = MASK_OUT_ABOVE_16(res);
913
914 m68ki_write_16(ea, FLAG_Z);
915 }
916
917
m68k_op_add_16_re_pd(void)918 void m68k_op_add_16_re_pd(void)
919 {
920 uint ea = EA_AY_PD_16();
921 uint src = MASK_OUT_ABOVE_16(DX);
922 uint dst = m68ki_read_16(ea);
923 uint res = src + dst;
924
925 FLAG_N = NFLAG_16(res);
926 FLAG_V = VFLAG_ADD_16(src, dst, res);
927 FLAG_X = FLAG_C = CFLAG_16(res);
928 FLAG_Z = MASK_OUT_ABOVE_16(res);
929
930 m68ki_write_16(ea, FLAG_Z);
931 }
932
933
m68k_op_add_16_re_di(void)934 void m68k_op_add_16_re_di(void)
935 {
936 uint ea = EA_AY_DI_16();
937 uint src = MASK_OUT_ABOVE_16(DX);
938 uint dst = m68ki_read_16(ea);
939 uint res = src + dst;
940
941 FLAG_N = NFLAG_16(res);
942 FLAG_V = VFLAG_ADD_16(src, dst, res);
943 FLAG_X = FLAG_C = CFLAG_16(res);
944 FLAG_Z = MASK_OUT_ABOVE_16(res);
945
946 m68ki_write_16(ea, FLAG_Z);
947 }
948
949
m68k_op_add_16_re_ix(void)950 void m68k_op_add_16_re_ix(void)
951 {
952 uint ea = EA_AY_IX_16();
953 uint src = MASK_OUT_ABOVE_16(DX);
954 uint dst = m68ki_read_16(ea);
955 uint res = src + dst;
956
957 FLAG_N = NFLAG_16(res);
958 FLAG_V = VFLAG_ADD_16(src, dst, res);
959 FLAG_X = FLAG_C = CFLAG_16(res);
960 FLAG_Z = MASK_OUT_ABOVE_16(res);
961
962 m68ki_write_16(ea, FLAG_Z);
963 }
964
965
m68k_op_add_16_re_aw(void)966 void m68k_op_add_16_re_aw(void)
967 {
968 uint ea = EA_AW_16();
969 uint src = MASK_OUT_ABOVE_16(DX);
970 uint dst = m68ki_read_16(ea);
971 uint res = src + dst;
972
973 FLAG_N = NFLAG_16(res);
974 FLAG_V = VFLAG_ADD_16(src, dst, res);
975 FLAG_X = FLAG_C = CFLAG_16(res);
976 FLAG_Z = MASK_OUT_ABOVE_16(res);
977
978 m68ki_write_16(ea, FLAG_Z);
979 }
980
981
m68k_op_add_16_re_al(void)982 void m68k_op_add_16_re_al(void)
983 {
984 uint ea = EA_AL_16();
985 uint src = MASK_OUT_ABOVE_16(DX);
986 uint dst = m68ki_read_16(ea);
987 uint res = src + dst;
988
989 FLAG_N = NFLAG_16(res);
990 FLAG_V = VFLAG_ADD_16(src, dst, res);
991 FLAG_X = FLAG_C = CFLAG_16(res);
992 FLAG_Z = MASK_OUT_ABOVE_16(res);
993
994 m68ki_write_16(ea, FLAG_Z);
995 }
996
997
m68k_op_add_32_re_ai(void)998 void m68k_op_add_32_re_ai(void)
999 {
1000 uint ea = EA_AY_AI_32();
1001 uint src = DX;
1002 uint dst = m68ki_read_32(ea);
1003 uint res = src + dst;
1004
1005 FLAG_N = NFLAG_32(res);
1006 FLAG_V = VFLAG_ADD_32(src, dst, res);
1007 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1008 FLAG_Z = MASK_OUT_ABOVE_32(res);
1009
1010 m68ki_write_32(ea, FLAG_Z);
1011 }
1012
1013
m68k_op_add_32_re_pi(void)1014 void m68k_op_add_32_re_pi(void)
1015 {
1016 uint ea = EA_AY_PI_32();
1017 uint src = DX;
1018 uint dst = m68ki_read_32(ea);
1019 uint res = src + dst;
1020
1021 FLAG_N = NFLAG_32(res);
1022 FLAG_V = VFLAG_ADD_32(src, dst, res);
1023 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1024 FLAG_Z = MASK_OUT_ABOVE_32(res);
1025
1026 m68ki_write_32(ea, FLAG_Z);
1027 }
1028
1029
m68k_op_add_32_re_pd(void)1030 void m68k_op_add_32_re_pd(void)
1031 {
1032 uint ea = EA_AY_PD_32();
1033 uint src = DX;
1034 uint dst = m68ki_read_32(ea);
1035 uint res = src + dst;
1036
1037 FLAG_N = NFLAG_32(res);
1038 FLAG_V = VFLAG_ADD_32(src, dst, res);
1039 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1040 FLAG_Z = MASK_OUT_ABOVE_32(res);
1041
1042 m68ki_write_32(ea, FLAG_Z);
1043 }
1044
1045
m68k_op_add_32_re_di(void)1046 void m68k_op_add_32_re_di(void)
1047 {
1048 uint ea = EA_AY_DI_32();
1049 uint src = DX;
1050 uint dst = m68ki_read_32(ea);
1051 uint res = src + dst;
1052
1053 FLAG_N = NFLAG_32(res);
1054 FLAG_V = VFLAG_ADD_32(src, dst, res);
1055 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1056 FLAG_Z = MASK_OUT_ABOVE_32(res);
1057
1058 m68ki_write_32(ea, FLAG_Z);
1059 }
1060
1061
m68k_op_add_32_re_ix(void)1062 void m68k_op_add_32_re_ix(void)
1063 {
1064 uint ea = EA_AY_IX_32();
1065 uint src = DX;
1066 uint dst = m68ki_read_32(ea);
1067 uint res = src + dst;
1068
1069 FLAG_N = NFLAG_32(res);
1070 FLAG_V = VFLAG_ADD_32(src, dst, res);
1071 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1072 FLAG_Z = MASK_OUT_ABOVE_32(res);
1073
1074 m68ki_write_32(ea, FLAG_Z);
1075 }
1076
1077
m68k_op_add_32_re_aw(void)1078 void m68k_op_add_32_re_aw(void)
1079 {
1080 uint ea = EA_AW_32();
1081 uint src = DX;
1082 uint dst = m68ki_read_32(ea);
1083 uint res = src + dst;
1084
1085 FLAG_N = NFLAG_32(res);
1086 FLAG_V = VFLAG_ADD_32(src, dst, res);
1087 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1088 FLAG_Z = MASK_OUT_ABOVE_32(res);
1089
1090 m68ki_write_32(ea, FLAG_Z);
1091 }
1092
1093
m68k_op_add_32_re_al(void)1094 void m68k_op_add_32_re_al(void)
1095 {
1096 uint ea = EA_AL_32();
1097 uint src = DX;
1098 uint dst = m68ki_read_32(ea);
1099 uint res = src + dst;
1100
1101 FLAG_N = NFLAG_32(res);
1102 FLAG_V = VFLAG_ADD_32(src, dst, res);
1103 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1104 FLAG_Z = MASK_OUT_ABOVE_32(res);
1105
1106 m68ki_write_32(ea, FLAG_Z);
1107 }
1108
1109
m68k_op_adda_16_d(void)1110 void m68k_op_adda_16_d(void)
1111 {
1112 uint* r_dst = &AX;
1113
1114 *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(DY));
1115 }
1116
1117
m68k_op_adda_16_a(void)1118 void m68k_op_adda_16_a(void)
1119 {
1120 uint* r_dst = &AX;
1121
1122 *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(AY));
1123 }
1124
1125
m68k_op_adda_16_ai(void)1126 void m68k_op_adda_16_ai(void)
1127 {
1128 signed short src = MAKE_INT_16(OPER_AY_AI_16());
1129 uint* r_dst = &AX;
1130
1131 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1132 }
1133
1134
m68k_op_adda_16_pi(void)1135 void m68k_op_adda_16_pi(void)
1136 {
1137 signed short src = MAKE_INT_16(OPER_AY_PI_16());
1138 uint* r_dst = &AX;
1139
1140 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1141 }
1142
1143
m68k_op_adda_16_pd(void)1144 void m68k_op_adda_16_pd(void)
1145 {
1146 signed short src = MAKE_INT_16(OPER_AY_PD_16());
1147 uint* r_dst = &AX;
1148
1149 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1150 }
1151
1152
m68k_op_adda_16_di(void)1153 void m68k_op_adda_16_di(void)
1154 {
1155 signed short src = MAKE_INT_16(OPER_AY_DI_16());
1156 uint* r_dst = &AX;
1157
1158 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1159 }
1160
1161
m68k_op_adda_16_ix(void)1162 void m68k_op_adda_16_ix(void)
1163 {
1164 signed short src = MAKE_INT_16(OPER_AY_IX_16());
1165 uint* r_dst = &AX;
1166
1167 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1168 }
1169
1170
m68k_op_adda_16_aw(void)1171 void m68k_op_adda_16_aw(void)
1172 {
1173 signed short src = MAKE_INT_16(OPER_AW_16());
1174 uint* r_dst = &AX;
1175
1176 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1177 }
1178
1179
m68k_op_adda_16_al(void)1180 void m68k_op_adda_16_al(void)
1181 {
1182 signed short src = MAKE_INT_16(OPER_AL_16());
1183 uint* r_dst = &AX;
1184
1185 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1186 }
1187
1188
m68k_op_adda_16_pcdi(void)1189 void m68k_op_adda_16_pcdi(void)
1190 {
1191 signed short src = MAKE_INT_16(OPER_PCDI_16());
1192 uint* r_dst = &AX;
1193
1194 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1195 }
1196
1197
m68k_op_adda_16_pcix(void)1198 void m68k_op_adda_16_pcix(void)
1199 {
1200 signed short src = MAKE_INT_16(OPER_PCIX_16());
1201 uint* r_dst = &AX;
1202
1203 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1204 }
1205
1206
m68k_op_adda_16_i(void)1207 void m68k_op_adda_16_i(void)
1208 {
1209 signed short src = MAKE_INT_16(OPER_I_16());
1210 uint* r_dst = &AX;
1211
1212 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1213 }
1214
1215
m68k_op_adda_32_d(void)1216 void m68k_op_adda_32_d(void)
1217 {
1218 uint* r_dst = &AX;
1219
1220 *r_dst = MASK_OUT_ABOVE_32(*r_dst + DY);
1221 }
1222
1223
m68k_op_adda_32_a(void)1224 void m68k_op_adda_32_a(void)
1225 {
1226 uint* r_dst = &AX;
1227
1228 *r_dst = MASK_OUT_ABOVE_32(*r_dst + AY);
1229 }
1230
1231
m68k_op_adda_32_ai(void)1232 void m68k_op_adda_32_ai(void)
1233 {
1234 uint src = OPER_AY_AI_32();
1235 uint* r_dst = &AX;
1236
1237 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1238 }
1239
1240
m68k_op_adda_32_pi(void)1241 void m68k_op_adda_32_pi(void)
1242 {
1243 uint src = OPER_AY_PI_32();
1244 uint* r_dst = &AX;
1245
1246 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1247 }
1248
1249
m68k_op_adda_32_pd(void)1250 void m68k_op_adda_32_pd(void)
1251 {
1252 uint src = OPER_AY_PD_32();
1253 uint* r_dst = &AX;
1254
1255 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1256 }
1257
1258
m68k_op_adda_32_di(void)1259 void m68k_op_adda_32_di(void)
1260 {
1261 uint src = OPER_AY_DI_32();
1262 uint* r_dst = &AX;
1263
1264 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1265 }
1266
1267
m68k_op_adda_32_ix(void)1268 void m68k_op_adda_32_ix(void)
1269 {
1270 uint src = OPER_AY_IX_32();
1271 uint* r_dst = &AX;
1272
1273 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1274 }
1275
1276
m68k_op_adda_32_aw(void)1277 void m68k_op_adda_32_aw(void)
1278 {
1279 uint src = OPER_AW_32();
1280 uint* r_dst = &AX;
1281
1282 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1283 }
1284
1285
m68k_op_adda_32_al(void)1286 void m68k_op_adda_32_al(void)
1287 {
1288 uint src = OPER_AL_32();
1289 uint* r_dst = &AX;
1290
1291 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1292 }
1293
1294
m68k_op_adda_32_pcdi(void)1295 void m68k_op_adda_32_pcdi(void)
1296 {
1297 uint src = OPER_PCDI_32();
1298 uint* r_dst = &AX;
1299
1300 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1301 }
1302
1303
m68k_op_adda_32_pcix(void)1304 void m68k_op_adda_32_pcix(void)
1305 {
1306 uint src = OPER_PCIX_32();
1307 uint* r_dst = &AX;
1308
1309 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1310 }
1311
1312
m68k_op_adda_32_i(void)1313 void m68k_op_adda_32_i(void)
1314 {
1315 uint src = OPER_I_32();
1316 uint* r_dst = &AX;
1317
1318 *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
1319 }
1320
1321
m68k_op_addi_8_d(void)1322 void m68k_op_addi_8_d(void)
1323 {
1324 uint* r_dst = &DY;
1325 uint src = OPER_I_8();
1326 uint dst = MASK_OUT_ABOVE_8(*r_dst);
1327 uint res = src + dst;
1328
1329 FLAG_N = NFLAG_8(res);
1330 FLAG_V = VFLAG_ADD_8(src, dst, res);
1331 FLAG_X = FLAG_C = CFLAG_8(res);
1332 FLAG_Z = MASK_OUT_ABOVE_8(res);
1333
1334 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
1335 }
1336
1337
m68k_op_addi_8_ai(void)1338 void m68k_op_addi_8_ai(void)
1339 {
1340 uint src = OPER_I_8();
1341 uint ea = EA_AY_AI_8();
1342 uint dst = m68ki_read_8(ea);
1343 uint res = src + dst;
1344
1345 FLAG_N = NFLAG_8(res);
1346 FLAG_V = VFLAG_ADD_8(src, dst, res);
1347 FLAG_X = FLAG_C = CFLAG_8(res);
1348 FLAG_Z = MASK_OUT_ABOVE_8(res);
1349
1350 m68ki_write_8(ea, FLAG_Z);
1351 }
1352
1353
m68k_op_addi_8_pi(void)1354 void m68k_op_addi_8_pi(void)
1355 {
1356 uint src = OPER_I_8();
1357 uint ea = EA_AY_PI_8();
1358 uint dst = m68ki_read_8(ea);
1359 uint res = src + dst;
1360
1361 FLAG_N = NFLAG_8(res);
1362 FLAG_V = VFLAG_ADD_8(src, dst, res);
1363 FLAG_X = FLAG_C = CFLAG_8(res);
1364 FLAG_Z = MASK_OUT_ABOVE_8(res);
1365
1366 m68ki_write_8(ea, FLAG_Z);
1367 }
1368
1369
m68k_op_addi_8_pi7(void)1370 void m68k_op_addi_8_pi7(void)
1371 {
1372 uint src = OPER_I_8();
1373 uint ea = EA_A7_PI_8();
1374 uint dst = m68ki_read_8(ea);
1375 uint res = src + dst;
1376
1377 FLAG_N = NFLAG_8(res);
1378 FLAG_V = VFLAG_ADD_8(src, dst, res);
1379 FLAG_X = FLAG_C = CFLAG_8(res);
1380 FLAG_Z = MASK_OUT_ABOVE_8(res);
1381
1382 m68ki_write_8(ea, FLAG_Z);
1383 }
1384
1385
m68k_op_addi_8_pd(void)1386 void m68k_op_addi_8_pd(void)
1387 {
1388 uint src = OPER_I_8();
1389 uint ea = EA_AY_PD_8();
1390 uint dst = m68ki_read_8(ea);
1391 uint res = src + dst;
1392
1393 FLAG_N = NFLAG_8(res);
1394 FLAG_V = VFLAG_ADD_8(src, dst, res);
1395 FLAG_X = FLAG_C = CFLAG_8(res);
1396 FLAG_Z = MASK_OUT_ABOVE_8(res);
1397
1398 m68ki_write_8(ea, FLAG_Z);
1399 }
1400
1401
m68k_op_addi_8_pd7(void)1402 void m68k_op_addi_8_pd7(void)
1403 {
1404 uint src = OPER_I_8();
1405 uint ea = EA_A7_PD_8();
1406 uint dst = m68ki_read_8(ea);
1407 uint res = src + dst;
1408
1409 FLAG_N = NFLAG_8(res);
1410 FLAG_V = VFLAG_ADD_8(src, dst, res);
1411 FLAG_X = FLAG_C = CFLAG_8(res);
1412 FLAG_Z = MASK_OUT_ABOVE_8(res);
1413
1414 m68ki_write_8(ea, FLAG_Z);
1415 }
1416
1417
m68k_op_addi_8_di(void)1418 void m68k_op_addi_8_di(void)
1419 {
1420 uint src = OPER_I_8();
1421 uint ea = EA_AY_DI_8();
1422 uint dst = m68ki_read_8(ea);
1423 uint res = src + dst;
1424
1425 FLAG_N = NFLAG_8(res);
1426 FLAG_V = VFLAG_ADD_8(src, dst, res);
1427 FLAG_X = FLAG_C = CFLAG_8(res);
1428 FLAG_Z = MASK_OUT_ABOVE_8(res);
1429
1430 m68ki_write_8(ea, FLAG_Z);
1431 }
1432
1433
m68k_op_addi_8_ix(void)1434 void m68k_op_addi_8_ix(void)
1435 {
1436 uint src = OPER_I_8();
1437 uint ea = EA_AY_IX_8();
1438 uint dst = m68ki_read_8(ea);
1439 uint res = src + dst;
1440
1441 FLAG_N = NFLAG_8(res);
1442 FLAG_V = VFLAG_ADD_8(src, dst, res);
1443 FLAG_X = FLAG_C = CFLAG_8(res);
1444 FLAG_Z = MASK_OUT_ABOVE_8(res);
1445
1446 m68ki_write_8(ea, FLAG_Z);
1447 }
1448
1449
m68k_op_addi_8_aw(void)1450 void m68k_op_addi_8_aw(void)
1451 {
1452 uint src = OPER_I_8();
1453 uint ea = EA_AW_8();
1454 uint dst = m68ki_read_8(ea);
1455 uint res = src + dst;
1456
1457 FLAG_N = NFLAG_8(res);
1458 FLAG_V = VFLAG_ADD_8(src, dst, res);
1459 FLAG_X = FLAG_C = CFLAG_8(res);
1460 FLAG_Z = MASK_OUT_ABOVE_8(res);
1461
1462 m68ki_write_8(ea, FLAG_Z);
1463 }
1464
1465
m68k_op_addi_8_al(void)1466 void m68k_op_addi_8_al(void)
1467 {
1468 uint src = OPER_I_8();
1469 uint ea = EA_AL_8();
1470 uint dst = m68ki_read_8(ea);
1471 uint res = src + dst;
1472
1473 FLAG_N = NFLAG_8(res);
1474 FLAG_V = VFLAG_ADD_8(src, dst, res);
1475 FLAG_X = FLAG_C = CFLAG_8(res);
1476 FLAG_Z = MASK_OUT_ABOVE_8(res);
1477
1478 m68ki_write_8(ea, FLAG_Z);
1479 }
1480
1481
m68k_op_addi_16_d(void)1482 void m68k_op_addi_16_d(void)
1483 {
1484 uint* r_dst = &DY;
1485 uint src = OPER_I_16();
1486 uint dst = MASK_OUT_ABOVE_16(*r_dst);
1487 uint res = src + dst;
1488
1489 FLAG_N = NFLAG_16(res);
1490 FLAG_V = VFLAG_ADD_16(src, dst, res);
1491 FLAG_X = FLAG_C = CFLAG_16(res);
1492 FLAG_Z = MASK_OUT_ABOVE_16(res);
1493
1494 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
1495 }
1496
1497
m68k_op_addi_16_ai(void)1498 void m68k_op_addi_16_ai(void)
1499 {
1500 uint src = OPER_I_16();
1501 uint ea = EA_AY_AI_16();
1502 uint dst = m68ki_read_16(ea);
1503 uint res = src + dst;
1504
1505 FLAG_N = NFLAG_16(res);
1506 FLAG_V = VFLAG_ADD_16(src, dst, res);
1507 FLAG_X = FLAG_C = CFLAG_16(res);
1508 FLAG_Z = MASK_OUT_ABOVE_16(res);
1509
1510 m68ki_write_16(ea, FLAG_Z);
1511 }
1512
1513
m68k_op_addi_16_pi(void)1514 void m68k_op_addi_16_pi(void)
1515 {
1516 uint src = OPER_I_16();
1517 uint ea = EA_AY_PI_16();
1518 uint dst = m68ki_read_16(ea);
1519 uint res = src + dst;
1520
1521 FLAG_N = NFLAG_16(res);
1522 FLAG_V = VFLAG_ADD_16(src, dst, res);
1523 FLAG_X = FLAG_C = CFLAG_16(res);
1524 FLAG_Z = MASK_OUT_ABOVE_16(res);
1525
1526 m68ki_write_16(ea, FLAG_Z);
1527 }
1528
1529
m68k_op_addi_16_pd(void)1530 void m68k_op_addi_16_pd(void)
1531 {
1532 uint src = OPER_I_16();
1533 uint ea = EA_AY_PD_16();
1534 uint dst = m68ki_read_16(ea);
1535 uint res = src + dst;
1536
1537 FLAG_N = NFLAG_16(res);
1538 FLAG_V = VFLAG_ADD_16(src, dst, res);
1539 FLAG_X = FLAG_C = CFLAG_16(res);
1540 FLAG_Z = MASK_OUT_ABOVE_16(res);
1541
1542 m68ki_write_16(ea, FLAG_Z);
1543 }
1544
1545
m68k_op_addi_16_di(void)1546 void m68k_op_addi_16_di(void)
1547 {
1548 uint src = OPER_I_16();
1549 uint ea = EA_AY_DI_16();
1550 uint dst = m68ki_read_16(ea);
1551 uint res = src + dst;
1552
1553 FLAG_N = NFLAG_16(res);
1554 FLAG_V = VFLAG_ADD_16(src, dst, res);
1555 FLAG_X = FLAG_C = CFLAG_16(res);
1556 FLAG_Z = MASK_OUT_ABOVE_16(res);
1557
1558 m68ki_write_16(ea, FLAG_Z);
1559 }
1560
1561
m68k_op_addi_16_ix(void)1562 void m68k_op_addi_16_ix(void)
1563 {
1564 uint src = OPER_I_16();
1565 uint ea = EA_AY_IX_16();
1566 uint dst = m68ki_read_16(ea);
1567 uint res = src + dst;
1568
1569 FLAG_N = NFLAG_16(res);
1570 FLAG_V = VFLAG_ADD_16(src, dst, res);
1571 FLAG_X = FLAG_C = CFLAG_16(res);
1572 FLAG_Z = MASK_OUT_ABOVE_16(res);
1573
1574 m68ki_write_16(ea, FLAG_Z);
1575 }
1576
1577
m68k_op_addi_16_aw(void)1578 void m68k_op_addi_16_aw(void)
1579 {
1580 uint src = OPER_I_16();
1581 uint ea = EA_AW_16();
1582 uint dst = m68ki_read_16(ea);
1583 uint res = src + dst;
1584
1585 FLAG_N = NFLAG_16(res);
1586 FLAG_V = VFLAG_ADD_16(src, dst, res);
1587 FLAG_X = FLAG_C = CFLAG_16(res);
1588 FLAG_Z = MASK_OUT_ABOVE_16(res);
1589
1590 m68ki_write_16(ea, FLAG_Z);
1591 }
1592
1593
m68k_op_addi_16_al(void)1594 void m68k_op_addi_16_al(void)
1595 {
1596 uint src = OPER_I_16();
1597 uint ea = EA_AL_16();
1598 uint dst = m68ki_read_16(ea);
1599 uint res = src + dst;
1600
1601 FLAG_N = NFLAG_16(res);
1602 FLAG_V = VFLAG_ADD_16(src, dst, res);
1603 FLAG_X = FLAG_C = CFLAG_16(res);
1604 FLAG_Z = MASK_OUT_ABOVE_16(res);
1605
1606 m68ki_write_16(ea, FLAG_Z);
1607 }
1608
1609
m68k_op_addi_32_d(void)1610 void m68k_op_addi_32_d(void)
1611 {
1612 uint* r_dst = &DY;
1613 uint src = OPER_I_32();
1614 uint dst = *r_dst;
1615 uint res = src + dst;
1616
1617 FLAG_N = NFLAG_32(res);
1618 FLAG_V = VFLAG_ADD_32(src, dst, res);
1619 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1620 FLAG_Z = MASK_OUT_ABOVE_32(res);
1621
1622 *r_dst = FLAG_Z;
1623 }
1624
1625
m68k_op_addi_32_ai(void)1626 void m68k_op_addi_32_ai(void)
1627 {
1628 uint src = OPER_I_32();
1629 uint ea = EA_AY_AI_32();
1630 uint dst = m68ki_read_32(ea);
1631 uint res = src + dst;
1632
1633 FLAG_N = NFLAG_32(res);
1634 FLAG_V = VFLAG_ADD_32(src, dst, res);
1635 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1636 FLAG_Z = MASK_OUT_ABOVE_32(res);
1637
1638 m68ki_write_32(ea, FLAG_Z);
1639 }
1640
1641
m68k_op_addi_32_pi(void)1642 void m68k_op_addi_32_pi(void)
1643 {
1644 uint src = OPER_I_32();
1645 uint ea = EA_AY_PI_32();
1646 uint dst = m68ki_read_32(ea);
1647 uint res = src + dst;
1648
1649 FLAG_N = NFLAG_32(res);
1650 FLAG_V = VFLAG_ADD_32(src, dst, res);
1651 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1652 FLAG_Z = MASK_OUT_ABOVE_32(res);
1653
1654 m68ki_write_32(ea, FLAG_Z);
1655 }
1656
1657
m68k_op_addi_32_pd(void)1658 void m68k_op_addi_32_pd(void)
1659 {
1660 uint src = OPER_I_32();
1661 uint ea = EA_AY_PD_32();
1662 uint dst = m68ki_read_32(ea);
1663 uint res = src + dst;
1664
1665 FLAG_N = NFLAG_32(res);
1666 FLAG_V = VFLAG_ADD_32(src, dst, res);
1667 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1668 FLAG_Z = MASK_OUT_ABOVE_32(res);
1669
1670 m68ki_write_32(ea, FLAG_Z);
1671 }
1672
1673
m68k_op_addi_32_di(void)1674 void m68k_op_addi_32_di(void)
1675 {
1676 uint src = OPER_I_32();
1677 uint ea = EA_AY_DI_32();
1678 uint dst = m68ki_read_32(ea);
1679 uint res = src + dst;
1680
1681 FLAG_N = NFLAG_32(res);
1682 FLAG_V = VFLAG_ADD_32(src, dst, res);
1683 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1684 FLAG_Z = MASK_OUT_ABOVE_32(res);
1685
1686 m68ki_write_32(ea, FLAG_Z);
1687 }
1688
1689
m68k_op_addi_32_ix(void)1690 void m68k_op_addi_32_ix(void)
1691 {
1692 uint src = OPER_I_32();
1693 uint ea = EA_AY_IX_32();
1694 uint dst = m68ki_read_32(ea);
1695 uint res = src + dst;
1696
1697 FLAG_N = NFLAG_32(res);
1698 FLAG_V = VFLAG_ADD_32(src, dst, res);
1699 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1700 FLAG_Z = MASK_OUT_ABOVE_32(res);
1701
1702 m68ki_write_32(ea, FLAG_Z);
1703 }
1704
1705
m68k_op_addi_32_aw(void)1706 void m68k_op_addi_32_aw(void)
1707 {
1708 uint src = OPER_I_32();
1709 uint ea = EA_AW_32();
1710 uint dst = m68ki_read_32(ea);
1711 uint res = src + dst;
1712
1713 FLAG_N = NFLAG_32(res);
1714 FLAG_V = VFLAG_ADD_32(src, dst, res);
1715 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1716 FLAG_Z = MASK_OUT_ABOVE_32(res);
1717
1718 m68ki_write_32(ea, FLAG_Z);
1719 }
1720
1721
m68k_op_addi_32_al(void)1722 void m68k_op_addi_32_al(void)
1723 {
1724 uint src = OPER_I_32();
1725 uint ea = EA_AL_32();
1726 uint dst = m68ki_read_32(ea);
1727 uint res = src + dst;
1728
1729 FLAG_N = NFLAG_32(res);
1730 FLAG_V = VFLAG_ADD_32(src, dst, res);
1731 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
1732 FLAG_Z = MASK_OUT_ABOVE_32(res);
1733
1734 m68ki_write_32(ea, FLAG_Z);
1735 }
1736
1737
m68k_op_addq_8_d(void)1738 void m68k_op_addq_8_d(void)
1739 {
1740 uint* r_dst = &DY;
1741 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1742 uint dst = MASK_OUT_ABOVE_8(*r_dst);
1743 uint res = src + dst;
1744
1745 FLAG_N = NFLAG_8(res);
1746 FLAG_V = VFLAG_ADD_8(src, dst, res);
1747 FLAG_X = FLAG_C = CFLAG_8(res);
1748 FLAG_Z = MASK_OUT_ABOVE_8(res);
1749
1750 *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
1751 }
1752
1753
m68k_op_addq_8_ai(void)1754 void m68k_op_addq_8_ai(void)
1755 {
1756 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1757 uint ea = EA_AY_AI_8();
1758 uint dst = m68ki_read_8(ea);
1759 uint res = src + dst;
1760
1761 FLAG_N = NFLAG_8(res);
1762 FLAG_V = VFLAG_ADD_8(src, dst, res);
1763 FLAG_X = FLAG_C = CFLAG_8(res);
1764 FLAG_Z = MASK_OUT_ABOVE_8(res);
1765
1766 m68ki_write_8(ea, FLAG_Z);
1767 }
1768
1769
m68k_op_addq_8_pi(void)1770 void m68k_op_addq_8_pi(void)
1771 {
1772 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1773 uint ea = EA_AY_PI_8();
1774 uint dst = m68ki_read_8(ea);
1775 uint res = src + dst;
1776
1777 FLAG_N = NFLAG_8(res);
1778 FLAG_V = VFLAG_ADD_8(src, dst, res);
1779 FLAG_X = FLAG_C = CFLAG_8(res);
1780 FLAG_Z = MASK_OUT_ABOVE_8(res);
1781
1782 m68ki_write_8(ea, FLAG_Z);
1783 }
1784
1785
m68k_op_addq_8_pi7(void)1786 void m68k_op_addq_8_pi7(void)
1787 {
1788 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1789 uint ea = EA_A7_PI_8();
1790 uint dst = m68ki_read_8(ea);
1791 uint res = src + dst;
1792
1793 FLAG_N = NFLAG_8(res);
1794 FLAG_V = VFLAG_ADD_8(src, dst, res);
1795 FLAG_X = FLAG_C = CFLAG_8(res);
1796 FLAG_Z = MASK_OUT_ABOVE_8(res);
1797
1798 m68ki_write_8(ea, FLAG_Z);
1799 }
1800
1801
m68k_op_addq_8_pd(void)1802 void m68k_op_addq_8_pd(void)
1803 {
1804 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1805 uint ea = EA_AY_PD_8();
1806 uint dst = m68ki_read_8(ea);
1807 uint res = src + dst;
1808
1809 FLAG_N = NFLAG_8(res);
1810 FLAG_V = VFLAG_ADD_8(src, dst, res);
1811 FLAG_X = FLAG_C = CFLAG_8(res);
1812 FLAG_Z = MASK_OUT_ABOVE_8(res);
1813
1814 m68ki_write_8(ea, FLAG_Z);
1815 }
1816
1817
m68k_op_addq_8_pd7(void)1818 void m68k_op_addq_8_pd7(void)
1819 {
1820 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1821 uint ea = EA_A7_PD_8();
1822 uint dst = m68ki_read_8(ea);
1823 uint res = src + dst;
1824
1825 FLAG_N = NFLAG_8(res);
1826 FLAG_V = VFLAG_ADD_8(src, dst, res);
1827 FLAG_X = FLAG_C = CFLAG_8(res);
1828 FLAG_Z = MASK_OUT_ABOVE_8(res);
1829
1830 m68ki_write_8(ea, FLAG_Z);
1831 }
1832
1833
m68k_op_addq_8_di(void)1834 void m68k_op_addq_8_di(void)
1835 {
1836 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1837 uint ea = EA_AY_DI_8();
1838 uint dst = m68ki_read_8(ea);
1839 uint res = src + dst;
1840
1841 FLAG_N = NFLAG_8(res);
1842 FLAG_V = VFLAG_ADD_8(src, dst, res);
1843 FLAG_X = FLAG_C = CFLAG_8(res);
1844 FLAG_Z = MASK_OUT_ABOVE_8(res);
1845
1846 m68ki_write_8(ea, FLAG_Z);
1847 }
1848
1849
m68k_op_addq_8_ix(void)1850 void m68k_op_addq_8_ix(void)
1851 {
1852 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1853 uint ea = EA_AY_IX_8();
1854 uint dst = m68ki_read_8(ea);
1855 uint res = src + dst;
1856
1857 FLAG_N = NFLAG_8(res);
1858 FLAG_V = VFLAG_ADD_8(src, dst, res);
1859 FLAG_X = FLAG_C = CFLAG_8(res);
1860 FLAG_Z = MASK_OUT_ABOVE_8(res);
1861
1862 m68ki_write_8(ea, FLAG_Z);
1863 }
1864
1865
m68k_op_addq_8_aw(void)1866 void m68k_op_addq_8_aw(void)
1867 {
1868 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1869 uint ea = EA_AW_8();
1870 uint dst = m68ki_read_8(ea);
1871 uint res = src + dst;
1872
1873 FLAG_N = NFLAG_8(res);
1874 FLAG_V = VFLAG_ADD_8(src, dst, res);
1875 FLAG_X = FLAG_C = CFLAG_8(res);
1876 FLAG_Z = MASK_OUT_ABOVE_8(res);
1877
1878 m68ki_write_8(ea, FLAG_Z);
1879 }
1880
1881
m68k_op_addq_8_al(void)1882 void m68k_op_addq_8_al(void)
1883 {
1884 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1885 uint ea = EA_AL_8();
1886 uint dst = m68ki_read_8(ea);
1887 uint res = src + dst;
1888
1889 FLAG_N = NFLAG_8(res);
1890 FLAG_V = VFLAG_ADD_8(src, dst, res);
1891 FLAG_X = FLAG_C = CFLAG_8(res);
1892 FLAG_Z = MASK_OUT_ABOVE_8(res);
1893
1894 m68ki_write_8(ea, FLAG_Z);
1895 }
1896
1897
m68k_op_addq_16_d(void)1898 void m68k_op_addq_16_d(void)
1899 {
1900 uint* r_dst = &DY;
1901 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1902 uint dst = MASK_OUT_ABOVE_16(*r_dst);
1903 uint res = src + dst;
1904
1905 FLAG_N = NFLAG_16(res);
1906 FLAG_V = VFLAG_ADD_16(src, dst, res);
1907 FLAG_X = FLAG_C = CFLAG_16(res);
1908 FLAG_Z = MASK_OUT_ABOVE_16(res);
1909
1910 *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
1911 }
1912
1913
m68k_op_addq_16_a(void)1914 void m68k_op_addq_16_a(void)
1915 {
1916 uint* r_dst = &AY;
1917
1918 *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1);
1919 }
1920
1921
m68k_op_addq_16_ai(void)1922 void m68k_op_addq_16_ai(void)
1923 {
1924 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1925 uint ea = EA_AY_AI_16();
1926 uint dst = m68ki_read_16(ea);
1927 uint res = src + dst;
1928
1929 FLAG_N = NFLAG_16(res);
1930 FLAG_V = VFLAG_ADD_16(src, dst, res);
1931 FLAG_X = FLAG_C = CFLAG_16(res);
1932 FLAG_Z = MASK_OUT_ABOVE_16(res);
1933
1934 m68ki_write_16(ea, FLAG_Z);
1935 }
1936
1937
m68k_op_addq_16_pi(void)1938 void m68k_op_addq_16_pi(void)
1939 {
1940 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1941 uint ea = EA_AY_PI_16();
1942 uint dst = m68ki_read_16(ea);
1943 uint res = src + dst;
1944
1945 FLAG_N = NFLAG_16(res);
1946 FLAG_V = VFLAG_ADD_16(src, dst, res);
1947 FLAG_X = FLAG_C = CFLAG_16(res);
1948 FLAG_Z = MASK_OUT_ABOVE_16(res);
1949
1950 m68ki_write_16(ea, FLAG_Z);
1951 }
1952
1953
m68k_op_addq_16_pd(void)1954 void m68k_op_addq_16_pd(void)
1955 {
1956 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1957 uint ea = EA_AY_PD_16();
1958 uint dst = m68ki_read_16(ea);
1959 uint res = src + dst;
1960
1961 FLAG_N = NFLAG_16(res);
1962 FLAG_V = VFLAG_ADD_16(src, dst, res);
1963 FLAG_X = FLAG_C = CFLAG_16(res);
1964 FLAG_Z = MASK_OUT_ABOVE_16(res);
1965
1966 m68ki_write_16(ea, FLAG_Z);
1967 }
1968
1969
m68k_op_addq_16_di(void)1970 void m68k_op_addq_16_di(void)
1971 {
1972 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1973 uint ea = EA_AY_DI_16();
1974 uint dst = m68ki_read_16(ea);
1975 uint res = src + dst;
1976
1977 FLAG_N = NFLAG_16(res);
1978 FLAG_V = VFLAG_ADD_16(src, dst, res);
1979 FLAG_X = FLAG_C = CFLAG_16(res);
1980 FLAG_Z = MASK_OUT_ABOVE_16(res);
1981
1982 m68ki_write_16(ea, FLAG_Z);
1983 }
1984
1985
m68k_op_addq_16_ix(void)1986 void m68k_op_addq_16_ix(void)
1987 {
1988 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
1989 uint ea = EA_AY_IX_16();
1990 uint dst = m68ki_read_16(ea);
1991 uint res = src + dst;
1992
1993 FLAG_N = NFLAG_16(res);
1994 FLAG_V = VFLAG_ADD_16(src, dst, res);
1995 FLAG_X = FLAG_C = CFLAG_16(res);
1996 FLAG_Z = MASK_OUT_ABOVE_16(res);
1997
1998 m68ki_write_16(ea, FLAG_Z);
1999 }
2000
2001
m68k_op_addq_16_aw(void)2002 void m68k_op_addq_16_aw(void)
2003 {
2004 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2005 uint ea = EA_AW_16();
2006 uint dst = m68ki_read_16(ea);
2007 uint res = src + dst;
2008
2009 FLAG_N = NFLAG_16(res);
2010 FLAG_V = VFLAG_ADD_16(src, dst, res);
2011 FLAG_X = FLAG_C = CFLAG_16(res);
2012 FLAG_Z = MASK_OUT_ABOVE_16(res);
2013
2014 m68ki_write_16(ea, FLAG_Z);
2015 }
2016
2017
m68k_op_addq_16_al(void)2018 void m68k_op_addq_16_al(void)
2019 {
2020 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2021 uint ea = EA_AL_16();
2022 uint dst = m68ki_read_16(ea);
2023 uint res = src + dst;
2024
2025 FLAG_N = NFLAG_16(res);
2026 FLAG_V = VFLAG_ADD_16(src, dst, res);
2027 FLAG_X = FLAG_C = CFLAG_16(res);
2028 FLAG_Z = MASK_OUT_ABOVE_16(res);
2029
2030 m68ki_write_16(ea, FLAG_Z);
2031 }
2032
2033
m68k_op_addq_32_d(void)2034 void m68k_op_addq_32_d(void)
2035 {
2036 uint* r_dst = &DY;
2037 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2038 uint dst = *r_dst;
2039 uint res = src + dst;
2040
2041 FLAG_N = NFLAG_32(res);
2042 FLAG_V = VFLAG_ADD_32(src, dst, res);
2043 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2044 FLAG_Z = MASK_OUT_ABOVE_32(res);
2045
2046 *r_dst = FLAG_Z;
2047 }
2048
2049
m68k_op_addq_32_a(void)2050 void m68k_op_addq_32_a(void)
2051 {
2052 uint* r_dst = &AY;
2053
2054 *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1);
2055 }
2056
2057
m68k_op_addq_32_ai(void)2058 void m68k_op_addq_32_ai(void)
2059 {
2060 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2061 uint ea = EA_AY_AI_32();
2062 uint dst = m68ki_read_32(ea);
2063 uint res = src + dst;
2064
2065
2066 FLAG_N = NFLAG_32(res);
2067 FLAG_V = VFLAG_ADD_32(src, dst, res);
2068 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2069 FLAG_Z = MASK_OUT_ABOVE_32(res);
2070
2071 m68ki_write_32(ea, FLAG_Z);
2072 }
2073
2074
m68k_op_addq_32_pi(void)2075 void m68k_op_addq_32_pi(void)
2076 {
2077 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2078 uint ea = EA_AY_PI_32();
2079 uint dst = m68ki_read_32(ea);
2080 uint res = src + dst;
2081
2082
2083 FLAG_N = NFLAG_32(res);
2084 FLAG_V = VFLAG_ADD_32(src, dst, res);
2085 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2086 FLAG_Z = MASK_OUT_ABOVE_32(res);
2087
2088 m68ki_write_32(ea, FLAG_Z);
2089 }
2090
2091
m68k_op_addq_32_pd(void)2092 void m68k_op_addq_32_pd(void)
2093 {
2094 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2095 uint ea = EA_AY_PD_32();
2096 uint dst = m68ki_read_32(ea);
2097 uint res = src + dst;
2098
2099
2100 FLAG_N = NFLAG_32(res);
2101 FLAG_V = VFLAG_ADD_32(src, dst, res);
2102 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2103 FLAG_Z = MASK_OUT_ABOVE_32(res);
2104
2105 m68ki_write_32(ea, FLAG_Z);
2106 }
2107
2108
m68k_op_addq_32_di(void)2109 void m68k_op_addq_32_di(void)
2110 {
2111 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2112 uint ea = EA_AY_DI_32();
2113 uint dst = m68ki_read_32(ea);
2114 uint res = src + dst;
2115
2116
2117 FLAG_N = NFLAG_32(res);
2118 FLAG_V = VFLAG_ADD_32(src, dst, res);
2119 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2120 FLAG_Z = MASK_OUT_ABOVE_32(res);
2121
2122 m68ki_write_32(ea, FLAG_Z);
2123 }
2124
2125
m68k_op_addq_32_ix(void)2126 void m68k_op_addq_32_ix(void)
2127 {
2128 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2129 uint ea = EA_AY_IX_32();
2130 uint dst = m68ki_read_32(ea);
2131 uint res = src + dst;
2132
2133
2134 FLAG_N = NFLAG_32(res);
2135 FLAG_V = VFLAG_ADD_32(src, dst, res);
2136 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2137 FLAG_Z = MASK_OUT_ABOVE_32(res);
2138
2139 m68ki_write_32(ea, FLAG_Z);
2140 }
2141
2142
m68k_op_addq_32_aw(void)2143 void m68k_op_addq_32_aw(void)
2144 {
2145 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2146 uint ea = EA_AW_32();
2147 uint dst = m68ki_read_32(ea);
2148 uint res = src + dst;
2149
2150
2151 FLAG_N = NFLAG_32(res);
2152 FLAG_V = VFLAG_ADD_32(src, dst, res);
2153 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2154 FLAG_Z = MASK_OUT_ABOVE_32(res);
2155
2156 m68ki_write_32(ea, FLAG_Z);
2157 }
2158
2159
m68k_op_addq_32_al(void)2160 void m68k_op_addq_32_al(void)
2161 {
2162 uint src = (((REG_IR >> 9) - 1) & 7) + 1;
2163 uint ea = EA_AL_32();
2164 uint dst = m68ki_read_32(ea);
2165 uint res = src + dst;
2166
2167
2168 FLAG_N = NFLAG_32(res);
2169 FLAG_V = VFLAG_ADD_32(src, dst, res);
2170 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2171 FLAG_Z = MASK_OUT_ABOVE_32(res);
2172
2173 m68ki_write_32(ea, FLAG_Z);
2174 }
2175
2176
m68k_op_addx_8_rr(void)2177 void m68k_op_addx_8_rr(void)
2178 {
2179 uint* r_dst = &DX;
2180 uint src = MASK_OUT_ABOVE_8(DY);
2181 uint dst = MASK_OUT_ABOVE_8(*r_dst);
2182 uint res = src + dst + XFLAG_AS_1();
2183
2184 FLAG_N = NFLAG_8(res);
2185 FLAG_V = VFLAG_ADD_8(src, dst, res);
2186 FLAG_X = FLAG_C = CFLAG_8(res);
2187
2188 res = MASK_OUT_ABOVE_8(res);
2189 FLAG_Z |= res;
2190
2191 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
2192 }
2193
2194
m68k_op_addx_16_rr(void)2195 void m68k_op_addx_16_rr(void)
2196 {
2197 uint* r_dst = &DX;
2198 uint src = MASK_OUT_ABOVE_16(DY);
2199 uint dst = MASK_OUT_ABOVE_16(*r_dst);
2200 uint res = src + dst + XFLAG_AS_1();
2201
2202 FLAG_N = NFLAG_16(res);
2203 FLAG_V = VFLAG_ADD_16(src, dst, res);
2204 FLAG_X = FLAG_C = CFLAG_16(res);
2205
2206 res = MASK_OUT_ABOVE_16(res);
2207 FLAG_Z |= res;
2208
2209 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
2210 }
2211
2212
m68k_op_addx_32_rr(void)2213 void m68k_op_addx_32_rr(void)
2214 {
2215 uint* r_dst = &DX;
2216 uint src = DY;
2217 uint dst = *r_dst;
2218 uint res = src + dst + XFLAG_AS_1();
2219
2220 FLAG_N = NFLAG_32(res);
2221 FLAG_V = VFLAG_ADD_32(src, dst, res);
2222 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2223
2224 res = MASK_OUT_ABOVE_32(res);
2225 FLAG_Z |= res;
2226
2227 *r_dst = res;
2228 }
2229
2230
m68k_op_addx_8_mm_ax7(void)2231 void m68k_op_addx_8_mm_ax7(void)
2232 {
2233 uint src = OPER_AY_PD_8();
2234 uint ea = EA_A7_PD_8();
2235 uint dst = m68ki_read_8(ea);
2236 uint res = src + dst + XFLAG_AS_1();
2237
2238 FLAG_N = NFLAG_8(res);
2239 FLAG_V = VFLAG_ADD_8(src, dst, res);
2240 FLAG_X = FLAG_C = CFLAG_8(res);
2241
2242 res = MASK_OUT_ABOVE_8(res);
2243 FLAG_Z |= res;
2244
2245 m68ki_write_8(ea, res);
2246 }
2247
2248
m68k_op_addx_8_mm_ay7(void)2249 void m68k_op_addx_8_mm_ay7(void)
2250 {
2251 uint src = OPER_A7_PD_8();
2252 uint ea = EA_AX_PD_8();
2253 uint dst = m68ki_read_8(ea);
2254 uint res = src + dst + XFLAG_AS_1();
2255
2256 FLAG_N = NFLAG_8(res);
2257 FLAG_V = VFLAG_ADD_8(src, dst, res);
2258 FLAG_X = FLAG_C = CFLAG_8(res);
2259
2260 res = MASK_OUT_ABOVE_8(res);
2261 FLAG_Z |= res;
2262
2263 m68ki_write_8(ea, res);
2264 }
2265
2266
m68k_op_addx_8_mm_axy7(void)2267 void m68k_op_addx_8_mm_axy7(void)
2268 {
2269 uint src = OPER_A7_PD_8();
2270 uint ea = EA_A7_PD_8();
2271 uint dst = m68ki_read_8(ea);
2272 uint res = src + dst + XFLAG_AS_1();
2273
2274 FLAG_N = NFLAG_8(res);
2275 FLAG_V = VFLAG_ADD_8(src, dst, res);
2276 FLAG_X = FLAG_C = CFLAG_8(res);
2277
2278 res = MASK_OUT_ABOVE_8(res);
2279 FLAG_Z |= res;
2280
2281 m68ki_write_8(ea, res);
2282 }
2283
2284
m68k_op_addx_8_mm(void)2285 void m68k_op_addx_8_mm(void)
2286 {
2287 uint src = OPER_AY_PD_8();
2288 uint ea = EA_AX_PD_8();
2289 uint dst = m68ki_read_8(ea);
2290 uint res = src + dst + XFLAG_AS_1();
2291
2292 FLAG_N = NFLAG_8(res);
2293 FLAG_V = VFLAG_ADD_8(src, dst, res);
2294 FLAG_X = FLAG_C = CFLAG_8(res);
2295
2296 res = MASK_OUT_ABOVE_8(res);
2297 FLAG_Z |= res;
2298
2299 m68ki_write_8(ea, res);
2300 }
2301
2302
m68k_op_addx_16_mm(void)2303 void m68k_op_addx_16_mm(void)
2304 {
2305 uint src = OPER_AY_PD_16();
2306 uint ea = EA_AX_PD_16();
2307 uint dst = m68ki_read_16(ea);
2308 uint res = src + dst + XFLAG_AS_1();
2309
2310 FLAG_N = NFLAG_16(res);
2311 FLAG_V = VFLAG_ADD_16(src, dst, res);
2312 FLAG_X = FLAG_C = CFLAG_16(res);
2313
2314 res = MASK_OUT_ABOVE_16(res);
2315 FLAG_Z |= res;
2316
2317 m68ki_write_16(ea, res);
2318 }
2319
2320
m68k_op_addx_32_mm(void)2321 void m68k_op_addx_32_mm(void)
2322 {
2323 uint src = OPER_AY_PD_32();
2324 uint ea = EA_AX_PD_32();
2325 uint dst = m68ki_read_32(ea);
2326 uint res = src + dst + XFLAG_AS_1();
2327
2328 FLAG_N = NFLAG_32(res);
2329 FLAG_V = VFLAG_ADD_32(src, dst, res);
2330 FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
2331
2332 res = MASK_OUT_ABOVE_32(res);
2333 FLAG_Z |= res;
2334
2335 m68ki_write_32(ea, res);
2336 }
2337
2338
m68k_op_and_8_er_d(void)2339 void m68k_op_and_8_er_d(void)
2340 {
2341 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (DY | 0xffffff00));
2342
2343 FLAG_N = NFLAG_8(FLAG_Z);
2344 FLAG_C = CFLAG_CLEAR;
2345 FLAG_V = VFLAG_CLEAR;
2346 }
2347
2348
m68k_op_and_8_er_ai(void)2349 void m68k_op_and_8_er_ai(void)
2350 {
2351 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_AI_8() | 0xffffff00));
2352
2353 FLAG_N = NFLAG_8(FLAG_Z);
2354 FLAG_C = CFLAG_CLEAR;
2355 FLAG_V = VFLAG_CLEAR;
2356 }
2357
2358
m68k_op_and_8_er_pi(void)2359 void m68k_op_and_8_er_pi(void)
2360 {
2361 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_PI_8() | 0xffffff00));
2362
2363 FLAG_N = NFLAG_8(FLAG_Z);
2364 FLAG_C = CFLAG_CLEAR;
2365 FLAG_V = VFLAG_CLEAR;
2366 }
2367
2368
m68k_op_and_8_er_pi7(void)2369 void m68k_op_and_8_er_pi7(void)
2370 {
2371 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_A7_PI_8() | 0xffffff00));
2372
2373 FLAG_N = NFLAG_8(FLAG_Z);
2374 FLAG_C = CFLAG_CLEAR;
2375 FLAG_V = VFLAG_CLEAR;
2376 }
2377
2378
m68k_op_and_8_er_pd(void)2379 void m68k_op_and_8_er_pd(void)
2380 {
2381 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_PD_8() | 0xffffff00));
2382
2383 FLAG_N = NFLAG_8(FLAG_Z);
2384 FLAG_C = CFLAG_CLEAR;
2385 FLAG_V = VFLAG_CLEAR;
2386 }
2387
2388
m68k_op_and_8_er_pd7(void)2389 void m68k_op_and_8_er_pd7(void)
2390 {
2391 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_A7_PD_8() | 0xffffff00));
2392
2393 FLAG_N = NFLAG_8(FLAG_Z);
2394 FLAG_C = CFLAG_CLEAR;
2395 FLAG_V = VFLAG_CLEAR;
2396 }
2397
2398
m68k_op_and_8_er_di(void)2399 void m68k_op_and_8_er_di(void)
2400 {
2401 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_DI_8() | 0xffffff00));
2402
2403 FLAG_N = NFLAG_8(FLAG_Z);
2404 FLAG_C = CFLAG_CLEAR;
2405 FLAG_V = VFLAG_CLEAR;
2406 }
2407
2408
m68k_op_and_8_er_ix(void)2409 void m68k_op_and_8_er_ix(void)
2410 {
2411 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_IX_8() | 0xffffff00));
2412
2413 FLAG_N = NFLAG_8(FLAG_Z);
2414 FLAG_C = CFLAG_CLEAR;
2415 FLAG_V = VFLAG_CLEAR;
2416 }
2417
2418
m68k_op_and_8_er_aw(void)2419 void m68k_op_and_8_er_aw(void)
2420 {
2421 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AW_8() | 0xffffff00));
2422
2423 FLAG_N = NFLAG_8(FLAG_Z);
2424 FLAG_C = CFLAG_CLEAR;
2425 FLAG_V = VFLAG_CLEAR;
2426 }
2427
2428
m68k_op_and_8_er_al(void)2429 void m68k_op_and_8_er_al(void)
2430 {
2431 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AL_8() | 0xffffff00));
2432
2433 FLAG_N = NFLAG_8(FLAG_Z);
2434 FLAG_C = CFLAG_CLEAR;
2435 FLAG_V = VFLAG_CLEAR;
2436 }
2437
2438
m68k_op_and_8_er_pcdi(void)2439 void m68k_op_and_8_er_pcdi(void)
2440 {
2441 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_PCDI_8() | 0xffffff00));
2442
2443 FLAG_N = NFLAG_8(FLAG_Z);
2444 FLAG_C = CFLAG_CLEAR;
2445 FLAG_V = VFLAG_CLEAR;
2446 }
2447
2448
m68k_op_and_8_er_pcix(void)2449 void m68k_op_and_8_er_pcix(void)
2450 {
2451 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_PCIX_8() | 0xffffff00));
2452
2453 FLAG_N = NFLAG_8(FLAG_Z);
2454 FLAG_C = CFLAG_CLEAR;
2455 FLAG_V = VFLAG_CLEAR;
2456 }
2457
2458
m68k_op_and_8_er_i(void)2459 void m68k_op_and_8_er_i(void)
2460 {
2461 FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_I_8() | 0xffffff00));
2462
2463 FLAG_N = NFLAG_8(FLAG_Z);
2464 FLAG_C = CFLAG_CLEAR;
2465 FLAG_V = VFLAG_CLEAR;
2466 }
2467
2468
m68k_op_and_16_er_d(void)2469 void m68k_op_and_16_er_d(void)
2470 {
2471 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (DY | 0xffff0000));
2472
2473 FLAG_N = NFLAG_16(FLAG_Z);
2474 FLAG_C = CFLAG_CLEAR;
2475 FLAG_V = VFLAG_CLEAR;
2476 }
2477
2478
m68k_op_and_16_er_ai(void)2479 void m68k_op_and_16_er_ai(void)
2480 {
2481 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_AI_16() | 0xffff0000));
2482
2483 FLAG_N = NFLAG_16(FLAG_Z);
2484 FLAG_C = CFLAG_CLEAR;
2485 FLAG_V = VFLAG_CLEAR;
2486 }
2487
2488
m68k_op_and_16_er_pi(void)2489 void m68k_op_and_16_er_pi(void)
2490 {
2491 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_PI_16() | 0xffff0000));
2492
2493 FLAG_N = NFLAG_16(FLAG_Z);
2494 FLAG_C = CFLAG_CLEAR;
2495 FLAG_V = VFLAG_CLEAR;
2496 }
2497
2498
m68k_op_and_16_er_pd(void)2499 void m68k_op_and_16_er_pd(void)
2500 {
2501 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_PD_16() | 0xffff0000));
2502
2503 FLAG_N = NFLAG_16(FLAG_Z);
2504 FLAG_C = CFLAG_CLEAR;
2505 FLAG_V = VFLAG_CLEAR;
2506 }
2507
2508
m68k_op_and_16_er_di(void)2509 void m68k_op_and_16_er_di(void)
2510 {
2511 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_DI_16() | 0xffff0000));
2512
2513 FLAG_N = NFLAG_16(FLAG_Z);
2514 FLAG_C = CFLAG_CLEAR;
2515 FLAG_V = VFLAG_CLEAR;
2516 }
2517
2518
m68k_op_and_16_er_ix(void)2519 void m68k_op_and_16_er_ix(void)
2520 {
2521 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_IX_16() | 0xffff0000));
2522
2523 FLAG_N = NFLAG_16(FLAG_Z);
2524 FLAG_C = CFLAG_CLEAR;
2525 FLAG_V = VFLAG_CLEAR;
2526 }
2527
2528
m68k_op_and_16_er_aw(void)2529 void m68k_op_and_16_er_aw(void)
2530 {
2531 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AW_16() | 0xffff0000));
2532
2533 FLAG_N = NFLAG_16(FLAG_Z);
2534 FLAG_C = CFLAG_CLEAR;
2535 FLAG_V = VFLAG_CLEAR;
2536 }
2537
2538
m68k_op_and_16_er_al(void)2539 void m68k_op_and_16_er_al(void)
2540 {
2541 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AL_16() | 0xffff0000));
2542
2543 FLAG_N = NFLAG_16(FLAG_Z);
2544 FLAG_C = CFLAG_CLEAR;
2545 FLAG_V = VFLAG_CLEAR;
2546 }
2547
2548
m68k_op_and_16_er_pcdi(void)2549 void m68k_op_and_16_er_pcdi(void)
2550 {
2551 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_PCDI_16() | 0xffff0000));
2552
2553 FLAG_N = NFLAG_16(FLAG_Z);
2554 FLAG_C = CFLAG_CLEAR;
2555 FLAG_V = VFLAG_CLEAR;
2556 }
2557
2558
m68k_op_and_16_er_pcix(void)2559 void m68k_op_and_16_er_pcix(void)
2560 {
2561 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_PCIX_16() | 0xffff0000));
2562
2563 FLAG_N = NFLAG_16(FLAG_Z);
2564 FLAG_C = CFLAG_CLEAR;
2565 FLAG_V = VFLAG_CLEAR;
2566 }
2567
2568
m68k_op_and_16_er_i(void)2569 void m68k_op_and_16_er_i(void)
2570 {
2571 FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_I_16() | 0xffff0000));
2572
2573 FLAG_N = NFLAG_16(FLAG_Z);
2574 FLAG_C = CFLAG_CLEAR;
2575 FLAG_V = VFLAG_CLEAR;
2576 }
2577
2578
m68k_op_and_32_er_d(void)2579 void m68k_op_and_32_er_d(void)
2580 {
2581 FLAG_Z = DX &= DY;
2582
2583 FLAG_N = NFLAG_32(FLAG_Z);
2584 FLAG_C = CFLAG_CLEAR;
2585 FLAG_V = VFLAG_CLEAR;
2586 }
2587
2588
m68k_op_and_32_er_ai(void)2589 void m68k_op_and_32_er_ai(void)
2590 {
2591 FLAG_Z = DX &= OPER_AY_AI_32();
2592
2593 FLAG_N = NFLAG_32(FLAG_Z);
2594 FLAG_C = CFLAG_CLEAR;
2595 FLAG_V = VFLAG_CLEAR;
2596 }
2597
2598
m68k_op_and_32_er_pi(void)2599 void m68k_op_and_32_er_pi(void)
2600 {
2601 FLAG_Z = DX &= OPER_AY_PI_32();
2602
2603 FLAG_N = NFLAG_32(FLAG_Z);
2604 FLAG_C = CFLAG_CLEAR;
2605 FLAG_V = VFLAG_CLEAR;
2606 }
2607
2608
m68k_op_and_32_er_pd(void)2609 void m68k_op_and_32_er_pd(void)
2610 {
2611 FLAG_Z = DX &= OPER_AY_PD_32();
2612
2613 FLAG_N = NFLAG_32(FLAG_Z);
2614 FLAG_C = CFLAG_CLEAR;
2615 FLAG_V = VFLAG_CLEAR;
2616 }
2617
2618
m68k_op_and_32_er_di(void)2619 void m68k_op_and_32_er_di(void)
2620 {
2621 FLAG_Z = DX &= OPER_AY_DI_32();
2622
2623 FLAG_N = NFLAG_32(FLAG_Z);
2624 FLAG_C = CFLAG_CLEAR;
2625 FLAG_V = VFLAG_CLEAR;
2626 }
2627
2628
m68k_op_and_32_er_ix(void)2629 void m68k_op_and_32_er_ix(void)
2630 {
2631 FLAG_Z = DX &= OPER_AY_IX_32();
2632
2633 FLAG_N = NFLAG_32(FLAG_Z);
2634 FLAG_C = CFLAG_CLEAR;
2635 FLAG_V = VFLAG_CLEAR;
2636 }
2637
2638
m68k_op_and_32_er_aw(void)2639 void m68k_op_and_32_er_aw(void)
2640 {
2641 FLAG_Z = DX &= OPER_AW_32();
2642
2643 FLAG_N = NFLAG_32(FLAG_Z);
2644 FLAG_C = CFLAG_CLEAR;
2645 FLAG_V = VFLAG_CLEAR;
2646 }
2647
2648
m68k_op_and_32_er_al(void)2649 void m68k_op_and_32_er_al(void)
2650 {
2651 FLAG_Z = DX &= OPER_AL_32();
2652
2653 FLAG_N = NFLAG_32(FLAG_Z);
2654 FLAG_C = CFLAG_CLEAR;
2655 FLAG_V = VFLAG_CLEAR;
2656 }
2657
2658
m68k_op_and_32_er_pcdi(void)2659 void m68k_op_and_32_er_pcdi(void)
2660 {
2661 FLAG_Z = DX &= OPER_PCDI_32();
2662
2663 FLAG_N = NFLAG_32(FLAG_Z);
2664 FLAG_C = CFLAG_CLEAR;
2665 FLAG_V = VFLAG_CLEAR;
2666 }
2667
2668
m68k_op_and_32_er_pcix(void)2669 void m68k_op_and_32_er_pcix(void)
2670 {
2671 FLAG_Z = DX &= OPER_PCIX_32();
2672
2673 FLAG_N = NFLAG_32(FLAG_Z);
2674 FLAG_C = CFLAG_CLEAR;
2675 FLAG_V = VFLAG_CLEAR;
2676 }
2677
2678
m68k_op_and_32_er_i(void)2679 void m68k_op_and_32_er_i(void)
2680 {
2681 FLAG_Z = DX &= OPER_I_32();
2682
2683 FLAG_N = NFLAG_32(FLAG_Z);
2684 FLAG_C = CFLAG_CLEAR;
2685 FLAG_V = VFLAG_CLEAR;
2686 }
2687
2688
m68k_op_and_8_re_ai(void)2689 void m68k_op_and_8_re_ai(void)
2690 {
2691 uint ea = EA_AY_AI_8();
2692 uint res = DX & m68ki_read_8(ea);
2693
2694 FLAG_N = NFLAG_8(res);
2695 FLAG_C = CFLAG_CLEAR;
2696 FLAG_V = VFLAG_CLEAR;
2697 FLAG_Z = MASK_OUT_ABOVE_8(res);
2698
2699 m68ki_write_8(ea, FLAG_Z);
2700 }
2701
2702
m68k_op_and_8_re_pi(void)2703 void m68k_op_and_8_re_pi(void)
2704 {
2705 uint ea = EA_AY_PI_8();
2706 uint res = DX & m68ki_read_8(ea);
2707
2708 FLAG_N = NFLAG_8(res);
2709 FLAG_C = CFLAG_CLEAR;
2710 FLAG_V = VFLAG_CLEAR;
2711 FLAG_Z = MASK_OUT_ABOVE_8(res);
2712
2713 m68ki_write_8(ea, FLAG_Z);
2714 }
2715
2716
m68k_op_and_8_re_pi7(void)2717 void m68k_op_and_8_re_pi7(void)
2718 {
2719 uint ea = EA_A7_PI_8();
2720 uint res = DX & m68ki_read_8(ea);
2721
2722 FLAG_N = NFLAG_8(res);
2723 FLAG_C = CFLAG_CLEAR;
2724 FLAG_V = VFLAG_CLEAR;
2725 FLAG_Z = MASK_OUT_ABOVE_8(res);
2726
2727 m68ki_write_8(ea, FLAG_Z);
2728 }
2729
2730
m68k_op_and_8_re_pd(void)2731 void m68k_op_and_8_re_pd(void)
2732 {
2733 uint ea = EA_AY_PD_8();
2734 uint res = DX & m68ki_read_8(ea);
2735
2736 FLAG_N = NFLAG_8(res);
2737 FLAG_C = CFLAG_CLEAR;
2738 FLAG_V = VFLAG_CLEAR;
2739 FLAG_Z = MASK_OUT_ABOVE_8(res);
2740
2741 m68ki_write_8(ea, FLAG_Z);
2742 }
2743
2744
m68k_op_and_8_re_pd7(void)2745 void m68k_op_and_8_re_pd7(void)
2746 {
2747 uint ea = EA_A7_PD_8();
2748 uint res = DX & m68ki_read_8(ea);
2749
2750 FLAG_N = NFLAG_8(res);
2751 FLAG_C = CFLAG_CLEAR;
2752 FLAG_V = VFLAG_CLEAR;
2753 FLAG_Z = MASK_OUT_ABOVE_8(res);
2754
2755 m68ki_write_8(ea, FLAG_Z);
2756 }
2757
2758
m68k_op_and_8_re_di(void)2759 void m68k_op_and_8_re_di(void)
2760 {
2761 uint ea = EA_AY_DI_8();
2762 uint res = DX & m68ki_read_8(ea);
2763
2764 FLAG_N = NFLAG_8(res);
2765 FLAG_C = CFLAG_CLEAR;
2766 FLAG_V = VFLAG_CLEAR;
2767 FLAG_Z = MASK_OUT_ABOVE_8(res);
2768
2769 m68ki_write_8(ea, FLAG_Z);
2770 }
2771
2772
m68k_op_and_8_re_ix(void)2773 void m68k_op_and_8_re_ix(void)
2774 {
2775 uint ea = EA_AY_IX_8();
2776 uint res = DX & m68ki_read_8(ea);
2777
2778 FLAG_N = NFLAG_8(res);
2779 FLAG_C = CFLAG_CLEAR;
2780 FLAG_V = VFLAG_CLEAR;
2781 FLAG_Z = MASK_OUT_ABOVE_8(res);
2782
2783 m68ki_write_8(ea, FLAG_Z);
2784 }
2785
2786
m68k_op_and_8_re_aw(void)2787 void m68k_op_and_8_re_aw(void)
2788 {
2789 uint ea = EA_AW_8();
2790 uint res = DX & m68ki_read_8(ea);
2791
2792 FLAG_N = NFLAG_8(res);
2793 FLAG_C = CFLAG_CLEAR;
2794 FLAG_V = VFLAG_CLEAR;
2795 FLAG_Z = MASK_OUT_ABOVE_8(res);
2796
2797 m68ki_write_8(ea, FLAG_Z);
2798 }
2799
2800
m68k_op_and_8_re_al(void)2801 void m68k_op_and_8_re_al(void)
2802 {
2803 uint ea = EA_AL_8();
2804 uint res = DX & m68ki_read_8(ea);
2805
2806 FLAG_N = NFLAG_8(res);
2807 FLAG_C = CFLAG_CLEAR;
2808 FLAG_V = VFLAG_CLEAR;
2809 FLAG_Z = MASK_OUT_ABOVE_8(res);
2810
2811 m68ki_write_8(ea, FLAG_Z);
2812 }
2813
2814
m68k_op_and_16_re_ai(void)2815 void m68k_op_and_16_re_ai(void)
2816 {
2817 uint ea = EA_AY_AI_16();
2818 uint res = DX & m68ki_read_16(ea);
2819
2820 FLAG_N = NFLAG_16(res);
2821 FLAG_C = CFLAG_CLEAR;
2822 FLAG_V = VFLAG_CLEAR;
2823 FLAG_Z = MASK_OUT_ABOVE_16(res);
2824
2825 m68ki_write_16(ea, FLAG_Z);
2826 }
2827
2828
m68k_op_and_16_re_pi(void)2829 void m68k_op_and_16_re_pi(void)
2830 {
2831 uint ea = EA_AY_PI_16();
2832 uint res = DX & m68ki_read_16(ea);
2833
2834 FLAG_N = NFLAG_16(res);
2835 FLAG_C = CFLAG_CLEAR;
2836 FLAG_V = VFLAG_CLEAR;
2837 FLAG_Z = MASK_OUT_ABOVE_16(res);
2838
2839 m68ki_write_16(ea, FLAG_Z);
2840 }
2841
2842
m68k_op_and_16_re_pd(void)2843 void m68k_op_and_16_re_pd(void)
2844 {
2845 uint ea = EA_AY_PD_16();
2846 uint res = DX & m68ki_read_16(ea);
2847
2848 FLAG_N = NFLAG_16(res);
2849 FLAG_C = CFLAG_CLEAR;
2850 FLAG_V = VFLAG_CLEAR;
2851 FLAG_Z = MASK_OUT_ABOVE_16(res);
2852
2853 m68ki_write_16(ea, FLAG_Z);
2854 }
2855
2856
m68k_op_and_16_re_di(void)2857 void m68k_op_and_16_re_di(void)
2858 {
2859 uint ea = EA_AY_DI_16();
2860 uint res = DX & m68ki_read_16(ea);
2861
2862 FLAG_N = NFLAG_16(res);
2863 FLAG_C = CFLAG_CLEAR;
2864 FLAG_V = VFLAG_CLEAR;
2865 FLAG_Z = MASK_OUT_ABOVE_16(res);
2866
2867 m68ki_write_16(ea, FLAG_Z);
2868 }
2869
2870
m68k_op_and_16_re_ix(void)2871 void m68k_op_and_16_re_ix(void)
2872 {
2873 uint ea = EA_AY_IX_16();
2874 uint res = DX & m68ki_read_16(ea);
2875
2876 FLAG_N = NFLAG_16(res);
2877 FLAG_C = CFLAG_CLEAR;
2878 FLAG_V = VFLAG_CLEAR;
2879 FLAG_Z = MASK_OUT_ABOVE_16(res);
2880
2881 m68ki_write_16(ea, FLAG_Z);
2882 }
2883
2884
m68k_op_and_16_re_aw(void)2885 void m68k_op_and_16_re_aw(void)
2886 {
2887 uint ea = EA_AW_16();
2888 uint res = DX & m68ki_read_16(ea);
2889
2890 FLAG_N = NFLAG_16(res);
2891 FLAG_C = CFLAG_CLEAR;
2892 FLAG_V = VFLAG_CLEAR;
2893 FLAG_Z = MASK_OUT_ABOVE_16(res);
2894
2895 m68ki_write_16(ea, FLAG_Z);
2896 }
2897
2898
m68k_op_and_16_re_al(void)2899 void m68k_op_and_16_re_al(void)
2900 {
2901 uint ea = EA_AL_16();
2902 uint res = DX & m68ki_read_16(ea);
2903
2904 FLAG_N = NFLAG_16(res);
2905 FLAG_C = CFLAG_CLEAR;
2906 FLAG_V = VFLAG_CLEAR;
2907 FLAG_Z = MASK_OUT_ABOVE_16(res);
2908
2909 m68ki_write_16(ea, FLAG_Z);
2910 }
2911
2912
m68k_op_and_32_re_ai(void)2913 void m68k_op_and_32_re_ai(void)
2914 {
2915 uint ea = EA_AY_AI_32();
2916 uint res = DX & m68ki_read_32(ea);
2917
2918 FLAG_N = NFLAG_32(res);
2919 FLAG_Z = res;
2920 FLAG_C = CFLAG_CLEAR;
2921 FLAG_V = VFLAG_CLEAR;
2922
2923 m68ki_write_32(ea, res);
2924 }
2925
2926
m68k_op_and_32_re_pi(void)2927 void m68k_op_and_32_re_pi(void)
2928 {
2929 uint ea = EA_AY_PI_32();
2930 uint res = DX & m68ki_read_32(ea);
2931
2932 FLAG_N = NFLAG_32(res);
2933 FLAG_Z = res;
2934 FLAG_C = CFLAG_CLEAR;
2935 FLAG_V = VFLAG_CLEAR;
2936
2937 m68ki_write_32(ea, res);
2938 }
2939
2940
m68k_op_and_32_re_pd(void)2941 void m68k_op_and_32_re_pd(void)
2942 {
2943 uint ea = EA_AY_PD_32();
2944 uint res = DX & m68ki_read_32(ea);
2945
2946 FLAG_N = NFLAG_32(res);
2947 FLAG_Z = res;
2948 FLAG_C = CFLAG_CLEAR;
2949 FLAG_V = VFLAG_CLEAR;
2950
2951 m68ki_write_32(ea, res);
2952 }
2953
2954
m68k_op_and_32_re_di(void)2955 void m68k_op_and_32_re_di(void)
2956 {
2957 uint ea = EA_AY_DI_32();
2958 uint res = DX & m68ki_read_32(ea);
2959
2960 FLAG_N = NFLAG_32(res);
2961 FLAG_Z = res;
2962 FLAG_C = CFLAG_CLEAR;
2963 FLAG_V = VFLAG_CLEAR;
2964
2965 m68ki_write_32(ea, res);
2966 }
2967
2968
m68k_op_and_32_re_ix(void)2969 void m68k_op_and_32_re_ix(void)
2970 {
2971 uint ea = EA_AY_IX_32();
2972 uint res = DX & m68ki_read_32(ea);
2973
2974 FLAG_N = NFLAG_32(res);
2975 FLAG_Z = res;
2976 FLAG_C = CFLAG_CLEAR;
2977 FLAG_V = VFLAG_CLEAR;
2978
2979 m68ki_write_32(ea, res);
2980 }
2981
2982
m68k_op_and_32_re_aw(void)2983 void m68k_op_and_32_re_aw(void)
2984 {
2985 uint ea = EA_AW_32();
2986 uint res = DX & m68ki_read_32(ea);
2987
2988 FLAG_N = NFLAG_32(res);
2989 FLAG_Z = res;
2990 FLAG_C = CFLAG_CLEAR;
2991 FLAG_V = VFLAG_CLEAR;
2992
2993 m68ki_write_32(ea, res);
2994 }
2995
2996
m68k_op_and_32_re_al(void)2997 void m68k_op_and_32_re_al(void)
2998 {
2999 uint ea = EA_AL_32();
3000 uint res = DX & m68ki_read_32(ea);
3001
3002 FLAG_N = NFLAG_32(res);
3003 FLAG_Z = res;
3004 FLAG_C = CFLAG_CLEAR;
3005 FLAG_V = VFLAG_CLEAR;
3006
3007 m68ki_write_32(ea, res);
3008 }
3009
3010
m68k_op_andi_8_d(void)3011 void m68k_op_andi_8_d(void)
3012 {
3013 FLAG_Z = MASK_OUT_ABOVE_8(DY &= (OPER_I_8() | 0xffffff00));
3014
3015 FLAG_N = NFLAG_8(FLAG_Z);
3016 FLAG_C = CFLAG_CLEAR;
3017 FLAG_V = VFLAG_CLEAR;
3018 }
3019
3020
m68k_op_andi_8_ai(void)3021 void m68k_op_andi_8_ai(void)
3022 {
3023 uint src = OPER_I_8();
3024 uint ea = EA_AY_AI_8();
3025 uint res = src & m68ki_read_8(ea);
3026
3027 FLAG_N = NFLAG_8(res);
3028 FLAG_Z = res;
3029 FLAG_C = CFLAG_CLEAR;
3030 FLAG_V = VFLAG_CLEAR;
3031
3032 m68ki_write_8(ea, res);
3033 }
3034
3035
m68k_op_andi_8_pi(void)3036 void m68k_op_andi_8_pi(void)
3037 {
3038 uint src = OPER_I_8();
3039 uint ea = EA_AY_PI_8();
3040 uint res = src & m68ki_read_8(ea);
3041
3042 FLAG_N = NFLAG_8(res);
3043 FLAG_Z = res;
3044 FLAG_C = CFLAG_CLEAR;
3045 FLAG_V = VFLAG_CLEAR;
3046
3047 m68ki_write_8(ea, res);
3048 }
3049
3050
m68k_op_andi_8_pi7(void)3051 void m68k_op_andi_8_pi7(void)
3052 {
3053 uint src = OPER_I_8();
3054 uint ea = EA_A7_PI_8();
3055 uint res = src & m68ki_read_8(ea);
3056
3057 FLAG_N = NFLAG_8(res);
3058 FLAG_Z = res;
3059 FLAG_C = CFLAG_CLEAR;
3060 FLAG_V = VFLAG_CLEAR;
3061
3062 m68ki_write_8(ea, res);
3063 }
3064
3065
m68k_op_andi_8_pd(void)3066 void m68k_op_andi_8_pd(void)
3067 {
3068 uint src = OPER_I_8();
3069 uint ea = EA_AY_PD_8();
3070 uint res = src & m68ki_read_8(ea);
3071
3072 FLAG_N = NFLAG_8(res);
3073 FLAG_Z = res;
3074 FLAG_C = CFLAG_CLEAR;
3075 FLAG_V = VFLAG_CLEAR;
3076
3077 m68ki_write_8(ea, res);
3078 }
3079
3080
m68k_op_andi_8_pd7(void)3081 void m68k_op_andi_8_pd7(void)
3082 {
3083 uint src = OPER_I_8();
3084 uint ea = EA_A7_PD_8();
3085 uint res = src & m68ki_read_8(ea);
3086
3087 FLAG_N = NFLAG_8(res);
3088 FLAG_Z = res;
3089 FLAG_C = CFLAG_CLEAR;
3090 FLAG_V = VFLAG_CLEAR;
3091
3092 m68ki_write_8(ea, res);
3093 }
3094
3095
m68k_op_andi_8_di(void)3096 void m68k_op_andi_8_di(void)
3097 {
3098 uint src = OPER_I_8();
3099 uint ea = EA_AY_DI_8();
3100 uint res = src & m68ki_read_8(ea);
3101
3102 FLAG_N = NFLAG_8(res);
3103 FLAG_Z = res;
3104 FLAG_C = CFLAG_CLEAR;
3105 FLAG_V = VFLAG_CLEAR;
3106
3107 m68ki_write_8(ea, res);
3108 }
3109
3110
m68k_op_andi_8_ix(void)3111 void m68k_op_andi_8_ix(void)
3112 {
3113 uint src = OPER_I_8();
3114 uint ea = EA_AY_IX_8();
3115 uint res = src & m68ki_read_8(ea);
3116
3117 FLAG_N = NFLAG_8(res);
3118 FLAG_Z = res;
3119 FLAG_C = CFLAG_CLEAR;
3120 FLAG_V = VFLAG_CLEAR;
3121
3122 m68ki_write_8(ea, res);
3123 }
3124
3125
m68k_op_andi_8_aw(void)3126 void m68k_op_andi_8_aw(void)
3127 {
3128 uint src = OPER_I_8();
3129 uint ea = EA_AW_8();
3130 uint res = src & m68ki_read_8(ea);
3131
3132 FLAG_N = NFLAG_8(res);
3133 FLAG_Z = res;
3134 FLAG_C = CFLAG_CLEAR;
3135 FLAG_V = VFLAG_CLEAR;
3136
3137 m68ki_write_8(ea, res);
3138 }
3139
3140
m68k_op_andi_8_al(void)3141 void m68k_op_andi_8_al(void)
3142 {
3143 uint src = OPER_I_8();
3144 uint ea = EA_AL_8();
3145 uint res = src & m68ki_read_8(ea);
3146
3147 FLAG_N = NFLAG_8(res);
3148 FLAG_Z = res;
3149 FLAG_C = CFLAG_CLEAR;
3150 FLAG_V = VFLAG_CLEAR;
3151
3152 m68ki_write_8(ea, res);
3153 }
3154
3155
m68k_op_andi_16_d(void)3156 void m68k_op_andi_16_d(void)
3157 {
3158 FLAG_Z = MASK_OUT_ABOVE_16(DY &= (OPER_I_16() | 0xffff0000));
3159
3160 FLAG_N = NFLAG_16(FLAG_Z);
3161 FLAG_C = CFLAG_CLEAR;
3162 FLAG_V = VFLAG_CLEAR;
3163 }
3164
3165
m68k_op_andi_16_ai(void)3166 void m68k_op_andi_16_ai(void)
3167 {
3168 uint src = OPER_I_16();
3169 uint ea = EA_AY_AI_16();
3170 uint res = src & m68ki_read_16(ea);
3171
3172 FLAG_N = NFLAG_16(res);
3173 FLAG_Z = res;
3174 FLAG_C = CFLAG_CLEAR;
3175 FLAG_V = VFLAG_CLEAR;
3176
3177 m68ki_write_16(ea, res);
3178 }
3179
3180
m68k_op_andi_16_pi(void)3181 void m68k_op_andi_16_pi(void)
3182 {
3183 uint src = OPER_I_16();
3184 uint ea = EA_AY_PI_16();
3185 uint res = src & m68ki_read_16(ea);
3186
3187 FLAG_N = NFLAG_16(res);
3188 FLAG_Z = res;
3189 FLAG_C = CFLAG_CLEAR;
3190 FLAG_V = VFLAG_CLEAR;
3191
3192 m68ki_write_16(ea, res);
3193 }
3194
3195
m68k_op_andi_16_pd(void)3196 void m68k_op_andi_16_pd(void)
3197 {
3198 uint src = OPER_I_16();
3199 uint ea = EA_AY_PD_16();
3200 uint res = src & m68ki_read_16(ea);
3201
3202 FLAG_N = NFLAG_16(res);
3203 FLAG_Z = res;
3204 FLAG_C = CFLAG_CLEAR;
3205 FLAG_V = VFLAG_CLEAR;
3206
3207 m68ki_write_16(ea, res);
3208 }
3209
3210
m68k_op_andi_16_di(void)3211 void m68k_op_andi_16_di(void)
3212 {
3213 uint src = OPER_I_16();
3214 uint ea = EA_AY_DI_16();
3215 uint res = src & m68ki_read_16(ea);
3216
3217 FLAG_N = NFLAG_16(res);
3218 FLAG_Z = res;
3219 FLAG_C = CFLAG_CLEAR;
3220 FLAG_V = VFLAG_CLEAR;
3221
3222 m68ki_write_16(ea, res);
3223 }
3224
3225
m68k_op_andi_16_ix(void)3226 void m68k_op_andi_16_ix(void)
3227 {
3228 uint src = OPER_I_16();
3229 uint ea = EA_AY_IX_16();
3230 uint res = src & m68ki_read_16(ea);
3231
3232 FLAG_N = NFLAG_16(res);
3233 FLAG_Z = res;
3234 FLAG_C = CFLAG_CLEAR;
3235 FLAG_V = VFLAG_CLEAR;
3236
3237 m68ki_write_16(ea, res);
3238 }
3239
3240
m68k_op_andi_16_aw(void)3241 void m68k_op_andi_16_aw(void)
3242 {
3243 uint src = OPER_I_16();
3244 uint ea = EA_AW_16();
3245 uint res = src & m68ki_read_16(ea);
3246
3247 FLAG_N = NFLAG_16(res);
3248 FLAG_Z = res;
3249 FLAG_C = CFLAG_CLEAR;
3250 FLAG_V = VFLAG_CLEAR;
3251
3252 m68ki_write_16(ea, res);
3253 }
3254
3255
m68k_op_andi_16_al(void)3256 void m68k_op_andi_16_al(void)
3257 {
3258 uint src = OPER_I_16();
3259 uint ea = EA_AL_16();
3260 uint res = src & m68ki_read_16(ea);
3261
3262 FLAG_N = NFLAG_16(res);
3263 FLAG_Z = res;
3264 FLAG_C = CFLAG_CLEAR;
3265 FLAG_V = VFLAG_CLEAR;
3266
3267 m68ki_write_16(ea, res);
3268 }
3269
3270
m68k_op_andi_32_d(void)3271 void m68k_op_andi_32_d(void)
3272 {
3273 FLAG_Z = DY &= (OPER_I_32());
3274
3275 FLAG_N = NFLAG_32(FLAG_Z);
3276 FLAG_C = CFLAG_CLEAR;
3277 FLAG_V = VFLAG_CLEAR;
3278 }
3279
3280
m68k_op_andi_32_ai(void)3281 void m68k_op_andi_32_ai(void)
3282 {
3283 uint src = OPER_I_32();
3284 uint ea = EA_AY_AI_32();
3285 uint res = src & m68ki_read_32(ea);
3286
3287 FLAG_N = NFLAG_32(res);
3288 FLAG_Z = res;
3289 FLAG_C = CFLAG_CLEAR;
3290 FLAG_V = VFLAG_CLEAR;
3291
3292 m68ki_write_32(ea, res);
3293 }
3294
3295
m68k_op_andi_32_pi(void)3296 void m68k_op_andi_32_pi(void)
3297 {
3298 uint src = OPER_I_32();
3299 uint ea = EA_AY_PI_32();
3300 uint res = src & m68ki_read_32(ea);
3301
3302 FLAG_N = NFLAG_32(res);
3303 FLAG_Z = res;
3304 FLAG_C = CFLAG_CLEAR;
3305 FLAG_V = VFLAG_CLEAR;
3306
3307 m68ki_write_32(ea, res);
3308 }
3309
3310
m68k_op_andi_32_pd(void)3311 void m68k_op_andi_32_pd(void)
3312 {
3313 uint src = OPER_I_32();
3314 uint ea = EA_AY_PD_32();
3315 uint res = src & m68ki_read_32(ea);
3316
3317 FLAG_N = NFLAG_32(res);
3318 FLAG_Z = res;
3319 FLAG_C = CFLAG_CLEAR;
3320 FLAG_V = VFLAG_CLEAR;
3321
3322 m68ki_write_32(ea, res);
3323 }
3324
3325
m68k_op_andi_32_di(void)3326 void m68k_op_andi_32_di(void)
3327 {
3328 uint src = OPER_I_32();
3329 uint ea = EA_AY_DI_32();
3330 uint res = src & m68ki_read_32(ea);
3331
3332 FLAG_N = NFLAG_32(res);
3333 FLAG_Z = res;
3334 FLAG_C = CFLAG_CLEAR;
3335 FLAG_V = VFLAG_CLEAR;
3336
3337 m68ki_write_32(ea, res);
3338 }
3339
3340
m68k_op_andi_32_ix(void)3341 void m68k_op_andi_32_ix(void)
3342 {
3343 uint src = OPER_I_32();
3344 uint ea = EA_AY_IX_32();
3345 uint res = src & m68ki_read_32(ea);
3346
3347 FLAG_N = NFLAG_32(res);
3348 FLAG_Z = res;
3349 FLAG_C = CFLAG_CLEAR;
3350 FLAG_V = VFLAG_CLEAR;
3351
3352 m68ki_write_32(ea, res);
3353 }
3354
3355
m68k_op_andi_32_aw(void)3356 void m68k_op_andi_32_aw(void)
3357 {
3358 uint src = OPER_I_32();
3359 uint ea = EA_AW_32();
3360 uint res = src & m68ki_read_32(ea);
3361
3362 FLAG_N = NFLAG_32(res);
3363 FLAG_Z = res;
3364 FLAG_C = CFLAG_CLEAR;
3365 FLAG_V = VFLAG_CLEAR;
3366
3367 m68ki_write_32(ea, res);
3368 }
3369
3370
m68k_op_andi_32_al(void)3371 void m68k_op_andi_32_al(void)
3372 {
3373 uint src = OPER_I_32();
3374 uint ea = EA_AL_32();
3375 uint res = src & m68ki_read_32(ea);
3376
3377 FLAG_N = NFLAG_32(res);
3378 FLAG_Z = res;
3379 FLAG_C = CFLAG_CLEAR;
3380 FLAG_V = VFLAG_CLEAR;
3381
3382 m68ki_write_32(ea, res);
3383 }
3384
3385
m68k_op_andi_8_toc(void)3386 void m68k_op_andi_8_toc(void)
3387 {
3388 m68ki_set_ccr(m68ki_get_ccr() & OPER_I_8());
3389 }
3390
3391
m68k_op_andi_16_tos(void)3392 void m68k_op_andi_16_tos(void)
3393 {
3394 if(FLAG_S)
3395 {
3396 uint src = OPER_I_16();
3397 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
3398 m68ki_set_sr(m68ki_get_sr() & src);
3399 return;
3400 }
3401 m68ki_exception_privilege_violation();
3402 }
3403
3404
m68k_op_asr_8_s(void)3405 void m68k_op_asr_8_s(void)
3406 {
3407 uint* r_dst = &DY;
3408 uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3409 uint src = MASK_OUT_ABOVE_8(*r_dst);
3410 uint res = src >> shift;
3411
3412 if(GET_MSB_8(src))
3413 res |= m68ki_shift_8_table[shift];
3414
3415 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3416
3417 FLAG_N = NFLAG_8(res);
3418 FLAG_Z = res;
3419 FLAG_V = VFLAG_CLEAR;
3420 FLAG_X = FLAG_C = src << (9-shift);
3421 }
3422
3423
m68k_op_asr_16_s(void)3424 void m68k_op_asr_16_s(void)
3425 {
3426 uint* r_dst = &DY;
3427 uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3428 uint src = MASK_OUT_ABOVE_16(*r_dst);
3429 uint res = src >> shift;
3430
3431 if(GET_MSB_16(src))
3432 res |= m68ki_shift_16_table[shift];
3433
3434 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3435
3436 FLAG_N = NFLAG_16(res);
3437 FLAG_Z = res;
3438 FLAG_V = VFLAG_CLEAR;
3439 FLAG_X = FLAG_C = src << (9-shift);
3440 }
3441
3442
m68k_op_asr_32_s(void)3443 void m68k_op_asr_32_s(void)
3444 {
3445 uint* r_dst = &DY;
3446 uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3447 uint src = *r_dst;
3448 uint res = src >> shift;
3449
3450 if(GET_MSB_32(src))
3451 res |= m68ki_shift_32_table[shift];
3452
3453 *r_dst = res;
3454
3455 FLAG_N = NFLAG_32(res);
3456 FLAG_Z = res;
3457 FLAG_V = VFLAG_CLEAR;
3458 FLAG_X = FLAG_C = src << (9-shift);
3459 }
3460
3461
m68k_op_asr_8_r(void)3462 void m68k_op_asr_8_r(void)
3463 {
3464 uint* r_dst = &DY;
3465 uint shift = DX & 0x3f;
3466 uint src = MASK_OUT_ABOVE_8(*r_dst);
3467 uint res = src >> shift;
3468
3469 if(shift != 0)
3470 {
3471 USE_CYCLES(shift<<CYC_SHIFT);
3472
3473 if(shift < 8)
3474 {
3475 if(GET_MSB_8(src))
3476 res |= m68ki_shift_8_table[shift];
3477
3478 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3479
3480 FLAG_X = FLAG_C = src << (9-shift);
3481 FLAG_N = NFLAG_8(res);
3482 FLAG_Z = res;
3483 FLAG_V = VFLAG_CLEAR;
3484 return;
3485 }
3486
3487 if(GET_MSB_8(src))
3488 {
3489 *r_dst |= 0xff;
3490 FLAG_C = CFLAG_SET;
3491 FLAG_X = XFLAG_SET;
3492 FLAG_N = NFLAG_SET;
3493 FLAG_Z = ZFLAG_CLEAR;
3494 FLAG_V = VFLAG_CLEAR;
3495 return;
3496 }
3497
3498 *r_dst &= 0xffffff00;
3499 FLAG_C = CFLAG_CLEAR;
3500 FLAG_X = XFLAG_CLEAR;
3501 FLAG_N = NFLAG_CLEAR;
3502 FLAG_Z = ZFLAG_SET;
3503 FLAG_V = VFLAG_CLEAR;
3504 return;
3505 }
3506
3507 FLAG_C = CFLAG_CLEAR;
3508 FLAG_N = NFLAG_8(src);
3509 FLAG_Z = src;
3510 FLAG_V = VFLAG_CLEAR;
3511 }
3512
3513
m68k_op_asr_16_r(void)3514 void m68k_op_asr_16_r(void)
3515 {
3516 uint* r_dst = &DY;
3517 uint shift = DX & 0x3f;
3518 uint src = MASK_OUT_ABOVE_16(*r_dst);
3519 uint res = src >> shift;
3520
3521 if(shift != 0)
3522 {
3523 USE_CYCLES(shift<<CYC_SHIFT);
3524
3525 if(shift < 16)
3526 {
3527 if(GET_MSB_16(src))
3528 res |= m68ki_shift_16_table[shift];
3529
3530 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3531
3532 FLAG_C = FLAG_X = (src >> (shift - 1))<<8;
3533 FLAG_N = NFLAG_16(res);
3534 FLAG_Z = res;
3535 FLAG_V = VFLAG_CLEAR;
3536 return;
3537 }
3538
3539 if(GET_MSB_16(src))
3540 {
3541 *r_dst |= 0xffff;
3542 FLAG_C = CFLAG_SET;
3543 FLAG_X = XFLAG_SET;
3544 FLAG_N = NFLAG_SET;
3545 FLAG_Z = ZFLAG_CLEAR;
3546 FLAG_V = VFLAG_CLEAR;
3547 return;
3548 }
3549
3550 *r_dst &= 0xffff0000;
3551 FLAG_C = CFLAG_CLEAR;
3552 FLAG_X = XFLAG_CLEAR;
3553 FLAG_N = NFLAG_CLEAR;
3554 FLAG_Z = ZFLAG_SET;
3555 FLAG_V = VFLAG_CLEAR;
3556 return;
3557 }
3558
3559 FLAG_C = CFLAG_CLEAR;
3560 FLAG_N = NFLAG_16(src);
3561 FLAG_Z = src;
3562 FLAG_V = VFLAG_CLEAR;
3563 }
3564
3565
m68k_op_asr_32_r(void)3566 void m68k_op_asr_32_r(void)
3567 {
3568 uint* r_dst = &DY;
3569 uint shift = DX & 0x3f;
3570 uint src = *r_dst;
3571 uint res = src >> shift;
3572
3573 if(shift != 0)
3574 {
3575 USE_CYCLES(shift<<CYC_SHIFT);
3576
3577 if(shift < 32)
3578 {
3579 if(GET_MSB_32(src))
3580 res |= m68ki_shift_32_table[shift];
3581
3582 *r_dst = res;
3583
3584 FLAG_C = FLAG_X = (src >> (shift - 1))<<8;
3585 FLAG_N = NFLAG_32(res);
3586 FLAG_Z = res;
3587 FLAG_V = VFLAG_CLEAR;
3588 return;
3589 }
3590
3591 if(GET_MSB_32(src))
3592 {
3593 *r_dst = 0xffffffff;
3594 FLAG_C = CFLAG_SET;
3595 FLAG_X = XFLAG_SET;
3596 FLAG_N = NFLAG_SET;
3597 FLAG_Z = ZFLAG_CLEAR;
3598 FLAG_V = VFLAG_CLEAR;
3599 return;
3600 }
3601
3602 *r_dst = 0;
3603 FLAG_C = CFLAG_CLEAR;
3604 FLAG_X = XFLAG_CLEAR;
3605 FLAG_N = NFLAG_CLEAR;
3606 FLAG_Z = ZFLAG_SET;
3607 FLAG_V = VFLAG_CLEAR;
3608 return;
3609 }
3610
3611 FLAG_C = CFLAG_CLEAR;
3612 FLAG_N = NFLAG_32(src);
3613 FLAG_Z = src;
3614 FLAG_V = VFLAG_CLEAR;
3615 }
3616
3617
m68k_op_asr_16_ai(void)3618 void m68k_op_asr_16_ai(void)
3619 {
3620 uint ea = EA_AY_AI_16();
3621 uint src = m68ki_read_16(ea);
3622 uint res = src >> 1;
3623
3624 if(GET_MSB_16(src))
3625 res |= 0x8000;
3626
3627 m68ki_write_16(ea, res);
3628
3629 FLAG_N = NFLAG_16(res);
3630 FLAG_Z = res;
3631 FLAG_V = VFLAG_CLEAR;
3632 FLAG_C = FLAG_X = src << 8;
3633 }
3634
3635
m68k_op_asr_16_pi(void)3636 void m68k_op_asr_16_pi(void)
3637 {
3638 uint ea = EA_AY_PI_16();
3639 uint src = m68ki_read_16(ea);
3640 uint res = src >> 1;
3641
3642 if(GET_MSB_16(src))
3643 res |= 0x8000;
3644
3645 m68ki_write_16(ea, res);
3646
3647 FLAG_N = NFLAG_16(res);
3648 FLAG_Z = res;
3649 FLAG_V = VFLAG_CLEAR;
3650 FLAG_C = FLAG_X = src << 8;
3651 }
3652
3653
m68k_op_asr_16_pd(void)3654 void m68k_op_asr_16_pd(void)
3655 {
3656 uint ea = EA_AY_PD_16();
3657 uint src = m68ki_read_16(ea);
3658 uint res = src >> 1;
3659
3660 if(GET_MSB_16(src))
3661 res |= 0x8000;
3662
3663 m68ki_write_16(ea, res);
3664
3665 FLAG_N = NFLAG_16(res);
3666 FLAG_Z = res;
3667 FLAG_V = VFLAG_CLEAR;
3668 FLAG_C = FLAG_X = src << 8;
3669 }
3670
3671
m68k_op_asr_16_di(void)3672 void m68k_op_asr_16_di(void)
3673 {
3674 uint ea = EA_AY_DI_16();
3675 uint src = m68ki_read_16(ea);
3676 uint res = src >> 1;
3677
3678 if(GET_MSB_16(src))
3679 res |= 0x8000;
3680
3681 m68ki_write_16(ea, res);
3682
3683 FLAG_N = NFLAG_16(res);
3684 FLAG_Z = res;
3685 FLAG_V = VFLAG_CLEAR;
3686 FLAG_C = FLAG_X = src << 8;
3687 }
3688
3689
m68k_op_asr_16_ix(void)3690 void m68k_op_asr_16_ix(void)
3691 {
3692 uint ea = EA_AY_IX_16();
3693 uint src = m68ki_read_16(ea);
3694 uint res = src >> 1;
3695
3696 if(GET_MSB_16(src))
3697 res |= 0x8000;
3698
3699 m68ki_write_16(ea, res);
3700
3701 FLAG_N = NFLAG_16(res);
3702 FLAG_Z = res;
3703 FLAG_V = VFLAG_CLEAR;
3704 FLAG_C = FLAG_X = src << 8;
3705 }
3706
3707
m68k_op_asr_16_aw(void)3708 void m68k_op_asr_16_aw(void)
3709 {
3710 uint ea = EA_AW_16();
3711 uint src = m68ki_read_16(ea);
3712 uint res = src >> 1;
3713
3714 if(GET_MSB_16(src))
3715 res |= 0x8000;
3716
3717 m68ki_write_16(ea, res);
3718
3719 FLAG_N = NFLAG_16(res);
3720 FLAG_Z = res;
3721 FLAG_V = VFLAG_CLEAR;
3722 FLAG_C = FLAG_X = src << 8;
3723 }
3724
3725
m68k_op_asr_16_al(void)3726 void m68k_op_asr_16_al(void)
3727 {
3728 uint ea = EA_AL_16();
3729 uint src = m68ki_read_16(ea);
3730 uint res = src >> 1;
3731
3732 if(GET_MSB_16(src))
3733 res |= 0x8000;
3734
3735 m68ki_write_16(ea, res);
3736
3737 FLAG_N = NFLAG_16(res);
3738 FLAG_Z = res;
3739 FLAG_V = VFLAG_CLEAR;
3740 FLAG_C = FLAG_X = src << 8;
3741 }
3742
3743
m68k_op_asl_8_s(void)3744 void m68k_op_asl_8_s(void)
3745 {
3746 uint* r_dst = &DY;
3747 uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3748 uint src = MASK_OUT_ABOVE_8(*r_dst);
3749 uint res = MASK_OUT_ABOVE_8(src << shift);
3750
3751 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3752
3753 FLAG_X = FLAG_C = src << shift;
3754 FLAG_N = NFLAG_8(res);
3755 FLAG_Z = res;
3756 src &= m68ki_shift_8_table[shift + 1];
3757 FLAG_V = (!(src == 0 || (src == m68ki_shift_8_table[shift + 1] && shift < 8)))<<7;
3758 }
3759
3760
m68k_op_asl_16_s(void)3761 void m68k_op_asl_16_s(void)
3762 {
3763 uint* r_dst = &DY;
3764 uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3765 uint src = MASK_OUT_ABOVE_16(*r_dst);
3766 uint res = MASK_OUT_ABOVE_16(src << shift);
3767
3768 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3769
3770 FLAG_N = NFLAG_16(res);
3771 FLAG_Z = res;
3772 FLAG_X = FLAG_C = src >> (8-shift);
3773 src &= m68ki_shift_16_table[shift + 1];
3774 FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7;
3775 }
3776
3777
m68k_op_asl_32_s(void)3778 void m68k_op_asl_32_s(void)
3779 {
3780 uint* r_dst = &DY;
3781 uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
3782 uint src = *r_dst;
3783 uint res = MASK_OUT_ABOVE_32(src << shift);
3784
3785 *r_dst = res;
3786
3787 FLAG_N = NFLAG_32(res);
3788 FLAG_Z = res;
3789 FLAG_X = FLAG_C = src >> (24-shift);
3790 src &= m68ki_shift_32_table[shift + 1];
3791 FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7;
3792 }
3793
3794
m68k_op_asl_8_r(void)3795 void m68k_op_asl_8_r(void)
3796 {
3797 uint* r_dst = &DY;
3798 uint shift = DX & 0x3f;
3799 uint src = MASK_OUT_ABOVE_8(*r_dst);
3800 uint res = MASK_OUT_ABOVE_8(src << shift);
3801
3802 if(shift != 0)
3803 {
3804 USE_CYCLES(shift<<CYC_SHIFT);
3805
3806 if(shift < 8)
3807 {
3808 *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
3809 FLAG_X = FLAG_C = src << shift;
3810 FLAG_N = NFLAG_8(res);
3811 FLAG_Z = res;
3812 src &= m68ki_shift_8_table[shift + 1];
3813 FLAG_V = (!(src == 0 || src == m68ki_shift_8_table[shift + 1]))<<7;
3814 return;
3815 }
3816
3817 *r_dst &= 0xffffff00;
3818 FLAG_X = FLAG_C = ((shift == 8 ? src & 1 : 0))<<8;
3819 FLAG_N = NFLAG_CLEAR;
3820 FLAG_Z = ZFLAG_SET;
3821 FLAG_V = (!(src == 0))<<7;
3822 return;
3823 }
3824
3825 FLAG_C = CFLAG_CLEAR;
3826 FLAG_N = NFLAG_8(src);
3827 FLAG_Z = src;
3828 FLAG_V = VFLAG_CLEAR;
3829 }
3830
3831
m68k_op_asl_16_r(void)3832 void m68k_op_asl_16_r(void)
3833 {
3834 uint* r_dst = &DY;
3835 uint shift = DX & 0x3f;
3836 uint src = MASK_OUT_ABOVE_16(*r_dst);
3837 uint res = MASK_OUT_ABOVE_16(src << shift);
3838
3839 if(shift != 0)
3840 {
3841 USE_CYCLES(shift<<CYC_SHIFT);
3842
3843 if(shift < 16)
3844 {
3845 *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
3846 FLAG_X = FLAG_C = (src << shift) >> 8;
3847 FLAG_N = NFLAG_16(res);
3848 FLAG_Z = res;
3849 src &= m68ki_shift_16_table[shift + 1];
3850 FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7;
3851 return;
3852 }
3853
3854 *r_dst &= 0xffff0000;
3855 FLAG_X = FLAG_C = ((shift == 16 ? src & 1 : 0))<<8;
3856 FLAG_N = NFLAG_CLEAR;
3857 FLAG_Z = ZFLAG_SET;
3858 FLAG_V = (!(src == 0))<<7;
3859 return;
3860 }
3861
3862 FLAG_C = CFLAG_CLEAR;
3863 FLAG_N = NFLAG_16(src);
3864 FLAG_Z = src;
3865 FLAG_V = VFLAG_CLEAR;
3866 }
3867
3868
m68k_op_asl_32_r(void)3869 void m68k_op_asl_32_r(void)
3870 {
3871 uint* r_dst = &DY;
3872 uint shift = DX & 0x3f;
3873 uint src = *r_dst;
3874 uint res = MASK_OUT_ABOVE_32(src << shift);
3875
3876 if(shift != 0)
3877 {
3878 USE_CYCLES(shift<<CYC_SHIFT);
3879
3880 if(shift < 32)
3881 {
3882 *r_dst = res;
3883 FLAG_X = FLAG_C = (src >> (32 - shift)) << 8;
3884 FLAG_N = NFLAG_32(res);
3885 FLAG_Z = res;
3886 src &= m68ki_shift_32_table[shift + 1];
3887 FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7;
3888 return;
3889 }
3890
3891 *r_dst = 0;
3892 FLAG_X = FLAG_C = ((shift == 32 ? src & 1 : 0))<<8;
3893 FLAG_N = NFLAG_CLEAR;
3894 FLAG_Z = ZFLAG_SET;
3895 FLAG_V = (!(src == 0))<<7;
3896 return;
3897 }
3898
3899 FLAG_C = CFLAG_CLEAR;
3900 FLAG_N = NFLAG_32(src);
3901 FLAG_Z = src;
3902 FLAG_V = VFLAG_CLEAR;
3903 }
3904
3905
m68k_op_asl_16_ai(void)3906 void m68k_op_asl_16_ai(void)
3907 {
3908 uint ea = EA_AY_AI_16();
3909 uint src = m68ki_read_16(ea);
3910 uint res = MASK_OUT_ABOVE_16(src << 1);
3911
3912 m68ki_write_16(ea, res);
3913
3914 FLAG_N = NFLAG_16(res);
3915 FLAG_Z = res;
3916 FLAG_X = FLAG_C = src >> 7;
3917 src &= 0xc000;
3918 FLAG_V = (!(src == 0 || src == 0xc000))<<7;
3919 }
3920
3921
m68k_op_asl_16_pi(void)3922 void m68k_op_asl_16_pi(void)
3923 {
3924 uint ea = EA_AY_PI_16();
3925 uint src = m68ki_read_16(ea);
3926 uint res = MASK_OUT_ABOVE_16(src << 1);
3927
3928 m68ki_write_16(ea, res);
3929
3930 FLAG_N = NFLAG_16(res);
3931 FLAG_Z = res;
3932 FLAG_X = FLAG_C = src >> 7;
3933 src &= 0xc000;
3934 FLAG_V = (!(src == 0 || src == 0xc000))<<7;
3935 }
3936
3937
m68k_op_asl_16_pd(void)3938 void m68k_op_asl_16_pd(void)
3939 {
3940 uint ea = EA_AY_PD_16();
3941 uint src = m68ki_read_16(ea);
3942 uint res = MASK_OUT_ABOVE_16(src << 1);
3943
3944 m68ki_write_16(ea, res);
3945
3946 FLAG_N = NFLAG_16(res);
3947 FLAG_Z = res;
3948 FLAG_X = FLAG_C = src >> 7;
3949 src &= 0xc000;
3950 FLAG_V = (!(src == 0 || src == 0xc000))<<7;
3951 }
3952
3953
m68k_op_asl_16_di(void)3954 void m68k_op_asl_16_di(void)
3955 {
3956 uint ea = EA_AY_DI_16();
3957 uint src = m68ki_read_16(ea);
3958 uint res = MASK_OUT_ABOVE_16(src << 1);
3959
3960 m68ki_write_16(ea, res);
3961
3962 FLAG_N = NFLAG_16(res);
3963 FLAG_Z = res;
3964 FLAG_X = FLAG_C = src >> 7;
3965 src &= 0xc000;
3966 FLAG_V = (!(src == 0 || src == 0xc000))<<7;
3967 }
3968
3969
m68k_op_asl_16_ix(void)3970 void m68k_op_asl_16_ix(void)
3971 {
3972 uint ea = EA_AY_IX_16();
3973 uint src = m68ki_read_16(ea);
3974 uint res = MASK_OUT_ABOVE_16(src << 1);
3975
3976 m68ki_write_16(ea, res);
3977
3978 FLAG_N = NFLAG_16(res);
3979 FLAG_Z = res;
3980 FLAG_X = FLAG_C = src >> 7;
3981 src &= 0xc000;
3982 FLAG_V = (!(src == 0 || src == 0xc000))<<7;
3983 }
3984
3985
m68k_op_asl_16_aw(void)3986 void m68k_op_asl_16_aw(void)
3987 {
3988 uint ea = EA_AW_16();
3989 uint src = m68ki_read_16(ea);
3990 uint res = MASK_OUT_ABOVE_16(src << 1);
3991
3992 m68ki_write_16(ea, res);
3993
3994 FLAG_N = NFLAG_16(res);
3995 FLAG_Z = res;
3996 FLAG_X = FLAG_C = src >> 7;
3997 src &= 0xc000;
3998 FLAG_V = (!(src == 0 || src == 0xc000))<<7;
3999 }
4000
4001
m68k_op_asl_16_al(void)4002 void m68k_op_asl_16_al(void)
4003 {
4004 uint ea = EA_AL_16();
4005 uint src = m68ki_read_16(ea);
4006 uint res = MASK_OUT_ABOVE_16(src << 1);
4007
4008 m68ki_write_16(ea, res);
4009
4010 FLAG_N = NFLAG_16(res);
4011 FLAG_Z = res;
4012 FLAG_X = FLAG_C = src >> 7;
4013 src &= 0xc000;
4014 FLAG_V = (!(src == 0 || src == 0xc000))<<7;
4015 }
4016
4017
m68k_op_bhi_8(void)4018 void m68k_op_bhi_8(void)
4019 {
4020 if(COND_HI())
4021 {
4022 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4023 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4024 return;
4025 }
4026 USE_CYCLES(CYC_BCC_NOTAKE_B);
4027 }
4028
4029
m68k_op_bls_8(void)4030 void m68k_op_bls_8(void)
4031 {
4032 if(COND_LS())
4033 {
4034 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4035 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4036 return;
4037 }
4038 USE_CYCLES(CYC_BCC_NOTAKE_B);
4039 }
4040
4041
m68k_op_bcc_8(void)4042 void m68k_op_bcc_8(void)
4043 {
4044 if(COND_CC())
4045 {
4046 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4047 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4048 return;
4049 }
4050 USE_CYCLES(CYC_BCC_NOTAKE_B);
4051 }
4052
4053
m68k_op_bcs_8(void)4054 void m68k_op_bcs_8(void)
4055 {
4056 if(COND_CS())
4057 {
4058 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4059 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4060 return;
4061 }
4062 USE_CYCLES(CYC_BCC_NOTAKE_B);
4063 }
4064
4065
m68k_op_bne_8(void)4066 void m68k_op_bne_8(void)
4067 {
4068 if(COND_NE())
4069 {
4070 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4071 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4072 return;
4073 }
4074 USE_CYCLES(CYC_BCC_NOTAKE_B);
4075 }
4076
4077
m68k_op_beq_8(void)4078 void m68k_op_beq_8(void)
4079 {
4080 if(COND_EQ())
4081 {
4082 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4083 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4084 return;
4085 }
4086 USE_CYCLES(CYC_BCC_NOTAKE_B);
4087 }
4088
4089
m68k_op_bvc_8(void)4090 void m68k_op_bvc_8(void)
4091 {
4092 if(COND_VC())
4093 {
4094 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4095 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4096 return;
4097 }
4098 USE_CYCLES(CYC_BCC_NOTAKE_B);
4099 }
4100
4101
m68k_op_bvs_8(void)4102 void m68k_op_bvs_8(void)
4103 {
4104 if(COND_VS())
4105 {
4106 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4107 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4108 return;
4109 }
4110 USE_CYCLES(CYC_BCC_NOTAKE_B);
4111 }
4112
4113
m68k_op_bpl_8(void)4114 void m68k_op_bpl_8(void)
4115 {
4116 if(COND_PL())
4117 {
4118 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4119 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4120 return;
4121 }
4122 USE_CYCLES(CYC_BCC_NOTAKE_B);
4123 }
4124
4125
m68k_op_bmi_8(void)4126 void m68k_op_bmi_8(void)
4127 {
4128 if(COND_MI())
4129 {
4130 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4131 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4132 return;
4133 }
4134 USE_CYCLES(CYC_BCC_NOTAKE_B);
4135 }
4136
4137
m68k_op_bge_8(void)4138 void m68k_op_bge_8(void)
4139 {
4140 if(COND_GE())
4141 {
4142 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4143 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4144 return;
4145 }
4146 USE_CYCLES(CYC_BCC_NOTAKE_B);
4147 }
4148
4149
m68k_op_blt_8(void)4150 void m68k_op_blt_8(void)
4151 {
4152 if(COND_LT())
4153 {
4154 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4155 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4156 return;
4157 }
4158 USE_CYCLES(CYC_BCC_NOTAKE_B);
4159 }
4160
4161
m68k_op_bgt_8(void)4162 void m68k_op_bgt_8(void)
4163 {
4164 if(COND_GT())
4165 {
4166 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4167 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4168 return;
4169 }
4170 USE_CYCLES(CYC_BCC_NOTAKE_B);
4171 }
4172
4173
m68k_op_ble_8(void)4174 void m68k_op_ble_8(void)
4175 {
4176 if(COND_LE())
4177 {
4178 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4179 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
4180 return;
4181 }
4182 USE_CYCLES(CYC_BCC_NOTAKE_B);
4183 }
4184
4185
m68k_op_bhi_16(void)4186 void m68k_op_bhi_16(void)
4187 {
4188 if(COND_HI())
4189 {
4190 uint offset = OPER_I_16();
4191 REG_PC -= 2;
4192 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4193 m68ki_branch_16(offset);
4194 return;
4195 }
4196 REG_PC += 2;
4197 USE_CYCLES(CYC_BCC_NOTAKE_W);
4198 }
4199
4200
m68k_op_bls_16(void)4201 void m68k_op_bls_16(void)
4202 {
4203 if(COND_LS())
4204 {
4205 uint offset = OPER_I_16();
4206 REG_PC -= 2;
4207 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4208 m68ki_branch_16(offset);
4209 return;
4210 }
4211 REG_PC += 2;
4212 USE_CYCLES(CYC_BCC_NOTAKE_W);
4213 }
4214
4215
m68k_op_bcc_16(void)4216 void m68k_op_bcc_16(void)
4217 {
4218 if(COND_CC())
4219 {
4220 uint offset = OPER_I_16();
4221 REG_PC -= 2;
4222 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4223 m68ki_branch_16(offset);
4224 return;
4225 }
4226 REG_PC += 2;
4227 USE_CYCLES(CYC_BCC_NOTAKE_W);
4228 }
4229
4230
m68k_op_bcs_16(void)4231 void m68k_op_bcs_16(void)
4232 {
4233 if(COND_CS())
4234 {
4235 uint offset = OPER_I_16();
4236 REG_PC -= 2;
4237 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4238 m68ki_branch_16(offset);
4239 return;
4240 }
4241 REG_PC += 2;
4242 USE_CYCLES(CYC_BCC_NOTAKE_W);
4243 }
4244
4245
m68k_op_bne_16(void)4246 void m68k_op_bne_16(void)
4247 {
4248 if(COND_NE())
4249 {
4250 uint offset = OPER_I_16();
4251 REG_PC -= 2;
4252 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4253 m68ki_branch_16(offset);
4254 return;
4255 }
4256 REG_PC += 2;
4257 USE_CYCLES(CYC_BCC_NOTAKE_W);
4258 }
4259
4260
m68k_op_beq_16(void)4261 void m68k_op_beq_16(void)
4262 {
4263 if(COND_EQ())
4264 {
4265 uint offset = OPER_I_16();
4266 REG_PC -= 2;
4267 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4268 m68ki_branch_16(offset);
4269 return;
4270 }
4271 REG_PC += 2;
4272 USE_CYCLES(CYC_BCC_NOTAKE_W);
4273 }
4274
4275
m68k_op_bvc_16(void)4276 void m68k_op_bvc_16(void)
4277 {
4278 if(COND_VC())
4279 {
4280 uint offset = OPER_I_16();
4281 REG_PC -= 2;
4282 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4283 m68ki_branch_16(offset);
4284 return;
4285 }
4286 REG_PC += 2;
4287 USE_CYCLES(CYC_BCC_NOTAKE_W);
4288 }
4289
4290
m68k_op_bvs_16(void)4291 void m68k_op_bvs_16(void)
4292 {
4293 if(COND_VS())
4294 {
4295 uint offset = OPER_I_16();
4296 REG_PC -= 2;
4297 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4298 m68ki_branch_16(offset);
4299 return;
4300 }
4301 REG_PC += 2;
4302 USE_CYCLES(CYC_BCC_NOTAKE_W);
4303 }
4304
4305
m68k_op_bpl_16(void)4306 void m68k_op_bpl_16(void)
4307 {
4308 if(COND_PL())
4309 {
4310 uint offset = OPER_I_16();
4311 REG_PC -= 2;
4312 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4313 m68ki_branch_16(offset);
4314 return;
4315 }
4316 REG_PC += 2;
4317 USE_CYCLES(CYC_BCC_NOTAKE_W);
4318 }
4319
4320
m68k_op_bmi_16(void)4321 void m68k_op_bmi_16(void)
4322 {
4323 if(COND_MI())
4324 {
4325 uint offset = OPER_I_16();
4326 REG_PC -= 2;
4327 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4328 m68ki_branch_16(offset);
4329 return;
4330 }
4331 REG_PC += 2;
4332 USE_CYCLES(CYC_BCC_NOTAKE_W);
4333 }
4334
4335
m68k_op_bge_16(void)4336 void m68k_op_bge_16(void)
4337 {
4338 if(COND_GE())
4339 {
4340 uint offset = OPER_I_16();
4341 REG_PC -= 2;
4342 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4343 m68ki_branch_16(offset);
4344 return;
4345 }
4346 REG_PC += 2;
4347 USE_CYCLES(CYC_BCC_NOTAKE_W);
4348 }
4349
4350
m68k_op_blt_16(void)4351 void m68k_op_blt_16(void)
4352 {
4353 if(COND_LT())
4354 {
4355 uint offset = OPER_I_16();
4356 REG_PC -= 2;
4357 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4358 m68ki_branch_16(offset);
4359 return;
4360 }
4361 REG_PC += 2;
4362 USE_CYCLES(CYC_BCC_NOTAKE_W);
4363 }
4364
4365
m68k_op_bgt_16(void)4366 void m68k_op_bgt_16(void)
4367 {
4368 if(COND_GT())
4369 {
4370 uint offset = OPER_I_16();
4371 REG_PC -= 2;
4372 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4373 m68ki_branch_16(offset);
4374 return;
4375 }
4376 REG_PC += 2;
4377 USE_CYCLES(CYC_BCC_NOTAKE_W);
4378 }
4379
4380
m68k_op_ble_16(void)4381 void m68k_op_ble_16(void)
4382 {
4383 if(COND_LE())
4384 {
4385 uint offset = OPER_I_16();
4386 REG_PC -= 2;
4387 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4388 m68ki_branch_16(offset);
4389 return;
4390 }
4391 REG_PC += 2;
4392 USE_CYCLES(CYC_BCC_NOTAKE_W);
4393 }
4394
4395
m68k_op_bhi_32(void)4396 void m68k_op_bhi_32(void)
4397 {
4398 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4399 {
4400 if(COND_HI())
4401 {
4402 uint offset = OPER_I_32();
4403 REG_PC -= 4;
4404 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4405 m68ki_branch_32(offset);
4406 return;
4407 }
4408 REG_PC += 4;
4409 return;
4410 }
4411 m68ki_exception_illegal();
4412 }
4413
4414
m68k_op_bls_32(void)4415 void m68k_op_bls_32(void)
4416 {
4417 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4418 {
4419 if(COND_LS())
4420 {
4421 uint offset = OPER_I_32();
4422 REG_PC -= 4;
4423 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4424 m68ki_branch_32(offset);
4425 return;
4426 }
4427 REG_PC += 4;
4428 return;
4429 }
4430 m68ki_exception_illegal();
4431 }
4432
4433
m68k_op_bcc_32(void)4434 void m68k_op_bcc_32(void)
4435 {
4436 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4437 {
4438 if(COND_CC())
4439 {
4440 uint offset = OPER_I_32();
4441 REG_PC -= 4;
4442 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4443 m68ki_branch_32(offset);
4444 return;
4445 }
4446 REG_PC += 4;
4447 return;
4448 }
4449 m68ki_exception_illegal();
4450 }
4451
4452
m68k_op_bcs_32(void)4453 void m68k_op_bcs_32(void)
4454 {
4455 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4456 {
4457 if(COND_CS())
4458 {
4459 uint offset = OPER_I_32();
4460 REG_PC -= 4;
4461 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4462 m68ki_branch_32(offset);
4463 return;
4464 }
4465 REG_PC += 4;
4466 return;
4467 }
4468 m68ki_exception_illegal();
4469 }
4470
4471
m68k_op_bne_32(void)4472 void m68k_op_bne_32(void)
4473 {
4474 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4475 {
4476 if(COND_NE())
4477 {
4478 uint offset = OPER_I_32();
4479 REG_PC -= 4;
4480 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4481 m68ki_branch_32(offset);
4482 return;
4483 }
4484 REG_PC += 4;
4485 return;
4486 }
4487 m68ki_exception_illegal();
4488 }
4489
4490
m68k_op_beq_32(void)4491 void m68k_op_beq_32(void)
4492 {
4493 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4494 {
4495 if(COND_EQ())
4496 {
4497 uint offset = OPER_I_32();
4498 REG_PC -= 4;
4499 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4500 m68ki_branch_32(offset);
4501 return;
4502 }
4503 REG_PC += 4;
4504 return;
4505 }
4506 m68ki_exception_illegal();
4507 }
4508
4509
m68k_op_bvc_32(void)4510 void m68k_op_bvc_32(void)
4511 {
4512 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4513 {
4514 if(COND_VC())
4515 {
4516 uint offset = OPER_I_32();
4517 REG_PC -= 4;
4518 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4519 m68ki_branch_32(offset);
4520 return;
4521 }
4522 REG_PC += 4;
4523 return;
4524 }
4525 m68ki_exception_illegal();
4526 }
4527
4528
m68k_op_bvs_32(void)4529 void m68k_op_bvs_32(void)
4530 {
4531 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4532 {
4533 if(COND_VS())
4534 {
4535 uint offset = OPER_I_32();
4536 REG_PC -= 4;
4537 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4538 m68ki_branch_32(offset);
4539 return;
4540 }
4541 REG_PC += 4;
4542 return;
4543 }
4544 m68ki_exception_illegal();
4545 }
4546
4547
m68k_op_bpl_32(void)4548 void m68k_op_bpl_32(void)
4549 {
4550 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4551 {
4552 if(COND_PL())
4553 {
4554 uint offset = OPER_I_32();
4555 REG_PC -= 4;
4556 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4557 m68ki_branch_32(offset);
4558 return;
4559 }
4560 REG_PC += 4;
4561 return;
4562 }
4563 m68ki_exception_illegal();
4564 }
4565
4566
m68k_op_bmi_32(void)4567 void m68k_op_bmi_32(void)
4568 {
4569 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4570 {
4571 if(COND_MI())
4572 {
4573 uint offset = OPER_I_32();
4574 REG_PC -= 4;
4575 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4576 m68ki_branch_32(offset);
4577 return;
4578 }
4579 REG_PC += 4;
4580 return;
4581 }
4582 m68ki_exception_illegal();
4583 }
4584
4585
m68k_op_bge_32(void)4586 void m68k_op_bge_32(void)
4587 {
4588 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4589 {
4590 if(COND_GE())
4591 {
4592 uint offset = OPER_I_32();
4593 REG_PC -= 4;
4594 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4595 m68ki_branch_32(offset);
4596 return;
4597 }
4598 REG_PC += 4;
4599 return;
4600 }
4601 m68ki_exception_illegal();
4602 }
4603
4604
m68k_op_blt_32(void)4605 void m68k_op_blt_32(void)
4606 {
4607 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4608 {
4609 if(COND_LT())
4610 {
4611 uint offset = OPER_I_32();
4612 REG_PC -= 4;
4613 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4614 m68ki_branch_32(offset);
4615 return;
4616 }
4617 REG_PC += 4;
4618 return;
4619 }
4620 m68ki_exception_illegal();
4621 }
4622
4623
m68k_op_bgt_32(void)4624 void m68k_op_bgt_32(void)
4625 {
4626 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4627 {
4628 if(COND_GT())
4629 {
4630 uint offset = OPER_I_32();
4631 REG_PC -= 4;
4632 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4633 m68ki_branch_32(offset);
4634 return;
4635 }
4636 REG_PC += 4;
4637 return;
4638 }
4639 m68ki_exception_illegal();
4640 }
4641
4642
m68k_op_ble_32(void)4643 void m68k_op_ble_32(void)
4644 {
4645 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
4646 {
4647 if(COND_LE())
4648 {
4649 uint offset = OPER_I_32();
4650 REG_PC -= 4;
4651 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
4652 m68ki_branch_32(offset);
4653 return;
4654 }
4655 REG_PC += 4;
4656 return;
4657 }
4658 m68ki_exception_illegal();
4659 }
4660
4661
m68k_op_bchg_32_r_d(void)4662 void m68k_op_bchg_32_r_d(void)
4663 {
4664 uint* r_dst = &DY;
4665 uint mask = 1 << (DX & 0x1f);
4666
4667 FLAG_Z = *r_dst & mask;
4668 *r_dst ^= mask;
4669 }
4670
4671
m68k_op_bchg_8_r_ai(void)4672 void m68k_op_bchg_8_r_ai(void)
4673 {
4674 uint ea = EA_AY_AI_8();
4675 uint src = m68ki_read_8(ea);
4676 uint mask = 1 << (DX & 7);
4677
4678 FLAG_Z = src & mask;
4679 m68ki_write_8(ea, src ^ mask);
4680 }
4681
4682
m68k_op_bchg_8_r_pi(void)4683 void m68k_op_bchg_8_r_pi(void)
4684 {
4685 uint ea = EA_AY_PI_8();
4686 uint src = m68ki_read_8(ea);
4687 uint mask = 1 << (DX & 7);
4688
4689 FLAG_Z = src & mask;
4690 m68ki_write_8(ea, src ^ mask);
4691 }
4692
4693
m68k_op_bchg_8_r_pi7(void)4694 void m68k_op_bchg_8_r_pi7(void)
4695 {
4696 uint ea = EA_A7_PI_8();
4697 uint src = m68ki_read_8(ea);
4698 uint mask = 1 << (DX & 7);
4699
4700 FLAG_Z = src & mask;
4701 m68ki_write_8(ea, src ^ mask);
4702 }
4703
4704
m68k_op_bchg_8_r_pd(void)4705 void m68k_op_bchg_8_r_pd(void)
4706 {
4707 uint ea = EA_AY_PD_8();
4708 uint src = m68ki_read_8(ea);
4709 uint mask = 1 << (DX & 7);
4710
4711 FLAG_Z = src & mask;
4712 m68ki_write_8(ea, src ^ mask);
4713 }
4714
4715
m68k_op_bchg_8_r_pd7(void)4716 void m68k_op_bchg_8_r_pd7(void)
4717 {
4718 uint ea = EA_A7_PD_8();
4719 uint src = m68ki_read_8(ea);
4720 uint mask = 1 << (DX & 7);
4721
4722 FLAG_Z = src & mask;
4723 m68ki_write_8(ea, src ^ mask);
4724 }
4725
4726
m68k_op_bchg_8_r_di(void)4727 void m68k_op_bchg_8_r_di(void)
4728 {
4729 uint ea = EA_AY_DI_8();
4730 uint src = m68ki_read_8(ea);
4731 uint mask = 1 << (DX & 7);
4732
4733 FLAG_Z = src & mask;
4734 m68ki_write_8(ea, src ^ mask);
4735 }
4736
4737
m68k_op_bchg_8_r_ix(void)4738 void m68k_op_bchg_8_r_ix(void)
4739 {
4740 uint ea = EA_AY_IX_8();
4741 uint src = m68ki_read_8(ea);
4742 uint mask = 1 << (DX & 7);
4743
4744 FLAG_Z = src & mask;
4745 m68ki_write_8(ea, src ^ mask);
4746 }
4747
4748
m68k_op_bchg_8_r_aw(void)4749 void m68k_op_bchg_8_r_aw(void)
4750 {
4751 uint ea = EA_AW_8();
4752 uint src = m68ki_read_8(ea);
4753 uint mask = 1 << (DX & 7);
4754
4755 FLAG_Z = src & mask;
4756 m68ki_write_8(ea, src ^ mask);
4757 }
4758
4759
m68k_op_bchg_8_r_al(void)4760 void m68k_op_bchg_8_r_al(void)
4761 {
4762 uint ea = EA_AL_8();
4763 uint src = m68ki_read_8(ea);
4764 uint mask = 1 << (DX & 7);
4765
4766 FLAG_Z = src & mask;
4767 m68ki_write_8(ea, src ^ mask);
4768 }
4769
4770
m68k_op_bchg_32_s_d(void)4771 void m68k_op_bchg_32_s_d(void)
4772 {
4773 uint* r_dst = &DY;
4774 uint mask = 1 << (OPER_I_8() & 0x1f);
4775
4776 FLAG_Z = *r_dst & mask;
4777 *r_dst ^= mask;
4778 }
4779
4780
m68k_op_bchg_8_s_ai(void)4781 void m68k_op_bchg_8_s_ai(void)
4782 {
4783 uint mask = 1 << (OPER_I_8() & 7);
4784 uint ea = EA_AY_AI_8();
4785 uint src = m68ki_read_8(ea);
4786
4787 FLAG_Z = src & mask;
4788 m68ki_write_8(ea, src ^ mask);
4789 }
4790
4791
m68k_op_bchg_8_s_pi(void)4792 void m68k_op_bchg_8_s_pi(void)
4793 {
4794 uint mask = 1 << (OPER_I_8() & 7);
4795 uint ea = EA_AY_PI_8();
4796 uint src = m68ki_read_8(ea);
4797
4798 FLAG_Z = src & mask;
4799 m68ki_write_8(ea, src ^ mask);
4800 }
4801
4802
m68k_op_bchg_8_s_pi7(void)4803 void m68k_op_bchg_8_s_pi7(void)
4804 {
4805 uint mask = 1 << (OPER_I_8() & 7);
4806 uint ea = EA_A7_PI_8();
4807 uint src = m68ki_read_8(ea);
4808
4809 FLAG_Z = src & mask;
4810 m68ki_write_8(ea, src ^ mask);
4811 }
4812
4813
m68k_op_bchg_8_s_pd(void)4814 void m68k_op_bchg_8_s_pd(void)
4815 {
4816 uint mask = 1 << (OPER_I_8() & 7);
4817 uint ea = EA_AY_PD_8();
4818 uint src = m68ki_read_8(ea);
4819
4820 FLAG_Z = src & mask;
4821 m68ki_write_8(ea, src ^ mask);
4822 }
4823
4824
m68k_op_bchg_8_s_pd7(void)4825 void m68k_op_bchg_8_s_pd7(void)
4826 {
4827 uint mask = 1 << (OPER_I_8() & 7);
4828 uint ea = EA_A7_PD_8();
4829 uint src = m68ki_read_8(ea);
4830
4831 FLAG_Z = src & mask;
4832 m68ki_write_8(ea, src ^ mask);
4833 }
4834
4835
m68k_op_bchg_8_s_di(void)4836 void m68k_op_bchg_8_s_di(void)
4837 {
4838 uint mask = 1 << (OPER_I_8() & 7);
4839 uint ea = EA_AY_DI_8();
4840 uint src = m68ki_read_8(ea);
4841
4842 FLAG_Z = src & mask;
4843 m68ki_write_8(ea, src ^ mask);
4844 }
4845
4846
m68k_op_bchg_8_s_ix(void)4847 void m68k_op_bchg_8_s_ix(void)
4848 {
4849 uint mask = 1 << (OPER_I_8() & 7);
4850 uint ea = EA_AY_IX_8();
4851 uint src = m68ki_read_8(ea);
4852
4853 FLAG_Z = src & mask;
4854 m68ki_write_8(ea, src ^ mask);
4855 }
4856
4857
m68k_op_bchg_8_s_aw(void)4858 void m68k_op_bchg_8_s_aw(void)
4859 {
4860 uint mask = 1 << (OPER_I_8() & 7);
4861 uint ea = EA_AW_8();
4862 uint src = m68ki_read_8(ea);
4863
4864 FLAG_Z = src & mask;
4865 m68ki_write_8(ea, src ^ mask);
4866 }
4867
4868
m68k_op_bchg_8_s_al(void)4869 void m68k_op_bchg_8_s_al(void)
4870 {
4871 uint mask = 1 << (OPER_I_8() & 7);
4872 uint ea = EA_AL_8();
4873 uint src = m68ki_read_8(ea);
4874
4875 FLAG_Z = src & mask;
4876 m68ki_write_8(ea, src ^ mask);
4877 }
4878
4879
m68k_op_bclr_32_r_d(void)4880 void m68k_op_bclr_32_r_d(void)
4881 {
4882 uint* r_dst = &DY;
4883 uint mask = 1 << (DX & 0x1f);
4884
4885 FLAG_Z = *r_dst & mask;
4886 *r_dst &= ~mask;
4887 }
4888
4889
m68k_op_bclr_8_r_ai(void)4890 void m68k_op_bclr_8_r_ai(void)
4891 {
4892 uint ea = EA_AY_AI_8();
4893 uint src = m68ki_read_8(ea);
4894 uint mask = 1 << (DX & 7);
4895
4896 FLAG_Z = src & mask;
4897 m68ki_write_8(ea, src & ~mask);
4898 }
4899
4900
m68k_op_bclr_8_r_pi(void)4901 void m68k_op_bclr_8_r_pi(void)
4902 {
4903 uint ea = EA_AY_PI_8();
4904 uint src = m68ki_read_8(ea);
4905 uint mask = 1 << (DX & 7);
4906
4907 FLAG_Z = src & mask;
4908 m68ki_write_8(ea, src & ~mask);
4909 }
4910
4911
m68k_op_bclr_8_r_pi7(void)4912 void m68k_op_bclr_8_r_pi7(void)
4913 {
4914 uint ea = EA_A7_PI_8();
4915 uint src = m68ki_read_8(ea);
4916 uint mask = 1 << (DX & 7);
4917
4918 FLAG_Z = src & mask;
4919 m68ki_write_8(ea, src & ~mask);
4920 }
4921
4922
m68k_op_bclr_8_r_pd(void)4923 void m68k_op_bclr_8_r_pd(void)
4924 {
4925 uint ea = EA_AY_PD_8();
4926 uint src = m68ki_read_8(ea);
4927 uint mask = 1 << (DX & 7);
4928
4929 FLAG_Z = src & mask;
4930 m68ki_write_8(ea, src & ~mask);
4931 }
4932
4933
m68k_op_bclr_8_r_pd7(void)4934 void m68k_op_bclr_8_r_pd7(void)
4935 {
4936 uint ea = EA_A7_PD_8();
4937 uint src = m68ki_read_8(ea);
4938 uint mask = 1 << (DX & 7);
4939
4940 FLAG_Z = src & mask;
4941 m68ki_write_8(ea, src & ~mask);
4942 }
4943
4944
m68k_op_bclr_8_r_di(void)4945 void m68k_op_bclr_8_r_di(void)
4946 {
4947 uint ea = EA_AY_DI_8();
4948 uint src = m68ki_read_8(ea);
4949 uint mask = 1 << (DX & 7);
4950
4951 FLAG_Z = src & mask;
4952 m68ki_write_8(ea, src & ~mask);
4953 }
4954
4955
m68k_op_bclr_8_r_ix(void)4956 void m68k_op_bclr_8_r_ix(void)
4957 {
4958 uint ea = EA_AY_IX_8();
4959 uint src = m68ki_read_8(ea);
4960 uint mask = 1 << (DX & 7);
4961
4962 FLAG_Z = src & mask;
4963 m68ki_write_8(ea, src & ~mask);
4964 }
4965
4966
m68k_op_bclr_8_r_aw(void)4967 void m68k_op_bclr_8_r_aw(void)
4968 {
4969 uint ea = EA_AW_8();
4970 uint src = m68ki_read_8(ea);
4971 uint mask = 1 << (DX & 7);
4972
4973 FLAG_Z = src & mask;
4974 m68ki_write_8(ea, src & ~mask);
4975 }
4976
4977
m68k_op_bclr_8_r_al(void)4978 void m68k_op_bclr_8_r_al(void)
4979 {
4980 uint ea = EA_AL_8();
4981 uint src = m68ki_read_8(ea);
4982 uint mask = 1 << (DX & 7);
4983
4984 FLAG_Z = src & mask;
4985 m68ki_write_8(ea, src & ~mask);
4986 }
4987
4988
m68k_op_bclr_32_s_d(void)4989 void m68k_op_bclr_32_s_d(void)
4990 {
4991 uint* r_dst = &DY;
4992 uint mask = 1 << (OPER_I_8() & 0x1f);
4993
4994 FLAG_Z = *r_dst & mask;
4995 *r_dst &= ~mask;
4996 }
4997
4998
m68k_op_bclr_8_s_ai(void)4999 void m68k_op_bclr_8_s_ai(void)
5000 {
5001 uint mask = 1 << (OPER_I_8() & 7);
5002 uint ea = EA_AY_AI_8();
5003 uint src = m68ki_read_8(ea);
5004
5005 FLAG_Z = src & mask;
5006 m68ki_write_8(ea, src & ~mask);
5007 }
5008
5009
m68k_op_bclr_8_s_pi(void)5010 void m68k_op_bclr_8_s_pi(void)
5011 {
5012 uint mask = 1 << (OPER_I_8() & 7);
5013 uint ea = EA_AY_PI_8();
5014 uint src = m68ki_read_8(ea);
5015
5016 FLAG_Z = src & mask;
5017 m68ki_write_8(ea, src & ~mask);
5018 }
5019
5020
m68k_op_bclr_8_s_pi7(void)5021 void m68k_op_bclr_8_s_pi7(void)
5022 {
5023 uint mask = 1 << (OPER_I_8() & 7);
5024 uint ea = EA_A7_PI_8();
5025 uint src = m68ki_read_8(ea);
5026
5027 FLAG_Z = src & mask;
5028 m68ki_write_8(ea, src & ~mask);
5029 }
5030
5031
m68k_op_bclr_8_s_pd(void)5032 void m68k_op_bclr_8_s_pd(void)
5033 {
5034 uint mask = 1 << (OPER_I_8() & 7);
5035 uint ea = EA_AY_PD_8();
5036 uint src = m68ki_read_8(ea);
5037
5038 FLAG_Z = src & mask;
5039 m68ki_write_8(ea, src & ~mask);
5040 }
5041
5042
m68k_op_bclr_8_s_pd7(void)5043 void m68k_op_bclr_8_s_pd7(void)
5044 {
5045 uint mask = 1 << (OPER_I_8() & 7);
5046 uint ea = EA_A7_PD_8();
5047 uint src = m68ki_read_8(ea);
5048
5049 FLAG_Z = src & mask;
5050 m68ki_write_8(ea, src & ~mask);
5051 }
5052
5053
m68k_op_bclr_8_s_di(void)5054 void m68k_op_bclr_8_s_di(void)
5055 {
5056 uint mask = 1 << (OPER_I_8() & 7);
5057 uint ea = EA_AY_DI_8();
5058 uint src = m68ki_read_8(ea);
5059
5060 FLAG_Z = src & mask;
5061 m68ki_write_8(ea, src & ~mask);
5062 }
5063
5064
m68k_op_bclr_8_s_ix(void)5065 void m68k_op_bclr_8_s_ix(void)
5066 {
5067 uint mask = 1 << (OPER_I_8() & 7);
5068 uint ea = EA_AY_IX_8();
5069 uint src = m68ki_read_8(ea);
5070
5071 FLAG_Z = src & mask;
5072 m68ki_write_8(ea, src & ~mask);
5073 }
5074
5075
m68k_op_bclr_8_s_aw(void)5076 void m68k_op_bclr_8_s_aw(void)
5077 {
5078 uint mask = 1 << (OPER_I_8() & 7);
5079 uint ea = EA_AW_8();
5080 uint src = m68ki_read_8(ea);
5081
5082 FLAG_Z = src & mask;
5083 m68ki_write_8(ea, src & ~mask);
5084 }
5085
5086
m68k_op_bclr_8_s_al(void)5087 void m68k_op_bclr_8_s_al(void)
5088 {
5089 uint mask = 1 << (OPER_I_8() & 7);
5090 uint ea = EA_AL_8();
5091 uint src = m68ki_read_8(ea);
5092
5093 FLAG_Z = src & mask;
5094 m68ki_write_8(ea, src & ~mask);
5095 }
5096
5097
m68k_op_bfchg_32_d(void)5098 void m68k_op_bfchg_32_d(void)
5099 {
5100 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5101 {
5102 uint word2 = OPER_I_16();
5103 uint offset = (word2>>6)&31;
5104 uint width = word2;
5105 uint* data = &DY;
5106 uint64 mask;
5107
5108
5109 if(BIT_B(word2))
5110 offset = REG_D[offset&7];
5111 if(BIT_5(word2))
5112 width = REG_D[width&7];
5113
5114 offset &= 31;
5115 width = ((width-1) & 31) + 1;
5116
5117 mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5118 mask = ROR_32(mask, offset);
5119
5120 FLAG_N = NFLAG_32(*data<<offset);
5121 FLAG_Z = *data & mask;
5122 FLAG_V = VFLAG_CLEAR;
5123 FLAG_C = CFLAG_CLEAR;
5124
5125 *data ^= mask;
5126
5127 return;
5128 }
5129 m68ki_exception_illegal();
5130 }
5131
5132
m68k_op_bfchg_32_ai(void)5133 void m68k_op_bfchg_32_ai(void)
5134 {
5135 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5136 {
5137 uint word2 = OPER_I_16();
5138 sint offset = (word2>>6)&31;
5139 uint width = word2;
5140 uint mask_base;
5141 uint data_long;
5142 uint mask_long;
5143 uint data_byte = 0;
5144 uint mask_byte = 0;
5145 uint ea = EA_AY_AI_8();
5146
5147
5148 if(BIT_B(word2))
5149 offset = MAKE_INT_32(REG_D[offset&7]);
5150 if(BIT_5(word2))
5151 width = REG_D[width&7];
5152
5153 /* Offset is signed so we have to use ugly math =( */
5154 ea += offset / 8;
5155 offset %= 8;
5156 if(offset < 0)
5157 {
5158 offset += 8;
5159 ea--;
5160 }
5161 width = ((width-1) & 31) + 1;
5162
5163 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5164 mask_long = mask_base >> offset;
5165
5166 data_long = m68ki_read_32(ea);
5167 FLAG_N = NFLAG_32(data_long << offset);
5168 FLAG_Z = data_long & mask_long;
5169 FLAG_V = VFLAG_CLEAR;
5170 FLAG_C = CFLAG_CLEAR;
5171
5172 m68ki_write_32(ea, data_long ^ mask_long);
5173
5174 if((width + offset) > 32)
5175 {
5176 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5177 data_byte = m68ki_read_8(ea+4);
5178 FLAG_Z |= (data_byte & mask_byte);
5179 m68ki_write_8(ea+4, data_byte ^ mask_byte);
5180 }
5181 return;
5182 }
5183 m68ki_exception_illegal();
5184 }
5185
5186
m68k_op_bfchg_32_di(void)5187 void m68k_op_bfchg_32_di(void)
5188 {
5189 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5190 {
5191 uint word2 = OPER_I_16();
5192 sint offset = (word2>>6)&31;
5193 uint width = word2;
5194 uint mask_base;
5195 uint data_long;
5196 uint mask_long;
5197 uint data_byte = 0;
5198 uint mask_byte = 0;
5199 uint ea = EA_AY_DI_8();
5200
5201
5202 if(BIT_B(word2))
5203 offset = MAKE_INT_32(REG_D[offset&7]);
5204 if(BIT_5(word2))
5205 width = REG_D[width&7];
5206
5207 /* Offset is signed so we have to use ugly math =( */
5208 ea += offset / 8;
5209 offset %= 8;
5210 if(offset < 0)
5211 {
5212 offset += 8;
5213 ea--;
5214 }
5215 width = ((width-1) & 31) + 1;
5216
5217 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5218 mask_long = mask_base >> offset;
5219
5220 data_long = m68ki_read_32(ea);
5221 FLAG_N = NFLAG_32(data_long << offset);
5222 FLAG_Z = data_long & mask_long;
5223 FLAG_V = VFLAG_CLEAR;
5224 FLAG_C = CFLAG_CLEAR;
5225
5226 m68ki_write_32(ea, data_long ^ mask_long);
5227
5228 if((width + offset) > 32)
5229 {
5230 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5231 data_byte = m68ki_read_8(ea+4);
5232 FLAG_Z |= (data_byte & mask_byte);
5233 m68ki_write_8(ea+4, data_byte ^ mask_byte);
5234 }
5235 return;
5236 }
5237 m68ki_exception_illegal();
5238 }
5239
5240
m68k_op_bfchg_32_ix(void)5241 void m68k_op_bfchg_32_ix(void)
5242 {
5243 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5244 {
5245 uint word2 = OPER_I_16();
5246 sint offset = (word2>>6)&31;
5247 uint width = word2;
5248 uint mask_base;
5249 uint data_long;
5250 uint mask_long;
5251 uint data_byte = 0;
5252 uint mask_byte = 0;
5253 uint ea = EA_AY_IX_8();
5254
5255
5256 if(BIT_B(word2))
5257 offset = MAKE_INT_32(REG_D[offset&7]);
5258 if(BIT_5(word2))
5259 width = REG_D[width&7];
5260
5261 /* Offset is signed so we have to use ugly math =( */
5262 ea += offset / 8;
5263 offset %= 8;
5264 if(offset < 0)
5265 {
5266 offset += 8;
5267 ea--;
5268 }
5269 width = ((width-1) & 31) + 1;
5270
5271 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5272 mask_long = mask_base >> offset;
5273
5274 data_long = m68ki_read_32(ea);
5275 FLAG_N = NFLAG_32(data_long << offset);
5276 FLAG_Z = data_long & mask_long;
5277 FLAG_V = VFLAG_CLEAR;
5278 FLAG_C = CFLAG_CLEAR;
5279
5280 m68ki_write_32(ea, data_long ^ mask_long);
5281
5282 if((width + offset) > 32)
5283 {
5284 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5285 data_byte = m68ki_read_8(ea+4);
5286 FLAG_Z |= (data_byte & mask_byte);
5287 m68ki_write_8(ea+4, data_byte ^ mask_byte);
5288 }
5289 return;
5290 }
5291 m68ki_exception_illegal();
5292 }
5293
5294
m68k_op_bfchg_32_aw(void)5295 void m68k_op_bfchg_32_aw(void)
5296 {
5297 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5298 {
5299 uint word2 = OPER_I_16();
5300 sint offset = (word2>>6)&31;
5301 uint width = word2;
5302 uint mask_base;
5303 uint data_long;
5304 uint mask_long;
5305 uint data_byte = 0;
5306 uint mask_byte = 0;
5307 uint ea = EA_AW_8();
5308
5309
5310 if(BIT_B(word2))
5311 offset = MAKE_INT_32(REG_D[offset&7]);
5312 if(BIT_5(word2))
5313 width = REG_D[width&7];
5314
5315 /* Offset is signed so we have to use ugly math =( */
5316 ea += offset / 8;
5317 offset %= 8;
5318 if(offset < 0)
5319 {
5320 offset += 8;
5321 ea--;
5322 }
5323 width = ((width-1) & 31) + 1;
5324
5325 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5326 mask_long = mask_base >> offset;
5327
5328 data_long = m68ki_read_32(ea);
5329 FLAG_N = NFLAG_32(data_long << offset);
5330 FLAG_Z = data_long & mask_long;
5331 FLAG_V = VFLAG_CLEAR;
5332 FLAG_C = CFLAG_CLEAR;
5333
5334 m68ki_write_32(ea, data_long ^ mask_long);
5335
5336 if((width + offset) > 32)
5337 {
5338 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5339 data_byte = m68ki_read_8(ea+4);
5340 FLAG_Z |= (data_byte & mask_byte);
5341 m68ki_write_8(ea+4, data_byte ^ mask_byte);
5342 }
5343 return;
5344 }
5345 m68ki_exception_illegal();
5346 }
5347
5348
m68k_op_bfchg_32_al(void)5349 void m68k_op_bfchg_32_al(void)
5350 {
5351 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5352 {
5353 uint word2 = OPER_I_16();
5354 sint offset = (word2>>6)&31;
5355 uint width = word2;
5356 uint mask_base;
5357 uint data_long;
5358 uint mask_long;
5359 uint data_byte = 0;
5360 uint mask_byte = 0;
5361 uint ea = EA_AL_8();
5362
5363
5364 if(BIT_B(word2))
5365 offset = MAKE_INT_32(REG_D[offset&7]);
5366 if(BIT_5(word2))
5367 width = REG_D[width&7];
5368
5369 /* Offset is signed so we have to use ugly math =( */
5370 ea += offset / 8;
5371 offset %= 8;
5372 if(offset < 0)
5373 {
5374 offset += 8;
5375 ea--;
5376 }
5377 width = ((width-1) & 31) + 1;
5378
5379 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5380 mask_long = mask_base >> offset;
5381
5382 data_long = m68ki_read_32(ea);
5383 FLAG_N = NFLAG_32(data_long << offset);
5384 FLAG_Z = data_long & mask_long;
5385 FLAG_V = VFLAG_CLEAR;
5386 FLAG_C = CFLAG_CLEAR;
5387
5388 m68ki_write_32(ea, data_long ^ mask_long);
5389
5390 if((width + offset) > 32)
5391 {
5392 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5393 data_byte = m68ki_read_8(ea+4);
5394 FLAG_Z |= (data_byte & mask_byte);
5395 m68ki_write_8(ea+4, data_byte ^ mask_byte);
5396 }
5397 return;
5398 }
5399 m68ki_exception_illegal();
5400 }
5401
5402
m68k_op_bfclr_32_d(void)5403 void m68k_op_bfclr_32_d(void)
5404 {
5405 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5406 {
5407 uint word2 = OPER_I_16();
5408 uint offset = (word2>>6)&31;
5409 uint width = word2;
5410 uint* data = &DY;
5411 uint64 mask;
5412
5413
5414 if(BIT_B(word2))
5415 offset = REG_D[offset&7];
5416 if(BIT_5(word2))
5417 width = REG_D[width&7];
5418
5419
5420 offset &= 31;
5421 width = ((width-1) & 31) + 1;
5422
5423
5424 mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5425 mask = ROR_32(mask, offset);
5426
5427 FLAG_N = NFLAG_32(*data<<offset);
5428 FLAG_Z = *data & mask;
5429 FLAG_V = VFLAG_CLEAR;
5430 FLAG_C = CFLAG_CLEAR;
5431
5432 *data &= ~mask;
5433
5434 return;
5435 }
5436 m68ki_exception_illegal();
5437 }
5438
5439
m68k_op_bfclr_32_ai(void)5440 void m68k_op_bfclr_32_ai(void)
5441 {
5442 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5443 {
5444 uint word2 = OPER_I_16();
5445 sint offset = (word2>>6)&31;
5446 uint width = word2;
5447 uint mask_base;
5448 uint data_long;
5449 uint mask_long;
5450 uint data_byte = 0;
5451 uint mask_byte = 0;
5452 uint ea = EA_AY_AI_8();
5453
5454
5455 if(BIT_B(word2))
5456 offset = MAKE_INT_32(REG_D[offset&7]);
5457 if(BIT_5(word2))
5458 width = REG_D[width&7];
5459
5460 /* Offset is signed so we have to use ugly math =( */
5461 ea += offset / 8;
5462 offset %= 8;
5463 if(offset < 0)
5464 {
5465 offset += 8;
5466 ea--;
5467 }
5468 width = ((width-1) & 31) + 1;
5469
5470 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5471 mask_long = mask_base >> offset;
5472
5473 data_long = m68ki_read_32(ea);
5474 FLAG_N = NFLAG_32(data_long << offset);
5475 FLAG_Z = data_long & mask_long;
5476 FLAG_V = VFLAG_CLEAR;
5477 FLAG_C = CFLAG_CLEAR;
5478
5479 m68ki_write_32(ea, data_long & ~mask_long);
5480
5481 if((width + offset) > 32)
5482 {
5483 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5484 data_byte = m68ki_read_8(ea+4);
5485 FLAG_Z |= (data_byte & mask_byte);
5486 m68ki_write_8(ea+4, data_byte & ~mask_byte);
5487 }
5488 return;
5489 }
5490 m68ki_exception_illegal();
5491 }
5492
5493
m68k_op_bfclr_32_di(void)5494 void m68k_op_bfclr_32_di(void)
5495 {
5496 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5497 {
5498 uint word2 = OPER_I_16();
5499 sint offset = (word2>>6)&31;
5500 uint width = word2;
5501 uint mask_base;
5502 uint data_long;
5503 uint mask_long;
5504 uint data_byte = 0;
5505 uint mask_byte = 0;
5506 uint ea = EA_AY_DI_8();
5507
5508
5509 if(BIT_B(word2))
5510 offset = MAKE_INT_32(REG_D[offset&7]);
5511 if(BIT_5(word2))
5512 width = REG_D[width&7];
5513
5514 /* Offset is signed so we have to use ugly math =( */
5515 ea += offset / 8;
5516 offset %= 8;
5517 if(offset < 0)
5518 {
5519 offset += 8;
5520 ea--;
5521 }
5522 width = ((width-1) & 31) + 1;
5523
5524 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5525 mask_long = mask_base >> offset;
5526
5527 data_long = m68ki_read_32(ea);
5528 FLAG_N = NFLAG_32(data_long << offset);
5529 FLAG_Z = data_long & mask_long;
5530 FLAG_V = VFLAG_CLEAR;
5531 FLAG_C = CFLAG_CLEAR;
5532
5533 m68ki_write_32(ea, data_long & ~mask_long);
5534
5535 if((width + offset) > 32)
5536 {
5537 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5538 data_byte = m68ki_read_8(ea+4);
5539 FLAG_Z |= (data_byte & mask_byte);
5540 m68ki_write_8(ea+4, data_byte & ~mask_byte);
5541 }
5542 return;
5543 }
5544 m68ki_exception_illegal();
5545 }
5546
5547
m68k_op_bfclr_32_ix(void)5548 void m68k_op_bfclr_32_ix(void)
5549 {
5550 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5551 {
5552 uint word2 = OPER_I_16();
5553 sint offset = (word2>>6)&31;
5554 uint width = word2;
5555 uint mask_base;
5556 uint data_long;
5557 uint mask_long;
5558 uint data_byte = 0;
5559 uint mask_byte = 0;
5560 uint ea = EA_AY_IX_8();
5561
5562
5563 if(BIT_B(word2))
5564 offset = MAKE_INT_32(REG_D[offset&7]);
5565 if(BIT_5(word2))
5566 width = REG_D[width&7];
5567
5568 /* Offset is signed so we have to use ugly math =( */
5569 ea += offset / 8;
5570 offset %= 8;
5571 if(offset < 0)
5572 {
5573 offset += 8;
5574 ea--;
5575 }
5576 width = ((width-1) & 31) + 1;
5577
5578 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5579 mask_long = mask_base >> offset;
5580
5581 data_long = m68ki_read_32(ea);
5582 FLAG_N = NFLAG_32(data_long << offset);
5583 FLAG_Z = data_long & mask_long;
5584 FLAG_V = VFLAG_CLEAR;
5585 FLAG_C = CFLAG_CLEAR;
5586
5587 m68ki_write_32(ea, data_long & ~mask_long);
5588
5589 if((width + offset) > 32)
5590 {
5591 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5592 data_byte = m68ki_read_8(ea+4);
5593 FLAG_Z |= (data_byte & mask_byte);
5594 m68ki_write_8(ea+4, data_byte & ~mask_byte);
5595 }
5596 return;
5597 }
5598 m68ki_exception_illegal();
5599 }
5600
5601
m68k_op_bfclr_32_aw(void)5602 void m68k_op_bfclr_32_aw(void)
5603 {
5604 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5605 {
5606 uint word2 = OPER_I_16();
5607 sint offset = (word2>>6)&31;
5608 uint width = word2;
5609 uint mask_base;
5610 uint data_long;
5611 uint mask_long;
5612 uint data_byte = 0;
5613 uint mask_byte = 0;
5614 uint ea = EA_AW_8();
5615
5616
5617 if(BIT_B(word2))
5618 offset = MAKE_INT_32(REG_D[offset&7]);
5619 if(BIT_5(word2))
5620 width = REG_D[width&7];
5621
5622 /* Offset is signed so we have to use ugly math =( */
5623 ea += offset / 8;
5624 offset %= 8;
5625 if(offset < 0)
5626 {
5627 offset += 8;
5628 ea--;
5629 }
5630 width = ((width-1) & 31) + 1;
5631
5632 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5633 mask_long = mask_base >> offset;
5634
5635 data_long = m68ki_read_32(ea);
5636 FLAG_N = NFLAG_32(data_long << offset);
5637 FLAG_Z = data_long & mask_long;
5638 FLAG_V = VFLAG_CLEAR;
5639 FLAG_C = CFLAG_CLEAR;
5640
5641 m68ki_write_32(ea, data_long & ~mask_long);
5642
5643 if((width + offset) > 32)
5644 {
5645 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5646 data_byte = m68ki_read_8(ea+4);
5647 FLAG_Z |= (data_byte & mask_byte);
5648 m68ki_write_8(ea+4, data_byte & ~mask_byte);
5649 }
5650 return;
5651 }
5652 m68ki_exception_illegal();
5653 }
5654
5655
m68k_op_bfclr_32_al(void)5656 void m68k_op_bfclr_32_al(void)
5657 {
5658 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5659 {
5660 uint word2 = OPER_I_16();
5661 sint offset = (word2>>6)&31;
5662 uint width = word2;
5663 uint mask_base;
5664 uint data_long;
5665 uint mask_long;
5666 uint data_byte = 0;
5667 uint mask_byte = 0;
5668 uint ea = EA_AL_8();
5669
5670
5671 if(BIT_B(word2))
5672 offset = MAKE_INT_32(REG_D[offset&7]);
5673 if(BIT_5(word2))
5674 width = REG_D[width&7];
5675
5676 /* Offset is signed so we have to use ugly math =( */
5677 ea += offset / 8;
5678 offset %= 8;
5679 if(offset < 0)
5680 {
5681 offset += 8;
5682 ea--;
5683 }
5684 width = ((width-1) & 31) + 1;
5685
5686 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
5687 mask_long = mask_base >> offset;
5688
5689 data_long = m68ki_read_32(ea);
5690 FLAG_N = NFLAG_32(data_long << offset);
5691 FLAG_Z = data_long & mask_long;
5692 FLAG_V = VFLAG_CLEAR;
5693 FLAG_C = CFLAG_CLEAR;
5694
5695 m68ki_write_32(ea, data_long & ~mask_long);
5696
5697 if((width + offset) > 32)
5698 {
5699 mask_byte = MASK_OUT_ABOVE_8(mask_base);
5700 data_byte = m68ki_read_8(ea+4);
5701 FLAG_Z |= (data_byte & mask_byte);
5702 m68ki_write_8(ea+4, data_byte & ~mask_byte);
5703 }
5704 return;
5705 }
5706 m68ki_exception_illegal();
5707 }
5708
5709
m68k_op_bfexts_32_d(void)5710 void m68k_op_bfexts_32_d(void)
5711 {
5712 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5713 {
5714 uint word2 = OPER_I_16();
5715 uint offset = (word2>>6)&31;
5716 uint width = word2;
5717 uint64 data = DY;
5718
5719
5720 if(BIT_B(word2))
5721 offset = REG_D[offset&7];
5722 if(BIT_5(word2))
5723 width = REG_D[width&7];
5724
5725 offset &= 31;
5726 width = ((width-1) & 31) + 1;
5727
5728 data = ROL_32(data, offset);
5729 FLAG_N = NFLAG_32(data);
5730 data = MAKE_INT_32(data) >> (32 - width);
5731
5732 FLAG_Z = data;
5733 FLAG_V = VFLAG_CLEAR;
5734 FLAG_C = CFLAG_CLEAR;
5735
5736 REG_D[(word2>>12)&7] = data;
5737
5738 return;
5739 }
5740 m68ki_exception_illegal();
5741 }
5742
5743
m68k_op_bfexts_32_ai(void)5744 void m68k_op_bfexts_32_ai(void)
5745 {
5746 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5747 {
5748 uint word2 = OPER_I_16();
5749 sint offset = (word2>>6)&31;
5750 uint width = word2;
5751 uint data;
5752 uint ea = EA_AY_AI_8();
5753
5754
5755 if(BIT_B(word2))
5756 offset = MAKE_INT_32(REG_D[offset&7]);
5757 if(BIT_5(word2))
5758 width = REG_D[width&7];
5759
5760 /* Offset is signed so we have to use ugly math =( */
5761 ea += offset / 8;
5762 offset %= 8;
5763 if(offset < 0)
5764 {
5765 offset += 8;
5766 ea--;
5767 }
5768 width = ((width-1) & 31) + 1;
5769
5770 data = m68ki_read_32(ea);
5771
5772 data = MASK_OUT_ABOVE_32(data<<offset);
5773
5774 if((offset+width) > 32)
5775 data |= (m68ki_read_8(ea+4) << offset) >> 8;
5776
5777 FLAG_N = NFLAG_32(data);
5778 data = MAKE_INT_32(data) >> (32 - width);
5779
5780 FLAG_Z = data;
5781 FLAG_V = VFLAG_CLEAR;
5782 FLAG_C = CFLAG_CLEAR;
5783
5784 REG_D[(word2 >> 12) & 7] = data;
5785
5786 return;
5787 }
5788 m68ki_exception_illegal();
5789 }
5790
5791
m68k_op_bfexts_32_di(void)5792 void m68k_op_bfexts_32_di(void)
5793 {
5794 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5795 {
5796 uint word2 = OPER_I_16();
5797 sint offset = (word2>>6)&31;
5798 uint width = word2;
5799 uint data;
5800 uint ea = EA_AY_DI_8();
5801
5802
5803 if(BIT_B(word2))
5804 offset = MAKE_INT_32(REG_D[offset&7]);
5805 if(BIT_5(word2))
5806 width = REG_D[width&7];
5807
5808 /* Offset is signed so we have to use ugly math =( */
5809 ea += offset / 8;
5810 offset %= 8;
5811 if(offset < 0)
5812 {
5813 offset += 8;
5814 ea--;
5815 }
5816 width = ((width-1) & 31) + 1;
5817
5818 data = m68ki_read_32(ea);
5819
5820 data = MASK_OUT_ABOVE_32(data<<offset);
5821
5822 if((offset+width) > 32)
5823 data |= (m68ki_read_8(ea+4) << offset) >> 8;
5824
5825 FLAG_N = NFLAG_32(data);
5826 data = MAKE_INT_32(data) >> (32 - width);
5827
5828 FLAG_Z = data;
5829 FLAG_V = VFLAG_CLEAR;
5830 FLAG_C = CFLAG_CLEAR;
5831
5832 REG_D[(word2 >> 12) & 7] = data;
5833
5834 return;
5835 }
5836 m68ki_exception_illegal();
5837 }
5838
5839
m68k_op_bfexts_32_ix(void)5840 void m68k_op_bfexts_32_ix(void)
5841 {
5842 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5843 {
5844 uint word2 = OPER_I_16();
5845 sint offset = (word2>>6)&31;
5846 uint width = word2;
5847 uint data;
5848 uint ea = EA_AY_IX_8();
5849
5850
5851 if(BIT_B(word2))
5852 offset = MAKE_INT_32(REG_D[offset&7]);
5853 if(BIT_5(word2))
5854 width = REG_D[width&7];
5855
5856 /* Offset is signed so we have to use ugly math =( */
5857 ea += offset / 8;
5858 offset %= 8;
5859 if(offset < 0)
5860 {
5861 offset += 8;
5862 ea--;
5863 }
5864 width = ((width-1) & 31) + 1;
5865
5866 data = m68ki_read_32(ea);
5867
5868 data = MASK_OUT_ABOVE_32(data<<offset);
5869
5870 if((offset+width) > 32)
5871 data |= (m68ki_read_8(ea+4) << offset) >> 8;
5872
5873 FLAG_N = NFLAG_32(data);
5874 data = MAKE_INT_32(data) >> (32 - width);
5875
5876 FLAG_Z = data;
5877 FLAG_V = VFLAG_CLEAR;
5878 FLAG_C = CFLAG_CLEAR;
5879
5880 REG_D[(word2 >> 12) & 7] = data;
5881
5882 return;
5883 }
5884 m68ki_exception_illegal();
5885 }
5886
5887
m68k_op_bfexts_32_aw(void)5888 void m68k_op_bfexts_32_aw(void)
5889 {
5890 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5891 {
5892 uint word2 = OPER_I_16();
5893 sint offset = (word2>>6)&31;
5894 uint width = word2;
5895 uint data;
5896 uint ea = EA_AW_8();
5897
5898
5899 if(BIT_B(word2))
5900 offset = MAKE_INT_32(REG_D[offset&7]);
5901 if(BIT_5(word2))
5902 width = REG_D[width&7];
5903
5904 /* Offset is signed so we have to use ugly math =( */
5905 ea += offset / 8;
5906 offset %= 8;
5907 if(offset < 0)
5908 {
5909 offset += 8;
5910 ea--;
5911 }
5912 width = ((width-1) & 31) + 1;
5913
5914 data = m68ki_read_32(ea);
5915
5916 data = MASK_OUT_ABOVE_32(data<<offset);
5917
5918 if((offset+width) > 32)
5919 data |= (m68ki_read_8(ea+4) << offset) >> 8;
5920
5921 FLAG_N = NFLAG_32(data);
5922 data = MAKE_INT_32(data) >> (32 - width);
5923
5924 FLAG_Z = data;
5925 FLAG_V = VFLAG_CLEAR;
5926 FLAG_C = CFLAG_CLEAR;
5927
5928 REG_D[(word2 >> 12) & 7] = data;
5929
5930 return;
5931 }
5932 m68ki_exception_illegal();
5933 }
5934
5935
m68k_op_bfexts_32_al(void)5936 void m68k_op_bfexts_32_al(void)
5937 {
5938 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5939 {
5940 uint word2 = OPER_I_16();
5941 sint offset = (word2>>6)&31;
5942 uint width = word2;
5943 uint data;
5944 uint ea = EA_AL_8();
5945
5946
5947 if(BIT_B(word2))
5948 offset = MAKE_INT_32(REG_D[offset&7]);
5949 if(BIT_5(word2))
5950 width = REG_D[width&7];
5951
5952 /* Offset is signed so we have to use ugly math =( */
5953 ea += offset / 8;
5954 offset %= 8;
5955 if(offset < 0)
5956 {
5957 offset += 8;
5958 ea--;
5959 }
5960 width = ((width-1) & 31) + 1;
5961
5962 data = m68ki_read_32(ea);
5963
5964 data = MASK_OUT_ABOVE_32(data<<offset);
5965
5966 if((offset+width) > 32)
5967 data |= (m68ki_read_8(ea+4) << offset) >> 8;
5968
5969 FLAG_N = NFLAG_32(data);
5970 data = MAKE_INT_32(data) >> (32 - width);
5971
5972 FLAG_Z = data;
5973 FLAG_V = VFLAG_CLEAR;
5974 FLAG_C = CFLAG_CLEAR;
5975
5976 REG_D[(word2 >> 12) & 7] = data;
5977
5978 return;
5979 }
5980 m68ki_exception_illegal();
5981 }
5982
5983
m68k_op_bfexts_32_pcdi(void)5984 void m68k_op_bfexts_32_pcdi(void)
5985 {
5986 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
5987 {
5988 uint word2 = OPER_I_16();
5989 sint offset = (word2>>6)&31;
5990 uint width = word2;
5991 uint data;
5992 uint ea = EA_PCDI_8();
5993
5994
5995 if(BIT_B(word2))
5996 offset = MAKE_INT_32(REG_D[offset&7]);
5997 if(BIT_5(word2))
5998 width = REG_D[width&7];
5999
6000 /* Offset is signed so we have to use ugly math =( */
6001 ea += offset / 8;
6002 offset %= 8;
6003 if(offset < 0)
6004 {
6005 offset += 8;
6006 ea--;
6007 }
6008 width = ((width-1) & 31) + 1;
6009
6010 data = m68ki_read_32(ea);
6011
6012 data = MASK_OUT_ABOVE_32(data<<offset);
6013
6014 if((offset+width) > 32)
6015 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6016
6017 FLAG_N = NFLAG_32(data);
6018 data = MAKE_INT_32(data) >> (32 - width);
6019
6020 FLAG_Z = data;
6021 FLAG_V = VFLAG_CLEAR;
6022 FLAG_C = CFLAG_CLEAR;
6023
6024 REG_D[(word2 >> 12) & 7] = data;
6025
6026 return;
6027 }
6028 m68ki_exception_illegal();
6029 }
6030
6031
m68k_op_bfexts_32_pcix(void)6032 void m68k_op_bfexts_32_pcix(void)
6033 {
6034 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6035 {
6036 uint word2 = OPER_I_16();
6037 sint offset = (word2>>6)&31;
6038 uint width = word2;
6039 uint data;
6040 uint ea = EA_PCIX_8();
6041
6042
6043 if(BIT_B(word2))
6044 offset = MAKE_INT_32(REG_D[offset&7]);
6045 if(BIT_5(word2))
6046 width = REG_D[width&7];
6047
6048 /* Offset is signed so we have to use ugly math =( */
6049 ea += offset / 8;
6050 offset %= 8;
6051 if(offset < 0)
6052 {
6053 offset += 8;
6054 ea--;
6055 }
6056 width = ((width-1) & 31) + 1;
6057
6058 data = m68ki_read_32(ea);
6059
6060 data = MASK_OUT_ABOVE_32(data<<offset);
6061
6062 if((offset+width) > 32)
6063 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6064
6065 FLAG_N = NFLAG_32(data);
6066 data = MAKE_INT_32(data) >> (32 - width);
6067
6068 FLAG_Z = data;
6069 FLAG_V = VFLAG_CLEAR;
6070 FLAG_C = CFLAG_CLEAR;
6071
6072 REG_D[(word2 >> 12) & 7] = data;
6073
6074 return;
6075 }
6076 m68ki_exception_illegal();
6077 }
6078
6079
m68k_op_bfextu_32_d(void)6080 void m68k_op_bfextu_32_d(void)
6081 {
6082 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6083 {
6084 uint word2 = OPER_I_16();
6085 uint offset = (word2>>6)&31;
6086 uint width = word2;
6087 uint64 data = DY;
6088
6089
6090 if(BIT_B(word2))
6091 offset = REG_D[offset&7];
6092 if(BIT_5(word2))
6093 width = REG_D[width&7];
6094
6095 offset &= 31;
6096 width = ((width-1) & 31) + 1;
6097
6098 data = ROL_32(data, offset);
6099 FLAG_N = NFLAG_32(data);
6100 data >>= 32 - width;
6101
6102 FLAG_Z = data;
6103 FLAG_V = VFLAG_CLEAR;
6104 FLAG_C = CFLAG_CLEAR;
6105
6106 REG_D[(word2>>12)&7] = data;
6107
6108 return;
6109 }
6110 m68ki_exception_illegal();
6111 }
6112
6113
m68k_op_bfextu_32_ai(void)6114 void m68k_op_bfextu_32_ai(void)
6115 {
6116 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6117 {
6118 uint word2 = OPER_I_16();
6119 sint offset = (word2>>6)&31;
6120 uint width = word2;
6121 uint data;
6122 uint ea = EA_AY_AI_8();
6123
6124
6125 if(BIT_B(word2))
6126 offset = MAKE_INT_32(REG_D[offset&7]);
6127 if(BIT_5(word2))
6128 width = REG_D[width&7];
6129
6130 /* Offset is signed so we have to use ugly math =( */
6131 ea += offset / 8;
6132 offset %= 8;
6133 if(offset < 0)
6134 {
6135 offset += 8;
6136 ea--;
6137 }
6138 width = ((width-1) & 31) + 1;
6139
6140 data = m68ki_read_32(ea);
6141 data = MASK_OUT_ABOVE_32(data<<offset);
6142
6143 if((offset+width) > 32)
6144 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6145
6146 FLAG_N = NFLAG_32(data);
6147 data >>= (32 - width);
6148
6149 FLAG_Z = data;
6150 FLAG_V = VFLAG_CLEAR;
6151 FLAG_C = CFLAG_CLEAR;
6152
6153 REG_D[(word2 >> 12) & 7] = data;
6154
6155 return;
6156 }
6157 m68ki_exception_illegal();
6158 }
6159
6160
m68k_op_bfextu_32_di(void)6161 void m68k_op_bfextu_32_di(void)
6162 {
6163 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6164 {
6165 uint word2 = OPER_I_16();
6166 sint offset = (word2>>6)&31;
6167 uint width = word2;
6168 uint data;
6169 uint ea = EA_AY_DI_8();
6170
6171
6172 if(BIT_B(word2))
6173 offset = MAKE_INT_32(REG_D[offset&7]);
6174 if(BIT_5(word2))
6175 width = REG_D[width&7];
6176
6177 /* Offset is signed so we have to use ugly math =( */
6178 ea += offset / 8;
6179 offset %= 8;
6180 if(offset < 0)
6181 {
6182 offset += 8;
6183 ea--;
6184 }
6185 width = ((width-1) & 31) + 1;
6186
6187 data = m68ki_read_32(ea);
6188 data = MASK_OUT_ABOVE_32(data<<offset);
6189
6190 if((offset+width) > 32)
6191 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6192
6193 FLAG_N = NFLAG_32(data);
6194 data >>= (32 - width);
6195
6196 FLAG_Z = data;
6197 FLAG_V = VFLAG_CLEAR;
6198 FLAG_C = CFLAG_CLEAR;
6199
6200 REG_D[(word2 >> 12) & 7] = data;
6201
6202 return;
6203 }
6204 m68ki_exception_illegal();
6205 }
6206
6207
m68k_op_bfextu_32_ix(void)6208 void m68k_op_bfextu_32_ix(void)
6209 {
6210 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6211 {
6212 uint word2 = OPER_I_16();
6213 sint offset = (word2>>6)&31;
6214 uint width = word2;
6215 uint data;
6216 uint ea = EA_AY_IX_8();
6217
6218
6219 if(BIT_B(word2))
6220 offset = MAKE_INT_32(REG_D[offset&7]);
6221 if(BIT_5(word2))
6222 width = REG_D[width&7];
6223
6224 /* Offset is signed so we have to use ugly math =( */
6225 ea += offset / 8;
6226 offset %= 8;
6227 if(offset < 0)
6228 {
6229 offset += 8;
6230 ea--;
6231 }
6232 width = ((width-1) & 31) + 1;
6233
6234 data = m68ki_read_32(ea);
6235 data = MASK_OUT_ABOVE_32(data<<offset);
6236
6237 if((offset+width) > 32)
6238 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6239
6240 FLAG_N = NFLAG_32(data);
6241 data >>= (32 - width);
6242
6243 FLAG_Z = data;
6244 FLAG_V = VFLAG_CLEAR;
6245 FLAG_C = CFLAG_CLEAR;
6246
6247 REG_D[(word2 >> 12) & 7] = data;
6248
6249 return;
6250 }
6251 m68ki_exception_illegal();
6252 }
6253
6254
m68k_op_bfextu_32_aw(void)6255 void m68k_op_bfextu_32_aw(void)
6256 {
6257 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6258 {
6259 uint word2 = OPER_I_16();
6260 sint offset = (word2>>6)&31;
6261 uint width = word2;
6262 uint data;
6263 uint ea = EA_AW_8();
6264
6265
6266 if(BIT_B(word2))
6267 offset = MAKE_INT_32(REG_D[offset&7]);
6268 if(BIT_5(word2))
6269 width = REG_D[width&7];
6270
6271 /* Offset is signed so we have to use ugly math =( */
6272 ea += offset / 8;
6273 offset %= 8;
6274 if(offset < 0)
6275 {
6276 offset += 8;
6277 ea--;
6278 }
6279 width = ((width-1) & 31) + 1;
6280
6281 data = m68ki_read_32(ea);
6282 data = MASK_OUT_ABOVE_32(data<<offset);
6283
6284 if((offset+width) > 32)
6285 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6286
6287 FLAG_N = NFLAG_32(data);
6288 data >>= (32 - width);
6289
6290 FLAG_Z = data;
6291 FLAG_V = VFLAG_CLEAR;
6292 FLAG_C = CFLAG_CLEAR;
6293
6294 REG_D[(word2 >> 12) & 7] = data;
6295
6296 return;
6297 }
6298 m68ki_exception_illegal();
6299 }
6300
6301
m68k_op_bfextu_32_al(void)6302 void m68k_op_bfextu_32_al(void)
6303 {
6304 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6305 {
6306 uint word2 = OPER_I_16();
6307 sint offset = (word2>>6)&31;
6308 uint width = word2;
6309 uint data;
6310 uint ea = EA_AL_8();
6311
6312
6313 if(BIT_B(word2))
6314 offset = MAKE_INT_32(REG_D[offset&7]);
6315 if(BIT_5(word2))
6316 width = REG_D[width&7];
6317
6318 /* Offset is signed so we have to use ugly math =( */
6319 ea += offset / 8;
6320 offset %= 8;
6321 if(offset < 0)
6322 {
6323 offset += 8;
6324 ea--;
6325 }
6326 width = ((width-1) & 31) + 1;
6327
6328 data = m68ki_read_32(ea);
6329 data = MASK_OUT_ABOVE_32(data<<offset);
6330
6331 if((offset+width) > 32)
6332 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6333
6334 FLAG_N = NFLAG_32(data);
6335 data >>= (32 - width);
6336
6337 FLAG_Z = data;
6338 FLAG_V = VFLAG_CLEAR;
6339 FLAG_C = CFLAG_CLEAR;
6340
6341 REG_D[(word2 >> 12) & 7] = data;
6342
6343 return;
6344 }
6345 m68ki_exception_illegal();
6346 }
6347
6348
m68k_op_bfextu_32_pcdi(void)6349 void m68k_op_bfextu_32_pcdi(void)
6350 {
6351 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6352 {
6353 uint word2 = OPER_I_16();
6354 sint offset = (word2>>6)&31;
6355 uint width = word2;
6356 uint data;
6357 uint ea = EA_PCDI_8();
6358
6359
6360 if(BIT_B(word2))
6361 offset = MAKE_INT_32(REG_D[offset&7]);
6362 if(BIT_5(word2))
6363 width = REG_D[width&7];
6364
6365 /* Offset is signed so we have to use ugly math =( */
6366 ea += offset / 8;
6367 offset %= 8;
6368 if(offset < 0)
6369 {
6370 offset += 8;
6371 ea--;
6372 }
6373 width = ((width-1) & 31) + 1;
6374
6375 data = m68ki_read_32(ea);
6376 data = MASK_OUT_ABOVE_32(data<<offset);
6377
6378 if((offset+width) > 32)
6379 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6380
6381 FLAG_N = NFLAG_32(data);
6382 data >>= (32 - width);
6383
6384 FLAG_Z = data;
6385 FLAG_V = VFLAG_CLEAR;
6386 FLAG_C = CFLAG_CLEAR;
6387
6388 REG_D[(word2 >> 12) & 7] = data;
6389
6390 return;
6391 }
6392 m68ki_exception_illegal();
6393 }
6394
6395
m68k_op_bfextu_32_pcix(void)6396 void m68k_op_bfextu_32_pcix(void)
6397 {
6398 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6399 {
6400 uint word2 = OPER_I_16();
6401 sint offset = (word2>>6)&31;
6402 uint width = word2;
6403 uint data;
6404 uint ea = EA_PCIX_8();
6405
6406
6407 if(BIT_B(word2))
6408 offset = MAKE_INT_32(REG_D[offset&7]);
6409 if(BIT_5(word2))
6410 width = REG_D[width&7];
6411
6412 /* Offset is signed so we have to use ugly math =( */
6413 ea += offset / 8;
6414 offset %= 8;
6415 if(offset < 0)
6416 {
6417 offset += 8;
6418 ea--;
6419 }
6420 width = ((width-1) & 31) + 1;
6421
6422 data = m68ki_read_32(ea);
6423 data = MASK_OUT_ABOVE_32(data<<offset);
6424
6425 if((offset+width) > 32)
6426 data |= (m68ki_read_8(ea+4) << offset) >> 8;
6427
6428 FLAG_N = NFLAG_32(data);
6429 data >>= (32 - width);
6430
6431 FLAG_Z = data;
6432 FLAG_V = VFLAG_CLEAR;
6433 FLAG_C = CFLAG_CLEAR;
6434
6435 REG_D[(word2 >> 12) & 7] = data;
6436
6437 return;
6438 }
6439 m68ki_exception_illegal();
6440 }
6441
6442
m68k_op_bfffo_32_d(void)6443 void m68k_op_bfffo_32_d(void)
6444 {
6445 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6446 {
6447 uint word2 = OPER_I_16();
6448 uint offset = (word2>>6)&31;
6449 uint width = word2;
6450 uint64 data = DY;
6451 uint bit;
6452
6453
6454 if(BIT_B(word2))
6455 offset = REG_D[offset&7];
6456 if(BIT_5(word2))
6457 width = REG_D[width&7];
6458
6459 offset &= 31;
6460 width = ((width-1) & 31) + 1;
6461
6462 data = ROL_32(data, offset);
6463 FLAG_N = NFLAG_32(data);
6464 data >>= 32 - width;
6465
6466 FLAG_Z = data;
6467 FLAG_V = VFLAG_CLEAR;
6468 FLAG_C = CFLAG_CLEAR;
6469
6470 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6471 offset++;
6472
6473 REG_D[(word2>>12)&7] = offset;
6474
6475 return;
6476 }
6477 m68ki_exception_illegal();
6478 }
6479
6480
m68k_op_bfffo_32_ai(void)6481 void m68k_op_bfffo_32_ai(void)
6482 {
6483 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6484 {
6485 uint word2 = OPER_I_16();
6486 sint offset = (word2>>6)&31;
6487 sint local_offset;
6488 uint width = word2;
6489 uint data;
6490 uint bit;
6491 uint ea = EA_AY_AI_8();
6492
6493
6494 if(BIT_B(word2))
6495 offset = MAKE_INT_32(REG_D[offset&7]);
6496 if(BIT_5(word2))
6497 width = REG_D[width&7];
6498
6499 /* Offset is signed so we have to use ugly math =( */
6500 ea += offset / 8;
6501 local_offset = offset % 8;
6502 if(local_offset < 0)
6503 {
6504 local_offset += 8;
6505 ea--;
6506 }
6507 width = ((width-1) & 31) + 1;
6508
6509 data = m68ki_read_32(ea);
6510 data = MASK_OUT_ABOVE_32(data<<local_offset);
6511
6512 if((local_offset+width) > 32)
6513 data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
6514
6515 FLAG_N = NFLAG_32(data);
6516 data >>= (32 - width);
6517
6518 FLAG_Z = data;
6519 FLAG_V = VFLAG_CLEAR;
6520 FLAG_C = CFLAG_CLEAR;
6521
6522 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6523 offset++;
6524
6525 REG_D[(word2>>12)&7] = offset;
6526
6527 return;
6528 }
6529 m68ki_exception_illegal();
6530 }
6531
6532
m68k_op_bfffo_32_di(void)6533 void m68k_op_bfffo_32_di(void)
6534 {
6535 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6536 {
6537 uint word2 = OPER_I_16();
6538 sint offset = (word2>>6)&31;
6539 sint local_offset;
6540 uint width = word2;
6541 uint data;
6542 uint bit;
6543 uint ea = EA_AY_DI_8();
6544
6545
6546 if(BIT_B(word2))
6547 offset = MAKE_INT_32(REG_D[offset&7]);
6548 if(BIT_5(word2))
6549 width = REG_D[width&7];
6550
6551 /* Offset is signed so we have to use ugly math =( */
6552 ea += offset / 8;
6553 local_offset = offset % 8;
6554 if(local_offset < 0)
6555 {
6556 local_offset += 8;
6557 ea--;
6558 }
6559 width = ((width-1) & 31) + 1;
6560
6561 data = m68ki_read_32(ea);
6562 data = MASK_OUT_ABOVE_32(data<<local_offset);
6563
6564 if((local_offset+width) > 32)
6565 data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
6566
6567 FLAG_N = NFLAG_32(data);
6568 data >>= (32 - width);
6569
6570 FLAG_Z = data;
6571 FLAG_V = VFLAG_CLEAR;
6572 FLAG_C = CFLAG_CLEAR;
6573
6574 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6575 offset++;
6576
6577 REG_D[(word2>>12)&7] = offset;
6578
6579 return;
6580 }
6581 m68ki_exception_illegal();
6582 }
6583
6584
m68k_op_bfffo_32_ix(void)6585 void m68k_op_bfffo_32_ix(void)
6586 {
6587 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6588 {
6589 uint word2 = OPER_I_16();
6590 sint offset = (word2>>6)&31;
6591 sint local_offset;
6592 uint width = word2;
6593 uint data;
6594 uint bit;
6595 uint ea = EA_AY_IX_8();
6596
6597
6598 if(BIT_B(word2))
6599 offset = MAKE_INT_32(REG_D[offset&7]);
6600 if(BIT_5(word2))
6601 width = REG_D[width&7];
6602
6603 /* Offset is signed so we have to use ugly math =( */
6604 ea += offset / 8;
6605 local_offset = offset % 8;
6606 if(local_offset < 0)
6607 {
6608 local_offset += 8;
6609 ea--;
6610 }
6611 width = ((width-1) & 31) + 1;
6612
6613 data = m68ki_read_32(ea);
6614 data = MASK_OUT_ABOVE_32(data<<local_offset);
6615
6616 if((local_offset+width) > 32)
6617 data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
6618
6619 FLAG_N = NFLAG_32(data);
6620 data >>= (32 - width);
6621
6622 FLAG_Z = data;
6623 FLAG_V = VFLAG_CLEAR;
6624 FLAG_C = CFLAG_CLEAR;
6625
6626 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6627 offset++;
6628
6629 REG_D[(word2>>12)&7] = offset;
6630
6631 return;
6632 }
6633 m68ki_exception_illegal();
6634 }
6635
6636
m68k_op_bfffo_32_aw(void)6637 void m68k_op_bfffo_32_aw(void)
6638 {
6639 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6640 {
6641 uint word2 = OPER_I_16();
6642 sint offset = (word2>>6)&31;
6643 sint local_offset;
6644 uint width = word2;
6645 uint data;
6646 uint bit;
6647 uint ea = EA_AW_8();
6648
6649
6650 if(BIT_B(word2))
6651 offset = MAKE_INT_32(REG_D[offset&7]);
6652 if(BIT_5(word2))
6653 width = REG_D[width&7];
6654
6655 /* Offset is signed so we have to use ugly math =( */
6656 ea += offset / 8;
6657 local_offset = offset % 8;
6658 if(local_offset < 0)
6659 {
6660 local_offset += 8;
6661 ea--;
6662 }
6663 width = ((width-1) & 31) + 1;
6664
6665 data = m68ki_read_32(ea);
6666 data = MASK_OUT_ABOVE_32(data<<local_offset);
6667
6668 if((local_offset+width) > 32)
6669 data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
6670
6671 FLAG_N = NFLAG_32(data);
6672 data >>= (32 - width);
6673
6674 FLAG_Z = data;
6675 FLAG_V = VFLAG_CLEAR;
6676 FLAG_C = CFLAG_CLEAR;
6677
6678 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6679 offset++;
6680
6681 REG_D[(word2>>12)&7] = offset;
6682
6683 return;
6684 }
6685 m68ki_exception_illegal();
6686 }
6687
6688
m68k_op_bfffo_32_al(void)6689 void m68k_op_bfffo_32_al(void)
6690 {
6691 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6692 {
6693 uint word2 = OPER_I_16();
6694 sint offset = (word2>>6)&31;
6695 sint local_offset;
6696 uint width = word2;
6697 uint data;
6698 uint bit;
6699 uint ea = EA_AL_8();
6700
6701
6702 if(BIT_B(word2))
6703 offset = MAKE_INT_32(REG_D[offset&7]);
6704 if(BIT_5(word2))
6705 width = REG_D[width&7];
6706
6707 /* Offset is signed so we have to use ugly math =( */
6708 ea += offset / 8;
6709 local_offset = offset % 8;
6710 if(local_offset < 0)
6711 {
6712 local_offset += 8;
6713 ea--;
6714 }
6715 width = ((width-1) & 31) + 1;
6716
6717 data = m68ki_read_32(ea);
6718 data = MASK_OUT_ABOVE_32(data<<local_offset);
6719
6720 if((local_offset+width) > 32)
6721 data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
6722
6723 FLAG_N = NFLAG_32(data);
6724 data >>= (32 - width);
6725
6726 FLAG_Z = data;
6727 FLAG_V = VFLAG_CLEAR;
6728 FLAG_C = CFLAG_CLEAR;
6729
6730 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6731 offset++;
6732
6733 REG_D[(word2>>12)&7] = offset;
6734
6735 return;
6736 }
6737 m68ki_exception_illegal();
6738 }
6739
6740
m68k_op_bfffo_32_pcdi(void)6741 void m68k_op_bfffo_32_pcdi(void)
6742 {
6743 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6744 {
6745 uint word2 = OPER_I_16();
6746 sint offset = (word2>>6)&31;
6747 sint local_offset;
6748 uint width = word2;
6749 uint data;
6750 uint bit;
6751 uint ea = EA_PCDI_8();
6752
6753
6754 if(BIT_B(word2))
6755 offset = MAKE_INT_32(REG_D[offset&7]);
6756 if(BIT_5(word2))
6757 width = REG_D[width&7];
6758
6759 /* Offset is signed so we have to use ugly math =( */
6760 ea += offset / 8;
6761 local_offset = offset % 8;
6762 if(local_offset < 0)
6763 {
6764 local_offset += 8;
6765 ea--;
6766 }
6767 width = ((width-1) & 31) + 1;
6768
6769 data = m68ki_read_32(ea);
6770 data = MASK_OUT_ABOVE_32(data<<local_offset);
6771
6772 if((local_offset+width) > 32)
6773 data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
6774
6775 FLAG_N = NFLAG_32(data);
6776 data >>= (32 - width);
6777
6778 FLAG_Z = data;
6779 FLAG_V = VFLAG_CLEAR;
6780 FLAG_C = CFLAG_CLEAR;
6781
6782 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6783 offset++;
6784
6785 REG_D[(word2>>12)&7] = offset;
6786
6787 return;
6788 }
6789 m68ki_exception_illegal();
6790 }
6791
6792
m68k_op_bfffo_32_pcix(void)6793 void m68k_op_bfffo_32_pcix(void)
6794 {
6795 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6796 {
6797 uint word2 = OPER_I_16();
6798 sint offset = (word2>>6)&31;
6799 sint local_offset;
6800 uint width = word2;
6801 uint data;
6802 uint bit;
6803 uint ea = EA_PCIX_8();
6804
6805
6806 if(BIT_B(word2))
6807 offset = MAKE_INT_32(REG_D[offset&7]);
6808 if(BIT_5(word2))
6809 width = REG_D[width&7];
6810
6811 /* Offset is signed so we have to use ugly math =( */
6812 ea += offset / 8;
6813 local_offset = offset % 8;
6814 if(local_offset < 0)
6815 {
6816 local_offset += 8;
6817 ea--;
6818 }
6819 width = ((width-1) & 31) + 1;
6820
6821 data = m68ki_read_32(ea);
6822 data = MASK_OUT_ABOVE_32(data<<local_offset);
6823
6824 if((local_offset+width) > 32)
6825 data |= (m68ki_read_8(ea+4) << local_offset) >> 8;
6826
6827 FLAG_N = NFLAG_32(data);
6828 data >>= (32 - width);
6829
6830 FLAG_Z = data;
6831 FLAG_V = VFLAG_CLEAR;
6832 FLAG_C = CFLAG_CLEAR;
6833
6834 for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1)
6835 offset++;
6836
6837 REG_D[(word2>>12)&7] = offset;
6838
6839 return;
6840 }
6841 m68ki_exception_illegal();
6842 }
6843
6844
m68k_op_bfins_32_d(void)6845 void m68k_op_bfins_32_d(void)
6846 {
6847 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6848 {
6849 uint word2 = OPER_I_16();
6850 uint offset = (word2>>6)&31;
6851 uint width = word2;
6852 uint* data = &DY;
6853 uint64 mask;
6854 uint64 insert = REG_D[(word2>>12)&7];
6855
6856
6857 if(BIT_B(word2))
6858 offset = REG_D[offset&7];
6859 if(BIT_5(word2))
6860 width = REG_D[width&7];
6861
6862
6863 offset &= 31;
6864 width = ((width-1) & 31) + 1;
6865
6866
6867 mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
6868 mask = ROR_32(mask, offset);
6869
6870 insert = MASK_OUT_ABOVE_32(insert << (32 - width));
6871 FLAG_N = NFLAG_32(insert);
6872 FLAG_Z = insert;
6873 insert = ROR_32(insert, offset);
6874
6875 FLAG_V = VFLAG_CLEAR;
6876 FLAG_C = CFLAG_CLEAR;
6877
6878 *data &= ~mask;
6879 *data |= insert;
6880
6881 return;
6882 }
6883 m68ki_exception_illegal();
6884 }
6885
6886
m68k_op_bfins_32_ai(void)6887 void m68k_op_bfins_32_ai(void)
6888 {
6889 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6890 {
6891 uint word2 = OPER_I_16();
6892 sint offset = (word2>>6)&31;
6893 uint width = word2;
6894 uint insert_base = REG_D[(word2>>12)&7];
6895 uint insert_long;
6896 uint insert_byte;
6897 uint mask_base;
6898 uint data_long;
6899 uint mask_long;
6900 uint data_byte = 0;
6901 uint mask_byte = 0;
6902 uint ea = EA_AY_AI_8();
6903
6904
6905 if(BIT_B(word2))
6906 offset = MAKE_INT_32(REG_D[offset&7]);
6907 if(BIT_5(word2))
6908 width = REG_D[width&7];
6909
6910 /* Offset is signed so we have to use ugly math =( */
6911 ea += offset / 8;
6912 offset %= 8;
6913 if(offset < 0)
6914 {
6915 offset += 8;
6916 ea--;
6917 }
6918 width = ((width-1) & 31) + 1;
6919
6920 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
6921 mask_long = mask_base >> offset;
6922
6923 insert_base = MASK_OUT_ABOVE_32(insert_base << (32 - width));
6924 FLAG_N = NFLAG_32(insert_base);
6925 FLAG_Z = insert_base;
6926 insert_long = insert_base >> offset;
6927
6928 data_long = m68ki_read_32(ea);
6929 FLAG_V = VFLAG_CLEAR;
6930 FLAG_C = CFLAG_CLEAR;
6931
6932 m68ki_write_32(ea, (data_long & ~mask_long) | insert_long);
6933
6934 if((width + offset) > 32)
6935 {
6936 mask_byte = MASK_OUT_ABOVE_8(mask_base);
6937 insert_byte = MASK_OUT_ABOVE_8(insert_base);
6938 data_byte = m68ki_read_8(ea+4);
6939 FLAG_Z |= (data_byte & mask_byte);
6940 m68ki_write_8(ea+4, (data_byte & ~mask_byte) | insert_byte);
6941 }
6942 return;
6943 }
6944 m68ki_exception_illegal();
6945 }
6946
6947
m68k_op_bfins_32_di(void)6948 void m68k_op_bfins_32_di(void)
6949 {
6950 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
6951 {
6952 uint word2 = OPER_I_16();
6953 sint offset = (word2>>6)&31;
6954 uint width = word2;
6955 uint insert_base = REG_D[(word2>>12)&7];
6956 uint insert_long;
6957 uint insert_byte;
6958 uint mask_base;
6959 uint data_long;
6960 uint mask_long;
6961 uint data_byte = 0;
6962 uint mask_byte = 0;
6963 uint ea = EA_AY_DI_8();
6964
6965
6966 if(BIT_B(word2))
6967 offset = MAKE_INT_32(REG_D[offset&7]);
6968 if(BIT_5(word2))
6969 width = REG_D[width&7];
6970
6971 /* Offset is signed so we have to use ugly math =( */
6972 ea += offset / 8;
6973 offset %= 8;
6974 if(offset < 0)
6975 {
6976 offset += 8;
6977 ea--;
6978 }
6979 width = ((width-1) & 31) + 1;
6980
6981 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
6982 mask_long = mask_base >> offset;
6983
6984 insert_base = MASK_OUT_ABOVE_32(insert_base << (32 - width));
6985 FLAG_N = NFLAG_32(insert_base);
6986 FLAG_Z = insert_base;
6987 insert_long = insert_base >> offset;
6988
6989 data_long = m68ki_read_32(ea);
6990 FLAG_V = VFLAG_CLEAR;
6991 FLAG_C = CFLAG_CLEAR;
6992
6993 m68ki_write_32(ea, (data_long & ~mask_long) | insert_long);
6994
6995 if((width + offset) > 32)
6996 {
6997 mask_byte = MASK_OUT_ABOVE_8(mask_base);
6998 insert_byte = MASK_OUT_ABOVE_8(insert_base);
6999 data_byte = m68ki_read_8(ea+4);
7000 FLAG_Z |= (data_byte & mask_byte);
7001 m68ki_write_8(ea+4, (data_byte & ~mask_byte) | insert_byte);
7002 }
7003 return;
7004 }
7005 m68ki_exception_illegal();
7006 }
7007
7008
m68k_op_bfins_32_ix(void)7009 void m68k_op_bfins_32_ix(void)
7010 {
7011 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7012 {
7013 uint word2 = OPER_I_16();
7014 sint offset = (word2>>6)&31;
7015 uint width = word2;
7016 uint insert_base = REG_D[(word2>>12)&7];
7017 uint insert_long;
7018 uint insert_byte;
7019 uint mask_base;
7020 uint data_long;
7021 uint mask_long;
7022 uint data_byte = 0;
7023 uint mask_byte = 0;
7024 uint ea = EA_AY_IX_8();
7025
7026
7027 if(BIT_B(word2))
7028 offset = MAKE_INT_32(REG_D[offset&7]);
7029 if(BIT_5(word2))
7030 width = REG_D[width&7];
7031
7032 /* Offset is signed so we have to use ugly math =( */
7033 ea += offset / 8;
7034 offset %= 8;
7035 if(offset < 0)
7036 {
7037 offset += 8;
7038 ea--;
7039 }
7040 width = ((width-1) & 31) + 1;
7041
7042 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7043 mask_long = mask_base >> offset;
7044
7045 insert_base = MASK_OUT_ABOVE_32(insert_base << (32 - width));
7046 FLAG_N = NFLAG_32(insert_base);
7047 FLAG_Z = insert_base;
7048 insert_long = insert_base >> offset;
7049
7050 data_long = m68ki_read_32(ea);
7051 FLAG_V = VFLAG_CLEAR;
7052 FLAG_C = CFLAG_CLEAR;
7053
7054 m68ki_write_32(ea, (data_long & ~mask_long) | insert_long);
7055
7056 if((width + offset) > 32)
7057 {
7058 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7059 insert_byte = MASK_OUT_ABOVE_8(insert_base);
7060 data_byte = m68ki_read_8(ea+4);
7061 FLAG_Z |= (data_byte & mask_byte);
7062 m68ki_write_8(ea+4, (data_byte & ~mask_byte) | insert_byte);
7063 }
7064 return;
7065 }
7066 m68ki_exception_illegal();
7067 }
7068
7069
m68k_op_bfins_32_aw(void)7070 void m68k_op_bfins_32_aw(void)
7071 {
7072 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7073 {
7074 uint word2 = OPER_I_16();
7075 sint offset = (word2>>6)&31;
7076 uint width = word2;
7077 uint insert_base = REG_D[(word2>>12)&7];
7078 uint insert_long;
7079 uint insert_byte;
7080 uint mask_base;
7081 uint data_long;
7082 uint mask_long;
7083 uint data_byte = 0;
7084 uint mask_byte = 0;
7085 uint ea = EA_AW_8();
7086
7087
7088 if(BIT_B(word2))
7089 offset = MAKE_INT_32(REG_D[offset&7]);
7090 if(BIT_5(word2))
7091 width = REG_D[width&7];
7092
7093 /* Offset is signed so we have to use ugly math =( */
7094 ea += offset / 8;
7095 offset %= 8;
7096 if(offset < 0)
7097 {
7098 offset += 8;
7099 ea--;
7100 }
7101 width = ((width-1) & 31) + 1;
7102
7103 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7104 mask_long = mask_base >> offset;
7105
7106 insert_base = MASK_OUT_ABOVE_32(insert_base << (32 - width));
7107 FLAG_N = NFLAG_32(insert_base);
7108 FLAG_Z = insert_base;
7109 insert_long = insert_base >> offset;
7110
7111 data_long = m68ki_read_32(ea);
7112 FLAG_V = VFLAG_CLEAR;
7113 FLAG_C = CFLAG_CLEAR;
7114
7115 m68ki_write_32(ea, (data_long & ~mask_long) | insert_long);
7116
7117 if((width + offset) > 32)
7118 {
7119 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7120 insert_byte = MASK_OUT_ABOVE_8(insert_base);
7121 data_byte = m68ki_read_8(ea+4);
7122 FLAG_Z |= (data_byte & mask_byte);
7123 m68ki_write_8(ea+4, (data_byte & ~mask_byte) | insert_byte);
7124 }
7125 return;
7126 }
7127 m68ki_exception_illegal();
7128 }
7129
7130
m68k_op_bfins_32_al(void)7131 void m68k_op_bfins_32_al(void)
7132 {
7133 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7134 {
7135 uint word2 = OPER_I_16();
7136 sint offset = (word2>>6)&31;
7137 uint width = word2;
7138 uint insert_base = REG_D[(word2>>12)&7];
7139 uint insert_long;
7140 uint insert_byte;
7141 uint mask_base;
7142 uint data_long;
7143 uint mask_long;
7144 uint data_byte = 0;
7145 uint mask_byte = 0;
7146 uint ea = EA_AL_8();
7147
7148
7149 if(BIT_B(word2))
7150 offset = MAKE_INT_32(REG_D[offset&7]);
7151 if(BIT_5(word2))
7152 width = REG_D[width&7];
7153
7154 /* Offset is signed so we have to use ugly math =( */
7155 ea += offset / 8;
7156 offset %= 8;
7157 if(offset < 0)
7158 {
7159 offset += 8;
7160 ea--;
7161 }
7162 width = ((width-1) & 31) + 1;
7163
7164 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7165 mask_long = mask_base >> offset;
7166
7167 insert_base = MASK_OUT_ABOVE_32(insert_base << (32 - width));
7168 FLAG_N = NFLAG_32(insert_base);
7169 FLAG_Z = insert_base;
7170 insert_long = insert_base >> offset;
7171
7172 data_long = m68ki_read_32(ea);
7173 FLAG_V = VFLAG_CLEAR;
7174 FLAG_C = CFLAG_CLEAR;
7175
7176 m68ki_write_32(ea, (data_long & ~mask_long) | insert_long);
7177
7178 if((width + offset) > 32)
7179 {
7180 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7181 insert_byte = MASK_OUT_ABOVE_8(insert_base);
7182 data_byte = m68ki_read_8(ea+4);
7183 FLAG_Z |= (data_byte & mask_byte);
7184 m68ki_write_8(ea+4, (data_byte & ~mask_byte) | insert_byte);
7185 }
7186 return;
7187 }
7188 m68ki_exception_illegal();
7189 }
7190
7191
m68k_op_bfset_32_d(void)7192 void m68k_op_bfset_32_d(void)
7193 {
7194 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7195 {
7196 uint word2 = OPER_I_16();
7197 uint offset = (word2>>6)&31;
7198 uint width = word2;
7199 uint* data = &DY;
7200 uint64 mask;
7201
7202
7203 if(BIT_B(word2))
7204 offset = REG_D[offset&7];
7205 if(BIT_5(word2))
7206 width = REG_D[width&7];
7207
7208
7209 offset &= 31;
7210 width = ((width-1) & 31) + 1;
7211
7212
7213 mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7214 mask = ROR_32(mask, offset);
7215
7216 FLAG_N = NFLAG_32(*data<<offset);
7217 FLAG_Z = *data & mask;
7218 FLAG_V = VFLAG_CLEAR;
7219 FLAG_C = CFLAG_CLEAR;
7220
7221 *data |= mask;
7222
7223 return;
7224 }
7225 m68ki_exception_illegal();
7226 }
7227
7228
m68k_op_bfset_32_ai(void)7229 void m68k_op_bfset_32_ai(void)
7230 {
7231 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7232 {
7233 uint word2 = OPER_I_16();
7234 sint offset = (word2>>6)&31;
7235 uint width = word2;
7236 uint mask_base;
7237 uint data_long;
7238 uint mask_long;
7239 uint data_byte = 0;
7240 uint mask_byte = 0;
7241 uint ea = EA_AY_AI_8();
7242
7243
7244 if(BIT_B(word2))
7245 offset = MAKE_INT_32(REG_D[offset&7]);
7246 if(BIT_5(word2))
7247 width = REG_D[width&7];
7248
7249 /* Offset is signed so we have to use ugly math =( */
7250 ea += offset / 8;
7251 offset %= 8;
7252 if(offset < 0)
7253 {
7254 offset += 8;
7255 ea--;
7256 }
7257 width = ((width-1) & 31) + 1;
7258
7259
7260 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7261 mask_long = mask_base >> offset;
7262
7263 data_long = m68ki_read_32(ea);
7264 FLAG_N = NFLAG_32(data_long << offset);
7265 FLAG_Z = data_long & mask_long;
7266 FLAG_V = VFLAG_CLEAR;
7267 FLAG_C = CFLAG_CLEAR;
7268
7269 m68ki_write_32(ea, data_long | mask_long);
7270
7271 if((width + offset) > 32)
7272 {
7273 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7274 data_byte = m68ki_read_8(ea+4);
7275 FLAG_Z |= (data_byte & mask_byte);
7276 m68ki_write_8(ea+4, data_byte | mask_byte);
7277 }
7278 return;
7279 }
7280 m68ki_exception_illegal();
7281 }
7282
7283
m68k_op_bfset_32_di(void)7284 void m68k_op_bfset_32_di(void)
7285 {
7286 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7287 {
7288 uint word2 = OPER_I_16();
7289 sint offset = (word2>>6)&31;
7290 uint width = word2;
7291 uint mask_base;
7292 uint data_long;
7293 uint mask_long;
7294 uint data_byte = 0;
7295 uint mask_byte = 0;
7296 uint ea = EA_AY_DI_8();
7297
7298
7299 if(BIT_B(word2))
7300 offset = MAKE_INT_32(REG_D[offset&7]);
7301 if(BIT_5(word2))
7302 width = REG_D[width&7];
7303
7304 /* Offset is signed so we have to use ugly math =( */
7305 ea += offset / 8;
7306 offset %= 8;
7307 if(offset < 0)
7308 {
7309 offset += 8;
7310 ea--;
7311 }
7312 width = ((width-1) & 31) + 1;
7313
7314
7315 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7316 mask_long = mask_base >> offset;
7317
7318 data_long = m68ki_read_32(ea);
7319 FLAG_N = NFLAG_32(data_long << offset);
7320 FLAG_Z = data_long & mask_long;
7321 FLAG_V = VFLAG_CLEAR;
7322 FLAG_C = CFLAG_CLEAR;
7323
7324 m68ki_write_32(ea, data_long | mask_long);
7325
7326 if((width + offset) > 32)
7327 {
7328 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7329 data_byte = m68ki_read_8(ea+4);
7330 FLAG_Z |= (data_byte & mask_byte);
7331 m68ki_write_8(ea+4, data_byte | mask_byte);
7332 }
7333 return;
7334 }
7335 m68ki_exception_illegal();
7336 }
7337
7338
m68k_op_bfset_32_ix(void)7339 void m68k_op_bfset_32_ix(void)
7340 {
7341 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7342 {
7343 uint word2 = OPER_I_16();
7344 sint offset = (word2>>6)&31;
7345 uint width = word2;
7346 uint mask_base;
7347 uint data_long;
7348 uint mask_long;
7349 uint data_byte = 0;
7350 uint mask_byte = 0;
7351 uint ea = EA_AY_IX_8();
7352
7353
7354 if(BIT_B(word2))
7355 offset = MAKE_INT_32(REG_D[offset&7]);
7356 if(BIT_5(word2))
7357 width = REG_D[width&7];
7358
7359 /* Offset is signed so we have to use ugly math =( */
7360 ea += offset / 8;
7361 offset %= 8;
7362 if(offset < 0)
7363 {
7364 offset += 8;
7365 ea--;
7366 }
7367 width = ((width-1) & 31) + 1;
7368
7369
7370 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7371 mask_long = mask_base >> offset;
7372
7373 data_long = m68ki_read_32(ea);
7374 FLAG_N = NFLAG_32(data_long << offset);
7375 FLAG_Z = data_long & mask_long;
7376 FLAG_V = VFLAG_CLEAR;
7377 FLAG_C = CFLAG_CLEAR;
7378
7379 m68ki_write_32(ea, data_long | mask_long);
7380
7381 if((width + offset) > 32)
7382 {
7383 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7384 data_byte = m68ki_read_8(ea+4);
7385 FLAG_Z |= (data_byte & mask_byte);
7386 m68ki_write_8(ea+4, data_byte | mask_byte);
7387 }
7388 return;
7389 }
7390 m68ki_exception_illegal();
7391 }
7392
7393
m68k_op_bfset_32_aw(void)7394 void m68k_op_bfset_32_aw(void)
7395 {
7396 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7397 {
7398 uint word2 = OPER_I_16();
7399 sint offset = (word2>>6)&31;
7400 uint width = word2;
7401 uint mask_base;
7402 uint data_long;
7403 uint mask_long;
7404 uint data_byte = 0;
7405 uint mask_byte = 0;
7406 uint ea = EA_AW_8();
7407
7408
7409 if(BIT_B(word2))
7410 offset = MAKE_INT_32(REG_D[offset&7]);
7411 if(BIT_5(word2))
7412 width = REG_D[width&7];
7413
7414 /* Offset is signed so we have to use ugly math =( */
7415 ea += offset / 8;
7416 offset %= 8;
7417 if(offset < 0)
7418 {
7419 offset += 8;
7420 ea--;
7421 }
7422 width = ((width-1) & 31) + 1;
7423
7424
7425 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7426 mask_long = mask_base >> offset;
7427
7428 data_long = m68ki_read_32(ea);
7429 FLAG_N = NFLAG_32(data_long << offset);
7430 FLAG_Z = data_long & mask_long;
7431 FLAG_V = VFLAG_CLEAR;
7432 FLAG_C = CFLAG_CLEAR;
7433
7434 m68ki_write_32(ea, data_long | mask_long);
7435
7436 if((width + offset) > 32)
7437 {
7438 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7439 data_byte = m68ki_read_8(ea+4);
7440 FLAG_Z |= (data_byte & mask_byte);
7441 m68ki_write_8(ea+4, data_byte | mask_byte);
7442 }
7443 return;
7444 }
7445 m68ki_exception_illegal();
7446 }
7447
7448
m68k_op_bfset_32_al(void)7449 void m68k_op_bfset_32_al(void)
7450 {
7451 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7452 {
7453 uint word2 = OPER_I_16();
7454 sint offset = (word2>>6)&31;
7455 uint width = word2;
7456 uint mask_base;
7457 uint data_long;
7458 uint mask_long;
7459 uint data_byte = 0;
7460 uint mask_byte = 0;
7461 uint ea = EA_AL_8();
7462
7463
7464 if(BIT_B(word2))
7465 offset = MAKE_INT_32(REG_D[offset&7]);
7466 if(BIT_5(word2))
7467 width = REG_D[width&7];
7468
7469 /* Offset is signed so we have to use ugly math =( */
7470 ea += offset / 8;
7471 offset %= 8;
7472 if(offset < 0)
7473 {
7474 offset += 8;
7475 ea--;
7476 }
7477 width = ((width-1) & 31) + 1;
7478
7479
7480 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7481 mask_long = mask_base >> offset;
7482
7483 data_long = m68ki_read_32(ea);
7484 FLAG_N = NFLAG_32(data_long << offset);
7485 FLAG_Z = data_long & mask_long;
7486 FLAG_V = VFLAG_CLEAR;
7487 FLAG_C = CFLAG_CLEAR;
7488
7489 m68ki_write_32(ea, data_long | mask_long);
7490
7491 if((width + offset) > 32)
7492 {
7493 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7494 data_byte = m68ki_read_8(ea+4);
7495 FLAG_Z |= (data_byte & mask_byte);
7496 m68ki_write_8(ea+4, data_byte | mask_byte);
7497 }
7498 return;
7499 }
7500 m68ki_exception_illegal();
7501 }
7502
7503
m68k_op_bftst_32_d(void)7504 void m68k_op_bftst_32_d(void)
7505 {
7506 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7507 {
7508 uint word2 = OPER_I_16();
7509 uint offset = (word2>>6)&31;
7510 uint width = word2;
7511 uint* data = &DY;
7512 uint64 mask;
7513
7514
7515 if(BIT_B(word2))
7516 offset = REG_D[offset&7];
7517 if(BIT_5(word2))
7518 width = REG_D[width&7];
7519
7520
7521 offset &= 31;
7522 width = ((width-1) & 31) + 1;
7523
7524
7525 mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7526 mask = ROR_32(mask, offset);
7527
7528 FLAG_N = NFLAG_32(*data<<offset);
7529 FLAG_Z = *data & mask;
7530 FLAG_V = VFLAG_CLEAR;
7531 FLAG_C = CFLAG_CLEAR;
7532
7533 return;
7534 }
7535 m68ki_exception_illegal();
7536 }
7537
7538
m68k_op_bftst_32_ai(void)7539 void m68k_op_bftst_32_ai(void)
7540 {
7541 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7542 {
7543 uint word2 = OPER_I_16();
7544 sint offset = (word2>>6)&31;
7545 uint width = word2;
7546 uint mask_base;
7547 uint data_long;
7548 uint mask_long;
7549 uint data_byte = 0;
7550 uint mask_byte = 0;
7551 uint ea = EA_AY_AI_8();
7552
7553 if(BIT_B(word2))
7554 offset = MAKE_INT_32(REG_D[offset&7]);
7555 if(BIT_5(word2))
7556 width = REG_D[width&7];
7557
7558 /* Offset is signed so we have to use ugly math =( */
7559 ea += offset / 8;
7560 offset %= 8;
7561 if(offset < 0)
7562 {
7563 offset += 8;
7564 ea--;
7565 }
7566 width = ((width-1) & 31) + 1;
7567
7568
7569 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7570 mask_long = mask_base >> offset;
7571
7572 data_long = m68ki_read_32(ea);
7573 FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
7574 FLAG_Z = data_long & mask_long;
7575 FLAG_V = VFLAG_CLEAR;
7576 FLAG_C = CFLAG_CLEAR;
7577
7578 if((width + offset) > 32)
7579 {
7580 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7581 data_byte = m68ki_read_8(ea+4);
7582 FLAG_Z |= (data_byte & mask_byte);
7583 }
7584 return;
7585 }
7586 m68ki_exception_illegal();
7587 }
7588
7589
m68k_op_bftst_32_di(void)7590 void m68k_op_bftst_32_di(void)
7591 {
7592 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7593 {
7594 uint word2 = OPER_I_16();
7595 sint offset = (word2>>6)&31;
7596 uint width = word2;
7597 uint mask_base;
7598 uint data_long;
7599 uint mask_long;
7600 uint data_byte = 0;
7601 uint mask_byte = 0;
7602 uint ea = EA_AY_DI_8();
7603
7604 if(BIT_B(word2))
7605 offset = MAKE_INT_32(REG_D[offset&7]);
7606 if(BIT_5(word2))
7607 width = REG_D[width&7];
7608
7609 /* Offset is signed so we have to use ugly math =( */
7610 ea += offset / 8;
7611 offset %= 8;
7612 if(offset < 0)
7613 {
7614 offset += 8;
7615 ea--;
7616 }
7617 width = ((width-1) & 31) + 1;
7618
7619
7620 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7621 mask_long = mask_base >> offset;
7622
7623 data_long = m68ki_read_32(ea);
7624 FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
7625 FLAG_Z = data_long & mask_long;
7626 FLAG_V = VFLAG_CLEAR;
7627 FLAG_C = CFLAG_CLEAR;
7628
7629 if((width + offset) > 32)
7630 {
7631 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7632 data_byte = m68ki_read_8(ea+4);
7633 FLAG_Z |= (data_byte & mask_byte);
7634 }
7635 return;
7636 }
7637 m68ki_exception_illegal();
7638 }
7639
7640
m68k_op_bftst_32_ix(void)7641 void m68k_op_bftst_32_ix(void)
7642 {
7643 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7644 {
7645 uint word2 = OPER_I_16();
7646 sint offset = (word2>>6)&31;
7647 uint width = word2;
7648 uint mask_base;
7649 uint data_long;
7650 uint mask_long;
7651 uint data_byte = 0;
7652 uint mask_byte = 0;
7653 uint ea = EA_AY_IX_8();
7654
7655 if(BIT_B(word2))
7656 offset = MAKE_INT_32(REG_D[offset&7]);
7657 if(BIT_5(word2))
7658 width = REG_D[width&7];
7659
7660 /* Offset is signed so we have to use ugly math =( */
7661 ea += offset / 8;
7662 offset %= 8;
7663 if(offset < 0)
7664 {
7665 offset += 8;
7666 ea--;
7667 }
7668 width = ((width-1) & 31) + 1;
7669
7670
7671 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7672 mask_long = mask_base >> offset;
7673
7674 data_long = m68ki_read_32(ea);
7675 FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
7676 FLAG_Z = data_long & mask_long;
7677 FLAG_V = VFLAG_CLEAR;
7678 FLAG_C = CFLAG_CLEAR;
7679
7680 if((width + offset) > 32)
7681 {
7682 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7683 data_byte = m68ki_read_8(ea+4);
7684 FLAG_Z |= (data_byte & mask_byte);
7685 }
7686 return;
7687 }
7688 m68ki_exception_illegal();
7689 }
7690
7691
m68k_op_bftst_32_aw(void)7692 void m68k_op_bftst_32_aw(void)
7693 {
7694 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7695 {
7696 uint word2 = OPER_I_16();
7697 sint offset = (word2>>6)&31;
7698 uint width = word2;
7699 uint mask_base;
7700 uint data_long;
7701 uint mask_long;
7702 uint data_byte = 0;
7703 uint mask_byte = 0;
7704 uint ea = EA_AW_8();
7705
7706 if(BIT_B(word2))
7707 offset = MAKE_INT_32(REG_D[offset&7]);
7708 if(BIT_5(word2))
7709 width = REG_D[width&7];
7710
7711 /* Offset is signed so we have to use ugly math =( */
7712 ea += offset / 8;
7713 offset %= 8;
7714 if(offset < 0)
7715 {
7716 offset += 8;
7717 ea--;
7718 }
7719 width = ((width-1) & 31) + 1;
7720
7721
7722 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7723 mask_long = mask_base >> offset;
7724
7725 data_long = m68ki_read_32(ea);
7726 FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
7727 FLAG_Z = data_long & mask_long;
7728 FLAG_V = VFLAG_CLEAR;
7729 FLAG_C = CFLAG_CLEAR;
7730
7731 if((width + offset) > 32)
7732 {
7733 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7734 data_byte = m68ki_read_8(ea+4);
7735 FLAG_Z |= (data_byte & mask_byte);
7736 }
7737 return;
7738 }
7739 m68ki_exception_illegal();
7740 }
7741
7742
m68k_op_bftst_32_al(void)7743 void m68k_op_bftst_32_al(void)
7744 {
7745 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7746 {
7747 uint word2 = OPER_I_16();
7748 sint offset = (word2>>6)&31;
7749 uint width = word2;
7750 uint mask_base;
7751 uint data_long;
7752 uint mask_long;
7753 uint data_byte = 0;
7754 uint mask_byte = 0;
7755 uint ea = EA_AL_8();
7756
7757 if(BIT_B(word2))
7758 offset = MAKE_INT_32(REG_D[offset&7]);
7759 if(BIT_5(word2))
7760 width = REG_D[width&7];
7761
7762 /* Offset is signed so we have to use ugly math =( */
7763 ea += offset / 8;
7764 offset %= 8;
7765 if(offset < 0)
7766 {
7767 offset += 8;
7768 ea--;
7769 }
7770 width = ((width-1) & 31) + 1;
7771
7772
7773 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7774 mask_long = mask_base >> offset;
7775
7776 data_long = m68ki_read_32(ea);
7777 FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
7778 FLAG_Z = data_long & mask_long;
7779 FLAG_V = VFLAG_CLEAR;
7780 FLAG_C = CFLAG_CLEAR;
7781
7782 if((width + offset) > 32)
7783 {
7784 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7785 data_byte = m68ki_read_8(ea+4);
7786 FLAG_Z |= (data_byte & mask_byte);
7787 }
7788 return;
7789 }
7790 m68ki_exception_illegal();
7791 }
7792
7793
m68k_op_bftst_32_pcdi(void)7794 void m68k_op_bftst_32_pcdi(void)
7795 {
7796 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7797 {
7798 uint word2 = OPER_I_16();
7799 sint offset = (word2>>6)&31;
7800 uint width = word2;
7801 uint mask_base;
7802 uint data_long;
7803 uint mask_long;
7804 uint data_byte = 0;
7805 uint mask_byte = 0;
7806 uint ea = EA_PCDI_8();
7807
7808 if(BIT_B(word2))
7809 offset = MAKE_INT_32(REG_D[offset&7]);
7810 if(BIT_5(word2))
7811 width = REG_D[width&7];
7812
7813 /* Offset is signed so we have to use ugly math =( */
7814 ea += offset / 8;
7815 offset %= 8;
7816 if(offset < 0)
7817 {
7818 offset += 8;
7819 ea--;
7820 }
7821 width = ((width-1) & 31) + 1;
7822
7823
7824 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7825 mask_long = mask_base >> offset;
7826
7827 data_long = m68ki_read_32(ea);
7828 FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
7829 FLAG_Z = data_long & mask_long;
7830 FLAG_V = VFLAG_CLEAR;
7831 FLAG_C = CFLAG_CLEAR;
7832
7833 if((width + offset) > 32)
7834 {
7835 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7836 data_byte = m68ki_read_8(ea+4);
7837 FLAG_Z |= (data_byte & mask_byte);
7838 }
7839 return;
7840 }
7841 m68ki_exception_illegal();
7842 }
7843
7844
m68k_op_bftst_32_pcix(void)7845 void m68k_op_bftst_32_pcix(void)
7846 {
7847 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7848 {
7849 uint word2 = OPER_I_16();
7850 sint offset = (word2>>6)&31;
7851 uint width = word2;
7852 uint mask_base;
7853 uint data_long;
7854 uint mask_long;
7855 uint data_byte = 0;
7856 uint mask_byte = 0;
7857 uint ea = EA_PCIX_8();
7858
7859 if(BIT_B(word2))
7860 offset = MAKE_INT_32(REG_D[offset&7]);
7861 if(BIT_5(word2))
7862 width = REG_D[width&7];
7863
7864 /* Offset is signed so we have to use ugly math =( */
7865 ea += offset / 8;
7866 offset %= 8;
7867 if(offset < 0)
7868 {
7869 offset += 8;
7870 ea--;
7871 }
7872 width = ((width-1) & 31) + 1;
7873
7874
7875 mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width));
7876 mask_long = mask_base >> offset;
7877
7878 data_long = m68ki_read_32(ea);
7879 FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24;
7880 FLAG_Z = data_long & mask_long;
7881 FLAG_V = VFLAG_CLEAR;
7882 FLAG_C = CFLAG_CLEAR;
7883
7884 if((width + offset) > 32)
7885 {
7886 mask_byte = MASK_OUT_ABOVE_8(mask_base);
7887 data_byte = m68ki_read_8(ea+4);
7888 FLAG_Z |= (data_byte & mask_byte);
7889 }
7890 return;
7891 }
7892 m68ki_exception_illegal();
7893 }
7894
7895
m68k_op_bkpt(void)7896 void m68k_op_bkpt(void)
7897 {
7898 if(CPU_TYPE_IS_010_PLUS(CPU_TYPE))
7899 {
7900 m68ki_bkpt_ack(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE) ? REG_IR & 7 : 0); /* auto-disable (see m68kcpu.h) */
7901 }
7902 m68ki_exception_illegal();
7903 }
7904
7905
m68k_op_bra_8(void)7906 void m68k_op_bra_8(void)
7907 {
7908 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
7909 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
7910 if(REG_PC == REG_PPC)
7911 USE_ALL_CYCLES();
7912 }
7913
7914
m68k_op_bra_16(void)7915 void m68k_op_bra_16(void)
7916 {
7917 uint offset = OPER_I_16();
7918 REG_PC -= 2;
7919 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
7920 m68ki_branch_16(offset);
7921 if(REG_PC == REG_PPC)
7922 USE_ALL_CYCLES();
7923 }
7924
7925
m68k_op_bra_32(void)7926 void m68k_op_bra_32(void)
7927 {
7928 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
7929 {
7930 uint offset = OPER_I_32();
7931 REG_PC -= 4;
7932 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
7933 m68ki_branch_32(offset);
7934 if(REG_PC == REG_PPC)
7935 USE_ALL_CYCLES();
7936 return;
7937 }
7938 m68ki_exception_illegal();
7939 }
7940
7941
m68k_op_bset_32_r_d(void)7942 void m68k_op_bset_32_r_d(void)
7943 {
7944 uint* r_dst = &DY;
7945 uint mask = 1 << (DX & 0x1f);
7946
7947 FLAG_Z = *r_dst & mask;
7948 *r_dst |= mask;
7949 }
7950
7951
m68k_op_bset_8_r_ai(void)7952 void m68k_op_bset_8_r_ai(void)
7953 {
7954 uint ea = EA_AY_AI_8();
7955 uint src = m68ki_read_8(ea);
7956 uint mask = 1 << (DX & 7);
7957
7958 FLAG_Z = src & mask;
7959 m68ki_write_8(ea, src | mask);
7960 }
7961
7962
m68k_op_bset_8_r_pi(void)7963 void m68k_op_bset_8_r_pi(void)
7964 {
7965 uint ea = EA_AY_PI_8();
7966 uint src = m68ki_read_8(ea);
7967 uint mask = 1 << (DX & 7);
7968
7969 FLAG_Z = src & mask;
7970 m68ki_write_8(ea, src | mask);
7971 }
7972
7973
m68k_op_bset_8_r_pi7(void)7974 void m68k_op_bset_8_r_pi7(void)
7975 {
7976 uint ea = EA_A7_PI_8();
7977 uint src = m68ki_read_8(ea);
7978 uint mask = 1 << (DX & 7);
7979
7980 FLAG_Z = src & mask;
7981 m68ki_write_8(ea, src | mask);
7982 }
7983
7984
m68k_op_bset_8_r_pd(void)7985 void m68k_op_bset_8_r_pd(void)
7986 {
7987 uint ea = EA_AY_PD_8();
7988 uint src = m68ki_read_8(ea);
7989 uint mask = 1 << (DX & 7);
7990
7991 FLAG_Z = src & mask;
7992 m68ki_write_8(ea, src | mask);
7993 }
7994
7995
m68k_op_bset_8_r_pd7(void)7996 void m68k_op_bset_8_r_pd7(void)
7997 {
7998 uint ea = EA_A7_PD_8();
7999 uint src = m68ki_read_8(ea);
8000 uint mask = 1 << (DX & 7);
8001
8002 FLAG_Z = src & mask;
8003 m68ki_write_8(ea, src | mask);
8004 }
8005
8006
m68k_op_bset_8_r_di(void)8007 void m68k_op_bset_8_r_di(void)
8008 {
8009 uint ea = EA_AY_DI_8();
8010 uint src = m68ki_read_8(ea);
8011 uint mask = 1 << (DX & 7);
8012
8013 FLAG_Z = src & mask;
8014 m68ki_write_8(ea, src | mask);
8015 }
8016
8017
m68k_op_bset_8_r_ix(void)8018 void m68k_op_bset_8_r_ix(void)
8019 {
8020 uint ea = EA_AY_IX_8();
8021 uint src = m68ki_read_8(ea);
8022 uint mask = 1 << (DX & 7);
8023
8024 FLAG_Z = src & mask;
8025 m68ki_write_8(ea, src | mask);
8026 }
8027
8028
m68k_op_bset_8_r_aw(void)8029 void m68k_op_bset_8_r_aw(void)
8030 {
8031 uint ea = EA_AW_8();
8032 uint src = m68ki_read_8(ea);
8033 uint mask = 1 << (DX & 7);
8034
8035 FLAG_Z = src & mask;
8036 m68ki_write_8(ea, src | mask);
8037 }
8038
8039
m68k_op_bset_8_r_al(void)8040 void m68k_op_bset_8_r_al(void)
8041 {
8042 uint ea = EA_AL_8();
8043 uint src = m68ki_read_8(ea);
8044 uint mask = 1 << (DX & 7);
8045
8046 FLAG_Z = src & mask;
8047 m68ki_write_8(ea, src | mask);
8048 }
8049
8050
m68k_op_bset_32_s_d(void)8051 void m68k_op_bset_32_s_d(void)
8052 {
8053 uint* r_dst = &DY;
8054 uint mask = 1 << (OPER_I_8() & 0x1f);
8055
8056 FLAG_Z = *r_dst & mask;
8057 *r_dst |= mask;
8058 }
8059
8060
m68k_op_bset_8_s_ai(void)8061 void m68k_op_bset_8_s_ai(void)
8062 {
8063 uint mask = 1 << (OPER_I_8() & 7);
8064 uint ea = EA_AY_AI_8();
8065 uint src = m68ki_read_8(ea);
8066
8067 FLAG_Z = src & mask;
8068 m68ki_write_8(ea, src | mask);
8069 }
8070
8071
m68k_op_bset_8_s_pi(void)8072 void m68k_op_bset_8_s_pi(void)
8073 {
8074 uint mask = 1 << (OPER_I_8() & 7);
8075 uint ea = EA_AY_PI_8();
8076 uint src = m68ki_read_8(ea);
8077
8078 FLAG_Z = src & mask;
8079 m68ki_write_8(ea, src | mask);
8080 }
8081
8082
m68k_op_bset_8_s_pi7(void)8083 void m68k_op_bset_8_s_pi7(void)
8084 {
8085 uint mask = 1 << (OPER_I_8() & 7);
8086 uint ea = EA_A7_PI_8();
8087 uint src = m68ki_read_8(ea);
8088
8089 FLAG_Z = src & mask;
8090 m68ki_write_8(ea, src | mask);
8091 }
8092
8093
m68k_op_bset_8_s_pd(void)8094 void m68k_op_bset_8_s_pd(void)
8095 {
8096 uint mask = 1 << (OPER_I_8() & 7);
8097 uint ea = EA_AY_PD_8();
8098 uint src = m68ki_read_8(ea);
8099
8100 FLAG_Z = src & mask;
8101 m68ki_write_8(ea, src | mask);
8102 }
8103
8104
m68k_op_bset_8_s_pd7(void)8105 void m68k_op_bset_8_s_pd7(void)
8106 {
8107 uint mask = 1 << (OPER_I_8() & 7);
8108 uint ea = EA_A7_PD_8();
8109 uint src = m68ki_read_8(ea);
8110
8111 FLAG_Z = src & mask;
8112 m68ki_write_8(ea, src | mask);
8113 }
8114
8115
m68k_op_bset_8_s_di(void)8116 void m68k_op_bset_8_s_di(void)
8117 {
8118 uint mask = 1 << (OPER_I_8() & 7);
8119 uint ea = EA_AY_DI_8();
8120 uint src = m68ki_read_8(ea);
8121
8122 FLAG_Z = src & mask;
8123 m68ki_write_8(ea, src | mask);
8124 }
8125
8126
m68k_op_bset_8_s_ix(void)8127 void m68k_op_bset_8_s_ix(void)
8128 {
8129 uint mask = 1 << (OPER_I_8() & 7);
8130 uint ea = EA_AY_IX_8();
8131 uint src = m68ki_read_8(ea);
8132
8133 FLAG_Z = src & mask;
8134 m68ki_write_8(ea, src | mask);
8135 }
8136
8137
m68k_op_bset_8_s_aw(void)8138 void m68k_op_bset_8_s_aw(void)
8139 {
8140 uint mask = 1 << (OPER_I_8() & 7);
8141 uint ea = EA_AW_8();
8142 uint src = m68ki_read_8(ea);
8143
8144 FLAG_Z = src & mask;
8145 m68ki_write_8(ea, src | mask);
8146 }
8147
8148
m68k_op_bset_8_s_al(void)8149 void m68k_op_bset_8_s_al(void)
8150 {
8151 uint mask = 1 << (OPER_I_8() & 7);
8152 uint ea = EA_AL_8();
8153 uint src = m68ki_read_8(ea);
8154
8155 FLAG_Z = src & mask;
8156 m68ki_write_8(ea, src | mask);
8157 }
8158
8159
m68k_op_bsr_8(void)8160 void m68k_op_bsr_8(void)
8161 {
8162 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8163 m68ki_push_32(REG_PC);
8164 m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
8165 }
8166
8167
m68k_op_bsr_16(void)8168 void m68k_op_bsr_16(void)
8169 {
8170 uint offset = OPER_I_16();
8171 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8172 m68ki_push_32(REG_PC);
8173 REG_PC -= 2;
8174 m68ki_branch_16(offset);
8175 }
8176
8177
m68k_op_bsr_32(void)8178 void m68k_op_bsr_32(void)
8179 {
8180 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8181 {
8182 uint offset = OPER_I_32();
8183 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8184 m68ki_push_32(REG_PC);
8185 REG_PC -= 4;
8186 m68ki_branch_32(offset);
8187 return;
8188 }
8189 m68ki_exception_illegal();
8190 }
8191
8192
m68k_op_btst_32_r_d(void)8193 void m68k_op_btst_32_r_d(void)
8194 {
8195 FLAG_Z = DY & (1 << (DX & 0x1f));
8196 }
8197
8198
m68k_op_btst_8_r_ai(void)8199 void m68k_op_btst_8_r_ai(void)
8200 {
8201 FLAG_Z = OPER_AY_AI_8() & (1 << (DX & 7));
8202 }
8203
8204
m68k_op_btst_8_r_pi(void)8205 void m68k_op_btst_8_r_pi(void)
8206 {
8207 FLAG_Z = OPER_AY_PI_8() & (1 << (DX & 7));
8208 }
8209
8210
m68k_op_btst_8_r_pi7(void)8211 void m68k_op_btst_8_r_pi7(void)
8212 {
8213 FLAG_Z = OPER_A7_PI_8() & (1 << (DX & 7));
8214 }
8215
8216
m68k_op_btst_8_r_pd(void)8217 void m68k_op_btst_8_r_pd(void)
8218 {
8219 FLAG_Z = OPER_AY_PD_8() & (1 << (DX & 7));
8220 }
8221
8222
m68k_op_btst_8_r_pd7(void)8223 void m68k_op_btst_8_r_pd7(void)
8224 {
8225 FLAG_Z = OPER_A7_PD_8() & (1 << (DX & 7));
8226 }
8227
8228
m68k_op_btst_8_r_di(void)8229 void m68k_op_btst_8_r_di(void)
8230 {
8231 FLAG_Z = OPER_AY_DI_8() & (1 << (DX & 7));
8232 }
8233
8234
m68k_op_btst_8_r_ix(void)8235 void m68k_op_btst_8_r_ix(void)
8236 {
8237 FLAG_Z = OPER_AY_IX_8() & (1 << (DX & 7));
8238 }
8239
8240
m68k_op_btst_8_r_aw(void)8241 void m68k_op_btst_8_r_aw(void)
8242 {
8243 FLAG_Z = OPER_AW_8() & (1 << (DX & 7));
8244 }
8245
8246
m68k_op_btst_8_r_al(void)8247 void m68k_op_btst_8_r_al(void)
8248 {
8249 FLAG_Z = OPER_AL_8() & (1 << (DX & 7));
8250 }
8251
8252
m68k_op_btst_8_r_pcdi(void)8253 void m68k_op_btst_8_r_pcdi(void)
8254 {
8255 FLAG_Z = OPER_PCDI_8() & (1 << (DX & 7));
8256 }
8257
8258
m68k_op_btst_8_r_pcix(void)8259 void m68k_op_btst_8_r_pcix(void)
8260 {
8261 FLAG_Z = OPER_PCIX_8() & (1 << (DX & 7));
8262 }
8263
8264
m68k_op_btst_8_r_i(void)8265 void m68k_op_btst_8_r_i(void)
8266 {
8267 FLAG_Z = OPER_I_8() & (1 << (DX & 7));
8268 }
8269
8270
m68k_op_btst_32_s_d(void)8271 void m68k_op_btst_32_s_d(void)
8272 {
8273 FLAG_Z = DY & (1 << (OPER_I_8() & 0x1f));
8274 }
8275
8276
m68k_op_btst_8_s_ai(void)8277 void m68k_op_btst_8_s_ai(void)
8278 {
8279 uint bit = OPER_I_8() & 7;
8280
8281 FLAG_Z = OPER_AY_AI_8() & (1 << bit);
8282 }
8283
8284
m68k_op_btst_8_s_pi(void)8285 void m68k_op_btst_8_s_pi(void)
8286 {
8287 uint bit = OPER_I_8() & 7;
8288
8289 FLAG_Z = OPER_AY_PI_8() & (1 << bit);
8290 }
8291
8292
m68k_op_btst_8_s_pi7(void)8293 void m68k_op_btst_8_s_pi7(void)
8294 {
8295 uint bit = OPER_I_8() & 7;
8296
8297 FLAG_Z = OPER_A7_PI_8() & (1 << bit);
8298 }
8299
8300
m68k_op_btst_8_s_pd(void)8301 void m68k_op_btst_8_s_pd(void)
8302 {
8303 uint bit = OPER_I_8() & 7;
8304
8305 FLAG_Z = OPER_AY_PD_8() & (1 << bit);
8306 }
8307
8308
m68k_op_btst_8_s_pd7(void)8309 void m68k_op_btst_8_s_pd7(void)
8310 {
8311 uint bit = OPER_I_8() & 7;
8312
8313 FLAG_Z = OPER_A7_PD_8() & (1 << bit);
8314 }
8315
8316
m68k_op_btst_8_s_di(void)8317 void m68k_op_btst_8_s_di(void)
8318 {
8319 uint bit = OPER_I_8() & 7;
8320
8321 FLAG_Z = OPER_AY_DI_8() & (1 << bit);
8322 }
8323
8324
m68k_op_btst_8_s_ix(void)8325 void m68k_op_btst_8_s_ix(void)
8326 {
8327 uint bit = OPER_I_8() & 7;
8328
8329 FLAG_Z = OPER_AY_IX_8() & (1 << bit);
8330 }
8331
8332
m68k_op_btst_8_s_aw(void)8333 void m68k_op_btst_8_s_aw(void)
8334 {
8335 uint bit = OPER_I_8() & 7;
8336
8337 FLAG_Z = OPER_AW_8() & (1 << bit);
8338 }
8339
8340
m68k_op_btst_8_s_al(void)8341 void m68k_op_btst_8_s_al(void)
8342 {
8343 uint bit = OPER_I_8() & 7;
8344
8345 FLAG_Z = OPER_AL_8() & (1 << bit);
8346 }
8347
8348
m68k_op_btst_8_s_pcdi(void)8349 void m68k_op_btst_8_s_pcdi(void)
8350 {
8351 uint bit = OPER_I_8() & 7;
8352
8353 FLAG_Z = OPER_PCDI_8() & (1 << bit);
8354 }
8355
8356
m68k_op_btst_8_s_pcix(void)8357 void m68k_op_btst_8_s_pcix(void)
8358 {
8359 uint bit = OPER_I_8() & 7;
8360
8361 FLAG_Z = OPER_PCIX_8() & (1 << bit);
8362 }
8363
8364
m68k_op_callm_32_ai(void)8365 void m68k_op_callm_32_ai(void)
8366 {
8367 /* note: watch out for pcrelative modes */
8368 if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
8369 {
8370 uint ea = EA_AY_AI_32();
8371
8372 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8373 REG_PC += 2;
8374 (void)ea; /* just to avoid an 'unused variable' warning */
8375 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
8376 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
8377 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
8378 return;
8379 }
8380 m68ki_exception_illegal();
8381 }
8382
8383
m68k_op_callm_32_di(void)8384 void m68k_op_callm_32_di(void)
8385 {
8386 /* note: watch out for pcrelative modes */
8387 if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
8388 {
8389 uint ea = EA_AY_DI_32();
8390
8391 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8392 REG_PC += 2;
8393 (void)ea; /* just to avoid an 'unused variable' warning */
8394 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
8395 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
8396 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
8397 return;
8398 }
8399 m68ki_exception_illegal();
8400 }
8401
8402
m68k_op_callm_32_ix(void)8403 void m68k_op_callm_32_ix(void)
8404 {
8405 /* note: watch out for pcrelative modes */
8406 if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
8407 {
8408 uint ea = EA_AY_IX_32();
8409
8410 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8411 REG_PC += 2;
8412 (void)ea; /* just to avoid an 'unused variable' warning */
8413 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
8414 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
8415 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
8416 return;
8417 }
8418 m68ki_exception_illegal();
8419 }
8420
8421
m68k_op_callm_32_aw(void)8422 void m68k_op_callm_32_aw(void)
8423 {
8424 /* note: watch out for pcrelative modes */
8425 if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
8426 {
8427 uint ea = EA_AW_32();
8428
8429 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8430 REG_PC += 2;
8431 (void)ea; /* just to avoid an 'unused variable' warning */
8432 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
8433 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
8434 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
8435 return;
8436 }
8437 m68ki_exception_illegal();
8438 }
8439
8440
m68k_op_callm_32_al(void)8441 void m68k_op_callm_32_al(void)
8442 {
8443 /* note: watch out for pcrelative modes */
8444 if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
8445 {
8446 uint ea = EA_AL_32();
8447
8448 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8449 REG_PC += 2;
8450 (void)ea; /* just to avoid an 'unused variable' warning */
8451 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
8452 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
8453 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
8454 return;
8455 }
8456 m68ki_exception_illegal();
8457 }
8458
8459
m68k_op_callm_32_pcdi(void)8460 void m68k_op_callm_32_pcdi(void)
8461 {
8462 /* note: watch out for pcrelative modes */
8463 if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
8464 {
8465 uint ea = EA_PCDI_32();
8466
8467 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8468 REG_PC += 2;
8469 (void)ea; /* just to avoid an 'unused variable' warning */
8470 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
8471 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
8472 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
8473 return;
8474 }
8475 m68ki_exception_illegal();
8476 }
8477
8478
m68k_op_callm_32_pcix(void)8479 void m68k_op_callm_32_pcix(void)
8480 {
8481 /* note: watch out for pcrelative modes */
8482 if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE))
8483 {
8484 uint ea = EA_PCIX_32();
8485
8486 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8487 REG_PC += 2;
8488 (void)ea; /* just to avoid an 'unused variable' warning */
8489 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
8490 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
8491 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
8492 return;
8493 }
8494 m68ki_exception_illegal();
8495 }
8496
8497
m68k_op_cas_8_ai(void)8498 void m68k_op_cas_8_ai(void)
8499 {
8500 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8501 {
8502 uint word2 = OPER_I_16();
8503 uint ea = EA_AY_AI_8();
8504 uint dest = m68ki_read_8(ea);
8505 uint* compare = ®_D[word2 & 7];
8506 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8507
8508 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8509 FLAG_N = NFLAG_8(res);
8510 FLAG_Z = MASK_OUT_ABOVE_8(res);
8511 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8512 FLAG_C = CFLAG_8(res);
8513
8514 if(COND_NE())
8515 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8516 else
8517 {
8518 USE_CYCLES(3);
8519 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8520 }
8521 return;
8522 }
8523 m68ki_exception_illegal();
8524 }
8525
8526
m68k_op_cas_8_pi(void)8527 void m68k_op_cas_8_pi(void)
8528 {
8529 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8530 {
8531 uint word2 = OPER_I_16();
8532 uint ea = EA_AY_PI_8();
8533 uint dest = m68ki_read_8(ea);
8534 uint* compare = ®_D[word2 & 7];
8535 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8536
8537 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8538 FLAG_N = NFLAG_8(res);
8539 FLAG_Z = MASK_OUT_ABOVE_8(res);
8540 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8541 FLAG_C = CFLAG_8(res);
8542
8543 if(COND_NE())
8544 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8545 else
8546 {
8547 USE_CYCLES(3);
8548 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8549 }
8550 return;
8551 }
8552 m68ki_exception_illegal();
8553 }
8554
8555
m68k_op_cas_8_pi7(void)8556 void m68k_op_cas_8_pi7(void)
8557 {
8558 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8559 {
8560 uint word2 = OPER_I_16();
8561 uint ea = EA_A7_PI_8();
8562 uint dest = m68ki_read_8(ea);
8563 uint* compare = ®_D[word2 & 7];
8564 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8565
8566 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8567 FLAG_N = NFLAG_8(res);
8568 FLAG_Z = MASK_OUT_ABOVE_8(res);
8569 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8570 FLAG_C = CFLAG_8(res);
8571
8572 if(COND_NE())
8573 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8574 else
8575 {
8576 USE_CYCLES(3);
8577 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8578 }
8579 return;
8580 }
8581 m68ki_exception_illegal();
8582 }
8583
8584
m68k_op_cas_8_pd(void)8585 void m68k_op_cas_8_pd(void)
8586 {
8587 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8588 {
8589 uint word2 = OPER_I_16();
8590 uint ea = EA_AY_PD_8();
8591 uint dest = m68ki_read_8(ea);
8592 uint* compare = ®_D[word2 & 7];
8593 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8594
8595 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8596 FLAG_N = NFLAG_8(res);
8597 FLAG_Z = MASK_OUT_ABOVE_8(res);
8598 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8599 FLAG_C = CFLAG_8(res);
8600
8601 if(COND_NE())
8602 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8603 else
8604 {
8605 USE_CYCLES(3);
8606 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8607 }
8608 return;
8609 }
8610 m68ki_exception_illegal();
8611 }
8612
8613
m68k_op_cas_8_pd7(void)8614 void m68k_op_cas_8_pd7(void)
8615 {
8616 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8617 {
8618 uint word2 = OPER_I_16();
8619 uint ea = EA_A7_PD_8();
8620 uint dest = m68ki_read_8(ea);
8621 uint* compare = ®_D[word2 & 7];
8622 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8623
8624 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8625 FLAG_N = NFLAG_8(res);
8626 FLAG_Z = MASK_OUT_ABOVE_8(res);
8627 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8628 FLAG_C = CFLAG_8(res);
8629
8630 if(COND_NE())
8631 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8632 else
8633 {
8634 USE_CYCLES(3);
8635 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8636 }
8637 return;
8638 }
8639 m68ki_exception_illegal();
8640 }
8641
8642
m68k_op_cas_8_di(void)8643 void m68k_op_cas_8_di(void)
8644 {
8645 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8646 {
8647 uint word2 = OPER_I_16();
8648 uint ea = EA_AY_DI_8();
8649 uint dest = m68ki_read_8(ea);
8650 uint* compare = ®_D[word2 & 7];
8651 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8652
8653 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8654 FLAG_N = NFLAG_8(res);
8655 FLAG_Z = MASK_OUT_ABOVE_8(res);
8656 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8657 FLAG_C = CFLAG_8(res);
8658
8659 if(COND_NE())
8660 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8661 else
8662 {
8663 USE_CYCLES(3);
8664 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8665 }
8666 return;
8667 }
8668 m68ki_exception_illegal();
8669 }
8670
8671
m68k_op_cas_8_ix(void)8672 void m68k_op_cas_8_ix(void)
8673 {
8674 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8675 {
8676 uint word2 = OPER_I_16();
8677 uint ea = EA_AY_IX_8();
8678 uint dest = m68ki_read_8(ea);
8679 uint* compare = ®_D[word2 & 7];
8680 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8681
8682 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8683 FLAG_N = NFLAG_8(res);
8684 FLAG_Z = MASK_OUT_ABOVE_8(res);
8685 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8686 FLAG_C = CFLAG_8(res);
8687
8688 if(COND_NE())
8689 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8690 else
8691 {
8692 USE_CYCLES(3);
8693 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8694 }
8695 return;
8696 }
8697 m68ki_exception_illegal();
8698 }
8699
8700
m68k_op_cas_8_aw(void)8701 void m68k_op_cas_8_aw(void)
8702 {
8703 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8704 {
8705 uint word2 = OPER_I_16();
8706 uint ea = EA_AW_8();
8707 uint dest = m68ki_read_8(ea);
8708 uint* compare = ®_D[word2 & 7];
8709 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8710
8711 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8712 FLAG_N = NFLAG_8(res);
8713 FLAG_Z = MASK_OUT_ABOVE_8(res);
8714 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8715 FLAG_C = CFLAG_8(res);
8716
8717 if(COND_NE())
8718 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8719 else
8720 {
8721 USE_CYCLES(3);
8722 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8723 }
8724 return;
8725 }
8726 m68ki_exception_illegal();
8727 }
8728
8729
m68k_op_cas_8_al(void)8730 void m68k_op_cas_8_al(void)
8731 {
8732 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8733 {
8734 uint word2 = OPER_I_16();
8735 uint ea = EA_AL_8();
8736 uint dest = m68ki_read_8(ea);
8737 uint* compare = ®_D[word2 & 7];
8738 uint res = dest - MASK_OUT_ABOVE_8(*compare);
8739
8740 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8741 FLAG_N = NFLAG_8(res);
8742 FLAG_Z = MASK_OUT_ABOVE_8(res);
8743 FLAG_V = VFLAG_SUB_8(*compare, dest, res);
8744 FLAG_C = CFLAG_8(res);
8745
8746 if(COND_NE())
8747 *compare = MASK_OUT_BELOW_8(*compare) | dest;
8748 else
8749 {
8750 USE_CYCLES(3);
8751 m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7]));
8752 }
8753 return;
8754 }
8755 m68ki_exception_illegal();
8756 }
8757
8758
m68k_op_cas_16_ai(void)8759 void m68k_op_cas_16_ai(void)
8760 {
8761 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8762 {
8763 uint word2 = OPER_I_16();
8764 uint ea = EA_AY_AI_16();
8765 uint dest = m68ki_read_16(ea);
8766 uint* compare = ®_D[word2 & 7];
8767 uint res = dest - MASK_OUT_ABOVE_16(*compare);
8768
8769 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8770 FLAG_N = NFLAG_16(res);
8771 FLAG_Z = MASK_OUT_ABOVE_16(res);
8772 FLAG_V = VFLAG_SUB_16(*compare, dest, res);
8773 FLAG_C = CFLAG_16(res);
8774
8775 if(COND_NE())
8776 *compare = MASK_OUT_BELOW_16(*compare) | dest;
8777 else
8778 {
8779 USE_CYCLES(3);
8780 m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
8781 }
8782 return;
8783 }
8784 m68ki_exception_illegal();
8785 }
8786
8787
m68k_op_cas_16_pi(void)8788 void m68k_op_cas_16_pi(void)
8789 {
8790 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8791 {
8792 uint word2 = OPER_I_16();
8793 uint ea = EA_AY_PI_16();
8794 uint dest = m68ki_read_16(ea);
8795 uint* compare = ®_D[word2 & 7];
8796 uint res = dest - MASK_OUT_ABOVE_16(*compare);
8797
8798 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8799 FLAG_N = NFLAG_16(res);
8800 FLAG_Z = MASK_OUT_ABOVE_16(res);
8801 FLAG_V = VFLAG_SUB_16(*compare, dest, res);
8802 FLAG_C = CFLAG_16(res);
8803
8804 if(COND_NE())
8805 *compare = MASK_OUT_BELOW_16(*compare) | dest;
8806 else
8807 {
8808 USE_CYCLES(3);
8809 m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
8810 }
8811 return;
8812 }
8813 m68ki_exception_illegal();
8814 }
8815
8816
m68k_op_cas_16_pd(void)8817 void m68k_op_cas_16_pd(void)
8818 {
8819 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8820 {
8821 uint word2 = OPER_I_16();
8822 uint ea = EA_AY_PD_16();
8823 uint dest = m68ki_read_16(ea);
8824 uint* compare = ®_D[word2 & 7];
8825 uint res = dest - MASK_OUT_ABOVE_16(*compare);
8826
8827 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8828 FLAG_N = NFLAG_16(res);
8829 FLAG_Z = MASK_OUT_ABOVE_16(res);
8830 FLAG_V = VFLAG_SUB_16(*compare, dest, res);
8831 FLAG_C = CFLAG_16(res);
8832
8833 if(COND_NE())
8834 *compare = MASK_OUT_BELOW_16(*compare) | dest;
8835 else
8836 {
8837 USE_CYCLES(3);
8838 m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
8839 }
8840 return;
8841 }
8842 m68ki_exception_illegal();
8843 }
8844
8845
m68k_op_cas_16_di(void)8846 void m68k_op_cas_16_di(void)
8847 {
8848 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8849 {
8850 uint word2 = OPER_I_16();
8851 uint ea = EA_AY_DI_16();
8852 uint dest = m68ki_read_16(ea);
8853 uint* compare = ®_D[word2 & 7];
8854 uint res = dest - MASK_OUT_ABOVE_16(*compare);
8855
8856 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8857 FLAG_N = NFLAG_16(res);
8858 FLAG_Z = MASK_OUT_ABOVE_16(res);
8859 FLAG_V = VFLAG_SUB_16(*compare, dest, res);
8860 FLAG_C = CFLAG_16(res);
8861
8862 if(COND_NE())
8863 *compare = MASK_OUT_BELOW_16(*compare) | dest;
8864 else
8865 {
8866 USE_CYCLES(3);
8867 m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
8868 }
8869 return;
8870 }
8871 m68ki_exception_illegal();
8872 }
8873
8874
m68k_op_cas_16_ix(void)8875 void m68k_op_cas_16_ix(void)
8876 {
8877 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8878 {
8879 uint word2 = OPER_I_16();
8880 uint ea = EA_AY_IX_16();
8881 uint dest = m68ki_read_16(ea);
8882 uint* compare = ®_D[word2 & 7];
8883 uint res = dest - MASK_OUT_ABOVE_16(*compare);
8884
8885 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8886 FLAG_N = NFLAG_16(res);
8887 FLAG_Z = MASK_OUT_ABOVE_16(res);
8888 FLAG_V = VFLAG_SUB_16(*compare, dest, res);
8889 FLAG_C = CFLAG_16(res);
8890
8891 if(COND_NE())
8892 *compare = MASK_OUT_BELOW_16(*compare) | dest;
8893 else
8894 {
8895 USE_CYCLES(3);
8896 m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
8897 }
8898 return;
8899 }
8900 m68ki_exception_illegal();
8901 }
8902
8903
m68k_op_cas_16_aw(void)8904 void m68k_op_cas_16_aw(void)
8905 {
8906 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8907 {
8908 uint word2 = OPER_I_16();
8909 uint ea = EA_AW_16();
8910 uint dest = m68ki_read_16(ea);
8911 uint* compare = ®_D[word2 & 7];
8912 uint res = dest - MASK_OUT_ABOVE_16(*compare);
8913
8914 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8915 FLAG_N = NFLAG_16(res);
8916 FLAG_Z = MASK_OUT_ABOVE_16(res);
8917 FLAG_V = VFLAG_SUB_16(*compare, dest, res);
8918 FLAG_C = CFLAG_16(res);
8919
8920 if(COND_NE())
8921 *compare = MASK_OUT_BELOW_16(*compare) | dest;
8922 else
8923 {
8924 USE_CYCLES(3);
8925 m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
8926 }
8927 return;
8928 }
8929 m68ki_exception_illegal();
8930 }
8931
8932
m68k_op_cas_16_al(void)8933 void m68k_op_cas_16_al(void)
8934 {
8935 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8936 {
8937 uint word2 = OPER_I_16();
8938 uint ea = EA_AL_16();
8939 uint dest = m68ki_read_16(ea);
8940 uint* compare = ®_D[word2 & 7];
8941 uint res = dest - MASK_OUT_ABOVE_16(*compare);
8942
8943 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8944 FLAG_N = NFLAG_16(res);
8945 FLAG_Z = MASK_OUT_ABOVE_16(res);
8946 FLAG_V = VFLAG_SUB_16(*compare, dest, res);
8947 FLAG_C = CFLAG_16(res);
8948
8949 if(COND_NE())
8950 *compare = MASK_OUT_BELOW_16(*compare) | dest;
8951 else
8952 {
8953 USE_CYCLES(3);
8954 m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7]));
8955 }
8956 return;
8957 }
8958 m68ki_exception_illegal();
8959 }
8960
8961
m68k_op_cas_32_ai(void)8962 void m68k_op_cas_32_ai(void)
8963 {
8964 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8965 {
8966 uint word2 = OPER_I_16();
8967 uint ea = EA_AY_AI_32();
8968 uint dest = m68ki_read_32(ea);
8969 uint* compare = ®_D[word2 & 7];
8970 uint res = dest - *compare;
8971
8972 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
8973 FLAG_N = NFLAG_32(res);
8974 FLAG_Z = MASK_OUT_ABOVE_32(res);
8975 FLAG_V = VFLAG_SUB_32(*compare, dest, res);
8976 FLAG_C = CFLAG_SUB_32(*compare, dest, res);
8977
8978 if(COND_NE())
8979 *compare = dest;
8980 else
8981 {
8982 USE_CYCLES(3);
8983 m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
8984 }
8985 return;
8986 }
8987 m68ki_exception_illegal();
8988 }
8989
8990
m68k_op_cas_32_pi(void)8991 void m68k_op_cas_32_pi(void)
8992 {
8993 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
8994 {
8995 uint word2 = OPER_I_16();
8996 uint ea = EA_AY_PI_32();
8997 uint dest = m68ki_read_32(ea);
8998 uint* compare = ®_D[word2 & 7];
8999 uint res = dest - *compare;
9000
9001 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9002 FLAG_N = NFLAG_32(res);
9003 FLAG_Z = MASK_OUT_ABOVE_32(res);
9004 FLAG_V = VFLAG_SUB_32(*compare, dest, res);
9005 FLAG_C = CFLAG_SUB_32(*compare, dest, res);
9006
9007 if(COND_NE())
9008 *compare = dest;
9009 else
9010 {
9011 USE_CYCLES(3);
9012 m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
9013 }
9014 return;
9015 }
9016 m68ki_exception_illegal();
9017 }
9018
9019
m68k_op_cas_32_pd(void)9020 void m68k_op_cas_32_pd(void)
9021 {
9022 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9023 {
9024 uint word2 = OPER_I_16();
9025 uint ea = EA_AY_PD_32();
9026 uint dest = m68ki_read_32(ea);
9027 uint* compare = ®_D[word2 & 7];
9028 uint res = dest - *compare;
9029
9030 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9031 FLAG_N = NFLAG_32(res);
9032 FLAG_Z = MASK_OUT_ABOVE_32(res);
9033 FLAG_V = VFLAG_SUB_32(*compare, dest, res);
9034 FLAG_C = CFLAG_SUB_32(*compare, dest, res);
9035
9036 if(COND_NE())
9037 *compare = dest;
9038 else
9039 {
9040 USE_CYCLES(3);
9041 m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
9042 }
9043 return;
9044 }
9045 m68ki_exception_illegal();
9046 }
9047
9048
m68k_op_cas_32_di(void)9049 void m68k_op_cas_32_di(void)
9050 {
9051 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9052 {
9053 uint word2 = OPER_I_16();
9054 uint ea = EA_AY_DI_32();
9055 uint dest = m68ki_read_32(ea);
9056 uint* compare = ®_D[word2 & 7];
9057 uint res = dest - *compare;
9058
9059 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9060 FLAG_N = NFLAG_32(res);
9061 FLAG_Z = MASK_OUT_ABOVE_32(res);
9062 FLAG_V = VFLAG_SUB_32(*compare, dest, res);
9063 FLAG_C = CFLAG_SUB_32(*compare, dest, res);
9064
9065 if(COND_NE())
9066 *compare = dest;
9067 else
9068 {
9069 USE_CYCLES(3);
9070 m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
9071 }
9072 return;
9073 }
9074 m68ki_exception_illegal();
9075 }
9076
9077
m68k_op_cas_32_ix(void)9078 void m68k_op_cas_32_ix(void)
9079 {
9080 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9081 {
9082 uint word2 = OPER_I_16();
9083 uint ea = EA_AY_IX_32();
9084 uint dest = m68ki_read_32(ea);
9085 uint* compare = ®_D[word2 & 7];
9086 uint res = dest - *compare;
9087
9088 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9089 FLAG_N = NFLAG_32(res);
9090 FLAG_Z = MASK_OUT_ABOVE_32(res);
9091 FLAG_V = VFLAG_SUB_32(*compare, dest, res);
9092 FLAG_C = CFLAG_SUB_32(*compare, dest, res);
9093
9094 if(COND_NE())
9095 *compare = dest;
9096 else
9097 {
9098 USE_CYCLES(3);
9099 m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
9100 }
9101 return;
9102 }
9103 m68ki_exception_illegal();
9104 }
9105
9106
m68k_op_cas_32_aw(void)9107 void m68k_op_cas_32_aw(void)
9108 {
9109 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9110 {
9111 uint word2 = OPER_I_16();
9112 uint ea = EA_AW_32();
9113 uint dest = m68ki_read_32(ea);
9114 uint* compare = ®_D[word2 & 7];
9115 uint res = dest - *compare;
9116
9117 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9118 FLAG_N = NFLAG_32(res);
9119 FLAG_Z = MASK_OUT_ABOVE_32(res);
9120 FLAG_V = VFLAG_SUB_32(*compare, dest, res);
9121 FLAG_C = CFLAG_SUB_32(*compare, dest, res);
9122
9123 if(COND_NE())
9124 *compare = dest;
9125 else
9126 {
9127 USE_CYCLES(3);
9128 m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
9129 }
9130 return;
9131 }
9132 m68ki_exception_illegal();
9133 }
9134
9135
m68k_op_cas_32_al(void)9136 void m68k_op_cas_32_al(void)
9137 {
9138 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9139 {
9140 uint word2 = OPER_I_16();
9141 uint ea = EA_AL_32();
9142 uint dest = m68ki_read_32(ea);
9143 uint* compare = ®_D[word2 & 7];
9144 uint res = dest - *compare;
9145
9146 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9147 FLAG_N = NFLAG_32(res);
9148 FLAG_Z = MASK_OUT_ABOVE_32(res);
9149 FLAG_V = VFLAG_SUB_32(*compare, dest, res);
9150 FLAG_C = CFLAG_SUB_32(*compare, dest, res);
9151
9152 if(COND_NE())
9153 *compare = dest;
9154 else
9155 {
9156 USE_CYCLES(3);
9157 m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]);
9158 }
9159 return;
9160 }
9161 m68ki_exception_illegal();
9162 }
9163
9164
m68k_op_cas2_16(void)9165 void m68k_op_cas2_16(void)
9166 {
9167 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9168 {
9169 uint word2 = OPER_I_32();
9170 uint* compare1 = ®_D[(word2 >> 16) & 7];
9171 uint ea1 = REG_DA[(word2 >> 28) & 15];
9172 uint dest1 = m68ki_read_16(ea1);
9173 uint res1 = dest1 - MASK_OUT_ABOVE_16(*compare1);
9174 uint* compare2 = ®_D[word2 & 7];
9175 uint ea2 = REG_DA[(word2 >> 12) & 15];
9176 uint dest2 = m68ki_read_16(ea2);
9177 uint res2;
9178
9179 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9180 FLAG_N = NFLAG_16(res1);
9181 FLAG_Z = MASK_OUT_ABOVE_16(res1);
9182 FLAG_V = VFLAG_SUB_16(*compare1, dest1, res1);
9183 FLAG_C = CFLAG_16(res1);
9184
9185 if(COND_EQ())
9186 {
9187 res2 = dest2 - MASK_OUT_ABOVE_16(*compare2);
9188
9189 FLAG_N = NFLAG_16(res2);
9190 FLAG_Z = MASK_OUT_ABOVE_16(res2);
9191 FLAG_V = VFLAG_SUB_16(*compare2, dest2, res2);
9192 FLAG_C = CFLAG_16(res2);
9193
9194 if(COND_EQ())
9195 {
9196 USE_CYCLES(3);
9197 m68ki_write_16(ea1, REG_D[(word2 >> 22) & 7]);
9198 m68ki_write_16(ea2, REG_D[(word2 >> 6) & 7]);
9199 return;
9200 }
9201 }
9202 *compare1 = BIT_1F(word2) ? MAKE_INT_16(dest1) : MASK_OUT_BELOW_16(*compare1) | dest1;
9203 *compare2 = BIT_F(word2) ? MAKE_INT_16(dest2) : MASK_OUT_BELOW_16(*compare2) | dest2;
9204 return;
9205 }
9206 m68ki_exception_illegal();
9207 }
9208
9209
m68k_op_cas2_32(void)9210 void m68k_op_cas2_32(void)
9211 {
9212 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9213 {
9214 uint word2 = OPER_I_32();
9215 uint* compare1 = ®_D[(word2 >> 16) & 7];
9216 uint ea1 = REG_DA[(word2 >> 28) & 15];
9217 uint dest1 = m68ki_read_32(ea1);
9218 uint res1 = dest1 - *compare1;
9219 uint* compare2 = ®_D[word2 & 7];
9220 uint ea2 = REG_DA[(word2 >> 12) & 15];
9221 uint dest2 = m68ki_read_32(ea2);
9222 uint res2;
9223
9224 m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */
9225 FLAG_N = NFLAG_32(res1);
9226 FLAG_Z = MASK_OUT_ABOVE_32(res1);
9227 FLAG_V = VFLAG_SUB_32(*compare1, dest1, res1);
9228 FLAG_C = CFLAG_SUB_32(*compare1, dest1, res1);
9229
9230 if(COND_EQ())
9231 {
9232 res2 = dest2 - *compare2;
9233
9234 FLAG_N = NFLAG_32(res2);
9235 FLAG_Z = MASK_OUT_ABOVE_32(res2);
9236 FLAG_V = VFLAG_SUB_32(*compare2, dest2, res2);
9237 FLAG_C = CFLAG_SUB_32(*compare2, dest2, res2);
9238
9239 if(COND_EQ())
9240 {
9241 USE_CYCLES(3);
9242 m68ki_write_32(ea1, REG_D[(word2 >> 22) & 7]);
9243 m68ki_write_32(ea2, REG_D[(word2 >> 6) & 7]);
9244 return;
9245 }
9246 }
9247 *compare1 = dest1;
9248 *compare2 = dest2;
9249 return;
9250 }
9251 m68ki_exception_illegal();
9252 }
9253
9254
m68k_op_chk_16_d(void)9255 void m68k_op_chk_16_d(void)
9256 {
9257 sint src = MAKE_INT_16(DX);
9258 sint bound = MAKE_INT_16(DY);
9259
9260 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9261 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9262 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9263
9264 if(src >= 0 && src <= bound)
9265 {
9266 return;
9267 }
9268 FLAG_N = (src < 0)<<7;
9269 m68ki_exception_trap(EXCEPTION_CHK);
9270 }
9271
9272
m68k_op_chk_16_ai(void)9273 void m68k_op_chk_16_ai(void)
9274 {
9275 sint src = MAKE_INT_16(DX);
9276 sint bound = MAKE_INT_16(OPER_AY_AI_16());
9277
9278 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9279 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9280 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9281
9282 if(src >= 0 && src <= bound)
9283 {
9284 return;
9285 }
9286 FLAG_N = (src < 0)<<7;
9287 m68ki_exception_trap(EXCEPTION_CHK);
9288 }
9289
9290
m68k_op_chk_16_pi(void)9291 void m68k_op_chk_16_pi(void)
9292 {
9293 sint src = MAKE_INT_16(DX);
9294 sint bound = MAKE_INT_16(OPER_AY_PI_16());
9295
9296 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9297 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9298 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9299
9300 if(src >= 0 && src <= bound)
9301 {
9302 return;
9303 }
9304 FLAG_N = (src < 0)<<7;
9305 m68ki_exception_trap(EXCEPTION_CHK);
9306 }
9307
9308
m68k_op_chk_16_pd(void)9309 void m68k_op_chk_16_pd(void)
9310 {
9311 sint src = MAKE_INT_16(DX);
9312 sint bound = MAKE_INT_16(OPER_AY_PD_16());
9313
9314 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9315 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9316 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9317
9318 if(src >= 0 && src <= bound)
9319 {
9320 return;
9321 }
9322 FLAG_N = (src < 0)<<7;
9323 m68ki_exception_trap(EXCEPTION_CHK);
9324 }
9325
9326
m68k_op_chk_16_di(void)9327 void m68k_op_chk_16_di(void)
9328 {
9329 sint src = MAKE_INT_16(DX);
9330 sint bound = MAKE_INT_16(OPER_AY_DI_16());
9331
9332 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9333 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9334 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9335
9336 if(src >= 0 && src <= bound)
9337 {
9338 return;
9339 }
9340 FLAG_N = (src < 0)<<7;
9341 m68ki_exception_trap(EXCEPTION_CHK);
9342 }
9343
9344
m68k_op_chk_16_ix(void)9345 void m68k_op_chk_16_ix(void)
9346 {
9347 sint src = MAKE_INT_16(DX);
9348 sint bound = MAKE_INT_16(OPER_AY_IX_16());
9349
9350 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9351 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9352 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9353
9354 if(src >= 0 && src <= bound)
9355 {
9356 return;
9357 }
9358 FLAG_N = (src < 0)<<7;
9359 m68ki_exception_trap(EXCEPTION_CHK);
9360 }
9361
9362
m68k_op_chk_16_aw(void)9363 void m68k_op_chk_16_aw(void)
9364 {
9365 sint src = MAKE_INT_16(DX);
9366 sint bound = MAKE_INT_16(OPER_AW_16());
9367
9368 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9369 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9370 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9371
9372 if(src >= 0 && src <= bound)
9373 {
9374 return;
9375 }
9376 FLAG_N = (src < 0)<<7;
9377 m68ki_exception_trap(EXCEPTION_CHK);
9378 }
9379
9380
m68k_op_chk_16_al(void)9381 void m68k_op_chk_16_al(void)
9382 {
9383 sint src = MAKE_INT_16(DX);
9384 sint bound = MAKE_INT_16(OPER_AL_16());
9385
9386 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9387 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9388 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9389
9390 if(src >= 0 && src <= bound)
9391 {
9392 return;
9393 }
9394 FLAG_N = (src < 0)<<7;
9395 m68ki_exception_trap(EXCEPTION_CHK);
9396 }
9397
9398
m68k_op_chk_16_pcdi(void)9399 void m68k_op_chk_16_pcdi(void)
9400 {
9401 sint src = MAKE_INT_16(DX);
9402 sint bound = MAKE_INT_16(OPER_PCDI_16());
9403
9404 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9405 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9406 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9407
9408 if(src >= 0 && src <= bound)
9409 {
9410 return;
9411 }
9412 FLAG_N = (src < 0)<<7;
9413 m68ki_exception_trap(EXCEPTION_CHK);
9414 }
9415
9416
m68k_op_chk_16_pcix(void)9417 void m68k_op_chk_16_pcix(void)
9418 {
9419 sint src = MAKE_INT_16(DX);
9420 sint bound = MAKE_INT_16(OPER_PCIX_16());
9421
9422 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9423 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9424 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9425
9426 if(src >= 0 && src <= bound)
9427 {
9428 return;
9429 }
9430 FLAG_N = (src < 0)<<7;
9431 m68ki_exception_trap(EXCEPTION_CHK);
9432 }
9433
9434
m68k_op_chk_16_i(void)9435 void m68k_op_chk_16_i(void)
9436 {
9437 sint src = MAKE_INT_16(DX);
9438 sint bound = MAKE_INT_16(OPER_I_16());
9439
9440 FLAG_Z = ZFLAG_16(src); /* Undocumented */
9441 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9442 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9443
9444 if(src >= 0 && src <= bound)
9445 {
9446 return;
9447 }
9448 FLAG_N = (src < 0)<<7;
9449 m68ki_exception_trap(EXCEPTION_CHK);
9450 }
9451
9452
m68k_op_chk_32_d(void)9453 void m68k_op_chk_32_d(void)
9454 {
9455 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9456 {
9457 sint src = MAKE_INT_32(DX);
9458 sint bound = MAKE_INT_32(DY);
9459
9460 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9461 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9462 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9463
9464 if(src >= 0 && src <= bound)
9465 {
9466 return;
9467 }
9468 FLAG_N = (src < 0)<<7;
9469 m68ki_exception_trap(EXCEPTION_CHK);
9470 return;
9471 }
9472 m68ki_exception_illegal();
9473 }
9474
9475
m68k_op_chk_32_ai(void)9476 void m68k_op_chk_32_ai(void)
9477 {
9478 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9479 {
9480 sint src = MAKE_INT_32(DX);
9481 sint bound = MAKE_INT_32(OPER_AY_AI_32());
9482
9483 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9484 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9485 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9486
9487 if(src >= 0 && src <= bound)
9488 {
9489 return;
9490 }
9491 FLAG_N = (src < 0)<<7;
9492 m68ki_exception_trap(EXCEPTION_CHK);
9493 return;
9494 }
9495 m68ki_exception_illegal();
9496 }
9497
9498
m68k_op_chk_32_pi(void)9499 void m68k_op_chk_32_pi(void)
9500 {
9501 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9502 {
9503 sint src = MAKE_INT_32(DX);
9504 sint bound = MAKE_INT_32(OPER_AY_PI_32());
9505
9506 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9507 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9508 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9509
9510 if(src >= 0 && src <= bound)
9511 {
9512 return;
9513 }
9514 FLAG_N = (src < 0)<<7;
9515 m68ki_exception_trap(EXCEPTION_CHK);
9516 return;
9517 }
9518 m68ki_exception_illegal();
9519 }
9520
9521
m68k_op_chk_32_pd(void)9522 void m68k_op_chk_32_pd(void)
9523 {
9524 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9525 {
9526 sint src = MAKE_INT_32(DX);
9527 sint bound = MAKE_INT_32(OPER_AY_PD_32());
9528
9529 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9530 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9531 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9532
9533 if(src >= 0 && src <= bound)
9534 {
9535 return;
9536 }
9537 FLAG_N = (src < 0)<<7;
9538 m68ki_exception_trap(EXCEPTION_CHK);
9539 return;
9540 }
9541 m68ki_exception_illegal();
9542 }
9543
9544
m68k_op_chk_32_di(void)9545 void m68k_op_chk_32_di(void)
9546 {
9547 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9548 {
9549 sint src = MAKE_INT_32(DX);
9550 sint bound = MAKE_INT_32(OPER_AY_DI_32());
9551
9552 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9553 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9554 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9555
9556 if(src >= 0 && src <= bound)
9557 {
9558 return;
9559 }
9560 FLAG_N = (src < 0)<<7;
9561 m68ki_exception_trap(EXCEPTION_CHK);
9562 return;
9563 }
9564 m68ki_exception_illegal();
9565 }
9566
9567
m68k_op_chk_32_ix(void)9568 void m68k_op_chk_32_ix(void)
9569 {
9570 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9571 {
9572 sint src = MAKE_INT_32(DX);
9573 sint bound = MAKE_INT_32(OPER_AY_IX_32());
9574
9575 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9576 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9577 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9578
9579 if(src >= 0 && src <= bound)
9580 {
9581 return;
9582 }
9583 FLAG_N = (src < 0)<<7;
9584 m68ki_exception_trap(EXCEPTION_CHK);
9585 return;
9586 }
9587 m68ki_exception_illegal();
9588 }
9589
9590
m68k_op_chk_32_aw(void)9591 void m68k_op_chk_32_aw(void)
9592 {
9593 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9594 {
9595 sint src = MAKE_INT_32(DX);
9596 sint bound = MAKE_INT_32(OPER_AW_32());
9597
9598 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9599 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9600 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9601
9602 if(src >= 0 && src <= bound)
9603 {
9604 return;
9605 }
9606 FLAG_N = (src < 0)<<7;
9607 m68ki_exception_trap(EXCEPTION_CHK);
9608 return;
9609 }
9610 m68ki_exception_illegal();
9611 }
9612
9613
m68k_op_chk_32_al(void)9614 void m68k_op_chk_32_al(void)
9615 {
9616 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9617 {
9618 sint src = MAKE_INT_32(DX);
9619 sint bound = MAKE_INT_32(OPER_AL_32());
9620
9621 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9622 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9623 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9624
9625 if(src >= 0 && src <= bound)
9626 {
9627 return;
9628 }
9629 FLAG_N = (src < 0)<<7;
9630 m68ki_exception_trap(EXCEPTION_CHK);
9631 return;
9632 }
9633 m68ki_exception_illegal();
9634 }
9635
9636
m68k_op_chk_32_pcdi(void)9637 void m68k_op_chk_32_pcdi(void)
9638 {
9639 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9640 {
9641 sint src = MAKE_INT_32(DX);
9642 sint bound = MAKE_INT_32(OPER_PCDI_32());
9643
9644 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9645 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9646 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9647
9648 if(src >= 0 && src <= bound)
9649 {
9650 return;
9651 }
9652 FLAG_N = (src < 0)<<7;
9653 m68ki_exception_trap(EXCEPTION_CHK);
9654 return;
9655 }
9656 m68ki_exception_illegal();
9657 }
9658
9659
m68k_op_chk_32_pcix(void)9660 void m68k_op_chk_32_pcix(void)
9661 {
9662 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9663 {
9664 sint src = MAKE_INT_32(DX);
9665 sint bound = MAKE_INT_32(OPER_PCIX_32());
9666
9667 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9668 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9669 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9670
9671 if(src >= 0 && src <= bound)
9672 {
9673 return;
9674 }
9675 FLAG_N = (src < 0)<<7;
9676 m68ki_exception_trap(EXCEPTION_CHK);
9677 return;
9678 }
9679 m68ki_exception_illegal();
9680 }
9681
9682
m68k_op_chk_32_i(void)9683 void m68k_op_chk_32_i(void)
9684 {
9685 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9686 {
9687 sint src = MAKE_INT_32(DX);
9688 sint bound = MAKE_INT_32(OPER_I_32());
9689
9690 FLAG_Z = ZFLAG_32(src); /* Undocumented */
9691 FLAG_V = VFLAG_CLEAR; /* Undocumented */
9692 FLAG_C = CFLAG_CLEAR; /* Undocumented */
9693
9694 if(src >= 0 && src <= bound)
9695 {
9696 return;
9697 }
9698 FLAG_N = (src < 0)<<7;
9699 m68ki_exception_trap(EXCEPTION_CHK);
9700 return;
9701 }
9702 m68ki_exception_illegal();
9703 }
9704
9705
m68k_op_chk2cmp2_8_pcdi(void)9706 void m68k_op_chk2cmp2_8_pcdi(void)
9707 {
9708 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9709 {
9710 uint word2 = OPER_I_16();
9711 uint compare = REG_DA[(word2 >> 12) & 15]&0xff;
9712 uint ea = EA_PCDI_8();
9713 uint lower_bound = m68ki_read_pcrel_8(ea);
9714 uint upper_bound = m68ki_read_pcrel_8(ea + 1);
9715
9716 if(!BIT_F(word2))
9717 FLAG_C = MAKE_INT_8(compare) - MAKE_INT_8(lower_bound);
9718 else
9719 FLAG_C = compare - lower_bound;
9720 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9721 if(COND_CS())
9722 {
9723 if(BIT_B(word2))
9724 m68ki_exception_trap(EXCEPTION_CHK);
9725 return;
9726 }
9727
9728 FLAG_C = upper_bound - compare;
9729 if(COND_CS() && BIT_B(word2))
9730 m68ki_exception_trap(EXCEPTION_CHK);
9731 return;
9732 }
9733 m68ki_exception_illegal();
9734 }
9735
9736
m68k_op_chk2cmp2_8_pcix(void)9737 void m68k_op_chk2cmp2_8_pcix(void)
9738 {
9739 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9740 {
9741 uint word2 = OPER_I_16();
9742 uint compare = REG_DA[(word2 >> 12) & 15]&0xff;
9743 uint ea = EA_PCIX_8();
9744 uint lower_bound = m68ki_read_pcrel_8(ea);
9745 uint upper_bound = m68ki_read_pcrel_8(ea + 1);
9746
9747 if(!BIT_F(word2))
9748 FLAG_C = MAKE_INT_8(compare) - MAKE_INT_8(lower_bound);
9749 else
9750 FLAG_C = compare - lower_bound;
9751 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9752 if(COND_CS())
9753 {
9754 if(BIT_B(word2))
9755 m68ki_exception_trap(EXCEPTION_CHK);
9756 return;
9757 }
9758
9759 FLAG_C = upper_bound - compare;
9760 if(COND_CS() && BIT_B(word2))
9761 m68ki_exception_trap(EXCEPTION_CHK);
9762 return;
9763 }
9764 m68ki_exception_illegal();
9765 }
9766
9767
m68k_op_chk2cmp2_8_ai(void)9768 void m68k_op_chk2cmp2_8_ai(void)
9769 {
9770 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9771 {
9772 uint word2 = OPER_I_16();
9773 uint compare = REG_DA[(word2 >> 12) & 15]&0xff;
9774 uint ea = EA_AY_AI_8();
9775 uint lower_bound = m68ki_read_8(ea);
9776 uint upper_bound = m68ki_read_8(ea + 1);
9777
9778 if(!BIT_F(word2))
9779 FLAG_C = MAKE_INT_8(compare) - MAKE_INT_8(lower_bound);
9780 else
9781 FLAG_C = compare - lower_bound;
9782 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9783 if(COND_CS())
9784 {
9785 if(BIT_B(word2))
9786 m68ki_exception_trap(EXCEPTION_CHK);
9787 return;
9788 }
9789
9790 FLAG_C = upper_bound - compare;
9791 if(COND_CS() && BIT_B(word2))
9792 m68ki_exception_trap(EXCEPTION_CHK);
9793 return;
9794 }
9795 m68ki_exception_illegal();
9796 }
9797
9798
m68k_op_chk2cmp2_8_di(void)9799 void m68k_op_chk2cmp2_8_di(void)
9800 {
9801 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9802 {
9803 uint word2 = OPER_I_16();
9804 uint compare = REG_DA[(word2 >> 12) & 15]&0xff;
9805 uint ea = EA_AY_DI_8();
9806 uint lower_bound = m68ki_read_8(ea);
9807 uint upper_bound = m68ki_read_8(ea + 1);
9808
9809 if(!BIT_F(word2))
9810 FLAG_C = MAKE_INT_8(compare) - MAKE_INT_8(lower_bound);
9811 else
9812 FLAG_C = compare - lower_bound;
9813 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9814 if(COND_CS())
9815 {
9816 if(BIT_B(word2))
9817 m68ki_exception_trap(EXCEPTION_CHK);
9818 return;
9819 }
9820
9821 FLAG_C = upper_bound - compare;
9822 if(COND_CS() && BIT_B(word2))
9823 m68ki_exception_trap(EXCEPTION_CHK);
9824 return;
9825 }
9826 m68ki_exception_illegal();
9827 }
9828
9829
m68k_op_chk2cmp2_8_ix(void)9830 void m68k_op_chk2cmp2_8_ix(void)
9831 {
9832 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9833 {
9834 uint word2 = OPER_I_16();
9835 uint compare = REG_DA[(word2 >> 12) & 15]&0xff;
9836 uint ea = EA_AY_IX_8();
9837 uint lower_bound = m68ki_read_8(ea);
9838 uint upper_bound = m68ki_read_8(ea + 1);
9839
9840 if(!BIT_F(word2))
9841 FLAG_C = MAKE_INT_8(compare) - MAKE_INT_8(lower_bound);
9842 else
9843 FLAG_C = compare - lower_bound;
9844 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9845 if(COND_CS())
9846 {
9847 if(BIT_B(word2))
9848 m68ki_exception_trap(EXCEPTION_CHK);
9849 return;
9850 }
9851
9852 FLAG_C = upper_bound - compare;
9853 if(COND_CS() && BIT_B(word2))
9854 m68ki_exception_trap(EXCEPTION_CHK);
9855 return;
9856 }
9857 m68ki_exception_illegal();
9858 }
9859
9860
m68k_op_chk2cmp2_8_aw(void)9861 void m68k_op_chk2cmp2_8_aw(void)
9862 {
9863 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9864 {
9865 uint word2 = OPER_I_16();
9866 uint compare = REG_DA[(word2 >> 12) & 15]&0xff;
9867 uint ea = EA_AW_8();
9868 uint lower_bound = m68ki_read_8(ea);
9869 uint upper_bound = m68ki_read_8(ea + 1);
9870
9871 if(!BIT_F(word2))
9872 FLAG_C = MAKE_INT_8(compare) - MAKE_INT_8(lower_bound);
9873 else
9874 FLAG_C = compare - lower_bound;
9875 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9876 if(COND_CS())
9877 {
9878 if(BIT_B(word2))
9879 m68ki_exception_trap(EXCEPTION_CHK);
9880 return;
9881 }
9882
9883 FLAG_C = upper_bound - compare;
9884 if(COND_CS() && BIT_B(word2))
9885 m68ki_exception_trap(EXCEPTION_CHK);
9886 return;
9887 }
9888 m68ki_exception_illegal();
9889 }
9890
9891
m68k_op_chk2cmp2_8_al(void)9892 void m68k_op_chk2cmp2_8_al(void)
9893 {
9894 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9895 {
9896 uint word2 = OPER_I_16();
9897 uint compare = REG_DA[(word2 >> 12) & 15]&0xff;
9898 uint ea = EA_AL_8();
9899 uint lower_bound = m68ki_read_8(ea);
9900 uint upper_bound = m68ki_read_8(ea + 1);
9901
9902 if(!BIT_F(word2))
9903 FLAG_C = MAKE_INT_8(compare) - MAKE_INT_8(lower_bound);
9904 else
9905 FLAG_C = compare - lower_bound;
9906 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9907 if(COND_CS())
9908 {
9909 if(BIT_B(word2))
9910 m68ki_exception_trap(EXCEPTION_CHK);
9911 return;
9912 }
9913
9914 FLAG_C = upper_bound - compare;
9915 if(COND_CS() && BIT_B(word2))
9916 m68ki_exception_trap(EXCEPTION_CHK);
9917 return;
9918 }
9919 m68ki_exception_illegal();
9920 }
9921
9922
m68k_op_chk2cmp2_16_pcdi(void)9923 void m68k_op_chk2cmp2_16_pcdi(void)
9924 {
9925 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9926 {
9927 uint word2 = OPER_I_16();
9928 uint compare = REG_DA[(word2 >> 12) & 15]&0xffff;
9929 uint ea = EA_PCDI_16();
9930 uint lower_bound = m68ki_read_pcrel_16(ea);
9931 uint upper_bound = m68ki_read_pcrel_16(ea + 2);
9932
9933 if(!BIT_F(word2))
9934 FLAG_C = MAKE_INT_16(compare) - MAKE_INT_16(lower_bound);
9935 else
9936 FLAG_C = compare - lower_bound;
9937 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9938 FLAG_C = CFLAG_16(FLAG_C);
9939 if(COND_CS())
9940 {
9941 if(BIT_B(word2))
9942 m68ki_exception_trap(EXCEPTION_CHK);
9943 return;
9944 }
9945
9946 if(!BIT_F(word2))
9947 FLAG_C = MAKE_INT_16(upper_bound) - MAKE_INT_16(compare);
9948 else
9949 FLAG_C = upper_bound - compare;
9950 FLAG_C = CFLAG_16(FLAG_C);
9951 if(COND_CS() && BIT_B(word2))
9952 m68ki_exception_trap(EXCEPTION_CHK);
9953 return;
9954 }
9955 m68ki_exception_illegal();
9956 }
9957
9958
m68k_op_chk2cmp2_16_pcix(void)9959 void m68k_op_chk2cmp2_16_pcix(void)
9960 {
9961 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9962 {
9963 uint word2 = OPER_I_16();
9964 uint compare = REG_DA[(word2 >> 12) & 15]&0xffff;
9965 uint ea = EA_PCIX_16();
9966 uint lower_bound = m68ki_read_pcrel_16(ea);
9967 uint upper_bound = m68ki_read_pcrel_16(ea + 2);
9968
9969 if(!BIT_F(word2))
9970 FLAG_C = MAKE_INT_16(compare) - MAKE_INT_16(lower_bound);
9971 else
9972 FLAG_C = compare - lower_bound;
9973 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
9974 FLAG_C = CFLAG_16(FLAG_C);
9975 if(COND_CS())
9976 {
9977 if(BIT_B(word2))
9978 m68ki_exception_trap(EXCEPTION_CHK);
9979 return;
9980 }
9981
9982 if(!BIT_F(word2))
9983 FLAG_C = MAKE_INT_16(upper_bound) - MAKE_INT_16(compare);
9984 else
9985 FLAG_C = upper_bound - compare;
9986 FLAG_C = CFLAG_16(FLAG_C);
9987 if(COND_CS() && BIT_B(word2))
9988 m68ki_exception_trap(EXCEPTION_CHK);
9989 return;
9990 }
9991 m68ki_exception_illegal();
9992 }
9993
9994
m68k_op_chk2cmp2_16_ai(void)9995 void m68k_op_chk2cmp2_16_ai(void)
9996 {
9997 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
9998 {
9999 uint word2 = OPER_I_16();
10000 uint compare = REG_DA[(word2 >> 12) & 15]&0xffff;
10001 uint ea = EA_AY_AI_16();
10002 uint lower_bound = m68ki_read_16(ea);
10003 uint upper_bound = m68ki_read_16(ea + 2);
10004
10005 if(!BIT_F(word2))
10006 FLAG_C = MAKE_INT_16(compare) - MAKE_INT_16(lower_bound);
10007 else
10008 FLAG_C = compare - lower_bound;
10009
10010 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10011 FLAG_C = CFLAG_16(FLAG_C);
10012 if(COND_CS())
10013 {
10014 if(BIT_B(word2))
10015 m68ki_exception_trap(EXCEPTION_CHK);
10016 return;
10017 }
10018 if(!BIT_F(word2))
10019 FLAG_C = MAKE_INT_16(upper_bound) - MAKE_INT_16(compare);
10020 else
10021 FLAG_C = upper_bound - compare;
10022
10023 FLAG_C = CFLAG_16(FLAG_C);
10024 if(COND_CS() && BIT_B(word2))
10025 m68ki_exception_trap(EXCEPTION_CHK);
10026 return;
10027 }
10028 m68ki_exception_illegal();
10029 }
10030
10031
m68k_op_chk2cmp2_16_di(void)10032 void m68k_op_chk2cmp2_16_di(void)
10033 {
10034 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10035 {
10036 uint word2 = OPER_I_16();
10037 uint compare = REG_DA[(word2 >> 12) & 15]&0xffff;
10038 uint ea = EA_AY_DI_16();
10039 uint lower_bound = m68ki_read_16(ea);
10040 uint upper_bound = m68ki_read_16(ea + 2);
10041
10042 if(!BIT_F(word2))
10043 FLAG_C = MAKE_INT_16(compare) - MAKE_INT_16(lower_bound);
10044 else
10045 FLAG_C = compare - lower_bound;
10046
10047 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10048 FLAG_C = CFLAG_16(FLAG_C);
10049 if(COND_CS())
10050 {
10051 if(BIT_B(word2))
10052 m68ki_exception_trap(EXCEPTION_CHK);
10053 return;
10054 }
10055 if(!BIT_F(word2))
10056 FLAG_C = MAKE_INT_16(upper_bound) - MAKE_INT_16(compare);
10057 else
10058 FLAG_C = upper_bound - compare;
10059
10060 FLAG_C = CFLAG_16(FLAG_C);
10061 if(COND_CS() && BIT_B(word2))
10062 m68ki_exception_trap(EXCEPTION_CHK);
10063 return;
10064 }
10065 m68ki_exception_illegal();
10066 }
10067
10068
m68k_op_chk2cmp2_16_ix(void)10069 void m68k_op_chk2cmp2_16_ix(void)
10070 {
10071 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10072 {
10073 uint word2 = OPER_I_16();
10074 uint compare = REG_DA[(word2 >> 12) & 15]&0xffff;
10075 uint ea = EA_AY_IX_16();
10076 uint lower_bound = m68ki_read_16(ea);
10077 uint upper_bound = m68ki_read_16(ea + 2);
10078
10079 if(!BIT_F(word2))
10080 FLAG_C = MAKE_INT_16(compare) - MAKE_INT_16(lower_bound);
10081 else
10082 FLAG_C = compare - lower_bound;
10083
10084 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10085 FLAG_C = CFLAG_16(FLAG_C);
10086 if(COND_CS())
10087 {
10088 if(BIT_B(word2))
10089 m68ki_exception_trap(EXCEPTION_CHK);
10090 return;
10091 }
10092 if(!BIT_F(word2))
10093 FLAG_C = MAKE_INT_16(upper_bound) - MAKE_INT_16(compare);
10094 else
10095 FLAG_C = upper_bound - compare;
10096
10097 FLAG_C = CFLAG_16(FLAG_C);
10098 if(COND_CS() && BIT_B(word2))
10099 m68ki_exception_trap(EXCEPTION_CHK);
10100 return;
10101 }
10102 m68ki_exception_illegal();
10103 }
10104
10105
m68k_op_chk2cmp2_16_aw(void)10106 void m68k_op_chk2cmp2_16_aw(void)
10107 {
10108 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10109 {
10110 uint word2 = OPER_I_16();
10111 uint compare = REG_DA[(word2 >> 12) & 15]&0xffff;
10112 uint ea = EA_AW_16();
10113 uint lower_bound = m68ki_read_16(ea);
10114 uint upper_bound = m68ki_read_16(ea + 2);
10115
10116 if(!BIT_F(word2))
10117 FLAG_C = MAKE_INT_16(compare) - MAKE_INT_16(lower_bound);
10118 else
10119 FLAG_C = compare - lower_bound;
10120
10121 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10122 FLAG_C = CFLAG_16(FLAG_C);
10123 if(COND_CS())
10124 {
10125 if(BIT_B(word2))
10126 m68ki_exception_trap(EXCEPTION_CHK);
10127 return;
10128 }
10129 if(!BIT_F(word2))
10130 FLAG_C = MAKE_INT_16(upper_bound) - MAKE_INT_16(compare);
10131 else
10132 FLAG_C = upper_bound - compare;
10133
10134 FLAG_C = CFLAG_16(FLAG_C);
10135 if(COND_CS() && BIT_B(word2))
10136 m68ki_exception_trap(EXCEPTION_CHK);
10137 return;
10138 }
10139 m68ki_exception_illegal();
10140 }
10141
10142
m68k_op_chk2cmp2_16_al(void)10143 void m68k_op_chk2cmp2_16_al(void)
10144 {
10145 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10146 {
10147 uint word2 = OPER_I_16();
10148 uint compare = REG_DA[(word2 >> 12) & 15]&0xffff;
10149 uint ea = EA_AL_16();
10150 uint lower_bound = m68ki_read_16(ea);
10151 uint upper_bound = m68ki_read_16(ea + 2);
10152
10153 if(!BIT_F(word2))
10154 FLAG_C = MAKE_INT_16(compare) - MAKE_INT_16(lower_bound);
10155 else
10156 FLAG_C = compare - lower_bound;
10157
10158 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10159 FLAG_C = CFLAG_16(FLAG_C);
10160 if(COND_CS())
10161 {
10162 if(BIT_B(word2))
10163 m68ki_exception_trap(EXCEPTION_CHK);
10164 return;
10165 }
10166 if(!BIT_F(word2))
10167 FLAG_C = MAKE_INT_16(upper_bound) - MAKE_INT_16(compare);
10168 else
10169 FLAG_C = upper_bound - compare;
10170
10171 FLAG_C = CFLAG_16(FLAG_C);
10172 if(COND_CS() && BIT_B(word2))
10173 m68ki_exception_trap(EXCEPTION_CHK);
10174 return;
10175 }
10176 m68ki_exception_illegal();
10177 }
10178
10179
m68k_op_chk2cmp2_32_pcdi(void)10180 void m68k_op_chk2cmp2_32_pcdi(void)
10181 {
10182 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10183 {
10184 uint word2 = OPER_I_16();
10185 uint compare = REG_DA[(word2 >> 12) & 15];
10186 uint ea = EA_PCDI_32();
10187 uint lower_bound = m68ki_read_pcrel_32(ea);
10188 uint upper_bound = m68ki_read_pcrel_32(ea + 4);
10189
10190 FLAG_C = compare - lower_bound;
10191 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10192 FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C);
10193 if(COND_CS())
10194 {
10195 if(BIT_B(word2))
10196 m68ki_exception_trap(EXCEPTION_CHK);
10197 return;
10198 }
10199
10200 FLAG_C = upper_bound - compare;
10201 FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C);
10202 if(COND_CS() && BIT_B(word2))
10203 m68ki_exception_trap(EXCEPTION_CHK);
10204 return;
10205 }
10206 m68ki_exception_illegal();
10207 }
10208
10209
m68k_op_chk2cmp2_32_pcix(void)10210 void m68k_op_chk2cmp2_32_pcix(void)
10211 {
10212 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10213 {
10214 uint word2 = OPER_I_16();
10215 uint compare = REG_DA[(word2 >> 12) & 15];
10216 uint ea = EA_PCIX_32();
10217 uint lower_bound = m68ki_read_pcrel_32(ea);
10218 uint upper_bound = m68ki_read_pcrel_32(ea + 4);
10219
10220 FLAG_C = compare - lower_bound;
10221 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10222 FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C);
10223 if(COND_CS())
10224 {
10225 if(BIT_B(word2))
10226 m68ki_exception_trap(EXCEPTION_CHK);
10227 return;
10228 }
10229
10230 FLAG_C = upper_bound - compare;
10231 FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C);
10232 if(COND_CS() && BIT_B(word2))
10233 m68ki_exception_trap(EXCEPTION_CHK);
10234 return;
10235 }
10236 m68ki_exception_illegal();
10237 }
10238
10239
m68k_op_chk2cmp2_32_ai(void)10240 void m68k_op_chk2cmp2_32_ai(void)
10241 {
10242 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10243 {
10244 uint word2 = OPER_I_16();
10245 uint compare = REG_DA[(word2 >> 12) & 15];
10246 uint ea = EA_AY_AI_32();
10247 uint lower_bound = m68ki_read_32(ea);
10248 uint upper_bound = m68ki_read_32(ea + 4);
10249
10250 FLAG_C = compare - lower_bound;
10251 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10252 FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C);
10253 if(COND_CS())
10254 {
10255 if(BIT_B(word2))
10256 m68ki_exception_trap(EXCEPTION_CHK);
10257 return;
10258 }
10259
10260 FLAG_C = upper_bound - compare;
10261 FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C);
10262 if(COND_CS() && BIT_B(word2))
10263 m68ki_exception_trap(EXCEPTION_CHK);
10264 return;
10265 }
10266 m68ki_exception_illegal();
10267 }
10268
10269
m68k_op_chk2cmp2_32_di(void)10270 void m68k_op_chk2cmp2_32_di(void)
10271 {
10272 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10273 {
10274 uint word2 = OPER_I_16();
10275 uint compare = REG_DA[(word2 >> 12) & 15];
10276 uint ea = EA_AY_DI_32();
10277 uint lower_bound = m68ki_read_32(ea);
10278 uint upper_bound = m68ki_read_32(ea + 4);
10279
10280 FLAG_C = compare - lower_bound;
10281 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10282 FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C);
10283 if(COND_CS())
10284 {
10285 if(BIT_B(word2))
10286 m68ki_exception_trap(EXCEPTION_CHK);
10287 return;
10288 }
10289
10290 FLAG_C = upper_bound - compare;
10291 FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C);
10292 if(COND_CS() && BIT_B(word2))
10293 m68ki_exception_trap(EXCEPTION_CHK);
10294 return;
10295 }
10296 m68ki_exception_illegal();
10297 }
10298
10299
m68k_op_chk2cmp2_32_ix(void)10300 void m68k_op_chk2cmp2_32_ix(void)
10301 {
10302 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10303 {
10304 uint word2 = OPER_I_16();
10305 uint compare = REG_DA[(word2 >> 12) & 15];
10306 uint ea = EA_AY_IX_32();
10307 uint lower_bound = m68ki_read_32(ea);
10308 uint upper_bound = m68ki_read_32(ea + 4);
10309
10310 FLAG_C = compare - lower_bound;
10311 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10312 FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C);
10313 if(COND_CS())
10314 {
10315 if(BIT_B(word2))
10316 m68ki_exception_trap(EXCEPTION_CHK);
10317 return;
10318 }
10319
10320 FLAG_C = upper_bound - compare;
10321 FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C);
10322 if(COND_CS() && BIT_B(word2))
10323 m68ki_exception_trap(EXCEPTION_CHK);
10324 return;
10325 }
10326 m68ki_exception_illegal();
10327 }
10328
10329
m68k_op_chk2cmp2_32_aw(void)10330 void m68k_op_chk2cmp2_32_aw(void)
10331 {
10332 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10333 {
10334 uint word2 = OPER_I_16();
10335 uint compare = REG_DA[(word2 >> 12) & 15];
10336 uint ea = EA_AW_32();
10337 uint lower_bound = m68ki_read_32(ea);
10338 uint upper_bound = m68ki_read_32(ea + 4);
10339
10340 FLAG_C = compare - lower_bound;
10341 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10342 FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C);
10343 if(COND_CS())
10344 {
10345 if(BIT_B(word2))
10346 m68ki_exception_trap(EXCEPTION_CHK);
10347 return;
10348 }
10349
10350 FLAG_C = upper_bound - compare;
10351 FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C);
10352 if(COND_CS() && BIT_B(word2))
10353 m68ki_exception_trap(EXCEPTION_CHK);
10354 return;
10355 }
10356 m68ki_exception_illegal();
10357 }
10358
10359
m68k_op_chk2cmp2_32_al(void)10360 void m68k_op_chk2cmp2_32_al(void)
10361 {
10362 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
10363 {
10364 uint word2 = OPER_I_16();
10365 uint compare = REG_DA[(word2 >> 12) & 15];
10366 uint ea = EA_AL_32();
10367 uint lower_bound = m68ki_read_32(ea);
10368 uint upper_bound = m68ki_read_32(ea + 4);
10369
10370 FLAG_C = compare - lower_bound;
10371 FLAG_Z = !((upper_bound==compare) | (lower_bound==compare));
10372 FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C);
10373 if(COND_CS())
10374 {
10375 if(BIT_B(word2))
10376 m68ki_exception_trap(EXCEPTION_CHK);
10377 return;
10378 }
10379
10380 FLAG_C = upper_bound - compare;
10381 FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C);
10382 if(COND_CS() && BIT_B(word2))
10383 m68ki_exception_trap(EXCEPTION_CHK);
10384 return;
10385 }
10386 m68ki_exception_illegal();
10387 }
10388
10389
m68k_op_clr_8_d(void)10390 void m68k_op_clr_8_d(void)
10391 {
10392 DY &= 0xffffff00;
10393
10394 FLAG_N = NFLAG_CLEAR;
10395 FLAG_V = VFLAG_CLEAR;
10396 FLAG_C = CFLAG_CLEAR;
10397 FLAG_Z = ZFLAG_SET;
10398 }
10399
10400
m68k_op_clr_8_ai(void)10401 void m68k_op_clr_8_ai(void)
10402 {
10403 m68ki_write_8(EA_AY_AI_8(), 0);
10404
10405 FLAG_N = NFLAG_CLEAR;
10406 FLAG_V = VFLAG_CLEAR;
10407 FLAG_C = CFLAG_CLEAR;
10408 FLAG_Z = ZFLAG_SET;
10409 }
10410
10411
m68k_op_clr_8_pi(void)10412 void m68k_op_clr_8_pi(void)
10413 {
10414 m68ki_write_8(EA_AY_PI_8(), 0);
10415
10416 FLAG_N = NFLAG_CLEAR;
10417 FLAG_V = VFLAG_CLEAR;
10418 FLAG_C = CFLAG_CLEAR;
10419 FLAG_Z = ZFLAG_SET;
10420 }
10421
10422
m68k_op_clr_8_pi7(void)10423 void m68k_op_clr_8_pi7(void)
10424 {
10425 m68ki_write_8(EA_A7_PI_8(), 0);
10426
10427 FLAG_N = NFLAG_CLEAR;
10428 FLAG_V = VFLAG_CLEAR;
10429 FLAG_C = CFLAG_CLEAR;
10430 FLAG_Z = ZFLAG_SET;
10431 }
10432
10433
m68k_op_clr_8_pd(void)10434 void m68k_op_clr_8_pd(void)
10435 {
10436 m68ki_write_8(EA_AY_PD_8(), 0);
10437
10438 FLAG_N = NFLAG_CLEAR;
10439 FLAG_V = VFLAG_CLEAR;
10440 FLAG_C = CFLAG_CLEAR;
10441 FLAG_Z = ZFLAG_SET;
10442 }
10443
10444
m68k_op_clr_8_pd7(void)10445 void m68k_op_clr_8_pd7(void)
10446 {
10447 m68ki_write_8(EA_A7_PD_8(), 0);
10448
10449 FLAG_N = NFLAG_CLEAR;
10450 FLAG_V = VFLAG_CLEAR;
10451 FLAG_C = CFLAG_CLEAR;
10452 FLAG_Z = ZFLAG_SET;
10453 }
10454
10455
m68k_op_clr_8_di(void)10456 void m68k_op_clr_8_di(void)
10457 {
10458 m68ki_write_8(EA_AY_DI_8(), 0);
10459
10460 FLAG_N = NFLAG_CLEAR;
10461 FLAG_V = VFLAG_CLEAR;
10462 FLAG_C = CFLAG_CLEAR;
10463 FLAG_Z = ZFLAG_SET;
10464 }
10465
10466
m68k_op_clr_8_ix(void)10467 void m68k_op_clr_8_ix(void)
10468 {
10469 m68ki_write_8(EA_AY_IX_8(), 0);
10470
10471 FLAG_N = NFLAG_CLEAR;
10472 FLAG_V = VFLAG_CLEAR;
10473 FLAG_C = CFLAG_CLEAR;
10474 FLAG_Z = ZFLAG_SET;
10475 }
10476
10477
m68k_op_clr_8_aw(void)10478 void m68k_op_clr_8_aw(void)
10479 {
10480 m68ki_write_8(EA_AW_8(), 0);
10481
10482 FLAG_N = NFLAG_CLEAR;
10483 FLAG_V = VFLAG_CLEAR;
10484 FLAG_C = CFLAG_CLEAR;
10485 FLAG_Z = ZFLAG_SET;
10486 }
10487
10488
m68k_op_clr_8_al(void)10489 void m68k_op_clr_8_al(void)
10490 {
10491 m68ki_write_8(EA_AL_8(), 0);
10492
10493 FLAG_N = NFLAG_CLEAR;
10494 FLAG_V = VFLAG_CLEAR;
10495 FLAG_C = CFLAG_CLEAR;
10496 FLAG_Z = ZFLAG_SET;
10497 }
10498
10499
m68k_op_clr_16_d(void)10500 void m68k_op_clr_16_d(void)
10501 {
10502 DY &= 0xffff0000;
10503
10504 FLAG_N = NFLAG_CLEAR;
10505 FLAG_V = VFLAG_CLEAR;
10506 FLAG_C = CFLAG_CLEAR;
10507 FLAG_Z = ZFLAG_SET;
10508 }
10509
10510
m68k_op_clr_16_ai(void)10511 void m68k_op_clr_16_ai(void)
10512 {
10513 m68ki_write_16(EA_AY_AI_16(), 0);
10514
10515 FLAG_N = NFLAG_CLEAR;
10516 FLAG_V = VFLAG_CLEAR;
10517 FLAG_C = CFLAG_CLEAR;
10518 FLAG_Z = ZFLAG_SET;
10519 }
10520
10521
m68k_op_clr_16_pi(void)10522 void m68k_op_clr_16_pi(void)
10523 {
10524 m68ki_write_16(EA_AY_PI_16(), 0);
10525
10526 FLAG_N = NFLAG_CLEAR;
10527 FLAG_V = VFLAG_CLEAR;
10528 FLAG_C = CFLAG_CLEAR;
10529 FLAG_Z = ZFLAG_SET;
10530 }
10531
10532
m68k_op_clr_16_pd(void)10533 void m68k_op_clr_16_pd(void)
10534 {
10535 m68ki_write_16(EA_AY_PD_16(), 0);
10536
10537 FLAG_N = NFLAG_CLEAR;
10538 FLAG_V = VFLAG_CLEAR;
10539 FLAG_C = CFLAG_CLEAR;
10540 FLAG_Z = ZFLAG_SET;
10541 }
10542
10543
m68k_op_clr_16_di(void)10544 void m68k_op_clr_16_di(void)
10545 {
10546 m68ki_write_16(EA_AY_DI_16(), 0);
10547
10548 FLAG_N = NFLAG_CLEAR;
10549 FLAG_V = VFLAG_CLEAR;
10550 FLAG_C = CFLAG_CLEAR;
10551 FLAG_Z = ZFLAG_SET;
10552 }
10553
10554
m68k_op_clr_16_ix(void)10555 void m68k_op_clr_16_ix(void)
10556 {
10557 m68ki_write_16(EA_AY_IX_16(), 0);
10558
10559 FLAG_N = NFLAG_CLEAR;
10560 FLAG_V = VFLAG_CLEAR;
10561 FLAG_C = CFLAG_CLEAR;
10562 FLAG_Z = ZFLAG_SET;
10563 }
10564
10565
m68k_op_clr_16_aw(void)10566 void m68k_op_clr_16_aw(void)
10567 {
10568 m68ki_write_16(EA_AW_16(), 0);
10569
10570 FLAG_N = NFLAG_CLEAR;
10571 FLAG_V = VFLAG_CLEAR;
10572 FLAG_C = CFLAG_CLEAR;
10573 FLAG_Z = ZFLAG_SET;
10574 }
10575
10576
m68k_op_clr_16_al(void)10577 void m68k_op_clr_16_al(void)
10578 {
10579 m68ki_write_16(EA_AL_16(), 0);
10580
10581 FLAG_N = NFLAG_CLEAR;
10582 FLAG_V = VFLAG_CLEAR;
10583 FLAG_C = CFLAG_CLEAR;
10584 FLAG_Z = ZFLAG_SET;
10585 }
10586
10587
m68k_op_clr_32_d(void)10588 void m68k_op_clr_32_d(void)
10589 {
10590 DY = 0;
10591
10592 FLAG_N = NFLAG_CLEAR;
10593 FLAG_V = VFLAG_CLEAR;
10594 FLAG_C = CFLAG_CLEAR;
10595 FLAG_Z = ZFLAG_SET;
10596 }
10597
10598
m68k_op_clr_32_ai(void)10599 void m68k_op_clr_32_ai(void)
10600 {
10601 m68ki_write_32(EA_AY_AI_32(), 0);
10602
10603 FLAG_N = NFLAG_CLEAR;
10604 FLAG_V = VFLAG_CLEAR;
10605 FLAG_C = CFLAG_CLEAR;
10606 FLAG_Z = ZFLAG_SET;
10607 }
10608
10609
m68k_op_clr_32_pi(void)10610 void m68k_op_clr_32_pi(void)
10611 {
10612 m68ki_write_32(EA_AY_PI_32(), 0);
10613
10614 FLAG_N = NFLAG_CLEAR;
10615 FLAG_V = VFLAG_CLEAR;
10616 FLAG_C = CFLAG_CLEAR;
10617 FLAG_Z = ZFLAG_SET;
10618 }
10619
10620
m68k_op_clr_32_pd(void)10621 void m68k_op_clr_32_pd(void)
10622 {
10623 m68ki_write_32(EA_AY_PD_32(), 0);
10624
10625 FLAG_N = NFLAG_CLEAR;
10626 FLAG_V = VFLAG_CLEAR;
10627 FLAG_C = CFLAG_CLEAR;
10628 FLAG_Z = ZFLAG_SET;
10629 }
10630
10631
m68k_op_clr_32_di(void)10632 void m68k_op_clr_32_di(void)
10633 {
10634 m68ki_write_32(EA_AY_DI_32(), 0);
10635
10636 FLAG_N = NFLAG_CLEAR;
10637 FLAG_V = VFLAG_CLEAR;
10638 FLAG_C = CFLAG_CLEAR;
10639 FLAG_Z = ZFLAG_SET;
10640 }
10641
10642
m68k_op_clr_32_ix(void)10643 void m68k_op_clr_32_ix(void)
10644 {
10645 m68ki_write_32(EA_AY_IX_32(), 0);
10646
10647 FLAG_N = NFLAG_CLEAR;
10648 FLAG_V = VFLAG_CLEAR;
10649 FLAG_C = CFLAG_CLEAR;
10650 FLAG_Z = ZFLAG_SET;
10651 }
10652
10653
m68k_op_clr_32_aw(void)10654 void m68k_op_clr_32_aw(void)
10655 {
10656 m68ki_write_32(EA_AW_32(), 0);
10657
10658 FLAG_N = NFLAG_CLEAR;
10659 FLAG_V = VFLAG_CLEAR;
10660 FLAG_C = CFLAG_CLEAR;
10661 FLAG_Z = ZFLAG_SET;
10662 }
10663
10664
m68k_op_clr_32_al(void)10665 void m68k_op_clr_32_al(void)
10666 {
10667 m68ki_write_32(EA_AL_32(), 0);
10668
10669 FLAG_N = NFLAG_CLEAR;
10670 FLAG_V = VFLAG_CLEAR;
10671 FLAG_C = CFLAG_CLEAR;
10672 FLAG_Z = ZFLAG_SET;
10673 }
10674
10675
m68k_op_cmp_8_d(void)10676 void m68k_op_cmp_8_d(void)
10677 {
10678 uint src = MASK_OUT_ABOVE_8(DY);
10679 uint dst = MASK_OUT_ABOVE_8(DX);
10680 uint res = dst - src;
10681
10682 FLAG_N = NFLAG_8(res);
10683 FLAG_Z = MASK_OUT_ABOVE_8(res);
10684 FLAG_V = VFLAG_SUB_8(src, dst, res);
10685 FLAG_C = CFLAG_8(res);
10686 }
10687
10688
m68k_op_cmp_8_ai(void)10689 void m68k_op_cmp_8_ai(void)
10690 {
10691 uint src = OPER_AY_AI_8();
10692 uint dst = MASK_OUT_ABOVE_8(DX);
10693 uint res = dst - src;
10694
10695 FLAG_N = NFLAG_8(res);
10696 FLAG_Z = MASK_OUT_ABOVE_8(res);
10697 FLAG_V = VFLAG_SUB_8(src, dst, res);
10698 FLAG_C = CFLAG_8(res);
10699 }
10700
10701
m68k_op_cmp_8_pi(void)10702 void m68k_op_cmp_8_pi(void)
10703 {
10704 uint src = OPER_AY_PI_8();
10705 uint dst = MASK_OUT_ABOVE_8(DX);
10706 uint res = dst - src;
10707
10708 FLAG_N = NFLAG_8(res);
10709 FLAG_Z = MASK_OUT_ABOVE_8(res);
10710 FLAG_V = VFLAG_SUB_8(src, dst, res);
10711 FLAG_C = CFLAG_8(res);
10712 }
10713
10714
m68k_op_cmp_8_pi7(void)10715 void m68k_op_cmp_8_pi7(void)
10716 {
10717 uint src = OPER_A7_PI_8();
10718 uint dst = MASK_OUT_ABOVE_8(DX);
10719 uint res = dst - src;
10720
10721 FLAG_N = NFLAG_8(res);
10722 FLAG_Z = MASK_OUT_ABOVE_8(res);
10723 FLAG_V = VFLAG_SUB_8(src, dst, res);
10724 FLAG_C = CFLAG_8(res);
10725 }
10726
10727
m68k_op_cmp_8_pd(void)10728 void m68k_op_cmp_8_pd(void)
10729 {
10730 uint src = OPER_AY_PD_8();
10731 uint dst = MASK_OUT_ABOVE_8(DX);
10732 uint res = dst - src;
10733
10734 FLAG_N = NFLAG_8(res);
10735 FLAG_Z = MASK_OUT_ABOVE_8(res);
10736 FLAG_V = VFLAG_SUB_8(src, dst, res);
10737 FLAG_C = CFLAG_8(res);
10738 }
10739
10740
m68k_op_cmp_8_pd7(void)10741 void m68k_op_cmp_8_pd7(void)
10742 {
10743 uint src = OPER_A7_PD_8();
10744 uint dst = MASK_OUT_ABOVE_8(DX);
10745 uint res = dst - src;
10746
10747 FLAG_N = NFLAG_8(res);
10748 FLAG_Z = MASK_OUT_ABOVE_8(res);
10749 FLAG_V = VFLAG_SUB_8(src, dst, res);
10750 FLAG_C = CFLAG_8(res);
10751 }
10752
10753
m68k_op_cmp_8_di(void)10754 void m68k_op_cmp_8_di(void)
10755 {
10756 uint src = OPER_AY_DI_8();
10757 uint dst = MASK_OUT_ABOVE_8(DX);
10758 uint res = dst - src;
10759
10760 FLAG_N = NFLAG_8(res);
10761 FLAG_Z = MASK_OUT_ABOVE_8(res);
10762 FLAG_V = VFLAG_SUB_8(src, dst, res);
10763 FLAG_C = CFLAG_8(res);
10764 }
10765
10766
m68k_op_cmp_8_ix(void)10767 void m68k_op_cmp_8_ix(void)
10768 {
10769 uint src = OPER_AY_IX_8();
10770 uint dst = MASK_OUT_ABOVE_8(DX);
10771 uint res = dst - src;
10772
10773 FLAG_N = NFLAG_8(res);
10774 FLAG_Z = MASK_OUT_ABOVE_8(res);
10775 FLAG_V = VFLAG_SUB_8(src, dst, res);
10776 FLAG_C = CFLAG_8(res);
10777 }
10778
10779
m68k_op_cmp_8_aw(void)10780 void m68k_op_cmp_8_aw(void)
10781 {
10782 uint src = OPER_AW_8();
10783 uint dst = MASK_OUT_ABOVE_8(DX);
10784 uint res = dst - src;
10785
10786 FLAG_N = NFLAG_8(res);
10787 FLAG_Z = MASK_OUT_ABOVE_8(res);
10788 FLAG_V = VFLAG_SUB_8(src, dst, res);
10789 FLAG_C = CFLAG_8(res);
10790 }
10791
10792
m68k_op_cmp_8_al(void)10793 void m68k_op_cmp_8_al(void)
10794 {
10795 uint src = OPER_AL_8();
10796 uint dst = MASK_OUT_ABOVE_8(DX);
10797 uint res = dst - src;
10798
10799 FLAG_N = NFLAG_8(res);
10800 FLAG_Z = MASK_OUT_ABOVE_8(res);
10801 FLAG_V = VFLAG_SUB_8(src, dst, res);
10802 FLAG_C = CFLAG_8(res);
10803 }
10804
10805
m68k_op_cmp_8_pcdi(void)10806 void m68k_op_cmp_8_pcdi(void)
10807 {
10808 uint src = OPER_PCDI_8();
10809 uint dst = MASK_OUT_ABOVE_8(DX);
10810 uint res = dst - src;
10811
10812 FLAG_N = NFLAG_8(res);
10813 FLAG_Z = MASK_OUT_ABOVE_8(res);
10814 FLAG_V = VFLAG_SUB_8(src, dst, res);
10815 FLAG_C = CFLAG_8(res);
10816 }
10817
10818
m68k_op_cmp_8_pcix(void)10819 void m68k_op_cmp_8_pcix(void)
10820 {
10821 uint src = OPER_PCIX_8();
10822 uint dst = MASK_OUT_ABOVE_8(DX);
10823 uint res = dst - src;
10824
10825 FLAG_N = NFLAG_8(res);
10826 FLAG_Z = MASK_OUT_ABOVE_8(res);
10827 FLAG_V = VFLAG_SUB_8(src, dst, res);
10828 FLAG_C = CFLAG_8(res);
10829 }
10830
10831
m68k_op_cmp_8_i(void)10832 void m68k_op_cmp_8_i(void)
10833 {
10834 uint src = OPER_I_8();
10835 uint dst = MASK_OUT_ABOVE_8(DX);
10836 uint res = dst - src;
10837
10838 FLAG_N = NFLAG_8(res);
10839 FLAG_Z = MASK_OUT_ABOVE_8(res);
10840 FLAG_V = VFLAG_SUB_8(src, dst, res);
10841 FLAG_C = CFLAG_8(res);
10842 }
10843
10844
m68k_op_cmp_16_d(void)10845 void m68k_op_cmp_16_d(void)
10846 {
10847 uint src = MASK_OUT_ABOVE_16(DY);
10848 uint dst = MASK_OUT_ABOVE_16(DX);
10849 uint res = dst - src;
10850
10851 FLAG_N = NFLAG_16(res);
10852 FLAG_Z = MASK_OUT_ABOVE_16(res);
10853 FLAG_V = VFLAG_SUB_16(src, dst, res);
10854 FLAG_C = CFLAG_16(res);
10855 }
10856
10857
m68k_op_cmp_16_a(void)10858 void m68k_op_cmp_16_a(void)
10859 {
10860 uint src = MASK_OUT_ABOVE_16(AY);
10861 uint dst = MASK_OUT_ABOVE_16(DX);
10862 uint res = dst - src;
10863
10864 FLAG_N = NFLAG_16(res);
10865 FLAG_Z = MASK_OUT_ABOVE_16(res);
10866 FLAG_V = VFLAG_SUB_16(src, dst, res);
10867 FLAG_C = CFLAG_16(res);
10868 }
10869
10870
m68k_op_cmp_16_ai(void)10871 void m68k_op_cmp_16_ai(void)
10872 {
10873 uint src = OPER_AY_AI_16();
10874 uint dst = MASK_OUT_ABOVE_16(DX);
10875 uint res = dst - src;
10876
10877 FLAG_N = NFLAG_16(res);
10878 FLAG_Z = MASK_OUT_ABOVE_16(res);
10879 FLAG_V = VFLAG_SUB_16(src, dst, res);
10880 FLAG_C = CFLAG_16(res);
10881 }
10882
10883
m68k_op_cmp_16_pi(void)10884 void m68k_op_cmp_16_pi(void)
10885 {
10886 uint src = OPER_AY_PI_16();
10887 uint dst = MASK_OUT_ABOVE_16(DX);
10888 uint res = dst - src;
10889
10890 FLAG_N = NFLAG_16(res);
10891 FLAG_Z = MASK_OUT_ABOVE_16(res);
10892 FLAG_V = VFLAG_SUB_16(src, dst, res);
10893 FLAG_C = CFLAG_16(res);
10894 }
10895
10896
m68k_op_cmp_16_pd(void)10897 void m68k_op_cmp_16_pd(void)
10898 {
10899 uint src = OPER_AY_PD_16();
10900 uint dst = MASK_OUT_ABOVE_16(DX);
10901 uint res = dst - src;
10902
10903 FLAG_N = NFLAG_16(res);
10904 FLAG_Z = MASK_OUT_ABOVE_16(res);
10905 FLAG_V = VFLAG_SUB_16(src, dst, res);
10906 FLAG_C = CFLAG_16(res);
10907 }
10908
10909
m68k_op_cmp_16_di(void)10910 void m68k_op_cmp_16_di(void)
10911 {
10912 uint src = OPER_AY_DI_16();
10913 uint dst = MASK_OUT_ABOVE_16(DX);
10914 uint res = dst - src;
10915
10916 FLAG_N = NFLAG_16(res);
10917 FLAG_Z = MASK_OUT_ABOVE_16(res);
10918 FLAG_V = VFLAG_SUB_16(src, dst, res);
10919 FLAG_C = CFLAG_16(res);
10920 }
10921
10922
m68k_op_cmp_16_ix(void)10923 void m68k_op_cmp_16_ix(void)
10924 {
10925 uint src = OPER_AY_IX_16();
10926 uint dst = MASK_OUT_ABOVE_16(DX);
10927 uint res = dst - src;
10928
10929 FLAG_N = NFLAG_16(res);
10930 FLAG_Z = MASK_OUT_ABOVE_16(res);
10931 FLAG_V = VFLAG_SUB_16(src, dst, res);
10932 FLAG_C = CFLAG_16(res);
10933 }
10934
10935
m68k_op_cmp_16_aw(void)10936 void m68k_op_cmp_16_aw(void)
10937 {
10938 uint src = OPER_AW_16();
10939 uint dst = MASK_OUT_ABOVE_16(DX);
10940 uint res = dst - src;
10941
10942 FLAG_N = NFLAG_16(res);
10943 FLAG_Z = MASK_OUT_ABOVE_16(res);
10944 FLAG_V = VFLAG_SUB_16(src, dst, res);
10945 FLAG_C = CFLAG_16(res);
10946 }
10947
10948
m68k_op_cmp_16_al(void)10949 void m68k_op_cmp_16_al(void)
10950 {
10951 uint src = OPER_AL_16();
10952 uint dst = MASK_OUT_ABOVE_16(DX);
10953 uint res = dst - src;
10954
10955 FLAG_N = NFLAG_16(res);
10956 FLAG_Z = MASK_OUT_ABOVE_16(res);
10957 FLAG_V = VFLAG_SUB_16(src, dst, res);
10958 FLAG_C = CFLAG_16(res);
10959 }
10960
10961
m68k_op_cmp_16_pcdi(void)10962 void m68k_op_cmp_16_pcdi(void)
10963 {
10964 uint src = OPER_PCDI_16();
10965 uint dst = MASK_OUT_ABOVE_16(DX);
10966 uint res = dst - src;
10967
10968 FLAG_N = NFLAG_16(res);
10969 FLAG_Z = MASK_OUT_ABOVE_16(res);
10970 FLAG_V = VFLAG_SUB_16(src, dst, res);
10971 FLAG_C = CFLAG_16(res);
10972 }
10973
10974
m68k_op_cmp_16_pcix(void)10975 void m68k_op_cmp_16_pcix(void)
10976 {
10977 uint src = OPER_PCIX_16();
10978 uint dst = MASK_OUT_ABOVE_16(DX);
10979 uint res = dst - src;
10980
10981 FLAG_N = NFLAG_16(res);
10982 FLAG_Z = MASK_OUT_ABOVE_16(res);
10983 FLAG_V = VFLAG_SUB_16(src, dst, res);
10984 FLAG_C = CFLAG_16(res);
10985 }
10986
10987
m68k_op_cmp_16_i(void)10988 void m68k_op_cmp_16_i(void)
10989 {
10990 uint src = OPER_I_16();
10991 uint dst = MASK_OUT_ABOVE_16(DX);
10992 uint res = dst - src;
10993
10994 FLAG_N = NFLAG_16(res);
10995 FLAG_Z = MASK_OUT_ABOVE_16(res);
10996 FLAG_V = VFLAG_SUB_16(src, dst, res);
10997 FLAG_C = CFLAG_16(res);
10998 }
10999
11000
m68k_op_cmp_32_d(void)11001 void m68k_op_cmp_32_d(void)
11002 {
11003 uint src = DY;
11004 uint dst = DX;
11005 uint res = dst - src;
11006
11007 FLAG_N = NFLAG_32(res);
11008 FLAG_Z = MASK_OUT_ABOVE_32(res);
11009 FLAG_V = VFLAG_SUB_32(src, dst, res);
11010 FLAG_C = CFLAG_SUB_32(src, dst, res);
11011 }
11012
11013
m68k_op_cmp_32_a(void)11014 void m68k_op_cmp_32_a(void)
11015 {
11016 uint src = AY;
11017 uint dst = DX;
11018 uint res = dst - src;
11019
11020 FLAG_N = NFLAG_32(res);
11021 FLAG_Z = MASK_OUT_ABOVE_32(res);
11022 FLAG_V = VFLAG_SUB_32(src, dst, res);
11023 FLAG_C = CFLAG_SUB_32(src, dst, res);
11024 }
11025
11026
m68k_op_cmp_32_ai(void)11027 void m68k_op_cmp_32_ai(void)
11028 {
11029 uint src = OPER_AY_AI_32();
11030 uint dst = DX;
11031 uint res = dst - src;
11032
11033 FLAG_N = NFLAG_32(res);
11034 FLAG_Z = MASK_OUT_ABOVE_32(res);
11035 FLAG_V = VFLAG_SUB_32(src, dst, res);
11036 FLAG_C = CFLAG_SUB_32(src, dst, res);
11037 }
11038
11039
m68k_op_cmp_32_pi(void)11040 void m68k_op_cmp_32_pi(void)
11041 {
11042 uint src = OPER_AY_PI_32();
11043 uint dst = DX;
11044 uint res = dst - src;
11045
11046 FLAG_N = NFLAG_32(res);
11047 FLAG_Z = MASK_OUT_ABOVE_32(res);
11048 FLAG_V = VFLAG_SUB_32(src, dst, res);
11049 FLAG_C = CFLAG_SUB_32(src, dst, res);
11050 }
11051
11052
m68k_op_cmp_32_pd(void)11053 void m68k_op_cmp_32_pd(void)
11054 {
11055 uint src = OPER_AY_PD_32();
11056 uint dst = DX;
11057 uint res = dst - src;
11058
11059 FLAG_N = NFLAG_32(res);
11060 FLAG_Z = MASK_OUT_ABOVE_32(res);
11061 FLAG_V = VFLAG_SUB_32(src, dst, res);
11062 FLAG_C = CFLAG_SUB_32(src, dst, res);
11063 }
11064
11065
m68k_op_cmp_32_di(void)11066 void m68k_op_cmp_32_di(void)
11067 {
11068 uint src = OPER_AY_DI_32();
11069 uint dst = DX;
11070 uint res = dst - src;
11071
11072 FLAG_N = NFLAG_32(res);
11073 FLAG_Z = MASK_OUT_ABOVE_32(res);
11074 FLAG_V = VFLAG_SUB_32(src, dst, res);
11075 FLAG_C = CFLAG_SUB_32(src, dst, res);
11076 }
11077
11078
m68k_op_cmp_32_ix(void)11079 void m68k_op_cmp_32_ix(void)
11080 {
11081 uint src = OPER_AY_IX_32();
11082 uint dst = DX;
11083 uint res = dst - src;
11084
11085 FLAG_N = NFLAG_32(res);
11086 FLAG_Z = MASK_OUT_ABOVE_32(res);
11087 FLAG_V = VFLAG_SUB_32(src, dst, res);
11088 FLAG_C = CFLAG_SUB_32(src, dst, res);
11089 }
11090
11091
m68k_op_cmp_32_aw(void)11092 void m68k_op_cmp_32_aw(void)
11093 {
11094 uint src = OPER_AW_32();
11095 uint dst = DX;
11096 uint res = dst - src;
11097
11098 FLAG_N = NFLAG_32(res);
11099 FLAG_Z = MASK_OUT_ABOVE_32(res);
11100 FLAG_V = VFLAG_SUB_32(src, dst, res);
11101 FLAG_C = CFLAG_SUB_32(src, dst, res);
11102 }
11103
11104
m68k_op_cmp_32_al(void)11105 void m68k_op_cmp_32_al(void)
11106 {
11107 uint src = OPER_AL_32();
11108 uint dst = DX;
11109 uint res = dst - src;
11110
11111 FLAG_N = NFLAG_32(res);
11112 FLAG_Z = MASK_OUT_ABOVE_32(res);
11113 FLAG_V = VFLAG_SUB_32(src, dst, res);
11114 FLAG_C = CFLAG_SUB_32(src, dst, res);
11115 }
11116
11117
m68k_op_cmp_32_pcdi(void)11118 void m68k_op_cmp_32_pcdi(void)
11119 {
11120 uint src = OPER_PCDI_32();
11121 uint dst = DX;
11122 uint res = dst - src;
11123
11124 FLAG_N = NFLAG_32(res);
11125 FLAG_Z = MASK_OUT_ABOVE_32(res);
11126 FLAG_V = VFLAG_SUB_32(src, dst, res);
11127 FLAG_C = CFLAG_SUB_32(src, dst, res);
11128 }
11129
11130
m68k_op_cmp_32_pcix(void)11131 void m68k_op_cmp_32_pcix(void)
11132 {
11133 uint src = OPER_PCIX_32();
11134 uint dst = DX;
11135 uint res = dst - src;
11136
11137 FLAG_N = NFLAG_32(res);
11138 FLAG_Z = MASK_OUT_ABOVE_32(res);
11139 FLAG_V = VFLAG_SUB_32(src, dst, res);
11140 FLAG_C = CFLAG_SUB_32(src, dst, res);
11141 }
11142
11143
m68k_op_cmp_32_i(void)11144 void m68k_op_cmp_32_i(void)
11145 {
11146 uint src = OPER_I_32();
11147 uint dst = DX;
11148 uint res = dst - src;
11149
11150 FLAG_N = NFLAG_32(res);
11151 FLAG_Z = MASK_OUT_ABOVE_32(res);
11152 FLAG_V = VFLAG_SUB_32(src, dst, res);
11153 FLAG_C = CFLAG_SUB_32(src, dst, res);
11154 }
11155
11156
m68k_op_cmpa_16_d(void)11157 void m68k_op_cmpa_16_d(void)
11158 {
11159 uint src = MAKE_INT_16(DY);
11160 uint dst = AX;
11161 uint res = dst - src;
11162
11163 FLAG_N = NFLAG_32(res);
11164 FLAG_Z = MASK_OUT_ABOVE_32(res);
11165 FLAG_V = VFLAG_SUB_32(src, dst, res);
11166 FLAG_C = CFLAG_SUB_32(src, dst, res);
11167 }
11168
11169
m68k_op_cmpa_16_a(void)11170 void m68k_op_cmpa_16_a(void)
11171 {
11172 uint src = MAKE_INT_16(AY);
11173 uint dst = AX;
11174 uint res = dst - src;
11175
11176 FLAG_N = NFLAG_32(res);
11177 FLAG_Z = MASK_OUT_ABOVE_32(res);
11178 FLAG_V = VFLAG_SUB_32(src, dst, res);
11179 FLAG_C = CFLAG_SUB_32(src, dst, res);
11180 }
11181
11182
m68k_op_cmpa_16_ai(void)11183 void m68k_op_cmpa_16_ai(void)
11184 {
11185 uint src = MAKE_INT_16(OPER_AY_AI_16());
11186 uint dst = AX;
11187 uint res = dst - src;
11188
11189 FLAG_N = NFLAG_32(res);
11190 FLAG_Z = MASK_OUT_ABOVE_32(res);
11191 FLAG_V = VFLAG_SUB_32(src, dst, res);
11192 FLAG_C = CFLAG_SUB_32(src, dst, res);
11193 }
11194
11195
m68k_op_cmpa_16_pi(void)11196 void m68k_op_cmpa_16_pi(void)
11197 {
11198 uint src = MAKE_INT_16(OPER_AY_PI_16());
11199 uint dst = AX;
11200 uint res = dst - src;
11201
11202 FLAG_N = NFLAG_32(res);
11203 FLAG_Z = MASK_OUT_ABOVE_32(res);
11204 FLAG_V = VFLAG_SUB_32(src, dst, res);
11205 FLAG_C = CFLAG_SUB_32(src, dst, res);
11206 }
11207
11208
m68k_op_cmpa_16_pd(void)11209 void m68k_op_cmpa_16_pd(void)
11210 {
11211 uint src = MAKE_INT_16(OPER_AY_PD_16());
11212 uint dst = AX;
11213 uint res = dst - src;
11214
11215 FLAG_N = NFLAG_32(res);
11216 FLAG_Z = MASK_OUT_ABOVE_32(res);
11217 FLAG_V = VFLAG_SUB_32(src, dst, res);
11218 FLAG_C = CFLAG_SUB_32(src, dst, res);
11219 }
11220
11221
m68k_op_cmpa_16_di(void)11222 void m68k_op_cmpa_16_di(void)
11223 {
11224 uint src = MAKE_INT_16(OPER_AY_DI_16());
11225 uint dst = AX;
11226 uint res = dst - src;
11227
11228 FLAG_N = NFLAG_32(res);
11229 FLAG_Z = MASK_OUT_ABOVE_32(res);
11230 FLAG_V = VFLAG_SUB_32(src, dst, res);
11231 FLAG_C = CFLAG_SUB_32(src, dst, res);
11232 }
11233
11234
m68k_op_cmpa_16_ix(void)11235 void m68k_op_cmpa_16_ix(void)
11236 {
11237 uint src = MAKE_INT_16(OPER_AY_IX_16());
11238 uint dst = AX;
11239 uint res = dst - src;
11240
11241 FLAG_N = NFLAG_32(res);
11242 FLAG_Z = MASK_OUT_ABOVE_32(res);
11243 FLAG_V = VFLAG_SUB_32(src, dst, res);
11244 FLAG_C = CFLAG_SUB_32(src, dst, res);
11245 }
11246
11247
m68k_op_cmpa_16_aw(void)11248 void m68k_op_cmpa_16_aw(void)
11249 {
11250 uint src = MAKE_INT_16(OPER_AW_16());
11251 uint dst = AX;
11252 uint res = dst - src;
11253
11254 FLAG_N = NFLAG_32(res);
11255 FLAG_Z = MASK_OUT_ABOVE_32(res);
11256 FLAG_V = VFLAG_SUB_32(src, dst, res);
11257 FLAG_C = CFLAG_SUB_32(src, dst, res);
11258 }
11259
11260
m68k_op_cmpa_16_al(void)11261 void m68k_op_cmpa_16_al(void)
11262 {
11263 uint src = MAKE_INT_16(OPER_AL_16());
11264 uint dst = AX;
11265 uint res = dst - src;
11266
11267 FLAG_N = NFLAG_32(res);
11268 FLAG_Z = MASK_OUT_ABOVE_32(res);
11269 FLAG_V = VFLAG_SUB_32(src, dst, res);
11270 FLAG_C = CFLAG_SUB_32(src, dst, res);
11271 }
11272
11273
m68k_op_cmpa_16_pcdi(void)11274 void m68k_op_cmpa_16_pcdi(void)
11275 {
11276 uint src = MAKE_INT_16(OPER_PCDI_16());
11277 uint dst = AX;
11278 uint res = dst - src;
11279
11280 FLAG_N = NFLAG_32(res);
11281 FLAG_Z = MASK_OUT_ABOVE_32(res);
11282 FLAG_V = VFLAG_SUB_32(src, dst, res);
11283 FLAG_C = CFLAG_SUB_32(src, dst, res);
11284 }
11285
11286
m68k_op_cmpa_16_pcix(void)11287 void m68k_op_cmpa_16_pcix(void)
11288 {
11289 uint src = MAKE_INT_16(OPER_PCIX_16());
11290 uint dst = AX;
11291 uint res = dst - src;
11292
11293 FLAG_N = NFLAG_32(res);
11294 FLAG_Z = MASK_OUT_ABOVE_32(res);
11295 FLAG_V = VFLAG_SUB_32(src, dst, res);
11296 FLAG_C = CFLAG_SUB_32(src, dst, res);
11297 }
11298
11299
m68k_op_cmpa_16_i(void)11300 void m68k_op_cmpa_16_i(void)
11301 {
11302 uint src = MAKE_INT_16(OPER_I_16());
11303 uint dst = AX;
11304 uint res = dst - src;
11305
11306 FLAG_N = NFLAG_32(res);
11307 FLAG_Z = MASK_OUT_ABOVE_32(res);
11308 FLAG_V = VFLAG_SUB_32(src, dst, res);
11309 FLAG_C = CFLAG_SUB_32(src, dst, res);
11310 }
11311
11312
m68k_op_cmpa_32_d(void)11313 void m68k_op_cmpa_32_d(void)
11314 {
11315 uint src = DY;
11316 uint dst = AX;
11317 uint res = dst - src;
11318
11319 FLAG_N = NFLAG_32(res);
11320 FLAG_Z = MASK_OUT_ABOVE_32(res);
11321 FLAG_V = VFLAG_SUB_32(src, dst, res);
11322 FLAG_C = CFLAG_SUB_32(src, dst, res);
11323 }
11324
11325
m68k_op_cmpa_32_a(void)11326 void m68k_op_cmpa_32_a(void)
11327 {
11328 uint src = AY;
11329 uint dst = AX;
11330 uint res = dst - src;
11331
11332 FLAG_N = NFLAG_32(res);
11333 FLAG_Z = MASK_OUT_ABOVE_32(res);
11334 FLAG_V = VFLAG_SUB_32(src, dst, res);
11335 FLAG_C = CFLAG_SUB_32(src, dst, res);
11336 }
11337
11338
m68k_op_cmpa_32_ai(void)11339 void m68k_op_cmpa_32_ai(void)
11340 {
11341 uint src = OPER_AY_AI_32();
11342 uint dst = AX;
11343 uint res = dst - src;
11344
11345 FLAG_N = NFLAG_32(res);
11346 FLAG_Z = MASK_OUT_ABOVE_32(res);
11347 FLAG_V = VFLAG_SUB_32(src, dst, res);
11348 FLAG_C = CFLAG_SUB_32(src, dst, res);
11349 }
11350
11351
m68k_op_cmpa_32_pi(void)11352 void m68k_op_cmpa_32_pi(void)
11353 {
11354 uint src = OPER_AY_PI_32();
11355 uint dst = AX;
11356 uint res = dst - src;
11357
11358 FLAG_N = NFLAG_32(res);
11359 FLAG_Z = MASK_OUT_ABOVE_32(res);
11360 FLAG_V = VFLAG_SUB_32(src, dst, res);
11361 FLAG_C = CFLAG_SUB_32(src, dst, res);
11362 }
11363
11364
m68k_op_cmpa_32_pd(void)11365 void m68k_op_cmpa_32_pd(void)
11366 {
11367 uint src = OPER_AY_PD_32();
11368 uint dst = AX;
11369 uint res = dst - src;
11370
11371 FLAG_N = NFLAG_32(res);
11372 FLAG_Z = MASK_OUT_ABOVE_32(res);
11373 FLAG_V = VFLAG_SUB_32(src, dst, res);
11374 FLAG_C = CFLAG_SUB_32(src, dst, res);
11375 }
11376
11377
m68k_op_cmpa_32_di(void)11378 void m68k_op_cmpa_32_di(void)
11379 {
11380 uint src = OPER_AY_DI_32();
11381 uint dst = AX;
11382 uint res = dst - src;
11383
11384 FLAG_N = NFLAG_32(res);
11385 FLAG_Z = MASK_OUT_ABOVE_32(res);
11386 FLAG_V = VFLAG_SUB_32(src, dst, res);
11387 FLAG_C = CFLAG_SUB_32(src, dst, res);
11388 }
11389
11390
m68k_op_cmpa_32_ix(void)11391 void m68k_op_cmpa_32_ix(void)
11392 {
11393 uint src = OPER_AY_IX_32();
11394 uint dst = AX;
11395 uint res = dst - src;
11396
11397 FLAG_N = NFLAG_32(res);
11398 FLAG_Z = MASK_OUT_ABOVE_32(res);
11399 FLAG_V = VFLAG_SUB_32(src, dst, res);
11400 FLAG_C = CFLAG_SUB_32(src, dst, res);
11401 }
11402
11403
m68k_op_cmpa_32_aw(void)11404 void m68k_op_cmpa_32_aw(void)
11405 {
11406 uint src = OPER_AW_32();
11407 uint dst = AX;
11408 uint res = dst - src;
11409
11410 FLAG_N = NFLAG_32(res);
11411 FLAG_Z = MASK_OUT_ABOVE_32(res);
11412 FLAG_V = VFLAG_SUB_32(src, dst, res);
11413 FLAG_C = CFLAG_SUB_32(src, dst, res);
11414 }
11415
11416
m68k_op_cmpa_32_al(void)11417 void m68k_op_cmpa_32_al(void)
11418 {
11419 uint src = OPER_AL_32();
11420 uint dst = AX;
11421 uint res = dst - src;
11422
11423 FLAG_N = NFLAG_32(res);
11424 FLAG_Z = MASK_OUT_ABOVE_32(res);
11425 FLAG_V = VFLAG_SUB_32(src, dst, res);
11426 FLAG_C = CFLAG_SUB_32(src, dst, res);
11427 }
11428
11429
m68k_op_cmpa_32_pcdi(void)11430 void m68k_op_cmpa_32_pcdi(void)
11431 {
11432 uint src = OPER_PCDI_32();
11433 uint dst = AX;
11434 uint res = dst - src;
11435
11436 FLAG_N = NFLAG_32(res);
11437 FLAG_Z = MASK_OUT_ABOVE_32(res);
11438 FLAG_V = VFLAG_SUB_32(src, dst, res);
11439 FLAG_C = CFLAG_SUB_32(src, dst, res);
11440 }
11441
11442
m68k_op_cmpa_32_pcix(void)11443 void m68k_op_cmpa_32_pcix(void)
11444 {
11445 uint src = OPER_PCIX_32();
11446 uint dst = AX;
11447 uint res = dst - src;
11448
11449 FLAG_N = NFLAG_32(res);
11450 FLAG_Z = MASK_OUT_ABOVE_32(res);
11451 FLAG_V = VFLAG_SUB_32(src, dst, res);
11452 FLAG_C = CFLAG_SUB_32(src, dst, res);
11453 }
11454
11455
m68k_op_cmpa_32_i(void)11456 void m68k_op_cmpa_32_i(void)
11457 {
11458 uint src = OPER_I_32();
11459 uint dst = AX;
11460 uint res = dst - src;
11461
11462 FLAG_N = NFLAG_32(res);
11463 FLAG_Z = MASK_OUT_ABOVE_32(res);
11464 FLAG_V = VFLAG_SUB_32(src, dst, res);
11465 FLAG_C = CFLAG_SUB_32(src, dst, res);
11466 }
11467
11468
m68k_op_cmpi_8_d(void)11469 void m68k_op_cmpi_8_d(void)
11470 {
11471 uint src = OPER_I_8();
11472 uint dst = MASK_OUT_ABOVE_8(DY);
11473 uint res = dst - src;
11474
11475 FLAG_N = NFLAG_8(res);
11476 FLAG_Z = MASK_OUT_ABOVE_8(res);
11477 FLAG_V = VFLAG_SUB_8(src, dst, res);
11478 FLAG_C = CFLAG_8(res);
11479 }
11480
11481
m68k_op_cmpi_8_ai(void)11482 void m68k_op_cmpi_8_ai(void)
11483 {
11484 uint src = OPER_I_8();
11485 uint dst = OPER_AY_AI_8();
11486 uint res = dst - src;
11487
11488 FLAG_N = NFLAG_8(res);
11489 FLAG_Z = MASK_OUT_ABOVE_8(res);
11490 FLAG_V = VFLAG_SUB_8(src, dst, res);
11491 FLAG_C = CFLAG_8(res);
11492 }
11493
11494
m68k_op_cmpi_8_pi(void)11495 void m68k_op_cmpi_8_pi(void)
11496 {
11497 uint src = OPER_I_8();
11498 uint dst = OPER_AY_PI_8();
11499 uint res = dst - src;
11500
11501 FLAG_N = NFLAG_8(res);
11502 FLAG_Z = MASK_OUT_ABOVE_8(res);
11503 FLAG_V = VFLAG_SUB_8(src, dst, res);
11504 FLAG_C = CFLAG_8(res);
11505 }
11506
11507
m68k_op_cmpi_8_pi7(void)11508 void m68k_op_cmpi_8_pi7(void)
11509 {
11510 uint src = OPER_I_8();
11511 uint dst = OPER_A7_PI_8();
11512 uint res = dst - src;
11513
11514 FLAG_N = NFLAG_8(res);
11515 FLAG_Z = MASK_OUT_ABOVE_8(res);
11516 FLAG_V = VFLAG_SUB_8(src, dst, res);
11517 FLAG_C = CFLAG_8(res);
11518 }
11519
11520
m68k_op_cmpi_8_pd(void)11521 void m68k_op_cmpi_8_pd(void)
11522 {
11523 uint src = OPER_I_8();
11524 uint dst = OPER_AY_PD_8();
11525 uint res = dst - src;
11526
11527 FLAG_N = NFLAG_8(res);
11528 FLAG_Z = MASK_OUT_ABOVE_8(res);
11529 FLAG_V = VFLAG_SUB_8(src, dst, res);
11530 FLAG_C = CFLAG_8(res);
11531 }
11532
11533
m68k_op_cmpi_8_pd7(void)11534 void m68k_op_cmpi_8_pd7(void)
11535 {
11536 uint src = OPER_I_8();
11537 uint dst = OPER_A7_PD_8();
11538 uint res = dst - src;
11539
11540 FLAG_N = NFLAG_8(res);
11541 FLAG_Z = MASK_OUT_ABOVE_8(res);
11542 FLAG_V = VFLAG_SUB_8(src, dst, res);
11543 FLAG_C = CFLAG_8(res);
11544 }
11545
11546
m68k_op_cmpi_8_di(void)11547 void m68k_op_cmpi_8_di(void)
11548 {
11549 uint src = OPER_I_8();
11550 uint dst = OPER_AY_DI_8();
11551 uint res = dst - src;
11552
11553 FLAG_N = NFLAG_8(res);
11554 FLAG_Z = MASK_OUT_ABOVE_8(res);
11555 FLAG_V = VFLAG_SUB_8(src, dst, res);
11556 FLAG_C = CFLAG_8(res);
11557 }
11558
11559
m68k_op_cmpi_8_ix(void)11560 void m68k_op_cmpi_8_ix(void)
11561 {
11562 uint src = OPER_I_8();
11563 uint dst = OPER_AY_IX_8();
11564 uint res = dst - src;
11565
11566 FLAG_N = NFLAG_8(res);
11567 FLAG_Z = MASK_OUT_ABOVE_8(res);
11568 FLAG_V = VFLAG_SUB_8(src, dst, res);
11569 FLAG_C = CFLAG_8(res);
11570 }
11571
11572
m68k_op_cmpi_8_aw(void)11573 void m68k_op_cmpi_8_aw(void)
11574 {
11575 uint src = OPER_I_8();
11576 uint dst = OPER_AW_8();
11577 uint res = dst - src;
11578
11579 FLAG_N = NFLAG_8(res);
11580 FLAG_Z = MASK_OUT_ABOVE_8(res);
11581 FLAG_V = VFLAG_SUB_8(src, dst, res);
11582 FLAG_C = CFLAG_8(res);
11583 }
11584
11585
m68k_op_cmpi_8_al(void)11586 void m68k_op_cmpi_8_al(void)
11587 {
11588 uint src = OPER_I_8();
11589 uint dst = OPER_AL_8();
11590 uint res = dst - src;
11591
11592 FLAG_N = NFLAG_8(res);
11593 FLAG_Z = MASK_OUT_ABOVE_8(res);
11594 FLAG_V = VFLAG_SUB_8(src, dst, res);
11595 FLAG_C = CFLAG_8(res);
11596 }
11597
11598
m68k_op_cmpi_8_pcdi(void)11599 void m68k_op_cmpi_8_pcdi(void)
11600 {
11601 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
11602 {
11603 uint src = OPER_I_8();
11604 uint dst = OPER_PCDI_8();
11605 uint res = dst - src;
11606
11607 FLAG_N = NFLAG_8(res);
11608 FLAG_Z = MASK_OUT_ABOVE_8(res);
11609 FLAG_V = VFLAG_SUB_8(src, dst, res);
11610 FLAG_C = CFLAG_8(res);
11611 return;
11612 }
11613 m68ki_exception_illegal();
11614 }
11615
11616
m68k_op_cmpi_8_pcix(void)11617 void m68k_op_cmpi_8_pcix(void)
11618 {
11619 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
11620 {
11621 uint src = OPER_I_8();
11622 uint dst = OPER_PCIX_8();
11623 uint res = dst - src;
11624
11625 FLAG_N = NFLAG_8(res);
11626 FLAG_Z = MASK_OUT_ABOVE_8(res);
11627 FLAG_V = VFLAG_SUB_8(src, dst, res);
11628 FLAG_C = CFLAG_8(res);
11629 return;
11630 }
11631 m68ki_exception_illegal();
11632 }
11633
11634
m68k_op_cmpi_16_d(void)11635 void m68k_op_cmpi_16_d(void)
11636 {
11637 uint src = OPER_I_16();
11638 uint dst = MASK_OUT_ABOVE_16(DY);
11639 uint res = dst - src;
11640
11641 FLAG_N = NFLAG_16(res);
11642 FLAG_Z = MASK_OUT_ABOVE_16(res);
11643 FLAG_V = VFLAG_SUB_16(src, dst, res);
11644 FLAG_C = CFLAG_16(res);
11645 }
11646
11647
m68k_op_cmpi_16_ai(void)11648 void m68k_op_cmpi_16_ai(void)
11649 {
11650 uint src = OPER_I_16();
11651 uint dst = OPER_AY_AI_16();
11652 uint res = dst - src;
11653
11654 FLAG_N = NFLAG_16(res);
11655 FLAG_Z = MASK_OUT_ABOVE_16(res);
11656 FLAG_V = VFLAG_SUB_16(src, dst, res);
11657 FLAG_C = CFLAG_16(res);
11658 }
11659
11660
m68k_op_cmpi_16_pi(void)11661 void m68k_op_cmpi_16_pi(void)
11662 {
11663 uint src = OPER_I_16();
11664 uint dst = OPER_AY_PI_16();
11665 uint res = dst - src;
11666
11667 FLAG_N = NFLAG_16(res);
11668 FLAG_Z = MASK_OUT_ABOVE_16(res);
11669 FLAG_V = VFLAG_SUB_16(src, dst, res);
11670 FLAG_C = CFLAG_16(res);
11671 }
11672
11673
m68k_op_cmpi_16_pd(void)11674 void m68k_op_cmpi_16_pd(void)
11675 {
11676 uint src = OPER_I_16();
11677 uint dst = OPER_AY_PD_16();
11678 uint res = dst - src;
11679
11680 FLAG_N = NFLAG_16(res);
11681 FLAG_Z = MASK_OUT_ABOVE_16(res);
11682 FLAG_V = VFLAG_SUB_16(src, dst, res);
11683 FLAG_C = CFLAG_16(res);
11684 }
11685
11686
m68k_op_cmpi_16_di(void)11687 void m68k_op_cmpi_16_di(void)
11688 {
11689 uint src = OPER_I_16();
11690 uint dst = OPER_AY_DI_16();
11691 uint res = dst - src;
11692
11693 FLAG_N = NFLAG_16(res);
11694 FLAG_Z = MASK_OUT_ABOVE_16(res);
11695 FLAG_V = VFLAG_SUB_16(src, dst, res);
11696 FLAG_C = CFLAG_16(res);
11697 }
11698
11699
m68k_op_cmpi_16_ix(void)11700 void m68k_op_cmpi_16_ix(void)
11701 {
11702 uint src = OPER_I_16();
11703 uint dst = OPER_AY_IX_16();
11704 uint res = dst - src;
11705
11706 FLAG_N = NFLAG_16(res);
11707 FLAG_Z = MASK_OUT_ABOVE_16(res);
11708 FLAG_V = VFLAG_SUB_16(src, dst, res);
11709 FLAG_C = CFLAG_16(res);
11710 }
11711
11712
m68k_op_cmpi_16_aw(void)11713 void m68k_op_cmpi_16_aw(void)
11714 {
11715 uint src = OPER_I_16();
11716 uint dst = OPER_AW_16();
11717 uint res = dst - src;
11718
11719 FLAG_N = NFLAG_16(res);
11720 FLAG_Z = MASK_OUT_ABOVE_16(res);
11721 FLAG_V = VFLAG_SUB_16(src, dst, res);
11722 FLAG_C = CFLAG_16(res);
11723 }
11724
11725
m68k_op_cmpi_16_al(void)11726 void m68k_op_cmpi_16_al(void)
11727 {
11728 uint src = OPER_I_16();
11729 uint dst = OPER_AL_16();
11730 uint res = dst - src;
11731
11732 FLAG_N = NFLAG_16(res);
11733 FLAG_Z = MASK_OUT_ABOVE_16(res);
11734 FLAG_V = VFLAG_SUB_16(src, dst, res);
11735 FLAG_C = CFLAG_16(res);
11736 }
11737
11738
m68k_op_cmpi_16_pcdi(void)11739 void m68k_op_cmpi_16_pcdi(void)
11740 {
11741 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
11742 {
11743 uint src = OPER_I_16();
11744 uint dst = OPER_PCDI_16();
11745 uint res = dst - src;
11746
11747 FLAG_N = NFLAG_16(res);
11748 FLAG_Z = MASK_OUT_ABOVE_16(res);
11749 FLAG_V = VFLAG_SUB_16(src, dst, res);
11750 FLAG_C = CFLAG_16(res);
11751 return;
11752 }
11753 m68ki_exception_illegal();
11754 }
11755
11756
m68k_op_cmpi_16_pcix(void)11757 void m68k_op_cmpi_16_pcix(void)
11758 {
11759 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
11760 {
11761 uint src = OPER_I_16();
11762 uint dst = OPER_PCIX_16();
11763 uint res = dst - src;
11764
11765 FLAG_N = NFLAG_16(res);
11766 FLAG_Z = MASK_OUT_ABOVE_16(res);
11767 FLAG_V = VFLAG_SUB_16(src, dst, res);
11768 FLAG_C = CFLAG_16(res);
11769 return;
11770 }
11771 m68ki_exception_illegal();
11772 }
11773
11774
m68k_op_cmpi_32_d(void)11775 void m68k_op_cmpi_32_d(void)
11776 {
11777 uint src = OPER_I_32();
11778 uint dst = DY;
11779 uint res = dst - src;
11780
11781 FLAG_N = NFLAG_32(res);
11782 FLAG_Z = MASK_OUT_ABOVE_32(res);
11783 FLAG_V = VFLAG_SUB_32(src, dst, res);
11784 FLAG_C = CFLAG_SUB_32(src, dst, res);
11785 }
11786
11787
m68k_op_cmpi_32_ai(void)11788 void m68k_op_cmpi_32_ai(void)
11789 {
11790 uint src = OPER_I_32();
11791 uint dst = OPER_AY_AI_32();
11792 uint res = dst - src;
11793
11794 FLAG_N = NFLAG_32(res);
11795 FLAG_Z = MASK_OUT_ABOVE_32(res);
11796 FLAG_V = VFLAG_SUB_32(src, dst, res);
11797 FLAG_C = CFLAG_SUB_32(src, dst, res);
11798 }
11799
11800
m68k_op_cmpi_32_pi(void)11801 void m68k_op_cmpi_32_pi(void)
11802 {
11803 uint src = OPER_I_32();
11804 uint dst = OPER_AY_PI_32();
11805 uint res = dst - src;
11806
11807 FLAG_N = NFLAG_32(res);
11808 FLAG_Z = MASK_OUT_ABOVE_32(res);
11809 FLAG_V = VFLAG_SUB_32(src, dst, res);
11810 FLAG_C = CFLAG_SUB_32(src, dst, res);
11811 }
11812
11813
m68k_op_cmpi_32_pd(void)11814 void m68k_op_cmpi_32_pd(void)
11815 {
11816 uint src = OPER_I_32();
11817 uint dst = OPER_AY_PD_32();
11818 uint res = dst - src;
11819
11820 FLAG_N = NFLAG_32(res);
11821 FLAG_Z = MASK_OUT_ABOVE_32(res);
11822 FLAG_V = VFLAG_SUB_32(src, dst, res);
11823 FLAG_C = CFLAG_SUB_32(src, dst, res);
11824 }
11825
11826
m68k_op_cmpi_32_di(void)11827 void m68k_op_cmpi_32_di(void)
11828 {
11829 uint src = OPER_I_32();
11830 uint dst = OPER_AY_DI_32();
11831 uint res = dst - src;
11832
11833 FLAG_N = NFLAG_32(res);
11834 FLAG_Z = MASK_OUT_ABOVE_32(res);
11835 FLAG_V = VFLAG_SUB_32(src, dst, res);
11836 FLAG_C = CFLAG_SUB_32(src, dst, res);
11837 }
11838
11839
m68k_op_cmpi_32_ix(void)11840 void m68k_op_cmpi_32_ix(void)
11841 {
11842 uint src = OPER_I_32();
11843 uint dst = OPER_AY_IX_32();
11844 uint res = dst - src;
11845
11846 FLAG_N = NFLAG_32(res);
11847 FLAG_Z = MASK_OUT_ABOVE_32(res);
11848 FLAG_V = VFLAG_SUB_32(src, dst, res);
11849 FLAG_C = CFLAG_SUB_32(src, dst, res);
11850 }
11851
11852
m68k_op_cmpi_32_aw(void)11853 void m68k_op_cmpi_32_aw(void)
11854 {
11855 uint src = OPER_I_32();
11856 uint dst = OPER_AW_32();
11857 uint res = dst - src;
11858
11859 FLAG_N = NFLAG_32(res);
11860 FLAG_Z = MASK_OUT_ABOVE_32(res);
11861 FLAG_V = VFLAG_SUB_32(src, dst, res);
11862 FLAG_C = CFLAG_SUB_32(src, dst, res);
11863 }
11864
11865
m68k_op_cmpi_32_al(void)11866 void m68k_op_cmpi_32_al(void)
11867 {
11868 uint src = OPER_I_32();
11869 uint dst = OPER_AL_32();
11870 uint res = dst - src;
11871
11872 FLAG_N = NFLAG_32(res);
11873 FLAG_Z = MASK_OUT_ABOVE_32(res);
11874 FLAG_V = VFLAG_SUB_32(src, dst, res);
11875 FLAG_C = CFLAG_SUB_32(src, dst, res);
11876 }
11877
11878
m68k_op_cmpi_32_pcdi(void)11879 void m68k_op_cmpi_32_pcdi(void)
11880 {
11881 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
11882 {
11883 uint src = OPER_I_32();
11884 uint dst = OPER_PCDI_32();
11885 uint res = dst - src;
11886
11887 FLAG_N = NFLAG_32(res);
11888 FLAG_Z = MASK_OUT_ABOVE_32(res);
11889 FLAG_V = VFLAG_SUB_32(src, dst, res);
11890 FLAG_C = CFLAG_SUB_32(src, dst, res);
11891 return;
11892 }
11893 m68ki_exception_illegal();
11894 }
11895
11896
m68k_op_cmpi_32_pcix(void)11897 void m68k_op_cmpi_32_pcix(void)
11898 {
11899 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
11900 {
11901 uint src = OPER_I_32();
11902 uint dst = OPER_PCIX_32();
11903 uint res = dst - src;
11904
11905 FLAG_N = NFLAG_32(res);
11906 FLAG_Z = MASK_OUT_ABOVE_32(res);
11907 FLAG_V = VFLAG_SUB_32(src, dst, res);
11908 FLAG_C = CFLAG_SUB_32(src, dst, res);
11909 return;
11910 }
11911 m68ki_exception_illegal();
11912 }
11913
11914
m68k_op_cmpm_8_ax7(void)11915 void m68k_op_cmpm_8_ax7(void)
11916 {
11917 uint src = OPER_AY_PI_8();
11918 uint dst = OPER_A7_PI_8();
11919 uint res = dst - src;
11920
11921 FLAG_N = NFLAG_8(res);
11922 FLAG_Z = MASK_OUT_ABOVE_8(res);
11923 FLAG_V = VFLAG_SUB_8(src, dst, res);
11924 FLAG_C = CFLAG_8(res);
11925 }
11926
11927
m68k_op_cmpm_8_ay7(void)11928 void m68k_op_cmpm_8_ay7(void)
11929 {
11930 uint src = OPER_A7_PI_8();
11931 uint dst = OPER_AX_PI_8();
11932 uint res = dst - src;
11933
11934 FLAG_N = NFLAG_8(res);
11935 FLAG_Z = MASK_OUT_ABOVE_8(res);
11936 FLAG_V = VFLAG_SUB_8(src, dst, res);
11937 FLAG_C = CFLAG_8(res);
11938 }
11939
11940
m68k_op_cmpm_8_axy7(void)11941 void m68k_op_cmpm_8_axy7(void)
11942 {
11943 uint src = OPER_A7_PI_8();
11944 uint dst = OPER_A7_PI_8();
11945 uint res = dst - src;
11946
11947 FLAG_N = NFLAG_8(res);
11948 FLAG_Z = MASK_OUT_ABOVE_8(res);
11949 FLAG_V = VFLAG_SUB_8(src, dst, res);
11950 FLAG_C = CFLAG_8(res);
11951 }
11952
11953
m68k_op_cmpm_8(void)11954 void m68k_op_cmpm_8(void)
11955 {
11956 uint src = OPER_AY_PI_8();
11957 uint dst = OPER_AX_PI_8();
11958 uint res = dst - src;
11959
11960 FLAG_N = NFLAG_8(res);
11961 FLAG_Z = MASK_OUT_ABOVE_8(res);
11962 FLAG_V = VFLAG_SUB_8(src, dst, res);
11963 FLAG_C = CFLAG_8(res);
11964 }
11965
11966
m68k_op_cmpm_16(void)11967 void m68k_op_cmpm_16(void)
11968 {
11969 uint src = OPER_AY_PI_16();
11970 uint dst = OPER_AX_PI_16();
11971 uint res = dst - src;
11972
11973 FLAG_N = NFLAG_16(res);
11974 FLAG_Z = MASK_OUT_ABOVE_16(res);
11975 FLAG_V = VFLAG_SUB_16(src, dst, res);
11976 FLAG_C = CFLAG_16(res);
11977 }
11978
11979
m68k_op_cmpm_32(void)11980 void m68k_op_cmpm_32(void)
11981 {
11982 uint src = OPER_AY_PI_32();
11983 uint dst = OPER_AX_PI_32();
11984 uint res = dst - src;
11985
11986 FLAG_N = NFLAG_32(res);
11987 FLAG_Z = MASK_OUT_ABOVE_32(res);
11988 FLAG_V = VFLAG_SUB_32(src, dst, res);
11989 FLAG_C = CFLAG_SUB_32(src, dst, res);
11990 }
11991
11992
m68k_op_cpbcc_32(void)11993 void m68k_op_cpbcc_32(void)
11994 {
11995 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
11996 {
11997 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
11998 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
11999 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
12000 return;
12001 }
12002 m68ki_exception_1111();
12003 }
12004
12005
m68k_op_cpdbcc_32(void)12006 void m68k_op_cpdbcc_32(void)
12007 {
12008 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
12009 {
12010 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
12011 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
12012 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
12013 return;
12014 }
12015 m68ki_exception_1111();
12016 }
12017
12018
m68k_op_cpgen_32(void)12019 void m68k_op_cpgen_32(void)
12020 {
12021 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
12022 {
12023 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
12024 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
12025 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
12026 return;
12027 }
12028 m68ki_exception_1111();
12029 }
12030
12031
m68k_op_cpscc_32(void)12032 void m68k_op_cpscc_32(void)
12033 {
12034 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
12035 {
12036 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
12037 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
12038 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
12039 return;
12040 }
12041 m68ki_exception_1111();
12042 }
12043
12044
m68k_op_cptrapcc_32(void)12045 void m68k_op_cptrapcc_32(void)
12046 {
12047 if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE))
12048 {
12049 M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n",
12050 m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR,
12051 m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2))));
12052 return;
12053 }
12054 m68ki_exception_1111();
12055 }
12056
12057
12058 /* ======================================================================== */
12059 /* ============================== END OF FILE ============================= */
12060 /* ======================================================================== */
12061
12062
12063