notaz.gp2x.de / picodrive.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
platform ps2, handle audio similar to psp
[picodrive.git] / cpu / fame / famec_opcodes.h
... / ...
CommitLineData
1
2#ifdef PICODRIVE_HACK
3#define NOT_POLLING ctx->not_polling = 1;
4#else
5#define NOT_POLLING
6#endif
7
8// ORI
9OPCODE(0x0000)
10{
11 u32 adr, res;
12 u32 src, dst;
13
14 FETCH_BYTE(src);
15 res = DREGu8((Opcode >> 0) & 7);
16 res |= src;
17 flag_C = 0;
18 flag_V = 0;
19 flag_NotZ = res;
20 flag_N = res;
21 DREGu8((Opcode >> 0) & 7) = res;
22RET(8)
23}
24
25// ORI
26OPCODE(0x0010)
27{
28 u32 adr, res;
29 u32 src, dst;
30
31 FETCH_BYTE(src);
32 adr = AREG((Opcode >> 0) & 7);
33 PRE_IO
34 READ_BYTE_F(adr, res)
35 res |= src;
36 flag_C = 0;
37 flag_V = 0;
38 flag_NotZ = res;
39 flag_N = res;
40 WRITE_BYTE_F(adr, res)
41 POST_IO
42RET(16)
43}
44
45// ORI
46OPCODE(0x0018)
47{
48 u32 adr, res;
49 u32 src, dst;
50
51 FETCH_BYTE(src);
52 adr = AREG((Opcode >> 0) & 7);
53 AREG((Opcode >> 0) & 7) += 1;
54 PRE_IO
55 READ_BYTE_F(adr, res)
56 res |= src;
57 flag_C = 0;
58 flag_V = 0;
59 flag_NotZ = res;
60 flag_N = res;
61 WRITE_BYTE_F(adr, res)
62 POST_IO
63RET(16)
64}
65
66// ORI
67OPCODE(0x0020)
68{
69 u32 adr, res;
70 u32 src, dst;
71
72 FETCH_BYTE(src);
73 adr = AREG((Opcode >> 0) & 7) - 1;
74 AREG((Opcode >> 0) & 7) = adr;
75 PRE_IO
76 READ_BYTE_F(adr, res)
77 res |= src;
78 flag_C = 0;
79 flag_V = 0;
80 flag_NotZ = res;
81 flag_N = res;
82 WRITE_BYTE_F(adr, res)
83 POST_IO
84RET(18)
85}
86
87// ORI
88OPCODE(0x0028)
89{
90 u32 adr, res;
91 u32 src, dst;
92
93 FETCH_BYTE(src);
94 FETCH_SWORD(adr);
95 adr += AREG((Opcode >> 0) & 7);
96 PRE_IO
97 READ_BYTE_F(adr, res)
98 res |= src;
99 flag_C = 0;
100 flag_V = 0;
101 flag_NotZ = res;
102 flag_N = res;
103 WRITE_BYTE_F(adr, res)
104 POST_IO
105RET(20)
106}
107
108// ORI
109OPCODE(0x0030)
110{
111 u32 adr, res;
112 u32 src, dst;
113
114 FETCH_BYTE(src);
115 adr = AREG((Opcode >> 0) & 7);
116 DECODE_EXT_WORD
117 PRE_IO
118 READ_BYTE_F(adr, res)
119 res |= src;
120 flag_C = 0;
121 flag_V = 0;
122 flag_NotZ = res;
123 flag_N = res;
124 WRITE_BYTE_F(adr, res)
125 POST_IO
126RET(22)
127}
128
129// ORI
130OPCODE(0x0038)
131{
132 u32 adr, res;
133 u32 src, dst;
134
135 FETCH_BYTE(src);
136 FETCH_SWORD(adr);
137 PRE_IO
138 READ_BYTE_F(adr, res)
139 res |= src;
140 flag_C = 0;
141 flag_V = 0;
142 flag_NotZ = res;
143 flag_N = res;
144 WRITE_BYTE_F(adr, res)
145 POST_IO
146RET(20)
147}
148
149// ORI
150OPCODE(0x0039)
151{
152 u32 adr, res;
153 u32 src, dst;
154
155 FETCH_BYTE(src);
156 FETCH_LONG(adr);
157 PRE_IO
158 READ_BYTE_F(adr, res)
159 res |= src;
160 flag_C = 0;
161 flag_V = 0;
162 flag_NotZ = res;
163 flag_N = res;
164 WRITE_BYTE_F(adr, res)
165 POST_IO
166RET(24)
167}
168
169// ORI
170OPCODE(0x001F)
171{
172 u32 adr, res;
173 u32 src, dst;
174
175 FETCH_BYTE(src);
176 adr = AREG(7);
177 AREG(7) += 2;
178 PRE_IO
179 READ_BYTE_F(adr, res)
180 res |= src;
181 flag_C = 0;
182 flag_V = 0;
183 flag_NotZ = res;
184 flag_N = res;
185 WRITE_BYTE_F(adr, res)
186 POST_IO
187RET(16)
188}
189
190// ORI
191OPCODE(0x0027)
192{
193 u32 adr, res;
194 u32 src, dst;
195
196 FETCH_BYTE(src);
197 adr = AREG(7) - 2;
198 AREG(7) = adr;
199 PRE_IO
200 READ_BYTE_F(adr, res)
201 res |= src;
202 flag_C = 0;
203 flag_V = 0;
204 flag_NotZ = res;
205 flag_N = res;
206 WRITE_BYTE_F(adr, res)
207 POST_IO
208RET(18)
209}
210
211// ORI
212OPCODE(0x0040)
213{
214 u32 adr, res;
215 u32 src, dst;
216
217 FETCH_WORD(src);
218 res = DREGu16((Opcode >> 0) & 7);
219 res |= src;
220 flag_C = 0;
221 flag_V = 0;
222 flag_NotZ = res;
223 flag_N = res >> 8;
224 DREGu16((Opcode >> 0) & 7) = res;
225RET(8)
226}
227
228// ORI
229OPCODE(0x0050)
230{
231 u32 adr, res;
232 u32 src, dst;
233
234 FETCH_WORD(src);
235 adr = AREG((Opcode >> 0) & 7);
236 PRE_IO
237 READ_WORD_F(adr, res)
238 res |= src;
239 flag_C = 0;
240 flag_V = 0;
241 flag_NotZ = res;
242 flag_N = res >> 8;
243 WRITE_WORD_F(adr, res)
244 POST_IO
245RET(16)
246}
247
248// ORI
249OPCODE(0x0058)
250{
251 u32 adr, res;
252 u32 src, dst;
253
254 FETCH_WORD(src);
255 adr = AREG((Opcode >> 0) & 7);
256 AREG((Opcode >> 0) & 7) += 2;
257 PRE_IO
258 READ_WORD_F(adr, res)
259 res |= src;
260 flag_C = 0;
261 flag_V = 0;
262 flag_NotZ = res;
263 flag_N = res >> 8;
264 WRITE_WORD_F(adr, res)
265 POST_IO
266RET(16)
267}
268
269// ORI
270OPCODE(0x0060)
271{
272 u32 adr, res;
273 u32 src, dst;
274
275 FETCH_WORD(src);
276 adr = AREG((Opcode >> 0) & 7) - 2;
277 AREG((Opcode >> 0) & 7) = adr;
278 PRE_IO
279 READ_WORD_F(adr, res)
280 res |= src;
281 flag_C = 0;
282 flag_V = 0;
283 flag_NotZ = res;
284 flag_N = res >> 8;
285 WRITE_WORD_F(adr, res)
286 POST_IO
287RET(18)
288}
289
290// ORI
291OPCODE(0x0068)
292{
293 u32 adr, res;
294 u32 src, dst;
295
296 FETCH_WORD(src);
297 FETCH_SWORD(adr);
298 adr += AREG((Opcode >> 0) & 7);
299 PRE_IO
300 READ_WORD_F(adr, res)
301 res |= src;
302 flag_C = 0;
303 flag_V = 0;
304 flag_NotZ = res;
305 flag_N = res >> 8;
306 WRITE_WORD_F(adr, res)
307 POST_IO
308RET(20)
309}
310
311// ORI
312OPCODE(0x0070)
313{
314 u32 adr, res;
315 u32 src, dst;
316
317 FETCH_WORD(src);
318 adr = AREG((Opcode >> 0) & 7);
319 DECODE_EXT_WORD
320 PRE_IO
321 READ_WORD_F(adr, res)
322 res |= src;
323 flag_C = 0;
324 flag_V = 0;
325 flag_NotZ = res;
326 flag_N = res >> 8;
327 WRITE_WORD_F(adr, res)
328 POST_IO
329RET(22)
330}
331
332// ORI
333OPCODE(0x0078)
334{
335 u32 adr, res;
336 u32 src, dst;
337
338 FETCH_WORD(src);
339 FETCH_SWORD(adr);
340 PRE_IO
341 READ_WORD_F(adr, res)
342 res |= src;
343 flag_C = 0;
344 flag_V = 0;
345 flag_NotZ = res;
346 flag_N = res >> 8;
347 WRITE_WORD_F(adr, res)
348 POST_IO
349RET(20)
350}
351
352// ORI
353OPCODE(0x0079)
354{
355 u32 adr, res;
356 u32 src, dst;
357
358 FETCH_WORD(src);
359 FETCH_LONG(adr);
360 PRE_IO
361 READ_WORD_F(adr, res)
362 res |= src;
363 flag_C = 0;
364 flag_V = 0;
365 flag_NotZ = res;
366 flag_N = res >> 8;
367 WRITE_WORD_F(adr, res)
368 POST_IO
369RET(24)
370}
371
372// ORI
373OPCODE(0x005F)
374{
375 u32 adr, res;
376 u32 src, dst;
377
378 FETCH_WORD(src);
379 adr = AREG(7);
380 AREG(7) += 2;
381 PRE_IO
382 READ_WORD_F(adr, res)
383 res |= src;
384 flag_C = 0;
385 flag_V = 0;
386 flag_NotZ = res;
387 flag_N = res >> 8;
388 WRITE_WORD_F(adr, res)
389 POST_IO
390RET(16)
391}
392
393// ORI
394OPCODE(0x0067)
395{
396 u32 adr, res;
397 u32 src, dst;
398
399 FETCH_WORD(src);
400 adr = AREG(7) - 2;
401 AREG(7) = adr;
402 PRE_IO
403 READ_WORD_F(adr, res)
404 res |= src;
405 flag_C = 0;
406 flag_V = 0;
407 flag_NotZ = res;
408 flag_N = res >> 8;
409 WRITE_WORD_F(adr, res)
410 POST_IO
411RET(18)
412}
413
414// ORI
415OPCODE(0x0080)
416{
417 u32 adr, res;
418 u32 src, dst;
419
420 FETCH_LONG(src);
421 res = DREGu32((Opcode >> 0) & 7);
422 res |= src;
423 flag_C = 0;
424 flag_V = 0;
425 flag_NotZ = res;
426 flag_N = res >> 24;
427 DREGu32((Opcode >> 0) & 7) = res;
428RET(16)
429}
430
431// ORI
432OPCODE(0x0090)
433{
434 u32 adr, res;
435 u32 src, dst;
436
437 FETCH_LONG(src);
438 adr = AREG((Opcode >> 0) & 7);
439 PRE_IO
440 READ_LONG_F(adr, res)
441 res |= src;
442 flag_C = 0;
443 flag_V = 0;
444 flag_NotZ = res;
445 flag_N = res >> 24;
446 WRITE_LONG_F(adr, res)
447 POST_IO
448RET(28)
449}
450
451// ORI
452OPCODE(0x0098)
453{
454 u32 adr, res;
455 u32 src, dst;
456
457 FETCH_LONG(src);
458 adr = AREG((Opcode >> 0) & 7);
459 AREG((Opcode >> 0) & 7) += 4;
460 PRE_IO
461 READ_LONG_F(adr, res)
462 res |= src;
463 flag_C = 0;
464 flag_V = 0;
465 flag_NotZ = res;
466 flag_N = res >> 24;
467 WRITE_LONG_F(adr, res)
468 POST_IO
469RET(28)
470}
471
472// ORI
473OPCODE(0x00A0)
474{
475 u32 adr, res;
476 u32 src, dst;
477
478 FETCH_LONG(src);
479 adr = AREG((Opcode >> 0) & 7) - 4;
480 AREG((Opcode >> 0) & 7) = adr;
481 PRE_IO
482 READ_LONG_F(adr, res)
483 res |= src;
484 flag_C = 0;
485 flag_V = 0;
486 flag_NotZ = res;
487 flag_N = res >> 24;
488 WRITE_LONG_F(adr, res)
489 POST_IO
490RET(30)
491}
492
493// ORI
494OPCODE(0x00A8)
495{
496 u32 adr, res;
497 u32 src, dst;
498
499 FETCH_LONG(src);
500 FETCH_SWORD(adr);
501 adr += AREG((Opcode >> 0) & 7);
502 PRE_IO
503 READ_LONG_F(adr, res)
504 res |= src;
505 flag_C = 0;
506 flag_V = 0;
507 flag_NotZ = res;
508 flag_N = res >> 24;
509 WRITE_LONG_F(adr, res)
510 POST_IO
511RET(32)
512}
513
514// ORI
515OPCODE(0x00B0)
516{
517 u32 adr, res;
518 u32 src, dst;
519
520 FETCH_LONG(src);
521 adr = AREG((Opcode >> 0) & 7);
522 DECODE_EXT_WORD
523 PRE_IO
524 READ_LONG_F(adr, res)
525 res |= src;
526 flag_C = 0;
527 flag_V = 0;
528 flag_NotZ = res;
529 flag_N = res >> 24;
530 WRITE_LONG_F(adr, res)
531 POST_IO
532RET(34)
533}
534
535// ORI
536OPCODE(0x00B8)
537{
538 u32 adr, res;
539 u32 src, dst;
540
541 FETCH_LONG(src);
542 FETCH_SWORD(adr);
543 PRE_IO
544 READ_LONG_F(adr, res)
545 res |= src;
546 flag_C = 0;
547 flag_V = 0;
548 flag_NotZ = res;
549 flag_N = res >> 24;
550 WRITE_LONG_F(adr, res)
551 POST_IO
552RET(32)
553}
554
555// ORI
556OPCODE(0x00B9)
557{
558 u32 adr, res;
559 u32 src, dst;
560
561 FETCH_LONG(src);
562 FETCH_LONG(adr);
563 PRE_IO
564 READ_LONG_F(adr, res)
565 res |= src;
566 flag_C = 0;
567 flag_V = 0;
568 flag_NotZ = res;
569 flag_N = res >> 24;
570 WRITE_LONG_F(adr, res)
571 POST_IO
572RET(36)
573}
574
575// ORI
576OPCODE(0x009F)
577{
578 u32 adr, res;
579 u32 src, dst;
580
581 FETCH_LONG(src);
582 adr = AREG(7);
583 AREG(7) += 4;
584 PRE_IO
585 READ_LONG_F(adr, res)
586 res |= src;
587 flag_C = 0;
588 flag_V = 0;
589 flag_NotZ = res;
590 flag_N = res >> 24;
591 WRITE_LONG_F(adr, res)
592 POST_IO
593RET(28)
594}
595
596// ORI
597OPCODE(0x00A7)
598{
599 u32 adr, res;
600 u32 src, dst;
601
602 FETCH_LONG(src);
603 adr = AREG(7) - 4;
604 AREG(7) = adr;
605 PRE_IO
606 READ_LONG_F(adr, res)
607 res |= src;
608 flag_C = 0;
609 flag_V = 0;
610 flag_NotZ = res;
611 flag_N = res >> 24;
612 WRITE_LONG_F(adr, res)
613 POST_IO
614RET(30)
615}
616
617// ORICCR
618OPCODE(0x003C)
619{
620 u32 adr, res;
621 u32 src, dst;
622
623 FETCH_BYTE(res);
624 res &= M68K_CCR_MASK;
625 res |= GET_CCR;
626 SET_CCR(res)
627RET(20)
628}
629
630// ORISR
631OPCODE(0x007C)
632{
633 u32 adr, res;
634 u32 src, dst;
635
636 if (flag_S)
637 {
638 u32 res;
639 FETCH_WORD(res);
640 res &= M68K_SR_MASK;
641 res |= GET_SR;
642 SET_SR(res)
643 CHECK_INT_TO_JUMP(20)
644 }
645 else
646 {
647 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
648#ifdef USE_CYCLONE_TIMING
649 RET(0)
650#else
651 RET(4)
652#endif
653 }
654RET(20)
655}
656
657// ANDI
658OPCODE(0x0200)
659{
660 u32 adr, res;
661 u32 src, dst;
662
663 FETCH_BYTE(src);
664 res = DREGu8((Opcode >> 0) & 7);
665 res &= src;
666 flag_C = 0;
667 flag_V = 0;
668 flag_NotZ = res;
669 flag_N = res;
670 DREGu8((Opcode >> 0) & 7) = res;
671RET(8)
672}
673
674// ANDI
675OPCODE(0x0210)
676{
677 u32 adr, res;
678 u32 src, dst;
679
680 FETCH_BYTE(src);
681 adr = AREG((Opcode >> 0) & 7);
682 PRE_IO
683 READ_BYTE_F(adr, res)
684 res &= src;
685 flag_C = 0;
686 flag_V = 0;
687 flag_NotZ = res;
688 flag_N = res;
689 WRITE_BYTE_F(adr, res)
690 POST_IO
691RET(16)
692}
693
694// ANDI
695OPCODE(0x0218)
696{
697 u32 adr, res;
698 u32 src, dst;
699
700 FETCH_BYTE(src);
701 adr = AREG((Opcode >> 0) & 7);
702 AREG((Opcode >> 0) & 7) += 1;
703 PRE_IO
704 READ_BYTE_F(adr, res)
705 res &= src;
706 flag_C = 0;
707 flag_V = 0;
708 flag_NotZ = res;
709 flag_N = res;
710 WRITE_BYTE_F(adr, res)
711 POST_IO
712RET(16)
713}
714
715// ANDI
716OPCODE(0x0220)
717{
718 u32 adr, res;
719 u32 src, dst;
720
721 FETCH_BYTE(src);
722 adr = AREG((Opcode >> 0) & 7) - 1;
723 AREG((Opcode >> 0) & 7) = adr;
724 PRE_IO
725 READ_BYTE_F(adr, res)
726 res &= src;
727 flag_C = 0;
728 flag_V = 0;
729 flag_NotZ = res;
730 flag_N = res;
731 WRITE_BYTE_F(adr, res)
732 POST_IO
733RET(18)
734}
735
736// ANDI
737OPCODE(0x0228)
738{
739 u32 adr, res;
740 u32 src, dst;
741
742 FETCH_BYTE(src);
743 FETCH_SWORD(adr);
744 adr += AREG((Opcode >> 0) & 7);
745 PRE_IO
746 READ_BYTE_F(adr, res)
747 res &= src;
748 flag_C = 0;
749 flag_V = 0;
750 flag_NotZ = res;
751 flag_N = res;
752 WRITE_BYTE_F(adr, res)
753 POST_IO
754RET(20)
755}
756
757// ANDI
758OPCODE(0x0230)
759{
760 u32 adr, res;
761 u32 src, dst;
762
763 FETCH_BYTE(src);
764 adr = AREG((Opcode >> 0) & 7);
765 DECODE_EXT_WORD
766 PRE_IO
767 READ_BYTE_F(adr, res)
768 res &= src;
769 flag_C = 0;
770 flag_V = 0;
771 flag_NotZ = res;
772 flag_N = res;
773 WRITE_BYTE_F(adr, res)
774 POST_IO
775RET(22)
776}
777
778// ANDI
779OPCODE(0x0238)
780{
781 u32 adr, res;
782 u32 src, dst;
783
784 FETCH_BYTE(src);
785 FETCH_SWORD(adr);
786 PRE_IO
787 READ_BYTE_F(adr, res)
788 res &= src;
789 flag_C = 0;
790 flag_V = 0;
791 flag_NotZ = res;
792 flag_N = res;
793 WRITE_BYTE_F(adr, res)
794 POST_IO
795RET(20)
796}
797
798// ANDI
799OPCODE(0x0239)
800{
801 u32 adr, res;
802 u32 src, dst;
803
804 FETCH_BYTE(src);
805 FETCH_LONG(adr);
806 PRE_IO
807 READ_BYTE_F(adr, res)
808 res &= src;
809 flag_C = 0;
810 flag_V = 0;
811 flag_NotZ = res;
812 flag_N = res;
813 WRITE_BYTE_F(adr, res)
814 POST_IO
815RET(24)
816}
817
818// ANDI
819OPCODE(0x021F)
820{
821 u32 adr, res;
822 u32 src, dst;
823
824 FETCH_BYTE(src);
825 adr = AREG(7);
826 AREG(7) += 2;
827 PRE_IO
828 READ_BYTE_F(adr, res)
829 res &= src;
830 flag_C = 0;
831 flag_V = 0;
832 flag_NotZ = res;
833 flag_N = res;
834 WRITE_BYTE_F(adr, res)
835 POST_IO
836RET(16)
837}
838
839// ANDI
840OPCODE(0x0227)
841{
842 u32 adr, res;
843 u32 src, dst;
844
845 FETCH_BYTE(src);
846 adr = AREG(7) - 2;
847 AREG(7) = adr;
848 PRE_IO
849 READ_BYTE_F(adr, res)
850 res &= src;
851 flag_C = 0;
852 flag_V = 0;
853 flag_NotZ = res;
854 flag_N = res;
855 WRITE_BYTE_F(adr, res)
856 POST_IO
857RET(18)
858}
859
860// ANDI
861OPCODE(0x0240)
862{
863 u32 adr, res;
864 u32 src, dst;
865
866 FETCH_WORD(src);
867 res = DREGu16((Opcode >> 0) & 7);
868 res &= src;
869 flag_C = 0;
870 flag_V = 0;
871 flag_NotZ = res;
872 flag_N = res >> 8;
873 DREGu16((Opcode >> 0) & 7) = res;
874RET(8)
875}
876
877// ANDI
878OPCODE(0x0250)
879{
880 u32 adr, res;
881 u32 src, dst;
882
883 FETCH_WORD(src);
884 adr = AREG((Opcode >> 0) & 7);
885 PRE_IO
886 READ_WORD_F(adr, res)
887 res &= src;
888 flag_C = 0;
889 flag_V = 0;
890 flag_NotZ = res;
891 flag_N = res >> 8;
892 WRITE_WORD_F(adr, res)
893 POST_IO
894RET(16)
895}
896
897// ANDI
898OPCODE(0x0258)
899{
900 u32 adr, res;
901 u32 src, dst;
902
903 FETCH_WORD(src);
904 adr = AREG((Opcode >> 0) & 7);
905 AREG((Opcode >> 0) & 7) += 2;
906 PRE_IO
907 READ_WORD_F(adr, res)
908 res &= src;
909 flag_C = 0;
910 flag_V = 0;
911 flag_NotZ = res;
912 flag_N = res >> 8;
913 WRITE_WORD_F(adr, res)
914 POST_IO
915RET(16)
916}
917
918// ANDI
919OPCODE(0x0260)
920{
921 u32 adr, res;
922 u32 src, dst;
923
924 FETCH_WORD(src);
925 adr = AREG((Opcode >> 0) & 7) - 2;
926 AREG((Opcode >> 0) & 7) = adr;
927 PRE_IO
928 READ_WORD_F(adr, res)
929 res &= src;
930 flag_C = 0;
931 flag_V = 0;
932 flag_NotZ = res;
933 flag_N = res >> 8;
934 WRITE_WORD_F(adr, res)
935 POST_IO
936RET(18)
937}
938
939// ANDI
940OPCODE(0x0268)
941{
942 u32 adr, res;
943 u32 src, dst;
944
945 FETCH_WORD(src);
946 FETCH_SWORD(adr);
947 adr += AREG((Opcode >> 0) & 7);
948 PRE_IO
949 READ_WORD_F(adr, res)
950 res &= src;
951 flag_C = 0;
952 flag_V = 0;
953 flag_NotZ = res;
954 flag_N = res >> 8;
955 WRITE_WORD_F(adr, res)
956 POST_IO
957RET(20)
958}
959
960// ANDI
961OPCODE(0x0270)
962{
963 u32 adr, res;
964 u32 src, dst;
965
966 FETCH_WORD(src);
967 adr = AREG((Opcode >> 0) & 7);
968 DECODE_EXT_WORD
969 PRE_IO
970 READ_WORD_F(adr, res)
971 res &= src;
972 flag_C = 0;
973 flag_V = 0;
974 flag_NotZ = res;
975 flag_N = res >> 8;
976 WRITE_WORD_F(adr, res)
977 POST_IO
978RET(22)
979}
980
981// ANDI
982OPCODE(0x0278)
983{
984 u32 adr, res;
985 u32 src, dst;
986
987 FETCH_WORD(src);
988 FETCH_SWORD(adr);
989 PRE_IO
990 READ_WORD_F(adr, res)
991 res &= src;
992 flag_C = 0;
993 flag_V = 0;
994 flag_NotZ = res;
995 flag_N = res >> 8;
996 WRITE_WORD_F(adr, res)
997 POST_IO
998RET(20)
999}
1000
1001// ANDI
1002OPCODE(0x0279)
1003{
1004 u32 adr, res;
1005 u32 src, dst;
1006
1007 FETCH_WORD(src);
1008 FETCH_LONG(adr);
1009 PRE_IO
1010 READ_WORD_F(adr, res)
1011 res &= src;
1012 flag_C = 0;
1013 flag_V = 0;
1014 flag_NotZ = res;
1015 flag_N = res >> 8;
1016 WRITE_WORD_F(adr, res)
1017 POST_IO
1018RET(24)
1019}
1020
1021// ANDI
1022OPCODE(0x025F)
1023{
1024 u32 adr, res;
1025 u32 src, dst;
1026
1027 FETCH_WORD(src);
1028 adr = AREG(7);
1029 AREG(7) += 2;
1030 PRE_IO
1031 READ_WORD_F(adr, res)
1032 res &= src;
1033 flag_C = 0;
1034 flag_V = 0;
1035 flag_NotZ = res;
1036 flag_N = res >> 8;
1037 WRITE_WORD_F(adr, res)
1038 POST_IO
1039RET(16)
1040}
1041
1042// ANDI
1043OPCODE(0x0267)
1044{
1045 u32 adr, res;
1046 u32 src, dst;
1047
1048 FETCH_WORD(src);
1049 adr = AREG(7) - 2;
1050 AREG(7) = adr;
1051 PRE_IO
1052 READ_WORD_F(adr, res)
1053 res &= src;
1054 flag_C = 0;
1055 flag_V = 0;
1056 flag_NotZ = res;
1057 flag_N = res >> 8;
1058 WRITE_WORD_F(adr, res)
1059 POST_IO
1060RET(18)
1061}
1062
1063// ANDI
1064OPCODE(0x0280)
1065{
1066 u32 adr, res;
1067 u32 src, dst;
1068
1069 FETCH_LONG(src);
1070 res = DREGu32((Opcode >> 0) & 7);
1071 res &= src;
1072 flag_C = 0;
1073 flag_V = 0;
1074 flag_NotZ = res;
1075 flag_N = res >> 24;
1076 DREGu32((Opcode >> 0) & 7) = res;
1077RET(16)
1078}
1079
1080// ANDI
1081OPCODE(0x0290)
1082{
1083 u32 adr, res;
1084 u32 src, dst;
1085
1086 FETCH_LONG(src);
1087 adr = AREG((Opcode >> 0) & 7);
1088 PRE_IO
1089 READ_LONG_F(adr, res)
1090 res &= src;
1091 flag_C = 0;
1092 flag_V = 0;
1093 flag_NotZ = res;
1094 flag_N = res >> 24;
1095 WRITE_LONG_F(adr, res)
1096 POST_IO
1097RET(28)
1098}
1099
1100// ANDI
1101OPCODE(0x0298)
1102{
1103 u32 adr, res;
1104 u32 src, dst;
1105
1106 FETCH_LONG(src);
1107 adr = AREG((Opcode >> 0) & 7);
1108 AREG((Opcode >> 0) & 7) += 4;
1109 PRE_IO
1110 READ_LONG_F(adr, res)
1111 res &= src;
1112 flag_C = 0;
1113 flag_V = 0;
1114 flag_NotZ = res;
1115 flag_N = res >> 24;
1116 WRITE_LONG_F(adr, res)
1117 POST_IO
1118RET(28)
1119}
1120
1121// ANDI
1122OPCODE(0x02A0)
1123{
1124 u32 adr, res;
1125 u32 src, dst;
1126
1127 FETCH_LONG(src);
1128 adr = AREG((Opcode >> 0) & 7) - 4;
1129 AREG((Opcode >> 0) & 7) = adr;
1130 PRE_IO
1131 READ_LONG_F(adr, res)
1132 res &= src;
1133 flag_C = 0;
1134 flag_V = 0;
1135 flag_NotZ = res;
1136 flag_N = res >> 24;
1137 WRITE_LONG_F(adr, res)
1138 POST_IO
1139RET(30)
1140}
1141
1142// ANDI
1143OPCODE(0x02A8)
1144{
1145 u32 adr, res;
1146 u32 src, dst;
1147
1148 FETCH_LONG(src);
1149 FETCH_SWORD(adr);
1150 adr += AREG((Opcode >> 0) & 7);
1151 PRE_IO
1152 READ_LONG_F(adr, res)
1153 res &= src;
1154 flag_C = 0;
1155 flag_V = 0;
1156 flag_NotZ = res;
1157 flag_N = res >> 24;
1158 WRITE_LONG_F(adr, res)
1159 POST_IO
1160RET(32)
1161}
1162
1163// ANDI
1164OPCODE(0x02B0)
1165{
1166 u32 adr, res;
1167 u32 src, dst;
1168
1169 FETCH_LONG(src);
1170 adr = AREG((Opcode >> 0) & 7);
1171 DECODE_EXT_WORD
1172 PRE_IO
1173 READ_LONG_F(adr, res)
1174 res &= src;
1175 flag_C = 0;
1176 flag_V = 0;
1177 flag_NotZ = res;
1178 flag_N = res >> 24;
1179 WRITE_LONG_F(adr, res)
1180 POST_IO
1181RET(34)
1182}
1183
1184// ANDI
1185OPCODE(0x02B8)
1186{
1187 u32 adr, res;
1188 u32 src, dst;
1189
1190 FETCH_LONG(src);
1191 FETCH_SWORD(adr);
1192 PRE_IO
1193 READ_LONG_F(adr, res)
1194 res &= src;
1195 flag_C = 0;
1196 flag_V = 0;
1197 flag_NotZ = res;
1198 flag_N = res >> 24;
1199 WRITE_LONG_F(adr, res)
1200 POST_IO
1201RET(32)
1202}
1203
1204// ANDI
1205OPCODE(0x02B9)
1206{
1207 u32 adr, res;
1208 u32 src, dst;
1209
1210 FETCH_LONG(src);
1211 FETCH_LONG(adr);
1212 PRE_IO
1213 READ_LONG_F(adr, res)
1214 res &= src;
1215 flag_C = 0;
1216 flag_V = 0;
1217 flag_NotZ = res;
1218 flag_N = res >> 24;
1219 WRITE_LONG_F(adr, res)
1220 POST_IO
1221RET(36)
1222}
1223
1224// ANDI
1225OPCODE(0x029F)
1226{
1227 u32 adr, res;
1228 u32 src, dst;
1229
1230 FETCH_LONG(src);
1231 adr = AREG(7);
1232 AREG(7) += 4;
1233 PRE_IO
1234 READ_LONG_F(adr, res)
1235 res &= src;
1236 flag_C = 0;
1237 flag_V = 0;
1238 flag_NotZ = res;
1239 flag_N = res >> 24;
1240 WRITE_LONG_F(adr, res)
1241 POST_IO
1242RET(28)
1243}
1244
1245// ANDI
1246OPCODE(0x02A7)
1247{
1248 u32 adr, res;
1249 u32 src, dst;
1250
1251 FETCH_LONG(src);
1252 adr = AREG(7) - 4;
1253 AREG(7) = adr;
1254 PRE_IO
1255 READ_LONG_F(adr, res)
1256 res &= src;
1257 flag_C = 0;
1258 flag_V = 0;
1259 flag_NotZ = res;
1260 flag_N = res >> 24;
1261 WRITE_LONG_F(adr, res)
1262 POST_IO
1263RET(30)
1264}
1265
1266// ANDICCR
1267OPCODE(0x023C)
1268{
1269 u32 adr, res;
1270 u32 src, dst;
1271
1272 FETCH_BYTE(res);
1273 res &= M68K_CCR_MASK;
1274 res &= GET_CCR;
1275 SET_CCR(res)
1276RET(20)
1277}
1278
1279// ANDISR
1280OPCODE(0x027C)
1281{
1282 u32 adr, res;
1283 u32 src, dst;
1284
1285 if (flag_S)
1286 {
1287 FETCH_WORD(res);
1288 res &= M68K_SR_MASK;
1289 res &= GET_SR;
1290 SET_SR(res)
1291 if (!flag_S)
1292 {
1293 res = AREG(7);
1294 AREG(7) = ASP;
1295 ASP = res;
1296 }
1297 CHECK_INT_TO_JUMP(20)
1298 }
1299 else
1300 {
1301 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
1302#ifdef USE_CYCLONE_TIMING
1303 RET(0)
1304#else
1305 RET(4)
1306#endif
1307 }
1308RET(20)
1309}
1310
1311// EORI
1312OPCODE(0x0A00)
1313{
1314 u32 adr, res;
1315 u32 src, dst;
1316
1317 FETCH_BYTE(src);
1318 res = DREGu8((Opcode >> 0) & 7);
1319 res ^= src;
1320 flag_C = 0;
1321 flag_V = 0;
1322 flag_NotZ = res;
1323 flag_N = res;
1324 DREGu8((Opcode >> 0) & 7) = res;
1325RET(8)
1326}
1327
1328// EORI
1329OPCODE(0x0A10)
1330{
1331 u32 adr, res;
1332 u32 src, dst;
1333
1334 FETCH_BYTE(src);
1335 adr = AREG((Opcode >> 0) & 7);
1336 PRE_IO
1337 READ_BYTE_F(adr, res)
1338 res ^= src;
1339 flag_C = 0;
1340 flag_V = 0;
1341 flag_NotZ = res;
1342 flag_N = res;
1343 WRITE_BYTE_F(adr, res)
1344 POST_IO
1345RET(16)
1346}
1347
1348// EORI
1349OPCODE(0x0A18)
1350{
1351 u32 adr, res;
1352 u32 src, dst;
1353
1354 FETCH_BYTE(src);
1355 adr = AREG((Opcode >> 0) & 7);
1356 AREG((Opcode >> 0) & 7) += 1;
1357 PRE_IO
1358 READ_BYTE_F(adr, res)
1359 res ^= src;
1360 flag_C = 0;
1361 flag_V = 0;
1362 flag_NotZ = res;
1363 flag_N = res;
1364 WRITE_BYTE_F(adr, res)
1365 POST_IO
1366RET(16)
1367}
1368
1369// EORI
1370OPCODE(0x0A20)
1371{
1372 u32 adr, res;
1373 u32 src, dst;
1374
1375 FETCH_BYTE(src);
1376 adr = AREG((Opcode >> 0) & 7) - 1;
1377 AREG((Opcode >> 0) & 7) = adr;
1378 PRE_IO
1379 READ_BYTE_F(adr, res)
1380 res ^= src;
1381 flag_C = 0;
1382 flag_V = 0;
1383 flag_NotZ = res;
1384 flag_N = res;
1385 WRITE_BYTE_F(adr, res)
1386 POST_IO
1387RET(18)
1388}
1389
1390// EORI
1391OPCODE(0x0A28)
1392{
1393 u32 adr, res;
1394 u32 src, dst;
1395
1396 FETCH_BYTE(src);
1397 FETCH_SWORD(adr);
1398 adr += AREG((Opcode >> 0) & 7);
1399 PRE_IO
1400 READ_BYTE_F(adr, res)
1401 res ^= src;
1402 flag_C = 0;
1403 flag_V = 0;
1404 flag_NotZ = res;
1405 flag_N = res;
1406 WRITE_BYTE_F(adr, res)
1407 POST_IO
1408RET(20)
1409}
1410
1411// EORI
1412OPCODE(0x0A30)
1413{
1414 u32 adr, res;
1415 u32 src, dst;
1416
1417 FETCH_BYTE(src);
1418 adr = AREG((Opcode >> 0) & 7);
1419 DECODE_EXT_WORD
1420 PRE_IO
1421 READ_BYTE_F(adr, res)
1422 res ^= src;
1423 flag_C = 0;
1424 flag_V = 0;
1425 flag_NotZ = res;
1426 flag_N = res;
1427 WRITE_BYTE_F(adr, res)
1428 POST_IO
1429RET(22)
1430}
1431
1432// EORI
1433OPCODE(0x0A38)
1434{
1435 u32 adr, res;
1436 u32 src, dst;
1437
1438 FETCH_BYTE(src);
1439 FETCH_SWORD(adr);
1440 PRE_IO
1441 READ_BYTE_F(adr, res)
1442 res ^= src;
1443 flag_C = 0;
1444 flag_V = 0;
1445 flag_NotZ = res;
1446 flag_N = res;
1447 WRITE_BYTE_F(adr, res)
1448 POST_IO
1449RET(20)
1450}
1451
1452// EORI
1453OPCODE(0x0A39)
1454{
1455 u32 adr, res;
1456 u32 src, dst;
1457
1458 FETCH_BYTE(src);
1459 FETCH_LONG(adr);
1460 PRE_IO
1461 READ_BYTE_F(adr, res)
1462 res ^= src;
1463 flag_C = 0;
1464 flag_V = 0;
1465 flag_NotZ = res;
1466 flag_N = res;
1467 WRITE_BYTE_F(adr, res)
1468 POST_IO
1469RET(24)
1470}
1471
1472// EORI
1473OPCODE(0x0A1F)
1474{
1475 u32 adr, res;
1476 u32 src, dst;
1477
1478 FETCH_BYTE(src);
1479 adr = AREG(7);
1480 AREG(7) += 2;
1481 PRE_IO
1482 READ_BYTE_F(adr, res)
1483 res ^= src;
1484 flag_C = 0;
1485 flag_V = 0;
1486 flag_NotZ = res;
1487 flag_N = res;
1488 WRITE_BYTE_F(adr, res)
1489 POST_IO
1490RET(16)
1491}
1492
1493// EORI
1494OPCODE(0x0A27)
1495{
1496 u32 adr, res;
1497 u32 src, dst;
1498
1499 FETCH_BYTE(src);
1500 adr = AREG(7) - 2;
1501 AREG(7) = adr;
1502 PRE_IO
1503 READ_BYTE_F(adr, res)
1504 res ^= src;
1505 flag_C = 0;
1506 flag_V = 0;
1507 flag_NotZ = res;
1508 flag_N = res;
1509 WRITE_BYTE_F(adr, res)
1510 POST_IO
1511RET(18)
1512}
1513
1514// EORI
1515OPCODE(0x0A40)
1516{
1517 u32 adr, res;
1518 u32 src, dst;
1519
1520 FETCH_WORD(src);
1521 res = DREGu16((Opcode >> 0) & 7);
1522 res ^= src;
1523 flag_C = 0;
1524 flag_V = 0;
1525 flag_NotZ = res;
1526 flag_N = res >> 8;
1527 DREGu16((Opcode >> 0) & 7) = res;
1528RET(8)
1529}
1530
1531// EORI
1532OPCODE(0x0A50)
1533{
1534 u32 adr, res;
1535 u32 src, dst;
1536
1537 FETCH_WORD(src);
1538 adr = AREG((Opcode >> 0) & 7);
1539 PRE_IO
1540 READ_WORD_F(adr, res)
1541 res ^= src;
1542 flag_C = 0;
1543 flag_V = 0;
1544 flag_NotZ = res;
1545 flag_N = res >> 8;
1546 WRITE_WORD_F(adr, res)
1547 POST_IO
1548RET(16)
1549}
1550
1551// EORI
1552OPCODE(0x0A58)
1553{
1554 u32 adr, res;
1555 u32 src, dst;
1556
1557 FETCH_WORD(src);
1558 adr = AREG((Opcode >> 0) & 7);
1559 AREG((Opcode >> 0) & 7) += 2;
1560 PRE_IO
1561 READ_WORD_F(adr, res)
1562 res ^= src;
1563 flag_C = 0;
1564 flag_V = 0;
1565 flag_NotZ = res;
1566 flag_N = res >> 8;
1567 WRITE_WORD_F(adr, res)
1568 POST_IO
1569RET(16)
1570}
1571
1572// EORI
1573OPCODE(0x0A60)
1574{
1575 u32 adr, res;
1576 u32 src, dst;
1577
1578 FETCH_WORD(src);
1579 adr = AREG((Opcode >> 0) & 7) - 2;
1580 AREG((Opcode >> 0) & 7) = adr;
1581 PRE_IO
1582 READ_WORD_F(adr, res)
1583 res ^= src;
1584 flag_C = 0;
1585 flag_V = 0;
1586 flag_NotZ = res;
1587 flag_N = res >> 8;
1588 WRITE_WORD_F(adr, res)
1589 POST_IO
1590RET(18)
1591}
1592
1593// EORI
1594OPCODE(0x0A68)
1595{
1596 u32 adr, res;
1597 u32 src, dst;
1598
1599 FETCH_WORD(src);
1600 FETCH_SWORD(adr);
1601 adr += AREG((Opcode >> 0) & 7);
1602 PRE_IO
1603 READ_WORD_F(adr, res)
1604 res ^= src;
1605 flag_C = 0;
1606 flag_V = 0;
1607 flag_NotZ = res;
1608 flag_N = res >> 8;
1609 WRITE_WORD_F(adr, res)
1610 POST_IO
1611RET(20)
1612}
1613
1614// EORI
1615OPCODE(0x0A70)
1616{
1617 u32 adr, res;
1618 u32 src, dst;
1619
1620 FETCH_WORD(src);
1621 adr = AREG((Opcode >> 0) & 7);
1622 DECODE_EXT_WORD
1623 PRE_IO
1624 READ_WORD_F(adr, res)
1625 res ^= src;
1626 flag_C = 0;
1627 flag_V = 0;
1628 flag_NotZ = res;
1629 flag_N = res >> 8;
1630 WRITE_WORD_F(adr, res)
1631 POST_IO
1632RET(22)
1633}
1634
1635// EORI
1636OPCODE(0x0A78)
1637{
1638 u32 adr, res;
1639 u32 src, dst;
1640
1641 FETCH_WORD(src);
1642 FETCH_SWORD(adr);
1643 PRE_IO
1644 READ_WORD_F(adr, res)
1645 res ^= src;
1646 flag_C = 0;
1647 flag_V = 0;
1648 flag_NotZ = res;
1649 flag_N = res >> 8;
1650 WRITE_WORD_F(adr, res)
1651 POST_IO
1652RET(20)
1653}
1654
1655// EORI
1656OPCODE(0x0A79)
1657{
1658 u32 adr, res;
1659 u32 src, dst;
1660
1661 FETCH_WORD(src);
1662 FETCH_LONG(adr);
1663 PRE_IO
1664 READ_WORD_F(adr, res)
1665 res ^= src;
1666 flag_C = 0;
1667 flag_V = 0;
1668 flag_NotZ = res;
1669 flag_N = res >> 8;
1670 WRITE_WORD_F(adr, res)
1671 POST_IO
1672RET(24)
1673}
1674
1675// EORI
1676OPCODE(0x0A5F)
1677{
1678 u32 adr, res;
1679 u32 src, dst;
1680
1681 FETCH_WORD(src);
1682 adr = AREG(7);
1683 AREG(7) += 2;
1684 PRE_IO
1685 READ_WORD_F(adr, res)
1686 res ^= src;
1687 flag_C = 0;
1688 flag_V = 0;
1689 flag_NotZ = res;
1690 flag_N = res >> 8;
1691 WRITE_WORD_F(adr, res)
1692 POST_IO
1693RET(16)
1694}
1695
1696// EORI
1697OPCODE(0x0A67)
1698{
1699 u32 adr, res;
1700 u32 src, dst;
1701
1702 FETCH_WORD(src);
1703 adr = AREG(7) - 2;
1704 AREG(7) = adr;
1705 PRE_IO
1706 READ_WORD_F(adr, res)
1707 res ^= src;
1708 flag_C = 0;
1709 flag_V = 0;
1710 flag_NotZ = res;
1711 flag_N = res >> 8;
1712 WRITE_WORD_F(adr, res)
1713 POST_IO
1714RET(18)
1715}
1716
1717// EORI
1718OPCODE(0x0A80)
1719{
1720 u32 adr, res;
1721 u32 src, dst;
1722
1723 FETCH_LONG(src);
1724 res = DREGu32((Opcode >> 0) & 7);
1725 res ^= src;
1726 flag_C = 0;
1727 flag_V = 0;
1728 flag_NotZ = res;
1729 flag_N = res >> 24;
1730 DREGu32((Opcode >> 0) & 7) = res;
1731RET(16)
1732}
1733
1734// EORI
1735OPCODE(0x0A90)
1736{
1737 u32 adr, res;
1738 u32 src, dst;
1739
1740 FETCH_LONG(src);
1741 adr = AREG((Opcode >> 0) & 7);
1742 PRE_IO
1743 READ_LONG_F(adr, res)
1744 res ^= src;
1745 flag_C = 0;
1746 flag_V = 0;
1747 flag_NotZ = res;
1748 flag_N = res >> 24;
1749 WRITE_LONG_F(adr, res)
1750 POST_IO
1751RET(28)
1752}
1753
1754// EORI
1755OPCODE(0x0A98)
1756{
1757 u32 adr, res;
1758 u32 src, dst;
1759
1760 FETCH_LONG(src);
1761 adr = AREG((Opcode >> 0) & 7);
1762 AREG((Opcode >> 0) & 7) += 4;
1763 PRE_IO
1764 READ_LONG_F(adr, res)
1765 res ^= src;
1766 flag_C = 0;
1767 flag_V = 0;
1768 flag_NotZ = res;
1769 flag_N = res >> 24;
1770 WRITE_LONG_F(adr, res)
1771 POST_IO
1772RET(28)
1773}
1774
1775// EORI
1776OPCODE(0x0AA0)
1777{
1778 u32 adr, res;
1779 u32 src, dst;
1780
1781 FETCH_LONG(src);
1782 adr = AREG((Opcode >> 0) & 7) - 4;
1783 AREG((Opcode >> 0) & 7) = adr;
1784 PRE_IO
1785 READ_LONG_F(adr, res)
1786 res ^= src;
1787 flag_C = 0;
1788 flag_V = 0;
1789 flag_NotZ = res;
1790 flag_N = res >> 24;
1791 WRITE_LONG_F(adr, res)
1792 POST_IO
1793RET(30)
1794}
1795
1796// EORI
1797OPCODE(0x0AA8)
1798{
1799 u32 adr, res;
1800 u32 src, dst;
1801
1802 FETCH_LONG(src);
1803 FETCH_SWORD(adr);
1804 adr += AREG((Opcode >> 0) & 7);
1805 PRE_IO
1806 READ_LONG_F(adr, res)
1807 res ^= src;
1808 flag_C = 0;
1809 flag_V = 0;
1810 flag_NotZ = res;
1811 flag_N = res >> 24;
1812 WRITE_LONG_F(adr, res)
1813 POST_IO
1814RET(32)
1815}
1816
1817// EORI
1818OPCODE(0x0AB0)
1819{
1820 u32 adr, res;
1821 u32 src, dst;
1822
1823 FETCH_LONG(src);
1824 adr = AREG((Opcode >> 0) & 7);
1825 DECODE_EXT_WORD
1826 PRE_IO
1827 READ_LONG_F(adr, res)
1828 res ^= src;
1829 flag_C = 0;
1830 flag_V = 0;
1831 flag_NotZ = res;
1832 flag_N = res >> 24;
1833 WRITE_LONG_F(adr, res)
1834 POST_IO
1835RET(34)
1836}
1837
1838// EORI
1839OPCODE(0x0AB8)
1840{
1841 u32 adr, res;
1842 u32 src, dst;
1843
1844 FETCH_LONG(src);
1845 FETCH_SWORD(adr);
1846 PRE_IO
1847 READ_LONG_F(adr, res)
1848 res ^= src;
1849 flag_C = 0;
1850 flag_V = 0;
1851 flag_NotZ = res;
1852 flag_N = res >> 24;
1853 WRITE_LONG_F(adr, res)
1854 POST_IO
1855RET(32)
1856}
1857
1858// EORI
1859OPCODE(0x0AB9)
1860{
1861 u32 adr, res;
1862 u32 src, dst;
1863
1864 FETCH_LONG(src);
1865 FETCH_LONG(adr);
1866 PRE_IO
1867 READ_LONG_F(adr, res)
1868 res ^= src;
1869 flag_C = 0;
1870 flag_V = 0;
1871 flag_NotZ = res;
1872 flag_N = res >> 24;
1873 WRITE_LONG_F(adr, res)
1874 POST_IO
1875RET(36)
1876}
1877
1878// EORI
1879OPCODE(0x0A9F)
1880{
1881 u32 adr, res;
1882 u32 src, dst;
1883
1884 FETCH_LONG(src);
1885 adr = AREG(7);
1886 AREG(7) += 4;
1887 PRE_IO
1888 READ_LONG_F(adr, res)
1889 res ^= src;
1890 flag_C = 0;
1891 flag_V = 0;
1892 flag_NotZ = res;
1893 flag_N = res >> 24;
1894 WRITE_LONG_F(adr, res)
1895 POST_IO
1896RET(28)
1897}
1898
1899// EORI
1900OPCODE(0x0AA7)
1901{
1902 u32 adr, res;
1903 u32 src, dst;
1904
1905 FETCH_LONG(src);
1906 adr = AREG(7) - 4;
1907 AREG(7) = adr;
1908 PRE_IO
1909 READ_LONG_F(adr, res)
1910 res ^= src;
1911 flag_C = 0;
1912 flag_V = 0;
1913 flag_NotZ = res;
1914 flag_N = res >> 24;
1915 WRITE_LONG_F(adr, res)
1916 POST_IO
1917RET(30)
1918}
1919
1920// EORICCR
1921OPCODE(0x0A3C)
1922{
1923 u32 adr, res;
1924 u32 src, dst;
1925
1926 FETCH_BYTE(res);
1927 res &= M68K_CCR_MASK;
1928 res ^= GET_CCR;
1929 SET_CCR(res)
1930RET(20)
1931}
1932
1933// EORISR
1934OPCODE(0x0A7C)
1935{
1936 u32 adr, res;
1937 u32 src, dst;
1938
1939 if (flag_S)
1940 {
1941 FETCH_WORD(res);
1942 res &= M68K_SR_MASK;
1943 res ^= GET_SR;
1944 SET_SR(res)
1945 if (!flag_S)
1946 {
1947 res = AREG(7);
1948 AREG(7) = ASP;
1949 ASP = res;
1950 }
1951 CHECK_INT_TO_JUMP(20)
1952 }
1953 else
1954 {
1955 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
1956#ifdef USE_CYCLONE_TIMING
1957 RET(0)
1958#else
1959 RET(4)
1960#endif
1961 }
1962RET(20)
1963}
1964
1965// SUBI
1966OPCODE(0x0400)
1967{
1968 u32 adr, res;
1969 u32 src, dst;
1970
1971 FETCH_BYTE(src);
1972 dst = DREGu8((Opcode >> 0) & 7);
1973 res = dst - src;
1974 flag_N = flag_X = flag_C = res;
1975 flag_V = (src ^ dst) & (res ^ dst);
1976 flag_NotZ = res & 0xFF;
1977 DREGu8((Opcode >> 0) & 7) = res;
1978RET(8)
1979}
1980
1981// SUBI
1982OPCODE(0x0410)
1983{
1984 u32 adr, res;
1985 u32 src, dst;
1986
1987 FETCH_BYTE(src);
1988 adr = AREG((Opcode >> 0) & 7);
1989 PRE_IO
1990 READ_BYTE_F(adr, dst)
1991 res = dst - src;
1992 flag_N = flag_X = flag_C = res;
1993 flag_V = (src ^ dst) & (res ^ dst);
1994 flag_NotZ = res & 0xFF;
1995 WRITE_BYTE_F(adr, res)
1996 POST_IO
1997RET(16)
1998}
1999
2000// SUBI
2001OPCODE(0x0418)
2002{
2003 u32 adr, res;
2004 u32 src, dst;
2005
2006 FETCH_BYTE(src);
2007 adr = AREG((Opcode >> 0) & 7);
2008 AREG((Opcode >> 0) & 7) += 1;
2009 PRE_IO
2010 READ_BYTE_F(adr, dst)
2011 res = dst - src;
2012 flag_N = flag_X = flag_C = res;
2013 flag_V = (src ^ dst) & (res ^ dst);
2014 flag_NotZ = res & 0xFF;
2015 WRITE_BYTE_F(adr, res)
2016 POST_IO
2017RET(16)
2018}
2019
2020// SUBI
2021OPCODE(0x0420)
2022{
2023 u32 adr, res;
2024 u32 src, dst;
2025
2026 FETCH_BYTE(src);
2027 adr = AREG((Opcode >> 0) & 7) - 1;
2028 AREG((Opcode >> 0) & 7) = adr;
2029 PRE_IO
2030 READ_BYTE_F(adr, dst)
2031 res = dst - src;
2032 flag_N = flag_X = flag_C = res;
2033 flag_V = (src ^ dst) & (res ^ dst);
2034 flag_NotZ = res & 0xFF;
2035 WRITE_BYTE_F(adr, res)
2036 POST_IO
2037RET(18)
2038}
2039
2040// SUBI
2041OPCODE(0x0428)
2042{
2043 u32 adr, res;
2044 u32 src, dst;
2045
2046 FETCH_BYTE(src);
2047 FETCH_SWORD(adr);
2048 adr += AREG((Opcode >> 0) & 7);
2049 PRE_IO
2050 READ_BYTE_F(adr, dst)
2051 res = dst - src;
2052 flag_N = flag_X = flag_C = res;
2053 flag_V = (src ^ dst) & (res ^ dst);
2054 flag_NotZ = res & 0xFF;
2055 WRITE_BYTE_F(adr, res)
2056 POST_IO
2057RET(20)
2058}
2059
2060// SUBI
2061OPCODE(0x0430)
2062{
2063 u32 adr, res;
2064 u32 src, dst;
2065
2066 FETCH_BYTE(src);
2067 adr = AREG((Opcode >> 0) & 7);
2068 DECODE_EXT_WORD
2069 PRE_IO
2070 READ_BYTE_F(adr, dst)
2071 res = dst - src;
2072 flag_N = flag_X = flag_C = res;
2073 flag_V = (src ^ dst) & (res ^ dst);
2074 flag_NotZ = res & 0xFF;
2075 WRITE_BYTE_F(adr, res)
2076 POST_IO
2077RET(22)
2078}
2079
2080// SUBI
2081OPCODE(0x0438)
2082{
2083 u32 adr, res;
2084 u32 src, dst;
2085
2086 FETCH_BYTE(src);
2087 FETCH_SWORD(adr);
2088 PRE_IO
2089 READ_BYTE_F(adr, dst)
2090 res = dst - src;
2091 flag_N = flag_X = flag_C = res;
2092 flag_V = (src ^ dst) & (res ^ dst);
2093 flag_NotZ = res & 0xFF;
2094 WRITE_BYTE_F(adr, res)
2095 POST_IO
2096RET(20)
2097}
2098
2099// SUBI
2100OPCODE(0x0439)
2101{
2102 u32 adr, res;
2103 u32 src, dst;
2104
2105 FETCH_BYTE(src);
2106 FETCH_LONG(adr);
2107 PRE_IO
2108 READ_BYTE_F(adr, dst)
2109 res = dst - src;
2110 flag_N = flag_X = flag_C = res;
2111 flag_V = (src ^ dst) & (res ^ dst);
2112 flag_NotZ = res & 0xFF;
2113 WRITE_BYTE_F(adr, res)
2114 POST_IO
2115RET(24)
2116}
2117
2118// SUBI
2119OPCODE(0x041F)
2120{
2121 u32 adr, res;
2122 u32 src, dst;
2123
2124 FETCH_BYTE(src);
2125 adr = AREG(7);
2126 AREG(7) += 2;
2127 PRE_IO
2128 READ_BYTE_F(adr, dst)
2129 res = dst - src;
2130 flag_N = flag_X = flag_C = res;
2131 flag_V = (src ^ dst) & (res ^ dst);
2132 flag_NotZ = res & 0xFF;
2133 WRITE_BYTE_F(adr, res)
2134 POST_IO
2135RET(16)
2136}
2137
2138// SUBI
2139OPCODE(0x0427)
2140{
2141 u32 adr, res;
2142 u32 src, dst;
2143
2144 FETCH_BYTE(src);
2145 adr = AREG(7) - 2;
2146 AREG(7) = adr;
2147 PRE_IO
2148 READ_BYTE_F(adr, dst)
2149 res = dst - src;
2150 flag_N = flag_X = flag_C = res;
2151 flag_V = (src ^ dst) & (res ^ dst);
2152 flag_NotZ = res & 0xFF;
2153 WRITE_BYTE_F(adr, res)
2154 POST_IO
2155RET(18)
2156}
2157
2158// SUBI
2159OPCODE(0x0440)
2160{
2161 u32 adr, res;
2162 u32 src, dst;
2163
2164 FETCH_WORD(src);
2165 dst = DREGu16((Opcode >> 0) & 7);
2166 res = dst - src;
2167 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2168 flag_N = flag_X = flag_C = res >> 8;
2169 flag_NotZ = res & 0xFFFF;
2170 DREGu16((Opcode >> 0) & 7) = res;
2171RET(8)
2172}
2173
2174// SUBI
2175OPCODE(0x0450)
2176{
2177 u32 adr, res;
2178 u32 src, dst;
2179
2180 FETCH_WORD(src);
2181 adr = AREG((Opcode >> 0) & 7);
2182 PRE_IO
2183 READ_WORD_F(adr, dst)
2184 res = dst - src;
2185 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2186 flag_N = flag_X = flag_C = res >> 8;
2187 flag_NotZ = res & 0xFFFF;
2188 WRITE_WORD_F(adr, res)
2189 POST_IO
2190RET(16)
2191}
2192
2193// SUBI
2194OPCODE(0x0458)
2195{
2196 u32 adr, res;
2197 u32 src, dst;
2198
2199 FETCH_WORD(src);
2200 adr = AREG((Opcode >> 0) & 7);
2201 AREG((Opcode >> 0) & 7) += 2;
2202 PRE_IO
2203 READ_WORD_F(adr, dst)
2204 res = dst - src;
2205 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2206 flag_N = flag_X = flag_C = res >> 8;
2207 flag_NotZ = res & 0xFFFF;
2208 WRITE_WORD_F(adr, res)
2209 POST_IO
2210RET(16)
2211}
2212
2213// SUBI
2214OPCODE(0x0460)
2215{
2216 u32 adr, res;
2217 u32 src, dst;
2218
2219 FETCH_WORD(src);
2220 adr = AREG((Opcode >> 0) & 7) - 2;
2221 AREG((Opcode >> 0) & 7) = adr;
2222 PRE_IO
2223 READ_WORD_F(adr, dst)
2224 res = dst - src;
2225 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2226 flag_N = flag_X = flag_C = res >> 8;
2227 flag_NotZ = res & 0xFFFF;
2228 WRITE_WORD_F(adr, res)
2229 POST_IO
2230RET(18)
2231}
2232
2233// SUBI
2234OPCODE(0x0468)
2235{
2236 u32 adr, res;
2237 u32 src, dst;
2238
2239 FETCH_WORD(src);
2240 FETCH_SWORD(adr);
2241 adr += AREG((Opcode >> 0) & 7);
2242 PRE_IO
2243 READ_WORD_F(adr, dst)
2244 res = dst - src;
2245 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2246 flag_N = flag_X = flag_C = res >> 8;
2247 flag_NotZ = res & 0xFFFF;
2248 WRITE_WORD_F(adr, res)
2249 POST_IO
2250RET(20)
2251}
2252
2253// SUBI
2254OPCODE(0x0470)
2255{
2256 u32 adr, res;
2257 u32 src, dst;
2258
2259 FETCH_WORD(src);
2260 adr = AREG((Opcode >> 0) & 7);
2261 DECODE_EXT_WORD
2262 PRE_IO
2263 READ_WORD_F(adr, dst)
2264 res = dst - src;
2265 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2266 flag_N = flag_X = flag_C = res >> 8;
2267 flag_NotZ = res & 0xFFFF;
2268 WRITE_WORD_F(adr, res)
2269 POST_IO
2270RET(22)
2271}
2272
2273// SUBI
2274OPCODE(0x0478)
2275{
2276 u32 adr, res;
2277 u32 src, dst;
2278
2279 FETCH_WORD(src);
2280 FETCH_SWORD(adr);
2281 PRE_IO
2282 READ_WORD_F(adr, dst)
2283 res = dst - src;
2284 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2285 flag_N = flag_X = flag_C = res >> 8;
2286 flag_NotZ = res & 0xFFFF;
2287 WRITE_WORD_F(adr, res)
2288 POST_IO
2289RET(20)
2290}
2291
2292// SUBI
2293OPCODE(0x0479)
2294{
2295 u32 adr, res;
2296 u32 src, dst;
2297
2298 FETCH_WORD(src);
2299 FETCH_LONG(adr);
2300 PRE_IO
2301 READ_WORD_F(adr, dst)
2302 res = dst - src;
2303 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2304 flag_N = flag_X = flag_C = res >> 8;
2305 flag_NotZ = res & 0xFFFF;
2306 WRITE_WORD_F(adr, res)
2307 POST_IO
2308RET(24)
2309}
2310
2311// SUBI
2312OPCODE(0x045F)
2313{
2314 u32 adr, res;
2315 u32 src, dst;
2316
2317 FETCH_WORD(src);
2318 adr = AREG(7);
2319 AREG(7) += 2;
2320 PRE_IO
2321 READ_WORD_F(adr, dst)
2322 res = dst - src;
2323 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2324 flag_N = flag_X = flag_C = res >> 8;
2325 flag_NotZ = res & 0xFFFF;
2326 WRITE_WORD_F(adr, res)
2327 POST_IO
2328RET(16)
2329}
2330
2331// SUBI
2332OPCODE(0x0467)
2333{
2334 u32 adr, res;
2335 u32 src, dst;
2336
2337 FETCH_WORD(src);
2338 adr = AREG(7) - 2;
2339 AREG(7) = adr;
2340 PRE_IO
2341 READ_WORD_F(adr, dst)
2342 res = dst - src;
2343 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2344 flag_N = flag_X = flag_C = res >> 8;
2345 flag_NotZ = res & 0xFFFF;
2346 WRITE_WORD_F(adr, res)
2347 POST_IO
2348RET(18)
2349}
2350
2351// SUBI
2352OPCODE(0x0480)
2353{
2354 u32 adr, res;
2355 u32 src, dst;
2356
2357 FETCH_LONG(src);
2358 dst = DREGu32((Opcode >> 0) & 7);
2359 res = dst - src;
2360 flag_NotZ = res;
2361 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2362 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2363 flag_N = res >> 24;
2364 DREGu32((Opcode >> 0) & 7) = res;
2365RET(16)
2366}
2367
2368// SUBI
2369OPCODE(0x0490)
2370{
2371 u32 adr, res;
2372 u32 src, dst;
2373
2374 FETCH_LONG(src);
2375 adr = AREG((Opcode >> 0) & 7);
2376 PRE_IO
2377 READ_LONG_F(adr, dst)
2378 res = dst - src;
2379 flag_NotZ = res;
2380 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2381 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2382 flag_N = res >> 24;
2383 WRITE_LONG_F(adr, res)
2384 POST_IO
2385RET(28)
2386}
2387
2388// SUBI
2389OPCODE(0x0498)
2390{
2391 u32 adr, res;
2392 u32 src, dst;
2393
2394 FETCH_LONG(src);
2395 adr = AREG((Opcode >> 0) & 7);
2396 AREG((Opcode >> 0) & 7) += 4;
2397 PRE_IO
2398 READ_LONG_F(adr, dst)
2399 res = dst - src;
2400 flag_NotZ = res;
2401 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2402 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2403 flag_N = res >> 24;
2404 WRITE_LONG_F(adr, res)
2405 POST_IO
2406RET(28)
2407}
2408
2409// SUBI
2410OPCODE(0x04A0)
2411{
2412 u32 adr, res;
2413 u32 src, dst;
2414
2415 FETCH_LONG(src);
2416 adr = AREG((Opcode >> 0) & 7) - 4;
2417 AREG((Opcode >> 0) & 7) = adr;
2418 PRE_IO
2419 READ_LONG_F(adr, dst)
2420 res = dst - src;
2421 flag_NotZ = res;
2422 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2423 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2424 flag_N = res >> 24;
2425 WRITE_LONG_F(adr, res)
2426 POST_IO
2427RET(30)
2428}
2429
2430// SUBI
2431OPCODE(0x04A8)
2432{
2433 u32 adr, res;
2434 u32 src, dst;
2435
2436 FETCH_LONG(src);
2437 FETCH_SWORD(adr);
2438 adr += AREG((Opcode >> 0) & 7);
2439 PRE_IO
2440 READ_LONG_F(adr, dst)
2441 res = dst - src;
2442 flag_NotZ = res;
2443 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2444 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2445 flag_N = res >> 24;
2446 WRITE_LONG_F(adr, res)
2447 POST_IO
2448RET(32)
2449}
2450
2451// SUBI
2452OPCODE(0x04B0)
2453{
2454 u32 adr, res;
2455 u32 src, dst;
2456
2457 FETCH_LONG(src);
2458 adr = AREG((Opcode >> 0) & 7);
2459 DECODE_EXT_WORD
2460 PRE_IO
2461 READ_LONG_F(adr, dst)
2462 res = dst - src;
2463 flag_NotZ = res;
2464 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2465 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2466 flag_N = res >> 24;
2467 WRITE_LONG_F(adr, res)
2468 POST_IO
2469RET(34)
2470}
2471
2472// SUBI
2473OPCODE(0x04B8)
2474{
2475 u32 adr, res;
2476 u32 src, dst;
2477
2478 FETCH_LONG(src);
2479 FETCH_SWORD(adr);
2480 PRE_IO
2481 READ_LONG_F(adr, dst)
2482 res = dst - src;
2483 flag_NotZ = res;
2484 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2485 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2486 flag_N = res >> 24;
2487 WRITE_LONG_F(adr, res)
2488 POST_IO
2489RET(32)
2490}
2491
2492// SUBI
2493OPCODE(0x04B9)
2494{
2495 u32 adr, res;
2496 u32 src, dst;
2497
2498 FETCH_LONG(src);
2499 FETCH_LONG(adr);
2500 PRE_IO
2501 READ_LONG_F(adr, dst)
2502 res = dst - src;
2503 flag_NotZ = res;
2504 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2505 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2506 flag_N = res >> 24;
2507 WRITE_LONG_F(adr, res)
2508 POST_IO
2509RET(36)
2510}
2511
2512// SUBI
2513OPCODE(0x049F)
2514{
2515 u32 adr, res;
2516 u32 src, dst;
2517
2518 FETCH_LONG(src);
2519 adr = AREG(7);
2520 AREG(7) += 4;
2521 PRE_IO
2522 READ_LONG_F(adr, dst)
2523 res = dst - src;
2524 flag_NotZ = res;
2525 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2526 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2527 flag_N = res >> 24;
2528 WRITE_LONG_F(adr, res)
2529 POST_IO
2530RET(28)
2531}
2532
2533// SUBI
2534OPCODE(0x04A7)
2535{
2536 u32 adr, res;
2537 u32 src, dst;
2538
2539 FETCH_LONG(src);
2540 adr = AREG(7) - 4;
2541 AREG(7) = adr;
2542 PRE_IO
2543 READ_LONG_F(adr, dst)
2544 res = dst - src;
2545 flag_NotZ = res;
2546 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2547 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2548 flag_N = res >> 24;
2549 WRITE_LONG_F(adr, res)
2550 POST_IO
2551RET(30)
2552}
2553
2554// ADDI
2555OPCODE(0x0600)
2556{
2557 u32 adr, res;
2558 u32 src, dst;
2559
2560 FETCH_BYTE(src);
2561 dst = DREGu8((Opcode >> 0) & 7);
2562 res = dst + src;
2563 flag_N = flag_X = flag_C = res;
2564 flag_V = (src ^ res) & (dst ^ res);
2565 flag_NotZ = res & 0xFF;
2566 DREGu8((Opcode >> 0) & 7) = res;
2567RET(8)
2568}
2569
2570// ADDI
2571OPCODE(0x0610)
2572{
2573 u32 adr, res;
2574 u32 src, dst;
2575
2576 FETCH_BYTE(src);
2577 adr = AREG((Opcode >> 0) & 7);
2578 PRE_IO
2579 READ_BYTE_F(adr, dst)
2580 res = dst + src;
2581 flag_N = flag_X = flag_C = res;
2582 flag_V = (src ^ res) & (dst ^ res);
2583 flag_NotZ = res & 0xFF;
2584 WRITE_BYTE_F(adr, res)
2585 POST_IO
2586RET(16)
2587}
2588
2589// ADDI
2590OPCODE(0x0618)
2591{
2592 u32 adr, res;
2593 u32 src, dst;
2594
2595 FETCH_BYTE(src);
2596 adr = AREG((Opcode >> 0) & 7);
2597 AREG((Opcode >> 0) & 7) += 1;
2598 PRE_IO
2599 READ_BYTE_F(adr, dst)
2600 res = dst + src;
2601 flag_N = flag_X = flag_C = res;
2602 flag_V = (src ^ res) & (dst ^ res);
2603 flag_NotZ = res & 0xFF;
2604 WRITE_BYTE_F(adr, res)
2605 POST_IO
2606RET(16)
2607}
2608
2609// ADDI
2610OPCODE(0x0620)
2611{
2612 u32 adr, res;
2613 u32 src, dst;
2614
2615 FETCH_BYTE(src);
2616 adr = AREG((Opcode >> 0) & 7) - 1;
2617 AREG((Opcode >> 0) & 7) = adr;
2618 PRE_IO
2619 READ_BYTE_F(adr, dst)
2620 res = dst + src;
2621 flag_N = flag_X = flag_C = res;
2622 flag_V = (src ^ res) & (dst ^ res);
2623 flag_NotZ = res & 0xFF;
2624 WRITE_BYTE_F(adr, res)
2625 POST_IO
2626RET(18)
2627}
2628
2629// ADDI
2630OPCODE(0x0628)
2631{
2632 u32 adr, res;
2633 u32 src, dst;
2634
2635 FETCH_BYTE(src);
2636 FETCH_SWORD(adr);
2637 adr += AREG((Opcode >> 0) & 7);
2638 PRE_IO
2639 READ_BYTE_F(adr, dst)
2640 res = dst + src;
2641 flag_N = flag_X = flag_C = res;
2642 flag_V = (src ^ res) & (dst ^ res);
2643 flag_NotZ = res & 0xFF;
2644 WRITE_BYTE_F(adr, res)
2645 POST_IO
2646RET(20)
2647}
2648
2649// ADDI
2650OPCODE(0x0630)
2651{
2652 u32 adr, res;
2653 u32 src, dst;
2654
2655 FETCH_BYTE(src);
2656 adr = AREG((Opcode >> 0) & 7);
2657 DECODE_EXT_WORD
2658 PRE_IO
2659 READ_BYTE_F(adr, dst)
2660 res = dst + src;
2661 flag_N = flag_X = flag_C = res;
2662 flag_V = (src ^ res) & (dst ^ res);
2663 flag_NotZ = res & 0xFF;
2664 WRITE_BYTE_F(adr, res)
2665 POST_IO
2666RET(22)
2667}
2668
2669// ADDI
2670OPCODE(0x0638)
2671{
2672 u32 adr, res;
2673 u32 src, dst;
2674
2675 FETCH_BYTE(src);
2676 FETCH_SWORD(adr);
2677 PRE_IO
2678 READ_BYTE_F(adr, dst)
2679 res = dst + src;
2680 flag_N = flag_X = flag_C = res;
2681 flag_V = (src ^ res) & (dst ^ res);
2682 flag_NotZ = res & 0xFF;
2683 WRITE_BYTE_F(adr, res)
2684 POST_IO
2685RET(20)
2686}
2687
2688// ADDI
2689OPCODE(0x0639)
2690{
2691 u32 adr, res;
2692 u32 src, dst;
2693
2694 FETCH_BYTE(src);
2695 FETCH_LONG(adr);
2696 PRE_IO
2697 READ_BYTE_F(adr, dst)
2698 res = dst + src;
2699 flag_N = flag_X = flag_C = res;
2700 flag_V = (src ^ res) & (dst ^ res);
2701 flag_NotZ = res & 0xFF;
2702 WRITE_BYTE_F(adr, res)
2703 POST_IO
2704RET(24)
2705}
2706
2707// ADDI
2708OPCODE(0x061F)
2709{
2710 u32 adr, res;
2711 u32 src, dst;
2712
2713 FETCH_BYTE(src);
2714 adr = AREG(7);
2715 AREG(7) += 2;
2716 PRE_IO
2717 READ_BYTE_F(adr, dst)
2718 res = dst + src;
2719 flag_N = flag_X = flag_C = res;
2720 flag_V = (src ^ res) & (dst ^ res);
2721 flag_NotZ = res & 0xFF;
2722 WRITE_BYTE_F(adr, res)
2723 POST_IO
2724RET(16)
2725}
2726
2727// ADDI
2728OPCODE(0x0627)
2729{
2730 u32 adr, res;
2731 u32 src, dst;
2732
2733 FETCH_BYTE(src);
2734 adr = AREG(7) - 2;
2735 AREG(7) = adr;
2736 PRE_IO
2737 READ_BYTE_F(adr, dst)
2738 res = dst + src;
2739 flag_N = flag_X = flag_C = res;
2740 flag_V = (src ^ res) & (dst ^ res);
2741 flag_NotZ = res & 0xFF;
2742 WRITE_BYTE_F(adr, res)
2743 POST_IO
2744RET(18)
2745}
2746
2747// ADDI
2748OPCODE(0x0640)
2749{
2750 u32 adr, res;
2751 u32 src, dst;
2752
2753 FETCH_WORD(src);
2754 dst = DREGu16((Opcode >> 0) & 7);
2755 res = dst + src;
2756 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2757 flag_N = flag_X = flag_C = res >> 8;
2758 flag_NotZ = res & 0xFFFF;
2759 DREGu16((Opcode >> 0) & 7) = res;
2760RET(8)
2761}
2762
2763// ADDI
2764OPCODE(0x0650)
2765{
2766 u32 adr, res;
2767 u32 src, dst;
2768
2769 FETCH_WORD(src);
2770 adr = AREG((Opcode >> 0) & 7);
2771 PRE_IO
2772 READ_WORD_F(adr, dst)
2773 res = dst + src;
2774 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2775 flag_N = flag_X = flag_C = res >> 8;
2776 flag_NotZ = res & 0xFFFF;
2777 WRITE_WORD_F(adr, res)
2778 POST_IO
2779RET(16)
2780}
2781
2782// ADDI
2783OPCODE(0x0658)
2784{
2785 u32 adr, res;
2786 u32 src, dst;
2787
2788 FETCH_WORD(src);
2789 adr = AREG((Opcode >> 0) & 7);
2790 AREG((Opcode >> 0) & 7) += 2;
2791 PRE_IO
2792 READ_WORD_F(adr, dst)
2793 res = dst + src;
2794 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2795 flag_N = flag_X = flag_C = res >> 8;
2796 flag_NotZ = res & 0xFFFF;
2797 WRITE_WORD_F(adr, res)
2798 POST_IO
2799RET(16)
2800}
2801
2802// ADDI
2803OPCODE(0x0660)
2804{
2805 u32 adr, res;
2806 u32 src, dst;
2807
2808 FETCH_WORD(src);
2809 adr = AREG((Opcode >> 0) & 7) - 2;
2810 AREG((Opcode >> 0) & 7) = adr;
2811 PRE_IO
2812 READ_WORD_F(adr, dst)
2813 res = dst + src;
2814 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2815 flag_N = flag_X = flag_C = res >> 8;
2816 flag_NotZ = res & 0xFFFF;
2817 WRITE_WORD_F(adr, res)
2818 POST_IO
2819RET(18)
2820}
2821
2822// ADDI
2823OPCODE(0x0668)
2824{
2825 u32 adr, res;
2826 u32 src, dst;
2827
2828 FETCH_WORD(src);
2829 FETCH_SWORD(adr);
2830 adr += AREG((Opcode >> 0) & 7);
2831 PRE_IO
2832 READ_WORD_F(adr, dst)
2833 res = dst + src;
2834 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2835 flag_N = flag_X = flag_C = res >> 8;
2836 flag_NotZ = res & 0xFFFF;
2837 WRITE_WORD_F(adr, res)
2838 POST_IO
2839RET(20)
2840}
2841
2842// ADDI
2843OPCODE(0x0670)
2844{
2845 u32 adr, res;
2846 u32 src, dst;
2847
2848 FETCH_WORD(src);
2849 adr = AREG((Opcode >> 0) & 7);
2850 DECODE_EXT_WORD
2851 PRE_IO
2852 READ_WORD_F(adr, dst)
2853 res = dst + src;
2854 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2855 flag_N = flag_X = flag_C = res >> 8;
2856 flag_NotZ = res & 0xFFFF;
2857 WRITE_WORD_F(adr, res)
2858 POST_IO
2859RET(22)
2860}
2861
2862// ADDI
2863OPCODE(0x0678)
2864{
2865 u32 adr, res;
2866 u32 src, dst;
2867
2868 FETCH_WORD(src);
2869 FETCH_SWORD(adr);
2870 PRE_IO
2871 READ_WORD_F(adr, dst)
2872 res = dst + src;
2873 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2874 flag_N = flag_X = flag_C = res >> 8;
2875 flag_NotZ = res & 0xFFFF;
2876 WRITE_WORD_F(adr, res)
2877 POST_IO
2878RET(20)
2879}
2880
2881// ADDI
2882OPCODE(0x0679)
2883{
2884 u32 adr, res;
2885 u32 src, dst;
2886
2887 FETCH_WORD(src);
2888 FETCH_LONG(adr);
2889 PRE_IO
2890 READ_WORD_F(adr, dst)
2891 res = dst + src;
2892 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2893 flag_N = flag_X = flag_C = res >> 8;
2894 flag_NotZ = res & 0xFFFF;
2895 WRITE_WORD_F(adr, res)
2896 POST_IO
2897RET(24)
2898}
2899
2900// ADDI
2901OPCODE(0x065F)
2902{
2903 u32 adr, res;
2904 u32 src, dst;
2905
2906 FETCH_WORD(src);
2907 adr = AREG(7);
2908 AREG(7) += 2;
2909 PRE_IO
2910 READ_WORD_F(adr, dst)
2911 res = dst + src;
2912 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2913 flag_N = flag_X = flag_C = res >> 8;
2914 flag_NotZ = res & 0xFFFF;
2915 WRITE_WORD_F(adr, res)
2916 POST_IO
2917RET(16)
2918}
2919
2920// ADDI
2921OPCODE(0x0667)
2922{
2923 u32 adr, res;
2924 u32 src, dst;
2925
2926 FETCH_WORD(src);
2927 adr = AREG(7) - 2;
2928 AREG(7) = adr;
2929 PRE_IO
2930 READ_WORD_F(adr, dst)
2931 res = dst + src;
2932 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2933 flag_N = flag_X = flag_C = res >> 8;
2934 flag_NotZ = res & 0xFFFF;
2935 WRITE_WORD_F(adr, res)
2936 POST_IO
2937RET(18)
2938}
2939
2940// ADDI
2941OPCODE(0x0680)
2942{
2943 u32 adr, res;
2944 u32 src, dst;
2945
2946 FETCH_LONG(src);
2947 dst = DREGu32((Opcode >> 0) & 7);
2948 res = dst + src;
2949 flag_NotZ = res;
2950 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2951 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2952 flag_N = res >> 24;
2953 DREGu32((Opcode >> 0) & 7) = res;
2954RET(16)
2955}
2956
2957// ADDI
2958OPCODE(0x0690)
2959{
2960 u32 adr, res;
2961 u32 src, dst;
2962
2963 FETCH_LONG(src);
2964 adr = AREG((Opcode >> 0) & 7);
2965 PRE_IO
2966 READ_LONG_F(adr, dst)
2967 res = dst + src;
2968 flag_NotZ = res;
2969 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2970 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2971 flag_N = res >> 24;
2972 WRITE_LONG_F(adr, res)
2973 POST_IO
2974RET(28)
2975}
2976
2977// ADDI
2978OPCODE(0x0698)
2979{
2980 u32 adr, res;
2981 u32 src, dst;
2982
2983 FETCH_LONG(src);
2984 adr = AREG((Opcode >> 0) & 7);
2985 AREG((Opcode >> 0) & 7) += 4;
2986 PRE_IO
2987 READ_LONG_F(adr, dst)
2988 res = dst + src;
2989 flag_NotZ = res;
2990 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2991 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2992 flag_N = res >> 24;
2993 WRITE_LONG_F(adr, res)
2994 POST_IO
2995RET(28)
2996}
2997
2998// ADDI
2999OPCODE(0x06A0)
3000{
3001 u32 adr, res;
3002 u32 src, dst;
3003
3004 FETCH_LONG(src);
3005 adr = AREG((Opcode >> 0) & 7) - 4;
3006 AREG((Opcode >> 0) & 7) = adr;
3007 PRE_IO
3008 READ_LONG_F(adr, dst)
3009 res = dst + src;
3010 flag_NotZ = res;
3011 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3012 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3013 flag_N = res >> 24;
3014 WRITE_LONG_F(adr, res)
3015 POST_IO
3016RET(30)
3017}
3018
3019// ADDI
3020OPCODE(0x06A8)
3021{
3022 u32 adr, res;
3023 u32 src, dst;
3024
3025 FETCH_LONG(src);
3026 FETCH_SWORD(adr);
3027 adr += AREG((Opcode >> 0) & 7);
3028 PRE_IO
3029 READ_LONG_F(adr, dst)
3030 res = dst + src;
3031 flag_NotZ = res;
3032 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3033 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3034 flag_N = res >> 24;
3035 WRITE_LONG_F(adr, res)
3036 POST_IO
3037RET(32)
3038}
3039
3040// ADDI
3041OPCODE(0x06B0)
3042{
3043 u32 adr, res;
3044 u32 src, dst;
3045
3046 FETCH_LONG(src);
3047 adr = AREG((Opcode >> 0) & 7);
3048 DECODE_EXT_WORD
3049 PRE_IO
3050 READ_LONG_F(adr, dst)
3051 res = dst + src;
3052 flag_NotZ = res;
3053 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3054 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3055 flag_N = res >> 24;
3056 WRITE_LONG_F(adr, res)
3057 POST_IO
3058RET(34)
3059}
3060
3061// ADDI
3062OPCODE(0x06B8)
3063{
3064 u32 adr, res;
3065 u32 src, dst;
3066
3067 FETCH_LONG(src);
3068 FETCH_SWORD(adr);
3069 PRE_IO
3070 READ_LONG_F(adr, dst)
3071 res = dst + src;
3072 flag_NotZ = res;
3073 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3074 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3075 flag_N = res >> 24;
3076 WRITE_LONG_F(adr, res)
3077 POST_IO
3078RET(32)
3079}
3080
3081// ADDI
3082OPCODE(0x06B9)
3083{
3084 u32 adr, res;
3085 u32 src, dst;
3086
3087 FETCH_LONG(src);
3088 FETCH_LONG(adr);
3089 PRE_IO
3090 READ_LONG_F(adr, dst)
3091 res = dst + src;
3092 flag_NotZ = res;
3093 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3094 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3095 flag_N = res >> 24;
3096 WRITE_LONG_F(adr, res)
3097 POST_IO
3098RET(36)
3099}
3100
3101// ADDI
3102OPCODE(0x069F)
3103{
3104 u32 adr, res;
3105 u32 src, dst;
3106
3107 FETCH_LONG(src);
3108 adr = AREG(7);
3109 AREG(7) += 4;
3110 PRE_IO
3111 READ_LONG_F(adr, dst)
3112 res = dst + src;
3113 flag_NotZ = res;
3114 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3115 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3116 flag_N = res >> 24;
3117 WRITE_LONG_F(adr, res)
3118 POST_IO
3119RET(28)
3120}
3121
3122// ADDI
3123OPCODE(0x06A7)
3124{
3125 u32 adr, res;
3126 u32 src, dst;
3127
3128 FETCH_LONG(src);
3129 adr = AREG(7) - 4;
3130 AREG(7) = adr;
3131 PRE_IO
3132 READ_LONG_F(adr, dst)
3133 res = dst + src;
3134 flag_NotZ = res;
3135 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3136 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3137 flag_N = res >> 24;
3138 WRITE_LONG_F(adr, res)
3139 POST_IO
3140RET(30)
3141}
3142
3143// CMPI
3144OPCODE(0x0C00)
3145{
3146 u32 adr, res;
3147 u32 src, dst;
3148
3149 FETCH_BYTE(src);
3150 dst = DREGu8((Opcode >> 0) & 7);
3151 res = dst - src;
3152 flag_N = flag_C = res;
3153 flag_V = (src ^ dst) & (res ^ dst);
3154 flag_NotZ = res & 0xFF;
3155RET(8)
3156}
3157
3158// CMPI
3159OPCODE(0x0C10)
3160{
3161 u32 adr, res;
3162 u32 src, dst;
3163
3164 FETCH_BYTE(src);
3165 adr = AREG((Opcode >> 0) & 7);
3166 PRE_IO
3167 READ_BYTE_F(adr, dst)
3168 res = dst - src;
3169 flag_N = flag_C = res;
3170 flag_V = (src ^ dst) & (res ^ dst);
3171 flag_NotZ = res & 0xFF;
3172 POST_IO
3173RET(12)
3174}
3175
3176// CMPI
3177OPCODE(0x0C18)
3178{
3179 u32 adr, res;
3180 u32 src, dst;
3181
3182 FETCH_BYTE(src);
3183 adr = AREG((Opcode >> 0) & 7);
3184 AREG((Opcode >> 0) & 7) += 1;
3185 PRE_IO
3186 READ_BYTE_F(adr, dst)
3187 res = dst - src;
3188 flag_N = flag_C = res;
3189 flag_V = (src ^ dst) & (res ^ dst);
3190 flag_NotZ = res & 0xFF;
3191 POST_IO
3192RET(12)
3193}
3194
3195// CMPI
3196OPCODE(0x0C20)
3197{
3198 u32 adr, res;
3199 u32 src, dst;
3200
3201 FETCH_BYTE(src);
3202 adr = AREG((Opcode >> 0) & 7) - 1;
3203 AREG((Opcode >> 0) & 7) = adr;
3204 PRE_IO
3205 READ_BYTE_F(adr, dst)
3206 res = dst - src;
3207 flag_N = flag_C = res;
3208 flag_V = (src ^ dst) & (res ^ dst);
3209 flag_NotZ = res & 0xFF;
3210 POST_IO
3211RET(14)
3212}
3213
3214// CMPI
3215OPCODE(0x0C28)
3216{
3217 u32 adr, res;
3218 u32 src, dst;
3219
3220 FETCH_BYTE(src);
3221 FETCH_SWORD(adr);
3222 adr += AREG((Opcode >> 0) & 7);
3223 PRE_IO
3224 READ_BYTE_F(adr, dst)
3225 res = dst - src;
3226 flag_N = flag_C = res;
3227 flag_V = (src ^ dst) & (res ^ dst);
3228 flag_NotZ = res & 0xFF;
3229 POST_IO
3230RET(16)
3231}
3232
3233// CMPI
3234OPCODE(0x0C30)
3235{
3236 u32 adr, res;
3237 u32 src, dst;
3238
3239 FETCH_BYTE(src);
3240 adr = AREG((Opcode >> 0) & 7);
3241 DECODE_EXT_WORD
3242 PRE_IO
3243 READ_BYTE_F(adr, dst)
3244 res = dst - src;
3245 flag_N = flag_C = res;
3246 flag_V = (src ^ dst) & (res ^ dst);
3247 flag_NotZ = res & 0xFF;
3248 POST_IO
3249RET(18)
3250}
3251
3252// CMPI
3253OPCODE(0x0C38)
3254{
3255 u32 adr, res;
3256 u32 src, dst;
3257
3258 FETCH_BYTE(src);
3259 FETCH_SWORD(adr);
3260 PRE_IO
3261 READ_BYTE_F(adr, dst)
3262 res = dst - src;
3263 flag_N = flag_C = res;
3264 flag_V = (src ^ dst) & (res ^ dst);
3265 flag_NotZ = res & 0xFF;
3266 POST_IO
3267RET(16)
3268}
3269
3270// CMPI
3271OPCODE(0x0C39)
3272{
3273 u32 adr, res;
3274 u32 src, dst;
3275
3276 FETCH_BYTE(src);
3277 FETCH_LONG(adr);
3278 PRE_IO
3279 READ_BYTE_F(adr, dst)
3280 res = dst - src;
3281 flag_N = flag_C = res;
3282 flag_V = (src ^ dst) & (res ^ dst);
3283 flag_NotZ = res & 0xFF;
3284 POST_IO
3285RET(20)
3286}
3287
3288// CMPI
3289OPCODE(0x0C1F)
3290{
3291 u32 adr, res;
3292 u32 src, dst;
3293
3294 FETCH_BYTE(src);
3295 adr = AREG(7);
3296 AREG(7) += 2;
3297 PRE_IO
3298 READ_BYTE_F(adr, dst)
3299 res = dst - src;
3300 flag_N = flag_C = res;
3301 flag_V = (src ^ dst) & (res ^ dst);
3302 flag_NotZ = res & 0xFF;
3303 POST_IO
3304RET(12)
3305}
3306
3307// CMPI
3308OPCODE(0x0C27)
3309{
3310 u32 adr, res;
3311 u32 src, dst;
3312
3313 FETCH_BYTE(src);
3314 adr = AREG(7) - 2;
3315 AREG(7) = adr;
3316 PRE_IO
3317 READ_BYTE_F(adr, dst)
3318 res = dst - src;
3319 flag_N = flag_C = res;
3320 flag_V = (src ^ dst) & (res ^ dst);
3321 flag_NotZ = res & 0xFF;
3322 POST_IO
3323RET(14)
3324}
3325
3326// CMPI
3327OPCODE(0x0C40)
3328{
3329 u32 adr, res;
3330 u32 src, dst;
3331
3332 FETCH_WORD(src);
3333 dst = DREGu16((Opcode >> 0) & 7);
3334 res = dst - src;
3335 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3336 flag_N = flag_C = res >> 8;
3337 flag_NotZ = res & 0xFFFF;
3338RET(8)
3339}
3340
3341// CMPI
3342OPCODE(0x0C50)
3343{
3344 u32 adr, res;
3345 u32 src, dst;
3346
3347 FETCH_WORD(src);
3348 adr = AREG((Opcode >> 0) & 7);
3349 PRE_IO
3350 READ_WORD_F(adr, dst)
3351 res = dst - src;
3352 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3353 flag_N = flag_C = res >> 8;
3354 flag_NotZ = res & 0xFFFF;
3355 POST_IO
3356RET(12)
3357}
3358
3359// CMPI
3360OPCODE(0x0C58)
3361{
3362 u32 adr, res;
3363 u32 src, dst;
3364
3365 FETCH_WORD(src);
3366 adr = AREG((Opcode >> 0) & 7);
3367 AREG((Opcode >> 0) & 7) += 2;
3368 PRE_IO
3369 READ_WORD_F(adr, dst)
3370 res = dst - src;
3371 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3372 flag_N = flag_C = res >> 8;
3373 flag_NotZ = res & 0xFFFF;
3374 POST_IO
3375RET(12)
3376}
3377
3378// CMPI
3379OPCODE(0x0C60)
3380{
3381 u32 adr, res;
3382 u32 src, dst;
3383
3384 FETCH_WORD(src);
3385 adr = AREG((Opcode >> 0) & 7) - 2;
3386 AREG((Opcode >> 0) & 7) = adr;
3387 PRE_IO
3388 READ_WORD_F(adr, dst)
3389 res = dst - src;
3390 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3391 flag_N = flag_C = res >> 8;
3392 flag_NotZ = res & 0xFFFF;
3393 POST_IO
3394RET(14)
3395}
3396
3397// CMPI
3398OPCODE(0x0C68)
3399{
3400 u32 adr, res;
3401 u32 src, dst;
3402
3403 FETCH_WORD(src);
3404 FETCH_SWORD(adr);
3405 adr += AREG((Opcode >> 0) & 7);
3406 PRE_IO
3407 READ_WORD_F(adr, dst)
3408 res = dst - src;
3409 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3410 flag_N = flag_C = res >> 8;
3411 flag_NotZ = res & 0xFFFF;
3412 POST_IO
3413RET(16)
3414}
3415
3416// CMPI
3417OPCODE(0x0C70)
3418{
3419 u32 adr, res;
3420 u32 src, dst;
3421
3422 FETCH_WORD(src);
3423 adr = AREG((Opcode >> 0) & 7);
3424 DECODE_EXT_WORD
3425 PRE_IO
3426 READ_WORD_F(adr, dst)
3427 res = dst - src;
3428 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3429 flag_N = flag_C = res >> 8;
3430 flag_NotZ = res & 0xFFFF;
3431 POST_IO
3432RET(18)
3433}
3434
3435// CMPI
3436OPCODE(0x0C78)
3437{
3438 u32 adr, res;
3439 u32 src, dst;
3440
3441 FETCH_WORD(src);
3442 FETCH_SWORD(adr);
3443 PRE_IO
3444 READ_WORD_F(adr, dst)
3445 res = dst - src;
3446 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3447 flag_N = flag_C = res >> 8;
3448 flag_NotZ = res & 0xFFFF;
3449 POST_IO
3450RET(16)
3451}
3452
3453// CMPI
3454OPCODE(0x0C79)
3455{
3456 u32 adr, res;
3457 u32 src, dst;
3458
3459 FETCH_WORD(src);
3460 FETCH_LONG(adr);
3461 PRE_IO
3462 READ_WORD_F(adr, dst)
3463 res = dst - src;
3464 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3465 flag_N = flag_C = res >> 8;
3466 flag_NotZ = res & 0xFFFF;
3467 POST_IO
3468RET(20)
3469}
3470
3471// CMPI
3472OPCODE(0x0C5F)
3473{
3474 u32 adr, res;
3475 u32 src, dst;
3476
3477 FETCH_WORD(src);
3478 adr = AREG(7);
3479 AREG(7) += 2;
3480 PRE_IO
3481 READ_WORD_F(adr, dst)
3482 res = dst - src;
3483 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3484 flag_N = flag_C = res >> 8;
3485 flag_NotZ = res & 0xFFFF;
3486 POST_IO
3487RET(12)
3488}
3489
3490// CMPI
3491OPCODE(0x0C67)
3492{
3493 u32 adr, res;
3494 u32 src, dst;
3495
3496 FETCH_WORD(src);
3497 adr = AREG(7) - 2;
3498 AREG(7) = adr;
3499 PRE_IO
3500 READ_WORD_F(adr, dst)
3501 res = dst - src;
3502 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3503 flag_N = flag_C = res >> 8;
3504 flag_NotZ = res & 0xFFFF;
3505 POST_IO
3506RET(14)
3507}
3508
3509// CMPI
3510OPCODE(0x0C80)
3511{
3512 u32 adr, res;
3513 u32 src, dst;
3514
3515 FETCH_LONG(src);
3516 dst = DREGu32((Opcode >> 0) & 7);
3517 res = dst - src;
3518 flag_NotZ = res;
3519 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3520 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3521 flag_N = res >> 24;
3522RET(14)
3523}
3524
3525// CMPI
3526OPCODE(0x0C90)
3527{
3528 u32 adr, res;
3529 u32 src, dst;
3530
3531 FETCH_LONG(src);
3532 adr = AREG((Opcode >> 0) & 7);
3533 PRE_IO
3534 READ_LONG_F(adr, dst)
3535 res = dst - src;
3536 flag_NotZ = res;
3537 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3538 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3539 flag_N = res >> 24;
3540 POST_IO
3541RET(20)
3542}
3543
3544// CMPI
3545OPCODE(0x0C98)
3546{
3547 u32 adr, res;
3548 u32 src, dst;
3549
3550 FETCH_LONG(src);
3551 adr = AREG((Opcode >> 0) & 7);
3552 AREG((Opcode >> 0) & 7) += 4;
3553 PRE_IO
3554 READ_LONG_F(adr, dst)
3555 res = dst - src;
3556 flag_NotZ = res;
3557 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3558 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3559 flag_N = res >> 24;
3560 POST_IO
3561RET(20)
3562}
3563
3564// CMPI
3565OPCODE(0x0CA0)
3566{
3567 u32 adr, res;
3568 u32 src, dst;
3569
3570 FETCH_LONG(src);
3571 adr = AREG((Opcode >> 0) & 7) - 4;
3572 AREG((Opcode >> 0) & 7) = adr;
3573 PRE_IO
3574 READ_LONG_F(adr, dst)
3575 res = dst - src;
3576 flag_NotZ = res;
3577 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3578 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3579 flag_N = res >> 24;
3580 POST_IO
3581RET(22)
3582}
3583
3584// CMPI
3585OPCODE(0x0CA8)
3586{
3587 u32 adr, res;
3588 u32 src, dst;
3589
3590 FETCH_LONG(src);
3591 FETCH_SWORD(adr);
3592 adr += AREG((Opcode >> 0) & 7);
3593 PRE_IO
3594 READ_LONG_F(adr, dst)
3595 res = dst - src;
3596 flag_NotZ = res;
3597 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3598 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3599 flag_N = res >> 24;
3600 POST_IO
3601RET(24)
3602}
3603
3604// CMPI
3605OPCODE(0x0CB0)
3606{
3607 u32 adr, res;
3608 u32 src, dst;
3609
3610 FETCH_LONG(src);
3611 adr = AREG((Opcode >> 0) & 7);
3612 DECODE_EXT_WORD
3613 PRE_IO
3614 READ_LONG_F(adr, dst)
3615 res = dst - src;
3616 flag_NotZ = res;
3617 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3618 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3619 flag_N = res >> 24;
3620 POST_IO
3621RET(26)
3622}
3623
3624// CMPI
3625OPCODE(0x0CB8)
3626{
3627 u32 adr, res;
3628 u32 src, dst;
3629
3630 FETCH_LONG(src);
3631 FETCH_SWORD(adr);
3632 PRE_IO
3633 READ_LONG_F(adr, dst)
3634 res = dst - src;
3635 flag_NotZ = res;
3636 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3637 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3638 flag_N = res >> 24;
3639 POST_IO
3640RET(24)
3641}
3642
3643// CMPI
3644OPCODE(0x0CB9)
3645{
3646 u32 adr, res;
3647 u32 src, dst;
3648
3649 FETCH_LONG(src);
3650 FETCH_LONG(adr);
3651 PRE_IO
3652 READ_LONG_F(adr, dst)
3653 res = dst - src;
3654 flag_NotZ = res;
3655 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3656 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3657 flag_N = res >> 24;
3658 POST_IO
3659RET(28)
3660}
3661
3662// CMPI
3663OPCODE(0x0C9F)
3664{
3665 u32 adr, res;
3666 u32 src, dst;
3667
3668 FETCH_LONG(src);
3669 adr = AREG(7);
3670 AREG(7) += 4;
3671 PRE_IO
3672 READ_LONG_F(adr, dst)
3673 res = dst - src;
3674 flag_NotZ = res;
3675 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3676 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3677 flag_N = res >> 24;
3678 POST_IO
3679RET(20)
3680}
3681
3682// CMPI
3683OPCODE(0x0CA7)
3684{
3685 u32 adr, res;
3686 u32 src, dst;
3687
3688 FETCH_LONG(src);
3689 adr = AREG(7) - 4;
3690 AREG(7) = adr;
3691 PRE_IO
3692 READ_LONG_F(adr, dst)
3693 res = dst - src;
3694 flag_NotZ = res;
3695 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3696 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3697 flag_N = res >> 24;
3698 POST_IO
3699RET(22)
3700}
3701
3702// BTSTn
3703OPCODE(0x0800)
3704{
3705 u32 adr, res;
3706 u32 src, dst;
3707
3708 FETCH_BYTE(src);
3709 src = 1 << (src & 31);
3710 res = DREGu32((Opcode >> 0) & 7);
3711 flag_NotZ = res & src;
3712RET(10)
3713}
3714
3715// BTSTn
3716OPCODE(0x0810)
3717{
3718 u32 adr, res;
3719 u32 src, dst;
3720
3721 FETCH_BYTE(src);
3722 src = 1 << (src & 7);
3723 adr = AREG((Opcode >> 0) & 7);
3724 PRE_IO
3725 READ_BYTE_F(adr, res)
3726 flag_NotZ = res & src;
3727 POST_IO
3728RET(12)
3729}
3730
3731// BTSTn
3732OPCODE(0x0818)
3733{
3734 u32 adr, res;
3735 u32 src, dst;
3736
3737 FETCH_BYTE(src);
3738 src = 1 << (src & 7);
3739 adr = AREG((Opcode >> 0) & 7);
3740 AREG((Opcode >> 0) & 7) += 1;
3741 PRE_IO
3742 READ_BYTE_F(adr, res)
3743 flag_NotZ = res & src;
3744 POST_IO
3745RET(12)
3746}
3747
3748// BTSTn
3749OPCODE(0x0820)
3750{
3751 u32 adr, res;
3752 u32 src, dst;
3753
3754 FETCH_BYTE(src);
3755 src = 1 << (src & 7);
3756 adr = AREG((Opcode >> 0) & 7) - 1;
3757 AREG((Opcode >> 0) & 7) = adr;
3758 PRE_IO
3759 READ_BYTE_F(adr, res)
3760 flag_NotZ = res & src;
3761 POST_IO
3762RET(14)
3763}
3764
3765// BTSTn
3766OPCODE(0x0828)
3767{
3768 u32 adr, res;
3769 u32 src, dst;
3770
3771 FETCH_BYTE(src);
3772 src = 1 << (src & 7);
3773 FETCH_SWORD(adr);
3774 adr += AREG((Opcode >> 0) & 7);
3775 PRE_IO
3776 READ_BYTE_F(adr, res)
3777 flag_NotZ = res & src;
3778 POST_IO
3779RET(16)
3780}
3781
3782// BTSTn
3783OPCODE(0x0830)
3784{
3785 u32 adr, res;
3786 u32 src, dst;
3787
3788 FETCH_BYTE(src);
3789 src = 1 << (src & 7);
3790 adr = AREG((Opcode >> 0) & 7);
3791 DECODE_EXT_WORD
3792 PRE_IO
3793 READ_BYTE_F(adr, res)
3794 flag_NotZ = res & src;
3795 POST_IO
3796RET(18)
3797}
3798
3799// BTSTn
3800OPCODE(0x0838)
3801{
3802 u32 adr, res;
3803 u32 src, dst;
3804
3805 FETCH_BYTE(src);
3806 src = 1 << (src & 7);
3807 FETCH_SWORD(adr);
3808 PRE_IO
3809 READ_BYTE_F(adr, res)
3810 flag_NotZ = res & src;
3811 POST_IO
3812RET(16)
3813}
3814
3815// BTSTn
3816OPCODE(0x0839)
3817{
3818 u32 adr, res;
3819 u32 src, dst;
3820
3821 FETCH_BYTE(src);
3822 src = 1 << (src & 7);
3823 FETCH_LONG(adr);
3824 PRE_IO
3825 READ_BYTE_F(adr, res)
3826 flag_NotZ = res & src;
3827 POST_IO
3828RET(20)
3829}
3830
3831// BTSTn
3832OPCODE(0x083A)
3833{
3834 u32 adr, res;
3835 u32 src, dst;
3836
3837 FETCH_BYTE(src);
3838 src = 1 << (src & 7);
3839 adr = GET_SWORD + GET_PC;
3840 PC++;
3841 PRE_IO
3842 READ_BYTE_F(adr, res)
3843 flag_NotZ = res & src;
3844 POST_IO
3845RET(16)
3846}
3847
3848// BTSTn
3849OPCODE(0x083B)
3850{
3851 u32 adr, res;
3852 u32 src, dst;
3853
3854 FETCH_BYTE(src);
3855 src = 1 << (src & 7);
3856 adr = (uptr)(PC) - BasePC;
3857 DECODE_EXT_WORD
3858 PRE_IO
3859 READ_BYTE_F(adr, res)
3860 flag_NotZ = res & src;
3861 POST_IO
3862RET(18)
3863}
3864
3865// BTSTn
3866OPCODE(0x081F)
3867{
3868 u32 adr, res;
3869 u32 src, dst;
3870
3871 FETCH_BYTE(src);
3872 src = 1 << (src & 7);
3873 adr = AREG(7);
3874 AREG(7) += 2;
3875 PRE_IO
3876 READ_BYTE_F(adr, res)
3877 flag_NotZ = res & src;
3878 POST_IO
3879RET(12)
3880}
3881
3882// BTSTn
3883OPCODE(0x0827)
3884{
3885 u32 adr, res;
3886 u32 src, dst;
3887
3888 FETCH_BYTE(src);
3889 src = 1 << (src & 7);
3890 adr = AREG(7) - 2;
3891 AREG(7) = adr;
3892 PRE_IO
3893 READ_BYTE_F(adr, res)
3894 flag_NotZ = res & src;
3895 POST_IO
3896RET(14)
3897}
3898
3899// BCHGn
3900OPCODE(0x0840)
3901{
3902 u32 adr, res;
3903 u32 src, dst;
3904
3905 FETCH_BYTE(src);
3906 src = 1 << (src & 31);
3907 res = DREGu32((Opcode >> 0) & 7);
3908 flag_NotZ = res & src;
3909 res ^= src;
3910 DREGu32((Opcode >> 0) & 7) = res;
3911#ifdef USE_CYCLONE_TIMING
3912 if (src >> 16) ctx->io_cycle_counter -= 2;
3913RET(10)
3914#else
3915RET(12)
3916#endif
3917}
3918
3919// BCHGn
3920OPCODE(0x0850)
3921{
3922 u32 adr, res;
3923 u32 src, dst;
3924
3925 FETCH_BYTE(src);
3926 src = 1 << (src & 7);
3927 adr = AREG((Opcode >> 0) & 7);
3928 PRE_IO
3929 READ_BYTE_F(adr, res)
3930 flag_NotZ = res & src;
3931 res ^= src;
3932 WRITE_BYTE_F(adr, res)
3933 POST_IO
3934RET(16)
3935}
3936
3937// BCHGn
3938OPCODE(0x0858)
3939{
3940 u32 adr, res;
3941 u32 src, dst;
3942
3943 FETCH_BYTE(src);
3944 src = 1 << (src & 7);
3945 adr = AREG((Opcode >> 0) & 7);
3946 AREG((Opcode >> 0) & 7) += 1;
3947 PRE_IO
3948 READ_BYTE_F(adr, res)
3949 flag_NotZ = res & src;
3950 res ^= src;
3951 WRITE_BYTE_F(adr, res)
3952 POST_IO
3953RET(16)
3954}
3955
3956// BCHGn
3957OPCODE(0x0860)
3958{
3959 u32 adr, res;
3960 u32 src, dst;
3961
3962 FETCH_BYTE(src);
3963 src = 1 << (src & 7);
3964 adr = AREG((Opcode >> 0) & 7) - 1;
3965 AREG((Opcode >> 0) & 7) = adr;
3966 PRE_IO
3967 READ_BYTE_F(adr, res)
3968 flag_NotZ = res & src;
3969 res ^= src;
3970 WRITE_BYTE_F(adr, res)
3971 POST_IO
3972RET(18)
3973}
3974
3975// BCHGn
3976OPCODE(0x0868)
3977{
3978 u32 adr, res;
3979 u32 src, dst;
3980
3981 FETCH_BYTE(src);
3982 src = 1 << (src & 7);
3983 FETCH_SWORD(adr);
3984 adr += AREG((Opcode >> 0) & 7);
3985 PRE_IO
3986 READ_BYTE_F(adr, res)
3987 flag_NotZ = res & src;
3988 res ^= src;
3989 WRITE_BYTE_F(adr, res)
3990 POST_IO
3991RET(20)
3992}
3993
3994// BCHGn
3995OPCODE(0x0870)
3996{
3997 u32 adr, res;
3998 u32 src, dst;
3999
4000 FETCH_BYTE(src);
4001 src = 1 << (src & 7);
4002 adr = AREG((Opcode >> 0) & 7);
4003 DECODE_EXT_WORD
4004 PRE_IO
4005 READ_BYTE_F(adr, res)
4006 flag_NotZ = res & src;
4007 res ^= src;
4008 WRITE_BYTE_F(adr, res)
4009 POST_IO
4010RET(22)
4011}
4012
4013// BCHGn
4014OPCODE(0x0878)
4015{
4016 u32 adr, res;
4017 u32 src, dst;
4018
4019 FETCH_BYTE(src);
4020 src = 1 << (src & 7);
4021 FETCH_SWORD(adr);
4022 PRE_IO
4023 READ_BYTE_F(adr, res)
4024 flag_NotZ = res & src;
4025 res ^= src;
4026 WRITE_BYTE_F(adr, res)
4027 POST_IO
4028RET(20)
4029}
4030
4031// BCHGn
4032OPCODE(0x0879)
4033{
4034 u32 adr, res;
4035 u32 src, dst;
4036
4037 FETCH_BYTE(src);
4038 src = 1 << (src & 7);
4039 FETCH_LONG(adr);
4040 PRE_IO
4041 READ_BYTE_F(adr, res)
4042 flag_NotZ = res & src;
4043 res ^= src;
4044 WRITE_BYTE_F(adr, res)
4045 POST_IO
4046RET(24)
4047}
4048
4049// BCHGn
4050OPCODE(0x085F)
4051{
4052 u32 adr, res;
4053 u32 src, dst;
4054
4055 FETCH_BYTE(src);
4056 src = 1 << (src & 7);
4057 adr = AREG(7);
4058 AREG(7) += 2;
4059 PRE_IO
4060 READ_BYTE_F(adr, res)
4061 flag_NotZ = res & src;
4062 res ^= src;
4063 WRITE_BYTE_F(adr, res)
4064 POST_IO
4065RET(16)
4066}
4067
4068// BCHGn
4069OPCODE(0x0867)
4070{
4071 u32 adr, res;
4072 u32 src, dst;
4073
4074 FETCH_BYTE(src);
4075 src = 1 << (src & 7);
4076 adr = AREG(7) - 2;
4077 AREG(7) = adr;
4078 PRE_IO
4079 READ_BYTE_F(adr, res)
4080 flag_NotZ = res & src;
4081 res ^= src;
4082 WRITE_BYTE_F(adr, res)
4083 POST_IO
4084RET(18)
4085}
4086
4087// BCLRn
4088OPCODE(0x0880)
4089{
4090 u32 adr, res;
4091 u32 src, dst;
4092
4093 FETCH_BYTE(src);
4094 src = 1 << (src & 31);
4095 res = DREGu32((Opcode >> 0) & 7);
4096 flag_NotZ = res & src;
4097 res &= ~src;
4098 DREGu32((Opcode >> 0) & 7) = res;
4099#ifdef USE_CYCLONE_TIMING
4100 if (src >> 16) ctx->io_cycle_counter -= 2;
4101RET(12)
4102#else
4103RET(14)
4104#endif
4105}
4106
4107// BCLRn
4108OPCODE(0x0890)
4109{
4110 u32 adr, res;
4111 u32 src, dst;
4112
4113 FETCH_BYTE(src);
4114 src = 1 << (src & 7);
4115 adr = AREG((Opcode >> 0) & 7);
4116 PRE_IO
4117 READ_BYTE_F(adr, res)
4118 flag_NotZ = res & src;
4119 res &= ~src;
4120 WRITE_BYTE_F(adr, res)
4121 POST_IO
4122RET(16)
4123}
4124
4125// BCLRn
4126OPCODE(0x0898)
4127{
4128 u32 adr, res;
4129 u32 src, dst;
4130
4131 FETCH_BYTE(src);
4132 src = 1 << (src & 7);
4133 adr = AREG((Opcode >> 0) & 7);
4134 AREG((Opcode >> 0) & 7) += 1;
4135 PRE_IO
4136 READ_BYTE_F(adr, res)
4137 flag_NotZ = res & src;
4138 res &= ~src;
4139 WRITE_BYTE_F(adr, res)
4140 POST_IO
4141RET(16)
4142}
4143
4144// BCLRn
4145OPCODE(0x08A0)
4146{
4147 u32 adr, res;
4148 u32 src, dst;
4149
4150 FETCH_BYTE(src);
4151 src = 1 << (src & 7);
4152 adr = AREG((Opcode >> 0) & 7) - 1;
4153 AREG((Opcode >> 0) & 7) = adr;
4154 PRE_IO
4155 READ_BYTE_F(adr, res)
4156 flag_NotZ = res & src;
4157 res &= ~src;
4158 WRITE_BYTE_F(adr, res)
4159 POST_IO
4160RET(18)
4161}
4162
4163// BCLRn
4164OPCODE(0x08A8)
4165{
4166 u32 adr, res;
4167 u32 src, dst;
4168
4169 FETCH_BYTE(src);
4170 src = 1 << (src & 7);
4171 FETCH_SWORD(adr);
4172 adr += AREG((Opcode >> 0) & 7);
4173 PRE_IO
4174 READ_BYTE_F(adr, res)
4175 flag_NotZ = res & src;
4176 res &= ~src;
4177 WRITE_BYTE_F(adr, res)
4178 POST_IO
4179RET(20)
4180}
4181
4182// BCLRn
4183OPCODE(0x08B0)
4184{
4185 u32 adr, res;
4186 u32 src, dst;
4187
4188 FETCH_BYTE(src);
4189 src = 1 << (src & 7);
4190 adr = AREG((Opcode >> 0) & 7);
4191 DECODE_EXT_WORD
4192 PRE_IO
4193 READ_BYTE_F(adr, res)
4194 flag_NotZ = res & src;
4195 res &= ~src;
4196 WRITE_BYTE_F(adr, res)
4197 POST_IO
4198RET(22)
4199}
4200
4201// BCLRn
4202OPCODE(0x08B8)
4203{
4204 u32 adr, res;
4205 u32 src, dst;
4206
4207 FETCH_BYTE(src);
4208 src = 1 << (src & 7);
4209 FETCH_SWORD(adr);
4210 PRE_IO
4211 READ_BYTE_F(adr, res)
4212 flag_NotZ = res & src;
4213 res &= ~src;
4214 WRITE_BYTE_F(adr, res)
4215 POST_IO
4216RET(20)
4217}
4218
4219// BCLRn
4220OPCODE(0x08B9)
4221{
4222 u32 adr, res;
4223 u32 src, dst;
4224
4225 FETCH_BYTE(src);
4226 src = 1 << (src & 7);
4227 FETCH_LONG(adr);
4228 PRE_IO
4229 READ_BYTE_F(adr, res)
4230 flag_NotZ = res & src;
4231 res &= ~src;
4232 WRITE_BYTE_F(adr, res)
4233 POST_IO
4234RET(24)
4235}
4236
4237// BCLRn
4238OPCODE(0x089F)
4239{
4240 u32 adr, res;
4241 u32 src, dst;
4242
4243 FETCH_BYTE(src);
4244 src = 1 << (src & 7);
4245 adr = AREG(7);
4246 AREG(7) += 2;
4247 PRE_IO
4248 READ_BYTE_F(adr, res)
4249 flag_NotZ = res & src;
4250 res &= ~src;
4251 WRITE_BYTE_F(adr, res)
4252 POST_IO
4253RET(16)
4254}
4255
4256// BCLRn
4257OPCODE(0x08A7)
4258{
4259 u32 adr, res;
4260 u32 src, dst;
4261
4262 FETCH_BYTE(src);
4263 src = 1 << (src & 7);
4264 adr = AREG(7) - 2;
4265 AREG(7) = adr;
4266 PRE_IO
4267 READ_BYTE_F(adr, res)
4268 flag_NotZ = res & src;
4269 res &= ~src;
4270 WRITE_BYTE_F(adr, res)
4271 POST_IO
4272RET(18)
4273}
4274
4275// BSETn
4276OPCODE(0x08C0)
4277{
4278 u32 adr, res;
4279 u32 src, dst;
4280
4281 FETCH_BYTE(src);
4282 src = 1 << (src & 31);
4283 res = DREGu32((Opcode >> 0) & 7);
4284 flag_NotZ = res & src;
4285 res |= src;
4286 DREGu32((Opcode >> 0) & 7) = res;
4287#ifdef USE_CYCLONE_TIMING
4288 if (src >> 16) ctx->io_cycle_counter -= 2;
4289RET(10)
4290#else
4291RET(12)
4292#endif
4293}
4294
4295// BSETn
4296OPCODE(0x08D0)
4297{
4298 u32 adr, res;
4299 u32 src, dst;
4300
4301 FETCH_BYTE(src);
4302 src = 1 << (src & 7);
4303 adr = AREG((Opcode >> 0) & 7);
4304 PRE_IO
4305 READ_BYTE_F(adr, res)
4306 flag_NotZ = res & src;
4307 res |= src;
4308 WRITE_BYTE_F(adr, res)
4309 POST_IO
4310RET(16)
4311}
4312
4313// BSETn
4314OPCODE(0x08D8)
4315{
4316 u32 adr, res;
4317 u32 src, dst;
4318
4319 FETCH_BYTE(src);
4320 src = 1 << (src & 7);
4321 adr = AREG((Opcode >> 0) & 7);
4322 AREG((Opcode >> 0) & 7) += 1;
4323 PRE_IO
4324 READ_BYTE_F(adr, res)
4325 flag_NotZ = res & src;
4326 res |= src;
4327 WRITE_BYTE_F(adr, res)
4328 POST_IO
4329RET(16)
4330}
4331
4332// BSETn
4333OPCODE(0x08E0)
4334{
4335 u32 adr, res;
4336 u32 src, dst;
4337
4338 FETCH_BYTE(src);
4339 src = 1 << (src & 7);
4340 adr = AREG((Opcode >> 0) & 7) - 1;
4341 AREG((Opcode >> 0) & 7) = adr;
4342 PRE_IO
4343 READ_BYTE_F(adr, res)
4344 flag_NotZ = res & src;
4345 res |= src;
4346 WRITE_BYTE_F(adr, res)
4347 POST_IO
4348RET(18)
4349}
4350
4351// BSETn
4352OPCODE(0x08E8)
4353{
4354 u32 adr, res;
4355 u32 src, dst;
4356
4357 FETCH_BYTE(src);
4358 src = 1 << (src & 7);
4359 FETCH_SWORD(adr);
4360 adr += AREG((Opcode >> 0) & 7);
4361 PRE_IO
4362 READ_BYTE_F(adr, res)
4363 flag_NotZ = res & src;
4364 res |= src;
4365 WRITE_BYTE_F(adr, res)
4366 POST_IO
4367RET(20)
4368}
4369
4370// BSETn
4371OPCODE(0x08F0)
4372{
4373 u32 adr, res;
4374 u32 src, dst;
4375
4376 FETCH_BYTE(src);
4377 src = 1 << (src & 7);
4378 adr = AREG((Opcode >> 0) & 7);
4379 DECODE_EXT_WORD
4380 PRE_IO
4381 READ_BYTE_F(adr, res)
4382 flag_NotZ = res & src;
4383 res |= src;
4384 WRITE_BYTE_F(adr, res)
4385 POST_IO
4386RET(22)
4387}
4388
4389// BSETn
4390OPCODE(0x08F8)
4391{
4392 u32 adr, res;
4393 u32 src, dst;
4394
4395 FETCH_BYTE(src);
4396 src = 1 << (src & 7);
4397 FETCH_SWORD(adr);
4398 PRE_IO
4399 READ_BYTE_F(adr, res)
4400 flag_NotZ = res & src;
4401 res |= src;
4402 WRITE_BYTE_F(adr, res)
4403 POST_IO
4404RET(20)
4405}
4406
4407// BSETn
4408OPCODE(0x08F9)
4409{
4410 u32 adr, res;
4411 u32 src, dst;
4412
4413 FETCH_BYTE(src);
4414 src = 1 << (src & 7);
4415 FETCH_LONG(adr);
4416 PRE_IO
4417 READ_BYTE_F(adr, res)
4418 flag_NotZ = res & src;
4419 res |= src;
4420 WRITE_BYTE_F(adr, res)
4421 POST_IO
4422RET(24)
4423}
4424
4425// BSETn
4426OPCODE(0x08DF)
4427{
4428 u32 adr, res;
4429 u32 src, dst;
4430
4431 FETCH_BYTE(src);
4432 src = 1 << (src & 7);
4433 adr = AREG(7);
4434 AREG(7) += 2;
4435 PRE_IO
4436 READ_BYTE_F(adr, res)
4437 flag_NotZ = res & src;
4438 res |= src;
4439 WRITE_BYTE_F(adr, res)
4440 POST_IO
4441RET(16)
4442}
4443
4444// BSETn
4445OPCODE(0x08E7)
4446{
4447 u32 adr, res;
4448 u32 src, dst;
4449
4450 FETCH_BYTE(src);
4451 src = 1 << (src & 7);
4452 adr = AREG(7) - 2;
4453 AREG(7) = adr;
4454 PRE_IO
4455 READ_BYTE_F(adr, res)
4456 flag_NotZ = res & src;
4457 res |= src;
4458 WRITE_BYTE_F(adr, res)
4459 POST_IO
4460RET(18)
4461}
4462
4463// BTST
4464OPCODE(0x0100)
4465{
4466 u32 adr, res;
4467 u32 src, dst;
4468
4469 src = DREGu32((Opcode >> 9) & 7);
4470 src = 1 << (src & 31);
4471 res = DREGu32((Opcode >> 0) & 7);
4472 flag_NotZ = res & src;
4473RET(6)
4474}
4475
4476// BTST
4477OPCODE(0x0110)
4478{
4479 u32 adr, res;
4480 u32 src, dst;
4481
4482 src = DREGu8((Opcode >> 9) & 7);
4483 src = 1 << (src & 7);
4484 adr = AREG((Opcode >> 0) & 7);
4485 PRE_IO
4486 READ_BYTE_F(adr, res)
4487 flag_NotZ = res & src;
4488 POST_IO
4489RET(8)
4490}
4491
4492// BTST
4493OPCODE(0x0118)
4494{
4495 u32 adr, res;
4496 u32 src, dst;
4497
4498 src = DREGu8((Opcode >> 9) & 7);
4499 src = 1 << (src & 7);
4500 adr = AREG((Opcode >> 0) & 7);
4501 AREG((Opcode >> 0) & 7) += 1;
4502 PRE_IO
4503 READ_BYTE_F(adr, res)
4504 flag_NotZ = res & src;
4505 POST_IO
4506RET(8)
4507}
4508
4509// BTST
4510OPCODE(0x0120)
4511{
4512 u32 adr, res;
4513 u32 src, dst;
4514
4515 src = DREGu8((Opcode >> 9) & 7);
4516 src = 1 << (src & 7);
4517 adr = AREG((Opcode >> 0) & 7) - 1;
4518 AREG((Opcode >> 0) & 7) = adr;
4519 PRE_IO
4520 READ_BYTE_F(adr, res)
4521 flag_NotZ = res & src;
4522 POST_IO
4523RET(10)
4524}
4525
4526// BTST
4527OPCODE(0x0128)
4528{
4529 u32 adr, res;
4530 u32 src, dst;
4531
4532 src = DREGu8((Opcode >> 9) & 7);
4533 src = 1 << (src & 7);
4534 FETCH_SWORD(adr);
4535 adr += AREG((Opcode >> 0) & 7);
4536 PRE_IO
4537 READ_BYTE_F(adr, res)
4538 flag_NotZ = res & src;
4539 POST_IO
4540RET(12)
4541}
4542
4543// BTST
4544OPCODE(0x0130)
4545{
4546 u32 adr, res;
4547 u32 src, dst;
4548
4549 src = DREGu8((Opcode >> 9) & 7);
4550 src = 1 << (src & 7);
4551 adr = AREG((Opcode >> 0) & 7);
4552 DECODE_EXT_WORD
4553 PRE_IO
4554 READ_BYTE_F(adr, res)
4555 flag_NotZ = res & src;
4556 POST_IO
4557RET(14)
4558}
4559
4560// BTST
4561OPCODE(0x0138)
4562{
4563 u32 adr, res;
4564 u32 src, dst;
4565
4566 src = DREGu8((Opcode >> 9) & 7);
4567 src = 1 << (src & 7);
4568 FETCH_SWORD(adr);
4569 PRE_IO
4570 READ_BYTE_F(adr, res)
4571 flag_NotZ = res & src;
4572 POST_IO
4573RET(12)
4574}
4575
4576// BTST
4577OPCODE(0x0139)
4578{
4579 u32 adr, res;
4580 u32 src, dst;
4581
4582 src = DREGu8((Opcode >> 9) & 7);
4583 src = 1 << (src & 7);
4584 FETCH_LONG(adr);
4585 PRE_IO
4586 READ_BYTE_F(adr, res)
4587 flag_NotZ = res & src;
4588 POST_IO
4589RET(16)
4590}
4591
4592// BTST
4593OPCODE(0x013A)
4594{
4595 u32 adr, res;
4596 u32 src, dst;
4597
4598 src = DREGu8((Opcode >> 9) & 7);
4599 src = 1 << (src & 7);
4600 adr = GET_SWORD + GET_PC;
4601 PC++;
4602 PRE_IO
4603 READ_BYTE_F(adr, res)
4604 flag_NotZ = res & src;
4605 POST_IO
4606RET(12)
4607}
4608
4609// BTST
4610OPCODE(0x013B)
4611{
4612 u32 adr, res;
4613 u32 src, dst;
4614
4615 src = DREGu8((Opcode >> 9) & 7);
4616 src = 1 << (src & 7);
4617 adr = (uptr)(PC) - BasePC;
4618 DECODE_EXT_WORD
4619 PRE_IO
4620 READ_BYTE_F(adr, res)
4621 flag_NotZ = res & src;
4622 POST_IO
4623RET(14)
4624}
4625
4626// BTST
4627OPCODE(0x013C)
4628{
4629 u32 adr, res;
4630 u32 src, dst;
4631
4632 src = DREGu8((Opcode >> 9) & 7);
4633 src = 1 << (src & 7);
4634 FETCH_BYTE(res);
4635 flag_NotZ = res & src;
4636RET(10)
4637}
4638
4639// BTST
4640OPCODE(0x011F)
4641{
4642 u32 adr, res;
4643 u32 src, dst;
4644
4645 src = DREGu8((Opcode >> 9) & 7);
4646 src = 1 << (src & 7);
4647 adr = AREG(7);
4648 AREG(7) += 2;
4649 PRE_IO
4650 READ_BYTE_F(adr, res)
4651 flag_NotZ = res & src;
4652 POST_IO
4653RET(8)
4654}
4655
4656// BTST
4657OPCODE(0x0127)
4658{
4659 u32 adr, res;
4660 u32 src, dst;
4661
4662 src = DREGu8((Opcode >> 9) & 7);
4663 src = 1 << (src & 7);
4664 adr = AREG(7) - 2;
4665 AREG(7) = adr;
4666 PRE_IO
4667 READ_BYTE_F(adr, res)
4668 flag_NotZ = res & src;
4669 POST_IO
4670RET(10)
4671}
4672
4673// BCHG
4674OPCODE(0x0140)
4675{
4676 u32 adr, res;
4677 u32 src, dst;
4678
4679 src = DREGu32((Opcode >> 9) & 7);
4680 src = 1 << (src & 31);
4681 res = DREGu32((Opcode >> 0) & 7);
4682 flag_NotZ = res & src;
4683 res ^= src;
4684 DREGu32((Opcode >> 0) & 7) = res;
4685#ifdef USE_CYCLONE_TIMING
4686 if (src >> 16) ctx->io_cycle_counter -= 2;
4687RET(6)
4688#else
4689RET(8)
4690#endif
4691}
4692
4693// BCHG
4694OPCODE(0x0150)
4695{
4696 u32 adr, res;
4697 u32 src, dst;
4698
4699 src = DREGu8((Opcode >> 9) & 7);
4700 src = 1 << (src & 7);
4701 adr = AREG((Opcode >> 0) & 7);
4702 PRE_IO
4703 READ_BYTE_F(adr, res)
4704 flag_NotZ = res & src;
4705 res ^= src;
4706 WRITE_BYTE_F(adr, res)
4707 POST_IO
4708RET(12)
4709}
4710
4711// BCHG
4712OPCODE(0x0158)
4713{
4714 u32 adr, res;
4715 u32 src, dst;
4716
4717 src = DREGu8((Opcode >> 9) & 7);
4718 src = 1 << (src & 7);
4719 adr = AREG((Opcode >> 0) & 7);
4720 AREG((Opcode >> 0) & 7) += 1;
4721 PRE_IO
4722 READ_BYTE_F(adr, res)
4723 flag_NotZ = res & src;
4724 res ^= src;
4725 WRITE_BYTE_F(adr, res)
4726 POST_IO
4727RET(12)
4728}
4729
4730// BCHG
4731OPCODE(0x0160)
4732{
4733 u32 adr, res;
4734 u32 src, dst;
4735
4736 src = DREGu8((Opcode >> 9) & 7);
4737 src = 1 << (src & 7);
4738 adr = AREG((Opcode >> 0) & 7) - 1;
4739 AREG((Opcode >> 0) & 7) = adr;
4740 PRE_IO
4741 READ_BYTE_F(adr, res)
4742 flag_NotZ = res & src;
4743 res ^= src;
4744 WRITE_BYTE_F(adr, res)
4745 POST_IO
4746RET(14)
4747}
4748
4749// BCHG
4750OPCODE(0x0168)
4751{
4752 u32 adr, res;
4753 u32 src, dst;
4754
4755 src = DREGu8((Opcode >> 9) & 7);
4756 src = 1 << (src & 7);
4757 FETCH_SWORD(adr);
4758 adr += AREG((Opcode >> 0) & 7);
4759 PRE_IO
4760 READ_BYTE_F(adr, res)
4761 flag_NotZ = res & src;
4762 res ^= src;
4763 WRITE_BYTE_F(adr, res)
4764 POST_IO
4765RET(16)
4766}
4767
4768// BCHG
4769OPCODE(0x0170)
4770{
4771 u32 adr, res;
4772 u32 src, dst;
4773
4774 src = DREGu8((Opcode >> 9) & 7);
4775 src = 1 << (src & 7);
4776 adr = AREG((Opcode >> 0) & 7);
4777 DECODE_EXT_WORD
4778 PRE_IO
4779 READ_BYTE_F(adr, res)
4780 flag_NotZ = res & src;
4781 res ^= src;
4782 WRITE_BYTE_F(adr, res)
4783 POST_IO
4784RET(18)
4785}
4786
4787// BCHG
4788OPCODE(0x0178)
4789{
4790 u32 adr, res;
4791 u32 src, dst;
4792
4793 src = DREGu8((Opcode >> 9) & 7);
4794 src = 1 << (src & 7);
4795 FETCH_SWORD(adr);
4796 PRE_IO
4797 READ_BYTE_F(adr, res)
4798 flag_NotZ = res & src;
4799 res ^= src;
4800 WRITE_BYTE_F(adr, res)
4801 POST_IO
4802RET(16)
4803}
4804
4805// BCHG
4806OPCODE(0x0179)
4807{
4808 u32 adr, res;
4809 u32 src, dst;
4810
4811 src = DREGu8((Opcode >> 9) & 7);
4812 src = 1 << (src & 7);
4813 FETCH_LONG(adr);
4814 PRE_IO
4815 READ_BYTE_F(adr, res)
4816 flag_NotZ = res & src;
4817 res ^= src;
4818 WRITE_BYTE_F(adr, res)
4819 POST_IO
4820RET(20)
4821}
4822
4823// BCHG
4824OPCODE(0x015F)
4825{
4826 u32 adr, res;
4827 u32 src, dst;
4828
4829 src = DREGu8((Opcode >> 9) & 7);
4830 src = 1 << (src & 7);
4831 adr = AREG(7);
4832 AREG(7) += 2;
4833 PRE_IO
4834 READ_BYTE_F(adr, res)
4835 flag_NotZ = res & src;
4836 res ^= src;
4837 WRITE_BYTE_F(adr, res)
4838 POST_IO
4839RET(12)
4840}
4841
4842// BCHG
4843OPCODE(0x0167)
4844{
4845 u32 adr, res;
4846 u32 src, dst;
4847
4848 src = DREGu8((Opcode >> 9) & 7);
4849 src = 1 << (src & 7);
4850 adr = AREG(7) - 2;
4851 AREG(7) = adr;
4852 PRE_IO
4853 READ_BYTE_F(adr, res)
4854 flag_NotZ = res & src;
4855 res ^= src;
4856 WRITE_BYTE_F(adr, res)
4857 POST_IO
4858RET(14)
4859}
4860
4861// BCLR
4862OPCODE(0x0180)
4863{
4864 u32 adr, res;
4865 u32 src, dst;
4866
4867 src = DREGu32((Opcode >> 9) & 7);
4868 src = 1 << (src & 31);
4869 res = DREGu32((Opcode >> 0) & 7);
4870 flag_NotZ = res & src;
4871 res &= ~src;
4872 DREGu32((Opcode >> 0) & 7) = res;
4873#ifdef USE_CYCLONE_TIMING
4874 if (src >> 16) ctx->io_cycle_counter -= 2;
4875RET(8)
4876#else
4877RET(10)
4878#endif
4879}
4880
4881// BCLR
4882OPCODE(0x0190)
4883{
4884 u32 adr, res;
4885 u32 src, dst;
4886
4887 src = DREGu8((Opcode >> 9) & 7);
4888 src = 1 << (src & 7);
4889 adr = AREG((Opcode >> 0) & 7);
4890 PRE_IO
4891 READ_BYTE_F(adr, res)
4892 flag_NotZ = res & src;
4893 res &= ~src;
4894 WRITE_BYTE_F(adr, res)
4895 POST_IO
4896RET(12)
4897}
4898
4899// BCLR
4900OPCODE(0x0198)
4901{
4902 u32 adr, res;
4903 u32 src, dst;
4904
4905 src = DREGu8((Opcode >> 9) & 7);
4906 src = 1 << (src & 7);
4907 adr = AREG((Opcode >> 0) & 7);
4908 AREG((Opcode >> 0) & 7) += 1;
4909 PRE_IO
4910 READ_BYTE_F(adr, res)
4911 flag_NotZ = res & src;
4912 res &= ~src;
4913 WRITE_BYTE_F(adr, res)
4914 POST_IO
4915RET(12)
4916}
4917
4918// BCLR
4919OPCODE(0x01A0)
4920{
4921 u32 adr, res;
4922 u32 src, dst;
4923
4924 src = DREGu8((Opcode >> 9) & 7);
4925 src = 1 << (src & 7);
4926 adr = AREG((Opcode >> 0) & 7) - 1;
4927 AREG((Opcode >> 0) & 7) = adr;
4928 PRE_IO
4929 READ_BYTE_F(adr, res)
4930 flag_NotZ = res & src;
4931 res &= ~src;
4932 WRITE_BYTE_F(adr, res)
4933 POST_IO
4934RET(14)
4935}
4936
4937// BCLR
4938OPCODE(0x01A8)
4939{
4940 u32 adr, res;
4941 u32 src, dst;
4942
4943 src = DREGu8((Opcode >> 9) & 7);
4944 src = 1 << (src & 7);
4945 FETCH_SWORD(adr);
4946 adr += AREG((Opcode >> 0) & 7);
4947 PRE_IO
4948 READ_BYTE_F(adr, res)
4949 flag_NotZ = res & src;
4950 res &= ~src;
4951 WRITE_BYTE_F(adr, res)
4952 POST_IO
4953RET(16)
4954}
4955
4956// BCLR
4957OPCODE(0x01B0)
4958{
4959 u32 adr, res;
4960 u32 src, dst;
4961
4962 src = DREGu8((Opcode >> 9) & 7);
4963 src = 1 << (src & 7);
4964 adr = AREG((Opcode >> 0) & 7);
4965 DECODE_EXT_WORD
4966 PRE_IO
4967 READ_BYTE_F(adr, res)
4968 flag_NotZ = res & src;
4969 res &= ~src;
4970 WRITE_BYTE_F(adr, res)
4971 POST_IO
4972RET(18)
4973}
4974
4975// BCLR
4976OPCODE(0x01B8)
4977{
4978 u32 adr, res;
4979 u32 src, dst;
4980
4981 src = DREGu8((Opcode >> 9) & 7);
4982 src = 1 << (src & 7);
4983 FETCH_SWORD(adr);
4984 PRE_IO
4985 READ_BYTE_F(adr, res)
4986 flag_NotZ = res & src;
4987 res &= ~src;
4988 WRITE_BYTE_F(adr, res)
4989 POST_IO
4990RET(16)
4991}
4992
4993// BCLR
4994OPCODE(0x01B9)
4995{
4996 u32 adr, res;
4997 u32 src, dst;
4998
4999 src = DREGu8((Opcode >> 9) & 7);
5000 src = 1 << (src & 7);
5001 FETCH_LONG(adr);
5002 PRE_IO
5003 READ_BYTE_F(adr, res)
5004 flag_NotZ = res & src;
5005 res &= ~src;
5006 WRITE_BYTE_F(adr, res)
5007 POST_IO
5008RET(20)
5009}
5010
5011// BCLR
5012OPCODE(0x019F)
5013{
5014 u32 adr, res;
5015 u32 src, dst;
5016
5017 src = DREGu8((Opcode >> 9) & 7);
5018 src = 1 << (src & 7);
5019 adr = AREG(7);
5020 AREG(7) += 2;
5021 PRE_IO
5022 READ_BYTE_F(adr, res)
5023 flag_NotZ = res & src;
5024 res &= ~src;
5025 WRITE_BYTE_F(adr, res)
5026 POST_IO
5027RET(12)
5028}
5029
5030// BCLR
5031OPCODE(0x01A7)
5032{
5033 u32 adr, res;
5034 u32 src, dst;
5035
5036 src = DREGu8((Opcode >> 9) & 7);
5037 src = 1 << (src & 7);
5038 adr = AREG(7) - 2;
5039 AREG(7) = adr;
5040 PRE_IO
5041 READ_BYTE_F(adr, res)
5042 flag_NotZ = res & src;
5043 res &= ~src;
5044 WRITE_BYTE_F(adr, res)
5045 POST_IO
5046RET(14)
5047}
5048
5049// BSET
5050OPCODE(0x01C0)
5051{
5052 u32 adr, res;
5053 u32 src, dst;
5054
5055 src = DREGu32((Opcode >> 9) & 7);
5056 src = 1 << (src & 31);
5057 res = DREGu32((Opcode >> 0) & 7);
5058 flag_NotZ = res & src;
5059 res |= src;
5060 DREGu32((Opcode >> 0) & 7) = res;
5061#ifdef USE_CYCLONE_TIMING
5062 if (src >> 16) ctx->io_cycle_counter -= 2;
5063RET(6)
5064#else
5065RET(8)
5066#endif
5067}
5068
5069// BSET
5070OPCODE(0x01D0)
5071{
5072 u32 adr, res;
5073 u32 src, dst;
5074
5075 src = DREGu8((Opcode >> 9) & 7);
5076 src = 1 << (src & 7);
5077 adr = AREG((Opcode >> 0) & 7);
5078 PRE_IO
5079 READ_BYTE_F(adr, res)
5080 flag_NotZ = res & src;
5081 res |= src;
5082 WRITE_BYTE_F(adr, res)
5083 POST_IO
5084RET(12)
5085}
5086
5087// BSET
5088OPCODE(0x01D8)
5089{
5090 u32 adr, res;
5091 u32 src, dst;
5092
5093 src = DREGu8((Opcode >> 9) & 7);
5094 src = 1 << (src & 7);
5095 adr = AREG((Opcode >> 0) & 7);
5096 AREG((Opcode >> 0) & 7) += 1;
5097 PRE_IO
5098 READ_BYTE_F(adr, res)
5099 flag_NotZ = res & src;
5100 res |= src;
5101 WRITE_BYTE_F(adr, res)
5102 POST_IO
5103RET(12)
5104}
5105
5106// BSET
5107OPCODE(0x01E0)
5108{
5109 u32 adr, res;
5110 u32 src, dst;
5111
5112 src = DREGu8((Opcode >> 9) & 7);
5113 src = 1 << (src & 7);
5114 adr = AREG((Opcode >> 0) & 7) - 1;
5115 AREG((Opcode >> 0) & 7) = adr;
5116 PRE_IO
5117 READ_BYTE_F(adr, res)
5118 flag_NotZ = res & src;
5119 res |= src;
5120 WRITE_BYTE_F(adr, res)
5121 POST_IO
5122RET(14)
5123}
5124
5125// BSET
5126OPCODE(0x01E8)
5127{
5128 u32 adr, res;
5129 u32 src, dst;
5130
5131 src = DREGu8((Opcode >> 9) & 7);
5132 src = 1 << (src & 7);
5133 FETCH_SWORD(adr);
5134 adr += AREG((Opcode >> 0) & 7);
5135 PRE_IO
5136 READ_BYTE_F(adr, res)
5137 flag_NotZ = res & src;
5138 res |= src;
5139 WRITE_BYTE_F(adr, res)
5140 POST_IO
5141RET(16)
5142}
5143
5144// BSET
5145OPCODE(0x01F0)
5146{
5147 u32 adr, res;
5148 u32 src, dst;
5149
5150 src = DREGu8((Opcode >> 9) & 7);
5151 src = 1 << (src & 7);
5152 adr = AREG((Opcode >> 0) & 7);
5153 DECODE_EXT_WORD
5154 PRE_IO
5155 READ_BYTE_F(adr, res)
5156 flag_NotZ = res & src;
5157 res |= src;
5158 WRITE_BYTE_F(adr, res)
5159 POST_IO
5160RET(18)
5161}
5162
5163// BSET
5164OPCODE(0x01F8)
5165{
5166 u32 adr, res;
5167 u32 src, dst;
5168
5169 src = DREGu8((Opcode >> 9) & 7);
5170 src = 1 << (src & 7);
5171 FETCH_SWORD(adr);
5172 PRE_IO
5173 READ_BYTE_F(adr, res)
5174 flag_NotZ = res & src;
5175 res |= src;
5176 WRITE_BYTE_F(adr, res)
5177 POST_IO
5178RET(16)
5179}
5180
5181// BSET
5182OPCODE(0x01F9)
5183{
5184 u32 adr, res;
5185 u32 src, dst;
5186
5187 src = DREGu8((Opcode >> 9) & 7);
5188 src = 1 << (src & 7);
5189 FETCH_LONG(adr);
5190 PRE_IO
5191 READ_BYTE_F(adr, res)
5192 flag_NotZ = res & src;
5193 res |= src;
5194 WRITE_BYTE_F(adr, res)
5195 POST_IO
5196RET(20)
5197}
5198
5199// BSET
5200OPCODE(0x01DF)
5201{
5202 u32 adr, res;
5203 u32 src, dst;
5204
5205 src = DREGu8((Opcode >> 9) & 7);
5206 src = 1 << (src & 7);
5207 adr = AREG(7);
5208 AREG(7) += 2;
5209 PRE_IO
5210 READ_BYTE_F(adr, res)
5211 flag_NotZ = res & src;
5212 res |= src;
5213 WRITE_BYTE_F(adr, res)
5214 POST_IO
5215RET(12)
5216}
5217
5218// BSET
5219OPCODE(0x01E7)
5220{
5221 u32 adr, res;
5222 u32 src, dst;
5223
5224 src = DREGu8((Opcode >> 9) & 7);
5225 src = 1 << (src & 7);
5226 adr = AREG(7) - 2;
5227 AREG(7) = adr;
5228 PRE_IO
5229 READ_BYTE_F(adr, res)
5230 flag_NotZ = res & src;
5231 res |= src;
5232 WRITE_BYTE_F(adr, res)
5233 POST_IO
5234RET(14)
5235}
5236
5237// MOVEPWaD
5238OPCODE(0x0108)
5239{
5240 u32 adr, res;
5241 u32 src, dst;
5242
5243 FETCH_SWORD(adr);
5244 adr += AREG((Opcode >> 0) & 7);
5245 PRE_IO
5246 READ_BYTE_F(adr + 0, res)
5247 READ_BYTE_F(adr + 2, src)
5248 DREGu16((Opcode >> 9) & 7) = (res << 8) | src;
5249 POST_IO
5250#ifdef USE_CYCLONE_TIMING
5251RET(16)
5252#else
5253RET(24)
5254#endif
5255}
5256
5257// MOVEPLaD
5258OPCODE(0x0148)
5259{
5260 u32 adr, res;
5261 u32 src, dst;
5262
5263 FETCH_SWORD(adr);
5264 adr += AREG((Opcode >> 0) & 7);
5265 PRE_IO
5266 READ_BYTE_F(adr, res)
5267 res <<= 24;
5268 adr += 2;
5269 READ_BYTE_F(adr, src)
5270 res |= src << 16;
5271 adr += 2;
5272 READ_BYTE_F(adr, src)
5273 res |= src << 8;
5274 adr += 2;
5275 READ_BYTE_F(adr, src)
5276 DREG((Opcode >> 9) & 7) = res | src;
5277 POST_IO
5278#ifdef USE_CYCLONE_TIMING
5279RET(24)
5280#else
5281RET(32)
5282#endif
5283}
5284
5285// MOVEPWDa
5286OPCODE(0x0188)
5287{
5288 u32 adr, res;
5289 u32 src, dst;
5290
5291 res = DREGu32((Opcode >> 9) & 7);
5292 FETCH_SWORD(adr);
5293 adr += AREG((Opcode >> 0) & 7);
5294 PRE_IO
5295 WRITE_BYTE_F(adr + 0, res >> 8)
5296 WRITE_BYTE_F(adr + 2, res >> 0)
5297 POST_IO
5298#ifdef USE_CYCLONE_TIMING
5299RET(16)
5300#else
5301RET(24)
5302#endif
5303}
5304
5305// MOVEPLDa
5306OPCODE(0x01C8)
5307{
5308 u32 adr, res;
5309 u32 src, dst;
5310
5311 res = DREGu32((Opcode >> 9) & 7);
5312 FETCH_SWORD(adr);
5313 adr += AREG((Opcode >> 0) & 7);
5314 PRE_IO
5315 WRITE_BYTE_F(adr, res >> 24)
5316 adr += 2;
5317 WRITE_BYTE_F(adr, res >> 16)
5318 adr += 2;
5319 WRITE_BYTE_F(adr, res >> 8)
5320 adr += 2;
5321 WRITE_BYTE_F(adr, res >> 0)
5322 POST_IO
5323#ifdef USE_CYCLONE_TIMING
5324RET(24)
5325#else
5326RET(32)
5327#endif
5328}
5329
5330// MOVEB
5331OPCODE(0x1000)
5332{
5333 u32 adr, res;
5334 u32 src, dst;
5335
5336 res = DREGu8((Opcode >> 0) & 7);
5337 flag_C = 0;
5338 flag_V = 0;
5339 flag_NotZ = res;
5340 flag_N = res;
5341 DREGu8((Opcode >> 9) & 7) = res;
5342RET(4)
5343}
5344
5345// MOVEB
5346OPCODE(0x1080)
5347{
5348 u32 adr, res;
5349 u32 src, dst;
5350
5351 res = DREGu8((Opcode >> 0) & 7);
5352 flag_C = 0;
5353 flag_V = 0;
5354 flag_NotZ = res;
5355 flag_N = res;
5356 adr = AREG((Opcode >> 9) & 7);
5357 PRE_IO
5358 WRITE_BYTE_F(adr, res)
5359 POST_IO
5360RET(8)
5361}
5362
5363// MOVEB
5364OPCODE(0x10C0)
5365{
5366 u32 adr, res;
5367 u32 src, dst;
5368
5369 res = DREGu8((Opcode >> 0) & 7);
5370 flag_C = 0;
5371 flag_V = 0;
5372 flag_NotZ = res;
5373 flag_N = res;
5374 adr = AREG((Opcode >> 9) & 7);
5375 AREG((Opcode >> 9) & 7) += 1;
5376 PRE_IO
5377 WRITE_BYTE_F(adr, res)
5378 POST_IO
5379RET(8)
5380}
5381
5382// MOVEB
5383OPCODE(0x1100)
5384{
5385 u32 adr, res;
5386 u32 src, dst;
5387
5388 res = DREGu8((Opcode >> 0) & 7);
5389 flag_C = 0;
5390 flag_V = 0;
5391 flag_NotZ = res;
5392 flag_N = res;
5393 adr = AREG((Opcode >> 9) & 7) - 1;
5394 AREG((Opcode >> 9) & 7) = adr;
5395 PRE_IO
5396 WRITE_BYTE_F(adr, res)
5397 POST_IO
5398RET(8)
5399}
5400
5401// MOVEB
5402OPCODE(0x1140)
5403{
5404 u32 adr, res;
5405 u32 src, dst;
5406
5407 res = DREGu8((Opcode >> 0) & 7);
5408 flag_C = 0;
5409 flag_V = 0;
5410 flag_NotZ = res;
5411 flag_N = res;
5412 FETCH_SWORD(adr);
5413 adr += AREG((Opcode >> 9) & 7);
5414 PRE_IO
5415 WRITE_BYTE_F(adr, res)
5416 POST_IO
5417RET(12)
5418}
5419
5420// MOVEB
5421OPCODE(0x1180)
5422{
5423 u32 adr, res;
5424 u32 src, dst;
5425
5426 res = DREGu8((Opcode >> 0) & 7);
5427 flag_C = 0;
5428 flag_V = 0;
5429 flag_NotZ = res;
5430 flag_N = res;
5431 adr = AREG((Opcode >> 9) & 7);
5432 DECODE_EXT_WORD
5433 PRE_IO
5434 WRITE_BYTE_F(adr, res)
5435 POST_IO
5436RET(14)
5437}
5438
5439// MOVEB
5440OPCODE(0x11C0)
5441{
5442 u32 adr, res;
5443 u32 src, dst;
5444
5445 res = DREGu8((Opcode >> 0) & 7);
5446 flag_C = 0;
5447 flag_V = 0;
5448 flag_NotZ = res;
5449 flag_N = res;
5450 FETCH_SWORD(adr);
5451 PRE_IO
5452 WRITE_BYTE_F(adr, res)
5453 POST_IO
5454RET(12)
5455}
5456
5457// MOVEB
5458OPCODE(0x13C0)
5459{
5460 u32 adr, res;
5461 u32 src, dst;
5462
5463 res = DREGu8((Opcode >> 0) & 7);
5464 flag_C = 0;
5465 flag_V = 0;
5466 flag_NotZ = res;
5467 flag_N = res;
5468 FETCH_LONG(adr);
5469 PRE_IO
5470 WRITE_BYTE_F(adr, res)
5471 POST_IO
5472RET(16)
5473}
5474
5475// MOVEB
5476OPCODE(0x1EC0)
5477{
5478 u32 adr, res;
5479 u32 src, dst;
5480
5481 res = DREGu8((Opcode >> 0) & 7);
5482 flag_C = 0;
5483 flag_V = 0;
5484 flag_NotZ = res;
5485 flag_N = res;
5486 adr = AREG(7);
5487 AREG(7) += 2;
5488 PRE_IO
5489 WRITE_BYTE_F(adr, res)
5490 POST_IO
5491RET(8)
5492}
5493
5494// MOVEB
5495OPCODE(0x1F00)
5496{
5497 u32 adr, res;
5498 u32 src, dst;
5499
5500 res = DREGu8((Opcode >> 0) & 7);
5501 flag_C = 0;
5502 flag_V = 0;
5503 flag_NotZ = res;
5504 flag_N = res;
5505 adr = AREG(7) - 2;
5506 AREG(7) = adr;
5507 PRE_IO
5508 WRITE_BYTE_F(adr, res)
5509 POST_IO
5510RET(8)
5511}
5512
5513#if 0
5514// MOVEB
5515OPCODE(0x1008)
5516{
5517 u32 adr, res;
5518 u32 src, dst;
5519
5520 // can't read byte from Ax registers !
5521 ctx->execinfo |= M68K_FAULTED;
5522 ctx->io_cycle_counter = 0;
5523/*
5524 goto famec_Exec_End;
5525 flag_C = 0;
5526 flag_V = 0;
5527 flag_NotZ = res;
5528 flag_N = res;
5529 DREGu8((Opcode >> 9) & 7) = res;
5530*/
5531RET(4)
5532}
5533
5534// MOVEB
5535OPCODE(0x1088)
5536{
5537 u32 adr, res;
5538 u32 src, dst;
5539
5540 // can't read byte from Ax registers !
5541 ctx->execinfo |= M68K_FAULTED;
5542 ctx->io_cycle_counter = 0;
5543/*
5544 goto famec_Exec_End;
5545 flag_C = 0;
5546 flag_V = 0;
5547 flag_NotZ = res;
5548 flag_N = res;
5549 adr = AREG((Opcode >> 9) & 7);
5550 PRE_IO
5551 WRITE_BYTE_F(adr, res)
5552 POST_IO
5553*/
5554RET(8)
5555}
5556
5557// MOVEB
5558OPCODE(0x10C8)
5559{
5560 u32 adr, res;
5561 u32 src, dst;
5562
5563 // can't read byte from Ax registers !
5564 ctx->execinfo |= M68K_FAULTED;
5565 ctx->io_cycle_counter = 0;
5566/*
5567 goto famec_Exec_End;
5568 flag_C = 0;
5569 flag_V = 0;
5570 flag_NotZ = res;
5571 flag_N = res;
5572 adr = AREG((Opcode >> 9) & 7);
5573 AREG((Opcode >> 9) & 7) += 1;
5574 PRE_IO
5575 WRITE_BYTE_F(adr, res)
5576 POST_IO
5577*/
5578RET(8)
5579}
5580
5581// MOVEB
5582OPCODE(0x1108)
5583{
5584 u32 adr, res;
5585 u32 src, dst;
5586
5587 // can't read byte from Ax registers !
5588 ctx->execinfo |= M68K_FAULTED;
5589 ctx->io_cycle_counter = 0;
5590/*
5591 goto famec_Exec_End;
5592 flag_C = 0;
5593 flag_V = 0;
5594 flag_NotZ = res;
5595 flag_N = res;
5596 adr = AREG((Opcode >> 9) & 7) - 1;
5597 AREG((Opcode >> 9) & 7) = adr;
5598 PRE_IO
5599 WRITE_BYTE_F(adr, res)
5600 POST_IO
5601*/
5602RET(8)
5603}
5604
5605// MOVEB
5606OPCODE(0x1148)
5607{
5608 u32 adr, res;
5609 u32 src, dst;
5610
5611 // can't read byte from Ax registers !
5612 ctx->execinfo |= M68K_FAULTED;
5613 ctx->io_cycle_counter = 0;
5614/*
5615 goto famec_Exec_End;
5616 flag_C = 0;
5617 flag_V = 0;
5618 flag_NotZ = res;
5619 flag_N = res;
5620 FETCH_SWORD(adr);
5621 adr += AREG((Opcode >> 9) & 7);
5622 PRE_IO
5623 WRITE_BYTE_F(adr, res)
5624 POST_IO
5625*/
5626RET(12)
5627}
5628
5629// MOVEB
5630OPCODE(0x1188)
5631{
5632 u32 adr, res;
5633 u32 src, dst;
5634
5635 // can't read byte from Ax registers !
5636 ctx->execinfo |= M68K_FAULTED;
5637 ctx->io_cycle_counter = 0;
5638/*
5639 goto famec_Exec_End;
5640 flag_C = 0;
5641 flag_V = 0;
5642 flag_NotZ = res;
5643 flag_N = res;
5644 adr = AREG((Opcode >> 9) & 7);
5645 DECODE_EXT_WORD
5646 PRE_IO
5647 WRITE_BYTE_F(adr, res)
5648 POST_IO
5649*/
5650RET(14)
5651}
5652
5653// MOVEB
5654OPCODE(0x11C8)
5655{
5656 u32 adr, res;
5657 u32 src, dst;
5658
5659 // can't read byte from Ax registers !
5660 ctx->execinfo |= M68K_FAULTED;
5661 ctx->io_cycle_counter = 0;
5662/*
5663 goto famec_Exec_End;
5664 flag_C = 0;
5665 flag_V = 0;
5666 flag_NotZ = res;
5667 flag_N = res;
5668 FETCH_SWORD(adr);
5669 PRE_IO
5670 WRITE_BYTE_F(adr, res)
5671 POST_IO
5672*/
5673RET(12)
5674}
5675
5676// MOVEB
5677OPCODE(0x13C8)
5678{
5679 u32 adr, res;
5680 u32 src, dst;
5681
5682 // can't read byte from Ax registers !
5683 ctx->execinfo |= M68K_FAULTED;
5684 ctx->io_cycle_counter = 0;
5685/*
5686 goto famec_Exec_End;
5687 flag_C = 0;
5688 flag_V = 0;
5689 flag_NotZ = res;
5690 flag_N = res;
5691 FETCH_LONG(adr);
5692 PRE_IO
5693 WRITE_BYTE_F(adr, res)
5694 POST_IO
5695*/
5696RET(16)
5697}
5698
5699// MOVEB
5700OPCODE(0x1EC8)
5701{
5702 u32 adr, res;
5703 u32 src, dst;
5704
5705 // can't read byte from Ax registers !
5706 ctx->execinfo |= M68K_FAULTED;
5707 ctx->io_cycle_counter = 0;
5708/*
5709 goto famec_Exec_End;
5710 flag_C = 0;
5711 flag_V = 0;
5712 flag_NotZ = res;
5713 flag_N = res;
5714 adr = AREG(7);
5715 AREG(7) += 2;
5716 PRE_IO
5717 WRITE_BYTE_F(adr, res)
5718 POST_IO
5719*/
5720RET(8)
5721}
5722
5723// MOVEB
5724OPCODE(0x1F08)
5725{
5726 u32 adr, res;
5727 u32 src, dst;
5728
5729 // can't read byte from Ax registers !
5730 ctx->execinfo |= M68K_FAULTED;
5731 ctx->io_cycle_counter = 0;
5732/*
5733 goto famec_Exec_End;
5734 flag_C = 0;
5735 flag_V = 0;
5736 flag_NotZ = res;
5737 flag_N = res;
5738 adr = AREG(7) - 2;
5739 AREG(7) = adr;
5740 PRE_IO
5741 WRITE_BYTE_F(adr, res)
5742 POST_IO
5743*/
5744RET(8)
5745}
5746#endif
5747
5748// MOVEB
5749OPCODE(0x1010)
5750{
5751 u32 adr, res;
5752 u32 src, dst;
5753
5754 adr = AREG((Opcode >> 0) & 7);
5755 PRE_IO
5756 READ_BYTE_F(adr, res)
5757 flag_C = 0;
5758 flag_V = 0;
5759 flag_NotZ = res;
5760 flag_N = res;
5761 DREGu8((Opcode >> 9) & 7) = res;
5762 POST_IO
5763RET(8)
5764}
5765
5766// MOVEB
5767OPCODE(0x1090)
5768{
5769 u32 adr, res;
5770 u32 src, dst;
5771
5772 adr = AREG((Opcode >> 0) & 7);
5773 PRE_IO
5774 READ_BYTE_F(adr, res)
5775 flag_C = 0;
5776 flag_V = 0;
5777 flag_NotZ = res;
5778 flag_N = res;
5779 adr = AREG((Opcode >> 9) & 7);
5780 WRITE_BYTE_F(adr, res)
5781 POST_IO
5782RET(12)
5783}
5784
5785// MOVEB
5786OPCODE(0x10D0)
5787{
5788 u32 adr, res;
5789 u32 src, dst;
5790
5791 adr = AREG((Opcode >> 0) & 7);
5792 PRE_IO
5793 READ_BYTE_F(adr, res)
5794 flag_C = 0;
5795 flag_V = 0;
5796 flag_NotZ = res;
5797 flag_N = res;
5798 adr = AREG((Opcode >> 9) & 7);
5799 AREG((Opcode >> 9) & 7) += 1;
5800 WRITE_BYTE_F(adr, res)
5801 POST_IO
5802RET(12)
5803}
5804
5805// MOVEB
5806OPCODE(0x1110)
5807{
5808 u32 adr, res;
5809 u32 src, dst;
5810
5811 adr = AREG((Opcode >> 0) & 7);
5812 PRE_IO
5813 READ_BYTE_F(adr, res)
5814 flag_C = 0;
5815 flag_V = 0;
5816 flag_NotZ = res;
5817 flag_N = res;
5818 adr = AREG((Opcode >> 9) & 7) - 1;
5819 AREG((Opcode >> 9) & 7) = adr;
5820 WRITE_BYTE_F(adr, res)
5821 POST_IO
5822RET(12)
5823}
5824
5825// MOVEB
5826OPCODE(0x1150)
5827{
5828 u32 adr, res;
5829 u32 src, dst;
5830
5831 adr = AREG((Opcode >> 0) & 7);
5832 PRE_IO
5833 READ_BYTE_F(adr, res)
5834 flag_C = 0;
5835 flag_V = 0;
5836 flag_NotZ = res;
5837 flag_N = res;
5838 FETCH_SWORD(adr);
5839 adr += AREG((Opcode >> 9) & 7);
5840 WRITE_BYTE_F(adr, res)
5841 POST_IO
5842RET(16)
5843}
5844
5845// MOVEB
5846OPCODE(0x1190)
5847{
5848 u32 adr, res;
5849 u32 src, dst;
5850
5851 adr = AREG((Opcode >> 0) & 7);
5852 PRE_IO
5853 READ_BYTE_F(adr, res)
5854 flag_C = 0;
5855 flag_V = 0;
5856 flag_NotZ = res;
5857 flag_N = res;
5858 adr = AREG((Opcode >> 9) & 7);
5859 DECODE_EXT_WORD
5860 WRITE_BYTE_F(adr, res)
5861 POST_IO
5862RET(18)
5863}
5864
5865// MOVEB
5866OPCODE(0x11D0)
5867{
5868 u32 adr, res;
5869 u32 src, dst;
5870
5871 adr = AREG((Opcode >> 0) & 7);
5872 PRE_IO
5873 READ_BYTE_F(adr, res)
5874 flag_C = 0;
5875 flag_V = 0;
5876 flag_NotZ = res;
5877 flag_N = res;
5878 FETCH_SWORD(adr);
5879 WRITE_BYTE_F(adr, res)
5880 POST_IO
5881RET(16)
5882}
5883
5884// MOVEB
5885OPCODE(0x13D0)
5886{
5887 u32 adr, res;
5888 u32 src, dst;
5889
5890 adr = AREG((Opcode >> 0) & 7);
5891 PRE_IO
5892 READ_BYTE_F(adr, res)
5893 flag_C = 0;
5894 flag_V = 0;
5895 flag_NotZ = res;
5896 flag_N = res;
5897 FETCH_LONG(adr);
5898 WRITE_BYTE_F(adr, res)
5899 POST_IO
5900RET(20)
5901}
5902
5903// MOVEB
5904OPCODE(0x1ED0)
5905{
5906 u32 adr, res;
5907 u32 src, dst;
5908
5909 adr = AREG((Opcode >> 0) & 7);
5910 PRE_IO
5911 READ_BYTE_F(adr, res)
5912 flag_C = 0;
5913 flag_V = 0;
5914 flag_NotZ = res;
5915 flag_N = res;
5916 adr = AREG(7);
5917 AREG(7) += 2;
5918 WRITE_BYTE_F(adr, res)
5919 POST_IO
5920RET(12)
5921}
5922
5923// MOVEB
5924OPCODE(0x1F10)
5925{
5926 u32 adr, res;
5927 u32 src, dst;
5928
5929 adr = AREG((Opcode >> 0) & 7);
5930 PRE_IO
5931 READ_BYTE_F(adr, res)
5932 flag_C = 0;
5933 flag_V = 0;
5934 flag_NotZ = res;
5935 flag_N = res;
5936 adr = AREG(7) - 2;
5937 AREG(7) = adr;
5938 WRITE_BYTE_F(adr, res)
5939 POST_IO
5940RET(12)
5941}
5942
5943// MOVEB
5944OPCODE(0x1018)
5945{
5946 u32 adr, res;
5947 u32 src, dst;
5948
5949 adr = AREG((Opcode >> 0) & 7);
5950 AREG((Opcode >> 0) & 7) += 1;
5951 PRE_IO
5952 READ_BYTE_F(adr, res)
5953 flag_C = 0;
5954 flag_V = 0;
5955 flag_NotZ = res;
5956 flag_N = res;
5957 DREGu8((Opcode >> 9) & 7) = res;
5958 POST_IO
5959RET(8)
5960}
5961
5962// MOVEB
5963OPCODE(0x1098)
5964{
5965 u32 adr, res;
5966 u32 src, dst;
5967
5968 adr = AREG((Opcode >> 0) & 7);
5969 AREG((Opcode >> 0) & 7) += 1;
5970 PRE_IO
5971 READ_BYTE_F(adr, res)
5972 flag_C = 0;
5973 flag_V = 0;
5974 flag_NotZ = res;
5975 flag_N = res;
5976 adr = AREG((Opcode >> 9) & 7);
5977 WRITE_BYTE_F(adr, res)
5978 POST_IO
5979RET(12)
5980}
5981
5982// MOVEB
5983OPCODE(0x10D8)
5984{
5985 u32 adr, res;
5986 u32 src, dst;
5987
5988 adr = AREG((Opcode >> 0) & 7);
5989 AREG((Opcode >> 0) & 7) += 1;
5990 PRE_IO
5991 READ_BYTE_F(adr, res)
5992 flag_C = 0;
5993 flag_V = 0;
5994 flag_NotZ = res;
5995 flag_N = res;
5996 adr = AREG((Opcode >> 9) & 7);
5997 AREG((Opcode >> 9) & 7) += 1;
5998 WRITE_BYTE_F(adr, res)
5999 POST_IO
6000RET(12)
6001}
6002
6003// MOVEB
6004OPCODE(0x1118)
6005{
6006 u32 adr, res;
6007 u32 src, dst;
6008
6009 adr = AREG((Opcode >> 0) & 7);
6010 AREG((Opcode >> 0) & 7) += 1;
6011 PRE_IO
6012 READ_BYTE_F(adr, res)
6013 flag_C = 0;
6014 flag_V = 0;
6015 flag_NotZ = res;
6016 flag_N = res;
6017 adr = AREG((Opcode >> 9) & 7) - 1;
6018 AREG((Opcode >> 9) & 7) = adr;
6019 WRITE_BYTE_F(adr, res)
6020 POST_IO
6021RET(12)
6022}
6023
6024// MOVEB
6025OPCODE(0x1158)
6026{
6027 u32 adr, res;
6028 u32 src, dst;
6029
6030 adr = AREG((Opcode >> 0) & 7);
6031 AREG((Opcode >> 0) & 7) += 1;
6032 PRE_IO
6033 READ_BYTE_F(adr, res)
6034 flag_C = 0;
6035 flag_V = 0;
6036 flag_NotZ = res;
6037 flag_N = res;
6038 FETCH_SWORD(adr);
6039 adr += AREG((Opcode >> 9) & 7);
6040 WRITE_BYTE_F(adr, res)
6041 POST_IO
6042RET(16)
6043}
6044
6045// MOVEB
6046OPCODE(0x1198)
6047{
6048 u32 adr, res;
6049 u32 src, dst;
6050
6051 adr = AREG((Opcode >> 0) & 7);
6052 AREG((Opcode >> 0) & 7) += 1;
6053 PRE_IO
6054 READ_BYTE_F(adr, res)
6055 flag_C = 0;
6056 flag_V = 0;
6057 flag_NotZ = res;
6058 flag_N = res;
6059 adr = AREG((Opcode >> 9) & 7);
6060 DECODE_EXT_WORD
6061 WRITE_BYTE_F(adr, res)
6062 POST_IO
6063RET(18)
6064}
6065
6066// MOVEB
6067OPCODE(0x11D8)
6068{
6069 u32 adr, res;
6070 u32 src, dst;
6071
6072 adr = AREG((Opcode >> 0) & 7);
6073 AREG((Opcode >> 0) & 7) += 1;
6074 PRE_IO
6075 READ_BYTE_F(adr, res)
6076 flag_C = 0;
6077 flag_V = 0;
6078 flag_NotZ = res;
6079 flag_N = res;
6080 FETCH_SWORD(adr);
6081 WRITE_BYTE_F(adr, res)
6082 POST_IO
6083RET(16)
6084}
6085
6086// MOVEB
6087OPCODE(0x13D8)
6088{
6089 u32 adr, res;
6090 u32 src, dst;
6091
6092 adr = AREG((Opcode >> 0) & 7);
6093 AREG((Opcode >> 0) & 7) += 1;
6094 PRE_IO
6095 READ_BYTE_F(adr, res)
6096 flag_C = 0;
6097 flag_V = 0;
6098 flag_NotZ = res;
6099 flag_N = res;
6100 FETCH_LONG(adr);
6101 WRITE_BYTE_F(adr, res)
6102 POST_IO
6103RET(20)
6104}
6105
6106// MOVEB
6107OPCODE(0x1ED8)
6108{
6109 u32 adr, res;
6110 u32 src, dst;
6111
6112 adr = AREG((Opcode >> 0) & 7);
6113 AREG((Opcode >> 0) & 7) += 1;
6114 PRE_IO
6115 READ_BYTE_F(adr, res)
6116 flag_C = 0;
6117 flag_V = 0;
6118 flag_NotZ = res;
6119 flag_N = res;
6120 adr = AREG(7);
6121 AREG(7) += 2;
6122 WRITE_BYTE_F(adr, res)
6123 POST_IO
6124RET(12)
6125}
6126
6127// MOVEB
6128OPCODE(0x1F18)
6129{
6130 u32 adr, res;
6131 u32 src, dst;
6132
6133 adr = AREG((Opcode >> 0) & 7);
6134 AREG((Opcode >> 0) & 7) += 1;
6135 PRE_IO
6136 READ_BYTE_F(adr, res)
6137 flag_C = 0;
6138 flag_V = 0;
6139 flag_NotZ = res;
6140 flag_N = res;
6141 adr = AREG(7) - 2;
6142 AREG(7) = adr;
6143 WRITE_BYTE_F(adr, res)
6144 POST_IO
6145RET(12)
6146}
6147
6148// MOVEB
6149OPCODE(0x1020)
6150{
6151 u32 adr, res;
6152 u32 src, dst;
6153
6154 adr = AREG((Opcode >> 0) & 7) - 1;
6155 AREG((Opcode >> 0) & 7) = adr;
6156 PRE_IO
6157 READ_BYTE_F(adr, res)
6158 flag_C = 0;
6159 flag_V = 0;
6160 flag_NotZ = res;
6161 flag_N = res;
6162 DREGu8((Opcode >> 9) & 7) = res;
6163 POST_IO
6164RET(10)
6165}
6166
6167// MOVEB
6168OPCODE(0x10A0)
6169{
6170 u32 adr, res;
6171 u32 src, dst;
6172
6173 adr = AREG((Opcode >> 0) & 7) - 1;
6174 AREG((Opcode >> 0) & 7) = adr;
6175 PRE_IO
6176 READ_BYTE_F(adr, res)
6177 flag_C = 0;
6178 flag_V = 0;
6179 flag_NotZ = res;
6180 flag_N = res;
6181 adr = AREG((Opcode >> 9) & 7);
6182 WRITE_BYTE_F(adr, res)
6183 POST_IO
6184RET(14)
6185}
6186
6187// MOVEB
6188OPCODE(0x10E0)
6189{
6190 u32 adr, res;
6191 u32 src, dst;
6192
6193 adr = AREG((Opcode >> 0) & 7) - 1;
6194 AREG((Opcode >> 0) & 7) = adr;
6195 PRE_IO
6196 READ_BYTE_F(adr, res)
6197 flag_C = 0;
6198 flag_V = 0;
6199 flag_NotZ = res;
6200 flag_N = res;
6201 adr = AREG((Opcode >> 9) & 7);
6202 AREG((Opcode >> 9) & 7) += 1;
6203 WRITE_BYTE_F(adr, res)
6204 POST_IO
6205RET(14)
6206}
6207
6208// MOVEB
6209OPCODE(0x1120)
6210{
6211 u32 adr, res;
6212 u32 src, dst;
6213
6214 adr = AREG((Opcode >> 0) & 7) - 1;
6215 AREG((Opcode >> 0) & 7) = adr;
6216 PRE_IO
6217 READ_BYTE_F(adr, res)
6218 flag_C = 0;
6219 flag_V = 0;
6220 flag_NotZ = res;
6221 flag_N = res;
6222 adr = AREG((Opcode >> 9) & 7) - 1;
6223 AREG((Opcode >> 9) & 7) = adr;
6224 WRITE_BYTE_F(adr, res)
6225 POST_IO
6226RET(14)
6227}
6228
6229// MOVEB
6230OPCODE(0x1160)
6231{
6232 u32 adr, res;
6233 u32 src, dst;
6234
6235 adr = AREG((Opcode >> 0) & 7) - 1;
6236 AREG((Opcode >> 0) & 7) = adr;
6237 PRE_IO
6238 READ_BYTE_F(adr, res)
6239 flag_C = 0;
6240 flag_V = 0;
6241 flag_NotZ = res;
6242 flag_N = res;
6243 FETCH_SWORD(adr);
6244 adr += AREG((Opcode >> 9) & 7);
6245 WRITE_BYTE_F(adr, res)
6246 POST_IO
6247RET(18)
6248}
6249
6250// MOVEB
6251OPCODE(0x11A0)
6252{
6253 u32 adr, res;
6254 u32 src, dst;
6255
6256 adr = AREG((Opcode >> 0) & 7) - 1;
6257 AREG((Opcode >> 0) & 7) = adr;
6258 PRE_IO
6259 READ_BYTE_F(adr, res)
6260 flag_C = 0;
6261 flag_V = 0;
6262 flag_NotZ = res;
6263 flag_N = res;
6264 adr = AREG((Opcode >> 9) & 7);
6265 DECODE_EXT_WORD
6266 WRITE_BYTE_F(adr, res)
6267 POST_IO
6268RET(20)
6269}
6270
6271// MOVEB
6272OPCODE(0x11E0)
6273{
6274 u32 adr, res;
6275 u32 src, dst;
6276
6277 adr = AREG((Opcode >> 0) & 7) - 1;
6278 AREG((Opcode >> 0) & 7) = adr;
6279 PRE_IO
6280 READ_BYTE_F(adr, res)
6281 flag_C = 0;
6282 flag_V = 0;
6283 flag_NotZ = res;
6284 flag_N = res;
6285 FETCH_SWORD(adr);
6286 WRITE_BYTE_F(adr, res)
6287 POST_IO
6288RET(18)
6289}
6290
6291// MOVEB
6292OPCODE(0x13E0)
6293{
6294 u32 adr, res;
6295 u32 src, dst;
6296
6297 adr = AREG((Opcode >> 0) & 7) - 1;
6298 AREG((Opcode >> 0) & 7) = adr;
6299 PRE_IO
6300 READ_BYTE_F(adr, res)
6301 flag_C = 0;
6302 flag_V = 0;
6303 flag_NotZ = res;
6304 flag_N = res;
6305 FETCH_LONG(adr);
6306 WRITE_BYTE_F(adr, res)
6307 POST_IO
6308RET(22)
6309}
6310
6311// MOVEB
6312OPCODE(0x1EE0)
6313{
6314 u32 adr, res;
6315 u32 src, dst;
6316
6317 adr = AREG((Opcode >> 0) & 7) - 1;
6318 AREG((Opcode >> 0) & 7) = adr;
6319 PRE_IO
6320 READ_BYTE_F(adr, res)
6321 flag_C = 0;
6322 flag_V = 0;
6323 flag_NotZ = res;
6324 flag_N = res;
6325 adr = AREG(7);
6326 AREG(7) += 2;
6327 WRITE_BYTE_F(adr, res)
6328 POST_IO
6329RET(14)
6330}
6331
6332// MOVEB
6333OPCODE(0x1F20)
6334{
6335 u32 adr, res;
6336 u32 src, dst;
6337
6338 adr = AREG((Opcode >> 0) & 7) - 1;
6339 AREG((Opcode >> 0) & 7) = adr;
6340 PRE_IO
6341 READ_BYTE_F(adr, res)
6342 flag_C = 0;
6343 flag_V = 0;
6344 flag_NotZ = res;
6345 flag_N = res;
6346 adr = AREG(7) - 2;
6347 AREG(7) = adr;
6348 WRITE_BYTE_F(adr, res)
6349 POST_IO
6350RET(14)
6351}
6352
6353// MOVEB
6354OPCODE(0x1028)
6355{
6356 u32 adr, res;
6357 u32 src, dst;
6358
6359 FETCH_SWORD(adr);
6360 adr += AREG((Opcode >> 0) & 7);
6361 PRE_IO
6362 READ_BYTE_F(adr, res)
6363 flag_C = 0;
6364 flag_V = 0;
6365 flag_NotZ = res;
6366 flag_N = res;
6367 DREGu8((Opcode >> 9) & 7) = res;
6368 POST_IO
6369RET(12)
6370}
6371
6372// MOVEB
6373OPCODE(0x10A8)
6374{
6375 u32 adr, res;
6376 u32 src, dst;
6377
6378 FETCH_SWORD(adr);
6379 adr += AREG((Opcode >> 0) & 7);
6380 PRE_IO
6381 READ_BYTE_F(adr, res)
6382 flag_C = 0;
6383 flag_V = 0;
6384 flag_NotZ = res;
6385 flag_N = res;
6386 adr = AREG((Opcode >> 9) & 7);
6387 WRITE_BYTE_F(adr, res)
6388 POST_IO
6389RET(16)
6390}
6391
6392// MOVEB
6393OPCODE(0x10E8)
6394{
6395 u32 adr, res;
6396 u32 src, dst;
6397
6398 FETCH_SWORD(adr);
6399 adr += AREG((Opcode >> 0) & 7);
6400 PRE_IO
6401 READ_BYTE_F(adr, res)
6402 flag_C = 0;
6403 flag_V = 0;
6404 flag_NotZ = res;
6405 flag_N = res;
6406 adr = AREG((Opcode >> 9) & 7);
6407 AREG((Opcode >> 9) & 7) += 1;
6408 WRITE_BYTE_F(adr, res)
6409 POST_IO
6410RET(16)
6411}
6412
6413// MOVEB
6414OPCODE(0x1128)
6415{
6416 u32 adr, res;
6417 u32 src, dst;
6418
6419 FETCH_SWORD(adr);
6420 adr += AREG((Opcode >> 0) & 7);
6421 PRE_IO
6422 READ_BYTE_F(adr, res)
6423 flag_C = 0;
6424 flag_V = 0;
6425 flag_NotZ = res;
6426 flag_N = res;
6427 adr = AREG((Opcode >> 9) & 7) - 1;
6428 AREG((Opcode >> 9) & 7) = adr;
6429 WRITE_BYTE_F(adr, res)
6430 POST_IO
6431RET(16)
6432}
6433
6434// MOVEB
6435OPCODE(0x1168)
6436{
6437 u32 adr, res;
6438 u32 src, dst;
6439
6440 FETCH_SWORD(adr);
6441 adr += AREG((Opcode >> 0) & 7);
6442 PRE_IO
6443 READ_BYTE_F(adr, res)
6444 flag_C = 0;
6445 flag_V = 0;
6446 flag_NotZ = res;
6447 flag_N = res;
6448 FETCH_SWORD(adr);
6449 adr += AREG((Opcode >> 9) & 7);
6450 WRITE_BYTE_F(adr, res)
6451 POST_IO
6452RET(20)
6453}
6454
6455// MOVEB
6456OPCODE(0x11A8)
6457{
6458 u32 adr, res;
6459 u32 src, dst;
6460
6461 FETCH_SWORD(adr);
6462 adr += AREG((Opcode >> 0) & 7);
6463 PRE_IO
6464 READ_BYTE_F(adr, res)
6465 flag_C = 0;
6466 flag_V = 0;
6467 flag_NotZ = res;
6468 flag_N = res;
6469 adr = AREG((Opcode >> 9) & 7);
6470 DECODE_EXT_WORD
6471 WRITE_BYTE_F(adr, res)
6472 POST_IO
6473RET(22)
6474}
6475
6476// MOVEB
6477OPCODE(0x11E8)
6478{
6479 u32 adr, res;
6480 u32 src, dst;
6481
6482 FETCH_SWORD(adr);
6483 adr += AREG((Opcode >> 0) & 7);
6484 PRE_IO
6485 READ_BYTE_F(adr, res)
6486 flag_C = 0;
6487 flag_V = 0;
6488 flag_NotZ = res;
6489 flag_N = res;
6490 FETCH_SWORD(adr);
6491 WRITE_BYTE_F(adr, res)
6492 POST_IO
6493RET(20)
6494}
6495
6496// MOVEB
6497OPCODE(0x13E8)
6498{
6499 u32 adr, res;
6500 u32 src, dst;
6501
6502 FETCH_SWORD(adr);
6503 adr += AREG((Opcode >> 0) & 7);
6504 PRE_IO
6505 READ_BYTE_F(adr, res)
6506 flag_C = 0;
6507 flag_V = 0;
6508 flag_NotZ = res;
6509 flag_N = res;
6510 FETCH_LONG(adr);
6511 WRITE_BYTE_F(adr, res)
6512 POST_IO
6513RET(24)
6514}
6515
6516// MOVEB
6517OPCODE(0x1EE8)
6518{
6519 u32 adr, res;
6520 u32 src, dst;
6521
6522 FETCH_SWORD(adr);
6523 adr += AREG((Opcode >> 0) & 7);
6524 PRE_IO
6525 READ_BYTE_F(adr, res)
6526 flag_C = 0;
6527 flag_V = 0;
6528 flag_NotZ = res;
6529 flag_N = res;
6530 adr = AREG(7);
6531 AREG(7) += 2;
6532 WRITE_BYTE_F(adr, res)
6533 POST_IO
6534RET(16)
6535}
6536
6537// MOVEB
6538OPCODE(0x1F28)
6539{
6540 u32 adr, res;
6541 u32 src, dst;
6542
6543 FETCH_SWORD(adr);
6544 adr += AREG((Opcode >> 0) & 7);
6545 PRE_IO
6546 READ_BYTE_F(adr, res)
6547 flag_C = 0;
6548 flag_V = 0;
6549 flag_NotZ = res;
6550 flag_N = res;
6551 adr = AREG(7) - 2;
6552 AREG(7) = adr;
6553 WRITE_BYTE_F(adr, res)
6554 POST_IO
6555RET(16)
6556}
6557
6558// MOVEB
6559OPCODE(0x1030)
6560{
6561 u32 adr, res;
6562 u32 src, dst;
6563
6564 adr = AREG((Opcode >> 0) & 7);
6565 DECODE_EXT_WORD
6566 PRE_IO
6567 READ_BYTE_F(adr, res)
6568 flag_C = 0;
6569 flag_V = 0;
6570 flag_NotZ = res;
6571 flag_N = res;
6572 DREGu8((Opcode >> 9) & 7) = res;
6573 POST_IO
6574RET(14)
6575}
6576
6577// MOVEB
6578OPCODE(0x10B0)
6579{
6580 u32 adr, res;
6581 u32 src, dst;
6582
6583 adr = AREG((Opcode >> 0) & 7);
6584 DECODE_EXT_WORD
6585 PRE_IO
6586 READ_BYTE_F(adr, res)
6587 flag_C = 0;
6588 flag_V = 0;
6589 flag_NotZ = res;
6590 flag_N = res;
6591 adr = AREG((Opcode >> 9) & 7);
6592 WRITE_BYTE_F(adr, res)
6593 POST_IO
6594RET(18)
6595}
6596
6597// MOVEB
6598OPCODE(0x10F0)
6599{
6600 u32 adr, res;
6601 u32 src, dst;
6602
6603 adr = AREG((Opcode >> 0) & 7);
6604 DECODE_EXT_WORD
6605 PRE_IO
6606 READ_BYTE_F(adr, res)
6607 flag_C = 0;
6608 flag_V = 0;
6609 flag_NotZ = res;
6610 flag_N = res;
6611 adr = AREG((Opcode >> 9) & 7);
6612 AREG((Opcode >> 9) & 7) += 1;
6613 WRITE_BYTE_F(adr, res)
6614 POST_IO
6615RET(18)
6616}
6617
6618// MOVEB
6619OPCODE(0x1130)
6620{
6621 u32 adr, res;
6622 u32 src, dst;
6623
6624 adr = AREG((Opcode >> 0) & 7);
6625 DECODE_EXT_WORD
6626 PRE_IO
6627 READ_BYTE_F(adr, res)
6628 flag_C = 0;
6629 flag_V = 0;
6630 flag_NotZ = res;
6631 flag_N = res;
6632 adr = AREG((Opcode >> 9) & 7) - 1;
6633 AREG((Opcode >> 9) & 7) = adr;
6634 WRITE_BYTE_F(adr, res)
6635 POST_IO
6636RET(18)
6637}
6638
6639// MOVEB
6640OPCODE(0x1170)
6641{
6642 u32 adr, res;
6643 u32 src, dst;
6644
6645 adr = AREG((Opcode >> 0) & 7);
6646 DECODE_EXT_WORD
6647 PRE_IO
6648 READ_BYTE_F(adr, res)
6649 flag_C = 0;
6650 flag_V = 0;
6651 flag_NotZ = res;
6652 flag_N = res;
6653 FETCH_SWORD(adr);
6654 adr += AREG((Opcode >> 9) & 7);
6655 WRITE_BYTE_F(adr, res)
6656 POST_IO
6657RET(22)
6658}
6659
6660// MOVEB
6661OPCODE(0x11B0)
6662{
6663 u32 adr, res;
6664 u32 src, dst;
6665
6666 adr = AREG((Opcode >> 0) & 7);
6667 DECODE_EXT_WORD
6668 PRE_IO
6669 READ_BYTE_F(adr, res)
6670 flag_C = 0;
6671 flag_V = 0;
6672 flag_NotZ = res;
6673 flag_N = res;
6674 adr = AREG((Opcode >> 9) & 7);
6675 DECODE_EXT_WORD
6676 WRITE_BYTE_F(adr, res)
6677 POST_IO
6678RET(24)
6679}
6680
6681// MOVEB
6682OPCODE(0x11F0)
6683{
6684 u32 adr, res;
6685 u32 src, dst;
6686
6687 adr = AREG((Opcode >> 0) & 7);
6688 DECODE_EXT_WORD
6689 PRE_IO
6690 READ_BYTE_F(adr, res)
6691 flag_C = 0;
6692 flag_V = 0;
6693 flag_NotZ = res;
6694 flag_N = res;
6695 FETCH_SWORD(adr);
6696 WRITE_BYTE_F(adr, res)
6697 POST_IO
6698RET(22)
6699}
6700
6701// MOVEB
6702OPCODE(0x13F0)
6703{
6704 u32 adr, res;
6705 u32 src, dst;
6706
6707 adr = AREG((Opcode >> 0) & 7);
6708 DECODE_EXT_WORD
6709 PRE_IO
6710 READ_BYTE_F(adr, res)
6711 flag_C = 0;
6712 flag_V = 0;
6713 flag_NotZ = res;
6714 flag_N = res;
6715 FETCH_LONG(adr);
6716 WRITE_BYTE_F(adr, res)
6717 POST_IO
6718RET(26)
6719}
6720
6721// MOVEB
6722OPCODE(0x1EF0)
6723{
6724 u32 adr, res;
6725 u32 src, dst;
6726
6727 adr = AREG((Opcode >> 0) & 7);
6728 DECODE_EXT_WORD
6729 PRE_IO
6730 READ_BYTE_F(adr, res)
6731 flag_C = 0;
6732 flag_V = 0;
6733 flag_NotZ = res;
6734 flag_N = res;
6735 adr = AREG(7);
6736 AREG(7) += 2;
6737 WRITE_BYTE_F(adr, res)
6738 POST_IO
6739RET(18)
6740}
6741
6742// MOVEB
6743OPCODE(0x1F30)
6744{
6745 u32 adr, res;
6746 u32 src, dst;
6747
6748 adr = AREG((Opcode >> 0) & 7);
6749 DECODE_EXT_WORD
6750 PRE_IO
6751 READ_BYTE_F(adr, res)
6752 flag_C = 0;
6753 flag_V = 0;
6754 flag_NotZ = res;
6755 flag_N = res;
6756 adr = AREG(7) - 2;
6757 AREG(7) = adr;
6758 WRITE_BYTE_F(adr, res)
6759 POST_IO
6760RET(18)
6761}
6762
6763// MOVEB
6764OPCODE(0x1038)
6765{
6766 u32 adr, res;
6767 u32 src, dst;
6768
6769 FETCH_SWORD(adr);
6770 PRE_IO
6771 READ_BYTE_F(adr, res)
6772 flag_C = 0;
6773 flag_V = 0;
6774 flag_NotZ = res;
6775 flag_N = res;
6776 DREGu8((Opcode >> 9) & 7) = res;
6777 POST_IO
6778RET(12)
6779}
6780
6781// MOVEB
6782OPCODE(0x10B8)
6783{
6784 u32 adr, res;
6785 u32 src, dst;
6786
6787 FETCH_SWORD(adr);
6788 PRE_IO
6789 READ_BYTE_F(adr, res)
6790 flag_C = 0;
6791 flag_V = 0;
6792 flag_NotZ = res;
6793 flag_N = res;
6794 adr = AREG((Opcode >> 9) & 7);
6795 WRITE_BYTE_F(adr, res)
6796 POST_IO
6797RET(16)
6798}
6799
6800// MOVEB
6801OPCODE(0x10F8)
6802{
6803 u32 adr, res;
6804 u32 src, dst;
6805
6806 FETCH_SWORD(adr);
6807 PRE_IO
6808 READ_BYTE_F(adr, res)
6809 flag_C = 0;
6810 flag_V = 0;
6811 flag_NotZ = res;
6812 flag_N = res;
6813 adr = AREG((Opcode >> 9) & 7);
6814 AREG((Opcode >> 9) & 7) += 1;
6815 WRITE_BYTE_F(adr, res)
6816 POST_IO
6817RET(16)
6818}
6819
6820// MOVEB
6821OPCODE(0x1138)
6822{
6823 u32 adr, res;
6824 u32 src, dst;
6825
6826 FETCH_SWORD(adr);
6827 PRE_IO
6828 READ_BYTE_F(adr, res)
6829 flag_C = 0;
6830 flag_V = 0;
6831 flag_NotZ = res;
6832 flag_N = res;
6833 adr = AREG((Opcode >> 9) & 7) - 1;
6834 AREG((Opcode >> 9) & 7) = adr;
6835 WRITE_BYTE_F(adr, res)
6836 POST_IO
6837RET(16)
6838}
6839
6840// MOVEB
6841OPCODE(0x1178)
6842{
6843 u32 adr, res;
6844 u32 src, dst;
6845
6846 FETCH_SWORD(adr);
6847 PRE_IO
6848 READ_BYTE_F(adr, res)
6849 flag_C = 0;
6850 flag_V = 0;
6851 flag_NotZ = res;
6852 flag_N = res;
6853 FETCH_SWORD(adr);
6854 adr += AREG((Opcode >> 9) & 7);
6855 WRITE_BYTE_F(adr, res)
6856 POST_IO
6857RET(20)
6858}
6859
6860// MOVEB
6861OPCODE(0x11B8)
6862{
6863 u32 adr, res;
6864 u32 src, dst;
6865
6866 FETCH_SWORD(adr);
6867 PRE_IO
6868 READ_BYTE_F(adr, res)
6869 flag_C = 0;
6870 flag_V = 0;
6871 flag_NotZ = res;
6872 flag_N = res;
6873 adr = AREG((Opcode >> 9) & 7);
6874 DECODE_EXT_WORD
6875 WRITE_BYTE_F(adr, res)
6876 POST_IO
6877RET(22)
6878}
6879
6880// MOVEB
6881OPCODE(0x11F8)
6882{
6883 u32 adr, res;
6884 u32 src, dst;
6885
6886 FETCH_SWORD(adr);
6887 PRE_IO
6888 READ_BYTE_F(adr, res)
6889 flag_C = 0;
6890 flag_V = 0;
6891 flag_NotZ = res;
6892 flag_N = res;
6893 FETCH_SWORD(adr);
6894 WRITE_BYTE_F(adr, res)
6895 POST_IO
6896RET(20)
6897}
6898
6899// MOVEB
6900OPCODE(0x13F8)
6901{
6902 u32 adr, res;
6903 u32 src, dst;
6904
6905 FETCH_SWORD(adr);
6906 PRE_IO
6907 READ_BYTE_F(adr, res)
6908 flag_C = 0;
6909 flag_V = 0;
6910 flag_NotZ = res;
6911 flag_N = res;
6912 FETCH_LONG(adr);
6913 WRITE_BYTE_F(adr, res)
6914 POST_IO
6915RET(24)
6916}
6917
6918// MOVEB
6919OPCODE(0x1EF8)
6920{
6921 u32 adr, res;
6922 u32 src, dst;
6923
6924 FETCH_SWORD(adr);
6925 PRE_IO
6926 READ_BYTE_F(adr, res)
6927 flag_C = 0;
6928 flag_V = 0;
6929 flag_NotZ = res;
6930 flag_N = res;
6931 adr = AREG(7);
6932 AREG(7) += 2;
6933 WRITE_BYTE_F(adr, res)
6934 POST_IO
6935RET(16)
6936}
6937
6938// MOVEB
6939OPCODE(0x1F38)
6940{
6941 u32 adr, res;
6942 u32 src, dst;
6943
6944 FETCH_SWORD(adr);
6945 PRE_IO
6946 READ_BYTE_F(adr, res)
6947 flag_C = 0;
6948 flag_V = 0;
6949 flag_NotZ = res;
6950 flag_N = res;
6951 adr = AREG(7) - 2;
6952 AREG(7) = adr;
6953 WRITE_BYTE_F(adr, res)
6954 POST_IO
6955RET(16)
6956}
6957
6958// MOVEB
6959OPCODE(0x1039)
6960{
6961 u32 adr, res;
6962 u32 src, dst;
6963
6964 FETCH_LONG(adr);
6965 PRE_IO
6966 READ_BYTE_F(adr, res)
6967 flag_C = 0;
6968 flag_V = 0;
6969 flag_NotZ = res;
6970 flag_N = res;
6971 DREGu8((Opcode >> 9) & 7) = res;
6972 POST_IO
6973RET(16)
6974}
6975
6976// MOVEB
6977OPCODE(0x10B9)
6978{
6979 u32 adr, res;
6980 u32 src, dst;
6981
6982 FETCH_LONG(adr);
6983 PRE_IO
6984 READ_BYTE_F(adr, res)
6985 flag_C = 0;
6986 flag_V = 0;
6987 flag_NotZ = res;
6988 flag_N = res;
6989 adr = AREG((Opcode >> 9) & 7);
6990 WRITE_BYTE_F(adr, res)
6991 POST_IO
6992RET(20)
6993}
6994
6995// MOVEB
6996OPCODE(0x10F9)
6997{
6998 u32 adr, res;
6999 u32 src, dst;
7000
7001 FETCH_LONG(adr);
7002 PRE_IO
7003 READ_BYTE_F(adr, res)
7004 flag_C = 0;
7005 flag_V = 0;
7006 flag_NotZ = res;
7007 flag_N = res;
7008 adr = AREG((Opcode >> 9) & 7);
7009 AREG((Opcode >> 9) & 7) += 1;
7010 WRITE_BYTE_F(adr, res)
7011 POST_IO
7012RET(20)
7013}
7014
7015// MOVEB
7016OPCODE(0x1139)
7017{
7018 u32 adr, res;
7019 u32 src, dst;
7020
7021 FETCH_LONG(adr);
7022 PRE_IO
7023 READ_BYTE_F(adr, res)
7024 flag_C = 0;
7025 flag_V = 0;
7026 flag_NotZ = res;
7027 flag_N = res;
7028 adr = AREG((Opcode >> 9) & 7) - 1;
7029 AREG((Opcode >> 9) & 7) = adr;
7030 WRITE_BYTE_F(adr, res)
7031 POST_IO
7032RET(20)
7033}
7034
7035// MOVEB
7036OPCODE(0x1179)
7037{
7038 u32 adr, res;
7039 u32 src, dst;
7040
7041 FETCH_LONG(adr);
7042 PRE_IO
7043 READ_BYTE_F(adr, res)
7044 flag_C = 0;
7045 flag_V = 0;
7046 flag_NotZ = res;
7047 flag_N = res;
7048 FETCH_SWORD(adr);
7049 adr += AREG((Opcode >> 9) & 7);
7050 WRITE_BYTE_F(adr, res)
7051 POST_IO
7052RET(24)
7053}
7054
7055// MOVEB
7056OPCODE(0x11B9)
7057{
7058 u32 adr, res;
7059 u32 src, dst;
7060
7061 FETCH_LONG(adr);
7062 PRE_IO
7063 READ_BYTE_F(adr, res)
7064 flag_C = 0;
7065 flag_V = 0;
7066 flag_NotZ = res;
7067 flag_N = res;
7068 adr = AREG((Opcode >> 9) & 7);
7069 DECODE_EXT_WORD
7070 WRITE_BYTE_F(adr, res)
7071 POST_IO
7072RET(26)
7073}
7074
7075// MOVEB
7076OPCODE(0x11F9)
7077{
7078 u32 adr, res;
7079 u32 src, dst;
7080
7081 FETCH_LONG(adr);
7082 PRE_IO
7083 READ_BYTE_F(adr, res)
7084 flag_C = 0;
7085 flag_V = 0;
7086 flag_NotZ = res;
7087 flag_N = res;
7088 FETCH_SWORD(adr);
7089 WRITE_BYTE_F(adr, res)
7090 POST_IO
7091RET(24)
7092}
7093
7094// MOVEB
7095OPCODE(0x13F9)
7096{
7097 u32 adr, res;
7098 u32 src, dst;
7099
7100 FETCH_LONG(adr);
7101 PRE_IO
7102 READ_BYTE_F(adr, res)
7103 flag_C = 0;
7104 flag_V = 0;
7105 flag_NotZ = res;
7106 flag_N = res;
7107 FETCH_LONG(adr);
7108 WRITE_BYTE_F(adr, res)
7109 POST_IO
7110RET(28)
7111}
7112
7113// MOVEB
7114OPCODE(0x1EF9)
7115{
7116 u32 adr, res;
7117 u32 src, dst;
7118
7119 FETCH_LONG(adr);
7120 PRE_IO
7121 READ_BYTE_F(adr, res)
7122 flag_C = 0;
7123 flag_V = 0;
7124 flag_NotZ = res;
7125 flag_N = res;
7126 adr = AREG(7);
7127 AREG(7) += 2;
7128 WRITE_BYTE_F(adr, res)
7129 POST_IO
7130RET(20)
7131}
7132
7133// MOVEB
7134OPCODE(0x1F39)
7135{
7136 u32 adr, res;
7137 u32 src, dst;
7138
7139 FETCH_LONG(adr);
7140 PRE_IO
7141 READ_BYTE_F(adr, res)
7142 flag_C = 0;
7143 flag_V = 0;
7144 flag_NotZ = res;
7145 flag_N = res;
7146 adr = AREG(7) - 2;
7147 AREG(7) = adr;
7148 WRITE_BYTE_F(adr, res)
7149 POST_IO
7150RET(20)
7151}
7152
7153// MOVEB
7154OPCODE(0x103A)
7155{
7156 u32 adr, res;
7157 u32 src, dst;
7158
7159 adr = GET_SWORD + GET_PC;
7160 PC++;
7161 PRE_IO
7162 READ_BYTE_F(adr, res)
7163 flag_C = 0;
7164 flag_V = 0;
7165 flag_NotZ = res;
7166 flag_N = res;
7167 DREGu8((Opcode >> 9) & 7) = res;
7168 POST_IO
7169RET(12)
7170}
7171
7172// MOVEB
7173OPCODE(0x10BA)
7174{
7175 u32 adr, res;
7176 u32 src, dst;
7177
7178 adr = GET_SWORD + GET_PC;
7179 PC++;
7180 PRE_IO
7181 READ_BYTE_F(adr, res)
7182 flag_C = 0;
7183 flag_V = 0;
7184 flag_NotZ = res;
7185 flag_N = res;
7186 adr = AREG((Opcode >> 9) & 7);
7187 WRITE_BYTE_F(adr, res)
7188 POST_IO
7189RET(16)
7190}
7191
7192// MOVEB
7193OPCODE(0x10FA)
7194{
7195 u32 adr, res;
7196 u32 src, dst;
7197
7198 adr = GET_SWORD + GET_PC;
7199 PC++;
7200 PRE_IO
7201 READ_BYTE_F(adr, res)
7202 flag_C = 0;
7203 flag_V = 0;
7204 flag_NotZ = res;
7205 flag_N = res;
7206 adr = AREG((Opcode >> 9) & 7);
7207 AREG((Opcode >> 9) & 7) += 1;
7208 WRITE_BYTE_F(adr, res)
7209 POST_IO
7210RET(16)
7211}
7212
7213// MOVEB
7214OPCODE(0x113A)
7215{
7216 u32 adr, res;
7217 u32 src, dst;
7218
7219 adr = GET_SWORD + GET_PC;
7220 PC++;
7221 PRE_IO
7222 READ_BYTE_F(adr, res)
7223 flag_C = 0;
7224 flag_V = 0;
7225 flag_NotZ = res;
7226 flag_N = res;
7227 adr = AREG((Opcode >> 9) & 7) - 1;
7228 AREG((Opcode >> 9) & 7) = adr;
7229 WRITE_BYTE_F(adr, res)
7230 POST_IO
7231RET(16)
7232}
7233
7234// MOVEB
7235OPCODE(0x117A)
7236{
7237 u32 adr, res;
7238 u32 src, dst;
7239
7240 adr = GET_SWORD + GET_PC;
7241 PC++;
7242 PRE_IO
7243 READ_BYTE_F(adr, res)
7244 flag_C = 0;
7245 flag_V = 0;
7246 flag_NotZ = res;
7247 flag_N = res;
7248 FETCH_SWORD(adr);
7249 adr += AREG((Opcode >> 9) & 7);
7250 WRITE_BYTE_F(adr, res)
7251 POST_IO
7252RET(20)
7253}
7254
7255// MOVEB
7256OPCODE(0x11BA)
7257{
7258 u32 adr, res;
7259 u32 src, dst;
7260
7261 adr = GET_SWORD + GET_PC;
7262 PC++;
7263 PRE_IO
7264 READ_BYTE_F(adr, res)
7265 flag_C = 0;
7266 flag_V = 0;
7267 flag_NotZ = res;
7268 flag_N = res;
7269 adr = AREG((Opcode >> 9) & 7);
7270 DECODE_EXT_WORD
7271 WRITE_BYTE_F(adr, res)
7272 POST_IO
7273RET(22)
7274}
7275
7276// MOVEB
7277OPCODE(0x11FA)
7278{
7279 u32 adr, res;
7280 u32 src, dst;
7281
7282 adr = GET_SWORD + GET_PC;
7283 PC++;
7284 PRE_IO
7285 READ_BYTE_F(adr, res)
7286 flag_C = 0;
7287 flag_V = 0;
7288 flag_NotZ = res;
7289 flag_N = res;
7290 FETCH_SWORD(adr);
7291 WRITE_BYTE_F(adr, res)
7292 POST_IO
7293RET(20)
7294}
7295
7296// MOVEB
7297OPCODE(0x13FA)
7298{
7299 u32 adr, res;
7300 u32 src, dst;
7301
7302 adr = GET_SWORD + GET_PC;
7303 PC++;
7304 PRE_IO
7305 READ_BYTE_F(adr, res)
7306 flag_C = 0;
7307 flag_V = 0;
7308 flag_NotZ = res;
7309 flag_N = res;
7310 FETCH_LONG(adr);
7311 WRITE_BYTE_F(adr, res)
7312 POST_IO
7313RET(24)
7314}
7315
7316// MOVEB
7317OPCODE(0x1EFA)
7318{
7319 u32 adr, res;
7320 u32 src, dst;
7321
7322 adr = GET_SWORD + GET_PC;
7323 PC++;
7324 PRE_IO
7325 READ_BYTE_F(adr, res)
7326 flag_C = 0;
7327 flag_V = 0;
7328 flag_NotZ = res;
7329 flag_N = res;
7330 adr = AREG(7);
7331 AREG(7) += 2;
7332 WRITE_BYTE_F(adr, res)
7333 POST_IO
7334RET(16)
7335}
7336
7337// MOVEB
7338OPCODE(0x1F3A)
7339{
7340 u32 adr, res;
7341 u32 src, dst;
7342
7343 adr = GET_SWORD + GET_PC;
7344 PC++;
7345 PRE_IO
7346 READ_BYTE_F(adr, res)
7347 flag_C = 0;
7348 flag_V = 0;
7349 flag_NotZ = res;
7350 flag_N = res;
7351 adr = AREG(7) - 2;
7352 AREG(7) = adr;
7353 WRITE_BYTE_F(adr, res)
7354 POST_IO
7355RET(16)
7356}
7357
7358// MOVEB
7359OPCODE(0x103B)
7360{
7361 u32 adr, res;
7362 u32 src, dst;
7363
7364 adr = (uptr)(PC) - BasePC;
7365 DECODE_EXT_WORD
7366 PRE_IO
7367 READ_BYTE_F(adr, res)
7368 flag_C = 0;
7369 flag_V = 0;
7370 flag_NotZ = res;
7371 flag_N = res;
7372 DREGu8((Opcode >> 9) & 7) = res;
7373 POST_IO
7374RET(14)
7375}
7376
7377// MOVEB
7378OPCODE(0x10BB)
7379{
7380 u32 adr, res;
7381 u32 src, dst;
7382
7383 adr = (uptr)(PC) - BasePC;
7384 DECODE_EXT_WORD
7385 PRE_IO
7386 READ_BYTE_F(adr, res)
7387 flag_C = 0;
7388 flag_V = 0;
7389 flag_NotZ = res;
7390 flag_N = res;
7391 adr = AREG((Opcode >> 9) & 7);
7392 WRITE_BYTE_F(adr, res)
7393 POST_IO
7394RET(18)
7395}
7396
7397// MOVEB
7398OPCODE(0x10FB)
7399{
7400 u32 adr, res;
7401 u32 src, dst;
7402
7403 adr = (uptr)(PC) - BasePC;
7404 DECODE_EXT_WORD
7405 PRE_IO
7406 READ_BYTE_F(adr, res)
7407 flag_C = 0;
7408 flag_V = 0;
7409 flag_NotZ = res;
7410 flag_N = res;
7411 adr = AREG((Opcode >> 9) & 7);
7412 AREG((Opcode >> 9) & 7) += 1;
7413 WRITE_BYTE_F(adr, res)
7414 POST_IO
7415RET(18)
7416}
7417
7418// MOVEB
7419OPCODE(0x113B)
7420{
7421 u32 adr, res;
7422 u32 src, dst;
7423
7424 adr = (uptr)(PC) - BasePC;
7425 DECODE_EXT_WORD
7426 PRE_IO
7427 READ_BYTE_F(adr, res)
7428 flag_C = 0;
7429 flag_V = 0;
7430 flag_NotZ = res;
7431 flag_N = res;
7432 adr = AREG((Opcode >> 9) & 7) - 1;
7433 AREG((Opcode >> 9) & 7) = adr;
7434 WRITE_BYTE_F(adr, res)
7435 POST_IO
7436RET(18)
7437}
7438
7439// MOVEB
7440OPCODE(0x117B)
7441{
7442 u32 adr, res;
7443 u32 src, dst;
7444
7445 adr = (uptr)(PC) - BasePC;
7446 DECODE_EXT_WORD
7447 PRE_IO
7448 READ_BYTE_F(adr, res)
7449 flag_C = 0;
7450 flag_V = 0;
7451 flag_NotZ = res;
7452 flag_N = res;
7453 FETCH_SWORD(adr);
7454 adr += AREG((Opcode >> 9) & 7);
7455 WRITE_BYTE_F(adr, res)
7456 POST_IO
7457RET(22)
7458}
7459
7460// MOVEB
7461OPCODE(0x11BB)
7462{
7463 u32 adr, res;
7464 u32 src, dst;
7465
7466 adr = (uptr)(PC) - BasePC;
7467 DECODE_EXT_WORD
7468 PRE_IO
7469 READ_BYTE_F(adr, res)
7470 flag_C = 0;
7471 flag_V = 0;
7472 flag_NotZ = res;
7473 flag_N = res;
7474 adr = AREG((Opcode >> 9) & 7);
7475 DECODE_EXT_WORD
7476 WRITE_BYTE_F(adr, res)
7477 POST_IO
7478RET(24)
7479}
7480
7481// MOVEB
7482OPCODE(0x11FB)
7483{
7484 u32 adr, res;
7485 u32 src, dst;
7486
7487 adr = (uptr)(PC) - BasePC;
7488 DECODE_EXT_WORD
7489 PRE_IO
7490 READ_BYTE_F(adr, res)
7491 flag_C = 0;
7492 flag_V = 0;
7493 flag_NotZ = res;
7494 flag_N = res;
7495 FETCH_SWORD(adr);
7496 WRITE_BYTE_F(adr, res)
7497 POST_IO
7498RET(22)
7499}
7500
7501// MOVEB
7502OPCODE(0x13FB)
7503{
7504 u32 adr, res;
7505 u32 src, dst;
7506
7507 adr = (uptr)(PC) - BasePC;
7508 DECODE_EXT_WORD
7509 PRE_IO
7510 READ_BYTE_F(adr, res)
7511 flag_C = 0;
7512 flag_V = 0;
7513 flag_NotZ = res;
7514 flag_N = res;
7515 FETCH_LONG(adr);
7516 WRITE_BYTE_F(adr, res)
7517 POST_IO
7518RET(26)
7519}
7520
7521// MOVEB
7522OPCODE(0x1EFB)
7523{
7524 u32 adr, res;
7525 u32 src, dst;
7526
7527 adr = (uptr)(PC) - BasePC;
7528 DECODE_EXT_WORD
7529 PRE_IO
7530 READ_BYTE_F(adr, res)
7531 flag_C = 0;
7532 flag_V = 0;
7533 flag_NotZ = res;
7534 flag_N = res;
7535 adr = AREG(7);
7536 AREG(7) += 2;
7537 WRITE_BYTE_F(adr, res)
7538 POST_IO
7539RET(18)
7540}
7541
7542// MOVEB
7543OPCODE(0x1F3B)
7544{
7545 u32 adr, res;
7546 u32 src, dst;
7547
7548 adr = (uptr)(PC) - BasePC;
7549 DECODE_EXT_WORD
7550 PRE_IO
7551 READ_BYTE_F(adr, res)
7552 flag_C = 0;
7553 flag_V = 0;
7554 flag_NotZ = res;
7555 flag_N = res;
7556 adr = AREG(7) - 2;
7557 AREG(7) = adr;
7558 WRITE_BYTE_F(adr, res)
7559 POST_IO
7560RET(18)
7561}
7562
7563// MOVEB
7564OPCODE(0x103C)
7565{
7566 u32 adr, res;
7567 u32 src, dst;
7568
7569 FETCH_BYTE(res);
7570 flag_C = 0;
7571 flag_V = 0;
7572 flag_NotZ = res;
7573 flag_N = res;
7574 DREGu8((Opcode >> 9) & 7) = res;
7575RET(8)
7576}
7577
7578// MOVEB
7579OPCODE(0x10BC)
7580{
7581 u32 adr, res;
7582 u32 src, dst;
7583
7584 FETCH_BYTE(res);
7585 flag_C = 0;
7586 flag_V = 0;
7587 flag_NotZ = res;
7588 flag_N = res;
7589 adr = AREG((Opcode >> 9) & 7);
7590 PRE_IO
7591 WRITE_BYTE_F(adr, res)
7592 POST_IO
7593RET(12)
7594}
7595
7596// MOVEB
7597OPCODE(0x10FC)
7598{
7599 u32 adr, res;
7600 u32 src, dst;
7601
7602 FETCH_BYTE(res);
7603 flag_C = 0;
7604 flag_V = 0;
7605 flag_NotZ = res;
7606 flag_N = res;
7607 adr = AREG((Opcode >> 9) & 7);
7608 AREG((Opcode >> 9) & 7) += 1;
7609 PRE_IO
7610 WRITE_BYTE_F(adr, res)
7611 POST_IO
7612RET(12)
7613}
7614
7615// MOVEB
7616OPCODE(0x113C)
7617{
7618 u32 adr, res;
7619 u32 src, dst;
7620
7621 FETCH_BYTE(res);
7622 flag_C = 0;
7623 flag_V = 0;
7624 flag_NotZ = res;
7625 flag_N = res;
7626 adr = AREG((Opcode >> 9) & 7) - 1;
7627 AREG((Opcode >> 9) & 7) = adr;
7628 PRE_IO
7629 WRITE_BYTE_F(adr, res)
7630 POST_IO
7631RET(12)
7632}
7633
7634// MOVEB
7635OPCODE(0x117C)
7636{
7637 u32 adr, res;
7638 u32 src, dst;
7639
7640 FETCH_BYTE(res);
7641 flag_C = 0;
7642 flag_V = 0;
7643 flag_NotZ = res;
7644 flag_N = res;
7645 FETCH_SWORD(adr);
7646 adr += AREG((Opcode >> 9) & 7);
7647 PRE_IO
7648 WRITE_BYTE_F(adr, res)
7649 POST_IO
7650RET(16)
7651}
7652
7653// MOVEB
7654OPCODE(0x11BC)
7655{
7656 u32 adr, res;
7657 u32 src, dst;
7658
7659 FETCH_BYTE(res);
7660 flag_C = 0;
7661 flag_V = 0;
7662 flag_NotZ = res;
7663 flag_N = res;
7664 adr = AREG((Opcode >> 9) & 7);
7665 DECODE_EXT_WORD
7666 PRE_IO
7667 WRITE_BYTE_F(adr, res)
7668 POST_IO
7669RET(18)
7670}
7671
7672// MOVEB
7673OPCODE(0x11FC)
7674{
7675 u32 adr, res;
7676 u32 src, dst;
7677
7678 FETCH_BYTE(res);
7679 flag_C = 0;
7680 flag_V = 0;
7681 flag_NotZ = res;
7682 flag_N = res;
7683 FETCH_SWORD(adr);
7684 PRE_IO
7685 WRITE_BYTE_F(adr, res)
7686 POST_IO
7687RET(16)
7688}
7689
7690// MOVEB
7691OPCODE(0x13FC)
7692{
7693 u32 adr, res;
7694 u32 src, dst;
7695
7696 FETCH_BYTE(res);
7697 flag_C = 0;
7698 flag_V = 0;
7699 flag_NotZ = res;
7700 flag_N = res;
7701 FETCH_LONG(adr);
7702 PRE_IO
7703 WRITE_BYTE_F(adr, res)
7704 POST_IO
7705RET(20)
7706}
7707
7708// MOVEB
7709OPCODE(0x1EFC)
7710{
7711 u32 adr, res;
7712 u32 src, dst;
7713
7714 FETCH_BYTE(res);
7715 flag_C = 0;
7716 flag_V = 0;
7717 flag_NotZ = res;
7718 flag_N = res;
7719 adr = AREG(7);
7720 AREG(7) += 2;
7721 PRE_IO
7722 WRITE_BYTE_F(adr, res)
7723 POST_IO
7724RET(12)
7725}
7726
7727// MOVEB
7728OPCODE(0x1F3C)
7729{
7730 u32 adr, res;
7731 u32 src, dst;
7732
7733 FETCH_BYTE(res);
7734 flag_C = 0;
7735 flag_V = 0;
7736 flag_NotZ = res;
7737 flag_N = res;
7738 adr = AREG(7) - 2;
7739 AREG(7) = adr;
7740 PRE_IO
7741 WRITE_BYTE_F(adr, res)
7742 POST_IO
7743RET(12)
7744}
7745
7746// MOVEB
7747OPCODE(0x101F)
7748{
7749 u32 adr, res;
7750 u32 src, dst;
7751
7752 adr = AREG(7);
7753 AREG(7) += 2;
7754 PRE_IO
7755 READ_BYTE_F(adr, res)
7756 flag_C = 0;
7757 flag_V = 0;
7758 flag_NotZ = res;
7759 flag_N = res;
7760 DREGu8((Opcode >> 9) & 7) = res;
7761 POST_IO
7762RET(8)
7763}
7764
7765// MOVEB
7766OPCODE(0x109F)
7767{
7768 u32 adr, res;
7769 u32 src, dst;
7770
7771 adr = AREG(7);
7772 AREG(7) += 2;
7773 PRE_IO
7774 READ_BYTE_F(adr, res)
7775 flag_C = 0;
7776 flag_V = 0;
7777 flag_NotZ = res;
7778 flag_N = res;
7779 adr = AREG((Opcode >> 9) & 7);
7780 WRITE_BYTE_F(adr, res)
7781 POST_IO
7782RET(12)
7783}
7784
7785// MOVEB
7786OPCODE(0x10DF)
7787{
7788 u32 adr, res;
7789 u32 src, dst;
7790
7791 adr = AREG(7);
7792 AREG(7) += 2;
7793 PRE_IO
7794 READ_BYTE_F(adr, res)
7795 flag_C = 0;
7796 flag_V = 0;
7797 flag_NotZ = res;
7798 flag_N = res;
7799 adr = AREG((Opcode >> 9) & 7);
7800 AREG((Opcode >> 9) & 7) += 1;
7801 WRITE_BYTE_F(adr, res)
7802 POST_IO
7803RET(12)
7804}
7805
7806// MOVEB
7807OPCODE(0x111F)
7808{
7809 u32 adr, res;
7810 u32 src, dst;
7811
7812 adr = AREG(7);
7813 AREG(7) += 2;
7814 PRE_IO
7815 READ_BYTE_F(adr, res)
7816 flag_C = 0;
7817 flag_V = 0;
7818 flag_NotZ = res;
7819 flag_N = res;
7820 adr = AREG((Opcode >> 9) & 7) - 1;
7821 AREG((Opcode >> 9) & 7) = adr;
7822 WRITE_BYTE_F(adr, res)
7823 POST_IO
7824RET(12)
7825}
7826
7827// MOVEB
7828OPCODE(0x115F)
7829{
7830 u32 adr, res;
7831 u32 src, dst;
7832
7833 adr = AREG(7);
7834 AREG(7) += 2;
7835 PRE_IO
7836 READ_BYTE_F(adr, res)
7837 flag_C = 0;
7838 flag_V = 0;
7839 flag_NotZ = res;
7840 flag_N = res;
7841 FETCH_SWORD(adr);
7842 adr += AREG((Opcode >> 9) & 7);
7843 WRITE_BYTE_F(adr, res)
7844 POST_IO
7845RET(16)
7846}
7847
7848// MOVEB
7849OPCODE(0x119F)
7850{
7851 u32 adr, res;
7852 u32 src, dst;
7853
7854 adr = AREG(7);
7855 AREG(7) += 2;
7856 PRE_IO
7857 READ_BYTE_F(adr, res)
7858 flag_C = 0;
7859 flag_V = 0;
7860 flag_NotZ = res;
7861 flag_N = res;
7862 adr = AREG((Opcode >> 9) & 7);
7863 DECODE_EXT_WORD
7864 WRITE_BYTE_F(adr, res)
7865 POST_IO
7866RET(18)
7867}
7868
7869// MOVEB
7870OPCODE(0x11DF)
7871{
7872 u32 adr, res;
7873 u32 src, dst;
7874
7875 adr = AREG(7);
7876 AREG(7) += 2;
7877 PRE_IO
7878 READ_BYTE_F(adr, res)
7879 flag_C = 0;
7880 flag_V = 0;
7881 flag_NotZ = res;
7882 flag_N = res;
7883 FETCH_SWORD(adr);
7884 WRITE_BYTE_F(adr, res)
7885 POST_IO
7886RET(16)
7887}
7888
7889// MOVEB
7890OPCODE(0x13DF)
7891{
7892 u32 adr, res;
7893 u32 src, dst;
7894
7895 adr = AREG(7);
7896 AREG(7) += 2;
7897 PRE_IO
7898 READ_BYTE_F(adr, res)
7899 flag_C = 0;
7900 flag_V = 0;
7901 flag_NotZ = res;
7902 flag_N = res;
7903 FETCH_LONG(adr);
7904 WRITE_BYTE_F(adr, res)
7905 POST_IO
7906RET(20)
7907}
7908
7909// MOVEB
7910OPCODE(0x1EDF)
7911{
7912 u32 adr, res;
7913 u32 src, dst;
7914
7915 adr = AREG(7);
7916 AREG(7) += 2;
7917 PRE_IO
7918 READ_BYTE_F(adr, res)
7919 flag_C = 0;
7920 flag_V = 0;
7921 flag_NotZ = res;
7922 flag_N = res;
7923 adr = AREG(7);
7924 AREG(7) += 2;
7925 WRITE_BYTE_F(adr, res)
7926 POST_IO
7927RET(12)
7928}
7929
7930// MOVEB
7931OPCODE(0x1F1F)
7932{
7933 u32 adr, res;
7934 u32 src, dst;
7935
7936 adr = AREG(7);
7937 AREG(7) += 2;
7938 PRE_IO
7939 READ_BYTE_F(adr, res)
7940 flag_C = 0;
7941 flag_V = 0;
7942 flag_NotZ = res;
7943 flag_N = res;
7944 adr = AREG(7) - 2;
7945 AREG(7) = adr;
7946 WRITE_BYTE_F(adr, res)
7947 POST_IO
7948RET(12)
7949}
7950
7951// MOVEB
7952OPCODE(0x1027)
7953{
7954 u32 adr, res;
7955 u32 src, dst;
7956
7957 adr = AREG(7) - 2;
7958 AREG(7) = adr;
7959 PRE_IO
7960 READ_BYTE_F(adr, res)
7961 flag_C = 0;
7962 flag_V = 0;
7963 flag_NotZ = res;
7964 flag_N = res;
7965 DREGu8((Opcode >> 9) & 7) = res;
7966 POST_IO
7967RET(10)
7968}
7969
7970// MOVEB
7971OPCODE(0x10A7)
7972{
7973 u32 adr, res;
7974 u32 src, dst;
7975
7976 adr = AREG(7) - 2;
7977 AREG(7) = adr;
7978 PRE_IO
7979 READ_BYTE_F(adr, res)
7980 flag_C = 0;
7981 flag_V = 0;
7982 flag_NotZ = res;
7983 flag_N = res;
7984 adr = AREG((Opcode >> 9) & 7);
7985 WRITE_BYTE_F(adr, res)
7986 POST_IO
7987RET(14)
7988}
7989
7990// MOVEB
7991OPCODE(0x10E7)
7992{
7993 u32 adr, res;
7994 u32 src, dst;
7995
7996 adr = AREG(7) - 2;
7997 AREG(7) = adr;
7998 PRE_IO
7999 READ_BYTE_F(adr, res)
8000 flag_C = 0;
8001 flag_V = 0;
8002 flag_NotZ = res;
8003 flag_N = res;
8004 adr = AREG((Opcode >> 9) & 7);
8005 AREG((Opcode >> 9) & 7) += 1;
8006 WRITE_BYTE_F(adr, res)
8007 POST_IO
8008RET(14)
8009}
8010
8011// MOVEB
8012OPCODE(0x1127)
8013{
8014 u32 adr, res;
8015 u32 src, dst;
8016
8017 adr = AREG(7) - 2;
8018 AREG(7) = adr;
8019 PRE_IO
8020 READ_BYTE_F(adr, res)
8021 flag_C = 0;
8022 flag_V = 0;
8023 flag_NotZ = res;
8024 flag_N = res;
8025 adr = AREG((Opcode >> 9) & 7) - 1;
8026 AREG((Opcode >> 9) & 7) = adr;
8027 WRITE_BYTE_F(adr, res)
8028 POST_IO
8029RET(14)
8030}
8031
8032// MOVEB
8033OPCODE(0x1167)
8034{
8035 u32 adr, res;
8036 u32 src, dst;
8037
8038 adr = AREG(7) - 2;
8039 AREG(7) = adr;
8040 PRE_IO
8041 READ_BYTE_F(adr, res)
8042 flag_C = 0;
8043 flag_V = 0;
8044 flag_NotZ = res;
8045 flag_N = res;
8046 FETCH_SWORD(adr);
8047 adr += AREG((Opcode >> 9) & 7);
8048 WRITE_BYTE_F(adr, res)
8049 POST_IO
8050RET(18)
8051}
8052
8053// MOVEB
8054OPCODE(0x11A7)
8055{
8056 u32 adr, res;
8057 u32 src, dst;
8058
8059 adr = AREG(7) - 2;
8060 AREG(7) = adr;
8061 PRE_IO
8062 READ_BYTE_F(adr, res)
8063 flag_C = 0;
8064 flag_V = 0;
8065 flag_NotZ = res;
8066 flag_N = res;
8067 adr = AREG((Opcode >> 9) & 7);
8068 DECODE_EXT_WORD
8069 WRITE_BYTE_F(adr, res)
8070 POST_IO
8071RET(20)
8072}
8073
8074// MOVEB
8075OPCODE(0x11E7)
8076{
8077 u32 adr, res;
8078 u32 src, dst;
8079
8080 adr = AREG(7) - 2;
8081 AREG(7) = adr;
8082 PRE_IO
8083 READ_BYTE_F(adr, res)
8084 flag_C = 0;
8085 flag_V = 0;
8086 flag_NotZ = res;
8087 flag_N = res;
8088 FETCH_SWORD(adr);
8089 WRITE_BYTE_F(adr, res)
8090 POST_IO
8091RET(18)
8092}
8093
8094// MOVEB
8095OPCODE(0x13E7)
8096{
8097 u32 adr, res;
8098 u32 src, dst;
8099
8100 adr = AREG(7) - 2;
8101 AREG(7) = adr;
8102 PRE_IO
8103 READ_BYTE_F(adr, res)
8104 flag_C = 0;
8105 flag_V = 0;
8106 flag_NotZ = res;
8107 flag_N = res;
8108 FETCH_LONG(adr);
8109 WRITE_BYTE_F(adr, res)
8110 POST_IO
8111RET(22)
8112}
8113
8114// MOVEB
8115OPCODE(0x1EE7)
8116{
8117 u32 adr, res;
8118 u32 src, dst;
8119
8120 adr = AREG(7) - 2;
8121 AREG(7) = adr;
8122 PRE_IO
8123 READ_BYTE_F(adr, res)
8124 flag_C = 0;
8125 flag_V = 0;
8126 flag_NotZ = res;
8127 flag_N = res;
8128 adr = AREG(7);
8129 AREG(7) += 2;
8130 WRITE_BYTE_F(adr, res)
8131 POST_IO
8132RET(14)
8133}
8134
8135// MOVEB
8136OPCODE(0x1F27)
8137{
8138 u32 adr, res;
8139 u32 src, dst;
8140
8141 adr = AREG(7) - 2;
8142 AREG(7) = adr;
8143 PRE_IO
8144 READ_BYTE_F(adr, res)
8145 flag_C = 0;
8146 flag_V = 0;
8147 flag_NotZ = res;
8148 flag_N = res;
8149 adr = AREG(7) - 2;
8150 AREG(7) = adr;
8151 WRITE_BYTE_F(adr, res)
8152 POST_IO
8153RET(14)
8154}
8155
8156// MOVEL
8157OPCODE(0x2000)
8158{
8159 u32 adr, res;
8160 u32 src, dst;
8161
8162 res = DREGu32((Opcode >> 0) & 7);
8163 flag_C = 0;
8164 flag_V = 0;
8165 flag_NotZ = res;
8166 flag_N = res >> 24;
8167 DREGu32((Opcode >> 9) & 7) = res;
8168RET(4)
8169}
8170
8171// MOVEL
8172OPCODE(0x2080)
8173{
8174 u32 adr, res;
8175 u32 src, dst;
8176
8177 res = DREGu32((Opcode >> 0) & 7);
8178 flag_C = 0;
8179 flag_V = 0;
8180 flag_NotZ = res;
8181 flag_N = res >> 24;
8182 adr = AREG((Opcode >> 9) & 7);
8183 PRE_IO
8184 WRITE_LONG_F(adr, res)
8185 POST_IO
8186RET(12)
8187}
8188
8189// MOVEL
8190OPCODE(0x20C0)
8191{
8192 u32 adr, res;
8193 u32 src, dst;
8194
8195 res = DREGu32((Opcode >> 0) & 7);
8196 flag_C = 0;
8197 flag_V = 0;
8198 flag_NotZ = res;
8199 flag_N = res >> 24;
8200 adr = AREG((Opcode >> 9) & 7);
8201 AREG((Opcode >> 9) & 7) += 4;
8202 PRE_IO
8203 WRITE_LONG_F(adr, res)
8204 POST_IO
8205RET(12)
8206}
8207
8208// MOVEL
8209OPCODE(0x2100)
8210{
8211 u32 adr, res;
8212 u32 src, dst;
8213
8214 res = DREGu32((Opcode >> 0) & 7);
8215 flag_C = 0;
8216 flag_V = 0;
8217 flag_NotZ = res;
8218 flag_N = res >> 24;
8219 adr = AREG((Opcode >> 9) & 7) - 4;
8220 AREG((Opcode >> 9) & 7) = adr;
8221 PRE_IO
8222 WRITE_LONG_DEC_F(adr, res)
8223 POST_IO
8224RET(12)
8225}
8226
8227// MOVEL
8228OPCODE(0x2140)
8229{
8230 u32 adr, res;
8231 u32 src, dst;
8232
8233 res = DREGu32((Opcode >> 0) & 7);
8234 flag_C = 0;
8235 flag_V = 0;
8236 flag_NotZ = res;
8237 flag_N = res >> 24;
8238 FETCH_SWORD(adr);
8239 adr += AREG((Opcode >> 9) & 7);
8240 PRE_IO
8241 WRITE_LONG_F(adr, res)
8242 POST_IO
8243RET(16)
8244}
8245
8246// MOVEL
8247OPCODE(0x2180)
8248{
8249 u32 adr, res;
8250 u32 src, dst;
8251
8252 res = DREGu32((Opcode >> 0) & 7);
8253 flag_C = 0;
8254 flag_V = 0;
8255 flag_NotZ = res;
8256 flag_N = res >> 24;
8257 adr = AREG((Opcode >> 9) & 7);
8258 DECODE_EXT_WORD
8259 PRE_IO
8260 WRITE_LONG_F(adr, res)
8261 POST_IO
8262RET(18)
8263}
8264
8265// MOVEL
8266OPCODE(0x21C0)
8267{
8268 u32 adr, res;
8269 u32 src, dst;
8270
8271 res = DREGu32((Opcode >> 0) & 7);
8272 flag_C = 0;
8273 flag_V = 0;
8274 flag_NotZ = res;
8275 flag_N = res >> 24;
8276 FETCH_SWORD(adr);
8277 PRE_IO
8278 WRITE_LONG_F(adr, res)
8279 POST_IO
8280RET(16)
8281}
8282
8283// MOVEL
8284OPCODE(0x23C0)
8285{
8286 u32 adr, res;
8287 u32 src, dst;
8288
8289 res = DREGu32((Opcode >> 0) & 7);
8290 flag_C = 0;
8291 flag_V = 0;
8292 flag_NotZ = res;
8293 flag_N = res >> 24;
8294 FETCH_LONG(adr);
8295 PRE_IO
8296 WRITE_LONG_F(adr, res)
8297 POST_IO
8298RET(20)
8299}
8300
8301// MOVEL
8302OPCODE(0x2EC0)
8303{
8304 u32 adr, res;
8305 u32 src, dst;
8306
8307 res = DREGu32((Opcode >> 0) & 7);
8308 flag_C = 0;
8309 flag_V = 0;
8310 flag_NotZ = res;
8311 flag_N = res >> 24;
8312 adr = AREG(7);
8313 AREG(7) += 4;
8314 PRE_IO
8315 WRITE_LONG_F(adr, res)
8316 POST_IO
8317RET(12)
8318}
8319
8320// MOVEL
8321OPCODE(0x2F00)
8322{
8323 u32 adr, res;
8324 u32 src, dst;
8325
8326 res = DREGu32((Opcode >> 0) & 7);
8327 flag_C = 0;
8328 flag_V = 0;
8329 flag_NotZ = res;
8330 flag_N = res >> 24;
8331 adr = AREG(7) - 4;
8332 AREG(7) = adr;
8333 PRE_IO
8334 WRITE_LONG_DEC_F(adr, res)
8335 POST_IO
8336RET(12)
8337}
8338
8339// MOVEL
8340OPCODE(0x2008)
8341{
8342 u32 adr, res;
8343 u32 src, dst;
8344
8345 res = AREGu32((Opcode >> 0) & 7);
8346 flag_C = 0;
8347 flag_V = 0;
8348 flag_NotZ = res;
8349 flag_N = res >> 24;
8350 DREGu32((Opcode >> 9) & 7) = res;
8351RET(4)
8352}
8353
8354// MOVEL
8355OPCODE(0x2088)
8356{
8357 u32 adr, res;
8358 u32 src, dst;
8359
8360 res = AREGu32((Opcode >> 0) & 7);
8361 flag_C = 0;
8362 flag_V = 0;
8363 flag_NotZ = res;
8364 flag_N = res >> 24;
8365 adr = AREG((Opcode >> 9) & 7);
8366 PRE_IO
8367 WRITE_LONG_F(adr, res)
8368 POST_IO
8369RET(12)
8370}
8371
8372// MOVEL
8373OPCODE(0x20C8)
8374{
8375 u32 adr, res;
8376 u32 src, dst;
8377
8378 res = AREGu32((Opcode >> 0) & 7);
8379 flag_C = 0;
8380 flag_V = 0;
8381 flag_NotZ = res;
8382 flag_N = res >> 24;
8383 adr = AREG((Opcode >> 9) & 7);
8384 AREG((Opcode >> 9) & 7) += 4;
8385 PRE_IO
8386 WRITE_LONG_F(adr, res)
8387 POST_IO
8388RET(12)
8389}
8390
8391// MOVEL
8392OPCODE(0x2108)
8393{
8394 u32 adr, res;
8395 u32 src, dst;
8396
8397 res = AREGu32((Opcode >> 0) & 7);
8398 flag_C = 0;
8399 flag_V = 0;
8400 flag_NotZ = res;
8401 flag_N = res >> 24;
8402 adr = AREG((Opcode >> 9) & 7) - 4;
8403 AREG((Opcode >> 9) & 7) = adr;
8404 PRE_IO
8405 WRITE_LONG_DEC_F(adr, res)
8406 POST_IO
8407RET(12)
8408}
8409
8410// MOVEL
8411OPCODE(0x2148)
8412{
8413 u32 adr, res;
8414 u32 src, dst;
8415
8416 res = AREGu32((Opcode >> 0) & 7);
8417 flag_C = 0;
8418 flag_V = 0;
8419 flag_NotZ = res;
8420 flag_N = res >> 24;
8421 FETCH_SWORD(adr);
8422 adr += AREG((Opcode >> 9) & 7);
8423 PRE_IO
8424 WRITE_LONG_F(adr, res)
8425 POST_IO
8426RET(16)
8427}
8428
8429// MOVEL
8430OPCODE(0x2188)
8431{
8432 u32 adr, res;
8433 u32 src, dst;
8434
8435 res = AREGu32((Opcode >> 0) & 7);
8436 flag_C = 0;
8437 flag_V = 0;
8438 flag_NotZ = res;
8439 flag_N = res >> 24;
8440 adr = AREG((Opcode >> 9) & 7);
8441 DECODE_EXT_WORD
8442 PRE_IO
8443 WRITE_LONG_F(adr, res)
8444 POST_IO
8445RET(18)
8446}
8447
8448// MOVEL
8449OPCODE(0x21C8)
8450{
8451 u32 adr, res;
8452 u32 src, dst;
8453
8454 res = AREGu32((Opcode >> 0) & 7);
8455 flag_C = 0;
8456 flag_V = 0;
8457 flag_NotZ = res;
8458 flag_N = res >> 24;
8459 FETCH_SWORD(adr);
8460 PRE_IO
8461 WRITE_LONG_F(adr, res)
8462 POST_IO
8463RET(16)
8464}
8465
8466// MOVEL
8467OPCODE(0x23C8)
8468{
8469 u32 adr, res;
8470 u32 src, dst;
8471
8472 res = AREGu32((Opcode >> 0) & 7);
8473 flag_C = 0;
8474 flag_V = 0;
8475 flag_NotZ = res;
8476 flag_N = res >> 24;
8477 FETCH_LONG(adr);
8478 PRE_IO
8479 WRITE_LONG_F(adr, res)
8480 POST_IO
8481RET(20)
8482}
8483
8484// MOVEL
8485OPCODE(0x2EC8)
8486{
8487 u32 adr, res;
8488 u32 src, dst;
8489
8490 res = AREGu32((Opcode >> 0) & 7);
8491 flag_C = 0;
8492 flag_V = 0;
8493 flag_NotZ = res;
8494 flag_N = res >> 24;
8495 adr = AREG(7);
8496 AREG(7) += 4;
8497 PRE_IO
8498 WRITE_LONG_F(adr, res)
8499 POST_IO
8500RET(12)
8501}
8502
8503// MOVEL
8504OPCODE(0x2F08)
8505{
8506 u32 adr, res;
8507 u32 src, dst;
8508
8509 res = AREGu32((Opcode >> 0) & 7);
8510 flag_C = 0;
8511 flag_V = 0;
8512 flag_NotZ = res;
8513 flag_N = res >> 24;
8514 adr = AREG(7) - 4;
8515 AREG(7) = adr;
8516 PRE_IO
8517 WRITE_LONG_DEC_F(adr, res)
8518 POST_IO
8519RET(12)
8520}
8521
8522// MOVEL
8523OPCODE(0x2010)
8524{
8525 u32 adr, res;
8526 u32 src, dst;
8527
8528 adr = AREG((Opcode >> 0) & 7);
8529 PRE_IO
8530 READ_LONG_F(adr, res)
8531 flag_C = 0;
8532 flag_V = 0;
8533 flag_NotZ = res;
8534 flag_N = res >> 24;
8535 DREGu32((Opcode >> 9) & 7) = res;
8536 POST_IO
8537RET(12)
8538}
8539
8540// MOVEL
8541OPCODE(0x2090)
8542{
8543 u32 adr, res;
8544 u32 src, dst;
8545
8546 adr = AREG((Opcode >> 0) & 7);
8547 PRE_IO
8548 READ_LONG_F(adr, res)
8549 flag_C = 0;
8550 flag_V = 0;
8551 flag_NotZ = res;
8552 flag_N = res >> 24;
8553 adr = AREG((Opcode >> 9) & 7);
8554 WRITE_LONG_F(adr, res)
8555 POST_IO
8556RET(20)
8557}
8558
8559// MOVEL
8560OPCODE(0x20D0)
8561{
8562 u32 adr, res;
8563 u32 src, dst;
8564
8565 adr = AREG((Opcode >> 0) & 7);
8566 PRE_IO
8567 READ_LONG_F(adr, res)
8568 flag_C = 0;
8569 flag_V = 0;
8570 flag_NotZ = res;
8571 flag_N = res >> 24;
8572 adr = AREG((Opcode >> 9) & 7);
8573 AREG((Opcode >> 9) & 7) += 4;
8574 WRITE_LONG_F(adr, res)
8575 POST_IO
8576RET(20)
8577}
8578
8579// MOVEL
8580OPCODE(0x2110)
8581{
8582 u32 adr, res;
8583 u32 src, dst;
8584
8585 adr = AREG((Opcode >> 0) & 7);
8586 PRE_IO
8587 READ_LONG_F(adr, res)
8588 flag_C = 0;
8589 flag_V = 0;
8590 flag_NotZ = res;
8591 flag_N = res >> 24;
8592 adr = AREG((Opcode >> 9) & 7) - 4;
8593 AREG((Opcode >> 9) & 7) = adr;
8594 WRITE_LONG_DEC_F(adr, res)
8595 POST_IO
8596RET(20)
8597}
8598
8599// MOVEL
8600OPCODE(0x2150)
8601{
8602 u32 adr, res;
8603 u32 src, dst;
8604
8605 adr = AREG((Opcode >> 0) & 7);
8606 PRE_IO
8607 READ_LONG_F(adr, res)
8608 flag_C = 0;
8609 flag_V = 0;
8610 flag_NotZ = res;
8611 flag_N = res >> 24;
8612 FETCH_SWORD(adr);
8613 adr += AREG((Opcode >> 9) & 7);
8614 WRITE_LONG_F(adr, res)
8615 POST_IO
8616RET(24)
8617}
8618
8619// MOVEL
8620OPCODE(0x2190)
8621{
8622 u32 adr, res;
8623 u32 src, dst;
8624
8625 adr = AREG((Opcode >> 0) & 7);
8626 PRE_IO
8627 READ_LONG_F(adr, res)
8628 flag_C = 0;
8629 flag_V = 0;
8630 flag_NotZ = res;
8631 flag_N = res >> 24;
8632 adr = AREG((Opcode >> 9) & 7);
8633 DECODE_EXT_WORD
8634 WRITE_LONG_F(adr, res)
8635 POST_IO
8636RET(26)
8637}
8638
8639// MOVEL
8640OPCODE(0x21D0)
8641{
8642 u32 adr, res;
8643 u32 src, dst;
8644
8645 adr = AREG((Opcode >> 0) & 7);
8646 PRE_IO
8647 READ_LONG_F(adr, res)
8648 flag_C = 0;
8649 flag_V = 0;
8650 flag_NotZ = res;
8651 flag_N = res >> 24;
8652 FETCH_SWORD(adr);
8653 WRITE_LONG_F(adr, res)
8654 POST_IO
8655RET(24)
8656}
8657
8658// MOVEL
8659OPCODE(0x23D0)
8660{
8661 u32 adr, res;
8662 u32 src, dst;
8663
8664 adr = AREG((Opcode >> 0) & 7);
8665 PRE_IO
8666 READ_LONG_F(adr, res)
8667 flag_C = 0;
8668 flag_V = 0;
8669 flag_NotZ = res;
8670 flag_N = res >> 24;
8671 FETCH_LONG(adr);
8672 WRITE_LONG_F(adr, res)
8673 POST_IO
8674RET(28)
8675}
8676
8677// MOVEL
8678OPCODE(0x2ED0)
8679{
8680 u32 adr, res;
8681 u32 src, dst;
8682
8683 adr = AREG((Opcode >> 0) & 7);
8684 PRE_IO
8685 READ_LONG_F(adr, res)
8686 flag_C = 0;
8687 flag_V = 0;
8688 flag_NotZ = res;
8689 flag_N = res >> 24;
8690 adr = AREG(7);
8691 AREG(7) += 4;
8692 WRITE_LONG_F(adr, res)
8693 POST_IO
8694RET(20)
8695}
8696
8697// MOVEL
8698OPCODE(0x2F10)
8699{
8700 u32 adr, res;
8701 u32 src, dst;
8702
8703 adr = AREG((Opcode >> 0) & 7);
8704 PRE_IO
8705 READ_LONG_F(adr, res)
8706 flag_C = 0;
8707 flag_V = 0;
8708 flag_NotZ = res;
8709 flag_N = res >> 24;
8710 adr = AREG(7) - 4;
8711 AREG(7) = adr;
8712 WRITE_LONG_DEC_F(adr, res)
8713 POST_IO
8714RET(20)
8715}
8716
8717// MOVEL
8718OPCODE(0x2018)
8719{
8720 u32 adr, res;
8721 u32 src, dst;
8722
8723 adr = AREG((Opcode >> 0) & 7);
8724 AREG((Opcode >> 0) & 7) += 4;
8725 PRE_IO
8726 READ_LONG_F(adr, res)
8727 flag_C = 0;
8728 flag_V = 0;
8729 flag_NotZ = res;
8730 flag_N = res >> 24;
8731 DREGu32((Opcode >> 9) & 7) = res;
8732 POST_IO
8733RET(12)
8734}
8735
8736// MOVEL
8737OPCODE(0x2098)
8738{
8739 u32 adr, res;
8740 u32 src, dst;
8741
8742 adr = AREG((Opcode >> 0) & 7);
8743 AREG((Opcode >> 0) & 7) += 4;
8744 PRE_IO
8745 READ_LONG_F(adr, res)
8746 flag_C = 0;
8747 flag_V = 0;
8748 flag_NotZ = res;
8749 flag_N = res >> 24;
8750 adr = AREG((Opcode >> 9) & 7);
8751 WRITE_LONG_F(adr, res)
8752 POST_IO
8753RET(20)
8754}
8755
8756// MOVEL
8757OPCODE(0x20D8)
8758{
8759 u32 adr, res;
8760 u32 src, dst;
8761
8762 adr = AREG((Opcode >> 0) & 7);
8763 AREG((Opcode >> 0) & 7) += 4;
8764 PRE_IO
8765 READ_LONG_F(adr, res)
8766 flag_C = 0;
8767 flag_V = 0;
8768 flag_NotZ = res;
8769 flag_N = res >> 24;
8770 adr = AREG((Opcode >> 9) & 7);
8771 AREG((Opcode >> 9) & 7) += 4;
8772 WRITE_LONG_F(adr, res)
8773 POST_IO
8774RET(20)
8775}
8776
8777// MOVEL
8778OPCODE(0x2118)
8779{
8780 u32 adr, res;
8781 u32 src, dst;
8782
8783 adr = AREG((Opcode >> 0) & 7);
8784 AREG((Opcode >> 0) & 7) += 4;
8785 PRE_IO
8786 READ_LONG_F(adr, res)
8787 flag_C = 0;
8788 flag_V = 0;
8789 flag_NotZ = res;
8790 flag_N = res >> 24;
8791 adr = AREG((Opcode >> 9) & 7) - 4;
8792 AREG((Opcode >> 9) & 7) = adr;
8793 WRITE_LONG_DEC_F(adr, res)
8794 POST_IO
8795RET(20)
8796}
8797
8798// MOVEL
8799OPCODE(0x2158)
8800{
8801 u32 adr, res;
8802 u32 src, dst;
8803
8804 adr = AREG((Opcode >> 0) & 7);
8805 AREG((Opcode >> 0) & 7) += 4;
8806 PRE_IO
8807 READ_LONG_F(adr, res)
8808 flag_C = 0;
8809 flag_V = 0;
8810 flag_NotZ = res;
8811 flag_N = res >> 24;
8812 FETCH_SWORD(adr);
8813 adr += AREG((Opcode >> 9) & 7);
8814 WRITE_LONG_F(adr, res)
8815 POST_IO
8816RET(24)
8817}
8818
8819// MOVEL
8820OPCODE(0x2198)
8821{
8822 u32 adr, res;
8823 u32 src, dst;
8824
8825 adr = AREG((Opcode >> 0) & 7);
8826 AREG((Opcode >> 0) & 7) += 4;
8827 PRE_IO
8828 READ_LONG_F(adr, res)
8829 flag_C = 0;
8830 flag_V = 0;
8831 flag_NotZ = res;
8832 flag_N = res >> 24;
8833 adr = AREG((Opcode >> 9) & 7);
8834 DECODE_EXT_WORD
8835 WRITE_LONG_F(adr, res)
8836 POST_IO
8837RET(26)
8838}
8839
8840// MOVEL
8841OPCODE(0x21D8)
8842{
8843 u32 adr, res;
8844 u32 src, dst;
8845
8846 adr = AREG((Opcode >> 0) & 7);
8847 AREG((Opcode >> 0) & 7) += 4;
8848 PRE_IO
8849 READ_LONG_F(adr, res)
8850 flag_C = 0;
8851 flag_V = 0;
8852 flag_NotZ = res;
8853 flag_N = res >> 24;
8854 FETCH_SWORD(adr);
8855 WRITE_LONG_F(adr, res)
8856 POST_IO
8857RET(24)
8858}
8859
8860// MOVEL
8861OPCODE(0x23D8)
8862{
8863 u32 adr, res;
8864 u32 src, dst;
8865
8866 adr = AREG((Opcode >> 0) & 7);
8867 AREG((Opcode >> 0) & 7) += 4;
8868 PRE_IO
8869 READ_LONG_F(adr, res)
8870 flag_C = 0;
8871 flag_V = 0;
8872 flag_NotZ = res;
8873 flag_N = res >> 24;
8874 FETCH_LONG(adr);
8875 WRITE_LONG_F(adr, res)
8876 POST_IO
8877RET(28)
8878}
8879
8880// MOVEL
8881OPCODE(0x2ED8)
8882{
8883 u32 adr, res;
8884 u32 src, dst;
8885
8886 adr = AREG((Opcode >> 0) & 7);
8887 AREG((Opcode >> 0) & 7) += 4;
8888 PRE_IO
8889 READ_LONG_F(adr, res)
8890 flag_C = 0;
8891 flag_V = 0;
8892 flag_NotZ = res;
8893 flag_N = res >> 24;
8894 adr = AREG(7);
8895 AREG(7) += 4;
8896 WRITE_LONG_F(adr, res)
8897 POST_IO
8898RET(20)
8899}
8900
8901// MOVEL
8902OPCODE(0x2F18)
8903{
8904 u32 adr, res;
8905 u32 src, dst;
8906
8907 adr = AREG((Opcode >> 0) & 7);
8908 AREG((Opcode >> 0) & 7) += 4;
8909 PRE_IO
8910 READ_LONG_F(adr, res)
8911 flag_C = 0;
8912 flag_V = 0;
8913 flag_NotZ = res;
8914 flag_N = res >> 24;
8915 adr = AREG(7) - 4;
8916 AREG(7) = adr;
8917 WRITE_LONG_DEC_F(adr, res)
8918 POST_IO
8919RET(20)
8920}
8921
8922// MOVEL
8923OPCODE(0x2020)
8924{
8925 u32 adr, res;
8926 u32 src, dst;
8927
8928 adr = AREG((Opcode >> 0) & 7) - 4;
8929 AREG((Opcode >> 0) & 7) = adr;
8930 PRE_IO
8931 READ_LONG_F(adr, res)
8932 flag_C = 0;
8933 flag_V = 0;
8934 flag_NotZ = res;
8935 flag_N = res >> 24;
8936 DREGu32((Opcode >> 9) & 7) = res;
8937 POST_IO
8938RET(14)
8939}
8940
8941// MOVEL
8942OPCODE(0x20A0)
8943{
8944 u32 adr, res;
8945 u32 src, dst;
8946
8947 adr = AREG((Opcode >> 0) & 7) - 4;
8948 AREG((Opcode >> 0) & 7) = adr;
8949 PRE_IO
8950 READ_LONG_F(adr, res)
8951 flag_C = 0;
8952 flag_V = 0;
8953 flag_NotZ = res;
8954 flag_N = res >> 24;
8955 adr = AREG((Opcode >> 9) & 7);
8956 WRITE_LONG_F(adr, res)
8957 POST_IO
8958RET(22)
8959}
8960
8961// MOVEL
8962OPCODE(0x20E0)
8963{
8964 u32 adr, res;
8965 u32 src, dst;
8966
8967 adr = AREG((Opcode >> 0) & 7) - 4;
8968 AREG((Opcode >> 0) & 7) = adr;
8969 PRE_IO
8970 READ_LONG_F(adr, res)
8971 flag_C = 0;
8972 flag_V = 0;
8973 flag_NotZ = res;
8974 flag_N = res >> 24;
8975 adr = AREG((Opcode >> 9) & 7);
8976 AREG((Opcode >> 9) & 7) += 4;
8977 WRITE_LONG_F(adr, res)
8978 POST_IO
8979RET(22)
8980}
8981
8982// MOVEL
8983OPCODE(0x2120)
8984{
8985 u32 adr, res;
8986 u32 src, dst;
8987
8988 adr = AREG((Opcode >> 0) & 7) - 4;
8989 AREG((Opcode >> 0) & 7) = adr;
8990 PRE_IO
8991 READ_LONG_F(adr, res)
8992 flag_C = 0;
8993 flag_V = 0;
8994 flag_NotZ = res;
8995 flag_N = res >> 24;
8996 adr = AREG((Opcode >> 9) & 7) - 4;
8997 AREG((Opcode >> 9) & 7) = adr;
8998 WRITE_LONG_DEC_F(adr, res)
8999 POST_IO
9000RET(22)
9001}
9002
9003// MOVEL
9004OPCODE(0x2160)
9005{
9006 u32 adr, res;
9007 u32 src, dst;
9008
9009 adr = AREG((Opcode >> 0) & 7) - 4;
9010 AREG((Opcode >> 0) & 7) = adr;
9011 PRE_IO
9012 READ_LONG_F(adr, res)
9013 flag_C = 0;
9014 flag_V = 0;
9015 flag_NotZ = res;
9016 flag_N = res >> 24;
9017 FETCH_SWORD(adr);
9018 adr += AREG((Opcode >> 9) & 7);
9019 WRITE_LONG_F(adr, res)
9020 POST_IO
9021RET(26)
9022}
9023
9024// MOVEL
9025OPCODE(0x21A0)
9026{
9027 u32 adr, res;
9028 u32 src, dst;
9029
9030 adr = AREG((Opcode >> 0) & 7) - 4;
9031 AREG((Opcode >> 0) & 7) = adr;
9032 PRE_IO
9033 READ_LONG_F(adr, res)
9034 flag_C = 0;
9035 flag_V = 0;
9036 flag_NotZ = res;
9037 flag_N = res >> 24;
9038 adr = AREG((Opcode >> 9) & 7);
9039 DECODE_EXT_WORD
9040 WRITE_LONG_F(adr, res)
9041 POST_IO
9042RET(28)
9043}
9044
9045// MOVEL
9046OPCODE(0x21E0)
9047{
9048 u32 adr, res;
9049 u32 src, dst;
9050
9051 adr = AREG((Opcode >> 0) & 7) - 4;
9052 AREG((Opcode >> 0) & 7) = adr;
9053 PRE_IO
9054 READ_LONG_F(adr, res)
9055 flag_C = 0;
9056 flag_V = 0;
9057 flag_NotZ = res;
9058 flag_N = res >> 24;
9059 FETCH_SWORD(adr);
9060 WRITE_LONG_F(adr, res)
9061 POST_IO
9062RET(26)
9063}
9064
9065// MOVEL
9066OPCODE(0x23E0)
9067{
9068 u32 adr, res;
9069 u32 src, dst;
9070
9071 adr = AREG((Opcode >> 0) & 7) - 4;
9072 AREG((Opcode >> 0) & 7) = adr;
9073 PRE_IO
9074 READ_LONG_F(adr, res)
9075 flag_C = 0;
9076 flag_V = 0;
9077 flag_NotZ = res;
9078 flag_N = res >> 24;
9079 FETCH_LONG(adr);
9080 WRITE_LONG_F(adr, res)
9081 POST_IO
9082RET(30)
9083}
9084
9085// MOVEL
9086OPCODE(0x2EE0)
9087{
9088 u32 adr, res;
9089 u32 src, dst;
9090
9091 adr = AREG((Opcode >> 0) & 7) - 4;
9092 AREG((Opcode >> 0) & 7) = adr;
9093 PRE_IO
9094 READ_LONG_F(adr, res)
9095 flag_C = 0;
9096 flag_V = 0;
9097 flag_NotZ = res;
9098 flag_N = res >> 24;
9099 adr = AREG(7);
9100 AREG(7) += 4;
9101 WRITE_LONG_F(adr, res)
9102 POST_IO
9103RET(22)
9104}
9105
9106// MOVEL
9107OPCODE(0x2F20)
9108{
9109 u32 adr, res;
9110 u32 src, dst;
9111
9112 adr = AREG((Opcode >> 0) & 7) - 4;
9113 AREG((Opcode >> 0) & 7) = adr;
9114 PRE_IO
9115 READ_LONG_F(adr, res)
9116 flag_C = 0;
9117 flag_V = 0;
9118 flag_NotZ = res;
9119 flag_N = res >> 24;
9120 adr = AREG(7) - 4;
9121 AREG(7) = adr;
9122 WRITE_LONG_DEC_F(adr, res)
9123 POST_IO
9124RET(22)
9125}
9126
9127// MOVEL
9128OPCODE(0x2028)
9129{
9130 u32 adr, res;
9131 u32 src, dst;
9132
9133 FETCH_SWORD(adr);
9134 adr += AREG((Opcode >> 0) & 7);
9135 PRE_IO
9136 READ_LONG_F(adr, res)
9137 flag_C = 0;
9138 flag_V = 0;
9139 flag_NotZ = res;
9140 flag_N = res >> 24;
9141 DREGu32((Opcode >> 9) & 7) = res;
9142 POST_IO
9143RET(16)
9144}
9145
9146// MOVEL
9147OPCODE(0x20A8)
9148{
9149 u32 adr, res;
9150 u32 src, dst;
9151
9152 FETCH_SWORD(adr);
9153 adr += AREG((Opcode >> 0) & 7);
9154 PRE_IO
9155 READ_LONG_F(adr, res)
9156 flag_C = 0;
9157 flag_V = 0;
9158 flag_NotZ = res;
9159 flag_N = res >> 24;
9160 adr = AREG((Opcode >> 9) & 7);
9161 WRITE_LONG_F(adr, res)
9162 POST_IO
9163RET(24)
9164}
9165
9166// MOVEL
9167OPCODE(0x20E8)
9168{
9169 u32 adr, res;
9170 u32 src, dst;
9171
9172 FETCH_SWORD(adr);
9173 adr += AREG((Opcode >> 0) & 7);
9174 PRE_IO
9175 READ_LONG_F(adr, res)
9176 flag_C = 0;
9177 flag_V = 0;
9178 flag_NotZ = res;
9179 flag_N = res >> 24;
9180 adr = AREG((Opcode >> 9) & 7);
9181 AREG((Opcode >> 9) & 7) += 4;
9182 WRITE_LONG_F(adr, res)
9183 POST_IO
9184RET(24)
9185}
9186
9187// MOVEL
9188OPCODE(0x2128)
9189{
9190 u32 adr, res;
9191 u32 src, dst;
9192
9193 FETCH_SWORD(adr);
9194 adr += AREG((Opcode >> 0) & 7);
9195 PRE_IO
9196 READ_LONG_F(adr, res)
9197 flag_C = 0;
9198 flag_V = 0;
9199 flag_NotZ = res;
9200 flag_N = res >> 24;
9201 adr = AREG((Opcode >> 9) & 7) - 4;
9202 AREG((Opcode >> 9) & 7) = adr;
9203 WRITE_LONG_DEC_F(adr, res)
9204 POST_IO
9205RET(24)
9206}
9207
9208// MOVEL
9209OPCODE(0x2168)
9210{
9211 u32 adr, res;
9212 u32 src, dst;
9213
9214 FETCH_SWORD(adr);
9215 adr += AREG((Opcode >> 0) & 7);
9216 PRE_IO
9217 READ_LONG_F(adr, res)
9218 flag_C = 0;
9219 flag_V = 0;
9220 flag_NotZ = res;
9221 flag_N = res >> 24;
9222 FETCH_SWORD(adr);
9223 adr += AREG((Opcode >> 9) & 7);
9224 WRITE_LONG_F(adr, res)
9225 POST_IO
9226RET(28)
9227}
9228
9229// MOVEL
9230OPCODE(0x21A8)
9231{
9232 u32 adr, res;
9233 u32 src, dst;
9234
9235 FETCH_SWORD(adr);
9236 adr += AREG((Opcode >> 0) & 7);
9237 PRE_IO
9238 READ_LONG_F(adr, res)
9239 flag_C = 0;
9240 flag_V = 0;
9241 flag_NotZ = res;
9242 flag_N = res >> 24;
9243 adr = AREG((Opcode >> 9) & 7);
9244 DECODE_EXT_WORD
9245 WRITE_LONG_F(adr, res)
9246 POST_IO
9247RET(30)
9248}
9249
9250// MOVEL
9251OPCODE(0x21E8)
9252{
9253 u32 adr, res;
9254 u32 src, dst;
9255
9256 FETCH_SWORD(adr);
9257 adr += AREG((Opcode >> 0) & 7);
9258 PRE_IO
9259 READ_LONG_F(adr, res)
9260 flag_C = 0;
9261 flag_V = 0;
9262 flag_NotZ = res;
9263 flag_N = res >> 24;
9264 FETCH_SWORD(adr);
9265 WRITE_LONG_F(adr, res)
9266 POST_IO
9267RET(28)
9268}
9269
9270// MOVEL
9271OPCODE(0x23E8)
9272{
9273 u32 adr, res;
9274 u32 src, dst;
9275
9276 FETCH_SWORD(adr);
9277 adr += AREG((Opcode >> 0) & 7);
9278 PRE_IO
9279 READ_LONG_F(adr, res)
9280 flag_C = 0;
9281 flag_V = 0;
9282 flag_NotZ = res;
9283 flag_N = res >> 24;
9284 FETCH_LONG(adr);
9285 WRITE_LONG_F(adr, res)
9286 POST_IO
9287RET(32)
9288}
9289
9290// MOVEL
9291OPCODE(0x2EE8)
9292{
9293 u32 adr, res;
9294 u32 src, dst;
9295
9296 FETCH_SWORD(adr);
9297 adr += AREG((Opcode >> 0) & 7);
9298 PRE_IO
9299 READ_LONG_F(adr, res)
9300 flag_C = 0;
9301 flag_V = 0;
9302 flag_NotZ = res;
9303 flag_N = res >> 24;
9304 adr = AREG(7);
9305 AREG(7) += 4;
9306 WRITE_LONG_F(adr, res)
9307 POST_IO
9308RET(24)
9309}
9310
9311// MOVEL
9312OPCODE(0x2F28)
9313{
9314 u32 adr, res;
9315 u32 src, dst;
9316
9317 FETCH_SWORD(adr);
9318 adr += AREG((Opcode >> 0) & 7);
9319 PRE_IO
9320 READ_LONG_F(adr, res)
9321 flag_C = 0;
9322 flag_V = 0;
9323 flag_NotZ = res;
9324 flag_N = res >> 24;
9325 adr = AREG(7) - 4;
9326 AREG(7) = adr;
9327 WRITE_LONG_DEC_F(adr, res)
9328 POST_IO
9329RET(24)
9330}
9331
9332// MOVEL
9333OPCODE(0x2030)
9334{
9335 u32 adr, res;
9336 u32 src, dst;
9337
9338 adr = AREG((Opcode >> 0) & 7);
9339 DECODE_EXT_WORD
9340 PRE_IO
9341 READ_LONG_F(adr, res)
9342 flag_C = 0;
9343 flag_V = 0;
9344 flag_NotZ = res;
9345 flag_N = res >> 24;
9346 DREGu32((Opcode >> 9) & 7) = res;
9347 POST_IO
9348RET(18)
9349}
9350
9351// MOVEL
9352OPCODE(0x20B0)
9353{
9354 u32 adr, res;
9355 u32 src, dst;
9356
9357 adr = AREG((Opcode >> 0) & 7);
9358 DECODE_EXT_WORD
9359 PRE_IO
9360 READ_LONG_F(adr, res)
9361 flag_C = 0;
9362 flag_V = 0;
9363 flag_NotZ = res;
9364 flag_N = res >> 24;
9365 adr = AREG((Opcode >> 9) & 7);
9366 WRITE_LONG_F(adr, res)
9367 POST_IO
9368RET(26)
9369}
9370
9371// MOVEL
9372OPCODE(0x20F0)
9373{
9374 u32 adr, res;
9375 u32 src, dst;
9376
9377 adr = AREG((Opcode >> 0) & 7);
9378 DECODE_EXT_WORD
9379 PRE_IO
9380 READ_LONG_F(adr, res)
9381 flag_C = 0;
9382 flag_V = 0;
9383 flag_NotZ = res;
9384 flag_N = res >> 24;
9385 adr = AREG((Opcode >> 9) & 7);
9386 AREG((Opcode >> 9) & 7) += 4;
9387 WRITE_LONG_F(adr, res)
9388 POST_IO
9389RET(26)
9390}
9391
9392// MOVEL
9393OPCODE(0x2130)
9394{
9395 u32 adr, res;
9396 u32 src, dst;
9397
9398 adr = AREG((Opcode >> 0) & 7);
9399 DECODE_EXT_WORD
9400 PRE_IO
9401 READ_LONG_F(adr, res)
9402 flag_C = 0;
9403 flag_V = 0;
9404 flag_NotZ = res;
9405 flag_N = res >> 24;
9406 adr = AREG((Opcode >> 9) & 7) - 4;
9407 AREG((Opcode >> 9) & 7) = adr;
9408 WRITE_LONG_DEC_F(adr, res)
9409 POST_IO
9410RET(26)
9411}
9412
9413// MOVEL
9414OPCODE(0x2170)
9415{
9416 u32 adr, res;
9417 u32 src, dst;
9418
9419 adr = AREG((Opcode >> 0) & 7);
9420 DECODE_EXT_WORD
9421 PRE_IO
9422 READ_LONG_F(adr, res)
9423 flag_C = 0;
9424 flag_V = 0;
9425 flag_NotZ = res;
9426 flag_N = res >> 24;
9427 FETCH_SWORD(adr);
9428 adr += AREG((Opcode >> 9) & 7);
9429 WRITE_LONG_F(adr, res)
9430 POST_IO
9431RET(30)
9432}
9433
9434// MOVEL
9435OPCODE(0x21B0)
9436{
9437 u32 adr, res;
9438 u32 src, dst;
9439
9440 adr = AREG((Opcode >> 0) & 7);
9441 DECODE_EXT_WORD
9442 PRE_IO
9443 READ_LONG_F(adr, res)
9444 flag_C = 0;
9445 flag_V = 0;
9446 flag_NotZ = res;
9447 flag_N = res >> 24;
9448 adr = AREG((Opcode >> 9) & 7);
9449 DECODE_EXT_WORD
9450 WRITE_LONG_F(adr, res)
9451 POST_IO
9452RET(32)
9453}
9454
9455// MOVEL
9456OPCODE(0x21F0)
9457{
9458 u32 adr, res;
9459 u32 src, dst;
9460
9461 adr = AREG((Opcode >> 0) & 7);
9462 DECODE_EXT_WORD
9463 PRE_IO
9464 READ_LONG_F(adr, res)
9465 flag_C = 0;
9466 flag_V = 0;
9467 flag_NotZ = res;
9468 flag_N = res >> 24;
9469 FETCH_SWORD(adr);
9470 WRITE_LONG_F(adr, res)
9471 POST_IO
9472RET(30)
9473}
9474
9475// MOVEL
9476OPCODE(0x23F0)
9477{
9478 u32 adr, res;
9479 u32 src, dst;
9480
9481 adr = AREG((Opcode >> 0) & 7);
9482 DECODE_EXT_WORD
9483 PRE_IO
9484 READ_LONG_F(adr, res)
9485 flag_C = 0;
9486 flag_V = 0;
9487 flag_NotZ = res;
9488 flag_N = res >> 24;
9489 FETCH_LONG(adr);
9490 WRITE_LONG_F(adr, res)
9491 POST_IO
9492RET(34)
9493}
9494
9495// MOVEL
9496OPCODE(0x2EF0)
9497{
9498 u32 adr, res;
9499 u32 src, dst;
9500
9501 adr = AREG((Opcode >> 0) & 7);
9502 DECODE_EXT_WORD
9503 PRE_IO
9504 READ_LONG_F(adr, res)
9505 flag_C = 0;
9506 flag_V = 0;
9507 flag_NotZ = res;
9508 flag_N = res >> 24;
9509 adr = AREG(7);
9510 AREG(7) += 4;
9511 WRITE_LONG_F(adr, res)
9512 POST_IO
9513RET(26)
9514}
9515
9516// MOVEL
9517OPCODE(0x2F30)
9518{
9519 u32 adr, res;
9520 u32 src, dst;
9521
9522 adr = AREG((Opcode >> 0) & 7);
9523 DECODE_EXT_WORD
9524 PRE_IO
9525 READ_LONG_F(adr, res)
9526 flag_C = 0;
9527 flag_V = 0;
9528 flag_NotZ = res;
9529 flag_N = res >> 24;
9530 adr = AREG(7) - 4;
9531 AREG(7) = adr;
9532 WRITE_LONG_DEC_F(adr, res)
9533 POST_IO
9534RET(26)
9535}
9536
9537// MOVEL
9538OPCODE(0x2038)
9539{
9540 u32 adr, res;
9541 u32 src, dst;
9542
9543 FETCH_SWORD(adr);
9544 PRE_IO
9545 READ_LONG_F(adr, res)
9546 flag_C = 0;
9547 flag_V = 0;
9548 flag_NotZ = res;
9549 flag_N = res >> 24;
9550 DREGu32((Opcode >> 9) & 7) = res;
9551 POST_IO
9552RET(16)
9553}
9554
9555// MOVEL
9556OPCODE(0x20B8)
9557{
9558 u32 adr, res;
9559 u32 src, dst;
9560
9561 FETCH_SWORD(adr);
9562 PRE_IO
9563 READ_LONG_F(adr, res)
9564 flag_C = 0;
9565 flag_V = 0;
9566 flag_NotZ = res;
9567 flag_N = res >> 24;
9568 adr = AREG((Opcode >> 9) & 7);
9569 WRITE_LONG_F(adr, res)
9570 POST_IO
9571RET(24)
9572}
9573
9574// MOVEL
9575OPCODE(0x20F8)
9576{
9577 u32 adr, res;
9578 u32 src, dst;
9579
9580 FETCH_SWORD(adr);
9581 PRE_IO
9582 READ_LONG_F(adr, res)
9583 flag_C = 0;
9584 flag_V = 0;
9585 flag_NotZ = res;
9586 flag_N = res >> 24;
9587 adr = AREG((Opcode >> 9) & 7);
9588 AREG((Opcode >> 9) & 7) += 4;
9589 WRITE_LONG_F(adr, res)
9590 POST_IO
9591RET(24)
9592}
9593
9594// MOVEL
9595OPCODE(0x2138)
9596{
9597 u32 adr, res;
9598 u32 src, dst;
9599
9600 FETCH_SWORD(adr);
9601 PRE_IO
9602 READ_LONG_F(adr, res)
9603 flag_C = 0;
9604 flag_V = 0;
9605 flag_NotZ = res;
9606 flag_N = res >> 24;
9607 adr = AREG((Opcode >> 9) & 7) - 4;
9608 AREG((Opcode >> 9) & 7) = adr;
9609 WRITE_LONG_DEC_F(adr, res)
9610 POST_IO
9611RET(24)
9612}
9613
9614// MOVEL
9615OPCODE(0x2178)
9616{
9617 u32 adr, res;
9618 u32 src, dst;
9619
9620 FETCH_SWORD(adr);
9621 PRE_IO
9622 READ_LONG_F(adr, res)
9623 flag_C = 0;
9624 flag_V = 0;
9625 flag_NotZ = res;
9626 flag_N = res >> 24;
9627 FETCH_SWORD(adr);
9628 adr += AREG((Opcode >> 9) & 7);
9629 WRITE_LONG_F(adr, res)
9630 POST_IO
9631RET(28)
9632}
9633
9634// MOVEL
9635OPCODE(0x21B8)
9636{
9637 u32 adr, res;
9638 u32 src, dst;
9639
9640 FETCH_SWORD(adr);
9641 PRE_IO
9642 READ_LONG_F(adr, res)
9643 flag_C = 0;
9644 flag_V = 0;
9645 flag_NotZ = res;
9646 flag_N = res >> 24;
9647 adr = AREG((Opcode >> 9) & 7);
9648 DECODE_EXT_WORD
9649 WRITE_LONG_F(adr, res)
9650 POST_IO
9651RET(30)
9652}
9653
9654// MOVEL
9655OPCODE(0x21F8)
9656{
9657 u32 adr, res;
9658 u32 src, dst;
9659
9660 FETCH_SWORD(adr);
9661 PRE_IO
9662 READ_LONG_F(adr, res)
9663 flag_C = 0;
9664 flag_V = 0;
9665 flag_NotZ = res;
9666 flag_N = res >> 24;
9667 FETCH_SWORD(adr);
9668 WRITE_LONG_F(adr, res)
9669 POST_IO
9670RET(28)
9671}
9672
9673// MOVEL
9674OPCODE(0x23F8)
9675{
9676 u32 adr, res;
9677 u32 src, dst;
9678
9679 FETCH_SWORD(adr);
9680 PRE_IO
9681 READ_LONG_F(adr, res)
9682 flag_C = 0;
9683 flag_V = 0;
9684 flag_NotZ = res;
9685 flag_N = res >> 24;
9686 FETCH_LONG(adr);
9687 WRITE_LONG_F(adr, res)
9688 POST_IO
9689RET(32)
9690}
9691
9692// MOVEL
9693OPCODE(0x2EF8)
9694{
9695 u32 adr, res;
9696 u32 src, dst;
9697
9698 FETCH_SWORD(adr);
9699 PRE_IO
9700 READ_LONG_F(adr, res)
9701 flag_C = 0;
9702 flag_V = 0;
9703 flag_NotZ = res;
9704 flag_N = res >> 24;
9705 adr = AREG(7);
9706 AREG(7) += 4;
9707 WRITE_LONG_F(adr, res)
9708 POST_IO
9709RET(24)
9710}
9711
9712// MOVEL
9713OPCODE(0x2F38)
9714{
9715 u32 adr, res;
9716 u32 src, dst;
9717
9718 FETCH_SWORD(adr);
9719 PRE_IO
9720 READ_LONG_F(adr, res)
9721 flag_C = 0;
9722 flag_V = 0;
9723 flag_NotZ = res;
9724 flag_N = res >> 24;
9725 adr = AREG(7) - 4;
9726 AREG(7) = adr;
9727 WRITE_LONG_DEC_F(adr, res)
9728 POST_IO
9729RET(24)
9730}
9731
9732// MOVEL
9733OPCODE(0x2039)
9734{
9735 u32 adr, res;
9736 u32 src, dst;
9737
9738 FETCH_LONG(adr);
9739 PRE_IO
9740 READ_LONG_F(adr, res)
9741 flag_C = 0;
9742 flag_V = 0;
9743 flag_NotZ = res;
9744 flag_N = res >> 24;
9745 DREGu32((Opcode >> 9) & 7) = res;
9746 POST_IO
9747RET(20)
9748}
9749
9750// MOVEL
9751OPCODE(0x20B9)
9752{
9753 u32 adr, res;
9754 u32 src, dst;
9755
9756 FETCH_LONG(adr);
9757 PRE_IO
9758 READ_LONG_F(adr, res)
9759 flag_C = 0;
9760 flag_V = 0;
9761 flag_NotZ = res;
9762 flag_N = res >> 24;
9763 adr = AREG((Opcode >> 9) & 7);
9764 WRITE_LONG_F(adr, res)
9765 POST_IO
9766RET(28)
9767}
9768
9769// MOVEL
9770OPCODE(0x20F9)
9771{
9772 u32 adr, res;
9773 u32 src, dst;
9774
9775 FETCH_LONG(adr);
9776 PRE_IO
9777 READ_LONG_F(adr, res)
9778 flag_C = 0;
9779 flag_V = 0;
9780 flag_NotZ = res;
9781 flag_N = res >> 24;
9782 adr = AREG((Opcode >> 9) & 7);
9783 AREG((Opcode >> 9) & 7) += 4;
9784 WRITE_LONG_F(adr, res)
9785 POST_IO
9786RET(28)
9787}
9788
9789// MOVEL
9790OPCODE(0x2139)
9791{
9792 u32 adr, res;
9793 u32 src, dst;
9794
9795 FETCH_LONG(adr);
9796 PRE_IO
9797 READ_LONG_F(adr, res)
9798 flag_C = 0;
9799 flag_V = 0;
9800 flag_NotZ = res;
9801 flag_N = res >> 24;
9802 adr = AREG((Opcode >> 9) & 7) - 4;
9803 AREG((Opcode >> 9) & 7) = adr;
9804 WRITE_LONG_DEC_F(adr, res)
9805 POST_IO
9806RET(28)
9807}
9808
9809// MOVEL
9810OPCODE(0x2179)
9811{
9812 u32 adr, res;
9813 u32 src, dst;
9814
9815 FETCH_LONG(adr);
9816 PRE_IO
9817 READ_LONG_F(adr, res)
9818 flag_C = 0;
9819 flag_V = 0;
9820 flag_NotZ = res;
9821 flag_N = res >> 24;
9822 FETCH_SWORD(adr);
9823 adr += AREG((Opcode >> 9) & 7);
9824 WRITE_LONG_F(adr, res)
9825 POST_IO
9826RET(32)
9827}
9828
9829// MOVEL
9830OPCODE(0x21B9)
9831{
9832 u32 adr, res;
9833 u32 src, dst;
9834
9835 FETCH_LONG(adr);
9836 PRE_IO
9837 READ_LONG_F(adr, res)
9838 flag_C = 0;
9839 flag_V = 0;
9840 flag_NotZ = res;
9841 flag_N = res >> 24;
9842 adr = AREG((Opcode >> 9) & 7);
9843 DECODE_EXT_WORD
9844 WRITE_LONG_F(adr, res)
9845 POST_IO
9846RET(34)
9847}
9848
9849// MOVEL
9850OPCODE(0x21F9)
9851{
9852 u32 adr, res;
9853 u32 src, dst;
9854
9855 FETCH_LONG(adr);
9856 PRE_IO
9857 READ_LONG_F(adr, res)
9858 flag_C = 0;
9859 flag_V = 0;
9860 flag_NotZ = res;
9861 flag_N = res >> 24;
9862 FETCH_SWORD(adr);
9863 WRITE_LONG_F(adr, res)
9864 POST_IO
9865RET(32)
9866}
9867
9868// MOVEL
9869OPCODE(0x23F9)
9870{
9871 u32 adr, res;
9872 u32 src, dst;
9873
9874 FETCH_LONG(adr);
9875 PRE_IO
9876 READ_LONG_F(adr, res)
9877 flag_C = 0;
9878 flag_V = 0;
9879 flag_NotZ = res;
9880 flag_N = res >> 24;
9881 FETCH_LONG(adr);
9882 WRITE_LONG_F(adr, res)
9883 POST_IO
9884RET(36)
9885}
9886
9887// MOVEL
9888OPCODE(0x2EF9)
9889{
9890 u32 adr, res;
9891 u32 src, dst;
9892
9893 FETCH_LONG(adr);
9894 PRE_IO
9895 READ_LONG_F(adr, res)
9896 flag_C = 0;
9897 flag_V = 0;
9898 flag_NotZ = res;
9899 flag_N = res >> 24;
9900 adr = AREG(7);
9901 AREG(7) += 4;
9902 WRITE_LONG_F(adr, res)
9903 POST_IO
9904RET(28)
9905}
9906
9907// MOVEL
9908OPCODE(0x2F39)
9909{
9910 u32 adr, res;
9911 u32 src, dst;
9912
9913 FETCH_LONG(adr);
9914 PRE_IO
9915 READ_LONG_F(adr, res)
9916 flag_C = 0;
9917 flag_V = 0;
9918 flag_NotZ = res;
9919 flag_N = res >> 24;
9920 adr = AREG(7) - 4;
9921 AREG(7) = adr;
9922 WRITE_LONG_DEC_F(adr, res)
9923 POST_IO
9924RET(28)
9925}
9926
9927// MOVEL
9928OPCODE(0x203A)
9929{
9930 u32 adr, res;
9931 u32 src, dst;
9932
9933 adr = GET_SWORD + GET_PC;
9934 PC++;
9935 PRE_IO
9936 READ_LONG_F(adr, res)
9937 flag_C = 0;
9938 flag_V = 0;
9939 flag_NotZ = res;
9940 flag_N = res >> 24;
9941 DREGu32((Opcode >> 9) & 7) = res;
9942 POST_IO
9943RET(16)
9944}
9945
9946// MOVEL
9947OPCODE(0x20BA)
9948{
9949 u32 adr, res;
9950 u32 src, dst;
9951
9952 adr = GET_SWORD + GET_PC;
9953 PC++;
9954 PRE_IO
9955 READ_LONG_F(adr, res)
9956 flag_C = 0;
9957 flag_V = 0;
9958 flag_NotZ = res;
9959 flag_N = res >> 24;
9960 adr = AREG((Opcode >> 9) & 7);
9961 WRITE_LONG_F(adr, res)
9962 POST_IO
9963RET(24)
9964}
9965
9966// MOVEL
9967OPCODE(0x20FA)
9968{
9969 u32 adr, res;
9970 u32 src, dst;
9971
9972 adr = GET_SWORD + GET_PC;
9973 PC++;
9974 PRE_IO
9975 READ_LONG_F(adr, res)
9976 flag_C = 0;
9977 flag_V = 0;
9978 flag_NotZ = res;
9979 flag_N = res >> 24;
9980 adr = AREG((Opcode >> 9) & 7);
9981 AREG((Opcode >> 9) & 7) += 4;
9982 WRITE_LONG_F(adr, res)
9983 POST_IO
9984RET(24)
9985}
9986
9987// MOVEL
9988OPCODE(0x213A)
9989{
9990 u32 adr, res;
9991 u32 src, dst;
9992
9993 adr = GET_SWORD + GET_PC;
9994 PC++;
9995 PRE_IO
9996 READ_LONG_F(adr, res)
9997 flag_C = 0;
9998 flag_V = 0;
9999 flag_NotZ = res;
10000 flag_N = res >> 24;
10001 adr = AREG((Opcode >> 9) & 7) - 4;
10002 AREG((Opcode >> 9) & 7) = adr;
10003 WRITE_LONG_DEC_F(adr, res)
10004 POST_IO
10005RET(24)
10006}
10007
10008// MOVEL
10009OPCODE(0x217A)
10010{
10011 u32 adr, res;
10012 u32 src, dst;
10013
10014 adr = GET_SWORD + GET_PC;
10015 PC++;
10016 PRE_IO
10017 READ_LONG_F(adr, res)
10018 flag_C = 0;
10019 flag_V = 0;
10020 flag_NotZ = res;
10021 flag_N = res >> 24;
10022 FETCH_SWORD(adr);
10023 adr += AREG((Opcode >> 9) & 7);
10024 WRITE_LONG_F(adr, res)
10025 POST_IO
10026RET(28)
10027}
10028
10029// MOVEL
10030OPCODE(0x21BA)
10031{
10032 u32 adr, res;
10033 u32 src, dst;
10034
10035 adr = GET_SWORD + GET_PC;
10036 PC++;
10037 PRE_IO
10038 READ_LONG_F(adr, res)
10039 flag_C = 0;
10040 flag_V = 0;
10041 flag_NotZ = res;
10042 flag_N = res >> 24;
10043 adr = AREG((Opcode >> 9) & 7);
10044 DECODE_EXT_WORD
10045 WRITE_LONG_F(adr, res)
10046 POST_IO
10047RET(30)
10048}
10049
10050// MOVEL
10051OPCODE(0x21FA)
10052{
10053 u32 adr, res;
10054 u32 src, dst;
10055
10056 adr = GET_SWORD + GET_PC;
10057 PC++;
10058 PRE_IO
10059 READ_LONG_F(adr, res)
10060 flag_C = 0;
10061 flag_V = 0;
10062 flag_NotZ = res;
10063 flag_N = res >> 24;
10064 FETCH_SWORD(adr);
10065 WRITE_LONG_F(adr, res)
10066 POST_IO
10067RET(28)
10068}
10069
10070// MOVEL
10071OPCODE(0x23FA)
10072{
10073 u32 adr, res;
10074 u32 src, dst;
10075
10076 adr = GET_SWORD + GET_PC;
10077 PC++;
10078 PRE_IO
10079 READ_LONG_F(adr, res)
10080 flag_C = 0;
10081 flag_V = 0;
10082 flag_NotZ = res;
10083 flag_N = res >> 24;
10084 FETCH_LONG(adr);
10085 WRITE_LONG_F(adr, res)
10086 POST_IO
10087RET(32)
10088}
10089
10090// MOVEL
10091OPCODE(0x2EFA)
10092{
10093 u32 adr, res;
10094 u32 src, dst;
10095
10096 adr = GET_SWORD + GET_PC;
10097 PC++;
10098 PRE_IO
10099 READ_LONG_F(adr, res)
10100 flag_C = 0;
10101 flag_V = 0;
10102 flag_NotZ = res;
10103 flag_N = res >> 24;
10104 adr = AREG(7);
10105 AREG(7) += 4;
10106 WRITE_LONG_F(adr, res)
10107 POST_IO
10108RET(24)
10109}
10110
10111// MOVEL
10112OPCODE(0x2F3A)
10113{
10114 u32 adr, res;
10115 u32 src, dst;
10116
10117 adr = GET_SWORD + GET_PC;
10118 PC++;
10119 PRE_IO
10120 READ_LONG_F(adr, res)
10121 flag_C = 0;
10122 flag_V = 0;
10123 flag_NotZ = res;
10124 flag_N = res >> 24;
10125 adr = AREG(7) - 4;
10126 AREG(7) = adr;
10127 WRITE_LONG_DEC_F(adr, res)
10128 POST_IO
10129RET(24)
10130}
10131
10132// MOVEL
10133OPCODE(0x203B)
10134{
10135 u32 adr, res;
10136 u32 src, dst;
10137
10138 adr = GET_PC;
10139 DECODE_EXT_WORD
10140 PRE_IO
10141 READ_LONG_F(adr, res)
10142 flag_C = 0;
10143 flag_V = 0;
10144 flag_NotZ = res;
10145 flag_N = res >> 24;
10146 DREGu32((Opcode >> 9) & 7) = res;
10147 POST_IO
10148RET(18)
10149}
10150
10151// MOVEL
10152OPCODE(0x20BB)
10153{
10154 u32 adr, res;
10155 u32 src, dst;
10156
10157 adr = GET_PC;
10158 DECODE_EXT_WORD
10159 PRE_IO
10160 READ_LONG_F(adr, res)
10161 flag_C = 0;
10162 flag_V = 0;
10163 flag_NotZ = res;
10164 flag_N = res >> 24;
10165 adr = AREG((Opcode >> 9) & 7);
10166 WRITE_LONG_F(adr, res)
10167 POST_IO
10168RET(26)
10169}
10170
10171// MOVEL
10172OPCODE(0x20FB)
10173{
10174 u32 adr, res;
10175 u32 src, dst;
10176
10177 adr = GET_PC;
10178 DECODE_EXT_WORD
10179 PRE_IO
10180 READ_LONG_F(adr, res)
10181 flag_C = 0;
10182 flag_V = 0;
10183 flag_NotZ = res;
10184 flag_N = res >> 24;
10185 adr = AREG((Opcode >> 9) & 7);
10186 AREG((Opcode >> 9) & 7) += 4;
10187 WRITE_LONG_F(adr, res)
10188 POST_IO
10189RET(26)
10190}
10191
10192// MOVEL
10193OPCODE(0x213B)
10194{
10195 u32 adr, res;
10196 u32 src, dst;
10197
10198 adr = GET_PC;
10199 DECODE_EXT_WORD
10200 PRE_IO
10201 READ_LONG_F(adr, res)
10202 flag_C = 0;
10203 flag_V = 0;
10204 flag_NotZ = res;
10205 flag_N = res >> 24;
10206 adr = AREG((Opcode >> 9) & 7) - 4;
10207 AREG((Opcode >> 9) & 7) = adr;
10208 WRITE_LONG_DEC_F(adr, res)
10209 POST_IO
10210RET(26)
10211}
10212
10213// MOVEL
10214OPCODE(0x217B)
10215{
10216 u32 adr, res;
10217 u32 src, dst;
10218
10219 adr = GET_PC;
10220 DECODE_EXT_WORD
10221 PRE_IO
10222 READ_LONG_F(adr, res)
10223 flag_C = 0;
10224 flag_V = 0;
10225 flag_NotZ = res;
10226 flag_N = res >> 24;
10227 FETCH_SWORD(adr);
10228 adr += AREG((Opcode >> 9) & 7);
10229 WRITE_LONG_F(adr, res)
10230 POST_IO
10231RET(30)
10232}
10233
10234// MOVEL
10235OPCODE(0x21BB)
10236{
10237 u32 adr, res;
10238 u32 src, dst;
10239
10240 adr = GET_PC;
10241 DECODE_EXT_WORD
10242 PRE_IO
10243 READ_LONG_F(adr, res)
10244 flag_C = 0;
10245 flag_V = 0;
10246 flag_NotZ = res;
10247 flag_N = res >> 24;
10248 adr = AREG((Opcode >> 9) & 7);
10249 DECODE_EXT_WORD
10250 WRITE_LONG_F(adr, res)
10251 POST_IO
10252RET(32)
10253}
10254
10255// MOVEL
10256OPCODE(0x21FB)
10257{
10258 u32 adr, res;
10259 u32 src, dst;
10260
10261 adr = GET_PC;
10262 DECODE_EXT_WORD
10263 PRE_IO
10264 READ_LONG_F(adr, res)
10265 flag_C = 0;
10266 flag_V = 0;
10267 flag_NotZ = res;
10268 flag_N = res >> 24;
10269 FETCH_SWORD(adr);
10270 WRITE_LONG_F(adr, res)
10271 POST_IO
10272RET(30)
10273}
10274
10275// MOVEL
10276OPCODE(0x23FB)
10277{
10278 u32 adr, res;
10279 u32 src, dst;
10280
10281 adr = GET_PC;
10282 DECODE_EXT_WORD
10283 PRE_IO
10284 READ_LONG_F(adr, res)
10285 flag_C = 0;
10286 flag_V = 0;
10287 flag_NotZ = res;
10288 flag_N = res >> 24;
10289 FETCH_LONG(adr);
10290 WRITE_LONG_F(adr, res)
10291 POST_IO
10292RET(34)
10293}
10294
10295// MOVEL
10296OPCODE(0x2EFB)
10297{
10298 u32 adr, res;
10299 u32 src, dst;
10300
10301 adr = GET_PC;
10302 DECODE_EXT_WORD
10303 PRE_IO
10304 READ_LONG_F(adr, res)
10305 flag_C = 0;
10306 flag_V = 0;
10307 flag_NotZ = res;
10308 flag_N = res >> 24;
10309 adr = AREG(7);
10310 AREG(7) += 4;
10311 WRITE_LONG_F(adr, res)
10312 POST_IO
10313RET(26)
10314}
10315
10316// MOVEL
10317OPCODE(0x2F3B)
10318{
10319 u32 adr, res;
10320 u32 src, dst;
10321
10322 adr = GET_PC;
10323 DECODE_EXT_WORD
10324 PRE_IO
10325 READ_LONG_F(adr, res)
10326 flag_C = 0;
10327 flag_V = 0;
10328 flag_NotZ = res;
10329 flag_N = res >> 24;
10330 adr = AREG(7) - 4;
10331 AREG(7) = adr;
10332 WRITE_LONG_DEC_F(adr, res)
10333 POST_IO
10334RET(26)
10335}
10336
10337// MOVEL
10338OPCODE(0x203C)
10339{
10340 u32 adr, res;
10341 u32 src, dst;
10342
10343 FETCH_LONG(res);
10344 flag_C = 0;
10345 flag_V = 0;
10346 flag_NotZ = res;
10347 flag_N = res >> 24;
10348 DREGu32((Opcode >> 9) & 7) = res;
10349RET(12)
10350}
10351
10352// MOVEL
10353OPCODE(0x20BC)
10354{
10355 u32 adr, res;
10356 u32 src, dst;
10357
10358 FETCH_LONG(res);
10359 flag_C = 0;
10360 flag_V = 0;
10361 flag_NotZ = res;
10362 flag_N = res >> 24;
10363 adr = AREG((Opcode >> 9) & 7);
10364 PRE_IO
10365 WRITE_LONG_F(adr, res)
10366 POST_IO
10367RET(20)
10368}
10369
10370// MOVEL
10371OPCODE(0x20FC)
10372{
10373 u32 adr, res;
10374 u32 src, dst;
10375
10376 FETCH_LONG(res);
10377 flag_C = 0;
10378 flag_V = 0;
10379 flag_NotZ = res;
10380 flag_N = res >> 24;
10381 adr = AREG((Opcode >> 9) & 7);
10382 AREG((Opcode >> 9) & 7) += 4;
10383 PRE_IO
10384 WRITE_LONG_F(adr, res)
10385 POST_IO
10386RET(20)
10387}
10388
10389// MOVEL
10390OPCODE(0x213C)
10391{
10392 u32 adr, res;
10393 u32 src, dst;
10394
10395 FETCH_LONG(res);
10396 flag_C = 0;
10397 flag_V = 0;
10398 flag_NotZ = res;
10399 flag_N = res >> 24;
10400 adr = AREG((Opcode >> 9) & 7) - 4;
10401 AREG((Opcode >> 9) & 7) = adr;
10402 PRE_IO
10403 WRITE_LONG_DEC_F(adr, res)
10404 POST_IO
10405RET(20)
10406}
10407
10408// MOVEL
10409OPCODE(0x217C)
10410{
10411 u32 adr, res;
10412 u32 src, dst;
10413
10414 FETCH_LONG(res);
10415 flag_C = 0;
10416 flag_V = 0;
10417 flag_NotZ = res;
10418 flag_N = res >> 24;
10419 FETCH_SWORD(adr);
10420 adr += AREG((Opcode >> 9) & 7);
10421 PRE_IO
10422 WRITE_LONG_F(adr, res)
10423 POST_IO
10424RET(24)
10425}
10426
10427// MOVEL
10428OPCODE(0x21BC)
10429{
10430 u32 adr, res;
10431 u32 src, dst;
10432
10433 FETCH_LONG(res);
10434 flag_C = 0;
10435 flag_V = 0;
10436 flag_NotZ = res;
10437 flag_N = res >> 24;
10438 adr = AREG((Opcode >> 9) & 7);
10439 DECODE_EXT_WORD
10440 PRE_IO
10441 WRITE_LONG_F(adr, res)
10442 POST_IO
10443RET(26)
10444}
10445
10446// MOVEL
10447OPCODE(0x21FC)
10448{
10449 u32 adr, res;
10450 u32 src, dst;
10451
10452 FETCH_LONG(res);
10453 flag_C = 0;
10454 flag_V = 0;
10455 flag_NotZ = res;
10456 flag_N = res >> 24;
10457 FETCH_SWORD(adr);
10458 PRE_IO
10459 WRITE_LONG_F(adr, res)
10460 POST_IO
10461RET(24)
10462}
10463
10464// MOVEL
10465OPCODE(0x23FC)
10466{
10467 u32 adr, res;
10468 u32 src, dst;
10469
10470 FETCH_LONG(res);
10471 flag_C = 0;
10472 flag_V = 0;
10473 flag_NotZ = res;
10474 flag_N = res >> 24;
10475 FETCH_LONG(adr);
10476 PRE_IO
10477 WRITE_LONG_F(adr, res)
10478 POST_IO
10479RET(28)
10480}
10481
10482// MOVEL
10483OPCODE(0x2EFC)
10484{
10485 u32 adr, res;
10486 u32 src, dst;
10487
10488 FETCH_LONG(res);
10489 flag_C = 0;
10490 flag_V = 0;
10491 flag_NotZ = res;
10492 flag_N = res >> 24;
10493 adr = AREG(7);
10494 AREG(7) += 4;
10495 PRE_IO
10496 WRITE_LONG_F(adr, res)
10497 POST_IO
10498RET(20)
10499}
10500
10501// MOVEL
10502OPCODE(0x2F3C)
10503{
10504 u32 adr, res;
10505 u32 src, dst;
10506
10507 FETCH_LONG(res);
10508 flag_C = 0;
10509 flag_V = 0;
10510 flag_NotZ = res;
10511 flag_N = res >> 24;
10512 adr = AREG(7) - 4;
10513 AREG(7) = adr;
10514 PRE_IO
10515 WRITE_LONG_DEC_F(adr, res)
10516 POST_IO
10517RET(20)
10518}
10519
10520// MOVEL
10521OPCODE(0x201F)
10522{
10523 u32 adr, res;
10524 u32 src, dst;
10525
10526 adr = AREG(7);
10527 AREG(7) += 4;
10528 PRE_IO
10529 READ_LONG_F(adr, res)
10530 flag_C = 0;
10531 flag_V = 0;
10532 flag_NotZ = res;
10533 flag_N = res >> 24;
10534 DREGu32((Opcode >> 9) & 7) = res;
10535 POST_IO
10536RET(12)
10537}
10538
10539// MOVEL
10540OPCODE(0x209F)
10541{
10542 u32 adr, res;
10543 u32 src, dst;
10544
10545 adr = AREG(7);
10546 AREG(7) += 4;
10547 PRE_IO
10548 READ_LONG_F(adr, res)
10549 flag_C = 0;
10550 flag_V = 0;
10551 flag_NotZ = res;
10552 flag_N = res >> 24;
10553 adr = AREG((Opcode >> 9) & 7);
10554 WRITE_LONG_F(adr, res)
10555 POST_IO
10556RET(20)
10557}
10558
10559// MOVEL
10560OPCODE(0x20DF)
10561{
10562 u32 adr, res;
10563 u32 src, dst;
10564
10565 adr = AREG(7);
10566 AREG(7) += 4;
10567 PRE_IO
10568 READ_LONG_F(adr, res)
10569 flag_C = 0;
10570 flag_V = 0;
10571 flag_NotZ = res;
10572 flag_N = res >> 24;
10573 adr = AREG((Opcode >> 9) & 7);
10574 AREG((Opcode >> 9) & 7) += 4;
10575 WRITE_LONG_F(adr, res)
10576 POST_IO
10577RET(20)
10578}
10579
10580// MOVEL
10581OPCODE(0x211F)
10582{
10583 u32 adr, res;
10584 u32 src, dst;
10585
10586 adr = AREG(7);
10587 AREG(7) += 4;
10588 PRE_IO
10589 READ_LONG_F(adr, res)
10590 flag_C = 0;
10591 flag_V = 0;
10592 flag_NotZ = res;
10593 flag_N = res >> 24;
10594 adr = AREG((Opcode >> 9) & 7) - 4;
10595 AREG((Opcode >> 9) & 7) = adr;
10596 WRITE_LONG_DEC_F(adr, res)
10597 POST_IO
10598RET(20)
10599}
10600
10601// MOVEL
10602OPCODE(0x215F)
10603{
10604 u32 adr, res;
10605 u32 src, dst;
10606
10607 adr = AREG(7);
10608 AREG(7) += 4;
10609 PRE_IO
10610 READ_LONG_F(adr, res)
10611 flag_C = 0;
10612 flag_V = 0;
10613 flag_NotZ = res;
10614 flag_N = res >> 24;
10615 FETCH_SWORD(adr);
10616 adr += AREG((Opcode >> 9) & 7);
10617 WRITE_LONG_F(adr, res)
10618 POST_IO
10619RET(24)
10620}
10621
10622// MOVEL
10623OPCODE(0x219F)
10624{
10625 u32 adr, res;
10626 u32 src, dst;
10627
10628 adr = AREG(7);
10629 AREG(7) += 4;
10630 PRE_IO
10631 READ_LONG_F(adr, res)
10632 flag_C = 0;
10633 flag_V = 0;
10634 flag_NotZ = res;
10635 flag_N = res >> 24;
10636 adr = AREG((Opcode >> 9) & 7);
10637 DECODE_EXT_WORD
10638 WRITE_LONG_F(adr, res)
10639 POST_IO
10640RET(26)
10641}
10642
10643// MOVEL
10644OPCODE(0x21DF)
10645{
10646 u32 adr, res;
10647 u32 src, dst;
10648
10649 adr = AREG(7);
10650 AREG(7) += 4;
10651 PRE_IO
10652 READ_LONG_F(adr, res)
10653 flag_C = 0;
10654 flag_V = 0;
10655 flag_NotZ = res;
10656 flag_N = res >> 24;
10657 FETCH_SWORD(adr);
10658 WRITE_LONG_F(adr, res)
10659 POST_IO
10660RET(24)
10661}
10662
10663// MOVEL
10664OPCODE(0x23DF)
10665{
10666 u32 adr, res;
10667 u32 src, dst;
10668
10669 adr = AREG(7);
10670 AREG(7) += 4;
10671 PRE_IO
10672 READ_LONG_F(adr, res)
10673 flag_C = 0;
10674 flag_V = 0;
10675 flag_NotZ = res;
10676 flag_N = res >> 24;
10677 FETCH_LONG(adr);
10678 WRITE_LONG_F(adr, res)
10679 POST_IO
10680RET(28)
10681}
10682
10683// MOVEL
10684OPCODE(0x2EDF)
10685{
10686 u32 adr, res;
10687 u32 src, dst;
10688
10689 adr = AREG(7);
10690 AREG(7) += 4;
10691 PRE_IO
10692 READ_LONG_F(adr, res)
10693 flag_C = 0;
10694 flag_V = 0;
10695 flag_NotZ = res;
10696 flag_N = res >> 24;
10697 adr = AREG(7);
10698 AREG(7) += 4;
10699 WRITE_LONG_F(adr, res)
10700 POST_IO
10701RET(20)
10702}
10703
10704// MOVEL
10705OPCODE(0x2F1F)
10706{
10707 u32 adr, res;
10708 u32 src, dst;
10709
10710 adr = AREG(7);
10711 AREG(7) += 4;
10712 PRE_IO
10713 READ_LONG_F(adr, res)
10714 flag_C = 0;
10715 flag_V = 0;
10716 flag_NotZ = res;
10717 flag_N = res >> 24;
10718 adr = AREG(7) - 4;
10719 AREG(7) = adr;
10720 WRITE_LONG_DEC_F(adr, res)
10721 POST_IO
10722RET(20)
10723}
10724
10725// MOVEL
10726OPCODE(0x2027)
10727{
10728 u32 adr, res;
10729 u32 src, dst;
10730
10731 adr = AREG(7) - 4;
10732 AREG(7) = adr;
10733 PRE_IO
10734 READ_LONG_F(adr, res)
10735 flag_C = 0;
10736 flag_V = 0;
10737 flag_NotZ = res;
10738 flag_N = res >> 24;
10739 DREGu32((Opcode >> 9) & 7) = res;
10740 POST_IO
10741RET(14)
10742}
10743
10744// MOVEL
10745OPCODE(0x20A7)
10746{
10747 u32 adr, res;
10748 u32 src, dst;
10749
10750 adr = AREG(7) - 4;
10751 AREG(7) = adr;
10752 PRE_IO
10753 READ_LONG_F(adr, res)
10754 flag_C = 0;
10755 flag_V = 0;
10756 flag_NotZ = res;
10757 flag_N = res >> 24;
10758 adr = AREG((Opcode >> 9) & 7);
10759 WRITE_LONG_F(adr, res)
10760 POST_IO
10761RET(22)
10762}
10763
10764// MOVEL
10765OPCODE(0x20E7)
10766{
10767 u32 adr, res;
10768 u32 src, dst;
10769
10770 adr = AREG(7) - 4;
10771 AREG(7) = adr;
10772 PRE_IO
10773 READ_LONG_F(adr, res)
10774 flag_C = 0;
10775 flag_V = 0;
10776 flag_NotZ = res;
10777 flag_N = res >> 24;
10778 adr = AREG((Opcode >> 9) & 7);
10779 AREG((Opcode >> 9) & 7) += 4;
10780 WRITE_LONG_F(adr, res)
10781 POST_IO
10782RET(22)
10783}
10784
10785// MOVEL
10786OPCODE(0x2127)
10787{
10788 u32 adr, res;
10789 u32 src, dst;
10790
10791 adr = AREG(7) - 4;
10792 AREG(7) = adr;
10793 PRE_IO
10794 READ_LONG_F(adr, res)
10795 flag_C = 0;
10796 flag_V = 0;
10797 flag_NotZ = res;
10798 flag_N = res >> 24;
10799 adr = AREG((Opcode >> 9) & 7) - 4;
10800 AREG((Opcode >> 9) & 7) = adr;
10801 WRITE_LONG_DEC_F(adr, res)
10802 POST_IO
10803RET(22)
10804}
10805
10806// MOVEL
10807OPCODE(0x2167)
10808{
10809 u32 adr, res;
10810 u32 src, dst;
10811
10812 adr = AREG(7) - 4;
10813 AREG(7) = adr;
10814 PRE_IO
10815 READ_LONG_F(adr, res)
10816 flag_C = 0;
10817 flag_V = 0;
10818 flag_NotZ = res;
10819 flag_N = res >> 24;
10820 FETCH_SWORD(adr);
10821 adr += AREG((Opcode >> 9) & 7);
10822 WRITE_LONG_F(adr, res)
10823 POST_IO
10824RET(26)
10825}
10826
10827// MOVEL
10828OPCODE(0x21A7)
10829{
10830 u32 adr, res;
10831 u32 src, dst;
10832
10833 adr = AREG(7) - 4;
10834 AREG(7) = adr;
10835 PRE_IO
10836 READ_LONG_F(adr, res)
10837 flag_C = 0;
10838 flag_V = 0;
10839 flag_NotZ = res;
10840 flag_N = res >> 24;
10841 adr = AREG((Opcode >> 9) & 7);
10842 DECODE_EXT_WORD
10843 WRITE_LONG_F(adr, res)
10844 POST_IO
10845RET(28)
10846}
10847
10848// MOVEL
10849OPCODE(0x21E7)
10850{
10851 u32 adr, res;
10852 u32 src, dst;
10853
10854 adr = AREG(7) - 4;
10855 AREG(7) = adr;
10856 PRE_IO
10857 READ_LONG_F(adr, res)
10858 flag_C = 0;
10859 flag_V = 0;
10860 flag_NotZ = res;
10861 flag_N = res >> 24;
10862 FETCH_SWORD(adr);
10863 WRITE_LONG_F(adr, res)
10864 POST_IO
10865RET(26)
10866}
10867
10868// MOVEL
10869OPCODE(0x23E7)
10870{
10871 u32 adr, res;
10872 u32 src, dst;
10873
10874 adr = AREG(7) - 4;
10875 AREG(7) = adr;
10876 PRE_IO
10877 READ_LONG_F(adr, res)
10878 flag_C = 0;
10879 flag_V = 0;
10880 flag_NotZ = res;
10881 flag_N = res >> 24;
10882 FETCH_LONG(adr);
10883 WRITE_LONG_F(adr, res)
10884 POST_IO
10885RET(30)
10886}
10887
10888// MOVEL
10889OPCODE(0x2EE7)
10890{
10891 u32 adr, res;
10892 u32 src, dst;
10893
10894 adr = AREG(7) - 4;
10895 AREG(7) = adr;
10896 PRE_IO
10897 READ_LONG_F(adr, res)
10898 flag_C = 0;
10899 flag_V = 0;
10900 flag_NotZ = res;
10901 flag_N = res >> 24;
10902 adr = AREG(7);
10903 AREG(7) += 4;
10904 WRITE_LONG_F(adr, res)
10905 POST_IO
10906RET(22)
10907}
10908
10909// MOVEL
10910OPCODE(0x2F27)
10911{
10912 u32 adr, res;
10913 u32 src, dst;
10914
10915 adr = AREG(7) - 4;
10916 AREG(7) = adr;
10917 PRE_IO
10918 READ_LONG_F(adr, res)
10919 flag_C = 0;
10920 flag_V = 0;
10921 flag_NotZ = res;
10922 flag_N = res >> 24;
10923 adr = AREG(7) - 4;
10924 AREG(7) = adr;
10925 WRITE_LONG_DEC_F(adr, res)
10926 POST_IO
10927RET(22)
10928}
10929
10930// MOVEAL
10931OPCODE(0x2040)
10932{
10933 u32 adr, res;
10934 u32 src, dst;
10935
10936 res = (s32)DREGs32((Opcode >> 0) & 7);
10937 AREG((Opcode >> 9) & 7) = res;
10938RET(4)
10939}
10940
10941// MOVEAL
10942OPCODE(0x2048)
10943{
10944 u32 adr, res;
10945 u32 src, dst;
10946
10947 res = (s32)AREGs32((Opcode >> 0) & 7);
10948 AREG((Opcode >> 9) & 7) = res;
10949RET(4)
10950}
10951
10952// MOVEAL
10953OPCODE(0x2050)
10954{
10955 u32 adr, res;
10956 u32 src, dst;
10957
10958 adr = AREG((Opcode >> 0) & 7);
10959 PRE_IO
10960 READSX_LONG_F(adr, res)
10961 AREG((Opcode >> 9) & 7) = res;
10962 POST_IO
10963RET(12)
10964}
10965
10966// MOVEAL
10967OPCODE(0x2058)
10968{
10969 u32 adr, res;
10970 u32 src, dst;
10971
10972 adr = AREG((Opcode >> 0) & 7);
10973 AREG((Opcode >> 0) & 7) += 4;
10974 PRE_IO
10975 READSX_LONG_F(adr, res)
10976 AREG((Opcode >> 9) & 7) = res;
10977 POST_IO
10978RET(12)
10979}
10980
10981// MOVEAL
10982OPCODE(0x2060)
10983{
10984 u32 adr, res;
10985 u32 src, dst;
10986
10987 adr = AREG((Opcode >> 0) & 7) - 4;
10988 AREG((Opcode >> 0) & 7) = adr;
10989 PRE_IO
10990 READSX_LONG_F(adr, res)
10991 AREG((Opcode >> 9) & 7) = res;
10992 POST_IO
10993RET(14)
10994}
10995
10996// MOVEAL
10997OPCODE(0x2068)
10998{
10999 u32 adr, res;
11000 u32 src, dst;
11001
11002 FETCH_SWORD(adr);
11003 adr += AREG((Opcode >> 0) & 7);
11004 PRE_IO
11005 READSX_LONG_F(adr, res)
11006 AREG((Opcode >> 9) & 7) = res;
11007 POST_IO
11008RET(16)
11009}
11010
11011// MOVEAL
11012OPCODE(0x2070)
11013{
11014 u32 adr, res;
11015 u32 src, dst;
11016
11017 adr = AREG((Opcode >> 0) & 7);
11018 DECODE_EXT_WORD
11019 PRE_IO
11020 READSX_LONG_F(adr, res)
11021 AREG((Opcode >> 9) & 7) = res;
11022 POST_IO
11023RET(18)
11024}
11025
11026// MOVEAL
11027OPCODE(0x2078)
11028{
11029 u32 adr, res;
11030 u32 src, dst;
11031
11032 FETCH_SWORD(adr);
11033 PRE_IO
11034 READSX_LONG_F(adr, res)
11035 AREG((Opcode >> 9) & 7) = res;
11036 POST_IO
11037RET(16)
11038}
11039
11040// MOVEAL
11041OPCODE(0x2079)
11042{
11043 u32 adr, res;
11044 u32 src, dst;
11045
11046 FETCH_LONG(adr);
11047 PRE_IO
11048 READSX_LONG_F(adr, res)
11049 AREG((Opcode >> 9) & 7) = res;
11050 POST_IO
11051RET(20)
11052}
11053
11054// MOVEAL
11055OPCODE(0x207A)
11056{
11057 u32 adr, res;
11058 u32 src, dst;
11059
11060 adr = GET_SWORD + GET_PC;
11061 PC++;
11062 PRE_IO
11063 READSX_LONG_F(adr, res)
11064 AREG((Opcode >> 9) & 7) = res;
11065 POST_IO
11066RET(16)
11067}
11068
11069// MOVEAL
11070OPCODE(0x207B)
11071{
11072 u32 adr, res;
11073 u32 src, dst;
11074
11075 adr = GET_PC;
11076 DECODE_EXT_WORD
11077 PRE_IO
11078 READSX_LONG_F(adr, res)
11079 AREG((Opcode >> 9) & 7) = res;
11080 POST_IO
11081RET(18)
11082}
11083
11084// MOVEAL
11085OPCODE(0x207C)
11086{
11087 u32 adr, res;
11088 u32 src, dst;
11089
11090 FETCH_LONG(res);
11091 AREG((Opcode >> 9) & 7) = res;
11092RET(12)
11093}
11094
11095// MOVEAL
11096OPCODE(0x205F)
11097{
11098 u32 adr, res;
11099 u32 src, dst;
11100
11101 adr = AREG(7);
11102 AREG(7) += 4;
11103 PRE_IO
11104 READSX_LONG_F(adr, res)
11105 AREG((Opcode >> 9) & 7) = res;
11106 POST_IO
11107RET(12)
11108}
11109
11110// MOVEAL
11111OPCODE(0x2067)
11112{
11113 u32 adr, res;
11114 u32 src, dst;
11115
11116 adr = AREG(7) - 4;
11117 AREG(7) = adr;
11118 PRE_IO
11119 READSX_LONG_F(adr, res)
11120 AREG((Opcode >> 9) & 7) = res;
11121 POST_IO
11122RET(14)
11123}
11124
11125// MOVEW
11126OPCODE(0x3000)
11127{
11128 u32 adr, res;
11129 u32 src, dst;
11130
11131 res = DREGu16((Opcode >> 0) & 7);
11132 flag_C = 0;
11133 flag_V = 0;
11134 flag_NotZ = res;
11135 flag_N = res >> 8;
11136 DREGu16((Opcode >> 9) & 7) = res;
11137RET(4)
11138}
11139
11140// MOVEW
11141OPCODE(0x3080)
11142{
11143 u32 adr, res;
11144 u32 src, dst;
11145
11146 res = DREGu16((Opcode >> 0) & 7);
11147 flag_C = 0;
11148 flag_V = 0;
11149 flag_NotZ = res;
11150 flag_N = res >> 8;
11151 adr = AREG((Opcode >> 9) & 7);
11152 PRE_IO
11153 WRITE_WORD_F(adr, res)
11154 POST_IO
11155RET(8)
11156}
11157
11158// MOVEW
11159OPCODE(0x30C0)
11160{
11161 u32 adr, res;
11162 u32 src, dst;
11163
11164 res = DREGu16((Opcode >> 0) & 7);
11165 flag_C = 0;
11166 flag_V = 0;
11167 flag_NotZ = res;
11168 flag_N = res >> 8;
11169 adr = AREG((Opcode >> 9) & 7);
11170 AREG((Opcode >> 9) & 7) += 2;
11171 PRE_IO
11172 WRITE_WORD_F(adr, res)
11173 POST_IO
11174RET(8)
11175}
11176
11177// MOVEW
11178OPCODE(0x3100)
11179{
11180 u32 adr, res;
11181 u32 src, dst;
11182
11183 res = DREGu16((Opcode >> 0) & 7);
11184 flag_C = 0;
11185 flag_V = 0;
11186 flag_NotZ = res;
11187 flag_N = res >> 8;
11188 adr = AREG((Opcode >> 9) & 7) - 2;
11189 AREG((Opcode >> 9) & 7) = adr;
11190 PRE_IO
11191 WRITE_WORD_F(adr, res)
11192 POST_IO
11193RET(8)
11194}
11195
11196// MOVEW
11197OPCODE(0x3140)
11198{
11199 u32 adr, res;
11200 u32 src, dst;
11201
11202 res = DREGu16((Opcode >> 0) & 7);
11203 flag_C = 0;
11204 flag_V = 0;
11205 flag_NotZ = res;
11206 flag_N = res >> 8;
11207 FETCH_SWORD(adr);
11208 adr += AREG((Opcode >> 9) & 7);
11209 PRE_IO
11210 WRITE_WORD_F(adr, res)
11211 POST_IO
11212RET(12)
11213}
11214
11215// MOVEW
11216OPCODE(0x3180)
11217{
11218 u32 adr, res;
11219 u32 src, dst;
11220
11221 res = DREGu16((Opcode >> 0) & 7);
11222 flag_C = 0;
11223 flag_V = 0;
11224 flag_NotZ = res;
11225 flag_N = res >> 8;
11226 adr = AREG((Opcode >> 9) & 7);
11227 DECODE_EXT_WORD
11228 PRE_IO
11229 WRITE_WORD_F(adr, res)
11230 POST_IO
11231RET(14)
11232}
11233
11234// MOVEW
11235OPCODE(0x31C0)
11236{
11237 u32 adr, res;
11238 u32 src, dst;
11239
11240 res = DREGu16((Opcode >> 0) & 7);
11241 flag_C = 0;
11242 flag_V = 0;
11243 flag_NotZ = res;
11244 flag_N = res >> 8;
11245 FETCH_SWORD(adr);
11246 PRE_IO
11247 WRITE_WORD_F(adr, res)
11248 POST_IO
11249RET(12)
11250}
11251
11252// MOVEW
11253OPCODE(0x33C0)
11254{
11255 u32 adr, res;
11256 u32 src, dst;
11257
11258 res = DREGu16((Opcode >> 0) & 7);
11259 flag_C = 0;
11260 flag_V = 0;
11261 flag_NotZ = res;
11262 flag_N = res >> 8;
11263 FETCH_LONG(adr);
11264 PRE_IO
11265 WRITE_WORD_F(adr, res)
11266 POST_IO
11267RET(16)
11268}
11269
11270// MOVEW
11271OPCODE(0x3EC0)
11272{
11273 u32 adr, res;
11274 u32 src, dst;
11275
11276 res = DREGu16((Opcode >> 0) & 7);
11277 flag_C = 0;
11278 flag_V = 0;
11279 flag_NotZ = res;
11280 flag_N = res >> 8;
11281 adr = AREG(7);
11282 AREG(7) += 2;
11283 PRE_IO
11284 WRITE_WORD_F(adr, res)
11285 POST_IO
11286RET(8)
11287}
11288
11289// MOVEW
11290OPCODE(0x3F00)
11291{
11292 u32 adr, res;
11293 u32 src, dst;
11294
11295 res = DREGu16((Opcode >> 0) & 7);
11296 flag_C = 0;
11297 flag_V = 0;
11298 flag_NotZ = res;
11299 flag_N = res >> 8;
11300 adr = AREG(7) - 2;
11301 AREG(7) = adr;
11302 PRE_IO
11303 WRITE_WORD_F(adr, res)
11304 POST_IO
11305RET(8)
11306}
11307
11308// MOVEW
11309OPCODE(0x3008)
11310{
11311 u32 adr, res;
11312 u32 src, dst;
11313
11314 res = AREGu16((Opcode >> 0) & 7);
11315 flag_C = 0;
11316 flag_V = 0;
11317 flag_NotZ = res;
11318 flag_N = res >> 8;
11319 DREGu16((Opcode >> 9) & 7) = res;
11320RET(4)
11321}
11322
11323// MOVEW
11324OPCODE(0x3088)
11325{
11326 u32 adr, res;
11327 u32 src, dst;
11328
11329 res = AREGu16((Opcode >> 0) & 7);
11330 flag_C = 0;
11331 flag_V = 0;
11332 flag_NotZ = res;
11333 flag_N = res >> 8;
11334 adr = AREG((Opcode >> 9) & 7);
11335 PRE_IO
11336 WRITE_WORD_F(adr, res)
11337 POST_IO
11338RET(8)
11339}
11340
11341// MOVEW
11342OPCODE(0x30C8)
11343{
11344 u32 adr, res;
11345 u32 src, dst;
11346
11347 res = AREGu16((Opcode >> 0) & 7);
11348 flag_C = 0;
11349 flag_V = 0;
11350 flag_NotZ = res;
11351 flag_N = res >> 8;
11352 adr = AREG((Opcode >> 9) & 7);
11353 AREG((Opcode >> 9) & 7) += 2;
11354 PRE_IO
11355 WRITE_WORD_F(adr, res)
11356 POST_IO
11357RET(8)
11358}
11359
11360// MOVEW
11361OPCODE(0x3108)
11362{
11363 u32 adr, res;
11364 u32 src, dst;
11365
11366 res = AREGu16((Opcode >> 0) & 7);
11367 flag_C = 0;
11368 flag_V = 0;
11369 flag_NotZ = res;
11370 flag_N = res >> 8;
11371 adr = AREG((Opcode >> 9) & 7) - 2;
11372 AREG((Opcode >> 9) & 7) = adr;
11373 PRE_IO
11374 WRITE_WORD_F(adr, res)
11375 POST_IO
11376RET(8)
11377}
11378
11379// MOVEW
11380OPCODE(0x3148)
11381{
11382 u32 adr, res;
11383 u32 src, dst;
11384
11385 res = AREGu16((Opcode >> 0) & 7);
11386 flag_C = 0;
11387 flag_V = 0;
11388 flag_NotZ = res;
11389 flag_N = res >> 8;
11390 FETCH_SWORD(adr);
11391 adr += AREG((Opcode >> 9) & 7);
11392 PRE_IO
11393 WRITE_WORD_F(adr, res)
11394 POST_IO
11395RET(12)
11396}
11397
11398// MOVEW
11399OPCODE(0x3188)
11400{
11401 u32 adr, res;
11402 u32 src, dst;
11403
11404 res = AREGu16((Opcode >> 0) & 7);
11405 flag_C = 0;
11406 flag_V = 0;
11407 flag_NotZ = res;
11408 flag_N = res >> 8;
11409 adr = AREG((Opcode >> 9) & 7);
11410 DECODE_EXT_WORD
11411 PRE_IO
11412 WRITE_WORD_F(adr, res)
11413 POST_IO
11414RET(14)
11415}
11416
11417// MOVEW
11418OPCODE(0x31C8)
11419{
11420 u32 adr, res;
11421 u32 src, dst;
11422
11423 res = AREGu16((Opcode >> 0) & 7);
11424 flag_C = 0;
11425 flag_V = 0;
11426 flag_NotZ = res;
11427 flag_N = res >> 8;
11428 FETCH_SWORD(adr);
11429 PRE_IO
11430 WRITE_WORD_F(adr, res)
11431 POST_IO
11432RET(12)
11433}
11434
11435// MOVEW
11436OPCODE(0x33C8)
11437{
11438 u32 adr, res;
11439 u32 src, dst;
11440
11441 res = AREGu16((Opcode >> 0) & 7);
11442 flag_C = 0;
11443 flag_V = 0;
11444 flag_NotZ = res;
11445 flag_N = res >> 8;
11446 FETCH_LONG(adr);
11447 PRE_IO
11448 WRITE_WORD_F(adr, res)
11449 POST_IO
11450RET(16)
11451}
11452
11453// MOVEW
11454OPCODE(0x3EC8)
11455{
11456 u32 adr, res;
11457 u32 src, dst;
11458
11459 res = AREGu16((Opcode >> 0) & 7);
11460 flag_C = 0;
11461 flag_V = 0;
11462 flag_NotZ = res;
11463 flag_N = res >> 8;
11464 adr = AREG(7);
11465 AREG(7) += 2;
11466 PRE_IO
11467 WRITE_WORD_F(adr, res)
11468 POST_IO
11469RET(8)
11470}
11471
11472// MOVEW
11473OPCODE(0x3F08)
11474{
11475 u32 adr, res;
11476 u32 src, dst;
11477
11478 res = AREGu16((Opcode >> 0) & 7);
11479 flag_C = 0;
11480 flag_V = 0;
11481 flag_NotZ = res;
11482 flag_N = res >> 8;
11483 adr = AREG(7) - 2;
11484 AREG(7) = adr;
11485 PRE_IO
11486 WRITE_WORD_F(adr, res)
11487 POST_IO
11488RET(8)
11489}
11490
11491// MOVEW
11492OPCODE(0x3010)
11493{
11494 u32 adr, res;
11495 u32 src, dst;
11496
11497 adr = AREG((Opcode >> 0) & 7);
11498 PRE_IO
11499 READ_WORD_F(adr, res)
11500 flag_C = 0;
11501 flag_V = 0;
11502 flag_NotZ = res;
11503 flag_N = res >> 8;
11504 DREGu16((Opcode >> 9) & 7) = res;
11505 POST_IO
11506RET(8)
11507}
11508
11509// MOVEW
11510OPCODE(0x3090)
11511{
11512 u32 adr, res;
11513 u32 src, dst;
11514
11515 adr = AREG((Opcode >> 0) & 7);
11516 PRE_IO
11517 READ_WORD_F(adr, res)
11518 flag_C = 0;
11519 flag_V = 0;
11520 flag_NotZ = res;
11521 flag_N = res >> 8;
11522 adr = AREG((Opcode >> 9) & 7);
11523 WRITE_WORD_F(adr, res)
11524 POST_IO
11525RET(12)
11526}
11527
11528// MOVEW
11529OPCODE(0x30D0)
11530{
11531 u32 adr, res;
11532 u32 src, dst;
11533
11534 adr = AREG((Opcode >> 0) & 7);
11535 PRE_IO
11536 READ_WORD_F(adr, res)
11537 flag_C = 0;
11538 flag_V = 0;
11539 flag_NotZ = res;
11540 flag_N = res >> 8;
11541 adr = AREG((Opcode >> 9) & 7);
11542 AREG((Opcode >> 9) & 7) += 2;
11543 WRITE_WORD_F(adr, res)
11544 POST_IO
11545RET(12)
11546}
11547
11548// MOVEW
11549OPCODE(0x3110)
11550{
11551 u32 adr, res;
11552 u32 src, dst;
11553
11554 adr = AREG((Opcode >> 0) & 7);
11555 PRE_IO
11556 READ_WORD_F(adr, res)
11557 flag_C = 0;
11558 flag_V = 0;
11559 flag_NotZ = res;
11560 flag_N = res >> 8;
11561 adr = AREG((Opcode >> 9) & 7) - 2;
11562 AREG((Opcode >> 9) & 7) = adr;
11563 WRITE_WORD_F(adr, res)
11564 POST_IO
11565RET(12)
11566}
11567
11568// MOVEW
11569OPCODE(0x3150)
11570{
11571 u32 adr, res;
11572 u32 src, dst;
11573
11574 adr = AREG((Opcode >> 0) & 7);
11575 PRE_IO
11576 READ_WORD_F(adr, res)
11577 flag_C = 0;
11578 flag_V = 0;
11579 flag_NotZ = res;
11580 flag_N = res >> 8;
11581 FETCH_SWORD(adr);
11582 adr += AREG((Opcode >> 9) & 7);
11583 WRITE_WORD_F(adr, res)
11584 POST_IO
11585RET(16)
11586}
11587
11588// MOVEW
11589OPCODE(0x3190)
11590{
11591 u32 adr, res;
11592 u32 src, dst;
11593
11594 adr = AREG((Opcode >> 0) & 7);
11595 PRE_IO
11596 READ_WORD_F(adr, res)
11597 flag_C = 0;
11598 flag_V = 0;
11599 flag_NotZ = res;
11600 flag_N = res >> 8;
11601 adr = AREG((Opcode >> 9) & 7);
11602 DECODE_EXT_WORD
11603 WRITE_WORD_F(adr, res)
11604 POST_IO
11605RET(18)
11606}
11607
11608// MOVEW
11609OPCODE(0x31D0)
11610{
11611 u32 adr, res;
11612 u32 src, dst;
11613
11614 adr = AREG((Opcode >> 0) & 7);
11615 PRE_IO
11616 READ_WORD_F(adr, res)
11617 flag_C = 0;
11618 flag_V = 0;
11619 flag_NotZ = res;
11620 flag_N = res >> 8;
11621 FETCH_SWORD(adr);
11622 WRITE_WORD_F(adr, res)
11623 POST_IO
11624RET(16)
11625}
11626
11627// MOVEW
11628OPCODE(0x33D0)
11629{
11630 u32 adr, res;
11631 u32 src, dst;
11632
11633 adr = AREG((Opcode >> 0) & 7);
11634 PRE_IO
11635 READ_WORD_F(adr, res)
11636 flag_C = 0;
11637 flag_V = 0;
11638 flag_NotZ = res;
11639 flag_N = res >> 8;
11640 FETCH_LONG(adr);
11641 WRITE_WORD_F(adr, res)
11642 POST_IO
11643RET(20)
11644}
11645
11646// MOVEW
11647OPCODE(0x3ED0)
11648{
11649 u32 adr, res;
11650 u32 src, dst;
11651
11652 adr = AREG((Opcode >> 0) & 7);
11653 PRE_IO
11654 READ_WORD_F(adr, res)
11655 flag_C = 0;
11656 flag_V = 0;
11657 flag_NotZ = res;
11658 flag_N = res >> 8;
11659 adr = AREG(7);
11660 AREG(7) += 2;
11661 WRITE_WORD_F(adr, res)
11662 POST_IO
11663RET(12)
11664}
11665
11666// MOVEW
11667OPCODE(0x3F10)
11668{
11669 u32 adr, res;
11670 u32 src, dst;
11671
11672 adr = AREG((Opcode >> 0) & 7);
11673 PRE_IO
11674 READ_WORD_F(adr, res)
11675 flag_C = 0;
11676 flag_V = 0;
11677 flag_NotZ = res;
11678 flag_N = res >> 8;
11679 adr = AREG(7) - 2;
11680 AREG(7) = adr;
11681 WRITE_WORD_F(adr, res)
11682 POST_IO
11683RET(12)
11684}
11685
11686// MOVEW
11687OPCODE(0x3018)
11688{
11689 u32 adr, res;
11690 u32 src, dst;
11691
11692 adr = AREG((Opcode >> 0) & 7);
11693 AREG((Opcode >> 0) & 7) += 2;
11694 PRE_IO
11695 READ_WORD_F(adr, res)
11696 flag_C = 0;
11697 flag_V = 0;
11698 flag_NotZ = res;
11699 flag_N = res >> 8;
11700 DREGu16((Opcode >> 9) & 7) = res;
11701 POST_IO
11702RET(8)
11703}
11704
11705// MOVEW
11706OPCODE(0x3098)
11707{
11708 u32 adr, res;
11709 u32 src, dst;
11710
11711 adr = AREG((Opcode >> 0) & 7);
11712 AREG((Opcode >> 0) & 7) += 2;
11713 PRE_IO
11714 READ_WORD_F(adr, res)
11715 flag_C = 0;
11716 flag_V = 0;
11717 flag_NotZ = res;
11718 flag_N = res >> 8;
11719 adr = AREG((Opcode >> 9) & 7);
11720 WRITE_WORD_F(adr, res)
11721 POST_IO
11722RET(12)
11723}
11724
11725// MOVEW
11726OPCODE(0x30D8)
11727{
11728 u32 adr, res;
11729 u32 src, dst;
11730
11731 adr = AREG((Opcode >> 0) & 7);
11732 AREG((Opcode >> 0) & 7) += 2;
11733 PRE_IO
11734 READ_WORD_F(adr, res)
11735 flag_C = 0;
11736 flag_V = 0;
11737 flag_NotZ = res;
11738 flag_N = res >> 8;
11739 adr = AREG((Opcode >> 9) & 7);
11740 AREG((Opcode >> 9) & 7) += 2;
11741 WRITE_WORD_F(adr, res)
11742 POST_IO
11743RET(12)
11744}
11745
11746// MOVEW
11747OPCODE(0x3118)
11748{
11749 u32 adr, res;
11750 u32 src, dst;
11751
11752 adr = AREG((Opcode >> 0) & 7);
11753 AREG((Opcode >> 0) & 7) += 2;
11754 PRE_IO
11755 READ_WORD_F(adr, res)
11756 flag_C = 0;
11757 flag_V = 0;
11758 flag_NotZ = res;
11759 flag_N = res >> 8;
11760 adr = AREG((Opcode >> 9) & 7) - 2;
11761 AREG((Opcode >> 9) & 7) = adr;
11762 WRITE_WORD_F(adr, res)
11763 POST_IO
11764RET(12)
11765}
11766
11767// MOVEW
11768OPCODE(0x3158)
11769{
11770 u32 adr, res;
11771 u32 src, dst;
11772
11773 adr = AREG((Opcode >> 0) & 7);
11774 AREG((Opcode >> 0) & 7) += 2;
11775 PRE_IO
11776 READ_WORD_F(adr, res)
11777 flag_C = 0;
11778 flag_V = 0;
11779 flag_NotZ = res;
11780 flag_N = res >> 8;
11781 FETCH_SWORD(adr);
11782 adr += AREG((Opcode >> 9) & 7);
11783 WRITE_WORD_F(adr, res)
11784 POST_IO
11785RET(16)
11786}
11787
11788// MOVEW
11789OPCODE(0x3198)
11790{
11791 u32 adr, res;
11792 u32 src, dst;
11793
11794 adr = AREG((Opcode >> 0) & 7);
11795 AREG((Opcode >> 0) & 7) += 2;
11796 PRE_IO
11797 READ_WORD_F(adr, res)
11798 flag_C = 0;
11799 flag_V = 0;
11800 flag_NotZ = res;
11801 flag_N = res >> 8;
11802 adr = AREG((Opcode >> 9) & 7);
11803 DECODE_EXT_WORD
11804 WRITE_WORD_F(adr, res)
11805 POST_IO
11806RET(18)
11807}
11808
11809// MOVEW
11810OPCODE(0x31D8)
11811{
11812 u32 adr, res;
11813 u32 src, dst;
11814
11815 adr = AREG((Opcode >> 0) & 7);
11816 AREG((Opcode >> 0) & 7) += 2;
11817 PRE_IO
11818 READ_WORD_F(adr, res)
11819 flag_C = 0;
11820 flag_V = 0;
11821 flag_NotZ = res;
11822 flag_N = res >> 8;
11823 FETCH_SWORD(adr);
11824 WRITE_WORD_F(adr, res)
11825 POST_IO
11826RET(16)
11827}
11828
11829// MOVEW
11830OPCODE(0x33D8)
11831{
11832 u32 adr, res;
11833 u32 src, dst;
11834
11835 adr = AREG((Opcode >> 0) & 7);
11836 AREG((Opcode >> 0) & 7) += 2;
11837 PRE_IO
11838 READ_WORD_F(adr, res)
11839 flag_C = 0;
11840 flag_V = 0;
11841 flag_NotZ = res;
11842 flag_N = res >> 8;
11843 FETCH_LONG(adr);
11844 WRITE_WORD_F(adr, res)
11845 POST_IO
11846RET(20)
11847}
11848
11849// MOVEW
11850OPCODE(0x3ED8)
11851{
11852 u32 adr, res;
11853 u32 src, dst;
11854
11855 adr = AREG((Opcode >> 0) & 7);
11856 AREG((Opcode >> 0) & 7) += 2;
11857 PRE_IO
11858 READ_WORD_F(adr, res)
11859 flag_C = 0;
11860 flag_V = 0;
11861 flag_NotZ = res;
11862 flag_N = res >> 8;
11863 adr = AREG(7);
11864 AREG(7) += 2;
11865 WRITE_WORD_F(adr, res)
11866 POST_IO
11867RET(12)
11868}
11869
11870// MOVEW
11871OPCODE(0x3F18)
11872{
11873 u32 adr, res;
11874 u32 src, dst;
11875
11876 adr = AREG((Opcode >> 0) & 7);
11877 AREG((Opcode >> 0) & 7) += 2;
11878 PRE_IO
11879 READ_WORD_F(adr, res)
11880 flag_C = 0;
11881 flag_V = 0;
11882 flag_NotZ = res;
11883 flag_N = res >> 8;
11884 adr = AREG(7) - 2;
11885 AREG(7) = adr;
11886 WRITE_WORD_F(adr, res)
11887 POST_IO
11888RET(12)
11889}
11890
11891// MOVEW
11892OPCODE(0x3020)
11893{
11894 u32 adr, res;
11895 u32 src, dst;
11896
11897 adr = AREG((Opcode >> 0) & 7) - 2;
11898 AREG((Opcode >> 0) & 7) = adr;
11899 PRE_IO
11900 READ_WORD_F(adr, res)
11901 flag_C = 0;
11902 flag_V = 0;
11903 flag_NotZ = res;
11904 flag_N = res >> 8;
11905 DREGu16((Opcode >> 9) & 7) = res;
11906 POST_IO
11907RET(10)
11908}
11909
11910// MOVEW
11911OPCODE(0x30A0)
11912{
11913 u32 adr, res;
11914 u32 src, dst;
11915
11916 adr = AREG((Opcode >> 0) & 7) - 2;
11917 AREG((Opcode >> 0) & 7) = adr;
11918 PRE_IO
11919 READ_WORD_F(adr, res)
11920 flag_C = 0;
11921 flag_V = 0;
11922 flag_NotZ = res;
11923 flag_N = res >> 8;
11924 adr = AREG((Opcode >> 9) & 7);
11925 WRITE_WORD_F(adr, res)
11926 POST_IO
11927RET(14)
11928}
11929
11930// MOVEW
11931OPCODE(0x30E0)
11932{
11933 u32 adr, res;
11934 u32 src, dst;
11935
11936 adr = AREG((Opcode >> 0) & 7) - 2;
11937 AREG((Opcode >> 0) & 7) = adr;
11938 PRE_IO
11939 READ_WORD_F(adr, res)
11940 flag_C = 0;
11941 flag_V = 0;
11942 flag_NotZ = res;
11943 flag_N = res >> 8;
11944 adr = AREG((Opcode >> 9) & 7);
11945 AREG((Opcode >> 9) & 7) += 2;
11946 WRITE_WORD_F(adr, res)
11947 POST_IO
11948RET(14)
11949}
11950
11951// MOVEW
11952OPCODE(0x3120)
11953{
11954 u32 adr, res;
11955 u32 src, dst;
11956
11957 adr = AREG((Opcode >> 0) & 7) - 2;
11958 AREG((Opcode >> 0) & 7) = adr;
11959 PRE_IO
11960 READ_WORD_F(adr, res)
11961 flag_C = 0;
11962 flag_V = 0;
11963 flag_NotZ = res;
11964 flag_N = res >> 8;
11965 adr = AREG((Opcode >> 9) & 7) - 2;
11966 AREG((Opcode >> 9) & 7) = adr;
11967 WRITE_WORD_F(adr, res)
11968 POST_IO
11969RET(14)
11970}
11971
11972// MOVEW
11973OPCODE(0x3160)
11974{
11975 u32 adr, res;
11976 u32 src, dst;
11977
11978 adr = AREG((Opcode >> 0) & 7) - 2;
11979 AREG((Opcode >> 0) & 7) = adr;
11980 PRE_IO
11981 READ_WORD_F(adr, res)
11982 flag_C = 0;
11983 flag_V = 0;
11984 flag_NotZ = res;
11985 flag_N = res >> 8;
11986 FETCH_SWORD(adr);
11987 adr += AREG((Opcode >> 9) & 7);
11988 WRITE_WORD_F(adr, res)
11989 POST_IO
11990RET(18)
11991}
11992
11993// MOVEW
11994OPCODE(0x31A0)
11995{
11996 u32 adr, res;
11997 u32 src, dst;
11998
11999 adr = AREG((Opcode >> 0) & 7) - 2;
12000 AREG((Opcode >> 0) & 7) = adr;
12001 PRE_IO
12002 READ_WORD_F(adr, res)
12003 flag_C = 0;
12004 flag_V = 0;
12005 flag_NotZ = res;
12006 flag_N = res >> 8;
12007 adr = AREG((Opcode >> 9) & 7);
12008 DECODE_EXT_WORD
12009 WRITE_WORD_F(adr, res)
12010 POST_IO
12011RET(20)
12012}
12013
12014// MOVEW
12015OPCODE(0x31E0)
12016{
12017 u32 adr, res;
12018 u32 src, dst;
12019
12020 adr = AREG((Opcode >> 0) & 7) - 2;
12021 AREG((Opcode >> 0) & 7) = adr;
12022 PRE_IO
12023 READ_WORD_F(adr, res)
12024 flag_C = 0;
12025 flag_V = 0;
12026 flag_NotZ = res;
12027 flag_N = res >> 8;
12028 FETCH_SWORD(adr);
12029 WRITE_WORD_F(adr, res)
12030 POST_IO
12031RET(18)
12032}
12033
12034// MOVEW
12035OPCODE(0x33E0)
12036{
12037 u32 adr, res;
12038 u32 src, dst;
12039
12040 adr = AREG((Opcode >> 0) & 7) - 2;
12041 AREG((Opcode >> 0) & 7) = adr;
12042 PRE_IO
12043 READ_WORD_F(adr, res)
12044 flag_C = 0;
12045 flag_V = 0;
12046 flag_NotZ = res;
12047 flag_N = res >> 8;
12048 FETCH_LONG(adr);
12049 WRITE_WORD_F(adr, res)
12050 POST_IO
12051RET(22)
12052}
12053
12054// MOVEW
12055OPCODE(0x3EE0)
12056{
12057 u32 adr, res;
12058 u32 src, dst;
12059
12060 adr = AREG((Opcode >> 0) & 7) - 2;
12061 AREG((Opcode >> 0) & 7) = adr;
12062 PRE_IO
12063 READ_WORD_F(adr, res)
12064 flag_C = 0;
12065 flag_V = 0;
12066 flag_NotZ = res;
12067 flag_N = res >> 8;
12068 adr = AREG(7);
12069 AREG(7) += 2;
12070 WRITE_WORD_F(adr, res)
12071 POST_IO
12072RET(14)
12073}
12074
12075// MOVEW
12076OPCODE(0x3F20)
12077{
12078 u32 adr, res;
12079 u32 src, dst;
12080
12081 adr = AREG((Opcode >> 0) & 7) - 2;
12082 AREG((Opcode >> 0) & 7) = adr;
12083 PRE_IO
12084 READ_WORD_F(adr, res)
12085 flag_C = 0;
12086 flag_V = 0;
12087 flag_NotZ = res;
12088 flag_N = res >> 8;
12089 adr = AREG(7) - 2;
12090 AREG(7) = adr;
12091 WRITE_WORD_F(adr, res)
12092 POST_IO
12093RET(14)
12094}
12095
12096// MOVEW
12097OPCODE(0x3028)
12098{
12099 u32 adr, res;
12100 u32 src, dst;
12101
12102 FETCH_SWORD(adr);
12103 adr += AREG((Opcode >> 0) & 7);
12104 PRE_IO
12105 READ_WORD_F(adr, res)
12106 flag_C = 0;
12107 flag_V = 0;
12108 flag_NotZ = res;
12109 flag_N = res >> 8;
12110 DREGu16((Opcode >> 9) & 7) = res;
12111 POST_IO
12112RET(12)
12113}
12114
12115// MOVEW
12116OPCODE(0x30A8)
12117{
12118 u32 adr, res;
12119 u32 src, dst;
12120
12121 FETCH_SWORD(adr);
12122 adr += AREG((Opcode >> 0) & 7);
12123 PRE_IO
12124 READ_WORD_F(adr, res)
12125 flag_C = 0;
12126 flag_V = 0;
12127 flag_NotZ = res;
12128 flag_N = res >> 8;
12129 adr = AREG((Opcode >> 9) & 7);
12130 WRITE_WORD_F(adr, res)
12131 POST_IO
12132RET(16)
12133}
12134
12135// MOVEW
12136OPCODE(0x30E8)
12137{
12138 u32 adr, res;
12139 u32 src, dst;
12140
12141 FETCH_SWORD(adr);
12142 adr += AREG((Opcode >> 0) & 7);
12143 PRE_IO
12144 READ_WORD_F(adr, res)
12145 flag_C = 0;
12146 flag_V = 0;
12147 flag_NotZ = res;
12148 flag_N = res >> 8;
12149 adr = AREG((Opcode >> 9) & 7);
12150 AREG((Opcode >> 9) & 7) += 2;
12151 WRITE_WORD_F(adr, res)
12152 POST_IO
12153RET(16)
12154}
12155
12156// MOVEW
12157OPCODE(0x3128)
12158{
12159 u32 adr, res;
12160 u32 src, dst;
12161
12162 FETCH_SWORD(adr);
12163 adr += AREG((Opcode >> 0) & 7);
12164 PRE_IO
12165 READ_WORD_F(adr, res)
12166 flag_C = 0;
12167 flag_V = 0;
12168 flag_NotZ = res;
12169 flag_N = res >> 8;
12170 adr = AREG((Opcode >> 9) & 7) - 2;
12171 AREG((Opcode >> 9) & 7) = adr;
12172 WRITE_WORD_F(adr, res)
12173 POST_IO
12174RET(16)
12175}
12176
12177// MOVEW
12178OPCODE(0x3168)
12179{
12180 u32 adr, res;
12181 u32 src, dst;
12182
12183 FETCH_SWORD(adr);
12184 adr += AREG((Opcode >> 0) & 7);
12185 PRE_IO
12186 READ_WORD_F(adr, res)
12187 flag_C = 0;
12188 flag_V = 0;
12189 flag_NotZ = res;
12190 flag_N = res >> 8;
12191 FETCH_SWORD(adr);
12192 adr += AREG((Opcode >> 9) & 7);
12193 WRITE_WORD_F(adr, res)
12194 POST_IO
12195RET(20)
12196}
12197
12198// MOVEW
12199OPCODE(0x31A8)
12200{
12201 u32 adr, res;
12202 u32 src, dst;
12203
12204 FETCH_SWORD(adr);
12205 adr += AREG((Opcode >> 0) & 7);
12206 PRE_IO
12207 READ_WORD_F(adr, res)
12208 flag_C = 0;
12209 flag_V = 0;
12210 flag_NotZ = res;
12211 flag_N = res >> 8;
12212 adr = AREG((Opcode >> 9) & 7);
12213 DECODE_EXT_WORD
12214 WRITE_WORD_F(adr, res)
12215 POST_IO
12216RET(22)
12217}
12218
12219// MOVEW
12220OPCODE(0x31E8)
12221{
12222 u32 adr, res;
12223 u32 src, dst;
12224
12225 FETCH_SWORD(adr);
12226 adr += AREG((Opcode >> 0) & 7);
12227 PRE_IO
12228 READ_WORD_F(adr, res)
12229 flag_C = 0;
12230 flag_V = 0;
12231 flag_NotZ = res;
12232 flag_N = res >> 8;
12233 FETCH_SWORD(adr);
12234 WRITE_WORD_F(adr, res)
12235 POST_IO
12236RET(20)
12237}
12238
12239// MOVEW
12240OPCODE(0x33E8)
12241{
12242 u32 adr, res;
12243 u32 src, dst;
12244
12245 FETCH_SWORD(adr);
12246 adr += AREG((Opcode >> 0) & 7);
12247 PRE_IO
12248 READ_WORD_F(adr, res)
12249 flag_C = 0;
12250 flag_V = 0;
12251 flag_NotZ = res;
12252 flag_N = res >> 8;
12253 FETCH_LONG(adr);
12254 WRITE_WORD_F(adr, res)
12255 POST_IO
12256RET(24)
12257}
12258
12259// MOVEW
12260OPCODE(0x3EE8)
12261{
12262 u32 adr, res;
12263 u32 src, dst;
12264
12265 FETCH_SWORD(adr);
12266 adr += AREG((Opcode >> 0) & 7);
12267 PRE_IO
12268 READ_WORD_F(adr, res)
12269 flag_C = 0;
12270 flag_V = 0;
12271 flag_NotZ = res;
12272 flag_N = res >> 8;
12273 adr = AREG(7);
12274 AREG(7) += 2;
12275 WRITE_WORD_F(adr, res)
12276 POST_IO
12277RET(16)
12278}
12279
12280// MOVEW
12281OPCODE(0x3F28)
12282{
12283 u32 adr, res;
12284 u32 src, dst;
12285
12286 FETCH_SWORD(adr);
12287 adr += AREG((Opcode >> 0) & 7);
12288 PRE_IO
12289 READ_WORD_F(adr, res)
12290 flag_C = 0;
12291 flag_V = 0;
12292 flag_NotZ = res;
12293 flag_N = res >> 8;
12294 adr = AREG(7) - 2;
12295 AREG(7) = adr;
12296 WRITE_WORD_F(adr, res)
12297 POST_IO
12298RET(16)
12299}
12300
12301// MOVEW
12302OPCODE(0x3030)
12303{
12304 u32 adr, res;
12305 u32 src, dst;
12306
12307 adr = AREG((Opcode >> 0) & 7);
12308 DECODE_EXT_WORD
12309 PRE_IO
12310 READ_WORD_F(adr, res)
12311 flag_C = 0;
12312 flag_V = 0;
12313 flag_NotZ = res;
12314 flag_N = res >> 8;
12315 DREGu16((Opcode >> 9) & 7) = res;
12316 POST_IO
12317RET(14)
12318}
12319
12320// MOVEW
12321OPCODE(0x30B0)
12322{
12323 u32 adr, res;
12324 u32 src, dst;
12325
12326 adr = AREG((Opcode >> 0) & 7);
12327 DECODE_EXT_WORD
12328 PRE_IO
12329 READ_WORD_F(adr, res)
12330 flag_C = 0;
12331 flag_V = 0;
12332 flag_NotZ = res;
12333 flag_N = res >> 8;
12334 adr = AREG((Opcode >> 9) & 7);
12335 WRITE_WORD_F(adr, res)
12336 POST_IO
12337RET(18)
12338}
12339
12340// MOVEW
12341OPCODE(0x30F0)
12342{
12343 u32 adr, res;
12344 u32 src, dst;
12345
12346 adr = AREG((Opcode >> 0) & 7);
12347 DECODE_EXT_WORD
12348 PRE_IO
12349 READ_WORD_F(adr, res)
12350 flag_C = 0;
12351 flag_V = 0;
12352 flag_NotZ = res;
12353 flag_N = res >> 8;
12354 adr = AREG((Opcode >> 9) & 7);
12355 AREG((Opcode >> 9) & 7) += 2;
12356 WRITE_WORD_F(adr, res)
12357 POST_IO
12358RET(18)
12359}
12360
12361// MOVEW
12362OPCODE(0x3130)
12363{
12364 u32 adr, res;
12365 u32 src, dst;
12366
12367 adr = AREG((Opcode >> 0) & 7);
12368 DECODE_EXT_WORD
12369 PRE_IO
12370 READ_WORD_F(adr, res)
12371 flag_C = 0;
12372 flag_V = 0;
12373 flag_NotZ = res;
12374 flag_N = res >> 8;
12375 adr = AREG((Opcode >> 9) & 7) - 2;
12376 AREG((Opcode >> 9) & 7) = adr;
12377 WRITE_WORD_F(adr, res)
12378 POST_IO
12379RET(18)
12380}
12381
12382// MOVEW
12383OPCODE(0x3170)
12384{
12385 u32 adr, res;
12386 u32 src, dst;
12387
12388 adr = AREG((Opcode >> 0) & 7);
12389 DECODE_EXT_WORD
12390 PRE_IO
12391 READ_WORD_F(adr, res)
12392 flag_C = 0;
12393 flag_V = 0;
12394 flag_NotZ = res;
12395 flag_N = res >> 8;
12396 FETCH_SWORD(adr);
12397 adr += AREG((Opcode >> 9) & 7);
12398 WRITE_WORD_F(adr, res)
12399 POST_IO
12400RET(22)
12401}
12402
12403// MOVEW
12404OPCODE(0x31B0)
12405{
12406 u32 adr, res;
12407 u32 src, dst;
12408
12409 adr = AREG((Opcode >> 0) & 7);
12410 DECODE_EXT_WORD
12411 PRE_IO
12412 READ_WORD_F(adr, res)
12413 flag_C = 0;
12414 flag_V = 0;
12415 flag_NotZ = res;
12416 flag_N = res >> 8;
12417 adr = AREG((Opcode >> 9) & 7);
12418 DECODE_EXT_WORD
12419 WRITE_WORD_F(adr, res)
12420 POST_IO
12421RET(24)
12422}
12423
12424// MOVEW
12425OPCODE(0x31F0)
12426{
12427 u32 adr, res;
12428 u32 src, dst;
12429
12430 adr = AREG((Opcode >> 0) & 7);
12431 DECODE_EXT_WORD
12432 PRE_IO
12433 READ_WORD_F(adr, res)
12434 flag_C = 0;
12435 flag_V = 0;
12436 flag_NotZ = res;
12437 flag_N = res >> 8;
12438 FETCH_SWORD(adr);
12439 WRITE_WORD_F(adr, res)
12440 POST_IO
12441RET(22)
12442}
12443
12444// MOVEW
12445OPCODE(0x33F0)
12446{
12447 u32 adr, res;
12448 u32 src, dst;
12449
12450 adr = AREG((Opcode >> 0) & 7);
12451 DECODE_EXT_WORD
12452 PRE_IO
12453 READ_WORD_F(adr, res)
12454 flag_C = 0;
12455 flag_V = 0;
12456 flag_NotZ = res;
12457 flag_N = res >> 8;
12458 FETCH_LONG(adr);
12459 WRITE_WORD_F(adr, res)
12460 POST_IO
12461RET(26)
12462}
12463
12464// MOVEW
12465OPCODE(0x3EF0)
12466{
12467 u32 adr, res;
12468 u32 src, dst;
12469
12470 adr = AREG((Opcode >> 0) & 7);
12471 DECODE_EXT_WORD
12472 PRE_IO
12473 READ_WORD_F(adr, res)
12474 flag_C = 0;
12475 flag_V = 0;
12476 flag_NotZ = res;
12477 flag_N = res >> 8;
12478 adr = AREG(7);
12479 AREG(7) += 2;
12480 WRITE_WORD_F(adr, res)
12481 POST_IO
12482RET(18)
12483}
12484
12485// MOVEW
12486OPCODE(0x3F30)
12487{
12488 u32 adr, res;
12489 u32 src, dst;
12490
12491 adr = AREG((Opcode >> 0) & 7);
12492 DECODE_EXT_WORD
12493 PRE_IO
12494 READ_WORD_F(adr, res)
12495 flag_C = 0;
12496 flag_V = 0;
12497 flag_NotZ = res;
12498 flag_N = res >> 8;
12499 adr = AREG(7) - 2;
12500 AREG(7) = adr;
12501 WRITE_WORD_F(adr, res)
12502 POST_IO
12503RET(18)
12504}
12505
12506// MOVEW
12507OPCODE(0x3038)
12508{
12509 u32 adr, res;
12510 u32 src, dst;
12511
12512 FETCH_SWORD(adr);
12513 PRE_IO
12514 READ_WORD_F(adr, res)
12515 flag_C = 0;
12516 flag_V = 0;
12517 flag_NotZ = res;
12518 flag_N = res >> 8;
12519 DREGu16((Opcode >> 9) & 7) = res;
12520 POST_IO
12521RET(12)
12522}
12523
12524// MOVEW
12525OPCODE(0x30B8)
12526{
12527 u32 adr, res;
12528 u32 src, dst;
12529
12530 FETCH_SWORD(adr);
12531 PRE_IO
12532 READ_WORD_F(adr, res)
12533 flag_C = 0;
12534 flag_V = 0;
12535 flag_NotZ = res;
12536 flag_N = res >> 8;
12537 adr = AREG((Opcode >> 9) & 7);
12538 WRITE_WORD_F(adr, res)
12539 POST_IO
12540RET(16)
12541}
12542
12543// MOVEW
12544OPCODE(0x30F8)
12545{
12546 u32 adr, res;
12547 u32 src, dst;
12548
12549 FETCH_SWORD(adr);
12550 PRE_IO
12551 READ_WORD_F(adr, res)
12552 flag_C = 0;
12553 flag_V = 0;
12554 flag_NotZ = res;
12555 flag_N = res >> 8;
12556 adr = AREG((Opcode >> 9) & 7);
12557 AREG((Opcode >> 9) & 7) += 2;
12558 WRITE_WORD_F(adr, res)
12559 POST_IO
12560RET(16)
12561}
12562
12563// MOVEW
12564OPCODE(0x3138)
12565{
12566 u32 adr, res;
12567 u32 src, dst;
12568
12569 FETCH_SWORD(adr);
12570 PRE_IO
12571 READ_WORD_F(adr, res)
12572 flag_C = 0;
12573 flag_V = 0;
12574 flag_NotZ = res;
12575 flag_N = res >> 8;
12576 adr = AREG((Opcode >> 9) & 7) - 2;
12577 AREG((Opcode >> 9) & 7) = adr;
12578 WRITE_WORD_F(adr, res)
12579 POST_IO
12580RET(16)
12581}
12582
12583// MOVEW
12584OPCODE(0x3178)
12585{
12586 u32 adr, res;
12587 u32 src, dst;
12588
12589 FETCH_SWORD(adr);
12590 PRE_IO
12591 READ_WORD_F(adr, res)
12592 flag_C = 0;
12593 flag_V = 0;
12594 flag_NotZ = res;
12595 flag_N = res >> 8;
12596 FETCH_SWORD(adr);
12597 adr += AREG((Opcode >> 9) & 7);
12598 WRITE_WORD_F(adr, res)
12599 POST_IO
12600RET(20)
12601}
12602
12603// MOVEW
12604OPCODE(0x31B8)
12605{
12606 u32 adr, res;
12607 u32 src, dst;
12608
12609 FETCH_SWORD(adr);
12610 PRE_IO
12611 READ_WORD_F(adr, res)
12612 flag_C = 0;
12613 flag_V = 0;
12614 flag_NotZ = res;
12615 flag_N = res >> 8;
12616 adr = AREG((Opcode >> 9) & 7);
12617 DECODE_EXT_WORD
12618 WRITE_WORD_F(adr, res)
12619 POST_IO
12620RET(22)
12621}
12622
12623// MOVEW
12624OPCODE(0x31F8)
12625{
12626 u32 adr, res;
12627 u32 src, dst;
12628
12629 FETCH_SWORD(adr);
12630 PRE_IO
12631 READ_WORD_F(adr, res)
12632 flag_C = 0;
12633 flag_V = 0;
12634 flag_NotZ = res;
12635 flag_N = res >> 8;
12636 FETCH_SWORD(adr);
12637 WRITE_WORD_F(adr, res)
12638 POST_IO
12639RET(20)
12640}
12641
12642// MOVEW
12643OPCODE(0x33F8)
12644{
12645 u32 adr, res;
12646 u32 src, dst;
12647
12648 FETCH_SWORD(adr);
12649 PRE_IO
12650 READ_WORD_F(adr, res)
12651 flag_C = 0;
12652 flag_V = 0;
12653 flag_NotZ = res;
12654 flag_N = res >> 8;
12655 FETCH_LONG(adr);
12656 WRITE_WORD_F(adr, res)
12657 POST_IO
12658RET(24)
12659}
12660
12661// MOVEW
12662OPCODE(0x3EF8)
12663{
12664 u32 adr, res;
12665 u32 src, dst;
12666
12667 FETCH_SWORD(adr);
12668 PRE_IO
12669 READ_WORD_F(adr, res)
12670 flag_C = 0;
12671 flag_V = 0;
12672 flag_NotZ = res;
12673 flag_N = res >> 8;
12674 adr = AREG(7);
12675 AREG(7) += 2;
12676 WRITE_WORD_F(adr, res)
12677 POST_IO
12678RET(16)
12679}
12680
12681// MOVEW
12682OPCODE(0x3F38)
12683{
12684 u32 adr, res;
12685 u32 src, dst;
12686
12687 FETCH_SWORD(adr);
12688 PRE_IO
12689 READ_WORD_F(adr, res)
12690 flag_C = 0;
12691 flag_V = 0;
12692 flag_NotZ = res;
12693 flag_N = res >> 8;
12694 adr = AREG(7) - 2;
12695 AREG(7) = adr;
12696 WRITE_WORD_F(adr, res)
12697 POST_IO
12698RET(16)
12699}
12700
12701// MOVEW
12702OPCODE(0x3039)
12703{
12704 u32 adr, res;
12705 u32 src, dst;
12706
12707 FETCH_LONG(adr);
12708 PRE_IO
12709 READ_WORD_F(adr, res)
12710 flag_C = 0;
12711 flag_V = 0;
12712 flag_NotZ = res;
12713 flag_N = res >> 8;
12714 DREGu16((Opcode >> 9) & 7) = res;
12715 POST_IO
12716RET(16)
12717}
12718
12719// MOVEW
12720OPCODE(0x30B9)
12721{
12722 u32 adr, res;
12723 u32 src, dst;
12724
12725 FETCH_LONG(adr);
12726 PRE_IO
12727 READ_WORD_F(adr, res)
12728 flag_C = 0;
12729 flag_V = 0;
12730 flag_NotZ = res;
12731 flag_N = res >> 8;
12732 adr = AREG((Opcode >> 9) & 7);
12733 WRITE_WORD_F(adr, res)
12734 POST_IO
12735RET(20)
12736}
12737
12738// MOVEW
12739OPCODE(0x30F9)
12740{
12741 u32 adr, res;
12742 u32 src, dst;
12743
12744 FETCH_LONG(adr);
12745 PRE_IO
12746 READ_WORD_F(adr, res)
12747 flag_C = 0;
12748 flag_V = 0;
12749 flag_NotZ = res;
12750 flag_N = res >> 8;
12751 adr = AREG((Opcode >> 9) & 7);
12752 AREG((Opcode >> 9) & 7) += 2;
12753 WRITE_WORD_F(adr, res)
12754 POST_IO
12755RET(20)
12756}
12757
12758// MOVEW
12759OPCODE(0x3139)
12760{
12761 u32 adr, res;
12762 u32 src, dst;
12763
12764 FETCH_LONG(adr);
12765 PRE_IO
12766 READ_WORD_F(adr, res)
12767 flag_C = 0;
12768 flag_V = 0;
12769 flag_NotZ = res;
12770 flag_N = res >> 8;
12771 adr = AREG((Opcode >> 9) & 7) - 2;
12772 AREG((Opcode >> 9) & 7) = adr;
12773 WRITE_WORD_F(adr, res)
12774 POST_IO
12775RET(20)
12776}
12777
12778// MOVEW
12779OPCODE(0x3179)
12780{
12781 u32 adr, res;
12782 u32 src, dst;
12783
12784 FETCH_LONG(adr);
12785 PRE_IO
12786 READ_WORD_F(adr, res)
12787 flag_C = 0;
12788 flag_V = 0;
12789 flag_NotZ = res;
12790 flag_N = res >> 8;
12791 FETCH_SWORD(adr);
12792 adr += AREG((Opcode >> 9) & 7);
12793 WRITE_WORD_F(adr, res)
12794 POST_IO
12795RET(24)
12796}
12797
12798// MOVEW
12799OPCODE(0x31B9)
12800{
12801 u32 adr, res;
12802 u32 src, dst;
12803
12804 FETCH_LONG(adr);
12805 PRE_IO
12806 READ_WORD_F(adr, res)
12807 flag_C = 0;
12808 flag_V = 0;
12809 flag_NotZ = res;
12810 flag_N = res >> 8;
12811 adr = AREG((Opcode >> 9) & 7);
12812 DECODE_EXT_WORD
12813 WRITE_WORD_F(adr, res)
12814 POST_IO
12815RET(26)
12816}
12817
12818// MOVEW
12819OPCODE(0x31F9)
12820{
12821 u32 adr, res;
12822 u32 src, dst;
12823
12824 FETCH_LONG(adr);
12825 PRE_IO
12826 READ_WORD_F(adr, res)
12827 flag_C = 0;
12828 flag_V = 0;
12829 flag_NotZ = res;
12830 flag_N = res >> 8;
12831 FETCH_SWORD(adr);
12832 WRITE_WORD_F(adr, res)
12833 POST_IO
12834RET(24)
12835}
12836
12837// MOVEW
12838OPCODE(0x33F9)
12839{
12840 u32 adr, res;
12841 u32 src, dst;
12842
12843 FETCH_LONG(adr);
12844 PRE_IO
12845 READ_WORD_F(adr, res)
12846 flag_C = 0;
12847 flag_V = 0;
12848 flag_NotZ = res;
12849 flag_N = res >> 8;
12850 FETCH_LONG(adr);
12851 WRITE_WORD_F(adr, res)
12852 POST_IO
12853RET(28)
12854}
12855
12856// MOVEW
12857OPCODE(0x3EF9)
12858{
12859 u32 adr, res;
12860 u32 src, dst;
12861
12862 FETCH_LONG(adr);
12863 PRE_IO
12864 READ_WORD_F(adr, res)
12865 flag_C = 0;
12866 flag_V = 0;
12867 flag_NotZ = res;
12868 flag_N = res >> 8;
12869 adr = AREG(7);
12870 AREG(7) += 2;
12871 WRITE_WORD_F(adr, res)
12872 POST_IO
12873RET(20)
12874}
12875
12876// MOVEW
12877OPCODE(0x3F39)
12878{
12879 u32 adr, res;
12880 u32 src, dst;
12881
12882 FETCH_LONG(adr);
12883 PRE_IO
12884 READ_WORD_F(adr, res)
12885 flag_C = 0;
12886 flag_V = 0;
12887 flag_NotZ = res;
12888 flag_N = res >> 8;
12889 adr = AREG(7) - 2;
12890 AREG(7) = adr;
12891 WRITE_WORD_F(adr, res)
12892 POST_IO
12893RET(20)
12894}
12895
12896// MOVEW
12897OPCODE(0x303A)
12898{
12899 u32 adr, res;
12900 u32 src, dst;
12901
12902 adr = GET_SWORD + GET_PC;
12903 PC++;
12904 PRE_IO
12905 READ_WORD_F(adr, res)
12906 flag_C = 0;
12907 flag_V = 0;
12908 flag_NotZ = res;
12909 flag_N = res >> 8;
12910 DREGu16((Opcode >> 9) & 7) = res;
12911 POST_IO
12912RET(12)
12913}
12914
12915// MOVEW
12916OPCODE(0x30BA)
12917{
12918 u32 adr, res;
12919 u32 src, dst;
12920
12921 adr = GET_SWORD + GET_PC;
12922 PC++;
12923 PRE_IO
12924 READ_WORD_F(adr, res)
12925 flag_C = 0;
12926 flag_V = 0;
12927 flag_NotZ = res;
12928 flag_N = res >> 8;
12929 adr = AREG((Opcode >> 9) & 7);
12930 WRITE_WORD_F(adr, res)
12931 POST_IO
12932RET(16)
12933}
12934
12935// MOVEW
12936OPCODE(0x30FA)
12937{
12938 u32 adr, res;
12939 u32 src, dst;
12940
12941 adr = GET_SWORD + GET_PC;
12942 PC++;
12943 PRE_IO
12944 READ_WORD_F(adr, res)
12945 flag_C = 0;
12946 flag_V = 0;
12947 flag_NotZ = res;
12948 flag_N = res >> 8;
12949 adr = AREG((Opcode >> 9) & 7);
12950 AREG((Opcode >> 9) & 7) += 2;
12951 WRITE_WORD_F(adr, res)
12952 POST_IO
12953RET(16)
12954}
12955
12956// MOVEW
12957OPCODE(0x313A)
12958{
12959 u32 adr, res;
12960 u32 src, dst;
12961
12962 adr = GET_SWORD + GET_PC;
12963 PC++;
12964 PRE_IO
12965 READ_WORD_F(adr, res)
12966 flag_C = 0;
12967 flag_V = 0;
12968 flag_NotZ = res;
12969 flag_N = res >> 8;
12970 adr = AREG((Opcode >> 9) & 7) - 2;
12971 AREG((Opcode >> 9) & 7) = adr;
12972 WRITE_WORD_F(adr, res)
12973 POST_IO
12974RET(16)
12975}
12976
12977// MOVEW
12978OPCODE(0x317A)
12979{
12980 u32 adr, res;
12981 u32 src, dst;
12982
12983 adr = GET_SWORD + GET_PC;
12984 PC++;
12985 PRE_IO
12986 READ_WORD_F(adr, res)
12987 flag_C = 0;
12988 flag_V = 0;
12989 flag_NotZ = res;
12990 flag_N = res >> 8;
12991 FETCH_SWORD(adr);
12992 adr += AREG((Opcode >> 9) & 7);
12993 WRITE_WORD_F(adr, res)
12994 POST_IO
12995RET(20)
12996}
12997
12998// MOVEW
12999OPCODE(0x31BA)
13000{
13001 u32 adr, res;
13002 u32 src, dst;
13003
13004 adr = GET_SWORD + GET_PC;
13005 PC++;
13006 PRE_IO
13007 READ_WORD_F(adr, res)
13008 flag_C = 0;
13009 flag_V = 0;
13010 flag_NotZ = res;
13011 flag_N = res >> 8;
13012 adr = AREG((Opcode >> 9) & 7);
13013 DECODE_EXT_WORD
13014 WRITE_WORD_F(adr, res)
13015 POST_IO
13016RET(22)
13017}
13018
13019// MOVEW
13020OPCODE(0x31FA)
13021{
13022 u32 adr, res;
13023 u32 src, dst;
13024
13025 adr = GET_SWORD + GET_PC;
13026 PC++;
13027 PRE_IO
13028 READ_WORD_F(adr, res)
13029 flag_C = 0;
13030 flag_V = 0;
13031 flag_NotZ = res;
13032 flag_N = res >> 8;
13033 FETCH_SWORD(adr);
13034 WRITE_WORD_F(adr, res)
13035 POST_IO
13036RET(20)
13037}
13038
13039// MOVEW
13040OPCODE(0x33FA)
13041{
13042 u32 adr, res;
13043 u32 src, dst;
13044
13045 adr = GET_SWORD + GET_PC;
13046 PC++;
13047 PRE_IO
13048 READ_WORD_F(adr, res)
13049 flag_C = 0;
13050 flag_V = 0;
13051 flag_NotZ = res;
13052 flag_N = res >> 8;
13053 FETCH_LONG(adr);
13054 WRITE_WORD_F(adr, res)
13055 POST_IO
13056RET(24)
13057}
13058
13059// MOVEW
13060OPCODE(0x3EFA)
13061{
13062 u32 adr, res;
13063 u32 src, dst;
13064
13065 adr = GET_SWORD + GET_PC;
13066 PC++;
13067 PRE_IO
13068 READ_WORD_F(adr, res)
13069 flag_C = 0;
13070 flag_V = 0;
13071 flag_NotZ = res;
13072 flag_N = res >> 8;
13073 adr = AREG(7);
13074 AREG(7) += 2;
13075 WRITE_WORD_F(adr, res)
13076 POST_IO
13077RET(16)
13078}
13079
13080// MOVEW
13081OPCODE(0x3F3A)
13082{
13083 u32 adr, res;
13084 u32 src, dst;
13085
13086 adr = GET_SWORD + GET_PC;
13087 PC++;
13088 PRE_IO
13089 READ_WORD_F(adr, res)
13090 flag_C = 0;
13091 flag_V = 0;
13092 flag_NotZ = res;
13093 flag_N = res >> 8;
13094 adr = AREG(7) - 2;
13095 AREG(7) = adr;
13096 WRITE_WORD_F(adr, res)
13097 POST_IO
13098RET(16)
13099}
13100
13101// MOVEW
13102OPCODE(0x303B)
13103{
13104 u32 adr, res;
13105 u32 src, dst;
13106
13107 adr = GET_PC;
13108 DECODE_EXT_WORD
13109 PRE_IO
13110 READ_WORD_F(adr, res)
13111 flag_C = 0;
13112 flag_V = 0;
13113 flag_NotZ = res;
13114 flag_N = res >> 8;
13115 DREGu16((Opcode >> 9) & 7) = res;
13116 POST_IO
13117RET(14)
13118}
13119
13120// MOVEW
13121OPCODE(0x30BB)
13122{
13123 u32 adr, res;
13124 u32 src, dst;
13125
13126 adr = GET_PC;
13127 DECODE_EXT_WORD
13128 PRE_IO
13129 READ_WORD_F(adr, res)
13130 flag_C = 0;
13131 flag_V = 0;
13132 flag_NotZ = res;
13133 flag_N = res >> 8;
13134 adr = AREG((Opcode >> 9) & 7);
13135 WRITE_WORD_F(adr, res)
13136 POST_IO
13137RET(18)
13138}
13139
13140// MOVEW
13141OPCODE(0x30FB)
13142{
13143 u32 adr, res;
13144 u32 src, dst;
13145
13146 adr = GET_PC;
13147 DECODE_EXT_WORD
13148 PRE_IO
13149 READ_WORD_F(adr, res)
13150 flag_C = 0;
13151 flag_V = 0;
13152 flag_NotZ = res;
13153 flag_N = res >> 8;
13154 adr = AREG((Opcode >> 9) & 7);
13155 AREG((Opcode >> 9) & 7) += 2;
13156 WRITE_WORD_F(adr, res)
13157 POST_IO
13158RET(18)
13159}
13160
13161// MOVEW
13162OPCODE(0x313B)
13163{
13164 u32 adr, res;
13165 u32 src, dst;
13166
13167 adr = GET_PC;
13168 DECODE_EXT_WORD
13169 PRE_IO
13170 READ_WORD_F(adr, res)
13171 flag_C = 0;
13172 flag_V = 0;
13173 flag_NotZ = res;
13174 flag_N = res >> 8;
13175 adr = AREG((Opcode >> 9) & 7) - 2;
13176 AREG((Opcode >> 9) & 7) = adr;
13177 WRITE_WORD_F(adr, res)
13178 POST_IO
13179RET(18)
13180}
13181
13182// MOVEW
13183OPCODE(0x317B)
13184{
13185 u32 adr, res;
13186 u32 src, dst;
13187
13188 adr = GET_PC;
13189 DECODE_EXT_WORD
13190 PRE_IO
13191 READ_WORD_F(adr, res)
13192 flag_C = 0;
13193 flag_V = 0;
13194 flag_NotZ = res;
13195 flag_N = res >> 8;
13196 FETCH_SWORD(adr);
13197 adr += AREG((Opcode >> 9) & 7);
13198 WRITE_WORD_F(adr, res)
13199 POST_IO
13200RET(22)
13201}
13202
13203// MOVEW
13204OPCODE(0x31BB)
13205{
13206 u32 adr, res;
13207 u32 src, dst;
13208
13209 adr = GET_PC;
13210 DECODE_EXT_WORD
13211 PRE_IO
13212 READ_WORD_F(adr, res)
13213 flag_C = 0;
13214 flag_V = 0;
13215 flag_NotZ = res;
13216 flag_N = res >> 8;
13217 adr = AREG((Opcode >> 9) & 7);
13218 DECODE_EXT_WORD
13219 WRITE_WORD_F(adr, res)
13220 POST_IO
13221RET(24)
13222}
13223
13224// MOVEW
13225OPCODE(0x31FB)
13226{
13227 u32 adr, res;
13228 u32 src, dst;
13229
13230 adr = GET_PC;
13231 DECODE_EXT_WORD
13232 PRE_IO
13233 READ_WORD_F(adr, res)
13234 flag_C = 0;
13235 flag_V = 0;
13236 flag_NotZ = res;
13237 flag_N = res >> 8;
13238 FETCH_SWORD(adr);
13239 WRITE_WORD_F(adr, res)
13240 POST_IO
13241RET(22)
13242}
13243
13244// MOVEW
13245OPCODE(0x33FB)
13246{
13247 u32 adr, res;
13248 u32 src, dst;
13249
13250 adr = GET_PC;
13251 DECODE_EXT_WORD
13252 PRE_IO
13253 READ_WORD_F(adr, res)
13254 flag_C = 0;
13255 flag_V = 0;
13256 flag_NotZ = res;
13257 flag_N = res >> 8;
13258 FETCH_LONG(adr);
13259 WRITE_WORD_F(adr, res)
13260 POST_IO
13261RET(26)
13262}
13263
13264// MOVEW
13265OPCODE(0x3EFB)
13266{
13267 u32 adr, res;
13268 u32 src, dst;
13269
13270 adr = GET_PC;
13271 DECODE_EXT_WORD
13272 PRE_IO
13273 READ_WORD_F(adr, res)
13274 flag_C = 0;
13275 flag_V = 0;
13276 flag_NotZ = res;
13277 flag_N = res >> 8;
13278 adr = AREG(7);
13279 AREG(7) += 2;
13280 WRITE_WORD_F(adr, res)
13281 POST_IO
13282RET(18)
13283}
13284
13285// MOVEW
13286OPCODE(0x3F3B)
13287{
13288 u32 adr, res;
13289 u32 src, dst;
13290
13291 adr = GET_PC;
13292 DECODE_EXT_WORD
13293 PRE_IO
13294 READ_WORD_F(adr, res)
13295 flag_C = 0;
13296 flag_V = 0;
13297 flag_NotZ = res;
13298 flag_N = res >> 8;
13299 adr = AREG(7) - 2;
13300 AREG(7) = adr;
13301 WRITE_WORD_F(adr, res)
13302 POST_IO
13303RET(18)
13304}
13305
13306// MOVEW
13307OPCODE(0x303C)
13308{
13309 u32 adr, res;
13310 u32 src, dst;
13311
13312 FETCH_WORD(res);
13313 flag_C = 0;
13314 flag_V = 0;
13315 flag_NotZ = res;
13316 flag_N = res >> 8;
13317 DREGu16((Opcode >> 9) & 7) = res;
13318RET(8)
13319}
13320
13321// MOVEW
13322OPCODE(0x30BC)
13323{
13324 u32 adr, res;
13325 u32 src, dst;
13326
13327 FETCH_WORD(res);
13328 flag_C = 0;
13329 flag_V = 0;
13330 flag_NotZ = res;
13331 flag_N = res >> 8;
13332 adr = AREG((Opcode >> 9) & 7);
13333 PRE_IO
13334 WRITE_WORD_F(adr, res)
13335 POST_IO
13336RET(12)
13337}
13338
13339// MOVEW
13340OPCODE(0x30FC)
13341{
13342 u32 adr, res;
13343 u32 src, dst;
13344
13345 FETCH_WORD(res);
13346 flag_C = 0;
13347 flag_V = 0;
13348 flag_NotZ = res;
13349 flag_N = res >> 8;
13350 adr = AREG((Opcode >> 9) & 7);
13351 AREG((Opcode >> 9) & 7) += 2;
13352 PRE_IO
13353 WRITE_WORD_F(adr, res)
13354 POST_IO
13355RET(12)
13356}
13357
13358// MOVEW
13359OPCODE(0x313C)
13360{
13361 u32 adr, res;
13362 u32 src, dst;
13363
13364 FETCH_WORD(res);
13365 flag_C = 0;
13366 flag_V = 0;
13367 flag_NotZ = res;
13368 flag_N = res >> 8;
13369 adr = AREG((Opcode >> 9) & 7) - 2;
13370 AREG((Opcode >> 9) & 7) = adr;
13371 PRE_IO
13372 WRITE_WORD_F(adr, res)
13373 POST_IO
13374RET(12)
13375}
13376
13377// MOVEW
13378OPCODE(0x317C)
13379{
13380 u32 adr, res;
13381 u32 src, dst;
13382
13383 FETCH_WORD(res);
13384 flag_C = 0;
13385 flag_V = 0;
13386 flag_NotZ = res;
13387 flag_N = res >> 8;
13388 FETCH_SWORD(adr);
13389 adr += AREG((Opcode >> 9) & 7);
13390 PRE_IO
13391 WRITE_WORD_F(adr, res)
13392 POST_IO
13393RET(16)
13394}
13395
13396// MOVEW
13397OPCODE(0x31BC)
13398{
13399 u32 adr, res;
13400 u32 src, dst;
13401
13402 FETCH_WORD(res);
13403 flag_C = 0;
13404 flag_V = 0;
13405 flag_NotZ = res;
13406 flag_N = res >> 8;
13407 adr = AREG((Opcode >> 9) & 7);
13408 DECODE_EXT_WORD
13409 PRE_IO
13410 WRITE_WORD_F(adr, res)
13411 POST_IO
13412RET(18)
13413}
13414
13415// MOVEW
13416OPCODE(0x31FC)
13417{
13418 u32 adr, res;
13419 u32 src, dst;
13420
13421 FETCH_WORD(res);
13422 flag_C = 0;
13423 flag_V = 0;
13424 flag_NotZ = res;
13425 flag_N = res >> 8;
13426 FETCH_SWORD(adr);
13427 PRE_IO
13428 WRITE_WORD_F(adr, res)
13429 POST_IO
13430RET(16)
13431}
13432
13433// MOVEW
13434OPCODE(0x33FC)
13435{
13436 u32 adr, res;
13437 u32 src, dst;
13438
13439 FETCH_WORD(res);
13440 flag_C = 0;
13441 flag_V = 0;
13442 flag_NotZ = res;
13443 flag_N = res >> 8;
13444 FETCH_LONG(adr);
13445 PRE_IO
13446 WRITE_WORD_F(adr, res)
13447 POST_IO
13448RET(20)
13449}
13450
13451// MOVEW
13452OPCODE(0x3EFC)
13453{
13454 u32 adr, res;
13455 u32 src, dst;
13456
13457 FETCH_WORD(res);
13458 flag_C = 0;
13459 flag_V = 0;
13460 flag_NotZ = res;
13461 flag_N = res >> 8;
13462 adr = AREG(7);
13463 AREG(7) += 2;
13464 PRE_IO
13465 WRITE_WORD_F(adr, res)
13466 POST_IO
13467RET(12)
13468}
13469
13470// MOVEW
13471OPCODE(0x3F3C)
13472{
13473 u32 adr, res;
13474 u32 src, dst;
13475
13476 FETCH_WORD(res);
13477 flag_C = 0;
13478 flag_V = 0;
13479 flag_NotZ = res;
13480 flag_N = res >> 8;
13481 adr = AREG(7) - 2;
13482 AREG(7) = adr;
13483 PRE_IO
13484 WRITE_WORD_F(adr, res)
13485 POST_IO
13486RET(12)
13487}
13488
13489// MOVEW
13490OPCODE(0x301F)
13491{
13492 u32 adr, res;
13493 u32 src, dst;
13494
13495 adr = AREG(7);
13496 AREG(7) += 2;
13497 PRE_IO
13498 READ_WORD_F(adr, res)
13499 flag_C = 0;
13500 flag_V = 0;
13501 flag_NotZ = res;
13502 flag_N = res >> 8;
13503 DREGu16((Opcode >> 9) & 7) = res;
13504 POST_IO
13505RET(8)
13506}
13507
13508// MOVEW
13509OPCODE(0x309F)
13510{
13511 u32 adr, res;
13512 u32 src, dst;
13513
13514 adr = AREG(7);
13515 AREG(7) += 2;
13516 PRE_IO
13517 READ_WORD_F(adr, res)
13518 flag_C = 0;
13519 flag_V = 0;
13520 flag_NotZ = res;
13521 flag_N = res >> 8;
13522 adr = AREG((Opcode >> 9) & 7);
13523 WRITE_WORD_F(adr, res)
13524 POST_IO
13525RET(12)
13526}
13527
13528// MOVEW
13529OPCODE(0x30DF)
13530{
13531 u32 adr, res;
13532 u32 src, dst;
13533
13534 adr = AREG(7);
13535 AREG(7) += 2;
13536 PRE_IO
13537 READ_WORD_F(adr, res)
13538 flag_C = 0;
13539 flag_V = 0;
13540 flag_NotZ = res;
13541 flag_N = res >> 8;
13542 adr = AREG((Opcode >> 9) & 7);
13543 AREG((Opcode >> 9) & 7) += 2;
13544 WRITE_WORD_F(adr, res)
13545 POST_IO
13546RET(12)
13547}
13548
13549// MOVEW
13550OPCODE(0x311F)
13551{
13552 u32 adr, res;
13553 u32 src, dst;
13554
13555 adr = AREG(7);
13556 AREG(7) += 2;
13557 PRE_IO
13558 READ_WORD_F(adr, res)
13559 flag_C = 0;
13560 flag_V = 0;
13561 flag_NotZ = res;
13562 flag_N = res >> 8;
13563 adr = AREG((Opcode >> 9) & 7) - 2;
13564 AREG((Opcode >> 9) & 7) = adr;
13565 WRITE_WORD_F(adr, res)
13566 POST_IO
13567RET(12)
13568}
13569
13570// MOVEW
13571OPCODE(0x315F)
13572{
13573 u32 adr, res;
13574 u32 src, dst;
13575
13576 adr = AREG(7);
13577 AREG(7) += 2;
13578 PRE_IO
13579 READ_WORD_F(adr, res)
13580 flag_C = 0;
13581 flag_V = 0;
13582 flag_NotZ = res;
13583 flag_N = res >> 8;
13584 FETCH_SWORD(adr);
13585 adr += AREG((Opcode >> 9) & 7);
13586 WRITE_WORD_F(adr, res)
13587 POST_IO
13588RET(16)
13589}
13590
13591// MOVEW
13592OPCODE(0x319F)
13593{
13594 u32 adr, res;
13595 u32 src, dst;
13596
13597 adr = AREG(7);
13598 AREG(7) += 2;
13599 PRE_IO
13600 READ_WORD_F(adr, res)
13601 flag_C = 0;
13602 flag_V = 0;
13603 flag_NotZ = res;
13604 flag_N = res >> 8;
13605 adr = AREG((Opcode >> 9) & 7);
13606 DECODE_EXT_WORD
13607 WRITE_WORD_F(adr, res)
13608 POST_IO
13609RET(18)
13610}
13611
13612// MOVEW
13613OPCODE(0x31DF)
13614{
13615 u32 adr, res;
13616 u32 src, dst;
13617
13618 adr = AREG(7);
13619 AREG(7) += 2;
13620 PRE_IO
13621 READ_WORD_F(adr, res)
13622 flag_C = 0;
13623 flag_V = 0;
13624 flag_NotZ = res;
13625 flag_N = res >> 8;
13626 FETCH_SWORD(adr);
13627 WRITE_WORD_F(adr, res)
13628 POST_IO
13629RET(16)
13630}
13631
13632// MOVEW
13633OPCODE(0x33DF)
13634{
13635 u32 adr, res;
13636 u32 src, dst;
13637
13638 adr = AREG(7);
13639 AREG(7) += 2;
13640 PRE_IO
13641 READ_WORD_F(adr, res)
13642 flag_C = 0;
13643 flag_V = 0;
13644 flag_NotZ = res;
13645 flag_N = res >> 8;
13646 FETCH_LONG(adr);
13647 WRITE_WORD_F(adr, res)
13648 POST_IO
13649RET(20)
13650}
13651
13652// MOVEW
13653OPCODE(0x3EDF)
13654{
13655 u32 adr, res;
13656 u32 src, dst;
13657
13658 adr = AREG(7);
13659 AREG(7) += 2;
13660 PRE_IO
13661 READ_WORD_F(adr, res)
13662 flag_C = 0;
13663 flag_V = 0;
13664 flag_NotZ = res;
13665 flag_N = res >> 8;
13666 adr = AREG(7);
13667 AREG(7) += 2;
13668 WRITE_WORD_F(adr, res)
13669 POST_IO
13670RET(12)
13671}
13672
13673// MOVEW
13674OPCODE(0x3F1F)
13675{
13676 u32 adr, res;
13677 u32 src, dst;
13678
13679 adr = AREG(7);
13680 AREG(7) += 2;
13681 PRE_IO
13682 READ_WORD_F(adr, res)
13683 flag_C = 0;
13684 flag_V = 0;
13685 flag_NotZ = res;
13686 flag_N = res >> 8;
13687 adr = AREG(7) - 2;
13688 AREG(7) = adr;
13689 WRITE_WORD_F(adr, res)
13690 POST_IO
13691RET(12)
13692}
13693
13694// MOVEW
13695OPCODE(0x3027)
13696{
13697 u32 adr, res;
13698 u32 src, dst;
13699
13700 adr = AREG(7) - 2;
13701 AREG(7) = adr;
13702 PRE_IO
13703 READ_WORD_F(adr, res)
13704 flag_C = 0;
13705 flag_V = 0;
13706 flag_NotZ = res;
13707 flag_N = res >> 8;
13708 DREGu16((Opcode >> 9) & 7) = res;
13709 POST_IO
13710RET(10)
13711}
13712
13713// MOVEW
13714OPCODE(0x30A7)
13715{
13716 u32 adr, res;
13717 u32 src, dst;
13718
13719 adr = AREG(7) - 2;
13720 AREG(7) = adr;
13721 PRE_IO
13722 READ_WORD_F(adr, res)
13723 flag_C = 0;
13724 flag_V = 0;
13725 flag_NotZ = res;
13726 flag_N = res >> 8;
13727 adr = AREG((Opcode >> 9) & 7);
13728 WRITE_WORD_F(adr, res)
13729 POST_IO
13730RET(14)
13731}
13732
13733// MOVEW
13734OPCODE(0x30E7)
13735{
13736 u32 adr, res;
13737 u32 src, dst;
13738
13739 adr = AREG(7) - 2;
13740 AREG(7) = adr;
13741 PRE_IO
13742 READ_WORD_F(adr, res)
13743 flag_C = 0;
13744 flag_V = 0;
13745 flag_NotZ = res;
13746 flag_N = res >> 8;
13747 adr = AREG((Opcode >> 9) & 7);
13748 AREG((Opcode >> 9) & 7) += 2;
13749 WRITE_WORD_F(adr, res)
13750 POST_IO
13751RET(14)
13752}
13753
13754// MOVEW
13755OPCODE(0x3127)
13756{
13757 u32 adr, res;
13758 u32 src, dst;
13759
13760 adr = AREG(7) - 2;
13761 AREG(7) = adr;
13762 PRE_IO
13763 READ_WORD_F(adr, res)
13764 flag_C = 0;
13765 flag_V = 0;
13766 flag_NotZ = res;
13767 flag_N = res >> 8;
13768 adr = AREG((Opcode >> 9) & 7) - 2;
13769 AREG((Opcode >> 9) & 7) = adr;
13770 WRITE_WORD_F(adr, res)
13771 POST_IO
13772RET(14)
13773}
13774
13775// MOVEW
13776OPCODE(0x3167)
13777{
13778 u32 adr, res;
13779 u32 src, dst;
13780
13781 adr = AREG(7) - 2;
13782 AREG(7) = adr;
13783 PRE_IO
13784 READ_WORD_F(adr, res)
13785 flag_C = 0;
13786 flag_V = 0;
13787 flag_NotZ = res;
13788 flag_N = res >> 8;
13789 FETCH_SWORD(adr);
13790 adr += AREG((Opcode >> 9) & 7);
13791 WRITE_WORD_F(adr, res)
13792 POST_IO
13793RET(18)
13794}
13795
13796// MOVEW
13797OPCODE(0x31A7)
13798{
13799 u32 adr, res;
13800 u32 src, dst;
13801
13802 adr = AREG(7) - 2;
13803 AREG(7) = adr;
13804 PRE_IO
13805 READ_WORD_F(adr, res)
13806 flag_C = 0;
13807 flag_V = 0;
13808 flag_NotZ = res;
13809 flag_N = res >> 8;
13810 adr = AREG((Opcode >> 9) & 7);
13811 DECODE_EXT_WORD
13812 WRITE_WORD_F(adr, res)
13813 POST_IO
13814RET(20)
13815}
13816
13817// MOVEW
13818OPCODE(0x31E7)
13819{
13820 u32 adr, res;
13821 u32 src, dst;
13822
13823 adr = AREG(7) - 2;
13824 AREG(7) = adr;
13825 PRE_IO
13826 READ_WORD_F(adr, res)
13827 flag_C = 0;
13828 flag_V = 0;
13829 flag_NotZ = res;
13830 flag_N = res >> 8;
13831 FETCH_SWORD(adr);
13832 WRITE_WORD_F(adr, res)
13833 POST_IO
13834RET(18)
13835}
13836
13837// MOVEW
13838OPCODE(0x33E7)
13839{
13840 u32 adr, res;
13841 u32 src, dst;
13842
13843 adr = AREG(7) - 2;
13844 AREG(7) = adr;
13845 PRE_IO
13846 READ_WORD_F(adr, res)
13847 flag_C = 0;
13848 flag_V = 0;
13849 flag_NotZ = res;
13850 flag_N = res >> 8;
13851 FETCH_LONG(adr);
13852 WRITE_WORD_F(adr, res)
13853 POST_IO
13854RET(22)
13855}
13856
13857// MOVEW
13858OPCODE(0x3EE7)
13859{
13860 u32 adr, res;
13861 u32 src, dst;
13862
13863 adr = AREG(7) - 2;
13864 AREG(7) = adr;
13865 PRE_IO
13866 READ_WORD_F(adr, res)
13867 flag_C = 0;
13868 flag_V = 0;
13869 flag_NotZ = res;
13870 flag_N = res >> 8;
13871 adr = AREG(7);
13872 AREG(7) += 2;
13873 WRITE_WORD_F(adr, res)
13874 POST_IO
13875RET(14)
13876}
13877
13878// MOVEW
13879OPCODE(0x3F27)
13880{
13881 u32 adr, res;
13882 u32 src, dst;
13883
13884 adr = AREG(7) - 2;
13885 AREG(7) = adr;
13886 PRE_IO
13887 READ_WORD_F(adr, res)
13888 flag_C = 0;
13889 flag_V = 0;
13890 flag_NotZ = res;
13891 flag_N = res >> 8;
13892 adr = AREG(7) - 2;
13893 AREG(7) = adr;
13894 WRITE_WORD_F(adr, res)
13895 POST_IO
13896RET(14)
13897}
13898
13899// MOVEAW
13900OPCODE(0x3040)
13901{
13902 u32 adr, res;
13903 u32 src, dst;
13904
13905 res = (s32)DREGs16((Opcode >> 0) & 7);
13906 AREG((Opcode >> 9) & 7) = res;
13907RET(4)
13908}
13909
13910// MOVEAW
13911OPCODE(0x3048)
13912{
13913 u32 adr, res;
13914 u32 src, dst;
13915
13916 res = (s32)AREGs16((Opcode >> 0) & 7);
13917 AREG((Opcode >> 9) & 7) = res;
13918RET(4)
13919}
13920
13921// MOVEAW
13922OPCODE(0x3050)
13923{
13924 u32 adr, res;
13925 u32 src, dst;
13926
13927 adr = AREG((Opcode >> 0) & 7);
13928 PRE_IO
13929 READSX_WORD_F(adr, res)
13930 AREG((Opcode >> 9) & 7) = res;
13931 POST_IO
13932RET(8)
13933}
13934
13935// MOVEAW
13936OPCODE(0x3058)
13937{
13938 u32 adr, res;
13939 u32 src, dst;
13940
13941 adr = AREG((Opcode >> 0) & 7);
13942 AREG((Opcode >> 0) & 7) += 2;
13943 PRE_IO
13944 READSX_WORD_F(adr, res)
13945 AREG((Opcode >> 9) & 7) = res;
13946 POST_IO
13947RET(8)
13948}
13949
13950// MOVEAW
13951OPCODE(0x3060)
13952{
13953 u32 adr, res;
13954 u32 src, dst;
13955
13956 adr = AREG((Opcode >> 0) & 7) - 2;
13957 AREG((Opcode >> 0) & 7) = adr;
13958 PRE_IO
13959 READSX_WORD_F(adr, res)
13960 AREG((Opcode >> 9) & 7) = res;
13961 POST_IO
13962RET(10)
13963}
13964
13965// MOVEAW
13966OPCODE(0x3068)
13967{
13968 u32 adr, res;
13969 u32 src, dst;
13970
13971 FETCH_SWORD(adr);
13972 adr += AREG((Opcode >> 0) & 7);
13973 PRE_IO
13974 READSX_WORD_F(adr, res)
13975 AREG((Opcode >> 9) & 7) = res;
13976 POST_IO
13977RET(12)
13978}
13979
13980// MOVEAW
13981OPCODE(0x3070)
13982{
13983 u32 adr, res;
13984 u32 src, dst;
13985
13986 adr = AREG((Opcode >> 0) & 7);
13987 DECODE_EXT_WORD
13988 PRE_IO
13989 READSX_WORD_F(adr, res)
13990 AREG((Opcode >> 9) & 7) = res;
13991 POST_IO
13992RET(14)
13993}
13994
13995// MOVEAW
13996OPCODE(0x3078)
13997{
13998 u32 adr, res;
13999 u32 src, dst;
14000
14001 FETCH_SWORD(adr);
14002 PRE_IO
14003 READSX_WORD_F(adr, res)
14004 AREG((Opcode >> 9) & 7) = res;
14005 POST_IO
14006RET(12)
14007}
14008
14009// MOVEAW
14010OPCODE(0x3079)
14011{
14012 u32 adr, res;
14013 u32 src, dst;
14014
14015 FETCH_LONG(adr);
14016 PRE_IO
14017 READSX_WORD_F(adr, res)
14018 AREG((Opcode >> 9) & 7) = res;
14019 POST_IO
14020RET(16)
14021}
14022
14023// MOVEAW
14024OPCODE(0x307A)
14025{
14026 u32 adr, res;
14027 u32 src, dst;
14028
14029 adr = GET_SWORD + GET_PC;
14030 PC++;
14031 PRE_IO
14032 READSX_WORD_F(adr, res)
14033 AREG((Opcode >> 9) & 7) = res;
14034 POST_IO
14035RET(12)
14036}
14037
14038// MOVEAW
14039OPCODE(0x307B)
14040{
14041 u32 adr, res;
14042 u32 src, dst;
14043
14044 adr = GET_PC;
14045 DECODE_EXT_WORD
14046 PRE_IO
14047 READSX_WORD_F(adr, res)
14048 AREG((Opcode >> 9) & 7) = res;
14049 POST_IO
14050RET(14)
14051}
14052
14053// MOVEAW
14054OPCODE(0x307C)
14055{
14056 u32 adr, res;
14057 u32 src, dst;
14058
14059 FETCH_SWORD(res);
14060 AREG((Opcode >> 9) & 7) = res;
14061RET(8)
14062}
14063
14064// MOVEAW
14065OPCODE(0x305F)
14066{
14067 u32 adr, res;
14068 u32 src, dst;
14069
14070 adr = AREG(7);
14071 AREG(7) += 2;
14072 PRE_IO
14073 READSX_WORD_F(adr, res)
14074 AREG((Opcode >> 9) & 7) = res;
14075 POST_IO
14076RET(8)
14077}
14078
14079// MOVEAW
14080OPCODE(0x3067)
14081{
14082 u32 adr, res;
14083 u32 src, dst;
14084
14085 adr = AREG(7) - 2;
14086 AREG(7) = adr;
14087 PRE_IO
14088 READSX_WORD_F(adr, res)
14089 AREG((Opcode >> 9) & 7) = res;
14090 POST_IO
14091RET(10)
14092}
14093
14094// NEGX
14095OPCODE(0x4000)
14096{
14097 u32 adr, res;
14098 u32 src, dst;
14099
14100 src = DREGu8((Opcode >> 0) & 7);
14101 res = -src - ((flag_X >> 8) & 1);
14102 flag_V = res & src;
14103 flag_N = flag_X = flag_C = res;
14104 flag_NotZ |= res & 0xFF;
14105 DREGu8((Opcode >> 0) & 7) = res;
14106RET(4)
14107}
14108
14109// NEGX
14110OPCODE(0x4010)
14111{
14112 u32 adr, res;
14113 u32 src, dst;
14114
14115 adr = AREG((Opcode >> 0) & 7);
14116 PRE_IO
14117 READ_BYTE_F(adr, src)
14118 res = -src - ((flag_X >> 8) & 1);
14119 flag_V = res & src;
14120 flag_N = flag_X = flag_C = res;
14121 flag_NotZ |= res & 0xFF;
14122 WRITE_BYTE_F(adr, res)
14123 POST_IO
14124RET(12)
14125}
14126
14127// NEGX
14128OPCODE(0x4018)
14129{
14130 u32 adr, res;
14131 u32 src, dst;
14132
14133 adr = AREG((Opcode >> 0) & 7);
14134 AREG((Opcode >> 0) & 7) += 1;
14135 PRE_IO
14136 READ_BYTE_F(adr, src)
14137 res = -src - ((flag_X >> 8) & 1);
14138 flag_V = res & src;
14139 flag_N = flag_X = flag_C = res;
14140 flag_NotZ |= res & 0xFF;
14141 WRITE_BYTE_F(adr, res)
14142 POST_IO
14143RET(12)
14144}
14145
14146// NEGX
14147OPCODE(0x4020)
14148{
14149 u32 adr, res;
14150 u32 src, dst;
14151
14152 adr = AREG((Opcode >> 0) & 7) - 1;
14153 AREG((Opcode >> 0) & 7) = adr;
14154 PRE_IO
14155 READ_BYTE_F(adr, src)
14156 res = -src - ((flag_X >> 8) & 1);
14157 flag_V = res & src;
14158 flag_N = flag_X = flag_C = res;
14159 flag_NotZ |= res & 0xFF;
14160 WRITE_BYTE_F(adr, res)
14161 POST_IO
14162RET(14)
14163}
14164
14165// NEGX
14166OPCODE(0x4028)
14167{
14168 u32 adr, res;
14169 u32 src, dst;
14170
14171 FETCH_SWORD(adr);
14172 adr += AREG((Opcode >> 0) & 7);
14173 PRE_IO
14174 READ_BYTE_F(adr, src)
14175 res = -src - ((flag_X >> 8) & 1);
14176 flag_V = res & src;
14177 flag_N = flag_X = flag_C = res;
14178 flag_NotZ |= res & 0xFF;
14179 WRITE_BYTE_F(adr, res)
14180 POST_IO
14181RET(16)
14182}
14183
14184// NEGX
14185OPCODE(0x4030)
14186{
14187 u32 adr, res;
14188 u32 src, dst;
14189
14190 adr = AREG((Opcode >> 0) & 7);
14191 DECODE_EXT_WORD
14192 PRE_IO
14193 READ_BYTE_F(adr, src)
14194 res = -src - ((flag_X >> 8) & 1);
14195 flag_V = res & src;
14196 flag_N = flag_X = flag_C = res;
14197 flag_NotZ |= res & 0xFF;
14198 WRITE_BYTE_F(adr, res)
14199 POST_IO
14200RET(18)
14201}
14202
14203// NEGX
14204OPCODE(0x4038)
14205{
14206 u32 adr, res;
14207 u32 src, dst;
14208
14209 FETCH_SWORD(adr);
14210 PRE_IO
14211 READ_BYTE_F(adr, src)
14212 res = -src - ((flag_X >> 8) & 1);
14213 flag_V = res & src;
14214 flag_N = flag_X = flag_C = res;
14215 flag_NotZ |= res & 0xFF;
14216 WRITE_BYTE_F(adr, res)
14217 POST_IO
14218RET(16)
14219}
14220
14221// NEGX
14222OPCODE(0x4039)
14223{
14224 u32 adr, res;
14225 u32 src, dst;
14226
14227 FETCH_LONG(adr);
14228 PRE_IO
14229 READ_BYTE_F(adr, src)
14230 res = -src - ((flag_X >> 8) & 1);
14231 flag_V = res & src;
14232 flag_N = flag_X = flag_C = res;
14233 flag_NotZ |= res & 0xFF;
14234 WRITE_BYTE_F(adr, res)
14235 POST_IO
14236RET(20)
14237}
14238
14239// NEGX
14240OPCODE(0x401F)
14241{
14242 u32 adr, res;
14243 u32 src, dst;
14244
14245 adr = AREG(7);
14246 AREG(7) += 2;
14247 PRE_IO
14248 READ_BYTE_F(adr, src)
14249 res = -src - ((flag_X >> 8) & 1);
14250 flag_V = res & src;
14251 flag_N = flag_X = flag_C = res;
14252 flag_NotZ |= res & 0xFF;
14253 WRITE_BYTE_F(adr, res)
14254 POST_IO
14255RET(12)
14256}
14257
14258// NEGX
14259OPCODE(0x4027)
14260{
14261 u32 adr, res;
14262 u32 src, dst;
14263
14264 adr = AREG(7) - 2;
14265 AREG(7) = adr;
14266 PRE_IO
14267 READ_BYTE_F(adr, src)
14268 res = -src - ((flag_X >> 8) & 1);
14269 flag_V = res & src;
14270 flag_N = flag_X = flag_C = res;
14271 flag_NotZ |= res & 0xFF;
14272 WRITE_BYTE_F(adr, res)
14273 POST_IO
14274RET(14)
14275}
14276
14277// NEGX
14278OPCODE(0x4040)
14279{
14280 u32 adr, res;
14281 u32 src, dst;
14282
14283 src = DREGu16((Opcode >> 0) & 7);
14284 res = -src - ((flag_X >> 8) & 1);
14285 flag_V = (res & src) >> 8;
14286 flag_N = flag_X = flag_C = res >> 8;
14287 flag_NotZ |= res & 0xFFFF;
14288 DREGu16((Opcode >> 0) & 7) = res;
14289RET(4)
14290}
14291
14292// NEGX
14293OPCODE(0x4050)
14294{
14295 u32 adr, res;
14296 u32 src, dst;
14297
14298 adr = AREG((Opcode >> 0) & 7);
14299 PRE_IO
14300 READ_WORD_F(adr, src)
14301 res = -src - ((flag_X >> 8) & 1);
14302 flag_V = (res & src) >> 8;
14303 flag_N = flag_X = flag_C = res >> 8;
14304 flag_NotZ |= res & 0xFFFF;
14305 WRITE_WORD_F(adr, res)
14306 POST_IO
14307RET(12)
14308}
14309
14310// NEGX
14311OPCODE(0x4058)
14312{
14313 u32 adr, res;
14314 u32 src, dst;
14315
14316 adr = AREG((Opcode >> 0) & 7);
14317 AREG((Opcode >> 0) & 7) += 2;
14318 PRE_IO
14319 READ_WORD_F(adr, src)
14320 res = -src - ((flag_X >> 8) & 1);
14321 flag_V = (res & src) >> 8;
14322 flag_N = flag_X = flag_C = res >> 8;
14323 flag_NotZ |= res & 0xFFFF;
14324 WRITE_WORD_F(adr, res)
14325 POST_IO
14326RET(12)
14327}
14328
14329// NEGX
14330OPCODE(0x4060)
14331{
14332 u32 adr, res;
14333 u32 src, dst;
14334
14335 adr = AREG((Opcode >> 0) & 7) - 2;
14336 AREG((Opcode >> 0) & 7) = adr;
14337 PRE_IO
14338 READ_WORD_F(adr, src)
14339 res = -src - ((flag_X >> 8) & 1);
14340 flag_V = (res & src) >> 8;
14341 flag_N = flag_X = flag_C = res >> 8;
14342 flag_NotZ |= res & 0xFFFF;
14343 WRITE_WORD_F(adr, res)
14344 POST_IO
14345RET(14)
14346}
14347
14348// NEGX
14349OPCODE(0x4068)
14350{
14351 u32 adr, res;
14352 u32 src, dst;
14353
14354 FETCH_SWORD(adr);
14355 adr += AREG((Opcode >> 0) & 7);
14356 PRE_IO
14357 READ_WORD_F(adr, src)
14358 res = -src - ((flag_X >> 8) & 1);
14359 flag_V = (res & src) >> 8;
14360 flag_N = flag_X = flag_C = res >> 8;
14361 flag_NotZ |= res & 0xFFFF;
14362 WRITE_WORD_F(adr, res)
14363 POST_IO
14364RET(16)
14365}
14366
14367// NEGX
14368OPCODE(0x4070)
14369{
14370 u32 adr, res;
14371 u32 src, dst;
14372
14373 adr = AREG((Opcode >> 0) & 7);
14374 DECODE_EXT_WORD
14375 PRE_IO
14376 READ_WORD_F(adr, src)
14377 res = -src - ((flag_X >> 8) & 1);
14378 flag_V = (res & src) >> 8;
14379 flag_N = flag_X = flag_C = res >> 8;
14380 flag_NotZ |= res & 0xFFFF;
14381 WRITE_WORD_F(adr, res)
14382 POST_IO
14383RET(18)
14384}
14385
14386// NEGX
14387OPCODE(0x4078)
14388{
14389 u32 adr, res;
14390 u32 src, dst;
14391
14392 FETCH_SWORD(adr);
14393 PRE_IO
14394 READ_WORD_F(adr, src)
14395 res = -src - ((flag_X >> 8) & 1);
14396 flag_V = (res & src) >> 8;
14397 flag_N = flag_X = flag_C = res >> 8;
14398 flag_NotZ |= res & 0xFFFF;
14399 WRITE_WORD_F(adr, res)
14400 POST_IO
14401RET(16)
14402}
14403
14404// NEGX
14405OPCODE(0x4079)
14406{
14407 u32 adr, res;
14408 u32 src, dst;
14409
14410 FETCH_LONG(adr);
14411 PRE_IO
14412 READ_WORD_F(adr, src)
14413 res = -src - ((flag_X >> 8) & 1);
14414 flag_V = (res & src) >> 8;
14415 flag_N = flag_X = flag_C = res >> 8;
14416 flag_NotZ |= res & 0xFFFF;
14417 WRITE_WORD_F(adr, res)
14418 POST_IO
14419RET(20)
14420}
14421
14422// NEGX
14423OPCODE(0x405F)
14424{
14425 u32 adr, res;
14426 u32 src, dst;
14427
14428 adr = AREG(7);
14429 AREG(7) += 2;
14430 PRE_IO
14431 READ_WORD_F(adr, src)
14432 res = -src - ((flag_X >> 8) & 1);
14433 flag_V = (res & src) >> 8;
14434 flag_N = flag_X = flag_C = res >> 8;
14435 flag_NotZ |= res & 0xFFFF;
14436 WRITE_WORD_F(adr, res)
14437 POST_IO
14438RET(12)
14439}
14440
14441// NEGX
14442OPCODE(0x4067)
14443{
14444 u32 adr, res;
14445 u32 src, dst;
14446
14447 adr = AREG(7) - 2;
14448 AREG(7) = adr;
14449 PRE_IO
14450 READ_WORD_F(adr, src)
14451 res = -src - ((flag_X >> 8) & 1);
14452 flag_V = (res & src) >> 8;
14453 flag_N = flag_X = flag_C = res >> 8;
14454 flag_NotZ |= res & 0xFFFF;
14455 WRITE_WORD_F(adr, res)
14456 POST_IO
14457RET(14)
14458}
14459
14460// NEGX
14461OPCODE(0x4080)
14462{
14463 u32 adr, res;
14464 u32 src, dst;
14465
14466 src = DREGu32((Opcode >> 0) & 7);
14467 res = -src - ((flag_X >> 8) & 1);
14468 flag_NotZ |= res;
14469 flag_V = (res & src) >> 24;
14470flag_X = flag_C = (res?1:0)<<8;
14471// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14472 flag_N = res >> 24;
14473 DREGu32((Opcode >> 0) & 7) = res;
14474RET(6)
14475}
14476
14477// NEGX
14478OPCODE(0x4090)
14479{
14480 u32 adr, res;
14481 u32 src, dst;
14482
14483 adr = AREG((Opcode >> 0) & 7);
14484 PRE_IO
14485 READ_LONG_F(adr, src)
14486 res = -src - ((flag_X >> 8) & 1);
14487 flag_NotZ |= res;
14488 flag_V = (res & src) >> 24;
14489flag_X = flag_C = (res?1:0)<<8;
14490// flag_X = flag_C = ((src & res & 1) | (src >> 1) | (res >> 1)) >> 23;
14491 flag_N = res >> 24;
14492 WRITE_LONG_F(adr, res)
14493 POST_IO
14494RET(20)
14495}
14496
14497// NEGX
14498OPCODE(0x4098)
14499{
14500 u32 adr, res;
14501 u32 src, dst;
14502
14503 adr = AREG((Opcode >> 0) & 7);
14504 AREG((Opcode >> 0) & 7) += 4;
14505 PRE_IO
14506 READ_LONG_F(adr, src)
14507 res = -src - ((flag_X >> 8) & 1);
14508 flag_NotZ |= res;
14509 flag_V = (res & src) >> 24;
14510flag_X = flag_C = (res?1:0)<<8;
14511// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14512 flag_N = res >> 24;
14513 WRITE_LONG_F(adr, res)
14514 POST_IO
14515RET(20)
14516}
14517
14518// NEGX
14519OPCODE(0x40A0)
14520{
14521 u32 adr, res;
14522 u32 src, dst;
14523
14524 adr = AREG((Opcode >> 0) & 7) - 4;
14525 AREG((Opcode >> 0) & 7) = adr;
14526 PRE_IO
14527 READ_LONG_F(adr, src)
14528 res = -src - ((flag_X >> 8) & 1);
14529 flag_NotZ |= res;
14530 flag_V = (res & src) >> 24;
14531flag_X = flag_C = (res?1:0)<<8;
14532// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14533 flag_N = res >> 24;
14534 WRITE_LONG_F(adr, res)
14535 POST_IO
14536RET(22)
14537}
14538
14539// NEGX
14540OPCODE(0x40A8)
14541{
14542 u32 adr, res;
14543 u32 src, dst;
14544
14545 FETCH_SWORD(adr);
14546 adr += AREG((Opcode >> 0) & 7);
14547 PRE_IO
14548 READ_LONG_F(adr, src)
14549 res = -src - ((flag_X >> 8) & 1);
14550 flag_NotZ |= res;
14551 flag_V = (res & src) >> 24;
14552flag_X = flag_C = (res?1:0)<<8;
14553// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14554 flag_N = res >> 24;
14555 WRITE_LONG_F(adr, res)
14556 POST_IO
14557RET(24)
14558}
14559
14560// NEGX
14561OPCODE(0x40B0)
14562{
14563 u32 adr, res;
14564 u32 src, dst;
14565
14566 adr = AREG((Opcode >> 0) & 7);
14567 DECODE_EXT_WORD
14568 PRE_IO
14569 READ_LONG_F(adr, src)
14570 res = -src - ((flag_X >> 8) & 1);
14571 flag_NotZ |= res;
14572 flag_V = (res & src) >> 24;
14573flag_X = flag_C = (res?1:0)<<8;
14574// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14575 flag_N = res >> 24;
14576 WRITE_LONG_F(adr, res)
14577 POST_IO
14578RET(26)
14579}
14580
14581// NEGX
14582OPCODE(0x40B8)
14583{
14584 u32 adr, res;
14585 u32 src, dst;
14586
14587 FETCH_SWORD(adr);
14588 PRE_IO
14589 READ_LONG_F(adr, src)
14590 res = -src - ((flag_X >> 8) & 1);
14591 flag_NotZ |= res;
14592 flag_V = (res & src) >> 24;
14593flag_X = flag_C = (res?1:0)<<8;
14594// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14595 flag_N = res >> 24;
14596 WRITE_LONG_F(adr, res)
14597 POST_IO
14598RET(24)
14599}
14600
14601// NEGX
14602OPCODE(0x40B9)
14603{
14604 u32 adr, res;
14605 u32 src, dst;
14606
14607 FETCH_LONG(adr);
14608 PRE_IO
14609 READ_LONG_F(adr, src)
14610 res = -src - ((flag_X >> 8) & 1);
14611 flag_NotZ |= res;
14612 flag_V = (res & src) >> 24;
14613flag_X = flag_C = (res?1:0)<<8;
14614// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14615 flag_N = res >> 24;
14616 WRITE_LONG_F(adr, res)
14617 POST_IO
14618RET(28)
14619}
14620
14621// NEGX
14622OPCODE(0x409F)
14623{
14624 u32 adr, res;
14625 u32 src, dst;
14626
14627 adr = AREG(7);
14628 AREG(7) += 4;
14629 PRE_IO
14630 READ_LONG_F(adr, src)
14631 res = -src - ((flag_X >> 8) & 1);
14632 flag_NotZ |= res;
14633 flag_V = (res & src) >> 24;
14634flag_X = flag_C = (res?1:0)<<8;
14635// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14636 flag_N = res >> 24;
14637 WRITE_LONG_F(adr, res)
14638 POST_IO
14639RET(20)
14640}
14641
14642// NEGX
14643OPCODE(0x40A7)
14644{
14645 u32 adr, res;
14646 u32 src, dst;
14647
14648 adr = AREG(7) - 4;
14649 AREG(7) = adr;
14650 PRE_IO
14651 READ_LONG_F(adr, src)
14652 res = -src - ((flag_X >> 8) & 1);
14653 flag_NotZ |= res;
14654 flag_V = (res & src) >> 24;
14655flag_X = flag_C = (res?1:0)<<8;
14656// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14657 flag_N = res >> 24;
14658 WRITE_LONG_F(adr, res)
14659 POST_IO
14660RET(22)
14661}
14662
14663// CLR
14664OPCODE(0x4200)
14665{
14666 u32 adr, res;
14667 u32 src, dst;
14668
14669 res = 0;
14670 flag_N = flag_NotZ = flag_V = flag_C = 0;
14671 DREGu8((Opcode >> 0) & 7) = res;
14672RET(4)
14673}
14674
14675// CLR
14676OPCODE(0x4210)
14677{
14678 u32 adr, res;
14679 u32 src, dst;
14680
14681 adr = AREG((Opcode >> 0) & 7);
14682 res = 0;
14683 flag_N = flag_NotZ = flag_V = flag_C = 0;
14684 PRE_IO
14685 WRITE_BYTE_F(adr, res)
14686 POST_IO
14687RET(12)
14688}
14689
14690// CLR
14691OPCODE(0x4218)
14692{
14693 u32 adr, res;
14694 u32 src, dst;
14695
14696 adr = AREG((Opcode >> 0) & 7);
14697 AREG((Opcode >> 0) & 7) += 1;
14698 res = 0;
14699 flag_N = flag_NotZ = flag_V = flag_C = 0;
14700 PRE_IO
14701 WRITE_BYTE_F(adr, res)
14702 POST_IO
14703RET(12)
14704}
14705
14706// CLR
14707OPCODE(0x4220)
14708{
14709 u32 adr, res;
14710 u32 src, dst;
14711
14712 adr = AREG((Opcode >> 0) & 7) - 1;
14713 AREG((Opcode >> 0) & 7) = adr;
14714 res = 0;
14715 flag_N = flag_NotZ = flag_V = flag_C = 0;
14716 PRE_IO
14717 WRITE_BYTE_F(adr, res)
14718 POST_IO
14719RET(14)
14720}
14721
14722// CLR
14723OPCODE(0x4228)
14724{
14725 u32 adr, res;
14726 u32 src, dst;
14727
14728 FETCH_SWORD(adr);
14729 adr += AREG((Opcode >> 0) & 7);
14730 res = 0;
14731 flag_N = flag_NotZ = flag_V = flag_C = 0;
14732 PRE_IO
14733 WRITE_BYTE_F(adr, res)
14734 POST_IO
14735RET(16)
14736}
14737
14738// CLR
14739OPCODE(0x4230)
14740{
14741 u32 adr, res;
14742 u32 src, dst;
14743
14744 adr = AREG((Opcode >> 0) & 7);
14745 DECODE_EXT_WORD
14746 res = 0;
14747 flag_N = flag_NotZ = flag_V = flag_C = 0;
14748 PRE_IO
14749 WRITE_BYTE_F(adr, res)
14750 POST_IO
14751RET(18)
14752}
14753
14754// CLR
14755OPCODE(0x4238)
14756{
14757 u32 adr, res;
14758 u32 src, dst;
14759
14760 FETCH_SWORD(adr);
14761 res = 0;
14762 flag_N = flag_NotZ = flag_V = flag_C = 0;
14763 PRE_IO
14764 WRITE_BYTE_F(adr, res)
14765 POST_IO
14766RET(16)
14767}
14768
14769// CLR
14770OPCODE(0x4239)
14771{
14772 u32 adr, res;
14773 u32 src, dst;
14774
14775 FETCH_LONG(adr);
14776 res = 0;
14777 flag_N = flag_NotZ = flag_V = flag_C = 0;
14778 PRE_IO
14779 WRITE_BYTE_F(adr, res)
14780 POST_IO
14781RET(20)
14782}
14783
14784// CLR
14785OPCODE(0x421F)
14786{
14787 u32 adr, res;
14788 u32 src, dst;
14789
14790 adr = AREG(7);
14791 AREG(7) += 2;
14792 res = 0;
14793 flag_N = flag_NotZ = flag_V = flag_C = 0;
14794 PRE_IO
14795 WRITE_BYTE_F(adr, res)
14796 POST_IO
14797RET(12)
14798}
14799
14800// CLR
14801OPCODE(0x4227)
14802{
14803 u32 adr, res;
14804 u32 src, dst;
14805
14806 adr = AREG(7) - 2;
14807 AREG(7) = adr;
14808 res = 0;
14809 flag_N = flag_NotZ = flag_V = flag_C = 0;
14810 PRE_IO
14811 WRITE_BYTE_F(adr, res)
14812 POST_IO
14813RET(14)
14814}
14815
14816// CLR
14817OPCODE(0x4240)
14818{
14819 u32 adr, res;
14820 u32 src, dst;
14821
14822 res = 0;
14823 flag_N = flag_NotZ = flag_V = flag_C = 0;
14824 DREGu16((Opcode >> 0) & 7) = res;
14825RET(4)
14826}
14827
14828// CLR
14829OPCODE(0x4250)
14830{
14831 u32 adr, res;
14832 u32 src, dst;
14833
14834 adr = AREG((Opcode >> 0) & 7);
14835 res = 0;
14836 flag_N = flag_NotZ = flag_V = flag_C = 0;
14837 PRE_IO
14838 WRITE_WORD_F(adr, res)
14839 POST_IO
14840RET(12)
14841}
14842
14843// CLR
14844OPCODE(0x4258)
14845{
14846 u32 adr, res;
14847 u32 src, dst;
14848
14849 adr = AREG((Opcode >> 0) & 7);
14850 AREG((Opcode >> 0) & 7) += 2;
14851 res = 0;
14852 flag_N = flag_NotZ = flag_V = flag_C = 0;
14853 PRE_IO
14854 WRITE_WORD_F(adr, res)
14855 POST_IO
14856RET(12)
14857}
14858
14859// CLR
14860OPCODE(0x4260)
14861{
14862 u32 adr, res;
14863 u32 src, dst;
14864
14865 adr = AREG((Opcode >> 0) & 7) - 2;
14866 AREG((Opcode >> 0) & 7) = adr;
14867 res = 0;
14868 flag_N = flag_NotZ = flag_V = flag_C = 0;
14869 PRE_IO
14870 WRITE_WORD_F(adr, res)
14871 POST_IO
14872RET(14)
14873}
14874
14875// CLR
14876OPCODE(0x4268)
14877{
14878 u32 adr, res;
14879 u32 src, dst;
14880
14881 FETCH_SWORD(adr);
14882 adr += AREG((Opcode >> 0) & 7);
14883 res = 0;
14884 flag_N = flag_NotZ = flag_V = flag_C = 0;
14885 PRE_IO
14886 WRITE_WORD_F(adr, res)
14887 POST_IO
14888RET(16)
14889}
14890
14891// CLR
14892OPCODE(0x4270)
14893{
14894 u32 adr, res;
14895 u32 src, dst;
14896
14897 adr = AREG((Opcode >> 0) & 7);
14898 DECODE_EXT_WORD
14899 res = 0;
14900 flag_N = flag_NotZ = flag_V = flag_C = 0;
14901 PRE_IO
14902 WRITE_WORD_F(adr, res)
14903 POST_IO
14904RET(18)
14905}
14906
14907// CLR
14908OPCODE(0x4278)
14909{
14910 u32 adr, res;
14911 u32 src, dst;
14912
14913 FETCH_SWORD(adr);
14914 res = 0;
14915 flag_N = flag_NotZ = flag_V = flag_C = 0;
14916 PRE_IO
14917 WRITE_WORD_F(adr, res)
14918 POST_IO
14919RET(16)
14920}
14921
14922// CLR
14923OPCODE(0x4279)
14924{
14925 u32 adr, res;
14926 u32 src, dst;
14927
14928 FETCH_LONG(adr);
14929 res = 0;
14930 flag_N = flag_NotZ = flag_V = flag_C = 0;
14931 PRE_IO
14932 WRITE_WORD_F(adr, res)
14933 POST_IO
14934RET(20)
14935}
14936
14937// CLR
14938OPCODE(0x425F)
14939{
14940 u32 adr, res;
14941 u32 src, dst;
14942
14943 adr = AREG(7);
14944 AREG(7) += 2;
14945 res = 0;
14946 flag_N = flag_NotZ = flag_V = flag_C = 0;
14947 PRE_IO
14948 WRITE_WORD_F(adr, res)
14949 POST_IO
14950RET(12)
14951}
14952
14953// CLR
14954OPCODE(0x4267)
14955{
14956 u32 adr, res;
14957 u32 src, dst;
14958
14959 adr = AREG(7) - 2;
14960 AREG(7) = adr;
14961 res = 0;
14962 flag_N = flag_NotZ = flag_V = flag_C = 0;
14963 PRE_IO
14964 WRITE_WORD_F(adr, res)
14965 POST_IO
14966RET(14)
14967}
14968
14969// CLR
14970OPCODE(0x4280)
14971{
14972 u32 adr, res;
14973 u32 src, dst;
14974
14975 res = 0;
14976 flag_N = flag_NotZ = flag_V = flag_C = 0;
14977 DREGu32((Opcode >> 0) & 7) = res;
14978RET(6)
14979}
14980
14981// CLR
14982OPCODE(0x4290)
14983{
14984 u32 adr, res;
14985 u32 src, dst;
14986
14987 adr = AREG((Opcode >> 0) & 7);
14988 res = 0;
14989 flag_N = flag_NotZ = flag_V = flag_C = 0;
14990 PRE_IO
14991 WRITE_LONG_F(adr, res)
14992 POST_IO
14993RET(20)
14994}
14995
14996// CLR
14997OPCODE(0x4298)
14998{
14999 u32 adr, res;
15000 u32 src, dst;
15001
15002 adr = AREG((Opcode >> 0) & 7);
15003 AREG((Opcode >> 0) & 7) += 4;
15004 res = 0;
15005 flag_N = flag_NotZ = flag_V = flag_C = 0;
15006 PRE_IO
15007 WRITE_LONG_F(adr, res)
15008 POST_IO
15009RET(20)
15010}
15011
15012// CLR
15013OPCODE(0x42A0)
15014{
15015 u32 adr, res;
15016 u32 src, dst;
15017
15018 adr = AREG((Opcode >> 0) & 7) - 4;
15019 AREG((Opcode >> 0) & 7) = adr;
15020 res = 0;
15021 flag_N = flag_NotZ = flag_V = flag_C = 0;
15022 PRE_IO
15023 WRITE_LONG_F(adr, res)
15024 POST_IO
15025RET(22)
15026}
15027
15028// CLR
15029OPCODE(0x42A8)
15030{
15031 u32 adr, res;
15032 u32 src, dst;
15033
15034 FETCH_SWORD(adr);
15035 adr += AREG((Opcode >> 0) & 7);
15036 res = 0;
15037 flag_N = flag_NotZ = flag_V = flag_C = 0;
15038 PRE_IO
15039 WRITE_LONG_F(adr, res)
15040 POST_IO
15041RET(24)
15042}
15043
15044// CLR
15045OPCODE(0x42B0)
15046{
15047 u32 adr, res;
15048 u32 src, dst;
15049
15050 adr = AREG((Opcode >> 0) & 7);
15051 DECODE_EXT_WORD
15052 res = 0;
15053 flag_N = flag_NotZ = flag_V = flag_C = 0;
15054 PRE_IO
15055 WRITE_LONG_F(adr, res)
15056 POST_IO
15057RET(26)
15058}
15059
15060// CLR
15061OPCODE(0x42B8)
15062{
15063 u32 adr, res;
15064 u32 src, dst;
15065
15066 FETCH_SWORD(adr);
15067 res = 0;
15068 flag_N = flag_NotZ = flag_V = flag_C = 0;
15069 PRE_IO
15070 WRITE_LONG_F(adr, res)
15071 POST_IO
15072RET(24)
15073}
15074
15075// CLR
15076OPCODE(0x42B9)
15077{
15078 u32 adr, res;
15079 u32 src, dst;
15080
15081 FETCH_LONG(adr);
15082 res = 0;
15083 flag_N = flag_NotZ = flag_V = flag_C = 0;
15084 PRE_IO
15085 WRITE_LONG_F(adr, res)
15086 POST_IO
15087RET(28)
15088}
15089
15090// CLR
15091OPCODE(0x429F)
15092{
15093 u32 adr, res;
15094 u32 src, dst;
15095
15096 adr = AREG(7);
15097 AREG(7) += 4;
15098 res = 0;
15099 flag_N = flag_NotZ = flag_V = flag_C = 0;
15100 PRE_IO
15101 WRITE_LONG_F(adr, res)
15102 POST_IO
15103RET(20)
15104}
15105
15106// CLR
15107OPCODE(0x42A7)
15108{
15109 u32 adr, res;
15110 u32 src, dst;
15111
15112 adr = AREG(7) - 4;
15113 AREG(7) = adr;
15114 res = 0;
15115 flag_N = flag_NotZ = flag_V = flag_C = 0;
15116 PRE_IO
15117 WRITE_LONG_F(adr, res)
15118 POST_IO
15119RET(22)
15120}
15121
15122// NEG
15123OPCODE(0x4400)
15124{
15125 u32 adr, res;
15126 u32 src, dst;
15127
15128 src = DREGu8((Opcode >> 0) & 7);
15129 res = -src;
15130 flag_V = res & src;
15131 flag_N = flag_X = flag_C = res;
15132 flag_NotZ = res & 0xFF;
15133 DREGu8((Opcode >> 0) & 7) = res;
15134RET(4)
15135}
15136
15137// NEG
15138OPCODE(0x4410)
15139{
15140 u32 adr, res;
15141 u32 src, dst;
15142
15143 adr = AREG((Opcode >> 0) & 7);
15144 PRE_IO
15145 READ_BYTE_F(adr, src)
15146 res = -src;
15147 flag_V = res & src;
15148 flag_N = flag_X = flag_C = res;
15149 flag_NotZ = res & 0xFF;
15150 WRITE_BYTE_F(adr, res)
15151 POST_IO
15152RET(12)
15153}
15154
15155// NEG
15156OPCODE(0x4418)
15157{
15158 u32 adr, res;
15159 u32 src, dst;
15160
15161 adr = AREG((Opcode >> 0) & 7);
15162 AREG((Opcode >> 0) & 7) += 1;
15163 PRE_IO
15164 READ_BYTE_F(adr, src)
15165 res = -src;
15166 flag_V = res & src;
15167 flag_N = flag_X = flag_C = res;
15168 flag_NotZ = res & 0xFF;
15169 WRITE_BYTE_F(adr, res)
15170 POST_IO
15171RET(12)
15172}
15173
15174// NEG
15175OPCODE(0x4420)
15176{
15177 u32 adr, res;
15178 u32 src, dst;
15179
15180 adr = AREG((Opcode >> 0) & 7) - 1;
15181 AREG((Opcode >> 0) & 7) = adr;
15182 PRE_IO
15183 READ_BYTE_F(adr, src)
15184 res = -src;
15185 flag_V = res & src;
15186 flag_N = flag_X = flag_C = res;
15187 flag_NotZ = res & 0xFF;
15188 WRITE_BYTE_F(adr, res)
15189 POST_IO
15190RET(14)
15191}
15192
15193// NEG
15194OPCODE(0x4428)
15195{
15196 u32 adr, res;
15197 u32 src, dst;
15198
15199 FETCH_SWORD(adr);
15200 adr += AREG((Opcode >> 0) & 7);
15201 PRE_IO
15202 READ_BYTE_F(adr, src)
15203 res = -src;
15204 flag_V = res & src;
15205 flag_N = flag_X = flag_C = res;
15206 flag_NotZ = res & 0xFF;
15207 WRITE_BYTE_F(adr, res)
15208 POST_IO
15209RET(16)
15210}
15211
15212// NEG
15213OPCODE(0x4430)
15214{
15215 u32 adr, res;
15216 u32 src, dst;
15217
15218 adr = AREG((Opcode >> 0) & 7);
15219 DECODE_EXT_WORD
15220 PRE_IO
15221 READ_BYTE_F(adr, src)
15222 res = -src;
15223 flag_V = res & src;
15224 flag_N = flag_X = flag_C = res;
15225 flag_NotZ = res & 0xFF;
15226 WRITE_BYTE_F(adr, res)
15227 POST_IO
15228RET(18)
15229}
15230
15231// NEG
15232OPCODE(0x4438)
15233{
15234 u32 adr, res;
15235 u32 src, dst;
15236
15237 FETCH_SWORD(adr);
15238 PRE_IO
15239 READ_BYTE_F(adr, src)
15240 res = -src;
15241 flag_V = res & src;
15242 flag_N = flag_X = flag_C = res;
15243 flag_NotZ = res & 0xFF;
15244 WRITE_BYTE_F(adr, res)
15245 POST_IO
15246RET(16)
15247}
15248
15249// NEG
15250OPCODE(0x4439)
15251{
15252 u32 adr, res;
15253 u32 src, dst;
15254
15255 FETCH_LONG(adr);
15256 PRE_IO
15257 READ_BYTE_F(adr, src)
15258 res = -src;
15259 flag_V = res & src;
15260 flag_N = flag_X = flag_C = res;
15261 flag_NotZ = res & 0xFF;
15262 WRITE_BYTE_F(adr, res)
15263 POST_IO
15264RET(20)
15265}
15266
15267// NEG
15268OPCODE(0x441F)
15269{
15270 u32 adr, res;
15271 u32 src, dst;
15272
15273 adr = AREG(7);
15274 AREG(7) += 2;
15275 PRE_IO
15276 READ_BYTE_F(adr, src)
15277 res = -src;
15278 flag_V = res & src;
15279 flag_N = flag_X = flag_C = res;
15280 flag_NotZ = res & 0xFF;
15281 WRITE_BYTE_F(adr, res)
15282 POST_IO
15283RET(12)
15284}
15285
15286// NEG
15287OPCODE(0x4427)
15288{
15289 u32 adr, res;
15290 u32 src, dst;
15291
15292 adr = AREG(7) - 2;
15293 AREG(7) = adr;
15294 PRE_IO
15295 READ_BYTE_F(adr, src)
15296 res = -src;
15297 flag_V = res & src;
15298 flag_N = flag_X = flag_C = res;
15299 flag_NotZ = res & 0xFF;
15300 WRITE_BYTE_F(adr, res)
15301 POST_IO
15302RET(14)
15303}
15304
15305// NEG
15306OPCODE(0x4440)
15307{
15308 u32 adr, res;
15309 u32 src, dst;
15310
15311 src = DREGu16((Opcode >> 0) & 7);
15312 res = -src;
15313 flag_V = (res & src) >> 8;
15314 flag_N = flag_X = flag_C = res >> 8;
15315 flag_NotZ = res & 0xFFFF;
15316 DREGu16((Opcode >> 0) & 7) = res;
15317RET(4)
15318}
15319
15320// NEG
15321OPCODE(0x4450)
15322{
15323 u32 adr, res;
15324 u32 src, dst;
15325
15326 adr = AREG((Opcode >> 0) & 7);
15327 PRE_IO
15328 READ_WORD_F(adr, src)
15329 res = -src;
15330 flag_V = (res & src) >> 8;
15331 flag_N = flag_X = flag_C = res >> 8;
15332 flag_NotZ = res & 0xFFFF;
15333 WRITE_WORD_F(adr, res)
15334 POST_IO
15335RET(12)
15336}
15337
15338// NEG
15339OPCODE(0x4458)
15340{
15341 u32 adr, res;
15342 u32 src, dst;
15343
15344 adr = AREG((Opcode >> 0) & 7);
15345 AREG((Opcode >> 0) & 7) += 2;
15346 PRE_IO
15347 READ_WORD_F(adr, src)
15348 res = -src;
15349 flag_V = (res & src) >> 8;
15350 flag_N = flag_X = flag_C = res >> 8;
15351 flag_NotZ = res & 0xFFFF;
15352 WRITE_WORD_F(adr, res)
15353 POST_IO
15354RET(12)
15355}
15356
15357// NEG
15358OPCODE(0x4460)
15359{
15360 u32 adr, res;
15361 u32 src, dst;
15362
15363 adr = AREG((Opcode >> 0) & 7) - 2;
15364 AREG((Opcode >> 0) & 7) = adr;
15365 PRE_IO
15366 READ_WORD_F(adr, src)
15367 res = -src;
15368 flag_V = (res & src) >> 8;
15369 flag_N = flag_X = flag_C = res >> 8;
15370 flag_NotZ = res & 0xFFFF;
15371 WRITE_WORD_F(adr, res)
15372 POST_IO
15373RET(14)
15374}
15375
15376// NEG
15377OPCODE(0x4468)
15378{
15379 u32 adr, res;
15380 u32 src, dst;
15381
15382 FETCH_SWORD(adr);
15383 adr += AREG((Opcode >> 0) & 7);
15384 PRE_IO
15385 READ_WORD_F(adr, src)
15386 res = -src;
15387 flag_V = (res & src) >> 8;
15388 flag_N = flag_X = flag_C = res >> 8;
15389 flag_NotZ = res & 0xFFFF;
15390 WRITE_WORD_F(adr, res)
15391 POST_IO
15392RET(16)
15393}
15394
15395// NEG
15396OPCODE(0x4470)
15397{
15398 u32 adr, res;
15399 u32 src, dst;
15400
15401 adr = AREG((Opcode >> 0) & 7);
15402 DECODE_EXT_WORD
15403 PRE_IO
15404 READ_WORD_F(adr, src)
15405 res = -src;
15406 flag_V = (res & src) >> 8;
15407 flag_N = flag_X = flag_C = res >> 8;
15408 flag_NotZ = res & 0xFFFF;
15409 WRITE_WORD_F(adr, res)
15410 POST_IO
15411RET(18)
15412}
15413
15414// NEG
15415OPCODE(0x4478)
15416{
15417 u32 adr, res;
15418 u32 src, dst;
15419
15420 FETCH_SWORD(adr);
15421 PRE_IO
15422 READ_WORD_F(adr, src)
15423 res = -src;
15424 flag_V = (res & src) >> 8;
15425 flag_N = flag_X = flag_C = res >> 8;
15426 flag_NotZ = res & 0xFFFF;
15427 WRITE_WORD_F(adr, res)
15428 POST_IO
15429RET(16)
15430}
15431
15432// NEG
15433OPCODE(0x4479)
15434{
15435 u32 adr, res;
15436 u32 src, dst;
15437
15438 FETCH_LONG(adr);
15439 PRE_IO
15440 READ_WORD_F(adr, src)
15441 res = -src;
15442 flag_V = (res & src) >> 8;
15443 flag_N = flag_X = flag_C = res >> 8;
15444 flag_NotZ = res & 0xFFFF;
15445 WRITE_WORD_F(adr, res)
15446 POST_IO
15447RET(20)
15448}
15449
15450// NEG
15451OPCODE(0x445F)
15452{
15453 u32 adr, res;
15454 u32 src, dst;
15455
15456 adr = AREG(7);
15457 AREG(7) += 2;
15458 PRE_IO
15459 READ_WORD_F(adr, src)
15460 res = -src;
15461 flag_V = (res & src) >> 8;
15462 flag_N = flag_X = flag_C = res >> 8;
15463 flag_NotZ = res & 0xFFFF;
15464 WRITE_WORD_F(adr, res)
15465 POST_IO
15466RET(12)
15467}
15468
15469// NEG
15470OPCODE(0x4467)
15471{
15472 u32 adr, res;
15473 u32 src, dst;
15474
15475 adr = AREG(7) - 2;
15476 AREG(7) = adr;
15477 PRE_IO
15478 READ_WORD_F(adr, src)
15479 res = -src;
15480 flag_V = (res & src) >> 8;
15481 flag_N = flag_X = flag_C = res >> 8;
15482 flag_NotZ = res & 0xFFFF;
15483 WRITE_WORD_F(adr, res)
15484 POST_IO
15485RET(14)
15486}
15487
15488// NEG
15489OPCODE(0x4480)
15490{
15491 u32 adr, res;
15492 u32 src, dst;
15493
15494 src = DREGu32((Opcode >> 0) & 7);
15495 res = -src;
15496 flag_NotZ = res;
15497 flag_V = (res & src) >> 24;
15498 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15499 flag_N = res >> 24;
15500 DREGu32((Opcode >> 0) & 7) = res;
15501RET(6)
15502}
15503
15504// NEG
15505OPCODE(0x4490)
15506{
15507 u32 adr, res;
15508 u32 src, dst;
15509
15510 adr = AREG((Opcode >> 0) & 7);
15511 PRE_IO
15512 READ_LONG_F(adr, src)
15513 res = -src;
15514 flag_NotZ = res;
15515 flag_V = (res & src) >> 24;
15516 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15517 flag_N = res >> 24;
15518 WRITE_LONG_F(adr, res)
15519 POST_IO
15520RET(20)
15521}
15522
15523// NEG
15524OPCODE(0x4498)
15525{
15526 u32 adr, res;
15527 u32 src, dst;
15528
15529 adr = AREG((Opcode >> 0) & 7);
15530 AREG((Opcode >> 0) & 7) += 4;
15531 PRE_IO
15532 READ_LONG_F(adr, src)
15533 res = -src;
15534 flag_NotZ = res;
15535 flag_V = (res & src) >> 24;
15536 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15537 flag_N = res >> 24;
15538 WRITE_LONG_F(adr, res)
15539 POST_IO
15540RET(20)
15541}
15542
15543// NEG
15544OPCODE(0x44A0)
15545{
15546 u32 adr, res;
15547 u32 src, dst;
15548
15549 adr = AREG((Opcode >> 0) & 7) - 4;
15550 AREG((Opcode >> 0) & 7) = adr;
15551 PRE_IO
15552 READ_LONG_F(adr, src)
15553 res = -src;
15554 flag_NotZ = res;
15555 flag_V = (res & src) >> 24;
15556 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15557 flag_N = res >> 24;
15558 WRITE_LONG_F(adr, res)
15559 POST_IO
15560RET(22)
15561}
15562
15563// NEG
15564OPCODE(0x44A8)
15565{
15566 u32 adr, res;
15567 u32 src, dst;
15568
15569 FETCH_SWORD(adr);
15570 adr += AREG((Opcode >> 0) & 7);
15571 PRE_IO
15572 READ_LONG_F(adr, src)
15573 res = -src;
15574 flag_NotZ = res;
15575 flag_V = (res & src) >> 24;
15576 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15577 flag_N = res >> 24;
15578 WRITE_LONG_F(adr, res)
15579 POST_IO
15580RET(24)
15581}
15582
15583// NEG
15584OPCODE(0x44B0)
15585{
15586 u32 adr, res;
15587 u32 src, dst;
15588
15589 adr = AREG((Opcode >> 0) & 7);
15590 DECODE_EXT_WORD
15591 PRE_IO
15592 READ_LONG_F(adr, src)
15593 res = -src;
15594 flag_NotZ = res;
15595 flag_V = (res & src) >> 24;
15596 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15597 flag_N = res >> 24;
15598 WRITE_LONG_F(adr, res)
15599 POST_IO
15600RET(26)
15601}
15602
15603// NEG
15604OPCODE(0x44B8)
15605{
15606 u32 adr, res;
15607 u32 src, dst;
15608
15609 FETCH_SWORD(adr);
15610 PRE_IO
15611 READ_LONG_F(adr, src)
15612 res = -src;
15613 flag_NotZ = res;
15614 flag_V = (res & src) >> 24;
15615 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15616 flag_N = res >> 24;
15617 WRITE_LONG_F(adr, res)
15618 POST_IO
15619RET(24)
15620}
15621
15622// NEG
15623OPCODE(0x44B9)
15624{
15625 u32 adr, res;
15626 u32 src, dst;
15627
15628 FETCH_LONG(adr);
15629 PRE_IO
15630 READ_LONG_F(adr, src)
15631 res = -src;
15632 flag_NotZ = res;
15633 flag_V = (res & src) >> 24;
15634 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15635 flag_N = res >> 24;
15636 WRITE_LONG_F(adr, res)
15637 POST_IO
15638RET(28)
15639}
15640
15641// NEG
15642OPCODE(0x449F)
15643{
15644 u32 adr, res;
15645 u32 src, dst;
15646
15647 adr = AREG(7);
15648 AREG(7) += 4;
15649 PRE_IO
15650 READ_LONG_F(adr, src)
15651 res = -src;
15652 flag_NotZ = res;
15653 flag_V = (res & src) >> 24;
15654 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15655 flag_N = res >> 24;
15656 WRITE_LONG_F(adr, res)
15657 POST_IO
15658RET(20)
15659}
15660
15661// NEG
15662OPCODE(0x44A7)
15663{
15664 u32 adr, res;
15665 u32 src, dst;
15666
15667 adr = AREG(7) - 4;
15668 AREG(7) = adr;
15669 PRE_IO
15670 READ_LONG_F(adr, src)
15671 res = -src;
15672 flag_NotZ = res;
15673 flag_V = (res & src) >> 24;
15674 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15675 flag_N = res >> 24;
15676 WRITE_LONG_F(adr, res)
15677 POST_IO
15678RET(22)
15679}
15680
15681// NOT
15682OPCODE(0x4600)
15683{
15684 u32 adr, res;
15685 u32 src, dst;
15686
15687 src = DREGu8((Opcode >> 0) & 7);
15688 res = ~src;
15689 flag_C = 0;
15690 flag_V = 0;
15691 flag_N = res;
15692 flag_NotZ = res & 0xFF;
15693 DREGu8((Opcode >> 0) & 7) = res;
15694RET(4)
15695}
15696
15697// NOT
15698OPCODE(0x4610)
15699{
15700 u32 adr, res;
15701 u32 src, dst;
15702
15703 adr = AREG((Opcode >> 0) & 7);
15704 PRE_IO
15705 READ_BYTE_F(adr, src)
15706 res = ~src;
15707 flag_C = 0;
15708 flag_V = 0;
15709 flag_N = res;
15710 flag_NotZ = res & 0xFF;
15711 WRITE_BYTE_F(adr, res)
15712 POST_IO
15713RET(12)
15714}
15715
15716// NOT
15717OPCODE(0x4618)
15718{
15719 u32 adr, res;
15720 u32 src, dst;
15721
15722 adr = AREG((Opcode >> 0) & 7);
15723 AREG((Opcode >> 0) & 7) += 1;
15724 PRE_IO
15725 READ_BYTE_F(adr, src)
15726 res = ~src;
15727 flag_C = 0;
15728 flag_V = 0;
15729 flag_N = res;
15730 flag_NotZ = res & 0xFF;
15731 WRITE_BYTE_F(adr, res)
15732 POST_IO
15733RET(12)
15734}
15735
15736// NOT
15737OPCODE(0x4620)
15738{
15739 u32 adr, res;
15740 u32 src, dst;
15741
15742 adr = AREG((Opcode >> 0) & 7) - 1;
15743 AREG((Opcode >> 0) & 7) = adr;
15744 PRE_IO
15745 READ_BYTE_F(adr, src)
15746 res = ~src;
15747 flag_C = 0;
15748 flag_V = 0;
15749 flag_N = res;
15750 flag_NotZ = res & 0xFF;
15751 WRITE_BYTE_F(adr, res)
15752 POST_IO
15753RET(14)
15754}
15755
15756// NOT
15757OPCODE(0x4628)
15758{
15759 u32 adr, res;
15760 u32 src, dst;
15761
15762 FETCH_SWORD(adr);
15763 adr += AREG((Opcode >> 0) & 7);
15764 PRE_IO
15765 READ_BYTE_F(adr, src)
15766 res = ~src;
15767 flag_C = 0;
15768 flag_V = 0;
15769 flag_N = res;
15770 flag_NotZ = res & 0xFF;
15771 WRITE_BYTE_F(adr, res)
15772 POST_IO
15773RET(16)
15774}
15775
15776// NOT
15777OPCODE(0x4630)
15778{
15779 u32 adr, res;
15780 u32 src, dst;
15781
15782 adr = AREG((Opcode >> 0) & 7);
15783 DECODE_EXT_WORD
15784 PRE_IO
15785 READ_BYTE_F(adr, src)
15786 res = ~src;
15787 flag_C = 0;
15788 flag_V = 0;
15789 flag_N = res;
15790 flag_NotZ = res & 0xFF;
15791 WRITE_BYTE_F(adr, res)
15792 POST_IO
15793RET(18)
15794}
15795
15796// NOT
15797OPCODE(0x4638)
15798{
15799 u32 adr, res;
15800 u32 src, dst;
15801
15802 FETCH_SWORD(adr);
15803 PRE_IO
15804 READ_BYTE_F(adr, src)
15805 res = ~src;
15806 flag_C = 0;
15807 flag_V = 0;
15808 flag_N = res;
15809 flag_NotZ = res & 0xFF;
15810 WRITE_BYTE_F(adr, res)
15811 POST_IO
15812RET(16)
15813}
15814
15815// NOT
15816OPCODE(0x4639)
15817{
15818 u32 adr, res;
15819 u32 src, dst;
15820
15821 FETCH_LONG(adr);
15822 PRE_IO
15823 READ_BYTE_F(adr, src)
15824 res = ~src;
15825 flag_C = 0;
15826 flag_V = 0;
15827 flag_N = res;
15828 flag_NotZ = res & 0xFF;
15829 WRITE_BYTE_F(adr, res)
15830 POST_IO
15831RET(20)
15832}
15833
15834// NOT
15835OPCODE(0x461F)
15836{
15837 u32 adr, res;
15838 u32 src, dst;
15839
15840 adr = AREG(7);
15841 AREG(7) += 2;
15842 PRE_IO
15843 READ_BYTE_F(adr, src)
15844 res = ~src;
15845 flag_C = 0;
15846 flag_V = 0;
15847 flag_N = res;
15848 flag_NotZ = res & 0xFF;
15849 WRITE_BYTE_F(adr, res)
15850 POST_IO
15851RET(12)
15852}
15853
15854// NOT
15855OPCODE(0x4627)
15856{
15857 u32 adr, res;
15858 u32 src, dst;
15859
15860 adr = AREG(7) - 2;
15861 AREG(7) = adr;
15862 PRE_IO
15863 READ_BYTE_F(adr, src)
15864 res = ~src;
15865 flag_C = 0;
15866 flag_V = 0;
15867 flag_N = res;
15868 flag_NotZ = res & 0xFF;
15869 WRITE_BYTE_F(adr, res)
15870 POST_IO
15871RET(14)
15872}
15873
15874// NOT
15875OPCODE(0x4640)
15876{
15877 u32 adr, res;
15878 u32 src, dst;
15879
15880 src = DREGu16((Opcode >> 0) & 7);
15881 res = ~src;
15882 flag_C = 0;
15883 flag_V = 0;
15884 flag_NotZ = res & 0xFFFF;
15885 flag_N = res >> 8;
15886 DREGu16((Opcode >> 0) & 7) = res;
15887RET(4)
15888}
15889
15890// NOT
15891OPCODE(0x4650)
15892{
15893 u32 adr, res;
15894 u32 src, dst;
15895
15896 adr = AREG((Opcode >> 0) & 7);
15897 PRE_IO
15898 READ_WORD_F(adr, src)
15899 res = ~src;
15900 flag_C = 0;
15901 flag_V = 0;
15902 flag_NotZ = res & 0xFFFF;
15903 flag_N = res >> 8;
15904 WRITE_WORD_F(adr, res)
15905 POST_IO
15906RET(12)
15907}
15908
15909// NOT
15910OPCODE(0x4658)
15911{
15912 u32 adr, res;
15913 u32 src, dst;
15914
15915 adr = AREG((Opcode >> 0) & 7);
15916 AREG((Opcode >> 0) & 7) += 2;
15917 PRE_IO
15918 READ_WORD_F(adr, src)
15919 res = ~src;
15920 flag_C = 0;
15921 flag_V = 0;
15922 flag_NotZ = res & 0xFFFF;
15923 flag_N = res >> 8;
15924 WRITE_WORD_F(adr, res)
15925 POST_IO
15926RET(12)
15927}
15928
15929// NOT
15930OPCODE(0x4660)
15931{
15932 u32 adr, res;
15933 u32 src, dst;
15934
15935 adr = AREG((Opcode >> 0) & 7) - 2;
15936 AREG((Opcode >> 0) & 7) = adr;
15937 PRE_IO
15938 READ_WORD_F(adr, src)
15939 res = ~src;
15940 flag_C = 0;
15941 flag_V = 0;
15942 flag_NotZ = res & 0xFFFF;
15943 flag_N = res >> 8;
15944 WRITE_WORD_F(adr, res)
15945 POST_IO
15946RET(14)
15947}
15948
15949// NOT
15950OPCODE(0x4668)
15951{
15952 u32 adr, res;
15953 u32 src, dst;
15954
15955 FETCH_SWORD(adr);
15956 adr += AREG((Opcode >> 0) & 7);
15957 PRE_IO
15958 READ_WORD_F(adr, src)
15959 res = ~src;
15960 flag_C = 0;
15961 flag_V = 0;
15962 flag_NotZ = res & 0xFFFF;
15963 flag_N = res >> 8;
15964 WRITE_WORD_F(adr, res)
15965 POST_IO
15966RET(16)
15967}
15968
15969// NOT
15970OPCODE(0x4670)
15971{
15972 u32 adr, res;
15973 u32 src, dst;
15974
15975 adr = AREG((Opcode >> 0) & 7);
15976 DECODE_EXT_WORD
15977 PRE_IO
15978 READ_WORD_F(adr, src)
15979 res = ~src;
15980 flag_C = 0;
15981 flag_V = 0;
15982 flag_NotZ = res & 0xFFFF;
15983 flag_N = res >> 8;
15984 WRITE_WORD_F(adr, res)
15985 POST_IO
15986RET(18)
15987}
15988
15989// NOT
15990OPCODE(0x4678)
15991{
15992 u32 adr, res;
15993 u32 src, dst;
15994
15995 FETCH_SWORD(adr);
15996 PRE_IO
15997 READ_WORD_F(adr, src)
15998 res = ~src;
15999 flag_C = 0;
16000 flag_V = 0;
16001 flag_NotZ = res & 0xFFFF;
16002 flag_N = res >> 8;
16003 WRITE_WORD_F(adr, res)
16004 POST_IO
16005RET(16)
16006}
16007
16008// NOT
16009OPCODE(0x4679)
16010{
16011 u32 adr, res;
16012 u32 src, dst;
16013
16014 FETCH_LONG(adr);
16015 PRE_IO
16016 READ_WORD_F(adr, src)
16017 res = ~src;
16018 flag_C = 0;
16019 flag_V = 0;
16020 flag_NotZ = res & 0xFFFF;
16021 flag_N = res >> 8;
16022 WRITE_WORD_F(adr, res)
16023 POST_IO
16024RET(20)
16025}
16026
16027// NOT
16028OPCODE(0x465F)
16029{
16030 u32 adr, res;
16031 u32 src, dst;
16032
16033 adr = AREG(7);
16034 AREG(7) += 2;
16035 PRE_IO
16036 READ_WORD_F(adr, src)
16037 res = ~src;
16038 flag_C = 0;
16039 flag_V = 0;
16040 flag_NotZ = res & 0xFFFF;
16041 flag_N = res >> 8;
16042 WRITE_WORD_F(adr, res)
16043 POST_IO
16044RET(12)
16045}
16046
16047// NOT
16048OPCODE(0x4667)
16049{
16050 u32 adr, res;
16051 u32 src, dst;
16052
16053 adr = AREG(7) - 2;
16054 AREG(7) = adr;
16055 PRE_IO
16056 READ_WORD_F(adr, src)
16057 res = ~src;
16058 flag_C = 0;
16059 flag_V = 0;
16060 flag_NotZ = res & 0xFFFF;
16061 flag_N = res >> 8;
16062 WRITE_WORD_F(adr, res)
16063 POST_IO
16064RET(14)
16065}
16066
16067// NOT
16068OPCODE(0x4680)
16069{
16070 u32 adr, res;
16071 u32 src, dst;
16072
16073 src = DREGu32((Opcode >> 0) & 7);
16074 res = ~src;
16075 flag_C = 0;
16076 flag_V = 0;
16077 flag_NotZ = res;
16078 flag_N = res >> 24;
16079 DREGu32((Opcode >> 0) & 7) = res;
16080RET(6)
16081}
16082
16083// NOT
16084OPCODE(0x4690)
16085{
16086 u32 adr, res;
16087 u32 src, dst;
16088
16089 adr = AREG((Opcode >> 0) & 7);
16090 PRE_IO
16091 READ_LONG_F(adr, src)
16092 res = ~src;
16093 flag_C = 0;
16094 flag_V = 0;
16095 flag_NotZ = res;
16096 flag_N = res >> 24;
16097 WRITE_LONG_F(adr, res)
16098 POST_IO
16099RET(20)
16100}
16101
16102// NOT
16103OPCODE(0x4698)
16104{
16105 u32 adr, res;
16106 u32 src, dst;
16107
16108 adr = AREG((Opcode >> 0) & 7);
16109 AREG((Opcode >> 0) & 7) += 4;
16110 PRE_IO
16111 READ_LONG_F(adr, src)
16112 res = ~src;
16113 flag_C = 0;
16114 flag_V = 0;
16115 flag_NotZ = res;
16116 flag_N = res >> 24;
16117 WRITE_LONG_F(adr, res)
16118 POST_IO
16119RET(20)
16120}
16121
16122// NOT
16123OPCODE(0x46A0)
16124{
16125 u32 adr, res;
16126 u32 src, dst;
16127
16128 adr = AREG((Opcode >> 0) & 7) - 4;
16129 AREG((Opcode >> 0) & 7) = adr;
16130 PRE_IO
16131 READ_LONG_F(adr, src)
16132 res = ~src;
16133 flag_C = 0;
16134 flag_V = 0;
16135 flag_NotZ = res;
16136 flag_N = res >> 24;
16137 WRITE_LONG_F(adr, res)
16138 POST_IO
16139RET(22)
16140}
16141
16142// NOT
16143OPCODE(0x46A8)
16144{
16145 u32 adr, res;
16146 u32 src, dst;
16147
16148 FETCH_SWORD(adr);
16149 adr += AREG((Opcode >> 0) & 7);
16150 PRE_IO
16151 READ_LONG_F(adr, src)
16152 res = ~src;
16153 flag_C = 0;
16154 flag_V = 0;
16155 flag_NotZ = res;
16156 flag_N = res >> 24;
16157 WRITE_LONG_F(adr, res)
16158 POST_IO
16159RET(24)
16160}
16161
16162// NOT
16163OPCODE(0x46B0)
16164{
16165 u32 adr, res;
16166 u32 src, dst;
16167
16168 adr = AREG((Opcode >> 0) & 7);
16169 DECODE_EXT_WORD
16170 PRE_IO
16171 READ_LONG_F(adr, src)
16172 res = ~src;
16173 flag_C = 0;
16174 flag_V = 0;
16175 flag_NotZ = res;
16176 flag_N = res >> 24;
16177 WRITE_LONG_F(adr, res)
16178 POST_IO
16179RET(26)
16180}
16181
16182// NOT
16183OPCODE(0x46B8)
16184{
16185 u32 adr, res;
16186 u32 src, dst;
16187
16188 FETCH_SWORD(adr);
16189 PRE_IO
16190 READ_LONG_F(adr, src)
16191 res = ~src;
16192 flag_C = 0;
16193 flag_V = 0;
16194 flag_NotZ = res;
16195 flag_N = res >> 24;
16196 WRITE_LONG_F(adr, res)
16197 POST_IO
16198RET(24)
16199}
16200
16201// NOT
16202OPCODE(0x46B9)
16203{
16204 u32 adr, res;
16205 u32 src, dst;
16206
16207 FETCH_LONG(adr);
16208 PRE_IO
16209 READ_LONG_F(adr, src)
16210 res = ~src;
16211 flag_C = 0;
16212 flag_V = 0;
16213 flag_NotZ = res;
16214 flag_N = res >> 24;
16215 WRITE_LONG_F(adr, res)
16216 POST_IO
16217RET(28)
16218}
16219
16220// NOT
16221OPCODE(0x469F)
16222{
16223 u32 adr, res;
16224 u32 src, dst;
16225
16226 adr = AREG(7);
16227 AREG(7) += 4;
16228 PRE_IO
16229 READ_LONG_F(adr, src)
16230 res = ~src;
16231 flag_C = 0;
16232 flag_V = 0;
16233 flag_NotZ = res;
16234 flag_N = res >> 24;
16235 WRITE_LONG_F(adr, res)
16236 POST_IO
16237RET(20)
16238}
16239
16240// NOT
16241OPCODE(0x46A7)
16242{
16243 u32 adr, res;
16244 u32 src, dst;
16245
16246 adr = AREG(7) - 4;
16247 AREG(7) = adr;
16248 PRE_IO
16249 READ_LONG_F(adr, src)
16250 res = ~src;
16251 flag_C = 0;
16252 flag_V = 0;
16253 flag_NotZ = res;
16254 flag_N = res >> 24;
16255 WRITE_LONG_F(adr, res)
16256 POST_IO
16257RET(22)
16258}
16259
16260// MOVESRa
16261OPCODE(0x40C0)
16262{
16263 u32 adr, res;
16264 u32 src, dst;
16265
16266 res = GET_SR;
16267 DREGu16((Opcode >> 0) & 7) = res;
16268RET(6)
16269}
16270
16271// MOVESRa
16272OPCODE(0x40D0)
16273{
16274 u32 adr, res;
16275 u32 src, dst;
16276
16277 res = GET_SR;
16278 adr = AREG((Opcode >> 0) & 7);
16279 PRE_IO
16280 WRITE_WORD_F(adr, res)
16281 POST_IO
16282RET(12)
16283}
16284
16285// MOVESRa
16286OPCODE(0x40D8)
16287{
16288 u32 adr, res;
16289 u32 src, dst;
16290
16291 res = GET_SR;
16292 adr = AREG((Opcode >> 0) & 7);
16293 AREG((Opcode >> 0) & 7) += 2;
16294 PRE_IO
16295 WRITE_WORD_F(adr, res)
16296 POST_IO
16297RET(12)
16298}
16299
16300// MOVESRa
16301OPCODE(0x40E0)
16302{
16303 u32 adr, res;
16304 u32 src, dst;
16305
16306 res = GET_SR;
16307 adr = AREG((Opcode >> 0) & 7) - 2;
16308 AREG((Opcode >> 0) & 7) = adr;
16309 PRE_IO
16310 WRITE_WORD_F(adr, res)
16311 POST_IO
16312RET(14)
16313}
16314
16315// MOVESRa
16316OPCODE(0x40E8)
16317{
16318 u32 adr, res;
16319 u32 src, dst;
16320
16321 res = GET_SR;
16322 FETCH_SWORD(adr);
16323 adr += AREG((Opcode >> 0) & 7);
16324 PRE_IO
16325 WRITE_WORD_F(adr, res)
16326 POST_IO
16327RET(16)
16328}
16329
16330// MOVESRa
16331OPCODE(0x40F0)
16332{
16333 u32 adr, res;
16334 u32 src, dst;
16335
16336 res = GET_SR;
16337 adr = AREG((Opcode >> 0) & 7);
16338 DECODE_EXT_WORD
16339 PRE_IO
16340 WRITE_WORD_F(adr, res)
16341 POST_IO
16342RET(18)
16343}
16344
16345// MOVESRa
16346OPCODE(0x40F8)
16347{
16348 u32 adr, res;
16349 u32 src, dst;
16350
16351 res = GET_SR;
16352 FETCH_SWORD(adr);
16353 PRE_IO
16354 WRITE_WORD_F(adr, res)
16355 POST_IO
16356RET(16)
16357}
16358
16359// MOVESRa
16360OPCODE(0x40F9)
16361{
16362 u32 adr, res;
16363 u32 src, dst;
16364
16365 res = GET_SR;
16366 FETCH_LONG(adr);
16367 PRE_IO
16368 WRITE_WORD_F(adr, res)
16369 POST_IO
16370RET(20)
16371}
16372
16373// MOVESRa
16374OPCODE(0x40DF)
16375{
16376 u32 adr, res;
16377 u32 src, dst;
16378
16379 res = GET_SR;
16380 adr = AREG(7);
16381 AREG(7) += 2;
16382 PRE_IO
16383 WRITE_WORD_F(adr, res)
16384 POST_IO
16385RET(12)
16386}
16387
16388// MOVESRa
16389OPCODE(0x40E7)
16390{
16391 u32 adr, res;
16392 u32 src, dst;
16393
16394 res = GET_SR;
16395 adr = AREG(7) - 2;
16396 AREG(7) = adr;
16397 PRE_IO
16398 WRITE_WORD_F(adr, res)
16399 POST_IO
16400RET(14)
16401}
16402
16403// MOVEaCCR
16404OPCODE(0x44C0)
16405{
16406 u32 adr, res;
16407 u32 src, dst;
16408
16409 res = DREGu16((Opcode >> 0) & 7);
16410 SET_CCR(res)
16411RET(12)
16412}
16413
16414// MOVEaCCR
16415OPCODE(0x44D0)
16416{
16417 u32 adr, res;
16418 u32 src, dst;
16419
16420 adr = AREG((Opcode >> 0) & 7);
16421 PRE_IO
16422 READ_WORD_F(adr, res)
16423 SET_CCR(res)
16424 POST_IO
16425RET(16)
16426}
16427
16428// MOVEaCCR
16429OPCODE(0x44D8)
16430{
16431 u32 adr, res;
16432 u32 src, dst;
16433
16434 adr = AREG((Opcode >> 0) & 7);
16435 AREG((Opcode >> 0) & 7) += 2;
16436 PRE_IO
16437 READ_WORD_F(adr, res)
16438 SET_CCR(res)
16439 POST_IO
16440RET(16)
16441}
16442
16443// MOVEaCCR
16444OPCODE(0x44E0)
16445{
16446 u32 adr, res;
16447 u32 src, dst;
16448
16449 adr = AREG((Opcode >> 0) & 7) - 2;
16450 AREG((Opcode >> 0) & 7) = adr;
16451 PRE_IO
16452 READ_WORD_F(adr, res)
16453 SET_CCR(res)
16454 POST_IO
16455RET(18)
16456}
16457
16458// MOVEaCCR
16459OPCODE(0x44E8)
16460{
16461 u32 adr, res;
16462 u32 src, dst;
16463
16464 FETCH_SWORD(adr);
16465 adr += AREG((Opcode >> 0) & 7);
16466 PRE_IO
16467 READ_WORD_F(adr, res)
16468 SET_CCR(res)
16469 POST_IO
16470RET(20)
16471}
16472
16473// MOVEaCCR
16474OPCODE(0x44F0)
16475{
16476 u32 adr, res;
16477 u32 src, dst;
16478
16479 adr = AREG((Opcode >> 0) & 7);
16480 DECODE_EXT_WORD
16481 PRE_IO
16482 READ_WORD_F(adr, res)
16483 SET_CCR(res)
16484 POST_IO
16485RET(22)
16486}
16487
16488// MOVEaCCR
16489OPCODE(0x44F8)
16490{
16491 u32 adr, res;
16492 u32 src, dst;
16493
16494 FETCH_SWORD(adr);
16495 PRE_IO
16496 READ_WORD_F(adr, res)
16497 SET_CCR(res)
16498 POST_IO
16499RET(20)
16500}
16501
16502// MOVEaCCR
16503OPCODE(0x44F9)
16504{
16505 u32 adr, res;
16506 u32 src, dst;
16507
16508 FETCH_LONG(adr);
16509 PRE_IO
16510 READ_WORD_F(adr, res)
16511 SET_CCR(res)
16512 POST_IO
16513RET(24)
16514}
16515
16516// MOVEaCCR
16517OPCODE(0x44FA)
16518{
16519 u32 adr, res;
16520 u32 src, dst;
16521
16522 adr = GET_SWORD + GET_PC;
16523 PC++;
16524 PRE_IO
16525 READ_WORD_F(adr, res)
16526 SET_CCR(res)
16527 POST_IO
16528RET(20)
16529}
16530
16531// MOVEaCCR
16532OPCODE(0x44FB)
16533{
16534 u32 adr, res;
16535 u32 src, dst;
16536
16537 adr = GET_PC;
16538 DECODE_EXT_WORD
16539 PRE_IO
16540 READ_WORD_F(adr, res)
16541 SET_CCR(res)
16542 POST_IO
16543RET(22)
16544}
16545
16546// MOVEaCCR
16547OPCODE(0x44FC)
16548{
16549 u32 adr, res;
16550 u32 src, dst;
16551
16552 FETCH_WORD(res);
16553 SET_CCR(res)
16554RET(16)
16555}
16556
16557// MOVEaCCR
16558OPCODE(0x44DF)
16559{
16560 u32 adr, res;
16561 u32 src, dst;
16562
16563 adr = AREG(7);
16564 AREG(7) += 2;
16565 PRE_IO
16566 READ_WORD_F(adr, res)
16567 SET_CCR(res)
16568 POST_IO
16569RET(16)
16570}
16571
16572// MOVEaCCR
16573OPCODE(0x44E7)
16574{
16575 u32 adr, res;
16576 u32 src, dst;
16577
16578 adr = AREG(7) - 2;
16579 AREG(7) = adr;
16580 PRE_IO
16581 READ_WORD_F(adr, res)
16582 SET_CCR(res)
16583 POST_IO
16584RET(18)
16585}
16586
16587// MOVEaSR
16588OPCODE(0x46C0)
16589{
16590 u32 adr, res;
16591 u32 src, dst;
16592
16593 if (flag_S)
16594 {
16595 res = DREGu16((Opcode >> 0) & 7);
16596 SET_SR(res)
16597 if (!flag_S)
16598 {
16599 res = AREG(7);
16600 AREG(7) = ASP;
16601 ASP = res;
16602 }
16603 CHECK_INT_TO_JUMP(12)
16604 }
16605 else
16606 {
16607 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16608#ifdef USE_CYCLONE_TIMING
16609 RET(0)
16610#else
16611 RET(4)
16612#endif
16613 }
16614RET(12)
16615}
16616
16617// MOVEaSR
16618OPCODE(0x46D0)
16619{
16620 u32 adr, res;
16621 u32 src, dst;
16622
16623 if (flag_S)
16624 {
16625 adr = AREG((Opcode >> 0) & 7);
16626 PRE_IO
16627 READ_WORD_F(adr, res)
16628 SET_SR(res)
16629 if (!flag_S)
16630 {
16631 res = AREG(7);
16632 AREG(7) = ASP;
16633 ASP = res;
16634 }
16635 POST_IO
16636 CHECK_INT_TO_JUMP(16)
16637 }
16638 else
16639 {
16640 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16641#ifdef USE_CYCLONE_TIMING
16642 RET(0)
16643#else
16644 RET(4)
16645#endif
16646 }
16647RET(16)
16648}
16649
16650// MOVEaSR
16651OPCODE(0x46D8)
16652{
16653 u32 adr, res;
16654 u32 src, dst;
16655
16656 if (flag_S)
16657 {
16658 adr = AREG((Opcode >> 0) & 7);
16659 AREG((Opcode >> 0) & 7) += 2;
16660 PRE_IO
16661 READ_WORD_F(adr, res)
16662 SET_SR(res)
16663 if (!flag_S)
16664 {
16665 res = AREG(7);
16666 AREG(7) = ASP;
16667 ASP = res;
16668 }
16669 POST_IO
16670 CHECK_INT_TO_JUMP(16)
16671 }
16672 else
16673 {
16674 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16675#ifdef USE_CYCLONE_TIMING
16676 RET(0)
16677#else
16678 RET(4)
16679#endif
16680 }
16681RET(16)
16682}
16683
16684// MOVEaSR
16685OPCODE(0x46E0)
16686{
16687 u32 adr, res;
16688 u32 src, dst;
16689
16690 if (flag_S)
16691 {
16692 adr = AREG((Opcode >> 0) & 7) - 2;
16693 AREG((Opcode >> 0) & 7) = adr;
16694 PRE_IO
16695 READ_WORD_F(adr, res)
16696 SET_SR(res)
16697 if (!flag_S)
16698 {
16699 res = AREG(7);
16700 AREG(7) = ASP;
16701 ASP = res;
16702 }
16703 POST_IO
16704 CHECK_INT_TO_JUMP(18)
16705 }
16706 else
16707 {
16708 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16709#ifdef USE_CYCLONE_TIMING
16710 RET(0)
16711#else
16712 RET(4)
16713#endif
16714 }
16715RET(18)
16716}
16717
16718// MOVEaSR
16719OPCODE(0x46E8)
16720{
16721 u32 adr, res;
16722 u32 src, dst;
16723
16724 if (flag_S)
16725 {
16726 FETCH_SWORD(adr);
16727 adr += AREG((Opcode >> 0) & 7);
16728 PRE_IO
16729 READ_WORD_F(adr, res)
16730 SET_SR(res)
16731 if (!flag_S)
16732 {
16733 res = AREG(7);
16734 AREG(7) = ASP;
16735 ASP = res;
16736 }
16737 POST_IO
16738 CHECK_INT_TO_JUMP(20)
16739 }
16740 else
16741 {
16742 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16743#ifdef USE_CYCLONE_TIMING
16744 RET(0)
16745#else
16746 RET(4)
16747#endif
16748 }
16749RET(20)
16750}
16751
16752// MOVEaSR
16753OPCODE(0x46F0)
16754{
16755 u32 adr, res;
16756 u32 src, dst;
16757
16758 if (flag_S)
16759 {
16760 adr = AREG((Opcode >> 0) & 7);
16761 DECODE_EXT_WORD
16762 PRE_IO
16763 READ_WORD_F(adr, res)
16764 SET_SR(res)
16765 if (!flag_S)
16766 {
16767 res = AREG(7);
16768 AREG(7) = ASP;
16769 ASP = res;
16770 }
16771 POST_IO
16772 CHECK_INT_TO_JUMP(22)
16773 }
16774 else
16775 {
16776 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16777#ifdef USE_CYCLONE_TIMING
16778 RET(0)
16779#else
16780 RET(4)
16781#endif
16782 }
16783RET(22)
16784}
16785
16786
16787// MOVEaSR
16788OPCODE(0x46F8)
16789{
16790 u32 adr, res;
16791 u32 src, dst;
16792
16793 if (flag_S)
16794 {
16795 FETCH_SWORD(adr);
16796 PRE_IO
16797 READ_WORD_F(adr, res)
16798 SET_SR(res)
16799 if (!flag_S)
16800 {
16801 res = AREG(7);
16802 AREG(7) = ASP;
16803 ASP = res;
16804 }
16805 POST_IO
16806 CHECK_INT_TO_JUMP(20)
16807 }
16808 else
16809 {
16810 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16811#ifdef USE_CYCLONE_TIMING
16812 RET(0)
16813#else
16814 RET(4)
16815#endif
16816 }
16817RET(20)
16818}
16819
16820// MOVEaSR
16821OPCODE(0x46F9)
16822{
16823 u32 adr, res;
16824 u32 src, dst;
16825
16826 if (flag_S)
16827 {
16828 FETCH_LONG(adr);
16829 PRE_IO
16830 READ_WORD_F(adr, res)
16831 SET_SR(res)
16832 if (!flag_S)
16833 {
16834 res = AREG(7);
16835 AREG(7) = ASP;
16836 ASP = res;
16837 }
16838 POST_IO
16839 CHECK_INT_TO_JUMP(24)
16840 }
16841 else
16842 {
16843 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16844#ifdef USE_CYCLONE_TIMING
16845 RET(0)
16846#else
16847 RET(4)
16848#endif
16849 }
16850RET(24)
16851}
16852
16853// MOVEaSR
16854OPCODE(0x46FA)
16855{
16856 u32 adr, res;
16857 u32 src, dst;
16858
16859 if (flag_S)
16860 {
16861 adr = GET_SWORD + GET_PC;
16862 PC++;
16863 PRE_IO
16864 READ_WORD_F(adr, res)
16865 SET_SR(res)
16866 if (!flag_S)
16867 {
16868 res = AREG(7);
16869 AREG(7) = ASP;
16870 ASP = res;
16871 }
16872 POST_IO
16873 CHECK_INT_TO_JUMP(20)
16874 }
16875 else
16876 {
16877 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16878#ifdef USE_CYCLONE_TIMING
16879 RET(0)
16880#else
16881 RET(4)
16882#endif
16883 }
16884RET(20)
16885}
16886
16887// MOVEaSR
16888OPCODE(0x46FB)
16889{
16890 u32 adr, res;
16891 u32 src, dst;
16892
16893 if (flag_S)
16894 {
16895 adr = GET_PC;
16896 DECODE_EXT_WORD
16897 PRE_IO
16898 READ_WORD_F(adr, res)
16899 SET_SR(res)
16900 if (!flag_S)
16901 {
16902 res = AREG(7);
16903 AREG(7) = ASP;
16904 ASP = res;
16905 }
16906 POST_IO
16907 CHECK_INT_TO_JUMP(22)
16908 }
16909 else
16910 {
16911 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16912#ifdef USE_CYCLONE_TIMING
16913 RET(0)
16914#else
16915 RET(4)
16916#endif
16917 }
16918RET(22)
16919}
16920
16921// MOVEaSR
16922OPCODE(0x46FC)
16923{
16924 u32 adr, res;
16925 u32 src, dst;
16926
16927 if (flag_S)
16928 {
16929 FETCH_WORD(res);
16930 SET_SR(res)
16931 if (!flag_S)
16932 {
16933 res = AREG(7);
16934 AREG(7) = ASP;
16935 ASP = res;
16936 }
16937 CHECK_INT_TO_JUMP(16)
16938 }
16939 else
16940 {
16941 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16942#ifdef USE_CYCLONE_TIMING
16943 RET(0)
16944#else
16945 RET(4)
16946#endif
16947 }
16948RET(16)
16949}
16950
16951// MOVEaSR
16952OPCODE(0x46DF)
16953{
16954 u32 adr, res;
16955 u32 src, dst;
16956
16957 if (flag_S)
16958 {
16959 adr = AREG(7);
16960 AREG(7) += 2;
16961 PRE_IO
16962 READ_WORD_F(adr, res)
16963 SET_SR(res)
16964 if (!flag_S)
16965 {
16966 res = AREG(7);
16967 AREG(7) = ASP;
16968 ASP = res;
16969 }
16970 POST_IO
16971 CHECK_INT_TO_JUMP(16)
16972 }
16973 else
16974 {
16975 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
16976#ifdef USE_CYCLONE_TIMING
16977 RET(0)
16978#else
16979 RET(4)
16980#endif
16981 }
16982RET(16)
16983}
16984
16985// MOVEaSR
16986OPCODE(0x46E7)
16987{
16988 u32 adr, res;
16989 u32 src, dst;
16990
16991 if (flag_S)
16992 {
16993 adr = AREG(7) - 2;
16994 AREG(7) = adr;
16995 PRE_IO
16996 READ_WORD_F(adr, res)
16997 SET_SR(res)
16998 if (!flag_S)
16999 {
17000 res = AREG(7);
17001 AREG(7) = ASP;
17002 ASP = res;
17003 }
17004 POST_IO
17005 CHECK_INT_TO_JUMP(18)
17006 }
17007 else
17008 {
17009 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
17010#ifdef USE_CYCLONE_TIMING
17011 RET(0)
17012#else
17013 RET(4)
17014#endif
17015 }
17016RET(18)
17017}
17018
17019// NBCD
17020OPCODE(0x4800)
17021{
17022 u32 adr, res;
17023 u32 src, dst;
17024
17025 dst = DREGu8((Opcode >> 0) & 7);
17026 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17027
17028 if (res != 0)
17029 {
17030 flag_V = res;
17031 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17032 res = (res + 0x9a) & 0xFF;
17033 DREGu8((Opcode >> 0) & 7) = res;
17034 flag_V &= ~res;
17035 flag_NotZ |= res;
17036 flag_X = flag_C = M68K_SR_C;
17037 }
17038 else flag_V = flag_X = flag_C = 0;
17039 flag_N = res;
17040RET(6)
17041}
17042
17043// NBCD
17044OPCODE(0x4810)
17045{
17046 u32 adr, res;
17047 u32 src, dst;
17048
17049 adr = AREG((Opcode >> 0) & 7);
17050 PRE_IO
17051 READ_BYTE_F(adr, dst)
17052 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17053
17054 if (res != 0)
17055 {
17056 flag_V = res;
17057 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17058 res = (res + 0x9a) & 0xFF;
17059 WRITE_BYTE_F(adr, res)
17060 flag_V &= ~res;
17061 flag_NotZ |= res;
17062 flag_X = flag_C = M68K_SR_C;
17063 }
17064 else flag_V = flag_X = flag_C = 0;
17065 flag_N = res;
17066 POST_IO
17067RET(12)
17068}
17069
17070// NBCD
17071OPCODE(0x4818)
17072{
17073 u32 adr, res;
17074 u32 src, dst;
17075
17076 adr = AREG((Opcode >> 0) & 7);
17077 AREG((Opcode >> 0) & 7) += 1;
17078 PRE_IO
17079 READ_BYTE_F(adr, dst)
17080 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17081
17082 if (res != 0)
17083 {
17084 flag_V = res;
17085 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17086 res = (res + 0x9a) & 0xFF;
17087 WRITE_BYTE_F(adr, res)
17088 flag_V &= ~res;
17089 flag_NotZ |= res;
17090 flag_X = flag_C = M68K_SR_C;
17091 }
17092 else flag_V = flag_X = flag_C = 0;
17093 flag_N = res;
17094 POST_IO
17095RET(12)
17096}
17097
17098// NBCD
17099OPCODE(0x4820)
17100{
17101 u32 adr, res;
17102 u32 src, dst;
17103
17104 adr = AREG((Opcode >> 0) & 7) - 1;
17105 AREG((Opcode >> 0) & 7) = adr;
17106 PRE_IO
17107 READ_BYTE_F(adr, dst)
17108 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17109
17110 if (res != 0)
17111 {
17112 flag_V = res;
17113 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17114 res = (res + 0x9a) & 0xFF;
17115 WRITE_BYTE_F(adr, res)
17116 flag_V &= ~res;
17117 flag_NotZ |= res;
17118 flag_X = flag_C = M68K_SR_C;
17119 }
17120 else flag_V = flag_X = flag_C = 0;
17121 flag_N = res;
17122 POST_IO
17123RET(14)
17124}
17125
17126// NBCD
17127OPCODE(0x4828)
17128{
17129 u32 adr, res;
17130 u32 src, dst;
17131
17132 FETCH_SWORD(adr);
17133 adr += AREG((Opcode >> 0) & 7);
17134 PRE_IO
17135 READ_BYTE_F(adr, dst)
17136 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17137
17138 if (res != 0)
17139 {
17140 flag_V = res;
17141 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17142 res = (res + 0x9a) & 0xFF;
17143 WRITE_BYTE_F(adr, res)
17144 flag_V &= ~res;
17145 flag_NotZ |= res;
17146 flag_X = flag_C = M68K_SR_C;
17147 }
17148 else flag_V = flag_X = flag_C = 0;
17149 flag_N = res;
17150 POST_IO
17151RET(16)
17152}
17153
17154// NBCD
17155OPCODE(0x4830)
17156{
17157 u32 adr, res;
17158 u32 src, dst;
17159
17160 adr = AREG((Opcode >> 0) & 7);
17161 DECODE_EXT_WORD
17162 PRE_IO
17163 READ_BYTE_F(adr, dst)
17164 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17165
17166 if (res != 0)
17167 {
17168 flag_V = res;
17169 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17170 res = (res + 0x9a) & 0xFF;
17171 WRITE_BYTE_F(adr, res)
17172 flag_V &= ~res;
17173 flag_NotZ |= res;
17174 flag_X = flag_C = M68K_SR_C;
17175 }
17176 else flag_V = flag_X = flag_C = 0;
17177 flag_N = res;
17178 POST_IO
17179RET(18)
17180}
17181
17182// NBCD
17183OPCODE(0x4838)
17184{
17185 u32 adr, res;
17186 u32 src, dst;
17187
17188 FETCH_SWORD(adr);
17189 PRE_IO
17190 READ_BYTE_F(adr, dst)
17191 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17192
17193 if (res != 0)
17194 {
17195 flag_V = res;
17196 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17197 res = (res + 0x9a) & 0xFF;
17198 WRITE_BYTE_F(adr, res)
17199 flag_V &= ~res;
17200 flag_NotZ |= res;
17201 flag_X = flag_C = M68K_SR_C;
17202 }
17203 else flag_V = flag_X = flag_C = 0;
17204 flag_N = res;
17205 POST_IO
17206RET(16)
17207}
17208
17209// NBCD
17210OPCODE(0x4839)
17211{
17212 u32 adr, res;
17213 u32 src, dst;
17214
17215 FETCH_LONG(adr);
17216 PRE_IO
17217 READ_BYTE_F(adr, dst)
17218 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17219
17220 if (res != 0)
17221 {
17222 flag_V = res;
17223 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17224 res = (res + 0x9a) & 0xFF;
17225 WRITE_BYTE_F(adr, res)
17226 flag_V &= ~res;
17227 flag_NotZ |= res;
17228 flag_X = flag_C = M68K_SR_C;
17229 }
17230 else flag_V = flag_X = flag_C = 0;
17231 flag_N = res;
17232 POST_IO
17233RET(20)
17234}
17235
17236// NBCD
17237OPCODE(0x481F)
17238{
17239 u32 adr, res;
17240 u32 src, dst;
17241
17242 adr = AREG(7);
17243 AREG(7) += 2;
17244 PRE_IO
17245 READ_BYTE_F(adr, dst)
17246 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17247
17248 if (res != 0)
17249 {
17250 flag_V = res;
17251 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17252 res = (res + 0x9a) & 0xFF;
17253 WRITE_BYTE_F(adr, res)
17254 flag_V &= ~res;
17255 flag_NotZ |= res;
17256 flag_X = flag_C = M68K_SR_C;
17257 }
17258 else flag_V = flag_X = flag_C = 0;
17259 flag_N = res;
17260 POST_IO
17261RET(12)
17262}
17263
17264// NBCD
17265OPCODE(0x4827)
17266{
17267 u32 adr, res;
17268 u32 src, dst;
17269
17270 adr = AREG(7) - 2;
17271 AREG(7) = adr;
17272 PRE_IO
17273 READ_BYTE_F(adr, dst)
17274 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
17275
17276 if (res != 0)
17277 {
17278 flag_V = res;
17279 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17280 res = (res + 0x9a) & 0xFF;
17281 WRITE_BYTE_F(adr, res)
17282 flag_V &= ~res;
17283 flag_NotZ |= res;
17284 flag_X = flag_C = M68K_SR_C;
17285 }
17286 else flag_V = flag_X = flag_C = 0;
17287 flag_N = res;
17288 POST_IO
17289RET(14)
17290}
17291
17292// PEA
17293OPCODE(0x4850)
17294{
17295 u32 adr, res;
17296 u32 src, dst;
17297
17298 adr = AREG((Opcode >> 0) & 7);
17299 PRE_IO
17300 PUSH_32_F(adr)
17301 POST_IO
17302RET(12)
17303}
17304
17305// PEA
17306OPCODE(0x4868)
17307{
17308 u32 adr, res;
17309 u32 src, dst;
17310
17311 FETCH_SWORD(adr);
17312 adr += AREG((Opcode >> 0) & 7);
17313 PRE_IO
17314 PUSH_32_F(adr)
17315 POST_IO
17316RET(16)
17317}
17318
17319// PEA
17320OPCODE(0x4870)
17321{
17322 u32 adr, res;
17323 u32 src, dst;
17324
17325 adr = AREG((Opcode >> 0) & 7);
17326 DECODE_EXT_WORD
17327 PRE_IO
17328 PUSH_32_F(adr)
17329 POST_IO
17330RET(20)
17331}
17332
17333// PEA
17334OPCODE(0x4878)
17335{
17336 u32 adr, res;
17337 u32 src, dst;
17338
17339 FETCH_SWORD(adr);
17340 PRE_IO
17341 PUSH_32_F(adr)
17342 POST_IO
17343RET(16)
17344}
17345
17346// PEA
17347OPCODE(0x4879)
17348{
17349 u32 adr, res;
17350 u32 src, dst;
17351
17352 FETCH_LONG(adr);
17353 PRE_IO
17354 PUSH_32_F(adr)
17355 POST_IO
17356RET(20)
17357}
17358
17359// PEA
17360OPCODE(0x487A)
17361{
17362 u32 adr, res;
17363 u32 src, dst;
17364
17365 adr = GET_SWORD + GET_PC;
17366 PC++;
17367 PRE_IO
17368 PUSH_32_F(adr)
17369 POST_IO
17370RET(16)
17371}
17372
17373// PEA
17374OPCODE(0x487B)
17375{
17376 u32 adr, res;
17377 u32 src, dst;
17378
17379 adr = GET_PC;
17380 DECODE_EXT_WORD
17381 PRE_IO
17382 PUSH_32_F(adr)
17383 POST_IO
17384RET(20)
17385}
17386
17387// SWAP
17388OPCODE(0x4840)
17389{
17390 u32 adr, res;
17391 u32 src, dst;
17392
17393 res = DREGu32((Opcode >> 0) & 7);
17394 res = (res >> 16) | (res << 16);
17395 flag_C = 0;
17396 flag_V = 0;
17397 flag_NotZ = res;
17398 flag_N = res >> 24;
17399 DREGu32((Opcode >> 0) & 7) = res;
17400RET(4)
17401}
17402
17403// MOVEMRa
17404OPCODE(0x4890)
17405{
17406 u32 adr, res;
17407 u32 src, dst;
17408
17409 u32 *psrc;
17410
17411 FETCH_WORD(res);
17412 adr = AREG((Opcode >> 0) & 7);
17413 psrc = &DREGu32(0);
17414 dst = adr;
17415 PRE_IO
17416 do
17417 {
17418 if (res & 1)
17419 {
17420 WRITE_WORD_F(adr, *psrc)
17421 adr += 2;
17422 }
17423 psrc++;
17424 } while (res >>= 1);
17425 POST_IO
17426 ctx->io_cycle_counter -= (adr - dst) * 2;
17427#ifdef USE_CYCLONE_TIMING
17428RET(8)
17429#else
17430RET(12)
17431#endif
17432}
17433
17434// MOVEMRa
17435OPCODE(0x48A0)
17436{
17437 u32 adr, res;
17438 u32 src, dst;
17439
17440 u32 *psrc;
17441
17442 FETCH_WORD(res);
17443 adr = AREG((Opcode >> 0) & 7);
17444 psrc = &AREGu32(7);
17445 dst = adr;
17446 PRE_IO
17447 do
17448 {
17449 if (res & 1)
17450 {
17451 adr -= 2;
17452 WRITE_WORD_F(adr, *psrc)
17453 }
17454 psrc--;
17455 } while (res >>= 1);
17456 AREG((Opcode >> 0) & 7) = adr;
17457 POST_IO
17458 ctx->io_cycle_counter -= (dst - adr) * 2;
17459RET(8)
17460}
17461
17462// MOVEMRa
17463OPCODE(0x48A8)
17464{
17465 u32 adr, res;
17466 u32 src, dst;
17467
17468 u32 *psrc;
17469
17470 FETCH_WORD(res);
17471 FETCH_SWORD(adr);
17472 adr += AREG((Opcode >> 0) & 7);
17473 psrc = &DREGu32(0);
17474 dst = adr;
17475 PRE_IO
17476 do
17477 {
17478 if (res & 1)
17479 {
17480 WRITE_WORD_F(adr, *psrc)
17481 adr += 2;
17482 }
17483 psrc++;
17484 } while (res >>= 1);
17485 POST_IO
17486 ctx->io_cycle_counter -= (adr - dst) * 2;
17487#ifdef USE_CYCLONE_TIMING
17488RET(12)
17489#else
17490RET(20)
17491#endif
17492}
17493
17494// MOVEMRa
17495OPCODE(0x48B0)
17496{
17497 u32 adr, res;
17498 u32 src, dst;
17499
17500 u32 *psrc;
17501
17502 FETCH_WORD(res);
17503 adr = AREG((Opcode >> 0) & 7);
17504 DECODE_EXT_WORD
17505 psrc = &DREGu32(0);
17506 dst = adr;
17507 PRE_IO
17508 do
17509 {
17510 if (res & 1)
17511 {
17512 WRITE_WORD_F(adr, *psrc)
17513 adr += 2;
17514 }
17515 psrc++;
17516 } while (res >>= 1);
17517 POST_IO
17518 ctx->io_cycle_counter -= (adr - dst) * 2;
17519#ifdef USE_CYCLONE_TIMING
17520RET(14)
17521#else
17522RET(24)
17523#endif
17524}
17525
17526// MOVEMRa
17527OPCODE(0x48B8)
17528{
17529 u32 adr, res;
17530 u32 src, dst;
17531
17532 u32 *psrc;
17533
17534 FETCH_WORD(res);
17535 FETCH_SWORD(adr);
17536 psrc = &DREGu32(0);
17537 dst = adr;
17538 PRE_IO
17539 do
17540 {
17541 if (res & 1)
17542 {
17543 WRITE_WORD_F(adr, *psrc)
17544 adr += 2;
17545 }
17546 psrc++;
17547 } while (res >>= 1);
17548 POST_IO
17549 ctx->io_cycle_counter -= (adr - dst) * 2;
17550#ifdef USE_CYCLONE_TIMING
17551RET(12)
17552#else
17553RET(20)
17554#endif
17555}
17556
17557// MOVEMRa
17558OPCODE(0x48B9)
17559{
17560 u32 adr, res;
17561 u32 src, dst;
17562
17563 u32 *psrc;
17564
17565 FETCH_WORD(res);
17566 FETCH_LONG(adr);
17567 psrc = &DREGu32(0);
17568 dst = adr;
17569 PRE_IO
17570 do
17571 {
17572 if (res & 1)
17573 {
17574 WRITE_WORD_F(adr, *psrc)
17575 adr += 2;
17576 }
17577 psrc++;
17578 } while (res >>= 1);
17579 POST_IO
17580 ctx->io_cycle_counter -= (adr - dst) * 2;
17581#ifdef USE_CYCLONE_TIMING
17582RET(16)
17583#else
17584RET(28)
17585#endif
17586}
17587
17588// MOVEMRa
17589OPCODE(0x48A7)
17590{
17591 u32 adr, res;
17592 u32 src, dst;
17593
17594 u32 *psrc;
17595
17596 FETCH_WORD(res);
17597 adr = AREG(7);
17598 psrc = &AREGu32(7);
17599 dst = adr;
17600 PRE_IO
17601 do
17602 {
17603 if (res & 1)
17604 {
17605 adr -= 2;
17606 WRITE_WORD_F(adr, *psrc)
17607 }
17608 psrc--;
17609 } while (res >>= 1);
17610 AREG(7) = adr;
17611 POST_IO
17612 ctx->io_cycle_counter -= (dst - adr) * 2;
17613RET(8)
17614}
17615
17616// MOVEMRa
17617OPCODE(0x48D0)
17618{
17619 u32 adr, res;
17620 u32 src, dst;
17621
17622 u32 *psrc;
17623
17624 FETCH_WORD(res);
17625 adr = AREG((Opcode >> 0) & 7);
17626 psrc = &DREGu32(0);
17627 dst = adr;
17628 PRE_IO
17629 do
17630 {
17631 if (res & 1)
17632 {
17633 WRITE_LONG_F(adr, *psrc)
17634 adr += 4;
17635 }
17636 psrc++;
17637 } while (res >>= 1);
17638 POST_IO
17639 ctx->io_cycle_counter -= (adr - dst) * 2;
17640#ifdef USE_CYCLONE_TIMING
17641RET(8)
17642#else
17643RET(16)
17644#endif
17645}
17646
17647// MOVEMRa
17648OPCODE(0x48E0)
17649{
17650 u32 adr, res;
17651 u32 src, dst;
17652
17653 u32 *psrc;
17654
17655 FETCH_WORD(res);
17656 adr = AREG((Opcode >> 0) & 7);
17657 psrc = &AREGu32(7);
17658 dst = adr;
17659 PRE_IO
17660 do
17661 {
17662 if (res & 1)
17663 {
17664 adr -= 4;
17665 WRITE_LONG_DEC_F(adr, *psrc)
17666 }
17667 psrc--;
17668 } while (res >>= 1);
17669 AREG((Opcode >> 0) & 7) = adr;
17670 POST_IO
17671 ctx->io_cycle_counter -= (dst - adr) * 2;
17672RET(8)
17673}
17674
17675// MOVEMRa
17676OPCODE(0x48E8)
17677{
17678 u32 adr, res;
17679 u32 src, dst;
17680
17681 u32 *psrc;
17682
17683 FETCH_WORD(res);
17684 FETCH_SWORD(adr);
17685 adr += AREG((Opcode >> 0) & 7);
17686 psrc = &DREGu32(0);
17687 dst = adr;
17688 PRE_IO
17689 do
17690 {
17691 if (res & 1)
17692 {
17693 WRITE_LONG_F(adr, *psrc)
17694 adr += 4;
17695 }
17696 psrc++;
17697 } while (res >>= 1);
17698 POST_IO
17699 ctx->io_cycle_counter -= (adr - dst) * 2;
17700#ifdef USE_CYCLONE_TIMING
17701RET(12)
17702#else
17703RET(24)
17704#endif
17705}
17706
17707// MOVEMRa
17708OPCODE(0x48F0)
17709{
17710 u32 adr, res;
17711 u32 src, dst;
17712
17713 u32 *psrc;
17714
17715 FETCH_WORD(res);
17716 adr = AREG((Opcode >> 0) & 7);
17717 DECODE_EXT_WORD
17718 psrc = &DREGu32(0);
17719 dst = adr;
17720 PRE_IO
17721 do
17722 {
17723 if (res & 1)
17724 {
17725 WRITE_LONG_F(adr, *psrc)
17726 adr += 4;
17727 }
17728 psrc++;
17729 } while (res >>= 1);
17730 POST_IO
17731 ctx->io_cycle_counter -= (adr - dst) * 2;
17732#ifdef USE_CYCLONE_TIMING
17733RET(14)
17734#else
17735RET(28)
17736#endif
17737}
17738
17739// MOVEMRa
17740OPCODE(0x48F8)
17741{
17742 u32 adr, res;
17743 u32 src, dst;
17744
17745 u32 *psrc;
17746
17747 FETCH_WORD(res);
17748 FETCH_SWORD(adr);
17749 psrc = &DREGu32(0);
17750 dst = adr;
17751 PRE_IO
17752 do
17753 {
17754 if (res & 1)
17755 {
17756 WRITE_LONG_F(adr, *psrc)
17757 adr += 4;
17758 }
17759 psrc++;
17760 } while (res >>= 1);
17761 POST_IO
17762 ctx->io_cycle_counter -= (adr - dst) * 2;
17763#ifdef USE_CYCLONE_TIMING
17764RET(12)
17765#else
17766RET(24)
17767#endif
17768}
17769
17770// MOVEMRa
17771OPCODE(0x48F9)
17772{
17773 u32 adr, res;
17774 u32 src, dst;
17775
17776 u32 *psrc;
17777
17778 FETCH_WORD(res);
17779 FETCH_LONG(adr);
17780 psrc = &DREGu32(0);
17781 dst = adr;
17782 PRE_IO
17783 do
17784 {
17785 if (res & 1)
17786 {
17787 WRITE_LONG_F(adr, *psrc)
17788 adr += 4;
17789 }
17790 psrc++;
17791 } while (res >>= 1);
17792 POST_IO
17793 ctx->io_cycle_counter -= (adr - dst) * 2;
17794#ifdef USE_CYCLONE_TIMING
17795RET(16)
17796#else
17797RET(32)
17798#endif
17799}
17800
17801// MOVEMRa
17802OPCODE(0x48E7)
17803{
17804 u32 adr, res;
17805 u32 src, dst;
17806
17807 u32 *psrc;
17808
17809 FETCH_WORD(res);
17810 adr = AREG(7);
17811 psrc = &AREGu32(7);
17812 dst = adr;
17813 PRE_IO
17814 do
17815 {
17816 if (res & 1)
17817 {
17818 adr -= 4;
17819 WRITE_LONG_DEC_F(adr, *psrc)
17820 }
17821 psrc--;
17822 } while (res >>= 1);
17823 AREG(7) = adr;
17824 POST_IO
17825 ctx->io_cycle_counter -= (dst - adr) * 2;
17826RET(8)
17827}
17828
17829// EXT
17830OPCODE(0x4880)
17831{
17832 u32 adr, res;
17833 u32 src, dst;
17834
17835 res = (s32)DREGs8((Opcode >> 0) & 7);
17836 flag_C = 0;
17837 flag_V = 0;
17838 flag_NotZ = res;
17839 flag_N = res;
17840 DREGu16((Opcode >> 0) & 7) = res;
17841RET(4)
17842}
17843
17844// EXT
17845OPCODE(0x48C0)
17846{
17847 u32 adr, res;
17848 u32 src, dst;
17849
17850 res = (s32)DREGs16((Opcode >> 0) & 7);
17851 flag_C = 0;
17852 flag_V = 0;
17853 flag_NotZ = res;
17854 flag_N = res >> 8;
17855 DREGu32((Opcode >> 0) & 7) = res;
17856RET(4)
17857}
17858
17859// TST
17860OPCODE(0x4A00)
17861{
17862 u32 adr, res;
17863 u32 src, dst;
17864
17865 res = DREGu8((Opcode >> 0) & 7);
17866 flag_C = 0;
17867 flag_V = 0;
17868 flag_NotZ = res;
17869 flag_N = res;
17870RET(4)
17871}
17872
17873// TST
17874OPCODE(0x4A10)
17875{
17876 u32 adr, res;
17877 u32 src, dst;
17878
17879 adr = AREG((Opcode >> 0) & 7);
17880 PRE_IO
17881 READ_BYTE_F(adr, res)
17882 flag_C = 0;
17883 flag_V = 0;
17884 flag_NotZ = res;
17885 flag_N = res;
17886 POST_IO
17887RET(8)
17888}
17889
17890// TST
17891OPCODE(0x4A18)
17892{
17893 u32 adr, res;
17894 u32 src, dst;
17895
17896 adr = AREG((Opcode >> 0) & 7);
17897 AREG((Opcode >> 0) & 7) += 1;
17898 PRE_IO
17899 READ_BYTE_F(adr, res)
17900 flag_C = 0;
17901 flag_V = 0;
17902 flag_NotZ = res;
17903 flag_N = res;
17904 POST_IO
17905RET(8)
17906}
17907
17908// TST
17909OPCODE(0x4A20)
17910{
17911 u32 adr, res;
17912 u32 src, dst;
17913
17914 adr = AREG((Opcode >> 0) & 7) - 1;
17915 AREG((Opcode >> 0) & 7) = adr;
17916 PRE_IO
17917 READ_BYTE_F(adr, res)
17918 flag_C = 0;
17919 flag_V = 0;
17920 flag_NotZ = res;
17921 flag_N = res;
17922 POST_IO
17923RET(10)
17924}
17925
17926// TST
17927OPCODE(0x4A28)
17928{
17929 u32 adr, res;
17930 u32 src, dst;
17931
17932 FETCH_SWORD(adr);
17933 adr += AREG((Opcode >> 0) & 7);
17934 PRE_IO
17935 READ_BYTE_F(adr, res)
17936 flag_C = 0;
17937 flag_V = 0;
17938 flag_NotZ = res;
17939 flag_N = res;
17940 POST_IO
17941RET(12)
17942}
17943
17944// TST
17945OPCODE(0x4A30)
17946{
17947 u32 adr, res;
17948 u32 src, dst;
17949
17950 adr = AREG((Opcode >> 0) & 7);
17951 DECODE_EXT_WORD
17952 PRE_IO
17953 READ_BYTE_F(adr, res)
17954 flag_C = 0;
17955 flag_V = 0;
17956 flag_NotZ = res;
17957 flag_N = res;
17958 POST_IO
17959RET(14)
17960}
17961
17962// TST
17963OPCODE(0x4A38)
17964{
17965 u32 adr, res;
17966 u32 src, dst;
17967
17968 FETCH_SWORD(adr);
17969 PRE_IO
17970 READ_BYTE_F(adr, res)
17971 flag_C = 0;
17972 flag_V = 0;
17973 flag_NotZ = res;
17974 flag_N = res;
17975 POST_IO
17976RET(12)
17977}
17978
17979// TST
17980OPCODE(0x4A39)
17981{
17982 u32 adr, res;
17983 u32 src, dst;
17984
17985 FETCH_LONG(adr);
17986 PRE_IO
17987 READ_BYTE_F(adr, res)
17988 flag_C = 0;
17989 flag_V = 0;
17990 flag_NotZ = res;
17991 flag_N = res;
17992 POST_IO
17993RET(16)
17994}
17995
17996// TST
17997OPCODE(0x4A1F)
17998{
17999 u32 adr, res;
18000 u32 src, dst;
18001
18002 adr = AREG(7);
18003 AREG(7) += 2;
18004 PRE_IO
18005 READ_BYTE_F(adr, res)
18006 flag_C = 0;
18007 flag_V = 0;
18008 flag_NotZ = res;
18009 flag_N = res;
18010 POST_IO
18011RET(8)
18012}
18013
18014// TST
18015OPCODE(0x4A27)
18016{
18017 u32 adr, res;
18018 u32 src, dst;
18019
18020 adr = AREG(7) - 2;
18021 AREG(7) = adr;
18022 PRE_IO
18023 READ_BYTE_F(adr, res)
18024 flag_C = 0;
18025 flag_V = 0;
18026 flag_NotZ = res;
18027 flag_N = res;
18028 POST_IO
18029RET(10)
18030}
18031
18032// TST
18033OPCODE(0x4A40)
18034{
18035 u32 adr, res;
18036 u32 src, dst;
18037
18038 res = DREGu16((Opcode >> 0) & 7);
18039 flag_C = 0;
18040 flag_V = 0;
18041 flag_NotZ = res;
18042 flag_N = res >> 8;
18043RET(4)
18044}
18045
18046// TST
18047OPCODE(0x4A50)
18048{
18049 u32 adr, res;
18050 u32 src, dst;
18051
18052 adr = AREG((Opcode >> 0) & 7);
18053 PRE_IO
18054 READ_WORD_F(adr, res)
18055 flag_C = 0;
18056 flag_V = 0;
18057 flag_NotZ = res;
18058 flag_N = res >> 8;
18059 POST_IO
18060RET(8)
18061}
18062
18063// TST
18064OPCODE(0x4A58)
18065{
18066 u32 adr, res;
18067 u32 src, dst;
18068
18069 adr = AREG((Opcode >> 0) & 7);
18070 AREG((Opcode >> 0) & 7) += 2;
18071 PRE_IO
18072 READ_WORD_F(adr, res)
18073 flag_C = 0;
18074 flag_V = 0;
18075 flag_NotZ = res;
18076 flag_N = res >> 8;
18077 POST_IO
18078RET(8)
18079}
18080
18081// TST
18082OPCODE(0x4A60)
18083{
18084 u32 adr, res;
18085 u32 src, dst;
18086
18087 adr = AREG((Opcode >> 0) & 7) - 2;
18088 AREG((Opcode >> 0) & 7) = adr;
18089 PRE_IO
18090 READ_WORD_F(adr, res)
18091 flag_C = 0;
18092 flag_V = 0;
18093 flag_NotZ = res;
18094 flag_N = res >> 8;
18095 POST_IO
18096RET(10)
18097}
18098
18099// TST
18100OPCODE(0x4A68)
18101{
18102 u32 adr, res;
18103 u32 src, dst;
18104
18105 FETCH_SWORD(adr);
18106 adr += AREG((Opcode >> 0) & 7);
18107 PRE_IO
18108 READ_WORD_F(adr, res)
18109 flag_C = 0;
18110 flag_V = 0;
18111 flag_NotZ = res;
18112 flag_N = res >> 8;
18113 POST_IO
18114RET(12)
18115}
18116
18117// TST
18118OPCODE(0x4A70)
18119{
18120 u32 adr, res;
18121 u32 src, dst;
18122
18123 adr = AREG((Opcode >> 0) & 7);
18124 DECODE_EXT_WORD
18125 PRE_IO
18126 READ_WORD_F(adr, res)
18127 flag_C = 0;
18128 flag_V = 0;
18129 flag_NotZ = res;
18130 flag_N = res >> 8;
18131 POST_IO
18132RET(14)
18133}
18134
18135// TST
18136OPCODE(0x4A78)
18137{
18138 u32 adr, res;
18139 u32 src, dst;
18140
18141 FETCH_SWORD(adr);
18142 PRE_IO
18143 READ_WORD_F(adr, res)
18144 flag_C = 0;
18145 flag_V = 0;
18146 flag_NotZ = res;
18147 flag_N = res >> 8;
18148 POST_IO
18149RET(12)
18150}
18151
18152// TST
18153OPCODE(0x4A79)
18154{
18155 u32 adr, res;
18156 u32 src, dst;
18157
18158 FETCH_LONG(adr);
18159 PRE_IO
18160 READ_WORD_F(adr, res)
18161 flag_C = 0;
18162 flag_V = 0;
18163 flag_NotZ = res;
18164 flag_N = res >> 8;
18165 POST_IO
18166RET(16)
18167}
18168
18169// TST
18170OPCODE(0x4A5F)
18171{
18172 u32 adr, res;
18173 u32 src, dst;
18174
18175 adr = AREG(7);
18176 AREG(7) += 2;
18177 PRE_IO
18178 READ_WORD_F(adr, res)
18179 flag_C = 0;
18180 flag_V = 0;
18181 flag_NotZ = res;
18182 flag_N = res >> 8;
18183 POST_IO
18184RET(8)
18185}
18186
18187// TST
18188OPCODE(0x4A67)
18189{
18190 u32 adr, res;
18191 u32 src, dst;
18192
18193 adr = AREG(7) - 2;
18194 AREG(7) = adr;
18195 PRE_IO
18196 READ_WORD_F(adr, res)
18197 flag_C = 0;
18198 flag_V = 0;
18199 flag_NotZ = res;
18200 flag_N = res >> 8;
18201 POST_IO
18202RET(10)
18203}
18204
18205// TST
18206OPCODE(0x4A80)
18207{
18208 u32 adr, res;
18209 u32 src, dst;
18210
18211 res = DREGu32((Opcode >> 0) & 7);
18212 flag_C = 0;
18213 flag_V = 0;
18214 flag_NotZ = res;
18215 flag_N = res >> 24;
18216RET(4)
18217}
18218
18219// TST
18220OPCODE(0x4A90)
18221{
18222 u32 adr, res;
18223 u32 src, dst;
18224
18225 adr = AREG((Opcode >> 0) & 7);
18226 PRE_IO
18227 READ_LONG_F(adr, res)
18228 flag_C = 0;
18229 flag_V = 0;
18230 flag_NotZ = res;
18231 flag_N = res >> 24;
18232 POST_IO
18233RET(12)
18234}
18235
18236// TST
18237OPCODE(0x4A98)
18238{
18239 u32 adr, res;
18240 u32 src, dst;
18241
18242 adr = AREG((Opcode >> 0) & 7);
18243 AREG((Opcode >> 0) & 7) += 4;
18244 PRE_IO
18245 READ_LONG_F(adr, res)
18246 flag_C = 0;
18247 flag_V = 0;
18248 flag_NotZ = res;
18249 flag_N = res >> 24;
18250 POST_IO
18251RET(12)
18252}
18253
18254// TST
18255OPCODE(0x4AA0)
18256{
18257 u32 adr, res;
18258 u32 src, dst;
18259
18260 adr = AREG((Opcode >> 0) & 7) - 4;
18261 AREG((Opcode >> 0) & 7) = adr;
18262 PRE_IO
18263 READ_LONG_F(adr, res)
18264 flag_C = 0;
18265 flag_V = 0;
18266 flag_NotZ = res;
18267 flag_N = res >> 24;
18268 POST_IO
18269RET(14)
18270}
18271
18272// TST
18273OPCODE(0x4AA8)
18274{
18275 u32 adr, res;
18276 u32 src, dst;
18277
18278 FETCH_SWORD(adr);
18279 adr += AREG((Opcode >> 0) & 7);
18280 PRE_IO
18281 READ_LONG_F(adr, res)
18282 flag_C = 0;
18283 flag_V = 0;
18284 flag_NotZ = res;
18285 flag_N = res >> 24;
18286 POST_IO
18287RET(16)
18288}
18289
18290// TST
18291OPCODE(0x4AB0)
18292{
18293 u32 adr, res;
18294 u32 src, dst;
18295
18296 adr = AREG((Opcode >> 0) & 7);
18297 DECODE_EXT_WORD
18298 PRE_IO
18299 READ_LONG_F(adr, res)
18300 flag_C = 0;
18301 flag_V = 0;
18302 flag_NotZ = res;
18303 flag_N = res >> 24;
18304 POST_IO
18305RET(18)
18306}
18307
18308// TST
18309OPCODE(0x4AB8)
18310{
18311 u32 adr, res;
18312 u32 src, dst;
18313
18314 FETCH_SWORD(adr);
18315 PRE_IO
18316 READ_LONG_F(adr, res)
18317 flag_C = 0;
18318 flag_V = 0;
18319 flag_NotZ = res;
18320 flag_N = res >> 24;
18321 POST_IO
18322RET(16)
18323}
18324
18325// TST
18326OPCODE(0x4AB9)
18327{
18328 u32 adr, res;
18329 u32 src, dst;
18330
18331 FETCH_LONG(adr);
18332 PRE_IO
18333 READ_LONG_F(adr, res)
18334 flag_C = 0;
18335 flag_V = 0;
18336 flag_NotZ = res;
18337 flag_N = res >> 24;
18338 POST_IO
18339RET(20)
18340}
18341
18342// TST
18343OPCODE(0x4A9F)
18344{
18345 u32 adr, res;
18346 u32 src, dst;
18347
18348 adr = AREG(7);
18349 AREG(7) += 4;
18350 PRE_IO
18351 READ_LONG_F(adr, res)
18352 flag_C = 0;
18353 flag_V = 0;
18354 flag_NotZ = res;
18355 flag_N = res >> 24;
18356 POST_IO
18357RET(12)
18358}
18359
18360// TST
18361OPCODE(0x4AA7)
18362{
18363 u32 adr, res;
18364 u32 src, dst;
18365
18366 adr = AREG(7) - 4;
18367 AREG(7) = adr;
18368 PRE_IO
18369 READ_LONG_F(adr, res)
18370 flag_C = 0;
18371 flag_V = 0;
18372 flag_NotZ = res;
18373 flag_N = res >> 24;
18374 POST_IO
18375RET(14)
18376}
18377
18378// TAS
18379OPCODE(0x4AC0)
18380{
18381 u32 adr, res;
18382 u32 src, dst;
18383
18384 res = DREGu8((Opcode >> 0) & 7);
18385 flag_C = 0;
18386 flag_V = 0;
18387 flag_NotZ = res;
18388 flag_N = res;
18389 res |= 0x80;
18390 DREGu8((Opcode >> 0) & 7) = res;
18391RET(4)
18392}
18393
18394// TAS
18395OPCODE(0x4AD0)
18396{
18397 u32 adr, res;
18398 u32 src, dst;
18399
18400 adr = AREG((Opcode >> 0) & 7);
18401 PRE_IO
18402 READ_BYTE_F(adr, res)
18403 flag_C = 0;
18404 flag_V = 0;
18405 flag_NotZ = res;
18406 flag_N = res;
18407#ifdef PICODRIVE_HACK
18408 if (ctx == &PicoCpuFS68k) {
18409 res |= 0x80;
18410 WRITE_BYTE_F(adr, res);
18411 }
18412#endif
18413
18414 POST_IO
18415#ifdef USE_CYCLONE_TIMING
18416RET(14)
18417#else
18418RET(8)
18419#endif
18420}
18421
18422// TAS
18423OPCODE(0x4AD8)
18424{
18425 u32 adr, res;
18426 u32 src, dst;
18427
18428 adr = AREG((Opcode >> 0) & 7);
18429 AREG((Opcode >> 0) & 7) += 1;
18430 PRE_IO
18431 READ_BYTE_F(adr, res)
18432 flag_C = 0;
18433 flag_V = 0;
18434 flag_NotZ = res;
18435 flag_N = res;
18436
18437#ifdef PICODRIVE_HACK
18438 if (ctx == &PicoCpuFS68k) {
18439 res |= 0x80;
18440 WRITE_BYTE_F(adr, res);
18441 }
18442#endif
18443
18444 POST_IO
18445#ifdef USE_CYCLONE_TIMING
18446RET(14)
18447#else
18448RET(8)
18449#endif
18450}
18451
18452// TAS
18453OPCODE(0x4AE0)
18454{
18455 u32 adr, res;
18456 u32 src, dst;
18457
18458 adr = AREG((Opcode >> 0) & 7) - 1;
18459 AREG((Opcode >> 0) & 7) = adr;
18460 PRE_IO
18461 READ_BYTE_F(adr, res)
18462 flag_C = 0;
18463 flag_V = 0;
18464 flag_NotZ = res;
18465 flag_N = res;
18466
18467#ifdef PICODRIVE_HACK
18468 if (ctx == &PicoCpuFS68k) {
18469 res |= 0x80;
18470 WRITE_BYTE_F(adr, res);
18471 }
18472#endif
18473
18474 POST_IO
18475#ifdef USE_CYCLONE_TIMING
18476RET(16)
18477#else
18478RET(10)
18479#endif
18480}
18481
18482// TAS
18483OPCODE(0x4AE8)
18484{
18485 u32 adr, res;
18486 u32 src, dst;
18487
18488 FETCH_SWORD(adr);
18489 adr += AREG((Opcode >> 0) & 7);
18490 PRE_IO
18491 READ_BYTE_F(adr, res)
18492 flag_C = 0;
18493 flag_V = 0;
18494 flag_NotZ = res;
18495 flag_N = res;
18496
18497#ifdef PICODRIVE_HACK
18498 if (ctx == &PicoCpuFS68k) {
18499 res |= 0x80;
18500 WRITE_BYTE_F(adr, res);
18501 }
18502#endif
18503
18504 POST_IO
18505#ifdef USE_CYCLONE_TIMING
18506RET(18)
18507#else
18508RET(12)
18509#endif
18510}
18511
18512// TAS
18513OPCODE(0x4AF0)
18514{
18515 u32 adr, res;
18516 u32 src, dst;
18517
18518 adr = AREG((Opcode >> 0) & 7);
18519 DECODE_EXT_WORD
18520 PRE_IO
18521 READ_BYTE_F(adr, res)
18522 flag_C = 0;
18523 flag_V = 0;
18524 flag_NotZ = res;
18525 flag_N = res;
18526
18527#ifdef PICODRIVE_HACK
18528 if (ctx == &PicoCpuFS68k) {
18529 res |= 0x80;
18530 WRITE_BYTE_F(adr, res);
18531 }
18532#endif
18533
18534 POST_IO
18535#ifdef USE_CYCLONE_TIMING
18536RET(20)
18537#else
18538RET(14)
18539#endif
18540}
18541
18542// TAS
18543OPCODE(0x4AF8)
18544{
18545 u32 adr, res;
18546 u32 src, dst;
18547
18548 FETCH_SWORD(adr);
18549 PRE_IO
18550 READ_BYTE_F(adr, res)
18551 flag_C = 0;
18552 flag_V = 0;
18553 flag_NotZ = res;
18554 flag_N = res;
18555
18556#ifdef PICODRIVE_HACK
18557 if (ctx == &PicoCpuFS68k) {
18558 res |= 0x80;
18559 WRITE_BYTE_F(adr, res);
18560 }
18561#endif
18562
18563 POST_IO
18564#ifdef USE_CYCLONE_TIMING
18565RET(18)
18566#else
18567RET(12)
18568#endif
18569}
18570
18571// TAS
18572OPCODE(0x4AF9)
18573{
18574 u32 adr, res;
18575 u32 src, dst;
18576
18577 FETCH_LONG(adr);
18578 PRE_IO
18579 READ_BYTE_F(adr, res)
18580 flag_C = 0;
18581 flag_V = 0;
18582 flag_NotZ = res;
18583 flag_N = res;
18584
18585#ifdef PICODRIVE_HACK
18586 if (ctx == &PicoCpuFS68k) {
18587 res |= 0x80;
18588 WRITE_BYTE_F(adr, res);
18589 }
18590#endif
18591
18592 POST_IO
18593#ifdef USE_CYCLONE_TIMING
18594RET(22)
18595#else
18596RET(16)
18597#endif
18598}
18599
18600// TAS
18601OPCODE(0x4ADF)
18602{
18603 u32 adr, res;
18604 u32 src, dst;
18605
18606 adr = AREG(7);
18607 AREG(7) += 2;
18608 PRE_IO
18609 READ_BYTE_F(adr, res)
18610 flag_C = 0;
18611 flag_V = 0;
18612 flag_NotZ = res;
18613 flag_N = res;
18614
18615#ifdef PICODRIVE_HACK
18616 if (ctx == &PicoCpuFS68k) {
18617 res |= 0x80;
18618 WRITE_BYTE_F(adr, res);
18619 }
18620#endif
18621
18622 POST_IO
18623#ifdef USE_CYCLONE_TIMING
18624RET(14)
18625#else
18626RET(8)
18627#endif
18628}
18629
18630// TAS
18631OPCODE(0x4AE7)
18632{
18633 u32 adr, res;
18634 u32 src, dst;
18635
18636 adr = AREG(7) - 2;
18637 AREG(7) = adr;
18638 PRE_IO
18639 READ_BYTE_F(adr, res)
18640 flag_C = 0;
18641 flag_V = 0;
18642 flag_NotZ = res;
18643 flag_N = res;
18644
18645#ifdef PICODRIVE_HACK
18646 if (ctx == &PicoCpuFS68k) {
18647 res |= 0x80;
18648 WRITE_BYTE_F(adr, res);
18649 }
18650#endif
18651
18652 POST_IO
18653#ifdef USE_CYCLONE_TIMING
18654RET(20)
18655#else
18656RET(8)
18657#endif
18658}
18659
18660// ILLEGAL
18661OPCODE(0x4AFC)
18662{
18663#ifdef PICODRIVE_HACK
18664 extern void SekFinishIdleDet(void);
18665 SekFinishIdleDet();
18666#endif
18667 SET_PC(execute_exception(ctx, M68K_ILLEGAL_INSTRUCTION_EX, GET_PC-2, GET_SR));
18668RET(0)
18669}
18670
18671// ILLEGAL A000-AFFF
18672OPCODE(0xA000)
18673{
18674 SET_PC(execute_exception(ctx, M68K_1010_EX, GET_PC-2, GET_SR));
18675RET(0)
18676}
18677
18678// ILLEGAL F000-FFFF
18679OPCODE(0xF000)
18680{
18681 SET_PC(execute_exception(ctx, M68K_1111_EX, GET_PC-2, GET_SR));
18682RET(0)
18683}
18684
18685// MOVEMaR
18686OPCODE(0x4C90)
18687{
18688 u32 adr, res;
18689 u32 src, dst;
18690
18691 s32 *psrc;
18692
18693 FETCH_WORD(res);
18694 adr = AREG((Opcode >> 0) & 7);
18695 psrc = &DREGs32(0);
18696 dst = adr;
18697 PRE_IO
18698 do
18699 {
18700 if (res & 1)
18701 {
18702 READSX_WORD_F(adr, *psrc)
18703 adr += 2;
18704 }
18705 psrc++;
18706 } while (res >>= 1);
18707 POST_IO
18708 ctx->io_cycle_counter -= (adr - dst) * 2;
18709#ifdef USE_CYCLONE_TIMING
18710RET(12)
18711#else
18712RET(16)
18713#endif
18714}
18715
18716// MOVEMaR
18717OPCODE(0x4C98)
18718{
18719 u32 adr, res;
18720 u32 src, dst;
18721
18722 s32 *psrc;
18723
18724 FETCH_WORD(res);
18725 adr = AREG((Opcode >> 0) & 7);
18726 psrc = &DREGs32(0);
18727 dst = adr;
18728 PRE_IO
18729 do
18730 {
18731 if (res & 1)
18732 {
18733 READSX_WORD_F(adr, *psrc)
18734 adr += 2;
18735 }
18736 psrc++;
18737 } while (res >>= 1);
18738 AREG((Opcode >> 0) & 7) = adr;
18739 POST_IO
18740 ctx->io_cycle_counter -= (adr - dst) * 2;
18741RET(12)
18742}
18743
18744// MOVEMaR
18745OPCODE(0x4CA8)
18746{
18747 u32 adr, res;
18748 u32 src, dst;
18749
18750 s32 *psrc;
18751
18752 FETCH_WORD(res);
18753 FETCH_SWORD(adr);
18754 adr += AREG((Opcode >> 0) & 7);
18755 psrc = &DREGs32(0);
18756 dst = adr;
18757 PRE_IO
18758 do
18759 {
18760 if (res & 1)
18761 {
18762 READSX_WORD_F(adr, *psrc)
18763 adr += 2;
18764 }
18765 psrc++;
18766 } while (res >>= 1);
18767 POST_IO
18768 ctx->io_cycle_counter -= (adr - dst) * 2;
18769#ifdef USE_CYCLONE_TIMING
18770RET(16)
18771#else
18772RET(24)
18773#endif
18774}
18775
18776// MOVEMaR
18777OPCODE(0x4CB0)
18778{
18779 u32 adr, res;
18780 u32 src, dst;
18781
18782 s32 *psrc;
18783
18784 FETCH_WORD(res);
18785 adr = AREG((Opcode >> 0) & 7);
18786 DECODE_EXT_WORD
18787 psrc = &DREGs32(0);
18788 dst = adr;
18789 PRE_IO
18790 do
18791 {
18792 if (res & 1)
18793 {
18794 READSX_WORD_F(adr, *psrc)
18795 adr += 2;
18796 }
18797 psrc++;
18798 } while (res >>= 1);
18799 POST_IO
18800 ctx->io_cycle_counter -= (adr - dst) * 2;
18801#ifdef USE_CYCLONE_TIMING
18802RET(18)
18803#else
18804RET(28)
18805#endif
18806}
18807
18808// MOVEMaR
18809OPCODE(0x4CB8)
18810{
18811 u32 adr, res;
18812 u32 src, dst;
18813
18814 s32 *psrc;
18815
18816 FETCH_WORD(res);
18817 FETCH_SWORD(adr);
18818 psrc = &DREGs32(0);
18819 dst = adr;
18820 PRE_IO
18821 do
18822 {
18823 if (res & 1)
18824 {
18825 READSX_WORD_F(adr, *psrc)
18826 adr += 2;
18827 }
18828 psrc++;
18829 } while (res >>= 1);
18830 POST_IO
18831 ctx->io_cycle_counter -= (adr - dst) * 2;
18832#ifdef USE_CYCLONE_TIMING
18833RET(16)
18834#else
18835RET(24)
18836#endif
18837}
18838
18839// MOVEMaR
18840OPCODE(0x4CB9)
18841{
18842 u32 adr, res;
18843 u32 src, dst;
18844
18845 s32 *psrc;
18846
18847 FETCH_WORD(res);
18848 FETCH_LONG(adr);
18849 psrc = &DREGs32(0);
18850 dst = adr;
18851 PRE_IO
18852 do
18853 {
18854 if (res & 1)
18855 {
18856 READSX_WORD_F(adr, *psrc)
18857 adr += 2;
18858 }
18859 psrc++;
18860 } while (res >>= 1);
18861 POST_IO
18862 ctx->io_cycle_counter -= (adr - dst) * 2;
18863#ifdef USE_CYCLONE_TIMING
18864RET(20)
18865#else
18866RET(32)
18867#endif
18868}
18869
18870// MOVEMaR
18871OPCODE(0x4CBA)
18872{
18873 u32 adr, res;
18874 u32 src, dst;
18875
18876 s32 *psrc;
18877
18878 FETCH_WORD(res);
18879 adr = GET_SWORD + GET_PC;
18880 PC++;
18881 psrc = &DREGs32(0);
18882 dst = adr;
18883 PRE_IO
18884 do
18885 {
18886 if (res & 1)
18887 {
18888 READSX_WORD_F(adr, *psrc)
18889 adr += 2;
18890 }
18891 psrc++;
18892 } while (res >>= 1);
18893 POST_IO
18894 ctx->io_cycle_counter -= (adr - dst) * 2;
18895#ifdef USE_CYCLONE_TIMING
18896RET(16)
18897#else
18898RET(24)
18899#endif
18900}
18901
18902// MOVEMaR
18903OPCODE(0x4CBB)
18904{
18905 u32 adr, res;
18906 u32 src, dst;
18907
18908 s32 *psrc;
18909
18910 FETCH_WORD(res);
18911 adr = GET_PC;
18912 DECODE_EXT_WORD
18913 psrc = &DREGs32(0);
18914 dst = adr;
18915 PRE_IO
18916 do
18917 {
18918 if (res & 1)
18919 {
18920 READSX_WORD_F(adr, *psrc)
18921 adr += 2;
18922 }
18923 psrc++;
18924 } while (res >>= 1);
18925 POST_IO
18926 ctx->io_cycle_counter -= (adr - dst) * 2;
18927#ifdef USE_CYCLONE_TIMING
18928RET(18)
18929#else
18930RET(28)
18931#endif
18932}
18933
18934// MOVEMaR
18935OPCODE(0x4C9F)
18936{
18937 u32 adr, res;
18938 u32 src, dst;
18939
18940 s32 *psrc;
18941
18942 FETCH_WORD(res);
18943 adr = AREG(7);
18944 psrc = &DREGs32(0);
18945 dst = adr;
18946 PRE_IO
18947 do
18948 {
18949 if (res & 1)
18950 {
18951 READSX_WORD_F(adr, *psrc)
18952 adr += 2;
18953 }
18954 psrc++;
18955 } while (res >>= 1);
18956 AREG(7) = adr;
18957 POST_IO
18958 ctx->io_cycle_counter -= (adr - dst) * 2;
18959RET(12)
18960}
18961
18962// MOVEMaR
18963OPCODE(0x4CD0)
18964{
18965 u32 adr, res;
18966 u32 src, dst;
18967
18968 u32 *psrc;
18969
18970 FETCH_WORD(res);
18971 adr = AREG((Opcode >> 0) & 7);
18972 psrc = &DREGu32(0);
18973 dst = adr;
18974 PRE_IO
18975 do
18976 {
18977 if (res & 1)
18978 {
18979 READ_LONG_F(adr, *psrc)
18980 adr += 4;
18981 }
18982 psrc++;
18983 } while (res >>= 1);
18984 POST_IO
18985 ctx->io_cycle_counter -= (adr - dst) * 2;
18986#ifdef USE_CYCLONE_TIMING
18987RET(12)
18988#else
18989RET(20)
18990#endif
18991}
18992
18993// MOVEMaR
18994OPCODE(0x4CD8)
18995{
18996 u32 adr, res;
18997 u32 src, dst;
18998
18999 u32 *psrc;
19000
19001 FETCH_WORD(res);
19002 adr = AREG((Opcode >> 0) & 7);
19003 psrc = &DREGu32(0);
19004 dst = adr;
19005 PRE_IO
19006 do
19007 {
19008 if (res & 1)
19009 {
19010 READ_LONG_F(adr, *psrc)
19011 adr += 4;
19012 }
19013 psrc++;
19014 } while (res >>= 1);
19015 AREG((Opcode >> 0) & 7) = adr;
19016 POST_IO
19017 ctx->io_cycle_counter -= (adr - dst) * 2;
19018RET(12)
19019}
19020
19021// MOVEMaR
19022OPCODE(0x4CE8)
19023{
19024 u32 adr, res;
19025 u32 src, dst;
19026
19027 u32 *psrc;
19028
19029 FETCH_WORD(res);
19030 FETCH_SWORD(adr);
19031 adr += AREG((Opcode >> 0) & 7);
19032 psrc = &DREGu32(0);
19033 dst = adr;
19034 PRE_IO
19035 do
19036 {
19037 if (res & 1)
19038 {
19039 READ_LONG_F(adr, *psrc)
19040 adr += 4;
19041 }
19042 psrc++;
19043 } while (res >>= 1);
19044 POST_IO
19045 ctx->io_cycle_counter -= (adr - dst) * 2;
19046#ifdef USE_CYCLONE_TIMING
19047RET(16)
19048#else
19049RET(28)
19050#endif
19051}
19052
19053// MOVEMaR
19054OPCODE(0x4CF0)
19055{
19056 u32 adr, res;
19057 u32 src, dst;
19058
19059 u32 *psrc;
19060
19061 FETCH_WORD(res);
19062 adr = AREG((Opcode >> 0) & 7);
19063 DECODE_EXT_WORD
19064 psrc = &DREGu32(0);
19065 dst = adr;
19066 PRE_IO
19067 do
19068 {
19069 if (res & 1)
19070 {
19071 READ_LONG_F(adr, *psrc)
19072 adr += 4;
19073 }
19074 psrc++;
19075 } while (res >>= 1);
19076 POST_IO
19077 ctx->io_cycle_counter -= (adr - dst) * 2;
19078#ifdef USE_CYCLONE_TIMING
19079RET(18)
19080#else
19081RET(32)
19082#endif
19083}
19084
19085// MOVEMaR
19086OPCODE(0x4CF8)
19087{
19088 u32 adr, res;
19089 u32 src, dst;
19090
19091 u32 *psrc;
19092
19093 FETCH_WORD(res);
19094 FETCH_SWORD(adr);
19095 psrc = &DREGu32(0);
19096 dst = adr;
19097 PRE_IO
19098 do
19099 {
19100 if (res & 1)
19101 {
19102 READ_LONG_F(adr, *psrc)
19103 adr += 4;
19104 }
19105 psrc++;
19106 } while (res >>= 1);
19107 POST_IO
19108 ctx->io_cycle_counter -= (adr - dst) * 2;
19109#ifdef USE_CYCLONE_TIMING
19110RET(16)
19111#else
19112RET(28)
19113#endif
19114}
19115
19116// MOVEMaR
19117OPCODE(0x4CF9)
19118{
19119 u32 adr, res;
19120 u32 src, dst;
19121
19122 u32 *psrc;
19123
19124 FETCH_WORD(res);
19125 FETCH_LONG(adr);
19126 psrc = &DREGu32(0);
19127 dst = adr;
19128 PRE_IO
19129 do
19130 {
19131 if (res & 1)
19132 {
19133 READ_LONG_F(adr, *psrc)
19134 adr += 4;
19135 }
19136 psrc++;
19137 } while (res >>= 1);
19138 POST_IO
19139 ctx->io_cycle_counter -= (adr - dst) * 2;
19140#ifdef USE_CYCLONE_TIMING
19141RET(20)
19142#else
19143RET(36)
19144#endif
19145}
19146
19147// MOVEMaR
19148OPCODE(0x4CFA)
19149{
19150 u32 adr, res;
19151 u32 src, dst;
19152
19153 u32 *psrc;
19154
19155 FETCH_WORD(res);
19156 adr = GET_SWORD + GET_PC;
19157 PC++;
19158 psrc = &DREGu32(0);
19159 dst = adr;
19160 PRE_IO
19161 do
19162 {
19163 if (res & 1)
19164 {
19165 READ_LONG_F(adr, *psrc)
19166 adr += 4;
19167 }
19168 psrc++;
19169 } while (res >>= 1);
19170 POST_IO
19171 ctx->io_cycle_counter -= (adr - dst) * 2;
19172#ifdef USE_CYCLONE_TIMING
19173RET(16)
19174#else
19175RET(28)
19176#endif
19177}
19178
19179// MOVEMaR
19180OPCODE(0x4CFB)
19181{
19182 u32 adr, res;
19183 u32 src, dst;
19184
19185 u32 *psrc;
19186
19187 FETCH_WORD(res);
19188 adr = GET_PC;
19189 DECODE_EXT_WORD
19190 psrc = &DREGu32(0);
19191 dst = adr;
19192 PRE_IO
19193 do
19194 {
19195 if (res & 1)
19196 {
19197 READ_LONG_F(adr, *psrc)
19198 adr += 4;
19199 }
19200 psrc++;
19201 } while (res >>= 1);
19202 POST_IO
19203 ctx->io_cycle_counter -= (adr - dst) * 2;
19204#ifdef USE_CYCLONE_TIMING
19205RET(18)
19206#else
19207RET(32)
19208#endif
19209}
19210
19211// MOVEMaR
19212OPCODE(0x4CDF)
19213{
19214 u32 adr, res;
19215 u32 src, dst;
19216
19217 u32 *psrc;
19218
19219 FETCH_WORD(res);
19220 adr = AREG(7);
19221 psrc = &DREGu32(0);
19222 dst = adr;
19223 PRE_IO
19224 do
19225 {
19226 if (res & 1)
19227 {
19228 READ_LONG_F(adr, *psrc)
19229 adr += 4;
19230 }
19231 psrc++;
19232 } while (res >>= 1);
19233 AREG(7) = adr;
19234 POST_IO
19235 ctx->io_cycle_counter -= (adr - dst) * 2;
19236RET(12)
19237}
19238
19239// TRAP
19240OPCODE(0x4E40)
19241{
19242 SET_PC(execute_exception(ctx, M68K_TRAP_BASE_EX + (Opcode & 0xF), GET_PC, GET_SR));
19243#ifdef USE_CYCLONE_TIMING
19244RET(0)
19245#else
19246RET(4)
19247#endif
19248}
19249
19250// LINK
19251OPCODE(0x4E50)
19252{
19253 u32 adr, res;
19254 u32 src, dst;
19255
19256 res = AREGu32((Opcode >> 0) & 7);
19257 PRE_IO
19258 PUSH_32_F(res)
19259 res = AREG(7);
19260 AREG((Opcode >> 0) & 7) = res;
19261 FETCH_SWORD(res);
19262 AREG(7) += res;
19263 POST_IO
19264RET(16)
19265}
19266
19267// LINKA7
19268OPCODE(0x4E57)
19269{
19270 u32 adr, res;
19271 u32 src, dst;
19272
19273 AREG(7) -= 4;
19274 PRE_IO
19275 WRITE_LONG_DEC_F(AREG(7), AREG(7))
19276 FETCH_SWORD(res);
19277 AREG(7) += res;
19278 POST_IO
19279RET(16)
19280}
19281
19282// ULNK
19283OPCODE(0x4E58)
19284{
19285 u32 adr, res;
19286 u32 src, dst;
19287
19288 src = AREGu32((Opcode >> 0) & 7);
19289 AREG(7) = src + 4;
19290 PRE_IO
19291 READ_LONG_F(src, res)
19292 AREG((Opcode >> 0) & 7) = res;
19293 POST_IO
19294RET(12)
19295}
19296
19297// ULNKA7
19298OPCODE(0x4E5F)
19299{
19300 u32 adr, res;
19301 u32 src, dst;
19302
19303 PRE_IO
19304 READ_LONG_F(AREG(7), AREG(7))
19305 POST_IO
19306RET(12)
19307}
19308
19309// MOVEAUSP
19310OPCODE(0x4E60)
19311{
19312 u32 adr, res;
19313 u32 src, dst;
19314
19315 if (!flag_S)
19316 {
19317 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19318#ifdef USE_CYCLONE_TIMING
19319RET(0)
19320#else
19321 RET(4)
19322#endif
19323 }
19324 res = AREGu32((Opcode >> 0) & 7);
19325 ASP = res;
19326RET(4)
19327}
19328
19329// MOVEUSPA
19330OPCODE(0x4E68)
19331{
19332 u32 adr, res;
19333 u32 src, dst;
19334
19335 if (!flag_S)
19336 {
19337 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19338#ifdef USE_CYCLONE_TIMING
19339RET(0)
19340#else
19341 RET(4)
19342#endif
19343 }
19344 res = ASP;
19345 AREG((Opcode >> 0) & 7) = res;
19346RET(4)
19347}
19348
19349// RESET
19350OPCODE(0x4E70)
19351{
19352 u32 adr, res;
19353 u32 src, dst;
19354
19355 if (!flag_S)
19356 {
19357 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19358#ifdef USE_CYCLONE_TIMING
19359RET(0)
19360#else
19361 RET(4)
19362#endif
19363 }
19364 PRE_IO
19365 if (ctx->reset_handler) ctx->reset_handler();
19366// CPU->Reset_CallBack();
19367 POST_IO
19368RET(132)
19369}
19370
19371// NOP
19372OPCODE(0x4E71)
19373{
19374RET(4)
19375}
19376
19377// STOP
19378OPCODE(0x4E72)
19379{
19380 u32 adr, res;
19381 u32 src, dst;
19382
19383 if (!flag_S)
19384 {
19385 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19386#ifdef USE_CYCLONE_TIMING
19387RET(0)
19388#else
19389 RET(4)
19390#endif
19391 }
19392 FETCH_WORD(res);
19393 res &= M68K_SR_MASK;
19394 SET_SR(res)
19395 if (!flag_S)
19396 {
19397 res = AREG(7);
19398 AREG(7) = ASP;
19399 ASP = res;
19400 }
19401 ctx->execinfo |= FM68K_HALTED;
19402RET0()
19403}
19404
19405// RTE
19406OPCODE(0x4E73)
19407{
19408 u32 adr, res;
19409 u32 src, dst;
19410
19411 if (!flag_S)
19412 {
19413 SET_PC(execute_exception(ctx, M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
19414#ifdef USE_CYCLONE_TIMING
19415RET(0)
19416#else
19417 RET(4)
19418#endif
19419 }
19420 PRE_IO
19421 POP_16_F(res)
19422 SET_SR(res)
19423 POP_32_F(res)
19424 SET_PC(res)
19425 if (!flag_S)
19426 {
19427 res = AREG(7);
19428 AREG(7) = ASP;
19429 ASP = res;
19430 }
19431 CHECK_BRANCH_EXCEPTION(res)
19432 POST_IO
19433 ctx->execinfo &= ~(FM68K_EMULATE_GROUP_0|FM68K_EMULATE_TRACE|FM68K_DO_TRACE);
19434 CHECK_INT_TO_JUMP(20)
19435RET(20)
19436}
19437
19438// RTS
19439OPCODE(0x4E75)
19440{
19441 u32 adr, res;
19442 u32 src, dst;
19443
19444 PRE_IO
19445 POP_32_F(res)
19446 SET_PC(res)
19447 CHECK_BRANCH_EXCEPTION(res)
19448 POST_IO
19449RET(16)
19450}
19451
19452// TRAPV
19453OPCODE(0x4E76)
19454{
19455 if (flag_V & 0x80) {
19456 SET_PC(execute_exception(ctx, M68K_TRAPV_EX, GET_PC, GET_SR));
19457#ifdef USE_CYCLONE_TIMING
19458RET(0)
19459#endif
19460 }
19461RET(4)
19462}
19463
19464// RTR
19465OPCODE(0x4E77)
19466{
19467 u32 adr, res;
19468 u32 src, dst;
19469
19470 PRE_IO
19471 POP_16_F(res)
19472 SET_CCR(res)
19473 POP_32_F(res)
19474 SET_PC(res)
19475 CHECK_BRANCH_EXCEPTION(res)
19476 POST_IO
19477RET(20)
19478}
19479
19480// JSR
19481OPCODE(0x4E90)
19482{
19483 u32 adr, res;
19484 u32 src, dst;
19485
19486 adr = AREG((Opcode >> 0) & 7);
19487 {
19488 u32 oldPC;
19489
19490 oldPC = GET_PC;
19491 PRE_IO
19492 PUSH_32_F(oldPC)
19493 }
19494 SET_PC(adr)
19495 CHECK_BRANCH_EXCEPTION(adr)
19496 POST_IO
19497RET(16)
19498}
19499
19500// JSR
19501OPCODE(0x4EA8)
19502{
19503 u32 adr, res;
19504 u32 src, dst;
19505
19506 FETCH_SWORD(adr);
19507 adr += AREG((Opcode >> 0) & 7);
19508 {
19509 u32 oldPC;
19510
19511 oldPC = GET_PC;
19512 PRE_IO
19513 PUSH_32_F(oldPC)
19514 }
19515 SET_PC(adr)
19516 CHECK_BRANCH_EXCEPTION(adr)
19517 POST_IO
19518RET(18)
19519}
19520
19521// JSR
19522OPCODE(0x4EB0)
19523{
19524 u32 adr, res;
19525 u32 src, dst;
19526
19527 adr = AREG((Opcode >> 0) & 7);
19528 DECODE_EXT_WORD
19529 {
19530 u32 oldPC;
19531
19532 oldPC = GET_PC;
19533 PRE_IO
19534 PUSH_32_F(oldPC)
19535 }
19536 SET_PC(adr)
19537 CHECK_BRANCH_EXCEPTION(adr)
19538 POST_IO
19539RET(22)
19540}
19541
19542// JSR
19543OPCODE(0x4EB8)
19544{
19545 u32 adr, res;
19546 u32 src, dst;
19547
19548 FETCH_SWORD(adr);
19549 {
19550 u32 oldPC;
19551
19552 oldPC = GET_PC;
19553 PRE_IO
19554 PUSH_32_F(oldPC)
19555 }
19556 SET_PC(adr)
19557 CHECK_BRANCH_EXCEPTION(adr)
19558 POST_IO
19559RET(18)
19560}
19561
19562// JSR
19563OPCODE(0x4EB9)
19564{
19565 u32 adr, res;
19566 u32 src, dst;
19567
19568 FETCH_LONG(adr);
19569 {
19570 u32 oldPC;
19571
19572 oldPC = GET_PC;
19573 PRE_IO
19574 PUSH_32_F(oldPC)
19575 }
19576 SET_PC(adr)
19577 CHECK_BRANCH_EXCEPTION(adr)
19578 POST_IO
19579RET(20)
19580}
19581
19582// JSR
19583OPCODE(0x4EBA)
19584{
19585 u32 adr, res;
19586 u32 src, dst;
19587
19588 adr = GET_SWORD + GET_PC;
19589 PC++;
19590 {
19591 u32 oldPC;
19592
19593 oldPC = GET_PC;
19594 PRE_IO
19595 PUSH_32_F(oldPC)
19596 }
19597 SET_PC(adr)
19598 CHECK_BRANCH_EXCEPTION(adr)
19599 POST_IO
19600RET(18)
19601}
19602
19603// JSR
19604OPCODE(0x4EBB)
19605{
19606 u32 adr, res;
19607 u32 src, dst;
19608
19609 adr = GET_PC;
19610 DECODE_EXT_WORD
19611 {
19612 u32 oldPC;
19613
19614 oldPC = GET_PC;
19615 PRE_IO
19616 PUSH_32_F(oldPC)
19617 }
19618 SET_PC(adr)
19619 CHECK_BRANCH_EXCEPTION(adr)
19620 POST_IO
19621RET(22)
19622}
19623
19624// JMP
19625OPCODE(0x4ED0)
19626{
19627 u32 adr, res;
19628 u32 src, dst;
19629
19630 adr = AREG((Opcode >> 0) & 7);
19631 SET_PC(adr)
19632 CHECK_BRANCH_EXCEPTION(adr)
19633RET(8)
19634}
19635
19636// JMP
19637OPCODE(0x4EE8)
19638{
19639 u32 adr, res;
19640 u32 src, dst;
19641
19642 FETCH_SWORD(adr);
19643 adr += AREG((Opcode >> 0) & 7);
19644 SET_PC(adr)
19645 CHECK_BRANCH_EXCEPTION(adr)
19646RET(10)
19647}
19648
19649// JMP
19650OPCODE(0x4EF0)
19651{
19652 u32 adr, res;
19653 u32 src, dst;
19654
19655 adr = AREG((Opcode >> 0) & 7);
19656 DECODE_EXT_WORD
19657 SET_PC(adr)
19658 CHECK_BRANCH_EXCEPTION(adr)
19659RET(14)
19660}
19661
19662// JMP
19663OPCODE(0x4EF8)
19664{
19665 u32 adr, res;
19666 u32 src, dst;
19667
19668 FETCH_SWORD(adr);
19669 SET_PC(adr)
19670 CHECK_BRANCH_EXCEPTION(adr)
19671RET(10)
19672}
19673
19674// JMP
19675OPCODE(0x4EF9)
19676{
19677 u32 adr, res;
19678 u32 src, dst;
19679
19680 FETCH_LONG(adr);
19681 SET_PC(adr)
19682 CHECK_BRANCH_EXCEPTION(adr)
19683RET(12)
19684}
19685
19686// JMP
19687OPCODE(0x4EFA)
19688{
19689 u32 adr, res;
19690 u32 src, dst;
19691
19692 adr = GET_SWORD + GET_PC;
19693 PC++;
19694 SET_PC(adr)
19695 CHECK_BRANCH_EXCEPTION(adr)
19696RET(10)
19697}
19698
19699// JMP
19700OPCODE(0x4EFB)
19701{
19702 u32 adr, res;
19703 u32 src, dst;
19704
19705 adr = GET_PC;
19706 DECODE_EXT_WORD
19707 SET_PC(adr)
19708 CHECK_BRANCH_EXCEPTION(adr)
19709RET(14)
19710}
19711
19712// CHK
19713OPCODE(0x4180)
19714{
19715 s32 src, res;
19716
19717 src = DREGs16((Opcode >> 0) & 7);
19718 res = DREGs16((Opcode >> 9) & 7);
19719 if ((res < 0) || (res > src))
19720 {
19721 flag_N = res >> 8;
19722 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19723RET(4)
19724 }
19725RET(10)
19726}
19727
19728// CHK
19729OPCODE(0x4190)
19730{
19731 s32 src, res;
19732 u32 adr;
19733
19734 adr = AREG((Opcode >> 0) & 7);
19735 PRE_IO
19736 READSX_WORD_F(adr, src)
19737 res = DREGs16((Opcode >> 9) & 7);
19738 if ((res < 0) || (res > src))
19739 {
19740 flag_N = res >> 8;
19741 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19742RET(8)
19743 }
19744 POST_IO
19745RET(14)
19746}
19747
19748// CHK
19749OPCODE(0x4198)
19750{
19751 s32 src, res;
19752 u32 adr;
19753
19754 adr = AREG((Opcode >> 0) & 7);
19755 AREG((Opcode >> 0) & 7) += 2;
19756 PRE_IO
19757 READSX_WORD_F(adr, src)
19758 res = DREGs16((Opcode >> 9) & 7);
19759 if ((res < 0) || (res > src))
19760 {
19761 flag_N = res >> 8;
19762 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19763RET(8)
19764 }
19765 POST_IO
19766RET(14)
19767}
19768
19769// CHK
19770OPCODE(0x41A0)
19771{
19772 s32 src, res;
19773 u32 adr;
19774
19775 adr = AREG((Opcode >> 0) & 7) - 2;
19776 AREG((Opcode >> 0) & 7) = adr;
19777 PRE_IO
19778 READSX_WORD_F(adr, src)
19779 res = DREGs16((Opcode >> 9) & 7);
19780 if ((res < 0) || (res > src))
19781 {
19782 flag_N = res >> 8;
19783 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19784RET(10)
19785 }
19786 POST_IO
19787RET(16)
19788}
19789
19790// CHK
19791OPCODE(0x41A8)
19792{
19793 s32 src, res;
19794 u32 adr;
19795
19796 FETCH_SWORD(adr);
19797 adr += AREG((Opcode >> 0) & 7);
19798 PRE_IO
19799 READSX_WORD_F(adr, src)
19800 res = DREGs16((Opcode >> 9) & 7);
19801 if ((res < 0) || (res > src))
19802 {
19803 flag_N = res >> 8;
19804 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19805RET(12)
19806 }
19807 POST_IO
19808RET(18)
19809}
19810
19811// CHK
19812OPCODE(0x41B0)
19813{
19814 s32 src, res;
19815 u32 adr;
19816
19817 adr = AREG((Opcode >> 0) & 7);
19818 DECODE_EXT_WORD
19819 PRE_IO
19820 READSX_WORD_F(adr, src)
19821 res = DREGs16((Opcode >> 9) & 7);
19822 if ((res < 0) || (res > src))
19823 {
19824 flag_N = res >> 8;
19825 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19826RET(14)
19827 }
19828 POST_IO
19829RET(20)
19830}
19831
19832// CHK
19833OPCODE(0x41B8)
19834{
19835 s32 src, res;
19836 u32 adr;
19837
19838 FETCH_SWORD(adr);
19839 PRE_IO
19840 READSX_WORD_F(adr, src)
19841 res = DREGs16((Opcode >> 9) & 7);
19842 if ((res < 0) || (res > src))
19843 {
19844 flag_N = res >> 8;
19845 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19846RET(12)
19847 }
19848 POST_IO
19849RET(18)
19850}
19851
19852// CHK
19853OPCODE(0x41B9)
19854{
19855 s32 src, res;
19856 u32 adr;
19857
19858 FETCH_LONG(adr);
19859 PRE_IO
19860 READSX_WORD_F(adr, src)
19861 res = DREGs16((Opcode >> 9) & 7);
19862 if ((res < 0) || (res > src))
19863 {
19864 flag_N = res >> 8;
19865 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19866RET(16)
19867 }
19868 POST_IO
19869RET(22)
19870}
19871
19872// CHK
19873OPCODE(0x41BA)
19874{
19875 s32 src, res;
19876 u32 adr;
19877
19878 adr = GET_SWORD + GET_PC;
19879 PC++;
19880 PRE_IO
19881 READSX_WORD_F(adr, src)
19882 res = DREGs16((Opcode >> 9) & 7);
19883 if ((res < 0) || (res > src))
19884 {
19885 flag_N = res >> 8;
19886 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19887RET(12)
19888 }
19889 POST_IO
19890RET(18)
19891}
19892
19893// CHK
19894OPCODE(0x41BB)
19895{
19896 s32 src, res;
19897 u32 adr;
19898
19899 adr = GET_PC;
19900 DECODE_EXT_WORD
19901 PRE_IO
19902 READSX_WORD_F(adr, src)
19903 res = DREGs16((Opcode >> 9) & 7);
19904 if ((res < 0) || (res > src))
19905 {
19906 flag_N = res >> 8;
19907 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19908RET(14)
19909 }
19910 POST_IO
19911RET(20)
19912}
19913
19914// CHK
19915OPCODE(0x41BC)
19916{
19917 s32 src, res;
19918 u32 adr;
19919
19920 FETCH_SWORD(src);
19921 res = DREGs16((Opcode >> 9) & 7);
19922 if ((res < 0) || (res > src))
19923 {
19924 flag_N = res >> 8;
19925 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19926RET(8)
19927 }
19928 POST_IO
19929RET(14)
19930}
19931
19932// CHK
19933OPCODE(0x419F)
19934{
19935 s32 src, res;
19936 u32 adr;
19937
19938 adr = AREG(7);
19939 AREG(7) += 2;
19940 PRE_IO
19941 READSX_WORD_F(adr, src)
19942 res = DREGs16((Opcode >> 9) & 7);
19943 if ((res < 0) || (res > src))
19944 {
19945 flag_N = res >> 8;
19946 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19947RET(8)
19948 }
19949 POST_IO
19950RET(14)
19951}
19952
19953// CHK
19954OPCODE(0x41A7)
19955{
19956 s32 src, res;
19957 u32 adr;
19958
19959 adr = AREG(7) - 2;
19960 AREG(7) = adr;
19961 PRE_IO
19962 READSX_WORD_F(adr, src)
19963 res = DREGs16((Opcode >> 9) & 7);
19964 if ((res < 0) || (res > src))
19965 {
19966 flag_N = res >> 8;
19967 SET_PC(execute_exception(ctx, M68K_CHK_EX, GET_PC, GET_SR));
19968RET(10)
19969 }
19970 POST_IO
19971RET(16)
19972}
19973
19974// LEA
19975OPCODE(0x41D0)
19976{
19977 u32 adr, res;
19978 u32 src, dst;
19979
19980 adr = AREG((Opcode >> 0) & 7);
19981 res = adr;
19982 AREG((Opcode >> 9) & 7) = res;
19983RET(4)
19984}
19985
19986// LEA
19987OPCODE(0x41E8)
19988{
19989 u32 adr, res;
19990 u32 src, dst;
19991
19992 FETCH_SWORD(adr);
19993 adr += AREG((Opcode >> 0) & 7);
19994 res = adr;
19995 AREG((Opcode >> 9) & 7) = res;
19996RET(8)
19997}
19998
19999// LEA
20000OPCODE(0x41F0)
20001{
20002 u32 adr, res;
20003 u32 src, dst;
20004
20005 adr = AREG((Opcode >> 0) & 7);
20006 DECODE_EXT_WORD
20007 res = adr;
20008 AREG((Opcode >> 9) & 7) = res;
20009RET(12)
20010}
20011
20012// LEA
20013OPCODE(0x41F8)
20014{
20015 u32 adr, res;
20016 u32 src, dst;
20017
20018 FETCH_SWORD(adr);
20019 res = adr;
20020 AREG((Opcode >> 9) & 7) = res;
20021RET(8)
20022}
20023
20024// LEA
20025OPCODE(0x41F9)
20026{
20027 u32 adr, res;
20028 u32 src, dst;
20029
20030 FETCH_LONG(adr);
20031 res = adr;
20032 AREG((Opcode >> 9) & 7) = res;
20033RET(12)
20034}
20035
20036// LEA
20037OPCODE(0x41FA)
20038{
20039 u32 adr, res;
20040 u32 src, dst;
20041
20042 adr = GET_SWORD + GET_PC;
20043 PC++;
20044 res = adr;
20045 AREG((Opcode >> 9) & 7) = res;
20046RET(8)
20047}
20048
20049// LEA
20050OPCODE(0x41FB)
20051{
20052 u32 adr, res;
20053 u32 src, dst;
20054
20055 adr = GET_PC;
20056 DECODE_EXT_WORD
20057 res = adr;
20058 AREG((Opcode >> 9) & 7) = res;
20059RET(12)
20060}
20061
20062// STCC
20063OPCODE(0x50C0)
20064{
20065 u32 adr, res;
20066 u32 src, dst;
20067
20068 res = 0xFF;
20069 DREGu8((Opcode >> 0) & 7) = res;
20070 RET(6)
20071}
20072
20073// STCC
20074OPCODE(0x51C0)
20075{
20076 u32 adr, res;
20077 u32 src, dst;
20078
20079 res = 0;
20080 DREGu8((Opcode >> 0) & 7) = res;
20081 RET(4)
20082}
20083
20084// STCC
20085OPCODE(0x52C0)
20086{
20087 u32 adr, res;
20088 u32 src, dst;
20089
20090 if (flag_NotZ && (!(flag_C & 0x100)))
20091 {
20092 res = 0xFF;
20093 DREGu8((Opcode >> 0) & 7) = res;
20094 RET(6)
20095 }
20096 res = 0;
20097 DREGu8((Opcode >> 0) & 7) = res;
20098 RET(4)
20099}
20100
20101// STCC
20102OPCODE(0x53C0)
20103{
20104 u32 adr, res;
20105 u32 src, dst;
20106
20107 if ((!flag_NotZ) || (flag_C & 0x100))
20108 {
20109 res = 0xFF;
20110 DREGu8((Opcode >> 0) & 7) = res;
20111 RET(6)
20112 }
20113 res = 0;
20114 DREGu8((Opcode >> 0) & 7) = res;
20115 RET(4)
20116}
20117
20118// STCC
20119OPCODE(0x54C0)
20120{
20121 u32 adr, res;
20122 u32 src, dst;
20123
20124 if (!(flag_C & 0x100))
20125 {
20126 res = 0xFF;
20127 DREGu8((Opcode >> 0) & 7) = res;
20128 RET(6)
20129 }
20130 res = 0;
20131 DREGu8((Opcode >> 0) & 7) = res;
20132 RET(4)
20133}
20134
20135// STCC
20136OPCODE(0x55C0)
20137{
20138 u32 adr, res;
20139 u32 src, dst;
20140
20141 if (flag_C & 0x100)
20142 {
20143 res = 0xFF;
20144 DREGu8((Opcode >> 0) & 7) = res;
20145 RET(6)
20146 }
20147 res = 0;
20148 DREGu8((Opcode >> 0) & 7) = res;
20149 RET(4)
20150}
20151
20152// STCC
20153OPCODE(0x56C0)
20154{
20155 u32 adr, res;
20156 u32 src, dst;
20157
20158 if (flag_NotZ)
20159 {
20160 res = 0xFF;
20161 DREGu8((Opcode >> 0) & 7) = res;
20162 RET(6)
20163 }
20164 res = 0;
20165 DREGu8((Opcode >> 0) & 7) = res;
20166 RET(4)
20167}
20168
20169// STCC
20170OPCODE(0x57C0)
20171{
20172 u32 adr, res;
20173 u32 src, dst;
20174
20175 if (!flag_NotZ)
20176 {
20177 res = 0xFF;
20178 DREGu8((Opcode >> 0) & 7) = res;
20179 RET(6)
20180 }
20181 res = 0;
20182 DREGu8((Opcode >> 0) & 7) = res;
20183 RET(4)
20184}
20185
20186// STCC
20187OPCODE(0x58C0)
20188{
20189 u32 adr, res;
20190 u32 src, dst;
20191
20192 if (!(flag_V & 0x80))
20193 {
20194 res = 0xFF;
20195 DREGu8((Opcode >> 0) & 7) = res;
20196 RET(6)
20197 }
20198 res = 0;
20199 DREGu8((Opcode >> 0) & 7) = res;
20200 RET(4)
20201}
20202
20203// STCC
20204OPCODE(0x59C0)
20205{
20206 u32 adr, res;
20207 u32 src, dst;
20208
20209 if (flag_V & 0x80)
20210 {
20211 res = 0xFF;
20212 DREGu8((Opcode >> 0) & 7) = res;
20213 RET(6)
20214 }
20215 res = 0;
20216 DREGu8((Opcode >> 0) & 7) = res;
20217 RET(4)
20218}
20219
20220// STCC
20221OPCODE(0x5AC0)
20222{
20223 u32 adr, res;
20224 u32 src, dst;
20225
20226 if (!(flag_N & 0x80))
20227 {
20228 res = 0xFF;
20229 DREGu8((Opcode >> 0) & 7) = res;
20230 RET(6)
20231 }
20232 res = 0;
20233 DREGu8((Opcode >> 0) & 7) = res;
20234 RET(4)
20235}
20236
20237// STCC
20238OPCODE(0x5BC0)
20239{
20240 u32 adr, res;
20241 u32 src, dst;
20242
20243 if (flag_N & 0x80)
20244 {
20245 res = 0xFF;
20246 DREGu8((Opcode >> 0) & 7) = res;
20247 RET(6)
20248 }
20249 res = 0;
20250 DREGu8((Opcode >> 0) & 7) = res;
20251 RET(4)
20252}
20253
20254// STCC
20255OPCODE(0x5CC0)
20256{
20257 u32 adr, res;
20258 u32 src, dst;
20259
20260 if (!((flag_N ^ flag_V) & 0x80))
20261 {
20262 res = 0xFF;
20263 DREGu8((Opcode >> 0) & 7) = res;
20264 RET(6)
20265 }
20266 res = 0;
20267 DREGu8((Opcode >> 0) & 7) = res;
20268 RET(4)
20269}
20270
20271// STCC
20272OPCODE(0x5DC0)
20273{
20274 u32 adr, res;
20275 u32 src, dst;
20276
20277 if ((flag_N ^ flag_V) & 0x80)
20278 {
20279 res = 0xFF;
20280 DREGu8((Opcode >> 0) & 7) = res;
20281 RET(6)
20282 }
20283 res = 0;
20284 DREGu8((Opcode >> 0) & 7) = res;
20285 RET(4)
20286}
20287
20288// STCC
20289OPCODE(0x5EC0)
20290{
20291 u32 adr, res;
20292 u32 src, dst;
20293
20294 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20295 {
20296 res = 0xFF;
20297 DREGu8((Opcode >> 0) & 7) = res;
20298 RET(6)
20299 }
20300 res = 0;
20301 DREGu8((Opcode >> 0) & 7) = res;
20302 RET(4)
20303}
20304
20305// STCC
20306OPCODE(0x5FC0)
20307{
20308 u32 adr, res;
20309 u32 src, dst;
20310
20311 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20312 {
20313 res = 0xFF;
20314 DREGu8((Opcode >> 0) & 7) = res;
20315 RET(6)
20316 }
20317 res = 0;
20318 DREGu8((Opcode >> 0) & 7) = res;
20319 RET(4)
20320}
20321
20322// STCC
20323OPCODE(0x50D0)
20324{
20325 u32 adr, res;
20326 u32 src, dst;
20327
20328 adr = AREG((Opcode >> 0) & 7);
20329 res = 0xFF;
20330 PRE_IO
20331 WRITE_BYTE_F(adr, res)
20332 POST_IO
20333 RET(12)
20334}
20335
20336// STCC
20337OPCODE(0x51D0)
20338{
20339 u32 adr, res;
20340 u32 src, dst;
20341
20342 adr = AREG((Opcode >> 0) & 7);
20343 res = 0;
20344 PRE_IO
20345 WRITE_BYTE_F(adr, res)
20346 POST_IO
20347 RET(12)
20348}
20349
20350// STCC
20351OPCODE(0x52D0)
20352{
20353 u32 adr, res;
20354 u32 src, dst;
20355
20356 adr = AREG((Opcode >> 0) & 7);
20357 if (flag_NotZ && (!(flag_C & 0x100)))
20358 {
20359 res = 0xFF;
20360 PRE_IO
20361 WRITE_BYTE_F(adr, res)
20362 POST_IO
20363 RET(12)
20364 }
20365 res = 0;
20366 PRE_IO
20367 WRITE_BYTE_F(adr, res)
20368 POST_IO
20369 RET(12)
20370}
20371
20372// STCC
20373OPCODE(0x53D0)
20374{
20375 u32 adr, res;
20376 u32 src, dst;
20377
20378 adr = AREG((Opcode >> 0) & 7);
20379 if ((!flag_NotZ) || (flag_C & 0x100))
20380 {
20381 res = 0xFF;
20382 PRE_IO
20383 WRITE_BYTE_F(adr, res)
20384 POST_IO
20385 RET(12)
20386 }
20387 res = 0;
20388 PRE_IO
20389 WRITE_BYTE_F(adr, res)
20390 POST_IO
20391 RET(12)
20392}
20393
20394// STCC
20395OPCODE(0x54D0)
20396{
20397 u32 adr, res;
20398 u32 src, dst;
20399
20400 adr = AREG((Opcode >> 0) & 7);
20401 if (!(flag_C & 0x100))
20402 {
20403 res = 0xFF;
20404 PRE_IO
20405 WRITE_BYTE_F(adr, res)
20406 POST_IO
20407 RET(12)
20408 }
20409 res = 0;
20410 PRE_IO
20411 WRITE_BYTE_F(adr, res)
20412 POST_IO
20413 RET(12)
20414}
20415
20416// STCC
20417OPCODE(0x55D0)
20418{
20419 u32 adr, res;
20420 u32 src, dst;
20421
20422 adr = AREG((Opcode >> 0) & 7);
20423 if (flag_C & 0x100)
20424 {
20425 res = 0xFF;
20426 PRE_IO
20427 WRITE_BYTE_F(adr, res)
20428 POST_IO
20429 RET(12)
20430 }
20431 res = 0;
20432 PRE_IO
20433 WRITE_BYTE_F(adr, res)
20434 POST_IO
20435 RET(12)
20436}
20437
20438// STCC
20439OPCODE(0x56D0)
20440{
20441 u32 adr, res;
20442 u32 src, dst;
20443
20444 adr = AREG((Opcode >> 0) & 7);
20445 if (flag_NotZ)
20446 {
20447 res = 0xFF;
20448 PRE_IO
20449 WRITE_BYTE_F(adr, res)
20450 POST_IO
20451 RET(12)
20452 }
20453 res = 0;
20454 PRE_IO
20455 WRITE_BYTE_F(adr, res)
20456 POST_IO
20457 RET(12)
20458}
20459
20460// STCC
20461OPCODE(0x57D0)
20462{
20463 u32 adr, res;
20464 u32 src, dst;
20465
20466 adr = AREG((Opcode >> 0) & 7);
20467 if (!flag_NotZ)
20468 {
20469 res = 0xFF;
20470 PRE_IO
20471 WRITE_BYTE_F(adr, res)
20472 POST_IO
20473 RET(12)
20474 }
20475 res = 0;
20476 PRE_IO
20477 WRITE_BYTE_F(adr, res)
20478 POST_IO
20479 RET(12)
20480}
20481
20482// STCC
20483OPCODE(0x58D0)
20484{
20485 u32 adr, res;
20486 u32 src, dst;
20487
20488 adr = AREG((Opcode >> 0) & 7);
20489 if (!(flag_V & 0x80))
20490 {
20491 res = 0xFF;
20492 PRE_IO
20493 WRITE_BYTE_F(adr, res)
20494 POST_IO
20495 RET(12)
20496 }
20497 res = 0;
20498 PRE_IO
20499 WRITE_BYTE_F(adr, res)
20500 POST_IO
20501 RET(12)
20502}
20503
20504// STCC
20505OPCODE(0x59D0)
20506{
20507 u32 adr, res;
20508 u32 src, dst;
20509
20510 adr = AREG((Opcode >> 0) & 7);
20511 if (flag_V & 0x80)
20512 {
20513 res = 0xFF;
20514 PRE_IO
20515 WRITE_BYTE_F(adr, res)
20516 POST_IO
20517 RET(12)
20518 }
20519 res = 0;
20520 PRE_IO
20521 WRITE_BYTE_F(adr, res)
20522 POST_IO
20523 RET(12)
20524}
20525
20526// STCC
20527OPCODE(0x5AD0)
20528{
20529 u32 adr, res;
20530 u32 src, dst;
20531
20532 adr = AREG((Opcode >> 0) & 7);
20533 if (!(flag_N & 0x80))
20534 {
20535 res = 0xFF;
20536 PRE_IO
20537 WRITE_BYTE_F(adr, res)
20538 POST_IO
20539 RET(12)
20540 }
20541 res = 0;
20542 PRE_IO
20543 WRITE_BYTE_F(adr, res)
20544 POST_IO
20545 RET(12)
20546}
20547
20548// STCC
20549OPCODE(0x5BD0)
20550{
20551 u32 adr, res;
20552 u32 src, dst;
20553
20554 adr = AREG((Opcode >> 0) & 7);
20555 if (flag_N & 0x80)
20556 {
20557 res = 0xFF;
20558 PRE_IO
20559 WRITE_BYTE_F(adr, res)
20560 POST_IO
20561 RET(12)
20562 }
20563 res = 0;
20564 PRE_IO
20565 WRITE_BYTE_F(adr, res)
20566 POST_IO
20567 RET(12)
20568}
20569
20570// STCC
20571OPCODE(0x5CD0)
20572{
20573 u32 adr, res;
20574 u32 src, dst;
20575
20576 adr = AREG((Opcode >> 0) & 7);
20577 if (!((flag_N ^ flag_V) & 0x80))
20578 {
20579 res = 0xFF;
20580 PRE_IO
20581 WRITE_BYTE_F(adr, res)
20582 POST_IO
20583 RET(12)
20584 }
20585 res = 0;
20586 PRE_IO
20587 WRITE_BYTE_F(adr, res)
20588 POST_IO
20589 RET(12)
20590}
20591
20592// STCC
20593OPCODE(0x5DD0)
20594{
20595 u32 adr, res;
20596 u32 src, dst;
20597
20598 adr = AREG((Opcode >> 0) & 7);
20599 if ((flag_N ^ flag_V) & 0x80)
20600 {
20601 res = 0xFF;
20602 PRE_IO
20603 WRITE_BYTE_F(adr, res)
20604 POST_IO
20605 RET(12)
20606 }
20607 res = 0;
20608 PRE_IO
20609 WRITE_BYTE_F(adr, res)
20610 POST_IO
20611 RET(12)
20612}
20613
20614// STCC
20615OPCODE(0x5ED0)
20616{
20617 u32 adr, res;
20618 u32 src, dst;
20619
20620 adr = AREG((Opcode >> 0) & 7);
20621 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20622 {
20623 res = 0xFF;
20624 PRE_IO
20625 WRITE_BYTE_F(adr, res)
20626 POST_IO
20627 RET(12)
20628 }
20629 res = 0;
20630 PRE_IO
20631 WRITE_BYTE_F(adr, res)
20632 POST_IO
20633 RET(12)
20634}
20635
20636// STCC
20637OPCODE(0x5FD0)
20638{
20639 u32 adr, res;
20640 u32 src, dst;
20641
20642 adr = AREG((Opcode >> 0) & 7);
20643 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20644 {
20645 res = 0xFF;
20646 PRE_IO
20647 WRITE_BYTE_F(adr, res)
20648 POST_IO
20649 RET(12)
20650 }
20651 res = 0;
20652 PRE_IO
20653 WRITE_BYTE_F(adr, res)
20654 POST_IO
20655 RET(12)
20656}
20657
20658// STCC
20659OPCODE(0x50D8)
20660{
20661 u32 adr, res;
20662 u32 src, dst;
20663
20664 adr = AREG((Opcode >> 0) & 7);
20665 AREG((Opcode >> 0) & 7) += 1;
20666 res = 0xFF;
20667 PRE_IO
20668 WRITE_BYTE_F(adr, res)
20669 POST_IO
20670 RET(12)
20671}
20672
20673// STCC
20674OPCODE(0x51D8)
20675{
20676 u32 adr, res;
20677 u32 src, dst;
20678
20679 adr = AREG((Opcode >> 0) & 7);
20680 AREG((Opcode >> 0) & 7) += 1;
20681 res = 0;
20682 PRE_IO
20683 WRITE_BYTE_F(adr, res)
20684 POST_IO
20685 RET(12)
20686}
20687
20688// STCC
20689OPCODE(0x52D8)
20690{
20691 u32 adr, res;
20692 u32 src, dst;
20693
20694 adr = AREG((Opcode >> 0) & 7);
20695 AREG((Opcode >> 0) & 7) += 1;
20696 if (flag_NotZ && (!(flag_C & 0x100)))
20697 {
20698 res = 0xFF;
20699 PRE_IO
20700 WRITE_BYTE_F(adr, res)
20701 POST_IO
20702 RET(12)
20703 }
20704 res = 0;
20705 PRE_IO
20706 WRITE_BYTE_F(adr, res)
20707 POST_IO
20708 RET(12)
20709}
20710
20711// STCC
20712OPCODE(0x53D8)
20713{
20714 u32 adr, res;
20715 u32 src, dst;
20716
20717 adr = AREG((Opcode >> 0) & 7);
20718 AREG((Opcode >> 0) & 7) += 1;
20719 if ((!flag_NotZ) || (flag_C & 0x100))
20720 {
20721 res = 0xFF;
20722 PRE_IO
20723 WRITE_BYTE_F(adr, res)
20724 POST_IO
20725 RET(12)
20726 }
20727 res = 0;
20728 PRE_IO
20729 WRITE_BYTE_F(adr, res)
20730 POST_IO
20731 RET(12)
20732}
20733
20734// STCC
20735OPCODE(0x54D8)
20736{
20737 u32 adr, res;
20738 u32 src, dst;
20739
20740 adr = AREG((Opcode >> 0) & 7);
20741 AREG((Opcode >> 0) & 7) += 1;
20742 if (!(flag_C & 0x100))
20743 {
20744 res = 0xFF;
20745 PRE_IO
20746 WRITE_BYTE_F(adr, res)
20747 POST_IO
20748 RET(12)
20749 }
20750 res = 0;
20751 PRE_IO
20752 WRITE_BYTE_F(adr, res)
20753 POST_IO
20754 RET(12)
20755}
20756
20757// STCC
20758OPCODE(0x55D8)
20759{
20760 u32 adr, res;
20761 u32 src, dst;
20762
20763 adr = AREG((Opcode >> 0) & 7);
20764 AREG((Opcode >> 0) & 7) += 1;
20765 if (flag_C & 0x100)
20766 {
20767 res = 0xFF;
20768 PRE_IO
20769 WRITE_BYTE_F(adr, res)
20770 POST_IO
20771 RET(12)
20772 }
20773 res = 0;
20774 PRE_IO
20775 WRITE_BYTE_F(adr, res)
20776 POST_IO
20777 RET(12)
20778}
20779
20780// STCC
20781OPCODE(0x56D8)
20782{
20783 u32 adr, res;
20784 u32 src, dst;
20785
20786 adr = AREG((Opcode >> 0) & 7);
20787 AREG((Opcode >> 0) & 7) += 1;
20788 if (flag_NotZ)
20789 {
20790 res = 0xFF;
20791 PRE_IO
20792 WRITE_BYTE_F(adr, res)
20793 POST_IO
20794 RET(12)
20795 }
20796 res = 0;
20797 PRE_IO
20798 WRITE_BYTE_F(adr, res)
20799 POST_IO
20800 RET(12)
20801}
20802
20803// STCC
20804OPCODE(0x57D8)
20805{
20806 u32 adr, res;
20807 u32 src, dst;
20808
20809 adr = AREG((Opcode >> 0) & 7);
20810 AREG((Opcode >> 0) & 7) += 1;
20811 if (!flag_NotZ)
20812 {
20813 res = 0xFF;
20814 PRE_IO
20815 WRITE_BYTE_F(adr, res)
20816 POST_IO
20817 RET(12)
20818 }
20819 res = 0;
20820 PRE_IO
20821 WRITE_BYTE_F(adr, res)
20822 POST_IO
20823 RET(12)
20824}
20825
20826// STCC
20827OPCODE(0x58D8)
20828{
20829 u32 adr, res;
20830 u32 src, dst;
20831
20832 adr = AREG((Opcode >> 0) & 7);
20833 AREG((Opcode >> 0) & 7) += 1;
20834 if (!(flag_V & 0x80))
20835 {
20836 res = 0xFF;
20837 PRE_IO
20838 WRITE_BYTE_F(adr, res)
20839 POST_IO
20840 RET(12)
20841 }
20842 res = 0;
20843 PRE_IO
20844 WRITE_BYTE_F(adr, res)
20845 POST_IO
20846 RET(12)
20847}
20848
20849// STCC
20850OPCODE(0x59D8)
20851{
20852 u32 adr, res;
20853 u32 src, dst;
20854
20855 adr = AREG((Opcode >> 0) & 7);
20856 AREG((Opcode >> 0) & 7) += 1;
20857 if (flag_V & 0x80)
20858 {
20859 res = 0xFF;
20860 PRE_IO
20861 WRITE_BYTE_F(adr, res)
20862 POST_IO
20863 RET(12)
20864 }
20865 res = 0;
20866 PRE_IO
20867 WRITE_BYTE_F(adr, res)
20868 POST_IO
20869 RET(12)
20870}
20871
20872// STCC
20873OPCODE(0x5AD8)
20874{
20875 u32 adr, res;
20876 u32 src, dst;
20877
20878 adr = AREG((Opcode >> 0) & 7);
20879 AREG((Opcode >> 0) & 7) += 1;
20880 if (!(flag_N & 0x80))
20881 {
20882 res = 0xFF;
20883 PRE_IO
20884 WRITE_BYTE_F(adr, res)
20885 POST_IO
20886 RET(12)
20887 }
20888 res = 0;
20889 PRE_IO
20890 WRITE_BYTE_F(adr, res)
20891 POST_IO
20892 RET(12)
20893}
20894
20895// STCC
20896OPCODE(0x5BD8)
20897{
20898 u32 adr, res;
20899 u32 src, dst;
20900
20901 adr = AREG((Opcode >> 0) & 7);
20902 AREG((Opcode >> 0) & 7) += 1;
20903 if (flag_N & 0x80)
20904 {
20905 res = 0xFF;
20906 PRE_IO
20907 WRITE_BYTE_F(adr, res)
20908 POST_IO
20909 RET(12)
20910 }
20911 res = 0;
20912 PRE_IO
20913 WRITE_BYTE_F(adr, res)
20914 POST_IO
20915 RET(12)
20916}
20917
20918// STCC
20919OPCODE(0x5CD8)
20920{
20921 u32 adr, res;
20922 u32 src, dst;
20923
20924 adr = AREG((Opcode >> 0) & 7);
20925 AREG((Opcode >> 0) & 7) += 1;
20926 if (!((flag_N ^ flag_V) & 0x80))
20927 {
20928 res = 0xFF;
20929 PRE_IO
20930 WRITE_BYTE_F(adr, res)
20931 POST_IO
20932 RET(12)
20933 }
20934 res = 0;
20935 PRE_IO
20936 WRITE_BYTE_F(adr, res)
20937 POST_IO
20938 RET(12)
20939}
20940
20941// STCC
20942OPCODE(0x5DD8)
20943{
20944 u32 adr, res;
20945 u32 src, dst;
20946
20947 adr = AREG((Opcode >> 0) & 7);
20948 AREG((Opcode >> 0) & 7) += 1;
20949 if ((flag_N ^ flag_V) & 0x80)
20950 {
20951 res = 0xFF;
20952 PRE_IO
20953 WRITE_BYTE_F(adr, res)
20954 POST_IO
20955 RET(12)
20956 }
20957 res = 0;
20958 PRE_IO
20959 WRITE_BYTE_F(adr, res)
20960 POST_IO
20961 RET(12)
20962}
20963
20964// STCC
20965OPCODE(0x5ED8)
20966{
20967 u32 adr, res;
20968 u32 src, dst;
20969
20970 adr = AREG((Opcode >> 0) & 7);
20971 AREG((Opcode >> 0) & 7) += 1;
20972 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20973 {
20974 res = 0xFF;
20975 PRE_IO
20976 WRITE_BYTE_F(adr, res)
20977 POST_IO
20978 RET(12)
20979 }
20980 res = 0;
20981 PRE_IO
20982 WRITE_BYTE_F(adr, res)
20983 POST_IO
20984 RET(12)
20985}
20986
20987// STCC
20988OPCODE(0x5FD8)
20989{
20990 u32 adr, res;
20991 u32 src, dst;
20992
20993 adr = AREG((Opcode >> 0) & 7);
20994 AREG((Opcode >> 0) & 7) += 1;
20995 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20996 {
20997 res = 0xFF;
20998 PRE_IO
20999 WRITE_BYTE_F(adr, res)
21000 POST_IO
21001 RET(12)
21002 }
21003 res = 0;
21004 PRE_IO
21005 WRITE_BYTE_F(adr, res)
21006 POST_IO
21007 RET(12)
21008}
21009
21010// STCC
21011OPCODE(0x50E0)
21012{
21013 u32 adr, res;
21014 u32 src, dst;
21015
21016 adr = AREG((Opcode >> 0) & 7) - 1;
21017 AREG((Opcode >> 0) & 7) = adr;
21018 res = 0xFF;
21019 PRE_IO
21020 WRITE_BYTE_F(adr, res)
21021 POST_IO
21022 RET(14)
21023}
21024
21025// STCC
21026OPCODE(0x51E0)
21027{
21028 u32 adr, res;
21029 u32 src, dst;
21030
21031 adr = AREG((Opcode >> 0) & 7) - 1;
21032 AREG((Opcode >> 0) & 7) = adr;
21033 res = 0;
21034 PRE_IO
21035 WRITE_BYTE_F(adr, res)
21036 POST_IO
21037 RET(14)
21038}
21039
21040// STCC
21041OPCODE(0x52E0)
21042{
21043 u32 adr, res;
21044 u32 src, dst;
21045
21046 adr = AREG((Opcode >> 0) & 7) - 1;
21047 AREG((Opcode >> 0) & 7) = adr;
21048 if (flag_NotZ && (!(flag_C & 0x100)))
21049 {
21050 res = 0xFF;
21051 PRE_IO
21052 WRITE_BYTE_F(adr, res)
21053 POST_IO
21054 RET(14)
21055 }
21056 res = 0;
21057 PRE_IO
21058 WRITE_BYTE_F(adr, res)
21059 POST_IO
21060 RET(14)
21061}
21062
21063// STCC
21064OPCODE(0x53E0)
21065{
21066 u32 adr, res;
21067 u32 src, dst;
21068
21069 adr = AREG((Opcode >> 0) & 7) - 1;
21070 AREG((Opcode >> 0) & 7) = adr;
21071 if ((!flag_NotZ) || (flag_C & 0x100))
21072 {
21073 res = 0xFF;
21074 PRE_IO
21075 WRITE_BYTE_F(adr, res)
21076 POST_IO
21077 RET(14)
21078 }
21079 res = 0;
21080 PRE_IO
21081 WRITE_BYTE_F(adr, res)
21082 POST_IO
21083 RET(14)
21084}
21085
21086// STCC
21087OPCODE(0x54E0)
21088{
21089 u32 adr, res;
21090 u32 src, dst;
21091
21092 adr = AREG((Opcode >> 0) & 7) - 1;
21093 AREG((Opcode >> 0) & 7) = adr;
21094 if (!(flag_C & 0x100))
21095 {
21096 res = 0xFF;
21097 PRE_IO
21098 WRITE_BYTE_F(adr, res)
21099 POST_IO
21100 RET(14)
21101 }
21102 res = 0;
21103 PRE_IO
21104 WRITE_BYTE_F(adr, res)
21105 POST_IO
21106 RET(14)
21107}
21108
21109// STCC
21110OPCODE(0x55E0)
21111{
21112 u32 adr, res;
21113 u32 src, dst;
21114
21115 adr = AREG((Opcode >> 0) & 7) - 1;
21116 AREG((Opcode >> 0) & 7) = adr;
21117 if (flag_C & 0x100)
21118 {
21119 res = 0xFF;
21120 PRE_IO
21121 WRITE_BYTE_F(adr, res)
21122 POST_IO
21123 RET(14)
21124 }
21125 res = 0;
21126 PRE_IO
21127 WRITE_BYTE_F(adr, res)
21128 POST_IO
21129 RET(14)
21130}
21131
21132// STCC
21133OPCODE(0x56E0)
21134{
21135 u32 adr, res;
21136 u32 src, dst;
21137
21138 adr = AREG((Opcode >> 0) & 7) - 1;
21139 AREG((Opcode >> 0) & 7) = adr;
21140 if (flag_NotZ)
21141 {
21142 res = 0xFF;
21143 PRE_IO
21144 WRITE_BYTE_F(adr, res)
21145 POST_IO
21146 RET(14)
21147 }
21148 res = 0;
21149 PRE_IO
21150 WRITE_BYTE_F(adr, res)
21151 POST_IO
21152 RET(14)
21153}
21154
21155// STCC
21156OPCODE(0x57E0)
21157{
21158 u32 adr, res;
21159 u32 src, dst;
21160
21161 adr = AREG((Opcode >> 0) & 7) - 1;
21162 AREG((Opcode >> 0) & 7) = adr;
21163 if (!flag_NotZ)
21164 {
21165 res = 0xFF;
21166 PRE_IO
21167 WRITE_BYTE_F(adr, res)
21168 POST_IO
21169 RET(14)
21170 }
21171 res = 0;
21172 PRE_IO
21173 WRITE_BYTE_F(adr, res)
21174 POST_IO
21175 RET(14)
21176}
21177
21178// STCC
21179OPCODE(0x58E0)
21180{
21181 u32 adr, res;
21182 u32 src, dst;
21183
21184 adr = AREG((Opcode >> 0) & 7) - 1;
21185 AREG((Opcode >> 0) & 7) = adr;
21186 if (!(flag_V & 0x80))
21187 {
21188 res = 0xFF;
21189 PRE_IO
21190 WRITE_BYTE_F(adr, res)
21191 POST_IO
21192 RET(14)
21193 }
21194 res = 0;
21195 PRE_IO
21196 WRITE_BYTE_F(adr, res)
21197 POST_IO
21198 RET(14)
21199}
21200
21201// STCC
21202OPCODE(0x59E0)
21203{
21204 u32 adr, res;
21205 u32 src, dst;
21206
21207 adr = AREG((Opcode >> 0) & 7) - 1;
21208 AREG((Opcode >> 0) & 7) = adr;
21209 if (flag_V & 0x80)
21210 {
21211 res = 0xFF;
21212 PRE_IO
21213 WRITE_BYTE_F(adr, res)
21214 POST_IO
21215 RET(14)
21216 }
21217 res = 0;
21218 PRE_IO
21219 WRITE_BYTE_F(adr, res)
21220 POST_IO
21221 RET(14)
21222}
21223
21224// STCC
21225OPCODE(0x5AE0)
21226{
21227 u32 adr, res;
21228 u32 src, dst;
21229
21230 adr = AREG((Opcode >> 0) & 7) - 1;
21231 AREG((Opcode >> 0) & 7) = adr;
21232 if (!(flag_N & 0x80))
21233 {
21234 res = 0xFF;
21235 PRE_IO
21236 WRITE_BYTE_F(adr, res)
21237 POST_IO
21238 RET(14)
21239 }
21240 res = 0;
21241 PRE_IO
21242 WRITE_BYTE_F(adr, res)
21243 POST_IO
21244 RET(14)
21245}
21246
21247// STCC
21248OPCODE(0x5BE0)
21249{
21250 u32 adr, res;
21251 u32 src, dst;
21252
21253 adr = AREG((Opcode >> 0) & 7) - 1;
21254 AREG((Opcode >> 0) & 7) = adr;
21255 if (flag_N & 0x80)
21256 {
21257 res = 0xFF;
21258 PRE_IO
21259 WRITE_BYTE_F(adr, res)
21260 POST_IO
21261 RET(14)
21262 }
21263 res = 0;
21264 PRE_IO
21265 WRITE_BYTE_F(adr, res)
21266 POST_IO
21267 RET(14)
21268}
21269
21270// STCC
21271OPCODE(0x5CE0)
21272{
21273 u32 adr, res;
21274 u32 src, dst;
21275
21276 adr = AREG((Opcode >> 0) & 7) - 1;
21277 AREG((Opcode >> 0) & 7) = adr;
21278 if (!((flag_N ^ flag_V) & 0x80))
21279 {
21280 res = 0xFF;
21281 PRE_IO
21282 WRITE_BYTE_F(adr, res)
21283 POST_IO
21284 RET(14)
21285 }
21286 res = 0;
21287 PRE_IO
21288 WRITE_BYTE_F(adr, res)
21289 POST_IO
21290 RET(14)
21291}
21292
21293// STCC
21294OPCODE(0x5DE0)
21295{
21296 u32 adr, res;
21297 u32 src, dst;
21298
21299 adr = AREG((Opcode >> 0) & 7) - 1;
21300 AREG((Opcode >> 0) & 7) = adr;
21301 if ((flag_N ^ flag_V) & 0x80)
21302 {
21303 res = 0xFF;
21304 PRE_IO
21305 WRITE_BYTE_F(adr, res)
21306 POST_IO
21307 RET(14)
21308 }
21309 res = 0;
21310 PRE_IO
21311 WRITE_BYTE_F(adr, res)
21312 POST_IO
21313 RET(14)
21314}
21315
21316// STCC
21317OPCODE(0x5EE0)
21318{
21319 u32 adr, res;
21320 u32 src, dst;
21321
21322 adr = AREG((Opcode >> 0) & 7) - 1;
21323 AREG((Opcode >> 0) & 7) = adr;
21324 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21325 {
21326 res = 0xFF;
21327 PRE_IO
21328 WRITE_BYTE_F(adr, res)
21329 POST_IO
21330 RET(14)
21331 }
21332 res = 0;
21333 PRE_IO
21334 WRITE_BYTE_F(adr, res)
21335 POST_IO
21336 RET(14)
21337}
21338
21339// STCC
21340OPCODE(0x5FE0)
21341{
21342 u32 adr, res;
21343 u32 src, dst;
21344
21345 adr = AREG((Opcode >> 0) & 7) - 1;
21346 AREG((Opcode >> 0) & 7) = adr;
21347 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21348 {
21349 res = 0xFF;
21350 PRE_IO
21351 WRITE_BYTE_F(adr, res)
21352 POST_IO
21353 RET(14)
21354 }
21355 res = 0;
21356 PRE_IO
21357 WRITE_BYTE_F(adr, res)
21358 POST_IO
21359 RET(14)
21360}
21361
21362// STCC
21363OPCODE(0x50E8)
21364{
21365 u32 adr, res;
21366 u32 src, dst;
21367
21368 FETCH_SWORD(adr);
21369 adr += AREG((Opcode >> 0) & 7);
21370 res = 0xFF;
21371 PRE_IO
21372 WRITE_BYTE_F(adr, res)
21373 POST_IO
21374 RET(16)
21375}
21376
21377// STCC
21378OPCODE(0x51E8)
21379{
21380 u32 adr, res;
21381 u32 src, dst;
21382
21383 FETCH_SWORD(adr);
21384 adr += AREG((Opcode >> 0) & 7);
21385 res = 0;
21386 PRE_IO
21387 WRITE_BYTE_F(adr, res)
21388 POST_IO
21389 RET(16)
21390}
21391
21392// STCC
21393OPCODE(0x52E8)
21394{
21395 u32 adr, res;
21396 u32 src, dst;
21397
21398 FETCH_SWORD(adr);
21399 adr += AREG((Opcode >> 0) & 7);
21400 if (flag_NotZ && (!(flag_C & 0x100)))
21401 {
21402 res = 0xFF;
21403 PRE_IO
21404 WRITE_BYTE_F(adr, res)
21405 POST_IO
21406 RET(16)
21407 }
21408 res = 0;
21409 PRE_IO
21410 WRITE_BYTE_F(adr, res)
21411 POST_IO
21412 RET(16)
21413}
21414
21415// STCC
21416OPCODE(0x53E8)
21417{
21418 u32 adr, res;
21419 u32 src, dst;
21420
21421 FETCH_SWORD(adr);
21422 adr += AREG((Opcode >> 0) & 7);
21423 if ((!flag_NotZ) || (flag_C & 0x100))
21424 {
21425 res = 0xFF;
21426 PRE_IO
21427 WRITE_BYTE_F(adr, res)
21428 POST_IO
21429 RET(16)
21430 }
21431 res = 0;
21432 PRE_IO
21433 WRITE_BYTE_F(adr, res)
21434 POST_IO
21435 RET(16)
21436}
21437
21438// STCC
21439OPCODE(0x54E8)
21440{
21441 u32 adr, res;
21442 u32 src, dst;
21443
21444 FETCH_SWORD(adr);
21445 adr += AREG((Opcode >> 0) & 7);
21446 if (!(flag_C & 0x100))
21447 {
21448 res = 0xFF;
21449 PRE_IO
21450 WRITE_BYTE_F(adr, res)
21451 POST_IO
21452 RET(16)
21453 }
21454 res = 0;
21455 PRE_IO
21456 WRITE_BYTE_F(adr, res)
21457 POST_IO
21458 RET(16)
21459}
21460
21461// STCC
21462OPCODE(0x55E8)
21463{
21464 u32 adr, res;
21465 u32 src, dst;
21466
21467 FETCH_SWORD(adr);
21468 adr += AREG((Opcode >> 0) & 7);
21469 if (flag_C & 0x100)
21470 {
21471 res = 0xFF;
21472 PRE_IO
21473 WRITE_BYTE_F(adr, res)
21474 POST_IO
21475 RET(16)
21476 }
21477 res = 0;
21478 PRE_IO
21479 WRITE_BYTE_F(adr, res)
21480 POST_IO
21481 RET(16)
21482}
21483
21484// STCC
21485OPCODE(0x56E8)
21486{
21487 u32 adr, res;
21488 u32 src, dst;
21489
21490 FETCH_SWORD(adr);
21491 adr += AREG((Opcode >> 0) & 7);
21492 if (flag_NotZ)
21493 {
21494 res = 0xFF;
21495 PRE_IO
21496 WRITE_BYTE_F(adr, res)
21497 POST_IO
21498 RET(16)
21499 }
21500 res = 0;
21501 PRE_IO
21502 WRITE_BYTE_F(adr, res)
21503 POST_IO
21504 RET(16)
21505}
21506
21507// STCC
21508OPCODE(0x57E8)
21509{
21510 u32 adr, res;
21511 u32 src, dst;
21512
21513 FETCH_SWORD(adr);
21514 adr += AREG((Opcode >> 0) & 7);
21515 if (!flag_NotZ)
21516 {
21517 res = 0xFF;
21518 PRE_IO
21519 WRITE_BYTE_F(adr, res)
21520 POST_IO
21521 RET(16)
21522 }
21523 res = 0;
21524 PRE_IO
21525 WRITE_BYTE_F(adr, res)
21526 POST_IO
21527 RET(16)
21528}
21529
21530// STCC
21531OPCODE(0x58E8)
21532{
21533 u32 adr, res;
21534 u32 src, dst;
21535
21536 FETCH_SWORD(adr);
21537 adr += AREG((Opcode >> 0) & 7);
21538 if (!(flag_V & 0x80))
21539 {
21540 res = 0xFF;
21541 PRE_IO
21542 WRITE_BYTE_F(adr, res)
21543 POST_IO
21544 RET(16)
21545 }
21546 res = 0;
21547 PRE_IO
21548 WRITE_BYTE_F(adr, res)
21549 POST_IO
21550 RET(16)
21551}
21552
21553// STCC
21554OPCODE(0x59E8)
21555{
21556 u32 adr, res;
21557 u32 src, dst;
21558
21559 FETCH_SWORD(adr);
21560 adr += AREG((Opcode >> 0) & 7);
21561 if (flag_V & 0x80)
21562 {
21563 res = 0xFF;
21564 PRE_IO
21565 WRITE_BYTE_F(adr, res)
21566 POST_IO
21567 RET(16)
21568 }
21569 res = 0;
21570 PRE_IO
21571 WRITE_BYTE_F(adr, res)
21572 POST_IO
21573 RET(16)
21574}
21575
21576// STCC
21577OPCODE(0x5AE8)
21578{
21579 u32 adr, res;
21580 u32 src, dst;
21581
21582 FETCH_SWORD(adr);
21583 adr += AREG((Opcode >> 0) & 7);
21584 if (!(flag_N & 0x80))
21585 {
21586 res = 0xFF;
21587 PRE_IO
21588 WRITE_BYTE_F(adr, res)
21589 POST_IO
21590 RET(16)
21591 }
21592 res = 0;
21593 PRE_IO
21594 WRITE_BYTE_F(adr, res)
21595 POST_IO
21596 RET(16)
21597}
21598
21599// STCC
21600OPCODE(0x5BE8)
21601{
21602 u32 adr, res;
21603 u32 src, dst;
21604
21605 FETCH_SWORD(adr);
21606 adr += AREG((Opcode >> 0) & 7);
21607 if (flag_N & 0x80)
21608 {
21609 res = 0xFF;
21610 PRE_IO
21611 WRITE_BYTE_F(adr, res)
21612 POST_IO
21613 RET(16)
21614 }
21615 res = 0;
21616 PRE_IO
21617 WRITE_BYTE_F(adr, res)
21618 POST_IO
21619 RET(16)
21620}
21621
21622// STCC
21623OPCODE(0x5CE8)
21624{
21625 u32 adr, res;
21626 u32 src, dst;
21627
21628 FETCH_SWORD(adr);
21629 adr += AREG((Opcode >> 0) & 7);
21630 if (!((flag_N ^ flag_V) & 0x80))
21631 {
21632 res = 0xFF;
21633 PRE_IO
21634 WRITE_BYTE_F(adr, res)
21635 POST_IO
21636 RET(16)
21637 }
21638 res = 0;
21639 PRE_IO
21640 WRITE_BYTE_F(adr, res)
21641 POST_IO
21642 RET(16)
21643}
21644
21645// STCC
21646OPCODE(0x5DE8)
21647{
21648 u32 adr, res;
21649 u32 src, dst;
21650
21651 FETCH_SWORD(adr);
21652 adr += AREG((Opcode >> 0) & 7);
21653 if ((flag_N ^ flag_V) & 0x80)
21654 {
21655 res = 0xFF;
21656 PRE_IO
21657 WRITE_BYTE_F(adr, res)
21658 POST_IO
21659 RET(16)
21660 }
21661 res = 0;
21662 PRE_IO
21663 WRITE_BYTE_F(adr, res)
21664 POST_IO
21665 RET(16)
21666}
21667
21668// STCC
21669OPCODE(0x5EE8)
21670{
21671 u32 adr, res;
21672 u32 src, dst;
21673
21674 FETCH_SWORD(adr);
21675 adr += AREG((Opcode >> 0) & 7);
21676 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21677 {
21678 res = 0xFF;
21679 PRE_IO
21680 WRITE_BYTE_F(adr, res)
21681 POST_IO
21682 RET(16)
21683 }
21684 res = 0;
21685 PRE_IO
21686 WRITE_BYTE_F(adr, res)
21687 POST_IO
21688 RET(16)
21689}
21690
21691// STCC
21692OPCODE(0x5FE8)
21693{
21694 u32 adr, res;
21695 u32 src, dst;
21696
21697 FETCH_SWORD(adr);
21698 adr += AREG((Opcode >> 0) & 7);
21699 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21700 {
21701 res = 0xFF;
21702 PRE_IO
21703 WRITE_BYTE_F(adr, res)
21704 POST_IO
21705 RET(16)
21706 }
21707 res = 0;
21708 PRE_IO
21709 WRITE_BYTE_F(adr, res)
21710 POST_IO
21711 RET(16)
21712}
21713
21714// STCC
21715OPCODE(0x50F0)
21716{
21717 u32 adr, res;
21718 u32 src, dst;
21719
21720 adr = AREG((Opcode >> 0) & 7);
21721 DECODE_EXT_WORD
21722 res = 0xFF;
21723 PRE_IO
21724 WRITE_BYTE_F(adr, res)
21725 POST_IO
21726 RET(18)
21727}
21728
21729// STCC
21730OPCODE(0x51F0)
21731{
21732 u32 adr, res;
21733 u32 src, dst;
21734
21735 adr = AREG((Opcode >> 0) & 7);
21736 DECODE_EXT_WORD
21737 res = 0;
21738 PRE_IO
21739 WRITE_BYTE_F(adr, res)
21740 POST_IO
21741 RET(18)
21742}
21743
21744// STCC
21745OPCODE(0x52F0)
21746{
21747 u32 adr, res;
21748 u32 src, dst;
21749
21750 adr = AREG((Opcode >> 0) & 7);
21751 DECODE_EXT_WORD
21752 if (flag_NotZ && (!(flag_C & 0x100)))
21753 {
21754 res = 0xFF;
21755 PRE_IO
21756 WRITE_BYTE_F(adr, res)
21757 POST_IO
21758 RET(18)
21759 }
21760 res = 0;
21761 PRE_IO
21762 WRITE_BYTE_F(adr, res)
21763 POST_IO
21764 RET(18)
21765}
21766
21767// STCC
21768OPCODE(0x53F0)
21769{
21770 u32 adr, res;
21771 u32 src, dst;
21772
21773 adr = AREG((Opcode >> 0) & 7);
21774 DECODE_EXT_WORD
21775 if ((!flag_NotZ) || (flag_C & 0x100))
21776 {
21777 res = 0xFF;
21778 PRE_IO
21779 WRITE_BYTE_F(adr, res)
21780 POST_IO
21781 RET(18)
21782 }
21783 res = 0;
21784 PRE_IO
21785 WRITE_BYTE_F(adr, res)
21786 POST_IO
21787 RET(18)
21788}
21789
21790// STCC
21791OPCODE(0x54F0)
21792{
21793 u32 adr, res;
21794 u32 src, dst;
21795
21796 adr = AREG((Opcode >> 0) & 7);
21797 DECODE_EXT_WORD
21798 if (!(flag_C & 0x100))
21799 {
21800 res = 0xFF;
21801 PRE_IO
21802 WRITE_BYTE_F(adr, res)
21803 POST_IO
21804 RET(18)
21805 }
21806 res = 0;
21807 PRE_IO
21808 WRITE_BYTE_F(adr, res)
21809 POST_IO
21810 RET(18)
21811}
21812
21813// STCC
21814OPCODE(0x55F0)
21815{
21816 u32 adr, res;
21817 u32 src, dst;
21818
21819 adr = AREG((Opcode >> 0) & 7);
21820 DECODE_EXT_WORD
21821 if (flag_C & 0x100)
21822 {
21823 res = 0xFF;
21824 PRE_IO
21825 WRITE_BYTE_F(adr, res)
21826 POST_IO
21827 RET(18)
21828 }
21829 res = 0;
21830 PRE_IO
21831 WRITE_BYTE_F(adr, res)
21832 POST_IO
21833 RET(18)
21834}
21835
21836// STCC
21837OPCODE(0x56F0)
21838{
21839 u32 adr, res;
21840 u32 src, dst;
21841
21842 adr = AREG((Opcode >> 0) & 7);
21843 DECODE_EXT_WORD
21844 if (flag_NotZ)
21845 {
21846 res = 0xFF;
21847 PRE_IO
21848 WRITE_BYTE_F(adr, res)
21849 POST_IO
21850 RET(18)
21851 }
21852 res = 0;
21853 PRE_IO
21854 WRITE_BYTE_F(adr, res)
21855 POST_IO
21856 RET(18)
21857}
21858
21859// STCC
21860OPCODE(0x57F0)
21861{
21862 u32 adr, res;
21863 u32 src, dst;
21864
21865 adr = AREG((Opcode >> 0) & 7);
21866 DECODE_EXT_WORD
21867 if (!flag_NotZ)
21868 {
21869 res = 0xFF;
21870 PRE_IO
21871 WRITE_BYTE_F(adr, res)
21872 POST_IO
21873 RET(18)
21874 }
21875 res = 0;
21876 PRE_IO
21877 WRITE_BYTE_F(adr, res)
21878 POST_IO
21879 RET(18)
21880}
21881
21882// STCC
21883OPCODE(0x58F0)
21884{
21885 u32 adr, res;
21886 u32 src, dst;
21887
21888 adr = AREG((Opcode >> 0) & 7);
21889 DECODE_EXT_WORD
21890 if (!(flag_V & 0x80))
21891 {
21892 res = 0xFF;
21893 PRE_IO
21894 WRITE_BYTE_F(adr, res)
21895 POST_IO
21896 RET(18)
21897 }
21898 res = 0;
21899 PRE_IO
21900 WRITE_BYTE_F(adr, res)
21901 POST_IO
21902 RET(18)
21903}
21904
21905// STCC
21906OPCODE(0x59F0)
21907{
21908 u32 adr, res;
21909 u32 src, dst;
21910
21911 adr = AREG((Opcode >> 0) & 7);
21912 DECODE_EXT_WORD
21913 if (flag_V & 0x80)
21914 {
21915 res = 0xFF;
21916 PRE_IO
21917 WRITE_BYTE_F(adr, res)
21918 POST_IO
21919 RET(18)
21920 }
21921 res = 0;
21922 PRE_IO
21923 WRITE_BYTE_F(adr, res)
21924 POST_IO
21925 RET(18)
21926}
21927
21928// STCC
21929OPCODE(0x5AF0)
21930{
21931 u32 adr, res;
21932 u32 src, dst;
21933
21934 adr = AREG((Opcode >> 0) & 7);
21935 DECODE_EXT_WORD
21936 if (!(flag_N & 0x80))
21937 {
21938 res = 0xFF;
21939 PRE_IO
21940 WRITE_BYTE_F(adr, res)
21941 POST_IO
21942 RET(18)
21943 }
21944 res = 0;
21945 PRE_IO
21946 WRITE_BYTE_F(adr, res)
21947 POST_IO
21948 RET(18)
21949}
21950
21951// STCC
21952OPCODE(0x5BF0)
21953{
21954 u32 adr, res;
21955 u32 src, dst;
21956
21957 adr = AREG((Opcode >> 0) & 7);
21958 DECODE_EXT_WORD
21959 if (flag_N & 0x80)
21960 {
21961 res = 0xFF;
21962 PRE_IO
21963 WRITE_BYTE_F(adr, res)
21964 POST_IO
21965 RET(18)
21966 }
21967 res = 0;
21968 PRE_IO
21969 WRITE_BYTE_F(adr, res)
21970 POST_IO
21971 RET(18)
21972}
21973
21974// STCC
21975OPCODE(0x5CF0)
21976{
21977 u32 adr, res;
21978 u32 src, dst;
21979
21980 adr = AREG((Opcode >> 0) & 7);
21981 DECODE_EXT_WORD
21982 if (!((flag_N ^ flag_V) & 0x80))
21983 {
21984 res = 0xFF;
21985 PRE_IO
21986 WRITE_BYTE_F(adr, res)
21987 POST_IO
21988 RET(18)
21989 }
21990 res = 0;
21991 PRE_IO
21992 WRITE_BYTE_F(adr, res)
21993 POST_IO
21994 RET(18)
21995}
21996
21997// STCC
21998OPCODE(0x5DF0)
21999{
22000 u32 adr, res;
22001 u32 src, dst;
22002
22003 adr = AREG((Opcode >> 0) & 7);
22004 DECODE_EXT_WORD
22005 if ((flag_N ^ flag_V) & 0x80)
22006 {
22007 res = 0xFF;
22008 PRE_IO
22009 WRITE_BYTE_F(adr, res)
22010 POST_IO
22011 RET(18)
22012 }
22013 res = 0;
22014 PRE_IO
22015 WRITE_BYTE_F(adr, res)
22016 POST_IO
22017 RET(18)
22018}
22019
22020// STCC
22021OPCODE(0x5EF0)
22022{
22023 u32 adr, res;
22024 u32 src, dst;
22025
22026 adr = AREG((Opcode >> 0) & 7);
22027 DECODE_EXT_WORD
22028 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22029 {
22030 res = 0xFF;
22031 PRE_IO
22032 WRITE_BYTE_F(adr, res)
22033 POST_IO
22034 RET(18)
22035 }
22036 res = 0;
22037 PRE_IO
22038 WRITE_BYTE_F(adr, res)
22039 POST_IO
22040 RET(18)
22041}
22042
22043// STCC
22044OPCODE(0x5FF0)
22045{
22046 u32 adr, res;
22047 u32 src, dst;
22048
22049 adr = AREG((Opcode >> 0) & 7);
22050 DECODE_EXT_WORD
22051 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22052 {
22053 res = 0xFF;
22054 PRE_IO
22055 WRITE_BYTE_F(adr, res)
22056 POST_IO
22057 RET(18)
22058 }
22059 res = 0;
22060 PRE_IO
22061 WRITE_BYTE_F(adr, res)
22062 POST_IO
22063 RET(18)
22064}
22065
22066// STCC
22067OPCODE(0x50F8)
22068{
22069 u32 adr, res;
22070 u32 src, dst;
22071
22072 FETCH_SWORD(adr);
22073 res = 0xFF;
22074 PRE_IO
22075 WRITE_BYTE_F(adr, res)
22076 POST_IO
22077 RET(16)
22078}
22079
22080// STCC
22081OPCODE(0x51F8)
22082{
22083 u32 adr, res;
22084 u32 src, dst;
22085
22086 FETCH_SWORD(adr);
22087 res = 0;
22088 PRE_IO
22089 WRITE_BYTE_F(adr, res)
22090 POST_IO
22091 RET(16)
22092}
22093
22094// STCC
22095OPCODE(0x52F8)
22096{
22097 u32 adr, res;
22098 u32 src, dst;
22099
22100 FETCH_SWORD(adr);
22101 if (flag_NotZ && (!(flag_C & 0x100)))
22102 {
22103 res = 0xFF;
22104 PRE_IO
22105 WRITE_BYTE_F(adr, res)
22106 POST_IO
22107 RET(16)
22108 }
22109 res = 0;
22110 PRE_IO
22111 WRITE_BYTE_F(adr, res)
22112 POST_IO
22113 RET(16)
22114}
22115
22116// STCC
22117OPCODE(0x53F8)
22118{
22119 u32 adr, res;
22120 u32 src, dst;
22121
22122 FETCH_SWORD(adr);
22123 if ((!flag_NotZ) || (flag_C & 0x100))
22124 {
22125 res = 0xFF;
22126 PRE_IO
22127 WRITE_BYTE_F(adr, res)
22128 POST_IO
22129 RET(16)
22130 }
22131 res = 0;
22132 PRE_IO
22133 WRITE_BYTE_F(adr, res)
22134 POST_IO
22135 RET(16)
22136}
22137
22138// STCC
22139OPCODE(0x54F8)
22140{
22141 u32 adr, res;
22142 u32 src, dst;
22143
22144 FETCH_SWORD(adr);
22145 if (!(flag_C & 0x100))
22146 {
22147 res = 0xFF;
22148 PRE_IO
22149 WRITE_BYTE_F(adr, res)
22150 POST_IO
22151 RET(16)
22152 }
22153 res = 0;
22154 PRE_IO
22155 WRITE_BYTE_F(adr, res)
22156 POST_IO
22157 RET(16)
22158}
22159
22160// STCC
22161OPCODE(0x55F8)
22162{
22163 u32 adr, res;
22164 u32 src, dst;
22165
22166 FETCH_SWORD(adr);
22167 if (flag_C & 0x100)
22168 {
22169 res = 0xFF;
22170 PRE_IO
22171 WRITE_BYTE_F(adr, res)
22172 POST_IO
22173 RET(16)
22174 }
22175 res = 0;
22176 PRE_IO
22177 WRITE_BYTE_F(adr, res)
22178 POST_IO
22179 RET(16)
22180}
22181
22182// STCC
22183OPCODE(0x56F8)
22184{
22185 u32 adr, res;
22186 u32 src, dst;
22187
22188 FETCH_SWORD(adr);
22189 if (flag_NotZ)
22190 {
22191 res = 0xFF;
22192 PRE_IO
22193 WRITE_BYTE_F(adr, res)
22194 POST_IO
22195 RET(16)
22196 }
22197 res = 0;
22198 PRE_IO
22199 WRITE_BYTE_F(adr, res)
22200 POST_IO
22201 RET(16)
22202}
22203
22204// STCC
22205OPCODE(0x57F8)
22206{
22207 u32 adr, res;
22208 u32 src, dst;
22209
22210 FETCH_SWORD(adr);
22211 if (!flag_NotZ)
22212 {
22213 res = 0xFF;
22214 PRE_IO
22215 WRITE_BYTE_F(adr, res)
22216 POST_IO
22217 RET(16)
22218 }
22219 res = 0;
22220 PRE_IO
22221 WRITE_BYTE_F(adr, res)
22222 POST_IO
22223 RET(16)
22224}
22225
22226// STCC
22227OPCODE(0x58F8)
22228{
22229 u32 adr, res;
22230 u32 src, dst;
22231
22232 FETCH_SWORD(adr);
22233 if (!(flag_V & 0x80))
22234 {
22235 res = 0xFF;
22236 PRE_IO
22237 WRITE_BYTE_F(adr, res)
22238 POST_IO
22239 RET(16)
22240 }
22241 res = 0;
22242 PRE_IO
22243 WRITE_BYTE_F(adr, res)
22244 POST_IO
22245 RET(16)
22246}
22247
22248// STCC
22249OPCODE(0x59F8)
22250{
22251 u32 adr, res;
22252 u32 src, dst;
22253
22254 FETCH_SWORD(adr);
22255 if (flag_V & 0x80)
22256 {
22257 res = 0xFF;
22258 PRE_IO
22259 WRITE_BYTE_F(adr, res)
22260 POST_IO
22261 RET(16)
22262 }
22263 res = 0;
22264 PRE_IO
22265 WRITE_BYTE_F(adr, res)
22266 POST_IO
22267 RET(16)
22268}
22269
22270// STCC
22271OPCODE(0x5AF8)
22272{
22273 u32 adr, res;
22274 u32 src, dst;
22275
22276 FETCH_SWORD(adr);
22277 if (!(flag_N & 0x80))
22278 {
22279 res = 0xFF;
22280 PRE_IO
22281 WRITE_BYTE_F(adr, res)
22282 POST_IO
22283 RET(16)
22284 }
22285 res = 0;
22286 PRE_IO
22287 WRITE_BYTE_F(adr, res)
22288 POST_IO
22289 RET(16)
22290}
22291
22292// STCC
22293OPCODE(0x5BF8)
22294{
22295 u32 adr, res;
22296 u32 src, dst;
22297
22298 FETCH_SWORD(adr);
22299 if (flag_N & 0x80)
22300 {
22301 res = 0xFF;
22302 PRE_IO
22303 WRITE_BYTE_F(adr, res)
22304 POST_IO
22305 RET(16)
22306 }
22307 res = 0;
22308 PRE_IO
22309 WRITE_BYTE_F(adr, res)
22310 POST_IO
22311 RET(16)
22312}
22313
22314// STCC
22315OPCODE(0x5CF8)
22316{
22317 u32 adr, res;
22318 u32 src, dst;
22319
22320 FETCH_SWORD(adr);
22321 if (!((flag_N ^ flag_V) & 0x80))
22322 {
22323 res = 0xFF;
22324 PRE_IO
22325 WRITE_BYTE_F(adr, res)
22326 POST_IO
22327 RET(16)
22328 }
22329 res = 0;
22330 PRE_IO
22331 WRITE_BYTE_F(adr, res)
22332 POST_IO
22333 RET(16)
22334}
22335
22336// STCC
22337OPCODE(0x5DF8)
22338{
22339 u32 adr, res;
22340 u32 src, dst;
22341
22342 FETCH_SWORD(adr);
22343 if ((flag_N ^ flag_V) & 0x80)
22344 {
22345 res = 0xFF;
22346 PRE_IO
22347 WRITE_BYTE_F(adr, res)
22348 POST_IO
22349 RET(16)
22350 }
22351 res = 0;
22352 PRE_IO
22353 WRITE_BYTE_F(adr, res)
22354 POST_IO
22355 RET(16)
22356}
22357
22358// STCC
22359OPCODE(0x5EF8)
22360{
22361 u32 adr, res;
22362 u32 src, dst;
22363
22364 FETCH_SWORD(adr);
22365 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22366 {
22367 res = 0xFF;
22368 PRE_IO
22369 WRITE_BYTE_F(adr, res)
22370 POST_IO
22371 RET(16)
22372 }
22373 res = 0;
22374 PRE_IO
22375 WRITE_BYTE_F(adr, res)
22376 POST_IO
22377 RET(16)
22378}
22379
22380// STCC
22381OPCODE(0x5FF8)
22382{
22383 u32 adr, res;
22384 u32 src, dst;
22385
22386 FETCH_SWORD(adr);
22387 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22388 {
22389 res = 0xFF;
22390 PRE_IO
22391 WRITE_BYTE_F(adr, res)
22392 POST_IO
22393 RET(16)
22394 }
22395 res = 0;
22396 PRE_IO
22397 WRITE_BYTE_F(adr, res)
22398 POST_IO
22399 RET(16)
22400}
22401
22402// STCC
22403OPCODE(0x50F9)
22404{
22405 u32 adr, res;
22406 u32 src, dst;
22407
22408 FETCH_LONG(adr);
22409 res = 0xFF;
22410 PRE_IO
22411 WRITE_BYTE_F(adr, res)
22412 POST_IO
22413 RET(20)
22414}
22415
22416// STCC
22417OPCODE(0x51F9)
22418{
22419 u32 adr, res;
22420 u32 src, dst;
22421
22422 FETCH_LONG(adr);
22423 res = 0;
22424 PRE_IO
22425 WRITE_BYTE_F(adr, res)
22426 POST_IO
22427 RET(20)
22428}
22429
22430// STCC
22431OPCODE(0x52F9)
22432{
22433 u32 adr, res;
22434 u32 src, dst;
22435
22436 FETCH_LONG(adr);
22437 if (flag_NotZ && (!(flag_C & 0x100)))
22438 {
22439 res = 0xFF;
22440 PRE_IO
22441 WRITE_BYTE_F(adr, res)
22442 POST_IO
22443 RET(20)
22444 }
22445 res = 0;
22446 PRE_IO
22447 WRITE_BYTE_F(adr, res)
22448 POST_IO
22449 RET(20)
22450}
22451
22452// STCC
22453OPCODE(0x53F9)
22454{
22455 u32 adr, res;
22456 u32 src, dst;
22457
22458 FETCH_LONG(adr);
22459 if ((!flag_NotZ) || (flag_C & 0x100))
22460 {
22461 res = 0xFF;
22462 PRE_IO
22463 WRITE_BYTE_F(adr, res)
22464 POST_IO
22465 RET(20)
22466 }
22467 res = 0;
22468 PRE_IO
22469 WRITE_BYTE_F(adr, res)
22470 POST_IO
22471 RET(20)
22472}
22473
22474// STCC
22475OPCODE(0x54F9)
22476{
22477 u32 adr, res;
22478 u32 src, dst;
22479
22480 FETCH_LONG(adr);
22481 if (!(flag_C & 0x100))
22482 {
22483 res = 0xFF;
22484 PRE_IO
22485 WRITE_BYTE_F(adr, res)
22486 POST_IO
22487 RET(20)
22488 }
22489 res = 0;
22490 PRE_IO
22491 WRITE_BYTE_F(adr, res)
22492 POST_IO
22493 RET(20)
22494}
22495
22496// STCC
22497OPCODE(0x55F9)
22498{
22499 u32 adr, res;
22500 u32 src, dst;
22501
22502 FETCH_LONG(adr);
22503 if (flag_C & 0x100)
22504 {
22505 res = 0xFF;
22506 PRE_IO
22507 WRITE_BYTE_F(adr, res)
22508 POST_IO
22509 RET(20)
22510 }
22511 res = 0;
22512 PRE_IO
22513 WRITE_BYTE_F(adr, res)
22514 POST_IO
22515 RET(20)
22516}
22517
22518// STCC
22519OPCODE(0x56F9)
22520{
22521 u32 adr, res;
22522 u32 src, dst;
22523
22524 FETCH_LONG(adr);
22525 if (flag_NotZ)
22526 {
22527 res = 0xFF;
22528 PRE_IO
22529 WRITE_BYTE_F(adr, res)
22530 POST_IO
22531 RET(20)
22532 }
22533 res = 0;
22534 PRE_IO
22535 WRITE_BYTE_F(adr, res)
22536 POST_IO
22537 RET(20)
22538}
22539
22540// STCC
22541OPCODE(0x57F9)
22542{
22543 u32 adr, res;
22544 u32 src, dst;
22545
22546 FETCH_LONG(adr);
22547 if (!flag_NotZ)
22548 {
22549 res = 0xFF;
22550 PRE_IO
22551 WRITE_BYTE_F(adr, res)
22552 POST_IO
22553 RET(20)
22554 }
22555 res = 0;
22556 PRE_IO
22557 WRITE_BYTE_F(adr, res)
22558 POST_IO
22559 RET(20)
22560}
22561
22562// STCC
22563OPCODE(0x58F9)
22564{
22565 u32 adr, res;
22566 u32 src, dst;
22567
22568 FETCH_LONG(adr);
22569 if (!(flag_V & 0x80))
22570 {
22571 res = 0xFF;
22572 PRE_IO
22573 WRITE_BYTE_F(adr, res)
22574 POST_IO
22575 RET(20)
22576 }
22577 res = 0;
22578 PRE_IO
22579 WRITE_BYTE_F(adr, res)
22580 POST_IO
22581 RET(20)
22582}
22583
22584// STCC
22585OPCODE(0x59F9)
22586{
22587 u32 adr, res;
22588 u32 src, dst;
22589
22590 FETCH_LONG(adr);
22591 if (flag_V & 0x80)
22592 {
22593 res = 0xFF;
22594 PRE_IO
22595 WRITE_BYTE_F(adr, res)
22596 POST_IO
22597 RET(20)
22598 }
22599 res = 0;
22600 PRE_IO
22601 WRITE_BYTE_F(adr, res)
22602 POST_IO
22603 RET(20)
22604}
22605
22606// STCC
22607OPCODE(0x5AF9)
22608{
22609 u32 adr, res;
22610 u32 src, dst;
22611
22612 FETCH_LONG(adr);
22613 if (!(flag_N & 0x80))
22614 {
22615 res = 0xFF;
22616 PRE_IO
22617 WRITE_BYTE_F(adr, res)
22618 POST_IO
22619 RET(20)
22620 }
22621 res = 0;
22622 PRE_IO
22623 WRITE_BYTE_F(adr, res)
22624 POST_IO
22625 RET(20)
22626}
22627
22628// STCC
22629OPCODE(0x5BF9)
22630{
22631 u32 adr, res;
22632 u32 src, dst;
22633
22634 FETCH_LONG(adr);
22635 if (flag_N & 0x80)
22636 {
22637 res = 0xFF;
22638 PRE_IO
22639 WRITE_BYTE_F(adr, res)
22640 POST_IO
22641 RET(20)
22642 }
22643 res = 0;
22644 PRE_IO
22645 WRITE_BYTE_F(adr, res)
22646 POST_IO
22647 RET(20)
22648}
22649
22650// STCC
22651OPCODE(0x5CF9)
22652{
22653 u32 adr, res;
22654 u32 src, dst;
22655
22656 FETCH_LONG(adr);
22657 if (!((flag_N ^ flag_V) & 0x80))
22658 {
22659 res = 0xFF;
22660 PRE_IO
22661 WRITE_BYTE_F(adr, res)
22662 POST_IO
22663 RET(20)
22664 }
22665 res = 0;
22666 PRE_IO
22667 WRITE_BYTE_F(adr, res)
22668 POST_IO
22669 RET(20)
22670}
22671
22672// STCC
22673OPCODE(0x5DF9)
22674{
22675 u32 adr, res;
22676 u32 src, dst;
22677
22678 FETCH_LONG(adr);
22679 if ((flag_N ^ flag_V) & 0x80)
22680 {
22681 res = 0xFF;
22682 PRE_IO
22683 WRITE_BYTE_F(adr, res)
22684 POST_IO
22685 RET(20)
22686 }
22687 res = 0;
22688 PRE_IO
22689 WRITE_BYTE_F(adr, res)
22690 POST_IO
22691 RET(20)
22692}
22693
22694// STCC
22695OPCODE(0x5EF9)
22696{
22697 u32 adr, res;
22698 u32 src, dst;
22699
22700 FETCH_LONG(adr);
22701 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22702 {
22703 res = 0xFF;
22704 PRE_IO
22705 WRITE_BYTE_F(adr, res)
22706 POST_IO
22707 RET(20)
22708 }
22709 res = 0;
22710 PRE_IO
22711 WRITE_BYTE_F(adr, res)
22712 POST_IO
22713 RET(20)
22714}
22715
22716// STCC
22717OPCODE(0x5FF9)
22718{
22719 u32 adr, res;
22720 u32 src, dst;
22721
22722 FETCH_LONG(adr);
22723 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22724 {
22725 res = 0xFF;
22726 PRE_IO
22727 WRITE_BYTE_F(adr, res)
22728 POST_IO
22729 RET(20)
22730 }
22731 res = 0;
22732 PRE_IO
22733 WRITE_BYTE_F(adr, res)
22734 POST_IO
22735 RET(20)
22736}
22737
22738// STCC
22739OPCODE(0x50DF)
22740{
22741 u32 adr, res;
22742 u32 src, dst;
22743
22744 adr = AREG(7);
22745 AREG(7) += 2;
22746 res = 0xFF;
22747 PRE_IO
22748 WRITE_BYTE_F(adr, res)
22749 POST_IO
22750 RET(12)
22751}
22752
22753// STCC
22754OPCODE(0x51DF)
22755{
22756 u32 adr, res;
22757 u32 src, dst;
22758
22759 adr = AREG(7);
22760 AREG(7) += 2;
22761 res = 0;
22762 PRE_IO
22763 WRITE_BYTE_F(adr, res)
22764 POST_IO
22765 RET(12)
22766}
22767
22768// STCC
22769OPCODE(0x52DF)
22770{
22771 u32 adr, res;
22772 u32 src, dst;
22773
22774 adr = AREG(7);
22775 AREG(7) += 2;
22776 if (flag_NotZ && (!(flag_C & 0x100)))
22777 {
22778 res = 0xFF;
22779 PRE_IO
22780 WRITE_BYTE_F(adr, res)
22781 POST_IO
22782 RET(12)
22783 }
22784 res = 0;
22785 PRE_IO
22786 WRITE_BYTE_F(adr, res)
22787 POST_IO
22788 RET(12)
22789}
22790
22791// STCC
22792OPCODE(0x53DF)
22793{
22794 u32 adr, res;
22795 u32 src, dst;
22796
22797 adr = AREG(7);
22798 AREG(7) += 2;
22799 if ((!flag_NotZ) || (flag_C & 0x100))
22800 {
22801 res = 0xFF;
22802 PRE_IO
22803 WRITE_BYTE_F(adr, res)
22804 POST_IO
22805 RET(12)
22806 }
22807 res = 0;
22808 PRE_IO
22809 WRITE_BYTE_F(adr, res)
22810 POST_IO
22811 RET(12)
22812}
22813
22814// STCC
22815OPCODE(0x54DF)
22816{
22817 u32 adr, res;
22818 u32 src, dst;
22819
22820 adr = AREG(7);
22821 AREG(7) += 2;
22822 if (!(flag_C & 0x100))
22823 {
22824 res = 0xFF;
22825 PRE_IO
22826 WRITE_BYTE_F(adr, res)
22827 POST_IO
22828 RET(12)
22829 }
22830 res = 0;
22831 PRE_IO
22832 WRITE_BYTE_F(adr, res)
22833 POST_IO
22834 RET(12)
22835}
22836
22837// STCC
22838OPCODE(0x55DF)
22839{
22840 u32 adr, res;
22841 u32 src, dst;
22842
22843 adr = AREG(7);
22844 AREG(7) += 2;
22845 if (flag_C & 0x100)
22846 {
22847 res = 0xFF;
22848 PRE_IO
22849 WRITE_BYTE_F(adr, res)
22850 POST_IO
22851 RET(12)
22852 }
22853 res = 0;
22854 PRE_IO
22855 WRITE_BYTE_F(adr, res)
22856 POST_IO
22857 RET(12)
22858}
22859
22860// STCC
22861OPCODE(0x56DF)
22862{
22863 u32 adr, res;
22864 u32 src, dst;
22865
22866 adr = AREG(7);
22867 AREG(7) += 2;
22868 if (flag_NotZ)
22869 {
22870 res = 0xFF;
22871 PRE_IO
22872 WRITE_BYTE_F(adr, res)
22873 POST_IO
22874 RET(12)
22875 }
22876 res = 0;
22877 PRE_IO
22878 WRITE_BYTE_F(adr, res)
22879 POST_IO
22880 RET(12)
22881}
22882
22883// STCC
22884OPCODE(0x57DF)
22885{
22886 u32 adr, res;
22887 u32 src, dst;
22888
22889 adr = AREG(7);
22890 AREG(7) += 2;
22891 if (!flag_NotZ)
22892 {
22893 res = 0xFF;
22894 PRE_IO
22895 WRITE_BYTE_F(adr, res)
22896 POST_IO
22897 RET(12)
22898 }
22899 res = 0;
22900 PRE_IO
22901 WRITE_BYTE_F(adr, res)
22902 POST_IO
22903 RET(12)
22904}
22905
22906// STCC
22907OPCODE(0x58DF)
22908{
22909 u32 adr, res;
22910 u32 src, dst;
22911
22912 adr = AREG(7);
22913 AREG(7) += 2;
22914 if (!(flag_V & 0x80))
22915 {
22916 res = 0xFF;
22917 PRE_IO
22918 WRITE_BYTE_F(adr, res)
22919 POST_IO
22920 RET(12)
22921 }
22922 res = 0;
22923 PRE_IO
22924 WRITE_BYTE_F(adr, res)
22925 POST_IO
22926 RET(12)
22927}
22928
22929// STCC
22930OPCODE(0x59DF)
22931{
22932 u32 adr, res;
22933 u32 src, dst;
22934
22935 adr = AREG(7);
22936 AREG(7) += 2;
22937 if (flag_V & 0x80)
22938 {
22939 res = 0xFF;
22940 PRE_IO
22941 WRITE_BYTE_F(adr, res)
22942 POST_IO
22943 RET(12)
22944 }
22945 res = 0;
22946 PRE_IO
22947 WRITE_BYTE_F(adr, res)
22948 POST_IO
22949 RET(12)
22950}
22951
22952// STCC
22953OPCODE(0x5ADF)
22954{
22955 u32 adr, res;
22956 u32 src, dst;
22957
22958 adr = AREG(7);
22959 AREG(7) += 2;
22960 if (!(flag_N & 0x80))
22961 {
22962 res = 0xFF;
22963 PRE_IO
22964 WRITE_BYTE_F(adr, res)
22965 POST_IO
22966 RET(12)
22967 }
22968 res = 0;
22969 PRE_IO
22970 WRITE_BYTE_F(adr, res)
22971 POST_IO
22972 RET(12)
22973}
22974
22975// STCC
22976OPCODE(0x5BDF)
22977{
22978 u32 adr, res;
22979 u32 src, dst;
22980
22981 adr = AREG(7);
22982 AREG(7) += 2;
22983 if (flag_N & 0x80)
22984 {
22985 res = 0xFF;
22986 PRE_IO
22987 WRITE_BYTE_F(adr, res)
22988 POST_IO
22989 RET(12)
22990 }
22991 res = 0;
22992 PRE_IO
22993 WRITE_BYTE_F(adr, res)
22994 POST_IO
22995 RET(12)
22996}
22997
22998// STCC
22999OPCODE(0x5CDF)
23000{
23001 u32 adr, res;
23002 u32 src, dst;
23003
23004 adr = AREG(7);
23005 AREG(7) += 2;
23006 if (!((flag_N ^ flag_V) & 0x80))
23007 {
23008 res = 0xFF;
23009 PRE_IO
23010 WRITE_BYTE_F(adr, res)
23011 POST_IO
23012 RET(12)
23013 }
23014 res = 0;
23015 PRE_IO
23016 WRITE_BYTE_F(adr, res)
23017 POST_IO
23018 RET(12)
23019}
23020
23021// STCC
23022OPCODE(0x5DDF)
23023{
23024 u32 adr, res;
23025 u32 src, dst;
23026
23027 adr = AREG(7);
23028 AREG(7) += 2;
23029 if ((flag_N ^ flag_V) & 0x80)
23030 {
23031 res = 0xFF;
23032 PRE_IO
23033 WRITE_BYTE_F(adr, res)
23034 POST_IO
23035 RET(12)
23036 }
23037 res = 0;
23038 PRE_IO
23039 WRITE_BYTE_F(adr, res)
23040 POST_IO
23041 RET(12)
23042}
23043
23044// STCC
23045OPCODE(0x5EDF)
23046{
23047 u32 adr, res;
23048 u32 src, dst;
23049
23050 adr = AREG(7);
23051 AREG(7) += 2;
23052 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23053 {
23054 res = 0xFF;
23055 PRE_IO
23056 WRITE_BYTE_F(adr, res)
23057 POST_IO
23058 RET(12)
23059 }
23060 res = 0;
23061 PRE_IO
23062 WRITE_BYTE_F(adr, res)
23063 POST_IO
23064 RET(12)
23065}
23066
23067// STCC
23068OPCODE(0x5FDF)
23069{
23070 u32 adr, res;
23071 u32 src, dst;
23072
23073 adr = AREG(7);
23074 AREG(7) += 2;
23075 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23076 {
23077 res = 0xFF;
23078 PRE_IO
23079 WRITE_BYTE_F(adr, res)
23080 POST_IO
23081 RET(12)
23082 }
23083 res = 0;
23084 PRE_IO
23085 WRITE_BYTE_F(adr, res)
23086 POST_IO
23087 RET(12)
23088}
23089
23090// STCC
23091OPCODE(0x50E7)
23092{
23093 u32 adr, res;
23094 u32 src, dst;
23095
23096 adr = AREG(7) - 2;
23097 AREG(7) = adr;
23098 res = 0xFF;
23099 PRE_IO
23100 WRITE_BYTE_F(adr, res)
23101 POST_IO
23102 RET(14)
23103}
23104
23105// STCC
23106OPCODE(0x51E7)
23107{
23108 u32 adr, res;
23109 u32 src, dst;
23110
23111 adr = AREG(7) - 2;
23112 AREG(7) = adr;
23113 res = 0;
23114 PRE_IO
23115 WRITE_BYTE_F(adr, res)
23116 POST_IO
23117 RET(14)
23118}
23119
23120// STCC
23121OPCODE(0x52E7)
23122{
23123 u32 adr, res;
23124 u32 src, dst;
23125
23126 adr = AREG(7) - 2;
23127 AREG(7) = adr;
23128 if (flag_NotZ && (!(flag_C & 0x100)))
23129 {
23130 res = 0xFF;
23131 PRE_IO
23132 WRITE_BYTE_F(adr, res)
23133 POST_IO
23134 RET(14)
23135 }
23136 res = 0;
23137 PRE_IO
23138 WRITE_BYTE_F(adr, res)
23139 POST_IO
23140 RET(14)
23141}
23142
23143// STCC
23144OPCODE(0x53E7)
23145{
23146 u32 adr, res;
23147 u32 src, dst;
23148
23149 adr = AREG(7) - 2;
23150 AREG(7) = adr;
23151 if ((!flag_NotZ) || (flag_C & 0x100))
23152 {
23153 res = 0xFF;
23154 PRE_IO
23155 WRITE_BYTE_F(adr, res)
23156 POST_IO
23157 RET(14)
23158 }
23159 res = 0;
23160 PRE_IO
23161 WRITE_BYTE_F(adr, res)
23162 POST_IO
23163 RET(14)
23164}
23165
23166// STCC
23167OPCODE(0x54E7)
23168{
23169 u32 adr, res;
23170 u32 src, dst;
23171
23172 adr = AREG(7) - 2;
23173 AREG(7) = adr;
23174 if (!(flag_C & 0x100))
23175 {
23176 res = 0xFF;
23177 PRE_IO
23178 WRITE_BYTE_F(adr, res)
23179 POST_IO
23180 RET(14)
23181 }
23182 res = 0;
23183 PRE_IO
23184 WRITE_BYTE_F(adr, res)
23185 POST_IO
23186 RET(14)
23187}
23188
23189// STCC
23190OPCODE(0x55E7)
23191{
23192 u32 adr, res;
23193 u32 src, dst;
23194
23195 adr = AREG(7) - 2;
23196 AREG(7) = adr;
23197 if (flag_C & 0x100)
23198 {
23199 res = 0xFF;
23200 PRE_IO
23201 WRITE_BYTE_F(adr, res)
23202 POST_IO
23203 RET(14)
23204 }
23205 res = 0;
23206 PRE_IO
23207 WRITE_BYTE_F(adr, res)
23208 POST_IO
23209 RET(14)
23210}
23211
23212// STCC
23213OPCODE(0x56E7)
23214{
23215 u32 adr, res;
23216 u32 src, dst;
23217
23218 adr = AREG(7) - 2;
23219 AREG(7) = adr;
23220 if (flag_NotZ)
23221 {
23222 res = 0xFF;
23223 PRE_IO
23224 WRITE_BYTE_F(adr, res)
23225 POST_IO
23226 RET(14)
23227 }
23228 res = 0;
23229 PRE_IO
23230 WRITE_BYTE_F(adr, res)
23231 POST_IO
23232 RET(14)
23233}
23234
23235// STCC
23236OPCODE(0x57E7)
23237{
23238 u32 adr, res;
23239 u32 src, dst;
23240
23241 adr = AREG(7) - 2;
23242 AREG(7) = adr;
23243 if (!flag_NotZ)
23244 {
23245 res = 0xFF;
23246 PRE_IO
23247 WRITE_BYTE_F(adr, res)
23248 POST_IO
23249 RET(14)
23250 }
23251 res = 0;
23252 PRE_IO
23253 WRITE_BYTE_F(adr, res)
23254 POST_IO
23255 RET(14)
23256}
23257
23258// STCC
23259OPCODE(0x58E7)
23260{
23261 u32 adr, res;
23262 u32 src, dst;
23263
23264 adr = AREG(7) - 2;
23265 AREG(7) = adr;
23266 if (!(flag_V & 0x80))
23267 {
23268 res = 0xFF;
23269 PRE_IO
23270 WRITE_BYTE_F(adr, res)
23271 POST_IO
23272 RET(14)
23273 }
23274 res = 0;
23275 PRE_IO
23276 WRITE_BYTE_F(adr, res)
23277 POST_IO
23278 RET(14)
23279}
23280
23281// STCC
23282OPCODE(0x59E7)
23283{
23284 u32 adr, res;
23285 u32 src, dst;
23286
23287 adr = AREG(7) - 2;
23288 AREG(7) = adr;
23289 if (flag_V & 0x80)
23290 {
23291 res = 0xFF;
23292 PRE_IO
23293 WRITE_BYTE_F(adr, res)
23294 POST_IO
23295 RET(14)
23296 }
23297 res = 0;
23298 PRE_IO
23299 WRITE_BYTE_F(adr, res)
23300 POST_IO
23301 RET(14)
23302}
23303
23304// STCC
23305OPCODE(0x5AE7)
23306{
23307 u32 adr, res;
23308 u32 src, dst;
23309
23310 adr = AREG(7) - 2;
23311 AREG(7) = adr;
23312 if (!(flag_N & 0x80))
23313 {
23314 res = 0xFF;
23315 PRE_IO
23316 WRITE_BYTE_F(adr, res)
23317 POST_IO
23318 RET(14)
23319 }
23320 res = 0;
23321 PRE_IO
23322 WRITE_BYTE_F(adr, res)
23323 POST_IO
23324 RET(14)
23325}
23326
23327// STCC
23328OPCODE(0x5BE7)
23329{
23330 u32 adr, res;
23331 u32 src, dst;
23332
23333 adr = AREG(7) - 2;
23334 AREG(7) = adr;
23335 if (flag_N & 0x80)
23336 {
23337 res = 0xFF;
23338 PRE_IO
23339 WRITE_BYTE_F(adr, res)
23340 POST_IO
23341 RET(14)
23342 }
23343 res = 0;
23344 PRE_IO
23345 WRITE_BYTE_F(adr, res)
23346 POST_IO
23347 RET(14)
23348}
23349
23350// STCC
23351OPCODE(0x5CE7)
23352{
23353 u32 adr, res;
23354 u32 src, dst;
23355
23356 adr = AREG(7) - 2;
23357 AREG(7) = adr;
23358 if (!((flag_N ^ flag_V) & 0x80))
23359 {
23360 res = 0xFF;
23361 PRE_IO
23362 WRITE_BYTE_F(adr, res)
23363 POST_IO
23364 RET(14)
23365 }
23366 res = 0;
23367 PRE_IO
23368 WRITE_BYTE_F(adr, res)
23369 POST_IO
23370 RET(14)
23371}
23372
23373// STCC
23374OPCODE(0x5DE7)
23375{
23376 u32 adr, res;
23377 u32 src, dst;
23378
23379 adr = AREG(7) - 2;
23380 AREG(7) = adr;
23381 if ((flag_N ^ flag_V) & 0x80)
23382 {
23383 res = 0xFF;
23384 PRE_IO
23385 WRITE_BYTE_F(adr, res)
23386 POST_IO
23387 RET(14)
23388 }
23389 res = 0;
23390 PRE_IO
23391 WRITE_BYTE_F(adr, res)
23392 POST_IO
23393 RET(14)
23394}
23395
23396// STCC
23397OPCODE(0x5EE7)
23398{
23399 u32 adr, res;
23400 u32 src, dst;
23401
23402 adr = AREG(7) - 2;
23403 AREG(7) = adr;
23404 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23405 {
23406 res = 0xFF;
23407 PRE_IO
23408 WRITE_BYTE_F(adr, res)
23409 POST_IO
23410 RET(14)
23411 }
23412 res = 0;
23413 PRE_IO
23414 WRITE_BYTE_F(adr, res)
23415 POST_IO
23416 RET(14)
23417}
23418
23419// STCC
23420OPCODE(0x5FE7)
23421{
23422 u32 adr, res;
23423 u32 src, dst;
23424
23425 adr = AREG(7) - 2;
23426 AREG(7) = adr;
23427 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23428 {
23429 res = 0xFF;
23430 PRE_IO
23431 WRITE_BYTE_F(adr, res)
23432 POST_IO
23433 RET(14)
23434 }
23435 res = 0;
23436 PRE_IO
23437 WRITE_BYTE_F(adr, res)
23438 POST_IO
23439 RET(14)
23440}
23441
23442// DBCC
23443OPCODE(0x50C8)
23444{
23445 u32 adr, res;
23446 u32 src, dst;
23447
23448 PC++;
23449RET(12)
23450}
23451
23452// DBCC
23453OPCODE(0x51C8)
23454{
23455 u32 adr, res;
23456 u32 src, dst;
23457
23458 NOT_POLLING
23459
23460 res = DREGu16((Opcode >> 0) & 7);
23461 res--;
23462 DREGu16((Opcode >> 0) & 7) = res;
23463 if ((s32)res != -1)
23464 {
23465 u32 newPC;
23466
23467 newPC = GET_PC;
23468 newPC += GET_SWORD;
23469 SET_PC(newPC);
23470 CHECK_BRANCH_EXCEPTION(newPC)
23471 RET(10)
23472 }
23473 PC++;
23474RET(14)
23475}
23476
23477// DBCC
23478OPCODE(0x52C8)
23479{
23480 u32 adr, res;
23481 u32 src, dst;
23482
23483 NOT_POLLING
23484
23485 if ((!flag_NotZ) || (flag_C & 0x100))
23486 {
23487 res = DREGu16((Opcode >> 0) & 7);
23488 res--;
23489 DREGu16((Opcode >> 0) & 7) = res;
23490 if ((s32)res != -1)
23491 {
23492 u32 newPC;
23493
23494 newPC = GET_PC;
23495 newPC += GET_SWORD;
23496 SET_PC(newPC);
23497 CHECK_BRANCH_EXCEPTION(newPC)
23498 RET(10)
23499 }
23500 }
23501 else
23502 {
23503 PC++;
23504 RET(12)
23505 }
23506 PC++;
23507RET(14)
23508}
23509
23510// DBCC
23511OPCODE(0x53C8)
23512{
23513 u32 adr, res;
23514 u32 src, dst;
23515
23516 NOT_POLLING
23517
23518 if (flag_NotZ && (!(flag_C & 0x100)))
23519 {
23520 res = DREGu16((Opcode >> 0) & 7);
23521 res--;
23522 DREGu16((Opcode >> 0) & 7) = res;
23523 if ((s32)res != -1)
23524 {
23525 u32 newPC;
23526
23527 newPC = GET_PC;
23528 newPC += GET_SWORD;
23529 SET_PC(newPC);
23530 CHECK_BRANCH_EXCEPTION(newPC)
23531 RET(10)
23532 }
23533 }
23534 else
23535 {
23536 PC++;
23537 RET(12)
23538 }
23539 PC++;
23540RET(14)
23541}
23542
23543// DBCC
23544OPCODE(0x54C8)
23545{
23546 u32 adr, res;
23547 u32 src, dst;
23548
23549 NOT_POLLING
23550
23551 if (flag_C & 0x100)
23552 {
23553 res = DREGu16((Opcode >> 0) & 7);
23554 res--;
23555 DREGu16((Opcode >> 0) & 7) = res;
23556 if ((s32)res != -1)
23557 {
23558 u32 newPC;
23559
23560 newPC = GET_PC;
23561 newPC += GET_SWORD;
23562 SET_PC(newPC);
23563 CHECK_BRANCH_EXCEPTION(newPC)
23564 RET(10)
23565 }
23566 }
23567 else
23568 {
23569 PC++;
23570 RET(12)
23571 }
23572 PC++;
23573RET(14)
23574}
23575
23576// DBCC
23577OPCODE(0x55C8)
23578{
23579 u32 adr, res;
23580 u32 src, dst;
23581
23582 NOT_POLLING
23583
23584 if (!(flag_C & 0x100))
23585 {
23586 res = DREGu16((Opcode >> 0) & 7);
23587 res--;
23588 DREGu16((Opcode >> 0) & 7) = res;
23589 if ((s32)res != -1)
23590 {
23591 u32 newPC;
23592
23593 newPC = GET_PC;
23594 newPC += GET_SWORD;
23595 SET_PC(newPC);
23596 CHECK_BRANCH_EXCEPTION(newPC)
23597 RET(10)
23598 }
23599 }
23600 else
23601 {
23602 PC++;
23603 RET(12)
23604 }
23605 PC++;
23606RET(14)
23607}
23608
23609// DBCC
23610OPCODE(0x56C8)
23611{
23612 u32 adr, res;
23613 u32 src, dst;
23614
23615 NOT_POLLING
23616
23617 if (!flag_NotZ)
23618 {
23619 res = DREGu16((Opcode >> 0) & 7);
23620 res--;
23621 DREGu16((Opcode >> 0) & 7) = res;
23622 if ((s32)res != -1)
23623 {
23624 u32 newPC;
23625
23626 newPC = GET_PC;
23627 newPC += GET_SWORD;
23628 SET_PC(newPC);
23629 CHECK_BRANCH_EXCEPTION(newPC)
23630 RET(10)
23631 }
23632 }
23633 else
23634 {
23635 PC++;
23636 RET(12)
23637 }
23638 PC++;
23639RET(14)
23640}
23641
23642// DBCC
23643OPCODE(0x57C8)
23644{
23645 u32 adr, res;
23646 u32 src, dst;
23647
23648 NOT_POLLING
23649
23650 if (flag_NotZ)
23651 {
23652 res = DREGu16((Opcode >> 0) & 7);
23653 res--;
23654 DREGu16((Opcode >> 0) & 7) = res;
23655 if ((s32)res != -1)
23656 {
23657 u32 newPC;
23658
23659 newPC = GET_PC;
23660 newPC += GET_SWORD;
23661 SET_PC(newPC);
23662 CHECK_BRANCH_EXCEPTION(newPC)
23663 RET(10)
23664 }
23665 }
23666 else
23667 {
23668 PC++;
23669 RET(12)
23670 }
23671 PC++;
23672RET(14)
23673}
23674
23675// DBCC
23676OPCODE(0x58C8)
23677{
23678 u32 adr, res;
23679 u32 src, dst;
23680
23681 NOT_POLLING
23682
23683 if (flag_V & 0x80)
23684 {
23685 res = DREGu16((Opcode >> 0) & 7);
23686 res--;
23687 DREGu16((Opcode >> 0) & 7) = res;
23688 if ((s32)res != -1)
23689 {
23690 u32 newPC;
23691
23692 newPC = GET_PC;
23693 newPC += GET_SWORD;
23694 SET_PC(newPC);
23695 CHECK_BRANCH_EXCEPTION(newPC)
23696 RET(10)
23697 }
23698 }
23699 else
23700 {
23701 PC++;
23702 RET(12)
23703 }
23704 PC++;
23705RET(14)
23706}
23707
23708// DBCC
23709OPCODE(0x59C8)
23710{
23711 u32 adr, res;
23712 u32 src, dst;
23713
23714 NOT_POLLING
23715
23716 if (!(flag_V & 0x80))
23717 {
23718 res = DREGu16((Opcode >> 0) & 7);
23719 res--;
23720 DREGu16((Opcode >> 0) & 7) = res;
23721 if ((s32)res != -1)
23722 {
23723 u32 newPC;
23724
23725 newPC = GET_PC;
23726 newPC += GET_SWORD;
23727 SET_PC(newPC);
23728 CHECK_BRANCH_EXCEPTION(newPC)
23729 RET(10)
23730 }
23731 }
23732 else
23733 {
23734 PC++;
23735 RET(12)
23736 }
23737 PC++;
23738RET(14)
23739}
23740
23741// DBCC
23742OPCODE(0x5AC8)
23743{
23744 u32 adr, res;
23745 u32 src, dst;
23746
23747 NOT_POLLING
23748
23749 if (flag_N & 0x80)
23750 {
23751 res = DREGu16((Opcode >> 0) & 7);
23752 res--;
23753 DREGu16((Opcode >> 0) & 7) = res;
23754 if ((s32)res != -1)
23755 {
23756 u32 newPC;
23757
23758 newPC = GET_PC;
23759 newPC += GET_SWORD;
23760 SET_PC(newPC);
23761 CHECK_BRANCH_EXCEPTION(newPC)
23762 RET(10)
23763 }
23764 }
23765 else
23766 {
23767 PC++;
23768 RET(12)
23769 }
23770 PC++;
23771RET(14)
23772}
23773
23774// DBCC
23775OPCODE(0x5BC8)
23776{
23777 u32 adr, res;
23778 u32 src, dst;
23779
23780 NOT_POLLING
23781
23782 if (!(flag_N & 0x80))
23783 {
23784 res = DREGu16((Opcode >> 0) & 7);
23785 res--;
23786 DREGu16((Opcode >> 0) & 7) = res;
23787 if ((s32)res != -1)
23788 {
23789 u32 newPC;
23790
23791 newPC = GET_PC;
23792 newPC += GET_SWORD;
23793 SET_PC(newPC);
23794 CHECK_BRANCH_EXCEPTION(newPC)
23795 RET(10)
23796 }
23797 }
23798 else
23799 {
23800 PC++;
23801 RET(12)
23802 }
23803 PC++;
23804RET(14)
23805}
23806
23807// DBCC
23808OPCODE(0x5CC8)
23809{
23810 u32 adr, res;
23811 u32 src, dst;
23812
23813 NOT_POLLING
23814
23815 if ((flag_N ^ flag_V) & 0x80)
23816 {
23817 res = DREGu16((Opcode >> 0) & 7);
23818 res--;
23819 DREGu16((Opcode >> 0) & 7) = res;
23820 if ((s32)res != -1)
23821 {
23822 u32 newPC;
23823
23824 newPC = GET_PC;
23825 newPC += GET_SWORD;
23826 SET_PC(newPC);
23827 CHECK_BRANCH_EXCEPTION(newPC)
23828 RET(10)
23829 }
23830 }
23831 else
23832 {
23833 PC++;
23834 RET(12)
23835 }
23836 PC++;
23837RET(14)
23838}
23839
23840// DBCC
23841OPCODE(0x5DC8)
23842{
23843 u32 adr, res;
23844 u32 src, dst;
23845
23846 NOT_POLLING
23847
23848 if (!((flag_N ^ flag_V) & 0x80))
23849 {
23850 res = DREGu16((Opcode >> 0) & 7);
23851 res--;
23852 DREGu16((Opcode >> 0) & 7) = res;
23853 if ((s32)res != -1)
23854 {
23855 u32 newPC;
23856
23857 newPC = GET_PC;
23858 newPC += GET_SWORD;
23859 SET_PC(newPC);
23860 CHECK_BRANCH_EXCEPTION(newPC)
23861 RET(10)
23862 }
23863 }
23864 else
23865 {
23866 PC++;
23867 RET(12)
23868 }
23869 PC++;
23870RET(14)
23871}
23872
23873// DBCC
23874OPCODE(0x5EC8)
23875{
23876 u32 adr, res;
23877 u32 src, dst;
23878
23879 NOT_POLLING
23880
23881 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23882 {
23883 res = DREGu16((Opcode >> 0) & 7);
23884 res--;
23885 DREGu16((Opcode >> 0) & 7) = res;
23886 if ((s32)res != -1)
23887 {
23888 u32 newPC;
23889
23890 newPC = GET_PC;
23891 newPC += GET_SWORD;
23892 SET_PC(newPC);
23893 CHECK_BRANCH_EXCEPTION(newPC)
23894 RET(10)
23895 }
23896 }
23897 else
23898 {
23899 PC++;
23900 RET(12)
23901 }
23902 PC++;
23903RET(14)
23904}
23905
23906// DBCC
23907OPCODE(0x5FC8)
23908{
23909 u32 adr, res;
23910 u32 src, dst;
23911
23912 NOT_POLLING
23913
23914 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23915 {
23916 res = DREGu16((Opcode >> 0) & 7);
23917 res--;
23918 DREGu16((Opcode >> 0) & 7) = res;
23919 if ((s32)res != -1)
23920 {
23921 u32 newPC;
23922
23923 newPC = GET_PC;
23924 newPC += GET_SWORD;
23925 SET_PC(newPC);
23926 CHECK_BRANCH_EXCEPTION(newPC)
23927 RET(10)
23928 }
23929 }
23930 else
23931 {
23932 PC++;
23933 RET(12)
23934 }
23935 PC++;
23936RET(14)
23937}
23938
23939// ADDQ
23940OPCODE(0x5000)
23941{
23942 u32 adr, res;
23943 u32 src, dst;
23944
23945 src = (((Opcode >> 9) - 1) & 7) + 1;
23946 dst = DREGu8((Opcode >> 0) & 7);
23947 res = dst + src;
23948 flag_N = flag_X = flag_C = res;
23949 flag_V = (src ^ res) & (dst ^ res);
23950 flag_NotZ = res & 0xFF;
23951 DREGu8((Opcode >> 0) & 7) = res;
23952RET(4)
23953}
23954
23955// ADDQ
23956OPCODE(0x5010)
23957{
23958 u32 adr, res;
23959 u32 src, dst;
23960
23961 src = (((Opcode >> 9) - 1) & 7) + 1;
23962 adr = AREG((Opcode >> 0) & 7);
23963 PRE_IO
23964 READ_BYTE_F(adr, dst)
23965 res = dst + src;
23966 flag_N = flag_X = flag_C = res;
23967 flag_V = (src ^ res) & (dst ^ res);
23968 flag_NotZ = res & 0xFF;
23969 WRITE_BYTE_F(adr, res)
23970 POST_IO
23971RET(12)
23972}
23973
23974// ADDQ
23975OPCODE(0x5018)
23976{
23977 u32 adr, res;
23978 u32 src, dst;
23979
23980 src = (((Opcode >> 9) - 1) & 7) + 1;
23981 adr = AREG((Opcode >> 0) & 7);
23982 AREG((Opcode >> 0) & 7) += 1;
23983 PRE_IO
23984 READ_BYTE_F(adr, dst)
23985 res = dst + src;
23986 flag_N = flag_X = flag_C = res;
23987 flag_V = (src ^ res) & (dst ^ res);
23988 flag_NotZ = res & 0xFF;
23989 WRITE_BYTE_F(adr, res)
23990 POST_IO
23991RET(12)
23992}
23993
23994// ADDQ
23995OPCODE(0x5020)
23996{
23997 u32 adr, res;
23998 u32 src, dst;
23999
24000 src = (((Opcode >> 9) - 1) & 7) + 1;
24001 adr = AREG((Opcode >> 0) & 7) - 1;
24002 AREG((Opcode >> 0) & 7) = adr;
24003 PRE_IO
24004 READ_BYTE_F(adr, dst)
24005 res = dst + src;
24006 flag_N = flag_X = flag_C = res;
24007 flag_V = (src ^ res) & (dst ^ res);
24008 flag_NotZ = res & 0xFF;
24009 WRITE_BYTE_F(adr, res)
24010 POST_IO
24011RET(14)
24012}
24013
24014// ADDQ
24015OPCODE(0x5028)
24016{
24017 u32 adr, res;
24018 u32 src, dst;
24019
24020 src = (((Opcode >> 9) - 1) & 7) + 1;
24021 FETCH_SWORD(adr);
24022 adr += AREG((Opcode >> 0) & 7);
24023 PRE_IO
24024 READ_BYTE_F(adr, dst)
24025 res = dst + src;
24026 flag_N = flag_X = flag_C = res;
24027 flag_V = (src ^ res) & (dst ^ res);
24028 flag_NotZ = res & 0xFF;
24029 WRITE_BYTE_F(adr, res)
24030 POST_IO
24031RET(16)
24032}
24033
24034// ADDQ
24035OPCODE(0x5030)
24036{
24037 u32 adr, res;
24038 u32 src, dst;
24039
24040 src = (((Opcode >> 9) - 1) & 7) + 1;
24041 adr = AREG((Opcode >> 0) & 7);
24042 DECODE_EXT_WORD
24043 PRE_IO
24044 READ_BYTE_F(adr, dst)
24045 res = dst + src;
24046 flag_N = flag_X = flag_C = res;
24047 flag_V = (src ^ res) & (dst ^ res);
24048 flag_NotZ = res & 0xFF;
24049 WRITE_BYTE_F(adr, res)
24050 POST_IO
24051RET(18)
24052}
24053
24054// ADDQ
24055OPCODE(0x5038)
24056{
24057 u32 adr, res;
24058 u32 src, dst;
24059
24060 src = (((Opcode >> 9) - 1) & 7) + 1;
24061 FETCH_SWORD(adr);
24062 PRE_IO
24063 READ_BYTE_F(adr, dst)
24064 res = dst + src;
24065 flag_N = flag_X = flag_C = res;
24066 flag_V = (src ^ res) & (dst ^ res);
24067 flag_NotZ = res & 0xFF;
24068 WRITE_BYTE_F(adr, res)
24069 POST_IO
24070RET(16)
24071}
24072
24073// ADDQ
24074OPCODE(0x5039)
24075{
24076 u32 adr, res;
24077 u32 src, dst;
24078
24079 src = (((Opcode >> 9) - 1) & 7) + 1;
24080 FETCH_LONG(adr);
24081 PRE_IO
24082 READ_BYTE_F(adr, dst)
24083 res = dst + src;
24084 flag_N = flag_X = flag_C = res;
24085 flag_V = (src ^ res) & (dst ^ res);
24086 flag_NotZ = res & 0xFF;
24087 WRITE_BYTE_F(adr, res)
24088 POST_IO
24089RET(20)
24090}
24091
24092// ADDQ
24093OPCODE(0x501F)
24094{
24095 u32 adr, res;
24096 u32 src, dst;
24097
24098 src = (((Opcode >> 9) - 1) & 7) + 1;
24099 adr = AREG(7);
24100 AREG(7) += 2;
24101 PRE_IO
24102 READ_BYTE_F(adr, dst)
24103 res = dst + src;
24104 flag_N = flag_X = flag_C = res;
24105 flag_V = (src ^ res) & (dst ^ res);
24106 flag_NotZ = res & 0xFF;
24107 WRITE_BYTE_F(adr, res)
24108 POST_IO
24109RET(12)
24110}
24111
24112// ADDQ
24113OPCODE(0x5027)
24114{
24115 u32 adr, res;
24116 u32 src, dst;
24117
24118 src = (((Opcode >> 9) - 1) & 7) + 1;
24119 adr = AREG(7) - 2;
24120 AREG(7) = adr;
24121 PRE_IO
24122 READ_BYTE_F(adr, dst)
24123 res = dst + src;
24124 flag_N = flag_X = flag_C = res;
24125 flag_V = (src ^ res) & (dst ^ res);
24126 flag_NotZ = res & 0xFF;
24127 WRITE_BYTE_F(adr, res)
24128 POST_IO
24129RET(14)
24130}
24131
24132// ADDQ
24133OPCODE(0x5040)
24134{
24135 u32 adr, res;
24136 u32 src, dst;
24137
24138 src = (((Opcode >> 9) - 1) & 7) + 1;
24139 dst = DREGu16((Opcode >> 0) & 7);
24140 res = dst + src;
24141 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24142 flag_N = flag_X = flag_C = res >> 8;
24143 flag_NotZ = res & 0xFFFF;
24144 DREGu16((Opcode >> 0) & 7) = res;
24145RET(4)
24146}
24147
24148// ADDQ
24149OPCODE(0x5048)
24150{
24151 u32 adr, res;
24152 u32 src, dst;
24153
24154 src = (((Opcode >> 9) - 1) & 7) + 1;
24155 dst = AREGu32((Opcode >> 0) & 7);
24156 res = dst + src;
24157 AREG((Opcode >> 0) & 7) = res;
24158RET(8)
24159}
24160
24161// ADDQ
24162OPCODE(0x5050)
24163{
24164 u32 adr, res;
24165 u32 src, dst;
24166
24167 src = (((Opcode >> 9) - 1) & 7) + 1;
24168 adr = AREG((Opcode >> 0) & 7);
24169 PRE_IO
24170 READ_WORD_F(adr, dst)
24171 res = dst + src;
24172 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24173 flag_N = flag_X = flag_C = res >> 8;
24174 flag_NotZ = res & 0xFFFF;
24175 WRITE_WORD_F(adr, res)
24176 POST_IO
24177RET(12)
24178}
24179
24180// ADDQ
24181OPCODE(0x5058)
24182{
24183 u32 adr, res;
24184 u32 src, dst;
24185
24186 src = (((Opcode >> 9) - 1) & 7) + 1;
24187 adr = AREG((Opcode >> 0) & 7);
24188 AREG((Opcode >> 0) & 7) += 2;
24189 PRE_IO
24190 READ_WORD_F(adr, dst)
24191 res = dst + src;
24192 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24193 flag_N = flag_X = flag_C = res >> 8;
24194 flag_NotZ = res & 0xFFFF;
24195 WRITE_WORD_F(adr, res)
24196 POST_IO
24197RET(12)
24198}
24199
24200// ADDQ
24201OPCODE(0x5060)
24202{
24203 u32 adr, res;
24204 u32 src, dst;
24205
24206 src = (((Opcode >> 9) - 1) & 7) + 1;
24207 adr = AREG((Opcode >> 0) & 7) - 2;
24208 AREG((Opcode >> 0) & 7) = adr;
24209 PRE_IO
24210 READ_WORD_F(adr, dst)
24211 res = dst + src;
24212 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24213 flag_N = flag_X = flag_C = res >> 8;
24214 flag_NotZ = res & 0xFFFF;
24215 WRITE_WORD_F(adr, res)
24216 POST_IO
24217RET(14)
24218}
24219
24220// ADDQ
24221OPCODE(0x5068)
24222{
24223 u32 adr, res;
24224 u32 src, dst;
24225
24226 src = (((Opcode >> 9) - 1) & 7) + 1;
24227 FETCH_SWORD(adr);
24228 adr += AREG((Opcode >> 0) & 7);
24229 PRE_IO
24230 READ_WORD_F(adr, dst)
24231 res = dst + src;
24232 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24233 flag_N = flag_X = flag_C = res >> 8;
24234 flag_NotZ = res & 0xFFFF;
24235 WRITE_WORD_F(adr, res)
24236 POST_IO
24237RET(16)
24238}
24239
24240// ADDQ
24241OPCODE(0x5070)
24242{
24243 u32 adr, res;
24244 u32 src, dst;
24245
24246 src = (((Opcode >> 9) - 1) & 7) + 1;
24247 adr = AREG((Opcode >> 0) & 7);
24248 DECODE_EXT_WORD
24249 PRE_IO
24250 READ_WORD_F(adr, dst)
24251 res = dst + src;
24252 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24253 flag_N = flag_X = flag_C = res >> 8;
24254 flag_NotZ = res & 0xFFFF;
24255 WRITE_WORD_F(adr, res)
24256 POST_IO
24257RET(18)
24258}
24259
24260// ADDQ
24261OPCODE(0x5078)
24262{
24263 u32 adr, res;
24264 u32 src, dst;
24265
24266 src = (((Opcode >> 9) - 1) & 7) + 1;
24267 FETCH_SWORD(adr);
24268 PRE_IO
24269 READ_WORD_F(adr, dst)
24270 res = dst + src;
24271 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24272 flag_N = flag_X = flag_C = res >> 8;
24273 flag_NotZ = res & 0xFFFF;
24274 WRITE_WORD_F(adr, res)
24275 POST_IO
24276RET(16)
24277}
24278
24279// ADDQ
24280OPCODE(0x5079)
24281{
24282 u32 adr, res;
24283 u32 src, dst;
24284
24285 src = (((Opcode >> 9) - 1) & 7) + 1;
24286 FETCH_LONG(adr);
24287 PRE_IO
24288 READ_WORD_F(adr, dst)
24289 res = dst + src;
24290 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24291 flag_N = flag_X = flag_C = res >> 8;
24292 flag_NotZ = res & 0xFFFF;
24293 WRITE_WORD_F(adr, res)
24294 POST_IO
24295RET(20)
24296}
24297
24298// ADDQ
24299OPCODE(0x505F)
24300{
24301 u32 adr, res;
24302 u32 src, dst;
24303
24304 src = (((Opcode >> 9) - 1) & 7) + 1;
24305 adr = AREG(7);
24306 AREG(7) += 2;
24307 PRE_IO
24308 READ_WORD_F(adr, dst)
24309 res = dst + src;
24310 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24311 flag_N = flag_X = flag_C = res >> 8;
24312 flag_NotZ = res & 0xFFFF;
24313 WRITE_WORD_F(adr, res)
24314 POST_IO
24315RET(12)
24316}
24317
24318// ADDQ
24319OPCODE(0x5067)
24320{
24321 u32 adr, res;
24322 u32 src, dst;
24323
24324 src = (((Opcode >> 9) - 1) & 7) + 1;
24325 adr = AREG(7) - 2;
24326 AREG(7) = adr;
24327 PRE_IO
24328 READ_WORD_F(adr, dst)
24329 res = dst + src;
24330 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24331 flag_N = flag_X = flag_C = res >> 8;
24332 flag_NotZ = res & 0xFFFF;
24333 WRITE_WORD_F(adr, res)
24334 POST_IO
24335RET(14)
24336}
24337
24338// ADDQ
24339OPCODE(0x5080)
24340{
24341 u32 adr, res;
24342 u32 src, dst;
24343
24344 src = (((Opcode >> 9) - 1) & 7) + 1;
24345 dst = DREGu32((Opcode >> 0) & 7);
24346 res = dst + src;
24347 flag_NotZ = res;
24348 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24349 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24350 flag_N = res >> 24;
24351 DREGu32((Opcode >> 0) & 7) = res;
24352RET(8)
24353}
24354
24355// ADDQ
24356OPCODE(0x5088)
24357{
24358 u32 adr, res;
24359 u32 src, dst;
24360
24361 src = (((Opcode >> 9) - 1) & 7) + 1;
24362 dst = AREGu32((Opcode >> 0) & 7);
24363 res = dst + src;
24364 AREG((Opcode >> 0) & 7) = res;
24365RET(8)
24366}
24367
24368// ADDQ
24369OPCODE(0x5090)
24370{
24371 u32 adr, res;
24372 u32 src, dst;
24373
24374 src = (((Opcode >> 9) - 1) & 7) + 1;
24375 adr = AREG((Opcode >> 0) & 7);
24376 PRE_IO
24377 READ_LONG_F(adr, dst)
24378 res = dst + src;
24379 flag_NotZ = res;
24380 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24381 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24382 flag_N = res >> 24;
24383 WRITE_LONG_F(adr, res)
24384 POST_IO
24385RET(20)
24386}
24387
24388// ADDQ
24389OPCODE(0x5098)
24390{
24391 u32 adr, res;
24392 u32 src, dst;
24393
24394 src = (((Opcode >> 9) - 1) & 7) + 1;
24395 adr = AREG((Opcode >> 0) & 7);
24396 AREG((Opcode >> 0) & 7) += 4;
24397 PRE_IO
24398 READ_LONG_F(adr, dst)
24399 res = dst + src;
24400 flag_NotZ = res;
24401 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24402 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24403 flag_N = res >> 24;
24404 WRITE_LONG_F(adr, res)
24405 POST_IO
24406RET(20)
24407}
24408
24409// ADDQ
24410OPCODE(0x50A0)
24411{
24412 u32 adr, res;
24413 u32 src, dst;
24414
24415 src = (((Opcode >> 9) - 1) & 7) + 1;
24416 adr = AREG((Opcode >> 0) & 7) - 4;
24417 AREG((Opcode >> 0) & 7) = adr;
24418 PRE_IO
24419 READ_LONG_F(adr, dst)
24420 res = dst + src;
24421 flag_NotZ = res;
24422 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24423 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24424 flag_N = res >> 24;
24425 WRITE_LONG_F(adr, res)
24426 POST_IO
24427RET(22)
24428}
24429
24430// ADDQ
24431OPCODE(0x50A8)
24432{
24433 u32 adr, res;
24434 u32 src, dst;
24435
24436 src = (((Opcode >> 9) - 1) & 7) + 1;
24437 FETCH_SWORD(adr);
24438 adr += AREG((Opcode >> 0) & 7);
24439 PRE_IO
24440 READ_LONG_F(adr, dst)
24441 res = dst + src;
24442 flag_NotZ = res;
24443 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24444 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24445 flag_N = res >> 24;
24446 WRITE_LONG_F(adr, res)
24447 POST_IO
24448RET(24)
24449}
24450
24451// ADDQ
24452OPCODE(0x50B0)
24453{
24454 u32 adr, res;
24455 u32 src, dst;
24456
24457 src = (((Opcode >> 9) - 1) & 7) + 1;
24458 adr = AREG((Opcode >> 0) & 7);
24459 DECODE_EXT_WORD
24460 PRE_IO
24461 READ_LONG_F(adr, dst)
24462 res = dst + src;
24463 flag_NotZ = res;
24464 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24465 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24466 flag_N = res >> 24;
24467 WRITE_LONG_F(adr, res)
24468 POST_IO
24469RET(26)
24470}
24471
24472// ADDQ
24473OPCODE(0x50B8)
24474{
24475 u32 adr, res;
24476 u32 src, dst;
24477
24478 src = (((Opcode >> 9) - 1) & 7) + 1;
24479 FETCH_SWORD(adr);
24480 PRE_IO
24481 READ_LONG_F(adr, dst)
24482 res = dst + src;
24483 flag_NotZ = res;
24484 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24485 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24486 flag_N = res >> 24;
24487 WRITE_LONG_F(adr, res)
24488 POST_IO
24489RET(24)
24490}
24491
24492// ADDQ
24493OPCODE(0x50B9)
24494{
24495 u32 adr, res;
24496 u32 src, dst;
24497
24498 src = (((Opcode >> 9) - 1) & 7) + 1;
24499 FETCH_LONG(adr);
24500 PRE_IO
24501 READ_LONG_F(adr, dst)
24502 res = dst + src;
24503 flag_NotZ = res;
24504 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24505 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24506 flag_N = res >> 24;
24507 WRITE_LONG_F(adr, res)
24508 POST_IO
24509RET(28)
24510}
24511
24512// ADDQ
24513OPCODE(0x509F)
24514{
24515 u32 adr, res;
24516 u32 src, dst;
24517
24518 src = (((Opcode >> 9) - 1) & 7) + 1;
24519 adr = AREG(7);
24520 AREG(7) += 4;
24521 PRE_IO
24522 READ_LONG_F(adr, dst)
24523 res = dst + src;
24524 flag_NotZ = res;
24525 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24526 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24527 flag_N = res >> 24;
24528 WRITE_LONG_F(adr, res)
24529 POST_IO
24530RET(20)
24531}
24532
24533// ADDQ
24534OPCODE(0x50A7)
24535{
24536 u32 adr, res;
24537 u32 src, dst;
24538
24539 src = (((Opcode >> 9) - 1) & 7) + 1;
24540 adr = AREG(7) - 4;
24541 AREG(7) = adr;
24542 PRE_IO
24543 READ_LONG_F(adr, dst)
24544 res = dst + src;
24545 flag_NotZ = res;
24546 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24547 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24548 flag_N = res >> 24;
24549 WRITE_LONG_F(adr, res)
24550 POST_IO
24551RET(22)
24552}
24553
24554// SUBQ
24555OPCODE(0x5100)
24556{
24557 u32 adr, res;
24558 u32 src, dst;
24559
24560 src = (((Opcode >> 9) - 1) & 7) + 1;
24561 dst = DREGu8((Opcode >> 0) & 7);
24562 res = dst - src;
24563 flag_N = flag_X = flag_C = res;
24564 flag_V = (src ^ dst) & (res ^ dst);
24565 flag_NotZ = res & 0xFF;
24566 DREGu8((Opcode >> 0) & 7) = res;
24567RET(4)
24568}
24569
24570// SUBQ
24571OPCODE(0x5110)
24572{
24573 u32 adr, res;
24574 u32 src, dst;
24575
24576 src = (((Opcode >> 9) - 1) & 7) + 1;
24577 adr = AREG((Opcode >> 0) & 7);
24578 PRE_IO
24579 READ_BYTE_F(adr, dst)
24580 res = dst - src;
24581 flag_N = flag_X = flag_C = res;
24582 flag_V = (src ^ dst) & (res ^ dst);
24583 flag_NotZ = res & 0xFF;
24584 WRITE_BYTE_F(adr, res)
24585 POST_IO
24586RET(12)
24587}
24588
24589// SUBQ
24590OPCODE(0x5118)
24591{
24592 u32 adr, res;
24593 u32 src, dst;
24594
24595 src = (((Opcode >> 9) - 1) & 7) + 1;
24596 adr = AREG((Opcode >> 0) & 7);
24597 AREG((Opcode >> 0) & 7) += 1;
24598 PRE_IO
24599 READ_BYTE_F(adr, dst)
24600 res = dst - src;
24601 flag_N = flag_X = flag_C = res;
24602 flag_V = (src ^ dst) & (res ^ dst);
24603 flag_NotZ = res & 0xFF;
24604 WRITE_BYTE_F(adr, res)
24605 POST_IO
24606RET(12)
24607}
24608
24609// SUBQ
24610OPCODE(0x5120)
24611{
24612 u32 adr, res;
24613 u32 src, dst;
24614
24615 src = (((Opcode >> 9) - 1) & 7) + 1;
24616 adr = AREG((Opcode >> 0) & 7) - 1;
24617 AREG((Opcode >> 0) & 7) = adr;
24618 PRE_IO
24619 READ_BYTE_F(adr, dst)
24620 res = dst - src;
24621 flag_N = flag_X = flag_C = res;
24622 flag_V = (src ^ dst) & (res ^ dst);
24623 flag_NotZ = res & 0xFF;
24624 WRITE_BYTE_F(adr, res)
24625 POST_IO
24626RET(14)
24627}
24628
24629// SUBQ
24630OPCODE(0x5128)
24631{
24632 u32 adr, res;
24633 u32 src, dst;
24634
24635 src = (((Opcode >> 9) - 1) & 7) + 1;
24636 FETCH_SWORD(adr);
24637 adr += AREG((Opcode >> 0) & 7);
24638 PRE_IO
24639 READ_BYTE_F(adr, dst)
24640 res = dst - src;
24641 flag_N = flag_X = flag_C = res;
24642 flag_V = (src ^ dst) & (res ^ dst);
24643 flag_NotZ = res & 0xFF;
24644 WRITE_BYTE_F(adr, res)
24645 POST_IO
24646RET(16)
24647}
24648
24649// SUBQ
24650OPCODE(0x5130)
24651{
24652 u32 adr, res;
24653 u32 src, dst;
24654
24655 src = (((Opcode >> 9) - 1) & 7) + 1;
24656 adr = AREG((Opcode >> 0) & 7);
24657 DECODE_EXT_WORD
24658 PRE_IO
24659 READ_BYTE_F(adr, dst)
24660 res = dst - src;
24661 flag_N = flag_X = flag_C = res;
24662 flag_V = (src ^ dst) & (res ^ dst);
24663 flag_NotZ = res & 0xFF;
24664 WRITE_BYTE_F(adr, res)
24665 POST_IO
24666RET(18)
24667}
24668
24669// SUBQ
24670OPCODE(0x5138)
24671{
24672 u32 adr, res;
24673 u32 src, dst;
24674
24675 src = (((Opcode >> 9) - 1) & 7) + 1;
24676 FETCH_SWORD(adr);
24677 PRE_IO
24678 READ_BYTE_F(adr, dst)
24679 res = dst - src;
24680 flag_N = flag_X = flag_C = res;
24681 flag_V = (src ^ dst) & (res ^ dst);
24682 flag_NotZ = res & 0xFF;
24683 WRITE_BYTE_F(adr, res)
24684 POST_IO
24685RET(16)
24686}
24687
24688// SUBQ
24689OPCODE(0x5139)
24690{
24691 u32 adr, res;
24692 u32 src, dst;
24693
24694 src = (((Opcode >> 9) - 1) & 7) + 1;
24695 FETCH_LONG(adr);
24696 PRE_IO
24697 READ_BYTE_F(adr, dst)
24698 res = dst - src;
24699 flag_N = flag_X = flag_C = res;
24700 flag_V = (src ^ dst) & (res ^ dst);
24701 flag_NotZ = res & 0xFF;
24702 WRITE_BYTE_F(adr, res)
24703 POST_IO
24704RET(20)
24705}
24706
24707// SUBQ
24708OPCODE(0x511F)
24709{
24710 u32 adr, res;
24711 u32 src, dst;
24712
24713 src = (((Opcode >> 9) - 1) & 7) + 1;
24714 adr = AREG(7);
24715 AREG(7) += 2;
24716 PRE_IO
24717 READ_BYTE_F(adr, dst)
24718 res = dst - src;
24719 flag_N = flag_X = flag_C = res;
24720 flag_V = (src ^ dst) & (res ^ dst);
24721 flag_NotZ = res & 0xFF;
24722 WRITE_BYTE_F(adr, res)
24723 POST_IO
24724RET(12)
24725}
24726
24727// SUBQ
24728OPCODE(0x5127)
24729{
24730 u32 adr, res;
24731 u32 src, dst;
24732
24733 src = (((Opcode >> 9) - 1) & 7) + 1;
24734 adr = AREG(7) - 2;
24735 AREG(7) = adr;
24736 PRE_IO
24737 READ_BYTE_F(adr, dst)
24738 res = dst - src;
24739 flag_N = flag_X = flag_C = res;
24740 flag_V = (src ^ dst) & (res ^ dst);
24741 flag_NotZ = res & 0xFF;
24742 WRITE_BYTE_F(adr, res)
24743 POST_IO
24744RET(14)
24745}
24746
24747// SUBQ
24748OPCODE(0x5140)
24749{
24750 u32 adr, res;
24751 u32 src, dst;
24752
24753 src = (((Opcode >> 9) - 1) & 7) + 1;
24754 dst = DREGu16((Opcode >> 0) & 7);
24755 res = dst - src;
24756 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24757 flag_N = flag_X = flag_C = res >> 8;
24758 flag_NotZ = res & 0xFFFF;
24759 DREGu16((Opcode >> 0) & 7) = res;
24760RET(4)
24761}
24762
24763// SUBQ
24764OPCODE(0x5148)
24765{
24766 u32 adr, res;
24767 u32 src, dst;
24768
24769 src = (((Opcode >> 9) - 1) & 7) + 1;
24770 dst = AREGu32((Opcode >> 0) & 7);
24771 res = dst - src;
24772 AREG((Opcode >> 0) & 7) = res;
24773RET(8)
24774}
24775
24776// SUBQ
24777OPCODE(0x5150)
24778{
24779 u32 adr, res;
24780 u32 src, dst;
24781
24782 src = (((Opcode >> 9) - 1) & 7) + 1;
24783 adr = AREG((Opcode >> 0) & 7);
24784 PRE_IO
24785 READ_WORD_F(adr, dst)
24786 res = dst - src;
24787 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24788 flag_N = flag_X = flag_C = res >> 8;
24789 flag_NotZ = res & 0xFFFF;
24790 WRITE_WORD_F(adr, res)
24791 POST_IO
24792RET(12)
24793}
24794
24795// SUBQ
24796OPCODE(0x5158)
24797{
24798 u32 adr, res;
24799 u32 src, dst;
24800
24801 src = (((Opcode >> 9) - 1) & 7) + 1;
24802 adr = AREG((Opcode >> 0) & 7);
24803 AREG((Opcode >> 0) & 7) += 2;
24804 PRE_IO
24805 READ_WORD_F(adr, dst)
24806 res = dst - src;
24807 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24808 flag_N = flag_X = flag_C = res >> 8;
24809 flag_NotZ = res & 0xFFFF;
24810 WRITE_WORD_F(adr, res)
24811 POST_IO
24812RET(12)
24813}
24814
24815// SUBQ
24816OPCODE(0x5160)
24817{
24818 u32 adr, res;
24819 u32 src, dst;
24820
24821 src = (((Opcode >> 9) - 1) & 7) + 1;
24822 adr = AREG((Opcode >> 0) & 7) - 2;
24823 AREG((Opcode >> 0) & 7) = adr;
24824 PRE_IO
24825 READ_WORD_F(adr, dst)
24826 res = dst - src;
24827 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24828 flag_N = flag_X = flag_C = res >> 8;
24829 flag_NotZ = res & 0xFFFF;
24830 WRITE_WORD_F(adr, res)
24831 POST_IO
24832RET(14)
24833}
24834
24835// SUBQ
24836OPCODE(0x5168)
24837{
24838 u32 adr, res;
24839 u32 src, dst;
24840
24841 src = (((Opcode >> 9) - 1) & 7) + 1;
24842 FETCH_SWORD(adr);
24843 adr += AREG((Opcode >> 0) & 7);
24844 PRE_IO
24845 READ_WORD_F(adr, dst)
24846 res = dst - src;
24847 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24848 flag_N = flag_X = flag_C = res >> 8;
24849 flag_NotZ = res & 0xFFFF;
24850 WRITE_WORD_F(adr, res)
24851 POST_IO
24852RET(16)
24853}
24854
24855// SUBQ
24856OPCODE(0x5170)
24857{
24858 u32 adr, res;
24859 u32 src, dst;
24860
24861 src = (((Opcode >> 9) - 1) & 7) + 1;
24862 adr = AREG((Opcode >> 0) & 7);
24863 DECODE_EXT_WORD
24864 PRE_IO
24865 READ_WORD_F(adr, dst)
24866 res = dst - src;
24867 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24868 flag_N = flag_X = flag_C = res >> 8;
24869 flag_NotZ = res & 0xFFFF;
24870 WRITE_WORD_F(adr, res)
24871 POST_IO
24872RET(18)
24873}
24874
24875// SUBQ
24876OPCODE(0x5178)
24877{
24878 u32 adr, res;
24879 u32 src, dst;
24880
24881 src = (((Opcode >> 9) - 1) & 7) + 1;
24882 FETCH_SWORD(adr);
24883 PRE_IO
24884 READ_WORD_F(adr, dst)
24885 res = dst - src;
24886 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24887 flag_N = flag_X = flag_C = res >> 8;
24888 flag_NotZ = res & 0xFFFF;
24889 WRITE_WORD_F(adr, res)
24890 POST_IO
24891RET(16)
24892}
24893
24894// SUBQ
24895OPCODE(0x5179)
24896{
24897 u32 adr, res;
24898 u32 src, dst;
24899
24900 src = (((Opcode >> 9) - 1) & 7) + 1;
24901 FETCH_LONG(adr);
24902 PRE_IO
24903 READ_WORD_F(adr, dst)
24904 res = dst - src;
24905 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24906 flag_N = flag_X = flag_C = res >> 8;
24907 flag_NotZ = res & 0xFFFF;
24908 WRITE_WORD_F(adr, res)
24909 POST_IO
24910RET(20)
24911}
24912
24913// SUBQ
24914OPCODE(0x515F)
24915{
24916 u32 adr, res;
24917 u32 src, dst;
24918
24919 src = (((Opcode >> 9) - 1) & 7) + 1;
24920 adr = AREG(7);
24921 AREG(7) += 2;
24922 PRE_IO
24923 READ_WORD_F(adr, dst)
24924 res = dst - src;
24925 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24926 flag_N = flag_X = flag_C = res >> 8;
24927 flag_NotZ = res & 0xFFFF;
24928 WRITE_WORD_F(adr, res)
24929 POST_IO
24930RET(12)
24931}
24932
24933// SUBQ
24934OPCODE(0x5167)
24935{
24936 u32 adr, res;
24937 u32 src, dst;
24938
24939 src = (((Opcode >> 9) - 1) & 7) + 1;
24940 adr = AREG(7) - 2;
24941 AREG(7) = adr;
24942 PRE_IO
24943 READ_WORD_F(adr, dst)
24944 res = dst - src;
24945 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24946 flag_N = flag_X = flag_C = res >> 8;
24947 flag_NotZ = res & 0xFFFF;
24948 WRITE_WORD_F(adr, res)
24949 POST_IO
24950RET(14)
24951}
24952
24953// SUBQ
24954OPCODE(0x5180)
24955{
24956 u32 adr, res;
24957 u32 src, dst;
24958
24959 src = (((Opcode >> 9) - 1) & 7) + 1;
24960 dst = DREGu32((Opcode >> 0) & 7);
24961 res = dst - src;
24962 flag_NotZ = res;
24963 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24964 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24965 flag_N = res >> 24;
24966 DREGu32((Opcode >> 0) & 7) = res;
24967RET(8)
24968}
24969
24970// SUBQ
24971OPCODE(0x5188)
24972{
24973 u32 adr, res;
24974 u32 src, dst;
24975
24976 src = (((Opcode >> 9) - 1) & 7) + 1;
24977 dst = AREGu32((Opcode >> 0) & 7);
24978 res = dst - src;
24979 AREG((Opcode >> 0) & 7) = res;
24980RET(8)
24981}
24982
24983// SUBQ
24984OPCODE(0x5190)
24985{
24986 u32 adr, res;
24987 u32 src, dst;
24988
24989 src = (((Opcode >> 9) - 1) & 7) + 1;
24990 adr = AREG((Opcode >> 0) & 7);
24991 PRE_IO
24992 READ_LONG_F(adr, dst)
24993 res = dst - src;
24994 flag_NotZ = res;
24995 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24996 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24997 flag_N = res >> 24;
24998 WRITE_LONG_F(adr, res)
24999 POST_IO
25000RET(20)
25001}
25002
25003// SUBQ
25004OPCODE(0x5198)
25005{
25006 u32 adr, res;
25007 u32 src, dst;
25008
25009 src = (((Opcode >> 9) - 1) & 7) + 1;
25010 adr = AREG((Opcode >> 0) & 7);
25011 AREG((Opcode >> 0) & 7) += 4;
25012 PRE_IO
25013 READ_LONG_F(adr, dst)
25014 res = dst - src;
25015 flag_NotZ = res;
25016 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25017 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25018 flag_N = res >> 24;
25019 WRITE_LONG_F(adr, res)
25020 POST_IO
25021RET(20)
25022}
25023
25024// SUBQ
25025OPCODE(0x51A0)
25026{
25027 u32 adr, res;
25028 u32 src, dst;
25029
25030 src = (((Opcode >> 9) - 1) & 7) + 1;
25031 adr = AREG((Opcode >> 0) & 7) - 4;
25032 AREG((Opcode >> 0) & 7) = adr;
25033 PRE_IO
25034 READ_LONG_F(adr, dst)
25035 res = dst - src;
25036 flag_NotZ = res;
25037 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25038 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25039 flag_N = res >> 24;
25040 WRITE_LONG_F(adr, res)
25041 POST_IO
25042RET(22)
25043}
25044
25045// SUBQ
25046OPCODE(0x51A8)
25047{
25048 u32 adr, res;
25049 u32 src, dst;
25050
25051 src = (((Opcode >> 9) - 1) & 7) + 1;
25052 FETCH_SWORD(adr);
25053 adr += AREG((Opcode >> 0) & 7);
25054 PRE_IO
25055 READ_LONG_F(adr, dst)
25056 res = dst - src;
25057 flag_NotZ = res;
25058 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25059 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25060 flag_N = res >> 24;
25061 WRITE_LONG_F(adr, res)
25062 POST_IO
25063RET(24)
25064}
25065
25066// SUBQ
25067OPCODE(0x51B0)
25068{
25069 u32 adr, res;
25070 u32 src, dst;
25071
25072 src = (((Opcode >> 9) - 1) & 7) + 1;
25073 adr = AREG((Opcode >> 0) & 7);
25074 DECODE_EXT_WORD
25075 PRE_IO
25076 READ_LONG_F(adr, dst)
25077 res = dst - src;
25078 flag_NotZ = res;
25079 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25080 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25081 flag_N = res >> 24;
25082 WRITE_LONG_F(adr, res)
25083 POST_IO
25084RET(26)
25085}
25086
25087// SUBQ
25088OPCODE(0x51B8)
25089{
25090 u32 adr, res;
25091 u32 src, dst;
25092
25093 src = (((Opcode >> 9) - 1) & 7) + 1;
25094 FETCH_SWORD(adr);
25095 PRE_IO
25096 READ_LONG_F(adr, dst)
25097 res = dst - src;
25098 flag_NotZ = res;
25099 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25100 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25101 flag_N = res >> 24;
25102 WRITE_LONG_F(adr, res)
25103 POST_IO
25104RET(24)
25105}
25106
25107// SUBQ
25108OPCODE(0x51B9)
25109{
25110 u32 adr, res;
25111 u32 src, dst;
25112
25113 src = (((Opcode >> 9) - 1) & 7) + 1;
25114 FETCH_LONG(adr);
25115 PRE_IO
25116 READ_LONG_F(adr, dst)
25117 res = dst - src;
25118 flag_NotZ = res;
25119 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25120 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25121 flag_N = res >> 24;
25122 WRITE_LONG_F(adr, res)
25123 POST_IO
25124RET(28)
25125}
25126
25127// SUBQ
25128OPCODE(0x519F)
25129{
25130 u32 adr, res;
25131 u32 src, dst;
25132
25133 src = (((Opcode >> 9) - 1) & 7) + 1;
25134 adr = AREG(7);
25135 AREG(7) += 4;
25136 PRE_IO
25137 READ_LONG_F(adr, dst)
25138 res = dst - src;
25139 flag_NotZ = res;
25140 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25141 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25142 flag_N = res >> 24;
25143 WRITE_LONG_F(adr, res)
25144 POST_IO
25145RET(20)
25146}
25147
25148// SUBQ
25149OPCODE(0x51A7)
25150{
25151 u32 adr, res;
25152 u32 src, dst;
25153
25154 src = (((Opcode >> 9) - 1) & 7) + 1;
25155 adr = AREG(7) - 4;
25156 AREG(7) = adr;
25157 PRE_IO
25158 READ_LONG_F(adr, dst)
25159 res = dst - src;
25160 flag_NotZ = res;
25161 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25162 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25163 flag_N = res >> 24;
25164 WRITE_LONG_F(adr, res)
25165 POST_IO
25166RET(22)
25167}
25168
25169// BCC
25170OPCODE(0x6201)
25171{
25172 u32 adr, res;
25173 u32 src, dst;
25174
25175 if (flag_NotZ && (!(flag_C & 0x100)))
25176 {
25177 PC += ((s8)(Opcode & 0xFE)) >> 1;
25178 ctx->io_cycle_counter -= 2;
25179 }
25180RET(8)
25181}
25182
25183// BCC
25184OPCODE(0x6301)
25185{
25186 u32 adr, res;
25187 u32 src, dst;
25188
25189 if ((!flag_NotZ) || (flag_C & 0x100))
25190 {
25191 PC += ((s8)(Opcode & 0xFE)) >> 1;
25192 ctx->io_cycle_counter -= 2;
25193 }
25194RET(8)
25195}
25196
25197// BCC
25198OPCODE(0x6401)
25199{
25200 u32 adr, res;
25201 u32 src, dst;
25202
25203 if (!(flag_C & 0x100))
25204 {
25205 PC += ((s8)(Opcode & 0xFE)) >> 1;
25206 ctx->io_cycle_counter -= 2;
25207 }
25208RET(8)
25209}
25210
25211// BCC
25212OPCODE(0x6501)
25213{
25214 u32 adr, res;
25215 u32 src, dst;
25216
25217 if (flag_C & 0x100)
25218 {
25219 PC += ((s8)(Opcode & 0xFE)) >> 1;
25220 ctx->io_cycle_counter -= 2;
25221 }
25222RET(8)
25223}
25224
25225// BCC
25226OPCODE(0x6601)
25227{
25228 u32 adr, res;
25229 u32 src, dst;
25230
25231 if (flag_NotZ)
25232 {
25233 PC += ((s8)(Opcode & 0xFE)) >> 1;
25234 ctx->io_cycle_counter -= 2;
25235 }
25236RET(8)
25237}
25238
25239// BCC
25240OPCODE(0x6701)
25241{
25242 u32 adr, res;
25243 u32 src, dst;
25244
25245 if (!flag_NotZ)
25246 {
25247 PC += ((s8)(Opcode & 0xFE)) >> 1;
25248 ctx->io_cycle_counter -= 2;
25249 }
25250RET(8)
25251}
25252
25253// BCC
25254OPCODE(0x6801)
25255{
25256 u32 adr, res;
25257 u32 src, dst;
25258
25259 if (!(flag_V & 0x80))
25260 {
25261 PC += ((s8)(Opcode & 0xFE)) >> 1;
25262 ctx->io_cycle_counter -= 2;
25263 }
25264RET(8)
25265}
25266
25267// BCC
25268OPCODE(0x6901)
25269{
25270 u32 adr, res;
25271 u32 src, dst;
25272
25273 if (flag_V & 0x80)
25274 {
25275 PC += ((s8)(Opcode & 0xFE)) >> 1;
25276 ctx->io_cycle_counter -= 2;
25277 }
25278RET(8)
25279}
25280
25281// BCC
25282OPCODE(0x6A01)
25283{
25284 u32 adr, res;
25285 u32 src, dst;
25286
25287 if (!(flag_N & 0x80))
25288 {
25289 PC += ((s8)(Opcode & 0xFE)) >> 1;
25290 ctx->io_cycle_counter -= 2;
25291 }
25292RET(8)
25293}
25294
25295// BCC
25296OPCODE(0x6B01)
25297{
25298 u32 adr, res;
25299 u32 src, dst;
25300
25301 if (flag_N & 0x80)
25302 {
25303 PC += ((s8)(Opcode & 0xFE)) >> 1;
25304 ctx->io_cycle_counter -= 2;
25305 }
25306RET(8)
25307}
25308
25309// BCC
25310OPCODE(0x6C01)
25311{
25312 u32 adr, res;
25313 u32 src, dst;
25314
25315 if (!((flag_N ^ flag_V) & 0x80))
25316 {
25317 PC += ((s8)(Opcode & 0xFE)) >> 1;
25318 ctx->io_cycle_counter -= 2;
25319 }
25320RET(8)
25321}
25322
25323// BCC
25324OPCODE(0x6D01)
25325{
25326 u32 adr, res;
25327 u32 src, dst;
25328
25329 if ((flag_N ^ flag_V) & 0x80)
25330 {
25331 PC += ((s8)(Opcode & 0xFE)) >> 1;
25332 ctx->io_cycle_counter -= 2;
25333 }
25334RET(8)
25335}
25336
25337// BCC
25338OPCODE(0x6E01)
25339{
25340 u32 adr, res;
25341 u32 src, dst;
25342
25343 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25344 {
25345 PC += ((s8)(Opcode & 0xFE)) >> 1;
25346 ctx->io_cycle_counter -= 2;
25347 }
25348RET(8)
25349}
25350
25351// BCC
25352OPCODE(0x6F01)
25353{
25354 u32 adr, res;
25355 u32 src, dst;
25356
25357 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25358 {
25359 PC += ((s8)(Opcode & 0xFE)) >> 1;
25360 ctx->io_cycle_counter -= 2;
25361 }
25362RET(8)
25363}
25364
25365// BCC16
25366OPCODE(0x6200)
25367{
25368 u32 adr, res;
25369 u32 src, dst;
25370
25371 if (flag_NotZ && (!(flag_C & 0x100)))
25372 {
25373 u32 newPC;
25374
25375 newPC = GET_PC;
25376 newPC += GET_SWORD;
25377 SET_PC(newPC);
25378 CHECK_BRANCH_EXCEPTION(newPC)
25379 RET(10)
25380 }
25381 PC++;
25382RET(12)
25383}
25384
25385// BCC16
25386OPCODE(0x6300)
25387{
25388 u32 adr, res;
25389 u32 src, dst;
25390
25391 if ((!flag_NotZ) || (flag_C & 0x100))
25392 {
25393 u32 newPC;
25394
25395 newPC = GET_PC;
25396 newPC += GET_SWORD;
25397 SET_PC(newPC);
25398 CHECK_BRANCH_EXCEPTION(newPC)
25399 RET(10)
25400 }
25401 PC++;
25402RET(12)
25403}
25404
25405// BCC16
25406OPCODE(0x6400)
25407{
25408 u32 adr, res;
25409 u32 src, dst;
25410
25411 if (!(flag_C & 0x100))
25412 {
25413 u32 newPC;
25414
25415 newPC = GET_PC;
25416 newPC += GET_SWORD;
25417 SET_PC(newPC);
25418 CHECK_BRANCH_EXCEPTION(newPC)
25419 RET(10)
25420 }
25421 PC++;
25422RET(12)
25423}
25424
25425// BCC16
25426OPCODE(0x6500)
25427{
25428 u32 adr, res;
25429 u32 src, dst;
25430
25431 if (flag_C & 0x100)
25432 {
25433 u32 newPC;
25434
25435 newPC = GET_PC;
25436 newPC += GET_SWORD;
25437 SET_PC(newPC);
25438 CHECK_BRANCH_EXCEPTION(newPC)
25439 RET(10)
25440 }
25441 PC++;
25442RET(12)
25443}
25444
25445// BCC16
25446OPCODE(0x6600)
25447{
25448 u32 adr, res;
25449 u32 src, dst;
25450
25451 if (flag_NotZ)
25452 {
25453 u32 newPC;
25454
25455 newPC = GET_PC;
25456 newPC += GET_SWORD;
25457 SET_PC(newPC);
25458 CHECK_BRANCH_EXCEPTION(newPC)
25459 RET(10)
25460 }
25461 PC++;
25462RET(12)
25463}
25464
25465// BCC16
25466OPCODE(0x6700)
25467{
25468 u32 adr, res;
25469 u32 src, dst;
25470
25471 if (!flag_NotZ)
25472 {
25473 u32 newPC;
25474
25475 newPC = GET_PC;
25476 newPC += GET_SWORD;
25477 SET_PC(newPC);
25478 CHECK_BRANCH_EXCEPTION(newPC)
25479 RET(10)
25480 }
25481 PC++;
25482RET(12)
25483}
25484
25485// BCC16
25486OPCODE(0x6800)
25487{
25488 u32 adr, res;
25489 u32 src, dst;
25490
25491 if (!(flag_V & 0x80))
25492 {
25493 u32 newPC;
25494
25495 newPC = GET_PC;
25496 newPC += GET_SWORD;
25497 SET_PC(newPC);
25498 CHECK_BRANCH_EXCEPTION(newPC)
25499 RET(10)
25500 }
25501 PC++;
25502RET(12)
25503}
25504
25505// BCC16
25506OPCODE(0x6900)
25507{
25508 u32 adr, res;
25509 u32 src, dst;
25510
25511 if (flag_V & 0x80)
25512 {
25513 u32 newPC;
25514
25515 newPC = GET_PC;
25516 newPC += GET_SWORD;
25517 SET_PC(newPC);
25518 CHECK_BRANCH_EXCEPTION(newPC)
25519 RET(10)
25520 }
25521 PC++;
25522RET(12)
25523}
25524
25525// BCC16
25526OPCODE(0x6A00)
25527{
25528 u32 adr, res;
25529 u32 src, dst;
25530
25531 if (!(flag_N & 0x80))
25532 {
25533 u32 newPC;
25534
25535 newPC = GET_PC;
25536 newPC += GET_SWORD;
25537 SET_PC(newPC);
25538 CHECK_BRANCH_EXCEPTION(newPC)
25539 RET(10)
25540 }
25541 PC++;
25542RET(12)
25543}
25544
25545// BCC16
25546OPCODE(0x6B00)
25547{
25548 u32 adr, res;
25549 u32 src, dst;
25550
25551 if (flag_N & 0x80)
25552 {
25553 u32 newPC;
25554
25555 newPC = GET_PC;
25556 newPC += GET_SWORD;
25557 SET_PC(newPC);
25558 CHECK_BRANCH_EXCEPTION(newPC)
25559 RET(10)
25560 }
25561 PC++;
25562RET(12)
25563}
25564
25565// BCC16
25566OPCODE(0x6C00)
25567{
25568 u32 adr, res;
25569 u32 src, dst;
25570
25571 if (!((flag_N ^ flag_V) & 0x80))
25572 {
25573 u32 newPC;
25574
25575 newPC = GET_PC;
25576 newPC += GET_SWORD;
25577 SET_PC(newPC);
25578 CHECK_BRANCH_EXCEPTION(newPC)
25579 RET(10)
25580 }
25581 PC++;
25582RET(12)
25583}
25584
25585// BCC16
25586OPCODE(0x6D00)
25587{
25588 u32 adr, res;
25589 u32 src, dst;
25590
25591 if ((flag_N ^ flag_V) & 0x80)
25592 {
25593 u32 newPC;
25594
25595 newPC = GET_PC;
25596 newPC += GET_SWORD;
25597 SET_PC(newPC);
25598 CHECK_BRANCH_EXCEPTION(newPC)
25599 RET(10)
25600 }
25601 PC++;
25602RET(12)
25603}
25604
25605// BCC16
25606OPCODE(0x6E00)
25607{
25608 u32 adr, res;
25609 u32 src, dst;
25610
25611 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25612 {
25613 u32 newPC;
25614
25615 newPC = GET_PC;
25616 newPC += GET_SWORD;
25617 SET_PC(newPC);
25618 CHECK_BRANCH_EXCEPTION(newPC)
25619 RET(10)
25620 }
25621 PC++;
25622RET(12)
25623}
25624
25625// BCC16
25626OPCODE(0x6F00)
25627{
25628 u32 adr, res;
25629 u32 src, dst;
25630
25631 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25632 {
25633 u32 newPC;
25634
25635 newPC = GET_PC;
25636 newPC += GET_SWORD;
25637 SET_PC(newPC);
25638 CHECK_BRANCH_EXCEPTION(newPC)
25639 RET(10)
25640 }
25641 PC++;
25642RET(12)
25643}
25644
25645// BRA
25646OPCODE(0x6001)
25647{
25648#ifdef FAMEC_CHECK_BRANCHES
25649 u32 newPC = GET_PC;
25650 s8 offs=Opcode;
25651 newPC += offs;
25652 SET_PC(newPC);
25653 CHECK_BRANCH_EXCEPTION(offs)
25654#else
25655 PC += ((s8)(Opcode & 0xFE)) >> 1;
25656#endif
25657RET(10)
25658}
25659
25660// BRA16
25661OPCODE(0x6000)
25662{
25663 u32 adr, res;
25664 u32 src, dst;
25665
25666 {
25667 u32 newPC;
25668
25669 newPC = GET_PC;
25670 newPC += GET_SWORD;
25671 SET_PC(newPC);
25672 CHECK_BRANCH_EXCEPTION(newPC)
25673 }
25674RET(10)
25675}
25676
25677// BSR
25678OPCODE(0x6101)
25679{
25680 u32 adr, res;
25681 u32 src, dst;
25682 u32 oldPC;
25683 s8 offs;
25684
25685 PRE_IO
25686
25687 oldPC = GET_PC;
25688 PUSH_32_F(oldPC)
25689#ifdef FAMEC_CHECK_BRANCHES
25690 offs = Opcode;
25691 oldPC += offs;
25692 SET_PC(oldPC);
25693 CHECK_BRANCH_EXCEPTION(offs)
25694#else
25695 PC += ((s8)(Opcode & 0xFE)) >> 1;
25696#endif
25697 POST_IO
25698RET(18)
25699}
25700
25701// BSR16
25702OPCODE(0x6100)
25703{
25704 u32 adr, res;
25705 u32 src, dst;
25706
25707 PRE_IO
25708 {
25709 u32 oldPC, newPC;
25710
25711 newPC = GET_PC;
25712 oldPC = newPC + 2;
25713 PUSH_32_F(oldPC)
25714 newPC += GET_SWORD;
25715 SET_PC(newPC);
25716 CHECK_BRANCH_EXCEPTION(newPC)
25717 }
25718 POST_IO
25719RET(18)
25720}
25721
25722// MOVEQ
25723OPCODE(0x7000)
25724{
25725 u32 adr, res;
25726 u32 src, dst;
25727
25728 res = (s32)(s8)Opcode;
25729 flag_C = flag_V = 0;
25730 flag_N = flag_NotZ = res;
25731 DREGu32((Opcode >> 9) & 7) = res;
25732RET(4)
25733}
25734
25735// ORaD
25736OPCODE(0x8000)
25737{
25738 u32 adr, res;
25739 u32 src, dst;
25740
25741 src = DREGu8((Opcode >> 0) & 7);
25742 res = DREGu8((Opcode >> 9) & 7);
25743 res |= src;
25744 flag_C = 0;
25745 flag_V = 0;
25746 flag_NotZ = res;
25747 flag_N = res;
25748 DREGu8((Opcode >> 9) & 7) = res;
25749RET(4)
25750}
25751
25752// ORaD
25753OPCODE(0x8010)
25754{
25755 u32 adr, res;
25756 u32 src, dst;
25757
25758 adr = AREG((Opcode >> 0) & 7);
25759 PRE_IO
25760 READ_BYTE_F(adr, src)
25761 res = DREGu8((Opcode >> 9) & 7);
25762 res |= src;
25763 flag_C = 0;
25764 flag_V = 0;
25765 flag_NotZ = res;
25766 flag_N = res;
25767 DREGu8((Opcode >> 9) & 7) = res;
25768 POST_IO
25769RET(8)
25770}
25771
25772// ORaD
25773OPCODE(0x8018)
25774{
25775 u32 adr, res;
25776 u32 src, dst;
25777
25778 adr = AREG((Opcode >> 0) & 7);
25779 AREG((Opcode >> 0) & 7) += 1;
25780 PRE_IO
25781 READ_BYTE_F(adr, src)
25782 res = DREGu8((Opcode >> 9) & 7);
25783 res |= src;
25784 flag_C = 0;
25785 flag_V = 0;
25786 flag_NotZ = res;
25787 flag_N = res;
25788 DREGu8((Opcode >> 9) & 7) = res;
25789 POST_IO
25790RET(8)
25791}
25792
25793// ORaD
25794OPCODE(0x8020)
25795{
25796 u32 adr, res;
25797 u32 src, dst;
25798
25799 adr = AREG((Opcode >> 0) & 7) - 1;
25800 AREG((Opcode >> 0) & 7) = adr;
25801 PRE_IO
25802 READ_BYTE_F(adr, src)
25803 res = DREGu8((Opcode >> 9) & 7);
25804 res |= src;
25805 flag_C = 0;
25806 flag_V = 0;
25807 flag_NotZ = res;
25808 flag_N = res;
25809 DREGu8((Opcode >> 9) & 7) = res;
25810 POST_IO
25811RET(10)
25812}
25813
25814// ORaD
25815OPCODE(0x8028)
25816{
25817 u32 adr, res;
25818 u32 src, dst;
25819
25820 FETCH_SWORD(adr);
25821 adr += AREG((Opcode >> 0) & 7);
25822 PRE_IO
25823 READ_BYTE_F(adr, src)
25824 res = DREGu8((Opcode >> 9) & 7);
25825 res |= src;
25826 flag_C = 0;
25827 flag_V = 0;
25828 flag_NotZ = res;
25829 flag_N = res;
25830 DREGu8((Opcode >> 9) & 7) = res;
25831 POST_IO
25832RET(12)
25833}
25834
25835// ORaD
25836OPCODE(0x8030)
25837{
25838 u32 adr, res;
25839 u32 src, dst;
25840
25841 adr = AREG((Opcode >> 0) & 7);
25842 DECODE_EXT_WORD
25843 PRE_IO
25844 READ_BYTE_F(adr, src)
25845 res = DREGu8((Opcode >> 9) & 7);
25846 res |= src;
25847 flag_C = 0;
25848 flag_V = 0;
25849 flag_NotZ = res;
25850 flag_N = res;
25851 DREGu8((Opcode >> 9) & 7) = res;
25852 POST_IO
25853RET(14)
25854}
25855
25856// ORaD
25857OPCODE(0x8038)
25858{
25859 u32 adr, res;
25860 u32 src, dst;
25861
25862 FETCH_SWORD(adr);
25863 PRE_IO
25864 READ_BYTE_F(adr, src)
25865 res = DREGu8((Opcode >> 9) & 7);
25866 res |= src;
25867 flag_C = 0;
25868 flag_V = 0;
25869 flag_NotZ = res;
25870 flag_N = res;
25871 DREGu8((Opcode >> 9) & 7) = res;
25872 POST_IO
25873RET(12)
25874}
25875
25876// ORaD
25877OPCODE(0x8039)
25878{
25879 u32 adr, res;
25880 u32 src, dst;
25881
25882 FETCH_LONG(adr);
25883 PRE_IO
25884 READ_BYTE_F(adr, src)
25885 res = DREGu8((Opcode >> 9) & 7);
25886 res |= src;
25887 flag_C = 0;
25888 flag_V = 0;
25889 flag_NotZ = res;
25890 flag_N = res;
25891 DREGu8((Opcode >> 9) & 7) = res;
25892 POST_IO
25893RET(16)
25894}
25895
25896// ORaD
25897OPCODE(0x803A)
25898{
25899 u32 adr, res;
25900 u32 src, dst;
25901
25902 adr = GET_SWORD + GET_PC;
25903 PC++;
25904 PRE_IO
25905 READ_BYTE_F(adr, src)
25906 res = DREGu8((Opcode >> 9) & 7);
25907 res |= src;
25908 flag_C = 0;
25909 flag_V = 0;
25910 flag_NotZ = res;
25911 flag_N = res;
25912 DREGu8((Opcode >> 9) & 7) = res;
25913 POST_IO
25914RET(12)
25915}
25916
25917// ORaD
25918OPCODE(0x803B)
25919{
25920 u32 adr, res;
25921 u32 src, dst;
25922
25923 adr = GET_PC;
25924 DECODE_EXT_WORD
25925 PRE_IO
25926 READ_BYTE_F(adr, src)
25927 res = DREGu8((Opcode >> 9) & 7);
25928 res |= src;
25929 flag_C = 0;
25930 flag_V = 0;
25931 flag_NotZ = res;
25932 flag_N = res;
25933 DREGu8((Opcode >> 9) & 7) = res;
25934 POST_IO
25935RET(14)
25936}
25937
25938// ORaD
25939OPCODE(0x803C)
25940{
25941 u32 adr, res;
25942 u32 src, dst;
25943
25944 FETCH_BYTE(src);
25945 res = DREGu8((Opcode >> 9) & 7);
25946 res |= src;
25947 flag_C = 0;
25948 flag_V = 0;
25949 flag_NotZ = res;
25950 flag_N = res;
25951 DREGu8((Opcode >> 9) & 7) = res;
25952RET(8)
25953}
25954
25955// ORaD
25956OPCODE(0x801F)
25957{
25958 u32 adr, res;
25959 u32 src, dst;
25960
25961 adr = AREG(7);
25962 AREG(7) += 2;
25963 PRE_IO
25964 READ_BYTE_F(adr, src)
25965 res = DREGu8((Opcode >> 9) & 7);
25966 res |= src;
25967 flag_C = 0;
25968 flag_V = 0;
25969 flag_NotZ = res;
25970 flag_N = res;
25971 DREGu8((Opcode >> 9) & 7) = res;
25972 POST_IO
25973RET(8)
25974}
25975
25976// ORaD
25977OPCODE(0x8027)
25978{
25979 u32 adr, res;
25980 u32 src, dst;
25981
25982 adr = AREG(7) - 2;
25983 AREG(7) = adr;
25984 PRE_IO
25985 READ_BYTE_F(adr, src)
25986 res = DREGu8((Opcode >> 9) & 7);
25987 res |= src;
25988 flag_C = 0;
25989 flag_V = 0;
25990 flag_NotZ = res;
25991 flag_N = res;
25992 DREGu8((Opcode >> 9) & 7) = res;
25993 POST_IO
25994RET(10)
25995}
25996
25997// ORaD
25998OPCODE(0x8040)
25999{
26000 u32 adr, res;
26001 u32 src, dst;
26002
26003 src = DREGu16((Opcode >> 0) & 7);
26004 res = DREGu16((Opcode >> 9) & 7);
26005 res |= src;
26006 flag_C = 0;
26007 flag_V = 0;
26008 flag_NotZ = res;
26009 flag_N = res >> 8;
26010 DREGu16((Opcode >> 9) & 7) = res;
26011RET(4)
26012}
26013
26014// ORaD
26015OPCODE(0x8050)
26016{
26017 u32 adr, res;
26018 u32 src, dst;
26019
26020 adr = AREG((Opcode >> 0) & 7);
26021 PRE_IO
26022 READ_WORD_F(adr, src)
26023 res = DREGu16((Opcode >> 9) & 7);
26024 res |= src;
26025 flag_C = 0;
26026 flag_V = 0;
26027 flag_NotZ = res;
26028 flag_N = res >> 8;
26029 DREGu16((Opcode >> 9) & 7) = res;
26030 POST_IO
26031RET(8)
26032}
26033
26034// ORaD
26035OPCODE(0x8058)
26036{
26037 u32 adr, res;
26038 u32 src, dst;
26039
26040 adr = AREG((Opcode >> 0) & 7);
26041 AREG((Opcode >> 0) & 7) += 2;
26042 PRE_IO
26043 READ_WORD_F(adr, src)
26044 res = DREGu16((Opcode >> 9) & 7);
26045 res |= src;
26046 flag_C = 0;
26047 flag_V = 0;
26048 flag_NotZ = res;
26049 flag_N = res >> 8;
26050 DREGu16((Opcode >> 9) & 7) = res;
26051 POST_IO
26052RET(8)
26053}
26054
26055// ORaD
26056OPCODE(0x8060)
26057{
26058 u32 adr, res;
26059 u32 src, dst;
26060
26061 adr = AREG((Opcode >> 0) & 7) - 2;
26062 AREG((Opcode >> 0) & 7) = adr;
26063 PRE_IO
26064 READ_WORD_F(adr, src)
26065 res = DREGu16((Opcode >> 9) & 7);
26066 res |= src;
26067 flag_C = 0;
26068 flag_V = 0;
26069 flag_NotZ = res;
26070 flag_N = res >> 8;
26071 DREGu16((Opcode >> 9) & 7) = res;
26072 POST_IO
26073RET(10)
26074}
26075
26076// ORaD
26077OPCODE(0x8068)
26078{
26079 u32 adr, res;
26080 u32 src, dst;
26081
26082 FETCH_SWORD(adr);
26083 adr += AREG((Opcode >> 0) & 7);
26084 PRE_IO
26085 READ_WORD_F(adr, src)
26086 res = DREGu16((Opcode >> 9) & 7);
26087 res |= src;
26088 flag_C = 0;
26089 flag_V = 0;
26090 flag_NotZ = res;
26091 flag_N = res >> 8;
26092 DREGu16((Opcode >> 9) & 7) = res;
26093 POST_IO
26094RET(12)
26095}
26096
26097// ORaD
26098OPCODE(0x8070)
26099{
26100 u32 adr, res;
26101 u32 src, dst;
26102
26103 adr = AREG((Opcode >> 0) & 7);
26104 DECODE_EXT_WORD
26105 PRE_IO
26106 READ_WORD_F(adr, src)
26107 res = DREGu16((Opcode >> 9) & 7);
26108 res |= src;
26109 flag_C = 0;
26110 flag_V = 0;
26111 flag_NotZ = res;
26112 flag_N = res >> 8;
26113 DREGu16((Opcode >> 9) & 7) = res;
26114 POST_IO
26115RET(14)
26116}
26117
26118// ORaD
26119OPCODE(0x8078)
26120{
26121 u32 adr, res;
26122 u32 src, dst;
26123
26124 FETCH_SWORD(adr);
26125 PRE_IO
26126 READ_WORD_F(adr, src)
26127 res = DREGu16((Opcode >> 9) & 7);
26128 res |= src;
26129 flag_C = 0;
26130 flag_V = 0;
26131 flag_NotZ = res;
26132 flag_N = res >> 8;
26133 DREGu16((Opcode >> 9) & 7) = res;
26134 POST_IO
26135RET(12)
26136}
26137
26138// ORaD
26139OPCODE(0x8079)
26140{
26141 u32 adr, res;
26142 u32 src, dst;
26143
26144 FETCH_LONG(adr);
26145 PRE_IO
26146 READ_WORD_F(adr, src)
26147 res = DREGu16((Opcode >> 9) & 7);
26148 res |= src;
26149 flag_C = 0;
26150 flag_V = 0;
26151 flag_NotZ = res;
26152 flag_N = res >> 8;
26153 DREGu16((Opcode >> 9) & 7) = res;
26154 POST_IO
26155RET(16)
26156}
26157
26158// ORaD
26159OPCODE(0x807A)
26160{
26161 u32 adr, res;
26162 u32 src, dst;
26163
26164 adr = GET_SWORD + GET_PC;
26165 PC++;
26166 PRE_IO
26167 READ_WORD_F(adr, src)
26168 res = DREGu16((Opcode >> 9) & 7);
26169 res |= src;
26170 flag_C = 0;
26171 flag_V = 0;
26172 flag_NotZ = res;
26173 flag_N = res >> 8;
26174 DREGu16((Opcode >> 9) & 7) = res;
26175 POST_IO
26176RET(12)
26177}
26178
26179// ORaD
26180OPCODE(0x807B)
26181{
26182 u32 adr, res;
26183 u32 src, dst;
26184
26185 adr = GET_PC;
26186 DECODE_EXT_WORD
26187 PRE_IO
26188 READ_WORD_F(adr, src)
26189 res = DREGu16((Opcode >> 9) & 7);
26190 res |= src;
26191 flag_C = 0;
26192 flag_V = 0;
26193 flag_NotZ = res;
26194 flag_N = res >> 8;
26195 DREGu16((Opcode >> 9) & 7) = res;
26196 POST_IO
26197RET(14)
26198}
26199
26200// ORaD
26201OPCODE(0x807C)
26202{
26203 u32 adr, res;
26204 u32 src, dst;
26205
26206 FETCH_WORD(src);
26207 res = DREGu16((Opcode >> 9) & 7);
26208 res |= src;
26209 flag_C = 0;
26210 flag_V = 0;
26211 flag_NotZ = res;
26212 flag_N = res >> 8;
26213 DREGu16((Opcode >> 9) & 7) = res;
26214RET(8)
26215}
26216
26217// ORaD
26218OPCODE(0x805F)
26219{
26220 u32 adr, res;
26221 u32 src, dst;
26222
26223 adr = AREG(7);
26224 AREG(7) += 2;
26225 PRE_IO
26226 READ_WORD_F(adr, src)
26227 res = DREGu16((Opcode >> 9) & 7);
26228 res |= src;
26229 flag_C = 0;
26230 flag_V = 0;
26231 flag_NotZ = res;
26232 flag_N = res >> 8;
26233 DREGu16((Opcode >> 9) & 7) = res;
26234 POST_IO
26235RET(8)
26236}
26237
26238// ORaD
26239OPCODE(0x8067)
26240{
26241 u32 adr, res;
26242 u32 src, dst;
26243
26244 adr = AREG(7) - 2;
26245 AREG(7) = adr;
26246 PRE_IO
26247 READ_WORD_F(adr, src)
26248 res = DREGu16((Opcode >> 9) & 7);
26249 res |= src;
26250 flag_C = 0;
26251 flag_V = 0;
26252 flag_NotZ = res;
26253 flag_N = res >> 8;
26254 DREGu16((Opcode >> 9) & 7) = res;
26255 POST_IO
26256RET(10)
26257}
26258
26259// ORaD
26260OPCODE(0x8080)
26261{
26262 u32 adr, res;
26263 u32 src, dst;
26264
26265 src = DREGu32((Opcode >> 0) & 7);
26266 res = DREGu32((Opcode >> 9) & 7);
26267 res |= src;
26268 flag_C = 0;
26269 flag_V = 0;
26270 flag_NotZ = res;
26271 flag_N = res >> 24;
26272 DREGu32((Opcode >> 9) & 7) = res;
26273RET(8)
26274}
26275
26276// ORaD
26277OPCODE(0x8090)
26278{
26279 u32 adr, res;
26280 u32 src, dst;
26281
26282 adr = AREG((Opcode >> 0) & 7);
26283 PRE_IO
26284 READ_LONG_F(adr, src)
26285 res = DREGu32((Opcode >> 9) & 7);
26286 res |= src;
26287 flag_C = 0;
26288 flag_V = 0;
26289 flag_NotZ = res;
26290 flag_N = res >> 24;
26291 DREGu32((Opcode >> 9) & 7) = res;
26292 POST_IO
26293RET(14)
26294}
26295
26296// ORaD
26297OPCODE(0x8098)
26298{
26299 u32 adr, res;
26300 u32 src, dst;
26301
26302 adr = AREG((Opcode >> 0) & 7);
26303 AREG((Opcode >> 0) & 7) += 4;
26304 PRE_IO
26305 READ_LONG_F(adr, src)
26306 res = DREGu32((Opcode >> 9) & 7);
26307 res |= src;
26308 flag_C = 0;
26309 flag_V = 0;
26310 flag_NotZ = res;
26311 flag_N = res >> 24;
26312 DREGu32((Opcode >> 9) & 7) = res;
26313 POST_IO
26314RET(14)
26315}
26316
26317// ORaD
26318OPCODE(0x80A0)
26319{
26320 u32 adr, res;
26321 u32 src, dst;
26322
26323 adr = AREG((Opcode >> 0) & 7) - 4;
26324 AREG((Opcode >> 0) & 7) = adr;
26325 PRE_IO
26326 READ_LONG_F(adr, src)
26327 res = DREGu32((Opcode >> 9) & 7);
26328 res |= src;
26329 flag_C = 0;
26330 flag_V = 0;
26331 flag_NotZ = res;
26332 flag_N = res >> 24;
26333 DREGu32((Opcode >> 9) & 7) = res;
26334 POST_IO
26335RET(16)
26336}
26337
26338// ORaD
26339OPCODE(0x80A8)
26340{
26341 u32 adr, res;
26342 u32 src, dst;
26343
26344 FETCH_SWORD(adr);
26345 adr += AREG((Opcode >> 0) & 7);
26346 PRE_IO
26347 READ_LONG_F(adr, src)
26348 res = DREGu32((Opcode >> 9) & 7);
26349 res |= src;
26350 flag_C = 0;
26351 flag_V = 0;
26352 flag_NotZ = res;
26353 flag_N = res >> 24;
26354 DREGu32((Opcode >> 9) & 7) = res;
26355 POST_IO
26356RET(18)
26357}
26358
26359// ORaD
26360OPCODE(0x80B0)
26361{
26362 u32 adr, res;
26363 u32 src, dst;
26364
26365 adr = AREG((Opcode >> 0) & 7);
26366 DECODE_EXT_WORD
26367 PRE_IO
26368 READ_LONG_F(adr, src)
26369 res = DREGu32((Opcode >> 9) & 7);
26370 res |= src;
26371 flag_C = 0;
26372 flag_V = 0;
26373 flag_NotZ = res;
26374 flag_N = res >> 24;
26375 DREGu32((Opcode >> 9) & 7) = res;
26376 POST_IO
26377RET(20)
26378}
26379
26380// ORaD
26381OPCODE(0x80B8)
26382{
26383 u32 adr, res;
26384 u32 src, dst;
26385
26386 FETCH_SWORD(adr);
26387 PRE_IO
26388 READ_LONG_F(adr, src)
26389 res = DREGu32((Opcode >> 9) & 7);
26390 res |= src;
26391 flag_C = 0;
26392 flag_V = 0;
26393 flag_NotZ = res;
26394 flag_N = res >> 24;
26395 DREGu32((Opcode >> 9) & 7) = res;
26396 POST_IO
26397RET(18)
26398}
26399
26400// ORaD
26401OPCODE(0x80B9)
26402{
26403 u32 adr, res;
26404 u32 src, dst;
26405
26406 FETCH_LONG(adr);
26407 PRE_IO
26408 READ_LONG_F(adr, src)
26409 res = DREGu32((Opcode >> 9) & 7);
26410 res |= src;
26411 flag_C = 0;
26412 flag_V = 0;
26413 flag_NotZ = res;
26414 flag_N = res >> 24;
26415 DREGu32((Opcode >> 9) & 7) = res;
26416 POST_IO
26417RET(22)
26418}
26419
26420// ORaD
26421OPCODE(0x80BA)
26422{
26423 u32 adr, res;
26424 u32 src, dst;
26425
26426 adr = GET_SWORD + GET_PC;
26427 PC++;
26428 PRE_IO
26429 READ_LONG_F(adr, src)
26430 res = DREGu32((Opcode >> 9) & 7);
26431 res |= src;
26432 flag_C = 0;
26433 flag_V = 0;
26434 flag_NotZ = res;
26435 flag_N = res >> 24;
26436 DREGu32((Opcode >> 9) & 7) = res;
26437 POST_IO
26438RET(18)
26439}
26440
26441// ORaD
26442OPCODE(0x80BB)
26443{
26444 u32 adr, res;
26445 u32 src, dst;
26446
26447 adr = GET_PC;
26448 DECODE_EXT_WORD
26449 PRE_IO
26450 READ_LONG_F(adr, src)
26451 res = DREGu32((Opcode >> 9) & 7);
26452 res |= src;
26453 flag_C = 0;
26454 flag_V = 0;
26455 flag_NotZ = res;
26456 flag_N = res >> 24;
26457 DREGu32((Opcode >> 9) & 7) = res;
26458 POST_IO
26459RET(20)
26460}
26461
26462// ORaD
26463OPCODE(0x80BC)
26464{
26465 u32 adr, res;
26466 u32 src, dst;
26467
26468 FETCH_LONG(src);
26469 res = DREGu32((Opcode >> 9) & 7);
26470 res |= src;
26471 flag_C = 0;
26472 flag_V = 0;
26473 flag_NotZ = res;
26474 flag_N = res >> 24;
26475 DREGu32((Opcode >> 9) & 7) = res;
26476RET(16)
26477}
26478
26479// ORaD
26480OPCODE(0x809F)
26481{
26482 u32 adr, res;
26483 u32 src, dst;
26484
26485 adr = AREG(7);
26486 AREG(7) += 4;
26487 PRE_IO
26488 READ_LONG_F(adr, src)
26489 res = DREGu32((Opcode >> 9) & 7);
26490 res |= src;
26491 flag_C = 0;
26492 flag_V = 0;
26493 flag_NotZ = res;
26494 flag_N = res >> 24;
26495 DREGu32((Opcode >> 9) & 7) = res;
26496 POST_IO
26497RET(14)
26498}
26499
26500// ORaD
26501OPCODE(0x80A7)
26502{
26503 u32 adr, res;
26504 u32 src, dst;
26505
26506 adr = AREG(7) - 4;
26507 AREG(7) = adr;
26508 PRE_IO
26509 READ_LONG_F(adr, src)
26510 res = DREGu32((Opcode >> 9) & 7);
26511 res |= src;
26512 flag_C = 0;
26513 flag_V = 0;
26514 flag_NotZ = res;
26515 flag_N = res >> 24;
26516 DREGu32((Opcode >> 9) & 7) = res;
26517 POST_IO
26518RET(16)
26519}
26520
26521// ORDa
26522OPCODE(0x8110)
26523{
26524 u32 adr, res;
26525 u32 src, dst;
26526
26527 src = DREGu8((Opcode >> 9) & 7);
26528 adr = AREG((Opcode >> 0) & 7);
26529 PRE_IO
26530 READ_BYTE_F(adr, res)
26531 res |= src;
26532 flag_C = 0;
26533 flag_V = 0;
26534 flag_NotZ = res;
26535 flag_N = res;
26536 WRITE_BYTE_F(adr, res)
26537 POST_IO
26538RET(12)
26539}
26540
26541// ORDa
26542OPCODE(0x8118)
26543{
26544 u32 adr, res;
26545 u32 src, dst;
26546
26547 src = DREGu8((Opcode >> 9) & 7);
26548 adr = AREG((Opcode >> 0) & 7);
26549 AREG((Opcode >> 0) & 7) += 1;
26550 PRE_IO
26551 READ_BYTE_F(adr, res)
26552 res |= src;
26553 flag_C = 0;
26554 flag_V = 0;
26555 flag_NotZ = res;
26556 flag_N = res;
26557 WRITE_BYTE_F(adr, res)
26558 POST_IO
26559RET(12)
26560}
26561
26562// ORDa
26563OPCODE(0x8120)
26564{
26565 u32 adr, res;
26566 u32 src, dst;
26567
26568 src = DREGu8((Opcode >> 9) & 7);
26569 adr = AREG((Opcode >> 0) & 7) - 1;
26570 AREG((Opcode >> 0) & 7) = adr;
26571 PRE_IO
26572 READ_BYTE_F(adr, res)
26573 res |= src;
26574 flag_C = 0;
26575 flag_V = 0;
26576 flag_NotZ = res;
26577 flag_N = res;
26578 WRITE_BYTE_F(adr, res)
26579 POST_IO
26580RET(14)
26581}
26582
26583// ORDa
26584OPCODE(0x8128)
26585{
26586 u32 adr, res;
26587 u32 src, dst;
26588
26589 src = DREGu8((Opcode >> 9) & 7);
26590 FETCH_SWORD(adr);
26591 adr += AREG((Opcode >> 0) & 7);
26592 PRE_IO
26593 READ_BYTE_F(adr, res)
26594 res |= src;
26595 flag_C = 0;
26596 flag_V = 0;
26597 flag_NotZ = res;
26598 flag_N = res;
26599 WRITE_BYTE_F(adr, res)
26600 POST_IO
26601RET(16)
26602}
26603
26604// ORDa
26605OPCODE(0x8130)
26606{
26607 u32 adr, res;
26608 u32 src, dst;
26609
26610 src = DREGu8((Opcode >> 9) & 7);
26611 adr = AREG((Opcode >> 0) & 7);
26612 DECODE_EXT_WORD
26613 PRE_IO
26614 READ_BYTE_F(adr, res)
26615 res |= src;
26616 flag_C = 0;
26617 flag_V = 0;
26618 flag_NotZ = res;
26619 flag_N = res;
26620 WRITE_BYTE_F(adr, res)
26621 POST_IO
26622RET(18)
26623}
26624
26625// ORDa
26626OPCODE(0x8138)
26627{
26628 u32 adr, res;
26629 u32 src, dst;
26630
26631 src = DREGu8((Opcode >> 9) & 7);
26632 FETCH_SWORD(adr);
26633 PRE_IO
26634 READ_BYTE_F(adr, res)
26635 res |= src;
26636 flag_C = 0;
26637 flag_V = 0;
26638 flag_NotZ = res;
26639 flag_N = res;
26640 WRITE_BYTE_F(adr, res)
26641 POST_IO
26642RET(16)
26643}
26644
26645// ORDa
26646OPCODE(0x8139)
26647{
26648 u32 adr, res;
26649 u32 src, dst;
26650
26651 src = DREGu8((Opcode >> 9) & 7);
26652 FETCH_LONG(adr);
26653 PRE_IO
26654 READ_BYTE_F(adr, res)
26655 res |= src;
26656 flag_C = 0;
26657 flag_V = 0;
26658 flag_NotZ = res;
26659 flag_N = res;
26660 WRITE_BYTE_F(adr, res)
26661 POST_IO
26662RET(20)
26663}
26664
26665// ORDa
26666OPCODE(0x811F)
26667{
26668 u32 adr, res;
26669 u32 src, dst;
26670
26671 src = DREGu8((Opcode >> 9) & 7);
26672 adr = AREG(7);
26673 AREG(7) += 2;
26674 PRE_IO
26675 READ_BYTE_F(adr, res)
26676 res |= src;
26677 flag_C = 0;
26678 flag_V = 0;
26679 flag_NotZ = res;
26680 flag_N = res;
26681 WRITE_BYTE_F(adr, res)
26682 POST_IO
26683RET(12)
26684}
26685
26686// ORDa
26687OPCODE(0x8127)
26688{
26689 u32 adr, res;
26690 u32 src, dst;
26691
26692 src = DREGu8((Opcode >> 9) & 7);
26693 adr = AREG(7) - 2;
26694 AREG(7) = adr;
26695 PRE_IO
26696 READ_BYTE_F(adr, res)
26697 res |= src;
26698 flag_C = 0;
26699 flag_V = 0;
26700 flag_NotZ = res;
26701 flag_N = res;
26702 WRITE_BYTE_F(adr, res)
26703 POST_IO
26704RET(14)
26705}
26706
26707// ORDa
26708OPCODE(0x8150)
26709{
26710 u32 adr, res;
26711 u32 src, dst;
26712
26713 src = DREGu16((Opcode >> 9) & 7);
26714 adr = AREG((Opcode >> 0) & 7);
26715 PRE_IO
26716 READ_WORD_F(adr, res)
26717 res |= src;
26718 flag_C = 0;
26719 flag_V = 0;
26720 flag_NotZ = res;
26721 flag_N = res >> 8;
26722 WRITE_WORD_F(adr, res)
26723 POST_IO
26724RET(12)
26725}
26726
26727// ORDa
26728OPCODE(0x8158)
26729{
26730 u32 adr, res;
26731 u32 src, dst;
26732
26733 src = DREGu16((Opcode >> 9) & 7);
26734 adr = AREG((Opcode >> 0) & 7);
26735 AREG((Opcode >> 0) & 7) += 2;
26736 PRE_IO
26737 READ_WORD_F(adr, res)
26738 res |= src;
26739 flag_C = 0;
26740 flag_V = 0;
26741 flag_NotZ = res;
26742 flag_N = res >> 8;
26743 WRITE_WORD_F(adr, res)
26744 POST_IO
26745RET(12)
26746}
26747
26748// ORDa
26749OPCODE(0x8160)
26750{
26751 u32 adr, res;
26752 u32 src, dst;
26753
26754 src = DREGu16((Opcode >> 9) & 7);
26755 adr = AREG((Opcode >> 0) & 7) - 2;
26756 AREG((Opcode >> 0) & 7) = adr;
26757 PRE_IO
26758 READ_WORD_F(adr, res)
26759 res |= src;
26760 flag_C = 0;
26761 flag_V = 0;
26762 flag_NotZ = res;
26763 flag_N = res >> 8;
26764 WRITE_WORD_F(adr, res)
26765 POST_IO
26766RET(14)
26767}
26768
26769// ORDa
26770OPCODE(0x8168)
26771{
26772 u32 adr, res;
26773 u32 src, dst;
26774
26775 src = DREGu16((Opcode >> 9) & 7);
26776 FETCH_SWORD(adr);
26777 adr += AREG((Opcode >> 0) & 7);
26778 PRE_IO
26779 READ_WORD_F(adr, res)
26780 res |= src;
26781 flag_C = 0;
26782 flag_V = 0;
26783 flag_NotZ = res;
26784 flag_N = res >> 8;
26785 WRITE_WORD_F(adr, res)
26786 POST_IO
26787RET(16)
26788}
26789
26790// ORDa
26791OPCODE(0x8170)
26792{
26793 u32 adr, res;
26794 u32 src, dst;
26795
26796 src = DREGu16((Opcode >> 9) & 7);
26797 adr = AREG((Opcode >> 0) & 7);
26798 DECODE_EXT_WORD
26799 PRE_IO
26800 READ_WORD_F(adr, res)
26801 res |= src;
26802 flag_C = 0;
26803 flag_V = 0;
26804 flag_NotZ = res;
26805 flag_N = res >> 8;
26806 WRITE_WORD_F(adr, res)
26807 POST_IO
26808RET(18)
26809}
26810
26811// ORDa
26812OPCODE(0x8178)
26813{
26814 u32 adr, res;
26815 u32 src, dst;
26816
26817 src = DREGu16((Opcode >> 9) & 7);
26818 FETCH_SWORD(adr);
26819 PRE_IO
26820 READ_WORD_F(adr, res)
26821 res |= src;
26822 flag_C = 0;
26823 flag_V = 0;
26824 flag_NotZ = res;
26825 flag_N = res >> 8;
26826 WRITE_WORD_F(adr, res)
26827 POST_IO
26828RET(16)
26829}
26830
26831// ORDa
26832OPCODE(0x8179)
26833{
26834 u32 adr, res;
26835 u32 src, dst;
26836
26837 src = DREGu16((Opcode >> 9) & 7);
26838 FETCH_LONG(adr);
26839 PRE_IO
26840 READ_WORD_F(adr, res)
26841 res |= src;
26842 flag_C = 0;
26843 flag_V = 0;
26844 flag_NotZ = res;
26845 flag_N = res >> 8;
26846 WRITE_WORD_F(adr, res)
26847 POST_IO
26848RET(20)
26849}
26850
26851// ORDa
26852OPCODE(0x815F)
26853{
26854 u32 adr, res;
26855 u32 src, dst;
26856
26857 src = DREGu16((Opcode >> 9) & 7);
26858 adr = AREG(7);
26859 AREG(7) += 2;
26860 PRE_IO
26861 READ_WORD_F(adr, res)
26862 res |= src;
26863 flag_C = 0;
26864 flag_V = 0;
26865 flag_NotZ = res;
26866 flag_N = res >> 8;
26867 WRITE_WORD_F(adr, res)
26868 POST_IO
26869RET(12)
26870}
26871
26872// ORDa
26873OPCODE(0x8167)
26874{
26875 u32 adr, res;
26876 u32 src, dst;
26877
26878 src = DREGu16((Opcode >> 9) & 7);
26879 adr = AREG(7) - 2;
26880 AREG(7) = adr;
26881 PRE_IO
26882 READ_WORD_F(adr, res)
26883 res |= src;
26884 flag_C = 0;
26885 flag_V = 0;
26886 flag_NotZ = res;
26887 flag_N = res >> 8;
26888 WRITE_WORD_F(adr, res)
26889 POST_IO
26890RET(14)
26891}
26892
26893// ORDa
26894OPCODE(0x8190)
26895{
26896 u32 adr, res;
26897 u32 src, dst;
26898
26899 src = DREGu32((Opcode >> 9) & 7);
26900 adr = AREG((Opcode >> 0) & 7);
26901 PRE_IO
26902 READ_LONG_F(adr, res)
26903 res |= src;
26904 flag_C = 0;
26905 flag_V = 0;
26906 flag_NotZ = res;
26907 flag_N = res >> 24;
26908 WRITE_LONG_F(adr, res)
26909 POST_IO
26910RET(20)
26911}
26912
26913// ORDa
26914OPCODE(0x8198)
26915{
26916 u32 adr, res;
26917 u32 src, dst;
26918
26919 src = DREGu32((Opcode >> 9) & 7);
26920 adr = AREG((Opcode >> 0) & 7);
26921 AREG((Opcode >> 0) & 7) += 4;
26922 PRE_IO
26923 READ_LONG_F(adr, res)
26924 res |= src;
26925 flag_C = 0;
26926 flag_V = 0;
26927 flag_NotZ = res;
26928 flag_N = res >> 24;
26929 WRITE_LONG_F(adr, res)
26930 POST_IO
26931RET(20)
26932}
26933
26934// ORDa
26935OPCODE(0x81A0)
26936{
26937 u32 adr, res;
26938 u32 src, dst;
26939
26940 src = DREGu32((Opcode >> 9) & 7);
26941 adr = AREG((Opcode >> 0) & 7) - 4;
26942 AREG((Opcode >> 0) & 7) = adr;
26943 PRE_IO
26944 READ_LONG_F(adr, res)
26945 res |= src;
26946 flag_C = 0;
26947 flag_V = 0;
26948 flag_NotZ = res;
26949 flag_N = res >> 24;
26950 WRITE_LONG_F(adr, res)
26951 POST_IO
26952RET(22)
26953}
26954
26955// ORDa
26956OPCODE(0x81A8)
26957{
26958 u32 adr, res;
26959 u32 src, dst;
26960
26961 src = DREGu32((Opcode >> 9) & 7);
26962 FETCH_SWORD(adr);
26963 adr += AREG((Opcode >> 0) & 7);
26964 PRE_IO
26965 READ_LONG_F(adr, res)
26966 res |= src;
26967 flag_C = 0;
26968 flag_V = 0;
26969 flag_NotZ = res;
26970 flag_N = res >> 24;
26971 WRITE_LONG_F(adr, res)
26972 POST_IO
26973RET(24)
26974}
26975
26976// ORDa
26977OPCODE(0x81B0)
26978{
26979 u32 adr, res;
26980 u32 src, dst;
26981
26982 src = DREGu32((Opcode >> 9) & 7);
26983 adr = AREG((Opcode >> 0) & 7);
26984 DECODE_EXT_WORD
26985 PRE_IO
26986 READ_LONG_F(adr, res)
26987 res |= src;
26988 flag_C = 0;
26989 flag_V = 0;
26990 flag_NotZ = res;
26991 flag_N = res >> 24;
26992 WRITE_LONG_F(adr, res)
26993 POST_IO
26994RET(26)
26995}
26996
26997// ORDa
26998OPCODE(0x81B8)
26999{
27000 u32 adr, res;
27001 u32 src, dst;
27002
27003 src = DREGu32((Opcode >> 9) & 7);
27004 FETCH_SWORD(adr);
27005 PRE_IO
27006 READ_LONG_F(adr, res)
27007 res |= src;
27008 flag_C = 0;
27009 flag_V = 0;
27010 flag_NotZ = res;
27011 flag_N = res >> 24;
27012 WRITE_LONG_F(adr, res)
27013 POST_IO
27014RET(24)
27015}
27016
27017// ORDa
27018OPCODE(0x81B9)
27019{
27020 u32 adr, res;
27021 u32 src, dst;
27022
27023 src = DREGu32((Opcode >> 9) & 7);
27024 FETCH_LONG(adr);
27025 PRE_IO
27026 READ_LONG_F(adr, res)
27027 res |= src;
27028 flag_C = 0;
27029 flag_V = 0;
27030 flag_NotZ = res;
27031 flag_N = res >> 24;
27032 WRITE_LONG_F(adr, res)
27033 POST_IO
27034RET(28)
27035}
27036
27037// ORDa
27038OPCODE(0x819F)
27039{
27040 u32 adr, res;
27041 u32 src, dst;
27042
27043 src = DREGu32((Opcode >> 9) & 7);
27044 adr = AREG(7);
27045 AREG(7) += 4;
27046 PRE_IO
27047 READ_LONG_F(adr, res)
27048 res |= src;
27049 flag_C = 0;
27050 flag_V = 0;
27051 flag_NotZ = res;
27052 flag_N = res >> 24;
27053 WRITE_LONG_F(adr, res)
27054 POST_IO
27055RET(20)
27056}
27057
27058// ORDa
27059OPCODE(0x81A7)
27060{
27061 u32 adr, res;
27062 u32 src, dst;
27063
27064 src = DREGu32((Opcode >> 9) & 7);
27065 adr = AREG(7) - 4;
27066 AREG(7) = adr;
27067 PRE_IO
27068 READ_LONG_F(adr, res)
27069 res |= src;
27070 flag_C = 0;
27071 flag_V = 0;
27072 flag_NotZ = res;
27073 flag_N = res >> 24;
27074 WRITE_LONG_F(adr, res)
27075 POST_IO
27076RET(22)
27077}
27078
27079// SBCD
27080OPCODE(0x8100)
27081{
27082 u32 adr, res;
27083 u32 src, dst;
27084 u32 corf = 0;
27085
27086 src = DREGu8((Opcode >> 0) & 7);
27087 dst = DREGu8((Opcode >> 9) & 7);
27088 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27089 if (res > 0xF) corf = 6;
27090 res += (dst & 0xF0) - (src & 0xF0);
27091 flag_V = res;
27092 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27093 if (res > 0xff) res += 0xA0;
27094 res = (res - corf) & 0xFF;
27095 flag_V &= ~res;
27096 flag_NotZ |= res;
27097 flag_N = res;
27098 DREGu8((Opcode >> 9) & 7) = res;
27099RET(6)
27100}
27101
27102// SBCDM
27103OPCODE(0x8108)
27104{
27105 u32 adr, res;
27106 u32 src, dst;
27107 u32 corf = 0;
27108
27109 adr = AREG((Opcode >> 0) & 7) - 1;
27110 AREG((Opcode >> 0) & 7) = adr;
27111 PRE_IO
27112 READ_BYTE_F(adr, src)
27113 adr = AREG((Opcode >> 9) & 7) - 1;
27114 AREG((Opcode >> 9) & 7) = adr;
27115 READ_BYTE_F(adr, dst)
27116 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27117 if (res > 0xF) corf = 6;
27118 res += (dst & 0xF0) - (src & 0xF0);
27119 flag_V = res;
27120 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27121 if (res > 0xff) res += 0xA0;
27122 res = (res - corf) & 0xFF;
27123 flag_V &= ~res;
27124 flag_NotZ |= res;
27125 flag_N = res;
27126 WRITE_BYTE_F(adr, res)
27127 POST_IO
27128RET(18)
27129}
27130
27131// SBCD7M
27132OPCODE(0x810F)
27133{
27134 u32 adr, res;
27135 u32 src, dst;
27136 u32 corf = 0;
27137
27138 adr = AREG(7) - 2;
27139 AREG(7) = adr;
27140 PRE_IO
27141 READ_BYTE_F(adr, src)
27142 adr = AREG((Opcode >> 9) & 7) - 1;
27143 AREG((Opcode >> 9) & 7) = adr;
27144 READ_BYTE_F(adr, dst)
27145 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27146 if (res > 0xF) corf = 6;
27147 res += (dst & 0xF0) - (src & 0xF0);
27148 flag_V = res;
27149 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27150 if (res > 0xff) res += 0xA0;
27151 res = (res - corf) & 0xFF;
27152 flag_V &= ~res;
27153 flag_NotZ |= res;
27154 flag_N = res;
27155 WRITE_BYTE_F(adr, res)
27156 POST_IO
27157RET(18)
27158}
27159
27160// SBCDM7
27161OPCODE(0x8F08)
27162{
27163 u32 adr, res;
27164 u32 src, dst;
27165 u32 corf = 0;
27166
27167 adr = AREG((Opcode >> 0) & 7) - 1;
27168 AREG((Opcode >> 0) & 7) = adr;
27169 PRE_IO
27170 READ_BYTE_F(adr, src)
27171 adr = AREG(7) - 2;
27172 AREG(7) = adr;
27173 READ_BYTE_F(adr, dst)
27174 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27175 if (res > 0xF) corf = 6;
27176 res += (dst & 0xF0) - (src & 0xF0);
27177 flag_V = res;
27178 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27179 if (res > 0xff) res += 0xA0;
27180 res = (res - corf) & 0xFF;
27181 flag_V &= ~res;
27182 flag_NotZ |= res;
27183 flag_N = res;
27184 WRITE_BYTE_F(adr, res)
27185 POST_IO
27186RET(18)
27187}
27188
27189// SBCD7M7
27190OPCODE(0x8F0F)
27191{
27192 u32 adr, res;
27193 u32 src, dst;
27194 u32 corf = 0;
27195
27196 adr = AREG(7) - 2;
27197 AREG(7) = adr;
27198 PRE_IO
27199 READ_BYTE_F(adr, src)
27200 adr = AREG(7) - 2;
27201 AREG(7) = adr;
27202 READ_BYTE_F(adr, dst)
27203 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27204 if (res > 0xF) corf = 6;
27205 res += (dst & 0xF0) - (src & 0xF0);
27206 flag_V = res;
27207 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27208 if (res > 0xff) res += 0xA0;
27209 res = (res - corf) & 0xFF;
27210 flag_V &= ~res;
27211 flag_NotZ |= res;
27212 flag_N = res;
27213 WRITE_BYTE_F(adr, res)
27214 POST_IO
27215RET(18)
27216}
27217
27218// DIVU
27219OPCODE(0x80C0)
27220{
27221 u32 adr, res;
27222 u32 src, dst;
27223
27224 src = DREGu16((Opcode >> 0) & 7);
27225 if (src == 0)
27226 {
27227 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27228#ifdef USE_CYCLONE_TIMING_DIV
27229RET(4)
27230#else
27231RET(14)
27232#endif
27233 }
27234 dst = DREGu32((Opcode >> 9) & 7);
27235 {
27236 u32 q, r;
27237
27238 q = dst / src;
27239 r = dst % src;
27240
27241 if (q & 0xFFFF0000)
27242 {
27243 flag_V = M68K_SR_V;
27244#ifdef USE_CYCLONE_TIMING_DIV
27245RET(10)
27246#else
27247RET(70)
27248#endif
27249 }
27250 q &= 0x0000FFFF;
27251 flag_NotZ = q;
27252 flag_N = q >> 8;
27253 flag_V = flag_C = 0;
27254 res = q | (r << 16);
27255 DREGu32((Opcode >> 9) & 7) = res;
27256#ifdef USE_CYCLONE_TIMING_DIV
27257RET(138-BITCOUNT(res,q)*2)
27258#else
27259RET(90)
27260#endif
27261 }
27262}
27263
27264// DIVU
27265OPCODE(0x80D0)
27266{
27267 u32 adr, res;
27268 u32 src, dst;
27269
27270 adr = AREG((Opcode >> 0) & 7);
27271 PRE_IO
27272 READ_WORD_F(adr, src)
27273 if (src == 0)
27274 {
27275 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27276#ifdef USE_CYCLONE_TIMING_DIV
27277RET(8)
27278#else
27279RET(18)
27280#endif
27281 }
27282 dst = DREGu32((Opcode >> 9) & 7);
27283 {
27284 u32 q, r;
27285
27286 q = dst / src;
27287 r = dst % src;
27288
27289 if (q & 0xFFFF0000)
27290 {
27291 flag_V = M68K_SR_V;
27292#ifdef USE_CYCLONE_TIMING_DIV
27293RET(14)
27294#else
27295 RET(74)
27296#endif
27297 }
27298 q &= 0x0000FFFF;
27299 flag_NotZ = q;
27300 flag_N = q >> 8;
27301 flag_V = flag_C = 0;
27302 res = q | (r << 16);
27303 DREGu32((Opcode >> 9) & 7) = res;
27304#ifdef USE_CYCLONE_TIMING_DIV
27305RET(142-BITCOUNT(res,q)*2)
27306#else
27307RET(94)
27308#endif
27309 }
27310}
27311
27312// DIVU
27313OPCODE(0x80D8)
27314{
27315 u32 adr, res;
27316 u32 src, dst;
27317
27318 adr = AREG((Opcode >> 0) & 7);
27319 AREG((Opcode >> 0) & 7) += 2;
27320 PRE_IO
27321 READ_WORD_F(adr, src)
27322 if (src == 0)
27323 {
27324 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27325#ifdef USE_CYCLONE_TIMING_DIV
27326RET(8)
27327#else
27328RET(18)
27329#endif
27330 }
27331 dst = DREGu32((Opcode >> 9) & 7);
27332 {
27333 u32 q, r;
27334
27335 q = dst / src;
27336 r = dst % src;
27337
27338 if (q & 0xFFFF0000)
27339 {
27340 flag_V = M68K_SR_V;
27341#ifdef USE_CYCLONE_TIMING_DIV
27342RET(14)
27343#else
27344 RET(74)
27345#endif
27346 }
27347 q &= 0x0000FFFF;
27348 flag_NotZ = q;
27349 flag_N = q >> 8;
27350 flag_V = flag_C = 0;
27351 res = q | (r << 16);
27352 DREGu32((Opcode >> 9) & 7) = res;
27353#ifdef USE_CYCLONE_TIMING_DIV
27354RET(142-BITCOUNT(res,q)*2)
27355#else
27356RET(94)
27357#endif
27358 }
27359}
27360
27361// DIVU
27362OPCODE(0x80E0)
27363{
27364 u32 adr, res;
27365 u32 src, dst;
27366
27367 adr = AREG((Opcode >> 0) & 7) - 2;
27368 AREG((Opcode >> 0) & 7) = adr;
27369 PRE_IO
27370 READ_WORD_F(adr, src)
27371 if (src == 0)
27372 {
27373 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27374#ifdef USE_CYCLONE_TIMING_DIV
27375RET(10)
27376#else
27377RET(20)
27378#endif
27379 }
27380 dst = DREGu32((Opcode >> 9) & 7);
27381 {
27382 u32 q, r;
27383
27384 q = dst / src;
27385 r = dst % src;
27386
27387 if (q & 0xFFFF0000)
27388 {
27389 flag_V = M68K_SR_V;
27390#ifdef USE_CYCLONE_TIMING_DIV
27391RET(16)
27392#else
27393 RET(76)
27394#endif
27395 }
27396 q &= 0x0000FFFF;
27397 flag_NotZ = q;
27398 flag_N = q >> 8;
27399 flag_V = flag_C = 0;
27400 res = q | (r << 16);
27401 DREGu32((Opcode >> 9) & 7) = res;
27402#ifdef USE_CYCLONE_TIMING_DIV
27403RET(144-BITCOUNT(res,q)*2)
27404#else
27405RET(96)
27406#endif
27407 }
27408}
27409
27410// DIVU
27411OPCODE(0x80E8)
27412{
27413 u32 adr, res;
27414 u32 src, dst;
27415
27416 FETCH_SWORD(adr);
27417 adr += AREG((Opcode >> 0) & 7);
27418 PRE_IO
27419 READ_WORD_F(adr, src)
27420 if (src == 0)
27421 {
27422 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27423#ifdef USE_CYCLONE_TIMING_DIV
27424RET(12)
27425#else
27426RET(22)
27427#endif
27428 }
27429 dst = DREGu32((Opcode >> 9) & 7);
27430 {
27431 u32 q, r;
27432
27433 q = dst / src;
27434 r = dst % src;
27435
27436 if (q & 0xFFFF0000)
27437 {
27438 flag_V = M68K_SR_V;
27439#ifdef USE_CYCLONE_TIMING_DIV
27440RET(18)
27441#else
27442 RET(78)
27443#endif
27444 }
27445 q &= 0x0000FFFF;
27446 flag_NotZ = q;
27447 flag_N = q >> 8;
27448 flag_V = flag_C = 0;
27449 res = q | (r << 16);
27450 DREGu32((Opcode >> 9) & 7) = res;
27451#ifdef USE_CYCLONE_TIMING_DIV
27452RET(146-BITCOUNT(res,q)*2)
27453#else
27454RET(98)
27455#endif
27456 }
27457}
27458
27459// DIVU
27460OPCODE(0x80F0)
27461{
27462 u32 adr, res;
27463 u32 src, dst;
27464
27465 adr = AREG((Opcode >> 0) & 7);
27466 DECODE_EXT_WORD
27467 PRE_IO
27468 READ_WORD_F(adr, src)
27469 if (src == 0)
27470 {
27471 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27472#ifdef USE_CYCLONE_TIMING_DIV
27473RET(14)
27474#else
27475RET(24)
27476#endif
27477 }
27478 dst = DREGu32((Opcode >> 9) & 7);
27479 {
27480 u32 q, r;
27481
27482 q = dst / src;
27483 r = dst % src;
27484
27485 if (q & 0xFFFF0000)
27486 {
27487 flag_V = M68K_SR_V;
27488#ifdef USE_CYCLONE_TIMING_DIV
27489RET(20)
27490#else
27491 RET(80)
27492#endif
27493 }
27494 q &= 0x0000FFFF;
27495 flag_NotZ = q;
27496 flag_N = q >> 8;
27497 flag_V = flag_C = 0;
27498 res = q | (r << 16);
27499 DREGu32((Opcode >> 9) & 7) = res;
27500#ifdef USE_CYCLONE_TIMING_DIV
27501RET(148-BITCOUNT(res,q)*2)
27502#else
27503RET(100)
27504#endif
27505 }
27506}
27507
27508// DIVU
27509OPCODE(0x80F8)
27510{
27511 u32 adr, res;
27512 u32 src, dst;
27513
27514 FETCH_SWORD(adr);
27515 PRE_IO
27516 READ_WORD_F(adr, src)
27517 if (src == 0)
27518 {
27519 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27520#ifdef USE_CYCLONE_TIMING_DIV
27521RET(12)
27522#else
27523RET(22)
27524#endif
27525 }
27526 dst = DREGu32((Opcode >> 9) & 7);
27527 {
27528 u32 q, r;
27529
27530 q = dst / src;
27531 r = dst % src;
27532
27533 if (q & 0xFFFF0000)
27534 {
27535 flag_V = M68K_SR_V;
27536#ifdef USE_CYCLONE_TIMING_DIV
27537RET(18)
27538#else
27539 RET(78)
27540#endif
27541 }
27542 q &= 0x0000FFFF;
27543 flag_NotZ = q;
27544 flag_N = q >> 8;
27545 flag_V = flag_C = 0;
27546 res = q | (r << 16);
27547 DREGu32((Opcode >> 9) & 7) = res;
27548#ifdef USE_CYCLONE_TIMING_DIV
27549RET(146-BITCOUNT(res,q)*2)
27550#else
27551RET(98)
27552#endif
27553 }
27554}
27555
27556// DIVU
27557OPCODE(0x80F9)
27558{
27559 u32 adr, res;
27560 u32 src, dst;
27561
27562 FETCH_LONG(adr);
27563 PRE_IO
27564 READ_WORD_F(adr, src)
27565 if (src == 0)
27566 {
27567 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27568#ifdef USE_CYCLONE_TIMING_DIV
27569RET(16)
27570#else
27571RET(26)
27572#endif
27573 }
27574 dst = DREGu32((Opcode >> 9) & 7);
27575 {
27576 u32 q, r;
27577
27578 q = dst / src;
27579 r = dst % src;
27580
27581 if (q & 0xFFFF0000)
27582 {
27583 flag_V = M68K_SR_V;
27584#ifdef USE_CYCLONE_TIMING_DIV
27585RET(22)
27586#else
27587 RET(82)
27588#endif
27589 }
27590 q &= 0x0000FFFF;
27591 flag_NotZ = q;
27592 flag_N = q >> 8;
27593 flag_V = flag_C = 0;
27594 res = q | (r << 16);
27595 DREGu32((Opcode >> 9) & 7) = res;
27596#ifdef USE_CYCLONE_TIMING_DIV
27597RET(150-BITCOUNT(res,q)*2)
27598#else
27599RET(102)
27600#endif
27601 }
27602}
27603
27604// DIVU
27605OPCODE(0x80FA)
27606{
27607 u32 adr, res;
27608 u32 src, dst;
27609
27610 adr = GET_SWORD + GET_PC;
27611 PC++;
27612 PRE_IO
27613 READ_WORD_F(adr, src)
27614 if (src == 0)
27615 {
27616 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27617#ifdef USE_CYCLONE_TIMING_DIV
27618RET(12)
27619#else
27620RET(22)
27621#endif
27622 }
27623 dst = DREGu32((Opcode >> 9) & 7);
27624 {
27625 u32 q, r;
27626
27627 q = dst / src;
27628 r = dst % src;
27629
27630 if (q & 0xFFFF0000)
27631 {
27632 flag_V = M68K_SR_V;
27633#ifdef USE_CYCLONE_TIMING_DIV
27634RET(18)
27635#else
27636 RET(78)
27637#endif
27638 }
27639 q &= 0x0000FFFF;
27640 flag_NotZ = q;
27641 flag_N = q >> 8;
27642 flag_V = flag_C = 0;
27643 res = q | (r << 16);
27644 DREGu32((Opcode >> 9) & 7) = res;
27645#ifdef USE_CYCLONE_TIMING_DIV
27646RET(146-BITCOUNT(res,q)*2)
27647#else
27648RET(98)
27649#endif
27650 }
27651}
27652
27653// DIVU
27654OPCODE(0x80FB)
27655{
27656 u32 adr, res;
27657 u32 src, dst;
27658
27659 adr = GET_PC;
27660 DECODE_EXT_WORD
27661 PRE_IO
27662 READ_WORD_F(adr, src)
27663 if (src == 0)
27664 {
27665 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27666#ifdef USE_CYCLONE_TIMING_DIV
27667RET(14)
27668#else
27669RET(24)
27670#endif
27671 }
27672 dst = DREGu32((Opcode >> 9) & 7);
27673 {
27674 u32 q, r;
27675
27676 q = dst / src;
27677 r = dst % src;
27678
27679 if (q & 0xFFFF0000)
27680 {
27681 flag_V = M68K_SR_V;
27682#ifdef USE_CYCLONE_TIMING_DIV
27683RET(20)
27684#else
27685 RET(80)
27686#endif
27687 }
27688 q &= 0x0000FFFF;
27689 flag_NotZ = q;
27690 flag_N = q >> 8;
27691 flag_V = flag_C = 0;
27692 res = q | (r << 16);
27693 DREGu32((Opcode >> 9) & 7) = res;
27694#ifdef USE_CYCLONE_TIMING_DIV
27695RET(148-BITCOUNT(res,q)*2)
27696#else
27697RET(100)
27698#endif
27699 }
27700}
27701
27702// DIVU
27703OPCODE(0x80FC)
27704{
27705 u32 adr, res;
27706 u32 src, dst;
27707
27708 FETCH_WORD(src);
27709 if (src == 0)
27710 {
27711 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27712#ifdef USE_CYCLONE_TIMING_DIV
27713RET(8)
27714#else
27715RET(18)
27716#endif
27717 }
27718 dst = DREGu32((Opcode >> 9) & 7);
27719 {
27720 u32 q, r;
27721
27722 q = dst / src;
27723 r = dst % src;
27724
27725 if (q & 0xFFFF0000)
27726 {
27727 flag_V = M68K_SR_V;
27728#ifdef USE_CYCLONE_TIMING_DIV
27729RET(14)
27730#else
27731 RET(74)
27732#endif
27733 }
27734 q &= 0x0000FFFF;
27735 flag_NotZ = q;
27736 flag_N = q >> 8;
27737 flag_V = flag_C = 0;
27738 res = q | (r << 16);
27739 DREGu32((Opcode >> 9) & 7) = res;
27740#ifdef USE_CYCLONE_TIMING_DIV
27741RET(142-BITCOUNT(res,q)*2)
27742#else
27743RET(94)
27744#endif
27745 }
27746}
27747
27748// DIVU
27749OPCODE(0x80DF)
27750{
27751 u32 adr, res;
27752 u32 src, dst;
27753
27754 adr = AREG(7);
27755 AREG(7) += 2;
27756 PRE_IO
27757 READ_WORD_F(adr, src)
27758 if (src == 0)
27759 {
27760 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27761#ifdef USE_CYCLONE_TIMING_DIV
27762RET(8)
27763#else
27764RET(18)
27765#endif
27766 }
27767 dst = DREGu32((Opcode >> 9) & 7);
27768 {
27769 u32 q, r;
27770
27771 q = dst / src;
27772 r = dst % src;
27773
27774 if (q & 0xFFFF0000)
27775 {
27776 flag_V = M68K_SR_V;
27777#ifdef USE_CYCLONE_TIMING_DIV
27778RET(14)
27779#else
27780 RET(74)
27781#endif
27782 }
27783 q &= 0x0000FFFF;
27784 flag_NotZ = q;
27785 flag_N = q >> 8;
27786 flag_V = flag_C = 0;
27787 res = q | (r << 16);
27788 DREGu32((Opcode >> 9) & 7) = res;
27789#ifdef USE_CYCLONE_TIMING_DIV
27790RET(142-BITCOUNT(res,q)*2)
27791#else
27792RET(94)
27793#endif
27794 }
27795}
27796
27797// DIVU
27798OPCODE(0x80E7)
27799{
27800 u32 adr, res;
27801 u32 src, dst;
27802
27803 adr = AREG(7) - 2;
27804 AREG(7) = adr;
27805 PRE_IO
27806 READ_WORD_F(adr, src)
27807 if (src == 0)
27808 {
27809 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27810#ifdef USE_CYCLONE_TIMING_DIV
27811RET(10)
27812#else
27813RET(20)
27814#endif
27815 }
27816 dst = DREGu32((Opcode >> 9) & 7);
27817 {
27818 u32 q, r;
27819
27820 q = dst / src;
27821 r = dst % src;
27822
27823 if (q & 0xFFFF0000)
27824 {
27825 flag_V = M68K_SR_V;
27826#ifdef USE_CYCLONE_TIMING_DIV
27827RET(16)
27828#else
27829 RET(76)
27830#endif
27831 }
27832 q &= 0x0000FFFF;
27833 flag_NotZ = q;
27834 flag_N = q >> 8;
27835 flag_V = flag_C = 0;
27836 res = q | (r << 16);
27837 DREGu32((Opcode >> 9) & 7) = res;
27838#ifdef USE_CYCLONE_TIMING_DIV
27839RET(144-BITCOUNT(res,q)*2)
27840#else
27841RET(96)
27842#endif
27843 }
27844}
27845
27846// DIVS
27847OPCODE(0x81C0)
27848{
27849 u32 adr, res;
27850 u32 src, dst;
27851
27852 src = (s32)DREGs16((Opcode >> 0) & 7);
27853 if (src == 0)
27854 {
27855 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27856#ifdef USE_CYCLONE_TIMING_DIV
27857RET(4)
27858#else
27859 RET(14)
27860#endif
27861 }
27862 dst = DREGu32((Opcode >> 9) & 7);
27863 if ((dst == 0x80000000) && (src == (u32)-1))
27864 {
27865 flag_NotZ = flag_N = 0;
27866 flag_V = flag_C = 0;
27867 res = 0;
27868 DREGu32((Opcode >> 9) & 7) = res;
27869#ifdef USE_CYCLONE_TIMING_DIV
27870RET(16+(dst>>31)*2)
27871#else
27872 RET(50)
27873#endif
27874 }
27875 {
27876 s32 q, r;
27877
27878 q = (s32)dst / (s32)src;
27879 r = (s32)dst % (s32)src;
27880
27881 if ((q > 0x7FFF) || (q < -0x8000))
27882 {
27883 flag_V = M68K_SR_V;
27884#ifdef USE_CYCLONE_TIMING_DIV
27885if (q > 0xFFFF || q < -0x10000) {
27886 RET(16+(dst>>31)*2)
27887} else RET(152+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
27888#else
27889 RET(80)
27890#endif
27891 }
27892 q &= 0x0000FFFF;
27893 flag_NotZ = q;
27894 flag_N = q >> 8;
27895 flag_V = flag_C = 0;
27896 res = q | (r << 16);
27897 DREGu32((Opcode >> 9) & 7) = res;
27898#ifdef USE_CYCLONE_TIMING_DIV
27899RET(152+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
27900#else
27901RET(108)
27902#endif
27903 }
27904}
27905
27906// DIVS
27907OPCODE(0x81D0)
27908{
27909 u32 adr, res;
27910 u32 src, dst;
27911
27912 adr = AREG((Opcode >> 0) & 7);
27913 PRE_IO
27914 READSX_WORD_F(adr, src)
27915 if (src == 0)
27916 {
27917 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27918#ifdef USE_CYCLONE_TIMING_DIV
27919RET(8)
27920#else
27921 RET(18)
27922#endif
27923 }
27924 dst = DREGu32((Opcode >> 9) & 7);
27925 if ((dst == 0x80000000) && (src == (u32)-1))
27926 {
27927 flag_NotZ = flag_N = 0;
27928 flag_V = flag_C = 0;
27929 res = 0;
27930 DREGu32((Opcode >> 9) & 7) = res;
27931#ifdef USE_CYCLONE_TIMING_DIV
27932RET(20+(dst>>31)*2)
27933#else
27934 RET(54)
27935#endif
27936 }
27937 {
27938 s32 q, r;
27939
27940 q = (s32)dst / (s32)src;
27941 r = (s32)dst % (s32)src;
27942
27943 if ((q > 0x7FFF) || (q < -0x8000))
27944 {
27945 flag_V = M68K_SR_V;
27946#ifdef USE_CYCLONE_TIMING_DIV
27947if (q > 0xFFFF || q < -0x10000) {
27948 RET(20+(dst>>31)*2)
27949} else RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
27950#else
27951 RET(84)
27952#endif
27953 }
27954 q &= 0x0000FFFF;
27955 flag_NotZ = q;
27956 flag_N = q >> 8;
27957 flag_V = flag_C = 0;
27958 res = q | (r << 16);
27959 DREGu32((Opcode >> 9) & 7) = res;
27960#ifdef USE_CYCLONE_TIMING_DIV
27961RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
27962#else
27963RET(112)
27964#endif
27965 }
27966}
27967
27968// DIVS
27969OPCODE(0x81D8)
27970{
27971 u32 adr, res;
27972 u32 src, dst;
27973
27974 adr = AREG((Opcode >> 0) & 7);
27975 AREG((Opcode >> 0) & 7) += 2;
27976 PRE_IO
27977 READSX_WORD_F(adr, src)
27978 if (src == 0)
27979 {
27980 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
27981#ifdef USE_CYCLONE_TIMING_DIV
27982RET(8)
27983#else
27984 RET(18)
27985#endif
27986 }
27987 dst = DREGu32((Opcode >> 9) & 7);
27988 if ((dst == 0x80000000) && (src == (u32)-1))
27989 {
27990 flag_NotZ = flag_N = 0;
27991 flag_V = flag_C = 0;
27992 res = 0;
27993 DREGu32((Opcode >> 9) & 7) = res;
27994#ifdef USE_CYCLONE_TIMING_DIV
27995RET(20+(dst>>31)*2)
27996#else
27997 RET(54)
27998#endif
27999 }
28000 {
28001 s32 q, r;
28002
28003 q = (s32)dst / (s32)src;
28004 r = (s32)dst % (s32)src;
28005
28006 if ((q > 0x7FFF) || (q < -0x8000))
28007 {
28008 flag_V = M68K_SR_V;
28009#ifdef USE_CYCLONE_TIMING_DIV
28010if (q > 0xFFFF || q < -0x10000) {
28011 RET(20+(dst>>31)*2)
28012} else RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28013#else
28014 RET(84)
28015#endif
28016 }
28017 q &= 0x0000FFFF;
28018 flag_NotZ = q;
28019 flag_N = q >> 8;
28020 flag_V = flag_C = 0;
28021 res = q | (r << 16);
28022 DREGu32((Opcode >> 9) & 7) = res;
28023#ifdef USE_CYCLONE_TIMING_DIV
28024RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28025#else
28026RET(112)
28027#endif
28028 }
28029}
28030
28031// DIVS
28032OPCODE(0x81E0)
28033{
28034 u32 adr, res;
28035 u32 src, dst;
28036
28037 adr = AREG((Opcode >> 0) & 7) - 2;
28038 AREG((Opcode >> 0) & 7) = adr;
28039 PRE_IO
28040 READSX_WORD_F(adr, src)
28041 if (src == 0)
28042 {
28043 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28044#ifdef USE_CYCLONE_TIMING_DIV
28045RET(10)
28046#else
28047 RET(20)
28048#endif
28049 }
28050 dst = DREGu32((Opcode >> 9) & 7);
28051 if ((dst == 0x80000000) && (src == (u32)-1))
28052 {
28053 flag_NotZ = flag_N = 0;
28054 flag_V = flag_C = 0;
28055 res = 0;
28056 DREGu32((Opcode >> 9) & 7) = res;
28057#ifdef USE_CYCLONE_TIMING_DIV
28058RET(22+(dst>>31)*2)
28059#else
28060 RET(56)
28061#endif
28062 }
28063 {
28064 s32 q, r;
28065
28066 q = (s32)dst / (s32)src;
28067 r = (s32)dst % (s32)src;
28068
28069 if ((q > 0x7FFF) || (q < -0x8000))
28070 {
28071 flag_V = M68K_SR_V;
28072#ifdef USE_CYCLONE_TIMING_DIV
28073if (q > 0xFFFF || q < -0x10000) {
28074 RET(22+(dst>>31)*2)
28075} else RET(158+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28076#else
28077 RET(86)
28078#endif
28079 }
28080 q &= 0x0000FFFF;
28081 flag_NotZ = q;
28082 flag_N = q >> 8;
28083 flag_V = flag_C = 0;
28084 res = q | (r << 16);
28085 DREGu32((Opcode >> 9) & 7) = res;
28086#ifdef USE_CYCLONE_TIMING_DIV
28087RET(158+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28088#else
28089RET(114)
28090#endif
28091 }
28092}
28093
28094// DIVS
28095OPCODE(0x81E8)
28096{
28097 u32 adr, res;
28098 u32 src, dst;
28099
28100 FETCH_SWORD(adr);
28101 adr += AREG((Opcode >> 0) & 7);
28102 PRE_IO
28103 READSX_WORD_F(adr, src)
28104 if (src == 0)
28105 {
28106 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28107#ifdef USE_CYCLONE_TIMING_DIV
28108RET(12)
28109#else
28110 RET(22)
28111#endif
28112 }
28113 dst = DREGu32((Opcode >> 9) & 7);
28114 if ((dst == 0x80000000) && (src == (u32)-1))
28115 {
28116 flag_NotZ = flag_N = 0;
28117 flag_V = flag_C = 0;
28118 res = 0;
28119 DREGu32((Opcode >> 9) & 7) = res;
28120#ifdef USE_CYCLONE_TIMING_DIV
28121RET(24+(dst>>31)*2)
28122#else
28123 RET(58)
28124#endif
28125 }
28126 {
28127 s32 q, r;
28128
28129 q = (s32)dst / (s32)src;
28130 r = (s32)dst % (s32)src;
28131
28132 if ((q > 0x7FFF) || (q < -0x8000))
28133 {
28134 flag_V = M68K_SR_V;
28135#ifdef USE_CYCLONE_TIMING_DIV
28136if (q > 0xFFFF || q < -0x10000) {
28137 RET(24+(dst>>31)*2)
28138} else RET(160+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28139#else
28140 RET(88)
28141#endif
28142 }
28143 q &= 0x0000FFFF;
28144 flag_NotZ = q;
28145 flag_N = q >> 8;
28146 flag_V = flag_C = 0;
28147 res = q | (r << 16);
28148 DREGu32((Opcode >> 9) & 7) = res;
28149#ifdef USE_CYCLONE_TIMING_DIV
28150RET(160+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28151#else
28152RET(116)
28153#endif
28154 }
28155}
28156
28157// DIVS
28158OPCODE(0x81F0)
28159{
28160 u32 adr, res;
28161 u32 src, dst;
28162
28163 adr = AREG((Opcode >> 0) & 7);
28164 DECODE_EXT_WORD
28165 PRE_IO
28166 READSX_WORD_F(adr, src)
28167 if (src == 0)
28168 {
28169 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28170#ifdef USE_CYCLONE_TIMING_DIV
28171RET(14)
28172#else
28173 RET(24)
28174#endif
28175 }
28176 dst = DREGu32((Opcode >> 9) & 7);
28177 if ((dst == 0x80000000) && (src == (u32)-1))
28178 {
28179 flag_NotZ = flag_N = 0;
28180 flag_V = flag_C = 0;
28181 res = 0;
28182 DREGu32((Opcode >> 9) & 7) = res;
28183#ifdef USE_CYCLONE_TIMING_DIV
28184RET(26+(dst>>31)*2)
28185#else
28186 RET(60)
28187#endif
28188 }
28189 {
28190 s32 q, r;
28191
28192 q = (s32)dst / (s32)src;
28193 r = (s32)dst % (s32)src;
28194
28195 if ((q > 0x7FFF) || (q < -0x8000))
28196 {
28197 flag_V = M68K_SR_V;
28198#ifdef USE_CYCLONE_TIMING_DIV
28199if (q > 0xFFFF || q < -0x10000) {
28200 RET(26+(dst>>31)*2)
28201} else RET(162+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28202#else
28203 RET(90)
28204#endif
28205 }
28206 q &= 0x0000FFFF;
28207 flag_NotZ = q;
28208 flag_N = q >> 8;
28209 flag_V = flag_C = 0;
28210 res = q | (r << 16);
28211 DREGu32((Opcode >> 9) & 7) = res;
28212#ifdef USE_CYCLONE_TIMING_DIV
28213RET(162+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28214#else
28215RET(118)
28216#endif
28217 }
28218}
28219
28220// DIVS
28221OPCODE(0x81F8)
28222{
28223 u32 adr, res;
28224 u32 src, dst;
28225
28226 FETCH_SWORD(adr);
28227 PRE_IO
28228 READSX_WORD_F(adr, src)
28229 if (src == 0)
28230 {
28231 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28232#ifdef USE_CYCLONE_TIMING_DIV
28233RET(12)
28234#else
28235 RET(22)
28236#endif
28237 }
28238 dst = DREGu32((Opcode >> 9) & 7);
28239 if ((dst == 0x80000000) && (src == (u32)-1))
28240 {
28241 flag_NotZ = flag_N = 0;
28242 flag_V = flag_C = 0;
28243 res = 0;
28244 DREGu32((Opcode >> 9) & 7) = res;
28245#ifdef USE_CYCLONE_TIMING_DIV
28246RET(24+(dst>>31)*2)
28247#else
28248 RET(58)
28249#endif
28250 }
28251 {
28252 s32 q, r;
28253
28254 q = (s32)dst / (s32)src;
28255 r = (s32)dst % (s32)src;
28256
28257 if ((q > 0x7FFF) || (q < -0x8000))
28258 {
28259 flag_V = M68K_SR_V;
28260#ifdef USE_CYCLONE_TIMING_DIV
28261if (q > 0xFFFF || q < -0x10000) {
28262 RET(24+(dst>>31)*2)
28263} else RET(160+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28264#else
28265 RET(88)
28266#endif
28267 }
28268 q &= 0x0000FFFF;
28269 flag_NotZ = q;
28270 flag_N = q >> 8;
28271 flag_V = flag_C = 0;
28272 res = q | (r << 16);
28273 DREGu32((Opcode >> 9) & 7) = res;
28274#ifdef USE_CYCLONE_TIMING_DIV
28275RET(160+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28276#else
28277RET(116)
28278#endif
28279 }
28280}
28281
28282// DIVS
28283OPCODE(0x81F9)
28284{
28285 u32 adr, res;
28286 u32 src, dst;
28287
28288 FETCH_LONG(adr);
28289 PRE_IO
28290 READSX_WORD_F(adr, src)
28291 if (src == 0)
28292 {
28293 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28294#ifdef USE_CYCLONE_TIMING_DIV
28295RET(16)
28296#else
28297 RET(26)
28298#endif
28299 }
28300 dst = DREGu32((Opcode >> 9) & 7);
28301 if ((dst == 0x80000000) && (src == (u32)-1))
28302 {
28303 flag_NotZ = flag_N = 0;
28304 flag_V = flag_C = 0;
28305 res = 0;
28306 DREGu32((Opcode >> 9) & 7) = res;
28307#ifdef USE_CYCLONE_TIMING_DIV
28308RET(28+(dst>>31)*2)
28309#else
28310 RET(62)
28311#endif
28312 }
28313 {
28314 s32 q, r;
28315
28316 q = (s32)dst / (s32)src;
28317 r = (s32)dst % (s32)src;
28318
28319 if ((q > 0x7FFF) || (q < -0x8000))
28320 {
28321 flag_V = M68K_SR_V;
28322#ifdef USE_CYCLONE_TIMING_DIV
28323if (q > 0xFFFF || q < -0x10000) {
28324 RET(28+(dst>>31)*2)
28325} else RET(164+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28326#else
28327 RET(92)
28328#endif
28329 }
28330 q &= 0x0000FFFF;
28331 flag_NotZ = q;
28332 flag_N = q >> 8;
28333 flag_V = flag_C = 0;
28334 res = q | (r << 16);
28335 DREGu32((Opcode >> 9) & 7) = res;
28336#ifdef USE_CYCLONE_TIMING_DIV
28337RET(164+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28338#else
28339RET(120)
28340#endif
28341 }
28342}
28343
28344// DIVS
28345OPCODE(0x81FA)
28346{
28347 u32 adr, res;
28348 u32 src, dst;
28349
28350 adr = GET_SWORD + GET_PC;
28351 PC++;
28352 PRE_IO
28353 READSX_WORD_F(adr, src)
28354 if (src == 0)
28355 {
28356 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28357#ifdef USE_CYCLONE_TIMING_DIV
28358RET(12)
28359#else
28360 RET(22)
28361#endif
28362 }
28363 dst = DREGu32((Opcode >> 9) & 7);
28364 if ((dst == 0x80000000) && (src == (u32)-1))
28365 {
28366 flag_NotZ = flag_N = 0;
28367 flag_V = flag_C = 0;
28368 res = 0;
28369 DREGu32((Opcode >> 9) & 7) = res;
28370#ifdef USE_CYCLONE_TIMING_DIV
28371RET(24+(dst>>31)*2)
28372#else
28373 RET(58)
28374#endif
28375 }
28376 {
28377 s32 q, r;
28378
28379 q = (s32)dst / (s32)src;
28380 r = (s32)dst % (s32)src;
28381
28382 if ((q > 0x7FFF) || (q < -0x8000))
28383 {
28384 flag_V = M68K_SR_V;
28385#ifdef USE_CYCLONE_TIMING_DIV
28386if (q > 0xFFFF || q < -0x10000) {
28387 RET(24+(dst>>31)*2)
28388} else RET(160+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28389#else
28390 RET(88)
28391#endif
28392 }
28393 q &= 0x0000FFFF;
28394 flag_NotZ = q;
28395 flag_N = q >> 8;
28396 flag_V = flag_C = 0;
28397 res = q | (r << 16);
28398 DREGu32((Opcode >> 9) & 7) = res;
28399#ifdef USE_CYCLONE_TIMING_DIV
28400RET(160+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28401#else
28402RET(116)
28403#endif
28404 }
28405}
28406
28407// DIVS
28408OPCODE(0x81FB)
28409{
28410 u32 adr, res;
28411 u32 src, dst;
28412
28413 adr = GET_PC;
28414 DECODE_EXT_WORD
28415 PRE_IO
28416 READSX_WORD_F(adr, src)
28417 if (src == 0)
28418 {
28419 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28420#ifdef USE_CYCLONE_TIMING_DIV
28421RET(14)
28422#else
28423 RET(24)
28424#endif
28425 }
28426 dst = DREGu32((Opcode >> 9) & 7);
28427 if ((dst == 0x80000000) && (src == (u32)-1))
28428 {
28429 flag_NotZ = flag_N = 0;
28430 flag_V = flag_C = 0;
28431 res = 0;
28432 DREGu32((Opcode >> 9) & 7) = res;
28433#ifdef USE_CYCLONE_TIMING_DIV
28434RET(26+(dst>>31)*2)
28435#else
28436 RET(60)
28437#endif
28438 }
28439 {
28440 s32 q, r;
28441
28442 q = (s32)dst / (s32)src;
28443 r = (s32)dst % (s32)src;
28444
28445 if ((q > 0x7FFF) || (q < -0x8000))
28446 {
28447 flag_V = M68K_SR_V;
28448#ifdef USE_CYCLONE_TIMING_DIV
28449if (q > 0xFFFF || q < -0x10000) {
28450 RET(26+(dst>>31)*2)
28451} else RET(162+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28452#else
28453 RET(90)
28454#endif
28455 }
28456 q &= 0x0000FFFF;
28457 flag_NotZ = q;
28458 flag_N = q >> 8;
28459 flag_V = flag_C = 0;
28460 res = q | (r << 16);
28461 DREGu32((Opcode >> 9) & 7) = res;
28462#ifdef USE_CYCLONE_TIMING_DIV
28463RET(162+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28464#else
28465RET(118)
28466#endif
28467 }
28468}
28469
28470// DIVS
28471OPCODE(0x81FC)
28472{
28473 u32 adr, res;
28474 u32 src, dst;
28475
28476 FETCH_SWORD(src);
28477 if (src == 0)
28478 {
28479 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28480#ifdef USE_CYCLONE_TIMING_DIV
28481RET(8)
28482#else
28483 RET(18)
28484#endif
28485 }
28486 dst = DREGu32((Opcode >> 9) & 7);
28487 if ((dst == 0x80000000) && (src == (u32)-1))
28488 {
28489 flag_NotZ = flag_N = 0;
28490 flag_V = flag_C = 0;
28491 res = 0;
28492 DREGu32((Opcode >> 9) & 7) = res;
28493#ifdef USE_CYCLONE_TIMING_DIV
28494RET(20+(dst>>31)*2)
28495#else
28496 RET(54)
28497#endif
28498 }
28499 {
28500 s32 q, r;
28501
28502 q = (s32)dst / (s32)src;
28503 r = (s32)dst % (s32)src;
28504
28505 if ((q > 0x7FFF) || (q < -0x8000))
28506 {
28507 flag_V = M68K_SR_V;
28508#ifdef USE_CYCLONE_TIMING_DIV
28509if (q > 0xFFFF || q < -0x10000) {
28510 RET(20+(dst>>31)*2)
28511} else RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28512#else
28513 RET(84)
28514#endif
28515 }
28516 q &= 0x0000FFFF;
28517 flag_NotZ = q;
28518 flag_N = q >> 8;
28519 flag_V = flag_C = 0;
28520 res = q | (r << 16);
28521 DREGu32((Opcode >> 9) & 7) = res;
28522#ifdef USE_CYCLONE_TIMING_DIV
28523RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28524#else
28525RET(112)
28526#endif
28527 }
28528}
28529
28530// DIVS
28531OPCODE(0x81DF)
28532{
28533 u32 adr, res;
28534 u32 src, dst;
28535
28536 adr = AREG(7);
28537 AREG(7) += 2;
28538 PRE_IO
28539 READSX_WORD_F(adr, src)
28540 if (src == 0)
28541 {
28542 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28543#ifdef USE_CYCLONE_TIMING_DIV
28544RET(8)
28545#else
28546 RET(18)
28547#endif
28548 }
28549 dst = DREGu32((Opcode >> 9) & 7);
28550 if ((dst == 0x80000000) && (src == (u32)-1))
28551 {
28552 flag_NotZ = flag_N = 0;
28553 flag_V = flag_C = 0;
28554 res = 0;
28555 DREGu32((Opcode >> 9) & 7) = res;
28556#ifdef USE_CYCLONE_TIMING_DIV
28557RET(20+(dst>>31)*2)
28558#else
28559 RET(54)
28560#endif
28561 }
28562 {
28563 s32 q, r;
28564
28565 q = (s32)dst / (s32)src;
28566 r = (s32)dst % (s32)src;
28567
28568 if ((q > 0x7FFF) || (q < -0x8000))
28569 {
28570 flag_V = M68K_SR_V;
28571#ifdef USE_CYCLONE_TIMING_DIV
28572if (q > 0xFFFF || q < -0x10000) {
28573 RET(20+(dst>>31)*2)
28574} else RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28575#else
28576 RET(84)
28577#endif
28578 }
28579 q &= 0x0000FFFF;
28580 flag_NotZ = q;
28581 flag_N = q >> 8;
28582 flag_V = flag_C = 0;
28583 res = q | (r << 16);
28584 DREGu32((Opcode >> 9) & 7) = res;
28585#ifdef USE_CYCLONE_TIMING_DIV
28586RET(156+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28587#else
28588RET(112)
28589#endif
28590 }
28591}
28592
28593// DIVS
28594OPCODE(0x81E7)
28595{
28596 u32 adr, res;
28597 u32 src, dst;
28598
28599 adr = AREG(7) - 2;
28600 AREG(7) = adr;
28601 PRE_IO
28602 READSX_WORD_F(adr, src)
28603 if (src == 0)
28604 {
28605 SET_PC(execute_exception(ctx, M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
28606#ifdef USE_CYCLONE_TIMING_DIV
28607RET(10)
28608#else
28609 RET(20)
28610#endif
28611 }
28612 dst = DREGu32((Opcode >> 9) & 7);
28613 if ((dst == 0x80000000) && (src == (u32)-1))
28614 {
28615 flag_NotZ = flag_N = 0;
28616 flag_V = flag_C = 0;
28617 res = 0;
28618 DREGu32((Opcode >> 9) & 7) = res;
28619#ifdef USE_CYCLONE_TIMING_DIV
28620RET(22+(dst>>31)*2)
28621#else
28622 RET(56)
28623#endif
28624 }
28625 {
28626 s32 q, r;
28627
28628 q = (s32)dst / (s32)src;
28629 r = (s32)dst % (s32)src;
28630
28631 if ((q > 0x7FFF) || (q < -0x8000))
28632 {
28633 flag_V = M68K_SR_V;
28634#ifdef USE_CYCLONE_TIMING_DIV
28635if (q > 0xFFFF || q < -0x10000) {
28636 RET(22+(dst>>31)*2)
28637} else RET(158+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28638#else
28639 RET(86)
28640#endif
28641 }
28642 q &= 0x0000FFFF;
28643 flag_NotZ = q;
28644 flag_N = q >> 8;
28645 flag_V = flag_C = 0;
28646 res = q | (r << 16);
28647 DREGu32((Opcode >> 9) & 7) = res;
28648#ifdef USE_CYCLONE_TIMING_DIV
28649RET(158+(dst>>31)*4-(q>>31)*2-BITCOUNT(res,abs(q))*2)
28650#else
28651RET(114)
28652#endif
28653 }
28654}
28655
28656// SUBaD
28657OPCODE(0x9000)
28658{
28659 u32 adr, res;
28660 u32 src, dst;
28661
28662 src = DREGu8((Opcode >> 0) & 7);
28663 dst = DREGu8((Opcode >> 9) & 7);
28664 res = dst - src;
28665 flag_N = flag_X = flag_C = res;
28666 flag_V = (src ^ dst) & (res ^ dst);
28667 flag_NotZ = res & 0xFF;
28668 DREGu8((Opcode >> 9) & 7) = res;
28669RET(4)
28670}
28671
28672// SUBaD
28673#if 0
28674OPCODE(0x9008)
28675{
28676 u32 adr, res;
28677 u32 src, dst;
28678
28679 // can't read byte from Ax registers !
28680 ctx->execinfo |= M68K_FAULTED;
28681 ctx->io_cycle_counter = 0;
28682/*
28683 goto famec_Exec_End;
28684 dst = DREGu8((Opcode >> 9) & 7);
28685 res = dst - src;
28686 flag_N = flag_X = flag_C = res;
28687 flag_V = (src ^ dst) & (res ^ dst);
28688 flag_NotZ = res & 0xFF;
28689 DREGu8((Opcode >> 9) & 7) = res;
28690*/
28691RET(4)
28692}
28693#endif
28694
28695// SUBaD
28696OPCODE(0x9010)
28697{
28698 u32 adr, res;
28699 u32 src, dst;
28700
28701 adr = AREG((Opcode >> 0) & 7);
28702 PRE_IO
28703 READ_BYTE_F(adr, src)
28704 dst = DREGu8((Opcode >> 9) & 7);
28705 res = dst - src;
28706 flag_N = flag_X = flag_C = res;
28707 flag_V = (src ^ dst) & (res ^ dst);
28708 flag_NotZ = res & 0xFF;
28709 DREGu8((Opcode >> 9) & 7) = res;
28710 POST_IO
28711RET(8)
28712}
28713
28714// SUBaD
28715OPCODE(0x9018)
28716{
28717 u32 adr, res;
28718 u32 src, dst;
28719
28720 adr = AREG((Opcode >> 0) & 7);
28721 AREG((Opcode >> 0) & 7) += 1;
28722 PRE_IO
28723 READ_BYTE_F(adr, src)
28724 dst = DREGu8((Opcode >> 9) & 7);
28725 res = dst - src;
28726 flag_N = flag_X = flag_C = res;
28727 flag_V = (src ^ dst) & (res ^ dst);
28728 flag_NotZ = res & 0xFF;
28729 DREGu8((Opcode >> 9) & 7) = res;
28730 POST_IO
28731RET(8)
28732}
28733
28734// SUBaD
28735OPCODE(0x9020)
28736{
28737 u32 adr, res;
28738 u32 src, dst;
28739
28740 adr = AREG((Opcode >> 0) & 7) - 1;
28741 AREG((Opcode >> 0) & 7) = adr;
28742 PRE_IO
28743 READ_BYTE_F(adr, src)
28744 dst = DREGu8((Opcode >> 9) & 7);
28745 res = dst - src;
28746 flag_N = flag_X = flag_C = res;
28747 flag_V = (src ^ dst) & (res ^ dst);
28748 flag_NotZ = res & 0xFF;
28749 DREGu8((Opcode >> 9) & 7) = res;
28750 POST_IO
28751RET(10)
28752}
28753
28754// SUBaD
28755OPCODE(0x9028)
28756{
28757 u32 adr, res;
28758 u32 src, dst;
28759
28760 FETCH_SWORD(adr);
28761 adr += AREG((Opcode >> 0) & 7);
28762 PRE_IO
28763 READ_BYTE_F(adr, src)
28764 dst = DREGu8((Opcode >> 9) & 7);
28765 res = dst - src;
28766 flag_N = flag_X = flag_C = res;
28767 flag_V = (src ^ dst) & (res ^ dst);
28768 flag_NotZ = res & 0xFF;
28769 DREGu8((Opcode >> 9) & 7) = res;
28770 POST_IO
28771RET(12)
28772}
28773
28774// SUBaD
28775OPCODE(0x9030)
28776{
28777 u32 adr, res;
28778 u32 src, dst;
28779
28780 adr = AREG((Opcode >> 0) & 7);
28781 DECODE_EXT_WORD
28782 PRE_IO
28783 READ_BYTE_F(adr, src)
28784 dst = DREGu8((Opcode >> 9) & 7);
28785 res = dst - src;
28786 flag_N = flag_X = flag_C = res;
28787 flag_V = (src ^ dst) & (res ^ dst);
28788 flag_NotZ = res & 0xFF;
28789 DREGu8((Opcode >> 9) & 7) = res;
28790 POST_IO
28791RET(14)
28792}
28793
28794// SUBaD
28795OPCODE(0x9038)
28796{
28797 u32 adr, res;
28798 u32 src, dst;
28799
28800 FETCH_SWORD(adr);
28801 PRE_IO
28802 READ_BYTE_F(adr, src)
28803 dst = DREGu8((Opcode >> 9) & 7);
28804 res = dst - src;
28805 flag_N = flag_X = flag_C = res;
28806 flag_V = (src ^ dst) & (res ^ dst);
28807 flag_NotZ = res & 0xFF;
28808 DREGu8((Opcode >> 9) & 7) = res;
28809 POST_IO
28810RET(12)
28811}
28812
28813// SUBaD
28814OPCODE(0x9039)
28815{
28816 u32 adr, res;
28817 u32 src, dst;
28818
28819 FETCH_LONG(adr);
28820 PRE_IO
28821 READ_BYTE_F(adr, src)
28822 dst = DREGu8((Opcode >> 9) & 7);
28823 res = dst - src;
28824 flag_N = flag_X = flag_C = res;
28825 flag_V = (src ^ dst) & (res ^ dst);
28826 flag_NotZ = res & 0xFF;
28827 DREGu8((Opcode >> 9) & 7) = res;
28828 POST_IO
28829RET(16)
28830}
28831
28832// SUBaD
28833OPCODE(0x903A)
28834{
28835 u32 adr, res;
28836 u32 src, dst;
28837
28838 adr = GET_SWORD + GET_PC;
28839 PC++;
28840 PRE_IO
28841 READ_BYTE_F(adr, src)
28842 dst = DREGu8((Opcode >> 9) & 7);
28843 res = dst - src;
28844 flag_N = flag_X = flag_C = res;
28845 flag_V = (src ^ dst) & (res ^ dst);
28846 flag_NotZ = res & 0xFF;
28847 DREGu8((Opcode >> 9) & 7) = res;
28848 POST_IO
28849RET(12)
28850}
28851
28852// SUBaD
28853OPCODE(0x903B)
28854{
28855 u32 adr, res;
28856 u32 src, dst;
28857
28858 adr = GET_PC;
28859 DECODE_EXT_WORD
28860 PRE_IO
28861 READ_BYTE_F(adr, src)
28862 dst = DREGu8((Opcode >> 9) & 7);
28863 res = dst - src;
28864 flag_N = flag_X = flag_C = res;
28865 flag_V = (src ^ dst) & (res ^ dst);
28866 flag_NotZ = res & 0xFF;
28867 DREGu8((Opcode >> 9) & 7) = res;
28868 POST_IO
28869RET(14)
28870}
28871
28872// SUBaD
28873OPCODE(0x903C)
28874{
28875 u32 adr, res;
28876 u32 src, dst;
28877
28878 FETCH_BYTE(src);
28879 dst = DREGu8((Opcode >> 9) & 7);
28880 res = dst - src;
28881 flag_N = flag_X = flag_C = res;
28882 flag_V = (src ^ dst) & (res ^ dst);
28883 flag_NotZ = res & 0xFF;
28884 DREGu8((Opcode >> 9) & 7) = res;
28885RET(8)
28886}
28887
28888// SUBaD
28889OPCODE(0x901F)
28890{
28891 u32 adr, res;
28892 u32 src, dst;
28893
28894 adr = AREG(7);
28895 AREG(7) += 2;
28896 PRE_IO
28897 READ_BYTE_F(adr, src)
28898 dst = DREGu8((Opcode >> 9) & 7);
28899 res = dst - src;
28900 flag_N = flag_X = flag_C = res;
28901 flag_V = (src ^ dst) & (res ^ dst);
28902 flag_NotZ = res & 0xFF;
28903 DREGu8((Opcode >> 9) & 7) = res;
28904 POST_IO
28905RET(8)
28906}
28907
28908// SUBaD
28909OPCODE(0x9027)
28910{
28911 u32 adr, res;
28912 u32 src, dst;
28913
28914 adr = AREG(7) - 2;
28915 AREG(7) = adr;
28916 PRE_IO
28917 READ_BYTE_F(adr, src)
28918 dst = DREGu8((Opcode >> 9) & 7);
28919 res = dst - src;
28920 flag_N = flag_X = flag_C = res;
28921 flag_V = (src ^ dst) & (res ^ dst);
28922 flag_NotZ = res & 0xFF;
28923 DREGu8((Opcode >> 9) & 7) = res;
28924 POST_IO
28925RET(10)
28926}
28927
28928// SUBaD
28929OPCODE(0x9040)
28930{
28931 u32 adr, res;
28932 u32 src, dst;
28933
28934 src = DREGu16((Opcode >> 0) & 7);
28935 dst = DREGu16((Opcode >> 9) & 7);
28936 res = dst - src;
28937 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28938 flag_N = flag_X = flag_C = res >> 8;
28939 flag_NotZ = res & 0xFFFF;
28940 DREGu16((Opcode >> 9) & 7) = res;
28941RET(4)
28942}
28943
28944// SUBaD
28945OPCODE(0x9048)
28946{
28947 u32 adr, res;
28948 u32 src, dst;
28949
28950 src = AREGu16((Opcode >> 0) & 7);
28951 dst = DREGu16((Opcode >> 9) & 7);
28952 res = dst - src;
28953 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28954 flag_N = flag_X = flag_C = res >> 8;
28955 flag_NotZ = res & 0xFFFF;
28956 DREGu16((Opcode >> 9) & 7) = res;
28957RET(4)
28958}
28959
28960// SUBaD
28961OPCODE(0x9050)
28962{
28963 u32 adr, res;
28964 u32 src, dst;
28965
28966 adr = AREG((Opcode >> 0) & 7);
28967 PRE_IO
28968 READ_WORD_F(adr, src)
28969 dst = DREGu16((Opcode >> 9) & 7);
28970 res = dst - src;
28971 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28972 flag_N = flag_X = flag_C = res >> 8;
28973 flag_NotZ = res & 0xFFFF;
28974 DREGu16((Opcode >> 9) & 7) = res;
28975 POST_IO
28976RET(8)
28977}
28978
28979// SUBaD
28980OPCODE(0x9058)
28981{
28982 u32 adr, res;
28983 u32 src, dst;
28984
28985 adr = AREG((Opcode >> 0) & 7);
28986 AREG((Opcode >> 0) & 7) += 2;
28987 PRE_IO
28988 READ_WORD_F(adr, src)
28989 dst = DREGu16((Opcode >> 9) & 7);
28990 res = dst - src;
28991 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28992 flag_N = flag_X = flag_C = res >> 8;
28993 flag_NotZ = res & 0xFFFF;
28994 DREGu16((Opcode >> 9) & 7) = res;
28995 POST_IO
28996RET(8)
28997}
28998
28999// SUBaD
29000OPCODE(0x9060)
29001{
29002 u32 adr, res;
29003 u32 src, dst;
29004
29005 adr = AREG((Opcode >> 0) & 7) - 2;
29006 AREG((Opcode >> 0) & 7) = adr;
29007 PRE_IO
29008 READ_WORD_F(adr, src)
29009 dst = DREGu16((Opcode >> 9) & 7);
29010 res = dst - src;
29011 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29012 flag_N = flag_X = flag_C = res >> 8;
29013 flag_NotZ = res & 0xFFFF;
29014 DREGu16((Opcode >> 9) & 7) = res;
29015 POST_IO
29016RET(10)
29017}
29018
29019// SUBaD
29020OPCODE(0x9068)
29021{
29022 u32 adr, res;
29023 u32 src, dst;
29024
29025 FETCH_SWORD(adr);
29026 adr += AREG((Opcode >> 0) & 7);
29027 PRE_IO
29028 READ_WORD_F(adr, src)
29029 dst = DREGu16((Opcode >> 9) & 7);
29030 res = dst - src;
29031 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29032 flag_N = flag_X = flag_C = res >> 8;
29033 flag_NotZ = res & 0xFFFF;
29034 DREGu16((Opcode >> 9) & 7) = res;
29035 POST_IO
29036RET(12)
29037}
29038
29039// SUBaD
29040OPCODE(0x9070)
29041{
29042 u32 adr, res;
29043 u32 src, dst;
29044
29045 adr = AREG((Opcode >> 0) & 7);
29046 DECODE_EXT_WORD
29047 PRE_IO
29048 READ_WORD_F(adr, src)
29049 dst = DREGu16((Opcode >> 9) & 7);
29050 res = dst - src;
29051 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29052 flag_N = flag_X = flag_C = res >> 8;
29053 flag_NotZ = res & 0xFFFF;
29054 DREGu16((Opcode >> 9) & 7) = res;
29055 POST_IO
29056RET(14)
29057}
29058
29059// SUBaD
29060OPCODE(0x9078)
29061{
29062 u32 adr, res;
29063 u32 src, dst;
29064
29065 FETCH_SWORD(adr);
29066 PRE_IO
29067 READ_WORD_F(adr, src)
29068 dst = DREGu16((Opcode >> 9) & 7);
29069 res = dst - src;
29070 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29071 flag_N = flag_X = flag_C = res >> 8;
29072 flag_NotZ = res & 0xFFFF;
29073 DREGu16((Opcode >> 9) & 7) = res;
29074 POST_IO
29075RET(12)
29076}
29077
29078// SUBaD
29079OPCODE(0x9079)
29080{
29081 u32 adr, res;
29082 u32 src, dst;
29083
29084 FETCH_LONG(adr);
29085 PRE_IO
29086 READ_WORD_F(adr, src)
29087 dst = DREGu16((Opcode >> 9) & 7);
29088 res = dst - src;
29089 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29090 flag_N = flag_X = flag_C = res >> 8;
29091 flag_NotZ = res & 0xFFFF;
29092 DREGu16((Opcode >> 9) & 7) = res;
29093 POST_IO
29094RET(16)
29095}
29096
29097// SUBaD
29098OPCODE(0x907A)
29099{
29100 u32 adr, res;
29101 u32 src, dst;
29102
29103 adr = GET_SWORD + GET_PC;
29104 PC++;
29105 PRE_IO
29106 READ_WORD_F(adr, src)
29107 dst = DREGu16((Opcode >> 9) & 7);
29108 res = dst - src;
29109 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29110 flag_N = flag_X = flag_C = res >> 8;
29111 flag_NotZ = res & 0xFFFF;
29112 DREGu16((Opcode >> 9) & 7) = res;
29113 POST_IO
29114RET(12)
29115}
29116
29117// SUBaD
29118OPCODE(0x907B)
29119{
29120 u32 adr, res;
29121 u32 src, dst;
29122
29123 adr = GET_PC;
29124 DECODE_EXT_WORD
29125 PRE_IO
29126 READ_WORD_F(adr, src)
29127 dst = DREGu16((Opcode >> 9) & 7);
29128 res = dst - src;
29129 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29130 flag_N = flag_X = flag_C = res >> 8;
29131 flag_NotZ = res & 0xFFFF;
29132 DREGu16((Opcode >> 9) & 7) = res;
29133 POST_IO
29134RET(14)
29135}
29136
29137// SUBaD
29138OPCODE(0x907C)
29139{
29140 u32 adr, res;
29141 u32 src, dst;
29142
29143 FETCH_WORD(src);
29144 dst = DREGu16((Opcode >> 9) & 7);
29145 res = dst - src;
29146 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29147 flag_N = flag_X = flag_C = res >> 8;
29148 flag_NotZ = res & 0xFFFF;
29149 DREGu16((Opcode >> 9) & 7) = res;
29150RET(8)
29151}
29152
29153// SUBaD
29154OPCODE(0x905F)
29155{
29156 u32 adr, res;
29157 u32 src, dst;
29158
29159 adr = AREG(7);
29160 AREG(7) += 2;
29161 PRE_IO
29162 READ_WORD_F(adr, src)
29163 dst = DREGu16((Opcode >> 9) & 7);
29164 res = dst - src;
29165 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29166 flag_N = flag_X = flag_C = res >> 8;
29167 flag_NotZ = res & 0xFFFF;
29168 DREGu16((Opcode >> 9) & 7) = res;
29169 POST_IO
29170RET(8)
29171}
29172
29173// SUBaD
29174OPCODE(0x9067)
29175{
29176 u32 adr, res;
29177 u32 src, dst;
29178
29179 adr = AREG(7) - 2;
29180 AREG(7) = adr;
29181 PRE_IO
29182 READ_WORD_F(adr, src)
29183 dst = DREGu16((Opcode >> 9) & 7);
29184 res = dst - src;
29185 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29186 flag_N = flag_X = flag_C = res >> 8;
29187 flag_NotZ = res & 0xFFFF;
29188 DREGu16((Opcode >> 9) & 7) = res;
29189 POST_IO
29190RET(10)
29191}
29192
29193// SUBaD
29194OPCODE(0x9080)
29195{
29196 u32 adr, res;
29197 u32 src, dst;
29198
29199 src = DREGu32((Opcode >> 0) & 7);
29200 dst = DREGu32((Opcode >> 9) & 7);
29201 res = dst - src;
29202 flag_NotZ = res;
29203 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29204 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29205 flag_N = res >> 24;
29206 DREGu32((Opcode >> 9) & 7) = res;
29207RET(8)
29208}
29209
29210// SUBaD
29211OPCODE(0x9088)
29212{
29213 u32 adr, res;
29214 u32 src, dst;
29215
29216 src = AREGu32((Opcode >> 0) & 7);
29217 dst = DREGu32((Opcode >> 9) & 7);
29218 res = dst - src;
29219 flag_NotZ = res;
29220 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29221 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29222 flag_N = res >> 24;
29223 DREGu32((Opcode >> 9) & 7) = res;
29224RET(8)
29225}
29226
29227// SUBaD
29228OPCODE(0x9090)
29229{
29230 u32 adr, res;
29231 u32 src, dst;
29232
29233 adr = AREG((Opcode >> 0) & 7);
29234 PRE_IO
29235 READ_LONG_F(adr, src)
29236 dst = DREGu32((Opcode >> 9) & 7);
29237 res = dst - src;
29238 flag_NotZ = res;
29239 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29240 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29241 flag_N = res >> 24;
29242 DREGu32((Opcode >> 9) & 7) = res;
29243 POST_IO
29244RET(14)
29245}
29246
29247// SUBaD
29248OPCODE(0x9098)
29249{
29250 u32 adr, res;
29251 u32 src, dst;
29252
29253 adr = AREG((Opcode >> 0) & 7);
29254 AREG((Opcode >> 0) & 7) += 4;
29255 PRE_IO
29256 READ_LONG_F(adr, src)
29257 dst = DREGu32((Opcode >> 9) & 7);
29258 res = dst - src;
29259 flag_NotZ = res;
29260 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29261 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29262 flag_N = res >> 24;
29263 DREGu32((Opcode >> 9) & 7) = res;
29264 POST_IO
29265RET(14)
29266}
29267
29268// SUBaD
29269OPCODE(0x90A0)
29270{
29271 u32 adr, res;
29272 u32 src, dst;
29273
29274 adr = AREG((Opcode >> 0) & 7) - 4;
29275 AREG((Opcode >> 0) & 7) = adr;
29276 PRE_IO
29277 READ_LONG_F(adr, src)
29278 dst = DREGu32((Opcode >> 9) & 7);
29279 res = dst - src;
29280 flag_NotZ = res;
29281 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29282 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29283 flag_N = res >> 24;
29284 DREGu32((Opcode >> 9) & 7) = res;
29285 POST_IO
29286RET(16)
29287}
29288
29289// SUBaD
29290OPCODE(0x90A8)
29291{
29292 u32 adr, res;
29293 u32 src, dst;
29294
29295 FETCH_SWORD(adr);
29296 adr += AREG((Opcode >> 0) & 7);
29297 PRE_IO
29298 READ_LONG_F(adr, src)
29299 dst = DREGu32((Opcode >> 9) & 7);
29300 res = dst - src;
29301 flag_NotZ = res;
29302 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29303 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29304 flag_N = res >> 24;
29305 DREGu32((Opcode >> 9) & 7) = res;
29306 POST_IO
29307RET(18)
29308}
29309
29310// SUBaD
29311OPCODE(0x90B0)
29312{
29313 u32 adr, res;
29314 u32 src, dst;
29315
29316 adr = AREG((Opcode >> 0) & 7);
29317 DECODE_EXT_WORD
29318 PRE_IO
29319 READ_LONG_F(adr, src)
29320 dst = DREGu32((Opcode >> 9) & 7);
29321 res = dst - src;
29322 flag_NotZ = res;
29323 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29324 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29325 flag_N = res >> 24;
29326 DREGu32((Opcode >> 9) & 7) = res;
29327 POST_IO
29328RET(20)
29329}
29330
29331// SUBaD
29332OPCODE(0x90B8)
29333{
29334 u32 adr, res;
29335 u32 src, dst;
29336
29337 FETCH_SWORD(adr);
29338 PRE_IO
29339 READ_LONG_F(adr, src)
29340 dst = DREGu32((Opcode >> 9) & 7);
29341 res = dst - src;
29342 flag_NotZ = res;
29343 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29344 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29345 flag_N = res >> 24;
29346 DREGu32((Opcode >> 9) & 7) = res;
29347 POST_IO
29348RET(18)
29349}
29350
29351// SUBaD
29352OPCODE(0x90B9)
29353{
29354 u32 adr, res;
29355 u32 src, dst;
29356
29357 FETCH_LONG(adr);
29358 PRE_IO
29359 READ_LONG_F(adr, src)
29360 dst = DREGu32((Opcode >> 9) & 7);
29361 res = dst - src;
29362 flag_NotZ = res;
29363 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29364 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29365 flag_N = res >> 24;
29366 DREGu32((Opcode >> 9) & 7) = res;
29367 POST_IO
29368RET(22)
29369}
29370
29371// SUBaD
29372OPCODE(0x90BA)
29373{
29374 u32 adr, res;
29375 u32 src, dst;
29376
29377 adr = GET_SWORD + GET_PC;
29378 PC++;
29379 PRE_IO
29380 READ_LONG_F(adr, src)
29381 dst = DREGu32((Opcode >> 9) & 7);
29382 res = dst - src;
29383 flag_NotZ = res;
29384 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29385 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29386 flag_N = res >> 24;
29387 DREGu32((Opcode >> 9) & 7) = res;
29388 POST_IO
29389RET(18)
29390}
29391
29392// SUBaD
29393OPCODE(0x90BB)
29394{
29395 u32 adr, res;
29396 u32 src, dst;
29397
29398 adr = GET_PC;
29399 DECODE_EXT_WORD
29400 PRE_IO
29401 READ_LONG_F(adr, src)
29402 dst = DREGu32((Opcode >> 9) & 7);
29403 res = dst - src;
29404 flag_NotZ = res;
29405 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29406 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29407 flag_N = res >> 24;
29408 DREGu32((Opcode >> 9) & 7) = res;
29409 POST_IO
29410RET(20)
29411}
29412
29413// SUBaD
29414OPCODE(0x90BC)
29415{
29416 u32 adr, res;
29417 u32 src, dst;
29418
29419 FETCH_LONG(src);
29420 dst = DREGu32((Opcode >> 9) & 7);
29421 res = dst - src;
29422 flag_NotZ = res;
29423 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29424 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29425 flag_N = res >> 24;
29426 DREGu32((Opcode >> 9) & 7) = res;
29427RET(16)
29428}
29429
29430// SUBaD
29431OPCODE(0x909F)
29432{
29433 u32 adr, res;
29434 u32 src, dst;
29435
29436 adr = AREG(7);
29437 AREG(7) += 4;
29438 PRE_IO
29439 READ_LONG_F(adr, src)
29440 dst = DREGu32((Opcode >> 9) & 7);
29441 res = dst - src;
29442 flag_NotZ = res;
29443 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29444 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29445 flag_N = res >> 24;
29446 DREGu32((Opcode >> 9) & 7) = res;
29447 POST_IO
29448RET(14)
29449}
29450
29451// SUBaD
29452OPCODE(0x90A7)
29453{
29454 u32 adr, res;
29455 u32 src, dst;
29456
29457 adr = AREG(7) - 4;
29458 AREG(7) = adr;
29459 PRE_IO
29460 READ_LONG_F(adr, src)
29461 dst = DREGu32((Opcode >> 9) & 7);
29462 res = dst - src;
29463 flag_NotZ = res;
29464 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29465 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29466 flag_N = res >> 24;
29467 DREGu32((Opcode >> 9) & 7) = res;
29468 POST_IO
29469RET(16)
29470}
29471
29472// SUBDa
29473OPCODE(0x9110)
29474{
29475 u32 adr, res;
29476 u32 src, dst;
29477
29478 src = DREGu8((Opcode >> 9) & 7);
29479 adr = AREG((Opcode >> 0) & 7);
29480 PRE_IO
29481 READ_BYTE_F(adr, dst)
29482 res = dst - src;
29483 flag_N = flag_X = flag_C = res;
29484 flag_V = (src ^ dst) & (res ^ dst);
29485 flag_NotZ = res & 0xFF;
29486 WRITE_BYTE_F(adr, res)
29487 POST_IO
29488RET(12)
29489}
29490
29491// SUBDa
29492OPCODE(0x9118)
29493{
29494 u32 adr, res;
29495 u32 src, dst;
29496
29497 src = DREGu8((Opcode >> 9) & 7);
29498 adr = AREG((Opcode >> 0) & 7);
29499 AREG((Opcode >> 0) & 7) += 1;
29500 PRE_IO
29501 READ_BYTE_F(adr, dst)
29502 res = dst - src;
29503 flag_N = flag_X = flag_C = res;
29504 flag_V = (src ^ dst) & (res ^ dst);
29505 flag_NotZ = res & 0xFF;
29506 WRITE_BYTE_F(adr, res)
29507 POST_IO
29508RET(12)
29509}
29510
29511// SUBDa
29512OPCODE(0x9120)
29513{
29514 u32 adr, res;
29515 u32 src, dst;
29516
29517 src = DREGu8((Opcode >> 9) & 7);
29518 adr = AREG((Opcode >> 0) & 7) - 1;
29519 AREG((Opcode >> 0) & 7) = adr;
29520 PRE_IO
29521 READ_BYTE_F(adr, dst)
29522 res = dst - src;
29523 flag_N = flag_X = flag_C = res;
29524 flag_V = (src ^ dst) & (res ^ dst);
29525 flag_NotZ = res & 0xFF;
29526 WRITE_BYTE_F(adr, res)
29527 POST_IO
29528RET(14)
29529}
29530
29531// SUBDa
29532OPCODE(0x9128)
29533{
29534 u32 adr, res;
29535 u32 src, dst;
29536
29537 src = DREGu8((Opcode >> 9) & 7);
29538 FETCH_SWORD(adr);
29539 adr += AREG((Opcode >> 0) & 7);
29540 PRE_IO
29541 READ_BYTE_F(adr, dst)
29542 res = dst - src;
29543 flag_N = flag_X = flag_C = res;
29544 flag_V = (src ^ dst) & (res ^ dst);
29545 flag_NotZ = res & 0xFF;
29546 WRITE_BYTE_F(adr, res)
29547 POST_IO
29548RET(16)
29549}
29550
29551// SUBDa
29552OPCODE(0x9130)
29553{
29554 u32 adr, res;
29555 u32 src, dst;
29556
29557 src = DREGu8((Opcode >> 9) & 7);
29558 adr = AREG((Opcode >> 0) & 7);
29559 DECODE_EXT_WORD
29560 PRE_IO
29561 READ_BYTE_F(adr, dst)
29562 res = dst - src;
29563 flag_N = flag_X = flag_C = res;
29564 flag_V = (src ^ dst) & (res ^ dst);
29565 flag_NotZ = res & 0xFF;
29566 WRITE_BYTE_F(adr, res)
29567 POST_IO
29568RET(18)
29569}
29570
29571// SUBDa
29572OPCODE(0x9138)
29573{
29574 u32 adr, res;
29575 u32 src, dst;
29576
29577 src = DREGu8((Opcode >> 9) & 7);
29578 FETCH_SWORD(adr);
29579 PRE_IO
29580 READ_BYTE_F(adr, dst)
29581 res = dst - src;
29582 flag_N = flag_X = flag_C = res;
29583 flag_V = (src ^ dst) & (res ^ dst);
29584 flag_NotZ = res & 0xFF;
29585 WRITE_BYTE_F(adr, res)
29586 POST_IO
29587RET(16)
29588}
29589
29590// SUBDa
29591OPCODE(0x9139)
29592{
29593 u32 adr, res;
29594 u32 src, dst;
29595
29596 src = DREGu8((Opcode >> 9) & 7);
29597 FETCH_LONG(adr);
29598 PRE_IO
29599 READ_BYTE_F(adr, dst)
29600 res = dst - src;
29601 flag_N = flag_X = flag_C = res;
29602 flag_V = (src ^ dst) & (res ^ dst);
29603 flag_NotZ = res & 0xFF;
29604 WRITE_BYTE_F(adr, res)
29605 POST_IO
29606RET(20)
29607}
29608
29609// SUBDa
29610OPCODE(0x911F)
29611{
29612 u32 adr, res;
29613 u32 src, dst;
29614
29615 src = DREGu8((Opcode >> 9) & 7);
29616 adr = AREG(7);
29617 AREG(7) += 2;
29618 PRE_IO
29619 READ_BYTE_F(adr, dst)
29620 res = dst - src;
29621 flag_N = flag_X = flag_C = res;
29622 flag_V = (src ^ dst) & (res ^ dst);
29623 flag_NotZ = res & 0xFF;
29624 WRITE_BYTE_F(adr, res)
29625 POST_IO
29626RET(12)
29627}
29628
29629// SUBDa
29630OPCODE(0x9127)
29631{
29632 u32 adr, res;
29633 u32 src, dst;
29634
29635 src = DREGu8((Opcode >> 9) & 7);
29636 adr = AREG(7) - 2;
29637 AREG(7) = adr;
29638 PRE_IO
29639 READ_BYTE_F(adr, dst)
29640 res = dst - src;
29641 flag_N = flag_X = flag_C = res;
29642 flag_V = (src ^ dst) & (res ^ dst);
29643 flag_NotZ = res & 0xFF;
29644 WRITE_BYTE_F(adr, res)
29645 POST_IO
29646RET(14)
29647}
29648
29649// SUBDa
29650OPCODE(0x9150)
29651{
29652 u32 adr, res;
29653 u32 src, dst;
29654
29655 src = DREGu16((Opcode >> 9) & 7);
29656 adr = AREG((Opcode >> 0) & 7);
29657 PRE_IO
29658 READ_WORD_F(adr, dst)
29659 res = dst - src;
29660 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29661 flag_N = flag_X = flag_C = res >> 8;
29662 flag_NotZ = res & 0xFFFF;
29663 WRITE_WORD_F(adr, res)
29664 POST_IO
29665RET(12)
29666}
29667
29668// SUBDa
29669OPCODE(0x9158)
29670{
29671 u32 adr, res;
29672 u32 src, dst;
29673
29674 src = DREGu16((Opcode >> 9) & 7);
29675 adr = AREG((Opcode >> 0) & 7);
29676 AREG((Opcode >> 0) & 7) += 2;
29677 PRE_IO
29678 READ_WORD_F(adr, dst)
29679 res = dst - src;
29680 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29681 flag_N = flag_X = flag_C = res >> 8;
29682 flag_NotZ = res & 0xFFFF;
29683 WRITE_WORD_F(adr, res)
29684 POST_IO
29685RET(12)
29686}
29687
29688// SUBDa
29689OPCODE(0x9160)
29690{
29691 u32 adr, res;
29692 u32 src, dst;
29693
29694 src = DREGu16((Opcode >> 9) & 7);
29695 adr = AREG((Opcode >> 0) & 7) - 2;
29696 AREG((Opcode >> 0) & 7) = adr;
29697 PRE_IO
29698 READ_WORD_F(adr, dst)
29699 res = dst - src;
29700 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29701 flag_N = flag_X = flag_C = res >> 8;
29702 flag_NotZ = res & 0xFFFF;
29703 WRITE_WORD_F(adr, res)
29704 POST_IO
29705RET(14)
29706}
29707
29708// SUBDa
29709OPCODE(0x9168)
29710{
29711 u32 adr, res;
29712 u32 src, dst;
29713
29714 src = DREGu16((Opcode >> 9) & 7);
29715 FETCH_SWORD(adr);
29716 adr += AREG((Opcode >> 0) & 7);
29717 PRE_IO
29718 READ_WORD_F(adr, dst)
29719 res = dst - src;
29720 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29721 flag_N = flag_X = flag_C = res >> 8;
29722 flag_NotZ = res & 0xFFFF;
29723 WRITE_WORD_F(adr, res)
29724 POST_IO
29725RET(16)
29726}
29727
29728// SUBDa
29729OPCODE(0x9170)
29730{
29731 u32 adr, res;
29732 u32 src, dst;
29733
29734 src = DREGu16((Opcode >> 9) & 7);
29735 adr = AREG((Opcode >> 0) & 7);
29736 DECODE_EXT_WORD
29737 PRE_IO
29738 READ_WORD_F(adr, dst)
29739 res = dst - src;
29740 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29741 flag_N = flag_X = flag_C = res >> 8;
29742 flag_NotZ = res & 0xFFFF;
29743 WRITE_WORD_F(adr, res)
29744 POST_IO
29745RET(18)
29746}
29747
29748// SUBDa
29749OPCODE(0x9178)
29750{
29751 u32 adr, res;
29752 u32 src, dst;
29753
29754 src = DREGu16((Opcode >> 9) & 7);
29755 FETCH_SWORD(adr);
29756 PRE_IO
29757 READ_WORD_F(adr, dst)
29758 res = dst - src;
29759 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29760 flag_N = flag_X = flag_C = res >> 8;
29761 flag_NotZ = res & 0xFFFF;
29762 WRITE_WORD_F(adr, res)
29763 POST_IO
29764RET(16)
29765}
29766
29767// SUBDa
29768OPCODE(0x9179)
29769{
29770 u32 adr, res;
29771 u32 src, dst;
29772
29773 src = DREGu16((Opcode >> 9) & 7);
29774 FETCH_LONG(adr);
29775 PRE_IO
29776 READ_WORD_F(adr, dst)
29777 res = dst - src;
29778 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29779 flag_N = flag_X = flag_C = res >> 8;
29780 flag_NotZ = res & 0xFFFF;
29781 WRITE_WORD_F(adr, res)
29782 POST_IO
29783RET(20)
29784}
29785
29786// SUBDa
29787OPCODE(0x915F)
29788{
29789 u32 adr, res;
29790 u32 src, dst;
29791
29792 src = DREGu16((Opcode >> 9) & 7);
29793 adr = AREG(7);
29794 AREG(7) += 2;
29795 PRE_IO
29796 READ_WORD_F(adr, dst)
29797 res = dst - src;
29798 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29799 flag_N = flag_X = flag_C = res >> 8;
29800 flag_NotZ = res & 0xFFFF;
29801 WRITE_WORD_F(adr, res)
29802 POST_IO
29803RET(12)
29804}
29805
29806// SUBDa
29807OPCODE(0x9167)
29808{
29809 u32 adr, res;
29810 u32 src, dst;
29811
29812 src = DREGu16((Opcode >> 9) & 7);
29813 adr = AREG(7) - 2;
29814 AREG(7) = adr;
29815 PRE_IO
29816 READ_WORD_F(adr, dst)
29817 res = dst - src;
29818 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29819 flag_N = flag_X = flag_C = res >> 8;
29820 flag_NotZ = res & 0xFFFF;
29821 WRITE_WORD_F(adr, res)
29822 POST_IO
29823RET(14)
29824}
29825
29826// SUBDa
29827OPCODE(0x9190)
29828{
29829 u32 adr, res;
29830 u32 src, dst;
29831
29832 src = DREGu32((Opcode >> 9) & 7);
29833 adr = AREG((Opcode >> 0) & 7);
29834 PRE_IO
29835 READ_LONG_F(adr, dst)
29836 res = dst - src;
29837 flag_NotZ = res;
29838 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29839 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29840 flag_N = res >> 24;
29841 WRITE_LONG_F(adr, res)
29842 POST_IO
29843RET(20)
29844}
29845
29846// SUBDa
29847OPCODE(0x9198)
29848{
29849 u32 adr, res;
29850 u32 src, dst;
29851
29852 src = DREGu32((Opcode >> 9) & 7);
29853 adr = AREG((Opcode >> 0) & 7);
29854 AREG((Opcode >> 0) & 7) += 4;
29855 PRE_IO
29856 READ_LONG_F(adr, dst)
29857 res = dst - src;
29858 flag_NotZ = res;
29859 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29860 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29861 flag_N = res >> 24;
29862 WRITE_LONG_F(adr, res)
29863 POST_IO
29864RET(20)
29865}
29866
29867// SUBDa
29868OPCODE(0x91A0)
29869{
29870 u32 adr, res;
29871 u32 src, dst;
29872
29873 src = DREGu32((Opcode >> 9) & 7);
29874 adr = AREG((Opcode >> 0) & 7) - 4;
29875 AREG((Opcode >> 0) & 7) = adr;
29876 PRE_IO
29877 READ_LONG_F(adr, dst)
29878 res = dst - src;
29879 flag_NotZ = res;
29880 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29881 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29882 flag_N = res >> 24;
29883 WRITE_LONG_F(adr, res)
29884 POST_IO
29885RET(22)
29886}
29887
29888// SUBDa
29889OPCODE(0x91A8)
29890{
29891 u32 adr, res;
29892 u32 src, dst;
29893
29894 src = DREGu32((Opcode >> 9) & 7);
29895 FETCH_SWORD(adr);
29896 adr += AREG((Opcode >> 0) & 7);
29897 PRE_IO
29898 READ_LONG_F(adr, dst)
29899 res = dst - src;
29900 flag_NotZ = res;
29901 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29902 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29903 flag_N = res >> 24;
29904 WRITE_LONG_F(adr, res)
29905 POST_IO
29906RET(24)
29907}
29908
29909// SUBDa
29910OPCODE(0x91B0)
29911{
29912 u32 adr, res;
29913 u32 src, dst;
29914
29915 src = DREGu32((Opcode >> 9) & 7);
29916 adr = AREG((Opcode >> 0) & 7);
29917 DECODE_EXT_WORD
29918 PRE_IO
29919 READ_LONG_F(adr, dst)
29920 res = dst - src;
29921 flag_NotZ = res;
29922 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29923 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29924 flag_N = res >> 24;
29925 WRITE_LONG_F(adr, res)
29926 POST_IO
29927RET(26)
29928}
29929
29930// SUBDa
29931OPCODE(0x91B8)
29932{
29933 u32 adr, res;
29934 u32 src, dst;
29935
29936 src = DREGu32((Opcode >> 9) & 7);
29937 FETCH_SWORD(adr);
29938 PRE_IO
29939 READ_LONG_F(adr, dst)
29940 res = dst - src;
29941 flag_NotZ = res;
29942 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29943 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29944 flag_N = res >> 24;
29945 WRITE_LONG_F(adr, res)
29946 POST_IO
29947RET(24)
29948}
29949
29950// SUBDa
29951OPCODE(0x91B9)
29952{
29953 u32 adr, res;
29954 u32 src, dst;
29955
29956 src = DREGu32((Opcode >> 9) & 7);
29957 FETCH_LONG(adr);
29958 PRE_IO
29959 READ_LONG_F(adr, dst)
29960 res = dst - src;
29961 flag_NotZ = res;
29962 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29963 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29964 flag_N = res >> 24;
29965 WRITE_LONG_F(adr, res)
29966 POST_IO
29967RET(28)
29968}
29969
29970// SUBDa
29971OPCODE(0x919F)
29972{
29973 u32 adr, res;
29974 u32 src, dst;
29975
29976 src = DREGu32((Opcode >> 9) & 7);
29977 adr = AREG(7);
29978 AREG(7) += 4;
29979 PRE_IO
29980 READ_LONG_F(adr, dst)
29981 res = dst - src;
29982 flag_NotZ = res;
29983 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29984 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29985 flag_N = res >> 24;
29986 WRITE_LONG_F(adr, res)
29987 POST_IO
29988RET(20)
29989}
29990
29991// SUBDa
29992OPCODE(0x91A7)
29993{
29994 u32 adr, res;
29995 u32 src, dst;
29996
29997 src = DREGu32((Opcode >> 9) & 7);
29998 adr = AREG(7) - 4;
29999 AREG(7) = adr;
30000 PRE_IO
30001 READ_LONG_F(adr, dst)
30002 res = dst - src;
30003 flag_NotZ = res;
30004 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30005 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30006 flag_N = res >> 24;
30007 WRITE_LONG_F(adr, res)
30008 POST_IO
30009RET(22)
30010}
30011
30012// SUBX
30013OPCODE(0x9100)
30014{
30015 u32 adr, res;
30016 u32 src, dst;
30017
30018 src = DREGu8((Opcode >> 0) & 7);
30019 dst = DREGu8((Opcode >> 9) & 7);
30020 res = dst - src - ((flag_X >> 8) & 1);
30021 flag_N = flag_X = flag_C = res;
30022 flag_V = (src ^ dst) & (res ^ dst);
30023 flag_NotZ |= res & 0xFF;
30024 DREGu8((Opcode >> 9) & 7) = res;
30025RET(4)
30026}
30027
30028// SUBX
30029OPCODE(0x9140)
30030{
30031 u32 adr, res;
30032 u32 src, dst;
30033
30034 src = DREGu16((Opcode >> 0) & 7);
30035 dst = DREGu16((Opcode >> 9) & 7);
30036 res = dst - src - ((flag_X >> 8) & 1);
30037 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30038 flag_N = flag_X = flag_C = res >> 8;
30039 flag_NotZ |= res & 0xFFFF;
30040 DREGu16((Opcode >> 9) & 7) = res;
30041RET(4)
30042}
30043
30044// SUBX
30045OPCODE(0x9180)
30046{
30047 u32 adr, res;
30048 u32 src, dst;
30049
30050 src = DREGu32((Opcode >> 0) & 7);
30051 dst = DREGu32((Opcode >> 9) & 7);
30052 res = dst - src - ((flag_X >> 8) & 1);
30053 flag_NotZ |= res;
30054 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30055 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30056 flag_N = res >> 24;
30057 DREGu32((Opcode >> 9) & 7) = res;
30058RET(8)
30059}
30060
30061// SUBXM
30062OPCODE(0x9108)
30063{
30064 u32 adr, res;
30065 u32 src, dst;
30066
30067 adr = AREG((Opcode >> 0) & 7) - 1;
30068 AREG((Opcode >> 0) & 7) = adr;
30069 PRE_IO
30070 READ_BYTE_F(adr, src)
30071 adr = AREG((Opcode >> 9) & 7) - 1;
30072 AREG((Opcode >> 9) & 7) = adr;
30073 READ_BYTE_F(adr, dst)
30074 res = dst - src - ((flag_X >> 8) & 1);
30075 flag_N = flag_X = flag_C = res;
30076 flag_V = (src ^ dst) & (res ^ dst);
30077 flag_NotZ |= res & 0xFF;
30078 WRITE_BYTE_F(adr, res)
30079 POST_IO
30080RET(18)
30081}
30082
30083// SUBXM
30084OPCODE(0x9148)
30085{
30086 u32 adr, res;
30087 u32 src, dst;
30088
30089 adr = AREG((Opcode >> 0) & 7) - 2;
30090 AREG((Opcode >> 0) & 7) = adr;
30091 PRE_IO
30092 READ_WORD_F(adr, src)
30093 adr = AREG((Opcode >> 9) & 7) - 2;
30094 AREG((Opcode >> 9) & 7) = adr;
30095 READ_WORD_F(adr, dst)
30096 res = dst - src - ((flag_X >> 8) & 1);
30097 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30098 flag_N = flag_X = flag_C = res >> 8;
30099 flag_NotZ |= res & 0xFFFF;
30100 WRITE_WORD_F(adr, res)
30101 POST_IO
30102RET(18)
30103}
30104
30105// SUBXM
30106OPCODE(0x9188)
30107{
30108 u32 adr, res;
30109 u32 src, dst;
30110
30111 adr = AREG((Opcode >> 0) & 7) - 4;
30112 AREG((Opcode >> 0) & 7) = adr;
30113 PRE_IO
30114 READ_LONG_F(adr, src)
30115 adr = AREG((Opcode >> 9) & 7) - 4;
30116 AREG((Opcode >> 9) & 7) = adr;
30117 READ_LONG_F(adr, dst)
30118 res = dst - src - ((flag_X >> 8) & 1);
30119 flag_NotZ |= res;
30120 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30121 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30122 flag_N = res >> 24;
30123 WRITE_LONG_F(adr, res)
30124 POST_IO
30125RET(30)
30126}
30127
30128// SUBX7M
30129OPCODE(0x910F)
30130{
30131 u32 adr, res;
30132 u32 src, dst;
30133
30134 adr = AREG(7) - 2;
30135 AREG(7) = adr;
30136 PRE_IO
30137 READ_BYTE_F(adr, src)
30138 adr = AREG((Opcode >> 9) & 7) - 1;
30139 AREG((Opcode >> 9) & 7) = adr;
30140 READ_BYTE_F(adr, dst)
30141 res = dst - src - ((flag_X >> 8) & 1);
30142 flag_N = flag_X = flag_C = res;
30143 flag_V = (src ^ dst) & (res ^ dst);
30144 flag_NotZ |= res & 0xFF;
30145 WRITE_BYTE_F(adr, res)
30146 POST_IO
30147RET(18)
30148}
30149
30150// SUBX7M
30151OPCODE(0x914F)
30152{
30153 u32 adr, res;
30154 u32 src, dst;
30155
30156 adr = AREG(7) - 2;
30157 AREG(7) = adr;
30158 PRE_IO
30159 READ_WORD_F(adr, src)
30160 adr = AREG((Opcode >> 9) & 7) - 2;
30161 AREG((Opcode >> 9) & 7) = adr;
30162 READ_WORD_F(adr, dst)
30163 res = dst - src - ((flag_X >> 8) & 1);
30164 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30165 flag_N = flag_X = flag_C = res >> 8;
30166 flag_NotZ |= res & 0xFFFF;
30167 WRITE_WORD_F(adr, res)
30168 POST_IO
30169RET(18)
30170}
30171
30172// SUBX7M
30173OPCODE(0x918F)
30174{
30175 u32 adr, res;
30176 u32 src, dst;
30177
30178 adr = AREG(7) - 4;
30179 AREG(7) = adr;
30180 PRE_IO
30181 READ_LONG_F(adr, src)
30182 adr = AREG((Opcode >> 9) & 7) - 4;
30183 AREG((Opcode >> 9) & 7) = adr;
30184 READ_LONG_F(adr, dst)
30185 res = dst - src - ((flag_X >> 8) & 1);
30186 flag_NotZ |= res;
30187 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30188 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30189 flag_N = res >> 24;
30190 WRITE_LONG_F(adr, res)
30191 POST_IO
30192RET(30)
30193}
30194
30195// SUBXM7
30196OPCODE(0x9F08)
30197{
30198 u32 adr, res;
30199 u32 src, dst;
30200
30201 adr = AREG((Opcode >> 0) & 7) - 1;
30202 AREG((Opcode >> 0) & 7) = adr;
30203 PRE_IO
30204 READ_BYTE_F(adr, src)
30205 adr = AREG(7) - 2;
30206 AREG(7) = adr;
30207 READ_BYTE_F(adr, dst)
30208 res = dst - src - ((flag_X >> 8) & 1);
30209 flag_N = flag_X = flag_C = res;
30210 flag_V = (src ^ dst) & (res ^ dst);
30211 flag_NotZ |= res & 0xFF;
30212 WRITE_BYTE_F(adr, res)
30213 POST_IO
30214RET(18)
30215}
30216
30217// SUBXM7
30218OPCODE(0x9F48)
30219{
30220 u32 adr, res;
30221 u32 src, dst;
30222
30223 adr = AREG((Opcode >> 0) & 7) - 2;
30224 AREG((Opcode >> 0) & 7) = adr;
30225 PRE_IO
30226 READ_WORD_F(adr, src)
30227 adr = AREG(7) - 2;
30228 AREG(7) = adr;
30229 READ_WORD_F(adr, dst)
30230 res = dst - src - ((flag_X >> 8) & 1);
30231 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30232 flag_N = flag_X = flag_C = res >> 8;
30233 flag_NotZ |= res & 0xFFFF;
30234 WRITE_WORD_F(adr, res)
30235 POST_IO
30236RET(18)
30237}
30238
30239// SUBXM7
30240OPCODE(0x9F88)
30241{
30242 u32 adr, res;
30243 u32 src, dst;
30244
30245 adr = AREG((Opcode >> 0) & 7) - 4;
30246 AREG((Opcode >> 0) & 7) = adr;
30247 PRE_IO
30248 READ_LONG_F(adr, src)
30249 adr = AREG(7) - 4;
30250 AREG(7) = adr;
30251 READ_LONG_F(adr, dst)
30252 res = dst - src - ((flag_X >> 8) & 1);
30253 flag_NotZ |= res;
30254 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30255 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30256 flag_N = res >> 24;
30257 WRITE_LONG_F(adr, res)
30258 POST_IO
30259RET(30)
30260}
30261
30262// SUBX7M7
30263OPCODE(0x9F0F)
30264{
30265 u32 adr, res;
30266 u32 src, dst;
30267
30268 adr = AREG(7) - 2;
30269 AREG(7) = adr;
30270 PRE_IO
30271 READ_BYTE_F(adr, src)
30272 adr = AREG(7) - 2;
30273 AREG(7) = adr;
30274 READ_BYTE_F(adr, dst)
30275 res = dst - src - ((flag_X >> 8) & 1);
30276 flag_N = flag_X = flag_C = res;
30277 flag_V = (src ^ dst) & (res ^ dst);
30278 flag_NotZ |= res & 0xFF;
30279 WRITE_BYTE_F(adr, res)
30280 POST_IO
30281RET(18)
30282}
30283
30284// SUBX7M7
30285OPCODE(0x9F4F)
30286{
30287 u32 adr, res;
30288 u32 src, dst;
30289
30290 adr = AREG(7) - 2;
30291 AREG(7) = adr;
30292 PRE_IO
30293 READ_WORD_F(adr, src)
30294 adr = AREG(7) - 2;
30295 AREG(7) = adr;
30296 READ_WORD_F(adr, dst)
30297 res = dst - src - ((flag_X >> 8) & 1);
30298 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30299 flag_N = flag_X = flag_C = res >> 8;
30300 flag_NotZ |= res & 0xFFFF;
30301 WRITE_WORD_F(adr, res)
30302 POST_IO
30303RET(18)
30304}
30305
30306// SUBX7M7
30307OPCODE(0x9F8F)
30308{
30309 u32 adr, res;
30310 u32 src, dst;
30311
30312 adr = AREG(7) - 4;
30313 AREG(7) = adr;
30314 PRE_IO
30315 READ_LONG_F(adr, src)
30316 adr = AREG(7) - 4;
30317 AREG(7) = adr;
30318 READ_LONG_F(adr, dst)
30319 res = dst - src - ((flag_X >> 8) & 1);
30320 flag_NotZ |= res;
30321 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30322 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30323 flag_N = res >> 24;
30324 WRITE_LONG_F(adr, res)
30325 POST_IO
30326RET(30)
30327}
30328
30329// SUBA
30330OPCODE(0x90C0)
30331{
30332 u32 adr, res;
30333 u32 src, dst;
30334
30335 src = (s32)DREGs16((Opcode >> 0) & 7);
30336 dst = AREGu32((Opcode >> 9) & 7);
30337 res = dst - src;
30338 AREG((Opcode >> 9) & 7) = res;
30339RET(8)
30340}
30341
30342// SUBA
30343OPCODE(0x90C8)
30344{
30345 u32 adr, res;
30346 u32 src, dst;
30347
30348 src = (s32)AREGs16((Opcode >> 0) & 7);
30349 dst = AREGu32((Opcode >> 9) & 7);
30350 res = dst - src;
30351 AREG((Opcode >> 9) & 7) = res;
30352RET(8)
30353}
30354
30355// SUBA
30356OPCODE(0x90D0)
30357{
30358 u32 adr, res;
30359 u32 src, dst;
30360
30361 adr = AREG((Opcode >> 0) & 7);
30362 PRE_IO
30363 READSX_WORD_F(adr, src)
30364 dst = AREGu32((Opcode >> 9) & 7);
30365 res = dst - src;
30366 AREG((Opcode >> 9) & 7) = res;
30367 POST_IO
30368#ifdef USE_CYCLONE_TIMING
30369RET(12)
30370#else
30371RET(10)
30372#endif
30373}
30374
30375// SUBA
30376OPCODE(0x90D8)
30377{
30378 u32 adr, res;
30379 u32 src, dst;
30380
30381 adr = AREG((Opcode >> 0) & 7);
30382 AREG((Opcode >> 0) & 7) += 2;
30383 PRE_IO
30384 READSX_WORD_F(adr, src)
30385 dst = AREGu32((Opcode >> 9) & 7);
30386 res = dst - src;
30387 AREG((Opcode >> 9) & 7) = res;
30388 POST_IO
30389#ifdef USE_CYCLONE_TIMING
30390RET(12)
30391#else
30392RET(10)
30393#endif
30394}
30395
30396// SUBA
30397OPCODE(0x90E0)
30398{
30399 u32 adr, res;
30400 u32 src, dst;
30401
30402 adr = AREG((Opcode >> 0) & 7) - 2;
30403 AREG((Opcode >> 0) & 7) = adr;
30404 PRE_IO
30405 READSX_WORD_F(adr, src)
30406 dst = AREGu32((Opcode >> 9) & 7);
30407 res = dst - src;
30408 AREG((Opcode >> 9) & 7) = res;
30409 POST_IO
30410#ifdef USE_CYCLONE_TIMING
30411RET(14)
30412#else
30413RET(12)
30414#endif
30415}
30416
30417// SUBA
30418OPCODE(0x90E8)
30419{
30420 u32 adr, res;
30421 u32 src, dst;
30422
30423 FETCH_SWORD(adr);
30424 adr += AREG((Opcode >> 0) & 7);
30425 PRE_IO
30426 READSX_WORD_F(adr, src)
30427 dst = AREGu32((Opcode >> 9) & 7);
30428 res = dst - src;
30429 AREG((Opcode >> 9) & 7) = res;
30430 POST_IO
30431#ifdef USE_CYCLONE_TIMING
30432RET(16)
30433#else
30434RET(14)
30435#endif
30436}
30437
30438// SUBA
30439OPCODE(0x90F0)
30440{
30441 u32 adr, res;
30442 u32 src, dst;
30443
30444 adr = AREG((Opcode >> 0) & 7);
30445 DECODE_EXT_WORD
30446 PRE_IO
30447 READSX_WORD_F(adr, src)
30448 dst = AREGu32((Opcode >> 9) & 7);
30449 res = dst - src;
30450 AREG((Opcode >> 9) & 7) = res;
30451 POST_IO
30452#ifdef USE_CYCLONE_TIMING
30453RET(18)
30454#else
30455RET(16)
30456#endif
30457}
30458
30459// SUBA
30460OPCODE(0x90F8)
30461{
30462 u32 adr, res;
30463 u32 src, dst;
30464
30465 FETCH_SWORD(adr);
30466 PRE_IO
30467 READSX_WORD_F(adr, src)
30468 dst = AREGu32((Opcode >> 9) & 7);
30469 res = dst - src;
30470 AREG((Opcode >> 9) & 7) = res;
30471 POST_IO
30472#ifdef USE_CYCLONE_TIMING
30473RET(16)
30474#else
30475RET(14)
30476#endif
30477}
30478
30479// SUBA
30480OPCODE(0x90F9)
30481{
30482 u32 adr, res;
30483 u32 src, dst;
30484
30485 FETCH_LONG(adr);
30486 PRE_IO
30487 READSX_WORD_F(adr, src)
30488 dst = AREGu32((Opcode >> 9) & 7);
30489 res = dst - src;
30490 AREG((Opcode >> 9) & 7) = res;
30491 POST_IO
30492#ifdef USE_CYCLONE_TIMING
30493RET(20)
30494#else
30495RET(18)
30496#endif
30497}
30498
30499// SUBA
30500OPCODE(0x90FA)
30501{
30502 u32 adr, res;
30503 u32 src, dst;
30504
30505 adr = GET_SWORD + GET_PC;
30506 PC++;
30507 PRE_IO
30508 READSX_WORD_F(adr, src)
30509 dst = AREGu32((Opcode >> 9) & 7);
30510 res = dst - src;
30511 AREG((Opcode >> 9) & 7) = res;
30512 POST_IO
30513#ifdef USE_CYCLONE_TIMING
30514RET(16)
30515#else
30516RET(14)
30517#endif
30518}
30519
30520// SUBA
30521OPCODE(0x90FB)
30522{
30523 u32 adr, res;
30524 u32 src, dst;
30525
30526 adr = GET_PC;
30527 DECODE_EXT_WORD
30528 PRE_IO
30529 READSX_WORD_F(adr, src)
30530 dst = AREGu32((Opcode >> 9) & 7);
30531 res = dst - src;
30532 AREG((Opcode >> 9) & 7) = res;
30533 POST_IO
30534#ifdef USE_CYCLONE_TIMING
30535RET(18)
30536#else
30537RET(16)
30538#endif
30539}
30540
30541// SUBA
30542OPCODE(0x90FC)
30543{
30544 u32 adr, res;
30545 u32 src, dst;
30546
30547 FETCH_SWORD(src);
30548 dst = AREGu32((Opcode >> 9) & 7);
30549 res = dst - src;
30550 AREG((Opcode >> 9) & 7) = res;
30551RET(12)
30552}
30553
30554// SUBA
30555OPCODE(0x90DF)
30556{
30557 u32 adr, res;
30558 u32 src, dst;
30559
30560 adr = AREG(7);
30561 AREG(7) += 2;
30562 PRE_IO
30563 READSX_WORD_F(adr, src)
30564 dst = AREGu32((Opcode >> 9) & 7);
30565 res = dst - src;
30566 AREG((Opcode >> 9) & 7) = res;
30567 POST_IO
30568#ifdef USE_CYCLONE_TIMING
30569RET(12)
30570#else
30571RET(10)
30572#endif
30573}
30574
30575// SUBA
30576OPCODE(0x90E7)
30577{
30578 u32 adr, res;
30579 u32 src, dst;
30580
30581 adr = AREG(7) - 2;
30582 AREG(7) = adr;
30583 PRE_IO
30584 READSX_WORD_F(adr, src)
30585 dst = AREGu32((Opcode >> 9) & 7);
30586 res = dst - src;
30587 AREG((Opcode >> 9) & 7) = res;
30588 POST_IO
30589#ifdef USE_CYCLONE_TIMING
30590RET(14)
30591#else
30592RET(12)
30593#endif
30594}
30595
30596// SUBA
30597OPCODE(0x91C0)
30598{
30599 u32 adr, res;
30600 u32 src, dst;
30601
30602 src = (s32)DREGs32((Opcode >> 0) & 7);
30603 dst = AREGu32((Opcode >> 9) & 7);
30604 res = dst - src;
30605 AREG((Opcode >> 9) & 7) = res;
30606#ifdef USE_CYCLONE_TIMING
30607RET(8)
30608#else
30609RET(6)
30610#endif
30611}
30612
30613// SUBA
30614OPCODE(0x91C8)
30615{
30616 u32 adr, res;
30617 u32 src, dst;
30618
30619 src = (s32)AREGs32((Opcode >> 0) & 7);
30620 dst = AREGu32((Opcode >> 9) & 7);
30621 res = dst - src;
30622 AREG((Opcode >> 9) & 7) = res;
30623#ifdef USE_CYCLONE_TIMING
30624RET(8)
30625#else
30626RET(6)
30627#endif
30628}
30629
30630// SUBA
30631OPCODE(0x91D0)
30632{
30633 u32 adr, res;
30634 u32 src, dst;
30635
30636 adr = AREG((Opcode >> 0) & 7);
30637 PRE_IO
30638 READSX_LONG_F(adr, src)
30639 dst = AREGu32((Opcode >> 9) & 7);
30640 res = dst - src;
30641 AREG((Opcode >> 9) & 7) = res;
30642 POST_IO
30643RET(14)
30644}
30645
30646// SUBA
30647OPCODE(0x91D8)
30648{
30649 u32 adr, res;
30650 u32 src, dst;
30651
30652 adr = AREG((Opcode >> 0) & 7);
30653 AREG((Opcode >> 0) & 7) += 4;
30654 PRE_IO
30655 READSX_LONG_F(adr, src)
30656 dst = AREGu32((Opcode >> 9) & 7);
30657 res = dst - src;
30658 AREG((Opcode >> 9) & 7) = res;
30659 POST_IO
30660RET(14)
30661}
30662
30663// SUBA
30664OPCODE(0x91E0)
30665{
30666 u32 adr, res;
30667 u32 src, dst;
30668
30669 adr = AREG((Opcode >> 0) & 7) - 4;
30670 AREG((Opcode >> 0) & 7) = adr;
30671 PRE_IO
30672 READSX_LONG_F(adr, src)
30673 dst = AREGu32((Opcode >> 9) & 7);
30674 res = dst - src;
30675 AREG((Opcode >> 9) & 7) = res;
30676 POST_IO
30677RET(16)
30678}
30679
30680// SUBA
30681OPCODE(0x91E8)
30682{
30683 u32 adr, res;
30684 u32 src, dst;
30685
30686 FETCH_SWORD(adr);
30687 adr += AREG((Opcode >> 0) & 7);
30688 PRE_IO
30689 READSX_LONG_F(adr, src)
30690 dst = AREGu32((Opcode >> 9) & 7);
30691 res = dst - src;
30692 AREG((Opcode >> 9) & 7) = res;
30693 POST_IO
30694RET(18)
30695}
30696
30697// SUBA
30698OPCODE(0x91F0)
30699{
30700 u32 adr, res;
30701 u32 src, dst;
30702
30703 adr = AREG((Opcode >> 0) & 7);
30704 DECODE_EXT_WORD
30705 PRE_IO
30706 READSX_LONG_F(adr, src)
30707 dst = AREGu32((Opcode >> 9) & 7);
30708 res = dst - src;
30709 AREG((Opcode >> 9) & 7) = res;
30710 POST_IO
30711RET(20)
30712}
30713
30714// SUBA
30715OPCODE(0x91F8)
30716{
30717 u32 adr, res;
30718 u32 src, dst;
30719
30720 FETCH_SWORD(adr);
30721 PRE_IO
30722 READSX_LONG_F(adr, src)
30723 dst = AREGu32((Opcode >> 9) & 7);
30724 res = dst - src;
30725 AREG((Opcode >> 9) & 7) = res;
30726 POST_IO
30727RET(18)
30728}
30729
30730// SUBA
30731OPCODE(0x91F9)
30732{
30733 u32 adr, res;
30734 u32 src, dst;
30735
30736 FETCH_LONG(adr);
30737 PRE_IO
30738 READSX_LONG_F(adr, src)
30739 dst = AREGu32((Opcode >> 9) & 7);
30740 res = dst - src;
30741 AREG((Opcode >> 9) & 7) = res;
30742 POST_IO
30743RET(22)
30744}
30745
30746// SUBA
30747OPCODE(0x91FA)
30748{
30749 u32 adr, res;
30750 u32 src, dst;
30751
30752 adr = GET_SWORD + GET_PC;
30753 PC++;
30754 PRE_IO
30755 READSX_LONG_F(adr, src)
30756 dst = AREGu32((Opcode >> 9) & 7);
30757 res = dst - src;
30758 AREG((Opcode >> 9) & 7) = res;
30759 POST_IO
30760RET(18)
30761}
30762
30763// SUBA
30764OPCODE(0x91FB)
30765{
30766 u32 adr, res;
30767 u32 src, dst;
30768
30769 adr = GET_PC;
30770 DECODE_EXT_WORD
30771 PRE_IO
30772 READSX_LONG_F(adr, src)
30773 dst = AREGu32((Opcode >> 9) & 7);
30774 res = dst - src;
30775 AREG((Opcode >> 9) & 7) = res;
30776 POST_IO
30777RET(20)
30778}
30779
30780// SUBA
30781OPCODE(0x91FC)
30782{
30783 u32 adr, res;
30784 u32 src, dst;
30785
30786 FETCH_LONG(src);
30787 dst = AREGu32((Opcode >> 9) & 7);
30788 res = dst - src;
30789 AREG((Opcode >> 9) & 7) = res;
30790#ifdef USE_CYCLONE_TIMING
30791RET(16)
30792#else
30793RET(14)
30794#endif
30795}
30796
30797// SUBA
30798OPCODE(0x91DF)
30799{
30800 u32 adr, res;
30801 u32 src, dst;
30802
30803 adr = AREG(7);
30804 AREG(7) += 4;
30805 PRE_IO
30806 READSX_LONG_F(adr, src)
30807 dst = AREGu32((Opcode >> 9) & 7);
30808 res = dst - src;
30809 AREG((Opcode >> 9) & 7) = res;
30810 POST_IO
30811RET(14)
30812}
30813
30814// SUBA
30815OPCODE(0x91E7)
30816{
30817 u32 adr, res;
30818 u32 src, dst;
30819
30820 adr = AREG(7) - 4;
30821 AREG(7) = adr;
30822 PRE_IO
30823 READSX_LONG_F(adr, src)
30824 dst = AREGu32((Opcode >> 9) & 7);
30825 res = dst - src;
30826 AREG((Opcode >> 9) & 7) = res;
30827 POST_IO
30828RET(16)
30829}
30830
30831// CMP
30832OPCODE(0xB000)
30833{
30834 u32 adr, res;
30835 u32 src, dst;
30836
30837 src = DREGu8((Opcode >> 0) & 7);
30838 dst = DREGu8((Opcode >> 9) & 7);
30839 res = dst - src;
30840 flag_N = flag_C = res;
30841 flag_V = (src ^ dst) & (res ^ dst);
30842 flag_NotZ = res & 0xFF;
30843RET(4)
30844}
30845
30846// CMP
30847#if 0
30848OPCODE(0xB008)
30849{
30850 u32 adr, res;
30851 u32 src, dst;
30852
30853 // can't read byte from Ax registers !
30854 ctx->execinfo |= M68K_FAULTED;
30855 ctx->io_cycle_counter = 0;
30856/*
30857 goto famec_Exec_End;
30858 dst = DREGu8((Opcode >> 9) & 7);
30859 res = dst - src;
30860 flag_N = flag_C = res;
30861 flag_V = (src ^ dst) & (res ^ dst);
30862 flag_NotZ = res & 0xFF;
30863*/
30864RET(4)
30865}
30866#endif
30867
30868// CMP
30869OPCODE(0xB010)
30870{
30871 u32 adr, res;
30872 u32 src, dst;
30873
30874 adr = AREG((Opcode >> 0) & 7);
30875 PRE_IO
30876 READ_BYTE_F(adr, src)
30877 dst = DREGu8((Opcode >> 9) & 7);
30878 res = dst - src;
30879 flag_N = flag_C = res;
30880 flag_V = (src ^ dst) & (res ^ dst);
30881 flag_NotZ = res & 0xFF;
30882 POST_IO
30883RET(8)
30884}
30885
30886// CMP
30887OPCODE(0xB018)
30888{
30889 u32 adr, res;
30890 u32 src, dst;
30891
30892 adr = AREG((Opcode >> 0) & 7);
30893 AREG((Opcode >> 0) & 7) += 1;
30894 PRE_IO
30895 READ_BYTE_F(adr, src)
30896 dst = DREGu8((Opcode >> 9) & 7);
30897 res = dst - src;
30898 flag_N = flag_C = res;
30899 flag_V = (src ^ dst) & (res ^ dst);
30900 flag_NotZ = res & 0xFF;
30901 POST_IO
30902RET(8)
30903}
30904
30905// CMP
30906OPCODE(0xB020)
30907{
30908 u32 adr, res;
30909 u32 src, dst;
30910
30911 adr = AREG((Opcode >> 0) & 7) - 1;
30912 AREG((Opcode >> 0) & 7) = adr;
30913 PRE_IO
30914 READ_BYTE_F(adr, src)
30915 dst = DREGu8((Opcode >> 9) & 7);
30916 res = dst - src;
30917 flag_N = flag_C = res;
30918 flag_V = (src ^ dst) & (res ^ dst);
30919 flag_NotZ = res & 0xFF;
30920 POST_IO
30921RET(10)
30922}
30923
30924// CMP
30925OPCODE(0xB028)
30926{
30927 u32 adr, res;
30928 u32 src, dst;
30929
30930 FETCH_SWORD(adr);
30931 adr += AREG((Opcode >> 0) & 7);
30932 PRE_IO
30933 READ_BYTE_F(adr, src)
30934 dst = DREGu8((Opcode >> 9) & 7);
30935 res = dst - src;
30936 flag_N = flag_C = res;
30937 flag_V = (src ^ dst) & (res ^ dst);
30938 flag_NotZ = res & 0xFF;
30939 POST_IO
30940RET(12)
30941}
30942
30943// CMP
30944OPCODE(0xB030)
30945{
30946 u32 adr, res;
30947 u32 src, dst;
30948
30949 adr = AREG((Opcode >> 0) & 7);
30950 DECODE_EXT_WORD
30951 PRE_IO
30952 READ_BYTE_F(adr, src)
30953 dst = DREGu8((Opcode >> 9) & 7);
30954 res = dst - src;
30955 flag_N = flag_C = res;
30956 flag_V = (src ^ dst) & (res ^ dst);
30957 flag_NotZ = res & 0xFF;
30958 POST_IO
30959RET(14)
30960}
30961
30962// CMP
30963OPCODE(0xB038)
30964{
30965 u32 adr, res;
30966 u32 src, dst;
30967
30968 FETCH_SWORD(adr);
30969 PRE_IO
30970 READ_BYTE_F(adr, src)
30971 dst = DREGu8((Opcode >> 9) & 7);
30972 res = dst - src;
30973 flag_N = flag_C = res;
30974 flag_V = (src ^ dst) & (res ^ dst);
30975 flag_NotZ = res & 0xFF;
30976 POST_IO
30977RET(12)
30978}
30979
30980// CMP
30981OPCODE(0xB039)
30982{
30983 u32 adr, res;
30984 u32 src, dst;
30985
30986 FETCH_LONG(adr);
30987 PRE_IO
30988 READ_BYTE_F(adr, src)
30989 dst = DREGu8((Opcode >> 9) & 7);
30990 res = dst - src;
30991 flag_N = flag_C = res;
30992 flag_V = (src ^ dst) & (res ^ dst);
30993 flag_NotZ = res & 0xFF;
30994 POST_IO
30995RET(16)
30996}
30997
30998// CMP
30999OPCODE(0xB03A)
31000{
31001 u32 adr, res;
31002 u32 src, dst;
31003
31004 adr = GET_SWORD + GET_PC;
31005 PC++;
31006 PRE_IO
31007 READ_BYTE_F(adr, src)
31008 dst = DREGu8((Opcode >> 9) & 7);
31009 res = dst - src;
31010 flag_N = flag_C = res;
31011 flag_V = (src ^ dst) & (res ^ dst);
31012 flag_NotZ = res & 0xFF;
31013 POST_IO
31014RET(12)
31015}
31016
31017// CMP
31018OPCODE(0xB03B)
31019{
31020 u32 adr, res;
31021 u32 src, dst;
31022
31023 adr = GET_PC;
31024 DECODE_EXT_WORD
31025 PRE_IO
31026 READ_BYTE_F(adr, src)
31027 dst = DREGu8((Opcode >> 9) & 7);
31028 res = dst - src;
31029 flag_N = flag_C = res;
31030 flag_V = (src ^ dst) & (res ^ dst);
31031 flag_NotZ = res & 0xFF;
31032 POST_IO
31033RET(14)
31034}
31035
31036// CMP
31037OPCODE(0xB03C)
31038{
31039 u32 adr, res;
31040 u32 src, dst;
31041
31042 FETCH_BYTE(src);
31043 dst = DREGu8((Opcode >> 9) & 7);
31044 res = dst - src;
31045 flag_N = flag_C = res;
31046 flag_V = (src ^ dst) & (res ^ dst);
31047 flag_NotZ = res & 0xFF;
31048RET(8)
31049}
31050
31051// CMP
31052OPCODE(0xB01F)
31053{
31054 u32 adr, res;
31055 u32 src, dst;
31056
31057 adr = AREG(7);
31058 AREG(7) += 2;
31059 PRE_IO
31060 READ_BYTE_F(adr, src)
31061 dst = DREGu8((Opcode >> 9) & 7);
31062 res = dst - src;
31063 flag_N = flag_C = res;
31064 flag_V = (src ^ dst) & (res ^ dst);
31065 flag_NotZ = res & 0xFF;
31066 POST_IO
31067RET(8)
31068}
31069
31070// CMP
31071OPCODE(0xB027)
31072{
31073 u32 adr, res;
31074 u32 src, dst;
31075
31076 adr = AREG(7) - 2;
31077 AREG(7) = adr;
31078 PRE_IO
31079 READ_BYTE_F(adr, src)
31080 dst = DREGu8((Opcode >> 9) & 7);
31081 res = dst - src;
31082 flag_N = flag_C = res;
31083 flag_V = (src ^ dst) & (res ^ dst);
31084 flag_NotZ = res & 0xFF;
31085 POST_IO
31086RET(10)
31087}
31088
31089// CMP
31090OPCODE(0xB040)
31091{
31092 u32 adr, res;
31093 u32 src, dst;
31094
31095 src = DREGu16((Opcode >> 0) & 7);
31096 dst = DREGu16((Opcode >> 9) & 7);
31097 res = dst - src;
31098 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31099 flag_N = flag_C = res >> 8;
31100 flag_NotZ = res & 0xFFFF;
31101RET(4)
31102}
31103
31104// CMP
31105OPCODE(0xB048)
31106{
31107 u32 adr, res;
31108 u32 src, dst;
31109
31110 src = AREGu16((Opcode >> 0) & 7);
31111 dst = DREGu16((Opcode >> 9) & 7);
31112 res = dst - src;
31113 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31114 flag_N = flag_C = res >> 8;
31115 flag_NotZ = res & 0xFFFF;
31116RET(4)
31117}
31118
31119// CMP
31120OPCODE(0xB050)
31121{
31122 u32 adr, res;
31123 u32 src, dst;
31124
31125 adr = AREG((Opcode >> 0) & 7);
31126 PRE_IO
31127 READ_WORD_F(adr, src)
31128 dst = DREGu16((Opcode >> 9) & 7);
31129 res = dst - src;
31130 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31131 flag_N = flag_C = res >> 8;
31132 flag_NotZ = res & 0xFFFF;
31133 POST_IO
31134RET(8)
31135}
31136
31137// CMP
31138OPCODE(0xB058)
31139{
31140 u32 adr, res;
31141 u32 src, dst;
31142
31143 adr = AREG((Opcode >> 0) & 7);
31144 AREG((Opcode >> 0) & 7) += 2;
31145 PRE_IO
31146 READ_WORD_F(adr, src)
31147 dst = DREGu16((Opcode >> 9) & 7);
31148 res = dst - src;
31149 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31150 flag_N = flag_C = res >> 8;
31151 flag_NotZ = res & 0xFFFF;
31152 POST_IO
31153RET(8)
31154}
31155
31156// CMP
31157OPCODE(0xB060)
31158{
31159 u32 adr, res;
31160 u32 src, dst;
31161
31162 adr = AREG((Opcode >> 0) & 7) - 2;
31163 AREG((Opcode >> 0) & 7) = adr;
31164 PRE_IO
31165 READ_WORD_F(adr, src)
31166 dst = DREGu16((Opcode >> 9) & 7);
31167 res = dst - src;
31168 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31169 flag_N = flag_C = res >> 8;
31170 flag_NotZ = res & 0xFFFF;
31171 POST_IO
31172RET(10)
31173}
31174
31175// CMP
31176OPCODE(0xB068)
31177{
31178 u32 adr, res;
31179 u32 src, dst;
31180
31181 FETCH_SWORD(adr);
31182 adr += AREG((Opcode >> 0) & 7);
31183 PRE_IO
31184 READ_WORD_F(adr, src)
31185 dst = DREGu16((Opcode >> 9) & 7);
31186 res = dst - src;
31187 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31188 flag_N = flag_C = res >> 8;
31189 flag_NotZ = res & 0xFFFF;
31190 POST_IO
31191RET(12)
31192}
31193
31194// CMP
31195OPCODE(0xB070)
31196{
31197 u32 adr, res;
31198 u32 src, dst;
31199
31200 adr = AREG((Opcode >> 0) & 7);
31201 DECODE_EXT_WORD
31202 PRE_IO
31203 READ_WORD_F(adr, src)
31204 dst = DREGu16((Opcode >> 9) & 7);
31205 res = dst - src;
31206 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31207 flag_N = flag_C = res >> 8;
31208 flag_NotZ = res & 0xFFFF;
31209 POST_IO
31210RET(14)
31211}
31212
31213// CMP
31214OPCODE(0xB078)
31215{
31216 u32 adr, res;
31217 u32 src, dst;
31218
31219 FETCH_SWORD(adr);
31220 PRE_IO
31221 READ_WORD_F(adr, src)
31222 dst = DREGu16((Opcode >> 9) & 7);
31223 res = dst - src;
31224 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31225 flag_N = flag_C = res >> 8;
31226 flag_NotZ = res & 0xFFFF;
31227 POST_IO
31228RET(12)
31229}
31230
31231// CMP
31232OPCODE(0xB079)
31233{
31234 u32 adr, res;
31235 u32 src, dst;
31236
31237 FETCH_LONG(adr);
31238 PRE_IO
31239 READ_WORD_F(adr, src)
31240 dst = DREGu16((Opcode >> 9) & 7);
31241 res = dst - src;
31242 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31243 flag_N = flag_C = res >> 8;
31244 flag_NotZ = res & 0xFFFF;
31245 POST_IO
31246RET(16)
31247}
31248
31249// CMP
31250OPCODE(0xB07A)
31251{
31252 u32 adr, res;
31253 u32 src, dst;
31254
31255 adr = GET_SWORD + GET_PC;
31256 PC++;
31257 PRE_IO
31258 READ_WORD_F(adr, src)
31259 dst = DREGu16((Opcode >> 9) & 7);
31260 res = dst - src;
31261 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31262 flag_N = flag_C = res >> 8;
31263 flag_NotZ = res & 0xFFFF;
31264 POST_IO
31265RET(12)
31266}
31267
31268// CMP
31269OPCODE(0xB07B)
31270{
31271 u32 adr, res;
31272 u32 src, dst;
31273
31274 adr = GET_PC;
31275 DECODE_EXT_WORD
31276 PRE_IO
31277 READ_WORD_F(adr, src)
31278 dst = DREGu16((Opcode >> 9) & 7);
31279 res = dst - src;
31280 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31281 flag_N = flag_C = res >> 8;
31282 flag_NotZ = res & 0xFFFF;
31283 POST_IO
31284RET(14)
31285}
31286
31287// CMP
31288OPCODE(0xB07C)
31289{
31290 u32 adr, res;
31291 u32 src, dst;
31292
31293 FETCH_WORD(src);
31294 dst = DREGu16((Opcode >> 9) & 7);
31295 res = dst - src;
31296 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31297 flag_N = flag_C = res >> 8;
31298 flag_NotZ = res & 0xFFFF;
31299RET(8)
31300}
31301
31302// CMP
31303OPCODE(0xB05F)
31304{
31305 u32 adr, res;
31306 u32 src, dst;
31307
31308 adr = AREG(7);
31309 AREG(7) += 2;
31310 PRE_IO
31311 READ_WORD_F(adr, src)
31312 dst = DREGu16((Opcode >> 9) & 7);
31313 res = dst - src;
31314 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31315 flag_N = flag_C = res >> 8;
31316 flag_NotZ = res & 0xFFFF;
31317 POST_IO
31318RET(8)
31319}
31320
31321// CMP
31322OPCODE(0xB067)
31323{
31324 u32 adr, res;
31325 u32 src, dst;
31326
31327 adr = AREG(7) - 2;
31328 AREG(7) = adr;
31329 PRE_IO
31330 READ_WORD_F(adr, src)
31331 dst = DREGu16((Opcode >> 9) & 7);
31332 res = dst - src;
31333 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31334 flag_N = flag_C = res >> 8;
31335 flag_NotZ = res & 0xFFFF;
31336 POST_IO
31337RET(10)
31338}
31339
31340// CMP
31341OPCODE(0xB080)
31342{
31343 u32 adr, res;
31344 u32 src, dst;
31345
31346 src = DREGu32((Opcode >> 0) & 7);
31347 dst = DREGu32((Opcode >> 9) & 7);
31348 res = dst - src;
31349 flag_NotZ = res;
31350 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31351 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31352 flag_N = res >> 24;
31353RET(6)
31354}
31355
31356// CMP
31357OPCODE(0xB088)
31358{
31359 u32 adr, res;
31360 u32 src, dst;
31361
31362 src = AREGu32((Opcode >> 0) & 7);
31363 dst = DREGu32((Opcode >> 9) & 7);
31364 res = dst - src;
31365 flag_NotZ = res;
31366 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31367 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31368 flag_N = res >> 24;
31369RET(6)
31370}
31371
31372// CMP
31373OPCODE(0xB090)
31374{
31375 u32 adr, res;
31376 u32 src, dst;
31377
31378 adr = AREG((Opcode >> 0) & 7);
31379 PRE_IO
31380 READ_LONG_F(adr, src)
31381 dst = DREGu32((Opcode >> 9) & 7);
31382 res = dst - src;
31383 flag_NotZ = res;
31384 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31385 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31386 flag_N = res >> 24;
31387 POST_IO
31388RET(14)
31389}
31390
31391// CMP
31392OPCODE(0xB098)
31393{
31394 u32 adr, res;
31395 u32 src, dst;
31396
31397 adr = AREG((Opcode >> 0) & 7);
31398 AREG((Opcode >> 0) & 7) += 4;
31399 PRE_IO
31400 READ_LONG_F(adr, src)
31401 dst = DREGu32((Opcode >> 9) & 7);
31402 res = dst - src;
31403 flag_NotZ = res;
31404 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31405 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31406 flag_N = res >> 24;
31407 POST_IO
31408RET(14)
31409}
31410
31411// CMP
31412OPCODE(0xB0A0)
31413{
31414 u32 adr, res;
31415 u32 src, dst;
31416
31417 adr = AREG((Opcode >> 0) & 7) - 4;
31418 AREG((Opcode >> 0) & 7) = adr;
31419 PRE_IO
31420 READ_LONG_F(adr, src)
31421 dst = DREGu32((Opcode >> 9) & 7);
31422 res = dst - src;
31423 flag_NotZ = res;
31424 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31425 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31426 flag_N = res >> 24;
31427 POST_IO
31428RET(16)
31429}
31430
31431// CMP
31432OPCODE(0xB0A8)
31433{
31434 u32 adr, res;
31435 u32 src, dst;
31436
31437 FETCH_SWORD(adr);
31438 adr += AREG((Opcode >> 0) & 7);
31439 PRE_IO
31440 READ_LONG_F(adr, src)
31441 dst = DREGu32((Opcode >> 9) & 7);
31442 res = dst - src;
31443 flag_NotZ = res;
31444 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31445 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31446 flag_N = res >> 24;
31447 POST_IO
31448RET(18)
31449}
31450
31451// CMP
31452OPCODE(0xB0B0)
31453{
31454 u32 adr, res;
31455 u32 src, dst;
31456
31457 adr = AREG((Opcode >> 0) & 7);
31458 DECODE_EXT_WORD
31459 PRE_IO
31460 READ_LONG_F(adr, src)
31461 dst = DREGu32((Opcode >> 9) & 7);
31462 res = dst - src;
31463 flag_NotZ = res;
31464 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31465 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31466 flag_N = res >> 24;
31467 POST_IO
31468RET(20)
31469}
31470
31471// CMP
31472OPCODE(0xB0B8)
31473{
31474 u32 adr, res;
31475 u32 src, dst;
31476
31477 FETCH_SWORD(adr);
31478 PRE_IO
31479 READ_LONG_F(adr, src)
31480 dst = DREGu32((Opcode >> 9) & 7);
31481 res = dst - src;
31482 flag_NotZ = res;
31483 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31484 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31485 flag_N = res >> 24;
31486 POST_IO
31487RET(18)
31488}
31489
31490// CMP
31491OPCODE(0xB0B9)
31492{
31493 u32 adr, res;
31494 u32 src, dst;
31495
31496 FETCH_LONG(adr);
31497 PRE_IO
31498 READ_LONG_F(adr, src)
31499 dst = DREGu32((Opcode >> 9) & 7);
31500 res = dst - src;
31501 flag_NotZ = res;
31502 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31503 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31504 flag_N = res >> 24;
31505 POST_IO
31506RET(22)
31507}
31508
31509// CMP
31510OPCODE(0xB0BA)
31511{
31512 u32 adr, res;
31513 u32 src, dst;
31514
31515 adr = GET_SWORD + GET_PC;
31516 PC++;
31517 PRE_IO
31518 READ_LONG_F(adr, src)
31519 dst = DREGu32((Opcode >> 9) & 7);
31520 res = dst - src;
31521 flag_NotZ = res;
31522 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31523 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31524 flag_N = res >> 24;
31525 POST_IO
31526RET(18)
31527}
31528
31529// CMP
31530OPCODE(0xB0BB)
31531{
31532 u32 adr, res;
31533 u32 src, dst;
31534
31535 adr = GET_PC;
31536 DECODE_EXT_WORD
31537 PRE_IO
31538 READ_LONG_F(adr, src)
31539 dst = DREGu32((Opcode >> 9) & 7);
31540 res = dst - src;
31541 flag_NotZ = res;
31542 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31543 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31544 flag_N = res >> 24;
31545 POST_IO
31546RET(20)
31547}
31548
31549// CMP
31550OPCODE(0xB0BC)
31551{
31552 u32 adr, res;
31553 u32 src, dst;
31554
31555 FETCH_LONG(src);
31556 dst = DREGu32((Opcode >> 9) & 7);
31557 res = dst - src;
31558 flag_NotZ = res;
31559 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31560 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31561 flag_N = res >> 24;
31562RET(14)
31563}
31564
31565// CMP
31566OPCODE(0xB09F)
31567{
31568 u32 adr, res;
31569 u32 src, dst;
31570
31571 adr = AREG(7);
31572 AREG(7) += 4;
31573 PRE_IO
31574 READ_LONG_F(adr, src)
31575 dst = DREGu32((Opcode >> 9) & 7);
31576 res = dst - src;
31577 flag_NotZ = res;
31578 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31579 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31580 flag_N = res >> 24;
31581 POST_IO
31582RET(14)
31583}
31584
31585// CMP
31586OPCODE(0xB0A7)
31587{
31588 u32 adr, res;
31589 u32 src, dst;
31590
31591 adr = AREG(7) - 4;
31592 AREG(7) = adr;
31593 PRE_IO
31594 READ_LONG_F(adr, src)
31595 dst = DREGu32((Opcode >> 9) & 7);
31596 res = dst - src;
31597 flag_NotZ = res;
31598 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31599 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31600 flag_N = res >> 24;
31601 POST_IO
31602RET(16)
31603}
31604
31605// CMPM
31606OPCODE(0xB108)
31607{
31608 u32 adr, res;
31609 u32 src, dst;
31610
31611 adr = AREG((Opcode >> 0) & 7);
31612 AREG((Opcode >> 0) & 7) += 1;
31613 PRE_IO
31614 READ_BYTE_F(adr, src)
31615 adr = AREG((Opcode >> 9) & 7);
31616 AREG((Opcode >> 9) & 7) += 1;
31617 READ_BYTE_F(adr, dst)
31618 res = dst - src;
31619 flag_N = flag_C = res;
31620 flag_V = (src ^ dst) & (res ^ dst);
31621 flag_NotZ = res & 0xFF;
31622 POST_IO
31623RET(12)
31624}
31625
31626// CMPM
31627OPCODE(0xB148)
31628{
31629 u32 adr, res;
31630 u32 src, dst;
31631
31632 adr = AREG((Opcode >> 0) & 7);
31633 AREG((Opcode >> 0) & 7) += 2;
31634 PRE_IO
31635 READ_WORD_F(adr, src)
31636 adr = AREG((Opcode >> 9) & 7);
31637 AREG((Opcode >> 9) & 7) += 2;
31638 READ_WORD_F(adr, dst)
31639 res = dst - src;
31640 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31641 flag_N = flag_C = res >> 8;
31642 flag_NotZ = res & 0xFFFF;
31643 POST_IO
31644RET(12)
31645}
31646
31647// CMPM
31648OPCODE(0xB188)
31649{
31650 u32 adr, res;
31651 u32 src, dst;
31652
31653 adr = AREG((Opcode >> 0) & 7);
31654 AREG((Opcode >> 0) & 7) += 4;
31655 PRE_IO
31656 READ_LONG_F(adr, src)
31657 adr = AREG((Opcode >> 9) & 7);
31658 AREG((Opcode >> 9) & 7) += 4;
31659 READ_LONG_F(adr, dst)
31660 res = dst - src;
31661 flag_NotZ = res;
31662 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31663 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31664 flag_N = res >> 24;
31665 POST_IO
31666RET(20)
31667}
31668
31669// CMP7M
31670OPCODE(0xB10F)
31671{
31672 u32 adr, res;
31673 u32 src, dst;
31674
31675 adr = AREG(7);
31676 AREG(7) += 2;
31677 PRE_IO
31678 READ_BYTE_F(adr, src)
31679 adr = AREG((Opcode >> 9) & 7);
31680 AREG((Opcode >> 9) & 7) += 1;
31681 READ_BYTE_F(adr, dst)
31682 res = dst - src;
31683 flag_N = flag_C = res;
31684 flag_V = (src ^ dst) & (res ^ dst);
31685 flag_NotZ = res & 0xFF;
31686 POST_IO
31687RET(12)
31688}
31689
31690// CMP7M
31691OPCODE(0xB14F)
31692{
31693 u32 adr, res;
31694 u32 src, dst;
31695
31696 adr = AREG(7);
31697 AREG(7) += 2;
31698 PRE_IO
31699 READ_WORD_F(adr, src)
31700 adr = AREG((Opcode >> 9) & 7);
31701 AREG((Opcode >> 9) & 7) += 2;
31702 READ_WORD_F(adr, dst)
31703 res = dst - src;
31704 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31705 flag_N = flag_C = res >> 8;
31706 flag_NotZ = res & 0xFFFF;
31707 POST_IO
31708RET(12)
31709}
31710
31711// CMP7M
31712OPCODE(0xB18F)
31713{
31714 u32 adr, res;
31715 u32 src, dst;
31716
31717 adr = AREG(7);
31718 AREG(7) += 4;
31719 PRE_IO
31720 READ_LONG_F(adr, src)
31721 adr = AREG((Opcode >> 9) & 7);
31722 AREG((Opcode >> 9) & 7) += 4;
31723 READ_LONG_F(adr, dst)
31724 res = dst - src;
31725 flag_NotZ = res;
31726 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31727 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31728 flag_N = res >> 24;
31729 POST_IO
31730RET(20)
31731}
31732
31733// CMPM7
31734OPCODE(0xBF08)
31735{
31736 u32 adr, res;
31737 u32 src, dst;
31738
31739 adr = AREG((Opcode >> 0) & 7);
31740 AREG((Opcode >> 0) & 7) += 1;
31741 PRE_IO
31742 READ_BYTE_F(adr, src)
31743 adr = AREG(7);
31744 AREG(7) += 2;
31745 READ_BYTE_F(adr, dst)
31746 res = dst - src;
31747 flag_N = flag_C = res;
31748 flag_V = (src ^ dst) & (res ^ dst);
31749 flag_NotZ = res & 0xFF;
31750 POST_IO
31751RET(12)
31752}
31753
31754// CMPM7
31755OPCODE(0xBF48)
31756{
31757 u32 adr, res;
31758 u32 src, dst;
31759
31760 adr = AREG((Opcode >> 0) & 7);
31761 AREG((Opcode >> 0) & 7) += 2;
31762 PRE_IO
31763 READ_WORD_F(adr, src)
31764 adr = AREG(7);
31765 AREG(7) += 2;
31766 READ_WORD_F(adr, dst)
31767 res = dst - src;
31768 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31769 flag_N = flag_C = res >> 8;
31770 flag_NotZ = res & 0xFFFF;
31771 POST_IO
31772RET(12)
31773}
31774
31775// CMPM7
31776OPCODE(0xBF88)
31777{
31778 u32 adr, res;
31779 u32 src, dst;
31780
31781 adr = AREG((Opcode >> 0) & 7);
31782 AREG((Opcode >> 0) & 7) += 4;
31783 PRE_IO
31784 READ_LONG_F(adr, src)
31785 adr = AREG(7);
31786 AREG(7) += 4;
31787 READ_LONG_F(adr, dst)
31788 res = dst - src;
31789 flag_NotZ = res;
31790 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31791 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31792 flag_N = res >> 24;
31793 POST_IO
31794RET(20)
31795}
31796
31797// CMP7M7
31798OPCODE(0xBF0F)
31799{
31800 u32 adr, res;
31801 u32 src, dst;
31802
31803 adr = AREG(7);
31804 AREG(7) += 2;
31805 PRE_IO
31806 READ_BYTE_F(adr, src)
31807 adr = AREG(7);
31808 AREG(7) += 2;
31809 READ_BYTE_F(adr, dst)
31810 res = dst - src;
31811 flag_N = flag_C = res;
31812 flag_V = (src ^ dst) & (res ^ dst);
31813 flag_NotZ = res & 0xFF;
31814 POST_IO
31815RET(12)
31816}
31817
31818// CMP7M7
31819OPCODE(0xBF4F)
31820{
31821 u32 adr, res;
31822 u32 src, dst;
31823
31824 adr = AREG(7);
31825 AREG(7) += 2;
31826 PRE_IO
31827 READ_WORD_F(adr, src)
31828 adr = AREG(7);
31829 AREG(7) += 2;
31830 READ_WORD_F(adr, dst)
31831 res = dst - src;
31832 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31833 flag_N = flag_C = res >> 8;
31834 flag_NotZ = res & 0xFFFF;
31835 POST_IO
31836RET(12)
31837}
31838
31839// CMP7M7
31840OPCODE(0xBF8F)
31841{
31842 u32 adr, res;
31843 u32 src, dst;
31844
31845 adr = AREG(7);
31846 AREG(7) += 4;
31847 PRE_IO
31848 READ_LONG_F(adr, src)
31849 adr = AREG(7);
31850 AREG(7) += 4;
31851 READ_LONG_F(adr, dst)
31852 res = dst - src;
31853 flag_NotZ = res;
31854 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31855 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31856 flag_N = res >> 24;
31857 POST_IO
31858RET(20)
31859}
31860
31861// EORDa
31862OPCODE(0xB100)
31863{
31864 u32 adr, res;
31865 u32 src, dst;
31866
31867 src = DREGu8((Opcode >> 9) & 7);
31868 res = DREGu8((Opcode >> 0) & 7);
31869 res ^= src;
31870 flag_C = 0;
31871 flag_V = 0;
31872 flag_NotZ = res;
31873 flag_N = res;
31874 DREGu8((Opcode >> 0) & 7) = res;
31875RET(4)
31876}
31877
31878// EORDa
31879OPCODE(0xB110)
31880{
31881 u32 adr, res;
31882 u32 src, dst;
31883
31884 src = DREGu8((Opcode >> 9) & 7);
31885 adr = AREG((Opcode >> 0) & 7);
31886 PRE_IO
31887 READ_BYTE_F(adr, res)
31888 res ^= src;
31889 flag_C = 0;
31890 flag_V = 0;
31891 flag_NotZ = res;
31892 flag_N = res;
31893 WRITE_BYTE_F(adr, res)
31894 POST_IO
31895RET(12)
31896}
31897
31898// EORDa
31899OPCODE(0xB118)
31900{
31901 u32 adr, res;
31902 u32 src, dst;
31903
31904 src = DREGu8((Opcode >> 9) & 7);
31905 adr = AREG((Opcode >> 0) & 7);
31906 AREG((Opcode >> 0) & 7) += 1;
31907 PRE_IO
31908 READ_BYTE_F(adr, res)
31909 res ^= src;
31910 flag_C = 0;
31911 flag_V = 0;
31912 flag_NotZ = res;
31913 flag_N = res;
31914 WRITE_BYTE_F(adr, res)
31915 POST_IO
31916RET(12)
31917}
31918
31919// EORDa
31920OPCODE(0xB120)
31921{
31922 u32 adr, res;
31923 u32 src, dst;
31924
31925 src = DREGu8((Opcode >> 9) & 7);
31926 adr = AREG((Opcode >> 0) & 7) - 1;
31927 AREG((Opcode >> 0) & 7) = adr;
31928 PRE_IO
31929 READ_BYTE_F(adr, res)
31930 res ^= src;
31931 flag_C = 0;
31932 flag_V = 0;
31933 flag_NotZ = res;
31934 flag_N = res;
31935 WRITE_BYTE_F(adr, res)
31936 POST_IO
31937RET(14)
31938}
31939
31940// EORDa
31941OPCODE(0xB128)
31942{
31943 u32 adr, res;
31944 u32 src, dst;
31945
31946 src = DREGu8((Opcode >> 9) & 7);
31947 FETCH_SWORD(adr);
31948 adr += AREG((Opcode >> 0) & 7);
31949 PRE_IO
31950 READ_BYTE_F(adr, res)
31951 res ^= src;
31952 flag_C = 0;
31953 flag_V = 0;
31954 flag_NotZ = res;
31955 flag_N = res;
31956 WRITE_BYTE_F(adr, res)
31957 POST_IO
31958RET(16)
31959}
31960
31961// EORDa
31962OPCODE(0xB130)
31963{
31964 u32 adr, res;
31965 u32 src, dst;
31966
31967 src = DREGu8((Opcode >> 9) & 7);
31968 adr = AREG((Opcode >> 0) & 7);
31969 DECODE_EXT_WORD
31970 PRE_IO
31971 READ_BYTE_F(adr, res)
31972 res ^= src;
31973 flag_C = 0;
31974 flag_V = 0;
31975 flag_NotZ = res;
31976 flag_N = res;
31977 WRITE_BYTE_F(adr, res)
31978 POST_IO
31979RET(18)
31980}
31981
31982// EORDa
31983OPCODE(0xB138)
31984{
31985 u32 adr, res;
31986 u32 src, dst;
31987
31988 src = DREGu8((Opcode >> 9) & 7);
31989 FETCH_SWORD(adr);
31990 PRE_IO
31991 READ_BYTE_F(adr, res)
31992 res ^= src;
31993 flag_C = 0;
31994 flag_V = 0;
31995 flag_NotZ = res;
31996 flag_N = res;
31997 WRITE_BYTE_F(adr, res)
31998 POST_IO
31999RET(16)
32000}
32001
32002// EORDa
32003OPCODE(0xB139)
32004{
32005 u32 adr, res;
32006 u32 src, dst;
32007
32008 src = DREGu8((Opcode >> 9) & 7);
32009 FETCH_LONG(adr);
32010 PRE_IO
32011 READ_BYTE_F(adr, res)
32012 res ^= src;
32013 flag_C = 0;
32014 flag_V = 0;
32015 flag_NotZ = res;
32016 flag_N = res;
32017 WRITE_BYTE_F(adr, res)
32018 POST_IO
32019RET(20)
32020}
32021
32022// EORDa
32023OPCODE(0xB11F)
32024{
32025 u32 adr, res;
32026 u32 src, dst;
32027
32028 src = DREGu8((Opcode >> 9) & 7);
32029 adr = AREG(7);
32030 AREG(7) += 2;
32031 PRE_IO
32032 READ_BYTE_F(adr, res)
32033 res ^= src;
32034 flag_C = 0;
32035 flag_V = 0;
32036 flag_NotZ = res;
32037 flag_N = res;
32038 WRITE_BYTE_F(adr, res)
32039 POST_IO
32040RET(12)
32041}
32042
32043// EORDa
32044OPCODE(0xB127)
32045{
32046 u32 adr, res;
32047 u32 src, dst;
32048
32049 src = DREGu8((Opcode >> 9) & 7);
32050 adr = AREG(7) - 2;
32051 AREG(7) = adr;
32052 PRE_IO
32053 READ_BYTE_F(adr, res)
32054 res ^= src;
32055 flag_C = 0;
32056 flag_V = 0;
32057 flag_NotZ = res;
32058 flag_N = res;
32059 WRITE_BYTE_F(adr, res)
32060 POST_IO
32061RET(14)
32062}
32063
32064// EORDa
32065OPCODE(0xB140)
32066{
32067 u32 adr, res;
32068 u32 src, dst;
32069
32070 src = DREGu16((Opcode >> 9) & 7);
32071 res = DREGu16((Opcode >> 0) & 7);
32072 res ^= src;
32073 flag_C = 0;
32074 flag_V = 0;
32075 flag_NotZ = res;
32076 flag_N = res >> 8;
32077 DREGu16((Opcode >> 0) & 7) = res;
32078RET(4)
32079}
32080
32081// EORDa
32082OPCODE(0xB150)
32083{
32084 u32 adr, res;
32085 u32 src, dst;
32086
32087 src = DREGu16((Opcode >> 9) & 7);
32088 adr = AREG((Opcode >> 0) & 7);
32089 PRE_IO
32090 READ_WORD_F(adr, res)
32091 res ^= src;
32092 flag_C = 0;
32093 flag_V = 0;
32094 flag_NotZ = res;
32095 flag_N = res >> 8;
32096 WRITE_WORD_F(adr, res)
32097 POST_IO
32098RET(12)
32099}
32100
32101// EORDa
32102OPCODE(0xB158)
32103{
32104 u32 adr, res;
32105 u32 src, dst;
32106
32107 src = DREGu16((Opcode >> 9) & 7);
32108 adr = AREG((Opcode >> 0) & 7);
32109 AREG((Opcode >> 0) & 7) += 2;
32110 PRE_IO
32111 READ_WORD_F(adr, res)
32112 res ^= src;
32113 flag_C = 0;
32114 flag_V = 0;
32115 flag_NotZ = res;
32116 flag_N = res >> 8;
32117 WRITE_WORD_F(adr, res)
32118 POST_IO
32119RET(12)
32120}
32121
32122// EORDa
32123OPCODE(0xB160)
32124{
32125 u32 adr, res;
32126 u32 src, dst;
32127
32128 src = DREGu16((Opcode >> 9) & 7);
32129 adr = AREG((Opcode >> 0) & 7) - 2;
32130 AREG((Opcode >> 0) & 7) = adr;
32131 PRE_IO
32132 READ_WORD_F(adr, res)
32133 res ^= src;
32134 flag_C = 0;
32135 flag_V = 0;
32136 flag_NotZ = res;
32137 flag_N = res >> 8;
32138 WRITE_WORD_F(adr, res)
32139 POST_IO
32140RET(14)
32141}
32142
32143// EORDa
32144OPCODE(0xB168)
32145{
32146 u32 adr, res;
32147 u32 src, dst;
32148
32149 src = DREGu16((Opcode >> 9) & 7);
32150 FETCH_SWORD(adr);
32151 adr += AREG((Opcode >> 0) & 7);
32152 PRE_IO
32153 READ_WORD_F(adr, res)
32154 res ^= src;
32155 flag_C = 0;
32156 flag_V = 0;
32157 flag_NotZ = res;
32158 flag_N = res >> 8;
32159 WRITE_WORD_F(adr, res)
32160 POST_IO
32161RET(16)
32162}
32163
32164// EORDa
32165OPCODE(0xB170)
32166{
32167 u32 adr, res;
32168 u32 src, dst;
32169
32170 src = DREGu16((Opcode >> 9) & 7);
32171 adr = AREG((Opcode >> 0) & 7);
32172 DECODE_EXT_WORD
32173 PRE_IO
32174 READ_WORD_F(adr, res)
32175 res ^= src;
32176 flag_C = 0;
32177 flag_V = 0;
32178 flag_NotZ = res;
32179 flag_N = res >> 8;
32180 WRITE_WORD_F(adr, res)
32181 POST_IO
32182RET(18)
32183}
32184
32185// EORDa
32186OPCODE(0xB178)
32187{
32188 u32 adr, res;
32189 u32 src, dst;
32190
32191 src = DREGu16((Opcode >> 9) & 7);
32192 FETCH_SWORD(adr);
32193 PRE_IO
32194 READ_WORD_F(adr, res)
32195 res ^= src;
32196 flag_C = 0;
32197 flag_V = 0;
32198 flag_NotZ = res;
32199 flag_N = res >> 8;
32200 WRITE_WORD_F(adr, res)
32201 POST_IO
32202RET(16)
32203}
32204
32205// EORDa
32206OPCODE(0xB179)
32207{
32208 u32 adr, res;
32209 u32 src, dst;
32210
32211 src = DREGu16((Opcode >> 9) & 7);
32212 FETCH_LONG(adr);
32213 PRE_IO
32214 READ_WORD_F(adr, res)
32215 res ^= src;
32216 flag_C = 0;
32217 flag_V = 0;
32218 flag_NotZ = res;
32219 flag_N = res >> 8;
32220 WRITE_WORD_F(adr, res)
32221 POST_IO
32222RET(20)
32223}
32224
32225// EORDa
32226OPCODE(0xB15F)
32227{
32228 u32 adr, res;
32229 u32 src, dst;
32230
32231 src = DREGu16((Opcode >> 9) & 7);
32232 adr = AREG(7);
32233 AREG(7) += 2;
32234 PRE_IO
32235 READ_WORD_F(adr, res)
32236 res ^= src;
32237 flag_C = 0;
32238 flag_V = 0;
32239 flag_NotZ = res;
32240 flag_N = res >> 8;
32241 WRITE_WORD_F(adr, res)
32242 POST_IO
32243RET(12)
32244}
32245
32246// EORDa
32247OPCODE(0xB167)
32248{
32249 u32 adr, res;
32250 u32 src, dst;
32251
32252 src = DREGu16((Opcode >> 9) & 7);
32253 adr = AREG(7) - 2;
32254 AREG(7) = adr;
32255 PRE_IO
32256 READ_WORD_F(adr, res)
32257 res ^= src;
32258 flag_C = 0;
32259 flag_V = 0;
32260 flag_NotZ = res;
32261 flag_N = res >> 8;
32262 WRITE_WORD_F(adr, res)
32263 POST_IO
32264RET(14)
32265}
32266
32267// EORDa
32268OPCODE(0xB180)
32269{
32270 u32 adr, res;
32271 u32 src, dst;
32272
32273 src = DREGu32((Opcode >> 9) & 7);
32274 res = DREGu32((Opcode >> 0) & 7);
32275 res ^= src;
32276 flag_C = 0;
32277 flag_V = 0;
32278 flag_NotZ = res;
32279 flag_N = res >> 24;
32280 DREGu32((Opcode >> 0) & 7) = res;
32281RET(8)
32282}
32283
32284// EORDa
32285OPCODE(0xB190)
32286{
32287 u32 adr, res;
32288 u32 src, dst;
32289
32290 src = DREGu32((Opcode >> 9) & 7);
32291 adr = AREG((Opcode >> 0) & 7);
32292 PRE_IO
32293 READ_LONG_F(adr, res)
32294 res ^= src;
32295 flag_C = 0;
32296 flag_V = 0;
32297 flag_NotZ = res;
32298 flag_N = res >> 24;
32299 WRITE_LONG_F(adr, res)
32300 POST_IO
32301RET(20)
32302}
32303
32304// EORDa
32305OPCODE(0xB198)
32306{
32307 u32 adr, res;
32308 u32 src, dst;
32309
32310 src = DREGu32((Opcode >> 9) & 7);
32311 adr = AREG((Opcode >> 0) & 7);
32312 AREG((Opcode >> 0) & 7) += 4;
32313 PRE_IO
32314 READ_LONG_F(adr, res)
32315 res ^= src;
32316 flag_C = 0;
32317 flag_V = 0;
32318 flag_NotZ = res;
32319 flag_N = res >> 24;
32320 WRITE_LONG_F(adr, res)
32321 POST_IO
32322RET(20)
32323}
32324
32325// EORDa
32326OPCODE(0xB1A0)
32327{
32328 u32 adr, res;
32329 u32 src, dst;
32330
32331 src = DREGu32((Opcode >> 9) & 7);
32332 adr = AREG((Opcode >> 0) & 7) - 4;
32333 AREG((Opcode >> 0) & 7) = adr;
32334 PRE_IO
32335 READ_LONG_F(adr, res)
32336 res ^= src;
32337 flag_C = 0;
32338 flag_V = 0;
32339 flag_NotZ = res;
32340 flag_N = res >> 24;
32341 WRITE_LONG_F(adr, res)
32342 POST_IO
32343RET(22)
32344}
32345
32346// EORDa
32347OPCODE(0xB1A8)
32348{
32349 u32 adr, res;
32350 u32 src, dst;
32351
32352 src = DREGu32((Opcode >> 9) & 7);
32353 FETCH_SWORD(adr);
32354 adr += AREG((Opcode >> 0) & 7);
32355 PRE_IO
32356 READ_LONG_F(adr, res)
32357 res ^= src;
32358 flag_C = 0;
32359 flag_V = 0;
32360 flag_NotZ = res;
32361 flag_N = res >> 24;
32362 WRITE_LONG_F(adr, res)
32363 POST_IO
32364RET(24)
32365}
32366
32367// EORDa
32368OPCODE(0xB1B0)
32369{
32370 u32 adr, res;
32371 u32 src, dst;
32372
32373 src = DREGu32((Opcode >> 9) & 7);
32374 adr = AREG((Opcode >> 0) & 7);
32375 DECODE_EXT_WORD
32376 PRE_IO
32377 READ_LONG_F(adr, res)
32378 res ^= src;
32379 flag_C = 0;
32380 flag_V = 0;
32381 flag_NotZ = res;
32382 flag_N = res >> 24;
32383 WRITE_LONG_F(adr, res)
32384 POST_IO
32385RET(26)
32386}
32387
32388// EORDa
32389OPCODE(0xB1B8)
32390{
32391 u32 adr, res;
32392 u32 src, dst;
32393
32394 src = DREGu32((Opcode >> 9) & 7);
32395 FETCH_SWORD(adr);
32396 PRE_IO
32397 READ_LONG_F(adr, res)
32398 res ^= src;
32399 flag_C = 0;
32400 flag_V = 0;
32401 flag_NotZ = res;
32402 flag_N = res >> 24;
32403 WRITE_LONG_F(adr, res)
32404 POST_IO
32405RET(24)
32406}
32407
32408// EORDa
32409OPCODE(0xB1B9)
32410{
32411 u32 adr, res;
32412 u32 src, dst;
32413
32414 src = DREGu32((Opcode >> 9) & 7);
32415 FETCH_LONG(adr);
32416 PRE_IO
32417 READ_LONG_F(adr, res)
32418 res ^= src;
32419 flag_C = 0;
32420 flag_V = 0;
32421 flag_NotZ = res;
32422 flag_N = res >> 24;
32423 WRITE_LONG_F(adr, res)
32424 POST_IO
32425RET(28)
32426}
32427
32428// EORDa
32429OPCODE(0xB19F)
32430{
32431 u32 adr, res;
32432 u32 src, dst;
32433
32434 src = DREGu32((Opcode >> 9) & 7);
32435 adr = AREG(7);
32436 AREG(7) += 4;
32437 PRE_IO
32438 READ_LONG_F(adr, res)
32439 res ^= src;
32440 flag_C = 0;
32441 flag_V = 0;
32442 flag_NotZ = res;
32443 flag_N = res >> 24;
32444 WRITE_LONG_F(adr, res)
32445 POST_IO
32446RET(20)
32447}
32448
32449// EORDa
32450OPCODE(0xB1A7)
32451{
32452 u32 adr, res;
32453 u32 src, dst;
32454
32455 src = DREGu32((Opcode >> 9) & 7);
32456 adr = AREG(7) - 4;
32457 AREG(7) = adr;
32458 PRE_IO
32459 READ_LONG_F(adr, res)
32460 res ^= src;
32461 flag_C = 0;
32462 flag_V = 0;
32463 flag_NotZ = res;
32464 flag_N = res >> 24;
32465 WRITE_LONG_F(adr, res)
32466 POST_IO
32467RET(22)
32468}
32469
32470// CMPA
32471OPCODE(0xB0C0)
32472{
32473 u32 adr, res;
32474 u32 src, dst;
32475
32476 src = (s32)DREGs16((Opcode >> 0) & 7);
32477 dst = AREGu32((Opcode >> 9) & 7);
32478 res = dst - src;
32479 flag_NotZ = res;
32480 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32481 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32482 flag_N = res >> 24;
32483RET(6)
32484}
32485
32486// CMPA
32487OPCODE(0xB0C8)
32488{
32489 u32 adr, res;
32490 u32 src, dst;
32491
32492 src = (s32)AREGs16((Opcode >> 0) & 7);
32493 dst = AREGu32((Opcode >> 9) & 7);
32494 res = dst - src;
32495 flag_NotZ = res;
32496 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32497 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32498 flag_N = res >> 24;
32499RET(6)
32500}
32501
32502// CMPA
32503OPCODE(0xB0D0)
32504{
32505 u32 adr, res;
32506 u32 src, dst;
32507
32508 adr = AREG((Opcode >> 0) & 7);
32509 PRE_IO
32510 READSX_WORD_F(adr, src)
32511 dst = AREGu32((Opcode >> 9) & 7);
32512 res = dst - src;
32513 flag_NotZ = res;
32514 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32515 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32516 flag_N = res >> 24;
32517 POST_IO
32518RET(10)
32519}
32520
32521// CMPA
32522OPCODE(0xB0D8)
32523{
32524 u32 adr, res;
32525 u32 src, dst;
32526
32527 adr = AREG((Opcode >> 0) & 7);
32528 AREG((Opcode >> 0) & 7) += 2;
32529 PRE_IO
32530 READSX_WORD_F(adr, src)
32531 dst = AREGu32((Opcode >> 9) & 7);
32532 res = dst - src;
32533 flag_NotZ = res;
32534 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32535 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32536 flag_N = res >> 24;
32537 POST_IO
32538RET(10)
32539}
32540
32541// CMPA
32542OPCODE(0xB0E0)
32543{
32544 u32 adr, res;
32545 u32 src, dst;
32546
32547 adr = AREG((Opcode >> 0) & 7) - 2;
32548 AREG((Opcode >> 0) & 7) = adr;
32549 PRE_IO
32550 READSX_WORD_F(adr, src)
32551 dst = AREGu32((Opcode >> 9) & 7);
32552 res = dst - src;
32553 flag_NotZ = res;
32554 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32555 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32556 flag_N = res >> 24;
32557 POST_IO
32558RET(12)
32559}
32560
32561// CMPA
32562OPCODE(0xB0E8)
32563{
32564 u32 adr, res;
32565 u32 src, dst;
32566
32567 FETCH_SWORD(adr);
32568 adr += AREG((Opcode >> 0) & 7);
32569 PRE_IO
32570 READSX_WORD_F(adr, src)
32571 dst = AREGu32((Opcode >> 9) & 7);
32572 res = dst - src;
32573 flag_NotZ = res;
32574 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32575 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32576 flag_N = res >> 24;
32577 POST_IO
32578RET(14)
32579}
32580
32581// CMPA
32582OPCODE(0xB0F0)
32583{
32584 u32 adr, res;
32585 u32 src, dst;
32586
32587 adr = AREG((Opcode >> 0) & 7);
32588 DECODE_EXT_WORD
32589 PRE_IO
32590 READSX_WORD_F(adr, src)
32591 dst = AREGu32((Opcode >> 9) & 7);
32592 res = dst - src;
32593 flag_NotZ = res;
32594 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32595 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32596 flag_N = res >> 24;
32597 POST_IO
32598RET(16)
32599}
32600
32601// CMPA
32602OPCODE(0xB0F8)
32603{
32604 u32 adr, res;
32605 u32 src, dst;
32606
32607 FETCH_SWORD(adr);
32608 PRE_IO
32609 READSX_WORD_F(adr, src)
32610 dst = AREGu32((Opcode >> 9) & 7);
32611 res = dst - src;
32612 flag_NotZ = res;
32613 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32614 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32615 flag_N = res >> 24;
32616 POST_IO
32617RET(14)
32618}
32619
32620// CMPA
32621OPCODE(0xB0F9)
32622{
32623 u32 adr, res;
32624 u32 src, dst;
32625
32626 FETCH_LONG(adr);
32627 PRE_IO
32628 READSX_WORD_F(adr, src)
32629 dst = AREGu32((Opcode >> 9) & 7);
32630 res = dst - src;
32631 flag_NotZ = res;
32632 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32633 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32634 flag_N = res >> 24;
32635 POST_IO
32636RET(18)
32637}
32638
32639// CMPA
32640OPCODE(0xB0FA)
32641{
32642 u32 adr, res;
32643 u32 src, dst;
32644
32645 adr = GET_SWORD + GET_PC;
32646 PC++;
32647 PRE_IO
32648 READSX_WORD_F(adr, src)
32649 dst = AREGu32((Opcode >> 9) & 7);
32650 res = dst - src;
32651 flag_NotZ = res;
32652 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32653 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32654 flag_N = res >> 24;
32655 POST_IO
32656RET(14)
32657}
32658
32659// CMPA
32660OPCODE(0xB0FB)
32661{
32662 u32 adr, res;
32663 u32 src, dst;
32664
32665 adr = GET_PC;
32666 DECODE_EXT_WORD
32667 PRE_IO
32668 READSX_WORD_F(adr, src)
32669 dst = AREGu32((Opcode >> 9) & 7);
32670 res = dst - src;
32671 flag_NotZ = res;
32672 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32673 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32674 flag_N = res >> 24;
32675 POST_IO
32676RET(16)
32677}
32678
32679// CMPA
32680OPCODE(0xB0FC)
32681{
32682 u32 adr, res;
32683 u32 src, dst;
32684
32685 FETCH_SWORD(src);
32686 dst = AREGu32((Opcode >> 9) & 7);
32687 res = dst - src;
32688 flag_NotZ = res;
32689 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32690 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32691 flag_N = res >> 24;
32692RET(10)
32693}
32694
32695// CMPA
32696OPCODE(0xB0DF)
32697{
32698 u32 adr, res;
32699 u32 src, dst;
32700
32701 adr = AREG(7);
32702 AREG(7) += 2;
32703 PRE_IO
32704 READSX_WORD_F(adr, src)
32705 dst = AREGu32((Opcode >> 9) & 7);
32706 res = dst - src;
32707 flag_NotZ = res;
32708 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32709 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32710 flag_N = res >> 24;
32711 POST_IO
32712RET(10)
32713}
32714
32715// CMPA
32716OPCODE(0xB0E7)
32717{
32718 u32 adr, res;
32719 u32 src, dst;
32720
32721 adr = AREG(7) - 2;
32722 AREG(7) = adr;
32723 PRE_IO
32724 READSX_WORD_F(adr, src)
32725 dst = AREGu32((Opcode >> 9) & 7);
32726 res = dst - src;
32727 flag_NotZ = res;
32728 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32729 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32730 flag_N = res >> 24;
32731 POST_IO
32732RET(12)
32733}
32734
32735// CMPA
32736OPCODE(0xB1C0)
32737{
32738 u32 adr, res;
32739 u32 src, dst;
32740
32741 src = (s32)DREGs32((Opcode >> 0) & 7);
32742 dst = AREGu32((Opcode >> 9) & 7);
32743 res = dst - src;
32744 flag_NotZ = res;
32745 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32746 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32747 flag_N = res >> 24;
32748RET(6)
32749}
32750
32751// CMPA
32752OPCODE(0xB1C8)
32753{
32754 u32 adr, res;
32755 u32 src, dst;
32756
32757 src = (s32)AREGs32((Opcode >> 0) & 7);
32758 dst = AREGu32((Opcode >> 9) & 7);
32759 res = dst - src;
32760 flag_NotZ = res;
32761 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32762 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32763 flag_N = res >> 24;
32764RET(6)
32765}
32766
32767// CMPA
32768OPCODE(0xB1D0)
32769{
32770 u32 adr, res;
32771 u32 src, dst;
32772
32773 adr = AREG((Opcode >> 0) & 7);
32774 PRE_IO
32775 READSX_LONG_F(adr, src)
32776 dst = AREGu32((Opcode >> 9) & 7);
32777 res = dst - src;
32778 flag_NotZ = res;
32779 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32780 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32781 flag_N = res >> 24;
32782 POST_IO
32783RET(14)
32784}
32785
32786// CMPA
32787OPCODE(0xB1D8)
32788{
32789 u32 adr, res;
32790 u32 src, dst;
32791
32792 adr = AREG((Opcode >> 0) & 7);
32793 AREG((Opcode >> 0) & 7) += 4;
32794 PRE_IO
32795 READSX_LONG_F(adr, src)
32796 dst = AREGu32((Opcode >> 9) & 7);
32797 res = dst - src;
32798 flag_NotZ = res;
32799 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32800 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32801 flag_N = res >> 24;
32802 POST_IO
32803RET(14)
32804}
32805
32806// CMPA
32807OPCODE(0xB1E0)
32808{
32809 u32 adr, res;
32810 u32 src, dst;
32811
32812 adr = AREG((Opcode >> 0) & 7) - 4;
32813 AREG((Opcode >> 0) & 7) = adr;
32814 PRE_IO
32815 READSX_LONG_F(adr, src)
32816 dst = AREGu32((Opcode >> 9) & 7);
32817 res = dst - src;
32818 flag_NotZ = res;
32819 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32820 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32821 flag_N = res >> 24;
32822 POST_IO
32823RET(16)
32824}
32825
32826// CMPA
32827OPCODE(0xB1E8)
32828{
32829 u32 adr, res;
32830 u32 src, dst;
32831
32832 FETCH_SWORD(adr);
32833 adr += AREG((Opcode >> 0) & 7);
32834 PRE_IO
32835 READSX_LONG_F(adr, src)
32836 dst = AREGu32((Opcode >> 9) & 7);
32837 res = dst - src;
32838 flag_NotZ = res;
32839 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32840 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32841 flag_N = res >> 24;
32842 POST_IO
32843RET(18)
32844}
32845
32846// CMPA
32847OPCODE(0xB1F0)
32848{
32849 u32 adr, res;
32850 u32 src, dst;
32851
32852 adr = AREG((Opcode >> 0) & 7);
32853 DECODE_EXT_WORD
32854 PRE_IO
32855 READSX_LONG_F(adr, src)
32856 dst = AREGu32((Opcode >> 9) & 7);
32857 res = dst - src;
32858 flag_NotZ = res;
32859 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32860 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32861 flag_N = res >> 24;
32862 POST_IO
32863RET(20)
32864}
32865
32866// CMPA
32867OPCODE(0xB1F8)
32868{
32869 u32 adr, res;
32870 u32 src, dst;
32871
32872 FETCH_SWORD(adr);
32873 PRE_IO
32874 READSX_LONG_F(adr, src)
32875 dst = AREGu32((Opcode >> 9) & 7);
32876 res = dst - src;
32877 flag_NotZ = res;
32878 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32879 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32880 flag_N = res >> 24;
32881 POST_IO
32882RET(18)
32883}
32884
32885// CMPA
32886OPCODE(0xB1F9)
32887{
32888 u32 adr, res;
32889 u32 src, dst;
32890
32891 FETCH_LONG(adr);
32892 PRE_IO
32893 READSX_LONG_F(adr, src)
32894 dst = AREGu32((Opcode >> 9) & 7);
32895 res = dst - src;
32896 flag_NotZ = res;
32897 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32898 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32899 flag_N = res >> 24;
32900 POST_IO
32901RET(22)
32902}
32903
32904// CMPA
32905OPCODE(0xB1FA)
32906{
32907 u32 adr, res;
32908 u32 src, dst;
32909
32910 adr = GET_SWORD + GET_PC;
32911 PC++;
32912 PRE_IO
32913 READSX_LONG_F(adr, src)
32914 dst = AREGu32((Opcode >> 9) & 7);
32915 res = dst - src;
32916 flag_NotZ = res;
32917 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32918 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32919 flag_N = res >> 24;
32920 POST_IO
32921RET(18)
32922}
32923
32924// CMPA
32925OPCODE(0xB1FB)
32926{
32927 u32 adr, res;
32928 u32 src, dst;
32929
32930 adr = GET_PC;
32931 DECODE_EXT_WORD
32932 PRE_IO
32933 READSX_LONG_F(adr, src)
32934 dst = AREGu32((Opcode >> 9) & 7);
32935 res = dst - src;
32936 flag_NotZ = res;
32937 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32938 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32939 flag_N = res >> 24;
32940 POST_IO
32941RET(20)
32942}
32943
32944// CMPA
32945OPCODE(0xB1FC)
32946{
32947 u32 adr, res;
32948 u32 src, dst;
32949
32950 FETCH_LONG(src);
32951 dst = AREGu32((Opcode >> 9) & 7);
32952 res = dst - src;
32953 flag_NotZ = res;
32954 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32955 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32956 flag_N = res >> 24;
32957RET(14)
32958}
32959
32960// CMPA
32961OPCODE(0xB1DF)
32962{
32963 u32 adr, res;
32964 u32 src, dst;
32965
32966 adr = AREG(7);
32967 AREG(7) += 4;
32968 PRE_IO
32969 READSX_LONG_F(adr, src)
32970 dst = AREGu32((Opcode >> 9) & 7);
32971 res = dst - src;
32972 flag_NotZ = res;
32973 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32974 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32975 flag_N = res >> 24;
32976 POST_IO
32977RET(14)
32978}
32979
32980// CMPA
32981OPCODE(0xB1E7)
32982{
32983 u32 adr, res;
32984 u32 src, dst;
32985
32986 adr = AREG(7) - 4;
32987 AREG(7) = adr;
32988 PRE_IO
32989 READSX_LONG_F(adr, src)
32990 dst = AREGu32((Opcode >> 9) & 7);
32991 res = dst - src;
32992 flag_NotZ = res;
32993 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32994 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32995 flag_N = res >> 24;
32996 POST_IO
32997RET(16)
32998}
32999
33000// ANDaD
33001OPCODE(0xC000)
33002{
33003 u32 adr, res;
33004 u32 src, dst;
33005
33006 src = DREGu8((Opcode >> 0) & 7);
33007 res = DREGu8((Opcode >> 9) & 7);
33008 res &= src;
33009 flag_C = 0;
33010 flag_V = 0;
33011 flag_NotZ = res;
33012 flag_N = res;
33013 DREGu8((Opcode >> 9) & 7) = res;
33014RET(4)
33015}
33016
33017// ANDaD
33018OPCODE(0xC010)
33019{
33020 u32 adr, res;
33021 u32 src, dst;
33022
33023 adr = AREG((Opcode >> 0) & 7);
33024 PRE_IO
33025 READ_BYTE_F(adr, src)
33026 res = DREGu8((Opcode >> 9) & 7);
33027 res &= src;
33028 flag_C = 0;
33029 flag_V = 0;
33030 flag_NotZ = res;
33031 flag_N = res;
33032 DREGu8((Opcode >> 9) & 7) = res;
33033 POST_IO
33034RET(8)
33035}
33036
33037// ANDaD
33038OPCODE(0xC018)
33039{
33040 u32 adr, res;
33041 u32 src, dst;
33042
33043 adr = AREG((Opcode >> 0) & 7);
33044 AREG((Opcode >> 0) & 7) += 1;
33045 PRE_IO
33046 READ_BYTE_F(adr, src)
33047 res = DREGu8((Opcode >> 9) & 7);
33048 res &= src;
33049 flag_C = 0;
33050 flag_V = 0;
33051 flag_NotZ = res;
33052 flag_N = res;
33053 DREGu8((Opcode >> 9) & 7) = res;
33054 POST_IO
33055RET(8)
33056}
33057
33058// ANDaD
33059OPCODE(0xC020)
33060{
33061 u32 adr, res;
33062 u32 src, dst;
33063
33064 adr = AREG((Opcode >> 0) & 7) - 1;
33065 AREG((Opcode >> 0) & 7) = adr;
33066 PRE_IO
33067 READ_BYTE_F(adr, src)
33068 res = DREGu8((Opcode >> 9) & 7);
33069 res &= src;
33070 flag_C = 0;
33071 flag_V = 0;
33072 flag_NotZ = res;
33073 flag_N = res;
33074 DREGu8((Opcode >> 9) & 7) = res;
33075 POST_IO
33076RET(10)
33077}
33078
33079// ANDaD
33080OPCODE(0xC028)
33081{
33082 u32 adr, res;
33083 u32 src, dst;
33084
33085 FETCH_SWORD(adr);
33086 adr += AREG((Opcode >> 0) & 7);
33087 PRE_IO
33088 READ_BYTE_F(adr, src)
33089 res = DREGu8((Opcode >> 9) & 7);
33090 res &= src;
33091 flag_C = 0;
33092 flag_V = 0;
33093 flag_NotZ = res;
33094 flag_N = res;
33095 DREGu8((Opcode >> 9) & 7) = res;
33096 POST_IO
33097RET(12)
33098}
33099
33100// ANDaD
33101OPCODE(0xC030)
33102{
33103 u32 adr, res;
33104 u32 src, dst;
33105
33106 adr = AREG((Opcode >> 0) & 7);
33107 DECODE_EXT_WORD
33108 PRE_IO
33109 READ_BYTE_F(adr, src)
33110 res = DREGu8((Opcode >> 9) & 7);
33111 res &= src;
33112 flag_C = 0;
33113 flag_V = 0;
33114 flag_NotZ = res;
33115 flag_N = res;
33116 DREGu8((Opcode >> 9) & 7) = res;
33117 POST_IO
33118RET(14)
33119}
33120
33121// ANDaD
33122OPCODE(0xC038)
33123{
33124 u32 adr, res;
33125 u32 src, dst;
33126
33127 FETCH_SWORD(adr);
33128 PRE_IO
33129 READ_BYTE_F(adr, src)
33130 res = DREGu8((Opcode >> 9) & 7);
33131 res &= src;
33132 flag_C = 0;
33133 flag_V = 0;
33134 flag_NotZ = res;
33135 flag_N = res;
33136 DREGu8((Opcode >> 9) & 7) = res;
33137 POST_IO
33138RET(12)
33139}
33140
33141// ANDaD
33142OPCODE(0xC039)
33143{
33144 u32 adr, res;
33145 u32 src, dst;
33146
33147 FETCH_LONG(adr);
33148 PRE_IO
33149 READ_BYTE_F(adr, src)
33150 res = DREGu8((Opcode >> 9) & 7);
33151 res &= src;
33152 flag_C = 0;
33153 flag_V = 0;
33154 flag_NotZ = res;
33155 flag_N = res;
33156 DREGu8((Opcode >> 9) & 7) = res;
33157 POST_IO
33158RET(16)
33159}
33160
33161// ANDaD
33162OPCODE(0xC03A)
33163{
33164 u32 adr, res;
33165 u32 src, dst;
33166
33167 adr = GET_SWORD + GET_PC;
33168 PC++;
33169 PRE_IO
33170 READ_BYTE_F(adr, src)
33171 res = DREGu8((Opcode >> 9) & 7);
33172 res &= src;
33173 flag_C = 0;
33174 flag_V = 0;
33175 flag_NotZ = res;
33176 flag_N = res;
33177 DREGu8((Opcode >> 9) & 7) = res;
33178 POST_IO
33179RET(12)
33180}
33181
33182// ANDaD
33183OPCODE(0xC03B)
33184{
33185 u32 adr, res;
33186 u32 src, dst;
33187
33188 adr = GET_PC;
33189 DECODE_EXT_WORD
33190 PRE_IO
33191 READ_BYTE_F(adr, src)
33192 res = DREGu8((Opcode >> 9) & 7);
33193 res &= src;
33194 flag_C = 0;
33195 flag_V = 0;
33196 flag_NotZ = res;
33197 flag_N = res;
33198 DREGu8((Opcode >> 9) & 7) = res;
33199 POST_IO
33200RET(14)
33201}
33202
33203// ANDaD
33204OPCODE(0xC03C)
33205{
33206 u32 adr, res;
33207 u32 src, dst;
33208
33209 FETCH_BYTE(src);
33210 res = DREGu8((Opcode >> 9) & 7);
33211 res &= src;
33212 flag_C = 0;
33213 flag_V = 0;
33214 flag_NotZ = res;
33215 flag_N = res;
33216 DREGu8((Opcode >> 9) & 7) = res;
33217RET(8)
33218}
33219
33220// ANDaD
33221OPCODE(0xC01F)
33222{
33223 u32 adr, res;
33224 u32 src, dst;
33225
33226 adr = AREG(7);
33227 AREG(7) += 2;
33228 PRE_IO
33229 READ_BYTE_F(adr, src)
33230 res = DREGu8((Opcode >> 9) & 7);
33231 res &= src;
33232 flag_C = 0;
33233 flag_V = 0;
33234 flag_NotZ = res;
33235 flag_N = res;
33236 DREGu8((Opcode >> 9) & 7) = res;
33237 POST_IO
33238RET(8)
33239}
33240
33241// ANDaD
33242OPCODE(0xC027)
33243{
33244 u32 adr, res;
33245 u32 src, dst;
33246
33247 adr = AREG(7) - 2;
33248 AREG(7) = adr;
33249 PRE_IO
33250 READ_BYTE_F(adr, src)
33251 res = DREGu8((Opcode >> 9) & 7);
33252 res &= src;
33253 flag_C = 0;
33254 flag_V = 0;
33255 flag_NotZ = res;
33256 flag_N = res;
33257 DREGu8((Opcode >> 9) & 7) = res;
33258 POST_IO
33259RET(10)
33260}
33261
33262// ANDaD
33263OPCODE(0xC040)
33264{
33265 u32 adr, res;
33266 u32 src, dst;
33267
33268 src = DREGu16((Opcode >> 0) & 7);
33269 res = DREGu16((Opcode >> 9) & 7);
33270 res &= src;
33271 flag_C = 0;
33272 flag_V = 0;
33273 flag_NotZ = res;
33274 flag_N = res >> 8;
33275 DREGu16((Opcode >> 9) & 7) = res;
33276RET(4)
33277}
33278
33279// ANDaD
33280OPCODE(0xC050)
33281{
33282 u32 adr, res;
33283 u32 src, dst;
33284
33285 adr = AREG((Opcode >> 0) & 7);
33286 PRE_IO
33287 READ_WORD_F(adr, src)
33288 res = DREGu16((Opcode >> 9) & 7);
33289 res &= src;
33290 flag_C = 0;
33291 flag_V = 0;
33292 flag_NotZ = res;
33293 flag_N = res >> 8;
33294 DREGu16((Opcode >> 9) & 7) = res;
33295 POST_IO
33296RET(8)
33297}
33298
33299// ANDaD
33300OPCODE(0xC058)
33301{
33302 u32 adr, res;
33303 u32 src, dst;
33304
33305 adr = AREG((Opcode >> 0) & 7);
33306 AREG((Opcode >> 0) & 7) += 2;
33307 PRE_IO
33308 READ_WORD_F(adr, src)
33309 res = DREGu16((Opcode >> 9) & 7);
33310 res &= src;
33311 flag_C = 0;
33312 flag_V = 0;
33313 flag_NotZ = res;
33314 flag_N = res >> 8;
33315 DREGu16((Opcode >> 9) & 7) = res;
33316 POST_IO
33317RET(8)
33318}
33319
33320// ANDaD
33321OPCODE(0xC060)
33322{
33323 u32 adr, res;
33324 u32 src, dst;
33325
33326 adr = AREG((Opcode >> 0) & 7) - 2;
33327 AREG((Opcode >> 0) & 7) = adr;
33328 PRE_IO
33329 READ_WORD_F(adr, src)
33330 res = DREGu16((Opcode >> 9) & 7);
33331 res &= src;
33332 flag_C = 0;
33333 flag_V = 0;
33334 flag_NotZ = res;
33335 flag_N = res >> 8;
33336 DREGu16((Opcode >> 9) & 7) = res;
33337 POST_IO
33338RET(10)
33339}
33340
33341// ANDaD
33342OPCODE(0xC068)
33343{
33344 u32 adr, res;
33345 u32 src, dst;
33346
33347 FETCH_SWORD(adr);
33348 adr += AREG((Opcode >> 0) & 7);
33349 PRE_IO
33350 READ_WORD_F(adr, src)
33351 res = DREGu16((Opcode >> 9) & 7);
33352 res &= src;
33353 flag_C = 0;
33354 flag_V = 0;
33355 flag_NotZ = res;
33356 flag_N = res >> 8;
33357 DREGu16((Opcode >> 9) & 7) = res;
33358 POST_IO
33359RET(12)
33360}
33361
33362// ANDaD
33363OPCODE(0xC070)
33364{
33365 u32 adr, res;
33366 u32 src, dst;
33367
33368 adr = AREG((Opcode >> 0) & 7);
33369 DECODE_EXT_WORD
33370 PRE_IO
33371 READ_WORD_F(adr, src)
33372 res = DREGu16((Opcode >> 9) & 7);
33373 res &= src;
33374 flag_C = 0;
33375 flag_V = 0;
33376 flag_NotZ = res;
33377 flag_N = res >> 8;
33378 DREGu16((Opcode >> 9) & 7) = res;
33379 POST_IO
33380RET(14)
33381}
33382
33383// ANDaD
33384OPCODE(0xC078)
33385{
33386 u32 adr, res;
33387 u32 src, dst;
33388
33389 FETCH_SWORD(adr);
33390 PRE_IO
33391 READ_WORD_F(adr, src)
33392 res = DREGu16((Opcode >> 9) & 7);
33393 res &= src;
33394 flag_C = 0;
33395 flag_V = 0;
33396 flag_NotZ = res;
33397 flag_N = res >> 8;
33398 DREGu16((Opcode >> 9) & 7) = res;
33399 POST_IO
33400RET(12)
33401}
33402
33403// ANDaD
33404OPCODE(0xC079)
33405{
33406 u32 adr, res;
33407 u32 src, dst;
33408
33409 FETCH_LONG(adr);
33410 PRE_IO
33411 READ_WORD_F(adr, src)
33412 res = DREGu16((Opcode >> 9) & 7);
33413 res &= src;
33414 flag_C = 0;
33415 flag_V = 0;
33416 flag_NotZ = res;
33417 flag_N = res >> 8;
33418 DREGu16((Opcode >> 9) & 7) = res;
33419 POST_IO
33420RET(16)
33421}
33422
33423// ANDaD
33424OPCODE(0xC07A)
33425{
33426 u32 adr, res;
33427 u32 src, dst;
33428
33429 adr = GET_SWORD + GET_PC;
33430 PC++;
33431 PRE_IO
33432 READ_WORD_F(adr, src)
33433 res = DREGu16((Opcode >> 9) & 7);
33434 res &= src;
33435 flag_C = 0;
33436 flag_V = 0;
33437 flag_NotZ = res;
33438 flag_N = res >> 8;
33439 DREGu16((Opcode >> 9) & 7) = res;
33440 POST_IO
33441RET(12)
33442}
33443
33444// ANDaD
33445OPCODE(0xC07B)
33446{
33447 u32 adr, res;
33448 u32 src, dst;
33449
33450 adr = GET_PC;
33451 DECODE_EXT_WORD
33452 PRE_IO
33453 READ_WORD_F(adr, src)
33454 res = DREGu16((Opcode >> 9) & 7);
33455 res &= src;
33456 flag_C = 0;
33457 flag_V = 0;
33458 flag_NotZ = res;
33459 flag_N = res >> 8;
33460 DREGu16((Opcode >> 9) & 7) = res;
33461 POST_IO
33462RET(14)
33463}
33464
33465// ANDaD
33466OPCODE(0xC07C)
33467{
33468 u32 adr, res;
33469 u32 src, dst;
33470
33471 FETCH_WORD(src);
33472 res = DREGu16((Opcode >> 9) & 7);
33473 res &= src;
33474 flag_C = 0;
33475 flag_V = 0;
33476 flag_NotZ = res;
33477 flag_N = res >> 8;
33478 DREGu16((Opcode >> 9) & 7) = res;
33479RET(8)
33480}
33481
33482// ANDaD
33483OPCODE(0xC05F)
33484{
33485 u32 adr, res;
33486 u32 src, dst;
33487
33488 adr = AREG(7);
33489 AREG(7) += 2;
33490 PRE_IO
33491 READ_WORD_F(adr, src)
33492 res = DREGu16((Opcode >> 9) & 7);
33493 res &= src;
33494 flag_C = 0;
33495 flag_V = 0;
33496 flag_NotZ = res;
33497 flag_N = res >> 8;
33498 DREGu16((Opcode >> 9) & 7) = res;
33499 POST_IO
33500RET(8)
33501}
33502
33503// ANDaD
33504OPCODE(0xC067)
33505{
33506 u32 adr, res;
33507 u32 src, dst;
33508
33509 adr = AREG(7) - 2;
33510 AREG(7) = adr;
33511 PRE_IO
33512 READ_WORD_F(adr, src)
33513 res = DREGu16((Opcode >> 9) & 7);
33514 res &= src;
33515 flag_C = 0;
33516 flag_V = 0;
33517 flag_NotZ = res;
33518 flag_N = res >> 8;
33519 DREGu16((Opcode >> 9) & 7) = res;
33520 POST_IO
33521RET(10)
33522}
33523
33524// ANDaD
33525OPCODE(0xC080)
33526{
33527 u32 adr, res;
33528 u32 src, dst;
33529
33530 src = DREGu32((Opcode >> 0) & 7);
33531 res = DREGu32((Opcode >> 9) & 7);
33532 res &= src;
33533 flag_C = 0;
33534 flag_V = 0;
33535 flag_NotZ = res;
33536 flag_N = res >> 24;
33537 DREGu32((Opcode >> 9) & 7) = res;
33538RET(8)
33539}
33540
33541// ANDaD
33542OPCODE(0xC090)
33543{
33544 u32 adr, res;
33545 u32 src, dst;
33546
33547 adr = AREG((Opcode >> 0) & 7);
33548 PRE_IO
33549 READ_LONG_F(adr, src)
33550 res = DREGu32((Opcode >> 9) & 7);
33551 res &= src;
33552 flag_C = 0;
33553 flag_V = 0;
33554 flag_NotZ = res;
33555 flag_N = res >> 24;
33556 DREGu32((Opcode >> 9) & 7) = res;
33557 POST_IO
33558RET(14)
33559}
33560
33561// ANDaD
33562OPCODE(0xC098)
33563{
33564 u32 adr, res;
33565 u32 src, dst;
33566
33567 adr = AREG((Opcode >> 0) & 7);
33568 AREG((Opcode >> 0) & 7) += 4;
33569 PRE_IO
33570 READ_LONG_F(adr, src)
33571 res = DREGu32((Opcode >> 9) & 7);
33572 res &= src;
33573 flag_C = 0;
33574 flag_V = 0;
33575 flag_NotZ = res;
33576 flag_N = res >> 24;
33577 DREGu32((Opcode >> 9) & 7) = res;
33578 POST_IO
33579RET(14)
33580}
33581
33582// ANDaD
33583OPCODE(0xC0A0)
33584{
33585 u32 adr, res;
33586 u32 src, dst;
33587
33588 adr = AREG((Opcode >> 0) & 7) - 4;
33589 AREG((Opcode >> 0) & 7) = adr;
33590 PRE_IO
33591 READ_LONG_F(adr, src)
33592 res = DREGu32((Opcode >> 9) & 7);
33593 res &= src;
33594 flag_C = 0;
33595 flag_V = 0;
33596 flag_NotZ = res;
33597 flag_N = res >> 24;
33598 DREGu32((Opcode >> 9) & 7) = res;
33599 POST_IO
33600RET(16)
33601}
33602
33603// ANDaD
33604OPCODE(0xC0A8)
33605{
33606 u32 adr, res;
33607 u32 src, dst;
33608
33609 FETCH_SWORD(adr);
33610 adr += AREG((Opcode >> 0) & 7);
33611 PRE_IO
33612 READ_LONG_F(adr, src)
33613 res = DREGu32((Opcode >> 9) & 7);
33614 res &= src;
33615 flag_C = 0;
33616 flag_V = 0;
33617 flag_NotZ = res;
33618 flag_N = res >> 24;
33619 DREGu32((Opcode >> 9) & 7) = res;
33620 POST_IO
33621RET(18)
33622}
33623
33624// ANDaD
33625OPCODE(0xC0B0)
33626{
33627 u32 adr, res;
33628 u32 src, dst;
33629
33630 adr = AREG((Opcode >> 0) & 7);
33631 DECODE_EXT_WORD
33632 PRE_IO
33633 READ_LONG_F(adr, src)
33634 res = DREGu32((Opcode >> 9) & 7);
33635 res &= src;
33636 flag_C = 0;
33637 flag_V = 0;
33638 flag_NotZ = res;
33639 flag_N = res >> 24;
33640 DREGu32((Opcode >> 9) & 7) = res;
33641 POST_IO
33642RET(20)
33643}
33644
33645// ANDaD
33646OPCODE(0xC0B8)
33647{
33648 u32 adr, res;
33649 u32 src, dst;
33650
33651 FETCH_SWORD(adr);
33652 PRE_IO
33653 READ_LONG_F(adr, src)
33654 res = DREGu32((Opcode >> 9) & 7);
33655 res &= src;
33656 flag_C = 0;
33657 flag_V = 0;
33658 flag_NotZ = res;
33659 flag_N = res >> 24;
33660 DREGu32((Opcode >> 9) & 7) = res;
33661 POST_IO
33662RET(18)
33663}
33664
33665// ANDaD
33666OPCODE(0xC0B9)
33667{
33668 u32 adr, res;
33669 u32 src, dst;
33670
33671 FETCH_LONG(adr);
33672 PRE_IO
33673 READ_LONG_F(adr, src)
33674 res = DREGu32((Opcode >> 9) & 7);
33675 res &= src;
33676 flag_C = 0;
33677 flag_V = 0;
33678 flag_NotZ = res;
33679 flag_N = res >> 24;
33680 DREGu32((Opcode >> 9) & 7) = res;
33681 POST_IO
33682RET(22)
33683}
33684
33685// ANDaD
33686OPCODE(0xC0BA)
33687{
33688 u32 adr, res;
33689 u32 src, dst;
33690
33691 adr = GET_SWORD + GET_PC;
33692 PC++;
33693 PRE_IO
33694 READ_LONG_F(adr, src)
33695 res = DREGu32((Opcode >> 9) & 7);
33696 res &= src;
33697 flag_C = 0;
33698 flag_V = 0;
33699 flag_NotZ = res;
33700 flag_N = res >> 24;
33701 DREGu32((Opcode >> 9) & 7) = res;
33702 POST_IO
33703RET(18)
33704}
33705
33706// ANDaD
33707OPCODE(0xC0BB)
33708{
33709 u32 adr, res;
33710 u32 src, dst;
33711
33712 adr = GET_PC;
33713 DECODE_EXT_WORD
33714 PRE_IO
33715 READ_LONG_F(adr, src)
33716 res = DREGu32((Opcode >> 9) & 7);
33717 res &= src;
33718 flag_C = 0;
33719 flag_V = 0;
33720 flag_NotZ = res;
33721 flag_N = res >> 24;
33722 DREGu32((Opcode >> 9) & 7) = res;
33723 POST_IO
33724RET(20)
33725}
33726
33727// ANDaD
33728OPCODE(0xC0BC)
33729{
33730 u32 adr, res;
33731 u32 src, dst;
33732
33733 FETCH_LONG(src);
33734 res = DREGu32((Opcode >> 9) & 7);
33735 res &= src;
33736 flag_C = 0;
33737 flag_V = 0;
33738 flag_NotZ = res;
33739 flag_N = res >> 24;
33740 DREGu32((Opcode >> 9) & 7) = res;
33741RET(16)
33742}
33743
33744// ANDaD
33745OPCODE(0xC09F)
33746{
33747 u32 adr, res;
33748 u32 src, dst;
33749
33750 adr = AREG(7);
33751 AREG(7) += 4;
33752 PRE_IO
33753 READ_LONG_F(adr, src)
33754 res = DREGu32((Opcode >> 9) & 7);
33755 res &= src;
33756 flag_C = 0;
33757 flag_V = 0;
33758 flag_NotZ = res;
33759 flag_N = res >> 24;
33760 DREGu32((Opcode >> 9) & 7) = res;
33761 POST_IO
33762RET(14)
33763}
33764
33765// ANDaD
33766OPCODE(0xC0A7)
33767{
33768 u32 adr, res;
33769 u32 src, dst;
33770
33771 adr = AREG(7) - 4;
33772 AREG(7) = adr;
33773 PRE_IO
33774 READ_LONG_F(adr, src)
33775 res = DREGu32((Opcode >> 9) & 7);
33776 res &= src;
33777 flag_C = 0;
33778 flag_V = 0;
33779 flag_NotZ = res;
33780 flag_N = res >> 24;
33781 DREGu32((Opcode >> 9) & 7) = res;
33782 POST_IO
33783RET(16)
33784}
33785
33786// ANDDa
33787OPCODE(0xC110)
33788{
33789 u32 adr, res;
33790 u32 src, dst;
33791
33792 src = DREGu8((Opcode >> 9) & 7);
33793 adr = AREG((Opcode >> 0) & 7);
33794 PRE_IO
33795 READ_BYTE_F(adr, res)
33796 res &= src;
33797 flag_C = 0;
33798 flag_V = 0;
33799 flag_NotZ = res;
33800 flag_N = res;
33801 WRITE_BYTE_F(adr, res)
33802 POST_IO
33803RET(12)
33804}
33805
33806// ANDDa
33807OPCODE(0xC118)
33808{
33809 u32 adr, res;
33810 u32 src, dst;
33811
33812 src = DREGu8((Opcode >> 9) & 7);
33813 adr = AREG((Opcode >> 0) & 7);
33814 AREG((Opcode >> 0) & 7) += 1;
33815 PRE_IO
33816 READ_BYTE_F(adr, res)
33817 res &= src;
33818 flag_C = 0;
33819 flag_V = 0;
33820 flag_NotZ = res;
33821 flag_N = res;
33822 WRITE_BYTE_F(adr, res)
33823 POST_IO
33824RET(12)
33825}
33826
33827// ANDDa
33828OPCODE(0xC120)
33829{
33830 u32 adr, res;
33831 u32 src, dst;
33832
33833 src = DREGu8((Opcode >> 9) & 7);
33834 adr = AREG((Opcode >> 0) & 7) - 1;
33835 AREG((Opcode >> 0) & 7) = adr;
33836 PRE_IO
33837 READ_BYTE_F(adr, res)
33838 res &= src;
33839 flag_C = 0;
33840 flag_V = 0;
33841 flag_NotZ = res;
33842 flag_N = res;
33843 WRITE_BYTE_F(adr, res)
33844 POST_IO
33845RET(14)
33846}
33847
33848// ANDDa
33849OPCODE(0xC128)
33850{
33851 u32 adr, res;
33852 u32 src, dst;
33853
33854 src = DREGu8((Opcode >> 9) & 7);
33855 FETCH_SWORD(adr);
33856 adr += AREG((Opcode >> 0) & 7);
33857 PRE_IO
33858 READ_BYTE_F(adr, res)
33859 res &= src;
33860 flag_C = 0;
33861 flag_V = 0;
33862 flag_NotZ = res;
33863 flag_N = res;
33864 WRITE_BYTE_F(adr, res)
33865 POST_IO
33866RET(16)
33867}
33868
33869// ANDDa
33870OPCODE(0xC130)
33871{
33872 u32 adr, res;
33873 u32 src, dst;
33874
33875 src = DREGu8((Opcode >> 9) & 7);
33876 adr = AREG((Opcode >> 0) & 7);
33877 DECODE_EXT_WORD
33878 PRE_IO
33879 READ_BYTE_F(adr, res)
33880 res &= src;
33881 flag_C = 0;
33882 flag_V = 0;
33883 flag_NotZ = res;
33884 flag_N = res;
33885 WRITE_BYTE_F(adr, res)
33886 POST_IO
33887RET(18)
33888}
33889
33890// ANDDa
33891OPCODE(0xC138)
33892{
33893 u32 adr, res;
33894 u32 src, dst;
33895
33896 src = DREGu8((Opcode >> 9) & 7);
33897 FETCH_SWORD(adr);
33898 PRE_IO
33899 READ_BYTE_F(adr, res)
33900 res &= src;
33901 flag_C = 0;
33902 flag_V = 0;
33903 flag_NotZ = res;
33904 flag_N = res;
33905 WRITE_BYTE_F(adr, res)
33906 POST_IO
33907RET(16)
33908}
33909
33910// ANDDa
33911OPCODE(0xC139)
33912{
33913 u32 adr, res;
33914 u32 src, dst;
33915
33916 src = DREGu8((Opcode >> 9) & 7);
33917 FETCH_LONG(adr);
33918 PRE_IO
33919 READ_BYTE_F(adr, res)
33920 res &= src;
33921 flag_C = 0;
33922 flag_V = 0;
33923 flag_NotZ = res;
33924 flag_N = res;
33925 WRITE_BYTE_F(adr, res)
33926 POST_IO
33927RET(20)
33928}
33929
33930// ANDDa
33931OPCODE(0xC11F)
33932{
33933 u32 adr, res;
33934 u32 src, dst;
33935
33936 src = DREGu8((Opcode >> 9) & 7);
33937 adr = AREG(7);
33938 AREG(7) += 2;
33939 PRE_IO
33940 READ_BYTE_F(adr, res)
33941 res &= src;
33942 flag_C = 0;
33943 flag_V = 0;
33944 flag_NotZ = res;
33945 flag_N = res;
33946 WRITE_BYTE_F(adr, res)
33947 POST_IO
33948RET(12)
33949}
33950
33951// ANDDa
33952OPCODE(0xC127)
33953{
33954 u32 adr, res;
33955 u32 src, dst;
33956
33957 src = DREGu8((Opcode >> 9) & 7);
33958 adr = AREG(7) - 2;
33959 AREG(7) = adr;
33960 PRE_IO
33961 READ_BYTE_F(adr, res)
33962 res &= src;
33963 flag_C = 0;
33964 flag_V = 0;
33965 flag_NotZ = res;
33966 flag_N = res;
33967 WRITE_BYTE_F(adr, res)
33968 POST_IO
33969RET(14)
33970}
33971
33972// ANDDa
33973OPCODE(0xC150)
33974{
33975 u32 adr, res;
33976 u32 src, dst;
33977
33978 src = DREGu16((Opcode >> 9) & 7);
33979 adr = AREG((Opcode >> 0) & 7);
33980 PRE_IO
33981 READ_WORD_F(adr, res)
33982 res &= src;
33983 flag_C = 0;
33984 flag_V = 0;
33985 flag_NotZ = res;
33986 flag_N = res >> 8;
33987 WRITE_WORD_F(adr, res)
33988 POST_IO
33989RET(12)
33990}
33991
33992// ANDDa
33993OPCODE(0xC158)
33994{
33995 u32 adr, res;
33996 u32 src, dst;
33997
33998 src = DREGu16((Opcode >> 9) & 7);
33999 adr = AREG((Opcode >> 0) & 7);
34000 AREG((Opcode >> 0) & 7) += 2;
34001 PRE_IO
34002 READ_WORD_F(adr, res)
34003 res &= src;
34004 flag_C = 0;
34005 flag_V = 0;
34006 flag_NotZ = res;
34007 flag_N = res >> 8;
34008 WRITE_WORD_F(adr, res)
34009 POST_IO
34010RET(12)
34011}
34012
34013// ANDDa
34014OPCODE(0xC160)
34015{
34016 u32 adr, res;
34017 u32 src, dst;
34018
34019 src = DREGu16((Opcode >> 9) & 7);
34020 adr = AREG((Opcode >> 0) & 7) - 2;
34021 AREG((Opcode >> 0) & 7) = adr;
34022 PRE_IO
34023 READ_WORD_F(adr, res)
34024 res &= src;
34025 flag_C = 0;
34026 flag_V = 0;
34027 flag_NotZ = res;
34028 flag_N = res >> 8;
34029 WRITE_WORD_F(adr, res)
34030 POST_IO
34031RET(14)
34032}
34033
34034// ANDDa
34035OPCODE(0xC168)
34036{
34037 u32 adr, res;
34038 u32 src, dst;
34039
34040 src = DREGu16((Opcode >> 9) & 7);
34041 FETCH_SWORD(adr);
34042 adr += AREG((Opcode >> 0) & 7);
34043 PRE_IO
34044 READ_WORD_F(adr, res)
34045 res &= src;
34046 flag_C = 0;
34047 flag_V = 0;
34048 flag_NotZ = res;
34049 flag_N = res >> 8;
34050 WRITE_WORD_F(adr, res)
34051 POST_IO
34052RET(16)
34053}
34054
34055// ANDDa
34056OPCODE(0xC170)
34057{
34058 u32 adr, res;
34059 u32 src, dst;
34060
34061 src = DREGu16((Opcode >> 9) & 7);
34062 adr = AREG((Opcode >> 0) & 7);
34063 DECODE_EXT_WORD
34064 PRE_IO
34065 READ_WORD_F(adr, res)
34066 res &= src;
34067 flag_C = 0;
34068 flag_V = 0;
34069 flag_NotZ = res;
34070 flag_N = res >> 8;
34071 WRITE_WORD_F(adr, res)
34072 POST_IO
34073RET(18)
34074}
34075
34076// ANDDa
34077OPCODE(0xC178)
34078{
34079 u32 adr, res;
34080 u32 src, dst;
34081
34082 src = DREGu16((Opcode >> 9) & 7);
34083 FETCH_SWORD(adr);
34084 PRE_IO
34085 READ_WORD_F(adr, res)
34086 res &= src;
34087 flag_C = 0;
34088 flag_V = 0;
34089 flag_NotZ = res;
34090 flag_N = res >> 8;
34091 WRITE_WORD_F(adr, res)
34092 POST_IO
34093RET(16)
34094}
34095
34096// ANDDa
34097OPCODE(0xC179)
34098{
34099 u32 adr, res;
34100 u32 src, dst;
34101
34102 src = DREGu16((Opcode >> 9) & 7);
34103 FETCH_LONG(adr);
34104 PRE_IO
34105 READ_WORD_F(adr, res)
34106 res &= src;
34107 flag_C = 0;
34108 flag_V = 0;
34109 flag_NotZ = res;
34110 flag_N = res >> 8;
34111 WRITE_WORD_F(adr, res)
34112 POST_IO
34113RET(20)
34114}
34115
34116// ANDDa
34117OPCODE(0xC15F)
34118{
34119 u32 adr, res;
34120 u32 src, dst;
34121
34122 src = DREGu16((Opcode >> 9) & 7);
34123 adr = AREG(7);
34124 AREG(7) += 2;
34125 PRE_IO
34126 READ_WORD_F(adr, res)
34127 res &= src;
34128 flag_C = 0;
34129 flag_V = 0;
34130 flag_NotZ = res;
34131 flag_N = res >> 8;
34132 WRITE_WORD_F(adr, res)
34133 POST_IO
34134RET(12)
34135}
34136
34137// ANDDa
34138OPCODE(0xC167)
34139{
34140 u32 adr, res;
34141 u32 src, dst;
34142
34143 src = DREGu16((Opcode >> 9) & 7);
34144 adr = AREG(7) - 2;
34145 AREG(7) = adr;
34146 PRE_IO
34147 READ_WORD_F(adr, res)
34148 res &= src;
34149 flag_C = 0;
34150 flag_V = 0;
34151 flag_NotZ = res;
34152 flag_N = res >> 8;
34153 WRITE_WORD_F(adr, res)
34154 POST_IO
34155RET(14)
34156}
34157
34158// ANDDa
34159OPCODE(0xC190)
34160{
34161 u32 adr, res;
34162 u32 src, dst;
34163
34164 src = DREGu32((Opcode >> 9) & 7);
34165 adr = AREG((Opcode >> 0) & 7);
34166 PRE_IO
34167 READ_LONG_F(adr, res)
34168 res &= src;
34169 flag_C = 0;
34170 flag_V = 0;
34171 flag_NotZ = res;
34172 flag_N = res >> 24;
34173 WRITE_LONG_F(adr, res)
34174 POST_IO
34175RET(20)
34176}
34177
34178// ANDDa
34179OPCODE(0xC198)
34180{
34181 u32 adr, res;
34182 u32 src, dst;
34183
34184 src = DREGu32((Opcode >> 9) & 7);
34185 adr = AREG((Opcode >> 0) & 7);
34186 AREG((Opcode >> 0) & 7) += 4;
34187 PRE_IO
34188 READ_LONG_F(adr, res)
34189 res &= src;
34190 flag_C = 0;
34191 flag_V = 0;
34192 flag_NotZ = res;
34193 flag_N = res >> 24;
34194 WRITE_LONG_F(adr, res)
34195 POST_IO
34196RET(20)
34197}
34198
34199// ANDDa
34200OPCODE(0xC1A0)
34201{
34202 u32 adr, res;
34203 u32 src, dst;
34204
34205 src = DREGu32((Opcode >> 9) & 7);
34206 adr = AREG((Opcode >> 0) & 7) - 4;
34207 AREG((Opcode >> 0) & 7) = adr;
34208 PRE_IO
34209 READ_LONG_F(adr, res)
34210 res &= src;
34211 flag_C = 0;
34212 flag_V = 0;
34213 flag_NotZ = res;
34214 flag_N = res >> 24;
34215 WRITE_LONG_F(adr, res)
34216 POST_IO
34217RET(22)
34218}
34219
34220// ANDDa
34221OPCODE(0xC1A8)
34222{
34223 u32 adr, res;
34224 u32 src, dst;
34225
34226 src = DREGu32((Opcode >> 9) & 7);
34227 FETCH_SWORD(adr);
34228 adr += AREG((Opcode >> 0) & 7);
34229 PRE_IO
34230 READ_LONG_F(adr, res)
34231 res &= src;
34232 flag_C = 0;
34233 flag_V = 0;
34234 flag_NotZ = res;
34235 flag_N = res >> 24;
34236 WRITE_LONG_F(adr, res)
34237 POST_IO
34238RET(24)
34239}
34240
34241// ANDDa
34242OPCODE(0xC1B0)
34243{
34244 u32 adr, res;
34245 u32 src, dst;
34246
34247 src = DREGu32((Opcode >> 9) & 7);
34248 adr = AREG((Opcode >> 0) & 7);
34249 DECODE_EXT_WORD
34250 PRE_IO
34251 READ_LONG_F(adr, res)
34252 res &= src;
34253 flag_C = 0;
34254 flag_V = 0;
34255 flag_NotZ = res;
34256 flag_N = res >> 24;
34257 WRITE_LONG_F(adr, res)
34258 POST_IO
34259RET(26)
34260}
34261
34262// ANDDa
34263OPCODE(0xC1B8)
34264{
34265 u32 adr, res;
34266 u32 src, dst;
34267
34268 src = DREGu32((Opcode >> 9) & 7);
34269 FETCH_SWORD(adr);
34270 PRE_IO
34271 READ_LONG_F(adr, res)
34272 res &= src;
34273 flag_C = 0;
34274 flag_V = 0;
34275 flag_NotZ = res;
34276 flag_N = res >> 24;
34277 WRITE_LONG_F(adr, res)
34278 POST_IO
34279RET(24)
34280}
34281
34282// ANDDa
34283OPCODE(0xC1B9)
34284{
34285 u32 adr, res;
34286 u32 src, dst;
34287
34288 src = DREGu32((Opcode >> 9) & 7);
34289 FETCH_LONG(adr);
34290 PRE_IO
34291 READ_LONG_F(adr, res)
34292 res &= src;
34293 flag_C = 0;
34294 flag_V = 0;
34295 flag_NotZ = res;
34296 flag_N = res >> 24;
34297 WRITE_LONG_F(adr, res)
34298 POST_IO
34299RET(28)
34300}
34301
34302// ANDDa
34303OPCODE(0xC19F)
34304{
34305 u32 adr, res;
34306 u32 src, dst;
34307
34308 src = DREGu32((Opcode >> 9) & 7);
34309 adr = AREG(7);
34310 AREG(7) += 4;
34311 PRE_IO
34312 READ_LONG_F(adr, res)
34313 res &= src;
34314 flag_C = 0;
34315 flag_V = 0;
34316 flag_NotZ = res;
34317 flag_N = res >> 24;
34318 WRITE_LONG_F(adr, res)
34319 POST_IO
34320RET(20)
34321}
34322
34323// ANDDa
34324OPCODE(0xC1A7)
34325{
34326 u32 adr, res;
34327 u32 src, dst;
34328
34329 src = DREGu32((Opcode >> 9) & 7);
34330 adr = AREG(7) - 4;
34331 AREG(7) = adr;
34332 PRE_IO
34333 READ_LONG_F(adr, res)
34334 res &= src;
34335 flag_C = 0;
34336 flag_V = 0;
34337 flag_NotZ = res;
34338 flag_N = res >> 24;
34339 WRITE_LONG_F(adr, res)
34340 POST_IO
34341RET(22)
34342}
34343
34344// ABCD
34345OPCODE(0xC100)
34346{
34347 u32 adr, res;
34348 u32 src, dst;
34349 u32 corf = 0;
34350
34351 src = DREGu8((Opcode >> 0) & 7);
34352 dst = DREGu8((Opcode >> 9) & 7);
34353 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34354 if (res > 9) corf = 6;
34355 res += (dst & 0xF0) + (src & 0xF0);
34356 flag_V = ~res;
34357 res += corf;
34358 if (res > 0x9F)
34359 {
34360 res -= 0xA0;
34361 flag_X = flag_C = M68K_SR_C;
34362 }
34363 else flag_X = flag_C = 0;
34364 flag_V &= res;
34365 flag_NotZ |= res & 0xFF;
34366 flag_N = res;
34367 DREGu8((Opcode >> 9) & 7) = res;
34368RET(6)
34369}
34370
34371// ABCDM
34372OPCODE(0xC108)
34373{
34374 u32 adr, res;
34375 u32 src, dst;
34376 u32 corf = 0;
34377
34378 adr = AREG((Opcode >> 0) & 7) - 1;
34379 AREG((Opcode >> 0) & 7) = adr;
34380 PRE_IO
34381 READ_BYTE_F(adr, src)
34382 adr = AREG((Opcode >> 9) & 7) - 1;
34383 AREG((Opcode >> 9) & 7) = adr;
34384 READ_BYTE_F(adr, dst)
34385 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34386 if (res > 9) corf = 6;
34387 res += (dst & 0xF0) + (src & 0xF0);
34388 flag_V = ~res;
34389 res += corf;
34390 if (res > 0x9F)
34391 {
34392 res -= 0xA0;
34393 flag_X = flag_C = M68K_SR_C;
34394 }
34395 else flag_X = flag_C = 0;
34396 flag_V &= res;
34397 flag_NotZ |= res & 0xFF;
34398 flag_N = res;
34399 WRITE_BYTE_F(adr, res)
34400 POST_IO
34401RET(18)
34402}
34403
34404// ABCD7M
34405OPCODE(0xC10F)
34406{
34407 u32 adr, res;
34408 u32 src, dst;
34409 u32 corf = 0;
34410
34411 adr = AREG(7) - 2;
34412 AREG(7) = adr;
34413 PRE_IO
34414 READ_BYTE_F(adr, src)
34415 adr = AREG((Opcode >> 9) & 7) - 1;
34416 AREG((Opcode >> 9) & 7) = adr;
34417 READ_BYTE_F(adr, dst)
34418 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34419 if (res > 9) corf = 6;
34420 res += (dst & 0xF0) + (src & 0xF0);
34421 flag_V = ~res;
34422 res += corf;
34423 if (res > 0x9F)
34424 {
34425 res -= 0xA0;
34426 flag_X = flag_C = M68K_SR_C;
34427 }
34428 else flag_X = flag_C = 0;
34429 flag_V &= res;
34430 flag_NotZ |= res & 0xFF;
34431 flag_N = res;
34432 WRITE_BYTE_F(adr, res)
34433 POST_IO
34434RET(18)
34435}
34436
34437// ABCDM7
34438OPCODE(0xCF08)
34439{
34440 u32 adr, res;
34441 u32 src, dst;
34442 u32 corf = 0;
34443
34444 adr = AREG((Opcode >> 0) & 7) - 1;
34445 AREG((Opcode >> 0) & 7) = adr;
34446 PRE_IO
34447 READ_BYTE_F(adr, src)
34448 adr = AREG(7) - 2;
34449 AREG(7) = adr;
34450 READ_BYTE_F(adr, dst)
34451 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34452 if (res > 9) corf = 6;
34453 res += (dst & 0xF0) + (src & 0xF0);
34454 flag_V = ~res;
34455 res += corf;
34456 if (res > 0x9F)
34457 {
34458 res -= 0xA0;
34459 flag_X = flag_C = M68K_SR_C;
34460 }
34461 else flag_X = flag_C = 0;
34462 flag_V &= res;
34463 flag_NotZ |= res & 0xFF;
34464 flag_N = res;
34465 WRITE_BYTE_F(adr, res)
34466 POST_IO
34467RET(18)
34468}
34469
34470// ABCD7M7
34471OPCODE(0xCF0F)
34472{
34473 u32 adr, res;
34474 u32 src, dst;
34475 u32 corf = 0;
34476
34477 adr = AREG(7) - 2;
34478 AREG(7) = adr;
34479 PRE_IO
34480 READ_BYTE_F(adr, src)
34481 adr = AREG(7) - 2;
34482 AREG(7) = adr;
34483 READ_BYTE_F(adr, dst)
34484 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34485 if (res > 9) corf = 6;
34486 res += (dst & 0xF0) + (src & 0xF0);
34487 flag_V = ~res;
34488 res += corf;
34489 if (res > 0x9F)
34490 {
34491 res -= 0xA0;
34492 flag_X = flag_C = M68K_SR_C;
34493 }
34494 else flag_X = flag_C = 0;
34495 flag_V &= res;
34496 flag_NotZ |= res & 0xFF;
34497 flag_N = res;
34498 WRITE_BYTE_F(adr, res)
34499 POST_IO
34500RET(18)
34501}
34502
34503// MULU
34504OPCODE(0xC0C0)
34505{
34506 u32 adr, res;
34507 u32 src, dst;
34508
34509 src = DREGu16((Opcode >> 0) & 7);
34510 res = DREGu16((Opcode >> 9) & 7);
34511 res *= src;
34512 flag_N = res >> 24;
34513 flag_NotZ = res;
34514 flag_V = flag_C = 0;
34515 DREGu32((Opcode >> 9) & 7) = res;
34516#ifdef USE_CYCLONE_TIMING
34517RET(38+BITCOUNT(res,src)*2)
34518#else
34519RET(50)
34520#endif
34521}
34522
34523// MULU
34524OPCODE(0xC0D0)
34525{
34526 u32 adr, res;
34527 u32 src, dst;
34528
34529 adr = AREG((Opcode >> 0) & 7);
34530 PRE_IO
34531 READ_WORD_F(adr, src)
34532 res = DREGu16((Opcode >> 9) & 7);
34533 res *= src;
34534 flag_N = res >> 24;
34535 flag_NotZ = res;
34536 flag_V = flag_C = 0;
34537 DREGu32((Opcode >> 9) & 7) = res;
34538 POST_IO
34539#ifdef USE_CYCLONE_TIMING
34540RET(42+BITCOUNT(res,src)*2)
34541#else
34542RET(54)
34543#endif
34544}
34545
34546// MULU
34547OPCODE(0xC0D8)
34548{
34549 u32 adr, res;
34550 u32 src, dst;
34551
34552 adr = AREG((Opcode >> 0) & 7);
34553 AREG((Opcode >> 0) & 7) += 2;
34554 PRE_IO
34555 READ_WORD_F(adr, src)
34556 res = DREGu16((Opcode >> 9) & 7);
34557 res *= src;
34558 flag_N = res >> 24;
34559 flag_NotZ = res;
34560 flag_V = flag_C = 0;
34561 DREGu32((Opcode >> 9) & 7) = res;
34562 POST_IO
34563#ifdef USE_CYCLONE_TIMING
34564RET(42+BITCOUNT(res,src)*2)
34565#else
34566RET(54)
34567#endif
34568}
34569
34570// MULU
34571OPCODE(0xC0E0)
34572{
34573 u32 adr, res;
34574 u32 src, dst;
34575
34576 adr = AREG((Opcode >> 0) & 7) - 2;
34577 AREG((Opcode >> 0) & 7) = adr;
34578 PRE_IO
34579 READ_WORD_F(adr, src)
34580 res = DREGu16((Opcode >> 9) & 7);
34581 res *= src;
34582 flag_N = res >> 24;
34583 flag_NotZ = res;
34584 flag_V = flag_C = 0;
34585 DREGu32((Opcode >> 9) & 7) = res;
34586 POST_IO
34587#ifdef USE_CYCLONE_TIMING
34588RET(44+BITCOUNT(res,src)*2)
34589#else
34590RET(56)
34591#endif
34592}
34593
34594// MULU
34595OPCODE(0xC0E8)
34596{
34597 u32 adr, res;
34598 u32 src, dst;
34599
34600 FETCH_SWORD(adr);
34601 adr += AREG((Opcode >> 0) & 7);
34602 PRE_IO
34603 READ_WORD_F(adr, src)
34604 res = DREGu16((Opcode >> 9) & 7);
34605 res *= src;
34606 flag_N = res >> 24;
34607 flag_NotZ = res;
34608 flag_V = flag_C = 0;
34609 DREGu32((Opcode >> 9) & 7) = res;
34610 POST_IO
34611#ifdef USE_CYCLONE_TIMING
34612RET(46+BITCOUNT(res,src)*2)
34613#else
34614RET(58)
34615#endif
34616}
34617
34618// MULU
34619OPCODE(0xC0F0)
34620{
34621 u32 adr, res;
34622 u32 src, dst;
34623
34624 adr = AREG((Opcode >> 0) & 7);
34625 DECODE_EXT_WORD
34626 PRE_IO
34627 READ_WORD_F(adr, src)
34628 res = DREGu16((Opcode >> 9) & 7);
34629 res *= src;
34630 flag_N = res >> 24;
34631 flag_NotZ = res;
34632 flag_V = flag_C = 0;
34633 DREGu32((Opcode >> 9) & 7) = res;
34634 POST_IO
34635#ifdef USE_CYCLONE_TIMING
34636RET(48+BITCOUNT(res,src)*2)
34637#else
34638RET(60)
34639#endif
34640}
34641
34642// MULU
34643OPCODE(0xC0F8)
34644{
34645 u32 adr, res;
34646 u32 src, dst;
34647
34648 FETCH_SWORD(adr);
34649 PRE_IO
34650 READ_WORD_F(adr, src)
34651 res = DREGu16((Opcode >> 9) & 7);
34652 res *= src;
34653 flag_N = res >> 24;
34654 flag_NotZ = res;
34655 flag_V = flag_C = 0;
34656 DREGu32((Opcode >> 9) & 7) = res;
34657 POST_IO
34658#ifdef USE_CYCLONE_TIMING
34659RET(46+BITCOUNT(res,src)*2)
34660#else
34661RET(58)
34662#endif
34663}
34664
34665// MULU
34666OPCODE(0xC0F9)
34667{
34668 u32 adr, res;
34669 u32 src, dst;
34670
34671 FETCH_LONG(adr);
34672 PRE_IO
34673 READ_WORD_F(adr, src)
34674 res = DREGu16((Opcode >> 9) & 7);
34675 res *= src;
34676 flag_N = res >> 24;
34677 flag_NotZ = res;
34678 flag_V = flag_C = 0;
34679 DREGu32((Opcode >> 9) & 7) = res;
34680 POST_IO
34681#ifdef USE_CYCLONE_TIMING
34682RET(50+BITCOUNT(res,src)*2)
34683#else
34684RET(62)
34685#endif
34686}
34687
34688// MULU
34689OPCODE(0xC0FA)
34690{
34691 u32 adr, res;
34692 u32 src, dst;
34693
34694 adr = GET_SWORD + GET_PC;
34695 PC++;
34696 PRE_IO
34697 READ_WORD_F(adr, src)
34698 res = DREGu16((Opcode >> 9) & 7);
34699 res *= src;
34700 flag_N = res >> 24;
34701 flag_NotZ = res;
34702 flag_V = flag_C = 0;
34703 DREGu32((Opcode >> 9) & 7) = res;
34704 POST_IO
34705#ifdef USE_CYCLONE_TIMING
34706RET(46+BITCOUNT(res,src)*2)
34707#else
34708RET(58)
34709#endif
34710}
34711
34712// MULU
34713OPCODE(0xC0FB)
34714{
34715 u32 adr, res;
34716 u32 src, dst;
34717
34718 adr = GET_PC;
34719 DECODE_EXT_WORD
34720 PRE_IO
34721 READ_WORD_F(adr, src)
34722 res = DREGu16((Opcode >> 9) & 7);
34723 res *= src;
34724 flag_N = res >> 24;
34725 flag_NotZ = res;
34726 flag_V = flag_C = 0;
34727 DREGu32((Opcode >> 9) & 7) = res;
34728 POST_IO
34729#ifdef USE_CYCLONE_TIMING
34730RET(48+BITCOUNT(res,src)*2)
34731#else
34732RET(60)
34733#endif
34734}
34735
34736// MULU
34737OPCODE(0xC0FC)
34738{
34739 u32 adr, res;
34740 u32 src, dst;
34741
34742 FETCH_WORD(src);
34743 res = DREGu16((Opcode >> 9) & 7);
34744 res *= src;
34745 flag_N = res >> 24;
34746 flag_NotZ = res;
34747 flag_V = flag_C = 0;
34748 DREGu32((Opcode >> 9) & 7) = res;
34749#ifdef USE_CYCLONE_TIMING
34750RET(42+BITCOUNT(res,src)*2)
34751#else
34752RET(54)
34753#endif
34754}
34755
34756// MULU
34757OPCODE(0xC0DF)
34758{
34759 u32 adr, res;
34760 u32 src, dst;
34761
34762 adr = AREG(7);
34763 AREG(7) += 2;
34764 PRE_IO
34765 READ_WORD_F(adr, src)
34766 res = DREGu16((Opcode >> 9) & 7);
34767 res *= src;
34768 flag_N = res >> 24;
34769 flag_NotZ = res;
34770 flag_V = flag_C = 0;
34771 DREGu32((Opcode >> 9) & 7) = res;
34772 POST_IO
34773#ifdef USE_CYCLONE_TIMING
34774RET(42+BITCOUNT(res,src)*2)
34775#else
34776RET(54)
34777#endif
34778}
34779
34780// MULU
34781OPCODE(0xC0E7)
34782{
34783 u32 adr, res;
34784 u32 src, dst;
34785
34786 adr = AREG(7) - 2;
34787 AREG(7) = adr;
34788 PRE_IO
34789 READ_WORD_F(adr, src)
34790 res = DREGu16((Opcode >> 9) & 7);
34791 res *= src;
34792 flag_N = res >> 24;
34793 flag_NotZ = res;
34794 flag_V = flag_C = 0;
34795 DREGu32((Opcode >> 9) & 7) = res;
34796 POST_IO
34797#ifdef USE_CYCLONE_TIMING
34798RET(44+BITCOUNT(res,src)*2)
34799#else
34800RET(56)
34801#endif
34802}
34803
34804// MULS
34805OPCODE(0xC1C0)
34806{
34807 u32 adr, res;
34808 u32 src, dst;
34809
34810 src = (s32)DREGs16((Opcode >> 0) & 7);
34811 res = (s32)DREGs16((Opcode >> 9) & 7);
34812 res = ((s32)res) * ((s32)src);
34813 flag_N = res >> 24;
34814 flag_NotZ = res;
34815 flag_V = flag_C = 0;
34816 DREGu32((Opcode >> 9) & 7) = res;
34817#ifdef USE_CYCLONE_TIMING
34818RET(38+BITCOUNT(res,src^(src<<1)))
34819#else
34820RET(50)
34821#endif
34822}
34823
34824// MULS
34825OPCODE(0xC1D0)
34826{
34827 u32 adr, res;
34828 u32 src, dst;
34829
34830 adr = AREG((Opcode >> 0) & 7);
34831 PRE_IO
34832 READSX_WORD_F(adr, src)
34833 res = (s32)DREGs16((Opcode >> 9) & 7);
34834 res = ((s32)res) * ((s32)src);
34835 flag_N = res >> 24;
34836 flag_NotZ = res;
34837 flag_V = flag_C = 0;
34838 DREGu32((Opcode >> 9) & 7) = res;
34839 POST_IO
34840#ifdef USE_CYCLONE_TIMING
34841RET(42+BITCOUNT(res,src^(src<<1))*2)
34842#else
34843RET(54)
34844#endif
34845}
34846
34847// MULS
34848OPCODE(0xC1D8)
34849{
34850 u32 adr, res;
34851 u32 src, dst;
34852
34853 adr = AREG((Opcode >> 0) & 7);
34854 AREG((Opcode >> 0) & 7) += 2;
34855 PRE_IO
34856 READSX_WORD_F(adr, src)
34857 res = (s32)DREGs16((Opcode >> 9) & 7);
34858 res = ((s32)res) * ((s32)src);
34859 flag_N = res >> 24;
34860 flag_NotZ = res;
34861 flag_V = flag_C = 0;
34862 DREGu32((Opcode >> 9) & 7) = res;
34863 POST_IO
34864#ifdef USE_CYCLONE_TIMING
34865RET(42+BITCOUNT(res,src^(src<<1))*2)
34866#else
34867RET(54)
34868#endif
34869}
34870
34871// MULS
34872OPCODE(0xC1E0)
34873{
34874 u32 adr, res;
34875 u32 src, dst;
34876
34877 adr = AREG((Opcode >> 0) & 7) - 2;
34878 AREG((Opcode >> 0) & 7) = adr;
34879 PRE_IO
34880 READSX_WORD_F(adr, src)
34881 res = (s32)DREGs16((Opcode >> 9) & 7);
34882 res = ((s32)res) * ((s32)src);
34883 flag_N = res >> 24;
34884 flag_NotZ = res;
34885 flag_V = flag_C = 0;
34886 DREGu32((Opcode >> 9) & 7) = res;
34887 POST_IO
34888#ifdef USE_CYCLONE_TIMING
34889RET(44+BITCOUNT(res,src^(src<<1))*2)
34890#else
34891RET(56)
34892#endif
34893}
34894
34895// MULS
34896OPCODE(0xC1E8)
34897{
34898 u32 adr, res;
34899 u32 src, dst;
34900
34901 FETCH_SWORD(adr);
34902 adr += AREG((Opcode >> 0) & 7);
34903 PRE_IO
34904 READSX_WORD_F(adr, src)
34905 res = (s32)DREGs16((Opcode >> 9) & 7);
34906 res = ((s32)res) * ((s32)src);
34907 flag_N = res >> 24;
34908 flag_NotZ = res;
34909 flag_V = flag_C = 0;
34910 DREGu32((Opcode >> 9) & 7) = res;
34911 POST_IO
34912#ifdef USE_CYCLONE_TIMING
34913RET(46+BITCOUNT(res,src^(src<<1))*2)
34914#else
34915RET(58)
34916#endif
34917}
34918
34919// MULS
34920OPCODE(0xC1F0)
34921{
34922 u32 adr, res;
34923 u32 src, dst;
34924
34925 adr = AREG((Opcode >> 0) & 7);
34926 DECODE_EXT_WORD
34927 PRE_IO
34928 READSX_WORD_F(adr, src)
34929 res = (s32)DREGs16((Opcode >> 9) & 7);
34930 res = ((s32)res) * ((s32)src);
34931 flag_N = res >> 24;
34932 flag_NotZ = res;
34933 flag_V = flag_C = 0;
34934 DREGu32((Opcode >> 9) & 7) = res;
34935 POST_IO
34936#ifdef USE_CYCLONE_TIMING
34937RET(48+BITCOUNT(res,src^(src<<1))*2)
34938#else
34939RET(60)
34940#endif
34941}
34942
34943// MULS
34944OPCODE(0xC1F8)
34945{
34946 u32 adr, res;
34947 u32 src, dst;
34948
34949 FETCH_SWORD(adr);
34950 PRE_IO
34951 READSX_WORD_F(adr, src)
34952 res = (s32)DREGs16((Opcode >> 9) & 7);
34953 res = ((s32)res) * ((s32)src);
34954 flag_N = res >> 24;
34955 flag_NotZ = res;
34956 flag_V = flag_C = 0;
34957 DREGu32((Opcode >> 9) & 7) = res;
34958 POST_IO
34959#ifdef USE_CYCLONE_TIMING
34960RET(46+BITCOUNT(res,src^(src<<1))*2)
34961#else
34962RET(58)
34963#endif
34964}
34965
34966// MULS
34967OPCODE(0xC1F9)
34968{
34969 u32 adr, res;
34970 u32 src, dst;
34971
34972 FETCH_LONG(adr);
34973 PRE_IO
34974 READSX_WORD_F(adr, src)
34975 res = (s32)DREGs16((Opcode >> 9) & 7);
34976 res = ((s32)res) * ((s32)src);
34977 flag_N = res >> 24;
34978 flag_NotZ = res;
34979 flag_V = flag_C = 0;
34980 DREGu32((Opcode >> 9) & 7) = res;
34981 POST_IO
34982#ifdef USE_CYCLONE_TIMING
34983RET(50+BITCOUNT(res,src^(src<<1))*2)
34984#else
34985RET(62)
34986#endif
34987}
34988
34989// MULS
34990OPCODE(0xC1FA)
34991{
34992 u32 adr, res;
34993 u32 src, dst;
34994
34995 adr = GET_SWORD + GET_PC;
34996 PC++;
34997 PRE_IO
34998 READSX_WORD_F(adr, src)
34999 res = (s32)DREGs16((Opcode >> 9) & 7);
35000 res = ((s32)res) * ((s32)src);
35001 flag_N = res >> 24;
35002 flag_NotZ = res;
35003 flag_V = flag_C = 0;
35004 DREGu32((Opcode >> 9) & 7) = res;
35005 POST_IO
35006#ifdef USE_CYCLONE_TIMING
35007RET(46+BITCOUNT(res,src^(src<<1))*2)
35008#else
35009RET(58)
35010#endif
35011}
35012
35013// MULS
35014OPCODE(0xC1FB)
35015{
35016 u32 adr, res;
35017 u32 src, dst;
35018
35019 adr = GET_PC;
35020 DECODE_EXT_WORD
35021 PRE_IO
35022 READSX_WORD_F(adr, src)
35023 res = (s32)DREGs16((Opcode >> 9) & 7);
35024 res = ((s32)res) * ((s32)src);
35025 flag_N = res >> 24;
35026 flag_NotZ = res;
35027 flag_V = flag_C = 0;
35028 DREGu32((Opcode >> 9) & 7) = res;
35029 POST_IO
35030#ifdef USE_CYCLONE_TIMING
35031RET(48+BITCOUNT(res,src^(src<<1))*2)
35032#else
35033RET(60)
35034#endif
35035}
35036
35037// MULS
35038OPCODE(0xC1FC)
35039{
35040 u32 adr, res;
35041 u32 src, dst;
35042
35043 FETCH_SWORD(src);
35044 res = (s32)DREGs16((Opcode >> 9) & 7);
35045 res = ((s32)res) * ((s32)src);
35046 flag_N = res >> 24;
35047 flag_NotZ = res;
35048 flag_V = flag_C = 0;
35049 DREGu32((Opcode >> 9) & 7) = res;
35050#ifdef USE_CYCLONE_TIMING
35051RET(42+BITCOUNT(res,src^(src<<1))*2)
35052#else
35053RET(54)
35054#endif
35055}
35056
35057// MULS
35058OPCODE(0xC1DF)
35059{
35060 u32 adr, res;
35061 u32 src, dst;
35062
35063 adr = AREG(7);
35064 AREG(7) += 2;
35065 PRE_IO
35066 READSX_WORD_F(adr, src)
35067 res = (s32)DREGs16((Opcode >> 9) & 7);
35068 res = ((s32)res) * ((s32)src);
35069 flag_N = res >> 24;
35070 flag_NotZ = res;
35071 flag_V = flag_C = 0;
35072 DREGu32((Opcode >> 9) & 7) = res;
35073 POST_IO
35074#ifdef USE_CYCLONE_TIMING
35075RET(42+BITCOUNT(res,src^(src<<1))*2)
35076#else
35077RET(54)
35078#endif
35079}
35080
35081// MULS
35082OPCODE(0xC1E7)
35083{
35084 u32 adr, res;
35085 u32 src, dst;
35086
35087 adr = AREG(7) - 2;
35088 AREG(7) = adr;
35089 PRE_IO
35090 READSX_WORD_F(adr, src)
35091 res = (s32)DREGs16((Opcode >> 9) & 7);
35092 res = ((s32)res) * ((s32)src);
35093 flag_N = res >> 24;
35094 flag_NotZ = res;
35095 flag_V = flag_C = 0;
35096 DREGu32((Opcode >> 9) & 7) = res;
35097 POST_IO
35098#ifdef USE_CYCLONE_TIMING
35099RET(44+BITCOUNT(res,src^(src<<1))*2)
35100#else
35101RET(56)
35102#endif
35103}
35104
35105// EXGDD
35106OPCODE(0xC140)
35107{
35108 u32 adr, res;
35109 u32 src, dst;
35110
35111 res = DREGu32((Opcode >> 0) & 7);
35112 src = DREGu32((Opcode >> 9) & 7);
35113 DREGu32((Opcode >> 9) & 7) = res;
35114 res = src;
35115 DREGu32((Opcode >> 0) & 7) = res;
35116RET(6)
35117}
35118
35119// EXGAA
35120OPCODE(0xC148)
35121{
35122 u32 adr, res;
35123 u32 src, dst;
35124
35125 res = AREGu32((Opcode >> 0) & 7);
35126 src = AREGu32((Opcode >> 9) & 7);
35127 AREG((Opcode >> 9) & 7) = res;
35128 res = src;
35129 AREG((Opcode >> 0) & 7) = res;
35130RET(6)
35131}
35132
35133// EXGAD
35134OPCODE(0xC188)
35135{
35136 u32 adr, res;
35137 u32 src, dst;
35138
35139 res = AREGu32((Opcode >> 0) & 7);
35140 src = DREGu32((Opcode >> 9) & 7);
35141 DREGu32((Opcode >> 9) & 7) = res;
35142 res = src;
35143 AREG((Opcode >> 0) & 7) = res;
35144RET(6)
35145}
35146
35147// ADDaD
35148OPCODE(0xD000)
35149{
35150 u32 adr, res;
35151 u32 src, dst;
35152
35153 src = DREGu8((Opcode >> 0) & 7);
35154 dst = DREGu8((Opcode >> 9) & 7);
35155 res = dst + src;
35156 flag_N = flag_X = flag_C = res;
35157 flag_V = (src ^ res) & (dst ^ res);
35158 flag_NotZ = res & 0xFF;
35159 DREGu8((Opcode >> 9) & 7) = res;
35160RET(4)
35161}
35162
35163// ADDaD
35164#if 0
35165OPCODE(0xD008)
35166{
35167 u32 adr, res;
35168 u32 src, dst;
35169
35170 // can't read byte from Ax registers !
35171 ctx->execinfo |= M68K_FAULTED;
35172 ctx->io_cycle_counter = 0;
35173/*
35174 goto famec_Exec_End;
35175 dst = DREGu8((Opcode >> 9) & 7);
35176 res = dst + src;
35177 flag_N = flag_X = flag_C = res;
35178 flag_V = (src ^ res) & (dst ^ res);
35179 flag_NotZ = res & 0xFF;
35180 DREGu8((Opcode >> 9) & 7) = res;
35181*/
35182RET(4)
35183}
35184#endif
35185
35186// ADDaD
35187OPCODE(0xD010)
35188{
35189 u32 adr, res;
35190 u32 src, dst;
35191
35192 adr = AREG((Opcode >> 0) & 7);
35193 PRE_IO
35194 READ_BYTE_F(adr, src)
35195 dst = DREGu8((Opcode >> 9) & 7);
35196 res = dst + src;
35197 flag_N = flag_X = flag_C = res;
35198 flag_V = (src ^ res) & (dst ^ res);
35199 flag_NotZ = res & 0xFF;
35200 DREGu8((Opcode >> 9) & 7) = res;
35201 POST_IO
35202RET(8)
35203}
35204
35205// ADDaD
35206OPCODE(0xD018)
35207{
35208 u32 adr, res;
35209 u32 src, dst;
35210
35211 adr = AREG((Opcode >> 0) & 7);
35212 AREG((Opcode >> 0) & 7) += 1;
35213 PRE_IO
35214 READ_BYTE_F(adr, src)
35215 dst = DREGu8((Opcode >> 9) & 7);
35216 res = dst + src;
35217 flag_N = flag_X = flag_C = res;
35218 flag_V = (src ^ res) & (dst ^ res);
35219 flag_NotZ = res & 0xFF;
35220 DREGu8((Opcode >> 9) & 7) = res;
35221 POST_IO
35222RET(8)
35223}
35224
35225// ADDaD
35226OPCODE(0xD020)
35227{
35228 u32 adr, res;
35229 u32 src, dst;
35230
35231 adr = AREG((Opcode >> 0) & 7) - 1;
35232 AREG((Opcode >> 0) & 7) = adr;
35233 PRE_IO
35234 READ_BYTE_F(adr, src)
35235 dst = DREGu8((Opcode >> 9) & 7);
35236 res = dst + src;
35237 flag_N = flag_X = flag_C = res;
35238 flag_V = (src ^ res) & (dst ^ res);
35239 flag_NotZ = res & 0xFF;
35240 DREGu8((Opcode >> 9) & 7) = res;
35241 POST_IO
35242RET(10)
35243}
35244
35245// ADDaD
35246OPCODE(0xD028)
35247{
35248 u32 adr, res;
35249 u32 src, dst;
35250
35251 FETCH_SWORD(adr);
35252 adr += AREG((Opcode >> 0) & 7);
35253 PRE_IO
35254 READ_BYTE_F(adr, src)
35255 dst = DREGu8((Opcode >> 9) & 7);
35256 res = dst + src;
35257 flag_N = flag_X = flag_C = res;
35258 flag_V = (src ^ res) & (dst ^ res);
35259 flag_NotZ = res & 0xFF;
35260 DREGu8((Opcode >> 9) & 7) = res;
35261 POST_IO
35262RET(12)
35263}
35264
35265// ADDaD
35266OPCODE(0xD030)
35267{
35268 u32 adr, res;
35269 u32 src, dst;
35270
35271 adr = AREG((Opcode >> 0) & 7);
35272 DECODE_EXT_WORD
35273 PRE_IO
35274 READ_BYTE_F(adr, src)
35275 dst = DREGu8((Opcode >> 9) & 7);
35276 res = dst + src;
35277 flag_N = flag_X = flag_C = res;
35278 flag_V = (src ^ res) & (dst ^ res);
35279 flag_NotZ = res & 0xFF;
35280 DREGu8((Opcode >> 9) & 7) = res;
35281 POST_IO
35282RET(14)
35283}
35284
35285// ADDaD
35286OPCODE(0xD038)
35287{
35288 u32 adr, res;
35289 u32 src, dst;
35290
35291 FETCH_SWORD(adr);
35292 PRE_IO
35293 READ_BYTE_F(adr, src)
35294 dst = DREGu8((Opcode >> 9) & 7);
35295 res = dst + src;
35296 flag_N = flag_X = flag_C = res;
35297 flag_V = (src ^ res) & (dst ^ res);
35298 flag_NotZ = res & 0xFF;
35299 DREGu8((Opcode >> 9) & 7) = res;
35300 POST_IO
35301RET(12)
35302}
35303
35304// ADDaD
35305OPCODE(0xD039)
35306{
35307 u32 adr, res;
35308 u32 src, dst;
35309
35310 FETCH_LONG(adr);
35311 PRE_IO
35312 READ_BYTE_F(adr, src)
35313 dst = DREGu8((Opcode >> 9) & 7);
35314 res = dst + src;
35315 flag_N = flag_X = flag_C = res;
35316 flag_V = (src ^ res) & (dst ^ res);
35317 flag_NotZ = res & 0xFF;
35318 DREGu8((Opcode >> 9) & 7) = res;
35319 POST_IO
35320RET(16)
35321}
35322
35323// ADDaD
35324OPCODE(0xD03A)
35325{
35326 u32 adr, res;
35327 u32 src, dst;
35328
35329 adr = GET_SWORD + GET_PC;
35330 PC++;
35331 PRE_IO
35332 READ_BYTE_F(adr, src)
35333 dst = DREGu8((Opcode >> 9) & 7);
35334 res = dst + src;
35335 flag_N = flag_X = flag_C = res;
35336 flag_V = (src ^ res) & (dst ^ res);
35337 flag_NotZ = res & 0xFF;
35338 DREGu8((Opcode >> 9) & 7) = res;
35339 POST_IO
35340RET(12)
35341}
35342
35343// ADDaD
35344OPCODE(0xD03B)
35345{
35346 u32 adr, res;
35347 u32 src, dst;
35348
35349 adr = GET_PC;
35350 DECODE_EXT_WORD
35351 PRE_IO
35352 READ_BYTE_F(adr, src)
35353 dst = DREGu8((Opcode >> 9) & 7);
35354 res = dst + src;
35355 flag_N = flag_X = flag_C = res;
35356 flag_V = (src ^ res) & (dst ^ res);
35357 flag_NotZ = res & 0xFF;
35358 DREGu8((Opcode >> 9) & 7) = res;
35359 POST_IO
35360RET(14)
35361}
35362
35363// ADDaD
35364OPCODE(0xD03C)
35365{
35366 u32 adr, res;
35367 u32 src, dst;
35368
35369 FETCH_BYTE(src);
35370 dst = DREGu8((Opcode >> 9) & 7);
35371 res = dst + src;
35372 flag_N = flag_X = flag_C = res;
35373 flag_V = (src ^ res) & (dst ^ res);
35374 flag_NotZ = res & 0xFF;
35375 DREGu8((Opcode >> 9) & 7) = res;
35376RET(8)
35377}
35378
35379// ADDaD
35380OPCODE(0xD01F)
35381{
35382 u32 adr, res;
35383 u32 src, dst;
35384
35385 adr = AREG(7);
35386 AREG(7) += 2;
35387 PRE_IO
35388 READ_BYTE_F(adr, src)
35389 dst = DREGu8((Opcode >> 9) & 7);
35390 res = dst + src;
35391 flag_N = flag_X = flag_C = res;
35392 flag_V = (src ^ res) & (dst ^ res);
35393 flag_NotZ = res & 0xFF;
35394 DREGu8((Opcode >> 9) & 7) = res;
35395 POST_IO
35396RET(8)
35397}
35398
35399// ADDaD
35400OPCODE(0xD027)
35401{
35402 u32 adr, res;
35403 u32 src, dst;
35404
35405 adr = AREG(7) - 2;
35406 AREG(7) = adr;
35407 PRE_IO
35408 READ_BYTE_F(adr, src)
35409 dst = DREGu8((Opcode >> 9) & 7);
35410 res = dst + src;
35411 flag_N = flag_X = flag_C = res;
35412 flag_V = (src ^ res) & (dst ^ res);
35413 flag_NotZ = res & 0xFF;
35414 DREGu8((Opcode >> 9) & 7) = res;
35415 POST_IO
35416RET(10)
35417}
35418
35419// ADDaD
35420OPCODE(0xD040)
35421{
35422 u32 adr, res;
35423 u32 src, dst;
35424
35425 src = DREGu16((Opcode >> 0) & 7);
35426 dst = DREGu16((Opcode >> 9) & 7);
35427 res = dst + src;
35428 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35429 flag_N = flag_X = flag_C = res >> 8;
35430 flag_NotZ = res & 0xFFFF;
35431 DREGu16((Opcode >> 9) & 7) = res;
35432RET(4)
35433}
35434
35435// ADDaD
35436OPCODE(0xD048)
35437{
35438 u32 adr, res;
35439 u32 src, dst;
35440
35441 src = AREGu16((Opcode >> 0) & 7);
35442 dst = DREGu16((Opcode >> 9) & 7);
35443 res = dst + src;
35444 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35445 flag_N = flag_X = flag_C = res >> 8;
35446 flag_NotZ = res & 0xFFFF;
35447 DREGu16((Opcode >> 9) & 7) = res;
35448RET(4)
35449}
35450
35451// ADDaD
35452OPCODE(0xD050)
35453{
35454 u32 adr, res;
35455 u32 src, dst;
35456
35457 adr = AREG((Opcode >> 0) & 7);
35458 PRE_IO
35459 READ_WORD_F(adr, src)
35460 dst = DREGu16((Opcode >> 9) & 7);
35461 res = dst + src;
35462 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35463 flag_N = flag_X = flag_C = res >> 8;
35464 flag_NotZ = res & 0xFFFF;
35465 DREGu16((Opcode >> 9) & 7) = res;
35466 POST_IO
35467RET(8)
35468}
35469
35470// ADDaD
35471OPCODE(0xD058)
35472{
35473 u32 adr, res;
35474 u32 src, dst;
35475
35476 adr = AREG((Opcode >> 0) & 7);
35477 AREG((Opcode >> 0) & 7) += 2;
35478 PRE_IO
35479 READ_WORD_F(adr, src)
35480 dst = DREGu16((Opcode >> 9) & 7);
35481 res = dst + src;
35482 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35483 flag_N = flag_X = flag_C = res >> 8;
35484 flag_NotZ = res & 0xFFFF;
35485 DREGu16((Opcode >> 9) & 7) = res;
35486 POST_IO
35487RET(8)
35488}
35489
35490// ADDaD
35491OPCODE(0xD060)
35492{
35493 u32 adr, res;
35494 u32 src, dst;
35495
35496 adr = AREG((Opcode >> 0) & 7) - 2;
35497 AREG((Opcode >> 0) & 7) = adr;
35498 PRE_IO
35499 READ_WORD_F(adr, src)
35500 dst = DREGu16((Opcode >> 9) & 7);
35501 res = dst + src;
35502 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35503 flag_N = flag_X = flag_C = res >> 8;
35504 flag_NotZ = res & 0xFFFF;
35505 DREGu16((Opcode >> 9) & 7) = res;
35506 POST_IO
35507RET(10)
35508}
35509
35510// ADDaD
35511OPCODE(0xD068)
35512{
35513 u32 adr, res;
35514 u32 src, dst;
35515
35516 FETCH_SWORD(adr);
35517 adr += AREG((Opcode >> 0) & 7);
35518 PRE_IO
35519 READ_WORD_F(adr, src)
35520 dst = DREGu16((Opcode >> 9) & 7);
35521 res = dst + src;
35522 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35523 flag_N = flag_X = flag_C = res >> 8;
35524 flag_NotZ = res & 0xFFFF;
35525 DREGu16((Opcode >> 9) & 7) = res;
35526 POST_IO
35527RET(12)
35528}
35529
35530// ADDaD
35531OPCODE(0xD070)
35532{
35533 u32 adr, res;
35534 u32 src, dst;
35535
35536 adr = AREG((Opcode >> 0) & 7);
35537 DECODE_EXT_WORD
35538 PRE_IO
35539 READ_WORD_F(adr, src)
35540 dst = DREGu16((Opcode >> 9) & 7);
35541 res = dst + src;
35542 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35543 flag_N = flag_X = flag_C = res >> 8;
35544 flag_NotZ = res & 0xFFFF;
35545 DREGu16((Opcode >> 9) & 7) = res;
35546 POST_IO
35547RET(14)
35548}
35549
35550// ADDaD
35551OPCODE(0xD078)
35552{
35553 u32 adr, res;
35554 u32 src, dst;
35555
35556 FETCH_SWORD(adr);
35557 PRE_IO
35558 READ_WORD_F(adr, src)
35559 dst = DREGu16((Opcode >> 9) & 7);
35560 res = dst + src;
35561 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35562 flag_N = flag_X = flag_C = res >> 8;
35563 flag_NotZ = res & 0xFFFF;
35564 DREGu16((Opcode >> 9) & 7) = res;
35565 POST_IO
35566RET(12)
35567}
35568
35569// ADDaD
35570OPCODE(0xD079)
35571{
35572 u32 adr, res;
35573 u32 src, dst;
35574
35575 FETCH_LONG(adr);
35576 PRE_IO
35577 READ_WORD_F(adr, src)
35578 dst = DREGu16((Opcode >> 9) & 7);
35579 res = dst + src;
35580 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35581 flag_N = flag_X = flag_C = res >> 8;
35582 flag_NotZ = res & 0xFFFF;
35583 DREGu16((Opcode >> 9) & 7) = res;
35584 POST_IO
35585RET(16)
35586}
35587
35588// ADDaD
35589OPCODE(0xD07A)
35590{
35591 u32 adr, res;
35592 u32 src, dst;
35593
35594 adr = GET_SWORD + GET_PC;
35595 PC++;
35596 PRE_IO
35597 READ_WORD_F(adr, src)
35598 dst = DREGu16((Opcode >> 9) & 7);
35599 res = dst + src;
35600 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35601 flag_N = flag_X = flag_C = res >> 8;
35602 flag_NotZ = res & 0xFFFF;
35603 DREGu16((Opcode >> 9) & 7) = res;
35604 POST_IO
35605RET(12)
35606}
35607
35608// ADDaD
35609OPCODE(0xD07B)
35610{
35611 u32 adr, res;
35612 u32 src, dst;
35613
35614 adr = GET_PC;
35615 DECODE_EXT_WORD
35616 PRE_IO
35617 READ_WORD_F(adr, src)
35618 dst = DREGu16((Opcode >> 9) & 7);
35619 res = dst + src;
35620 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35621 flag_N = flag_X = flag_C = res >> 8;
35622 flag_NotZ = res & 0xFFFF;
35623 DREGu16((Opcode >> 9) & 7) = res;
35624 POST_IO
35625RET(14)
35626}
35627
35628// ADDaD
35629OPCODE(0xD07C)
35630{
35631 u32 adr, res;
35632 u32 src, dst;
35633
35634 FETCH_WORD(src);
35635 dst = DREGu16((Opcode >> 9) & 7);
35636 res = dst + src;
35637 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35638 flag_N = flag_X = flag_C = res >> 8;
35639 flag_NotZ = res & 0xFFFF;
35640 DREGu16((Opcode >> 9) & 7) = res;
35641RET(8)
35642}
35643
35644// ADDaD
35645OPCODE(0xD05F)
35646{
35647 u32 adr, res;
35648 u32 src, dst;
35649
35650 adr = AREG(7);
35651 AREG(7) += 2;
35652 PRE_IO
35653 READ_WORD_F(adr, src)
35654 dst = DREGu16((Opcode >> 9) & 7);
35655 res = dst + src;
35656 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35657 flag_N = flag_X = flag_C = res >> 8;
35658 flag_NotZ = res & 0xFFFF;
35659 DREGu16((Opcode >> 9) & 7) = res;
35660 POST_IO
35661RET(8)
35662}
35663
35664// ADDaD
35665OPCODE(0xD067)
35666{
35667 u32 adr, res;
35668 u32 src, dst;
35669
35670 adr = AREG(7) - 2;
35671 AREG(7) = adr;
35672 PRE_IO
35673 READ_WORD_F(adr, src)
35674 dst = DREGu16((Opcode >> 9) & 7);
35675 res = dst + src;
35676 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35677 flag_N = flag_X = flag_C = res >> 8;
35678 flag_NotZ = res & 0xFFFF;
35679 DREGu16((Opcode >> 9) & 7) = res;
35680 POST_IO
35681RET(10)
35682}
35683
35684// ADDaD
35685OPCODE(0xD080)
35686{
35687 u32 adr, res;
35688 u32 src, dst;
35689
35690 src = DREGu32((Opcode >> 0) & 7);
35691 dst = DREGu32((Opcode >> 9) & 7);
35692 res = dst + src;
35693 flag_NotZ = res;
35694 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35695 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35696 flag_N = res >> 24;
35697 DREGu32((Opcode >> 9) & 7) = res;
35698RET(8)
35699}
35700
35701// ADDaD
35702OPCODE(0xD088)
35703{
35704 u32 adr, res;
35705 u32 src, dst;
35706
35707 src = AREGu32((Opcode >> 0) & 7);
35708 dst = DREGu32((Opcode >> 9) & 7);
35709 res = dst + src;
35710 flag_NotZ = res;
35711 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35712 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35713 flag_N = res >> 24;
35714 DREGu32((Opcode >> 9) & 7) = res;
35715RET(8)
35716}
35717
35718// ADDaD
35719OPCODE(0xD090)
35720{
35721 u32 adr, res;
35722 u32 src, dst;
35723
35724 adr = AREG((Opcode >> 0) & 7);
35725 PRE_IO
35726 READ_LONG_F(adr, src)
35727 dst = DREGu32((Opcode >> 9) & 7);
35728 res = dst + src;
35729 flag_NotZ = res;
35730 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35731 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35732 flag_N = res >> 24;
35733 DREGu32((Opcode >> 9) & 7) = res;
35734 POST_IO
35735RET(14)
35736}
35737
35738// ADDaD
35739OPCODE(0xD098)
35740{
35741 u32 adr, res;
35742 u32 src, dst;
35743
35744 adr = AREG((Opcode >> 0) & 7);
35745 AREG((Opcode >> 0) & 7) += 4;
35746 PRE_IO
35747 READ_LONG_F(adr, src)
35748 dst = DREGu32((Opcode >> 9) & 7);
35749 res = dst + src;
35750 flag_NotZ = res;
35751 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35752 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35753 flag_N = res >> 24;
35754 DREGu32((Opcode >> 9) & 7) = res;
35755 POST_IO
35756RET(14)
35757}
35758
35759// ADDaD
35760OPCODE(0xD0A0)
35761{
35762 u32 adr, res;
35763 u32 src, dst;
35764
35765 adr = AREG((Opcode >> 0) & 7) - 4;
35766 AREG((Opcode >> 0) & 7) = adr;
35767 PRE_IO
35768 READ_LONG_F(adr, src)
35769 dst = DREGu32((Opcode >> 9) & 7);
35770 res = dst + src;
35771 flag_NotZ = res;
35772 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35773 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35774 flag_N = res >> 24;
35775 DREGu32((Opcode >> 9) & 7) = res;
35776 POST_IO
35777RET(16)
35778}
35779
35780// ADDaD
35781OPCODE(0xD0A8)
35782{
35783 u32 adr, res;
35784 u32 src, dst;
35785
35786 FETCH_SWORD(adr);
35787 adr += AREG((Opcode >> 0) & 7);
35788 PRE_IO
35789 READ_LONG_F(adr, src)
35790 dst = DREGu32((Opcode >> 9) & 7);
35791 res = dst + src;
35792 flag_NotZ = res;
35793 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35794 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35795 flag_N = res >> 24;
35796 DREGu32((Opcode >> 9) & 7) = res;
35797 POST_IO
35798RET(18)
35799}
35800
35801// ADDaD
35802OPCODE(0xD0B0)
35803{
35804 u32 adr, res;
35805 u32 src, dst;
35806
35807 adr = AREG((Opcode >> 0) & 7);
35808 DECODE_EXT_WORD
35809 PRE_IO
35810 READ_LONG_F(adr, src)
35811 dst = DREGu32((Opcode >> 9) & 7);
35812 res = dst + src;
35813 flag_NotZ = res;
35814 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35815 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35816 flag_N = res >> 24;
35817 DREGu32((Opcode >> 9) & 7) = res;
35818 POST_IO
35819RET(20)
35820}
35821
35822// ADDaD
35823OPCODE(0xD0B8)
35824{
35825 u32 adr, res;
35826 u32 src, dst;
35827
35828 FETCH_SWORD(adr);
35829 PRE_IO
35830 READ_LONG_F(adr, src)
35831 dst = DREGu32((Opcode >> 9) & 7);
35832 res = dst + src;
35833 flag_NotZ = res;
35834 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35835 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35836 flag_N = res >> 24;
35837 DREGu32((Opcode >> 9) & 7) = res;
35838 POST_IO
35839RET(18)
35840}
35841
35842// ADDaD
35843OPCODE(0xD0B9)
35844{
35845 u32 adr, res;
35846 u32 src, dst;
35847
35848 FETCH_LONG(adr);
35849 PRE_IO
35850 READ_LONG_F(adr, src)
35851 dst = DREGu32((Opcode >> 9) & 7);
35852 res = dst + src;
35853 flag_NotZ = res;
35854 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35855 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35856 flag_N = res >> 24;
35857 DREGu32((Opcode >> 9) & 7) = res;
35858 POST_IO
35859RET(22)
35860}
35861
35862// ADDaD
35863OPCODE(0xD0BA)
35864{
35865 u32 adr, res;
35866 u32 src, dst;
35867
35868 adr = GET_SWORD + GET_PC;
35869 PC++;
35870 PRE_IO
35871 READ_LONG_F(adr, src)
35872 dst = DREGu32((Opcode >> 9) & 7);
35873 res = dst + src;
35874 flag_NotZ = res;
35875 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35876 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35877 flag_N = res >> 24;
35878 DREGu32((Opcode >> 9) & 7) = res;
35879 POST_IO
35880RET(18)
35881}
35882
35883// ADDaD
35884OPCODE(0xD0BB)
35885{
35886 u32 adr, res;
35887 u32 src, dst;
35888
35889 adr = GET_PC;
35890 DECODE_EXT_WORD
35891 PRE_IO
35892 READ_LONG_F(adr, src)
35893 dst = DREGu32((Opcode >> 9) & 7);
35894 res = dst + src;
35895 flag_NotZ = res;
35896 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35897 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35898 flag_N = res >> 24;
35899 DREGu32((Opcode >> 9) & 7) = res;
35900 POST_IO
35901RET(20)
35902}
35903
35904// ADDaD
35905OPCODE(0xD0BC)
35906{
35907 u32 adr, res;
35908 u32 src, dst;
35909
35910 FETCH_LONG(src);
35911 dst = DREGu32((Opcode >> 9) & 7);
35912 res = dst + src;
35913 flag_NotZ = res;
35914 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35915 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35916 flag_N = res >> 24;
35917 DREGu32((Opcode >> 9) & 7) = res;
35918RET(16)
35919}
35920
35921// ADDaD
35922OPCODE(0xD09F)
35923{
35924 u32 adr, res;
35925 u32 src, dst;
35926
35927 adr = AREG(7);
35928 AREG(7) += 4;
35929 PRE_IO
35930 READ_LONG_F(adr, src)
35931 dst = DREGu32((Opcode >> 9) & 7);
35932 res = dst + src;
35933 flag_NotZ = res;
35934 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35935 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35936 flag_N = res >> 24;
35937 DREGu32((Opcode >> 9) & 7) = res;
35938 POST_IO
35939RET(14)
35940}
35941
35942// ADDaD
35943OPCODE(0xD0A7)
35944{
35945 u32 adr, res;
35946 u32 src, dst;
35947
35948 adr = AREG(7) - 4;
35949 AREG(7) = adr;
35950 PRE_IO
35951 READ_LONG_F(adr, src)
35952 dst = DREGu32((Opcode >> 9) & 7);
35953 res = dst + src;
35954 flag_NotZ = res;
35955 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35956 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35957 flag_N = res >> 24;
35958 DREGu32((Opcode >> 9) & 7) = res;
35959 POST_IO
35960RET(16)
35961}
35962
35963// ADDDa
35964OPCODE(0xD110)
35965{
35966 u32 adr, res;
35967 u32 src, dst;
35968
35969 src = DREGu8((Opcode >> 9) & 7);
35970 adr = AREG((Opcode >> 0) & 7);
35971 PRE_IO
35972 READ_BYTE_F(adr, dst)
35973 res = dst + src;
35974 flag_N = flag_X = flag_C = res;
35975 flag_V = (src ^ res) & (dst ^ res);
35976 flag_NotZ = res & 0xFF;
35977 WRITE_BYTE_F(adr, res)
35978 POST_IO
35979RET(12)
35980}
35981
35982// ADDDa
35983OPCODE(0xD118)
35984{
35985 u32 adr, res;
35986 u32 src, dst;
35987
35988 src = DREGu8((Opcode >> 9) & 7);
35989 adr = AREG((Opcode >> 0) & 7);
35990 AREG((Opcode >> 0) & 7) += 1;
35991 PRE_IO
35992 READ_BYTE_F(adr, dst)
35993 res = dst + src;
35994 flag_N = flag_X = flag_C = res;
35995 flag_V = (src ^ res) & (dst ^ res);
35996 flag_NotZ = res & 0xFF;
35997 WRITE_BYTE_F(adr, res)
35998 POST_IO
35999RET(12)
36000}
36001
36002// ADDDa
36003OPCODE(0xD120)
36004{
36005 u32 adr, res;
36006 u32 src, dst;
36007
36008 src = DREGu8((Opcode >> 9) & 7);
36009 adr = AREG((Opcode >> 0) & 7) - 1;
36010 AREG((Opcode >> 0) & 7) = adr;
36011 PRE_IO
36012 READ_BYTE_F(adr, dst)
36013 res = dst + src;
36014 flag_N = flag_X = flag_C = res;
36015 flag_V = (src ^ res) & (dst ^ res);
36016 flag_NotZ = res & 0xFF;
36017 WRITE_BYTE_F(adr, res)
36018 POST_IO
36019RET(14)
36020}
36021
36022// ADDDa
36023OPCODE(0xD128)
36024{
36025 u32 adr, res;
36026 u32 src, dst;
36027
36028 src = DREGu8((Opcode >> 9) & 7);
36029 FETCH_SWORD(adr);
36030 adr += AREG((Opcode >> 0) & 7);
36031 PRE_IO
36032 READ_BYTE_F(adr, dst)
36033 res = dst + src;
36034 flag_N = flag_X = flag_C = res;
36035 flag_V = (src ^ res) & (dst ^ res);
36036 flag_NotZ = res & 0xFF;
36037 WRITE_BYTE_F(adr, res)
36038 POST_IO
36039RET(16)
36040}
36041
36042// ADDDa
36043OPCODE(0xD130)
36044{
36045 u32 adr, res;
36046 u32 src, dst;
36047
36048 src = DREGu8((Opcode >> 9) & 7);
36049 adr = AREG((Opcode >> 0) & 7);
36050 DECODE_EXT_WORD
36051 PRE_IO
36052 READ_BYTE_F(adr, dst)
36053 res = dst + src;
36054 flag_N = flag_X = flag_C = res;
36055 flag_V = (src ^ res) & (dst ^ res);
36056 flag_NotZ = res & 0xFF;
36057 WRITE_BYTE_F(adr, res)
36058 POST_IO
36059RET(18)
36060}
36061
36062// ADDDa
36063OPCODE(0xD138)
36064{
36065 u32 adr, res;
36066 u32 src, dst;
36067
36068 src = DREGu8((Opcode >> 9) & 7);
36069 FETCH_SWORD(adr);
36070 PRE_IO
36071 READ_BYTE_F(adr, dst)
36072 res = dst + src;
36073 flag_N = flag_X = flag_C = res;
36074 flag_V = (src ^ res) & (dst ^ res);
36075 flag_NotZ = res & 0xFF;
36076 WRITE_BYTE_F(adr, res)
36077 POST_IO
36078RET(16)
36079}
36080
36081// ADDDa
36082OPCODE(0xD139)
36083{
36084 u32 adr, res;
36085 u32 src, dst;
36086
36087 src = DREGu8((Opcode >> 9) & 7);
36088 FETCH_LONG(adr);
36089 PRE_IO
36090 READ_BYTE_F(adr, dst)
36091 res = dst + src;
36092 flag_N = flag_X = flag_C = res;
36093 flag_V = (src ^ res) & (dst ^ res);
36094 flag_NotZ = res & 0xFF;
36095 WRITE_BYTE_F(adr, res)
36096 POST_IO
36097RET(20)
36098}
36099
36100// ADDDa
36101OPCODE(0xD11F)
36102{
36103 u32 adr, res;
36104 u32 src, dst;
36105
36106 src = DREGu8((Opcode >> 9) & 7);
36107 adr = AREG(7);
36108 AREG(7) += 2;
36109 PRE_IO
36110 READ_BYTE_F(adr, dst)
36111 res = dst + src;
36112 flag_N = flag_X = flag_C = res;
36113 flag_V = (src ^ res) & (dst ^ res);
36114 flag_NotZ = res & 0xFF;
36115 WRITE_BYTE_F(adr, res)
36116 POST_IO
36117RET(12)
36118}
36119
36120// ADDDa
36121OPCODE(0xD127)
36122{
36123 u32 adr, res;
36124 u32 src, dst;
36125
36126 src = DREGu8((Opcode >> 9) & 7);
36127 adr = AREG(7) - 2;
36128 AREG(7) = adr;
36129 PRE_IO
36130 READ_BYTE_F(adr, dst)
36131 res = dst + src;
36132 flag_N = flag_X = flag_C = res;
36133 flag_V = (src ^ res) & (dst ^ res);
36134 flag_NotZ = res & 0xFF;
36135 WRITE_BYTE_F(adr, res)
36136 POST_IO
36137RET(14)
36138}
36139
36140// ADDDa
36141OPCODE(0xD150)
36142{
36143 u32 adr, res;
36144 u32 src, dst;
36145
36146 src = DREGu16((Opcode >> 9) & 7);
36147 adr = AREG((Opcode >> 0) & 7);
36148 PRE_IO
36149 READ_WORD_F(adr, dst)
36150 res = dst + src;
36151 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36152 flag_N = flag_X = flag_C = res >> 8;
36153 flag_NotZ = res & 0xFFFF;
36154 WRITE_WORD_F(adr, res)
36155 POST_IO
36156RET(12)
36157}
36158
36159// ADDDa
36160OPCODE(0xD158)
36161{
36162 u32 adr, res;
36163 u32 src, dst;
36164
36165 src = DREGu16((Opcode >> 9) & 7);
36166 adr = AREG((Opcode >> 0) & 7);
36167 AREG((Opcode >> 0) & 7) += 2;
36168 PRE_IO
36169 READ_WORD_F(adr, dst)
36170 res = dst + src;
36171 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36172 flag_N = flag_X = flag_C = res >> 8;
36173 flag_NotZ = res & 0xFFFF;
36174 WRITE_WORD_F(adr, res)
36175 POST_IO
36176RET(12)
36177}
36178
36179// ADDDa
36180OPCODE(0xD160)
36181{
36182 u32 adr, res;
36183 u32 src, dst;
36184
36185 src = DREGu16((Opcode >> 9) & 7);
36186 adr = AREG((Opcode >> 0) & 7) - 2;
36187 AREG((Opcode >> 0) & 7) = adr;
36188 PRE_IO
36189 READ_WORD_F(adr, dst)
36190 res = dst + src;
36191 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36192 flag_N = flag_X = flag_C = res >> 8;
36193 flag_NotZ = res & 0xFFFF;
36194 WRITE_WORD_F(adr, res)
36195 POST_IO
36196RET(14)
36197}
36198
36199// ADDDa
36200OPCODE(0xD168)
36201{
36202 u32 adr, res;
36203 u32 src, dst;
36204
36205 src = DREGu16((Opcode >> 9) & 7);
36206 FETCH_SWORD(adr);
36207 adr += AREG((Opcode >> 0) & 7);
36208 PRE_IO
36209 READ_WORD_F(adr, dst)
36210 res = dst + src;
36211 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36212 flag_N = flag_X = flag_C = res >> 8;
36213 flag_NotZ = res & 0xFFFF;
36214 WRITE_WORD_F(adr, res)
36215 POST_IO
36216RET(16)
36217}
36218
36219// ADDDa
36220OPCODE(0xD170)
36221{
36222 u32 adr, res;
36223 u32 src, dst;
36224
36225 src = DREGu16((Opcode >> 9) & 7);
36226 adr = AREG((Opcode >> 0) & 7);
36227 DECODE_EXT_WORD
36228 PRE_IO
36229 READ_WORD_F(adr, dst)
36230 res = dst + src;
36231 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36232 flag_N = flag_X = flag_C = res >> 8;
36233 flag_NotZ = res & 0xFFFF;
36234 WRITE_WORD_F(adr, res)
36235 POST_IO
36236RET(18)
36237}
36238
36239// ADDDa
36240OPCODE(0xD178)
36241{
36242 u32 adr, res;
36243 u32 src, dst;
36244
36245 src = DREGu16((Opcode >> 9) & 7);
36246 FETCH_SWORD(adr);
36247 PRE_IO
36248 READ_WORD_F(adr, dst)
36249 res = dst + src;
36250 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36251 flag_N = flag_X = flag_C = res >> 8;
36252 flag_NotZ = res & 0xFFFF;
36253 WRITE_WORD_F(adr, res)
36254 POST_IO
36255RET(16)
36256}
36257
36258// ADDDa
36259OPCODE(0xD179)
36260{
36261 u32 adr, res;
36262 u32 src, dst;
36263
36264 src = DREGu16((Opcode >> 9) & 7);
36265 FETCH_LONG(adr);
36266 PRE_IO
36267 READ_WORD_F(adr, dst)
36268 res = dst + src;
36269 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36270 flag_N = flag_X = flag_C = res >> 8;
36271 flag_NotZ = res & 0xFFFF;
36272 WRITE_WORD_F(adr, res)
36273 POST_IO
36274RET(20)
36275}
36276
36277// ADDDa
36278OPCODE(0xD15F)
36279{
36280 u32 adr, res;
36281 u32 src, dst;
36282
36283 src = DREGu16((Opcode >> 9) & 7);
36284 adr = AREG(7);
36285 AREG(7) += 2;
36286 PRE_IO
36287 READ_WORD_F(adr, dst)
36288 res = dst + src;
36289 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36290 flag_N = flag_X = flag_C = res >> 8;
36291 flag_NotZ = res & 0xFFFF;
36292 WRITE_WORD_F(adr, res)
36293 POST_IO
36294RET(12)
36295}
36296
36297// ADDDa
36298OPCODE(0xD167)
36299{
36300 u32 adr, res;
36301 u32 src, dst;
36302
36303 src = DREGu16((Opcode >> 9) & 7);
36304 adr = AREG(7) - 2;
36305 AREG(7) = adr;
36306 PRE_IO
36307 READ_WORD_F(adr, dst)
36308 res = dst + src;
36309 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36310 flag_N = flag_X = flag_C = res >> 8;
36311 flag_NotZ = res & 0xFFFF;
36312 WRITE_WORD_F(adr, res)
36313 POST_IO
36314RET(14)
36315}
36316
36317// ADDDa
36318OPCODE(0xD190)
36319{
36320 u32 adr, res;
36321 u32 src, dst;
36322
36323 src = DREGu32((Opcode >> 9) & 7);
36324 adr = AREG((Opcode >> 0) & 7);
36325 PRE_IO
36326 READ_LONG_F(adr, dst)
36327 res = dst + src;
36328 flag_NotZ = res;
36329 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36330 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36331 flag_N = res >> 24;
36332 WRITE_LONG_F(adr, res)
36333 POST_IO
36334RET(20)
36335}
36336
36337// ADDDa
36338OPCODE(0xD198)
36339{
36340 u32 adr, res;
36341 u32 src, dst;
36342
36343 src = DREGu32((Opcode >> 9) & 7);
36344 adr = AREG((Opcode >> 0) & 7);
36345 AREG((Opcode >> 0) & 7) += 4;
36346 PRE_IO
36347 READ_LONG_F(adr, dst)
36348 res = dst + src;
36349 flag_NotZ = res;
36350 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36351 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36352 flag_N = res >> 24;
36353 WRITE_LONG_F(adr, res)
36354 POST_IO
36355RET(20)
36356}
36357
36358// ADDDa
36359OPCODE(0xD1A0)
36360{
36361 u32 adr, res;
36362 u32 src, dst;
36363
36364 src = DREGu32((Opcode >> 9) & 7);
36365 adr = AREG((Opcode >> 0) & 7) - 4;
36366 AREG((Opcode >> 0) & 7) = adr;
36367 PRE_IO
36368 READ_LONG_F(adr, dst)
36369 res = dst + src;
36370 flag_NotZ = res;
36371 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36372 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36373 flag_N = res >> 24;
36374 WRITE_LONG_F(adr, res)
36375 POST_IO
36376RET(22)
36377}
36378
36379// ADDDa
36380OPCODE(0xD1A8)
36381{
36382 u32 adr, res;
36383 u32 src, dst;
36384
36385 src = DREGu32((Opcode >> 9) & 7);
36386 FETCH_SWORD(adr);
36387 adr += AREG((Opcode >> 0) & 7);
36388 PRE_IO
36389 READ_LONG_F(adr, dst)
36390 res = dst + src;
36391 flag_NotZ = res;
36392 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36393 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36394 flag_N = res >> 24;
36395 WRITE_LONG_F(adr, res)
36396 POST_IO
36397RET(24)
36398}
36399
36400// ADDDa
36401OPCODE(0xD1B0)
36402{
36403 u32 adr, res;
36404 u32 src, dst;
36405
36406 src = DREGu32((Opcode >> 9) & 7);
36407 adr = AREG((Opcode >> 0) & 7);
36408 DECODE_EXT_WORD
36409 PRE_IO
36410 READ_LONG_F(adr, dst)
36411 res = dst + src;
36412 flag_NotZ = res;
36413 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36414 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36415 flag_N = res >> 24;
36416 WRITE_LONG_F(adr, res)
36417 POST_IO
36418RET(26)
36419}
36420
36421// ADDDa
36422OPCODE(0xD1B8)
36423{
36424 u32 adr, res;
36425 u32 src, dst;
36426
36427 src = DREGu32((Opcode >> 9) & 7);
36428 FETCH_SWORD(adr);
36429 PRE_IO
36430 READ_LONG_F(adr, dst)
36431 res = dst + src;
36432 flag_NotZ = res;
36433 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36434 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36435 flag_N = res >> 24;
36436 WRITE_LONG_F(adr, res)
36437 POST_IO
36438RET(24)
36439}
36440
36441// ADDDa
36442OPCODE(0xD1B9)
36443{
36444 u32 adr, res;
36445 u32 src, dst;
36446
36447 src = DREGu32((Opcode >> 9) & 7);
36448 FETCH_LONG(adr);
36449 PRE_IO
36450 READ_LONG_F(adr, dst)
36451 res = dst + src;
36452 flag_NotZ = res;
36453 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36454 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36455 flag_N = res >> 24;
36456 WRITE_LONG_F(adr, res)
36457 POST_IO
36458RET(28)
36459}
36460
36461// ADDDa
36462OPCODE(0xD19F)
36463{
36464 u32 adr, res;
36465 u32 src, dst;
36466
36467 src = DREGu32((Opcode >> 9) & 7);
36468 adr = AREG(7);
36469 AREG(7) += 4;
36470 PRE_IO
36471 READ_LONG_F(adr, dst)
36472 res = dst + src;
36473 flag_NotZ = res;
36474 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36475 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36476 flag_N = res >> 24;
36477 WRITE_LONG_F(adr, res)
36478 POST_IO
36479RET(20)
36480}
36481
36482// ADDDa
36483OPCODE(0xD1A7)
36484{
36485 u32 adr, res;
36486 u32 src, dst;
36487
36488 src = DREGu32((Opcode >> 9) & 7);
36489 adr = AREG(7) - 4;
36490 AREG(7) = adr;
36491 PRE_IO
36492 READ_LONG_F(adr, dst)
36493 res = dst + src;
36494 flag_NotZ = res;
36495 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36496 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36497 flag_N = res >> 24;
36498 WRITE_LONG_F(adr, res)
36499 POST_IO
36500RET(22)
36501}
36502
36503// ADDX
36504OPCODE(0xD100)
36505{
36506 u32 adr, res;
36507 u32 src, dst;
36508
36509 src = DREGu8((Opcode >> 0) & 7);
36510 dst = DREGu8((Opcode >> 9) & 7);
36511 res = dst + src + ((flag_X >> 8) & 1);
36512 flag_N = flag_X = flag_C = res;
36513 flag_V = (src ^ res) & (dst ^ res);
36514 flag_NotZ |= res & 0xFF;
36515 DREGu8((Opcode >> 9) & 7) = res;
36516RET(4)
36517}
36518
36519// ADDX
36520OPCODE(0xD140)
36521{
36522 u32 adr, res;
36523 u32 src, dst;
36524
36525 src = DREGu16((Opcode >> 0) & 7);
36526 dst = DREGu16((Opcode >> 9) & 7);
36527 res = dst + src + ((flag_X >> 8) & 1);
36528 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36529 flag_N = flag_X = flag_C = res >> 8;
36530 flag_NotZ |= res & 0xFFFF;
36531 DREGu16((Opcode >> 9) & 7) = res;
36532RET(4)
36533}
36534
36535// ADDX
36536OPCODE(0xD180)
36537{
36538 u32 adr, res;
36539 u32 src, dst;
36540
36541 src = DREGu32((Opcode >> 0) & 7);
36542 dst = DREGu32((Opcode >> 9) & 7);
36543 res = dst + src + ((flag_X >> 8) & 1);
36544 flag_NotZ |= res;
36545 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36546 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36547 flag_N = res >> 24;
36548 DREGu32((Opcode >> 9) & 7) = res;
36549RET(8)
36550}
36551
36552// ADDXM
36553OPCODE(0xD108)
36554{
36555 u32 adr, res;
36556 u32 src, dst;
36557
36558 adr = AREG((Opcode >> 0) & 7) - 1;
36559 AREG((Opcode >> 0) & 7) = adr;
36560 PRE_IO
36561 READ_BYTE_F(adr, src)
36562 adr = AREG((Opcode >> 9) & 7) - 1;
36563 AREG((Opcode >> 9) & 7) = adr;
36564 READ_BYTE_F(adr, dst)
36565 res = dst + src + ((flag_X >> 8) & 1);
36566 flag_N = flag_X = flag_C = res;
36567 flag_V = (src ^ res) & (dst ^ res);
36568 flag_NotZ |= res & 0xFF;
36569 WRITE_BYTE_F(adr, res)
36570 POST_IO
36571RET(18)
36572}
36573
36574// ADDXM
36575OPCODE(0xD148)
36576{
36577 u32 adr, res;
36578 u32 src, dst;
36579
36580 adr = AREG((Opcode >> 0) & 7) - 2;
36581 AREG((Opcode >> 0) & 7) = adr;
36582 PRE_IO
36583 READ_WORD_F(adr, src)
36584 adr = AREG((Opcode >> 9) & 7) - 2;
36585 AREG((Opcode >> 9) & 7) = adr;
36586 READ_WORD_F(adr, dst)
36587 res = dst + src + ((flag_X >> 8) & 1);
36588 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36589 flag_N = flag_X = flag_C = res >> 8;
36590 flag_NotZ |= res & 0xFFFF;
36591 WRITE_WORD_F(adr, res)
36592 POST_IO
36593RET(18)
36594}
36595
36596// ADDXM
36597OPCODE(0xD188)
36598{
36599 u32 adr, res;
36600 u32 src, dst;
36601
36602 adr = AREG((Opcode >> 0) & 7) - 4;
36603 AREG((Opcode >> 0) & 7) = adr;
36604 PRE_IO
36605 READ_LONG_F(adr, src)
36606 adr = AREG((Opcode >> 9) & 7) - 4;
36607 AREG((Opcode >> 9) & 7) = adr;
36608 READ_LONG_F(adr, dst)
36609 res = dst + src + ((flag_X >> 8) & 1);
36610 flag_NotZ |= res;
36611 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36612 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36613 flag_N = res >> 24;
36614 WRITE_LONG_F(adr, res)
36615 POST_IO
36616RET(30)
36617}
36618
36619// ADDX7M
36620OPCODE(0xD10F)
36621{
36622 u32 adr, res;
36623 u32 src, dst;
36624
36625 adr = AREG(7) - 2;
36626 AREG(7) = adr;
36627 PRE_IO
36628 READ_BYTE_F(adr, src)
36629 adr = AREG((Opcode >> 9) & 7) - 1;
36630 AREG((Opcode >> 9) & 7) = adr;
36631 READ_BYTE_F(adr, dst)
36632 res = dst + src + ((flag_X >> 8) & 1);
36633 flag_N = flag_X = flag_C = res;
36634 flag_V = (src ^ res) & (dst ^ res);
36635 flag_NotZ |= res & 0xFF;
36636 WRITE_BYTE_F(adr, res)
36637 POST_IO
36638RET(18)
36639}
36640
36641// ADDX7M
36642OPCODE(0xD14F)
36643{
36644 u32 adr, res;
36645 u32 src, dst;
36646
36647 adr = AREG(7) - 2;
36648 AREG(7) = adr;
36649 PRE_IO
36650 READ_WORD_F(adr, src)
36651 adr = AREG((Opcode >> 9) & 7) - 2;
36652 AREG((Opcode >> 9) & 7) = adr;
36653 READ_WORD_F(adr, dst)
36654 res = dst + src + ((flag_X >> 8) & 1);
36655 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36656 flag_N = flag_X = flag_C = res >> 8;
36657 flag_NotZ |= res & 0xFFFF;
36658 WRITE_WORD_F(adr, res)
36659 POST_IO
36660RET(18)
36661}
36662
36663// ADDX7M
36664OPCODE(0xD18F)
36665{
36666 u32 adr, res;
36667 u32 src, dst;
36668
36669 adr = AREG(7) - 4;
36670 AREG(7) = adr;
36671 PRE_IO
36672 READ_LONG_F(adr, src)
36673 adr = AREG((Opcode >> 9) & 7) - 4;
36674 AREG((Opcode >> 9) & 7) = adr;
36675 READ_LONG_F(adr, dst)
36676 res = dst + src + ((flag_X >> 8) & 1);
36677 flag_NotZ |= res;
36678 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36679 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36680 flag_N = res >> 24;
36681 WRITE_LONG_F(adr, res)
36682 POST_IO
36683RET(30)
36684}
36685
36686// ADDXM7
36687OPCODE(0xDF08)
36688{
36689 u32 adr, res;
36690 u32 src, dst;
36691
36692 adr = AREG((Opcode >> 0) & 7) - 1;
36693 AREG((Opcode >> 0) & 7) = adr;
36694 PRE_IO
36695 READ_BYTE_F(adr, src)
36696 adr = AREG(7) - 2;
36697 AREG(7) = adr;
36698 READ_BYTE_F(adr, dst)
36699 res = dst + src + ((flag_X >> 8) & 1);
36700 flag_N = flag_X = flag_C = res;
36701 flag_V = (src ^ res) & (dst ^ res);
36702 flag_NotZ |= res & 0xFF;
36703 WRITE_BYTE_F(adr, res)
36704 POST_IO
36705RET(18)
36706}
36707
36708// ADDXM7
36709OPCODE(0xDF48)
36710{
36711 u32 adr, res;
36712 u32 src, dst;
36713
36714 adr = AREG((Opcode >> 0) & 7) - 2;
36715 AREG((Opcode >> 0) & 7) = adr;
36716 PRE_IO
36717 READ_WORD_F(adr, src)
36718 adr = AREG(7) - 2;
36719 AREG(7) = adr;
36720 READ_WORD_F(adr, dst)
36721 res = dst + src + ((flag_X >> 8) & 1);
36722 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36723 flag_N = flag_X = flag_C = res >> 8;
36724 flag_NotZ |= res & 0xFFFF;
36725 WRITE_WORD_F(adr, res)
36726 POST_IO
36727RET(18)
36728}
36729
36730// ADDXM7
36731OPCODE(0xDF88)
36732{
36733 u32 adr, res;
36734 u32 src, dst;
36735
36736 adr = AREG((Opcode >> 0) & 7) - 4;
36737 AREG((Opcode >> 0) & 7) = adr;
36738 PRE_IO
36739 READ_LONG_F(adr, src)
36740 adr = AREG(7) - 4;
36741 AREG(7) = adr;
36742 READ_LONG_F(adr, dst)
36743 res = dst + src + ((flag_X >> 8) & 1);
36744 flag_NotZ |= res;
36745 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36746 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36747 flag_N = res >> 24;
36748 WRITE_LONG_F(adr, res)
36749 POST_IO
36750RET(30)
36751}
36752
36753// ADDX7M7
36754OPCODE(0xDF0F)
36755{
36756 u32 adr, res;
36757 u32 src, dst;
36758
36759 adr = AREG(7) - 2;
36760 AREG(7) = adr;
36761 PRE_IO
36762 READ_BYTE_F(adr, src)
36763 adr = AREG(7) - 2;
36764 AREG(7) = adr;
36765 READ_BYTE_F(adr, dst)
36766 res = dst + src + ((flag_X >> 8) & 1);
36767 flag_N = flag_X = flag_C = res;
36768 flag_V = (src ^ res) & (dst ^ res);
36769 flag_NotZ |= res & 0xFF;
36770 WRITE_BYTE_F(adr, res)
36771 POST_IO
36772RET(18)
36773}
36774
36775// ADDX7M7
36776OPCODE(0xDF4F)
36777{
36778 u32 adr, res;
36779 u32 src, dst;
36780
36781 adr = AREG(7) - 2;
36782 AREG(7) = adr;
36783 PRE_IO
36784 READ_WORD_F(adr, src)
36785 adr = AREG(7) - 2;
36786 AREG(7) = adr;
36787 READ_WORD_F(adr, dst)
36788 res = dst + src + ((flag_X >> 8) & 1);
36789 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36790 flag_N = flag_X = flag_C = res >> 8;
36791 flag_NotZ |= res & 0xFFFF;
36792 WRITE_WORD_F(adr, res)
36793 POST_IO
36794RET(18)
36795}
36796
36797// ADDX7M7
36798OPCODE(0xDF8F)
36799{
36800 u32 adr, res;
36801 u32 src, dst;
36802
36803 adr = AREG(7) - 4;
36804 AREG(7) = adr;
36805 PRE_IO
36806 READ_LONG_F(adr, src)
36807 adr = AREG(7) - 4;
36808 AREG(7) = adr;
36809 READ_LONG_F(adr, dst)
36810 res = dst + src + ((flag_X >> 8) & 1);
36811 flag_NotZ |= res;
36812 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36813 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36814 flag_N = res >> 24;
36815 WRITE_LONG_F(adr, res)
36816 POST_IO
36817RET(30)
36818}
36819
36820// ADDA
36821OPCODE(0xD0C0)
36822{
36823 u32 adr, res;
36824 u32 src, dst;
36825
36826 src = (s32)DREGs16((Opcode >> 0) & 7);
36827 dst = AREGu32((Opcode >> 9) & 7);
36828 res = dst + src;
36829 AREG((Opcode >> 9) & 7) = res;
36830RET(8)
36831}
36832
36833// ADDA
36834OPCODE(0xD0C8)
36835{
36836 u32 adr, res;
36837 u32 src, dst;
36838
36839 src = (s32)AREGs16((Opcode >> 0) & 7);
36840 dst = AREGu32((Opcode >> 9) & 7);
36841 res = dst + src;
36842 AREG((Opcode >> 9) & 7) = res;
36843RET(8)
36844}
36845
36846// ADDA
36847OPCODE(0xD0D0)
36848{
36849 u32 adr, res;
36850 u32 src, dst;
36851
36852 adr = AREG((Opcode >> 0) & 7);
36853 PRE_IO
36854 READSX_WORD_F(adr, src)
36855 dst = AREGu32((Opcode >> 9) & 7);
36856 res = dst + src;
36857 AREG((Opcode >> 9) & 7) = res;
36858 POST_IO
36859#ifdef USE_CYCLONE_TIMING
36860RET(12)
36861#else
36862RET(10)
36863#endif
36864}
36865
36866// ADDA
36867OPCODE(0xD0D8)
36868{
36869 u32 adr, res;
36870 u32 src, dst;
36871
36872 adr = AREG((Opcode >> 0) & 7);
36873 AREG((Opcode >> 0) & 7) += 2;
36874 PRE_IO
36875 READSX_WORD_F(adr, src)
36876 dst = AREGu32((Opcode >> 9) & 7);
36877 res = dst + src;
36878 AREG((Opcode >> 9) & 7) = res;
36879 POST_IO
36880#ifdef USE_CYCLONE_TIMING
36881RET(12)
36882#else
36883RET(10)
36884#endif
36885}
36886
36887// ADDA
36888OPCODE(0xD0E0)
36889{
36890 u32 adr, res;
36891 u32 src, dst;
36892
36893 adr = AREG((Opcode >> 0) & 7) - 2;
36894 AREG((Opcode >> 0) & 7) = adr;
36895 PRE_IO
36896 READSX_WORD_F(adr, src)
36897 dst = AREGu32((Opcode >> 9) & 7);
36898 res = dst + src;
36899 AREG((Opcode >> 9) & 7) = res;
36900 POST_IO
36901#ifdef USE_CYCLONE_TIMING
36902RET(14)
36903#else
36904RET(12)
36905#endif
36906}
36907
36908// ADDA
36909OPCODE(0xD0E8)
36910{
36911 u32 adr, res;
36912 u32 src, dst;
36913
36914 FETCH_SWORD(adr);
36915 adr += AREG((Opcode >> 0) & 7);
36916 PRE_IO
36917 READSX_WORD_F(adr, src)
36918 dst = AREGu32((Opcode >> 9) & 7);
36919 res = dst + src;
36920 AREG((Opcode >> 9) & 7) = res;
36921 POST_IO
36922#ifdef USE_CYCLONE_TIMING
36923RET(16)
36924#else
36925RET(14)
36926#endif
36927}
36928
36929// ADDA
36930OPCODE(0xD0F0)
36931{
36932 u32 adr, res;
36933 u32 src, dst;
36934
36935 adr = AREG((Opcode >> 0) & 7);
36936 DECODE_EXT_WORD
36937 PRE_IO
36938 READSX_WORD_F(adr, src)
36939 dst = AREGu32((Opcode >> 9) & 7);
36940 res = dst + src;
36941 AREG((Opcode >> 9) & 7) = res;
36942 POST_IO
36943#ifdef USE_CYCLONE_TIMING
36944RET(18)
36945#else
36946RET(16)
36947#endif
36948}
36949
36950// ADDA
36951OPCODE(0xD0F8)
36952{
36953 u32 adr, res;
36954 u32 src, dst;
36955
36956 FETCH_SWORD(adr);
36957 PRE_IO
36958 READSX_WORD_F(adr, src)
36959 dst = AREGu32((Opcode >> 9) & 7);
36960 res = dst + src;
36961 AREG((Opcode >> 9) & 7) = res;
36962 POST_IO
36963#ifdef USE_CYCLONE_TIMING
36964RET(16)
36965#else
36966RET(14)
36967#endif
36968}
36969
36970// ADDA
36971OPCODE(0xD0F9)
36972{
36973 u32 adr, res;
36974 u32 src, dst;
36975
36976 FETCH_LONG(adr);
36977 PRE_IO
36978 READSX_WORD_F(adr, src)
36979 dst = AREGu32((Opcode >> 9) & 7);
36980 res = dst + src;
36981 AREG((Opcode >> 9) & 7) = res;
36982 POST_IO
36983#ifdef USE_CYCLONE_TIMING
36984RET(20)
36985#else
36986RET(18)
36987#endif
36988}
36989
36990// ADDA
36991OPCODE(0xD0FA)
36992{
36993 u32 adr, res;
36994 u32 src, dst;
36995
36996 adr = GET_SWORD + GET_PC;
36997 PC++;
36998 PRE_IO
36999 READSX_WORD_F(adr, src)
37000 dst = AREGu32((Opcode >> 9) & 7);
37001 res = dst + src;
37002 AREG((Opcode >> 9) & 7) = res;
37003 POST_IO
37004#ifdef USE_CYCLONE_TIMING
37005RET(16)
37006#else
37007RET(14)
37008#endif
37009}
37010
37011// ADDA
37012OPCODE(0xD0FB)
37013{
37014 u32 adr, res;
37015 u32 src, dst;
37016
37017 adr = GET_PC;
37018 DECODE_EXT_WORD
37019 PRE_IO
37020 READSX_WORD_F(adr, src)
37021 dst = AREGu32((Opcode >> 9) & 7);
37022 res = dst + src;
37023 AREG((Opcode >> 9) & 7) = res;
37024 POST_IO
37025#ifdef USE_CYCLONE_TIMING
37026RET(18)
37027#else
37028RET(16)
37029#endif
37030}
37031
37032// ADDA
37033OPCODE(0xD0FC)
37034{
37035 u32 adr, res;
37036 u32 src, dst;
37037
37038 FETCH_SWORD(src);
37039 dst = AREGu32((Opcode >> 9) & 7);
37040 res = dst + src;
37041 AREG((Opcode >> 9) & 7) = res;
37042RET(12)
37043}
37044
37045// ADDA
37046OPCODE(0xD0DF)
37047{
37048 u32 adr, res;
37049 u32 src, dst;
37050
37051 adr = AREG(7);
37052 AREG(7) += 2;
37053 PRE_IO
37054 READSX_WORD_F(adr, src)
37055 dst = AREGu32((Opcode >> 9) & 7);
37056 res = dst + src;
37057 AREG((Opcode >> 9) & 7) = res;
37058 POST_IO
37059#ifdef USE_CYCLONE_TIMING
37060RET(12)
37061#else
37062RET(10)
37063#endif
37064}
37065
37066// ADDA
37067OPCODE(0xD0E7)
37068{
37069 u32 adr, res;
37070 u32 src, dst;
37071
37072 adr = AREG(7) - 2;
37073 AREG(7) = adr;
37074 PRE_IO
37075 READSX_WORD_F(adr, src)
37076 dst = AREGu32((Opcode >> 9) & 7);
37077 res = dst + src;
37078 AREG((Opcode >> 9) & 7) = res;
37079 POST_IO
37080#ifdef USE_CYCLONE_TIMING
37081RET(14)
37082#else
37083RET(12)
37084#endif
37085}
37086
37087// ADDA
37088OPCODE(0xD1C0)
37089{
37090 u32 adr, res;
37091 u32 src, dst;
37092
37093 src = (s32)DREGs32((Opcode >> 0) & 7);
37094 dst = AREGu32((Opcode >> 9) & 7);
37095 res = dst + src;
37096 AREG((Opcode >> 9) & 7) = res;
37097#ifdef USE_CYCLONE_TIMING
37098RET(8)
37099#else
37100RET(6)
37101#endif
37102}
37103
37104// ADDA
37105OPCODE(0xD1C8)
37106{
37107 u32 adr, res;
37108 u32 src, dst;
37109
37110 src = (s32)AREGs32((Opcode >> 0) & 7);
37111 dst = AREGu32((Opcode >> 9) & 7);
37112 res = dst + src;
37113 AREG((Opcode >> 9) & 7) = res;
37114#ifdef USE_CYCLONE_TIMING
37115RET(8)
37116#else
37117RET(6)
37118#endif
37119}
37120
37121// ADDA
37122OPCODE(0xD1D0)
37123{
37124 u32 adr, res;
37125 u32 src, dst;
37126
37127 adr = AREG((Opcode >> 0) & 7);
37128 PRE_IO
37129 READSX_LONG_F(adr, src)
37130 dst = AREGu32((Opcode >> 9) & 7);
37131 res = dst + src;
37132 AREG((Opcode >> 9) & 7) = res;
37133 POST_IO
37134RET(14)
37135}
37136
37137// ADDA
37138OPCODE(0xD1D8)
37139{
37140 u32 adr, res;
37141 u32 src, dst;
37142
37143 adr = AREG((Opcode >> 0) & 7);
37144 AREG((Opcode >> 0) & 7) += 4;
37145 PRE_IO
37146 READSX_LONG_F(adr, src)
37147 dst = AREGu32((Opcode >> 9) & 7);
37148 res = dst + src;
37149 AREG((Opcode >> 9) & 7) = res;
37150 POST_IO
37151RET(14)
37152}
37153
37154// ADDA
37155OPCODE(0xD1E0)
37156{
37157 u32 adr, res;
37158 u32 src, dst;
37159
37160 adr = AREG((Opcode >> 0) & 7) - 4;
37161 AREG((Opcode >> 0) & 7) = adr;
37162 PRE_IO
37163 READSX_LONG_F(adr, src)
37164 dst = AREGu32((Opcode >> 9) & 7);
37165 res = dst + src;
37166 AREG((Opcode >> 9) & 7) = res;
37167 POST_IO
37168RET(16)
37169}
37170
37171// ADDA
37172OPCODE(0xD1E8)
37173{
37174 u32 adr, res;
37175 u32 src, dst;
37176
37177 FETCH_SWORD(adr);
37178 adr += AREG((Opcode >> 0) & 7);
37179 PRE_IO
37180 READSX_LONG_F(adr, src)
37181 dst = AREGu32((Opcode >> 9) & 7);
37182 res = dst + src;
37183 AREG((Opcode >> 9) & 7) = res;
37184 POST_IO
37185RET(18)
37186}
37187
37188// ADDA
37189OPCODE(0xD1F0)
37190{
37191 u32 adr, res;
37192 u32 src, dst;
37193
37194 adr = AREG((Opcode >> 0) & 7);
37195 DECODE_EXT_WORD
37196 PRE_IO
37197 READSX_LONG_F(adr, src)
37198 dst = AREGu32((Opcode >> 9) & 7);
37199 res = dst + src;
37200 AREG((Opcode >> 9) & 7) = res;
37201 POST_IO
37202RET(20)
37203}
37204
37205// ADDA
37206OPCODE(0xD1F8)
37207{
37208 u32 adr, res;
37209 u32 src, dst;
37210
37211 FETCH_SWORD(adr);
37212 PRE_IO
37213 READSX_LONG_F(adr, src)
37214 dst = AREGu32((Opcode >> 9) & 7);
37215 res = dst + src;
37216 AREG((Opcode >> 9) & 7) = res;
37217 POST_IO
37218RET(18)
37219}
37220
37221// ADDA
37222OPCODE(0xD1F9)
37223{
37224 u32 adr, res;
37225 u32 src, dst;
37226
37227 FETCH_LONG(adr);
37228 PRE_IO
37229 READSX_LONG_F(adr, src)
37230 dst = AREGu32((Opcode >> 9) & 7);
37231 res = dst + src;
37232 AREG((Opcode >> 9) & 7) = res;
37233 POST_IO
37234RET(22)
37235}
37236
37237// ADDA
37238OPCODE(0xD1FA)
37239{
37240 u32 adr, res;
37241 u32 src, dst;
37242
37243 adr = GET_SWORD + GET_PC;
37244 PC++;
37245 PRE_IO
37246 READSX_LONG_F(adr, src)
37247 dst = AREGu32((Opcode >> 9) & 7);
37248 res = dst + src;
37249 AREG((Opcode >> 9) & 7) = res;
37250 POST_IO
37251RET(18)
37252}
37253
37254// ADDA
37255OPCODE(0xD1FB)
37256{
37257 u32 adr, res;
37258 u32 src, dst;
37259
37260 adr = GET_PC;
37261 DECODE_EXT_WORD
37262 PRE_IO
37263 READSX_LONG_F(adr, src)
37264 dst = AREGu32((Opcode >> 9) & 7);
37265 res = dst + src;
37266 AREG((Opcode >> 9) & 7) = res;
37267 POST_IO
37268RET(20)
37269}
37270
37271// ADDA
37272OPCODE(0xD1FC)
37273{
37274 u32 adr, res;
37275 u32 src, dst;
37276
37277 FETCH_LONG(src);
37278 dst = AREGu32((Opcode >> 9) & 7);
37279 res = dst + src;
37280 AREG((Opcode >> 9) & 7) = res;
37281#ifdef USE_CYCLONE_TIMING
37282RET(16)
37283#else
37284RET(14)
37285#endif
37286}
37287
37288// ADDA
37289OPCODE(0xD1DF)
37290{
37291 u32 adr, res;
37292 u32 src, dst;
37293
37294 adr = AREG(7);
37295 AREG(7) += 4;
37296 PRE_IO
37297 READSX_LONG_F(adr, src)
37298 dst = AREGu32((Opcode >> 9) & 7);
37299 res = dst + src;
37300 AREG((Opcode >> 9) & 7) = res;
37301 POST_IO
37302RET(14)
37303}
37304
37305// ADDA
37306OPCODE(0xD1E7)
37307{
37308 u32 adr, res;
37309 u32 src, dst;
37310
37311 adr = AREG(7) - 4;
37312 AREG(7) = adr;
37313 PRE_IO
37314 READSX_LONG_F(adr, src)
37315 dst = AREGu32((Opcode >> 9) & 7);
37316 res = dst + src;
37317 AREG((Opcode >> 9) & 7) = res;
37318 POST_IO
37319RET(16)
37320}
37321
37322// ASRk
37323OPCODE(0xE000)
37324{
37325 u32 adr, res;
37326 u32 src, dst;
37327
37328 u32 sft;
37329
37330 sft = (((Opcode >> 9) - 1) & 7) + 1;
37331 ctx->io_cycle_counter -= sft * 2;
37332 src = (s32)DREGs8((Opcode >> 0) & 7);
37333 flag_V = 0;
37334 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37335 res = ((s32)src) >> sft;
37336 flag_N = res >> 0;
37337 flag_NotZ = res;
37338 DREGu8((Opcode >> 0) & 7) = res;
37339RET(6)
37340}
37341
37342// ASRk
37343OPCODE(0xE040)
37344{
37345 u32 adr, res;
37346 u32 src, dst;
37347
37348 u32 sft;
37349
37350 sft = (((Opcode >> 9) - 1) & 7) + 1;
37351 ctx->io_cycle_counter -= sft * 2;
37352 src = (s32)DREGs16((Opcode >> 0) & 7);
37353 flag_V = 0;
37354 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37355 res = ((s32)src) >> sft;
37356 flag_N = res >> 8;
37357 flag_NotZ = res;
37358 DREGu16((Opcode >> 0) & 7) = res;
37359RET(6)
37360}
37361
37362// ASRk
37363OPCODE(0xE080)
37364{
37365 u32 adr, res;
37366 u32 src, dst;
37367
37368 u32 sft;
37369
37370 sft = (((Opcode >> 9) - 1) & 7) + 1;
37371 ctx->io_cycle_counter -= sft * 2;
37372 src = (s32)DREGs32((Opcode >> 0) & 7);
37373 flag_V = 0;
37374 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37375 res = ((s32)src) >> sft;
37376 flag_N = res >> 24;
37377 flag_NotZ = res;
37378 DREGu32((Opcode >> 0) & 7) = res;
37379RET(8)
37380}
37381
37382// LSRk
37383OPCODE(0xE008)
37384{
37385 u32 adr, res;
37386 u32 src, dst;
37387
37388 u32 sft;
37389
37390 sft = (((Opcode >> 9) - 1) & 7) + 1;
37391 ctx->io_cycle_counter -= sft * 2;
37392 src = DREGu8((Opcode >> 0) & 7);
37393 flag_N = flag_V = 0;
37394 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37395 res = src >> sft;
37396 flag_NotZ = res;
37397 DREGu8((Opcode >> 0) & 7) = res;
37398RET(6)
37399}
37400
37401// LSRk
37402OPCODE(0xE048)
37403{
37404 u32 adr, res;
37405 u32 src, dst;
37406
37407 u32 sft;
37408
37409 sft = (((Opcode >> 9) - 1) & 7) + 1;
37410 ctx->io_cycle_counter -= sft * 2;
37411 src = DREGu16((Opcode >> 0) & 7);
37412 flag_N = flag_V = 0;
37413 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37414 res = src >> sft;
37415 flag_NotZ = res;
37416 DREGu16((Opcode >> 0) & 7) = res;
37417RET(6)
37418}
37419
37420// LSRk
37421OPCODE(0xE088)
37422{
37423 u32 adr, res;
37424 u32 src, dst;
37425
37426 u32 sft;
37427
37428 sft = (((Opcode >> 9) - 1) & 7) + 1;
37429 ctx->io_cycle_counter -= sft * 2;
37430 src = DREGu32((Opcode >> 0) & 7);
37431 flag_N = flag_V = 0;
37432 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37433 res = src >> sft;
37434 flag_NotZ = res;
37435 DREGu32((Opcode >> 0) & 7) = res;
37436RET(8)
37437}
37438
37439// ROXRk
37440OPCODE(0xE010)
37441{
37442 u32 adr, res;
37443 u32 src, dst;
37444
37445 u32 sft;
37446
37447 sft = (((Opcode >> 9) - 1) & 7) + 1;
37448 ctx->io_cycle_counter -= sft * 2;
37449 src = DREGu8((Opcode >> 0) & 7);
37450 src |= (flag_X & M68K_SR_X) << 0;
37451 res = (src >> sft) | (src << (9 - sft));
37452 flag_X = flag_C = res >> 0;
37453 flag_V = 0;
37454 flag_N = res >> 0;
37455 flag_NotZ = res & 0x000000FF;
37456 DREGu8((Opcode >> 0) & 7) = res;
37457RET(6)
37458}
37459
37460// ROXRk
37461OPCODE(0xE050)
37462{
37463 u32 adr, res;
37464 u32 src, dst;
37465
37466 u32 sft;
37467
37468 sft = (((Opcode >> 9) - 1) & 7) + 1;
37469 ctx->io_cycle_counter -= sft * 2;
37470 src = DREGu16((Opcode >> 0) & 7);
37471 src |= (flag_X & M68K_SR_X) << 8;
37472 res = (src >> sft) | (src << (17 - sft));
37473 flag_X = flag_C = res >> 8;
37474 flag_V = 0;
37475 flag_N = res >> 8;
37476 flag_NotZ = res & 0x0000FFFF;
37477 DREGu16((Opcode >> 0) & 7) = res;
37478RET(6)
37479}
37480
37481// ROXRk
37482OPCODE(0xE090)
37483{
37484 u32 adr, res;
37485 u32 src, dst;
37486
37487 u32 sft;
37488
37489 sft = (((Opcode >> 9) - 1) & 7) + 1;
37490 ctx->io_cycle_counter -= sft * 2;
37491 src = DREGu32((Opcode >> 0) & 7);
37492 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37493 if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
37494 else res = (src >> sft) | (src << (33 - sft)) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + sft)));
37495 flag_X = flag_C;
37496 flag_V = 0;
37497 flag_N = res >> 24;
37498 flag_NotZ = res;
37499 DREGu32((Opcode >> 0) & 7) = res;
37500RET(8)
37501}
37502
37503// RORk
37504OPCODE(0xE018)
37505{
37506 u32 adr, res;
37507 u32 src, dst;
37508
37509 u32 sft;
37510
37511 sft = (((Opcode >> 9) - 1) & 7) + 1;
37512 ctx->io_cycle_counter -= sft * 2;
37513 src = DREGu8((Opcode >> 0) & 7);
37514 flag_V = 0;
37515 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37516 res = (src >> sft) | (src << (8 - sft));
37517 flag_N = res >> 0;
37518 flag_NotZ = res & 0x000000FF;
37519 DREGu8((Opcode >> 0) & 7) = res;
37520RET(6)
37521}
37522
37523// RORk
37524OPCODE(0xE058)
37525{
37526 u32 adr, res;
37527 u32 src, dst;
37528
37529 u32 sft;
37530
37531 sft = (((Opcode >> 9) - 1) & 7) + 1;
37532 ctx->io_cycle_counter -= sft * 2;
37533 src = DREGu16((Opcode >> 0) & 7);
37534 flag_V = 0;
37535 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37536 res = (src >> sft) | (src << (16 - sft));
37537 flag_N = res >> 8;
37538 flag_NotZ = res & 0x0000FFFF;
37539 DREGu16((Opcode >> 0) & 7) = res;
37540RET(6)
37541}
37542
37543// RORk
37544OPCODE(0xE098)
37545{
37546 u32 adr, res;
37547 u32 src, dst;
37548
37549 u32 sft;
37550
37551 sft = (((Opcode >> 9) - 1) & 7) + 1;
37552 ctx->io_cycle_counter -= sft * 2;
37553 src = DREGu32((Opcode >> 0) & 7);
37554 flag_V = 0;
37555 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37556 res = (src >> sft) | (src << (32 - sft));
37557 flag_N = res >> 24;
37558 flag_NotZ = res;
37559 DREGu32((Opcode >> 0) & 7) = res;
37560RET(8)
37561}
37562
37563// ASLk
37564OPCODE(0xE100)
37565{
37566 u32 adr, res;
37567 u32 src, dst;
37568
37569 u32 sft;
37570
37571 sft = (((Opcode >> 9) - 1) & 7) + 1;
37572 ctx->io_cycle_counter -= sft * 2;
37573 src = DREGu8((Opcode >> 0) & 7);
37574 if (sft < 8)
37575 {
37576 flag_X = flag_C = src << (0 + sft);
37577 res = src << sft;
37578 flag_N = res >> 0;
37579 flag_NotZ = res & 0x000000FF;
37580 DREGu8((Opcode >> 0) & 7) = res;
37581 flag_V = 0;
37582 if ((sft > 7) && (src)) flag_V = M68K_SR_V;
37583 else
37584 {
37585 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
37586 src &= msk;
37587 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37588 }
37589 RET(6)
37590 }
37591
37592 if (src) flag_V = M68K_SR_V;
37593 else flag_V = 0;
37594 flag_X = flag_C = src << M68K_SR_C_SFT;
37595 res = 0;
37596 DREGu8((Opcode >> 0) & 7) = res;
37597 flag_N = 0;
37598 flag_NotZ = 0;
37599RET(6)
37600}
37601
37602// ASLk
37603OPCODE(0xE140)
37604{
37605 u32 adr, res;
37606 u32 src, dst;
37607
37608 u32 sft;
37609
37610 sft = (((Opcode >> 9) - 1) & 7) + 1;
37611 ctx->io_cycle_counter -= sft * 2;
37612 src = DREGu16((Opcode >> 0) & 7);
37613 flag_X = flag_C = src >> (8 - sft);
37614 res = src << sft;
37615 flag_N = res >> 8;
37616 flag_NotZ = res & 0x0000FFFF;
37617 DREGu16((Opcode >> 0) & 7) = res;
37618 flag_V = 0;
37619 {
37620 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
37621 src &= msk;
37622 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37623 }
37624RET(6)
37625}
37626
37627// ASLk
37628OPCODE(0xE180)
37629{
37630 u32 adr, res;
37631 u32 src, dst;
37632
37633 u32 sft;
37634
37635 sft = (((Opcode >> 9) - 1) & 7) + 1;
37636 ctx->io_cycle_counter -= sft * 2;
37637 src = DREGu32((Opcode >> 0) & 7);
37638 flag_X = flag_C = src >> (24 - sft);
37639 res = src << sft;
37640 flag_N = res >> 24;
37641 flag_NotZ = res & 0xFFFFFFFF;
37642 DREGu32((Opcode >> 0) & 7) = res;
37643 flag_V = 0;
37644 {
37645 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
37646 src &= msk;
37647 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37648 }
37649RET(8)
37650}
37651
37652// LSLk
37653OPCODE(0xE108)
37654{
37655 u32 adr, res;
37656 u32 src, dst;
37657
37658 u32 sft;
37659
37660 sft = (((Opcode >> 9) - 1) & 7) + 1;
37661 ctx->io_cycle_counter -= sft * 2;
37662 src = DREGu8((Opcode >> 0) & 7);
37663 flag_V = 0;
37664 flag_X = flag_C = src << (0 + sft);
37665 res = src << sft;
37666 flag_N = res >> 0;
37667 flag_NotZ = res & 0x000000FF;
37668 DREGu8((Opcode >> 0) & 7) = res;
37669RET(6)
37670}
37671
37672// LSLk
37673OPCODE(0xE148)
37674{
37675 u32 adr, res;
37676 u32 src, dst;
37677
37678 u32 sft;
37679
37680 sft = (((Opcode >> 9) - 1) & 7) + 1;
37681 ctx->io_cycle_counter -= sft * 2;
37682 src = DREGu16((Opcode >> 0) & 7);
37683 flag_V = 0;
37684 flag_X = flag_C = src >> (8 - sft);
37685 res = src << sft;
37686 flag_N = res >> 8;
37687 flag_NotZ = res & 0x0000FFFF;
37688 DREGu16((Opcode >> 0) & 7) = res;
37689RET(6)
37690}
37691
37692// LSLk
37693OPCODE(0xE188)
37694{
37695 u32 adr, res;
37696 u32 src, dst;
37697
37698 u32 sft;
37699
37700 sft = (((Opcode >> 9) - 1) & 7) + 1;
37701 ctx->io_cycle_counter -= sft * 2;
37702 src = DREGu32((Opcode >> 0) & 7);
37703 flag_V = 0;
37704 flag_X = flag_C = src >> (24 - sft);
37705 res = src << sft;
37706 flag_N = res >> 24;
37707 flag_NotZ = res & 0xFFFFFFFF;
37708 DREGu32((Opcode >> 0) & 7) = res;
37709RET(8)
37710}
37711
37712// ROXLk
37713OPCODE(0xE110)
37714{
37715 u32 adr, res;
37716 u32 src, dst;
37717
37718 u32 sft;
37719
37720 sft = (((Opcode >> 9) - 1) & 7) + 1;
37721 ctx->io_cycle_counter -= sft * 2;
37722 src = DREGu8((Opcode >> 0) & 7);
37723 src |= (flag_X & M68K_SR_X) << 0;
37724 res = (src << sft) | (src >> (9 - sft));
37725 flag_X = flag_C = res >> 0;
37726 flag_V = 0;
37727 flag_N = res >> 0;
37728 flag_NotZ = res & 0x000000FF;
37729 DREGu8((Opcode >> 0) & 7) = res;
37730RET(6)
37731}
37732
37733// ROXLk
37734OPCODE(0xE150)
37735{
37736 u32 adr, res;
37737 u32 src, dst;
37738
37739 u32 sft;
37740
37741 sft = (((Opcode >> 9) - 1) & 7) + 1;
37742 ctx->io_cycle_counter -= sft * 2;
37743 src = DREGu16((Opcode >> 0) & 7);
37744 src |= (flag_X & M68K_SR_X) << 8;
37745 res = (src << sft) | (src >> (17 - sft));
37746 flag_X = flag_C = res >> 8;
37747 flag_V = 0;
37748 flag_N = res >> 8;
37749 flag_NotZ = res & 0x0000FFFF;
37750 DREGu16((Opcode >> 0) & 7) = res;
37751RET(6)
37752}
37753
37754// ROXLk
37755OPCODE(0xE190)
37756{
37757 u32 adr, res;
37758 u32 src, dst;
37759
37760 u32 sft;
37761
37762 sft = (((Opcode >> 9) - 1) & 7) + 1;
37763 ctx->io_cycle_counter -= sft * 2;
37764 src = DREGu32((Opcode >> 0) & 7);
37765 flag_C = src >> ((32 - M68K_SR_C_SFT) - sft);
37766 if (sft == 1) res = (src << 1) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - 1));
37767 else res = (src << sft) | (src >> (33 - sft)) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - sft));
37768 flag_X = flag_C;
37769 flag_V = 0;
37770 flag_N = res >> 24;
37771 flag_NotZ = res;
37772 DREGu32((Opcode >> 0) & 7) = res;
37773RET(8)
37774}
37775
37776// ROLk
37777OPCODE(0xE118)
37778{
37779 u32 adr, res;
37780 u32 src, dst;
37781
37782 u32 sft;
37783
37784 sft = (((Opcode >> 9) - 1) & 7) + 1;
37785 ctx->io_cycle_counter -= sft * 2;
37786 src = DREGu8((Opcode >> 0) & 7);
37787 flag_V = 0;
37788 flag_C = src << (0 + sft);
37789 res = (src << sft) | (src >> (8 - sft));
37790 flag_N = res >> 0;
37791 flag_NotZ = res & 0x000000FF;
37792 DREGu8((Opcode >> 0) & 7) = res;
37793RET(6)
37794}
37795
37796// ROLk
37797OPCODE(0xE158)
37798{
37799 u32 adr, res;
37800 u32 src, dst;
37801
37802 u32 sft;
37803
37804 sft = (((Opcode >> 9) - 1) & 7) + 1;
37805 ctx->io_cycle_counter -= sft * 2;
37806 src = DREGu16((Opcode >> 0) & 7);
37807 flag_V = 0;
37808 flag_C = src >> (8 - sft);
37809 res = (src << sft) | (src >> (16 - sft));
37810 flag_N = res >> 8;
37811 flag_NotZ = res & 0x0000FFFF;
37812 DREGu16((Opcode >> 0) & 7) = res;
37813RET(6)
37814}
37815
37816// ROLk
37817OPCODE(0xE198)
37818{
37819 u32 adr, res;
37820 u32 src, dst;
37821
37822 u32 sft;
37823
37824 sft = (((Opcode >> 9) - 1) & 7) + 1;
37825 ctx->io_cycle_counter -= sft * 2;
37826 src = DREGu32((Opcode >> 0) & 7);
37827 flag_V = 0;
37828 flag_C = src >> (24 - sft);
37829 res = (src << sft) | (src >> (32 - sft));
37830 flag_N = res >> 24;
37831 flag_NotZ = res;
37832 DREGu32((Opcode >> 0) & 7) = res;
37833RET(8)
37834}
37835
37836// ASRD
37837OPCODE(0xE020)
37838{
37839 u32 adr, res;
37840 u32 src, dst;
37841
37842 u32 sft;
37843
37844 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37845 src = (s32)DREGs8((Opcode >> 0) & 7);
37846 if (sft)
37847 {
37848 ctx->io_cycle_counter -= sft * 2;
37849 if (sft < 8)
37850 {
37851 flag_V = 0;
37852 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37853 res = ((s32)src) >> sft;
37854 flag_N = res >> 0;
37855 flag_NotZ = res;
37856 DREGu8((Opcode >> 0) & 7) = res;
37857 RET(6)
37858 }
37859
37860 if (src & (1 << 7))
37861 {
37862 flag_N = M68K_SR_N;
37863 flag_NotZ = 1;
37864 flag_V = 0;
37865 flag_C = M68K_SR_C;
37866 flag_X = M68K_SR_X;
37867 res = 0x000000FF;
37868 DREGu8((Opcode >> 0) & 7) = res;
37869 RET(6)
37870 }
37871
37872 flag_N = 0;
37873 flag_NotZ = 0;
37874 flag_V = 0;
37875 flag_C = 0;
37876 flag_X = 0;
37877 res = 0;
37878 DREGu8((Opcode >> 0) & 7) = res;
37879 RET(6)
37880 }
37881
37882 flag_V = 0;
37883 flag_C = 0;
37884 flag_N = src >> 0;
37885 flag_NotZ = src;
37886RET(6)
37887}
37888
37889// ASRD
37890OPCODE(0xE060)
37891{
37892 u32 adr, res;
37893 u32 src, dst;
37894
37895 u32 sft;
37896
37897 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37898 src = (s32)DREGs16((Opcode >> 0) & 7);
37899 if (sft)
37900 {
37901 ctx->io_cycle_counter -= sft * 2;
37902 if (sft < 16)
37903 {
37904 flag_V = 0;
37905 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37906 res = ((s32)src) >> sft;
37907 flag_N = res >> 8;
37908 flag_NotZ = res;
37909 DREGu16((Opcode >> 0) & 7) = res;
37910 RET(6)
37911 }
37912
37913 if (src & (1 << 15))
37914 {
37915 flag_N = M68K_SR_N;
37916 flag_NotZ = 1;
37917 flag_V = 0;
37918 flag_C = M68K_SR_C;
37919 flag_X = M68K_SR_X;
37920 res = 0x0000FFFF;
37921 DREGu16((Opcode >> 0) & 7) = res;
37922 RET(6)
37923 }
37924
37925 flag_N = 0;
37926 flag_NotZ = 0;
37927 flag_V = 0;
37928 flag_C = 0;
37929 flag_X = 0;
37930 res = 0;
37931 DREGu16((Opcode >> 0) & 7) = res;
37932 RET(6)
37933 }
37934
37935 flag_V = 0;
37936 flag_C = 0;
37937 flag_N = src >> 8;
37938 flag_NotZ = src;
37939RET(6)
37940}
37941
37942// ASRD
37943OPCODE(0xE0A0)
37944{
37945#ifdef USE_CYCLONE_TIMING
37946#define CYC 8
37947#else
37948#define CYC 6
37949#endif
37950 u32 adr, res;
37951 u32 src, dst;
37952
37953 u32 sft;
37954
37955 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37956 src = (s32)DREGs32((Opcode >> 0) & 7);
37957 if (sft)
37958 {
37959 ctx->io_cycle_counter -= sft * 2;
37960 if (sft < 32)
37961 {
37962 flag_V = 0;
37963 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37964 res = ((s32)src) >> sft;
37965 flag_N = res >> 24;
37966 flag_NotZ = res;
37967 DREGu32((Opcode >> 0) & 7) = res;
37968 RET(CYC)
37969 }
37970
37971 if (src & (1 << 31))
37972 {
37973 flag_N = M68K_SR_N;
37974 flag_NotZ = 1;
37975 flag_V = 0;
37976 flag_C = M68K_SR_C;
37977 flag_X = M68K_SR_X;
37978 res = 0xFFFFFFFF;
37979 DREGu32((Opcode >> 0) & 7) = res;
37980 RET(CYC)
37981 }
37982
37983 flag_N = 0;
37984 flag_NotZ = 0;
37985 flag_V = 0;
37986 flag_C = 0;
37987 flag_X = 0;
37988 res = 0;
37989 DREGu32((Opcode >> 0) & 7) = res;
37990 RET(CYC)
37991 }
37992
37993 flag_V = 0;
37994 flag_C = 0;
37995 flag_N = src >> 24;
37996 flag_NotZ = src;
37997RET(CYC)
37998#undef CYC
37999}
38000
38001// LSRD
38002OPCODE(0xE028)
38003{
38004 u32 adr, res;
38005 u32 src, dst;
38006
38007 u32 sft;
38008
38009 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38010 src = DREGu8((Opcode >> 0) & 7);
38011 if (sft)
38012 {
38013 ctx->io_cycle_counter -= sft * 2;
38014 if (sft <= 8)
38015 {
38016 flag_N = flag_V = 0;
38017 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
38018 res = src >> sft;
38019 flag_NotZ = res;
38020 DREGu8((Opcode >> 0) & 7) = res;
38021 RET(6)
38022 }
38023
38024 flag_X = flag_C = 0;
38025 flag_N = 0;
38026 flag_NotZ = 0;
38027 flag_V = 0;
38028 res = 0;
38029 DREGu8((Opcode >> 0) & 7) = res;
38030 RET(6)
38031 }
38032
38033 flag_V = 0;
38034 flag_C = 0;
38035 flag_N = src >> 0;
38036 flag_NotZ = src;
38037RET(6)
38038}
38039
38040// LSRD
38041OPCODE(0xE068)
38042{
38043 u32 adr, res;
38044 u32 src, dst;
38045
38046 u32 sft;
38047
38048 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38049 src = DREGu16((Opcode >> 0) & 7);
38050 if (sft)
38051 {
38052 ctx->io_cycle_counter -= sft * 2;
38053 if (sft <= 16)
38054 {
38055 flag_N = flag_V = 0;
38056 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
38057 res = src >> sft;
38058 flag_NotZ = res;
38059 DREGu16((Opcode >> 0) & 7) = res;
38060 RET(6)
38061 }
38062
38063 flag_X = flag_C = 0;
38064 flag_N = 0;
38065 flag_NotZ = 0;
38066 flag_V = 0;
38067 res = 0;
38068 DREGu16((Opcode >> 0) & 7) = res;
38069 RET(6)
38070 }
38071
38072 flag_V = 0;
38073 flag_C = 0;
38074 flag_N = src >> 8;
38075 flag_NotZ = src;
38076RET(6)
38077}
38078
38079// LSRD
38080OPCODE(0xE0A8)
38081{
38082#ifdef USE_CYCLONE_TIMING
38083#define CYC 8
38084#else
38085#define CYC 6
38086#endif
38087 u32 adr, res;
38088 u32 src, dst;
38089
38090 u32 sft;
38091
38092 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38093 src = DREGu32((Opcode >> 0) & 7);
38094 if (sft)
38095 {
38096 ctx->io_cycle_counter -= sft * 2;
38097 if (sft < 32)
38098 {
38099 flag_N = flag_V = 0;
38100 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
38101 res = src >> sft;
38102 flag_NotZ = res;
38103 DREGu32((Opcode >> 0) & 7) = res;
38104 RET(CYC)
38105 }
38106
38107 if (sft == 32) flag_C = src >> (31 - M68K_SR_C_SFT);
38108 else flag_C = 0;
38109 flag_X = flag_C;
38110 flag_N = 0;
38111 flag_NotZ = 0;
38112 flag_V = 0;
38113 res = 0;
38114 DREGu32((Opcode >> 0) & 7) = res;
38115 RET(CYC)
38116 }
38117
38118 flag_V = 0;
38119 flag_C = 0;
38120 flag_N = src >> 24;
38121 flag_NotZ = src;
38122RET(CYC)
38123#undef CYC
38124}
38125
38126// ROXRD
38127OPCODE(0xE030)
38128{
38129 u32 adr, res;
38130 u32 src, dst;
38131
38132 u32 sft;
38133
38134 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38135 src = DREGu8((Opcode >> 0) & 7);
38136 if (sft)
38137 {
38138 ctx->io_cycle_counter -= sft * 2;
38139 sft %= 9;
38140
38141 src |= (flag_X & M68K_SR_X) << 0;
38142 res = (src >> sft) | (src << (9 - sft));
38143 flag_X = flag_C = res >> 0;
38144 flag_V = 0;
38145 flag_N = res >> 0;
38146 flag_NotZ = res & 0x000000FF;
38147 DREGu8((Opcode >> 0) & 7) = res;
38148 RET(6)
38149 }
38150
38151 flag_V = 0;
38152 flag_C = flag_X;
38153 flag_N = src >> 0;
38154 flag_NotZ = src;
38155RET(6)
38156}
38157
38158// ROXRD
38159OPCODE(0xE070)
38160{
38161 u32 adr, res;
38162 u32 src, dst;
38163
38164 u32 sft;
38165
38166 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38167 src = DREGu16((Opcode >> 0) & 7);
38168 if (sft)
38169 {
38170 ctx->io_cycle_counter -= sft * 2;
38171 sft %= 17;
38172
38173 src |= (flag_X & M68K_SR_X) << 8;
38174 res = (src >> sft) | (src << (17 - sft));
38175 flag_X = flag_C = res >> 8;
38176 flag_V = 0;
38177 flag_N = res >> 8;
38178 flag_NotZ = res & 0x0000FFFF;
38179 DREGu16((Opcode >> 0) & 7) = res;
38180 RET(6)
38181 }
38182
38183 flag_V = 0;
38184 flag_C = flag_X;
38185 flag_N = src >> 8;
38186 flag_NotZ = src;
38187RET(6)
38188}
38189
38190// ROXRD
38191OPCODE(0xE0B0)
38192{
38193#ifdef USE_CYCLONE_TIMING
38194#define CYC 8
38195#else
38196#define CYC 6
38197#endif
38198 u32 adr, res;
38199 u32 src, dst;
38200
38201 u32 sft;
38202
38203 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38204 src = DREGu32((Opcode >> 0) & 7);
38205 if (sft)
38206 {
38207 ctx->io_cycle_counter -= sft * 2;
38208 sft %= 33;
38209
38210 if (sft != 0)
38211 {
38212 if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
38213 else res = (src >> sft) | (src << (33 - sft)) | (((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1))) >> (sft - 1));
38214 flag_X = (src >> (sft - 1)) << M68K_SR_X_SFT;
38215 }
38216 else res = src;
38217 flag_C = flag_X;
38218 flag_V = 0;
38219 flag_N = res >> 24;
38220 flag_NotZ = res;
38221 DREGu32((Opcode >> 0) & 7) = res;
38222 RET(CYC)
38223 }
38224
38225 flag_V = 0;
38226 flag_C = flag_X;
38227 flag_N = src >> 24;
38228 flag_NotZ = src;
38229RET(CYC)
38230#undef CYC
38231}
38232
38233// RORD
38234OPCODE(0xE038)
38235{
38236 u32 adr, res;
38237 u32 src, dst;
38238
38239 u32 sft;
38240
38241 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38242 src = DREGu8((Opcode >> 0) & 7);
38243 if (sft)
38244 {
38245 ctx->io_cycle_counter -= sft * 2;
38246 sft &= 0x07;
38247
38248 flag_C = src << (M68K_SR_C_SFT - ((sft - 1) & 7));
38249 res = (src >> sft) | (src << (8 - sft));
38250 flag_V = 0;
38251 flag_N = res >> 0;
38252 flag_NotZ = res & 0x000000FF;
38253 DREGu8((Opcode >> 0) & 7) = res;
38254 RET(6)
38255 }
38256
38257 flag_V = 0;
38258 flag_C = 0;
38259 flag_N = src >> 0;
38260 flag_NotZ = src;
38261RET(6)
38262}
38263
38264// RORD
38265OPCODE(0xE078)
38266{
38267 u32 adr, res;
38268 u32 src, dst;
38269
38270 u32 sft;
38271
38272 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38273 src = DREGu16((Opcode >> 0) & 7);
38274 if (sft)
38275 {
38276 ctx->io_cycle_counter -= sft * 2;
38277 sft &= 0x0F;
38278
38279 flag_C = (src >> ((sft - 1) & 15)) << M68K_SR_C_SFT;
38280 res = (src >> sft) | (src << (16 - sft));
38281 flag_V = 0;
38282 flag_N = res >> 8;
38283 flag_NotZ = res & 0x0000FFFF;
38284 DREGu16((Opcode >> 0) & 7) = res;
38285 RET(6)
38286 }
38287
38288 flag_V = 0;
38289 flag_C = 0;
38290 flag_N = src >> 8;
38291 flag_NotZ = src;
38292RET(6)
38293}
38294
38295// RORD
38296OPCODE(0xE0B8)
38297{
38298#ifdef USE_CYCLONE_TIMING
38299#define CYC 8
38300#else
38301#define CYC 6
38302#endif
38303 u32 adr, res;
38304 u32 src, dst;
38305
38306 u32 sft;
38307
38308 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38309 src = DREGu32((Opcode >> 0) & 7);
38310 if (sft)
38311 {
38312 ctx->io_cycle_counter -= sft * 2;
38313 sft &= 0x1F;
38314
38315 flag_C = (src >> ((sft - 1) & 31)) << M68K_SR_C_SFT;
38316 res = (src >> sft) | (src << (32 - sft));
38317 flag_V = 0;
38318 flag_N = res >> 24;
38319 flag_NotZ = res;
38320 DREGu32((Opcode >> 0) & 7) = res;
38321 RET(CYC)
38322 }
38323
38324 flag_V = 0;
38325 flag_C = 0;
38326 flag_N = src >> 24;
38327 flag_NotZ = src;
38328RET(CYC)
38329#undef CYC
38330}
38331
38332// ASLD
38333OPCODE(0xE120)
38334{
38335 u32 adr, res;
38336 u32 src, dst;
38337
38338 u32 sft;
38339
38340 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38341 src = DREGu8((Opcode >> 0) & 7);
38342 if (sft)
38343 {
38344 ctx->io_cycle_counter -= sft * 2;
38345 if (sft < 8)
38346 {
38347 flag_X = flag_C = (src << sft) >> 0;
38348 res = (src << sft) & 0x000000FF;
38349 flag_N = res >> 0;
38350 flag_NotZ = res;
38351 DREGu8((Opcode >> 0) & 7) = res;
38352 flag_V = 0;
38353 {
38354 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
38355 src &= msk;
38356 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38357 }
38358 RET(6)
38359 }
38360
38361 if (sft == 256) flag_C = src << M68K_SR_C_SFT;
38362 else flag_C = 0;
38363 flag_X = flag_C;
38364 if (src) flag_V = M68K_SR_V;
38365 else flag_V = 0;
38366 res = 0;
38367 DREGu8((Opcode >> 0) & 7) = res;
38368 flag_N = 0;
38369 flag_NotZ = 0;
38370 RET(6)
38371 }
38372
38373 flag_V = 0;
38374 flag_C = 0;
38375 flag_N = src >> 0;
38376 flag_NotZ = src;
38377RET(6)
38378}
38379
38380// ASLD
38381OPCODE(0xE160)
38382{
38383 u32 adr, res;
38384 u32 src, dst;
38385
38386 u32 sft;
38387
38388 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38389 src = DREGu16((Opcode >> 0) & 7);
38390 if (sft)
38391 {
38392 ctx->io_cycle_counter -= sft * 2;
38393 if (sft < 16)
38394 {
38395 flag_X = flag_C = (src << sft) >> 8;
38396 res = (src << sft) & 0x0000FFFF;
38397 flag_N = res >> 8;
38398 flag_NotZ = res;
38399 DREGu16((Opcode >> 0) & 7) = res;
38400 flag_V = 0;
38401 {
38402 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
38403 src &= msk;
38404 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38405 }
38406 RET(6)
38407 }
38408
38409 if (sft == 65536) flag_C = src << M68K_SR_C_SFT;
38410 else flag_C = 0;
38411 flag_X = flag_C;
38412 if (src) flag_V = M68K_SR_V;
38413 else flag_V = 0;
38414 res = 0;
38415 DREGu16((Opcode >> 0) & 7) = res;
38416 flag_N = 0;
38417 flag_NotZ = 0;
38418 RET(6)
38419 }
38420
38421 flag_V = 0;
38422 flag_C = 0;
38423 flag_N = src >> 8;
38424 flag_NotZ = src;
38425RET(6)
38426}
38427
38428// ASLD
38429OPCODE(0xE1A0)
38430{
38431#ifdef USE_CYCLONE_TIMING
38432#define CYC 8
38433#else
38434#define CYC 6
38435#endif
38436 u32 adr, res;
38437 u32 src, dst;
38438
38439 u32 sft;
38440
38441 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38442 src = DREGu32((Opcode >> 0) & 7);
38443 if (sft)
38444 {
38445 ctx->io_cycle_counter -= sft * 2;
38446 if (sft < 32)
38447 {
38448 flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38449 res = src << sft;
38450 flag_N = res >> 24;
38451 flag_NotZ = res;
38452 DREGu32((Opcode >> 0) & 7) = res;
38453 flag_V = 0;
38454 {
38455 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
38456 src &= msk;
38457 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38458 }
38459 RET(CYC)
38460 }
38461
38462 if (sft == 0) flag_C = src << M68K_SR_C_SFT;
38463 else flag_C = 0;
38464 flag_X = flag_C;
38465 if (src) flag_V = M68K_SR_V;
38466 else flag_V = 0;
38467 res = 0;
38468 DREGu32((Opcode >> 0) & 7) = res;
38469 flag_N = 0;
38470 flag_NotZ = 0;
38471 RET(CYC)
38472 }
38473
38474 flag_V = 0;
38475 flag_C = 0;
38476 flag_N = src >> 24;
38477 flag_NotZ = src;
38478RET(CYC)
38479#undef CYC
38480}
38481
38482// LSLD
38483OPCODE(0xE128)
38484{
38485 u32 adr, res;
38486 u32 src, dst;
38487
38488 u32 sft;
38489
38490 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38491 src = DREGu8((Opcode >> 0) & 7);
38492 if (sft)
38493 {
38494 ctx->io_cycle_counter -= sft * 2;
38495 if (sft <= 8)
38496 {
38497 flag_X = flag_C = (src << sft) >> 0;
38498 res = (src << sft) & 0x000000FF;
38499 flag_V = 0;
38500 flag_N = res >> 0;
38501 flag_NotZ = res;
38502 DREGu8((Opcode >> 0) & 7) = res;
38503 RET(6)
38504 }
38505
38506 flag_X = flag_C = 0;
38507 flag_N = 0;
38508 flag_NotZ = 0;
38509 flag_V = 0;
38510 res = 0;
38511 DREGu8((Opcode >> 0) & 7) = res;
38512 RET(6)
38513 }
38514
38515 flag_V = 0;
38516 flag_C = 0;
38517 flag_N = src >> 0;
38518 flag_NotZ = src;
38519RET(6)
38520}
38521
38522// LSLD
38523OPCODE(0xE168)
38524{
38525 u32 adr, res;
38526 u32 src, dst;
38527
38528 u32 sft;
38529
38530 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38531 src = DREGu16((Opcode >> 0) & 7);
38532 if (sft)
38533 {
38534 ctx->io_cycle_counter -= sft * 2;
38535 if (sft <= 16)
38536 {
38537 flag_X = flag_C = (src << sft) >> 8;
38538 res = (src << sft) & 0x0000FFFF;
38539 flag_V = 0;
38540 flag_N = res >> 8;
38541 flag_NotZ = res;
38542 DREGu16((Opcode >> 0) & 7) = res;
38543 RET(6)
38544 }
38545
38546 flag_X = flag_C = 0;
38547 flag_N = 0;
38548 flag_NotZ = 0;
38549 flag_V = 0;
38550 res = 0;
38551 DREGu16((Opcode >> 0) & 7) = res;
38552 RET(6)
38553 }
38554
38555 flag_V = 0;
38556 flag_C = 0;
38557 flag_N = src >> 8;
38558 flag_NotZ = src;
38559RET(6)
38560}
38561
38562// LSLD
38563OPCODE(0xE1A8)
38564{
38565#ifdef USE_CYCLONE_TIMING
38566#define CYC 8
38567#else
38568#define CYC 6
38569#endif
38570 u32 adr, res;
38571 u32 src, dst;
38572
38573 u32 sft;
38574
38575 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38576 src = DREGu32((Opcode >> 0) & 7);
38577 if (sft)
38578 {
38579 ctx->io_cycle_counter -= sft * 2;
38580 if (sft < 32)
38581 {
38582 flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38583 res = src << sft;
38584 flag_V = 0;
38585 flag_N = res >> 24;
38586 flag_NotZ = res;
38587 DREGu32((Opcode >> 0) & 7) = res;
38588 RET(CYC)
38589 }
38590
38591 if (sft == 32) flag_C = src << M68K_SR_C_SFT;
38592 else flag_C = 0;
38593 flag_X = flag_C;
38594 flag_N = 0;
38595 flag_NotZ = 0;
38596 flag_V = 0;
38597 res = 0;
38598 DREGu32((Opcode >> 0) & 7) = res;
38599 RET(CYC)
38600 }
38601
38602 flag_V = 0;
38603 flag_C = 0;
38604 flag_N = src >> 24;
38605 flag_NotZ = src;
38606RET(CYC)
38607#undef CYC
38608}
38609
38610// ROXLD
38611OPCODE(0xE130)
38612{
38613 u32 adr, res;
38614 u32 src, dst;
38615
38616 u32 sft;
38617
38618 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38619 src = DREGu8((Opcode >> 0) & 7);
38620 if (sft)
38621 {
38622 ctx->io_cycle_counter -= sft * 2;
38623 sft %= 9;
38624
38625 src |= (flag_X & M68K_SR_X) << 0;
38626 res = (src << sft) | (src >> (9 - sft));
38627 flag_X = flag_C = res >> 0;
38628 flag_V = 0;
38629 flag_N = res >> 0;
38630 flag_NotZ = res & 0x000000FF;
38631 DREGu8((Opcode >> 0) & 7) = res;
38632 RET(6)
38633 }
38634
38635 flag_V = 0;
38636 flag_C = flag_X;
38637 flag_N = src >> 0;
38638 flag_NotZ = src;
38639RET(6)
38640}
38641
38642// ROXLD
38643OPCODE(0xE170)
38644{
38645 u32 adr, res;
38646 u32 src, dst;
38647
38648 u32 sft;
38649
38650 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38651 src = DREGu16((Opcode >> 0) & 7);
38652 if (sft)
38653 {
38654 ctx->io_cycle_counter -= sft * 2;
38655 sft %= 17;
38656
38657 src |= (flag_X & M68K_SR_X) << 8;
38658 res = (src << sft) | (src >> (17 - sft));
38659 flag_X = flag_C = res >> 8;
38660 flag_V = 0;
38661 flag_N = res >> 8;
38662 flag_NotZ = res & 0x0000FFFF;
38663 DREGu16((Opcode >> 0) & 7) = res;
38664 RET(6)
38665 }
38666
38667 flag_V = 0;
38668 flag_C = flag_X;
38669 flag_N = src >> 8;
38670 flag_NotZ = src;
38671RET(6)
38672}
38673
38674// ROXLD
38675OPCODE(0xE1B0)
38676{
38677#ifdef USE_CYCLONE_TIMING
38678#define CYC 8
38679#else
38680#define CYC 6
38681#endif
38682 u32 adr, res;
38683 u32 src, dst;
38684
38685 u32 sft;
38686
38687 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38688 src = DREGu32((Opcode >> 0) & 7);
38689 if (sft)
38690 {
38691 ctx->io_cycle_counter -= sft * 2;
38692 sft %= 33;
38693
38694 if (sft != 0)
38695 {
38696 if (sft == 1) res = (src << 1) | ((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1);
38697 else res = (src << sft) | (src >> (33 - sft)) | (((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1));
38698 flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
38699 }
38700 else res = src;
38701 flag_C = flag_X;
38702 flag_V = 0;
38703 flag_N = res >> 24;
38704 flag_NotZ = res;
38705 DREGu32((Opcode >> 0) & 7) = res;
38706 RET(CYC)
38707 }
38708
38709 flag_V = 0;
38710 flag_C = flag_X;
38711 flag_N = src >> 24;
38712 flag_NotZ = src;
38713RET(CYC)
38714#undef CYC
38715}
38716
38717// ROLD
38718OPCODE(0xE138)
38719{
38720 u32 adr, res;
38721 u32 src, dst;
38722
38723 u32 sft;
38724
38725 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38726 src = DREGu8((Opcode >> 0) & 7);
38727 if (sft)
38728 {
38729 ctx->io_cycle_counter -= sft * 2;
38730 if (sft &= 0x07)
38731 {
38732 flag_C = (src << sft) >> 0;
38733 res = ((src << sft) | (src >> (8 - sft))) & 0x000000FF;
38734 flag_V = 0;
38735 flag_N = res >> 0;
38736 flag_NotZ = res;
38737 DREGu8((Opcode >> 0) & 7) = res;
38738 RET(6)
38739 }
38740
38741 flag_V = 0;
38742 flag_C = src << M68K_SR_C_SFT;
38743 flag_N = src >> 0;
38744 flag_NotZ = src;
38745 RET(6)
38746 }
38747
38748 flag_V = 0;
38749 flag_C = 0;
38750 flag_N = src >> 0;
38751 flag_NotZ = src;
38752RET(6)
38753}
38754
38755// ROLD
38756OPCODE(0xE178)
38757{
38758 u32 adr, res;
38759 u32 src, dst;
38760
38761 u32 sft;
38762
38763 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38764 src = DREGu16((Opcode >> 0) & 7);
38765 if (sft)
38766 {
38767 ctx->io_cycle_counter -= sft * 2;
38768 if (sft &= 0x0F)
38769 {
38770 flag_C = (src << sft) >> 8;
38771 res = ((src << sft) | (src >> (16 - sft))) & 0x0000FFFF;
38772 flag_V = 0;
38773 flag_N = res >> 8;
38774 flag_NotZ = res;
38775 DREGu16((Opcode >> 0) & 7) = res;
38776 RET(6)
38777 }
38778
38779 flag_V = 0;
38780 flag_C = src << M68K_SR_C_SFT;
38781 flag_N = src >> 8;
38782 flag_NotZ = src;
38783 RET(6)
38784 }
38785
38786 flag_V = 0;
38787 flag_C = 0;
38788 flag_N = src >> 8;
38789 flag_NotZ = src;
38790RET(6)
38791}
38792
38793// ROLD
38794OPCODE(0xE1B8)
38795{
38796#ifdef USE_CYCLONE_TIMING
38797#define CYC 8
38798#else
38799#define CYC 6
38800#endif
38801 u32 adr, res;
38802 u32 src, dst;
38803
38804 u32 sft;
38805
38806 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38807 src = DREGu32((Opcode >> 0) & 7);
38808 if (sft)
38809 {
38810 ctx->io_cycle_counter -= sft * 2;
38811 if (sft &= 0x1F)
38812 {
38813 flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38814 res = (src << sft) | (src >> (32 - sft));
38815 flag_V = 0;
38816 flag_N = res >> 24;
38817 flag_NotZ = res;
38818 DREGu32((Opcode >> 0) & 7) = res;
38819 RET(CYC)
38820 }
38821
38822 flag_V = 0;
38823 flag_C = src << M68K_SR_C_SFT;
38824 flag_N = src >> 24;
38825 flag_NotZ = src;
38826 RET(CYC)
38827 }
38828
38829 flag_V = 0;
38830 flag_C = 0;
38831 flag_N = src >> 24;
38832 flag_NotZ = src;
38833RET(CYC)
38834#undef CYC
38835}
38836
38837// ASR
38838OPCODE(0xE0D0)
38839{
38840 u32 adr, res;
38841 u32 src, dst;
38842
38843 adr = AREG((Opcode >> 0) & 7);
38844 PRE_IO
38845 READ_WORD_F(adr, src)
38846 flag_V = 0;
38847 flag_X = flag_C = src << M68K_SR_C_SFT;
38848 res = (src >> 1) | (src & (1 << 15));
38849 flag_N = res >> 8;
38850 flag_NotZ = res;
38851 WRITE_WORD_F(adr, res)
38852 POST_IO
38853RET(12)
38854}
38855
38856// ASR
38857OPCODE(0xE0D8)
38858{
38859 u32 adr, res;
38860 u32 src, dst;
38861
38862 adr = AREG((Opcode >> 0) & 7);
38863 AREG((Opcode >> 0) & 7) += 2;
38864 PRE_IO
38865 READ_WORD_F(adr, src)
38866 flag_V = 0;
38867 flag_X = flag_C = src << M68K_SR_C_SFT;
38868 res = (src >> 1) | (src & (1 << 15));
38869 flag_N = res >> 8;
38870 flag_NotZ = res;
38871 WRITE_WORD_F(adr, res)
38872 POST_IO
38873RET(12)
38874}
38875
38876// ASR
38877OPCODE(0xE0E0)
38878{
38879 u32 adr, res;
38880 u32 src, dst;
38881
38882 adr = AREG((Opcode >> 0) & 7) - 2;
38883 AREG((Opcode >> 0) & 7) = adr;
38884 PRE_IO
38885 READ_WORD_F(adr, src)
38886 flag_V = 0;
38887 flag_X = flag_C = src << M68K_SR_C_SFT;
38888 res = (src >> 1) | (src & (1 << 15));
38889 flag_N = res >> 8;
38890 flag_NotZ = res;
38891 WRITE_WORD_F(adr, res)
38892 POST_IO
38893RET(14)
38894}
38895
38896// ASR
38897OPCODE(0xE0E8)
38898{
38899 u32 adr, res;
38900 u32 src, dst;
38901
38902 FETCH_SWORD(adr);
38903 adr += AREG((Opcode >> 0) & 7);
38904 PRE_IO
38905 READ_WORD_F(adr, src)
38906 flag_V = 0;
38907 flag_X = flag_C = src << M68K_SR_C_SFT;
38908 res = (src >> 1) | (src & (1 << 15));
38909 flag_N = res >> 8;
38910 flag_NotZ = res;
38911 WRITE_WORD_F(adr, res)
38912 POST_IO
38913RET(16)
38914}
38915
38916// ASR
38917OPCODE(0xE0F0)
38918{
38919 u32 adr, res;
38920 u32 src, dst;
38921
38922 adr = AREG((Opcode >> 0) & 7);
38923 DECODE_EXT_WORD
38924 PRE_IO
38925 READ_WORD_F(adr, src)
38926 flag_V = 0;
38927 flag_X = flag_C = src << M68K_SR_C_SFT;
38928 res = (src >> 1) | (src & (1 << 15));
38929 flag_N = res >> 8;
38930 flag_NotZ = res;
38931 WRITE_WORD_F(adr, res)
38932 POST_IO
38933RET(18)
38934}
38935
38936// ASR
38937OPCODE(0xE0F8)
38938{
38939 u32 adr, res;
38940 u32 src, dst;
38941
38942 FETCH_SWORD(adr);
38943 PRE_IO
38944 READ_WORD_F(adr, src)
38945 flag_V = 0;
38946 flag_X = flag_C = src << M68K_SR_C_SFT;
38947 res = (src >> 1) | (src & (1 << 15));
38948 flag_N = res >> 8;
38949 flag_NotZ = res;
38950 WRITE_WORD_F(adr, res)
38951 POST_IO
38952RET(16)
38953}
38954
38955// ASR
38956OPCODE(0xE0F9)
38957{
38958 u32 adr, res;
38959 u32 src, dst;
38960
38961 FETCH_LONG(adr);
38962 PRE_IO
38963 READ_WORD_F(adr, src)
38964 flag_V = 0;
38965 flag_X = flag_C = src << M68K_SR_C_SFT;
38966 res = (src >> 1) | (src & (1 << 15));
38967 flag_N = res >> 8;
38968 flag_NotZ = res;
38969 WRITE_WORD_F(adr, res)
38970 POST_IO
38971RET(20)
38972}
38973
38974// ASR
38975OPCODE(0xE0DF)
38976{
38977 u32 adr, res;
38978 u32 src, dst;
38979
38980 adr = AREG(7);
38981 AREG(7) += 2;
38982 PRE_IO
38983 READ_WORD_F(adr, src)
38984 flag_V = 0;
38985 flag_X = flag_C = src << M68K_SR_C_SFT;
38986 res = (src >> 1) | (src & (1 << 15));
38987 flag_N = res >> 8;
38988 flag_NotZ = res;
38989 WRITE_WORD_F(adr, res)
38990 POST_IO
38991RET(12)
38992}
38993
38994// ASR
38995OPCODE(0xE0E7)
38996{
38997 u32 adr, res;
38998 u32 src, dst;
38999
39000 adr = AREG(7) - 2;
39001 AREG(7) = adr;
39002 PRE_IO
39003 READ_WORD_F(adr, src)
39004 flag_V = 0;
39005 flag_X = flag_C = src << M68K_SR_C_SFT;
39006 res = (src >> 1) | (src & (1 << 15));
39007 flag_N = res >> 8;
39008 flag_NotZ = res;
39009 WRITE_WORD_F(adr, res)
39010 POST_IO
39011RET(14)
39012}
39013
39014// LSR
39015OPCODE(0xE2D0)
39016{
39017 u32 adr, res;
39018 u32 src, dst;
39019
39020 adr = AREG((Opcode >> 0) & 7);
39021 PRE_IO
39022 READ_WORD_F(adr, src)
39023 flag_N = flag_V = 0;
39024 flag_X = flag_C = src << M68K_SR_C_SFT;
39025 res = src >> 1;
39026 flag_NotZ = res;
39027 WRITE_WORD_F(adr, res)
39028 POST_IO
39029RET(12)
39030}
39031
39032// LSR
39033OPCODE(0xE2D8)
39034{
39035 u32 adr, res;
39036 u32 src, dst;
39037
39038 adr = AREG((Opcode >> 0) & 7);
39039 AREG((Opcode >> 0) & 7) += 2;
39040 PRE_IO
39041 READ_WORD_F(adr, src)
39042 flag_N = flag_V = 0;
39043 flag_X = flag_C = src << M68K_SR_C_SFT;
39044 res = src >> 1;
39045 flag_NotZ = res;
39046 WRITE_WORD_F(adr, res)
39047 POST_IO
39048RET(12)
39049}
39050
39051// LSR
39052OPCODE(0xE2E0)
39053{
39054 u32 adr, res;
39055 u32 src, dst;
39056
39057 adr = AREG((Opcode >> 0) & 7) - 2;
39058 AREG((Opcode >> 0) & 7) = adr;
39059 PRE_IO
39060 READ_WORD_F(adr, src)
39061 flag_N = flag_V = 0;
39062 flag_X = flag_C = src << M68K_SR_C_SFT;
39063 res = src >> 1;
39064 flag_NotZ = res;
39065 WRITE_WORD_F(adr, res)
39066 POST_IO
39067RET(14)
39068}
39069
39070// LSR
39071OPCODE(0xE2E8)
39072{
39073 u32 adr, res;
39074 u32 src, dst;
39075
39076 FETCH_SWORD(adr);
39077 adr += AREG((Opcode >> 0) & 7);
39078 PRE_IO
39079 READ_WORD_F(adr, src)
39080 flag_N = flag_V = 0;
39081 flag_X = flag_C = src << M68K_SR_C_SFT;
39082 res = src >> 1;
39083 flag_NotZ = res;
39084 WRITE_WORD_F(adr, res)
39085 POST_IO
39086RET(16)
39087}
39088
39089// LSR
39090OPCODE(0xE2F0)
39091{
39092 u32 adr, res;
39093 u32 src, dst;
39094
39095 adr = AREG((Opcode >> 0) & 7);
39096 DECODE_EXT_WORD
39097 PRE_IO
39098 READ_WORD_F(adr, src)
39099 flag_N = flag_V = 0;
39100 flag_X = flag_C = src << M68K_SR_C_SFT;
39101 res = src >> 1;
39102 flag_NotZ = res;
39103 WRITE_WORD_F(adr, res)
39104 POST_IO
39105RET(18)
39106}
39107
39108// LSR
39109OPCODE(0xE2F8)
39110{
39111 u32 adr, res;
39112 u32 src, dst;
39113
39114 FETCH_SWORD(adr);
39115 PRE_IO
39116 READ_WORD_F(adr, src)
39117 flag_N = flag_V = 0;
39118 flag_X = flag_C = src << M68K_SR_C_SFT;
39119 res = src >> 1;
39120 flag_NotZ = res;
39121 WRITE_WORD_F(adr, res)
39122 POST_IO
39123RET(16)
39124}
39125
39126// LSR
39127OPCODE(0xE2F9)
39128{
39129 u32 adr, res;
39130 u32 src, dst;
39131
39132 FETCH_LONG(adr);
39133 PRE_IO
39134 READ_WORD_F(adr, src)
39135 flag_N = flag_V = 0;
39136 flag_X = flag_C = src << M68K_SR_C_SFT;
39137 res = src >> 1;
39138 flag_NotZ = res;
39139 WRITE_WORD_F(adr, res)
39140 POST_IO
39141RET(20)
39142}
39143
39144// LSR
39145OPCODE(0xE2DF)
39146{
39147 u32 adr, res;
39148 u32 src, dst;
39149
39150 adr = AREG(7);
39151 AREG(7) += 2;
39152 PRE_IO
39153 READ_WORD_F(adr, src)
39154 flag_N = flag_V = 0;
39155 flag_X = flag_C = src << M68K_SR_C_SFT;
39156 res = src >> 1;
39157 flag_NotZ = res;
39158 WRITE_WORD_F(adr, res)
39159 POST_IO
39160RET(12)
39161}
39162
39163// LSR
39164OPCODE(0xE2E7)
39165{
39166 u32 adr, res;
39167 u32 src, dst;
39168
39169 adr = AREG(7) - 2;
39170 AREG(7) = adr;
39171 PRE_IO
39172 READ_WORD_F(adr, src)
39173 flag_N = flag_V = 0;
39174 flag_X = flag_C = src << M68K_SR_C_SFT;
39175 res = src >> 1;
39176 flag_NotZ = res;
39177 WRITE_WORD_F(adr, res)
39178 POST_IO
39179RET(14)
39180}
39181
39182// ROXR
39183OPCODE(0xE4D0)
39184{
39185 u32 adr, res;
39186 u32 src, dst;
39187
39188 adr = AREG((Opcode >> 0) & 7);
39189 PRE_IO
39190 READ_WORD_F(adr, src)
39191 flag_V = 0;
39192 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39193 flag_C = flag_X = src << M68K_SR_C_SFT;
39194 flag_N = res >> 8;
39195 flag_NotZ = res;
39196 WRITE_WORD_F(adr, res)
39197 POST_IO
39198RET(12)
39199}
39200
39201// ROXR
39202OPCODE(0xE4D8)
39203{
39204 u32 adr, res;
39205 u32 src, dst;
39206
39207 adr = AREG((Opcode >> 0) & 7);
39208 AREG((Opcode >> 0) & 7) += 2;
39209 PRE_IO
39210 READ_WORD_F(adr, src)
39211 flag_V = 0;
39212 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39213 flag_C = flag_X = src << M68K_SR_C_SFT;
39214 flag_N = res >> 8;
39215 flag_NotZ = res;
39216 WRITE_WORD_F(adr, res)
39217 POST_IO
39218RET(12)
39219}
39220
39221// ROXR
39222OPCODE(0xE4E0)
39223{
39224 u32 adr, res;
39225 u32 src, dst;
39226
39227 adr = AREG((Opcode >> 0) & 7) - 2;
39228 AREG((Opcode >> 0) & 7) = adr;
39229 PRE_IO
39230 READ_WORD_F(adr, src)
39231 flag_V = 0;
39232 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39233 flag_C = flag_X = src << M68K_SR_C_SFT;
39234 flag_N = res >> 8;
39235 flag_NotZ = res;
39236 WRITE_WORD_F(adr, res)
39237 POST_IO
39238RET(14)
39239}
39240
39241// ROXR
39242OPCODE(0xE4E8)
39243{
39244 u32 adr, res;
39245 u32 src, dst;
39246
39247 FETCH_SWORD(adr);
39248 adr += AREG((Opcode >> 0) & 7);
39249 PRE_IO
39250 READ_WORD_F(adr, src)
39251 flag_V = 0;
39252 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39253 flag_C = flag_X = src << M68K_SR_C_SFT;
39254 flag_N = res >> 8;
39255 flag_NotZ = res;
39256 WRITE_WORD_F(adr, res)
39257 POST_IO
39258RET(16)
39259}
39260
39261// ROXR
39262OPCODE(0xE4F0)
39263{
39264 u32 adr, res;
39265 u32 src, dst;
39266
39267 adr = AREG((Opcode >> 0) & 7);
39268 DECODE_EXT_WORD
39269 PRE_IO
39270 READ_WORD_F(adr, src)
39271 flag_V = 0;
39272 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39273 flag_C = flag_X = src << M68K_SR_C_SFT;
39274 flag_N = res >> 8;
39275 flag_NotZ = res;
39276 WRITE_WORD_F(adr, res)
39277 POST_IO
39278RET(18)
39279}
39280
39281// ROXR
39282OPCODE(0xE4F8)
39283{
39284 u32 adr, res;
39285 u32 src, dst;
39286
39287 FETCH_SWORD(adr);
39288 PRE_IO
39289 READ_WORD_F(adr, src)
39290 flag_V = 0;
39291 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39292 flag_C = flag_X = src << M68K_SR_C_SFT;
39293 flag_N = res >> 8;
39294 flag_NotZ = res;
39295 WRITE_WORD_F(adr, res)
39296 POST_IO
39297RET(16)
39298}
39299
39300// ROXR
39301OPCODE(0xE4F9)
39302{
39303 u32 adr, res;
39304 u32 src, dst;
39305
39306 FETCH_LONG(adr);
39307 PRE_IO
39308 READ_WORD_F(adr, src)
39309 flag_V = 0;
39310 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39311 flag_C = flag_X = src << M68K_SR_C_SFT;
39312 flag_N = res >> 8;
39313 flag_NotZ = res;
39314 WRITE_WORD_F(adr, res)
39315 POST_IO
39316RET(20)
39317}
39318
39319// ROXR
39320OPCODE(0xE4DF)
39321{
39322 u32 adr, res;
39323 u32 src, dst;
39324
39325 adr = AREG(7);
39326 AREG(7) += 2;
39327 PRE_IO
39328 READ_WORD_F(adr, src)
39329 flag_V = 0;
39330 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39331 flag_C = flag_X = src << M68K_SR_C_SFT;
39332 flag_N = res >> 8;
39333 flag_NotZ = res;
39334 WRITE_WORD_F(adr, res)
39335 POST_IO
39336RET(12)
39337}
39338
39339// ROXR
39340OPCODE(0xE4E7)
39341{
39342 u32 adr, res;
39343 u32 src, dst;
39344
39345 adr = AREG(7) - 2;
39346 AREG(7) = adr;
39347 PRE_IO
39348 READ_WORD_F(adr, src)
39349 flag_V = 0;
39350 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39351 flag_C = flag_X = src << M68K_SR_C_SFT;
39352 flag_N = res >> 8;
39353 flag_NotZ = res;
39354 WRITE_WORD_F(adr, res)
39355 POST_IO
39356RET(14)
39357}
39358
39359// ROR
39360OPCODE(0xE6D0)
39361{
39362 u32 adr, res;
39363 u32 src, dst;
39364
39365 adr = AREG((Opcode >> 0) & 7);
39366 PRE_IO
39367 READ_WORD_F(adr, src)
39368 flag_V = 0;
39369 flag_C = src << M68K_SR_C_SFT;
39370 res = (src >> 1) | (src << 15);
39371 flag_N = res >> 8;
39372 flag_NotZ = res & 0x0000FFFF;
39373 WRITE_WORD_F(adr, res)
39374 POST_IO
39375RET(12)
39376}
39377
39378// ROR
39379OPCODE(0xE6D8)
39380{
39381 u32 adr, res;
39382 u32 src, dst;
39383
39384 adr = AREG((Opcode >> 0) & 7);
39385 AREG((Opcode >> 0) & 7) += 2;
39386 PRE_IO
39387 READ_WORD_F(adr, src)
39388 flag_V = 0;
39389 flag_C = src << M68K_SR_C_SFT;
39390 res = (src >> 1) | (src << 15);
39391 flag_N = res >> 8;
39392 flag_NotZ = res & 0x0000FFFF;
39393 WRITE_WORD_F(adr, res)
39394 POST_IO
39395RET(12)
39396}
39397
39398// ROR
39399OPCODE(0xE6E0)
39400{
39401 u32 adr, res;
39402 u32 src, dst;
39403
39404 adr = AREG((Opcode >> 0) & 7) - 2;
39405 AREG((Opcode >> 0) & 7) = adr;
39406 PRE_IO
39407 READ_WORD_F(adr, src)
39408 flag_V = 0;
39409 flag_C = src << M68K_SR_C_SFT;
39410 res = (src >> 1) | (src << 15);
39411 flag_N = res >> 8;
39412 flag_NotZ = res & 0x0000FFFF;
39413 WRITE_WORD_F(adr, res)
39414 POST_IO
39415RET(14)
39416}
39417
39418// ROR
39419OPCODE(0xE6E8)
39420{
39421 u32 adr, res;
39422 u32 src, dst;
39423
39424 FETCH_SWORD(adr);
39425 adr += AREG((Opcode >> 0) & 7);
39426 PRE_IO
39427 READ_WORD_F(adr, src)
39428 flag_V = 0;
39429 flag_C = src << M68K_SR_C_SFT;
39430 res = (src >> 1) | (src << 15);
39431 flag_N = res >> 8;
39432 flag_NotZ = res & 0x0000FFFF;
39433 WRITE_WORD_F(adr, res)
39434 POST_IO
39435RET(16)
39436}
39437
39438// ROR
39439OPCODE(0xE6F0)
39440{
39441 u32 adr, res;
39442 u32 src, dst;
39443
39444 adr = AREG((Opcode >> 0) & 7);
39445 DECODE_EXT_WORD
39446 PRE_IO
39447 READ_WORD_F(adr, src)
39448 flag_V = 0;
39449 flag_C = src << M68K_SR_C_SFT;
39450 res = (src >> 1) | (src << 15);
39451 flag_N = res >> 8;
39452 flag_NotZ = res & 0x0000FFFF;
39453 WRITE_WORD_F(adr, res)
39454 POST_IO
39455RET(18)
39456}
39457
39458// ROR
39459OPCODE(0xE6F8)
39460{
39461 u32 adr, res;
39462 u32 src, dst;
39463
39464 FETCH_SWORD(adr);
39465 PRE_IO
39466 READ_WORD_F(adr, src)
39467 flag_V = 0;
39468 flag_C = src << M68K_SR_C_SFT;
39469 res = (src >> 1) | (src << 15);
39470 flag_N = res >> 8;
39471 flag_NotZ = res & 0x0000FFFF;
39472 WRITE_WORD_F(adr, res)
39473 POST_IO
39474RET(16)
39475}
39476
39477// ROR
39478OPCODE(0xE6F9)
39479{
39480 u32 adr, res;
39481 u32 src, dst;
39482
39483 FETCH_LONG(adr);
39484 PRE_IO
39485 READ_WORD_F(adr, src)
39486 flag_V = 0;
39487 flag_C = src << M68K_SR_C_SFT;
39488 res = (src >> 1) | (src << 15);
39489 flag_N = res >> 8;
39490 flag_NotZ = res & 0x0000FFFF;
39491 WRITE_WORD_F(adr, res)
39492 POST_IO
39493RET(20)
39494}
39495
39496// ROR
39497OPCODE(0xE6DF)
39498{
39499 u32 adr, res;
39500 u32 src, dst;
39501
39502 adr = AREG(7);
39503 AREG(7) += 2;
39504 PRE_IO
39505 READ_WORD_F(adr, src)
39506 flag_V = 0;
39507 flag_C = src << M68K_SR_C_SFT;
39508 res = (src >> 1) | (src << 15);
39509 flag_N = res >> 8;
39510 flag_NotZ = res & 0x0000FFFF;
39511 WRITE_WORD_F(adr, res)
39512 POST_IO
39513RET(12)
39514}
39515
39516// ROR
39517OPCODE(0xE6E7)
39518{
39519 u32 adr, res;
39520 u32 src, dst;
39521
39522 adr = AREG(7) - 2;
39523 AREG(7) = adr;
39524 PRE_IO
39525 READ_WORD_F(adr, src)
39526 flag_V = 0;
39527 flag_C = src << M68K_SR_C_SFT;
39528 res = (src >> 1) | (src << 15);
39529 flag_N = res >> 8;
39530 flag_NotZ = res & 0x0000FFFF;
39531 WRITE_WORD_F(adr, res)
39532 POST_IO
39533RET(14)
39534}
39535
39536// ASL
39537OPCODE(0xE1D0)
39538{
39539 u32 adr, res;
39540 u32 src, dst;
39541
39542 adr = AREG((Opcode >> 0) & 7);
39543 PRE_IO
39544 READ_WORD_F(adr, src)
39545 flag_X = flag_C = src >> 7;
39546 res = src << 1;
39547 flag_V = (src ^ res) >> 8;
39548 flag_N = res >> 8;
39549 flag_NotZ = res & 0x0000FFFF;
39550 WRITE_WORD_F(adr, res)
39551 POST_IO
39552RET(12)
39553}
39554
39555// ASL
39556OPCODE(0xE1D8)
39557{
39558 u32 adr, res;
39559 u32 src, dst;
39560
39561 adr = AREG((Opcode >> 0) & 7);
39562 AREG((Opcode >> 0) & 7) += 2;
39563 PRE_IO
39564 READ_WORD_F(adr, src)
39565 flag_X = flag_C = src >> 7;
39566 res = src << 1;
39567 flag_V = (src ^ res) >> 8;
39568 flag_N = res >> 8;
39569 flag_NotZ = res & 0x0000FFFF;
39570 WRITE_WORD_F(adr, res)
39571 POST_IO
39572RET(12)
39573}
39574
39575// ASL
39576OPCODE(0xE1E0)
39577{
39578 u32 adr, res;
39579 u32 src, dst;
39580
39581 adr = AREG((Opcode >> 0) & 7) - 2;
39582 AREG((Opcode >> 0) & 7) = adr;
39583 PRE_IO
39584 READ_WORD_F(adr, src)
39585 flag_X = flag_C = src >> 7;
39586 res = src << 1;
39587 flag_V = (src ^ res) >> 8;
39588 flag_N = res >> 8;
39589 flag_NotZ = res & 0x0000FFFF;
39590 WRITE_WORD_F(adr, res)
39591 POST_IO
39592RET(14)
39593}
39594
39595// ASL
39596OPCODE(0xE1E8)
39597{
39598 u32 adr, res;
39599 u32 src, dst;
39600
39601 FETCH_SWORD(adr);
39602 adr += AREG((Opcode >> 0) & 7);
39603 PRE_IO
39604 READ_WORD_F(adr, src)
39605 flag_X = flag_C = src >> 7;
39606 res = src << 1;
39607 flag_V = (src ^ res) >> 8;
39608 flag_N = res >> 8;
39609 flag_NotZ = res & 0x0000FFFF;
39610 WRITE_WORD_F(adr, res)
39611 POST_IO
39612RET(16)
39613}
39614
39615// ASL
39616OPCODE(0xE1F0)
39617{
39618 u32 adr, res;
39619 u32 src, dst;
39620
39621 adr = AREG((Opcode >> 0) & 7);
39622 DECODE_EXT_WORD
39623 PRE_IO
39624 READ_WORD_F(adr, src)
39625 flag_X = flag_C = src >> 7;
39626 res = src << 1;
39627 flag_V = (src ^ res) >> 8;
39628 flag_N = res >> 8;
39629 flag_NotZ = res & 0x0000FFFF;
39630 WRITE_WORD_F(adr, res)
39631 POST_IO
39632RET(18)
39633}
39634
39635// ASL
39636OPCODE(0xE1F8)
39637{
39638 u32 adr, res;
39639 u32 src, dst;
39640
39641 FETCH_SWORD(adr);
39642 PRE_IO
39643 READ_WORD_F(adr, src)
39644 flag_X = flag_C = src >> 7;
39645 res = src << 1;
39646 flag_V = (src ^ res) >> 8;
39647 flag_N = res >> 8;
39648 flag_NotZ = res & 0x0000FFFF;
39649 WRITE_WORD_F(adr, res)
39650 POST_IO
39651RET(16)
39652}
39653
39654// ASL
39655OPCODE(0xE1F9)
39656{
39657 u32 adr, res;
39658 u32 src, dst;
39659
39660 FETCH_LONG(adr);
39661 PRE_IO
39662 READ_WORD_F(adr, src)
39663 flag_X = flag_C = src >> 7;
39664 res = src << 1;
39665 flag_V = (src ^ res) >> 8;
39666 flag_N = res >> 8;
39667 flag_NotZ = res & 0x0000FFFF;
39668 WRITE_WORD_F(adr, res)
39669 POST_IO
39670RET(20)
39671}
39672
39673// ASL
39674OPCODE(0xE1DF)
39675{
39676 u32 adr, res;
39677 u32 src, dst;
39678
39679 adr = AREG(7);
39680 AREG(7) += 2;
39681 PRE_IO
39682 READ_WORD_F(adr, src)
39683 flag_X = flag_C = src >> 7;
39684 res = src << 1;
39685 flag_V = (src ^ res) >> 8;
39686 flag_N = res >> 8;
39687 flag_NotZ = res & 0x0000FFFF;
39688 WRITE_WORD_F(adr, res)
39689 POST_IO
39690RET(12)
39691}
39692
39693// ASL
39694OPCODE(0xE1E7)
39695{
39696 u32 adr, res;
39697 u32 src, dst;
39698
39699 adr = AREG(7) - 2;
39700 AREG(7) = adr;
39701 PRE_IO
39702 READ_WORD_F(adr, src)
39703 flag_X = flag_C = src >> 7;
39704 res = src << 1;
39705 flag_V = (src ^ res) >> 8;
39706 flag_N = res >> 8;
39707 flag_NotZ = res & 0x0000FFFF;
39708 WRITE_WORD_F(adr, res)
39709 POST_IO
39710RET(14)
39711}
39712
39713// LSL
39714OPCODE(0xE3D0)
39715{
39716 u32 adr, res;
39717 u32 src, dst;
39718
39719 adr = AREG((Opcode >> 0) & 7);
39720 PRE_IO
39721 READ_WORD_F(adr, src)
39722 flag_V = 0;
39723 flag_X = flag_C = src >> 7;
39724 res = src << 1;
39725 flag_N = res >> 8;
39726 flag_NotZ = res & 0x0000FFFF;
39727 WRITE_WORD_F(adr, res)
39728 POST_IO
39729RET(12)
39730}
39731
39732// LSL
39733OPCODE(0xE3D8)
39734{
39735 u32 adr, res;
39736 u32 src, dst;
39737
39738 adr = AREG((Opcode >> 0) & 7);
39739 AREG((Opcode >> 0) & 7) += 2;
39740 PRE_IO
39741 READ_WORD_F(adr, src)
39742 flag_V = 0;
39743 flag_X = flag_C = src >> 7;
39744 res = src << 1;
39745 flag_N = res >> 8;
39746 flag_NotZ = res & 0x0000FFFF;
39747 WRITE_WORD_F(adr, res)
39748 POST_IO
39749RET(12)
39750}
39751
39752// LSL
39753OPCODE(0xE3E0)
39754{
39755 u32 adr, res;
39756 u32 src, dst;
39757
39758 adr = AREG((Opcode >> 0) & 7) - 2;
39759 AREG((Opcode >> 0) & 7) = adr;
39760 PRE_IO
39761 READ_WORD_F(adr, src)
39762 flag_V = 0;
39763 flag_X = flag_C = src >> 7;
39764 res = src << 1;
39765 flag_N = res >> 8;
39766 flag_NotZ = res & 0x0000FFFF;
39767 WRITE_WORD_F(adr, res)
39768 POST_IO
39769RET(14)
39770}
39771
39772// LSL
39773OPCODE(0xE3E8)
39774{
39775 u32 adr, res;
39776 u32 src, dst;
39777
39778 FETCH_SWORD(adr);
39779 adr += AREG((Opcode >> 0) & 7);
39780 PRE_IO
39781 READ_WORD_F(adr, src)
39782 flag_V = 0;
39783 flag_X = flag_C = src >> 7;
39784 res = src << 1;
39785 flag_N = res >> 8;
39786 flag_NotZ = res & 0x0000FFFF;
39787 WRITE_WORD_F(adr, res)
39788 POST_IO
39789RET(16)
39790}
39791
39792// LSL
39793OPCODE(0xE3F0)
39794{
39795 u32 adr, res;
39796 u32 src, dst;
39797
39798 adr = AREG((Opcode >> 0) & 7);
39799 DECODE_EXT_WORD
39800 PRE_IO
39801 READ_WORD_F(adr, src)
39802 flag_V = 0;
39803 flag_X = flag_C = src >> 7;
39804 res = src << 1;
39805 flag_N = res >> 8;
39806 flag_NotZ = res & 0x0000FFFF;
39807 WRITE_WORD_F(adr, res)
39808 POST_IO
39809RET(18)
39810}
39811
39812// LSL
39813OPCODE(0xE3F8)
39814{
39815 u32 adr, res;
39816 u32 src, dst;
39817
39818 FETCH_SWORD(adr);
39819 PRE_IO
39820 READ_WORD_F(adr, src)
39821 flag_V = 0;
39822 flag_X = flag_C = src >> 7;
39823 res = src << 1;
39824 flag_N = res >> 8;
39825 flag_NotZ = res & 0x0000FFFF;
39826 WRITE_WORD_F(adr, res)
39827 POST_IO
39828RET(16)
39829}
39830
39831// LSL
39832OPCODE(0xE3F9)
39833{
39834 u32 adr, res;
39835 u32 src, dst;
39836
39837 FETCH_LONG(adr);
39838 PRE_IO
39839 READ_WORD_F(adr, src)
39840 flag_V = 0;
39841 flag_X = flag_C = src >> 7;
39842 res = src << 1;
39843 flag_N = res >> 8;
39844 flag_NotZ = res & 0x0000FFFF;
39845 WRITE_WORD_F(adr, res)
39846 POST_IO
39847RET(20)
39848}
39849
39850// LSL
39851OPCODE(0xE3DF)
39852{
39853 u32 adr, res;
39854 u32 src, dst;
39855
39856 adr = AREG(7);
39857 AREG(7) += 2;
39858 PRE_IO
39859 READ_WORD_F(adr, src)
39860 flag_V = 0;
39861 flag_X = flag_C = src >> 7;
39862 res = src << 1;
39863 flag_N = res >> 8;
39864 flag_NotZ = res & 0x0000FFFF;
39865 WRITE_WORD_F(adr, res)
39866 POST_IO
39867RET(12)
39868}
39869
39870// LSL
39871OPCODE(0xE3E7)
39872{
39873 u32 adr, res;
39874 u32 src, dst;
39875
39876 adr = AREG(7) - 2;
39877 AREG(7) = adr;
39878 PRE_IO
39879 READ_WORD_F(adr, src)
39880 flag_V = 0;
39881 flag_X = flag_C = src >> 7;
39882 res = src << 1;
39883 flag_N = res >> 8;
39884 flag_NotZ = res & 0x0000FFFF;
39885 WRITE_WORD_F(adr, res)
39886 POST_IO
39887RET(14)
39888}
39889
39890// ROXL
39891OPCODE(0xE5D0)
39892{
39893 u32 adr, res;
39894 u32 src, dst;
39895
39896 adr = AREG((Opcode >> 0) & 7);
39897 PRE_IO
39898 READ_WORD_F(adr, src)
39899 flag_V = 0;
39900 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39901 flag_X = flag_C = src >> 7;
39902 flag_N = res >> 8;
39903 flag_NotZ = res & 0x0000FFFF;
39904 WRITE_WORD_F(adr, res)
39905 POST_IO
39906RET(12)
39907}
39908
39909// ROXL
39910OPCODE(0xE5D8)
39911{
39912 u32 adr, res;
39913 u32 src, dst;
39914
39915 adr = AREG((Opcode >> 0) & 7);
39916 AREG((Opcode >> 0) & 7) += 2;
39917 PRE_IO
39918 READ_WORD_F(adr, src)
39919 flag_V = 0;
39920 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39921 flag_X = flag_C = src >> 7;
39922 flag_N = res >> 8;
39923 flag_NotZ = res & 0x0000FFFF;
39924 WRITE_WORD_F(adr, res)
39925 POST_IO
39926RET(12)
39927}
39928
39929// ROXL
39930OPCODE(0xE5E0)
39931{
39932 u32 adr, res;
39933 u32 src, dst;
39934
39935 adr = AREG((Opcode >> 0) & 7) - 2;
39936 AREG((Opcode >> 0) & 7) = adr;
39937 PRE_IO
39938 READ_WORD_F(adr, src)
39939 flag_V = 0;
39940 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39941 flag_X = flag_C = src >> 7;
39942 flag_N = res >> 8;
39943 flag_NotZ = res & 0x0000FFFF;
39944 WRITE_WORD_F(adr, res)
39945 POST_IO
39946RET(14)
39947}
39948
39949// ROXL
39950OPCODE(0xE5E8)
39951{
39952 u32 adr, res;
39953 u32 src, dst;
39954
39955 FETCH_SWORD(adr);
39956 adr += AREG((Opcode >> 0) & 7);
39957 PRE_IO
39958 READ_WORD_F(adr, src)
39959 flag_V = 0;
39960 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39961 flag_X = flag_C = src >> 7;
39962 flag_N = res >> 8;
39963 flag_NotZ = res & 0x0000FFFF;
39964 WRITE_WORD_F(adr, res)
39965 POST_IO
39966RET(16)
39967}
39968
39969// ROXL
39970OPCODE(0xE5F0)
39971{
39972 u32 adr, res;
39973 u32 src, dst;
39974
39975 adr = AREG((Opcode >> 0) & 7);
39976 DECODE_EXT_WORD
39977 PRE_IO
39978 READ_WORD_F(adr, src)
39979 flag_V = 0;
39980 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39981 flag_X = flag_C = src >> 7;
39982 flag_N = res >> 8;
39983 flag_NotZ = res & 0x0000FFFF;
39984 WRITE_WORD_F(adr, res)
39985 POST_IO
39986RET(18)
39987}
39988
39989// ROXL
39990OPCODE(0xE5F8)
39991{
39992 u32 adr, res;
39993 u32 src, dst;
39994
39995 FETCH_SWORD(adr);
39996 PRE_IO
39997 READ_WORD_F(adr, src)
39998 flag_V = 0;
39999 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
40000 flag_X = flag_C = src >> 7;
40001 flag_N = res >> 8;
40002 flag_NotZ = res & 0x0000FFFF;
40003 WRITE_WORD_F(adr, res)
40004 POST_IO
40005RET(16)
40006}
40007
40008// ROXL
40009OPCODE(0xE5F9)
40010{
40011 u32 adr, res;
40012 u32 src, dst;
40013
40014 FETCH_LONG(adr);
40015 PRE_IO
40016 READ_WORD_F(adr, src)
40017 flag_V = 0;
40018 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
40019 flag_X = flag_C = src >> 7;
40020 flag_N = res >> 8;
40021 flag_NotZ = res & 0x0000FFFF;
40022 WRITE_WORD_F(adr, res)
40023 POST_IO
40024RET(20)
40025}
40026
40027// ROXL
40028OPCODE(0xE5DF)
40029{
40030 u32 adr, res;
40031 u32 src, dst;
40032
40033 adr = AREG(7);
40034 AREG(7) += 2;
40035 PRE_IO
40036 READ_WORD_F(adr, src)
40037 flag_V = 0;
40038 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
40039 flag_X = flag_C = src >> 7;
40040 flag_N = res >> 8;
40041 flag_NotZ = res & 0x0000FFFF;
40042 WRITE_WORD_F(adr, res)
40043 POST_IO
40044RET(12)
40045}
40046
40047// ROXL
40048OPCODE(0xE5E7)
40049{
40050 u32 adr, res;
40051 u32 src, dst;
40052
40053 adr = AREG(7) - 2;
40054 AREG(7) = adr;
40055 PRE_IO
40056 READ_WORD_F(adr, src)
40057 flag_V = 0;
40058 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
40059 flag_X = flag_C = src >> 7;
40060 flag_N = res >> 8;
40061 flag_NotZ = res & 0x0000FFFF;
40062 WRITE_WORD_F(adr, res)
40063 POST_IO
40064RET(14)
40065}
40066
40067// ROL
40068OPCODE(0xE7D0)
40069{
40070 u32 adr, res;
40071 u32 src, dst;
40072
40073 adr = AREG((Opcode >> 0) & 7);
40074 PRE_IO
40075 READ_WORD_F(adr, src)
40076 flag_V = 0;
40077 flag_C = src >> 7;
40078 res = (src << 1) | (src >> 15);
40079 flag_N = res >> 8;
40080 flag_NotZ = res & 0x0000FFFF;
40081 WRITE_WORD_F(adr, res)
40082 POST_IO
40083RET(12)
40084}
40085
40086// ROL
40087OPCODE(0xE7D8)
40088{
40089 u32 adr, res;
40090 u32 src, dst;
40091
40092 adr = AREG((Opcode >> 0) & 7);
40093 AREG((Opcode >> 0) & 7) += 2;
40094 PRE_IO
40095 READ_WORD_F(adr, src)
40096 flag_V = 0;
40097 flag_C = src >> 7;
40098 res = (src << 1) | (src >> 15);
40099 flag_N = res >> 8;
40100 flag_NotZ = res & 0x0000FFFF;
40101 WRITE_WORD_F(adr, res)
40102 POST_IO
40103RET(12)
40104}
40105
40106// ROL
40107OPCODE(0xE7E0)
40108{
40109 u32 adr, res;
40110 u32 src, dst;
40111
40112 adr = AREG((Opcode >> 0) & 7) - 2;
40113 AREG((Opcode >> 0) & 7) = adr;
40114 PRE_IO
40115 READ_WORD_F(adr, src)
40116 flag_V = 0;
40117 flag_C = src >> 7;
40118 res = (src << 1) | (src >> 15);
40119 flag_N = res >> 8;
40120 flag_NotZ = res & 0x0000FFFF;
40121 WRITE_WORD_F(adr, res)
40122 POST_IO
40123RET(14)
40124}
40125
40126// ROL
40127OPCODE(0xE7E8)
40128{
40129 u32 adr, res;
40130 u32 src, dst;
40131
40132 FETCH_SWORD(adr);
40133 adr += AREG((Opcode >> 0) & 7);
40134 PRE_IO
40135 READ_WORD_F(adr, src)
40136 flag_V = 0;
40137 flag_C = src >> 7;
40138 res = (src << 1) | (src >> 15);
40139 flag_N = res >> 8;
40140 flag_NotZ = res & 0x0000FFFF;
40141 WRITE_WORD_F(adr, res)
40142 POST_IO
40143RET(16)
40144}
40145
40146// ROL
40147OPCODE(0xE7F0)
40148{
40149 u32 adr, res;
40150 u32 src, dst;
40151
40152 adr = AREG((Opcode >> 0) & 7);
40153 DECODE_EXT_WORD
40154 PRE_IO
40155 READ_WORD_F(adr, src)
40156 flag_V = 0;
40157 flag_C = src >> 7;
40158 res = (src << 1) | (src >> 15);
40159 flag_N = res >> 8;
40160 flag_NotZ = res & 0x0000FFFF;
40161 WRITE_WORD_F(adr, res)
40162 POST_IO
40163RET(18)
40164}
40165
40166// ROL
40167OPCODE(0xE7F8)
40168{
40169 u32 adr, res;
40170 u32 src, dst;
40171
40172 FETCH_SWORD(adr);
40173 PRE_IO
40174 READ_WORD_F(adr, src)
40175 flag_V = 0;
40176 flag_C = src >> 7;
40177 res = (src << 1) | (src >> 15);
40178 flag_N = res >> 8;
40179 flag_NotZ = res & 0x0000FFFF;
40180 WRITE_WORD_F(adr, res)
40181 POST_IO
40182RET(16)
40183}
40184
40185// ROL
40186OPCODE(0xE7F9)
40187{
40188 u32 adr, res;
40189 u32 src, dst;
40190
40191 FETCH_LONG(adr);
40192 PRE_IO
40193 READ_WORD_F(adr, src)
40194 flag_V = 0;
40195 flag_C = src >> 7;
40196 res = (src << 1) | (src >> 15);
40197 flag_N = res >> 8;
40198 flag_NotZ = res & 0x0000FFFF;
40199 WRITE_WORD_F(adr, res)
40200 POST_IO
40201RET(20)
40202}
40203
40204// ROL
40205OPCODE(0xE7DF)
40206{
40207 u32 adr, res;
40208 u32 src, dst;
40209
40210 adr = AREG(7);
40211 AREG(7) += 2;
40212 PRE_IO
40213 READ_WORD_F(adr, src)
40214 flag_V = 0;
40215 flag_C = src >> 7;
40216 res = (src << 1) | (src >> 15);
40217 flag_N = res >> 8;
40218 flag_NotZ = res & 0x0000FFFF;
40219 WRITE_WORD_F(adr, res)
40220 POST_IO
40221RET(12)
40222}
40223
40224// ROL
40225OPCODE(0xE7E7)
40226{
40227 u32 adr, res;
40228 u32 src, dst;
40229
40230 adr = AREG(7) - 2;
40231 AREG(7) = adr;
40232 PRE_IO
40233 READ_WORD_F(adr, src)
40234 flag_V = 0;
40235 flag_C = src >> 7;
40236 res = (src << 1) | (src >> 15);
40237 flag_N = res >> 8;
40238 flag_NotZ = res & 0x0000FFFF;
40239 WRITE_WORD_F(adr, res)
40240 POST_IO
40241RET(14)
40242}
40243
40244#ifdef PICODRIVE_HACK
40245#if 0
40246#define UPDATE_IDLE_COUNT { \
40247 extern int idle_hit_counter; \
40248 idle_hit_counter++; \
40249}
40250#else
40251#define UPDATE_IDLE_COUNT
40252#endif
40253
40254// BRA
40255OPCODE(0x6001_idle)
40256{
40257#ifdef FAMEC_CHECK_BRANCHES
40258 u32 newPC = GET_PC;
40259 s8 offs=Opcode;
40260 newPC += offs;
40261 SET_PC(newPC);
40262 CHECK_BRANCH_EXCEPTION(offs)
40263#else
40264 PC += ((s8)(Opcode & 0xFE)) >> 1;
40265#endif
40266 UPDATE_IDLE_COUNT
40267RET0()
40268}
40269
40270// BCC
40271OPCODE(0x6601_idle)
40272{
40273 if (flag_NotZ)
40274 {
40275 UPDATE_IDLE_COUNT
40276 PC += ((s8)(Opcode & 0xFE)) >> 1;
40277 //if (idle_hit)
40278 RET0()
40279 }
40280RET(8)
40281}
40282
40283OPCODE(0x6701_idle)
40284{
40285 if (!flag_NotZ)
40286 {
40287 UPDATE_IDLE_COUNT
40288 PC += ((s8)(Opcode & 0xFE)) >> 1;
40289 //if (idle_hit)
40290 RET0()
40291 }
40292RET(8)
40293}
40294
40295
40296extern int SekIsIdleReady(void);
40297extern int SekIsIdleCode(unsigned short *dst, int bytes);
40298extern int SekRegisterIdlePatch(unsigned int pc, int oldop, int newop, void *ctx);
40299
40300OPCODE(idle_detector_bcc8)
40301{
40302 int frame_count, cond_true, bytes, ret, newop;
40303 u16 *dest_pc;
40304
40305 dest_pc = PC + (((s8)(Opcode & 0xFE)) >> 1);
40306
40307 if (!SekIsIdleReady())
40308 goto end;
40309
40310 bytes = 0 - (s8)(Opcode & 0xFE) - 2;
40311 ret = SekIsIdleCode(dest_pc, bytes);
40312 newop = (Opcode & 0xfe) | 0x7100;
40313 if (!ret) newop |= 0x200;
40314 if ( Opcode & 0x0100) newop |= 0x400; // beq
40315 if (!(Opcode & 0x0f00)) newop |= 0xc00; // bra
40316
40317 ret = SekRegisterIdlePatch(GET_PC - 2, Opcode, newop, ctx);
40318 switch (ret)
40319 {
40320 case 0: PC[-1] = newop; break;
40321 case 1: break;
40322 case 2: JumpTable[Opcode] = (Opcode & 0x0f00) ?
40323 ((Opcode & 0x0100) ? CAST_OP(0x6701) : CAST_OP(0x6601)) :
40324 CAST_OP(0x6001); break;
40325 }
40326
40327end:
40328 if ((Opcode & 0xff00) == 0x6000) cond_true = 1;
40329 else cond_true = (Opcode & 0x0100) ? !flag_NotZ : flag_NotZ; // beq?
40330 if (cond_true)
40331 {
40332 PC = dest_pc;
40333 ctx->io_cycle_counter -= 2;
40334 }
40335RET(8)
40336}
40337
40338#endif // PICODRIVE_HACK
fast MegaDrive/MegaCD/32X emulator