notaz.gp2x.de / picodrive.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
68k cores: fix bcd instructions
[picodrive.git] / cpu / fame / famec_opcodes.h
CommitLineData
70357ce5 1
ecc8036e 2#ifdef PICODRIVE_HACK
3#define NOT_POLLING g_m68kcontext->not_polling = 1;
4#else
5#define NOT_POLLING
6#endif
7
70357ce5 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 {
d0ae0cb4 647 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 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;
1077#ifdef USE_CYCLONE_TIMING
1078RET(14)
1079#else
1080RET(16)
1081#endif
1082}
1083
1084// ANDI
1085OPCODE(0x0290)
1086{
1087 u32 adr, res;
1088 u32 src, dst;
1089
1090 FETCH_LONG(src);
1091 adr = AREG((Opcode >> 0) & 7);
1092 PRE_IO
1093 READ_LONG_F(adr, res)
1094 res &= src;
1095 flag_C = 0;
1096 flag_V = 0;
1097 flag_NotZ = res;
1098 flag_N = res >> 24;
1099 WRITE_LONG_F(adr, res)
1100 POST_IO
1101RET(28)
1102}
1103
1104// ANDI
1105OPCODE(0x0298)
1106{
1107 u32 adr, res;
1108 u32 src, dst;
1109
1110 FETCH_LONG(src);
1111 adr = AREG((Opcode >> 0) & 7);
1112 AREG((Opcode >> 0) & 7) += 4;
1113 PRE_IO
1114 READ_LONG_F(adr, res)
1115 res &= src;
1116 flag_C = 0;
1117 flag_V = 0;
1118 flag_NotZ = res;
1119 flag_N = res >> 24;
1120 WRITE_LONG_F(adr, res)
1121 POST_IO
1122RET(28)
1123}
1124
1125// ANDI
1126OPCODE(0x02A0)
1127{
1128 u32 adr, res;
1129 u32 src, dst;
1130
1131 FETCH_LONG(src);
1132 adr = AREG((Opcode >> 0) & 7) - 4;
1133 AREG((Opcode >> 0) & 7) = adr;
1134 PRE_IO
1135 READ_LONG_F(adr, res)
1136 res &= src;
1137 flag_C = 0;
1138 flag_V = 0;
1139 flag_NotZ = res;
1140 flag_N = res >> 24;
1141 WRITE_LONG_F(adr, res)
1142 POST_IO
1143RET(30)
1144}
1145
1146// ANDI
1147OPCODE(0x02A8)
1148{
1149 u32 adr, res;
1150 u32 src, dst;
1151
1152 FETCH_LONG(src);
1153 FETCH_SWORD(adr);
1154 adr += AREG((Opcode >> 0) & 7);
1155 PRE_IO
1156 READ_LONG_F(adr, res)
1157 res &= src;
1158 flag_C = 0;
1159 flag_V = 0;
1160 flag_NotZ = res;
1161 flag_N = res >> 24;
1162 WRITE_LONG_F(adr, res)
1163 POST_IO
1164RET(32)
1165}
1166
1167// ANDI
1168OPCODE(0x02B0)
1169{
1170 u32 adr, res;
1171 u32 src, dst;
1172
1173 FETCH_LONG(src);
1174 adr = AREG((Opcode >> 0) & 7);
1175 DECODE_EXT_WORD
1176 PRE_IO
1177 READ_LONG_F(adr, res)
1178 res &= src;
1179 flag_C = 0;
1180 flag_V = 0;
1181 flag_NotZ = res;
1182 flag_N = res >> 24;
1183 WRITE_LONG_F(adr, res)
1184 POST_IO
1185RET(34)
1186}
1187
1188// ANDI
1189OPCODE(0x02B8)
1190{
1191 u32 adr, res;
1192 u32 src, dst;
1193
1194 FETCH_LONG(src);
1195 FETCH_SWORD(adr);
1196 PRE_IO
1197 READ_LONG_F(adr, res)
1198 res &= src;
1199 flag_C = 0;
1200 flag_V = 0;
1201 flag_NotZ = res;
1202 flag_N = res >> 24;
1203 WRITE_LONG_F(adr, res)
1204 POST_IO
1205RET(32)
1206}
1207
1208// ANDI
1209OPCODE(0x02B9)
1210{
1211 u32 adr, res;
1212 u32 src, dst;
1213
1214 FETCH_LONG(src);
1215 FETCH_LONG(adr);
1216 PRE_IO
1217 READ_LONG_F(adr, res)
1218 res &= src;
1219 flag_C = 0;
1220 flag_V = 0;
1221 flag_NotZ = res;
1222 flag_N = res >> 24;
1223 WRITE_LONG_F(adr, res)
1224 POST_IO
1225RET(36)
1226}
1227
1228// ANDI
1229OPCODE(0x029F)
1230{
1231 u32 adr, res;
1232 u32 src, dst;
1233
1234 FETCH_LONG(src);
1235 adr = AREG(7);
1236 AREG(7) += 4;
1237 PRE_IO
1238 READ_LONG_F(adr, res)
1239 res &= src;
1240 flag_C = 0;
1241 flag_V = 0;
1242 flag_NotZ = res;
1243 flag_N = res >> 24;
1244 WRITE_LONG_F(adr, res)
1245 POST_IO
1246RET(28)
1247}
1248
1249// ANDI
1250OPCODE(0x02A7)
1251{
1252 u32 adr, res;
1253 u32 src, dst;
1254
1255 FETCH_LONG(src);
1256 adr = AREG(7) - 4;
1257 AREG(7) = adr;
1258 PRE_IO
1259 READ_LONG_F(adr, res)
1260 res &= src;
1261 flag_C = 0;
1262 flag_V = 0;
1263 flag_NotZ = res;
1264 flag_N = res >> 24;
1265 WRITE_LONG_F(adr, res)
1266 POST_IO
1267RET(30)
1268}
1269
1270// ANDICCR
1271OPCODE(0x023C)
1272{
1273 u32 adr, res;
1274 u32 src, dst;
1275
1276 FETCH_BYTE(res);
1277 res &= M68K_CCR_MASK;
1278 res &= GET_CCR;
1279 SET_CCR(res)
1280RET(20)
1281}
1282
1283// ANDISR
1284OPCODE(0x027C)
1285{
1286 u32 adr, res;
1287 u32 src, dst;
1288
1289 if (flag_S)
1290 {
1291 FETCH_WORD(res);
1292 res &= M68K_SR_MASK;
1293 res &= GET_SR;
1294 SET_SR(res)
1295 if (!flag_S)
1296 {
1297 res = AREG(7);
1298 AREG(7) = ASP;
1299 ASP = res;
1300 }
1301 CHECK_INT_TO_JUMP(20)
1302 }
1303 else
1304 {
d0ae0cb4 1305 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 1306 RET(4)
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 {
d0ae0cb4 1955 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
03e4f2a3 1956 RET(0)
70357ce5 1957 }
1958RET(20)
1959}
1960
1961// SUBI
1962OPCODE(0x0400)
1963{
1964 u32 adr, res;
1965 u32 src, dst;
1966
1967 FETCH_BYTE(src);
1968 dst = DREGu8((Opcode >> 0) & 7);
1969 res = dst - src;
1970 flag_N = flag_X = flag_C = res;
1971 flag_V = (src ^ dst) & (res ^ dst);
1972 flag_NotZ = res & 0xFF;
1973 DREGu8((Opcode >> 0) & 7) = res;
1974RET(8)
1975}
1976
1977// SUBI
1978OPCODE(0x0410)
1979{
1980 u32 adr, res;
1981 u32 src, dst;
1982
1983 FETCH_BYTE(src);
1984 adr = AREG((Opcode >> 0) & 7);
1985 PRE_IO
1986 READ_BYTE_F(adr, dst)
1987 res = dst - src;
1988 flag_N = flag_X = flag_C = res;
1989 flag_V = (src ^ dst) & (res ^ dst);
1990 flag_NotZ = res & 0xFF;
1991 WRITE_BYTE_F(adr, res)
1992 POST_IO
1993RET(16)
1994}
1995
1996// SUBI
1997OPCODE(0x0418)
1998{
1999 u32 adr, res;
2000 u32 src, dst;
2001
2002 FETCH_BYTE(src);
2003 adr = AREG((Opcode >> 0) & 7);
2004 AREG((Opcode >> 0) & 7) += 1;
2005 PRE_IO
2006 READ_BYTE_F(adr, dst)
2007 res = dst - src;
2008 flag_N = flag_X = flag_C = res;
2009 flag_V = (src ^ dst) & (res ^ dst);
2010 flag_NotZ = res & 0xFF;
2011 WRITE_BYTE_F(adr, res)
2012 POST_IO
2013RET(16)
2014}
2015
2016// SUBI
2017OPCODE(0x0420)
2018{
2019 u32 adr, res;
2020 u32 src, dst;
2021
2022 FETCH_BYTE(src);
2023 adr = AREG((Opcode >> 0) & 7) - 1;
2024 AREG((Opcode >> 0) & 7) = adr;
2025 PRE_IO
2026 READ_BYTE_F(adr, dst)
2027 res = dst - src;
2028 flag_N = flag_X = flag_C = res;
2029 flag_V = (src ^ dst) & (res ^ dst);
2030 flag_NotZ = res & 0xFF;
2031 WRITE_BYTE_F(adr, res)
2032 POST_IO
2033RET(18)
2034}
2035
2036// SUBI
2037OPCODE(0x0428)
2038{
2039 u32 adr, res;
2040 u32 src, dst;
2041
2042 FETCH_BYTE(src);
2043 FETCH_SWORD(adr);
2044 adr += AREG((Opcode >> 0) & 7);
2045 PRE_IO
2046 READ_BYTE_F(adr, dst)
2047 res = dst - src;
2048 flag_N = flag_X = flag_C = res;
2049 flag_V = (src ^ dst) & (res ^ dst);
2050 flag_NotZ = res & 0xFF;
2051 WRITE_BYTE_F(adr, res)
2052 POST_IO
2053RET(20)
2054}
2055
2056// SUBI
2057OPCODE(0x0430)
2058{
2059 u32 adr, res;
2060 u32 src, dst;
2061
2062 FETCH_BYTE(src);
2063 adr = AREG((Opcode >> 0) & 7);
2064 DECODE_EXT_WORD
2065 PRE_IO
2066 READ_BYTE_F(adr, dst)
2067 res = dst - src;
2068 flag_N = flag_X = flag_C = res;
2069 flag_V = (src ^ dst) & (res ^ dst);
2070 flag_NotZ = res & 0xFF;
2071 WRITE_BYTE_F(adr, res)
2072 POST_IO
2073RET(22)
2074}
2075
2076// SUBI
2077OPCODE(0x0438)
2078{
2079 u32 adr, res;
2080 u32 src, dst;
2081
2082 FETCH_BYTE(src);
2083 FETCH_SWORD(adr);
2084 PRE_IO
2085 READ_BYTE_F(adr, dst)
2086 res = dst - src;
2087 flag_N = flag_X = flag_C = res;
2088 flag_V = (src ^ dst) & (res ^ dst);
2089 flag_NotZ = res & 0xFF;
2090 WRITE_BYTE_F(adr, res)
2091 POST_IO
2092RET(20)
2093}
2094
2095// SUBI
2096OPCODE(0x0439)
2097{
2098 u32 adr, res;
2099 u32 src, dst;
2100
2101 FETCH_BYTE(src);
2102 FETCH_LONG(adr);
2103 PRE_IO
2104 READ_BYTE_F(adr, dst)
2105 res = dst - src;
2106 flag_N = flag_X = flag_C = res;
2107 flag_V = (src ^ dst) & (res ^ dst);
2108 flag_NotZ = res & 0xFF;
2109 WRITE_BYTE_F(adr, res)
2110 POST_IO
2111RET(24)
2112}
2113
2114// SUBI
2115OPCODE(0x041F)
2116{
2117 u32 adr, res;
2118 u32 src, dst;
2119
2120 FETCH_BYTE(src);
2121 adr = AREG(7);
2122 AREG(7) += 2;
2123 PRE_IO
2124 READ_BYTE_F(adr, dst)
2125 res = dst - src;
2126 flag_N = flag_X = flag_C = res;
2127 flag_V = (src ^ dst) & (res ^ dst);
2128 flag_NotZ = res & 0xFF;
2129 WRITE_BYTE_F(adr, res)
2130 POST_IO
2131RET(16)
2132}
2133
2134// SUBI
2135OPCODE(0x0427)
2136{
2137 u32 adr, res;
2138 u32 src, dst;
2139
2140 FETCH_BYTE(src);
2141 adr = AREG(7) - 2;
2142 AREG(7) = adr;
2143 PRE_IO
2144 READ_BYTE_F(adr, dst)
2145 res = dst - src;
2146 flag_N = flag_X = flag_C = res;
2147 flag_V = (src ^ dst) & (res ^ dst);
2148 flag_NotZ = res & 0xFF;
2149 WRITE_BYTE_F(adr, res)
2150 POST_IO
2151RET(18)
2152}
2153
2154// SUBI
2155OPCODE(0x0440)
2156{
2157 u32 adr, res;
2158 u32 src, dst;
2159
2160 FETCH_WORD(src);
2161 dst = DREGu16((Opcode >> 0) & 7);
2162 res = dst - src;
2163 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2164 flag_N = flag_X = flag_C = res >> 8;
2165 flag_NotZ = res & 0xFFFF;
2166 DREGu16((Opcode >> 0) & 7) = res;
2167RET(8)
2168}
2169
2170// SUBI
2171OPCODE(0x0450)
2172{
2173 u32 adr, res;
2174 u32 src, dst;
2175
2176 FETCH_WORD(src);
2177 adr = AREG((Opcode >> 0) & 7);
2178 PRE_IO
2179 READ_WORD_F(adr, dst)
2180 res = dst - src;
2181 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2182 flag_N = flag_X = flag_C = res >> 8;
2183 flag_NotZ = res & 0xFFFF;
2184 WRITE_WORD_F(adr, res)
2185 POST_IO
2186RET(16)
2187}
2188
2189// SUBI
2190OPCODE(0x0458)
2191{
2192 u32 adr, res;
2193 u32 src, dst;
2194
2195 FETCH_WORD(src);
2196 adr = AREG((Opcode >> 0) & 7);
2197 AREG((Opcode >> 0) & 7) += 2;
2198 PRE_IO
2199 READ_WORD_F(adr, dst)
2200 res = dst - src;
2201 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2202 flag_N = flag_X = flag_C = res >> 8;
2203 flag_NotZ = res & 0xFFFF;
2204 WRITE_WORD_F(adr, res)
2205 POST_IO
2206RET(16)
2207}
2208
2209// SUBI
2210OPCODE(0x0460)
2211{
2212 u32 adr, res;
2213 u32 src, dst;
2214
2215 FETCH_WORD(src);
2216 adr = AREG((Opcode >> 0) & 7) - 2;
2217 AREG((Opcode >> 0) & 7) = adr;
2218 PRE_IO
2219 READ_WORD_F(adr, dst)
2220 res = dst - src;
2221 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2222 flag_N = flag_X = flag_C = res >> 8;
2223 flag_NotZ = res & 0xFFFF;
2224 WRITE_WORD_F(adr, res)
2225 POST_IO
2226RET(18)
2227}
2228
2229// SUBI
2230OPCODE(0x0468)
2231{
2232 u32 adr, res;
2233 u32 src, dst;
2234
2235 FETCH_WORD(src);
2236 FETCH_SWORD(adr);
2237 adr += AREG((Opcode >> 0) & 7);
2238 PRE_IO
2239 READ_WORD_F(adr, dst)
2240 res = dst - src;
2241 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2242 flag_N = flag_X = flag_C = res >> 8;
2243 flag_NotZ = res & 0xFFFF;
2244 WRITE_WORD_F(adr, res)
2245 POST_IO
2246RET(20)
2247}
2248
2249// SUBI
2250OPCODE(0x0470)
2251{
2252 u32 adr, res;
2253 u32 src, dst;
2254
2255 FETCH_WORD(src);
2256 adr = AREG((Opcode >> 0) & 7);
2257 DECODE_EXT_WORD
2258 PRE_IO
2259 READ_WORD_F(adr, dst)
2260 res = dst - src;
2261 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2262 flag_N = flag_X = flag_C = res >> 8;
2263 flag_NotZ = res & 0xFFFF;
2264 WRITE_WORD_F(adr, res)
2265 POST_IO
2266RET(22)
2267}
2268
2269// SUBI
2270OPCODE(0x0478)
2271{
2272 u32 adr, res;
2273 u32 src, dst;
2274
2275 FETCH_WORD(src);
2276 FETCH_SWORD(adr);
2277 PRE_IO
2278 READ_WORD_F(adr, dst)
2279 res = dst - src;
2280 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2281 flag_N = flag_X = flag_C = res >> 8;
2282 flag_NotZ = res & 0xFFFF;
2283 WRITE_WORD_F(adr, res)
2284 POST_IO
2285RET(20)
2286}
2287
2288// SUBI
2289OPCODE(0x0479)
2290{
2291 u32 adr, res;
2292 u32 src, dst;
2293
2294 FETCH_WORD(src);
2295 FETCH_LONG(adr);
2296 PRE_IO
2297 READ_WORD_F(adr, dst)
2298 res = dst - src;
2299 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2300 flag_N = flag_X = flag_C = res >> 8;
2301 flag_NotZ = res & 0xFFFF;
2302 WRITE_WORD_F(adr, res)
2303 POST_IO
2304RET(24)
2305}
2306
2307// SUBI
2308OPCODE(0x045F)
2309{
2310 u32 adr, res;
2311 u32 src, dst;
2312
2313 FETCH_WORD(src);
2314 adr = AREG(7);
2315 AREG(7) += 2;
2316 PRE_IO
2317 READ_WORD_F(adr, dst)
2318 res = dst - src;
2319 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2320 flag_N = flag_X = flag_C = res >> 8;
2321 flag_NotZ = res & 0xFFFF;
2322 WRITE_WORD_F(adr, res)
2323 POST_IO
2324RET(16)
2325}
2326
2327// SUBI
2328OPCODE(0x0467)
2329{
2330 u32 adr, res;
2331 u32 src, dst;
2332
2333 FETCH_WORD(src);
2334 adr = AREG(7) - 2;
2335 AREG(7) = adr;
2336 PRE_IO
2337 READ_WORD_F(adr, dst)
2338 res = dst - src;
2339 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
2340 flag_N = flag_X = flag_C = res >> 8;
2341 flag_NotZ = res & 0xFFFF;
2342 WRITE_WORD_F(adr, res)
2343 POST_IO
2344RET(18)
2345}
2346
2347// SUBI
2348OPCODE(0x0480)
2349{
2350 u32 adr, res;
2351 u32 src, dst;
2352
2353 FETCH_LONG(src);
2354 dst = DREGu32((Opcode >> 0) & 7);
2355 res = dst - src;
2356 flag_NotZ = res;
2357 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2358 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2359 flag_N = res >> 24;
2360 DREGu32((Opcode >> 0) & 7) = res;
2361RET(16)
2362}
2363
2364// SUBI
2365OPCODE(0x0490)
2366{
2367 u32 adr, res;
2368 u32 src, dst;
2369
2370 FETCH_LONG(src);
2371 adr = AREG((Opcode >> 0) & 7);
2372 PRE_IO
2373 READ_LONG_F(adr, dst)
2374 res = dst - src;
2375 flag_NotZ = res;
2376 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2377 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2378 flag_N = res >> 24;
2379 WRITE_LONG_F(adr, res)
2380 POST_IO
2381RET(28)
2382}
2383
2384// SUBI
2385OPCODE(0x0498)
2386{
2387 u32 adr, res;
2388 u32 src, dst;
2389
2390 FETCH_LONG(src);
2391 adr = AREG((Opcode >> 0) & 7);
2392 AREG((Opcode >> 0) & 7) += 4;
2393 PRE_IO
2394 READ_LONG_F(adr, dst)
2395 res = dst - src;
2396 flag_NotZ = res;
2397 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2398 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2399 flag_N = res >> 24;
2400 WRITE_LONG_F(adr, res)
2401 POST_IO
2402RET(28)
2403}
2404
2405// SUBI
2406OPCODE(0x04A0)
2407{
2408 u32 adr, res;
2409 u32 src, dst;
2410
2411 FETCH_LONG(src);
2412 adr = AREG((Opcode >> 0) & 7) - 4;
2413 AREG((Opcode >> 0) & 7) = adr;
2414 PRE_IO
2415 READ_LONG_F(adr, dst)
2416 res = dst - src;
2417 flag_NotZ = res;
2418 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2419 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2420 flag_N = res >> 24;
2421 WRITE_LONG_F(adr, res)
2422 POST_IO
2423RET(30)
2424}
2425
2426// SUBI
2427OPCODE(0x04A8)
2428{
2429 u32 adr, res;
2430 u32 src, dst;
2431
2432 FETCH_LONG(src);
2433 FETCH_SWORD(adr);
2434 adr += AREG((Opcode >> 0) & 7);
2435 PRE_IO
2436 READ_LONG_F(adr, dst)
2437 res = dst - src;
2438 flag_NotZ = res;
2439 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2440 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2441 flag_N = res >> 24;
2442 WRITE_LONG_F(adr, res)
2443 POST_IO
2444RET(32)
2445}
2446
2447// SUBI
2448OPCODE(0x04B0)
2449{
2450 u32 adr, res;
2451 u32 src, dst;
2452
2453 FETCH_LONG(src);
2454 adr = AREG((Opcode >> 0) & 7);
2455 DECODE_EXT_WORD
2456 PRE_IO
2457 READ_LONG_F(adr, dst)
2458 res = dst - src;
2459 flag_NotZ = res;
2460 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2461 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2462 flag_N = res >> 24;
2463 WRITE_LONG_F(adr, res)
2464 POST_IO
2465RET(34)
2466}
2467
2468// SUBI
2469OPCODE(0x04B8)
2470{
2471 u32 adr, res;
2472 u32 src, dst;
2473
2474 FETCH_LONG(src);
2475 FETCH_SWORD(adr);
2476 PRE_IO
2477 READ_LONG_F(adr, dst)
2478 res = dst - src;
2479 flag_NotZ = res;
2480 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2481 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2482 flag_N = res >> 24;
2483 WRITE_LONG_F(adr, res)
2484 POST_IO
2485RET(32)
2486}
2487
2488// SUBI
2489OPCODE(0x04B9)
2490{
2491 u32 adr, res;
2492 u32 src, dst;
2493
2494 FETCH_LONG(src);
2495 FETCH_LONG(adr);
2496 PRE_IO
2497 READ_LONG_F(adr, dst)
2498 res = dst - src;
2499 flag_NotZ = res;
2500 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2501 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2502 flag_N = res >> 24;
2503 WRITE_LONG_F(adr, res)
2504 POST_IO
2505RET(36)
2506}
2507
2508// SUBI
2509OPCODE(0x049F)
2510{
2511 u32 adr, res;
2512 u32 src, dst;
2513
2514 FETCH_LONG(src);
2515 adr = AREG(7);
2516 AREG(7) += 4;
2517 PRE_IO
2518 READ_LONG_F(adr, dst)
2519 res = dst - src;
2520 flag_NotZ = res;
2521 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2522 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2523 flag_N = res >> 24;
2524 WRITE_LONG_F(adr, res)
2525 POST_IO
2526RET(28)
2527}
2528
2529// SUBI
2530OPCODE(0x04A7)
2531{
2532 u32 adr, res;
2533 u32 src, dst;
2534
2535 FETCH_LONG(src);
2536 adr = AREG(7) - 4;
2537 AREG(7) = adr;
2538 PRE_IO
2539 READ_LONG_F(adr, dst)
2540 res = dst - src;
2541 flag_NotZ = res;
2542 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
2543 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
2544 flag_N = res >> 24;
2545 WRITE_LONG_F(adr, res)
2546 POST_IO
2547RET(30)
2548}
2549
2550// ADDI
2551OPCODE(0x0600)
2552{
2553 u32 adr, res;
2554 u32 src, dst;
2555
2556 FETCH_BYTE(src);
2557 dst = DREGu8((Opcode >> 0) & 7);
2558 res = dst + src;
2559 flag_N = flag_X = flag_C = res;
2560 flag_V = (src ^ res) & (dst ^ res);
2561 flag_NotZ = res & 0xFF;
2562 DREGu8((Opcode >> 0) & 7) = res;
2563RET(8)
2564}
2565
2566// ADDI
2567OPCODE(0x0610)
2568{
2569 u32 adr, res;
2570 u32 src, dst;
2571
2572 FETCH_BYTE(src);
2573 adr = AREG((Opcode >> 0) & 7);
2574 PRE_IO
2575 READ_BYTE_F(adr, dst)
2576 res = dst + src;
2577 flag_N = flag_X = flag_C = res;
2578 flag_V = (src ^ res) & (dst ^ res);
2579 flag_NotZ = res & 0xFF;
2580 WRITE_BYTE_F(adr, res)
2581 POST_IO
2582RET(16)
2583}
2584
2585// ADDI
2586OPCODE(0x0618)
2587{
2588 u32 adr, res;
2589 u32 src, dst;
2590
2591 FETCH_BYTE(src);
2592 adr = AREG((Opcode >> 0) & 7);
2593 AREG((Opcode >> 0) & 7) += 1;
2594 PRE_IO
2595 READ_BYTE_F(adr, dst)
2596 res = dst + src;
2597 flag_N = flag_X = flag_C = res;
2598 flag_V = (src ^ res) & (dst ^ res);
2599 flag_NotZ = res & 0xFF;
2600 WRITE_BYTE_F(adr, res)
2601 POST_IO
2602RET(16)
2603}
2604
2605// ADDI
2606OPCODE(0x0620)
2607{
2608 u32 adr, res;
2609 u32 src, dst;
2610
2611 FETCH_BYTE(src);
2612 adr = AREG((Opcode >> 0) & 7) - 1;
2613 AREG((Opcode >> 0) & 7) = adr;
2614 PRE_IO
2615 READ_BYTE_F(adr, dst)
2616 res = dst + src;
2617 flag_N = flag_X = flag_C = res;
2618 flag_V = (src ^ res) & (dst ^ res);
2619 flag_NotZ = res & 0xFF;
2620 WRITE_BYTE_F(adr, res)
2621 POST_IO
2622RET(18)
2623}
2624
2625// ADDI
2626OPCODE(0x0628)
2627{
2628 u32 adr, res;
2629 u32 src, dst;
2630
2631 FETCH_BYTE(src);
2632 FETCH_SWORD(adr);
2633 adr += AREG((Opcode >> 0) & 7);
2634 PRE_IO
2635 READ_BYTE_F(adr, dst)
2636 res = dst + src;
2637 flag_N = flag_X = flag_C = res;
2638 flag_V = (src ^ res) & (dst ^ res);
2639 flag_NotZ = res & 0xFF;
2640 WRITE_BYTE_F(adr, res)
2641 POST_IO
2642RET(20)
2643}
2644
2645// ADDI
2646OPCODE(0x0630)
2647{
2648 u32 adr, res;
2649 u32 src, dst;
2650
2651 FETCH_BYTE(src);
2652 adr = AREG((Opcode >> 0) & 7);
2653 DECODE_EXT_WORD
2654 PRE_IO
2655 READ_BYTE_F(adr, dst)
2656 res = dst + src;
2657 flag_N = flag_X = flag_C = res;
2658 flag_V = (src ^ res) & (dst ^ res);
2659 flag_NotZ = res & 0xFF;
2660 WRITE_BYTE_F(adr, res)
2661 POST_IO
2662RET(22)
2663}
2664
2665// ADDI
2666OPCODE(0x0638)
2667{
2668 u32 adr, res;
2669 u32 src, dst;
2670
2671 FETCH_BYTE(src);
2672 FETCH_SWORD(adr);
2673 PRE_IO
2674 READ_BYTE_F(adr, dst)
2675 res = dst + src;
2676 flag_N = flag_X = flag_C = res;
2677 flag_V = (src ^ res) & (dst ^ res);
2678 flag_NotZ = res & 0xFF;
2679 WRITE_BYTE_F(adr, res)
2680 POST_IO
2681RET(20)
2682}
2683
2684// ADDI
2685OPCODE(0x0639)
2686{
2687 u32 adr, res;
2688 u32 src, dst;
2689
2690 FETCH_BYTE(src);
2691 FETCH_LONG(adr);
2692 PRE_IO
2693 READ_BYTE_F(adr, dst)
2694 res = dst + src;
2695 flag_N = flag_X = flag_C = res;
2696 flag_V = (src ^ res) & (dst ^ res);
2697 flag_NotZ = res & 0xFF;
2698 WRITE_BYTE_F(adr, res)
2699 POST_IO
2700RET(24)
2701}
2702
2703// ADDI
2704OPCODE(0x061F)
2705{
2706 u32 adr, res;
2707 u32 src, dst;
2708
2709 FETCH_BYTE(src);
2710 adr = AREG(7);
2711 AREG(7) += 2;
2712 PRE_IO
2713 READ_BYTE_F(adr, dst)
2714 res = dst + src;
2715 flag_N = flag_X = flag_C = res;
2716 flag_V = (src ^ res) & (dst ^ res);
2717 flag_NotZ = res & 0xFF;
2718 WRITE_BYTE_F(adr, res)
2719 POST_IO
2720RET(16)
2721}
2722
2723// ADDI
2724OPCODE(0x0627)
2725{
2726 u32 adr, res;
2727 u32 src, dst;
2728
2729 FETCH_BYTE(src);
2730 adr = AREG(7) - 2;
2731 AREG(7) = adr;
2732 PRE_IO
2733 READ_BYTE_F(adr, dst)
2734 res = dst + src;
2735 flag_N = flag_X = flag_C = res;
2736 flag_V = (src ^ res) & (dst ^ res);
2737 flag_NotZ = res & 0xFF;
2738 WRITE_BYTE_F(adr, res)
2739 POST_IO
2740RET(18)
2741}
2742
2743// ADDI
2744OPCODE(0x0640)
2745{
2746 u32 adr, res;
2747 u32 src, dst;
2748
2749 FETCH_WORD(src);
2750 dst = DREGu16((Opcode >> 0) & 7);
2751 res = dst + src;
2752 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2753 flag_N = flag_X = flag_C = res >> 8;
2754 flag_NotZ = res & 0xFFFF;
2755 DREGu16((Opcode >> 0) & 7) = res;
2756RET(8)
2757}
2758
2759// ADDI
2760OPCODE(0x0650)
2761{
2762 u32 adr, res;
2763 u32 src, dst;
2764
2765 FETCH_WORD(src);
2766 adr = AREG((Opcode >> 0) & 7);
2767 PRE_IO
2768 READ_WORD_F(adr, dst)
2769 res = dst + src;
2770 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2771 flag_N = flag_X = flag_C = res >> 8;
2772 flag_NotZ = res & 0xFFFF;
2773 WRITE_WORD_F(adr, res)
2774 POST_IO
2775RET(16)
2776}
2777
2778// ADDI
2779OPCODE(0x0658)
2780{
2781 u32 adr, res;
2782 u32 src, dst;
2783
2784 FETCH_WORD(src);
2785 adr = AREG((Opcode >> 0) & 7);
2786 AREG((Opcode >> 0) & 7) += 2;
2787 PRE_IO
2788 READ_WORD_F(adr, dst)
2789 res = dst + src;
2790 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2791 flag_N = flag_X = flag_C = res >> 8;
2792 flag_NotZ = res & 0xFFFF;
2793 WRITE_WORD_F(adr, res)
2794 POST_IO
2795RET(16)
2796}
2797
2798// ADDI
2799OPCODE(0x0660)
2800{
2801 u32 adr, res;
2802 u32 src, dst;
2803
2804 FETCH_WORD(src);
2805 adr = AREG((Opcode >> 0) & 7) - 2;
2806 AREG((Opcode >> 0) & 7) = adr;
2807 PRE_IO
2808 READ_WORD_F(adr, dst)
2809 res = dst + src;
2810 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2811 flag_N = flag_X = flag_C = res >> 8;
2812 flag_NotZ = res & 0xFFFF;
2813 WRITE_WORD_F(adr, res)
2814 POST_IO
2815RET(18)
2816}
2817
2818// ADDI
2819OPCODE(0x0668)
2820{
2821 u32 adr, res;
2822 u32 src, dst;
2823
2824 FETCH_WORD(src);
2825 FETCH_SWORD(adr);
2826 adr += AREG((Opcode >> 0) & 7);
2827 PRE_IO
2828 READ_WORD_F(adr, dst)
2829 res = dst + src;
2830 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2831 flag_N = flag_X = flag_C = res >> 8;
2832 flag_NotZ = res & 0xFFFF;
2833 WRITE_WORD_F(adr, res)
2834 POST_IO
2835RET(20)
2836}
2837
2838// ADDI
2839OPCODE(0x0670)
2840{
2841 u32 adr, res;
2842 u32 src, dst;
2843
2844 FETCH_WORD(src);
2845 adr = AREG((Opcode >> 0) & 7);
2846 DECODE_EXT_WORD
2847 PRE_IO
2848 READ_WORD_F(adr, dst)
2849 res = dst + src;
2850 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2851 flag_N = flag_X = flag_C = res >> 8;
2852 flag_NotZ = res & 0xFFFF;
2853 WRITE_WORD_F(adr, res)
2854 POST_IO
2855RET(22)
2856}
2857
2858// ADDI
2859OPCODE(0x0678)
2860{
2861 u32 adr, res;
2862 u32 src, dst;
2863
2864 FETCH_WORD(src);
2865 FETCH_SWORD(adr);
2866 PRE_IO
2867 READ_WORD_F(adr, dst)
2868 res = dst + src;
2869 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2870 flag_N = flag_X = flag_C = res >> 8;
2871 flag_NotZ = res & 0xFFFF;
2872 WRITE_WORD_F(adr, res)
2873 POST_IO
2874RET(20)
2875}
2876
2877// ADDI
2878OPCODE(0x0679)
2879{
2880 u32 adr, res;
2881 u32 src, dst;
2882
2883 FETCH_WORD(src);
2884 FETCH_LONG(adr);
2885 PRE_IO
2886 READ_WORD_F(adr, dst)
2887 res = dst + src;
2888 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2889 flag_N = flag_X = flag_C = res >> 8;
2890 flag_NotZ = res & 0xFFFF;
2891 WRITE_WORD_F(adr, res)
2892 POST_IO
2893RET(24)
2894}
2895
2896// ADDI
2897OPCODE(0x065F)
2898{
2899 u32 adr, res;
2900 u32 src, dst;
2901
2902 FETCH_WORD(src);
2903 adr = AREG(7);
2904 AREG(7) += 2;
2905 PRE_IO
2906 READ_WORD_F(adr, dst)
2907 res = dst + src;
2908 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2909 flag_N = flag_X = flag_C = res >> 8;
2910 flag_NotZ = res & 0xFFFF;
2911 WRITE_WORD_F(adr, res)
2912 POST_IO
2913RET(16)
2914}
2915
2916// ADDI
2917OPCODE(0x0667)
2918{
2919 u32 adr, res;
2920 u32 src, dst;
2921
2922 FETCH_WORD(src);
2923 adr = AREG(7) - 2;
2924 AREG(7) = adr;
2925 PRE_IO
2926 READ_WORD_F(adr, dst)
2927 res = dst + src;
2928 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
2929 flag_N = flag_X = flag_C = res >> 8;
2930 flag_NotZ = res & 0xFFFF;
2931 WRITE_WORD_F(adr, res)
2932 POST_IO
2933RET(18)
2934}
2935
2936// ADDI
2937OPCODE(0x0680)
2938{
2939 u32 adr, res;
2940 u32 src, dst;
2941
2942 FETCH_LONG(src);
2943 dst = DREGu32((Opcode >> 0) & 7);
2944 res = dst + src;
2945 flag_NotZ = res;
2946 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2947 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2948 flag_N = res >> 24;
2949 DREGu32((Opcode >> 0) & 7) = res;
2950RET(16)
2951}
2952
2953// ADDI
2954OPCODE(0x0690)
2955{
2956 u32 adr, res;
2957 u32 src, dst;
2958
2959 FETCH_LONG(src);
2960 adr = AREG((Opcode >> 0) & 7);
2961 PRE_IO
2962 READ_LONG_F(adr, dst)
2963 res = dst + src;
2964 flag_NotZ = res;
2965 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2966 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2967 flag_N = res >> 24;
2968 WRITE_LONG_F(adr, res)
2969 POST_IO
2970RET(28)
2971}
2972
2973// ADDI
2974OPCODE(0x0698)
2975{
2976 u32 adr, res;
2977 u32 src, dst;
2978
2979 FETCH_LONG(src);
2980 adr = AREG((Opcode >> 0) & 7);
2981 AREG((Opcode >> 0) & 7) += 4;
2982 PRE_IO
2983 READ_LONG_F(adr, dst)
2984 res = dst + src;
2985 flag_NotZ = res;
2986 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
2987 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
2988 flag_N = res >> 24;
2989 WRITE_LONG_F(adr, res)
2990 POST_IO
2991RET(28)
2992}
2993
2994// ADDI
2995OPCODE(0x06A0)
2996{
2997 u32 adr, res;
2998 u32 src, dst;
2999
3000 FETCH_LONG(src);
3001 adr = AREG((Opcode >> 0) & 7) - 4;
3002 AREG((Opcode >> 0) & 7) = adr;
3003 PRE_IO
3004 READ_LONG_F(adr, dst)
3005 res = dst + src;
3006 flag_NotZ = res;
3007 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3008 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3009 flag_N = res >> 24;
3010 WRITE_LONG_F(adr, res)
3011 POST_IO
3012RET(30)
3013}
3014
3015// ADDI
3016OPCODE(0x06A8)
3017{
3018 u32 adr, res;
3019 u32 src, dst;
3020
3021 FETCH_LONG(src);
3022 FETCH_SWORD(adr);
3023 adr += AREG((Opcode >> 0) & 7);
3024 PRE_IO
3025 READ_LONG_F(adr, dst)
3026 res = dst + src;
3027 flag_NotZ = res;
3028 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3029 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3030 flag_N = res >> 24;
3031 WRITE_LONG_F(adr, res)
3032 POST_IO
3033RET(32)
3034}
3035
3036// ADDI
3037OPCODE(0x06B0)
3038{
3039 u32 adr, res;
3040 u32 src, dst;
3041
3042 FETCH_LONG(src);
3043 adr = AREG((Opcode >> 0) & 7);
3044 DECODE_EXT_WORD
3045 PRE_IO
3046 READ_LONG_F(adr, dst)
3047 res = dst + src;
3048 flag_NotZ = res;
3049 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3050 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3051 flag_N = res >> 24;
3052 WRITE_LONG_F(adr, res)
3053 POST_IO
3054RET(34)
3055}
3056
3057// ADDI
3058OPCODE(0x06B8)
3059{
3060 u32 adr, res;
3061 u32 src, dst;
3062
3063 FETCH_LONG(src);
3064 FETCH_SWORD(adr);
3065 PRE_IO
3066 READ_LONG_F(adr, dst)
3067 res = dst + src;
3068 flag_NotZ = res;
3069 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3070 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3071 flag_N = res >> 24;
3072 WRITE_LONG_F(adr, res)
3073 POST_IO
3074RET(32)
3075}
3076
3077// ADDI
3078OPCODE(0x06B9)
3079{
3080 u32 adr, res;
3081 u32 src, dst;
3082
3083 FETCH_LONG(src);
3084 FETCH_LONG(adr);
3085 PRE_IO
3086 READ_LONG_F(adr, dst)
3087 res = dst + src;
3088 flag_NotZ = res;
3089 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3090 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3091 flag_N = res >> 24;
3092 WRITE_LONG_F(adr, res)
3093 POST_IO
3094RET(36)
3095}
3096
3097// ADDI
3098OPCODE(0x069F)
3099{
3100 u32 adr, res;
3101 u32 src, dst;
3102
3103 FETCH_LONG(src);
3104 adr = AREG(7);
3105 AREG(7) += 4;
3106 PRE_IO
3107 READ_LONG_F(adr, dst)
3108 res = dst + src;
3109 flag_NotZ = res;
3110 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3111 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3112 flag_N = res >> 24;
3113 WRITE_LONG_F(adr, res)
3114 POST_IO
3115RET(28)
3116}
3117
3118// ADDI
3119OPCODE(0x06A7)
3120{
3121 u32 adr, res;
3122 u32 src, dst;
3123
3124 FETCH_LONG(src);
3125 adr = AREG(7) - 4;
3126 AREG(7) = adr;
3127 PRE_IO
3128 READ_LONG_F(adr, dst)
3129 res = dst + src;
3130 flag_NotZ = res;
3131 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
3132 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
3133 flag_N = res >> 24;
3134 WRITE_LONG_F(adr, res)
3135 POST_IO
3136RET(30)
3137}
3138
3139// CMPI
3140OPCODE(0x0C00)
3141{
3142 u32 adr, res;
3143 u32 src, dst;
3144
3145 FETCH_BYTE(src);
3146 dst = DREGu8((Opcode >> 0) & 7);
3147 res = dst - src;
3148 flag_N = flag_C = res;
3149 flag_V = (src ^ dst) & (res ^ dst);
3150 flag_NotZ = res & 0xFF;
3151RET(8)
3152}
3153
3154// CMPI
3155OPCODE(0x0C10)
3156{
3157 u32 adr, res;
3158 u32 src, dst;
3159
3160 FETCH_BYTE(src);
3161 adr = AREG((Opcode >> 0) & 7);
3162 PRE_IO
3163 READ_BYTE_F(adr, dst)
3164 res = dst - src;
3165 flag_N = flag_C = res;
3166 flag_V = (src ^ dst) & (res ^ dst);
3167 flag_NotZ = res & 0xFF;
3168 POST_IO
3169RET(12)
3170}
3171
3172// CMPI
3173OPCODE(0x0C18)
3174{
3175 u32 adr, res;
3176 u32 src, dst;
3177
3178 FETCH_BYTE(src);
3179 adr = AREG((Opcode >> 0) & 7);
3180 AREG((Opcode >> 0) & 7) += 1;
3181 PRE_IO
3182 READ_BYTE_F(adr, dst)
3183 res = dst - src;
3184 flag_N = flag_C = res;
3185 flag_V = (src ^ dst) & (res ^ dst);
3186 flag_NotZ = res & 0xFF;
3187 POST_IO
3188RET(12)
3189}
3190
3191// CMPI
3192OPCODE(0x0C20)
3193{
3194 u32 adr, res;
3195 u32 src, dst;
3196
3197 FETCH_BYTE(src);
3198 adr = AREG((Opcode >> 0) & 7) - 1;
3199 AREG((Opcode >> 0) & 7) = adr;
3200 PRE_IO
3201 READ_BYTE_F(adr, dst)
3202 res = dst - src;
3203 flag_N = flag_C = res;
3204 flag_V = (src ^ dst) & (res ^ dst);
3205 flag_NotZ = res & 0xFF;
3206 POST_IO
3207RET(14)
3208}
3209
3210// CMPI
3211OPCODE(0x0C28)
3212{
3213 u32 adr, res;
3214 u32 src, dst;
3215
3216 FETCH_BYTE(src);
3217 FETCH_SWORD(adr);
3218 adr += AREG((Opcode >> 0) & 7);
3219 PRE_IO
3220 READ_BYTE_F(adr, dst)
3221 res = dst - src;
3222 flag_N = flag_C = res;
3223 flag_V = (src ^ dst) & (res ^ dst);
3224 flag_NotZ = res & 0xFF;
3225 POST_IO
3226RET(16)
3227}
3228
3229// CMPI
3230OPCODE(0x0C30)
3231{
3232 u32 adr, res;
3233 u32 src, dst;
3234
3235 FETCH_BYTE(src);
3236 adr = AREG((Opcode >> 0) & 7);
3237 DECODE_EXT_WORD
3238 PRE_IO
3239 READ_BYTE_F(adr, dst)
3240 res = dst - src;
3241 flag_N = flag_C = res;
3242 flag_V = (src ^ dst) & (res ^ dst);
3243 flag_NotZ = res & 0xFF;
3244 POST_IO
3245RET(18)
3246}
3247
3248// CMPI
3249OPCODE(0x0C38)
3250{
3251 u32 adr, res;
3252 u32 src, dst;
3253
3254 FETCH_BYTE(src);
3255 FETCH_SWORD(adr);
3256 PRE_IO
3257 READ_BYTE_F(adr, dst)
3258 res = dst - src;
3259 flag_N = flag_C = res;
3260 flag_V = (src ^ dst) & (res ^ dst);
3261 flag_NotZ = res & 0xFF;
3262 POST_IO
3263RET(16)
3264}
3265
3266// CMPI
3267OPCODE(0x0C39)
3268{
3269 u32 adr, res;
3270 u32 src, dst;
3271
3272 FETCH_BYTE(src);
3273 FETCH_LONG(adr);
3274 PRE_IO
3275 READ_BYTE_F(adr, dst)
3276 res = dst - src;
3277 flag_N = flag_C = res;
3278 flag_V = (src ^ dst) & (res ^ dst);
3279 flag_NotZ = res & 0xFF;
3280 POST_IO
3281RET(20)
3282}
3283
3284// CMPI
3285OPCODE(0x0C1F)
3286{
3287 u32 adr, res;
3288 u32 src, dst;
3289
3290 FETCH_BYTE(src);
3291 adr = AREG(7);
3292 AREG(7) += 2;
3293 PRE_IO
3294 READ_BYTE_F(adr, dst)
3295 res = dst - src;
3296 flag_N = flag_C = res;
3297 flag_V = (src ^ dst) & (res ^ dst);
3298 flag_NotZ = res & 0xFF;
3299 POST_IO
3300RET(12)
3301}
3302
3303// CMPI
3304OPCODE(0x0C27)
3305{
3306 u32 adr, res;
3307 u32 src, dst;
3308
3309 FETCH_BYTE(src);
3310 adr = AREG(7) - 2;
3311 AREG(7) = adr;
3312 PRE_IO
3313 READ_BYTE_F(adr, dst)
3314 res = dst - src;
3315 flag_N = flag_C = res;
3316 flag_V = (src ^ dst) & (res ^ dst);
3317 flag_NotZ = res & 0xFF;
3318 POST_IO
3319RET(14)
3320}
3321
3322// CMPI
3323OPCODE(0x0C40)
3324{
3325 u32 adr, res;
3326 u32 src, dst;
3327
3328 FETCH_WORD(src);
3329 dst = DREGu16((Opcode >> 0) & 7);
3330 res = dst - src;
3331 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3332 flag_N = flag_C = res >> 8;
3333 flag_NotZ = res & 0xFFFF;
3334RET(8)
3335}
3336
3337// CMPI
3338OPCODE(0x0C50)
3339{
3340 u32 adr, res;
3341 u32 src, dst;
3342
3343 FETCH_WORD(src);
3344 adr = AREG((Opcode >> 0) & 7);
3345 PRE_IO
3346 READ_WORD_F(adr, dst)
3347 res = dst - src;
3348 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3349 flag_N = flag_C = res >> 8;
3350 flag_NotZ = res & 0xFFFF;
3351 POST_IO
3352RET(12)
3353}
3354
3355// CMPI
3356OPCODE(0x0C58)
3357{
3358 u32 adr, res;
3359 u32 src, dst;
3360
3361 FETCH_WORD(src);
3362 adr = AREG((Opcode >> 0) & 7);
3363 AREG((Opcode >> 0) & 7) += 2;
3364 PRE_IO
3365 READ_WORD_F(adr, dst)
3366 res = dst - src;
3367 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3368 flag_N = flag_C = res >> 8;
3369 flag_NotZ = res & 0xFFFF;
3370 POST_IO
3371RET(12)
3372}
3373
3374// CMPI
3375OPCODE(0x0C60)
3376{
3377 u32 adr, res;
3378 u32 src, dst;
3379
3380 FETCH_WORD(src);
3381 adr = AREG((Opcode >> 0) & 7) - 2;
3382 AREG((Opcode >> 0) & 7) = adr;
3383 PRE_IO
3384 READ_WORD_F(adr, dst)
3385 res = dst - src;
3386 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3387 flag_N = flag_C = res >> 8;
3388 flag_NotZ = res & 0xFFFF;
3389 POST_IO
3390RET(14)
3391}
3392
3393// CMPI
3394OPCODE(0x0C68)
3395{
3396 u32 adr, res;
3397 u32 src, dst;
3398
3399 FETCH_WORD(src);
3400 FETCH_SWORD(adr);
3401 adr += AREG((Opcode >> 0) & 7);
3402 PRE_IO
3403 READ_WORD_F(adr, dst)
3404 res = dst - src;
3405 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3406 flag_N = flag_C = res >> 8;
3407 flag_NotZ = res & 0xFFFF;
3408 POST_IO
3409RET(16)
3410}
3411
3412// CMPI
3413OPCODE(0x0C70)
3414{
3415 u32 adr, res;
3416 u32 src, dst;
3417
3418 FETCH_WORD(src);
3419 adr = AREG((Opcode >> 0) & 7);
3420 DECODE_EXT_WORD
3421 PRE_IO
3422 READ_WORD_F(adr, dst)
3423 res = dst - src;
3424 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3425 flag_N = flag_C = res >> 8;
3426 flag_NotZ = res & 0xFFFF;
3427 POST_IO
3428RET(18)
3429}
3430
3431// CMPI
3432OPCODE(0x0C78)
3433{
3434 u32 adr, res;
3435 u32 src, dst;
3436
3437 FETCH_WORD(src);
3438 FETCH_SWORD(adr);
3439 PRE_IO
3440 READ_WORD_F(adr, dst)
3441 res = dst - src;
3442 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3443 flag_N = flag_C = res >> 8;
3444 flag_NotZ = res & 0xFFFF;
3445 POST_IO
3446RET(16)
3447}
3448
3449// CMPI
3450OPCODE(0x0C79)
3451{
3452 u32 adr, res;
3453 u32 src, dst;
3454
3455 FETCH_WORD(src);
3456 FETCH_LONG(adr);
3457 PRE_IO
3458 READ_WORD_F(adr, dst)
3459 res = dst - src;
3460 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3461 flag_N = flag_C = res >> 8;
3462 flag_NotZ = res & 0xFFFF;
3463 POST_IO
3464RET(20)
3465}
3466
3467// CMPI
3468OPCODE(0x0C5F)
3469{
3470 u32 adr, res;
3471 u32 src, dst;
3472
3473 FETCH_WORD(src);
3474 adr = AREG(7);
3475 AREG(7) += 2;
3476 PRE_IO
3477 READ_WORD_F(adr, dst)
3478 res = dst - src;
3479 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3480 flag_N = flag_C = res >> 8;
3481 flag_NotZ = res & 0xFFFF;
3482 POST_IO
3483RET(12)
3484}
3485
3486// CMPI
3487OPCODE(0x0C67)
3488{
3489 u32 adr, res;
3490 u32 src, dst;
3491
3492 FETCH_WORD(src);
3493 adr = AREG(7) - 2;
3494 AREG(7) = adr;
3495 PRE_IO
3496 READ_WORD_F(adr, dst)
3497 res = dst - src;
3498 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
3499 flag_N = flag_C = res >> 8;
3500 flag_NotZ = res & 0xFFFF;
3501 POST_IO
3502RET(14)
3503}
3504
3505// CMPI
3506OPCODE(0x0C80)
3507{
3508 u32 adr, res;
3509 u32 src, dst;
3510
3511 FETCH_LONG(src);
3512 dst = DREGu32((Opcode >> 0) & 7);
3513 res = dst - src;
3514 flag_NotZ = res;
3515 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3516 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3517 flag_N = res >> 24;
3518RET(14)
3519}
3520
3521// CMPI
3522OPCODE(0x0C90)
3523{
3524 u32 adr, res;
3525 u32 src, dst;
3526
3527 FETCH_LONG(src);
3528 adr = AREG((Opcode >> 0) & 7);
3529 PRE_IO
3530 READ_LONG_F(adr, dst)
3531 res = dst - src;
3532 flag_NotZ = res;
3533 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3534 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3535 flag_N = res >> 24;
3536 POST_IO
3537RET(20)
3538}
3539
3540// CMPI
3541OPCODE(0x0C98)
3542{
3543 u32 adr, res;
3544 u32 src, dst;
3545
3546 FETCH_LONG(src);
3547 adr = AREG((Opcode >> 0) & 7);
3548 AREG((Opcode >> 0) & 7) += 4;
3549 PRE_IO
3550 READ_LONG_F(adr, dst)
3551 res = dst - src;
3552 flag_NotZ = res;
3553 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3554 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3555 flag_N = res >> 24;
3556 POST_IO
3557RET(20)
3558}
3559
3560// CMPI
3561OPCODE(0x0CA0)
3562{
3563 u32 adr, res;
3564 u32 src, dst;
3565
3566 FETCH_LONG(src);
3567 adr = AREG((Opcode >> 0) & 7) - 4;
3568 AREG((Opcode >> 0) & 7) = adr;
3569 PRE_IO
3570 READ_LONG_F(adr, dst)
3571 res = dst - src;
3572 flag_NotZ = res;
3573 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3574 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3575 flag_N = res >> 24;
3576 POST_IO
3577RET(22)
3578}
3579
3580// CMPI
3581OPCODE(0x0CA8)
3582{
3583 u32 adr, res;
3584 u32 src, dst;
3585
3586 FETCH_LONG(src);
3587 FETCH_SWORD(adr);
3588 adr += AREG((Opcode >> 0) & 7);
3589 PRE_IO
3590 READ_LONG_F(adr, dst)
3591 res = dst - src;
3592 flag_NotZ = res;
3593 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3594 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3595 flag_N = res >> 24;
3596 POST_IO
3597RET(24)
3598}
3599
3600// CMPI
3601OPCODE(0x0CB0)
3602{
3603 u32 adr, res;
3604 u32 src, dst;
3605
3606 FETCH_LONG(src);
3607 adr = AREG((Opcode >> 0) & 7);
3608 DECODE_EXT_WORD
3609 PRE_IO
3610 READ_LONG_F(adr, dst)
3611 res = dst - src;
3612 flag_NotZ = res;
3613 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3614 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3615 flag_N = res >> 24;
3616 POST_IO
3617RET(26)
3618}
3619
3620// CMPI
3621OPCODE(0x0CB8)
3622{
3623 u32 adr, res;
3624 u32 src, dst;
3625
3626 FETCH_LONG(src);
3627 FETCH_SWORD(adr);
3628 PRE_IO
3629 READ_LONG_F(adr, dst)
3630 res = dst - src;
3631 flag_NotZ = res;
3632 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3633 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3634 flag_N = res >> 24;
3635 POST_IO
3636RET(24)
3637}
3638
3639// CMPI
3640OPCODE(0x0CB9)
3641{
3642 u32 adr, res;
3643 u32 src, dst;
3644
3645 FETCH_LONG(src);
3646 FETCH_LONG(adr);
3647 PRE_IO
3648 READ_LONG_F(adr, dst)
3649 res = dst - src;
3650 flag_NotZ = res;
3651 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3652 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3653 flag_N = res >> 24;
3654 POST_IO
3655RET(28)
3656}
3657
3658// CMPI
3659OPCODE(0x0C9F)
3660{
3661 u32 adr, res;
3662 u32 src, dst;
3663
3664 FETCH_LONG(src);
3665 adr = AREG(7);
3666 AREG(7) += 4;
3667 PRE_IO
3668 READ_LONG_F(adr, dst)
3669 res = dst - src;
3670 flag_NotZ = res;
3671 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3672 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3673 flag_N = res >> 24;
3674 POST_IO
3675RET(20)
3676}
3677
3678// CMPI
3679OPCODE(0x0CA7)
3680{
3681 u32 adr, res;
3682 u32 src, dst;
3683
3684 FETCH_LONG(src);
3685 adr = AREG(7) - 4;
3686 AREG(7) = adr;
3687 PRE_IO
3688 READ_LONG_F(adr, dst)
3689 res = dst - src;
3690 flag_NotZ = res;
3691 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
3692 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
3693 flag_N = res >> 24;
3694 POST_IO
3695RET(22)
3696}
3697
3698// BTSTn
3699OPCODE(0x0800)
3700{
3701 u32 adr, res;
3702 u32 src, dst;
3703
3704 FETCH_BYTE(src);
3705 src = 1 << (src & 31);
3706 res = DREGu32((Opcode >> 0) & 7);
3707 flag_NotZ = res & src;
3708RET(10)
3709}
3710
3711// BTSTn
3712OPCODE(0x0810)
3713{
3714 u32 adr, res;
3715 u32 src, dst;
3716
3717 FETCH_BYTE(src);
3718 src = 1 << (src & 7);
3719 adr = AREG((Opcode >> 0) & 7);
3720 PRE_IO
3721 READ_BYTE_F(adr, res)
3722 flag_NotZ = res & src;
3723 POST_IO
3724RET(12)
3725}
3726
3727// BTSTn
3728OPCODE(0x0818)
3729{
3730 u32 adr, res;
3731 u32 src, dst;
3732
3733 FETCH_BYTE(src);
3734 src = 1 << (src & 7);
3735 adr = AREG((Opcode >> 0) & 7);
3736 AREG((Opcode >> 0) & 7) += 1;
3737 PRE_IO
3738 READ_BYTE_F(adr, res)
3739 flag_NotZ = res & src;
3740 POST_IO
3741RET(12)
3742}
3743
3744// BTSTn
3745OPCODE(0x0820)
3746{
3747 u32 adr, res;
3748 u32 src, dst;
3749
3750 FETCH_BYTE(src);
3751 src = 1 << (src & 7);
3752 adr = AREG((Opcode >> 0) & 7) - 1;
3753 AREG((Opcode >> 0) & 7) = adr;
3754 PRE_IO
3755 READ_BYTE_F(adr, res)
3756 flag_NotZ = res & src;
3757 POST_IO
3758RET(14)
3759}
3760
3761// BTSTn
3762OPCODE(0x0828)
3763{
3764 u32 adr, res;
3765 u32 src, dst;
3766
3767 FETCH_BYTE(src);
3768 src = 1 << (src & 7);
3769 FETCH_SWORD(adr);
3770 adr += AREG((Opcode >> 0) & 7);
3771 PRE_IO
3772 READ_BYTE_F(adr, res)
3773 flag_NotZ = res & src;
3774 POST_IO
3775RET(16)
3776}
3777
3778// BTSTn
3779OPCODE(0x0830)
3780{
3781 u32 adr, res;
3782 u32 src, dst;
3783
3784 FETCH_BYTE(src);
3785 src = 1 << (src & 7);
3786 adr = AREG((Opcode >> 0) & 7);
3787 DECODE_EXT_WORD
3788 PRE_IO
3789 READ_BYTE_F(adr, res)
3790 flag_NotZ = res & src;
3791 POST_IO
3792RET(18)
3793}
3794
3795// BTSTn
3796OPCODE(0x0838)
3797{
3798 u32 adr, res;
3799 u32 src, dst;
3800
3801 FETCH_BYTE(src);
3802 src = 1 << (src & 7);
3803 FETCH_SWORD(adr);
3804 PRE_IO
3805 READ_BYTE_F(adr, res)
3806 flag_NotZ = res & src;
3807 POST_IO
3808RET(16)
3809}
3810
3811// BTSTn
3812OPCODE(0x0839)
3813{
3814 u32 adr, res;
3815 u32 src, dst;
3816
3817 FETCH_BYTE(src);
3818 src = 1 << (src & 7);
3819 FETCH_LONG(adr);
3820 PRE_IO
3821 READ_BYTE_F(adr, res)
3822 flag_NotZ = res & src;
3823 POST_IO
3824RET(20)
3825}
3826
3827// BTSTn
3828OPCODE(0x083A)
3829{
3830 u32 adr, res;
3831 u32 src, dst;
3832
3833 FETCH_BYTE(src);
3834 src = 1 << (src & 7);
be26eb23 3835 adr = GET_SWORD + GET_PC;
70357ce5 3836 PC++;
3837 PRE_IO
3838 READ_BYTE_F(adr, res)
3839 flag_NotZ = res & src;
3840 POST_IO
3841RET(16)
3842}
3843
3844// BTSTn
3845OPCODE(0x083B)
3846{
3847 u32 adr, res;
3848 u32 src, dst;
3849
3850 FETCH_BYTE(src);
3851 src = 1 << (src & 7);
be26eb23 3852 adr = (uptr)(PC) - BasePC;
70357ce5 3853 DECODE_EXT_WORD
3854 PRE_IO
3855 READ_BYTE_F(adr, res)
3856 flag_NotZ = res & src;
3857 POST_IO
3858RET(18)
3859}
3860
3861// BTSTn
3862OPCODE(0x081F)
3863{
3864 u32 adr, res;
3865 u32 src, dst;
3866
3867 FETCH_BYTE(src);
3868 src = 1 << (src & 7);
3869 adr = AREG(7);
3870 AREG(7) += 2;
3871 PRE_IO
3872 READ_BYTE_F(adr, res)
3873 flag_NotZ = res & src;
3874 POST_IO
3875RET(12)
3876}
3877
3878// BTSTn
3879OPCODE(0x0827)
3880{
3881 u32 adr, res;
3882 u32 src, dst;
3883
3884 FETCH_BYTE(src);
3885 src = 1 << (src & 7);
3886 adr = AREG(7) - 2;
3887 AREG(7) = adr;
3888 PRE_IO
3889 READ_BYTE_F(adr, res)
3890 flag_NotZ = res & src;
3891 POST_IO
3892RET(14)
3893}
3894
3895// BCHGn
3896OPCODE(0x0840)
3897{
3898 u32 adr, res;
3899 u32 src, dst;
3900
3901 FETCH_BYTE(src);
3902 src = 1 << (src & 31);
3903 res = DREGu32((Opcode >> 0) & 7);
3904 flag_NotZ = res & src;
3905 res ^= src;
3906 DREGu32((Opcode >> 0) & 7) = res;
3907RET(12)
3908}
3909
3910// BCHGn
3911OPCODE(0x0850)
3912{
3913 u32 adr, res;
3914 u32 src, dst;
3915
3916 FETCH_BYTE(src);
3917 src = 1 << (src & 7);
3918 adr = AREG((Opcode >> 0) & 7);
3919 PRE_IO
3920 READ_BYTE_F(adr, res)
3921 flag_NotZ = res & src;
3922 res ^= src;
3923 WRITE_BYTE_F(adr, res)
3924 POST_IO
3925RET(16)
3926}
3927
3928// BCHGn
3929OPCODE(0x0858)
3930{
3931 u32 adr, res;
3932 u32 src, dst;
3933
3934 FETCH_BYTE(src);
3935 src = 1 << (src & 7);
3936 adr = AREG((Opcode >> 0) & 7);
3937 AREG((Opcode >> 0) & 7) += 1;
3938 PRE_IO
3939 READ_BYTE_F(adr, res)
3940 flag_NotZ = res & src;
3941 res ^= src;
3942 WRITE_BYTE_F(adr, res)
3943 POST_IO
3944RET(16)
3945}
3946
3947// BCHGn
3948OPCODE(0x0860)
3949{
3950 u32 adr, res;
3951 u32 src, dst;
3952
3953 FETCH_BYTE(src);
3954 src = 1 << (src & 7);
3955 adr = AREG((Opcode >> 0) & 7) - 1;
3956 AREG((Opcode >> 0) & 7) = adr;
3957 PRE_IO
3958 READ_BYTE_F(adr, res)
3959 flag_NotZ = res & src;
3960 res ^= src;
3961 WRITE_BYTE_F(adr, res)
3962 POST_IO
3963RET(18)
3964}
3965
3966// BCHGn
3967OPCODE(0x0868)
3968{
3969 u32 adr, res;
3970 u32 src, dst;
3971
3972 FETCH_BYTE(src);
3973 src = 1 << (src & 7);
3974 FETCH_SWORD(adr);
3975 adr += AREG((Opcode >> 0) & 7);
3976 PRE_IO
3977 READ_BYTE_F(adr, res)
3978 flag_NotZ = res & src;
3979 res ^= src;
3980 WRITE_BYTE_F(adr, res)
3981 POST_IO
3982RET(20)
3983}
3984
3985// BCHGn
3986OPCODE(0x0870)
3987{
3988 u32 adr, res;
3989 u32 src, dst;
3990
3991 FETCH_BYTE(src);
3992 src = 1 << (src & 7);
3993 adr = AREG((Opcode >> 0) & 7);
3994 DECODE_EXT_WORD
3995 PRE_IO
3996 READ_BYTE_F(adr, res)
3997 flag_NotZ = res & src;
3998 res ^= src;
3999 WRITE_BYTE_F(adr, res)
4000 POST_IO
4001RET(22)
4002}
4003
4004// BCHGn
4005OPCODE(0x0878)
4006{
4007 u32 adr, res;
4008 u32 src, dst;
4009
4010 FETCH_BYTE(src);
4011 src = 1 << (src & 7);
4012 FETCH_SWORD(adr);
4013 PRE_IO
4014 READ_BYTE_F(adr, res)
4015 flag_NotZ = res & src;
4016 res ^= src;
4017 WRITE_BYTE_F(adr, res)
4018 POST_IO
4019RET(20)
4020}
4021
4022// BCHGn
4023OPCODE(0x0879)
4024{
4025 u32 adr, res;
4026 u32 src, dst;
4027
4028 FETCH_BYTE(src);
4029 src = 1 << (src & 7);
4030 FETCH_LONG(adr);
4031 PRE_IO
4032 READ_BYTE_F(adr, res)
4033 flag_NotZ = res & src;
4034 res ^= src;
4035 WRITE_BYTE_F(adr, res)
4036 POST_IO
4037RET(24)
4038}
4039
4040// BCHGn
4041OPCODE(0x085F)
4042{
4043 u32 adr, res;
4044 u32 src, dst;
4045
4046 FETCH_BYTE(src);
4047 src = 1 << (src & 7);
4048 adr = AREG(7);
4049 AREG(7) += 2;
4050 PRE_IO
4051 READ_BYTE_F(adr, res)
4052 flag_NotZ = res & src;
4053 res ^= src;
4054 WRITE_BYTE_F(adr, res)
4055 POST_IO
4056RET(16)
4057}
4058
4059// BCHGn
4060OPCODE(0x0867)
4061{
4062 u32 adr, res;
4063 u32 src, dst;
4064
4065 FETCH_BYTE(src);
4066 src = 1 << (src & 7);
4067 adr = AREG(7) - 2;
4068 AREG(7) = adr;
4069 PRE_IO
4070 READ_BYTE_F(adr, res)
4071 flag_NotZ = res & src;
4072 res ^= src;
4073 WRITE_BYTE_F(adr, res)
4074 POST_IO
4075RET(18)
4076}
4077
4078// BCLRn
4079OPCODE(0x0880)
4080{
4081 u32 adr, res;
4082 u32 src, dst;
4083
4084 FETCH_BYTE(src);
4085 src = 1 << (src & 31);
4086 res = DREGu32((Opcode >> 0) & 7);
4087 flag_NotZ = res & src;
4088 res &= ~src;
4089 DREGu32((Opcode >> 0) & 7) = res;
4090RET(14)
4091}
4092
4093// BCLRn
4094OPCODE(0x0890)
4095{
4096 u32 adr, res;
4097 u32 src, dst;
4098
4099 FETCH_BYTE(src);
4100 src = 1 << (src & 7);
4101 adr = AREG((Opcode >> 0) & 7);
4102 PRE_IO
4103 READ_BYTE_F(adr, res)
4104 flag_NotZ = res & src;
4105 res &= ~src;
4106 WRITE_BYTE_F(adr, res)
4107 POST_IO
4108RET(16)
4109}
4110
4111// BCLRn
4112OPCODE(0x0898)
4113{
4114 u32 adr, res;
4115 u32 src, dst;
4116
4117 FETCH_BYTE(src);
4118 src = 1 << (src & 7);
4119 adr = AREG((Opcode >> 0) & 7);
4120 AREG((Opcode >> 0) & 7) += 1;
4121 PRE_IO
4122 READ_BYTE_F(adr, res)
4123 flag_NotZ = res & src;
4124 res &= ~src;
4125 WRITE_BYTE_F(adr, res)
4126 POST_IO
4127RET(16)
4128}
4129
4130// BCLRn
4131OPCODE(0x08A0)
4132{
4133 u32 adr, res;
4134 u32 src, dst;
4135
4136 FETCH_BYTE(src);
4137 src = 1 << (src & 7);
4138 adr = AREG((Opcode >> 0) & 7) - 1;
4139 AREG((Opcode >> 0) & 7) = adr;
4140 PRE_IO
4141 READ_BYTE_F(adr, res)
4142 flag_NotZ = res & src;
4143 res &= ~src;
4144 WRITE_BYTE_F(adr, res)
4145 POST_IO
4146RET(18)
4147}
4148
4149// BCLRn
4150OPCODE(0x08A8)
4151{
4152 u32 adr, res;
4153 u32 src, dst;
4154
4155 FETCH_BYTE(src);
4156 src = 1 << (src & 7);
4157 FETCH_SWORD(adr);
4158 adr += AREG((Opcode >> 0) & 7);
4159 PRE_IO
4160 READ_BYTE_F(adr, res)
4161 flag_NotZ = res & src;
4162 res &= ~src;
4163 WRITE_BYTE_F(adr, res)
4164 POST_IO
4165RET(20)
4166}
4167
4168// BCLRn
4169OPCODE(0x08B0)
4170{
4171 u32 adr, res;
4172 u32 src, dst;
4173
4174 FETCH_BYTE(src);
4175 src = 1 << (src & 7);
4176 adr = AREG((Opcode >> 0) & 7);
4177 DECODE_EXT_WORD
4178 PRE_IO
4179 READ_BYTE_F(adr, res)
4180 flag_NotZ = res & src;
4181 res &= ~src;
4182 WRITE_BYTE_F(adr, res)
4183 POST_IO
4184RET(22)
4185}
4186
4187// BCLRn
4188OPCODE(0x08B8)
4189{
4190 u32 adr, res;
4191 u32 src, dst;
4192
4193 FETCH_BYTE(src);
4194 src = 1 << (src & 7);
4195 FETCH_SWORD(adr);
4196 PRE_IO
4197 READ_BYTE_F(adr, res)
4198 flag_NotZ = res & src;
4199 res &= ~src;
4200 WRITE_BYTE_F(adr, res)
4201 POST_IO
4202RET(20)
4203}
4204
4205// BCLRn
4206OPCODE(0x08B9)
4207{
4208 u32 adr, res;
4209 u32 src, dst;
4210
4211 FETCH_BYTE(src);
4212 src = 1 << (src & 7);
4213 FETCH_LONG(adr);
4214 PRE_IO
4215 READ_BYTE_F(adr, res)
4216 flag_NotZ = res & src;
4217 res &= ~src;
4218 WRITE_BYTE_F(adr, res)
4219 POST_IO
4220RET(24)
4221}
4222
4223// BCLRn
4224OPCODE(0x089F)
4225{
4226 u32 adr, res;
4227 u32 src, dst;
4228
4229 FETCH_BYTE(src);
4230 src = 1 << (src & 7);
4231 adr = AREG(7);
4232 AREG(7) += 2;
4233 PRE_IO
4234 READ_BYTE_F(adr, res)
4235 flag_NotZ = res & src;
4236 res &= ~src;
4237 WRITE_BYTE_F(adr, res)
4238 POST_IO
4239RET(16)
4240}
4241
4242// BCLRn
4243OPCODE(0x08A7)
4244{
4245 u32 adr, res;
4246 u32 src, dst;
4247
4248 FETCH_BYTE(src);
4249 src = 1 << (src & 7);
4250 adr = AREG(7) - 2;
4251 AREG(7) = adr;
4252 PRE_IO
4253 READ_BYTE_F(adr, res)
4254 flag_NotZ = res & src;
4255 res &= ~src;
4256 WRITE_BYTE_F(adr, res)
4257 POST_IO
4258RET(18)
4259}
4260
4261// BSETn
4262OPCODE(0x08C0)
4263{
4264 u32 adr, res;
4265 u32 src, dst;
4266
4267 FETCH_BYTE(src);
4268 src = 1 << (src & 31);
4269 res = DREGu32((Opcode >> 0) & 7);
4270 flag_NotZ = res & src;
4271 res |= src;
4272 DREGu32((Opcode >> 0) & 7) = res;
4273RET(12)
4274}
4275
4276// BSETn
4277OPCODE(0x08D0)
4278{
4279 u32 adr, res;
4280 u32 src, dst;
4281
4282 FETCH_BYTE(src);
4283 src = 1 << (src & 7);
4284 adr = AREG((Opcode >> 0) & 7);
4285 PRE_IO
4286 READ_BYTE_F(adr, res)
4287 flag_NotZ = res & src;
4288 res |= src;
4289 WRITE_BYTE_F(adr, res)
4290 POST_IO
4291RET(16)
4292}
4293
4294// BSETn
4295OPCODE(0x08D8)
4296{
4297 u32 adr, res;
4298 u32 src, dst;
4299
4300 FETCH_BYTE(src);
4301 src = 1 << (src & 7);
4302 adr = AREG((Opcode >> 0) & 7);
4303 AREG((Opcode >> 0) & 7) += 1;
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(0x08E0)
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) - 1;
4322 AREG((Opcode >> 0) & 7) = adr;
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(18)
4330}
4331
4332// BSETn
4333OPCODE(0x08E8)
4334{
4335 u32 adr, res;
4336 u32 src, dst;
4337
4338 FETCH_BYTE(src);
4339 src = 1 << (src & 7);
4340 FETCH_SWORD(adr);
4341 adr += AREG((Opcode >> 0) & 7);
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(20)
4349}
4350
4351// BSETn
4352OPCODE(0x08F0)
4353{
4354 u32 adr, res;
4355 u32 src, dst;
4356
4357 FETCH_BYTE(src);
4358 src = 1 << (src & 7);
4359 adr = AREG((Opcode >> 0) & 7);
4360 DECODE_EXT_WORD
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(22)
4368}
4369
4370// BSETn
4371OPCODE(0x08F8)
4372{
4373 u32 adr, res;
4374 u32 src, dst;
4375
4376 FETCH_BYTE(src);
4377 src = 1 << (src & 7);
4378 FETCH_SWORD(adr);
4379 PRE_IO
4380 READ_BYTE_F(adr, res)
4381 flag_NotZ = res & src;
4382 res |= src;
4383 WRITE_BYTE_F(adr, res)
4384 POST_IO
4385RET(20)
4386}
4387
4388// BSETn
4389OPCODE(0x08F9)
4390{
4391 u32 adr, res;
4392 u32 src, dst;
4393
4394 FETCH_BYTE(src);
4395 src = 1 << (src & 7);
4396 FETCH_LONG(adr);
4397 PRE_IO
4398 READ_BYTE_F(adr, res)
4399 flag_NotZ = res & src;
4400 res |= src;
4401 WRITE_BYTE_F(adr, res)
4402 POST_IO
4403RET(24)
4404}
4405
4406// BSETn
4407OPCODE(0x08DF)
4408{
4409 u32 adr, res;
4410 u32 src, dst;
4411
4412 FETCH_BYTE(src);
4413 src = 1 << (src & 7);
4414 adr = AREG(7);
4415 AREG(7) += 2;
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(16)
4423}
4424
4425// BSETn
4426OPCODE(0x08E7)
4427{
4428 u32 adr, res;
4429 u32 src, dst;
4430
4431 FETCH_BYTE(src);
4432 src = 1 << (src & 7);
4433 adr = AREG(7) - 2;
4434 AREG(7) = adr;
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(18)
4442}
4443
4444// BTST
4445OPCODE(0x0100)
4446{
4447 u32 adr, res;
4448 u32 src, dst;
4449
4450 src = DREGu32((Opcode >> 9) & 7);
4451 src = 1 << (src & 31);
4452 res = DREGu32((Opcode >> 0) & 7);
4453 flag_NotZ = res & src;
4454RET(6)
4455}
4456
4457// BTST
4458OPCODE(0x0110)
4459{
4460 u32 adr, res;
4461 u32 src, dst;
4462
4463 src = DREGu8((Opcode >> 9) & 7);
4464 src = 1 << (src & 7);
4465 adr = AREG((Opcode >> 0) & 7);
4466 PRE_IO
4467 READ_BYTE_F(adr, res)
4468 flag_NotZ = res & src;
4469 POST_IO
4470RET(8)
4471}
4472
4473// BTST
4474OPCODE(0x0118)
4475{
4476 u32 adr, res;
4477 u32 src, dst;
4478
4479 src = DREGu8((Opcode >> 9) & 7);
4480 src = 1 << (src & 7);
4481 adr = AREG((Opcode >> 0) & 7);
4482 AREG((Opcode >> 0) & 7) += 1;
4483 PRE_IO
4484 READ_BYTE_F(adr, res)
4485 flag_NotZ = res & src;
4486 POST_IO
4487RET(8)
4488}
4489
4490// BTST
4491OPCODE(0x0120)
4492{
4493 u32 adr, res;
4494 u32 src, dst;
4495
4496 src = DREGu8((Opcode >> 9) & 7);
4497 src = 1 << (src & 7);
4498 adr = AREG((Opcode >> 0) & 7) - 1;
4499 AREG((Opcode >> 0) & 7) = adr;
4500 PRE_IO
4501 READ_BYTE_F(adr, res)
4502 flag_NotZ = res & src;
4503 POST_IO
4504RET(10)
4505}
4506
4507// BTST
4508OPCODE(0x0128)
4509{
4510 u32 adr, res;
4511 u32 src, dst;
4512
4513 src = DREGu8((Opcode >> 9) & 7);
4514 src = 1 << (src & 7);
4515 FETCH_SWORD(adr);
4516 adr += AREG((Opcode >> 0) & 7);
4517 PRE_IO
4518 READ_BYTE_F(adr, res)
4519 flag_NotZ = res & src;
4520 POST_IO
4521RET(12)
4522}
4523
4524// BTST
4525OPCODE(0x0130)
4526{
4527 u32 adr, res;
4528 u32 src, dst;
4529
4530 src = DREGu8((Opcode >> 9) & 7);
4531 src = 1 << (src & 7);
4532 adr = AREG((Opcode >> 0) & 7);
4533 DECODE_EXT_WORD
4534 PRE_IO
4535 READ_BYTE_F(adr, res)
4536 flag_NotZ = res & src;
4537 POST_IO
4538RET(14)
4539}
4540
4541// BTST
4542OPCODE(0x0138)
4543{
4544 u32 adr, res;
4545 u32 src, dst;
4546
4547 src = DREGu8((Opcode >> 9) & 7);
4548 src = 1 << (src & 7);
4549 FETCH_SWORD(adr);
4550 PRE_IO
4551 READ_BYTE_F(adr, res)
4552 flag_NotZ = res & src;
4553 POST_IO
4554RET(12)
4555}
4556
4557// BTST
4558OPCODE(0x0139)
4559{
4560 u32 adr, res;
4561 u32 src, dst;
4562
4563 src = DREGu8((Opcode >> 9) & 7);
4564 src = 1 << (src & 7);
4565 FETCH_LONG(adr);
4566 PRE_IO
4567 READ_BYTE_F(adr, res)
4568 flag_NotZ = res & src;
4569 POST_IO
4570RET(16)
4571}
4572
4573// BTST
4574OPCODE(0x013A)
4575{
4576 u32 adr, res;
4577 u32 src, dst;
4578
4579 src = DREGu8((Opcode >> 9) & 7);
4580 src = 1 << (src & 7);
be26eb23 4581 adr = GET_SWORD + GET_PC;
70357ce5 4582 PC++;
4583 PRE_IO
4584 READ_BYTE_F(adr, res)
4585 flag_NotZ = res & src;
4586 POST_IO
4587RET(12)
4588}
4589
4590// BTST
4591OPCODE(0x013B)
4592{
4593 u32 adr, res;
4594 u32 src, dst;
4595
4596 src = DREGu8((Opcode >> 9) & 7);
4597 src = 1 << (src & 7);
be26eb23 4598 adr = (uptr)(PC) - BasePC;
70357ce5 4599 DECODE_EXT_WORD
4600 PRE_IO
4601 READ_BYTE_F(adr, res)
4602 flag_NotZ = res & src;
4603 POST_IO
4604RET(14)
4605}
4606
4607// BTST
4608OPCODE(0x013C)
4609{
4610 u32 adr, res;
4611 u32 src, dst;
4612
4613 src = DREGu8((Opcode >> 9) & 7);
4614 src = 1 << (src & 7);
4615 FETCH_BYTE(res);
4616 flag_NotZ = res & src;
4617RET(8)
4618}
4619
4620// BTST
4621OPCODE(0x011F)
4622{
4623 u32 adr, res;
4624 u32 src, dst;
4625
4626 src = DREGu8((Opcode >> 9) & 7);
4627 src = 1 << (src & 7);
4628 adr = AREG(7);
4629 AREG(7) += 2;
4630 PRE_IO
4631 READ_BYTE_F(adr, res)
4632 flag_NotZ = res & src;
4633 POST_IO
4634RET(8)
4635}
4636
4637// BTST
4638OPCODE(0x0127)
4639{
4640 u32 adr, res;
4641 u32 src, dst;
4642
4643 src = DREGu8((Opcode >> 9) & 7);
4644 src = 1 << (src & 7);
4645 adr = AREG(7) - 2;
4646 AREG(7) = adr;
4647 PRE_IO
4648 READ_BYTE_F(adr, res)
4649 flag_NotZ = res & src;
4650 POST_IO
4651RET(10)
4652}
4653
4654// BCHG
4655OPCODE(0x0140)
4656{
4657 u32 adr, res;
4658 u32 src, dst;
4659
4660 src = DREGu32((Opcode >> 9) & 7);
4661 src = 1 << (src & 31);
4662 res = DREGu32((Opcode >> 0) & 7);
4663 flag_NotZ = res & src;
4664 res ^= src;
4665 DREGu32((Opcode >> 0) & 7) = res;
4666RET(8)
4667}
4668
4669// BCHG
4670OPCODE(0x0150)
4671{
4672 u32 adr, res;
4673 u32 src, dst;
4674
4675 src = DREGu8((Opcode >> 9) & 7);
4676 src = 1 << (src & 7);
4677 adr = AREG((Opcode >> 0) & 7);
4678 PRE_IO
4679 READ_BYTE_F(adr, res)
4680 flag_NotZ = res & src;
4681 res ^= src;
4682 WRITE_BYTE_F(adr, res)
4683 POST_IO
4684RET(12)
4685}
4686
4687// BCHG
4688OPCODE(0x0158)
4689{
4690 u32 adr, res;
4691 u32 src, dst;
4692
4693 src = DREGu8((Opcode >> 9) & 7);
4694 src = 1 << (src & 7);
4695 adr = AREG((Opcode >> 0) & 7);
4696 AREG((Opcode >> 0) & 7) += 1;
4697 PRE_IO
4698 READ_BYTE_F(adr, res)
4699 flag_NotZ = res & src;
4700 res ^= src;
4701 WRITE_BYTE_F(adr, res)
4702 POST_IO
4703RET(12)
4704}
4705
4706// BCHG
4707OPCODE(0x0160)
4708{
4709 u32 adr, res;
4710 u32 src, dst;
4711
4712 src = DREGu8((Opcode >> 9) & 7);
4713 src = 1 << (src & 7);
4714 adr = AREG((Opcode >> 0) & 7) - 1;
4715 AREG((Opcode >> 0) & 7) = adr;
4716 PRE_IO
4717 READ_BYTE_F(adr, res)
4718 flag_NotZ = res & src;
4719 res ^= src;
4720 WRITE_BYTE_F(adr, res)
4721 POST_IO
4722RET(14)
4723}
4724
4725// BCHG
4726OPCODE(0x0168)
4727{
4728 u32 adr, res;
4729 u32 src, dst;
4730
4731 src = DREGu8((Opcode >> 9) & 7);
4732 src = 1 << (src & 7);
4733 FETCH_SWORD(adr);
4734 adr += AREG((Opcode >> 0) & 7);
4735 PRE_IO
4736 READ_BYTE_F(adr, res)
4737 flag_NotZ = res & src;
4738 res ^= src;
4739 WRITE_BYTE_F(adr, res)
4740 POST_IO
4741RET(16)
4742}
4743
4744// BCHG
4745OPCODE(0x0170)
4746{
4747 u32 adr, res;
4748 u32 src, dst;
4749
4750 src = DREGu8((Opcode >> 9) & 7);
4751 src = 1 << (src & 7);
4752 adr = AREG((Opcode >> 0) & 7);
4753 DECODE_EXT_WORD
4754 PRE_IO
4755 READ_BYTE_F(adr, res)
4756 flag_NotZ = res & src;
4757 res ^= src;
4758 WRITE_BYTE_F(adr, res)
4759 POST_IO
4760RET(18)
4761}
4762
4763// BCHG
4764OPCODE(0x0178)
4765{
4766 u32 adr, res;
4767 u32 src, dst;
4768
4769 src = DREGu8((Opcode >> 9) & 7);
4770 src = 1 << (src & 7);
4771 FETCH_SWORD(adr);
4772 PRE_IO
4773 READ_BYTE_F(adr, res)
4774 flag_NotZ = res & src;
4775 res ^= src;
4776 WRITE_BYTE_F(adr, res)
4777 POST_IO
4778RET(16)
4779}
4780
4781// BCHG
4782OPCODE(0x0179)
4783{
4784 u32 adr, res;
4785 u32 src, dst;
4786
4787 src = DREGu8((Opcode >> 9) & 7);
4788 src = 1 << (src & 7);
4789 FETCH_LONG(adr);
4790 PRE_IO
4791 READ_BYTE_F(adr, res)
4792 flag_NotZ = res & src;
4793 res ^= src;
4794 WRITE_BYTE_F(adr, res)
4795 POST_IO
4796RET(20)
4797}
4798
4799// BCHG
4800OPCODE(0x015F)
4801{
4802 u32 adr, res;
4803 u32 src, dst;
4804
4805 src = DREGu8((Opcode >> 9) & 7);
4806 src = 1 << (src & 7);
4807 adr = AREG(7);
4808 AREG(7) += 2;
4809 PRE_IO
4810 READ_BYTE_F(adr, res)
4811 flag_NotZ = res & src;
4812 res ^= src;
4813 WRITE_BYTE_F(adr, res)
4814 POST_IO
4815RET(12)
4816}
4817
4818// BCHG
4819OPCODE(0x0167)
4820{
4821 u32 adr, res;
4822 u32 src, dst;
4823
4824 src = DREGu8((Opcode >> 9) & 7);
4825 src = 1 << (src & 7);
4826 adr = AREG(7) - 2;
4827 AREG(7) = adr;
4828 PRE_IO
4829 READ_BYTE_F(adr, res)
4830 flag_NotZ = res & src;
4831 res ^= src;
4832 WRITE_BYTE_F(adr, res)
4833 POST_IO
4834RET(14)
4835}
4836
4837// BCLR
4838OPCODE(0x0180)
4839{
4840 u32 adr, res;
4841 u32 src, dst;
4842
4843 src = DREGu32((Opcode >> 9) & 7);
4844 src = 1 << (src & 31);
4845 res = DREGu32((Opcode >> 0) & 7);
4846 flag_NotZ = res & src;
4847 res &= ~src;
4848 DREGu32((Opcode >> 0) & 7) = res;
4849RET(10)
4850}
4851
4852// BCLR
4853OPCODE(0x0190)
4854{
4855 u32 adr, res;
4856 u32 src, dst;
4857
4858 src = DREGu8((Opcode >> 9) & 7);
4859 src = 1 << (src & 7);
4860 adr = AREG((Opcode >> 0) & 7);
4861 PRE_IO
4862 READ_BYTE_F(adr, res)
4863 flag_NotZ = res & src;
4864 res &= ~src;
4865 WRITE_BYTE_F(adr, res)
4866 POST_IO
4867RET(12)
4868}
4869
4870// BCLR
4871OPCODE(0x0198)
4872{
4873 u32 adr, res;
4874 u32 src, dst;
4875
4876 src = DREGu8((Opcode >> 9) & 7);
4877 src = 1 << (src & 7);
4878 adr = AREG((Opcode >> 0) & 7);
4879 AREG((Opcode >> 0) & 7) += 1;
4880 PRE_IO
4881 READ_BYTE_F(adr, res)
4882 flag_NotZ = res & src;
4883 res &= ~src;
4884 WRITE_BYTE_F(adr, res)
4885 POST_IO
4886RET(12)
4887}
4888
4889// BCLR
4890OPCODE(0x01A0)
4891{
4892 u32 adr, res;
4893 u32 src, dst;
4894
4895 src = DREGu8((Opcode >> 9) & 7);
4896 src = 1 << (src & 7);
4897 adr = AREG((Opcode >> 0) & 7) - 1;
4898 AREG((Opcode >> 0) & 7) = adr;
4899 PRE_IO
4900 READ_BYTE_F(adr, res)
4901 flag_NotZ = res & src;
4902 res &= ~src;
4903 WRITE_BYTE_F(adr, res)
4904 POST_IO
4905RET(14)
4906}
4907
4908// BCLR
4909OPCODE(0x01A8)
4910{
4911 u32 adr, res;
4912 u32 src, dst;
4913
4914 src = DREGu8((Opcode >> 9) & 7);
4915 src = 1 << (src & 7);
4916 FETCH_SWORD(adr);
4917 adr += AREG((Opcode >> 0) & 7);
4918 PRE_IO
4919 READ_BYTE_F(adr, res)
4920 flag_NotZ = res & src;
4921 res &= ~src;
4922 WRITE_BYTE_F(adr, res)
4923 POST_IO
4924RET(16)
4925}
4926
4927// BCLR
4928OPCODE(0x01B0)
4929{
4930 u32 adr, res;
4931 u32 src, dst;
4932
4933 src = DREGu8((Opcode >> 9) & 7);
4934 src = 1 << (src & 7);
4935 adr = AREG((Opcode >> 0) & 7);
4936 DECODE_EXT_WORD
4937 PRE_IO
4938 READ_BYTE_F(adr, res)
4939 flag_NotZ = res & src;
4940 res &= ~src;
4941 WRITE_BYTE_F(adr, res)
4942 POST_IO
4943RET(18)
4944}
4945
4946// BCLR
4947OPCODE(0x01B8)
4948{
4949 u32 adr, res;
4950 u32 src, dst;
4951
4952 src = DREGu8((Opcode >> 9) & 7);
4953 src = 1 << (src & 7);
4954 FETCH_SWORD(adr);
4955 PRE_IO
4956 READ_BYTE_F(adr, res)
4957 flag_NotZ = res & src;
4958 res &= ~src;
4959 WRITE_BYTE_F(adr, res)
4960 POST_IO
4961RET(16)
4962}
4963
4964// BCLR
4965OPCODE(0x01B9)
4966{
4967 u32 adr, res;
4968 u32 src, dst;
4969
4970 src = DREGu8((Opcode >> 9) & 7);
4971 src = 1 << (src & 7);
4972 FETCH_LONG(adr);
4973 PRE_IO
4974 READ_BYTE_F(adr, res)
4975 flag_NotZ = res & src;
4976 res &= ~src;
4977 WRITE_BYTE_F(adr, res)
4978 POST_IO
4979RET(20)
4980}
4981
4982// BCLR
4983OPCODE(0x019F)
4984{
4985 u32 adr, res;
4986 u32 src, dst;
4987
4988 src = DREGu8((Opcode >> 9) & 7);
4989 src = 1 << (src & 7);
4990 adr = AREG(7);
4991 AREG(7) += 2;
4992 PRE_IO
4993 READ_BYTE_F(adr, res)
4994 flag_NotZ = res & src;
4995 res &= ~src;
4996 WRITE_BYTE_F(adr, res)
4997 POST_IO
4998RET(12)
4999}
5000
5001// BCLR
5002OPCODE(0x01A7)
5003{
5004 u32 adr, res;
5005 u32 src, dst;
5006
5007 src = DREGu8((Opcode >> 9) & 7);
5008 src = 1 << (src & 7);
5009 adr = AREG(7) - 2;
5010 AREG(7) = adr;
5011 PRE_IO
5012 READ_BYTE_F(adr, res)
5013 flag_NotZ = res & src;
5014 res &= ~src;
5015 WRITE_BYTE_F(adr, res)
5016 POST_IO
5017RET(14)
5018}
5019
5020// BSET
5021OPCODE(0x01C0)
5022{
5023 u32 adr, res;
5024 u32 src, dst;
5025
5026 src = DREGu32((Opcode >> 9) & 7);
5027 src = 1 << (src & 31);
5028 res = DREGu32((Opcode >> 0) & 7);
5029 flag_NotZ = res & src;
5030 res |= src;
5031 DREGu32((Opcode >> 0) & 7) = res;
5032RET(8)
5033}
5034
5035// BSET
5036OPCODE(0x01D0)
5037{
5038 u32 adr, res;
5039 u32 src, dst;
5040
5041 src = DREGu8((Opcode >> 9) & 7);
5042 src = 1 << (src & 7);
5043 adr = AREG((Opcode >> 0) & 7);
5044 PRE_IO
5045 READ_BYTE_F(adr, res)
5046 flag_NotZ = res & src;
5047 res |= src;
5048 WRITE_BYTE_F(adr, res)
5049 POST_IO
5050RET(12)
5051}
5052
5053// BSET
5054OPCODE(0x01D8)
5055{
5056 u32 adr, res;
5057 u32 src, dst;
5058
5059 src = DREGu8((Opcode >> 9) & 7);
5060 src = 1 << (src & 7);
5061 adr = AREG((Opcode >> 0) & 7);
5062 AREG((Opcode >> 0) & 7) += 1;
5063 PRE_IO
5064 READ_BYTE_F(adr, res)
5065 flag_NotZ = res & src;
5066 res |= src;
5067 WRITE_BYTE_F(adr, res)
5068 POST_IO
5069RET(12)
5070}
5071
5072// BSET
5073OPCODE(0x01E0)
5074{
5075 u32 adr, res;
5076 u32 src, dst;
5077
5078 src = DREGu8((Opcode >> 9) & 7);
5079 src = 1 << (src & 7);
5080 adr = AREG((Opcode >> 0) & 7) - 1;
5081 AREG((Opcode >> 0) & 7) = adr;
5082 PRE_IO
5083 READ_BYTE_F(adr, res)
5084 flag_NotZ = res & src;
5085 res |= src;
5086 WRITE_BYTE_F(adr, res)
5087 POST_IO
5088RET(14)
5089}
5090
5091// BSET
5092OPCODE(0x01E8)
5093{
5094 u32 adr, res;
5095 u32 src, dst;
5096
5097 src = DREGu8((Opcode >> 9) & 7);
5098 src = 1 << (src & 7);
5099 FETCH_SWORD(adr);
5100 adr += AREG((Opcode >> 0) & 7);
5101 PRE_IO
5102 READ_BYTE_F(adr, res)
5103 flag_NotZ = res & src;
5104 res |= src;
5105 WRITE_BYTE_F(adr, res)
5106 POST_IO
5107RET(16)
5108}
5109
5110// BSET
5111OPCODE(0x01F0)
5112{
5113 u32 adr, res;
5114 u32 src, dst;
5115
5116 src = DREGu8((Opcode >> 9) & 7);
5117 src = 1 << (src & 7);
5118 adr = AREG((Opcode >> 0) & 7);
5119 DECODE_EXT_WORD
5120 PRE_IO
5121 READ_BYTE_F(adr, res)
5122 flag_NotZ = res & src;
5123 res |= src;
5124 WRITE_BYTE_F(adr, res)
5125 POST_IO
5126RET(18)
5127}
5128
5129// BSET
5130OPCODE(0x01F8)
5131{
5132 u32 adr, res;
5133 u32 src, dst;
5134
5135 src = DREGu8((Opcode >> 9) & 7);
5136 src = 1 << (src & 7);
5137 FETCH_SWORD(adr);
5138 PRE_IO
5139 READ_BYTE_F(adr, res)
5140 flag_NotZ = res & src;
5141 res |= src;
5142 WRITE_BYTE_F(adr, res)
5143 POST_IO
5144RET(16)
5145}
5146
5147// BSET
5148OPCODE(0x01F9)
5149{
5150 u32 adr, res;
5151 u32 src, dst;
5152
5153 src = DREGu8((Opcode >> 9) & 7);
5154 src = 1 << (src & 7);
5155 FETCH_LONG(adr);
5156 PRE_IO
5157 READ_BYTE_F(adr, res)
5158 flag_NotZ = res & src;
5159 res |= src;
5160 WRITE_BYTE_F(adr, res)
5161 POST_IO
5162RET(20)
5163}
5164
5165// BSET
5166OPCODE(0x01DF)
5167{
5168 u32 adr, res;
5169 u32 src, dst;
5170
5171 src = DREGu8((Opcode >> 9) & 7);
5172 src = 1 << (src & 7);
5173 adr = AREG(7);
5174 AREG(7) += 2;
5175 PRE_IO
5176 READ_BYTE_F(adr, res)
5177 flag_NotZ = res & src;
5178 res |= src;
5179 WRITE_BYTE_F(adr, res)
5180 POST_IO
5181RET(12)
5182}
5183
5184// BSET
5185OPCODE(0x01E7)
5186{
5187 u32 adr, res;
5188 u32 src, dst;
5189
5190 src = DREGu8((Opcode >> 9) & 7);
5191 src = 1 << (src & 7);
5192 adr = AREG(7) - 2;
5193 AREG(7) = adr;
5194 PRE_IO
5195 READ_BYTE_F(adr, res)
5196 flag_NotZ = res & src;
5197 res |= src;
5198 WRITE_BYTE_F(adr, res)
5199 POST_IO
5200RET(14)
5201}
5202
5203// MOVEPWaD
5204OPCODE(0x0108)
5205{
5206 u32 adr, res;
5207 u32 src, dst;
5208
5209 FETCH_SWORD(adr);
5210 adr += AREG((Opcode >> 0) & 7);
5211 PRE_IO
5212 READ_BYTE_F(adr + 0, res)
5213 READ_BYTE_F(adr + 2, src)
5214 DREGu16((Opcode >> 9) & 7) = (res << 8) | src;
5215 POST_IO
03e4f2a3 5216#ifdef USE_CYCLONE_TIMING
5217RET(16)
5218#else
70357ce5 5219RET(24)
03e4f2a3 5220#endif
70357ce5 5221}
5222
5223// MOVEPLaD
5224OPCODE(0x0148)
5225{
5226 u32 adr, res;
5227 u32 src, dst;
5228
5229 FETCH_SWORD(adr);
5230 adr += AREG((Opcode >> 0) & 7);
5231 PRE_IO
5232 READ_BYTE_F(adr, res)
5233 res <<= 24;
5234 adr += 2;
5235 READ_BYTE_F(adr, src)
5236 res |= src << 16;
5237 adr += 2;
5238 READ_BYTE_F(adr, src)
5239 res |= src << 8;
5240 adr += 2;
5241 READ_BYTE_F(adr, src)
5242 DREG((Opcode >> 9) & 7) = res | src;
5243 POST_IO
03e4f2a3 5244#ifdef USE_CYCLONE_TIMING
5245RET(24)
5246#else
70357ce5 5247RET(32)
03e4f2a3 5248#endif
70357ce5 5249}
5250
5251// MOVEPWDa
5252OPCODE(0x0188)
5253{
5254 u32 adr, res;
5255 u32 src, dst;
5256
5257 res = DREGu32((Opcode >> 9) & 7);
5258 FETCH_SWORD(adr);
5259 adr += AREG((Opcode >> 0) & 7);
5260 PRE_IO
5261 WRITE_BYTE_F(adr + 0, res >> 8)
5262 WRITE_BYTE_F(adr + 2, res >> 0)
5263 POST_IO
03e4f2a3 5264#ifdef USE_CYCLONE_TIMING
5265RET(16)
5266#else
70357ce5 5267RET(24)
03e4f2a3 5268#endif
70357ce5 5269}
5270
5271// MOVEPLDa
5272OPCODE(0x01C8)
5273{
5274 u32 adr, res;
5275 u32 src, dst;
5276
5277 res = DREGu32((Opcode >> 9) & 7);
5278 FETCH_SWORD(adr);
5279 adr += AREG((Opcode >> 0) & 7);
5280 PRE_IO
5281 WRITE_BYTE_F(adr, res >> 24)
5282 adr += 2;
5283 WRITE_BYTE_F(adr, res >> 16)
5284 adr += 2;
5285 WRITE_BYTE_F(adr, res >> 8)
5286 adr += 2;
5287 WRITE_BYTE_F(adr, res >> 0)
5288 POST_IO
03e4f2a3 5289#ifdef USE_CYCLONE_TIMING
5290RET(24)
5291#else
70357ce5 5292RET(32)
03e4f2a3 5293#endif
70357ce5 5294}
5295
5296// MOVEB
5297OPCODE(0x1000)
5298{
5299 u32 adr, res;
5300 u32 src, dst;
5301
5302 res = DREGu8((Opcode >> 0) & 7);
5303 flag_C = 0;
5304 flag_V = 0;
5305 flag_NotZ = res;
5306 flag_N = res;
5307 DREGu8((Opcode >> 9) & 7) = res;
5308RET(4)
5309}
5310
5311// MOVEB
5312OPCODE(0x1080)
5313{
5314 u32 adr, res;
5315 u32 src, dst;
5316
5317 res = DREGu8((Opcode >> 0) & 7);
5318 flag_C = 0;
5319 flag_V = 0;
5320 flag_NotZ = res;
5321 flag_N = res;
5322 adr = AREG((Opcode >> 9) & 7);
5323 PRE_IO
5324 WRITE_BYTE_F(adr, res)
5325 POST_IO
5326RET(8)
5327}
5328
5329// MOVEB
5330OPCODE(0x10C0)
5331{
5332 u32 adr, res;
5333 u32 src, dst;
5334
5335 res = DREGu8((Opcode >> 0) & 7);
5336 flag_C = 0;
5337 flag_V = 0;
5338 flag_NotZ = res;
5339 flag_N = res;
5340 adr = AREG((Opcode >> 9) & 7);
5341 AREG((Opcode >> 9) & 7) += 1;
5342 PRE_IO
5343 WRITE_BYTE_F(adr, res)
5344 POST_IO
5345RET(8)
5346}
5347
5348// MOVEB
5349OPCODE(0x1100)
5350{
5351 u32 adr, res;
5352 u32 src, dst;
5353
5354 res = DREGu8((Opcode >> 0) & 7);
5355 flag_C = 0;
5356 flag_V = 0;
5357 flag_NotZ = res;
5358 flag_N = res;
5359 adr = AREG((Opcode >> 9) & 7) - 1;
5360 AREG((Opcode >> 9) & 7) = adr;
5361 PRE_IO
5362 WRITE_BYTE_F(adr, res)
5363 POST_IO
5364RET(8)
5365}
5366
5367// MOVEB
5368OPCODE(0x1140)
5369{
5370 u32 adr, res;
5371 u32 src, dst;
5372
5373 res = DREGu8((Opcode >> 0) & 7);
5374 flag_C = 0;
5375 flag_V = 0;
5376 flag_NotZ = res;
5377 flag_N = res;
5378 FETCH_SWORD(adr);
5379 adr += AREG((Opcode >> 9) & 7);
5380 PRE_IO
5381 WRITE_BYTE_F(adr, res)
5382 POST_IO
5383RET(12)
5384}
5385
5386// MOVEB
5387OPCODE(0x1180)
5388{
5389 u32 adr, res;
5390 u32 src, dst;
5391
5392 res = DREGu8((Opcode >> 0) & 7);
5393 flag_C = 0;
5394 flag_V = 0;
5395 flag_NotZ = res;
5396 flag_N = res;
5397 adr = AREG((Opcode >> 9) & 7);
5398 DECODE_EXT_WORD
5399 PRE_IO
5400 WRITE_BYTE_F(adr, res)
5401 POST_IO
5402RET(14)
5403}
5404
5405// MOVEB
5406OPCODE(0x11C0)
5407{
5408 u32 adr, res;
5409 u32 src, dst;
5410
5411 res = DREGu8((Opcode >> 0) & 7);
5412 flag_C = 0;
5413 flag_V = 0;
5414 flag_NotZ = res;
5415 flag_N = res;
5416 FETCH_SWORD(adr);
5417 PRE_IO
5418 WRITE_BYTE_F(adr, res)
5419 POST_IO
5420RET(12)
5421}
5422
5423// MOVEB
5424OPCODE(0x13C0)
5425{
5426 u32 adr, res;
5427 u32 src, dst;
5428
5429 res = DREGu8((Opcode >> 0) & 7);
5430 flag_C = 0;
5431 flag_V = 0;
5432 flag_NotZ = res;
5433 flag_N = res;
5434 FETCH_LONG(adr);
5435 PRE_IO
5436 WRITE_BYTE_F(adr, res)
5437 POST_IO
5438RET(16)
5439}
5440
5441// MOVEB
5442OPCODE(0x1EC0)
5443{
5444 u32 adr, res;
5445 u32 src, dst;
5446
5447 res = DREGu8((Opcode >> 0) & 7);
5448 flag_C = 0;
5449 flag_V = 0;
5450 flag_NotZ = res;
5451 flag_N = res;
5452 adr = AREG(7);
5453 AREG(7) += 2;
5454 PRE_IO
5455 WRITE_BYTE_F(adr, res)
5456 POST_IO
5457RET(8)
5458}
5459
5460// MOVEB
5461OPCODE(0x1F00)
5462{
5463 u32 adr, res;
5464 u32 src, dst;
5465
5466 res = DREGu8((Opcode >> 0) & 7);
5467 flag_C = 0;
5468 flag_V = 0;
5469 flag_NotZ = res;
5470 flag_N = res;
5471 adr = AREG(7) - 2;
5472 AREG(7) = adr;
5473 PRE_IO
5474 WRITE_BYTE_F(adr, res)
5475 POST_IO
5476RET(8)
5477}
5478
03e4f2a3 5479#if 0
70357ce5 5480// MOVEB
5481OPCODE(0x1008)
5482{
5483 u32 adr, res;
5484 u32 src, dst;
5485
5486 // can't read byte from Ax registers !
5487 m68kcontext.execinfo |= M68K_FAULTED;
5488 m68kcontext.io_cycle_counter = 0;
5489/*
5490 goto famec_Exec_End;
5491 flag_C = 0;
5492 flag_V = 0;
5493 flag_NotZ = res;
5494 flag_N = res;
5495 DREGu8((Opcode >> 9) & 7) = res;
5496*/
5497RET(4)
5498}
5499
5500// MOVEB
5501OPCODE(0x1088)
5502{
5503 u32 adr, res;
5504 u32 src, dst;
5505
5506 // can't read byte from Ax registers !
5507 m68kcontext.execinfo |= M68K_FAULTED;
5508 m68kcontext.io_cycle_counter = 0;
5509/*
5510 goto famec_Exec_End;
5511 flag_C = 0;
5512 flag_V = 0;
5513 flag_NotZ = res;
5514 flag_N = res;
5515 adr = AREG((Opcode >> 9) & 7);
5516 PRE_IO
5517 WRITE_BYTE_F(adr, res)
5518 POST_IO
5519*/
5520RET(8)
5521}
5522
5523// MOVEB
5524OPCODE(0x10C8)
5525{
5526 u32 adr, res;
5527 u32 src, dst;
5528
5529 // can't read byte from Ax registers !
5530 m68kcontext.execinfo |= M68K_FAULTED;
5531 m68kcontext.io_cycle_counter = 0;
5532/*
5533 goto famec_Exec_End;
5534 flag_C = 0;
5535 flag_V = 0;
5536 flag_NotZ = res;
5537 flag_N = res;
5538 adr = AREG((Opcode >> 9) & 7);
5539 AREG((Opcode >> 9) & 7) += 1;
5540 PRE_IO
5541 WRITE_BYTE_F(adr, res)
5542 POST_IO
5543*/
5544RET(8)
5545}
5546
5547// MOVEB
5548OPCODE(0x1108)
5549{
5550 u32 adr, res;
5551 u32 src, dst;
5552
5553 // can't read byte from Ax registers !
5554 m68kcontext.execinfo |= M68K_FAULTED;
5555 m68kcontext.io_cycle_counter = 0;
5556/*
5557 goto famec_Exec_End;
5558 flag_C = 0;
5559 flag_V = 0;
5560 flag_NotZ = res;
5561 flag_N = res;
5562 adr = AREG((Opcode >> 9) & 7) - 1;
5563 AREG((Opcode >> 9) & 7) = adr;
5564 PRE_IO
5565 WRITE_BYTE_F(adr, res)
5566 POST_IO
5567*/
5568RET(8)
5569}
5570
5571// MOVEB
5572OPCODE(0x1148)
5573{
5574 u32 adr, res;
5575 u32 src, dst;
5576
5577 // can't read byte from Ax registers !
5578 m68kcontext.execinfo |= M68K_FAULTED;
5579 m68kcontext.io_cycle_counter = 0;
5580/*
5581 goto famec_Exec_End;
5582 flag_C = 0;
5583 flag_V = 0;
5584 flag_NotZ = res;
5585 flag_N = res;
5586 FETCH_SWORD(adr);
5587 adr += AREG((Opcode >> 9) & 7);
5588 PRE_IO
5589 WRITE_BYTE_F(adr, res)
5590 POST_IO
5591*/
5592RET(12)
5593}
5594
5595// MOVEB
5596OPCODE(0x1188)
5597{
5598 u32 adr, res;
5599 u32 src, dst;
5600
5601 // can't read byte from Ax registers !
5602 m68kcontext.execinfo |= M68K_FAULTED;
5603 m68kcontext.io_cycle_counter = 0;
5604/*
5605 goto famec_Exec_End;
5606 flag_C = 0;
5607 flag_V = 0;
5608 flag_NotZ = res;
5609 flag_N = res;
5610 adr = AREG((Opcode >> 9) & 7);
5611 DECODE_EXT_WORD
5612 PRE_IO
5613 WRITE_BYTE_F(adr, res)
5614 POST_IO
5615*/
5616RET(14)
5617}
5618
5619// MOVEB
5620OPCODE(0x11C8)
5621{
5622 u32 adr, res;
5623 u32 src, dst;
5624
5625 // can't read byte from Ax registers !
5626 m68kcontext.execinfo |= M68K_FAULTED;
5627 m68kcontext.io_cycle_counter = 0;
5628/*
5629 goto famec_Exec_End;
5630 flag_C = 0;
5631 flag_V = 0;
5632 flag_NotZ = res;
5633 flag_N = res;
5634 FETCH_SWORD(adr);
5635 PRE_IO
5636 WRITE_BYTE_F(adr, res)
5637 POST_IO
5638*/
5639RET(12)
5640}
5641
5642// MOVEB
5643OPCODE(0x13C8)
5644{
5645 u32 adr, res;
5646 u32 src, dst;
5647
5648 // can't read byte from Ax registers !
5649 m68kcontext.execinfo |= M68K_FAULTED;
5650 m68kcontext.io_cycle_counter = 0;
5651/*
5652 goto famec_Exec_End;
5653 flag_C = 0;
5654 flag_V = 0;
5655 flag_NotZ = res;
5656 flag_N = res;
5657 FETCH_LONG(adr);
5658 PRE_IO
5659 WRITE_BYTE_F(adr, res)
5660 POST_IO
5661*/
5662RET(16)
5663}
5664
5665// MOVEB
5666OPCODE(0x1EC8)
5667{
5668 u32 adr, res;
5669 u32 src, dst;
5670
5671 // can't read byte from Ax registers !
5672 m68kcontext.execinfo |= M68K_FAULTED;
5673 m68kcontext.io_cycle_counter = 0;
5674/*
5675 goto famec_Exec_End;
5676 flag_C = 0;
5677 flag_V = 0;
5678 flag_NotZ = res;
5679 flag_N = res;
5680 adr = AREG(7);
5681 AREG(7) += 2;
5682 PRE_IO
5683 WRITE_BYTE_F(adr, res)
5684 POST_IO
5685*/
5686RET(8)
5687}
5688
5689// MOVEB
5690OPCODE(0x1F08)
5691{
5692 u32 adr, res;
5693 u32 src, dst;
5694
5695 // can't read byte from Ax registers !
5696 m68kcontext.execinfo |= M68K_FAULTED;
5697 m68kcontext.io_cycle_counter = 0;
5698/*
5699 goto famec_Exec_End;
5700 flag_C = 0;
5701 flag_V = 0;
5702 flag_NotZ = res;
5703 flag_N = res;
5704 adr = AREG(7) - 2;
5705 AREG(7) = adr;
5706 PRE_IO
5707 WRITE_BYTE_F(adr, res)
5708 POST_IO
5709*/
5710RET(8)
5711}
03e4f2a3 5712#endif
70357ce5 5713
5714// MOVEB
5715OPCODE(0x1010)
5716{
5717 u32 adr, res;
5718 u32 src, dst;
5719
5720 adr = AREG((Opcode >> 0) & 7);
5721 PRE_IO
5722 READ_BYTE_F(adr, res)
5723 flag_C = 0;
5724 flag_V = 0;
5725 flag_NotZ = res;
5726 flag_N = res;
5727 DREGu8((Opcode >> 9) & 7) = res;
5728 POST_IO
5729RET(8)
5730}
5731
5732// MOVEB
5733OPCODE(0x1090)
5734{
5735 u32 adr, res;
5736 u32 src, dst;
5737
5738 adr = AREG((Opcode >> 0) & 7);
5739 PRE_IO
5740 READ_BYTE_F(adr, res)
5741 flag_C = 0;
5742 flag_V = 0;
5743 flag_NotZ = res;
5744 flag_N = res;
5745 adr = AREG((Opcode >> 9) & 7);
5746 WRITE_BYTE_F(adr, res)
5747 POST_IO
5748RET(12)
5749}
5750
5751// MOVEB
5752OPCODE(0x10D0)
5753{
5754 u32 adr, res;
5755 u32 src, dst;
5756
5757 adr = AREG((Opcode >> 0) & 7);
5758 PRE_IO
5759 READ_BYTE_F(adr, res)
5760 flag_C = 0;
5761 flag_V = 0;
5762 flag_NotZ = res;
5763 flag_N = res;
5764 adr = AREG((Opcode >> 9) & 7);
5765 AREG((Opcode >> 9) & 7) += 1;
5766 WRITE_BYTE_F(adr, res)
5767 POST_IO
5768RET(12)
5769}
5770
5771// MOVEB
5772OPCODE(0x1110)
5773{
5774 u32 adr, res;
5775 u32 src, dst;
5776
5777 adr = AREG((Opcode >> 0) & 7);
5778 PRE_IO
5779 READ_BYTE_F(adr, res)
5780 flag_C = 0;
5781 flag_V = 0;
5782 flag_NotZ = res;
5783 flag_N = res;
5784 adr = AREG((Opcode >> 9) & 7) - 1;
5785 AREG((Opcode >> 9) & 7) = adr;
5786 WRITE_BYTE_F(adr, res)
5787 POST_IO
5788RET(12)
5789}
5790
5791// MOVEB
5792OPCODE(0x1150)
5793{
5794 u32 adr, res;
5795 u32 src, dst;
5796
5797 adr = AREG((Opcode >> 0) & 7);
5798 PRE_IO
5799 READ_BYTE_F(adr, res)
5800 flag_C = 0;
5801 flag_V = 0;
5802 flag_NotZ = res;
5803 flag_N = res;
5804 FETCH_SWORD(adr);
5805 adr += AREG((Opcode >> 9) & 7);
5806 WRITE_BYTE_F(adr, res)
5807 POST_IO
5808RET(16)
5809}
5810
5811// MOVEB
5812OPCODE(0x1190)
5813{
5814 u32 adr, res;
5815 u32 src, dst;
5816
5817 adr = AREG((Opcode >> 0) & 7);
5818 PRE_IO
5819 READ_BYTE_F(adr, res)
5820 flag_C = 0;
5821 flag_V = 0;
5822 flag_NotZ = res;
5823 flag_N = res;
5824 adr = AREG((Opcode >> 9) & 7);
5825 DECODE_EXT_WORD
5826 WRITE_BYTE_F(adr, res)
5827 POST_IO
5828RET(18)
5829}
5830
5831// MOVEB
5832OPCODE(0x11D0)
5833{
5834 u32 adr, res;
5835 u32 src, dst;
5836
5837 adr = AREG((Opcode >> 0) & 7);
5838 PRE_IO
5839 READ_BYTE_F(adr, res)
5840 flag_C = 0;
5841 flag_V = 0;
5842 flag_NotZ = res;
5843 flag_N = res;
5844 FETCH_SWORD(adr);
5845 WRITE_BYTE_F(adr, res)
5846 POST_IO
5847RET(16)
5848}
5849
5850// MOVEB
5851OPCODE(0x13D0)
5852{
5853 u32 adr, res;
5854 u32 src, dst;
5855
5856 adr = AREG((Opcode >> 0) & 7);
5857 PRE_IO
5858 READ_BYTE_F(adr, res)
5859 flag_C = 0;
5860 flag_V = 0;
5861 flag_NotZ = res;
5862 flag_N = res;
5863 FETCH_LONG(adr);
5864 WRITE_BYTE_F(adr, res)
5865 POST_IO
5866RET(20)
5867}
5868
5869// MOVEB
5870OPCODE(0x1ED0)
5871{
5872 u32 adr, res;
5873 u32 src, dst;
5874
5875 adr = AREG((Opcode >> 0) & 7);
5876 PRE_IO
5877 READ_BYTE_F(adr, res)
5878 flag_C = 0;
5879 flag_V = 0;
5880 flag_NotZ = res;
5881 flag_N = res;
5882 adr = AREG(7);
5883 AREG(7) += 2;
5884 WRITE_BYTE_F(adr, res)
5885 POST_IO
5886RET(12)
5887}
5888
5889// MOVEB
5890OPCODE(0x1F10)
5891{
5892 u32 adr, res;
5893 u32 src, dst;
5894
5895 adr = AREG((Opcode >> 0) & 7);
5896 PRE_IO
5897 READ_BYTE_F(adr, res)
5898 flag_C = 0;
5899 flag_V = 0;
5900 flag_NotZ = res;
5901 flag_N = res;
5902 adr = AREG(7) - 2;
5903 AREG(7) = adr;
5904 WRITE_BYTE_F(adr, res)
5905 POST_IO
5906RET(12)
5907}
5908
5909// MOVEB
5910OPCODE(0x1018)
5911{
5912 u32 adr, res;
5913 u32 src, dst;
5914
5915 adr = AREG((Opcode >> 0) & 7);
5916 AREG((Opcode >> 0) & 7) += 1;
5917 PRE_IO
5918 READ_BYTE_F(adr, res)
5919 flag_C = 0;
5920 flag_V = 0;
5921 flag_NotZ = res;
5922 flag_N = res;
5923 DREGu8((Opcode >> 9) & 7) = res;
5924 POST_IO
5925RET(8)
5926}
5927
5928// MOVEB
5929OPCODE(0x1098)
5930{
5931 u32 adr, res;
5932 u32 src, dst;
5933
5934 adr = AREG((Opcode >> 0) & 7);
5935 AREG((Opcode >> 0) & 7) += 1;
5936 PRE_IO
5937 READ_BYTE_F(adr, res)
5938 flag_C = 0;
5939 flag_V = 0;
5940 flag_NotZ = res;
5941 flag_N = res;
5942 adr = AREG((Opcode >> 9) & 7);
5943 WRITE_BYTE_F(adr, res)
5944 POST_IO
5945RET(12)
5946}
5947
5948// MOVEB
5949OPCODE(0x10D8)
5950{
5951 u32 adr, res;
5952 u32 src, dst;
5953
5954 adr = AREG((Opcode >> 0) & 7);
5955 AREG((Opcode >> 0) & 7) += 1;
5956 PRE_IO
5957 READ_BYTE_F(adr, res)
5958 flag_C = 0;
5959 flag_V = 0;
5960 flag_NotZ = res;
5961 flag_N = res;
5962 adr = AREG((Opcode >> 9) & 7);
5963 AREG((Opcode >> 9) & 7) += 1;
5964 WRITE_BYTE_F(adr, res)
5965 POST_IO
5966RET(12)
5967}
5968
5969// MOVEB
5970OPCODE(0x1118)
5971{
5972 u32 adr, res;
5973 u32 src, dst;
5974
5975 adr = AREG((Opcode >> 0) & 7);
5976 AREG((Opcode >> 0) & 7) += 1;
5977 PRE_IO
5978 READ_BYTE_F(adr, res)
5979 flag_C = 0;
5980 flag_V = 0;
5981 flag_NotZ = res;
5982 flag_N = res;
5983 adr = AREG((Opcode >> 9) & 7) - 1;
5984 AREG((Opcode >> 9) & 7) = adr;
5985 WRITE_BYTE_F(adr, res)
5986 POST_IO
5987RET(12)
5988}
5989
5990// MOVEB
5991OPCODE(0x1158)
5992{
5993 u32 adr, res;
5994 u32 src, dst;
5995
5996 adr = AREG((Opcode >> 0) & 7);
5997 AREG((Opcode >> 0) & 7) += 1;
5998 PRE_IO
5999 READ_BYTE_F(adr, res)
6000 flag_C = 0;
6001 flag_V = 0;
6002 flag_NotZ = res;
6003 flag_N = res;
6004 FETCH_SWORD(adr);
6005 adr += AREG((Opcode >> 9) & 7);
6006 WRITE_BYTE_F(adr, res)
6007 POST_IO
6008RET(16)
6009}
6010
6011// MOVEB
6012OPCODE(0x1198)
6013{
6014 u32 adr, res;
6015 u32 src, dst;
6016
6017 adr = AREG((Opcode >> 0) & 7);
6018 AREG((Opcode >> 0) & 7) += 1;
6019 PRE_IO
6020 READ_BYTE_F(adr, res)
6021 flag_C = 0;
6022 flag_V = 0;
6023 flag_NotZ = res;
6024 flag_N = res;
6025 adr = AREG((Opcode >> 9) & 7);
6026 DECODE_EXT_WORD
6027 WRITE_BYTE_F(adr, res)
6028 POST_IO
6029RET(18)
6030}
6031
6032// MOVEB
6033OPCODE(0x11D8)
6034{
6035 u32 adr, res;
6036 u32 src, dst;
6037
6038 adr = AREG((Opcode >> 0) & 7);
6039 AREG((Opcode >> 0) & 7) += 1;
6040 PRE_IO
6041 READ_BYTE_F(adr, res)
6042 flag_C = 0;
6043 flag_V = 0;
6044 flag_NotZ = res;
6045 flag_N = res;
6046 FETCH_SWORD(adr);
6047 WRITE_BYTE_F(adr, res)
6048 POST_IO
6049RET(16)
6050}
6051
6052// MOVEB
6053OPCODE(0x13D8)
6054{
6055 u32 adr, res;
6056 u32 src, dst;
6057
6058 adr = AREG((Opcode >> 0) & 7);
6059 AREG((Opcode >> 0) & 7) += 1;
6060 PRE_IO
6061 READ_BYTE_F(adr, res)
6062 flag_C = 0;
6063 flag_V = 0;
6064 flag_NotZ = res;
6065 flag_N = res;
6066 FETCH_LONG(adr);
6067 WRITE_BYTE_F(adr, res)
6068 POST_IO
6069RET(20)
6070}
6071
6072// MOVEB
6073OPCODE(0x1ED8)
6074{
6075 u32 adr, res;
6076 u32 src, dst;
6077
6078 adr = AREG((Opcode >> 0) & 7);
6079 AREG((Opcode >> 0) & 7) += 1;
6080 PRE_IO
6081 READ_BYTE_F(adr, res)
6082 flag_C = 0;
6083 flag_V = 0;
6084 flag_NotZ = res;
6085 flag_N = res;
6086 adr = AREG(7);
6087 AREG(7) += 2;
6088 WRITE_BYTE_F(adr, res)
6089 POST_IO
6090RET(12)
6091}
6092
6093// MOVEB
6094OPCODE(0x1F18)
6095{
6096 u32 adr, res;
6097 u32 src, dst;
6098
6099 adr = AREG((Opcode >> 0) & 7);
6100 AREG((Opcode >> 0) & 7) += 1;
6101 PRE_IO
6102 READ_BYTE_F(adr, res)
6103 flag_C = 0;
6104 flag_V = 0;
6105 flag_NotZ = res;
6106 flag_N = res;
6107 adr = AREG(7) - 2;
6108 AREG(7) = adr;
6109 WRITE_BYTE_F(adr, res)
6110 POST_IO
6111RET(12)
6112}
6113
6114// MOVEB
6115OPCODE(0x1020)
6116{
6117 u32 adr, res;
6118 u32 src, dst;
6119
6120 adr = AREG((Opcode >> 0) & 7) - 1;
6121 AREG((Opcode >> 0) & 7) = adr;
6122 PRE_IO
6123 READ_BYTE_F(adr, res)
6124 flag_C = 0;
6125 flag_V = 0;
6126 flag_NotZ = res;
6127 flag_N = res;
6128 DREGu8((Opcode >> 9) & 7) = res;
6129 POST_IO
6130RET(10)
6131}
6132
6133// MOVEB
6134OPCODE(0x10A0)
6135{
6136 u32 adr, res;
6137 u32 src, dst;
6138
6139 adr = AREG((Opcode >> 0) & 7) - 1;
6140 AREG((Opcode >> 0) & 7) = adr;
6141 PRE_IO
6142 READ_BYTE_F(adr, res)
6143 flag_C = 0;
6144 flag_V = 0;
6145 flag_NotZ = res;
6146 flag_N = res;
6147 adr = AREG((Opcode >> 9) & 7);
6148 WRITE_BYTE_F(adr, res)
6149 POST_IO
6150RET(14)
6151}
6152
6153// MOVEB
6154OPCODE(0x10E0)
6155{
6156 u32 adr, res;
6157 u32 src, dst;
6158
6159 adr = AREG((Opcode >> 0) & 7) - 1;
6160 AREG((Opcode >> 0) & 7) = adr;
6161 PRE_IO
6162 READ_BYTE_F(adr, res)
6163 flag_C = 0;
6164 flag_V = 0;
6165 flag_NotZ = res;
6166 flag_N = res;
6167 adr = AREG((Opcode >> 9) & 7);
6168 AREG((Opcode >> 9) & 7) += 1;
6169 WRITE_BYTE_F(adr, res)
6170 POST_IO
6171RET(14)
6172}
6173
6174// MOVEB
6175OPCODE(0x1120)
6176{
6177 u32 adr, res;
6178 u32 src, dst;
6179
6180 adr = AREG((Opcode >> 0) & 7) - 1;
6181 AREG((Opcode >> 0) & 7) = adr;
6182 PRE_IO
6183 READ_BYTE_F(adr, res)
6184 flag_C = 0;
6185 flag_V = 0;
6186 flag_NotZ = res;
6187 flag_N = res;
6188 adr = AREG((Opcode >> 9) & 7) - 1;
6189 AREG((Opcode >> 9) & 7) = adr;
6190 WRITE_BYTE_F(adr, res)
6191 POST_IO
6192RET(14)
6193}
6194
6195// MOVEB
6196OPCODE(0x1160)
6197{
6198 u32 adr, res;
6199 u32 src, dst;
6200
6201 adr = AREG((Opcode >> 0) & 7) - 1;
6202 AREG((Opcode >> 0) & 7) = adr;
6203 PRE_IO
6204 READ_BYTE_F(adr, res)
6205 flag_C = 0;
6206 flag_V = 0;
6207 flag_NotZ = res;
6208 flag_N = res;
6209 FETCH_SWORD(adr);
6210 adr += AREG((Opcode >> 9) & 7);
6211 WRITE_BYTE_F(adr, res)
6212 POST_IO
6213RET(18)
6214}
6215
6216// MOVEB
6217OPCODE(0x11A0)
6218{
6219 u32 adr, res;
6220 u32 src, dst;
6221
6222 adr = AREG((Opcode >> 0) & 7) - 1;
6223 AREG((Opcode >> 0) & 7) = adr;
6224 PRE_IO
6225 READ_BYTE_F(adr, res)
6226 flag_C = 0;
6227 flag_V = 0;
6228 flag_NotZ = res;
6229 flag_N = res;
6230 adr = AREG((Opcode >> 9) & 7);
6231 DECODE_EXT_WORD
6232 WRITE_BYTE_F(adr, res)
6233 POST_IO
6234RET(20)
6235}
6236
6237// MOVEB
6238OPCODE(0x11E0)
6239{
6240 u32 adr, res;
6241 u32 src, dst;
6242
6243 adr = AREG((Opcode >> 0) & 7) - 1;
6244 AREG((Opcode >> 0) & 7) = adr;
6245 PRE_IO
6246 READ_BYTE_F(adr, res)
6247 flag_C = 0;
6248 flag_V = 0;
6249 flag_NotZ = res;
6250 flag_N = res;
6251 FETCH_SWORD(adr);
6252 WRITE_BYTE_F(adr, res)
6253 POST_IO
6254RET(18)
6255}
6256
6257// MOVEB
6258OPCODE(0x13E0)
6259{
6260 u32 adr, res;
6261 u32 src, dst;
6262
6263 adr = AREG((Opcode >> 0) & 7) - 1;
6264 AREG((Opcode >> 0) & 7) = adr;
6265 PRE_IO
6266 READ_BYTE_F(adr, res)
6267 flag_C = 0;
6268 flag_V = 0;
6269 flag_NotZ = res;
6270 flag_N = res;
6271 FETCH_LONG(adr);
6272 WRITE_BYTE_F(adr, res)
6273 POST_IO
6274RET(22)
6275}
6276
6277// MOVEB
6278OPCODE(0x1EE0)
6279{
6280 u32 adr, res;
6281 u32 src, dst;
6282
6283 adr = AREG((Opcode >> 0) & 7) - 1;
6284 AREG((Opcode >> 0) & 7) = adr;
6285 PRE_IO
6286 READ_BYTE_F(adr, res)
6287 flag_C = 0;
6288 flag_V = 0;
6289 flag_NotZ = res;
6290 flag_N = res;
6291 adr = AREG(7);
6292 AREG(7) += 2;
6293 WRITE_BYTE_F(adr, res)
6294 POST_IO
6295RET(14)
6296}
6297
6298// MOVEB
6299OPCODE(0x1F20)
6300{
6301 u32 adr, res;
6302 u32 src, dst;
6303
6304 adr = AREG((Opcode >> 0) & 7) - 1;
6305 AREG((Opcode >> 0) & 7) = adr;
6306 PRE_IO
6307 READ_BYTE_F(adr, res)
6308 flag_C = 0;
6309 flag_V = 0;
6310 flag_NotZ = res;
6311 flag_N = res;
6312 adr = AREG(7) - 2;
6313 AREG(7) = adr;
6314 WRITE_BYTE_F(adr, res)
6315 POST_IO
6316RET(14)
6317}
6318
6319// MOVEB
6320OPCODE(0x1028)
6321{
6322 u32 adr, res;
6323 u32 src, dst;
6324
6325 FETCH_SWORD(adr);
6326 adr += AREG((Opcode >> 0) & 7);
6327 PRE_IO
6328 READ_BYTE_F(adr, res)
6329 flag_C = 0;
6330 flag_V = 0;
6331 flag_NotZ = res;
6332 flag_N = res;
6333 DREGu8((Opcode >> 9) & 7) = res;
6334 POST_IO
6335RET(12)
6336}
6337
6338// MOVEB
6339OPCODE(0x10A8)
6340{
6341 u32 adr, res;
6342 u32 src, dst;
6343
6344 FETCH_SWORD(adr);
6345 adr += AREG((Opcode >> 0) & 7);
6346 PRE_IO
6347 READ_BYTE_F(adr, res)
6348 flag_C = 0;
6349 flag_V = 0;
6350 flag_NotZ = res;
6351 flag_N = res;
6352 adr = AREG((Opcode >> 9) & 7);
6353 WRITE_BYTE_F(adr, res)
6354 POST_IO
6355RET(16)
6356}
6357
6358// MOVEB
6359OPCODE(0x10E8)
6360{
6361 u32 adr, res;
6362 u32 src, dst;
6363
6364 FETCH_SWORD(adr);
6365 adr += AREG((Opcode >> 0) & 7);
6366 PRE_IO
6367 READ_BYTE_F(adr, res)
6368 flag_C = 0;
6369 flag_V = 0;
6370 flag_NotZ = res;
6371 flag_N = res;
6372 adr = AREG((Opcode >> 9) & 7);
6373 AREG((Opcode >> 9) & 7) += 1;
6374 WRITE_BYTE_F(adr, res)
6375 POST_IO
6376RET(16)
6377}
6378
6379// MOVEB
6380OPCODE(0x1128)
6381{
6382 u32 adr, res;
6383 u32 src, dst;
6384
6385 FETCH_SWORD(adr);
6386 adr += AREG((Opcode >> 0) & 7);
6387 PRE_IO
6388 READ_BYTE_F(adr, res)
6389 flag_C = 0;
6390 flag_V = 0;
6391 flag_NotZ = res;
6392 flag_N = res;
6393 adr = AREG((Opcode >> 9) & 7) - 1;
6394 AREG((Opcode >> 9) & 7) = adr;
6395 WRITE_BYTE_F(adr, res)
6396 POST_IO
6397RET(16)
6398}
6399
6400// MOVEB
6401OPCODE(0x1168)
6402{
6403 u32 adr, res;
6404 u32 src, dst;
6405
6406 FETCH_SWORD(adr);
6407 adr += AREG((Opcode >> 0) & 7);
6408 PRE_IO
6409 READ_BYTE_F(adr, res)
6410 flag_C = 0;
6411 flag_V = 0;
6412 flag_NotZ = res;
6413 flag_N = res;
6414 FETCH_SWORD(adr);
6415 adr += AREG((Opcode >> 9) & 7);
6416 WRITE_BYTE_F(adr, res)
6417 POST_IO
6418RET(20)
6419}
6420
6421// MOVEB
6422OPCODE(0x11A8)
6423{
6424 u32 adr, res;
6425 u32 src, dst;
6426
6427 FETCH_SWORD(adr);
6428 adr += AREG((Opcode >> 0) & 7);
6429 PRE_IO
6430 READ_BYTE_F(adr, res)
6431 flag_C = 0;
6432 flag_V = 0;
6433 flag_NotZ = res;
6434 flag_N = res;
6435 adr = AREG((Opcode >> 9) & 7);
6436 DECODE_EXT_WORD
6437 WRITE_BYTE_F(adr, res)
6438 POST_IO
6439RET(22)
6440}
6441
6442// MOVEB
6443OPCODE(0x11E8)
6444{
6445 u32 adr, res;
6446 u32 src, dst;
6447
6448 FETCH_SWORD(adr);
6449 adr += AREG((Opcode >> 0) & 7);
6450 PRE_IO
6451 READ_BYTE_F(adr, res)
6452 flag_C = 0;
6453 flag_V = 0;
6454 flag_NotZ = res;
6455 flag_N = res;
6456 FETCH_SWORD(adr);
6457 WRITE_BYTE_F(adr, res)
6458 POST_IO
6459RET(20)
6460}
6461
6462// MOVEB
6463OPCODE(0x13E8)
6464{
6465 u32 adr, res;
6466 u32 src, dst;
6467
6468 FETCH_SWORD(adr);
6469 adr += AREG((Opcode >> 0) & 7);
6470 PRE_IO
6471 READ_BYTE_F(adr, res)
6472 flag_C = 0;
6473 flag_V = 0;
6474 flag_NotZ = res;
6475 flag_N = res;
6476 FETCH_LONG(adr);
6477 WRITE_BYTE_F(adr, res)
6478 POST_IO
6479RET(24)
6480}
6481
6482// MOVEB
6483OPCODE(0x1EE8)
6484{
6485 u32 adr, res;
6486 u32 src, dst;
6487
6488 FETCH_SWORD(adr);
6489 adr += AREG((Opcode >> 0) & 7);
6490 PRE_IO
6491 READ_BYTE_F(adr, res)
6492 flag_C = 0;
6493 flag_V = 0;
6494 flag_NotZ = res;
6495 flag_N = res;
6496 adr = AREG(7);
6497 AREG(7) += 2;
6498 WRITE_BYTE_F(adr, res)
6499 POST_IO
6500RET(16)
6501}
6502
6503// MOVEB
6504OPCODE(0x1F28)
6505{
6506 u32 adr, res;
6507 u32 src, dst;
6508
6509 FETCH_SWORD(adr);
6510 adr += AREG((Opcode >> 0) & 7);
6511 PRE_IO
6512 READ_BYTE_F(adr, res)
6513 flag_C = 0;
6514 flag_V = 0;
6515 flag_NotZ = res;
6516 flag_N = res;
6517 adr = AREG(7) - 2;
6518 AREG(7) = adr;
6519 WRITE_BYTE_F(adr, res)
6520 POST_IO
6521RET(16)
6522}
6523
6524// MOVEB
6525OPCODE(0x1030)
6526{
6527 u32 adr, res;
6528 u32 src, dst;
6529
6530 adr = AREG((Opcode >> 0) & 7);
6531 DECODE_EXT_WORD
6532 PRE_IO
6533 READ_BYTE_F(adr, res)
6534 flag_C = 0;
6535 flag_V = 0;
6536 flag_NotZ = res;
6537 flag_N = res;
6538 DREGu8((Opcode >> 9) & 7) = res;
6539 POST_IO
6540RET(14)
6541}
6542
6543// MOVEB
6544OPCODE(0x10B0)
6545{
6546 u32 adr, res;
6547 u32 src, dst;
6548
6549 adr = AREG((Opcode >> 0) & 7);
6550 DECODE_EXT_WORD
6551 PRE_IO
6552 READ_BYTE_F(adr, res)
6553 flag_C = 0;
6554 flag_V = 0;
6555 flag_NotZ = res;
6556 flag_N = res;
6557 adr = AREG((Opcode >> 9) & 7);
6558 WRITE_BYTE_F(adr, res)
6559 POST_IO
6560RET(18)
6561}
6562
6563// MOVEB
6564OPCODE(0x10F0)
6565{
6566 u32 adr, res;
6567 u32 src, dst;
6568
6569 adr = AREG((Opcode >> 0) & 7);
6570 DECODE_EXT_WORD
6571 PRE_IO
6572 READ_BYTE_F(adr, res)
6573 flag_C = 0;
6574 flag_V = 0;
6575 flag_NotZ = res;
6576 flag_N = res;
6577 adr = AREG((Opcode >> 9) & 7);
6578 AREG((Opcode >> 9) & 7) += 1;
6579 WRITE_BYTE_F(adr, res)
6580 POST_IO
6581RET(18)
6582}
6583
6584// MOVEB
6585OPCODE(0x1130)
6586{
6587 u32 adr, res;
6588 u32 src, dst;
6589
6590 adr = AREG((Opcode >> 0) & 7);
6591 DECODE_EXT_WORD
6592 PRE_IO
6593 READ_BYTE_F(adr, res)
6594 flag_C = 0;
6595 flag_V = 0;
6596 flag_NotZ = res;
6597 flag_N = res;
6598 adr = AREG((Opcode >> 9) & 7) - 1;
6599 AREG((Opcode >> 9) & 7) = adr;
6600 WRITE_BYTE_F(adr, res)
6601 POST_IO
6602RET(18)
6603}
6604
6605// MOVEB
6606OPCODE(0x1170)
6607{
6608 u32 adr, res;
6609 u32 src, dst;
6610
6611 adr = AREG((Opcode >> 0) & 7);
6612 DECODE_EXT_WORD
6613 PRE_IO
6614 READ_BYTE_F(adr, res)
6615 flag_C = 0;
6616 flag_V = 0;
6617 flag_NotZ = res;
6618 flag_N = res;
6619 FETCH_SWORD(adr);
6620 adr += AREG((Opcode >> 9) & 7);
6621 WRITE_BYTE_F(adr, res)
6622 POST_IO
6623RET(22)
6624}
6625
6626// MOVEB
6627OPCODE(0x11B0)
6628{
6629 u32 adr, res;
6630 u32 src, dst;
6631
6632 adr = AREG((Opcode >> 0) & 7);
6633 DECODE_EXT_WORD
6634 PRE_IO
6635 READ_BYTE_F(adr, res)
6636 flag_C = 0;
6637 flag_V = 0;
6638 flag_NotZ = res;
6639 flag_N = res;
6640 adr = AREG((Opcode >> 9) & 7);
6641 DECODE_EXT_WORD
6642 WRITE_BYTE_F(adr, res)
6643 POST_IO
6644RET(24)
6645}
6646
6647// MOVEB
6648OPCODE(0x11F0)
6649{
6650 u32 adr, res;
6651 u32 src, dst;
6652
6653 adr = AREG((Opcode >> 0) & 7);
6654 DECODE_EXT_WORD
6655 PRE_IO
6656 READ_BYTE_F(adr, res)
6657 flag_C = 0;
6658 flag_V = 0;
6659 flag_NotZ = res;
6660 flag_N = res;
6661 FETCH_SWORD(adr);
6662 WRITE_BYTE_F(adr, res)
6663 POST_IO
6664RET(22)
6665}
6666
6667// MOVEB
6668OPCODE(0x13F0)
6669{
6670 u32 adr, res;
6671 u32 src, dst;
6672
6673 adr = AREG((Opcode >> 0) & 7);
6674 DECODE_EXT_WORD
6675 PRE_IO
6676 READ_BYTE_F(adr, res)
6677 flag_C = 0;
6678 flag_V = 0;
6679 flag_NotZ = res;
6680 flag_N = res;
6681 FETCH_LONG(adr);
6682 WRITE_BYTE_F(adr, res)
6683 POST_IO
6684RET(26)
6685}
6686
6687// MOVEB
6688OPCODE(0x1EF0)
6689{
6690 u32 adr, res;
6691 u32 src, dst;
6692
6693 adr = AREG((Opcode >> 0) & 7);
6694 DECODE_EXT_WORD
6695 PRE_IO
6696 READ_BYTE_F(adr, res)
6697 flag_C = 0;
6698 flag_V = 0;
6699 flag_NotZ = res;
6700 flag_N = res;
6701 adr = AREG(7);
6702 AREG(7) += 2;
6703 WRITE_BYTE_F(adr, res)
6704 POST_IO
6705RET(18)
6706}
6707
6708// MOVEB
6709OPCODE(0x1F30)
6710{
6711 u32 adr, res;
6712 u32 src, dst;
6713
6714 adr = AREG((Opcode >> 0) & 7);
6715 DECODE_EXT_WORD
6716 PRE_IO
6717 READ_BYTE_F(adr, res)
6718 flag_C = 0;
6719 flag_V = 0;
6720 flag_NotZ = res;
6721 flag_N = res;
6722 adr = AREG(7) - 2;
6723 AREG(7) = adr;
6724 WRITE_BYTE_F(adr, res)
6725 POST_IO
6726RET(18)
6727}
6728
6729// MOVEB
6730OPCODE(0x1038)
6731{
6732 u32 adr, res;
6733 u32 src, dst;
6734
6735 FETCH_SWORD(adr);
6736 PRE_IO
6737 READ_BYTE_F(adr, res)
6738 flag_C = 0;
6739 flag_V = 0;
6740 flag_NotZ = res;
6741 flag_N = res;
6742 DREGu8((Opcode >> 9) & 7) = res;
6743 POST_IO
6744RET(12)
6745}
6746
6747// MOVEB
6748OPCODE(0x10B8)
6749{
6750 u32 adr, res;
6751 u32 src, dst;
6752
6753 FETCH_SWORD(adr);
6754 PRE_IO
6755 READ_BYTE_F(adr, res)
6756 flag_C = 0;
6757 flag_V = 0;
6758 flag_NotZ = res;
6759 flag_N = res;
6760 adr = AREG((Opcode >> 9) & 7);
6761 WRITE_BYTE_F(adr, res)
6762 POST_IO
6763RET(16)
6764}
6765
6766// MOVEB
6767OPCODE(0x10F8)
6768{
6769 u32 adr, res;
6770 u32 src, dst;
6771
6772 FETCH_SWORD(adr);
6773 PRE_IO
6774 READ_BYTE_F(adr, res)
6775 flag_C = 0;
6776 flag_V = 0;
6777 flag_NotZ = res;
6778 flag_N = res;
6779 adr = AREG((Opcode >> 9) & 7);
6780 AREG((Opcode >> 9) & 7) += 1;
6781 WRITE_BYTE_F(adr, res)
6782 POST_IO
6783RET(16)
6784}
6785
6786// MOVEB
6787OPCODE(0x1138)
6788{
6789 u32 adr, res;
6790 u32 src, dst;
6791
6792 FETCH_SWORD(adr);
6793 PRE_IO
6794 READ_BYTE_F(adr, res)
6795 flag_C = 0;
6796 flag_V = 0;
6797 flag_NotZ = res;
6798 flag_N = res;
6799 adr = AREG((Opcode >> 9) & 7) - 1;
6800 AREG((Opcode >> 9) & 7) = adr;
6801 WRITE_BYTE_F(adr, res)
6802 POST_IO
6803RET(16)
6804}
6805
6806// MOVEB
6807OPCODE(0x1178)
6808{
6809 u32 adr, res;
6810 u32 src, dst;
6811
6812 FETCH_SWORD(adr);
6813 PRE_IO
6814 READ_BYTE_F(adr, res)
6815 flag_C = 0;
6816 flag_V = 0;
6817 flag_NotZ = res;
6818 flag_N = res;
6819 FETCH_SWORD(adr);
6820 adr += AREG((Opcode >> 9) & 7);
6821 WRITE_BYTE_F(adr, res)
6822 POST_IO
6823RET(20)
6824}
6825
6826// MOVEB
6827OPCODE(0x11B8)
6828{
6829 u32 adr, res;
6830 u32 src, dst;
6831
6832 FETCH_SWORD(adr);
6833 PRE_IO
6834 READ_BYTE_F(adr, res)
6835 flag_C = 0;
6836 flag_V = 0;
6837 flag_NotZ = res;
6838 flag_N = res;
6839 adr = AREG((Opcode >> 9) & 7);
6840 DECODE_EXT_WORD
6841 WRITE_BYTE_F(adr, res)
6842 POST_IO
6843RET(22)
6844}
6845
6846// MOVEB
6847OPCODE(0x11F8)
6848{
6849 u32 adr, res;
6850 u32 src, dst;
6851
6852 FETCH_SWORD(adr);
6853 PRE_IO
6854 READ_BYTE_F(adr, res)
6855 flag_C = 0;
6856 flag_V = 0;
6857 flag_NotZ = res;
6858 flag_N = res;
6859 FETCH_SWORD(adr);
6860 WRITE_BYTE_F(adr, res)
6861 POST_IO
6862RET(20)
6863}
6864
6865// MOVEB
6866OPCODE(0x13F8)
6867{
6868 u32 adr, res;
6869 u32 src, dst;
6870
6871 FETCH_SWORD(adr);
6872 PRE_IO
6873 READ_BYTE_F(adr, res)
6874 flag_C = 0;
6875 flag_V = 0;
6876 flag_NotZ = res;
6877 flag_N = res;
6878 FETCH_LONG(adr);
6879 WRITE_BYTE_F(adr, res)
6880 POST_IO
6881RET(24)
6882}
6883
6884// MOVEB
6885OPCODE(0x1EF8)
6886{
6887 u32 adr, res;
6888 u32 src, dst;
6889
6890 FETCH_SWORD(adr);
6891 PRE_IO
6892 READ_BYTE_F(adr, res)
6893 flag_C = 0;
6894 flag_V = 0;
6895 flag_NotZ = res;
6896 flag_N = res;
6897 adr = AREG(7);
6898 AREG(7) += 2;
6899 WRITE_BYTE_F(adr, res)
6900 POST_IO
6901RET(16)
6902}
6903
6904// MOVEB
6905OPCODE(0x1F38)
6906{
6907 u32 adr, res;
6908 u32 src, dst;
6909
6910 FETCH_SWORD(adr);
6911 PRE_IO
6912 READ_BYTE_F(adr, res)
6913 flag_C = 0;
6914 flag_V = 0;
6915 flag_NotZ = res;
6916 flag_N = res;
6917 adr = AREG(7) - 2;
6918 AREG(7) = adr;
6919 WRITE_BYTE_F(adr, res)
6920 POST_IO
6921RET(16)
6922}
6923
6924// MOVEB
6925OPCODE(0x1039)
6926{
6927 u32 adr, res;
6928 u32 src, dst;
6929
6930 FETCH_LONG(adr);
6931 PRE_IO
6932 READ_BYTE_F(adr, res)
6933 flag_C = 0;
6934 flag_V = 0;
6935 flag_NotZ = res;
6936 flag_N = res;
6937 DREGu8((Opcode >> 9) & 7) = res;
6938 POST_IO
6939RET(16)
6940}
6941
6942// MOVEB
6943OPCODE(0x10B9)
6944{
6945 u32 adr, res;
6946 u32 src, dst;
6947
6948 FETCH_LONG(adr);
6949 PRE_IO
6950 READ_BYTE_F(adr, res)
6951 flag_C = 0;
6952 flag_V = 0;
6953 flag_NotZ = res;
6954 flag_N = res;
6955 adr = AREG((Opcode >> 9) & 7);
6956 WRITE_BYTE_F(adr, res)
6957 POST_IO
6958RET(20)
6959}
6960
6961// MOVEB
6962OPCODE(0x10F9)
6963{
6964 u32 adr, res;
6965 u32 src, dst;
6966
6967 FETCH_LONG(adr);
6968 PRE_IO
6969 READ_BYTE_F(adr, res)
6970 flag_C = 0;
6971 flag_V = 0;
6972 flag_NotZ = res;
6973 flag_N = res;
6974 adr = AREG((Opcode >> 9) & 7);
6975 AREG((Opcode >> 9) & 7) += 1;
6976 WRITE_BYTE_F(adr, res)
6977 POST_IO
6978RET(20)
6979}
6980
6981// MOVEB
6982OPCODE(0x1139)
6983{
6984 u32 adr, res;
6985 u32 src, dst;
6986
6987 FETCH_LONG(adr);
6988 PRE_IO
6989 READ_BYTE_F(adr, res)
6990 flag_C = 0;
6991 flag_V = 0;
6992 flag_NotZ = res;
6993 flag_N = res;
6994 adr = AREG((Opcode >> 9) & 7) - 1;
6995 AREG((Opcode >> 9) & 7) = adr;
6996 WRITE_BYTE_F(adr, res)
6997 POST_IO
6998RET(20)
6999}
7000
7001// MOVEB
7002OPCODE(0x1179)
7003{
7004 u32 adr, res;
7005 u32 src, dst;
7006
7007 FETCH_LONG(adr);
7008 PRE_IO
7009 READ_BYTE_F(adr, res)
7010 flag_C = 0;
7011 flag_V = 0;
7012 flag_NotZ = res;
7013 flag_N = res;
7014 FETCH_SWORD(adr);
7015 adr += AREG((Opcode >> 9) & 7);
7016 WRITE_BYTE_F(adr, res)
7017 POST_IO
7018RET(24)
7019}
7020
7021// MOVEB
7022OPCODE(0x11B9)
7023{
7024 u32 adr, res;
7025 u32 src, dst;
7026
7027 FETCH_LONG(adr);
7028 PRE_IO
7029 READ_BYTE_F(adr, res)
7030 flag_C = 0;
7031 flag_V = 0;
7032 flag_NotZ = res;
7033 flag_N = res;
7034 adr = AREG((Opcode >> 9) & 7);
7035 DECODE_EXT_WORD
7036 WRITE_BYTE_F(adr, res)
7037 POST_IO
7038RET(26)
7039}
7040
7041// MOVEB
7042OPCODE(0x11F9)
7043{
7044 u32 adr, res;
7045 u32 src, dst;
7046
7047 FETCH_LONG(adr);
7048 PRE_IO
7049 READ_BYTE_F(adr, res)
7050 flag_C = 0;
7051 flag_V = 0;
7052 flag_NotZ = res;
7053 flag_N = res;
7054 FETCH_SWORD(adr);
7055 WRITE_BYTE_F(adr, res)
7056 POST_IO
7057RET(24)
7058}
7059
7060// MOVEB
7061OPCODE(0x13F9)
7062{
7063 u32 adr, res;
7064 u32 src, dst;
7065
7066 FETCH_LONG(adr);
7067 PRE_IO
7068 READ_BYTE_F(adr, res)
7069 flag_C = 0;
7070 flag_V = 0;
7071 flag_NotZ = res;
7072 flag_N = res;
7073 FETCH_LONG(adr);
7074 WRITE_BYTE_F(adr, res)
7075 POST_IO
7076RET(28)
7077}
7078
7079// MOVEB
7080OPCODE(0x1EF9)
7081{
7082 u32 adr, res;
7083 u32 src, dst;
7084
7085 FETCH_LONG(adr);
7086 PRE_IO
7087 READ_BYTE_F(adr, res)
7088 flag_C = 0;
7089 flag_V = 0;
7090 flag_NotZ = res;
7091 flag_N = res;
7092 adr = AREG(7);
7093 AREG(7) += 2;
7094 WRITE_BYTE_F(adr, res)
7095 POST_IO
7096RET(20)
7097}
7098
7099// MOVEB
7100OPCODE(0x1F39)
7101{
7102 u32 adr, res;
7103 u32 src, dst;
7104
7105 FETCH_LONG(adr);
7106 PRE_IO
7107 READ_BYTE_F(adr, res)
7108 flag_C = 0;
7109 flag_V = 0;
7110 flag_NotZ = res;
7111 flag_N = res;
7112 adr = AREG(7) - 2;
7113 AREG(7) = adr;
7114 WRITE_BYTE_F(adr, res)
7115 POST_IO
7116RET(20)
7117}
7118
7119// MOVEB
7120OPCODE(0x103A)
7121{
7122 u32 adr, res;
7123 u32 src, dst;
7124
be26eb23 7125 adr = GET_SWORD + GET_PC;
70357ce5 7126 PC++;
7127 PRE_IO
7128 READ_BYTE_F(adr, res)
7129 flag_C = 0;
7130 flag_V = 0;
7131 flag_NotZ = res;
7132 flag_N = res;
7133 DREGu8((Opcode >> 9) & 7) = res;
7134 POST_IO
7135RET(12)
7136}
7137
7138// MOVEB
7139OPCODE(0x10BA)
7140{
7141 u32 adr, res;
7142 u32 src, dst;
7143
be26eb23 7144 adr = GET_SWORD + GET_PC;
70357ce5 7145 PC++;
7146 PRE_IO
7147 READ_BYTE_F(adr, res)
7148 flag_C = 0;
7149 flag_V = 0;
7150 flag_NotZ = res;
7151 flag_N = res;
7152 adr = AREG((Opcode >> 9) & 7);
7153 WRITE_BYTE_F(adr, res)
7154 POST_IO
7155RET(16)
7156}
7157
7158// MOVEB
7159OPCODE(0x10FA)
7160{
7161 u32 adr, res;
7162 u32 src, dst;
7163
be26eb23 7164 adr = GET_SWORD + GET_PC;
70357ce5 7165 PC++;
7166 PRE_IO
7167 READ_BYTE_F(adr, res)
7168 flag_C = 0;
7169 flag_V = 0;
7170 flag_NotZ = res;
7171 flag_N = res;
7172 adr = AREG((Opcode >> 9) & 7);
7173 AREG((Opcode >> 9) & 7) += 1;
7174 WRITE_BYTE_F(adr, res)
7175 POST_IO
7176RET(16)
7177}
7178
7179// MOVEB
7180OPCODE(0x113A)
7181{
7182 u32 adr, res;
7183 u32 src, dst;
7184
be26eb23 7185 adr = GET_SWORD + GET_PC;
70357ce5 7186 PC++;
7187 PRE_IO
7188 READ_BYTE_F(adr, res)
7189 flag_C = 0;
7190 flag_V = 0;
7191 flag_NotZ = res;
7192 flag_N = res;
7193 adr = AREG((Opcode >> 9) & 7) - 1;
7194 AREG((Opcode >> 9) & 7) = adr;
7195 WRITE_BYTE_F(adr, res)
7196 POST_IO
7197RET(16)
7198}
7199
7200// MOVEB
7201OPCODE(0x117A)
7202{
7203 u32 adr, res;
7204 u32 src, dst;
7205
be26eb23 7206 adr = GET_SWORD + GET_PC;
70357ce5 7207 PC++;
7208 PRE_IO
7209 READ_BYTE_F(adr, res)
7210 flag_C = 0;
7211 flag_V = 0;
7212 flag_NotZ = res;
7213 flag_N = res;
7214 FETCH_SWORD(adr);
7215 adr += AREG((Opcode >> 9) & 7);
7216 WRITE_BYTE_F(adr, res)
7217 POST_IO
7218RET(20)
7219}
7220
7221// MOVEB
7222OPCODE(0x11BA)
7223{
7224 u32 adr, res;
7225 u32 src, dst;
7226
be26eb23 7227 adr = GET_SWORD + GET_PC;
70357ce5 7228 PC++;
7229 PRE_IO
7230 READ_BYTE_F(adr, res)
7231 flag_C = 0;
7232 flag_V = 0;
7233 flag_NotZ = res;
7234 flag_N = res;
7235 adr = AREG((Opcode >> 9) & 7);
7236 DECODE_EXT_WORD
7237 WRITE_BYTE_F(adr, res)
7238 POST_IO
7239RET(22)
7240}
7241
7242// MOVEB
7243OPCODE(0x11FA)
7244{
7245 u32 adr, res;
7246 u32 src, dst;
7247
be26eb23 7248 adr = GET_SWORD + GET_PC;
70357ce5 7249 PC++;
7250 PRE_IO
7251 READ_BYTE_F(adr, res)
7252 flag_C = 0;
7253 flag_V = 0;
7254 flag_NotZ = res;
7255 flag_N = res;
7256 FETCH_SWORD(adr);
7257 WRITE_BYTE_F(adr, res)
7258 POST_IO
7259RET(20)
7260}
7261
7262// MOVEB
7263OPCODE(0x13FA)
7264{
7265 u32 adr, res;
7266 u32 src, dst;
7267
be26eb23 7268 adr = GET_SWORD + GET_PC;
70357ce5 7269 PC++;
7270 PRE_IO
7271 READ_BYTE_F(adr, res)
7272 flag_C = 0;
7273 flag_V = 0;
7274 flag_NotZ = res;
7275 flag_N = res;
7276 FETCH_LONG(adr);
7277 WRITE_BYTE_F(adr, res)
7278 POST_IO
7279RET(24)
7280}
7281
7282// MOVEB
7283OPCODE(0x1EFA)
7284{
7285 u32 adr, res;
7286 u32 src, dst;
7287
be26eb23 7288 adr = GET_SWORD + GET_PC;
70357ce5 7289 PC++;
7290 PRE_IO
7291 READ_BYTE_F(adr, res)
7292 flag_C = 0;
7293 flag_V = 0;
7294 flag_NotZ = res;
7295 flag_N = res;
7296 adr = AREG(7);
7297 AREG(7) += 2;
7298 WRITE_BYTE_F(adr, res)
7299 POST_IO
7300RET(16)
7301}
7302
7303// MOVEB
7304OPCODE(0x1F3A)
7305{
7306 u32 adr, res;
7307 u32 src, dst;
7308
be26eb23 7309 adr = GET_SWORD + GET_PC;
70357ce5 7310 PC++;
7311 PRE_IO
7312 READ_BYTE_F(adr, res)
7313 flag_C = 0;
7314 flag_V = 0;
7315 flag_NotZ = res;
7316 flag_N = res;
7317 adr = AREG(7) - 2;
7318 AREG(7) = adr;
7319 WRITE_BYTE_F(adr, res)
7320 POST_IO
7321RET(16)
7322}
7323
7324// MOVEB
7325OPCODE(0x103B)
7326{
7327 u32 adr, res;
7328 u32 src, dst;
7329
be26eb23 7330 adr = (uptr)(PC) - BasePC;
70357ce5 7331 DECODE_EXT_WORD
7332 PRE_IO
7333 READ_BYTE_F(adr, res)
7334 flag_C = 0;
7335 flag_V = 0;
7336 flag_NotZ = res;
7337 flag_N = res;
7338 DREGu8((Opcode >> 9) & 7) = res;
7339 POST_IO
7340RET(14)
7341}
7342
7343// MOVEB
7344OPCODE(0x10BB)
7345{
7346 u32 adr, res;
7347 u32 src, dst;
7348
be26eb23 7349 adr = (uptr)(PC) - BasePC;
70357ce5 7350 DECODE_EXT_WORD
7351 PRE_IO
7352 READ_BYTE_F(adr, res)
7353 flag_C = 0;
7354 flag_V = 0;
7355 flag_NotZ = res;
7356 flag_N = res;
7357 adr = AREG((Opcode >> 9) & 7);
7358 WRITE_BYTE_F(adr, res)
7359 POST_IO
7360RET(18)
7361}
7362
7363// MOVEB
7364OPCODE(0x10FB)
7365{
7366 u32 adr, res;
7367 u32 src, dst;
7368
be26eb23 7369 adr = (uptr)(PC) - BasePC;
70357ce5 7370 DECODE_EXT_WORD
7371 PRE_IO
7372 READ_BYTE_F(adr, res)
7373 flag_C = 0;
7374 flag_V = 0;
7375 flag_NotZ = res;
7376 flag_N = res;
7377 adr = AREG((Opcode >> 9) & 7);
7378 AREG((Opcode >> 9) & 7) += 1;
7379 WRITE_BYTE_F(adr, res)
7380 POST_IO
7381RET(18)
7382}
7383
7384// MOVEB
7385OPCODE(0x113B)
7386{
7387 u32 adr, res;
7388 u32 src, dst;
7389
be26eb23 7390 adr = (uptr)(PC) - BasePC;
70357ce5 7391 DECODE_EXT_WORD
7392 PRE_IO
7393 READ_BYTE_F(adr, res)
7394 flag_C = 0;
7395 flag_V = 0;
7396 flag_NotZ = res;
7397 flag_N = res;
7398 adr = AREG((Opcode >> 9) & 7) - 1;
7399 AREG((Opcode >> 9) & 7) = adr;
7400 WRITE_BYTE_F(adr, res)
7401 POST_IO
7402RET(18)
7403}
7404
7405// MOVEB
7406OPCODE(0x117B)
7407{
7408 u32 adr, res;
7409 u32 src, dst;
7410
be26eb23 7411 adr = (uptr)(PC) - BasePC;
70357ce5 7412 DECODE_EXT_WORD
7413 PRE_IO
7414 READ_BYTE_F(adr, res)
7415 flag_C = 0;
7416 flag_V = 0;
7417 flag_NotZ = res;
7418 flag_N = res;
7419 FETCH_SWORD(adr);
7420 adr += AREG((Opcode >> 9) & 7);
7421 WRITE_BYTE_F(adr, res)
7422 POST_IO
7423RET(22)
7424}
7425
7426// MOVEB
7427OPCODE(0x11BB)
7428{
7429 u32 adr, res;
7430 u32 src, dst;
7431
be26eb23 7432 adr = (uptr)(PC) - BasePC;
70357ce5 7433 DECODE_EXT_WORD
7434 PRE_IO
7435 READ_BYTE_F(adr, res)
7436 flag_C = 0;
7437 flag_V = 0;
7438 flag_NotZ = res;
7439 flag_N = res;
7440 adr = AREG((Opcode >> 9) & 7);
7441 DECODE_EXT_WORD
7442 WRITE_BYTE_F(adr, res)
7443 POST_IO
7444RET(24)
7445}
7446
7447// MOVEB
7448OPCODE(0x11FB)
7449{
7450 u32 adr, res;
7451 u32 src, dst;
7452
be26eb23 7453 adr = (uptr)(PC) - BasePC;
70357ce5 7454 DECODE_EXT_WORD
7455 PRE_IO
7456 READ_BYTE_F(adr, res)
7457 flag_C = 0;
7458 flag_V = 0;
7459 flag_NotZ = res;
7460 flag_N = res;
7461 FETCH_SWORD(adr);
7462 WRITE_BYTE_F(adr, res)
7463 POST_IO
7464RET(22)
7465}
7466
7467// MOVEB
7468OPCODE(0x13FB)
7469{
7470 u32 adr, res;
7471 u32 src, dst;
7472
be26eb23 7473 adr = (uptr)(PC) - BasePC;
70357ce5 7474 DECODE_EXT_WORD
7475 PRE_IO
7476 READ_BYTE_F(adr, res)
7477 flag_C = 0;
7478 flag_V = 0;
7479 flag_NotZ = res;
7480 flag_N = res;
7481 FETCH_LONG(adr);
7482 WRITE_BYTE_F(adr, res)
7483 POST_IO
7484RET(26)
7485}
7486
7487// MOVEB
7488OPCODE(0x1EFB)
7489{
7490 u32 adr, res;
7491 u32 src, dst;
7492
be26eb23 7493 adr = (uptr)(PC) - BasePC;
70357ce5 7494 DECODE_EXT_WORD
7495 PRE_IO
7496 READ_BYTE_F(adr, res)
7497 flag_C = 0;
7498 flag_V = 0;
7499 flag_NotZ = res;
7500 flag_N = res;
7501 adr = AREG(7);
7502 AREG(7) += 2;
7503 WRITE_BYTE_F(adr, res)
7504 POST_IO
7505RET(18)
7506}
7507
7508// MOVEB
7509OPCODE(0x1F3B)
7510{
7511 u32 adr, res;
7512 u32 src, dst;
7513
be26eb23 7514 adr = (uptr)(PC) - BasePC;
70357ce5 7515 DECODE_EXT_WORD
7516 PRE_IO
7517 READ_BYTE_F(adr, res)
7518 flag_C = 0;
7519 flag_V = 0;
7520 flag_NotZ = res;
7521 flag_N = res;
7522 adr = AREG(7) - 2;
7523 AREG(7) = adr;
7524 WRITE_BYTE_F(adr, res)
7525 POST_IO
7526RET(18)
7527}
7528
7529// MOVEB
7530OPCODE(0x103C)
7531{
7532 u32 adr, res;
7533 u32 src, dst;
7534
7535 FETCH_BYTE(res);
7536 flag_C = 0;
7537 flag_V = 0;
7538 flag_NotZ = res;
7539 flag_N = res;
7540 DREGu8((Opcode >> 9) & 7) = res;
7541RET(8)
7542}
7543
7544// MOVEB
7545OPCODE(0x10BC)
7546{
7547 u32 adr, res;
7548 u32 src, dst;
7549
7550 FETCH_BYTE(res);
7551 flag_C = 0;
7552 flag_V = 0;
7553 flag_NotZ = res;
7554 flag_N = res;
7555 adr = AREG((Opcode >> 9) & 7);
7556 PRE_IO
7557 WRITE_BYTE_F(adr, res)
7558 POST_IO
7559RET(12)
7560}
7561
7562// MOVEB
7563OPCODE(0x10FC)
7564{
7565 u32 adr, res;
7566 u32 src, dst;
7567
7568 FETCH_BYTE(res);
7569 flag_C = 0;
7570 flag_V = 0;
7571 flag_NotZ = res;
7572 flag_N = res;
7573 adr = AREG((Opcode >> 9) & 7);
7574 AREG((Opcode >> 9) & 7) += 1;
7575 PRE_IO
7576 WRITE_BYTE_F(adr, res)
7577 POST_IO
7578RET(12)
7579}
7580
7581// MOVEB
7582OPCODE(0x113C)
7583{
7584 u32 adr, res;
7585 u32 src, dst;
7586
7587 FETCH_BYTE(res);
7588 flag_C = 0;
7589 flag_V = 0;
7590 flag_NotZ = res;
7591 flag_N = res;
7592 adr = AREG((Opcode >> 9) & 7) - 1;
7593 AREG((Opcode >> 9) & 7) = adr;
7594 PRE_IO
7595 WRITE_BYTE_F(adr, res)
7596 POST_IO
7597RET(12)
7598}
7599
7600// MOVEB
7601OPCODE(0x117C)
7602{
7603 u32 adr, res;
7604 u32 src, dst;
7605
7606 FETCH_BYTE(res);
7607 flag_C = 0;
7608 flag_V = 0;
7609 flag_NotZ = res;
7610 flag_N = res;
7611 FETCH_SWORD(adr);
7612 adr += AREG((Opcode >> 9) & 7);
7613 PRE_IO
7614 WRITE_BYTE_F(adr, res)
7615 POST_IO
7616RET(16)
7617}
7618
7619// MOVEB
7620OPCODE(0x11BC)
7621{
7622 u32 adr, res;
7623 u32 src, dst;
7624
7625 FETCH_BYTE(res);
7626 flag_C = 0;
7627 flag_V = 0;
7628 flag_NotZ = res;
7629 flag_N = res;
7630 adr = AREG((Opcode >> 9) & 7);
7631 DECODE_EXT_WORD
7632 PRE_IO
7633 WRITE_BYTE_F(adr, res)
7634 POST_IO
7635RET(18)
7636}
7637
7638// MOVEB
7639OPCODE(0x11FC)
7640{
7641 u32 adr, res;
7642 u32 src, dst;
7643
7644 FETCH_BYTE(res);
7645 flag_C = 0;
7646 flag_V = 0;
7647 flag_NotZ = res;
7648 flag_N = res;
7649 FETCH_SWORD(adr);
7650 PRE_IO
7651 WRITE_BYTE_F(adr, res)
7652 POST_IO
7653RET(16)
7654}
7655
7656// MOVEB
7657OPCODE(0x13FC)
7658{
7659 u32 adr, res;
7660 u32 src, dst;
7661
7662 FETCH_BYTE(res);
7663 flag_C = 0;
7664 flag_V = 0;
7665 flag_NotZ = res;
7666 flag_N = res;
7667 FETCH_LONG(adr);
7668 PRE_IO
7669 WRITE_BYTE_F(adr, res)
7670 POST_IO
7671RET(20)
7672}
7673
7674// MOVEB
7675OPCODE(0x1EFC)
7676{
7677 u32 adr, res;
7678 u32 src, dst;
7679
7680 FETCH_BYTE(res);
7681 flag_C = 0;
7682 flag_V = 0;
7683 flag_NotZ = res;
7684 flag_N = res;
7685 adr = AREG(7);
7686 AREG(7) += 2;
7687 PRE_IO
7688 WRITE_BYTE_F(adr, res)
7689 POST_IO
7690RET(12)
7691}
7692
7693// MOVEB
7694OPCODE(0x1F3C)
7695{
7696 u32 adr, res;
7697 u32 src, dst;
7698
7699 FETCH_BYTE(res);
7700 flag_C = 0;
7701 flag_V = 0;
7702 flag_NotZ = res;
7703 flag_N = res;
7704 adr = AREG(7) - 2;
7705 AREG(7) = adr;
7706 PRE_IO
7707 WRITE_BYTE_F(adr, res)
7708 POST_IO
7709RET(12)
7710}
7711
7712// MOVEB
7713OPCODE(0x101F)
7714{
7715 u32 adr, res;
7716 u32 src, dst;
7717
7718 adr = AREG(7);
7719 AREG(7) += 2;
7720 PRE_IO
7721 READ_BYTE_F(adr, res)
7722 flag_C = 0;
7723 flag_V = 0;
7724 flag_NotZ = res;
7725 flag_N = res;
7726 DREGu8((Opcode >> 9) & 7) = res;
7727 POST_IO
7728RET(8)
7729}
7730
7731// MOVEB
7732OPCODE(0x109F)
7733{
7734 u32 adr, res;
7735 u32 src, dst;
7736
7737 adr = AREG(7);
7738 AREG(7) += 2;
7739 PRE_IO
7740 READ_BYTE_F(adr, res)
7741 flag_C = 0;
7742 flag_V = 0;
7743 flag_NotZ = res;
7744 flag_N = res;
7745 adr = AREG((Opcode >> 9) & 7);
7746 WRITE_BYTE_F(adr, res)
7747 POST_IO
7748RET(12)
7749}
7750
7751// MOVEB
7752OPCODE(0x10DF)
7753{
7754 u32 adr, res;
7755 u32 src, dst;
7756
7757 adr = AREG(7);
7758 AREG(7) += 2;
7759 PRE_IO
7760 READ_BYTE_F(adr, res)
7761 flag_C = 0;
7762 flag_V = 0;
7763 flag_NotZ = res;
7764 flag_N = res;
7765 adr = AREG((Opcode >> 9) & 7);
7766 AREG((Opcode >> 9) & 7) += 1;
7767 WRITE_BYTE_F(adr, res)
7768 POST_IO
7769RET(12)
7770}
7771
7772// MOVEB
7773OPCODE(0x111F)
7774{
7775 u32 adr, res;
7776 u32 src, dst;
7777
7778 adr = AREG(7);
7779 AREG(7) += 2;
7780 PRE_IO
7781 READ_BYTE_F(adr, res)
7782 flag_C = 0;
7783 flag_V = 0;
7784 flag_NotZ = res;
7785 flag_N = res;
7786 adr = AREG((Opcode >> 9) & 7) - 1;
7787 AREG((Opcode >> 9) & 7) = adr;
7788 WRITE_BYTE_F(adr, res)
7789 POST_IO
7790RET(12)
7791}
7792
7793// MOVEB
7794OPCODE(0x115F)
7795{
7796 u32 adr, res;
7797 u32 src, dst;
7798
7799 adr = AREG(7);
7800 AREG(7) += 2;
7801 PRE_IO
7802 READ_BYTE_F(adr, res)
7803 flag_C = 0;
7804 flag_V = 0;
7805 flag_NotZ = res;
7806 flag_N = res;
7807 FETCH_SWORD(adr);
7808 adr += AREG((Opcode >> 9) & 7);
7809 WRITE_BYTE_F(adr, res)
7810 POST_IO
7811RET(16)
7812}
7813
7814// MOVEB
7815OPCODE(0x119F)
7816{
7817 u32 adr, res;
7818 u32 src, dst;
7819
7820 adr = AREG(7);
7821 AREG(7) += 2;
7822 PRE_IO
7823 READ_BYTE_F(adr, res)
7824 flag_C = 0;
7825 flag_V = 0;
7826 flag_NotZ = res;
7827 flag_N = res;
7828 adr = AREG((Opcode >> 9) & 7);
7829 DECODE_EXT_WORD
7830 WRITE_BYTE_F(adr, res)
7831 POST_IO
7832RET(18)
7833}
7834
7835// MOVEB
7836OPCODE(0x11DF)
7837{
7838 u32 adr, res;
7839 u32 src, dst;
7840
7841 adr = AREG(7);
7842 AREG(7) += 2;
7843 PRE_IO
7844 READ_BYTE_F(adr, res)
7845 flag_C = 0;
7846 flag_V = 0;
7847 flag_NotZ = res;
7848 flag_N = res;
7849 FETCH_SWORD(adr);
7850 WRITE_BYTE_F(adr, res)
7851 POST_IO
7852RET(16)
7853}
7854
7855// MOVEB
7856OPCODE(0x13DF)
7857{
7858 u32 adr, res;
7859 u32 src, dst;
7860
7861 adr = AREG(7);
7862 AREG(7) += 2;
7863 PRE_IO
7864 READ_BYTE_F(adr, res)
7865 flag_C = 0;
7866 flag_V = 0;
7867 flag_NotZ = res;
7868 flag_N = res;
7869 FETCH_LONG(adr);
7870 WRITE_BYTE_F(adr, res)
7871 POST_IO
7872RET(20)
7873}
7874
7875// MOVEB
7876OPCODE(0x1EDF)
7877{
7878 u32 adr, res;
7879 u32 src, dst;
7880
7881 adr = AREG(7);
7882 AREG(7) += 2;
7883 PRE_IO
7884 READ_BYTE_F(adr, res)
7885 flag_C = 0;
7886 flag_V = 0;
7887 flag_NotZ = res;
7888 flag_N = res;
7889 adr = AREG(7);
7890 AREG(7) += 2;
7891 WRITE_BYTE_F(adr, res)
7892 POST_IO
7893RET(12)
7894}
7895
7896// MOVEB
7897OPCODE(0x1F1F)
7898{
7899 u32 adr, res;
7900 u32 src, dst;
7901
7902 adr = AREG(7);
7903 AREG(7) += 2;
7904 PRE_IO
7905 READ_BYTE_F(adr, res)
7906 flag_C = 0;
7907 flag_V = 0;
7908 flag_NotZ = res;
7909 flag_N = res;
7910 adr = AREG(7) - 2;
7911 AREG(7) = adr;
7912 WRITE_BYTE_F(adr, res)
7913 POST_IO
7914RET(12)
7915}
7916
7917// MOVEB
7918OPCODE(0x1027)
7919{
7920 u32 adr, res;
7921 u32 src, dst;
7922
7923 adr = AREG(7) - 2;
7924 AREG(7) = adr;
7925 PRE_IO
7926 READ_BYTE_F(adr, res)
7927 flag_C = 0;
7928 flag_V = 0;
7929 flag_NotZ = res;
7930 flag_N = res;
7931 DREGu8((Opcode >> 9) & 7) = res;
7932 POST_IO
7933RET(10)
7934}
7935
7936// MOVEB
7937OPCODE(0x10A7)
7938{
7939 u32 adr, res;
7940 u32 src, dst;
7941
7942 adr = AREG(7) - 2;
7943 AREG(7) = adr;
7944 PRE_IO
7945 READ_BYTE_F(adr, res)
7946 flag_C = 0;
7947 flag_V = 0;
7948 flag_NotZ = res;
7949 flag_N = res;
7950 adr = AREG((Opcode >> 9) & 7);
7951 WRITE_BYTE_F(adr, res)
7952 POST_IO
7953RET(14)
7954}
7955
7956// MOVEB
7957OPCODE(0x10E7)
7958{
7959 u32 adr, res;
7960 u32 src, dst;
7961
7962 adr = AREG(7) - 2;
7963 AREG(7) = adr;
7964 PRE_IO
7965 READ_BYTE_F(adr, res)
7966 flag_C = 0;
7967 flag_V = 0;
7968 flag_NotZ = res;
7969 flag_N = res;
7970 adr = AREG((Opcode >> 9) & 7);
7971 AREG((Opcode >> 9) & 7) += 1;
7972 WRITE_BYTE_F(adr, res)
7973 POST_IO
7974RET(14)
7975}
7976
7977// MOVEB
7978OPCODE(0x1127)
7979{
7980 u32 adr, res;
7981 u32 src, dst;
7982
7983 adr = AREG(7) - 2;
7984 AREG(7) = adr;
7985 PRE_IO
7986 READ_BYTE_F(adr, res)
7987 flag_C = 0;
7988 flag_V = 0;
7989 flag_NotZ = res;
7990 flag_N = res;
7991 adr = AREG((Opcode >> 9) & 7) - 1;
7992 AREG((Opcode >> 9) & 7) = adr;
7993 WRITE_BYTE_F(adr, res)
7994 POST_IO
7995RET(14)
7996}
7997
7998// MOVEB
7999OPCODE(0x1167)
8000{
8001 u32 adr, res;
8002 u32 src, dst;
8003
8004 adr = AREG(7) - 2;
8005 AREG(7) = adr;
8006 PRE_IO
8007 READ_BYTE_F(adr, res)
8008 flag_C = 0;
8009 flag_V = 0;
8010 flag_NotZ = res;
8011 flag_N = res;
8012 FETCH_SWORD(adr);
8013 adr += AREG((Opcode >> 9) & 7);
8014 WRITE_BYTE_F(adr, res)
8015 POST_IO
8016RET(18)
8017}
8018
8019// MOVEB
8020OPCODE(0x11A7)
8021{
8022 u32 adr, res;
8023 u32 src, dst;
8024
8025 adr = AREG(7) - 2;
8026 AREG(7) = adr;
8027 PRE_IO
8028 READ_BYTE_F(adr, res)
8029 flag_C = 0;
8030 flag_V = 0;
8031 flag_NotZ = res;
8032 flag_N = res;
8033 adr = AREG((Opcode >> 9) & 7);
8034 DECODE_EXT_WORD
8035 WRITE_BYTE_F(adr, res)
8036 POST_IO
8037RET(20)
8038}
8039
8040// MOVEB
8041OPCODE(0x11E7)
8042{
8043 u32 adr, res;
8044 u32 src, dst;
8045
8046 adr = AREG(7) - 2;
8047 AREG(7) = adr;
8048 PRE_IO
8049 READ_BYTE_F(adr, res)
8050 flag_C = 0;
8051 flag_V = 0;
8052 flag_NotZ = res;
8053 flag_N = res;
8054 FETCH_SWORD(adr);
8055 WRITE_BYTE_F(adr, res)
8056 POST_IO
8057RET(18)
8058}
8059
8060// MOVEB
8061OPCODE(0x13E7)
8062{
8063 u32 adr, res;
8064 u32 src, dst;
8065
8066 adr = AREG(7) - 2;
8067 AREG(7) = adr;
8068 PRE_IO
8069 READ_BYTE_F(adr, res)
8070 flag_C = 0;
8071 flag_V = 0;
8072 flag_NotZ = res;
8073 flag_N = res;
8074 FETCH_LONG(adr);
8075 WRITE_BYTE_F(adr, res)
8076 POST_IO
8077RET(22)
8078}
8079
8080// MOVEB
8081OPCODE(0x1EE7)
8082{
8083 u32 adr, res;
8084 u32 src, dst;
8085
8086 adr = AREG(7) - 2;
8087 AREG(7) = adr;
8088 PRE_IO
8089 READ_BYTE_F(adr, res)
8090 flag_C = 0;
8091 flag_V = 0;
8092 flag_NotZ = res;
8093 flag_N = res;
8094 adr = AREG(7);
8095 AREG(7) += 2;
8096 WRITE_BYTE_F(adr, res)
8097 POST_IO
8098RET(14)
8099}
8100
8101// MOVEB
8102OPCODE(0x1F27)
8103{
8104 u32 adr, res;
8105 u32 src, dst;
8106
8107 adr = AREG(7) - 2;
8108 AREG(7) = adr;
8109 PRE_IO
8110 READ_BYTE_F(adr, res)
8111 flag_C = 0;
8112 flag_V = 0;
8113 flag_NotZ = res;
8114 flag_N = res;
8115 adr = AREG(7) - 2;
8116 AREG(7) = adr;
8117 WRITE_BYTE_F(adr, res)
8118 POST_IO
8119RET(14)
8120}
8121
8122// MOVEL
8123OPCODE(0x2000)
8124{
8125 u32 adr, res;
8126 u32 src, dst;
8127
8128 res = DREGu32((Opcode >> 0) & 7);
8129 flag_C = 0;
8130 flag_V = 0;
8131 flag_NotZ = res;
8132 flag_N = res >> 24;
8133 DREGu32((Opcode >> 9) & 7) = res;
8134RET(4)
8135}
8136
8137// MOVEL
8138OPCODE(0x2080)
8139{
8140 u32 adr, res;
8141 u32 src, dst;
8142
8143 res = DREGu32((Opcode >> 0) & 7);
8144 flag_C = 0;
8145 flag_V = 0;
8146 flag_NotZ = res;
8147 flag_N = res >> 24;
8148 adr = AREG((Opcode >> 9) & 7);
8149 PRE_IO
8150 WRITE_LONG_F(adr, res)
8151 POST_IO
8152RET(12)
8153}
8154
8155// MOVEL
8156OPCODE(0x20C0)
8157{
8158 u32 adr, res;
8159 u32 src, dst;
8160
8161 res = DREGu32((Opcode >> 0) & 7);
8162 flag_C = 0;
8163 flag_V = 0;
8164 flag_NotZ = res;
8165 flag_N = res >> 24;
8166 adr = AREG((Opcode >> 9) & 7);
8167 AREG((Opcode >> 9) & 7) += 4;
8168 PRE_IO
8169 WRITE_LONG_F(adr, res)
8170 POST_IO
8171RET(12)
8172}
8173
8174// MOVEL
8175OPCODE(0x2100)
8176{
8177 u32 adr, res;
8178 u32 src, dst;
8179
8180 res = DREGu32((Opcode >> 0) & 7);
8181 flag_C = 0;
8182 flag_V = 0;
8183 flag_NotZ = res;
8184 flag_N = res >> 24;
8185 adr = AREG((Opcode >> 9) & 7) - 4;
8186 AREG((Opcode >> 9) & 7) = adr;
8187 PRE_IO
80db4442 8188 WRITE_LONG_DEC_F(adr, res)
70357ce5 8189 POST_IO
8190RET(12)
8191}
8192
8193// MOVEL
8194OPCODE(0x2140)
8195{
8196 u32 adr, res;
8197 u32 src, dst;
8198
8199 res = DREGu32((Opcode >> 0) & 7);
8200 flag_C = 0;
8201 flag_V = 0;
8202 flag_NotZ = res;
8203 flag_N = res >> 24;
8204 FETCH_SWORD(adr);
8205 adr += AREG((Opcode >> 9) & 7);
8206 PRE_IO
8207 WRITE_LONG_F(adr, res)
8208 POST_IO
8209RET(16)
8210}
8211
8212// MOVEL
8213OPCODE(0x2180)
8214{
8215 u32 adr, res;
8216 u32 src, dst;
8217
8218 res = DREGu32((Opcode >> 0) & 7);
8219 flag_C = 0;
8220 flag_V = 0;
8221 flag_NotZ = res;
8222 flag_N = res >> 24;
8223 adr = AREG((Opcode >> 9) & 7);
8224 DECODE_EXT_WORD
8225 PRE_IO
8226 WRITE_LONG_F(adr, res)
8227 POST_IO
8228RET(18)
8229}
8230
8231// MOVEL
8232OPCODE(0x21C0)
8233{
8234 u32 adr, res;
8235 u32 src, dst;
8236
8237 res = DREGu32((Opcode >> 0) & 7);
8238 flag_C = 0;
8239 flag_V = 0;
8240 flag_NotZ = res;
8241 flag_N = res >> 24;
8242 FETCH_SWORD(adr);
8243 PRE_IO
8244 WRITE_LONG_F(adr, res)
8245 POST_IO
8246RET(16)
8247}
8248
8249// MOVEL
8250OPCODE(0x23C0)
8251{
8252 u32 adr, res;
8253 u32 src, dst;
8254
8255 res = DREGu32((Opcode >> 0) & 7);
8256 flag_C = 0;
8257 flag_V = 0;
8258 flag_NotZ = res;
8259 flag_N = res >> 24;
8260 FETCH_LONG(adr);
8261 PRE_IO
8262 WRITE_LONG_F(adr, res)
8263 POST_IO
8264RET(20)
8265}
8266
8267// MOVEL
8268OPCODE(0x2EC0)
8269{
8270 u32 adr, res;
8271 u32 src, dst;
8272
8273 res = DREGu32((Opcode >> 0) & 7);
8274 flag_C = 0;
8275 flag_V = 0;
8276 flag_NotZ = res;
8277 flag_N = res >> 24;
8278 adr = AREG(7);
8279 AREG(7) += 4;
8280 PRE_IO
8281 WRITE_LONG_F(adr, res)
8282 POST_IO
8283RET(12)
8284}
8285
8286// MOVEL
8287OPCODE(0x2F00)
8288{
8289 u32 adr, res;
8290 u32 src, dst;
8291
8292 res = DREGu32((Opcode >> 0) & 7);
8293 flag_C = 0;
8294 flag_V = 0;
8295 flag_NotZ = res;
8296 flag_N = res >> 24;
8297 adr = AREG(7) - 4;
8298 AREG(7) = adr;
8299 PRE_IO
03e4f2a3 8300 WRITE_LONG_DEC_F(adr, res)
70357ce5 8301 POST_IO
8302RET(12)
8303}
8304
8305// MOVEL
8306OPCODE(0x2008)
8307{
8308 u32 adr, res;
8309 u32 src, dst;
8310
8311 res = AREGu32((Opcode >> 0) & 7);
8312 flag_C = 0;
8313 flag_V = 0;
8314 flag_NotZ = res;
8315 flag_N = res >> 24;
8316 DREGu32((Opcode >> 9) & 7) = res;
8317RET(4)
8318}
8319
8320// MOVEL
8321OPCODE(0x2088)
8322{
8323 u32 adr, res;
8324 u32 src, dst;
8325
8326 res = AREGu32((Opcode >> 0) & 7);
8327 flag_C = 0;
8328 flag_V = 0;
8329 flag_NotZ = res;
8330 flag_N = res >> 24;
8331 adr = AREG((Opcode >> 9) & 7);
8332 PRE_IO
8333 WRITE_LONG_F(adr, res)
8334 POST_IO
8335RET(12)
8336}
8337
8338// MOVEL
8339OPCODE(0x20C8)
8340{
8341 u32 adr, res;
8342 u32 src, dst;
8343
8344 res = AREGu32((Opcode >> 0) & 7);
8345 flag_C = 0;
8346 flag_V = 0;
8347 flag_NotZ = res;
8348 flag_N = res >> 24;
8349 adr = AREG((Opcode >> 9) & 7);
8350 AREG((Opcode >> 9) & 7) += 4;
8351 PRE_IO
8352 WRITE_LONG_F(adr, res)
8353 POST_IO
8354RET(12)
8355}
8356
8357// MOVEL
8358OPCODE(0x2108)
8359{
8360 u32 adr, res;
8361 u32 src, dst;
8362
8363 res = AREGu32((Opcode >> 0) & 7);
8364 flag_C = 0;
8365 flag_V = 0;
8366 flag_NotZ = res;
8367 flag_N = res >> 24;
8368 adr = AREG((Opcode >> 9) & 7) - 4;
8369 AREG((Opcode >> 9) & 7) = adr;
8370 PRE_IO
80db4442 8371 WRITE_LONG_DEC_F(adr, res)
70357ce5 8372 POST_IO
8373RET(12)
8374}
8375
8376// MOVEL
8377OPCODE(0x2148)
8378{
8379 u32 adr, res;
8380 u32 src, dst;
8381
8382 res = AREGu32((Opcode >> 0) & 7);
8383 flag_C = 0;
8384 flag_V = 0;
8385 flag_NotZ = res;
8386 flag_N = res >> 24;
8387 FETCH_SWORD(adr);
8388 adr += AREG((Opcode >> 9) & 7);
8389 PRE_IO
8390 WRITE_LONG_F(adr, res)
8391 POST_IO
8392RET(16)
8393}
8394
8395// MOVEL
8396OPCODE(0x2188)
8397{
8398 u32 adr, res;
8399 u32 src, dst;
8400
8401 res = AREGu32((Opcode >> 0) & 7);
8402 flag_C = 0;
8403 flag_V = 0;
8404 flag_NotZ = res;
8405 flag_N = res >> 24;
8406 adr = AREG((Opcode >> 9) & 7);
8407 DECODE_EXT_WORD
8408 PRE_IO
8409 WRITE_LONG_F(adr, res)
8410 POST_IO
8411RET(18)
8412}
8413
8414// MOVEL
8415OPCODE(0x21C8)
8416{
8417 u32 adr, res;
8418 u32 src, dst;
8419
8420 res = AREGu32((Opcode >> 0) & 7);
8421 flag_C = 0;
8422 flag_V = 0;
8423 flag_NotZ = res;
8424 flag_N = res >> 24;
8425 FETCH_SWORD(adr);
8426 PRE_IO
8427 WRITE_LONG_F(adr, res)
8428 POST_IO
8429RET(16)
8430}
8431
8432// MOVEL
8433OPCODE(0x23C8)
8434{
8435 u32 adr, res;
8436 u32 src, dst;
8437
8438 res = AREGu32((Opcode >> 0) & 7);
8439 flag_C = 0;
8440 flag_V = 0;
8441 flag_NotZ = res;
8442 flag_N = res >> 24;
8443 FETCH_LONG(adr);
8444 PRE_IO
8445 WRITE_LONG_F(adr, res)
8446 POST_IO
8447RET(20)
8448}
8449
8450// MOVEL
8451OPCODE(0x2EC8)
8452{
8453 u32 adr, res;
8454 u32 src, dst;
8455
8456 res = AREGu32((Opcode >> 0) & 7);
8457 flag_C = 0;
8458 flag_V = 0;
8459 flag_NotZ = res;
8460 flag_N = res >> 24;
8461 adr = AREG(7);
8462 AREG(7) += 4;
8463 PRE_IO
8464 WRITE_LONG_F(adr, res)
8465 POST_IO
8466RET(12)
8467}
8468
8469// MOVEL
8470OPCODE(0x2F08)
8471{
8472 u32 adr, res;
8473 u32 src, dst;
8474
8475 res = AREGu32((Opcode >> 0) & 7);
8476 flag_C = 0;
8477 flag_V = 0;
8478 flag_NotZ = res;
8479 flag_N = res >> 24;
8480 adr = AREG(7) - 4;
8481 AREG(7) = adr;
8482 PRE_IO
03e4f2a3 8483 WRITE_LONG_DEC_F(adr, res)
70357ce5 8484 POST_IO
8485RET(12)
8486}
8487
8488// MOVEL
8489OPCODE(0x2010)
8490{
8491 u32 adr, res;
8492 u32 src, dst;
8493
8494 adr = AREG((Opcode >> 0) & 7);
8495 PRE_IO
8496 READ_LONG_F(adr, res)
8497 flag_C = 0;
8498 flag_V = 0;
8499 flag_NotZ = res;
8500 flag_N = res >> 24;
8501 DREGu32((Opcode >> 9) & 7) = res;
8502 POST_IO
8503RET(12)
8504}
8505
8506// MOVEL
8507OPCODE(0x2090)
8508{
8509 u32 adr, res;
8510 u32 src, dst;
8511
8512 adr = AREG((Opcode >> 0) & 7);
8513 PRE_IO
8514 READ_LONG_F(adr, res)
8515 flag_C = 0;
8516 flag_V = 0;
8517 flag_NotZ = res;
8518 flag_N = res >> 24;
8519 adr = AREG((Opcode >> 9) & 7);
8520 WRITE_LONG_F(adr, res)
8521 POST_IO
8522RET(20)
8523}
8524
8525// MOVEL
8526OPCODE(0x20D0)
8527{
8528 u32 adr, res;
8529 u32 src, dst;
8530
8531 adr = AREG((Opcode >> 0) & 7);
8532 PRE_IO
8533 READ_LONG_F(adr, res)
8534 flag_C = 0;
8535 flag_V = 0;
8536 flag_NotZ = res;
8537 flag_N = res >> 24;
8538 adr = AREG((Opcode >> 9) & 7);
8539 AREG((Opcode >> 9) & 7) += 4;
8540 WRITE_LONG_F(adr, res)
8541 POST_IO
8542RET(20)
8543}
8544
8545// MOVEL
8546OPCODE(0x2110)
8547{
8548 u32 adr, res;
8549 u32 src, dst;
8550
8551 adr = AREG((Opcode >> 0) & 7);
8552 PRE_IO
8553 READ_LONG_F(adr, res)
8554 flag_C = 0;
8555 flag_V = 0;
8556 flag_NotZ = res;
8557 flag_N = res >> 24;
8558 adr = AREG((Opcode >> 9) & 7) - 4;
8559 AREG((Opcode >> 9) & 7) = adr;
80db4442 8560 WRITE_LONG_DEC_F(adr, res)
70357ce5 8561 POST_IO
8562RET(20)
8563}
8564
8565// MOVEL
8566OPCODE(0x2150)
8567{
8568 u32 adr, res;
8569 u32 src, dst;
8570
8571 adr = AREG((Opcode >> 0) & 7);
8572 PRE_IO
8573 READ_LONG_F(adr, res)
8574 flag_C = 0;
8575 flag_V = 0;
8576 flag_NotZ = res;
8577 flag_N = res >> 24;
8578 FETCH_SWORD(adr);
8579 adr += AREG((Opcode >> 9) & 7);
8580 WRITE_LONG_F(adr, res)
8581 POST_IO
8582RET(24)
8583}
8584
8585// MOVEL
8586OPCODE(0x2190)
8587{
8588 u32 adr, res;
8589 u32 src, dst;
8590
8591 adr = AREG((Opcode >> 0) & 7);
8592 PRE_IO
8593 READ_LONG_F(adr, res)
8594 flag_C = 0;
8595 flag_V = 0;
8596 flag_NotZ = res;
8597 flag_N = res >> 24;
8598 adr = AREG((Opcode >> 9) & 7);
8599 DECODE_EXT_WORD
8600 WRITE_LONG_F(adr, res)
8601 POST_IO
8602RET(26)
8603}
8604
8605// MOVEL
8606OPCODE(0x21D0)
8607{
8608 u32 adr, res;
8609 u32 src, dst;
8610
8611 adr = AREG((Opcode >> 0) & 7);
8612 PRE_IO
8613 READ_LONG_F(adr, res)
8614 flag_C = 0;
8615 flag_V = 0;
8616 flag_NotZ = res;
8617 flag_N = res >> 24;
8618 FETCH_SWORD(adr);
8619 WRITE_LONG_F(adr, res)
8620 POST_IO
8621RET(24)
8622}
8623
8624// MOVEL
8625OPCODE(0x23D0)
8626{
8627 u32 adr, res;
8628 u32 src, dst;
8629
8630 adr = AREG((Opcode >> 0) & 7);
8631 PRE_IO
8632 READ_LONG_F(adr, res)
8633 flag_C = 0;
8634 flag_V = 0;
8635 flag_NotZ = res;
8636 flag_N = res >> 24;
8637 FETCH_LONG(adr);
8638 WRITE_LONG_F(adr, res)
8639 POST_IO
8640RET(28)
8641}
8642
8643// MOVEL
8644OPCODE(0x2ED0)
8645{
8646 u32 adr, res;
8647 u32 src, dst;
8648
8649 adr = AREG((Opcode >> 0) & 7);
8650 PRE_IO
8651 READ_LONG_F(adr, res)
8652 flag_C = 0;
8653 flag_V = 0;
8654 flag_NotZ = res;
8655 flag_N = res >> 24;
8656 adr = AREG(7);
8657 AREG(7) += 4;
8658 WRITE_LONG_F(adr, res)
8659 POST_IO
8660RET(20)
8661}
8662
8663// MOVEL
8664OPCODE(0x2F10)
8665{
8666 u32 adr, res;
8667 u32 src, dst;
8668
8669 adr = AREG((Opcode >> 0) & 7);
8670 PRE_IO
8671 READ_LONG_F(adr, res)
8672 flag_C = 0;
8673 flag_V = 0;
8674 flag_NotZ = res;
8675 flag_N = res >> 24;
8676 adr = AREG(7) - 4;
8677 AREG(7) = adr;
03e4f2a3 8678 WRITE_LONG_DEC_F(adr, res)
70357ce5 8679 POST_IO
8680RET(20)
8681}
8682
8683// MOVEL
8684OPCODE(0x2018)
8685{
8686 u32 adr, res;
8687 u32 src, dst;
8688
8689 adr = AREG((Opcode >> 0) & 7);
8690 AREG((Opcode >> 0) & 7) += 4;
8691 PRE_IO
8692 READ_LONG_F(adr, res)
8693 flag_C = 0;
8694 flag_V = 0;
8695 flag_NotZ = res;
8696 flag_N = res >> 24;
8697 DREGu32((Opcode >> 9) & 7) = res;
8698 POST_IO
8699RET(12)
8700}
8701
8702// MOVEL
8703OPCODE(0x2098)
8704{
8705 u32 adr, res;
8706 u32 src, dst;
8707
8708 adr = AREG((Opcode >> 0) & 7);
8709 AREG((Opcode >> 0) & 7) += 4;
8710 PRE_IO
8711 READ_LONG_F(adr, res)
8712 flag_C = 0;
8713 flag_V = 0;
8714 flag_NotZ = res;
8715 flag_N = res >> 24;
8716 adr = AREG((Opcode >> 9) & 7);
8717 WRITE_LONG_F(adr, res)
8718 POST_IO
8719RET(20)
8720}
8721
8722// MOVEL
8723OPCODE(0x20D8)
8724{
8725 u32 adr, res;
8726 u32 src, dst;
8727
8728 adr = AREG((Opcode >> 0) & 7);
8729 AREG((Opcode >> 0) & 7) += 4;
8730 PRE_IO
8731 READ_LONG_F(adr, res)
8732 flag_C = 0;
8733 flag_V = 0;
8734 flag_NotZ = res;
8735 flag_N = res >> 24;
8736 adr = AREG((Opcode >> 9) & 7);
8737 AREG((Opcode >> 9) & 7) += 4;
8738 WRITE_LONG_F(adr, res)
8739 POST_IO
8740RET(20)
8741}
8742
8743// MOVEL
8744OPCODE(0x2118)
8745{
8746 u32 adr, res;
8747 u32 src, dst;
8748
8749 adr = AREG((Opcode >> 0) & 7);
8750 AREG((Opcode >> 0) & 7) += 4;
8751 PRE_IO
8752 READ_LONG_F(adr, res)
8753 flag_C = 0;
8754 flag_V = 0;
8755 flag_NotZ = res;
8756 flag_N = res >> 24;
8757 adr = AREG((Opcode >> 9) & 7) - 4;
8758 AREG((Opcode >> 9) & 7) = adr;
80db4442 8759 WRITE_LONG_DEC_F(adr, res)
70357ce5 8760 POST_IO
8761RET(20)
8762}
8763
8764// MOVEL
8765OPCODE(0x2158)
8766{
8767 u32 adr, res;
8768 u32 src, dst;
8769
8770 adr = AREG((Opcode >> 0) & 7);
8771 AREG((Opcode >> 0) & 7) += 4;
8772 PRE_IO
8773 READ_LONG_F(adr, res)
8774 flag_C = 0;
8775 flag_V = 0;
8776 flag_NotZ = res;
8777 flag_N = res >> 24;
8778 FETCH_SWORD(adr);
8779 adr += AREG((Opcode >> 9) & 7);
8780 WRITE_LONG_F(adr, res)
8781 POST_IO
8782RET(24)
8783}
8784
8785// MOVEL
8786OPCODE(0x2198)
8787{
8788 u32 adr, res;
8789 u32 src, dst;
8790
8791 adr = AREG((Opcode >> 0) & 7);
8792 AREG((Opcode >> 0) & 7) += 4;
8793 PRE_IO
8794 READ_LONG_F(adr, res)
8795 flag_C = 0;
8796 flag_V = 0;
8797 flag_NotZ = res;
8798 flag_N = res >> 24;
8799 adr = AREG((Opcode >> 9) & 7);
8800 DECODE_EXT_WORD
8801 WRITE_LONG_F(adr, res)
8802 POST_IO
8803RET(26)
8804}
8805
8806// MOVEL
8807OPCODE(0x21D8)
8808{
8809 u32 adr, res;
8810 u32 src, dst;
8811
8812 adr = AREG((Opcode >> 0) & 7);
8813 AREG((Opcode >> 0) & 7) += 4;
8814 PRE_IO
8815 READ_LONG_F(adr, res)
8816 flag_C = 0;
8817 flag_V = 0;
8818 flag_NotZ = res;
8819 flag_N = res >> 24;
8820 FETCH_SWORD(adr);
8821 WRITE_LONG_F(adr, res)
8822 POST_IO
8823RET(24)
8824}
8825
8826// MOVEL
8827OPCODE(0x23D8)
8828{
8829 u32 adr, res;
8830 u32 src, dst;
8831
8832 adr = AREG((Opcode >> 0) & 7);
8833 AREG((Opcode >> 0) & 7) += 4;
8834 PRE_IO
8835 READ_LONG_F(adr, res)
8836 flag_C = 0;
8837 flag_V = 0;
8838 flag_NotZ = res;
8839 flag_N = res >> 24;
8840 FETCH_LONG(adr);
8841 WRITE_LONG_F(adr, res)
8842 POST_IO
8843RET(28)
8844}
8845
8846// MOVEL
8847OPCODE(0x2ED8)
8848{
8849 u32 adr, res;
8850 u32 src, dst;
8851
8852 adr = AREG((Opcode >> 0) & 7);
8853 AREG((Opcode >> 0) & 7) += 4;
8854 PRE_IO
8855 READ_LONG_F(adr, res)
8856 flag_C = 0;
8857 flag_V = 0;
8858 flag_NotZ = res;
8859 flag_N = res >> 24;
8860 adr = AREG(7);
8861 AREG(7) += 4;
8862 WRITE_LONG_F(adr, res)
8863 POST_IO
8864RET(20)
8865}
8866
8867// MOVEL
8868OPCODE(0x2F18)
8869{
8870 u32 adr, res;
8871 u32 src, dst;
8872
8873 adr = AREG((Opcode >> 0) & 7);
8874 AREG((Opcode >> 0) & 7) += 4;
8875 PRE_IO
8876 READ_LONG_F(adr, res)
8877 flag_C = 0;
8878 flag_V = 0;
8879 flag_NotZ = res;
8880 flag_N = res >> 24;
8881 adr = AREG(7) - 4;
8882 AREG(7) = adr;
03e4f2a3 8883 WRITE_LONG_DEC_F(adr, res)
70357ce5 8884 POST_IO
8885RET(20)
8886}
8887
8888// MOVEL
8889OPCODE(0x2020)
8890{
8891 u32 adr, res;
8892 u32 src, dst;
8893
8894 adr = AREG((Opcode >> 0) & 7) - 4;
8895 AREG((Opcode >> 0) & 7) = adr;
8896 PRE_IO
8897 READ_LONG_F(adr, res)
8898 flag_C = 0;
8899 flag_V = 0;
8900 flag_NotZ = res;
8901 flag_N = res >> 24;
8902 DREGu32((Opcode >> 9) & 7) = res;
8903 POST_IO
8904RET(14)
8905}
8906
8907// MOVEL
8908OPCODE(0x20A0)
8909{
8910 u32 adr, res;
8911 u32 src, dst;
8912
8913 adr = AREG((Opcode >> 0) & 7) - 4;
8914 AREG((Opcode >> 0) & 7) = adr;
8915 PRE_IO
8916 READ_LONG_F(adr, res)
8917 flag_C = 0;
8918 flag_V = 0;
8919 flag_NotZ = res;
8920 flag_N = res >> 24;
8921 adr = AREG((Opcode >> 9) & 7);
8922 WRITE_LONG_F(adr, res)
8923 POST_IO
8924RET(22)
8925}
8926
8927// MOVEL
8928OPCODE(0x20E0)
8929{
8930 u32 adr, res;
8931 u32 src, dst;
8932
8933 adr = AREG((Opcode >> 0) & 7) - 4;
8934 AREG((Opcode >> 0) & 7) = adr;
8935 PRE_IO
8936 READ_LONG_F(adr, res)
8937 flag_C = 0;
8938 flag_V = 0;
8939 flag_NotZ = res;
8940 flag_N = res >> 24;
8941 adr = AREG((Opcode >> 9) & 7);
8942 AREG((Opcode >> 9) & 7) += 4;
8943 WRITE_LONG_F(adr, res)
8944 POST_IO
8945RET(22)
8946}
8947
8948// MOVEL
8949OPCODE(0x2120)
8950{
8951 u32 adr, res;
8952 u32 src, dst;
8953
8954 adr = AREG((Opcode >> 0) & 7) - 4;
8955 AREG((Opcode >> 0) & 7) = adr;
8956 PRE_IO
8957 READ_LONG_F(adr, res)
8958 flag_C = 0;
8959 flag_V = 0;
8960 flag_NotZ = res;
8961 flag_N = res >> 24;
8962 adr = AREG((Opcode >> 9) & 7) - 4;
8963 AREG((Opcode >> 9) & 7) = adr;
80db4442 8964 WRITE_LONG_DEC_F(adr, res)
70357ce5 8965 POST_IO
8966RET(22)
8967}
8968
8969// MOVEL
8970OPCODE(0x2160)
8971{
8972 u32 adr, res;
8973 u32 src, dst;
8974
8975 adr = AREG((Opcode >> 0) & 7) - 4;
8976 AREG((Opcode >> 0) & 7) = adr;
8977 PRE_IO
8978 READ_LONG_F(adr, res)
8979 flag_C = 0;
8980 flag_V = 0;
8981 flag_NotZ = res;
8982 flag_N = res >> 24;
8983 FETCH_SWORD(adr);
8984 adr += AREG((Opcode >> 9) & 7);
8985 WRITE_LONG_F(adr, res)
8986 POST_IO
8987RET(26)
8988}
8989
8990// MOVEL
8991OPCODE(0x21A0)
8992{
8993 u32 adr, res;
8994 u32 src, dst;
8995
8996 adr = AREG((Opcode >> 0) & 7) - 4;
8997 AREG((Opcode >> 0) & 7) = adr;
8998 PRE_IO
8999 READ_LONG_F(adr, res)
9000 flag_C = 0;
9001 flag_V = 0;
9002 flag_NotZ = res;
9003 flag_N = res >> 24;
9004 adr = AREG((Opcode >> 9) & 7);
9005 DECODE_EXT_WORD
9006 WRITE_LONG_F(adr, res)
9007 POST_IO
9008RET(28)
9009}
9010
9011// MOVEL
9012OPCODE(0x21E0)
9013{
9014 u32 adr, res;
9015 u32 src, dst;
9016
9017 adr = AREG((Opcode >> 0) & 7) - 4;
9018 AREG((Opcode >> 0) & 7) = adr;
9019 PRE_IO
9020 READ_LONG_F(adr, res)
9021 flag_C = 0;
9022 flag_V = 0;
9023 flag_NotZ = res;
9024 flag_N = res >> 24;
9025 FETCH_SWORD(adr);
9026 WRITE_LONG_F(adr, res)
9027 POST_IO
9028RET(26)
9029}
9030
9031// MOVEL
9032OPCODE(0x23E0)
9033{
9034 u32 adr, res;
9035 u32 src, dst;
9036
9037 adr = AREG((Opcode >> 0) & 7) - 4;
9038 AREG((Opcode >> 0) & 7) = adr;
9039 PRE_IO
9040 READ_LONG_F(adr, res)
9041 flag_C = 0;
9042 flag_V = 0;
9043 flag_NotZ = res;
9044 flag_N = res >> 24;
9045 FETCH_LONG(adr);
9046 WRITE_LONG_F(adr, res)
9047 POST_IO
9048RET(30)
9049}
9050
9051// MOVEL
9052OPCODE(0x2EE0)
9053{
9054 u32 adr, res;
9055 u32 src, dst;
9056
9057 adr = AREG((Opcode >> 0) & 7) - 4;
9058 AREG((Opcode >> 0) & 7) = adr;
9059 PRE_IO
9060 READ_LONG_F(adr, res)
9061 flag_C = 0;
9062 flag_V = 0;
9063 flag_NotZ = res;
9064 flag_N = res >> 24;
9065 adr = AREG(7);
9066 AREG(7) += 4;
9067 WRITE_LONG_F(adr, res)
9068 POST_IO
9069RET(22)
9070}
9071
9072// MOVEL
9073OPCODE(0x2F20)
9074{
9075 u32 adr, res;
9076 u32 src, dst;
9077
9078 adr = AREG((Opcode >> 0) & 7) - 4;
9079 AREG((Opcode >> 0) & 7) = adr;
9080 PRE_IO
9081 READ_LONG_F(adr, res)
9082 flag_C = 0;
9083 flag_V = 0;
9084 flag_NotZ = res;
9085 flag_N = res >> 24;
9086 adr = AREG(7) - 4;
9087 AREG(7) = adr;
03e4f2a3 9088 WRITE_LONG_DEC_F(adr, res)
70357ce5 9089 POST_IO
9090RET(22)
9091}
9092
9093// MOVEL
9094OPCODE(0x2028)
9095{
9096 u32 adr, res;
9097 u32 src, dst;
9098
9099 FETCH_SWORD(adr);
9100 adr += AREG((Opcode >> 0) & 7);
9101 PRE_IO
9102 READ_LONG_F(adr, res)
9103 flag_C = 0;
9104 flag_V = 0;
9105 flag_NotZ = res;
9106 flag_N = res >> 24;
9107 DREGu32((Opcode >> 9) & 7) = res;
9108 POST_IO
9109RET(16)
9110}
9111
9112// MOVEL
9113OPCODE(0x20A8)
9114{
9115 u32 adr, res;
9116 u32 src, dst;
9117
9118 FETCH_SWORD(adr);
9119 adr += AREG((Opcode >> 0) & 7);
9120 PRE_IO
9121 READ_LONG_F(adr, res)
9122 flag_C = 0;
9123 flag_V = 0;
9124 flag_NotZ = res;
9125 flag_N = res >> 24;
9126 adr = AREG((Opcode >> 9) & 7);
9127 WRITE_LONG_F(adr, res)
9128 POST_IO
9129RET(24)
9130}
9131
9132// MOVEL
9133OPCODE(0x20E8)
9134{
9135 u32 adr, res;
9136 u32 src, dst;
9137
9138 FETCH_SWORD(adr);
9139 adr += AREG((Opcode >> 0) & 7);
9140 PRE_IO
9141 READ_LONG_F(adr, res)
9142 flag_C = 0;
9143 flag_V = 0;
9144 flag_NotZ = res;
9145 flag_N = res >> 24;
9146 adr = AREG((Opcode >> 9) & 7);
9147 AREG((Opcode >> 9) & 7) += 4;
9148 WRITE_LONG_F(adr, res)
9149 POST_IO
9150RET(24)
9151}
9152
9153// MOVEL
9154OPCODE(0x2128)
9155{
9156 u32 adr, res;
9157 u32 src, dst;
9158
9159 FETCH_SWORD(adr);
9160 adr += AREG((Opcode >> 0) & 7);
9161 PRE_IO
9162 READ_LONG_F(adr, res)
9163 flag_C = 0;
9164 flag_V = 0;
9165 flag_NotZ = res;
9166 flag_N = res >> 24;
9167 adr = AREG((Opcode >> 9) & 7) - 4;
9168 AREG((Opcode >> 9) & 7) = adr;
80db4442 9169 WRITE_LONG_DEC_F(adr, res)
70357ce5 9170 POST_IO
9171RET(24)
9172}
9173
9174// MOVEL
9175OPCODE(0x2168)
9176{
9177 u32 adr, res;
9178 u32 src, dst;
9179
9180 FETCH_SWORD(adr);
9181 adr += AREG((Opcode >> 0) & 7);
9182 PRE_IO
9183 READ_LONG_F(adr, res)
9184 flag_C = 0;
9185 flag_V = 0;
9186 flag_NotZ = res;
9187 flag_N = res >> 24;
9188 FETCH_SWORD(adr);
9189 adr += AREG((Opcode >> 9) & 7);
9190 WRITE_LONG_F(adr, res)
9191 POST_IO
9192RET(28)
9193}
9194
9195// MOVEL
9196OPCODE(0x21A8)
9197{
9198 u32 adr, res;
9199 u32 src, dst;
9200
9201 FETCH_SWORD(adr);
9202 adr += AREG((Opcode >> 0) & 7);
9203 PRE_IO
9204 READ_LONG_F(adr, res)
9205 flag_C = 0;
9206 flag_V = 0;
9207 flag_NotZ = res;
9208 flag_N = res >> 24;
9209 adr = AREG((Opcode >> 9) & 7);
9210 DECODE_EXT_WORD
9211 WRITE_LONG_F(adr, res)
9212 POST_IO
9213RET(30)
9214}
9215
9216// MOVEL
9217OPCODE(0x21E8)
9218{
9219 u32 adr, res;
9220 u32 src, dst;
9221
9222 FETCH_SWORD(adr);
9223 adr += AREG((Opcode >> 0) & 7);
9224 PRE_IO
9225 READ_LONG_F(adr, res)
9226 flag_C = 0;
9227 flag_V = 0;
9228 flag_NotZ = res;
9229 flag_N = res >> 24;
9230 FETCH_SWORD(adr);
9231 WRITE_LONG_F(adr, res)
9232 POST_IO
9233RET(28)
9234}
9235
9236// MOVEL
9237OPCODE(0x23E8)
9238{
9239 u32 adr, res;
9240 u32 src, dst;
9241
9242 FETCH_SWORD(adr);
9243 adr += AREG((Opcode >> 0) & 7);
9244 PRE_IO
9245 READ_LONG_F(adr, res)
9246 flag_C = 0;
9247 flag_V = 0;
9248 flag_NotZ = res;
9249 flag_N = res >> 24;
9250 FETCH_LONG(adr);
9251 WRITE_LONG_F(adr, res)
9252 POST_IO
9253RET(32)
9254}
9255
9256// MOVEL
9257OPCODE(0x2EE8)
9258{
9259 u32 adr, res;
9260 u32 src, dst;
9261
9262 FETCH_SWORD(adr);
9263 adr += AREG((Opcode >> 0) & 7);
9264 PRE_IO
9265 READ_LONG_F(adr, res)
9266 flag_C = 0;
9267 flag_V = 0;
9268 flag_NotZ = res;
9269 flag_N = res >> 24;
9270 adr = AREG(7);
9271 AREG(7) += 4;
9272 WRITE_LONG_F(adr, res)
9273 POST_IO
9274RET(24)
9275}
9276
9277// MOVEL
9278OPCODE(0x2F28)
9279{
9280 u32 adr, res;
9281 u32 src, dst;
9282
9283 FETCH_SWORD(adr);
9284 adr += AREG((Opcode >> 0) & 7);
9285 PRE_IO
9286 READ_LONG_F(adr, res)
9287 flag_C = 0;
9288 flag_V = 0;
9289 flag_NotZ = res;
9290 flag_N = res >> 24;
9291 adr = AREG(7) - 4;
9292 AREG(7) = adr;
03e4f2a3 9293 WRITE_LONG_DEC_F(adr, res)
70357ce5 9294 POST_IO
9295RET(24)
9296}
9297
9298// MOVEL
9299OPCODE(0x2030)
9300{
9301 u32 adr, res;
9302 u32 src, dst;
9303
9304 adr = AREG((Opcode >> 0) & 7);
9305 DECODE_EXT_WORD
9306 PRE_IO
9307 READ_LONG_F(adr, res)
9308 flag_C = 0;
9309 flag_V = 0;
9310 flag_NotZ = res;
9311 flag_N = res >> 24;
9312 DREGu32((Opcode >> 9) & 7) = res;
9313 POST_IO
9314RET(18)
9315}
9316
9317// MOVEL
9318OPCODE(0x20B0)
9319{
9320 u32 adr, res;
9321 u32 src, dst;
9322
9323 adr = AREG((Opcode >> 0) & 7);
9324 DECODE_EXT_WORD
9325 PRE_IO
9326 READ_LONG_F(adr, res)
9327 flag_C = 0;
9328 flag_V = 0;
9329 flag_NotZ = res;
9330 flag_N = res >> 24;
9331 adr = AREG((Opcode >> 9) & 7);
9332 WRITE_LONG_F(adr, res)
9333 POST_IO
9334RET(26)
9335}
9336
9337// MOVEL
9338OPCODE(0x20F0)
9339{
9340 u32 adr, res;
9341 u32 src, dst;
9342
9343 adr = AREG((Opcode >> 0) & 7);
9344 DECODE_EXT_WORD
9345 PRE_IO
9346 READ_LONG_F(adr, res)
9347 flag_C = 0;
9348 flag_V = 0;
9349 flag_NotZ = res;
9350 flag_N = res >> 24;
9351 adr = AREG((Opcode >> 9) & 7);
9352 AREG((Opcode >> 9) & 7) += 4;
9353 WRITE_LONG_F(adr, res)
9354 POST_IO
9355RET(26)
9356}
9357
9358// MOVEL
9359OPCODE(0x2130)
9360{
9361 u32 adr, res;
9362 u32 src, dst;
9363
9364 adr = AREG((Opcode >> 0) & 7);
9365 DECODE_EXT_WORD
9366 PRE_IO
9367 READ_LONG_F(adr, res)
9368 flag_C = 0;
9369 flag_V = 0;
9370 flag_NotZ = res;
9371 flag_N = res >> 24;
9372 adr = AREG((Opcode >> 9) & 7) - 4;
9373 AREG((Opcode >> 9) & 7) = adr;
80db4442 9374 WRITE_LONG_DEC_F(adr, res)
70357ce5 9375 POST_IO
9376RET(26)
9377}
9378
9379// MOVEL
9380OPCODE(0x2170)
9381{
9382 u32 adr, res;
9383 u32 src, dst;
9384
9385 adr = AREG((Opcode >> 0) & 7);
9386 DECODE_EXT_WORD
9387 PRE_IO
9388 READ_LONG_F(adr, res)
9389 flag_C = 0;
9390 flag_V = 0;
9391 flag_NotZ = res;
9392 flag_N = res >> 24;
9393 FETCH_SWORD(adr);
9394 adr += AREG((Opcode >> 9) & 7);
9395 WRITE_LONG_F(adr, res)
9396 POST_IO
9397RET(30)
9398}
9399
9400// MOVEL
9401OPCODE(0x21B0)
9402{
9403 u32 adr, res;
9404 u32 src, dst;
9405
9406 adr = AREG((Opcode >> 0) & 7);
9407 DECODE_EXT_WORD
9408 PRE_IO
9409 READ_LONG_F(adr, res)
9410 flag_C = 0;
9411 flag_V = 0;
9412 flag_NotZ = res;
9413 flag_N = res >> 24;
9414 adr = AREG((Opcode >> 9) & 7);
9415 DECODE_EXT_WORD
9416 WRITE_LONG_F(adr, res)
9417 POST_IO
9418RET(32)
9419}
9420
9421// MOVEL
9422OPCODE(0x21F0)
9423{
9424 u32 adr, res;
9425 u32 src, dst;
9426
9427 adr = AREG((Opcode >> 0) & 7);
9428 DECODE_EXT_WORD
9429 PRE_IO
9430 READ_LONG_F(adr, res)
9431 flag_C = 0;
9432 flag_V = 0;
9433 flag_NotZ = res;
9434 flag_N = res >> 24;
9435 FETCH_SWORD(adr);
9436 WRITE_LONG_F(adr, res)
9437 POST_IO
9438RET(30)
9439}
9440
9441// MOVEL
9442OPCODE(0x23F0)
9443{
9444 u32 adr, res;
9445 u32 src, dst;
9446
9447 adr = AREG((Opcode >> 0) & 7);
9448 DECODE_EXT_WORD
9449 PRE_IO
9450 READ_LONG_F(adr, res)
9451 flag_C = 0;
9452 flag_V = 0;
9453 flag_NotZ = res;
9454 flag_N = res >> 24;
9455 FETCH_LONG(adr);
9456 WRITE_LONG_F(adr, res)
9457 POST_IO
9458RET(34)
9459}
9460
9461// MOVEL
9462OPCODE(0x2EF0)
9463{
9464 u32 adr, res;
9465 u32 src, dst;
9466
9467 adr = AREG((Opcode >> 0) & 7);
9468 DECODE_EXT_WORD
9469 PRE_IO
9470 READ_LONG_F(adr, res)
9471 flag_C = 0;
9472 flag_V = 0;
9473 flag_NotZ = res;
9474 flag_N = res >> 24;
9475 adr = AREG(7);
9476 AREG(7) += 4;
9477 WRITE_LONG_F(adr, res)
9478 POST_IO
9479RET(26)
9480}
9481
9482// MOVEL
9483OPCODE(0x2F30)
9484{
9485 u32 adr, res;
9486 u32 src, dst;
9487
9488 adr = AREG((Opcode >> 0) & 7);
9489 DECODE_EXT_WORD
9490 PRE_IO
9491 READ_LONG_F(adr, res)
9492 flag_C = 0;
9493 flag_V = 0;
9494 flag_NotZ = res;
9495 flag_N = res >> 24;
9496 adr = AREG(7) - 4;
9497 AREG(7) = adr;
03e4f2a3 9498 WRITE_LONG_DEC_F(adr, res)
70357ce5 9499 POST_IO
9500RET(26)
9501}
9502
9503// MOVEL
9504OPCODE(0x2038)
9505{
9506 u32 adr, res;
9507 u32 src, dst;
9508
9509 FETCH_SWORD(adr);
9510 PRE_IO
9511 READ_LONG_F(adr, res)
9512 flag_C = 0;
9513 flag_V = 0;
9514 flag_NotZ = res;
9515 flag_N = res >> 24;
9516 DREGu32((Opcode >> 9) & 7) = res;
9517 POST_IO
9518RET(16)
9519}
9520
9521// MOVEL
9522OPCODE(0x20B8)
9523{
9524 u32 adr, res;
9525 u32 src, dst;
9526
9527 FETCH_SWORD(adr);
9528 PRE_IO
9529 READ_LONG_F(adr, res)
9530 flag_C = 0;
9531 flag_V = 0;
9532 flag_NotZ = res;
9533 flag_N = res >> 24;
9534 adr = AREG((Opcode >> 9) & 7);
9535 WRITE_LONG_F(adr, res)
9536 POST_IO
9537RET(24)
9538}
9539
9540// MOVEL
9541OPCODE(0x20F8)
9542{
9543 u32 adr, res;
9544 u32 src, dst;
9545
9546 FETCH_SWORD(adr);
9547 PRE_IO
9548 READ_LONG_F(adr, res)
9549 flag_C = 0;
9550 flag_V = 0;
9551 flag_NotZ = res;
9552 flag_N = res >> 24;
9553 adr = AREG((Opcode >> 9) & 7);
9554 AREG((Opcode >> 9) & 7) += 4;
9555 WRITE_LONG_F(adr, res)
9556 POST_IO
9557RET(24)
9558}
9559
9560// MOVEL
9561OPCODE(0x2138)
9562{
9563 u32 adr, res;
9564 u32 src, dst;
9565
9566 FETCH_SWORD(adr);
9567 PRE_IO
9568 READ_LONG_F(adr, res)
9569 flag_C = 0;
9570 flag_V = 0;
9571 flag_NotZ = res;
9572 flag_N = res >> 24;
9573 adr = AREG((Opcode >> 9) & 7) - 4;
9574 AREG((Opcode >> 9) & 7) = adr;
80db4442 9575 WRITE_LONG_DEC_F(adr, res)
70357ce5 9576 POST_IO
9577RET(24)
9578}
9579
9580// MOVEL
9581OPCODE(0x2178)
9582{
9583 u32 adr, res;
9584 u32 src, dst;
9585
9586 FETCH_SWORD(adr);
9587 PRE_IO
9588 READ_LONG_F(adr, res)
9589 flag_C = 0;
9590 flag_V = 0;
9591 flag_NotZ = res;
9592 flag_N = res >> 24;
9593 FETCH_SWORD(adr);
9594 adr += AREG((Opcode >> 9) & 7);
9595 WRITE_LONG_F(adr, res)
9596 POST_IO
9597RET(28)
9598}
9599
9600// MOVEL
9601OPCODE(0x21B8)
9602{
9603 u32 adr, res;
9604 u32 src, dst;
9605
9606 FETCH_SWORD(adr);
9607 PRE_IO
9608 READ_LONG_F(adr, res)
9609 flag_C = 0;
9610 flag_V = 0;
9611 flag_NotZ = res;
9612 flag_N = res >> 24;
9613 adr = AREG((Opcode >> 9) & 7);
9614 DECODE_EXT_WORD
9615 WRITE_LONG_F(adr, res)
9616 POST_IO
9617RET(30)
9618}
9619
9620// MOVEL
9621OPCODE(0x21F8)
9622{
9623 u32 adr, res;
9624 u32 src, dst;
9625
9626 FETCH_SWORD(adr);
9627 PRE_IO
9628 READ_LONG_F(adr, res)
9629 flag_C = 0;
9630 flag_V = 0;
9631 flag_NotZ = res;
9632 flag_N = res >> 24;
9633 FETCH_SWORD(adr);
9634 WRITE_LONG_F(adr, res)
9635 POST_IO
9636RET(28)
9637}
9638
9639// MOVEL
9640OPCODE(0x23F8)
9641{
9642 u32 adr, res;
9643 u32 src, dst;
9644
9645 FETCH_SWORD(adr);
9646 PRE_IO
9647 READ_LONG_F(adr, res)
9648 flag_C = 0;
9649 flag_V = 0;
9650 flag_NotZ = res;
9651 flag_N = res >> 24;
9652 FETCH_LONG(adr);
9653 WRITE_LONG_F(adr, res)
9654 POST_IO
9655RET(32)
9656}
9657
9658// MOVEL
9659OPCODE(0x2EF8)
9660{
9661 u32 adr, res;
9662 u32 src, dst;
9663
9664 FETCH_SWORD(adr);
9665 PRE_IO
9666 READ_LONG_F(adr, res)
9667 flag_C = 0;
9668 flag_V = 0;
9669 flag_NotZ = res;
9670 flag_N = res >> 24;
9671 adr = AREG(7);
9672 AREG(7) += 4;
9673 WRITE_LONG_F(adr, res)
9674 POST_IO
9675RET(24)
9676}
9677
9678// MOVEL
9679OPCODE(0x2F38)
9680{
9681 u32 adr, res;
9682 u32 src, dst;
9683
9684 FETCH_SWORD(adr);
9685 PRE_IO
9686 READ_LONG_F(adr, res)
9687 flag_C = 0;
9688 flag_V = 0;
9689 flag_NotZ = res;
9690 flag_N = res >> 24;
9691 adr = AREG(7) - 4;
9692 AREG(7) = adr;
03e4f2a3 9693 WRITE_LONG_DEC_F(adr, res)
70357ce5 9694 POST_IO
9695RET(24)
9696}
9697
9698// MOVEL
9699OPCODE(0x2039)
9700{
9701 u32 adr, res;
9702 u32 src, dst;
9703
9704 FETCH_LONG(adr);
9705 PRE_IO
9706 READ_LONG_F(adr, res)
9707 flag_C = 0;
9708 flag_V = 0;
9709 flag_NotZ = res;
9710 flag_N = res >> 24;
9711 DREGu32((Opcode >> 9) & 7) = res;
9712 POST_IO
9713RET(20)
9714}
9715
9716// MOVEL
9717OPCODE(0x20B9)
9718{
9719 u32 adr, res;
9720 u32 src, dst;
9721
9722 FETCH_LONG(adr);
9723 PRE_IO
9724 READ_LONG_F(adr, res)
9725 flag_C = 0;
9726 flag_V = 0;
9727 flag_NotZ = res;
9728 flag_N = res >> 24;
9729 adr = AREG((Opcode >> 9) & 7);
9730 WRITE_LONG_F(adr, res)
9731 POST_IO
9732RET(28)
9733}
9734
9735// MOVEL
9736OPCODE(0x20F9)
9737{
9738 u32 adr, res;
9739 u32 src, dst;
9740
9741 FETCH_LONG(adr);
9742 PRE_IO
9743 READ_LONG_F(adr, res)
9744 flag_C = 0;
9745 flag_V = 0;
9746 flag_NotZ = res;
9747 flag_N = res >> 24;
9748 adr = AREG((Opcode >> 9) & 7);
9749 AREG((Opcode >> 9) & 7) += 4;
9750 WRITE_LONG_F(adr, res)
9751 POST_IO
9752RET(28)
9753}
9754
9755// MOVEL
9756OPCODE(0x2139)
9757{
9758 u32 adr, res;
9759 u32 src, dst;
9760
9761 FETCH_LONG(adr);
9762 PRE_IO
9763 READ_LONG_F(adr, res)
9764 flag_C = 0;
9765 flag_V = 0;
9766 flag_NotZ = res;
9767 flag_N = res >> 24;
9768 adr = AREG((Opcode >> 9) & 7) - 4;
9769 AREG((Opcode >> 9) & 7) = adr;
80db4442 9770 WRITE_LONG_DEC_F(adr, res)
70357ce5 9771 POST_IO
9772RET(28)
9773}
9774
9775// MOVEL
9776OPCODE(0x2179)
9777{
9778 u32 adr, res;
9779 u32 src, dst;
9780
9781 FETCH_LONG(adr);
9782 PRE_IO
9783 READ_LONG_F(adr, res)
9784 flag_C = 0;
9785 flag_V = 0;
9786 flag_NotZ = res;
9787 flag_N = res >> 24;
9788 FETCH_SWORD(adr);
9789 adr += AREG((Opcode >> 9) & 7);
9790 WRITE_LONG_F(adr, res)
9791 POST_IO
9792RET(32)
9793}
9794
9795// MOVEL
9796OPCODE(0x21B9)
9797{
9798 u32 adr, res;
9799 u32 src, dst;
9800
9801 FETCH_LONG(adr);
9802 PRE_IO
9803 READ_LONG_F(adr, res)
9804 flag_C = 0;
9805 flag_V = 0;
9806 flag_NotZ = res;
9807 flag_N = res >> 24;
9808 adr = AREG((Opcode >> 9) & 7);
9809 DECODE_EXT_WORD
9810 WRITE_LONG_F(adr, res)
9811 POST_IO
9812RET(34)
9813}
9814
9815// MOVEL
9816OPCODE(0x21F9)
9817{
9818 u32 adr, res;
9819 u32 src, dst;
9820
9821 FETCH_LONG(adr);
9822 PRE_IO
9823 READ_LONG_F(adr, res)
9824 flag_C = 0;
9825 flag_V = 0;
9826 flag_NotZ = res;
9827 flag_N = res >> 24;
9828 FETCH_SWORD(adr);
9829 WRITE_LONG_F(adr, res)
9830 POST_IO
9831RET(32)
9832}
9833
9834// MOVEL
9835OPCODE(0x23F9)
9836{
9837 u32 adr, res;
9838 u32 src, dst;
9839
9840 FETCH_LONG(adr);
9841 PRE_IO
9842 READ_LONG_F(adr, res)
9843 flag_C = 0;
9844 flag_V = 0;
9845 flag_NotZ = res;
9846 flag_N = res >> 24;
9847 FETCH_LONG(adr);
9848 WRITE_LONG_F(adr, res)
9849 POST_IO
9850RET(36)
9851}
9852
9853// MOVEL
9854OPCODE(0x2EF9)
9855{
9856 u32 adr, res;
9857 u32 src, dst;
9858
9859 FETCH_LONG(adr);
9860 PRE_IO
9861 READ_LONG_F(adr, res)
9862 flag_C = 0;
9863 flag_V = 0;
9864 flag_NotZ = res;
9865 flag_N = res >> 24;
9866 adr = AREG(7);
9867 AREG(7) += 4;
9868 WRITE_LONG_F(adr, res)
9869 POST_IO
9870RET(28)
9871}
9872
9873// MOVEL
9874OPCODE(0x2F39)
9875{
9876 u32 adr, res;
9877 u32 src, dst;
9878
9879 FETCH_LONG(adr);
9880 PRE_IO
9881 READ_LONG_F(adr, res)
9882 flag_C = 0;
9883 flag_V = 0;
9884 flag_NotZ = res;
9885 flag_N = res >> 24;
9886 adr = AREG(7) - 4;
9887 AREG(7) = adr;
03e4f2a3 9888 WRITE_LONG_DEC_F(adr, res)
70357ce5 9889 POST_IO
9890RET(28)
9891}
9892
9893// MOVEL
9894OPCODE(0x203A)
9895{
9896 u32 adr, res;
9897 u32 src, dst;
9898
be26eb23 9899 adr = GET_SWORD + GET_PC;
70357ce5 9900 PC++;
9901 PRE_IO
9902 READ_LONG_F(adr, res)
9903 flag_C = 0;
9904 flag_V = 0;
9905 flag_NotZ = res;
9906 flag_N = res >> 24;
9907 DREGu32((Opcode >> 9) & 7) = res;
9908 POST_IO
9909RET(16)
9910}
9911
9912// MOVEL
9913OPCODE(0x20BA)
9914{
9915 u32 adr, res;
9916 u32 src, dst;
9917
be26eb23 9918 adr = GET_SWORD + GET_PC;
70357ce5 9919 PC++;
9920 PRE_IO
9921 READ_LONG_F(adr, res)
9922 flag_C = 0;
9923 flag_V = 0;
9924 flag_NotZ = res;
9925 flag_N = res >> 24;
9926 adr = AREG((Opcode >> 9) & 7);
9927 WRITE_LONG_F(adr, res)
9928 POST_IO
9929RET(24)
9930}
9931
9932// MOVEL
9933OPCODE(0x20FA)
9934{
9935 u32 adr, res;
9936 u32 src, dst;
9937
be26eb23 9938 adr = GET_SWORD + GET_PC;
70357ce5 9939 PC++;
9940 PRE_IO
9941 READ_LONG_F(adr, res)
9942 flag_C = 0;
9943 flag_V = 0;
9944 flag_NotZ = res;
9945 flag_N = res >> 24;
9946 adr = AREG((Opcode >> 9) & 7);
9947 AREG((Opcode >> 9) & 7) += 4;
9948 WRITE_LONG_F(adr, res)
9949 POST_IO
9950RET(24)
9951}
9952
9953// MOVEL
9954OPCODE(0x213A)
9955{
9956 u32 adr, res;
9957 u32 src, dst;
9958
be26eb23 9959 adr = GET_SWORD + GET_PC;
70357ce5 9960 PC++;
9961 PRE_IO
9962 READ_LONG_F(adr, res)
9963 flag_C = 0;
9964 flag_V = 0;
9965 flag_NotZ = res;
9966 flag_N = res >> 24;
9967 adr = AREG((Opcode >> 9) & 7) - 4;
9968 AREG((Opcode >> 9) & 7) = adr;
80db4442 9969 WRITE_LONG_DEC_F(adr, res)
70357ce5 9970 POST_IO
9971RET(24)
9972}
9973
9974// MOVEL
9975OPCODE(0x217A)
9976{
9977 u32 adr, res;
9978 u32 src, dst;
9979
be26eb23 9980 adr = GET_SWORD + GET_PC;
70357ce5 9981 PC++;
9982 PRE_IO
9983 READ_LONG_F(adr, res)
9984 flag_C = 0;
9985 flag_V = 0;
9986 flag_NotZ = res;
9987 flag_N = res >> 24;
9988 FETCH_SWORD(adr);
9989 adr += AREG((Opcode >> 9) & 7);
9990 WRITE_LONG_F(adr, res)
9991 POST_IO
9992RET(28)
9993}
9994
9995// MOVEL
9996OPCODE(0x21BA)
9997{
9998 u32 adr, res;
9999 u32 src, dst;
10000
be26eb23 10001 adr = GET_SWORD + GET_PC;
70357ce5 10002 PC++;
10003 PRE_IO
10004 READ_LONG_F(adr, res)
10005 flag_C = 0;
10006 flag_V = 0;
10007 flag_NotZ = res;
10008 flag_N = res >> 24;
10009 adr = AREG((Opcode >> 9) & 7);
10010 DECODE_EXT_WORD
10011 WRITE_LONG_F(adr, res)
10012 POST_IO
10013RET(30)
10014}
10015
10016// MOVEL
10017OPCODE(0x21FA)
10018{
10019 u32 adr, res;
10020 u32 src, dst;
10021
be26eb23 10022 adr = GET_SWORD + GET_PC;
70357ce5 10023 PC++;
10024 PRE_IO
10025 READ_LONG_F(adr, res)
10026 flag_C = 0;
10027 flag_V = 0;
10028 flag_NotZ = res;
10029 flag_N = res >> 24;
10030 FETCH_SWORD(adr);
10031 WRITE_LONG_F(adr, res)
10032 POST_IO
10033RET(28)
10034}
10035
10036// MOVEL
10037OPCODE(0x23FA)
10038{
10039 u32 adr, res;
10040 u32 src, dst;
10041
be26eb23 10042 adr = GET_SWORD + GET_PC;
70357ce5 10043 PC++;
10044 PRE_IO
10045 READ_LONG_F(adr, res)
10046 flag_C = 0;
10047 flag_V = 0;
10048 flag_NotZ = res;
10049 flag_N = res >> 24;
10050 FETCH_LONG(adr);
10051 WRITE_LONG_F(adr, res)
10052 POST_IO
10053RET(32)
10054}
10055
10056// MOVEL
10057OPCODE(0x2EFA)
10058{
10059 u32 adr, res;
10060 u32 src, dst;
10061
be26eb23 10062 adr = GET_SWORD + GET_PC;
70357ce5 10063 PC++;
10064 PRE_IO
10065 READ_LONG_F(adr, res)
10066 flag_C = 0;
10067 flag_V = 0;
10068 flag_NotZ = res;
10069 flag_N = res >> 24;
10070 adr = AREG(7);
10071 AREG(7) += 4;
10072 WRITE_LONG_F(adr, res)
10073 POST_IO
10074RET(24)
10075}
10076
10077// MOVEL
10078OPCODE(0x2F3A)
10079{
10080 u32 adr, res;
10081 u32 src, dst;
10082
be26eb23 10083 adr = GET_SWORD + GET_PC;
70357ce5 10084 PC++;
10085 PRE_IO
10086 READ_LONG_F(adr, res)
10087 flag_C = 0;
10088 flag_V = 0;
10089 flag_NotZ = res;
10090 flag_N = res >> 24;
10091 adr = AREG(7) - 4;
10092 AREG(7) = adr;
03e4f2a3 10093 WRITE_LONG_DEC_F(adr, res)
70357ce5 10094 POST_IO
10095RET(24)
10096}
10097
10098// MOVEL
10099OPCODE(0x203B)
10100{
10101 u32 adr, res;
10102 u32 src, dst;
10103
be26eb23 10104 adr = GET_PC;
70357ce5 10105 DECODE_EXT_WORD
10106 PRE_IO
10107 READ_LONG_F(adr, res)
10108 flag_C = 0;
10109 flag_V = 0;
10110 flag_NotZ = res;
10111 flag_N = res >> 24;
10112 DREGu32((Opcode >> 9) & 7) = res;
10113 POST_IO
10114RET(18)
10115}
10116
10117// MOVEL
10118OPCODE(0x20BB)
10119{
10120 u32 adr, res;
10121 u32 src, dst;
10122
be26eb23 10123 adr = GET_PC;
70357ce5 10124 DECODE_EXT_WORD
10125 PRE_IO
10126 READ_LONG_F(adr, res)
10127 flag_C = 0;
10128 flag_V = 0;
10129 flag_NotZ = res;
10130 flag_N = res >> 24;
10131 adr = AREG((Opcode >> 9) & 7);
10132 WRITE_LONG_F(adr, res)
10133 POST_IO
10134RET(26)
10135}
10136
10137// MOVEL
10138OPCODE(0x20FB)
10139{
10140 u32 adr, res;
10141 u32 src, dst;
10142
be26eb23 10143 adr = GET_PC;
70357ce5 10144 DECODE_EXT_WORD
10145 PRE_IO
10146 READ_LONG_F(adr, res)
10147 flag_C = 0;
10148 flag_V = 0;
10149 flag_NotZ = res;
10150 flag_N = res >> 24;
10151 adr = AREG((Opcode >> 9) & 7);
10152 AREG((Opcode >> 9) & 7) += 4;
10153 WRITE_LONG_F(adr, res)
10154 POST_IO
10155RET(26)
10156}
10157
10158// MOVEL
10159OPCODE(0x213B)
10160{
10161 u32 adr, res;
10162 u32 src, dst;
10163
be26eb23 10164 adr = GET_PC;
70357ce5 10165 DECODE_EXT_WORD
10166 PRE_IO
10167 READ_LONG_F(adr, res)
10168 flag_C = 0;
10169 flag_V = 0;
10170 flag_NotZ = res;
10171 flag_N = res >> 24;
10172 adr = AREG((Opcode >> 9) & 7) - 4;
10173 AREG((Opcode >> 9) & 7) = adr;
80db4442 10174 WRITE_LONG_DEC_F(adr, res)
70357ce5 10175 POST_IO
10176RET(26)
10177}
10178
10179// MOVEL
10180OPCODE(0x217B)
10181{
10182 u32 adr, res;
10183 u32 src, dst;
10184
be26eb23 10185 adr = GET_PC;
70357ce5 10186 DECODE_EXT_WORD
10187 PRE_IO
10188 READ_LONG_F(adr, res)
10189 flag_C = 0;
10190 flag_V = 0;
10191 flag_NotZ = res;
10192 flag_N = res >> 24;
10193 FETCH_SWORD(adr);
10194 adr += AREG((Opcode >> 9) & 7);
10195 WRITE_LONG_F(adr, res)
10196 POST_IO
10197RET(30)
10198}
10199
10200// MOVEL
10201OPCODE(0x21BB)
10202{
10203 u32 adr, res;
10204 u32 src, dst;
10205
be26eb23 10206 adr = GET_PC;
70357ce5 10207 DECODE_EXT_WORD
10208 PRE_IO
10209 READ_LONG_F(adr, res)
10210 flag_C = 0;
10211 flag_V = 0;
10212 flag_NotZ = res;
10213 flag_N = res >> 24;
10214 adr = AREG((Opcode >> 9) & 7);
10215 DECODE_EXT_WORD
10216 WRITE_LONG_F(adr, res)
10217 POST_IO
10218RET(32)
10219}
10220
10221// MOVEL
10222OPCODE(0x21FB)
10223{
10224 u32 adr, res;
10225 u32 src, dst;
10226
be26eb23 10227 adr = GET_PC;
70357ce5 10228 DECODE_EXT_WORD
10229 PRE_IO
10230 READ_LONG_F(adr, res)
10231 flag_C = 0;
10232 flag_V = 0;
10233 flag_NotZ = res;
10234 flag_N = res >> 24;
10235 FETCH_SWORD(adr);
10236 WRITE_LONG_F(adr, res)
10237 POST_IO
10238RET(30)
10239}
10240
10241// MOVEL
10242OPCODE(0x23FB)
10243{
10244 u32 adr, res;
10245 u32 src, dst;
10246
be26eb23 10247 adr = GET_PC;
70357ce5 10248 DECODE_EXT_WORD
10249 PRE_IO
10250 READ_LONG_F(adr, res)
10251 flag_C = 0;
10252 flag_V = 0;
10253 flag_NotZ = res;
10254 flag_N = res >> 24;
10255 FETCH_LONG(adr);
10256 WRITE_LONG_F(adr, res)
10257 POST_IO
10258RET(34)
10259}
10260
10261// MOVEL
10262OPCODE(0x2EFB)
10263{
10264 u32 adr, res;
10265 u32 src, dst;
10266
be26eb23 10267 adr = GET_PC;
70357ce5 10268 DECODE_EXT_WORD
10269 PRE_IO
10270 READ_LONG_F(adr, res)
10271 flag_C = 0;
10272 flag_V = 0;
10273 flag_NotZ = res;
10274 flag_N = res >> 24;
10275 adr = AREG(7);
10276 AREG(7) += 4;
10277 WRITE_LONG_F(adr, res)
10278 POST_IO
10279RET(26)
10280}
10281
10282// MOVEL
10283OPCODE(0x2F3B)
10284{
10285 u32 adr, res;
10286 u32 src, dst;
10287
be26eb23 10288 adr = GET_PC;
70357ce5 10289 DECODE_EXT_WORD
10290 PRE_IO
10291 READ_LONG_F(adr, res)
10292 flag_C = 0;
10293 flag_V = 0;
10294 flag_NotZ = res;
10295 flag_N = res >> 24;
10296 adr = AREG(7) - 4;
10297 AREG(7) = adr;
03e4f2a3 10298 WRITE_LONG_DEC_F(adr, res)
70357ce5 10299 POST_IO
10300RET(26)
10301}
10302
10303// MOVEL
10304OPCODE(0x203C)
10305{
10306 u32 adr, res;
10307 u32 src, dst;
10308
10309 FETCH_LONG(res);
10310 flag_C = 0;
10311 flag_V = 0;
10312 flag_NotZ = res;
10313 flag_N = res >> 24;
10314 DREGu32((Opcode >> 9) & 7) = res;
10315RET(12)
10316}
10317
10318// MOVEL
10319OPCODE(0x20BC)
10320{
10321 u32 adr, res;
10322 u32 src, dst;
10323
10324 FETCH_LONG(res);
10325 flag_C = 0;
10326 flag_V = 0;
10327 flag_NotZ = res;
10328 flag_N = res >> 24;
10329 adr = AREG((Opcode >> 9) & 7);
10330 PRE_IO
10331 WRITE_LONG_F(adr, res)
10332 POST_IO
10333RET(20)
10334}
10335
10336// MOVEL
10337OPCODE(0x20FC)
10338{
10339 u32 adr, res;
10340 u32 src, dst;
10341
10342 FETCH_LONG(res);
10343 flag_C = 0;
10344 flag_V = 0;
10345 flag_NotZ = res;
10346 flag_N = res >> 24;
10347 adr = AREG((Opcode >> 9) & 7);
10348 AREG((Opcode >> 9) & 7) += 4;
10349 PRE_IO
10350 WRITE_LONG_F(adr, res)
10351 POST_IO
10352RET(20)
10353}
10354
10355// MOVEL
10356OPCODE(0x213C)
10357{
10358 u32 adr, res;
10359 u32 src, dst;
10360
10361 FETCH_LONG(res);
10362 flag_C = 0;
10363 flag_V = 0;
10364 flag_NotZ = res;
10365 flag_N = res >> 24;
10366 adr = AREG((Opcode >> 9) & 7) - 4;
10367 AREG((Opcode >> 9) & 7) = adr;
10368 PRE_IO
80db4442 10369 WRITE_LONG_DEC_F(adr, res)
70357ce5 10370 POST_IO
10371RET(20)
10372}
10373
10374// MOVEL
10375OPCODE(0x217C)
10376{
10377 u32 adr, res;
10378 u32 src, dst;
10379
10380 FETCH_LONG(res);
10381 flag_C = 0;
10382 flag_V = 0;
10383 flag_NotZ = res;
10384 flag_N = res >> 24;
10385 FETCH_SWORD(adr);
10386 adr += AREG((Opcode >> 9) & 7);
10387 PRE_IO
10388 WRITE_LONG_F(adr, res)
10389 POST_IO
10390RET(24)
10391}
10392
10393// MOVEL
10394OPCODE(0x21BC)
10395{
10396 u32 adr, res;
10397 u32 src, dst;
10398
10399 FETCH_LONG(res);
10400 flag_C = 0;
10401 flag_V = 0;
10402 flag_NotZ = res;
10403 flag_N = res >> 24;
10404 adr = AREG((Opcode >> 9) & 7);
10405 DECODE_EXT_WORD
10406 PRE_IO
10407 WRITE_LONG_F(adr, res)
10408 POST_IO
10409RET(26)
10410}
10411
10412// MOVEL
10413OPCODE(0x21FC)
10414{
10415 u32 adr, res;
10416 u32 src, dst;
10417
10418 FETCH_LONG(res);
10419 flag_C = 0;
10420 flag_V = 0;
10421 flag_NotZ = res;
10422 flag_N = res >> 24;
10423 FETCH_SWORD(adr);
10424 PRE_IO
10425 WRITE_LONG_F(adr, res)
10426 POST_IO
10427RET(24)
10428}
10429
10430// MOVEL
10431OPCODE(0x23FC)
10432{
10433 u32 adr, res;
10434 u32 src, dst;
10435
10436 FETCH_LONG(res);
10437 flag_C = 0;
10438 flag_V = 0;
10439 flag_NotZ = res;
10440 flag_N = res >> 24;
10441 FETCH_LONG(adr);
10442 PRE_IO
10443 WRITE_LONG_F(adr, res)
10444 POST_IO
10445RET(28)
10446}
10447
10448// MOVEL
10449OPCODE(0x2EFC)
10450{
10451 u32 adr, res;
10452 u32 src, dst;
10453
10454 FETCH_LONG(res);
10455 flag_C = 0;
10456 flag_V = 0;
10457 flag_NotZ = res;
10458 flag_N = res >> 24;
10459 adr = AREG(7);
10460 AREG(7) += 4;
10461 PRE_IO
10462 WRITE_LONG_F(adr, res)
10463 POST_IO
10464RET(20)
10465}
10466
10467// MOVEL
10468OPCODE(0x2F3C)
10469{
10470 u32 adr, res;
10471 u32 src, dst;
10472
10473 FETCH_LONG(res);
10474 flag_C = 0;
10475 flag_V = 0;
10476 flag_NotZ = res;
10477 flag_N = res >> 24;
10478 adr = AREG(7) - 4;
10479 AREG(7) = adr;
10480 PRE_IO
03e4f2a3 10481 WRITE_LONG_DEC_F(adr, res)
70357ce5 10482 POST_IO
10483RET(20)
10484}
10485
10486// MOVEL
10487OPCODE(0x201F)
10488{
10489 u32 adr, res;
10490 u32 src, dst;
10491
10492 adr = AREG(7);
10493 AREG(7) += 4;
10494 PRE_IO
10495 READ_LONG_F(adr, res)
10496 flag_C = 0;
10497 flag_V = 0;
10498 flag_NotZ = res;
10499 flag_N = res >> 24;
10500 DREGu32((Opcode >> 9) & 7) = res;
10501 POST_IO
10502RET(12)
10503}
10504
10505// MOVEL
10506OPCODE(0x209F)
10507{
10508 u32 adr, res;
10509 u32 src, dst;
10510
10511 adr = AREG(7);
10512 AREG(7) += 4;
10513 PRE_IO
10514 READ_LONG_F(adr, res)
10515 flag_C = 0;
10516 flag_V = 0;
10517 flag_NotZ = res;
10518 flag_N = res >> 24;
10519 adr = AREG((Opcode >> 9) & 7);
10520 WRITE_LONG_F(adr, res)
10521 POST_IO
10522RET(20)
10523}
10524
10525// MOVEL
10526OPCODE(0x20DF)
10527{
10528 u32 adr, res;
10529 u32 src, dst;
10530
10531 adr = AREG(7);
10532 AREG(7) += 4;
10533 PRE_IO
10534 READ_LONG_F(adr, res)
10535 flag_C = 0;
10536 flag_V = 0;
10537 flag_NotZ = res;
10538 flag_N = res >> 24;
10539 adr = AREG((Opcode >> 9) & 7);
10540 AREG((Opcode >> 9) & 7) += 4;
10541 WRITE_LONG_F(adr, res)
10542 POST_IO
10543RET(20)
10544}
10545
10546// MOVEL
10547OPCODE(0x211F)
10548{
10549 u32 adr, res;
10550 u32 src, dst;
10551
10552 adr = AREG(7);
10553 AREG(7) += 4;
10554 PRE_IO
10555 READ_LONG_F(adr, res)
10556 flag_C = 0;
10557 flag_V = 0;
10558 flag_NotZ = res;
10559 flag_N = res >> 24;
10560 adr = AREG((Opcode >> 9) & 7) - 4;
10561 AREG((Opcode >> 9) & 7) = adr;
80db4442 10562 WRITE_LONG_DEC_F(adr, res)
70357ce5 10563 POST_IO
10564RET(20)
10565}
10566
10567// MOVEL
10568OPCODE(0x215F)
10569{
10570 u32 adr, res;
10571 u32 src, dst;
10572
10573 adr = AREG(7);
10574 AREG(7) += 4;
10575 PRE_IO
10576 READ_LONG_F(adr, res)
10577 flag_C = 0;
10578 flag_V = 0;
10579 flag_NotZ = res;
10580 flag_N = res >> 24;
10581 FETCH_SWORD(adr);
10582 adr += AREG((Opcode >> 9) & 7);
10583 WRITE_LONG_F(adr, res)
10584 POST_IO
10585RET(24)
10586}
10587
10588// MOVEL
10589OPCODE(0x219F)
10590{
10591 u32 adr, res;
10592 u32 src, dst;
10593
10594 adr = AREG(7);
10595 AREG(7) += 4;
10596 PRE_IO
10597 READ_LONG_F(adr, res)
10598 flag_C = 0;
10599 flag_V = 0;
10600 flag_NotZ = res;
10601 flag_N = res >> 24;
10602 adr = AREG((Opcode >> 9) & 7);
10603 DECODE_EXT_WORD
10604 WRITE_LONG_F(adr, res)
10605 POST_IO
10606RET(26)
10607}
10608
10609// MOVEL
10610OPCODE(0x21DF)
10611{
10612 u32 adr, res;
10613 u32 src, dst;
10614
10615 adr = AREG(7);
10616 AREG(7) += 4;
10617 PRE_IO
10618 READ_LONG_F(adr, res)
10619 flag_C = 0;
10620 flag_V = 0;
10621 flag_NotZ = res;
10622 flag_N = res >> 24;
10623 FETCH_SWORD(adr);
10624 WRITE_LONG_F(adr, res)
10625 POST_IO
10626RET(24)
10627}
10628
10629// MOVEL
10630OPCODE(0x23DF)
10631{
10632 u32 adr, res;
10633 u32 src, dst;
10634
10635 adr = AREG(7);
10636 AREG(7) += 4;
10637 PRE_IO
10638 READ_LONG_F(adr, res)
10639 flag_C = 0;
10640 flag_V = 0;
10641 flag_NotZ = res;
10642 flag_N = res >> 24;
10643 FETCH_LONG(adr);
10644 WRITE_LONG_F(adr, res)
10645 POST_IO
10646RET(28)
10647}
10648
10649// MOVEL
10650OPCODE(0x2EDF)
10651{
10652 u32 adr, res;
10653 u32 src, dst;
10654
10655 adr = AREG(7);
10656 AREG(7) += 4;
10657 PRE_IO
10658 READ_LONG_F(adr, res)
10659 flag_C = 0;
10660 flag_V = 0;
10661 flag_NotZ = res;
10662 flag_N = res >> 24;
10663 adr = AREG(7);
10664 AREG(7) += 4;
10665 WRITE_LONG_F(adr, res)
10666 POST_IO
10667RET(20)
10668}
10669
10670// MOVEL
10671OPCODE(0x2F1F)
10672{
10673 u32 adr, res;
10674 u32 src, dst;
10675
10676 adr = AREG(7);
10677 AREG(7) += 4;
10678 PRE_IO
10679 READ_LONG_F(adr, res)
10680 flag_C = 0;
10681 flag_V = 0;
10682 flag_NotZ = res;
10683 flag_N = res >> 24;
10684 adr = AREG(7) - 4;
10685 AREG(7) = adr;
03e4f2a3 10686 WRITE_LONG_DEC_F(adr, res)
70357ce5 10687 POST_IO
10688RET(20)
10689}
10690
10691// MOVEL
10692OPCODE(0x2027)
10693{
10694 u32 adr, res;
10695 u32 src, dst;
10696
10697 adr = AREG(7) - 4;
10698 AREG(7) = adr;
10699 PRE_IO
10700 READ_LONG_F(adr, res)
10701 flag_C = 0;
10702 flag_V = 0;
10703 flag_NotZ = res;
10704 flag_N = res >> 24;
10705 DREGu32((Opcode >> 9) & 7) = res;
10706 POST_IO
10707RET(14)
10708}
10709
10710// MOVEL
10711OPCODE(0x20A7)
10712{
10713 u32 adr, res;
10714 u32 src, dst;
10715
10716 adr = AREG(7) - 4;
10717 AREG(7) = adr;
10718 PRE_IO
10719 READ_LONG_F(adr, res)
10720 flag_C = 0;
10721 flag_V = 0;
10722 flag_NotZ = res;
10723 flag_N = res >> 24;
10724 adr = AREG((Opcode >> 9) & 7);
10725 WRITE_LONG_F(adr, res)
10726 POST_IO
10727RET(22)
10728}
10729
10730// MOVEL
10731OPCODE(0x20E7)
10732{
10733 u32 adr, res;
10734 u32 src, dst;
10735
10736 adr = AREG(7) - 4;
10737 AREG(7) = adr;
10738 PRE_IO
10739 READ_LONG_F(adr, res)
10740 flag_C = 0;
10741 flag_V = 0;
10742 flag_NotZ = res;
10743 flag_N = res >> 24;
10744 adr = AREG((Opcode >> 9) & 7);
10745 AREG((Opcode >> 9) & 7) += 4;
10746 WRITE_LONG_F(adr, res)
10747 POST_IO
10748RET(22)
10749}
10750
10751// MOVEL
10752OPCODE(0x2127)
10753{
10754 u32 adr, res;
10755 u32 src, dst;
10756
10757 adr = AREG(7) - 4;
10758 AREG(7) = adr;
10759 PRE_IO
10760 READ_LONG_F(adr, res)
10761 flag_C = 0;
10762 flag_V = 0;
10763 flag_NotZ = res;
10764 flag_N = res >> 24;
10765 adr = AREG((Opcode >> 9) & 7) - 4;
10766 AREG((Opcode >> 9) & 7) = adr;
80db4442 10767 WRITE_LONG_DEC_F(adr, res)
70357ce5 10768 POST_IO
10769RET(22)
10770}
10771
10772// MOVEL
10773OPCODE(0x2167)
10774{
10775 u32 adr, res;
10776 u32 src, dst;
10777
10778 adr = AREG(7) - 4;
10779 AREG(7) = adr;
10780 PRE_IO
10781 READ_LONG_F(adr, res)
10782 flag_C = 0;
10783 flag_V = 0;
10784 flag_NotZ = res;
10785 flag_N = res >> 24;
10786 FETCH_SWORD(adr);
10787 adr += AREG((Opcode >> 9) & 7);
10788 WRITE_LONG_F(adr, res)
10789 POST_IO
10790RET(26)
10791}
10792
10793// MOVEL
10794OPCODE(0x21A7)
10795{
10796 u32 adr, res;
10797 u32 src, dst;
10798
10799 adr = AREG(7) - 4;
10800 AREG(7) = adr;
10801 PRE_IO
10802 READ_LONG_F(adr, res)
10803 flag_C = 0;
10804 flag_V = 0;
10805 flag_NotZ = res;
10806 flag_N = res >> 24;
10807 adr = AREG((Opcode >> 9) & 7);
10808 DECODE_EXT_WORD
10809 WRITE_LONG_F(adr, res)
10810 POST_IO
10811RET(28)
10812}
10813
10814// MOVEL
10815OPCODE(0x21E7)
10816{
10817 u32 adr, res;
10818 u32 src, dst;
10819
10820 adr = AREG(7) - 4;
10821 AREG(7) = adr;
10822 PRE_IO
10823 READ_LONG_F(adr, res)
10824 flag_C = 0;
10825 flag_V = 0;
10826 flag_NotZ = res;
10827 flag_N = res >> 24;
10828 FETCH_SWORD(adr);
10829 WRITE_LONG_F(adr, res)
10830 POST_IO
10831RET(26)
10832}
10833
10834// MOVEL
10835OPCODE(0x23E7)
10836{
10837 u32 adr, res;
10838 u32 src, dst;
10839
10840 adr = AREG(7) - 4;
10841 AREG(7) = adr;
10842 PRE_IO
10843 READ_LONG_F(adr, res)
10844 flag_C = 0;
10845 flag_V = 0;
10846 flag_NotZ = res;
10847 flag_N = res >> 24;
10848 FETCH_LONG(adr);
10849 WRITE_LONG_F(adr, res)
10850 POST_IO
10851RET(30)
10852}
10853
10854// MOVEL
10855OPCODE(0x2EE7)
10856{
10857 u32 adr, res;
10858 u32 src, dst;
10859
10860 adr = AREG(7) - 4;
10861 AREG(7) = adr;
10862 PRE_IO
10863 READ_LONG_F(adr, res)
10864 flag_C = 0;
10865 flag_V = 0;
10866 flag_NotZ = res;
10867 flag_N = res >> 24;
10868 adr = AREG(7);
10869 AREG(7) += 4;
10870 WRITE_LONG_F(adr, res)
10871 POST_IO
10872RET(22)
10873}
10874
10875// MOVEL
10876OPCODE(0x2F27)
10877{
10878 u32 adr, res;
10879 u32 src, dst;
10880
10881 adr = AREG(7) - 4;
10882 AREG(7) = adr;
10883 PRE_IO
10884 READ_LONG_F(adr, res)
10885 flag_C = 0;
10886 flag_V = 0;
10887 flag_NotZ = res;
10888 flag_N = res >> 24;
10889 adr = AREG(7) - 4;
10890 AREG(7) = adr;
03e4f2a3 10891 WRITE_LONG_DEC_F(adr, res)
70357ce5 10892 POST_IO
10893RET(22)
10894}
10895
10896// MOVEAL
10897OPCODE(0x2040)
10898{
10899 u32 adr, res;
10900 u32 src, dst;
10901
10902 res = (s32)DREGs32((Opcode >> 0) & 7);
10903 AREG((Opcode >> 9) & 7) = res;
10904RET(4)
10905}
10906
10907// MOVEAL
10908OPCODE(0x2048)
10909{
10910 u32 adr, res;
10911 u32 src, dst;
10912
10913 res = (s32)AREGs32((Opcode >> 0) & 7);
10914 AREG((Opcode >> 9) & 7) = res;
10915RET(4)
10916}
10917
10918// MOVEAL
10919OPCODE(0x2050)
10920{
10921 u32 adr, res;
10922 u32 src, dst;
10923
10924 adr = AREG((Opcode >> 0) & 7);
10925 PRE_IO
10926 READSX_LONG_F(adr, res)
10927 AREG((Opcode >> 9) & 7) = res;
10928 POST_IO
10929RET(12)
10930}
10931
10932// MOVEAL
10933OPCODE(0x2058)
10934{
10935 u32 adr, res;
10936 u32 src, dst;
10937
10938 adr = AREG((Opcode >> 0) & 7);
10939 AREG((Opcode >> 0) & 7) += 4;
10940 PRE_IO
10941 READSX_LONG_F(adr, res)
10942 AREG((Opcode >> 9) & 7) = res;
10943 POST_IO
10944RET(12)
10945}
10946
10947// MOVEAL
10948OPCODE(0x2060)
10949{
10950 u32 adr, res;
10951 u32 src, dst;
10952
10953 adr = AREG((Opcode >> 0) & 7) - 4;
10954 AREG((Opcode >> 0) & 7) = adr;
10955 PRE_IO
10956 READSX_LONG_F(adr, res)
10957 AREG((Opcode >> 9) & 7) = res;
10958 POST_IO
10959RET(14)
10960}
10961
10962// MOVEAL
10963OPCODE(0x2068)
10964{
10965 u32 adr, res;
10966 u32 src, dst;
10967
10968 FETCH_SWORD(adr);
10969 adr += AREG((Opcode >> 0) & 7);
10970 PRE_IO
10971 READSX_LONG_F(adr, res)
10972 AREG((Opcode >> 9) & 7) = res;
10973 POST_IO
10974RET(16)
10975}
10976
10977// MOVEAL
10978OPCODE(0x2070)
10979{
10980 u32 adr, res;
10981 u32 src, dst;
10982
10983 adr = AREG((Opcode >> 0) & 7);
10984 DECODE_EXT_WORD
10985 PRE_IO
10986 READSX_LONG_F(adr, res)
10987 AREG((Opcode >> 9) & 7) = res;
10988 POST_IO
10989RET(18)
10990}
10991
10992// MOVEAL
10993OPCODE(0x2078)
10994{
10995 u32 adr, res;
10996 u32 src, dst;
10997
10998 FETCH_SWORD(adr);
10999 PRE_IO
11000 READSX_LONG_F(adr, res)
11001 AREG((Opcode >> 9) & 7) = res;
11002 POST_IO
11003RET(16)
11004}
11005
11006// MOVEAL
11007OPCODE(0x2079)
11008{
11009 u32 adr, res;
11010 u32 src, dst;
11011
11012 FETCH_LONG(adr);
11013 PRE_IO
11014 READSX_LONG_F(adr, res)
11015 AREG((Opcode >> 9) & 7) = res;
11016 POST_IO
11017RET(20)
11018}
11019
11020// MOVEAL
11021OPCODE(0x207A)
11022{
11023 u32 adr, res;
11024 u32 src, dst;
11025
be26eb23 11026 adr = GET_SWORD + GET_PC;
70357ce5 11027 PC++;
11028 PRE_IO
11029 READSX_LONG_F(adr, res)
11030 AREG((Opcode >> 9) & 7) = res;
11031 POST_IO
11032RET(16)
11033}
11034
11035// MOVEAL
11036OPCODE(0x207B)
11037{
11038 u32 adr, res;
11039 u32 src, dst;
11040
be26eb23 11041 adr = GET_PC;
70357ce5 11042 DECODE_EXT_WORD
11043 PRE_IO
11044 READSX_LONG_F(adr, res)
11045 AREG((Opcode >> 9) & 7) = res;
11046 POST_IO
11047RET(18)
11048}
11049
11050// MOVEAL
11051OPCODE(0x207C)
11052{
11053 u32 adr, res;
11054 u32 src, dst;
11055
11056 FETCH_LONG(res);
11057 AREG((Opcode >> 9) & 7) = res;
11058RET(12)
11059}
11060
11061// MOVEAL
11062OPCODE(0x205F)
11063{
11064 u32 adr, res;
11065 u32 src, dst;
11066
11067 adr = AREG(7);
11068 AREG(7) += 4;
11069 PRE_IO
11070 READSX_LONG_F(adr, res)
11071 AREG((Opcode >> 9) & 7) = res;
11072 POST_IO
11073RET(12)
11074}
11075
11076// MOVEAL
11077OPCODE(0x2067)
11078{
11079 u32 adr, res;
11080 u32 src, dst;
11081
11082 adr = AREG(7) - 4;
11083 AREG(7) = adr;
11084 PRE_IO
11085 READSX_LONG_F(adr, res)
11086 AREG((Opcode >> 9) & 7) = res;
11087 POST_IO
11088RET(14)
11089}
11090
11091// MOVEW
11092OPCODE(0x3000)
11093{
11094 u32 adr, res;
11095 u32 src, dst;
11096
11097 res = DREGu16((Opcode >> 0) & 7);
11098 flag_C = 0;
11099 flag_V = 0;
11100 flag_NotZ = res;
11101 flag_N = res >> 8;
11102 DREGu16((Opcode >> 9) & 7) = res;
11103RET(4)
11104}
11105
11106// MOVEW
11107OPCODE(0x3080)
11108{
11109 u32 adr, res;
11110 u32 src, dst;
11111
11112 res = DREGu16((Opcode >> 0) & 7);
11113 flag_C = 0;
11114 flag_V = 0;
11115 flag_NotZ = res;
11116 flag_N = res >> 8;
11117 adr = AREG((Opcode >> 9) & 7);
11118 PRE_IO
11119 WRITE_WORD_F(adr, res)
11120 POST_IO
11121RET(8)
11122}
11123
11124// MOVEW
11125OPCODE(0x30C0)
11126{
11127 u32 adr, res;
11128 u32 src, dst;
11129
11130 res = DREGu16((Opcode >> 0) & 7);
11131 flag_C = 0;
11132 flag_V = 0;
11133 flag_NotZ = res;
11134 flag_N = res >> 8;
11135 adr = AREG((Opcode >> 9) & 7);
11136 AREG((Opcode >> 9) & 7) += 2;
11137 PRE_IO
11138 WRITE_WORD_F(adr, res)
11139 POST_IO
11140RET(8)
11141}
11142
11143// MOVEW
11144OPCODE(0x3100)
11145{
11146 u32 adr, res;
11147 u32 src, dst;
11148
11149 res = DREGu16((Opcode >> 0) & 7);
11150 flag_C = 0;
11151 flag_V = 0;
11152 flag_NotZ = res;
11153 flag_N = res >> 8;
11154 adr = AREG((Opcode >> 9) & 7) - 2;
11155 AREG((Opcode >> 9) & 7) = adr;
11156 PRE_IO
11157 WRITE_WORD_F(adr, res)
11158 POST_IO
11159RET(8)
11160}
11161
11162// MOVEW
11163OPCODE(0x3140)
11164{
11165 u32 adr, res;
11166 u32 src, dst;
11167
11168 res = DREGu16((Opcode >> 0) & 7);
11169 flag_C = 0;
11170 flag_V = 0;
11171 flag_NotZ = res;
11172 flag_N = res >> 8;
11173 FETCH_SWORD(adr);
11174 adr += AREG((Opcode >> 9) & 7);
11175 PRE_IO
11176 WRITE_WORD_F(adr, res)
11177 POST_IO
11178RET(12)
11179}
11180
11181// MOVEW
11182OPCODE(0x3180)
11183{
11184 u32 adr, res;
11185 u32 src, dst;
11186
11187 res = DREGu16((Opcode >> 0) & 7);
11188 flag_C = 0;
11189 flag_V = 0;
11190 flag_NotZ = res;
11191 flag_N = res >> 8;
11192 adr = AREG((Opcode >> 9) & 7);
11193 DECODE_EXT_WORD
11194 PRE_IO
11195 WRITE_WORD_F(adr, res)
11196 POST_IO
11197RET(14)
11198}
11199
11200// MOVEW
11201OPCODE(0x31C0)
11202{
11203 u32 adr, res;
11204 u32 src, dst;
11205
11206 res = DREGu16((Opcode >> 0) & 7);
11207 flag_C = 0;
11208 flag_V = 0;
11209 flag_NotZ = res;
11210 flag_N = res >> 8;
11211 FETCH_SWORD(adr);
11212 PRE_IO
11213 WRITE_WORD_F(adr, res)
11214 POST_IO
11215RET(12)
11216}
11217
11218// MOVEW
11219OPCODE(0x33C0)
11220{
11221 u32 adr, res;
11222 u32 src, dst;
11223
11224 res = DREGu16((Opcode >> 0) & 7);
11225 flag_C = 0;
11226 flag_V = 0;
11227 flag_NotZ = res;
11228 flag_N = res >> 8;
11229 FETCH_LONG(adr);
11230 PRE_IO
11231 WRITE_WORD_F(adr, res)
11232 POST_IO
11233RET(16)
11234}
11235
11236// MOVEW
11237OPCODE(0x3EC0)
11238{
11239 u32 adr, res;
11240 u32 src, dst;
11241
11242 res = DREGu16((Opcode >> 0) & 7);
11243 flag_C = 0;
11244 flag_V = 0;
11245 flag_NotZ = res;
11246 flag_N = res >> 8;
11247 adr = AREG(7);
11248 AREG(7) += 2;
11249 PRE_IO
11250 WRITE_WORD_F(adr, res)
11251 POST_IO
11252RET(8)
11253}
11254
11255// MOVEW
11256OPCODE(0x3F00)
11257{
11258 u32 adr, res;
11259 u32 src, dst;
11260
11261 res = DREGu16((Opcode >> 0) & 7);
11262 flag_C = 0;
11263 flag_V = 0;
11264 flag_NotZ = res;
11265 flag_N = res >> 8;
11266 adr = AREG(7) - 2;
11267 AREG(7) = adr;
11268 PRE_IO
11269 WRITE_WORD_F(adr, res)
11270 POST_IO
11271RET(8)
11272}
11273
11274// MOVEW
11275OPCODE(0x3008)
11276{
11277 u32 adr, res;
11278 u32 src, dst;
11279
11280 res = AREGu16((Opcode >> 0) & 7);
11281 flag_C = 0;
11282 flag_V = 0;
11283 flag_NotZ = res;
11284 flag_N = res >> 8;
11285 DREGu16((Opcode >> 9) & 7) = res;
11286RET(4)
11287}
11288
11289// MOVEW
11290OPCODE(0x3088)
11291{
11292 u32 adr, res;
11293 u32 src, dst;
11294
11295 res = AREGu16((Opcode >> 0) & 7);
11296 flag_C = 0;
11297 flag_V = 0;
11298 flag_NotZ = res;
11299 flag_N = res >> 8;
11300 adr = AREG((Opcode >> 9) & 7);
11301 PRE_IO
11302 WRITE_WORD_F(adr, res)
11303 POST_IO
11304RET(8)
11305}
11306
11307// MOVEW
11308OPCODE(0x30C8)
11309{
11310 u32 adr, res;
11311 u32 src, dst;
11312
11313 res = AREGu16((Opcode >> 0) & 7);
11314 flag_C = 0;
11315 flag_V = 0;
11316 flag_NotZ = res;
11317 flag_N = res >> 8;
11318 adr = AREG((Opcode >> 9) & 7);
11319 AREG((Opcode >> 9) & 7) += 2;
11320 PRE_IO
11321 WRITE_WORD_F(adr, res)
11322 POST_IO
11323RET(8)
11324}
11325
11326// MOVEW
11327OPCODE(0x3108)
11328{
11329 u32 adr, res;
11330 u32 src, dst;
11331
11332 res = AREGu16((Opcode >> 0) & 7);
11333 flag_C = 0;
11334 flag_V = 0;
11335 flag_NotZ = res;
11336 flag_N = res >> 8;
11337 adr = AREG((Opcode >> 9) & 7) - 2;
11338 AREG((Opcode >> 9) & 7) = adr;
11339 PRE_IO
11340 WRITE_WORD_F(adr, res)
11341 POST_IO
11342RET(8)
11343}
11344
11345// MOVEW
11346OPCODE(0x3148)
11347{
11348 u32 adr, res;
11349 u32 src, dst;
11350
11351 res = AREGu16((Opcode >> 0) & 7);
11352 flag_C = 0;
11353 flag_V = 0;
11354 flag_NotZ = res;
11355 flag_N = res >> 8;
11356 FETCH_SWORD(adr);
11357 adr += AREG((Opcode >> 9) & 7);
11358 PRE_IO
11359 WRITE_WORD_F(adr, res)
11360 POST_IO
11361RET(12)
11362}
11363
11364// MOVEW
11365OPCODE(0x3188)
11366{
11367 u32 adr, res;
11368 u32 src, dst;
11369
11370 res = AREGu16((Opcode >> 0) & 7);
11371 flag_C = 0;
11372 flag_V = 0;
11373 flag_NotZ = res;
11374 flag_N = res >> 8;
11375 adr = AREG((Opcode >> 9) & 7);
11376 DECODE_EXT_WORD
11377 PRE_IO
11378 WRITE_WORD_F(adr, res)
11379 POST_IO
11380RET(14)
11381}
11382
11383// MOVEW
11384OPCODE(0x31C8)
11385{
11386 u32 adr, res;
11387 u32 src, dst;
11388
11389 res = AREGu16((Opcode >> 0) & 7);
11390 flag_C = 0;
11391 flag_V = 0;
11392 flag_NotZ = res;
11393 flag_N = res >> 8;
11394 FETCH_SWORD(adr);
11395 PRE_IO
11396 WRITE_WORD_F(adr, res)
11397 POST_IO
11398RET(12)
11399}
11400
11401// MOVEW
11402OPCODE(0x33C8)
11403{
11404 u32 adr, res;
11405 u32 src, dst;
11406
11407 res = AREGu16((Opcode >> 0) & 7);
11408 flag_C = 0;
11409 flag_V = 0;
11410 flag_NotZ = res;
11411 flag_N = res >> 8;
11412 FETCH_LONG(adr);
11413 PRE_IO
11414 WRITE_WORD_F(adr, res)
11415 POST_IO
11416RET(16)
11417}
11418
11419// MOVEW
11420OPCODE(0x3EC8)
11421{
11422 u32 adr, res;
11423 u32 src, dst;
11424
11425 res = AREGu16((Opcode >> 0) & 7);
11426 flag_C = 0;
11427 flag_V = 0;
11428 flag_NotZ = res;
11429 flag_N = res >> 8;
11430 adr = AREG(7);
11431 AREG(7) += 2;
11432 PRE_IO
11433 WRITE_WORD_F(adr, res)
11434 POST_IO
11435RET(8)
11436}
11437
11438// MOVEW
11439OPCODE(0x3F08)
11440{
11441 u32 adr, res;
11442 u32 src, dst;
11443
11444 res = AREGu16((Opcode >> 0) & 7);
11445 flag_C = 0;
11446 flag_V = 0;
11447 flag_NotZ = res;
11448 flag_N = res >> 8;
11449 adr = AREG(7) - 2;
11450 AREG(7) = adr;
11451 PRE_IO
11452 WRITE_WORD_F(adr, res)
11453 POST_IO
11454RET(8)
11455}
11456
11457// MOVEW
11458OPCODE(0x3010)
11459{
11460 u32 adr, res;
11461 u32 src, dst;
11462
11463 adr = AREG((Opcode >> 0) & 7);
11464 PRE_IO
11465 READ_WORD_F(adr, res)
11466 flag_C = 0;
11467 flag_V = 0;
11468 flag_NotZ = res;
11469 flag_N = res >> 8;
11470 DREGu16((Opcode >> 9) & 7) = res;
11471 POST_IO
11472RET(8)
11473}
11474
11475// MOVEW
11476OPCODE(0x3090)
11477{
11478 u32 adr, res;
11479 u32 src, dst;
11480
11481 adr = AREG((Opcode >> 0) & 7);
11482 PRE_IO
11483 READ_WORD_F(adr, res)
11484 flag_C = 0;
11485 flag_V = 0;
11486 flag_NotZ = res;
11487 flag_N = res >> 8;
11488 adr = AREG((Opcode >> 9) & 7);
11489 WRITE_WORD_F(adr, res)
11490 POST_IO
11491RET(12)
11492}
11493
11494// MOVEW
11495OPCODE(0x30D0)
11496{
11497 u32 adr, res;
11498 u32 src, dst;
11499
11500 adr = AREG((Opcode >> 0) & 7);
11501 PRE_IO
11502 READ_WORD_F(adr, res)
11503 flag_C = 0;
11504 flag_V = 0;
11505 flag_NotZ = res;
11506 flag_N = res >> 8;
11507 adr = AREG((Opcode >> 9) & 7);
11508 AREG((Opcode >> 9) & 7) += 2;
11509 WRITE_WORD_F(adr, res)
11510 POST_IO
11511RET(12)
11512}
11513
11514// MOVEW
11515OPCODE(0x3110)
11516{
11517 u32 adr, res;
11518 u32 src, dst;
11519
11520 adr = AREG((Opcode >> 0) & 7);
11521 PRE_IO
11522 READ_WORD_F(adr, res)
11523 flag_C = 0;
11524 flag_V = 0;
11525 flag_NotZ = res;
11526 flag_N = res >> 8;
11527 adr = AREG((Opcode >> 9) & 7) - 2;
11528 AREG((Opcode >> 9) & 7) = adr;
11529 WRITE_WORD_F(adr, res)
11530 POST_IO
11531RET(12)
11532}
11533
11534// MOVEW
11535OPCODE(0x3150)
11536{
11537 u32 adr, res;
11538 u32 src, dst;
11539
11540 adr = AREG((Opcode >> 0) & 7);
11541 PRE_IO
11542 READ_WORD_F(adr, res)
11543 flag_C = 0;
11544 flag_V = 0;
11545 flag_NotZ = res;
11546 flag_N = res >> 8;
11547 FETCH_SWORD(adr);
11548 adr += AREG((Opcode >> 9) & 7);
11549 WRITE_WORD_F(adr, res)
11550 POST_IO
11551RET(16)
11552}
11553
11554// MOVEW
11555OPCODE(0x3190)
11556{
11557 u32 adr, res;
11558 u32 src, dst;
11559
11560 adr = AREG((Opcode >> 0) & 7);
11561 PRE_IO
11562 READ_WORD_F(adr, res)
11563 flag_C = 0;
11564 flag_V = 0;
11565 flag_NotZ = res;
11566 flag_N = res >> 8;
11567 adr = AREG((Opcode >> 9) & 7);
11568 DECODE_EXT_WORD
11569 WRITE_WORD_F(adr, res)
11570 POST_IO
11571RET(18)
11572}
11573
11574// MOVEW
11575OPCODE(0x31D0)
11576{
11577 u32 adr, res;
11578 u32 src, dst;
11579
11580 adr = AREG((Opcode >> 0) & 7);
11581 PRE_IO
11582 READ_WORD_F(adr, res)
11583 flag_C = 0;
11584 flag_V = 0;
11585 flag_NotZ = res;
11586 flag_N = res >> 8;
11587 FETCH_SWORD(adr);
11588 WRITE_WORD_F(adr, res)
11589 POST_IO
11590RET(16)
11591}
11592
11593// MOVEW
11594OPCODE(0x33D0)
11595{
11596 u32 adr, res;
11597 u32 src, dst;
11598
11599 adr = AREG((Opcode >> 0) & 7);
11600 PRE_IO
11601 READ_WORD_F(adr, res)
11602 flag_C = 0;
11603 flag_V = 0;
11604 flag_NotZ = res;
11605 flag_N = res >> 8;
11606 FETCH_LONG(adr);
11607 WRITE_WORD_F(adr, res)
11608 POST_IO
11609RET(20)
11610}
11611
11612// MOVEW
11613OPCODE(0x3ED0)
11614{
11615 u32 adr, res;
11616 u32 src, dst;
11617
11618 adr = AREG((Opcode >> 0) & 7);
11619 PRE_IO
11620 READ_WORD_F(adr, res)
11621 flag_C = 0;
11622 flag_V = 0;
11623 flag_NotZ = res;
11624 flag_N = res >> 8;
11625 adr = AREG(7);
11626 AREG(7) += 2;
11627 WRITE_WORD_F(adr, res)
11628 POST_IO
11629RET(12)
11630}
11631
11632// MOVEW
11633OPCODE(0x3F10)
11634{
11635 u32 adr, res;
11636 u32 src, dst;
11637
11638 adr = AREG((Opcode >> 0) & 7);
11639 PRE_IO
11640 READ_WORD_F(adr, res)
11641 flag_C = 0;
11642 flag_V = 0;
11643 flag_NotZ = res;
11644 flag_N = res >> 8;
11645 adr = AREG(7) - 2;
11646 AREG(7) = adr;
11647 WRITE_WORD_F(adr, res)
11648 POST_IO
11649RET(12)
11650}
11651
11652// MOVEW
11653OPCODE(0x3018)
11654{
11655 u32 adr, res;
11656 u32 src, dst;
11657
11658 adr = AREG((Opcode >> 0) & 7);
11659 AREG((Opcode >> 0) & 7) += 2;
11660 PRE_IO
11661 READ_WORD_F(adr, res)
11662 flag_C = 0;
11663 flag_V = 0;
11664 flag_NotZ = res;
11665 flag_N = res >> 8;
11666 DREGu16((Opcode >> 9) & 7) = res;
11667 POST_IO
11668RET(8)
11669}
11670
11671// MOVEW
11672OPCODE(0x3098)
11673{
11674 u32 adr, res;
11675 u32 src, dst;
11676
11677 adr = AREG((Opcode >> 0) & 7);
11678 AREG((Opcode >> 0) & 7) += 2;
11679 PRE_IO
11680 READ_WORD_F(adr, res)
11681 flag_C = 0;
11682 flag_V = 0;
11683 flag_NotZ = res;
11684 flag_N = res >> 8;
11685 adr = AREG((Opcode >> 9) & 7);
11686 WRITE_WORD_F(adr, res)
11687 POST_IO
11688RET(12)
11689}
11690
11691// MOVEW
11692OPCODE(0x30D8)
11693{
11694 u32 adr, res;
11695 u32 src, dst;
11696
11697 adr = AREG((Opcode >> 0) & 7);
11698 AREG((Opcode >> 0) & 7) += 2;
11699 PRE_IO
11700 READ_WORD_F(adr, res)
11701 flag_C = 0;
11702 flag_V = 0;
11703 flag_NotZ = res;
11704 flag_N = res >> 8;
11705 adr = AREG((Opcode >> 9) & 7);
11706 AREG((Opcode >> 9) & 7) += 2;
11707 WRITE_WORD_F(adr, res)
11708 POST_IO
11709RET(12)
11710}
11711
11712// MOVEW
11713OPCODE(0x3118)
11714{
11715 u32 adr, res;
11716 u32 src, dst;
11717
11718 adr = AREG((Opcode >> 0) & 7);
11719 AREG((Opcode >> 0) & 7) += 2;
11720 PRE_IO
11721 READ_WORD_F(adr, res)
11722 flag_C = 0;
11723 flag_V = 0;
11724 flag_NotZ = res;
11725 flag_N = res >> 8;
11726 adr = AREG((Opcode >> 9) & 7) - 2;
11727 AREG((Opcode >> 9) & 7) = adr;
11728 WRITE_WORD_F(adr, res)
11729 POST_IO
11730RET(12)
11731}
11732
11733// MOVEW
11734OPCODE(0x3158)
11735{
11736 u32 adr, res;
11737 u32 src, dst;
11738
11739 adr = AREG((Opcode >> 0) & 7);
11740 AREG((Opcode >> 0) & 7) += 2;
11741 PRE_IO
11742 READ_WORD_F(adr, res)
11743 flag_C = 0;
11744 flag_V = 0;
11745 flag_NotZ = res;
11746 flag_N = res >> 8;
11747 FETCH_SWORD(adr);
11748 adr += AREG((Opcode >> 9) & 7);
11749 WRITE_WORD_F(adr, res)
11750 POST_IO
11751RET(16)
11752}
11753
11754// MOVEW
11755OPCODE(0x3198)
11756{
11757 u32 adr, res;
11758 u32 src, dst;
11759
11760 adr = AREG((Opcode >> 0) & 7);
11761 AREG((Opcode >> 0) & 7) += 2;
11762 PRE_IO
11763 READ_WORD_F(adr, res)
11764 flag_C = 0;
11765 flag_V = 0;
11766 flag_NotZ = res;
11767 flag_N = res >> 8;
11768 adr = AREG((Opcode >> 9) & 7);
11769 DECODE_EXT_WORD
11770 WRITE_WORD_F(adr, res)
11771 POST_IO
11772RET(18)
11773}
11774
11775// MOVEW
11776OPCODE(0x31D8)
11777{
11778 u32 adr, res;
11779 u32 src, dst;
11780
11781 adr = AREG((Opcode >> 0) & 7);
11782 AREG((Opcode >> 0) & 7) += 2;
11783 PRE_IO
11784 READ_WORD_F(adr, res)
11785 flag_C = 0;
11786 flag_V = 0;
11787 flag_NotZ = res;
11788 flag_N = res >> 8;
11789 FETCH_SWORD(adr);
11790 WRITE_WORD_F(adr, res)
11791 POST_IO
11792RET(16)
11793}
11794
11795// MOVEW
11796OPCODE(0x33D8)
11797{
11798 u32 adr, res;
11799 u32 src, dst;
11800
11801 adr = AREG((Opcode >> 0) & 7);
11802 AREG((Opcode >> 0) & 7) += 2;
11803 PRE_IO
11804 READ_WORD_F(adr, res)
11805 flag_C = 0;
11806 flag_V = 0;
11807 flag_NotZ = res;
11808 flag_N = res >> 8;
11809 FETCH_LONG(adr);
11810 WRITE_WORD_F(adr, res)
11811 POST_IO
11812RET(20)
11813}
11814
11815// MOVEW
11816OPCODE(0x3ED8)
11817{
11818 u32 adr, res;
11819 u32 src, dst;
11820
11821 adr = AREG((Opcode >> 0) & 7);
11822 AREG((Opcode >> 0) & 7) += 2;
11823 PRE_IO
11824 READ_WORD_F(adr, res)
11825 flag_C = 0;
11826 flag_V = 0;
11827 flag_NotZ = res;
11828 flag_N = res >> 8;
11829 adr = AREG(7);
11830 AREG(7) += 2;
11831 WRITE_WORD_F(adr, res)
11832 POST_IO
11833RET(12)
11834}
11835
11836// MOVEW
11837OPCODE(0x3F18)
11838{
11839 u32 adr, res;
11840 u32 src, dst;
11841
11842 adr = AREG((Opcode >> 0) & 7);
11843 AREG((Opcode >> 0) & 7) += 2;
11844 PRE_IO
11845 READ_WORD_F(adr, res)
11846 flag_C = 0;
11847 flag_V = 0;
11848 flag_NotZ = res;
11849 flag_N = res >> 8;
11850 adr = AREG(7) - 2;
11851 AREG(7) = adr;
11852 WRITE_WORD_F(adr, res)
11853 POST_IO
11854RET(12)
11855}
11856
11857// MOVEW
11858OPCODE(0x3020)
11859{
11860 u32 adr, res;
11861 u32 src, dst;
11862
11863 adr = AREG((Opcode >> 0) & 7) - 2;
11864 AREG((Opcode >> 0) & 7) = adr;
11865 PRE_IO
11866 READ_WORD_F(adr, res)
11867 flag_C = 0;
11868 flag_V = 0;
11869 flag_NotZ = res;
11870 flag_N = res >> 8;
11871 DREGu16((Opcode >> 9) & 7) = res;
11872 POST_IO
11873RET(10)
11874}
11875
11876// MOVEW
11877OPCODE(0x30A0)
11878{
11879 u32 adr, res;
11880 u32 src, dst;
11881
11882 adr = AREG((Opcode >> 0) & 7) - 2;
11883 AREG((Opcode >> 0) & 7) = adr;
11884 PRE_IO
11885 READ_WORD_F(adr, res)
11886 flag_C = 0;
11887 flag_V = 0;
11888 flag_NotZ = res;
11889 flag_N = res >> 8;
11890 adr = AREG((Opcode >> 9) & 7);
11891 WRITE_WORD_F(adr, res)
11892 POST_IO
11893RET(14)
11894}
11895
11896// MOVEW
11897OPCODE(0x30E0)
11898{
11899 u32 adr, res;
11900 u32 src, dst;
11901
11902 adr = AREG((Opcode >> 0) & 7) - 2;
11903 AREG((Opcode >> 0) & 7) = adr;
11904 PRE_IO
11905 READ_WORD_F(adr, res)
11906 flag_C = 0;
11907 flag_V = 0;
11908 flag_NotZ = res;
11909 flag_N = res >> 8;
11910 adr = AREG((Opcode >> 9) & 7);
11911 AREG((Opcode >> 9) & 7) += 2;
11912 WRITE_WORD_F(adr, res)
11913 POST_IO
11914RET(14)
11915}
11916
11917// MOVEW
11918OPCODE(0x3120)
11919{
11920 u32 adr, res;
11921 u32 src, dst;
11922
11923 adr = AREG((Opcode >> 0) & 7) - 2;
11924 AREG((Opcode >> 0) & 7) = adr;
11925 PRE_IO
11926 READ_WORD_F(adr, res)
11927 flag_C = 0;
11928 flag_V = 0;
11929 flag_NotZ = res;
11930 flag_N = res >> 8;
11931 adr = AREG((Opcode >> 9) & 7) - 2;
11932 AREG((Opcode >> 9) & 7) = adr;
11933 WRITE_WORD_F(adr, res)
11934 POST_IO
11935RET(14)
11936}
11937
11938// MOVEW
11939OPCODE(0x3160)
11940{
11941 u32 adr, res;
11942 u32 src, dst;
11943
11944 adr = AREG((Opcode >> 0) & 7) - 2;
11945 AREG((Opcode >> 0) & 7) = adr;
11946 PRE_IO
11947 READ_WORD_F(adr, res)
11948 flag_C = 0;
11949 flag_V = 0;
11950 flag_NotZ = res;
11951 flag_N = res >> 8;
11952 FETCH_SWORD(adr);
11953 adr += AREG((Opcode >> 9) & 7);
11954 WRITE_WORD_F(adr, res)
11955 POST_IO
11956RET(18)
11957}
11958
11959// MOVEW
11960OPCODE(0x31A0)
11961{
11962 u32 adr, res;
11963 u32 src, dst;
11964
11965 adr = AREG((Opcode >> 0) & 7) - 2;
11966 AREG((Opcode >> 0) & 7) = adr;
11967 PRE_IO
11968 READ_WORD_F(adr, res)
11969 flag_C = 0;
11970 flag_V = 0;
11971 flag_NotZ = res;
11972 flag_N = res >> 8;
11973 adr = AREG((Opcode >> 9) & 7);
11974 DECODE_EXT_WORD
11975 WRITE_WORD_F(adr, res)
11976 POST_IO
11977RET(20)
11978}
11979
11980// MOVEW
11981OPCODE(0x31E0)
11982{
11983 u32 adr, res;
11984 u32 src, dst;
11985
11986 adr = AREG((Opcode >> 0) & 7) - 2;
11987 AREG((Opcode >> 0) & 7) = adr;
11988 PRE_IO
11989 READ_WORD_F(adr, res)
11990 flag_C = 0;
11991 flag_V = 0;
11992 flag_NotZ = res;
11993 flag_N = res >> 8;
11994 FETCH_SWORD(adr);
11995 WRITE_WORD_F(adr, res)
11996 POST_IO
11997RET(18)
11998}
11999
12000// MOVEW
12001OPCODE(0x33E0)
12002{
12003 u32 adr, res;
12004 u32 src, dst;
12005
12006 adr = AREG((Opcode >> 0) & 7) - 2;
12007 AREG((Opcode >> 0) & 7) = adr;
12008 PRE_IO
12009 READ_WORD_F(adr, res)
12010 flag_C = 0;
12011 flag_V = 0;
12012 flag_NotZ = res;
12013 flag_N = res >> 8;
12014 FETCH_LONG(adr);
12015 WRITE_WORD_F(adr, res)
12016 POST_IO
12017RET(22)
12018}
12019
12020// MOVEW
12021OPCODE(0x3EE0)
12022{
12023 u32 adr, res;
12024 u32 src, dst;
12025
12026 adr = AREG((Opcode >> 0) & 7) - 2;
12027 AREG((Opcode >> 0) & 7) = adr;
12028 PRE_IO
12029 READ_WORD_F(adr, res)
12030 flag_C = 0;
12031 flag_V = 0;
12032 flag_NotZ = res;
12033 flag_N = res >> 8;
12034 adr = AREG(7);
12035 AREG(7) += 2;
12036 WRITE_WORD_F(adr, res)
12037 POST_IO
12038RET(14)
12039}
12040
12041// MOVEW
12042OPCODE(0x3F20)
12043{
12044 u32 adr, res;
12045 u32 src, dst;
12046
12047 adr = AREG((Opcode >> 0) & 7) - 2;
12048 AREG((Opcode >> 0) & 7) = adr;
12049 PRE_IO
12050 READ_WORD_F(adr, res)
12051 flag_C = 0;
12052 flag_V = 0;
12053 flag_NotZ = res;
12054 flag_N = res >> 8;
12055 adr = AREG(7) - 2;
12056 AREG(7) = adr;
12057 WRITE_WORD_F(adr, res)
12058 POST_IO
12059RET(14)
12060}
12061
12062// MOVEW
12063OPCODE(0x3028)
12064{
12065 u32 adr, res;
12066 u32 src, dst;
12067
12068 FETCH_SWORD(adr);
12069 adr += AREG((Opcode >> 0) & 7);
12070 PRE_IO
12071 READ_WORD_F(adr, res)
12072 flag_C = 0;
12073 flag_V = 0;
12074 flag_NotZ = res;
12075 flag_N = res >> 8;
12076 DREGu16((Opcode >> 9) & 7) = res;
12077 POST_IO
12078RET(12)
12079}
12080
12081// MOVEW
12082OPCODE(0x30A8)
12083{
12084 u32 adr, res;
12085 u32 src, dst;
12086
12087 FETCH_SWORD(adr);
12088 adr += AREG((Opcode >> 0) & 7);
12089 PRE_IO
12090 READ_WORD_F(adr, res)
12091 flag_C = 0;
12092 flag_V = 0;
12093 flag_NotZ = res;
12094 flag_N = res >> 8;
12095 adr = AREG((Opcode >> 9) & 7);
12096 WRITE_WORD_F(adr, res)
12097 POST_IO
12098RET(16)
12099}
12100
12101// MOVEW
12102OPCODE(0x30E8)
12103{
12104 u32 adr, res;
12105 u32 src, dst;
12106
12107 FETCH_SWORD(adr);
12108 adr += AREG((Opcode >> 0) & 7);
12109 PRE_IO
12110 READ_WORD_F(adr, res)
12111 flag_C = 0;
12112 flag_V = 0;
12113 flag_NotZ = res;
12114 flag_N = res >> 8;
12115 adr = AREG((Opcode >> 9) & 7);
12116 AREG((Opcode >> 9) & 7) += 2;
12117 WRITE_WORD_F(adr, res)
12118 POST_IO
12119RET(16)
12120}
12121
12122// MOVEW
12123OPCODE(0x3128)
12124{
12125 u32 adr, res;
12126 u32 src, dst;
12127
12128 FETCH_SWORD(adr);
12129 adr += AREG((Opcode >> 0) & 7);
12130 PRE_IO
12131 READ_WORD_F(adr, res)
12132 flag_C = 0;
12133 flag_V = 0;
12134 flag_NotZ = res;
12135 flag_N = res >> 8;
12136 adr = AREG((Opcode >> 9) & 7) - 2;
12137 AREG((Opcode >> 9) & 7) = adr;
12138 WRITE_WORD_F(adr, res)
12139 POST_IO
12140RET(16)
12141}
12142
12143// MOVEW
12144OPCODE(0x3168)
12145{
12146 u32 adr, res;
12147 u32 src, dst;
12148
12149 FETCH_SWORD(adr);
12150 adr += AREG((Opcode >> 0) & 7);
12151 PRE_IO
12152 READ_WORD_F(adr, res)
12153 flag_C = 0;
12154 flag_V = 0;
12155 flag_NotZ = res;
12156 flag_N = res >> 8;
12157 FETCH_SWORD(adr);
12158 adr += AREG((Opcode >> 9) & 7);
12159 WRITE_WORD_F(adr, res)
12160 POST_IO
12161RET(20)
12162}
12163
12164// MOVEW
12165OPCODE(0x31A8)
12166{
12167 u32 adr, res;
12168 u32 src, dst;
12169
12170 FETCH_SWORD(adr);
12171 adr += AREG((Opcode >> 0) & 7);
12172 PRE_IO
12173 READ_WORD_F(adr, res)
12174 flag_C = 0;
12175 flag_V = 0;
12176 flag_NotZ = res;
12177 flag_N = res >> 8;
12178 adr = AREG((Opcode >> 9) & 7);
12179 DECODE_EXT_WORD
12180 WRITE_WORD_F(adr, res)
12181 POST_IO
12182RET(22)
12183}
12184
12185// MOVEW
12186OPCODE(0x31E8)
12187{
12188 u32 adr, res;
12189 u32 src, dst;
12190
12191 FETCH_SWORD(adr);
12192 adr += AREG((Opcode >> 0) & 7);
12193 PRE_IO
12194 READ_WORD_F(adr, res)
12195 flag_C = 0;
12196 flag_V = 0;
12197 flag_NotZ = res;
12198 flag_N = res >> 8;
12199 FETCH_SWORD(adr);
12200 WRITE_WORD_F(adr, res)
12201 POST_IO
12202RET(20)
12203}
12204
12205// MOVEW
12206OPCODE(0x33E8)
12207{
12208 u32 adr, res;
12209 u32 src, dst;
12210
12211 FETCH_SWORD(adr);
12212 adr += AREG((Opcode >> 0) & 7);
12213 PRE_IO
12214 READ_WORD_F(adr, res)
12215 flag_C = 0;
12216 flag_V = 0;
12217 flag_NotZ = res;
12218 flag_N = res >> 8;
12219 FETCH_LONG(adr);
12220 WRITE_WORD_F(adr, res)
12221 POST_IO
12222RET(24)
12223}
12224
12225// MOVEW
12226OPCODE(0x3EE8)
12227{
12228 u32 adr, res;
12229 u32 src, dst;
12230
12231 FETCH_SWORD(adr);
12232 adr += AREG((Opcode >> 0) & 7);
12233 PRE_IO
12234 READ_WORD_F(adr, res)
12235 flag_C = 0;
12236 flag_V = 0;
12237 flag_NotZ = res;
12238 flag_N = res >> 8;
12239 adr = AREG(7);
12240 AREG(7) += 2;
12241 WRITE_WORD_F(adr, res)
12242 POST_IO
12243RET(16)
12244}
12245
12246// MOVEW
12247OPCODE(0x3F28)
12248{
12249 u32 adr, res;
12250 u32 src, dst;
12251
12252 FETCH_SWORD(adr);
12253 adr += AREG((Opcode >> 0) & 7);
12254 PRE_IO
12255 READ_WORD_F(adr, res)
12256 flag_C = 0;
12257 flag_V = 0;
12258 flag_NotZ = res;
12259 flag_N = res >> 8;
12260 adr = AREG(7) - 2;
12261 AREG(7) = adr;
12262 WRITE_WORD_F(adr, res)
12263 POST_IO
12264RET(16)
12265}
12266
12267// MOVEW
12268OPCODE(0x3030)
12269{
12270 u32 adr, res;
12271 u32 src, dst;
12272
12273 adr = AREG((Opcode >> 0) & 7);
12274 DECODE_EXT_WORD
12275 PRE_IO
12276 READ_WORD_F(adr, res)
12277 flag_C = 0;
12278 flag_V = 0;
12279 flag_NotZ = res;
12280 flag_N = res >> 8;
12281 DREGu16((Opcode >> 9) & 7) = res;
12282 POST_IO
12283RET(14)
12284}
12285
12286// MOVEW
12287OPCODE(0x30B0)
12288{
12289 u32 adr, res;
12290 u32 src, dst;
12291
12292 adr = AREG((Opcode >> 0) & 7);
12293 DECODE_EXT_WORD
12294 PRE_IO
12295 READ_WORD_F(adr, res)
12296 flag_C = 0;
12297 flag_V = 0;
12298 flag_NotZ = res;
12299 flag_N = res >> 8;
12300 adr = AREG((Opcode >> 9) & 7);
12301 WRITE_WORD_F(adr, res)
12302 POST_IO
12303RET(18)
12304}
12305
12306// MOVEW
12307OPCODE(0x30F0)
12308{
12309 u32 adr, res;
12310 u32 src, dst;
12311
12312 adr = AREG((Opcode >> 0) & 7);
12313 DECODE_EXT_WORD
12314 PRE_IO
12315 READ_WORD_F(adr, res)
12316 flag_C = 0;
12317 flag_V = 0;
12318 flag_NotZ = res;
12319 flag_N = res >> 8;
12320 adr = AREG((Opcode >> 9) & 7);
12321 AREG((Opcode >> 9) & 7) += 2;
12322 WRITE_WORD_F(adr, res)
12323 POST_IO
12324RET(18)
12325}
12326
12327// MOVEW
12328OPCODE(0x3130)
12329{
12330 u32 adr, res;
12331 u32 src, dst;
12332
12333 adr = AREG((Opcode >> 0) & 7);
12334 DECODE_EXT_WORD
12335 PRE_IO
12336 READ_WORD_F(adr, res)
12337 flag_C = 0;
12338 flag_V = 0;
12339 flag_NotZ = res;
12340 flag_N = res >> 8;
12341 adr = AREG((Opcode >> 9) & 7) - 2;
12342 AREG((Opcode >> 9) & 7) = adr;
12343 WRITE_WORD_F(adr, res)
12344 POST_IO
12345RET(18)
12346}
12347
12348// MOVEW
12349OPCODE(0x3170)
12350{
12351 u32 adr, res;
12352 u32 src, dst;
12353
12354 adr = AREG((Opcode >> 0) & 7);
12355 DECODE_EXT_WORD
12356 PRE_IO
12357 READ_WORD_F(adr, res)
12358 flag_C = 0;
12359 flag_V = 0;
12360 flag_NotZ = res;
12361 flag_N = res >> 8;
12362 FETCH_SWORD(adr);
12363 adr += AREG((Opcode >> 9) & 7);
12364 WRITE_WORD_F(adr, res)
12365 POST_IO
12366RET(22)
12367}
12368
12369// MOVEW
12370OPCODE(0x31B0)
12371{
12372 u32 adr, res;
12373 u32 src, dst;
12374
12375 adr = AREG((Opcode >> 0) & 7);
12376 DECODE_EXT_WORD
12377 PRE_IO
12378 READ_WORD_F(adr, res)
12379 flag_C = 0;
12380 flag_V = 0;
12381 flag_NotZ = res;
12382 flag_N = res >> 8;
12383 adr = AREG((Opcode >> 9) & 7);
12384 DECODE_EXT_WORD
12385 WRITE_WORD_F(adr, res)
12386 POST_IO
12387RET(24)
12388}
12389
12390// MOVEW
12391OPCODE(0x31F0)
12392{
12393 u32 adr, res;
12394 u32 src, dst;
12395
12396 adr = AREG((Opcode >> 0) & 7);
12397 DECODE_EXT_WORD
12398 PRE_IO
12399 READ_WORD_F(adr, res)
12400 flag_C = 0;
12401 flag_V = 0;
12402 flag_NotZ = res;
12403 flag_N = res >> 8;
12404 FETCH_SWORD(adr);
12405 WRITE_WORD_F(adr, res)
12406 POST_IO
12407RET(22)
12408}
12409
12410// MOVEW
12411OPCODE(0x33F0)
12412{
12413 u32 adr, res;
12414 u32 src, dst;
12415
12416 adr = AREG((Opcode >> 0) & 7);
12417 DECODE_EXT_WORD
12418 PRE_IO
12419 READ_WORD_F(adr, res)
12420 flag_C = 0;
12421 flag_V = 0;
12422 flag_NotZ = res;
12423 flag_N = res >> 8;
12424 FETCH_LONG(adr);
12425 WRITE_WORD_F(adr, res)
12426 POST_IO
12427RET(26)
12428}
12429
12430// MOVEW
12431OPCODE(0x3EF0)
12432{
12433 u32 adr, res;
12434 u32 src, dst;
12435
12436 adr = AREG((Opcode >> 0) & 7);
12437 DECODE_EXT_WORD
12438 PRE_IO
12439 READ_WORD_F(adr, res)
12440 flag_C = 0;
12441 flag_V = 0;
12442 flag_NotZ = res;
12443 flag_N = res >> 8;
12444 adr = AREG(7);
12445 AREG(7) += 2;
12446 WRITE_WORD_F(adr, res)
12447 POST_IO
12448RET(18)
12449}
12450
12451// MOVEW
12452OPCODE(0x3F30)
12453{
12454 u32 adr, res;
12455 u32 src, dst;
12456
12457 adr = AREG((Opcode >> 0) & 7);
12458 DECODE_EXT_WORD
12459 PRE_IO
12460 READ_WORD_F(adr, res)
12461 flag_C = 0;
12462 flag_V = 0;
12463 flag_NotZ = res;
12464 flag_N = res >> 8;
12465 adr = AREG(7) - 2;
12466 AREG(7) = adr;
12467 WRITE_WORD_F(adr, res)
12468 POST_IO
12469RET(18)
12470}
12471
12472// MOVEW
12473OPCODE(0x3038)
12474{
12475 u32 adr, res;
12476 u32 src, dst;
12477
12478 FETCH_SWORD(adr);
12479 PRE_IO
12480 READ_WORD_F(adr, res)
12481 flag_C = 0;
12482 flag_V = 0;
12483 flag_NotZ = res;
12484 flag_N = res >> 8;
12485 DREGu16((Opcode >> 9) & 7) = res;
12486 POST_IO
12487RET(12)
12488}
12489
12490// MOVEW
12491OPCODE(0x30B8)
12492{
12493 u32 adr, res;
12494 u32 src, dst;
12495
12496 FETCH_SWORD(adr);
12497 PRE_IO
12498 READ_WORD_F(adr, res)
12499 flag_C = 0;
12500 flag_V = 0;
12501 flag_NotZ = res;
12502 flag_N = res >> 8;
12503 adr = AREG((Opcode >> 9) & 7);
12504 WRITE_WORD_F(adr, res)
12505 POST_IO
12506RET(16)
12507}
12508
12509// MOVEW
12510OPCODE(0x30F8)
12511{
12512 u32 adr, res;
12513 u32 src, dst;
12514
12515 FETCH_SWORD(adr);
12516 PRE_IO
12517 READ_WORD_F(adr, res)
12518 flag_C = 0;
12519 flag_V = 0;
12520 flag_NotZ = res;
12521 flag_N = res >> 8;
12522 adr = AREG((Opcode >> 9) & 7);
12523 AREG((Opcode >> 9) & 7) += 2;
12524 WRITE_WORD_F(adr, res)
12525 POST_IO
12526RET(16)
12527}
12528
12529// MOVEW
12530OPCODE(0x3138)
12531{
12532 u32 adr, res;
12533 u32 src, dst;
12534
12535 FETCH_SWORD(adr);
12536 PRE_IO
12537 READ_WORD_F(adr, res)
12538 flag_C = 0;
12539 flag_V = 0;
12540 flag_NotZ = res;
12541 flag_N = res >> 8;
12542 adr = AREG((Opcode >> 9) & 7) - 2;
12543 AREG((Opcode >> 9) & 7) = adr;
12544 WRITE_WORD_F(adr, res)
12545 POST_IO
12546RET(16)
12547}
12548
12549// MOVEW
12550OPCODE(0x3178)
12551{
12552 u32 adr, res;
12553 u32 src, dst;
12554
12555 FETCH_SWORD(adr);
12556 PRE_IO
12557 READ_WORD_F(adr, res)
12558 flag_C = 0;
12559 flag_V = 0;
12560 flag_NotZ = res;
12561 flag_N = res >> 8;
12562 FETCH_SWORD(adr);
12563 adr += AREG((Opcode >> 9) & 7);
12564 WRITE_WORD_F(adr, res)
12565 POST_IO
12566RET(20)
12567}
12568
12569// MOVEW
12570OPCODE(0x31B8)
12571{
12572 u32 adr, res;
12573 u32 src, dst;
12574
12575 FETCH_SWORD(adr);
12576 PRE_IO
12577 READ_WORD_F(adr, res)
12578 flag_C = 0;
12579 flag_V = 0;
12580 flag_NotZ = res;
12581 flag_N = res >> 8;
12582 adr = AREG((Opcode >> 9) & 7);
12583 DECODE_EXT_WORD
12584 WRITE_WORD_F(adr, res)
12585 POST_IO
12586RET(22)
12587}
12588
12589// MOVEW
12590OPCODE(0x31F8)
12591{
12592 u32 adr, res;
12593 u32 src, dst;
12594
12595 FETCH_SWORD(adr);
12596 PRE_IO
12597 READ_WORD_F(adr, res)
12598 flag_C = 0;
12599 flag_V = 0;
12600 flag_NotZ = res;
12601 flag_N = res >> 8;
12602 FETCH_SWORD(adr);
12603 WRITE_WORD_F(adr, res)
12604 POST_IO
12605RET(20)
12606}
12607
12608// MOVEW
12609OPCODE(0x33F8)
12610{
12611 u32 adr, res;
12612 u32 src, dst;
12613
12614 FETCH_SWORD(adr);
12615 PRE_IO
12616 READ_WORD_F(adr, res)
12617 flag_C = 0;
12618 flag_V = 0;
12619 flag_NotZ = res;
12620 flag_N = res >> 8;
12621 FETCH_LONG(adr);
12622 WRITE_WORD_F(adr, res)
12623 POST_IO
12624RET(24)
12625}
12626
12627// MOVEW
12628OPCODE(0x3EF8)
12629{
12630 u32 adr, res;
12631 u32 src, dst;
12632
12633 FETCH_SWORD(adr);
12634 PRE_IO
12635 READ_WORD_F(adr, res)
12636 flag_C = 0;
12637 flag_V = 0;
12638 flag_NotZ = res;
12639 flag_N = res >> 8;
12640 adr = AREG(7);
12641 AREG(7) += 2;
12642 WRITE_WORD_F(adr, res)
12643 POST_IO
12644RET(16)
12645}
12646
12647// MOVEW
12648OPCODE(0x3F38)
12649{
12650 u32 adr, res;
12651 u32 src, dst;
12652
12653 FETCH_SWORD(adr);
12654 PRE_IO
12655 READ_WORD_F(adr, res)
12656 flag_C = 0;
12657 flag_V = 0;
12658 flag_NotZ = res;
12659 flag_N = res >> 8;
12660 adr = AREG(7) - 2;
12661 AREG(7) = adr;
12662 WRITE_WORD_F(adr, res)
12663 POST_IO
12664RET(16)
12665}
12666
12667// MOVEW
12668OPCODE(0x3039)
12669{
12670 u32 adr, res;
12671 u32 src, dst;
12672
12673 FETCH_LONG(adr);
12674 PRE_IO
12675 READ_WORD_F(adr, res)
12676 flag_C = 0;
12677 flag_V = 0;
12678 flag_NotZ = res;
12679 flag_N = res >> 8;
12680 DREGu16((Opcode >> 9) & 7) = res;
12681 POST_IO
12682RET(16)
12683}
12684
12685// MOVEW
12686OPCODE(0x30B9)
12687{
12688 u32 adr, res;
12689 u32 src, dst;
12690
12691 FETCH_LONG(adr);
12692 PRE_IO
12693 READ_WORD_F(adr, res)
12694 flag_C = 0;
12695 flag_V = 0;
12696 flag_NotZ = res;
12697 flag_N = res >> 8;
12698 adr = AREG((Opcode >> 9) & 7);
12699 WRITE_WORD_F(adr, res)
12700 POST_IO
12701RET(20)
12702}
12703
12704// MOVEW
12705OPCODE(0x30F9)
12706{
12707 u32 adr, res;
12708 u32 src, dst;
12709
12710 FETCH_LONG(adr);
12711 PRE_IO
12712 READ_WORD_F(adr, res)
12713 flag_C = 0;
12714 flag_V = 0;
12715 flag_NotZ = res;
12716 flag_N = res >> 8;
12717 adr = AREG((Opcode >> 9) & 7);
12718 AREG((Opcode >> 9) & 7) += 2;
12719 WRITE_WORD_F(adr, res)
12720 POST_IO
12721RET(20)
12722}
12723
12724// MOVEW
12725OPCODE(0x3139)
12726{
12727 u32 adr, res;
12728 u32 src, dst;
12729
12730 FETCH_LONG(adr);
12731 PRE_IO
12732 READ_WORD_F(adr, res)
12733 flag_C = 0;
12734 flag_V = 0;
12735 flag_NotZ = res;
12736 flag_N = res >> 8;
12737 adr = AREG((Opcode >> 9) & 7) - 2;
12738 AREG((Opcode >> 9) & 7) = adr;
12739 WRITE_WORD_F(adr, res)
12740 POST_IO
12741RET(20)
12742}
12743
12744// MOVEW
12745OPCODE(0x3179)
12746{
12747 u32 adr, res;
12748 u32 src, dst;
12749
12750 FETCH_LONG(adr);
12751 PRE_IO
12752 READ_WORD_F(adr, res)
12753 flag_C = 0;
12754 flag_V = 0;
12755 flag_NotZ = res;
12756 flag_N = res >> 8;
12757 FETCH_SWORD(adr);
12758 adr += AREG((Opcode >> 9) & 7);
12759 WRITE_WORD_F(adr, res)
12760 POST_IO
12761RET(24)
12762}
12763
12764// MOVEW
12765OPCODE(0x31B9)
12766{
12767 u32 adr, res;
12768 u32 src, dst;
12769
12770 FETCH_LONG(adr);
12771 PRE_IO
12772 READ_WORD_F(adr, res)
12773 flag_C = 0;
12774 flag_V = 0;
12775 flag_NotZ = res;
12776 flag_N = res >> 8;
12777 adr = AREG((Opcode >> 9) & 7);
12778 DECODE_EXT_WORD
12779 WRITE_WORD_F(adr, res)
12780 POST_IO
12781RET(26)
12782}
12783
12784// MOVEW
12785OPCODE(0x31F9)
12786{
12787 u32 adr, res;
12788 u32 src, dst;
12789
12790 FETCH_LONG(adr);
12791 PRE_IO
12792 READ_WORD_F(adr, res)
12793 flag_C = 0;
12794 flag_V = 0;
12795 flag_NotZ = res;
12796 flag_N = res >> 8;
12797 FETCH_SWORD(adr);
12798 WRITE_WORD_F(adr, res)
12799 POST_IO
12800RET(24)
12801}
12802
12803// MOVEW
12804OPCODE(0x33F9)
12805{
12806 u32 adr, res;
12807 u32 src, dst;
12808
12809 FETCH_LONG(adr);
12810 PRE_IO
12811 READ_WORD_F(adr, res)
12812 flag_C = 0;
12813 flag_V = 0;
12814 flag_NotZ = res;
12815 flag_N = res >> 8;
12816 FETCH_LONG(adr);
12817 WRITE_WORD_F(adr, res)
12818 POST_IO
12819RET(28)
12820}
12821
12822// MOVEW
12823OPCODE(0x3EF9)
12824{
12825 u32 adr, res;
12826 u32 src, dst;
12827
12828 FETCH_LONG(adr);
12829 PRE_IO
12830 READ_WORD_F(adr, res)
12831 flag_C = 0;
12832 flag_V = 0;
12833 flag_NotZ = res;
12834 flag_N = res >> 8;
12835 adr = AREG(7);
12836 AREG(7) += 2;
12837 WRITE_WORD_F(adr, res)
12838 POST_IO
12839RET(20)
12840}
12841
12842// MOVEW
12843OPCODE(0x3F39)
12844{
12845 u32 adr, res;
12846 u32 src, dst;
12847
12848 FETCH_LONG(adr);
12849 PRE_IO
12850 READ_WORD_F(adr, res)
12851 flag_C = 0;
12852 flag_V = 0;
12853 flag_NotZ = res;
12854 flag_N = res >> 8;
12855 adr = AREG(7) - 2;
12856 AREG(7) = adr;
12857 WRITE_WORD_F(adr, res)
12858 POST_IO
12859RET(20)
12860}
12861
12862// MOVEW
12863OPCODE(0x303A)
12864{
12865 u32 adr, res;
12866 u32 src, dst;
12867
be26eb23 12868 adr = GET_SWORD + GET_PC;
70357ce5 12869 PC++;
12870 PRE_IO
12871 READ_WORD_F(adr, res)
12872 flag_C = 0;
12873 flag_V = 0;
12874 flag_NotZ = res;
12875 flag_N = res >> 8;
12876 DREGu16((Opcode >> 9) & 7) = res;
12877 POST_IO
12878RET(12)
12879}
12880
12881// MOVEW
12882OPCODE(0x30BA)
12883{
12884 u32 adr, res;
12885 u32 src, dst;
12886
be26eb23 12887 adr = GET_SWORD + GET_PC;
70357ce5 12888 PC++;
12889 PRE_IO
12890 READ_WORD_F(adr, res)
12891 flag_C = 0;
12892 flag_V = 0;
12893 flag_NotZ = res;
12894 flag_N = res >> 8;
12895 adr = AREG((Opcode >> 9) & 7);
12896 WRITE_WORD_F(adr, res)
12897 POST_IO
12898RET(16)
12899}
12900
12901// MOVEW
12902OPCODE(0x30FA)
12903{
12904 u32 adr, res;
12905 u32 src, dst;
12906
be26eb23 12907 adr = GET_SWORD + GET_PC;
70357ce5 12908 PC++;
12909 PRE_IO
12910 READ_WORD_F(adr, res)
12911 flag_C = 0;
12912 flag_V = 0;
12913 flag_NotZ = res;
12914 flag_N = res >> 8;
12915 adr = AREG((Opcode >> 9) & 7);
12916 AREG((Opcode >> 9) & 7) += 2;
12917 WRITE_WORD_F(adr, res)
12918 POST_IO
12919RET(16)
12920}
12921
12922// MOVEW
12923OPCODE(0x313A)
12924{
12925 u32 adr, res;
12926 u32 src, dst;
12927
be26eb23 12928 adr = GET_SWORD + GET_PC;
70357ce5 12929 PC++;
12930 PRE_IO
12931 READ_WORD_F(adr, res)
12932 flag_C = 0;
12933 flag_V = 0;
12934 flag_NotZ = res;
12935 flag_N = res >> 8;
12936 adr = AREG((Opcode >> 9) & 7) - 2;
12937 AREG((Opcode >> 9) & 7) = adr;
12938 WRITE_WORD_F(adr, res)
12939 POST_IO
12940RET(16)
12941}
12942
12943// MOVEW
12944OPCODE(0x317A)
12945{
12946 u32 adr, res;
12947 u32 src, dst;
12948
be26eb23 12949 adr = GET_SWORD + GET_PC;
70357ce5 12950 PC++;
12951 PRE_IO
12952 READ_WORD_F(adr, res)
12953 flag_C = 0;
12954 flag_V = 0;
12955 flag_NotZ = res;
12956 flag_N = res >> 8;
12957 FETCH_SWORD(adr);
12958 adr += AREG((Opcode >> 9) & 7);
12959 WRITE_WORD_F(adr, res)
12960 POST_IO
12961RET(20)
12962}
12963
12964// MOVEW
12965OPCODE(0x31BA)
12966{
12967 u32 adr, res;
12968 u32 src, dst;
12969
be26eb23 12970 adr = GET_SWORD + GET_PC;
70357ce5 12971 PC++;
12972 PRE_IO
12973 READ_WORD_F(adr, res)
12974 flag_C = 0;
12975 flag_V = 0;
12976 flag_NotZ = res;
12977 flag_N = res >> 8;
12978 adr = AREG((Opcode >> 9) & 7);
12979 DECODE_EXT_WORD
12980 WRITE_WORD_F(adr, res)
12981 POST_IO
12982RET(22)
12983}
12984
12985// MOVEW
12986OPCODE(0x31FA)
12987{
12988 u32 adr, res;
12989 u32 src, dst;
12990
be26eb23 12991 adr = GET_SWORD + GET_PC;
70357ce5 12992 PC++;
12993 PRE_IO
12994 READ_WORD_F(adr, res)
12995 flag_C = 0;
12996 flag_V = 0;
12997 flag_NotZ = res;
12998 flag_N = res >> 8;
12999 FETCH_SWORD(adr);
13000 WRITE_WORD_F(adr, res)
13001 POST_IO
13002RET(20)
13003}
13004
13005// MOVEW
13006OPCODE(0x33FA)
13007{
13008 u32 adr, res;
13009 u32 src, dst;
13010
be26eb23 13011 adr = GET_SWORD + GET_PC;
70357ce5 13012 PC++;
13013 PRE_IO
13014 READ_WORD_F(adr, res)
13015 flag_C = 0;
13016 flag_V = 0;
13017 flag_NotZ = res;
13018 flag_N = res >> 8;
13019 FETCH_LONG(adr);
13020 WRITE_WORD_F(adr, res)
13021 POST_IO
13022RET(24)
13023}
13024
13025// MOVEW
13026OPCODE(0x3EFA)
13027{
13028 u32 adr, res;
13029 u32 src, dst;
13030
be26eb23 13031 adr = GET_SWORD + GET_PC;
70357ce5 13032 PC++;
13033 PRE_IO
13034 READ_WORD_F(adr, res)
13035 flag_C = 0;
13036 flag_V = 0;
13037 flag_NotZ = res;
13038 flag_N = res >> 8;
13039 adr = AREG(7);
13040 AREG(7) += 2;
13041 WRITE_WORD_F(adr, res)
13042 POST_IO
13043RET(16)
13044}
13045
13046// MOVEW
13047OPCODE(0x3F3A)
13048{
13049 u32 adr, res;
13050 u32 src, dst;
13051
be26eb23 13052 adr = GET_SWORD + GET_PC;
70357ce5 13053 PC++;
13054 PRE_IO
13055 READ_WORD_F(adr, res)
13056 flag_C = 0;
13057 flag_V = 0;
13058 flag_NotZ = res;
13059 flag_N = res >> 8;
13060 adr = AREG(7) - 2;
13061 AREG(7) = adr;
13062 WRITE_WORD_F(adr, res)
13063 POST_IO
13064RET(16)
13065}
13066
13067// MOVEW
13068OPCODE(0x303B)
13069{
13070 u32 adr, res;
13071 u32 src, dst;
13072
be26eb23 13073 adr = GET_PC;
70357ce5 13074 DECODE_EXT_WORD
13075 PRE_IO
13076 READ_WORD_F(adr, res)
13077 flag_C = 0;
13078 flag_V = 0;
13079 flag_NotZ = res;
13080 flag_N = res >> 8;
13081 DREGu16((Opcode >> 9) & 7) = res;
13082 POST_IO
13083RET(14)
13084}
13085
13086// MOVEW
13087OPCODE(0x30BB)
13088{
13089 u32 adr, res;
13090 u32 src, dst;
13091
be26eb23 13092 adr = GET_PC;
70357ce5 13093 DECODE_EXT_WORD
13094 PRE_IO
13095 READ_WORD_F(adr, res)
13096 flag_C = 0;
13097 flag_V = 0;
13098 flag_NotZ = res;
13099 flag_N = res >> 8;
13100 adr = AREG((Opcode >> 9) & 7);
13101 WRITE_WORD_F(adr, res)
13102 POST_IO
13103RET(18)
13104}
13105
13106// MOVEW
13107OPCODE(0x30FB)
13108{
13109 u32 adr, res;
13110 u32 src, dst;
13111
be26eb23 13112 adr = GET_PC;
70357ce5 13113 DECODE_EXT_WORD
13114 PRE_IO
13115 READ_WORD_F(adr, res)
13116 flag_C = 0;
13117 flag_V = 0;
13118 flag_NotZ = res;
13119 flag_N = res >> 8;
13120 adr = AREG((Opcode >> 9) & 7);
13121 AREG((Opcode >> 9) & 7) += 2;
13122 WRITE_WORD_F(adr, res)
13123 POST_IO
13124RET(18)
13125}
13126
13127// MOVEW
13128OPCODE(0x313B)
13129{
13130 u32 adr, res;
13131 u32 src, dst;
13132
be26eb23 13133 adr = GET_PC;
70357ce5 13134 DECODE_EXT_WORD
13135 PRE_IO
13136 READ_WORD_F(adr, res)
13137 flag_C = 0;
13138 flag_V = 0;
13139 flag_NotZ = res;
13140 flag_N = res >> 8;
13141 adr = AREG((Opcode >> 9) & 7) - 2;
13142 AREG((Opcode >> 9) & 7) = adr;
13143 WRITE_WORD_F(adr, res)
13144 POST_IO
13145RET(18)
13146}
13147
13148// MOVEW
13149OPCODE(0x317B)
13150{
13151 u32 adr, res;
13152 u32 src, dst;
13153
be26eb23 13154 adr = GET_PC;
70357ce5 13155 DECODE_EXT_WORD
13156 PRE_IO
13157 READ_WORD_F(adr, res)
13158 flag_C = 0;
13159 flag_V = 0;
13160 flag_NotZ = res;
13161 flag_N = res >> 8;
13162 FETCH_SWORD(adr);
13163 adr += AREG((Opcode >> 9) & 7);
13164 WRITE_WORD_F(adr, res)
13165 POST_IO
13166RET(22)
13167}
13168
13169// MOVEW
13170OPCODE(0x31BB)
13171{
13172 u32 adr, res;
13173 u32 src, dst;
13174
be26eb23 13175 adr = GET_PC;
70357ce5 13176 DECODE_EXT_WORD
13177 PRE_IO
13178 READ_WORD_F(adr, res)
13179 flag_C = 0;
13180 flag_V = 0;
13181 flag_NotZ = res;
13182 flag_N = res >> 8;
13183 adr = AREG((Opcode >> 9) & 7);
13184 DECODE_EXT_WORD
13185 WRITE_WORD_F(adr, res)
13186 POST_IO
13187RET(24)
13188}
13189
13190// MOVEW
13191OPCODE(0x31FB)
13192{
13193 u32 adr, res;
13194 u32 src, dst;
13195
be26eb23 13196 adr = GET_PC;
70357ce5 13197 DECODE_EXT_WORD
13198 PRE_IO
13199 READ_WORD_F(adr, res)
13200 flag_C = 0;
13201 flag_V = 0;
13202 flag_NotZ = res;
13203 flag_N = res >> 8;
13204 FETCH_SWORD(adr);
13205 WRITE_WORD_F(adr, res)
13206 POST_IO
13207RET(22)
13208}
13209
13210// MOVEW
13211OPCODE(0x33FB)
13212{
13213 u32 adr, res;
13214 u32 src, dst;
13215
be26eb23 13216 adr = GET_PC;
70357ce5 13217 DECODE_EXT_WORD
13218 PRE_IO
13219 READ_WORD_F(adr, res)
13220 flag_C = 0;
13221 flag_V = 0;
13222 flag_NotZ = res;
13223 flag_N = res >> 8;
13224 FETCH_LONG(adr);
13225 WRITE_WORD_F(adr, res)
13226 POST_IO
13227RET(26)
13228}
13229
13230// MOVEW
13231OPCODE(0x3EFB)
13232{
13233 u32 adr, res;
13234 u32 src, dst;
13235
be26eb23 13236 adr = GET_PC;
70357ce5 13237 DECODE_EXT_WORD
13238 PRE_IO
13239 READ_WORD_F(adr, res)
13240 flag_C = 0;
13241 flag_V = 0;
13242 flag_NotZ = res;
13243 flag_N = res >> 8;
13244 adr = AREG(7);
13245 AREG(7) += 2;
13246 WRITE_WORD_F(adr, res)
13247 POST_IO
13248RET(18)
13249}
13250
13251// MOVEW
13252OPCODE(0x3F3B)
13253{
13254 u32 adr, res;
13255 u32 src, dst;
13256
be26eb23 13257 adr = GET_PC;
70357ce5 13258 DECODE_EXT_WORD
13259 PRE_IO
13260 READ_WORD_F(adr, res)
13261 flag_C = 0;
13262 flag_V = 0;
13263 flag_NotZ = res;
13264 flag_N = res >> 8;
13265 adr = AREG(7) - 2;
13266 AREG(7) = adr;
13267 WRITE_WORD_F(adr, res)
13268 POST_IO
13269RET(18)
13270}
13271
13272// MOVEW
13273OPCODE(0x303C)
13274{
13275 u32 adr, res;
13276 u32 src, dst;
13277
13278 FETCH_WORD(res);
13279 flag_C = 0;
13280 flag_V = 0;
13281 flag_NotZ = res;
13282 flag_N = res >> 8;
13283 DREGu16((Opcode >> 9) & 7) = res;
13284RET(8)
13285}
13286
13287// MOVEW
13288OPCODE(0x30BC)
13289{
13290 u32 adr, res;
13291 u32 src, dst;
13292
13293 FETCH_WORD(res);
13294 flag_C = 0;
13295 flag_V = 0;
13296 flag_NotZ = res;
13297 flag_N = res >> 8;
13298 adr = AREG((Opcode >> 9) & 7);
13299 PRE_IO
13300 WRITE_WORD_F(adr, res)
13301 POST_IO
13302RET(12)
13303}
13304
13305// MOVEW
13306OPCODE(0x30FC)
13307{
13308 u32 adr, res;
13309 u32 src, dst;
13310
13311 FETCH_WORD(res);
13312 flag_C = 0;
13313 flag_V = 0;
13314 flag_NotZ = res;
13315 flag_N = res >> 8;
13316 adr = AREG((Opcode >> 9) & 7);
13317 AREG((Opcode >> 9) & 7) += 2;
13318 PRE_IO
13319 WRITE_WORD_F(adr, res)
13320 POST_IO
13321RET(12)
13322}
13323
13324// MOVEW
13325OPCODE(0x313C)
13326{
13327 u32 adr, res;
13328 u32 src, dst;
13329
13330 FETCH_WORD(res);
13331 flag_C = 0;
13332 flag_V = 0;
13333 flag_NotZ = res;
13334 flag_N = res >> 8;
13335 adr = AREG((Opcode >> 9) & 7) - 2;
13336 AREG((Opcode >> 9) & 7) = adr;
13337 PRE_IO
13338 WRITE_WORD_F(adr, res)
13339 POST_IO
13340RET(12)
13341}
13342
13343// MOVEW
13344OPCODE(0x317C)
13345{
13346 u32 adr, res;
13347 u32 src, dst;
13348
13349 FETCH_WORD(res);
13350 flag_C = 0;
13351 flag_V = 0;
13352 flag_NotZ = res;
13353 flag_N = res >> 8;
13354 FETCH_SWORD(adr);
13355 adr += AREG((Opcode >> 9) & 7);
13356 PRE_IO
13357 WRITE_WORD_F(adr, res)
13358 POST_IO
13359RET(16)
13360}
13361
13362// MOVEW
13363OPCODE(0x31BC)
13364{
13365 u32 adr, res;
13366 u32 src, dst;
13367
13368 FETCH_WORD(res);
13369 flag_C = 0;
13370 flag_V = 0;
13371 flag_NotZ = res;
13372 flag_N = res >> 8;
13373 adr = AREG((Opcode >> 9) & 7);
13374 DECODE_EXT_WORD
13375 PRE_IO
13376 WRITE_WORD_F(adr, res)
13377 POST_IO
13378RET(18)
13379}
13380
13381// MOVEW
13382OPCODE(0x31FC)
13383{
13384 u32 adr, res;
13385 u32 src, dst;
13386
13387 FETCH_WORD(res);
13388 flag_C = 0;
13389 flag_V = 0;
13390 flag_NotZ = res;
13391 flag_N = res >> 8;
13392 FETCH_SWORD(adr);
13393 PRE_IO
13394 WRITE_WORD_F(adr, res)
13395 POST_IO
13396RET(16)
13397}
13398
13399// MOVEW
13400OPCODE(0x33FC)
13401{
13402 u32 adr, res;
13403 u32 src, dst;
13404
13405 FETCH_WORD(res);
13406 flag_C = 0;
13407 flag_V = 0;
13408 flag_NotZ = res;
13409 flag_N = res >> 8;
13410 FETCH_LONG(adr);
13411 PRE_IO
13412 WRITE_WORD_F(adr, res)
13413 POST_IO
13414RET(20)
13415}
13416
13417// MOVEW
13418OPCODE(0x3EFC)
13419{
13420 u32 adr, res;
13421 u32 src, dst;
13422
13423 FETCH_WORD(res);
13424 flag_C = 0;
13425 flag_V = 0;
13426 flag_NotZ = res;
13427 flag_N = res >> 8;
13428 adr = AREG(7);
13429 AREG(7) += 2;
13430 PRE_IO
13431 WRITE_WORD_F(adr, res)
13432 POST_IO
13433RET(12)
13434}
13435
13436// MOVEW
13437OPCODE(0x3F3C)
13438{
13439 u32 adr, res;
13440 u32 src, dst;
13441
13442 FETCH_WORD(res);
13443 flag_C = 0;
13444 flag_V = 0;
13445 flag_NotZ = res;
13446 flag_N = res >> 8;
13447 adr = AREG(7) - 2;
13448 AREG(7) = adr;
13449 PRE_IO
13450 WRITE_WORD_F(adr, res)
13451 POST_IO
13452RET(12)
13453}
13454
13455// MOVEW
13456OPCODE(0x301F)
13457{
13458 u32 adr, res;
13459 u32 src, dst;
13460
13461 adr = AREG(7);
13462 AREG(7) += 2;
13463 PRE_IO
13464 READ_WORD_F(adr, res)
13465 flag_C = 0;
13466 flag_V = 0;
13467 flag_NotZ = res;
13468 flag_N = res >> 8;
13469 DREGu16((Opcode >> 9) & 7) = res;
13470 POST_IO
13471RET(8)
13472}
13473
13474// MOVEW
13475OPCODE(0x309F)
13476{
13477 u32 adr, res;
13478 u32 src, dst;
13479
13480 adr = AREG(7);
13481 AREG(7) += 2;
13482 PRE_IO
13483 READ_WORD_F(adr, res)
13484 flag_C = 0;
13485 flag_V = 0;
13486 flag_NotZ = res;
13487 flag_N = res >> 8;
13488 adr = AREG((Opcode >> 9) & 7);
13489 WRITE_WORD_F(adr, res)
13490 POST_IO
13491RET(12)
13492}
13493
13494// MOVEW
13495OPCODE(0x30DF)
13496{
13497 u32 adr, res;
13498 u32 src, dst;
13499
13500 adr = AREG(7);
13501 AREG(7) += 2;
13502 PRE_IO
13503 READ_WORD_F(adr, res)
13504 flag_C = 0;
13505 flag_V = 0;
13506 flag_NotZ = res;
13507 flag_N = res >> 8;
13508 adr = AREG((Opcode >> 9) & 7);
13509 AREG((Opcode >> 9) & 7) += 2;
13510 WRITE_WORD_F(adr, res)
13511 POST_IO
13512RET(12)
13513}
13514
13515// MOVEW
13516OPCODE(0x311F)
13517{
13518 u32 adr, res;
13519 u32 src, dst;
13520
13521 adr = AREG(7);
13522 AREG(7) += 2;
13523 PRE_IO
13524 READ_WORD_F(adr, res)
13525 flag_C = 0;
13526 flag_V = 0;
13527 flag_NotZ = res;
13528 flag_N = res >> 8;
13529 adr = AREG((Opcode >> 9) & 7) - 2;
13530 AREG((Opcode >> 9) & 7) = adr;
13531 WRITE_WORD_F(adr, res)
13532 POST_IO
13533RET(12)
13534}
13535
13536// MOVEW
13537OPCODE(0x315F)
13538{
13539 u32 adr, res;
13540 u32 src, dst;
13541
13542 adr = AREG(7);
13543 AREG(7) += 2;
13544 PRE_IO
13545 READ_WORD_F(adr, res)
13546 flag_C = 0;
13547 flag_V = 0;
13548 flag_NotZ = res;
13549 flag_N = res >> 8;
13550 FETCH_SWORD(adr);
13551 adr += AREG((Opcode >> 9) & 7);
13552 WRITE_WORD_F(adr, res)
13553 POST_IO
13554RET(16)
13555}
13556
13557// MOVEW
13558OPCODE(0x319F)
13559{
13560 u32 adr, res;
13561 u32 src, dst;
13562
13563 adr = AREG(7);
13564 AREG(7) += 2;
13565 PRE_IO
13566 READ_WORD_F(adr, res)
13567 flag_C = 0;
13568 flag_V = 0;
13569 flag_NotZ = res;
13570 flag_N = res >> 8;
13571 adr = AREG((Opcode >> 9) & 7);
13572 DECODE_EXT_WORD
13573 WRITE_WORD_F(adr, res)
13574 POST_IO
13575RET(18)
13576}
13577
13578// MOVEW
13579OPCODE(0x31DF)
13580{
13581 u32 adr, res;
13582 u32 src, dst;
13583
13584 adr = AREG(7);
13585 AREG(7) += 2;
13586 PRE_IO
13587 READ_WORD_F(adr, res)
13588 flag_C = 0;
13589 flag_V = 0;
13590 flag_NotZ = res;
13591 flag_N = res >> 8;
13592 FETCH_SWORD(adr);
13593 WRITE_WORD_F(adr, res)
13594 POST_IO
13595RET(16)
13596}
13597
13598// MOVEW
13599OPCODE(0x33DF)
13600{
13601 u32 adr, res;
13602 u32 src, dst;
13603
13604 adr = AREG(7);
13605 AREG(7) += 2;
13606 PRE_IO
13607 READ_WORD_F(adr, res)
13608 flag_C = 0;
13609 flag_V = 0;
13610 flag_NotZ = res;
13611 flag_N = res >> 8;
13612 FETCH_LONG(adr);
13613 WRITE_WORD_F(adr, res)
13614 POST_IO
13615RET(20)
13616}
13617
13618// MOVEW
13619OPCODE(0x3EDF)
13620{
13621 u32 adr, res;
13622 u32 src, dst;
13623
13624 adr = AREG(7);
13625 AREG(7) += 2;
13626 PRE_IO
13627 READ_WORD_F(adr, res)
13628 flag_C = 0;
13629 flag_V = 0;
13630 flag_NotZ = res;
13631 flag_N = res >> 8;
13632 adr = AREG(7);
13633 AREG(7) += 2;
13634 WRITE_WORD_F(adr, res)
13635 POST_IO
13636RET(12)
13637}
13638
13639// MOVEW
13640OPCODE(0x3F1F)
13641{
13642 u32 adr, res;
13643 u32 src, dst;
13644
13645 adr = AREG(7);
13646 AREG(7) += 2;
13647 PRE_IO
13648 READ_WORD_F(adr, res)
13649 flag_C = 0;
13650 flag_V = 0;
13651 flag_NotZ = res;
13652 flag_N = res >> 8;
13653 adr = AREG(7) - 2;
13654 AREG(7) = adr;
13655 WRITE_WORD_F(adr, res)
13656 POST_IO
13657RET(12)
13658}
13659
13660// MOVEW
13661OPCODE(0x3027)
13662{
13663 u32 adr, res;
13664 u32 src, dst;
13665
13666 adr = AREG(7) - 2;
13667 AREG(7) = adr;
13668 PRE_IO
13669 READ_WORD_F(adr, res)
13670 flag_C = 0;
13671 flag_V = 0;
13672 flag_NotZ = res;
13673 flag_N = res >> 8;
13674 DREGu16((Opcode >> 9) & 7) = res;
13675 POST_IO
13676RET(10)
13677}
13678
13679// MOVEW
13680OPCODE(0x30A7)
13681{
13682 u32 adr, res;
13683 u32 src, dst;
13684
13685 adr = AREG(7) - 2;
13686 AREG(7) = adr;
13687 PRE_IO
13688 READ_WORD_F(adr, res)
13689 flag_C = 0;
13690 flag_V = 0;
13691 flag_NotZ = res;
13692 flag_N = res >> 8;
13693 adr = AREG((Opcode >> 9) & 7);
13694 WRITE_WORD_F(adr, res)
13695 POST_IO
13696RET(14)
13697}
13698
13699// MOVEW
13700OPCODE(0x30E7)
13701{
13702 u32 adr, res;
13703 u32 src, dst;
13704
13705 adr = AREG(7) - 2;
13706 AREG(7) = adr;
13707 PRE_IO
13708 READ_WORD_F(adr, res)
13709 flag_C = 0;
13710 flag_V = 0;
13711 flag_NotZ = res;
13712 flag_N = res >> 8;
13713 adr = AREG((Opcode >> 9) & 7);
13714 AREG((Opcode >> 9) & 7) += 2;
13715 WRITE_WORD_F(adr, res)
13716 POST_IO
13717RET(14)
13718}
13719
13720// MOVEW
13721OPCODE(0x3127)
13722{
13723 u32 adr, res;
13724 u32 src, dst;
13725
13726 adr = AREG(7) - 2;
13727 AREG(7) = adr;
13728 PRE_IO
13729 READ_WORD_F(adr, res)
13730 flag_C = 0;
13731 flag_V = 0;
13732 flag_NotZ = res;
13733 flag_N = res >> 8;
13734 adr = AREG((Opcode >> 9) & 7) - 2;
13735 AREG((Opcode >> 9) & 7) = adr;
13736 WRITE_WORD_F(adr, res)
13737 POST_IO
13738RET(14)
13739}
13740
13741// MOVEW
13742OPCODE(0x3167)
13743{
13744 u32 adr, res;
13745 u32 src, dst;
13746
13747 adr = AREG(7) - 2;
13748 AREG(7) = adr;
13749 PRE_IO
13750 READ_WORD_F(adr, res)
13751 flag_C = 0;
13752 flag_V = 0;
13753 flag_NotZ = res;
13754 flag_N = res >> 8;
13755 FETCH_SWORD(adr);
13756 adr += AREG((Opcode >> 9) & 7);
13757 WRITE_WORD_F(adr, res)
13758 POST_IO
13759RET(18)
13760}
13761
13762// MOVEW
13763OPCODE(0x31A7)
13764{
13765 u32 adr, res;
13766 u32 src, dst;
13767
13768 adr = AREG(7) - 2;
13769 AREG(7) = adr;
13770 PRE_IO
13771 READ_WORD_F(adr, res)
13772 flag_C = 0;
13773 flag_V = 0;
13774 flag_NotZ = res;
13775 flag_N = res >> 8;
13776 adr = AREG((Opcode >> 9) & 7);
13777 DECODE_EXT_WORD
13778 WRITE_WORD_F(adr, res)
13779 POST_IO
13780RET(20)
13781}
13782
13783// MOVEW
13784OPCODE(0x31E7)
13785{
13786 u32 adr, res;
13787 u32 src, dst;
13788
13789 adr = AREG(7) - 2;
13790 AREG(7) = adr;
13791 PRE_IO
13792 READ_WORD_F(adr, res)
13793 flag_C = 0;
13794 flag_V = 0;
13795 flag_NotZ = res;
13796 flag_N = res >> 8;
13797 FETCH_SWORD(adr);
13798 WRITE_WORD_F(adr, res)
13799 POST_IO
13800RET(18)
13801}
13802
13803// MOVEW
13804OPCODE(0x33E7)
13805{
13806 u32 adr, res;
13807 u32 src, dst;
13808
13809 adr = AREG(7) - 2;
13810 AREG(7) = adr;
13811 PRE_IO
13812 READ_WORD_F(adr, res)
13813 flag_C = 0;
13814 flag_V = 0;
13815 flag_NotZ = res;
13816 flag_N = res >> 8;
13817 FETCH_LONG(adr);
13818 WRITE_WORD_F(adr, res)
13819 POST_IO
13820RET(22)
13821}
13822
13823// MOVEW
13824OPCODE(0x3EE7)
13825{
13826 u32 adr, res;
13827 u32 src, dst;
13828
13829 adr = AREG(7) - 2;
13830 AREG(7) = adr;
13831 PRE_IO
13832 READ_WORD_F(adr, res)
13833 flag_C = 0;
13834 flag_V = 0;
13835 flag_NotZ = res;
13836 flag_N = res >> 8;
13837 adr = AREG(7);
13838 AREG(7) += 2;
13839 WRITE_WORD_F(adr, res)
13840 POST_IO
13841RET(14)
13842}
13843
13844// MOVEW
13845OPCODE(0x3F27)
13846{
13847 u32 adr, res;
13848 u32 src, dst;
13849
13850 adr = AREG(7) - 2;
13851 AREG(7) = adr;
13852 PRE_IO
13853 READ_WORD_F(adr, res)
13854 flag_C = 0;
13855 flag_V = 0;
13856 flag_NotZ = res;
13857 flag_N = res >> 8;
13858 adr = AREG(7) - 2;
13859 AREG(7) = adr;
13860 WRITE_WORD_F(adr, res)
13861 POST_IO
13862RET(14)
13863}
13864
13865// MOVEAW
13866OPCODE(0x3040)
13867{
13868 u32 adr, res;
13869 u32 src, dst;
13870
13871 res = (s32)DREGs16((Opcode >> 0) & 7);
13872 AREG((Opcode >> 9) & 7) = res;
13873RET(4)
13874}
13875
13876// MOVEAW
13877OPCODE(0x3048)
13878{
13879 u32 adr, res;
13880 u32 src, dst;
13881
13882 res = (s32)AREGs16((Opcode >> 0) & 7);
13883 AREG((Opcode >> 9) & 7) = res;
13884RET(4)
13885}
13886
13887// MOVEAW
13888OPCODE(0x3050)
13889{
13890 u32 adr, res;
13891 u32 src, dst;
13892
13893 adr = AREG((Opcode >> 0) & 7);
13894 PRE_IO
13895 READSX_WORD_F(adr, res)
13896 AREG((Opcode >> 9) & 7) = res;
13897 POST_IO
13898RET(8)
13899}
13900
13901// MOVEAW
13902OPCODE(0x3058)
13903{
13904 u32 adr, res;
13905 u32 src, dst;
13906
13907 adr = AREG((Opcode >> 0) & 7);
13908 AREG((Opcode >> 0) & 7) += 2;
13909 PRE_IO
13910 READSX_WORD_F(adr, res)
13911 AREG((Opcode >> 9) & 7) = res;
13912 POST_IO
13913RET(8)
13914}
13915
13916// MOVEAW
13917OPCODE(0x3060)
13918{
13919 u32 adr, res;
13920 u32 src, dst;
13921
13922 adr = AREG((Opcode >> 0) & 7) - 2;
13923 AREG((Opcode >> 0) & 7) = adr;
13924 PRE_IO
13925 READSX_WORD_F(adr, res)
13926 AREG((Opcode >> 9) & 7) = res;
13927 POST_IO
13928RET(10)
13929}
13930
13931// MOVEAW
13932OPCODE(0x3068)
13933{
13934 u32 adr, res;
13935 u32 src, dst;
13936
13937 FETCH_SWORD(adr);
13938 adr += AREG((Opcode >> 0) & 7);
13939 PRE_IO
13940 READSX_WORD_F(adr, res)
13941 AREG((Opcode >> 9) & 7) = res;
13942 POST_IO
13943RET(12)
13944}
13945
13946// MOVEAW
13947OPCODE(0x3070)
13948{
13949 u32 adr, res;
13950 u32 src, dst;
13951
13952 adr = AREG((Opcode >> 0) & 7);
13953 DECODE_EXT_WORD
13954 PRE_IO
13955 READSX_WORD_F(adr, res)
13956 AREG((Opcode >> 9) & 7) = res;
13957 POST_IO
13958RET(14)
13959}
13960
13961// MOVEAW
13962OPCODE(0x3078)
13963{
13964 u32 adr, res;
13965 u32 src, dst;
13966
13967 FETCH_SWORD(adr);
13968 PRE_IO
13969 READSX_WORD_F(adr, res)
13970 AREG((Opcode >> 9) & 7) = res;
13971 POST_IO
13972RET(12)
13973}
13974
13975// MOVEAW
13976OPCODE(0x3079)
13977{
13978 u32 adr, res;
13979 u32 src, dst;
13980
13981 FETCH_LONG(adr);
13982 PRE_IO
13983 READSX_WORD_F(adr, res)
13984 AREG((Opcode >> 9) & 7) = res;
13985 POST_IO
13986RET(16)
13987}
13988
13989// MOVEAW
13990OPCODE(0x307A)
13991{
13992 u32 adr, res;
13993 u32 src, dst;
13994
be26eb23 13995 adr = GET_SWORD + GET_PC;
70357ce5 13996 PC++;
13997 PRE_IO
13998 READSX_WORD_F(adr, res)
13999 AREG((Opcode >> 9) & 7) = res;
14000 POST_IO
14001RET(12)
14002}
14003
14004// MOVEAW
14005OPCODE(0x307B)
14006{
14007 u32 adr, res;
14008 u32 src, dst;
14009
be26eb23 14010 adr = GET_PC;
70357ce5 14011 DECODE_EXT_WORD
14012 PRE_IO
14013 READSX_WORD_F(adr, res)
14014 AREG((Opcode >> 9) & 7) = res;
14015 POST_IO
14016RET(14)
14017}
14018
14019// MOVEAW
14020OPCODE(0x307C)
14021{
14022 u32 adr, res;
14023 u32 src, dst;
14024
14025 FETCH_SWORD(res);
14026 AREG((Opcode >> 9) & 7) = res;
14027RET(8)
14028}
14029
14030// MOVEAW
14031OPCODE(0x305F)
14032{
14033 u32 adr, res;
14034 u32 src, dst;
14035
14036 adr = AREG(7);
14037 AREG(7) += 2;
14038 PRE_IO
14039 READSX_WORD_F(adr, res)
14040 AREG((Opcode >> 9) & 7) = res;
14041 POST_IO
14042RET(8)
14043}
14044
14045// MOVEAW
14046OPCODE(0x3067)
14047{
14048 u32 adr, res;
14049 u32 src, dst;
14050
14051 adr = AREG(7) - 2;
14052 AREG(7) = adr;
14053 PRE_IO
14054 READSX_WORD_F(adr, res)
14055 AREG((Opcode >> 9) & 7) = res;
14056 POST_IO
14057RET(10)
14058}
14059
14060// NEGX
14061OPCODE(0x4000)
14062{
14063 u32 adr, res;
14064 u32 src, dst;
14065
14066 src = DREGu8((Opcode >> 0) & 7);
14067 res = -src - ((flag_X >> 8) & 1);
14068 flag_V = res & src;
14069 flag_N = flag_X = flag_C = res;
14070 flag_NotZ |= res & 0xFF;
14071 DREGu8((Opcode >> 0) & 7) = res;
14072RET(4)
14073}
14074
14075// NEGX
14076OPCODE(0x4010)
14077{
14078 u32 adr, res;
14079 u32 src, dst;
14080
14081 adr = AREG((Opcode >> 0) & 7);
14082 PRE_IO
14083 READ_BYTE_F(adr, src)
14084 res = -src - ((flag_X >> 8) & 1);
14085 flag_V = res & src;
14086 flag_N = flag_X = flag_C = res;
14087 flag_NotZ |= res & 0xFF;
14088 WRITE_BYTE_F(adr, res)
14089 POST_IO
14090RET(12)
14091}
14092
14093// NEGX
14094OPCODE(0x4018)
14095{
14096 u32 adr, res;
14097 u32 src, dst;
14098
14099 adr = AREG((Opcode >> 0) & 7);
14100 AREG((Opcode >> 0) & 7) += 1;
14101 PRE_IO
14102 READ_BYTE_F(adr, src)
14103 res = -src - ((flag_X >> 8) & 1);
14104 flag_V = res & src;
14105 flag_N = flag_X = flag_C = res;
14106 flag_NotZ |= res & 0xFF;
14107 WRITE_BYTE_F(adr, res)
14108 POST_IO
14109RET(12)
14110}
14111
14112// NEGX
14113OPCODE(0x4020)
14114{
14115 u32 adr, res;
14116 u32 src, dst;
14117
14118 adr = AREG((Opcode >> 0) & 7) - 1;
14119 AREG((Opcode >> 0) & 7) = adr;
14120 PRE_IO
14121 READ_BYTE_F(adr, src)
14122 res = -src - ((flag_X >> 8) & 1);
14123 flag_V = res & src;
14124 flag_N = flag_X = flag_C = res;
14125 flag_NotZ |= res & 0xFF;
14126 WRITE_BYTE_F(adr, res)
14127 POST_IO
14128RET(14)
14129}
14130
14131// NEGX
14132OPCODE(0x4028)
14133{
14134 u32 adr, res;
14135 u32 src, dst;
14136
14137 FETCH_SWORD(adr);
14138 adr += AREG((Opcode >> 0) & 7);
14139 PRE_IO
14140 READ_BYTE_F(adr, src)
14141 res = -src - ((flag_X >> 8) & 1);
14142 flag_V = res & src;
14143 flag_N = flag_X = flag_C = res;
14144 flag_NotZ |= res & 0xFF;
14145 WRITE_BYTE_F(adr, res)
14146 POST_IO
14147RET(16)
14148}
14149
14150// NEGX
14151OPCODE(0x4030)
14152{
14153 u32 adr, res;
14154 u32 src, dst;
14155
14156 adr = AREG((Opcode >> 0) & 7);
14157 DECODE_EXT_WORD
14158 PRE_IO
14159 READ_BYTE_F(adr, src)
14160 res = -src - ((flag_X >> 8) & 1);
14161 flag_V = res & src;
14162 flag_N = flag_X = flag_C = res;
14163 flag_NotZ |= res & 0xFF;
14164 WRITE_BYTE_F(adr, res)
14165 POST_IO
14166RET(18)
14167}
14168
14169// NEGX
14170OPCODE(0x4038)
14171{
14172 u32 adr, res;
14173 u32 src, dst;
14174
14175 FETCH_SWORD(adr);
14176 PRE_IO
14177 READ_BYTE_F(adr, src)
14178 res = -src - ((flag_X >> 8) & 1);
14179 flag_V = res & src;
14180 flag_N = flag_X = flag_C = res;
14181 flag_NotZ |= res & 0xFF;
14182 WRITE_BYTE_F(adr, res)
14183 POST_IO
14184RET(16)
14185}
14186
14187// NEGX
14188OPCODE(0x4039)
14189{
14190 u32 adr, res;
14191 u32 src, dst;
14192
14193 FETCH_LONG(adr);
14194 PRE_IO
14195 READ_BYTE_F(adr, src)
14196 res = -src - ((flag_X >> 8) & 1);
14197 flag_V = res & src;
14198 flag_N = flag_X = flag_C = res;
14199 flag_NotZ |= res & 0xFF;
14200 WRITE_BYTE_F(adr, res)
14201 POST_IO
14202RET(20)
14203}
14204
14205// NEGX
14206OPCODE(0x401F)
14207{
14208 u32 adr, res;
14209 u32 src, dst;
14210
14211 adr = AREG(7);
14212 AREG(7) += 2;
14213 PRE_IO
14214 READ_BYTE_F(adr, src)
14215 res = -src - ((flag_X >> 8) & 1);
14216 flag_V = res & src;
14217 flag_N = flag_X = flag_C = res;
14218 flag_NotZ |= res & 0xFF;
14219 WRITE_BYTE_F(adr, res)
14220 POST_IO
14221RET(12)
14222}
14223
14224// NEGX
14225OPCODE(0x4027)
14226{
14227 u32 adr, res;
14228 u32 src, dst;
14229
14230 adr = AREG(7) - 2;
14231 AREG(7) = adr;
14232 PRE_IO
14233 READ_BYTE_F(adr, src)
14234 res = -src - ((flag_X >> 8) & 1);
14235 flag_V = res & src;
14236 flag_N = flag_X = flag_C = res;
14237 flag_NotZ |= res & 0xFF;
14238 WRITE_BYTE_F(adr, res)
14239 POST_IO
14240RET(14)
14241}
14242
14243// NEGX
14244OPCODE(0x4040)
14245{
14246 u32 adr, res;
14247 u32 src, dst;
14248
14249 src = DREGu16((Opcode >> 0) & 7);
14250 res = -src - ((flag_X >> 8) & 1);
14251 flag_V = (res & src) >> 8;
14252 flag_N = flag_X = flag_C = res >> 8;
14253 flag_NotZ |= res & 0xFFFF;
14254 DREGu16((Opcode >> 0) & 7) = res;
14255RET(4)
14256}
14257
14258// NEGX
14259OPCODE(0x4050)
14260{
14261 u32 adr, res;
14262 u32 src, dst;
14263
14264 adr = AREG((Opcode >> 0) & 7);
14265 PRE_IO
14266 READ_WORD_F(adr, src)
14267 res = -src - ((flag_X >> 8) & 1);
14268 flag_V = (res & src) >> 8;
14269 flag_N = flag_X = flag_C = res >> 8;
14270 flag_NotZ |= res & 0xFFFF;
14271 WRITE_WORD_F(adr, res)
14272 POST_IO
14273RET(12)
14274}
14275
14276// NEGX
14277OPCODE(0x4058)
14278{
14279 u32 adr, res;
14280 u32 src, dst;
14281
14282 adr = AREG((Opcode >> 0) & 7);
14283 AREG((Opcode >> 0) & 7) += 2;
14284 PRE_IO
14285 READ_WORD_F(adr, src)
14286 res = -src - ((flag_X >> 8) & 1);
14287 flag_V = (res & src) >> 8;
14288 flag_N = flag_X = flag_C = res >> 8;
14289 flag_NotZ |= res & 0xFFFF;
14290 WRITE_WORD_F(adr, res)
14291 POST_IO
14292RET(12)
14293}
14294
14295// NEGX
14296OPCODE(0x4060)
14297{
14298 u32 adr, res;
14299 u32 src, dst;
14300
14301 adr = AREG((Opcode >> 0) & 7) - 2;
14302 AREG((Opcode >> 0) & 7) = adr;
14303 PRE_IO
14304 READ_WORD_F(adr, src)
14305 res = -src - ((flag_X >> 8) & 1);
14306 flag_V = (res & src) >> 8;
14307 flag_N = flag_X = flag_C = res >> 8;
14308 flag_NotZ |= res & 0xFFFF;
14309 WRITE_WORD_F(adr, res)
14310 POST_IO
14311RET(14)
14312}
14313
14314// NEGX
14315OPCODE(0x4068)
14316{
14317 u32 adr, res;
14318 u32 src, dst;
14319
14320 FETCH_SWORD(adr);
14321 adr += AREG((Opcode >> 0) & 7);
14322 PRE_IO
14323 READ_WORD_F(adr, src)
14324 res = -src - ((flag_X >> 8) & 1);
14325 flag_V = (res & src) >> 8;
14326 flag_N = flag_X = flag_C = res >> 8;
14327 flag_NotZ |= res & 0xFFFF;
14328 WRITE_WORD_F(adr, res)
14329 POST_IO
14330RET(16)
14331}
14332
14333// NEGX
14334OPCODE(0x4070)
14335{
14336 u32 adr, res;
14337 u32 src, dst;
14338
14339 adr = AREG((Opcode >> 0) & 7);
14340 DECODE_EXT_WORD
14341 PRE_IO
14342 READ_WORD_F(adr, src)
14343 res = -src - ((flag_X >> 8) & 1);
14344 flag_V = (res & src) >> 8;
14345 flag_N = flag_X = flag_C = res >> 8;
14346 flag_NotZ |= res & 0xFFFF;
14347 WRITE_WORD_F(adr, res)
14348 POST_IO
14349RET(18)
14350}
14351
14352// NEGX
14353OPCODE(0x4078)
14354{
14355 u32 adr, res;
14356 u32 src, dst;
14357
14358 FETCH_SWORD(adr);
14359 PRE_IO
14360 READ_WORD_F(adr, src)
14361 res = -src - ((flag_X >> 8) & 1);
14362 flag_V = (res & src) >> 8;
14363 flag_N = flag_X = flag_C = res >> 8;
14364 flag_NotZ |= res & 0xFFFF;
14365 WRITE_WORD_F(adr, res)
14366 POST_IO
14367RET(16)
14368}
14369
14370// NEGX
14371OPCODE(0x4079)
14372{
14373 u32 adr, res;
14374 u32 src, dst;
14375
14376 FETCH_LONG(adr);
14377 PRE_IO
14378 READ_WORD_F(adr, src)
14379 res = -src - ((flag_X >> 8) & 1);
14380 flag_V = (res & src) >> 8;
14381 flag_N = flag_X = flag_C = res >> 8;
14382 flag_NotZ |= res & 0xFFFF;
14383 WRITE_WORD_F(adr, res)
14384 POST_IO
14385RET(20)
14386}
14387
14388// NEGX
14389OPCODE(0x405F)
14390{
14391 u32 adr, res;
14392 u32 src, dst;
14393
14394 adr = AREG(7);
14395 AREG(7) += 2;
14396 PRE_IO
14397 READ_WORD_F(adr, src)
14398 res = -src - ((flag_X >> 8) & 1);
14399 flag_V = (res & src) >> 8;
14400 flag_N = flag_X = flag_C = res >> 8;
14401 flag_NotZ |= res & 0xFFFF;
14402 WRITE_WORD_F(adr, res)
14403 POST_IO
14404RET(12)
14405}
14406
14407// NEGX
14408OPCODE(0x4067)
14409{
14410 u32 adr, res;
14411 u32 src, dst;
14412
14413 adr = AREG(7) - 2;
14414 AREG(7) = adr;
14415 PRE_IO
14416 READ_WORD_F(adr, src)
14417 res = -src - ((flag_X >> 8) & 1);
14418 flag_V = (res & src) >> 8;
14419 flag_N = flag_X = flag_C = res >> 8;
14420 flag_NotZ |= res & 0xFFFF;
14421 WRITE_WORD_F(adr, res)
14422 POST_IO
14423RET(14)
14424}
14425
14426// NEGX
14427OPCODE(0x4080)
14428{
14429 u32 adr, res;
14430 u32 src, dst;
14431
14432 src = DREGu32((Opcode >> 0) & 7);
14433 res = -src - ((flag_X >> 8) & 1);
14434 flag_NotZ |= res;
14435 flag_V = (res & src) >> 24;
14436flag_X = flag_C = (res?1:0)<<8;
14437// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14438 flag_N = res >> 24;
14439 DREGu32((Opcode >> 0) & 7) = res;
14440RET(6)
14441}
14442
14443// NEGX
14444OPCODE(0x4090)
14445{
14446 u32 adr, res;
14447 u32 src, dst;
14448
14449 adr = AREG((Opcode >> 0) & 7);
14450 PRE_IO
14451 READ_LONG_F(adr, src)
14452 res = -src - ((flag_X >> 8) & 1);
14453 flag_NotZ |= res;
14454 flag_V = (res & src) >> 24;
14455flag_X = flag_C = (res?1:0)<<8;
14456// flag_X = flag_C = ((src & res & 1) | (src >> 1) | (res >> 1)) >> 23;
14457 flag_N = res >> 24;
14458 WRITE_LONG_F(adr, res)
14459 POST_IO
14460RET(20)
14461}
14462
14463// NEGX
14464OPCODE(0x4098)
14465{
14466 u32 adr, res;
14467 u32 src, dst;
14468
14469 adr = AREG((Opcode >> 0) & 7);
14470 AREG((Opcode >> 0) & 7) += 4;
14471 PRE_IO
14472 READ_LONG_F(adr, src)
14473 res = -src - ((flag_X >> 8) & 1);
14474 flag_NotZ |= res;
14475 flag_V = (res & src) >> 24;
14476flag_X = flag_C = (res?1:0)<<8;
14477// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14478 flag_N = res >> 24;
14479 WRITE_LONG_F(adr, res)
14480 POST_IO
14481RET(20)
14482}
14483
14484// NEGX
14485OPCODE(0x40A0)
14486{
14487 u32 adr, res;
14488 u32 src, dst;
14489
14490 adr = AREG((Opcode >> 0) & 7) - 4;
14491 AREG((Opcode >> 0) & 7) = adr;
14492 PRE_IO
14493 READ_LONG_F(adr, src)
14494 res = -src - ((flag_X >> 8) & 1);
14495 flag_NotZ |= res;
14496 flag_V = (res & src) >> 24;
14497flag_X = flag_C = (res?1:0)<<8;
14498// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14499 flag_N = res >> 24;
14500 WRITE_LONG_F(adr, res)
14501 POST_IO
14502RET(22)
14503}
14504
14505// NEGX
14506OPCODE(0x40A8)
14507{
14508 u32 adr, res;
14509 u32 src, dst;
14510
14511 FETCH_SWORD(adr);
14512 adr += AREG((Opcode >> 0) & 7);
14513 PRE_IO
14514 READ_LONG_F(adr, src)
14515 res = -src - ((flag_X >> 8) & 1);
14516 flag_NotZ |= res;
14517 flag_V = (res & src) >> 24;
14518flag_X = flag_C = (res?1:0)<<8;
14519// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14520 flag_N = res >> 24;
14521 WRITE_LONG_F(adr, res)
14522 POST_IO
14523RET(24)
14524}
14525
14526// NEGX
14527OPCODE(0x40B0)
14528{
14529 u32 adr, res;
14530 u32 src, dst;
14531
14532 adr = AREG((Opcode >> 0) & 7);
14533 DECODE_EXT_WORD
14534 PRE_IO
14535 READ_LONG_F(adr, src)
14536 res = -src - ((flag_X >> 8) & 1);
14537 flag_NotZ |= res;
14538 flag_V = (res & src) >> 24;
14539flag_X = flag_C = (res?1:0)<<8;
14540// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14541 flag_N = res >> 24;
14542 WRITE_LONG_F(adr, res)
14543 POST_IO
14544RET(26)
14545}
14546
14547// NEGX
14548OPCODE(0x40B8)
14549{
14550 u32 adr, res;
14551 u32 src, dst;
14552
14553 FETCH_SWORD(adr);
14554 PRE_IO
14555 READ_LONG_F(adr, src)
14556 res = -src - ((flag_X >> 8) & 1);
14557 flag_NotZ |= res;
14558 flag_V = (res & src) >> 24;
14559flag_X = flag_C = (res?1:0)<<8;
14560// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14561 flag_N = res >> 24;
14562 WRITE_LONG_F(adr, res)
14563 POST_IO
14564RET(24)
14565}
14566
14567// NEGX
14568OPCODE(0x40B9)
14569{
14570 u32 adr, res;
14571 u32 src, dst;
14572
14573 FETCH_LONG(adr);
14574 PRE_IO
14575 READ_LONG_F(adr, src)
14576 res = -src - ((flag_X >> 8) & 1);
14577 flag_NotZ |= res;
14578 flag_V = (res & src) >> 24;
14579flag_X = flag_C = (res?1:0)<<8;
14580// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14581 flag_N = res >> 24;
14582 WRITE_LONG_F(adr, res)
14583 POST_IO
14584RET(28)
14585}
14586
14587// NEGX
14588OPCODE(0x409F)
14589{
14590 u32 adr, res;
14591 u32 src, dst;
14592
14593 adr = AREG(7);
14594 AREG(7) += 4;
14595 PRE_IO
14596 READ_LONG_F(adr, src)
14597 res = -src - ((flag_X >> 8) & 1);
14598 flag_NotZ |= res;
14599 flag_V = (res & src) >> 24;
14600flag_X = flag_C = (res?1:0)<<8;
14601// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14602 flag_N = res >> 24;
14603 WRITE_LONG_F(adr, res)
14604 POST_IO
14605RET(20)
14606}
14607
14608// NEGX
14609OPCODE(0x40A7)
14610{
14611 u32 adr, res;
14612 u32 src, dst;
14613
14614 adr = AREG(7) - 4;
14615 AREG(7) = adr;
14616 PRE_IO
14617 READ_LONG_F(adr, src)
14618 res = -src - ((flag_X >> 8) & 1);
14619 flag_NotZ |= res;
14620 flag_V = (res & src) >> 24;
14621flag_X = flag_C = (res?1:0)<<8;
14622// flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
14623 flag_N = res >> 24;
14624 WRITE_LONG_F(adr, res)
14625 POST_IO
14626RET(22)
14627}
14628
14629// CLR
14630OPCODE(0x4200)
14631{
14632 u32 adr, res;
14633 u32 src, dst;
14634
14635 res = 0;
14636 flag_N = flag_NotZ = flag_V = flag_C = 0;
14637 DREGu8((Opcode >> 0) & 7) = res;
14638RET(4)
14639}
14640
14641// CLR
14642OPCODE(0x4210)
14643{
14644 u32 adr, res;
14645 u32 src, dst;
14646
14647 adr = AREG((Opcode >> 0) & 7);
14648 res = 0;
14649 flag_N = flag_NotZ = flag_V = flag_C = 0;
14650 PRE_IO
14651 WRITE_BYTE_F(adr, res)
14652 POST_IO
14653RET(12)
14654}
14655
14656// CLR
14657OPCODE(0x4218)
14658{
14659 u32 adr, res;
14660 u32 src, dst;
14661
14662 adr = AREG((Opcode >> 0) & 7);
14663 AREG((Opcode >> 0) & 7) += 1;
14664 res = 0;
14665 flag_N = flag_NotZ = flag_V = flag_C = 0;
14666 PRE_IO
14667 WRITE_BYTE_F(adr, res)
14668 POST_IO
14669RET(12)
14670}
14671
14672// CLR
14673OPCODE(0x4220)
14674{
14675 u32 adr, res;
14676 u32 src, dst;
14677
14678 adr = AREG((Opcode >> 0) & 7) - 1;
14679 AREG((Opcode >> 0) & 7) = adr;
14680 res = 0;
14681 flag_N = flag_NotZ = flag_V = flag_C = 0;
14682 PRE_IO
14683 WRITE_BYTE_F(adr, res)
14684 POST_IO
14685RET(14)
14686}
14687
14688// CLR
14689OPCODE(0x4228)
14690{
14691 u32 adr, res;
14692 u32 src, dst;
14693
14694 FETCH_SWORD(adr);
14695 adr += AREG((Opcode >> 0) & 7);
14696 res = 0;
14697 flag_N = flag_NotZ = flag_V = flag_C = 0;
14698 PRE_IO
14699 WRITE_BYTE_F(adr, res)
14700 POST_IO
14701RET(16)
14702}
14703
14704// CLR
14705OPCODE(0x4230)
14706{
14707 u32 adr, res;
14708 u32 src, dst;
14709
14710 adr = AREG((Opcode >> 0) & 7);
14711 DECODE_EXT_WORD
14712 res = 0;
14713 flag_N = flag_NotZ = flag_V = flag_C = 0;
14714 PRE_IO
14715 WRITE_BYTE_F(adr, res)
14716 POST_IO
14717RET(18)
14718}
14719
14720// CLR
14721OPCODE(0x4238)
14722{
14723 u32 adr, res;
14724 u32 src, dst;
14725
14726 FETCH_SWORD(adr);
14727 res = 0;
14728 flag_N = flag_NotZ = flag_V = flag_C = 0;
14729 PRE_IO
14730 WRITE_BYTE_F(adr, res)
14731 POST_IO
14732RET(16)
14733}
14734
14735// CLR
14736OPCODE(0x4239)
14737{
14738 u32 adr, res;
14739 u32 src, dst;
14740
14741 FETCH_LONG(adr);
14742 res = 0;
14743 flag_N = flag_NotZ = flag_V = flag_C = 0;
14744 PRE_IO
14745 WRITE_BYTE_F(adr, res)
14746 POST_IO
14747RET(20)
14748}
14749
14750// CLR
14751OPCODE(0x421F)
14752{
14753 u32 adr, res;
14754 u32 src, dst;
14755
14756 adr = AREG(7);
14757 AREG(7) += 2;
14758 res = 0;
14759 flag_N = flag_NotZ = flag_V = flag_C = 0;
14760 PRE_IO
14761 WRITE_BYTE_F(adr, res)
14762 POST_IO
14763RET(12)
14764}
14765
14766// CLR
14767OPCODE(0x4227)
14768{
14769 u32 adr, res;
14770 u32 src, dst;
14771
14772 adr = AREG(7) - 2;
14773 AREG(7) = adr;
14774 res = 0;
14775 flag_N = flag_NotZ = flag_V = flag_C = 0;
14776 PRE_IO
14777 WRITE_BYTE_F(adr, res)
14778 POST_IO
14779RET(14)
14780}
14781
14782// CLR
14783OPCODE(0x4240)
14784{
14785 u32 adr, res;
14786 u32 src, dst;
14787
14788 res = 0;
14789 flag_N = flag_NotZ = flag_V = flag_C = 0;
14790 DREGu16((Opcode >> 0) & 7) = res;
14791RET(4)
14792}
14793
14794// CLR
14795OPCODE(0x4250)
14796{
14797 u32 adr, res;
14798 u32 src, dst;
14799
14800 adr = AREG((Opcode >> 0) & 7);
14801 res = 0;
14802 flag_N = flag_NotZ = flag_V = flag_C = 0;
14803 PRE_IO
14804 WRITE_WORD_F(adr, res)
14805 POST_IO
14806RET(12)
14807}
14808
14809// CLR
14810OPCODE(0x4258)
14811{
14812 u32 adr, res;
14813 u32 src, dst;
14814
14815 adr = AREG((Opcode >> 0) & 7);
14816 AREG((Opcode >> 0) & 7) += 2;
14817 res = 0;
14818 flag_N = flag_NotZ = flag_V = flag_C = 0;
14819 PRE_IO
14820 WRITE_WORD_F(adr, res)
14821 POST_IO
14822RET(12)
14823}
14824
14825// CLR
14826OPCODE(0x4260)
14827{
14828 u32 adr, res;
14829 u32 src, dst;
14830
14831 adr = AREG((Opcode >> 0) & 7) - 2;
14832 AREG((Opcode >> 0) & 7) = adr;
14833 res = 0;
14834 flag_N = flag_NotZ = flag_V = flag_C = 0;
14835 PRE_IO
14836 WRITE_WORD_F(adr, res)
14837 POST_IO
14838RET(14)
14839}
14840
14841// CLR
14842OPCODE(0x4268)
14843{
14844 u32 adr, res;
14845 u32 src, dst;
14846
14847 FETCH_SWORD(adr);
14848 adr += AREG((Opcode >> 0) & 7);
14849 res = 0;
14850 flag_N = flag_NotZ = flag_V = flag_C = 0;
14851 PRE_IO
14852 WRITE_WORD_F(adr, res)
14853 POST_IO
14854RET(16)
14855}
14856
14857// CLR
14858OPCODE(0x4270)
14859{
14860 u32 adr, res;
14861 u32 src, dst;
14862
14863 adr = AREG((Opcode >> 0) & 7);
14864 DECODE_EXT_WORD
14865 res = 0;
14866 flag_N = flag_NotZ = flag_V = flag_C = 0;
14867 PRE_IO
14868 WRITE_WORD_F(adr, res)
14869 POST_IO
14870RET(18)
14871}
14872
14873// CLR
14874OPCODE(0x4278)
14875{
14876 u32 adr, res;
14877 u32 src, dst;
14878
14879 FETCH_SWORD(adr);
14880 res = 0;
14881 flag_N = flag_NotZ = flag_V = flag_C = 0;
14882 PRE_IO
14883 WRITE_WORD_F(adr, res)
14884 POST_IO
14885RET(16)
14886}
14887
14888// CLR
14889OPCODE(0x4279)
14890{
14891 u32 adr, res;
14892 u32 src, dst;
14893
14894 FETCH_LONG(adr);
14895 res = 0;
14896 flag_N = flag_NotZ = flag_V = flag_C = 0;
14897 PRE_IO
14898 WRITE_WORD_F(adr, res)
14899 POST_IO
14900RET(20)
14901}
14902
14903// CLR
14904OPCODE(0x425F)
14905{
14906 u32 adr, res;
14907 u32 src, dst;
14908
14909 adr = AREG(7);
14910 AREG(7) += 2;
14911 res = 0;
14912 flag_N = flag_NotZ = flag_V = flag_C = 0;
14913 PRE_IO
14914 WRITE_WORD_F(adr, res)
14915 POST_IO
14916RET(12)
14917}
14918
14919// CLR
14920OPCODE(0x4267)
14921{
14922 u32 adr, res;
14923 u32 src, dst;
14924
14925 adr = AREG(7) - 2;
14926 AREG(7) = adr;
14927 res = 0;
14928 flag_N = flag_NotZ = flag_V = flag_C = 0;
14929 PRE_IO
14930 WRITE_WORD_F(adr, res)
14931 POST_IO
14932RET(14)
14933}
14934
14935// CLR
14936OPCODE(0x4280)
14937{
14938 u32 adr, res;
14939 u32 src, dst;
14940
14941 res = 0;
14942 flag_N = flag_NotZ = flag_V = flag_C = 0;
14943 DREGu32((Opcode >> 0) & 7) = res;
14944RET(6)
14945}
14946
14947// CLR
14948OPCODE(0x4290)
14949{
14950 u32 adr, res;
14951 u32 src, dst;
14952
14953 adr = AREG((Opcode >> 0) & 7);
14954 res = 0;
14955 flag_N = flag_NotZ = flag_V = flag_C = 0;
14956 PRE_IO
14957 WRITE_LONG_F(adr, res)
14958 POST_IO
14959RET(20)
14960}
14961
14962// CLR
14963OPCODE(0x4298)
14964{
14965 u32 adr, res;
14966 u32 src, dst;
14967
14968 adr = AREG((Opcode >> 0) & 7);
14969 AREG((Opcode >> 0) & 7) += 4;
14970 res = 0;
14971 flag_N = flag_NotZ = flag_V = flag_C = 0;
14972 PRE_IO
14973 WRITE_LONG_F(adr, res)
14974 POST_IO
14975RET(20)
14976}
14977
14978// CLR
14979OPCODE(0x42A0)
14980{
14981 u32 adr, res;
14982 u32 src, dst;
14983
14984 adr = AREG((Opcode >> 0) & 7) - 4;
14985 AREG((Opcode >> 0) & 7) = adr;
14986 res = 0;
14987 flag_N = flag_NotZ = flag_V = flag_C = 0;
14988 PRE_IO
14989 WRITE_LONG_F(adr, res)
14990 POST_IO
14991RET(22)
14992}
14993
14994// CLR
14995OPCODE(0x42A8)
14996{
14997 u32 adr, res;
14998 u32 src, dst;
14999
15000 FETCH_SWORD(adr);
15001 adr += AREG((Opcode >> 0) & 7);
15002 res = 0;
15003 flag_N = flag_NotZ = flag_V = flag_C = 0;
15004 PRE_IO
15005 WRITE_LONG_F(adr, res)
15006 POST_IO
15007RET(24)
15008}
15009
15010// CLR
15011OPCODE(0x42B0)
15012{
15013 u32 adr, res;
15014 u32 src, dst;
15015
15016 adr = AREG((Opcode >> 0) & 7);
15017 DECODE_EXT_WORD
15018 res = 0;
15019 flag_N = flag_NotZ = flag_V = flag_C = 0;
15020 PRE_IO
15021 WRITE_LONG_F(adr, res)
15022 POST_IO
15023RET(26)
15024}
15025
15026// CLR
15027OPCODE(0x42B8)
15028{
15029 u32 adr, res;
15030 u32 src, dst;
15031
15032 FETCH_SWORD(adr);
15033 res = 0;
15034 flag_N = flag_NotZ = flag_V = flag_C = 0;
15035 PRE_IO
15036 WRITE_LONG_F(adr, res)
15037 POST_IO
15038RET(24)
15039}
15040
15041// CLR
15042OPCODE(0x42B9)
15043{
15044 u32 adr, res;
15045 u32 src, dst;
15046
15047 FETCH_LONG(adr);
15048 res = 0;
15049 flag_N = flag_NotZ = flag_V = flag_C = 0;
15050 PRE_IO
15051 WRITE_LONG_F(adr, res)
15052 POST_IO
15053RET(28)
15054}
15055
15056// CLR
15057OPCODE(0x429F)
15058{
15059 u32 adr, res;
15060 u32 src, dst;
15061
15062 adr = AREG(7);
15063 AREG(7) += 4;
15064 res = 0;
15065 flag_N = flag_NotZ = flag_V = flag_C = 0;
15066 PRE_IO
15067 WRITE_LONG_F(adr, res)
15068 POST_IO
15069RET(20)
15070}
15071
15072// CLR
15073OPCODE(0x42A7)
15074{
15075 u32 adr, res;
15076 u32 src, dst;
15077
15078 adr = AREG(7) - 4;
15079 AREG(7) = adr;
15080 res = 0;
15081 flag_N = flag_NotZ = flag_V = flag_C = 0;
15082 PRE_IO
15083 WRITE_LONG_F(adr, res)
15084 POST_IO
15085RET(22)
15086}
15087
15088// NEG
15089OPCODE(0x4400)
15090{
15091 u32 adr, res;
15092 u32 src, dst;
15093
15094 src = DREGu8((Opcode >> 0) & 7);
15095 res = -src;
15096 flag_V = res & src;
15097 flag_N = flag_X = flag_C = res;
15098 flag_NotZ = res & 0xFF;
15099 DREGu8((Opcode >> 0) & 7) = res;
15100RET(4)
15101}
15102
15103// NEG
15104OPCODE(0x4410)
15105{
15106 u32 adr, res;
15107 u32 src, dst;
15108
15109 adr = AREG((Opcode >> 0) & 7);
15110 PRE_IO
15111 READ_BYTE_F(adr, src)
15112 res = -src;
15113 flag_V = res & src;
15114 flag_N = flag_X = flag_C = res;
15115 flag_NotZ = res & 0xFF;
15116 WRITE_BYTE_F(adr, res)
15117 POST_IO
15118RET(12)
15119}
15120
15121// NEG
15122OPCODE(0x4418)
15123{
15124 u32 adr, res;
15125 u32 src, dst;
15126
15127 adr = AREG((Opcode >> 0) & 7);
15128 AREG((Opcode >> 0) & 7) += 1;
15129 PRE_IO
15130 READ_BYTE_F(adr, src)
15131 res = -src;
15132 flag_V = res & src;
15133 flag_N = flag_X = flag_C = res;
15134 flag_NotZ = res & 0xFF;
15135 WRITE_BYTE_F(adr, res)
15136 POST_IO
15137RET(12)
15138}
15139
15140// NEG
15141OPCODE(0x4420)
15142{
15143 u32 adr, res;
15144 u32 src, dst;
15145
15146 adr = AREG((Opcode >> 0) & 7) - 1;
15147 AREG((Opcode >> 0) & 7) = adr;
15148 PRE_IO
15149 READ_BYTE_F(adr, src)
15150 res = -src;
15151 flag_V = res & src;
15152 flag_N = flag_X = flag_C = res;
15153 flag_NotZ = res & 0xFF;
15154 WRITE_BYTE_F(adr, res)
15155 POST_IO
15156RET(14)
15157}
15158
15159// NEG
15160OPCODE(0x4428)
15161{
15162 u32 adr, res;
15163 u32 src, dst;
15164
15165 FETCH_SWORD(adr);
15166 adr += AREG((Opcode >> 0) & 7);
15167 PRE_IO
15168 READ_BYTE_F(adr, src)
15169 res = -src;
15170 flag_V = res & src;
15171 flag_N = flag_X = flag_C = res;
15172 flag_NotZ = res & 0xFF;
15173 WRITE_BYTE_F(adr, res)
15174 POST_IO
15175RET(16)
15176}
15177
15178// NEG
15179OPCODE(0x4430)
15180{
15181 u32 adr, res;
15182 u32 src, dst;
15183
15184 adr = AREG((Opcode >> 0) & 7);
15185 DECODE_EXT_WORD
15186 PRE_IO
15187 READ_BYTE_F(adr, src)
15188 res = -src;
15189 flag_V = res & src;
15190 flag_N = flag_X = flag_C = res;
15191 flag_NotZ = res & 0xFF;
15192 WRITE_BYTE_F(adr, res)
15193 POST_IO
15194RET(18)
15195}
15196
15197// NEG
15198OPCODE(0x4438)
15199{
15200 u32 adr, res;
15201 u32 src, dst;
15202
15203 FETCH_SWORD(adr);
15204 PRE_IO
15205 READ_BYTE_F(adr, src)
15206 res = -src;
15207 flag_V = res & src;
15208 flag_N = flag_X = flag_C = res;
15209 flag_NotZ = res & 0xFF;
15210 WRITE_BYTE_F(adr, res)
15211 POST_IO
15212RET(16)
15213}
15214
15215// NEG
15216OPCODE(0x4439)
15217{
15218 u32 adr, res;
15219 u32 src, dst;
15220
15221 FETCH_LONG(adr);
15222 PRE_IO
15223 READ_BYTE_F(adr, src)
15224 res = -src;
15225 flag_V = res & src;
15226 flag_N = flag_X = flag_C = res;
15227 flag_NotZ = res & 0xFF;
15228 WRITE_BYTE_F(adr, res)
15229 POST_IO
15230RET(20)
15231}
15232
15233// NEG
15234OPCODE(0x441F)
15235{
15236 u32 adr, res;
15237 u32 src, dst;
15238
15239 adr = AREG(7);
15240 AREG(7) += 2;
15241 PRE_IO
15242 READ_BYTE_F(adr, src)
15243 res = -src;
15244 flag_V = res & src;
15245 flag_N = flag_X = flag_C = res;
15246 flag_NotZ = res & 0xFF;
15247 WRITE_BYTE_F(adr, res)
15248 POST_IO
15249RET(12)
15250}
15251
15252// NEG
15253OPCODE(0x4427)
15254{
15255 u32 adr, res;
15256 u32 src, dst;
15257
15258 adr = AREG(7) - 2;
15259 AREG(7) = adr;
15260 PRE_IO
15261 READ_BYTE_F(adr, src)
15262 res = -src;
15263 flag_V = res & src;
15264 flag_N = flag_X = flag_C = res;
15265 flag_NotZ = res & 0xFF;
15266 WRITE_BYTE_F(adr, res)
15267 POST_IO
15268RET(14)
15269}
15270
15271// NEG
15272OPCODE(0x4440)
15273{
15274 u32 adr, res;
15275 u32 src, dst;
15276
15277 src = DREGu16((Opcode >> 0) & 7);
15278 res = -src;
15279 flag_V = (res & src) >> 8;
15280 flag_N = flag_X = flag_C = res >> 8;
15281 flag_NotZ = res & 0xFFFF;
15282 DREGu16((Opcode >> 0) & 7) = res;
15283RET(4)
15284}
15285
15286// NEG
15287OPCODE(0x4450)
15288{
15289 u32 adr, res;
15290 u32 src, dst;
15291
15292 adr = AREG((Opcode >> 0) & 7);
15293 PRE_IO
15294 READ_WORD_F(adr, src)
15295 res = -src;
15296 flag_V = (res & src) >> 8;
15297 flag_N = flag_X = flag_C = res >> 8;
15298 flag_NotZ = res & 0xFFFF;
15299 WRITE_WORD_F(adr, res)
15300 POST_IO
15301RET(12)
15302}
15303
15304// NEG
15305OPCODE(0x4458)
15306{
15307 u32 adr, res;
15308 u32 src, dst;
15309
15310 adr = AREG((Opcode >> 0) & 7);
15311 AREG((Opcode >> 0) & 7) += 2;
15312 PRE_IO
15313 READ_WORD_F(adr, src)
15314 res = -src;
15315 flag_V = (res & src) >> 8;
15316 flag_N = flag_X = flag_C = res >> 8;
15317 flag_NotZ = res & 0xFFFF;
15318 WRITE_WORD_F(adr, res)
15319 POST_IO
15320RET(12)
15321}
15322
15323// NEG
15324OPCODE(0x4460)
15325{
15326 u32 adr, res;
15327 u32 src, dst;
15328
15329 adr = AREG((Opcode >> 0) & 7) - 2;
15330 AREG((Opcode >> 0) & 7) = adr;
15331 PRE_IO
15332 READ_WORD_F(adr, src)
15333 res = -src;
15334 flag_V = (res & src) >> 8;
15335 flag_N = flag_X = flag_C = res >> 8;
15336 flag_NotZ = res & 0xFFFF;
15337 WRITE_WORD_F(adr, res)
15338 POST_IO
15339RET(14)
15340}
15341
15342// NEG
15343OPCODE(0x4468)
15344{
15345 u32 adr, res;
15346 u32 src, dst;
15347
15348 FETCH_SWORD(adr);
15349 adr += AREG((Opcode >> 0) & 7);
15350 PRE_IO
15351 READ_WORD_F(adr, src)
15352 res = -src;
15353 flag_V = (res & src) >> 8;
15354 flag_N = flag_X = flag_C = res >> 8;
15355 flag_NotZ = res & 0xFFFF;
15356 WRITE_WORD_F(adr, res)
15357 POST_IO
15358RET(16)
15359}
15360
15361// NEG
15362OPCODE(0x4470)
15363{
15364 u32 adr, res;
15365 u32 src, dst;
15366
15367 adr = AREG((Opcode >> 0) & 7);
15368 DECODE_EXT_WORD
15369 PRE_IO
15370 READ_WORD_F(adr, src)
15371 res = -src;
15372 flag_V = (res & src) >> 8;
15373 flag_N = flag_X = flag_C = res >> 8;
15374 flag_NotZ = res & 0xFFFF;
15375 WRITE_WORD_F(adr, res)
15376 POST_IO
15377RET(18)
15378}
15379
15380// NEG
15381OPCODE(0x4478)
15382{
15383 u32 adr, res;
15384 u32 src, dst;
15385
15386 FETCH_SWORD(adr);
15387 PRE_IO
15388 READ_WORD_F(adr, src)
15389 res = -src;
15390 flag_V = (res & src) >> 8;
15391 flag_N = flag_X = flag_C = res >> 8;
15392 flag_NotZ = res & 0xFFFF;
15393 WRITE_WORD_F(adr, res)
15394 POST_IO
15395RET(16)
15396}
15397
15398// NEG
15399OPCODE(0x4479)
15400{
15401 u32 adr, res;
15402 u32 src, dst;
15403
15404 FETCH_LONG(adr);
15405 PRE_IO
15406 READ_WORD_F(adr, src)
15407 res = -src;
15408 flag_V = (res & src) >> 8;
15409 flag_N = flag_X = flag_C = res >> 8;
15410 flag_NotZ = res & 0xFFFF;
15411 WRITE_WORD_F(adr, res)
15412 POST_IO
15413RET(20)
15414}
15415
15416// NEG
15417OPCODE(0x445F)
15418{
15419 u32 adr, res;
15420 u32 src, dst;
15421
15422 adr = AREG(7);
15423 AREG(7) += 2;
15424 PRE_IO
15425 READ_WORD_F(adr, src)
15426 res = -src;
15427 flag_V = (res & src) >> 8;
15428 flag_N = flag_X = flag_C = res >> 8;
15429 flag_NotZ = res & 0xFFFF;
15430 WRITE_WORD_F(adr, res)
15431 POST_IO
15432RET(12)
15433}
15434
15435// NEG
15436OPCODE(0x4467)
15437{
15438 u32 adr, res;
15439 u32 src, dst;
15440
15441 adr = AREG(7) - 2;
15442 AREG(7) = adr;
15443 PRE_IO
15444 READ_WORD_F(adr, src)
15445 res = -src;
15446 flag_V = (res & src) >> 8;
15447 flag_N = flag_X = flag_C = res >> 8;
15448 flag_NotZ = res & 0xFFFF;
15449 WRITE_WORD_F(adr, res)
15450 POST_IO
15451RET(14)
15452}
15453
15454// NEG
15455OPCODE(0x4480)
15456{
15457 u32 adr, res;
15458 u32 src, dst;
15459
15460 src = DREGu32((Opcode >> 0) & 7);
15461 res = -src;
15462 flag_NotZ = res;
15463 flag_V = (res & src) >> 24;
15464 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15465 flag_N = res >> 24;
15466 DREGu32((Opcode >> 0) & 7) = res;
15467RET(6)
15468}
15469
15470// NEG
15471OPCODE(0x4490)
15472{
15473 u32 adr, res;
15474 u32 src, dst;
15475
15476 adr = AREG((Opcode >> 0) & 7);
15477 PRE_IO
15478 READ_LONG_F(adr, src)
15479 res = -src;
15480 flag_NotZ = res;
15481 flag_V = (res & src) >> 24;
15482 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15483 flag_N = res >> 24;
15484 WRITE_LONG_F(adr, res)
15485 POST_IO
15486RET(20)
15487}
15488
15489// NEG
15490OPCODE(0x4498)
15491{
15492 u32 adr, res;
15493 u32 src, dst;
15494
15495 adr = AREG((Opcode >> 0) & 7);
15496 AREG((Opcode >> 0) & 7) += 4;
15497 PRE_IO
15498 READ_LONG_F(adr, src)
15499 res = -src;
15500 flag_NotZ = res;
15501 flag_V = (res & src) >> 24;
15502 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15503 flag_N = res >> 24;
15504 WRITE_LONG_F(adr, res)
15505 POST_IO
15506RET(20)
15507}
15508
15509// NEG
15510OPCODE(0x44A0)
15511{
15512 u32 adr, res;
15513 u32 src, dst;
15514
15515 adr = AREG((Opcode >> 0) & 7) - 4;
15516 AREG((Opcode >> 0) & 7) = adr;
15517 PRE_IO
15518 READ_LONG_F(adr, src)
15519 res = -src;
15520 flag_NotZ = res;
15521 flag_V = (res & src) >> 24;
15522 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15523 flag_N = res >> 24;
15524 WRITE_LONG_F(adr, res)
15525 POST_IO
15526RET(22)
15527}
15528
15529// NEG
15530OPCODE(0x44A8)
15531{
15532 u32 adr, res;
15533 u32 src, dst;
15534
15535 FETCH_SWORD(adr);
15536 adr += AREG((Opcode >> 0) & 7);
15537 PRE_IO
15538 READ_LONG_F(adr, src)
15539 res = -src;
15540 flag_NotZ = res;
15541 flag_V = (res & src) >> 24;
15542 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15543 flag_N = res >> 24;
15544 WRITE_LONG_F(adr, res)
15545 POST_IO
15546RET(24)
15547}
15548
15549// NEG
15550OPCODE(0x44B0)
15551{
15552 u32 adr, res;
15553 u32 src, dst;
15554
15555 adr = AREG((Opcode >> 0) & 7);
15556 DECODE_EXT_WORD
15557 PRE_IO
15558 READ_LONG_F(adr, src)
15559 res = -src;
15560 flag_NotZ = res;
15561 flag_V = (res & src) >> 24;
15562 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15563 flag_N = res >> 24;
15564 WRITE_LONG_F(adr, res)
15565 POST_IO
15566RET(26)
15567}
15568
15569// NEG
15570OPCODE(0x44B8)
15571{
15572 u32 adr, res;
15573 u32 src, dst;
15574
15575 FETCH_SWORD(adr);
15576 PRE_IO
15577 READ_LONG_F(adr, src)
15578 res = -src;
15579 flag_NotZ = res;
15580 flag_V = (res & src) >> 24;
15581 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15582 flag_N = res >> 24;
15583 WRITE_LONG_F(adr, res)
15584 POST_IO
15585RET(24)
15586}
15587
15588// NEG
15589OPCODE(0x44B9)
15590{
15591 u32 adr, res;
15592 u32 src, dst;
15593
15594 FETCH_LONG(adr);
15595 PRE_IO
15596 READ_LONG_F(adr, src)
15597 res = -src;
15598 flag_NotZ = res;
15599 flag_V = (res & src) >> 24;
15600 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15601 flag_N = res >> 24;
15602 WRITE_LONG_F(adr, res)
15603 POST_IO
15604RET(28)
15605}
15606
15607// NEG
15608OPCODE(0x449F)
15609{
15610 u32 adr, res;
15611 u32 src, dst;
15612
15613 adr = AREG(7);
15614 AREG(7) += 4;
15615 PRE_IO
15616 READ_LONG_F(adr, src)
15617 res = -src;
15618 flag_NotZ = res;
15619 flag_V = (res & src) >> 24;
15620 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15621 flag_N = res >> 24;
15622 WRITE_LONG_F(adr, res)
15623 POST_IO
15624RET(20)
15625}
15626
15627// NEG
15628OPCODE(0x44A7)
15629{
15630 u32 adr, res;
15631 u32 src, dst;
15632
15633 adr = AREG(7) - 4;
15634 AREG(7) = adr;
15635 PRE_IO
15636 READ_LONG_F(adr, src)
15637 res = -src;
15638 flag_NotZ = res;
15639 flag_V = (res & src) >> 24;
15640 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
15641 flag_N = res >> 24;
15642 WRITE_LONG_F(adr, res)
15643 POST_IO
15644RET(22)
15645}
15646
15647// NOT
15648OPCODE(0x4600)
15649{
15650 u32 adr, res;
15651 u32 src, dst;
15652
15653 src = DREGu8((Opcode >> 0) & 7);
15654 res = ~src;
15655 flag_C = 0;
15656 flag_V = 0;
15657 flag_N = res;
15658 flag_NotZ = res & 0xFF;
15659 DREGu8((Opcode >> 0) & 7) = res;
15660RET(4)
15661}
15662
15663// NOT
15664OPCODE(0x4610)
15665{
15666 u32 adr, res;
15667 u32 src, dst;
15668
15669 adr = AREG((Opcode >> 0) & 7);
15670 PRE_IO
15671 READ_BYTE_F(adr, src)
15672 res = ~src;
15673 flag_C = 0;
15674 flag_V = 0;
15675 flag_N = res;
15676 flag_NotZ = res & 0xFF;
15677 WRITE_BYTE_F(adr, res)
15678 POST_IO
15679RET(12)
15680}
15681
15682// NOT
15683OPCODE(0x4618)
15684{
15685 u32 adr, res;
15686 u32 src, dst;
15687
15688 adr = AREG((Opcode >> 0) & 7);
15689 AREG((Opcode >> 0) & 7) += 1;
15690 PRE_IO
15691 READ_BYTE_F(adr, src)
15692 res = ~src;
15693 flag_C = 0;
15694 flag_V = 0;
15695 flag_N = res;
15696 flag_NotZ = res & 0xFF;
15697 WRITE_BYTE_F(adr, res)
15698 POST_IO
15699RET(12)
15700}
15701
15702// NOT
15703OPCODE(0x4620)
15704{
15705 u32 adr, res;
15706 u32 src, dst;
15707
15708 adr = AREG((Opcode >> 0) & 7) - 1;
15709 AREG((Opcode >> 0) & 7) = adr;
15710 PRE_IO
15711 READ_BYTE_F(adr, src)
15712 res = ~src;
15713 flag_C = 0;
15714 flag_V = 0;
15715 flag_N = res;
15716 flag_NotZ = res & 0xFF;
15717 WRITE_BYTE_F(adr, res)
15718 POST_IO
15719RET(14)
15720}
15721
15722// NOT
15723OPCODE(0x4628)
15724{
15725 u32 adr, res;
15726 u32 src, dst;
15727
15728 FETCH_SWORD(adr);
15729 adr += AREG((Opcode >> 0) & 7);
15730 PRE_IO
15731 READ_BYTE_F(adr, src)
15732 res = ~src;
15733 flag_C = 0;
15734 flag_V = 0;
15735 flag_N = res;
15736 flag_NotZ = res & 0xFF;
15737 WRITE_BYTE_F(adr, res)
15738 POST_IO
15739RET(16)
15740}
15741
15742// NOT
15743OPCODE(0x4630)
15744{
15745 u32 adr, res;
15746 u32 src, dst;
15747
15748 adr = AREG((Opcode >> 0) & 7);
15749 DECODE_EXT_WORD
15750 PRE_IO
15751 READ_BYTE_F(adr, src)
15752 res = ~src;
15753 flag_C = 0;
15754 flag_V = 0;
15755 flag_N = res;
15756 flag_NotZ = res & 0xFF;
15757 WRITE_BYTE_F(adr, res)
15758 POST_IO
15759RET(18)
15760}
15761
15762// NOT
15763OPCODE(0x4638)
15764{
15765 u32 adr, res;
15766 u32 src, dst;
15767
15768 FETCH_SWORD(adr);
15769 PRE_IO
15770 READ_BYTE_F(adr, src)
15771 res = ~src;
15772 flag_C = 0;
15773 flag_V = 0;
15774 flag_N = res;
15775 flag_NotZ = res & 0xFF;
15776 WRITE_BYTE_F(adr, res)
15777 POST_IO
15778RET(16)
15779}
15780
15781// NOT
15782OPCODE(0x4639)
15783{
15784 u32 adr, res;
15785 u32 src, dst;
15786
15787 FETCH_LONG(adr);
15788 PRE_IO
15789 READ_BYTE_F(adr, src)
15790 res = ~src;
15791 flag_C = 0;
15792 flag_V = 0;
15793 flag_N = res;
15794 flag_NotZ = res & 0xFF;
15795 WRITE_BYTE_F(adr, res)
15796 POST_IO
15797RET(20)
15798}
15799
15800// NOT
15801OPCODE(0x461F)
15802{
15803 u32 adr, res;
15804 u32 src, dst;
15805
15806 adr = AREG(7);
15807 AREG(7) += 2;
15808 PRE_IO
15809 READ_BYTE_F(adr, src)
15810 res = ~src;
15811 flag_C = 0;
15812 flag_V = 0;
15813 flag_N = res;
15814 flag_NotZ = res & 0xFF;
15815 WRITE_BYTE_F(adr, res)
15816 POST_IO
15817RET(12)
15818}
15819
15820// NOT
15821OPCODE(0x4627)
15822{
15823 u32 adr, res;
15824 u32 src, dst;
15825
15826 adr = AREG(7) - 2;
15827 AREG(7) = adr;
15828 PRE_IO
15829 READ_BYTE_F(adr, src)
15830 res = ~src;
15831 flag_C = 0;
15832 flag_V = 0;
15833 flag_N = res;
15834 flag_NotZ = res & 0xFF;
15835 WRITE_BYTE_F(adr, res)
15836 POST_IO
15837RET(14)
15838}
15839
15840// NOT
15841OPCODE(0x4640)
15842{
15843 u32 adr, res;
15844 u32 src, dst;
15845
15846 src = DREGu16((Opcode >> 0) & 7);
15847 res = ~src;
15848 flag_C = 0;
15849 flag_V = 0;
15850 flag_NotZ = res & 0xFFFF;
15851 flag_N = res >> 8;
15852 DREGu16((Opcode >> 0) & 7) = res;
15853RET(4)
15854}
15855
15856// NOT
15857OPCODE(0x4650)
15858{
15859 u32 adr, res;
15860 u32 src, dst;
15861
15862 adr = AREG((Opcode >> 0) & 7);
15863 PRE_IO
15864 READ_WORD_F(adr, src)
15865 res = ~src;
15866 flag_C = 0;
15867 flag_V = 0;
15868 flag_NotZ = res & 0xFFFF;
15869 flag_N = res >> 8;
15870 WRITE_WORD_F(adr, res)
15871 POST_IO
15872RET(12)
15873}
15874
15875// NOT
15876OPCODE(0x4658)
15877{
15878 u32 adr, res;
15879 u32 src, dst;
15880
15881 adr = AREG((Opcode >> 0) & 7);
15882 AREG((Opcode >> 0) & 7) += 2;
15883 PRE_IO
15884 READ_WORD_F(adr, src)
15885 res = ~src;
15886 flag_C = 0;
15887 flag_V = 0;
15888 flag_NotZ = res & 0xFFFF;
15889 flag_N = res >> 8;
15890 WRITE_WORD_F(adr, res)
15891 POST_IO
15892RET(12)
15893}
15894
15895// NOT
15896OPCODE(0x4660)
15897{
15898 u32 adr, res;
15899 u32 src, dst;
15900
15901 adr = AREG((Opcode >> 0) & 7) - 2;
15902 AREG((Opcode >> 0) & 7) = adr;
15903 PRE_IO
15904 READ_WORD_F(adr, src)
15905 res = ~src;
15906 flag_C = 0;
15907 flag_V = 0;
15908 flag_NotZ = res & 0xFFFF;
15909 flag_N = res >> 8;
15910 WRITE_WORD_F(adr, res)
15911 POST_IO
15912RET(14)
15913}
15914
15915// NOT
15916OPCODE(0x4668)
15917{
15918 u32 adr, res;
15919 u32 src, dst;
15920
15921 FETCH_SWORD(adr);
15922 adr += AREG((Opcode >> 0) & 7);
15923 PRE_IO
15924 READ_WORD_F(adr, src)
15925 res = ~src;
15926 flag_C = 0;
15927 flag_V = 0;
15928 flag_NotZ = res & 0xFFFF;
15929 flag_N = res >> 8;
15930 WRITE_WORD_F(adr, res)
15931 POST_IO
15932RET(16)
15933}
15934
15935// NOT
15936OPCODE(0x4670)
15937{
15938 u32 adr, res;
15939 u32 src, dst;
15940
15941 adr = AREG((Opcode >> 0) & 7);
15942 DECODE_EXT_WORD
15943 PRE_IO
15944 READ_WORD_F(adr, src)
15945 res = ~src;
15946 flag_C = 0;
15947 flag_V = 0;
15948 flag_NotZ = res & 0xFFFF;
15949 flag_N = res >> 8;
15950 WRITE_WORD_F(adr, res)
15951 POST_IO
15952RET(18)
15953}
15954
15955// NOT
15956OPCODE(0x4678)
15957{
15958 u32 adr, res;
15959 u32 src, dst;
15960
15961 FETCH_SWORD(adr);
15962 PRE_IO
15963 READ_WORD_F(adr, src)
15964 res = ~src;
15965 flag_C = 0;
15966 flag_V = 0;
15967 flag_NotZ = res & 0xFFFF;
15968 flag_N = res >> 8;
15969 WRITE_WORD_F(adr, res)
15970 POST_IO
15971RET(16)
15972}
15973
15974// NOT
15975OPCODE(0x4679)
15976{
15977 u32 adr, res;
15978 u32 src, dst;
15979
15980 FETCH_LONG(adr);
15981 PRE_IO
15982 READ_WORD_F(adr, src)
15983 res = ~src;
15984 flag_C = 0;
15985 flag_V = 0;
15986 flag_NotZ = res & 0xFFFF;
15987 flag_N = res >> 8;
15988 WRITE_WORD_F(adr, res)
15989 POST_IO
15990RET(20)
15991}
15992
15993// NOT
15994OPCODE(0x465F)
15995{
15996 u32 adr, res;
15997 u32 src, dst;
15998
15999 adr = AREG(7);
16000 AREG(7) += 2;
16001 PRE_IO
16002 READ_WORD_F(adr, src)
16003 res = ~src;
16004 flag_C = 0;
16005 flag_V = 0;
16006 flag_NotZ = res & 0xFFFF;
16007 flag_N = res >> 8;
16008 WRITE_WORD_F(adr, res)
16009 POST_IO
16010RET(12)
16011}
16012
16013// NOT
16014OPCODE(0x4667)
16015{
16016 u32 adr, res;
16017 u32 src, dst;
16018
16019 adr = AREG(7) - 2;
16020 AREG(7) = adr;
16021 PRE_IO
16022 READ_WORD_F(adr, src)
16023 res = ~src;
16024 flag_C = 0;
16025 flag_V = 0;
16026 flag_NotZ = res & 0xFFFF;
16027 flag_N = res >> 8;
16028 WRITE_WORD_F(adr, res)
16029 POST_IO
16030RET(14)
16031}
16032
16033// NOT
16034OPCODE(0x4680)
16035{
16036 u32 adr, res;
16037 u32 src, dst;
16038
16039 src = DREGu32((Opcode >> 0) & 7);
16040 res = ~src;
16041 flag_C = 0;
16042 flag_V = 0;
16043 flag_NotZ = res;
16044 flag_N = res >> 24;
16045 DREGu32((Opcode >> 0) & 7) = res;
16046RET(6)
16047}
16048
16049// NOT
16050OPCODE(0x4690)
16051{
16052 u32 adr, res;
16053 u32 src, dst;
16054
16055 adr = AREG((Opcode >> 0) & 7);
16056 PRE_IO
16057 READ_LONG_F(adr, src)
16058 res = ~src;
16059 flag_C = 0;
16060 flag_V = 0;
16061 flag_NotZ = res;
16062 flag_N = res >> 24;
16063 WRITE_LONG_F(adr, res)
16064 POST_IO
16065RET(20)
16066}
16067
16068// NOT
16069OPCODE(0x4698)
16070{
16071 u32 adr, res;
16072 u32 src, dst;
16073
16074 adr = AREG((Opcode >> 0) & 7);
16075 AREG((Opcode >> 0) & 7) += 4;
16076 PRE_IO
16077 READ_LONG_F(adr, src)
16078 res = ~src;
16079 flag_C = 0;
16080 flag_V = 0;
16081 flag_NotZ = res;
16082 flag_N = res >> 24;
16083 WRITE_LONG_F(adr, res)
16084 POST_IO
16085RET(20)
16086}
16087
16088// NOT
16089OPCODE(0x46A0)
16090{
16091 u32 adr, res;
16092 u32 src, dst;
16093
16094 adr = AREG((Opcode >> 0) & 7) - 4;
16095 AREG((Opcode >> 0) & 7) = adr;
16096 PRE_IO
16097 READ_LONG_F(adr, src)
16098 res = ~src;
16099 flag_C = 0;
16100 flag_V = 0;
16101 flag_NotZ = res;
16102 flag_N = res >> 24;
16103 WRITE_LONG_F(adr, res)
16104 POST_IO
16105RET(22)
16106}
16107
16108// NOT
16109OPCODE(0x46A8)
16110{
16111 u32 adr, res;
16112 u32 src, dst;
16113
16114 FETCH_SWORD(adr);
16115 adr += AREG((Opcode >> 0) & 7);
16116 PRE_IO
16117 READ_LONG_F(adr, src)
16118 res = ~src;
16119 flag_C = 0;
16120 flag_V = 0;
16121 flag_NotZ = res;
16122 flag_N = res >> 24;
16123 WRITE_LONG_F(adr, res)
16124 POST_IO
16125RET(24)
16126}
16127
16128// NOT
16129OPCODE(0x46B0)
16130{
16131 u32 adr, res;
16132 u32 src, dst;
16133
16134 adr = AREG((Opcode >> 0) & 7);
16135 DECODE_EXT_WORD
16136 PRE_IO
16137 READ_LONG_F(adr, src)
16138 res = ~src;
16139 flag_C = 0;
16140 flag_V = 0;
16141 flag_NotZ = res;
16142 flag_N = res >> 24;
16143 WRITE_LONG_F(adr, res)
16144 POST_IO
16145RET(26)
16146}
16147
16148// NOT
16149OPCODE(0x46B8)
16150{
16151 u32 adr, res;
16152 u32 src, dst;
16153
16154 FETCH_SWORD(adr);
16155 PRE_IO
16156 READ_LONG_F(adr, src)
16157 res = ~src;
16158 flag_C = 0;
16159 flag_V = 0;
16160 flag_NotZ = res;
16161 flag_N = res >> 24;
16162 WRITE_LONG_F(adr, res)
16163 POST_IO
16164RET(24)
16165}
16166
16167// NOT
16168OPCODE(0x46B9)
16169{
16170 u32 adr, res;
16171 u32 src, dst;
16172
16173 FETCH_LONG(adr);
16174 PRE_IO
16175 READ_LONG_F(adr, src)
16176 res = ~src;
16177 flag_C = 0;
16178 flag_V = 0;
16179 flag_NotZ = res;
16180 flag_N = res >> 24;
16181 WRITE_LONG_F(adr, res)
16182 POST_IO
16183RET(28)
16184}
16185
16186// NOT
16187OPCODE(0x469F)
16188{
16189 u32 adr, res;
16190 u32 src, dst;
16191
16192 adr = AREG(7);
16193 AREG(7) += 4;
16194 PRE_IO
16195 READ_LONG_F(adr, src)
16196 res = ~src;
16197 flag_C = 0;
16198 flag_V = 0;
16199 flag_NotZ = res;
16200 flag_N = res >> 24;
16201 WRITE_LONG_F(adr, res)
16202 POST_IO
16203RET(20)
16204}
16205
16206// NOT
16207OPCODE(0x46A7)
16208{
16209 u32 adr, res;
16210 u32 src, dst;
16211
16212 adr = AREG(7) - 4;
16213 AREG(7) = adr;
16214 PRE_IO
16215 READ_LONG_F(adr, src)
16216 res = ~src;
16217 flag_C = 0;
16218 flag_V = 0;
16219 flag_NotZ = res;
16220 flag_N = res >> 24;
16221 WRITE_LONG_F(adr, res)
16222 POST_IO
16223RET(22)
16224}
16225
16226// MOVESRa
16227OPCODE(0x40C0)
16228{
16229 u32 adr, res;
16230 u32 src, dst;
16231
16232 res = GET_SR;
16233 DREGu16((Opcode >> 0) & 7) = res;
16234RET(6)
16235}
16236
16237// MOVESRa
16238OPCODE(0x40D0)
16239{
16240 u32 adr, res;
16241 u32 src, dst;
16242
16243 res = GET_SR;
16244 adr = AREG((Opcode >> 0) & 7);
16245 PRE_IO
16246 WRITE_WORD_F(adr, res)
16247 POST_IO
16248RET(12)
16249}
16250
16251// MOVESRa
16252OPCODE(0x40D8)
16253{
16254 u32 adr, res;
16255 u32 src, dst;
16256
16257 res = GET_SR;
16258 adr = AREG((Opcode >> 0) & 7);
16259 AREG((Opcode >> 0) & 7) += 2;
16260 PRE_IO
16261 WRITE_WORD_F(adr, res)
16262 POST_IO
16263RET(12)
16264}
16265
16266// MOVESRa
16267OPCODE(0x40E0)
16268{
16269 u32 adr, res;
16270 u32 src, dst;
16271
16272 res = GET_SR;
16273 adr = AREG((Opcode >> 0) & 7) - 2;
16274 AREG((Opcode >> 0) & 7) = adr;
16275 PRE_IO
16276 WRITE_WORD_F(adr, res)
16277 POST_IO
16278RET(14)
16279}
16280
16281// MOVESRa
16282OPCODE(0x40E8)
16283{
16284 u32 adr, res;
16285 u32 src, dst;
16286
16287 res = GET_SR;
16288 FETCH_SWORD(adr);
16289 adr += AREG((Opcode >> 0) & 7);
16290 PRE_IO
16291 WRITE_WORD_F(adr, res)
16292 POST_IO
16293RET(16)
16294}
16295
16296// MOVESRa
16297OPCODE(0x40F0)
16298{
16299 u32 adr, res;
16300 u32 src, dst;
16301
16302 res = GET_SR;
16303 adr = AREG((Opcode >> 0) & 7);
16304 DECODE_EXT_WORD
16305 PRE_IO
16306 WRITE_WORD_F(adr, res)
16307 POST_IO
16308RET(18)
16309}
16310
16311// MOVESRa
16312OPCODE(0x40F8)
16313{
16314 u32 adr, res;
16315 u32 src, dst;
16316
16317 res = GET_SR;
16318 FETCH_SWORD(adr);
16319 PRE_IO
16320 WRITE_WORD_F(adr, res)
16321 POST_IO
16322RET(16)
16323}
16324
16325// MOVESRa
16326OPCODE(0x40F9)
16327{
16328 u32 adr, res;
16329 u32 src, dst;
16330
16331 res = GET_SR;
16332 FETCH_LONG(adr);
16333 PRE_IO
16334 WRITE_WORD_F(adr, res)
16335 POST_IO
16336RET(20)
16337}
16338
16339// MOVESRa
16340OPCODE(0x40DF)
16341{
16342 u32 adr, res;
16343 u32 src, dst;
16344
16345 res = GET_SR;
16346 adr = AREG(7);
16347 AREG(7) += 2;
16348 PRE_IO
16349 WRITE_WORD_F(adr, res)
16350 POST_IO
16351RET(12)
16352}
16353
16354// MOVESRa
16355OPCODE(0x40E7)
16356{
16357 u32 adr, res;
16358 u32 src, dst;
16359
16360 res = GET_SR;
16361 adr = AREG(7) - 2;
16362 AREG(7) = adr;
16363 PRE_IO
16364 WRITE_WORD_F(adr, res)
16365 POST_IO
16366RET(14)
16367}
16368
16369// MOVEaCCR
16370OPCODE(0x44C0)
16371{
16372 u32 adr, res;
16373 u32 src, dst;
16374
16375 res = DREGu16((Opcode >> 0) & 7);
16376 SET_CCR(res)
16377RET(12)
16378}
16379
16380// MOVEaCCR
16381OPCODE(0x44D0)
16382{
16383 u32 adr, res;
16384 u32 src, dst;
16385
16386 adr = AREG((Opcode >> 0) & 7);
16387 PRE_IO
16388 READ_WORD_F(adr, res)
16389 SET_CCR(res)
16390 POST_IO
16391RET(16)
16392}
16393
16394// MOVEaCCR
16395OPCODE(0x44D8)
16396{
16397 u32 adr, res;
16398 u32 src, dst;
16399
16400 adr = AREG((Opcode >> 0) & 7);
16401 AREG((Opcode >> 0) & 7) += 2;
16402 PRE_IO
16403 READ_WORD_F(adr, res)
16404 SET_CCR(res)
16405 POST_IO
16406RET(16)
16407}
16408
16409// MOVEaCCR
16410OPCODE(0x44E0)
16411{
16412 u32 adr, res;
16413 u32 src, dst;
16414
16415 adr = AREG((Opcode >> 0) & 7) - 2;
16416 AREG((Opcode >> 0) & 7) = adr;
16417 PRE_IO
16418 READ_WORD_F(adr, res)
16419 SET_CCR(res)
16420 POST_IO
16421RET(18)
16422}
16423
16424// MOVEaCCR
16425OPCODE(0x44E8)
16426{
16427 u32 adr, res;
16428 u32 src, dst;
16429
16430 FETCH_SWORD(adr);
16431 adr += AREG((Opcode >> 0) & 7);
16432 PRE_IO
16433 READ_WORD_F(adr, res)
16434 SET_CCR(res)
16435 POST_IO
16436RET(20)
16437}
16438
16439// MOVEaCCR
16440OPCODE(0x44F0)
16441{
16442 u32 adr, res;
16443 u32 src, dst;
16444
16445 adr = AREG((Opcode >> 0) & 7);
16446 DECODE_EXT_WORD
16447 PRE_IO
16448 READ_WORD_F(adr, res)
16449 SET_CCR(res)
16450 POST_IO
16451RET(22)
16452}
16453
16454// MOVEaCCR
16455OPCODE(0x44F8)
16456{
16457 u32 adr, res;
16458 u32 src, dst;
16459
16460 FETCH_SWORD(adr);
16461 PRE_IO
16462 READ_WORD_F(adr, res)
16463 SET_CCR(res)
16464 POST_IO
16465RET(20)
16466}
16467
16468// MOVEaCCR
16469OPCODE(0x44F9)
16470{
16471 u32 adr, res;
16472 u32 src, dst;
16473
16474 FETCH_LONG(adr);
16475 PRE_IO
16476 READ_WORD_F(adr, res)
16477 SET_CCR(res)
16478 POST_IO
16479RET(24)
16480}
16481
16482// MOVEaCCR
16483OPCODE(0x44FA)
16484{
16485 u32 adr, res;
16486 u32 src, dst;
16487
be26eb23 16488 adr = GET_SWORD + GET_PC;
70357ce5 16489 PC++;
16490 PRE_IO
16491 READ_WORD_F(adr, res)
16492 SET_CCR(res)
16493 POST_IO
16494RET(20)
16495}
16496
16497// MOVEaCCR
16498OPCODE(0x44FB)
16499{
16500 u32 adr, res;
16501 u32 src, dst;
16502
be26eb23 16503 adr = GET_PC;
70357ce5 16504 DECODE_EXT_WORD
16505 PRE_IO
16506 READ_WORD_F(adr, res)
16507 SET_CCR(res)
16508 POST_IO
16509RET(22)
16510}
16511
16512// MOVEaCCR
16513OPCODE(0x44FC)
16514{
16515 u32 adr, res;
16516 u32 src, dst;
16517
16518 FETCH_WORD(res);
16519 SET_CCR(res)
16520RET(16)
16521}
16522
16523// MOVEaCCR
16524OPCODE(0x44DF)
16525{
16526 u32 adr, res;
16527 u32 src, dst;
16528
16529 adr = AREG(7);
16530 AREG(7) += 2;
16531 PRE_IO
16532 READ_WORD_F(adr, res)
16533 SET_CCR(res)
16534 POST_IO
16535RET(16)
16536}
16537
16538// MOVEaCCR
16539OPCODE(0x44E7)
16540{
16541 u32 adr, res;
16542 u32 src, dst;
16543
16544 adr = AREG(7) - 2;
16545 AREG(7) = adr;
16546 PRE_IO
16547 READ_WORD_F(adr, res)
16548 SET_CCR(res)
16549 POST_IO
16550RET(18)
16551}
16552
16553// MOVEaSR
16554OPCODE(0x46C0)
16555{
16556 u32 adr, res;
16557 u32 src, dst;
16558
16559 if (flag_S)
16560 {
16561 res = DREGu16((Opcode >> 0) & 7);
16562 SET_SR(res)
16563 if (!flag_S)
16564 {
16565 res = AREG(7);
16566 AREG(7) = ASP;
16567 ASP = res;
16568 }
16569 CHECK_INT_TO_JUMP(12)
16570 }
16571 else
16572 {
d0ae0cb4 16573 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16574 RET(4)
16575 }
16576RET(12)
16577}
16578
16579// MOVEaSR
16580OPCODE(0x46D0)
16581{
16582 u32 adr, res;
16583 u32 src, dst;
16584
16585 if (flag_S)
16586 {
16587 adr = AREG((Opcode >> 0) & 7);
16588 PRE_IO
16589 READ_WORD_F(adr, res)
16590 SET_SR(res)
16591 if (!flag_S)
16592 {
16593 res = AREG(7);
16594 AREG(7) = ASP;
16595 ASP = res;
16596 }
16597 POST_IO
16598 CHECK_INT_TO_JUMP(16)
16599 }
16600 else
16601 {
d0ae0cb4 16602 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16603 RET(4)
16604 }
16605RET(16)
16606}
16607
16608// MOVEaSR
16609OPCODE(0x46D8)
16610{
16611 u32 adr, res;
16612 u32 src, dst;
16613
16614 if (flag_S)
16615 {
16616 adr = AREG((Opcode >> 0) & 7);
16617 AREG((Opcode >> 0) & 7) += 2;
16618 PRE_IO
16619 READ_WORD_F(adr, res)
16620 SET_SR(res)
16621 if (!flag_S)
16622 {
16623 res = AREG(7);
16624 AREG(7) = ASP;
16625 ASP = res;
16626 }
16627 POST_IO
16628 CHECK_INT_TO_JUMP(16)
16629 }
16630 else
16631 {
d0ae0cb4 16632 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16633 RET(4)
16634 }
16635RET(16)
16636}
16637
16638// MOVEaSR
16639OPCODE(0x46E0)
16640{
16641 u32 adr, res;
16642 u32 src, dst;
16643
16644 if (flag_S)
16645 {
16646 adr = AREG((Opcode >> 0) & 7) - 2;
16647 AREG((Opcode >> 0) & 7) = adr;
16648 PRE_IO
16649 READ_WORD_F(adr, res)
16650 SET_SR(res)
16651 if (!flag_S)
16652 {
16653 res = AREG(7);
16654 AREG(7) = ASP;
16655 ASP = res;
16656 }
16657 POST_IO
16658 CHECK_INT_TO_JUMP(18)
16659 }
16660 else
16661 {
d0ae0cb4 16662 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16663 RET(4)
16664 }
16665RET(18)
16666}
16667
16668// MOVEaSR
16669OPCODE(0x46E8)
16670{
16671 u32 adr, res;
16672 u32 src, dst;
16673
16674 if (flag_S)
16675 {
16676 FETCH_SWORD(adr);
16677 adr += AREG((Opcode >> 0) & 7);
16678 PRE_IO
16679 READ_WORD_F(adr, res)
16680 SET_SR(res)
16681 if (!flag_S)
16682 {
16683 res = AREG(7);
16684 AREG(7) = ASP;
16685 ASP = res;
16686 }
16687 POST_IO
16688 CHECK_INT_TO_JUMP(20)
16689 }
16690 else
16691 {
d0ae0cb4 16692 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16693 RET(4)
16694 }
16695RET(20)
16696}
16697
16698// MOVEaSR
16699OPCODE(0x46F0)
16700{
16701 u32 adr, res;
16702 u32 src, dst;
16703
16704 if (flag_S)
16705 {
16706 adr = AREG((Opcode >> 0) & 7);
16707 DECODE_EXT_WORD
16708 PRE_IO
16709 READ_WORD_F(adr, res)
16710 SET_SR(res)
16711 if (!flag_S)
16712 {
16713 res = AREG(7);
16714 AREG(7) = ASP;
16715 ASP = res;
16716 }
16717 POST_IO
16718 CHECK_INT_TO_JUMP(22)
16719 }
16720 else
16721 {
d0ae0cb4 16722 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16723 RET(4)
16724 }
16725RET(22)
16726}
16727
16728
16729// MOVEaSR
16730OPCODE(0x46F8)
16731{
16732 u32 adr, res;
16733 u32 src, dst;
16734
16735 if (flag_S)
16736 {
16737 FETCH_SWORD(adr);
16738 PRE_IO
16739 READ_WORD_F(adr, res)
16740 SET_SR(res)
16741 if (!flag_S)
16742 {
16743 res = AREG(7);
16744 AREG(7) = ASP;
16745 ASP = res;
16746 }
16747 POST_IO
16748 CHECK_INT_TO_JUMP(20)
16749 }
16750 else
16751 {
d0ae0cb4 16752 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16753 RET(4)
16754 }
16755RET(20)
16756}
16757
16758// MOVEaSR
16759OPCODE(0x46F9)
16760{
16761 u32 adr, res;
16762 u32 src, dst;
16763
16764 if (flag_S)
16765 {
16766 FETCH_LONG(adr);
16767 PRE_IO
16768 READ_WORD_F(adr, res)
16769 SET_SR(res)
16770 if (!flag_S)
16771 {
16772 res = AREG(7);
16773 AREG(7) = ASP;
16774 ASP = res;
16775 }
16776 POST_IO
16777 CHECK_INT_TO_JUMP(24)
16778 }
16779 else
16780 {
d0ae0cb4 16781 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16782 RET(4)
16783 }
16784RET(24)
16785}
16786
16787// MOVEaSR
16788OPCODE(0x46FA)
16789{
16790 u32 adr, res;
16791 u32 src, dst;
16792
16793 if (flag_S)
16794 {
be26eb23 16795 adr = GET_SWORD + GET_PC;
70357ce5 16796 PC++;
16797 PRE_IO
16798 READ_WORD_F(adr, res)
16799 SET_SR(res)
16800 if (!flag_S)
16801 {
16802 res = AREG(7);
16803 AREG(7) = ASP;
16804 ASP = res;
16805 }
16806 POST_IO
d0ae0cb4 16807 CHECK_INT_TO_JUMP(20)
70357ce5 16808 }
16809 else
16810 {
d0ae0cb4 16811 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16812 RET(4)
16813 }
16814RET(20)
16815}
16816
16817// MOVEaSR
16818OPCODE(0x46FB)
16819{
16820 u32 adr, res;
16821 u32 src, dst;
16822
16823 if (flag_S)
16824 {
be26eb23 16825 adr = GET_PC;
70357ce5 16826 DECODE_EXT_WORD
16827 PRE_IO
16828 READ_WORD_F(adr, res)
16829 SET_SR(res)
16830 if (!flag_S)
16831 {
16832 res = AREG(7);
16833 AREG(7) = ASP;
16834 ASP = res;
16835 }
16836 POST_IO
16837 CHECK_INT_TO_JUMP(22)
16838 }
16839 else
16840 {
d0ae0cb4 16841 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16842 RET(4)
16843 }
16844RET(22)
16845}
16846
16847// MOVEaSR
16848OPCODE(0x46FC)
16849{
16850 u32 adr, res;
16851 u32 src, dst;
16852
16853 if (flag_S)
16854 {
16855 FETCH_WORD(res);
16856 SET_SR(res)
16857 if (!flag_S)
16858 {
16859 res = AREG(7);
16860 AREG(7) = ASP;
16861 ASP = res;
16862 }
16863 CHECK_INT_TO_JUMP(16)
16864 }
16865 else
16866 {
d0ae0cb4 16867 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16868 RET(4)
16869 }
16870RET(16)
16871}
16872
16873// MOVEaSR
16874OPCODE(0x46DF)
16875{
16876 u32 adr, res;
16877 u32 src, dst;
16878
16879 if (flag_S)
16880 {
16881 adr = AREG(7);
16882 AREG(7) += 2;
16883 PRE_IO
16884 READ_WORD_F(adr, res)
16885 SET_SR(res)
16886 if (!flag_S)
16887 {
16888 res = AREG(7);
16889 AREG(7) = ASP;
16890 ASP = res;
16891 }
16892 POST_IO
16893 CHECK_INT_TO_JUMP(16)
16894 }
16895 else
16896 {
d0ae0cb4 16897 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16898 RET(4)
16899 }
16900RET(16)
16901}
16902
16903// MOVEaSR
16904OPCODE(0x46E7)
16905{
16906 u32 adr, res;
16907 u32 src, dst;
16908
16909 if (flag_S)
16910 {
16911 adr = AREG(7) - 2;
16912 AREG(7) = adr;
16913 PRE_IO
16914 READ_WORD_F(adr, res)
16915 SET_SR(res)
16916 if (!flag_S)
16917 {
16918 res = AREG(7);
16919 AREG(7) = ASP;
16920 ASP = res;
16921 }
16922 POST_IO
16923 CHECK_INT_TO_JUMP(18)
16924 }
16925 else
16926 {
d0ae0cb4 16927 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 16928 RET(4)
16929 }
16930RET(18)
16931}
16932
16933// NBCD
16934OPCODE(0x4800)
16935{
16936 u32 adr, res;
16937 u32 src, dst;
16938
c6e1e977 16939 dst = DREGu8((Opcode >> 0) & 7);
16940 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 16941
c6e1e977 16942 if (res != 0)
70357ce5 16943 {
c6e1e977 16944 flag_V = res;
16945 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
16946 res = (res + 0x9a) & 0xFF;
16947 DREGu8((Opcode >> 0) & 7) = res;
16948 flag_V &= ~res;
70357ce5 16949 flag_NotZ |= res;
16950 flag_X = flag_C = M68K_SR_C;
16951 }
c6e1e977 16952 else flag_V = flag_X = flag_C = 0;
70357ce5 16953 flag_N = res;
16954RET(6)
16955}
16956
16957// NBCD
16958OPCODE(0x4810)
16959{
16960 u32 adr, res;
16961 u32 src, dst;
16962
16963 adr = AREG((Opcode >> 0) & 7);
16964 PRE_IO
c6e1e977 16965 READ_BYTE_F(adr, dst)
16966 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 16967
c6e1e977 16968 if (res != 0)
70357ce5 16969 {
c6e1e977 16970 flag_V = res;
16971 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
16972 res = (res + 0x9a) & 0xFF;
16973 WRITE_BYTE_F(adr, res)
16974 flag_V &= ~res;
70357ce5 16975 flag_NotZ |= res;
16976 flag_X = flag_C = M68K_SR_C;
16977 }
c6e1e977 16978 else flag_V = flag_X = flag_C = 0;
70357ce5 16979 flag_N = res;
16980 POST_IO
16981RET(12)
16982}
16983
16984// NBCD
16985OPCODE(0x4818)
16986{
16987 u32 adr, res;
16988 u32 src, dst;
16989
16990 adr = AREG((Opcode >> 0) & 7);
16991 AREG((Opcode >> 0) & 7) += 1;
16992 PRE_IO
c6e1e977 16993 READ_BYTE_F(adr, dst)
16994 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 16995
c6e1e977 16996 if (res != 0)
70357ce5 16997 {
c6e1e977 16998 flag_V = res;
16999 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17000 res = (res + 0x9a) & 0xFF;
17001 WRITE_BYTE_F(adr, res)
17002 flag_V &= ~res;
70357ce5 17003 flag_NotZ |= res;
17004 flag_X = flag_C = M68K_SR_C;
17005 }
c6e1e977 17006 else flag_V = flag_X = flag_C = 0;
70357ce5 17007 flag_N = res;
17008 POST_IO
17009RET(12)
17010}
17011
17012// NBCD
17013OPCODE(0x4820)
17014{
17015 u32 adr, res;
17016 u32 src, dst;
17017
17018 adr = AREG((Opcode >> 0) & 7) - 1;
17019 AREG((Opcode >> 0) & 7) = adr;
17020 PRE_IO
c6e1e977 17021 READ_BYTE_F(adr, dst)
17022 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 17023
c6e1e977 17024 if (res != 0)
70357ce5 17025 {
c6e1e977 17026 flag_V = res;
17027 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17028 res = (res + 0x9a) & 0xFF;
17029 WRITE_BYTE_F(adr, res)
17030 flag_V &= ~res;
70357ce5 17031 flag_NotZ |= res;
17032 flag_X = flag_C = M68K_SR_C;
17033 }
c6e1e977 17034 else flag_V = flag_X = flag_C = 0;
70357ce5 17035 flag_N = res;
17036 POST_IO
17037RET(14)
17038}
17039
17040// NBCD
17041OPCODE(0x4828)
17042{
17043 u32 adr, res;
17044 u32 src, dst;
17045
17046 FETCH_SWORD(adr);
17047 adr += AREG((Opcode >> 0) & 7);
17048 PRE_IO
c6e1e977 17049 READ_BYTE_F(adr, dst)
17050 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 17051
c6e1e977 17052 if (res != 0)
70357ce5 17053 {
c6e1e977 17054 flag_V = res;
17055 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17056 res = (res + 0x9a) & 0xFF;
17057 WRITE_BYTE_F(adr, res)
17058 flag_V &= ~res;
70357ce5 17059 flag_NotZ |= res;
17060 flag_X = flag_C = M68K_SR_C;
17061 }
c6e1e977 17062 else flag_V = flag_X = flag_C = 0;
70357ce5 17063 flag_N = res;
17064 POST_IO
17065RET(16)
17066}
17067
17068// NBCD
17069OPCODE(0x4830)
17070{
17071 u32 adr, res;
17072 u32 src, dst;
17073
17074 adr = AREG((Opcode >> 0) & 7);
17075 DECODE_EXT_WORD
17076 PRE_IO
c6e1e977 17077 READ_BYTE_F(adr, dst)
17078 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 17079
c6e1e977 17080 if (res != 0)
70357ce5 17081 {
c6e1e977 17082 flag_V = res;
17083 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17084 res = (res + 0x9a) & 0xFF;
17085 WRITE_BYTE_F(adr, res)
17086 flag_V &= ~res;
70357ce5 17087 flag_NotZ |= res;
17088 flag_X = flag_C = M68K_SR_C;
17089 }
c6e1e977 17090 else flag_V = flag_X = flag_C = 0;
70357ce5 17091 flag_N = res;
17092 POST_IO
17093RET(18)
17094}
17095
17096// NBCD
17097OPCODE(0x4838)
17098{
17099 u32 adr, res;
17100 u32 src, dst;
17101
17102 FETCH_SWORD(adr);
17103 PRE_IO
c6e1e977 17104 READ_BYTE_F(adr, dst)
17105 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 17106
c6e1e977 17107 if (res != 0)
70357ce5 17108 {
c6e1e977 17109 flag_V = res;
17110 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17111 res = (res + 0x9a) & 0xFF;
17112 WRITE_BYTE_F(adr, res)
17113 flag_V &= ~res;
70357ce5 17114 flag_NotZ |= res;
17115 flag_X = flag_C = M68K_SR_C;
17116 }
c6e1e977 17117 else flag_V = flag_X = flag_C = 0;
70357ce5 17118 flag_N = res;
17119 POST_IO
17120RET(16)
17121}
17122
17123// NBCD
17124OPCODE(0x4839)
17125{
17126 u32 adr, res;
17127 u32 src, dst;
17128
17129 FETCH_LONG(adr);
17130 PRE_IO
c6e1e977 17131 READ_BYTE_F(adr, dst)
17132 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 17133
c6e1e977 17134 if (res != 0)
70357ce5 17135 {
c6e1e977 17136 flag_V = res;
17137 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17138 res = (res + 0x9a) & 0xFF;
17139 WRITE_BYTE_F(adr, res)
17140 flag_V &= ~res;
70357ce5 17141 flag_NotZ |= res;
17142 flag_X = flag_C = M68K_SR_C;
17143 }
c6e1e977 17144 else flag_V = flag_X = flag_C = 0;
70357ce5 17145 flag_N = res;
17146 POST_IO
17147RET(20)
17148}
17149
17150// NBCD
17151OPCODE(0x481F)
17152{
17153 u32 adr, res;
17154 u32 src, dst;
17155
17156 adr = AREG(7);
17157 AREG(7) += 2;
17158 PRE_IO
c6e1e977 17159 READ_BYTE_F(adr, dst)
17160 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 17161
c6e1e977 17162 if (res != 0)
70357ce5 17163 {
c6e1e977 17164 flag_V = res;
17165 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17166 res = (res + 0x9a) & 0xFF;
17167 WRITE_BYTE_F(adr, res)
17168 flag_V &= ~res;
70357ce5 17169 flag_NotZ |= res;
17170 flag_X = flag_C = M68K_SR_C;
17171 }
c6e1e977 17172 else flag_V = flag_X = flag_C = 0;
70357ce5 17173 flag_N = res;
17174 POST_IO
17175RET(12)
17176}
17177
17178// NBCD
17179OPCODE(0x4827)
17180{
17181 u32 adr, res;
17182 u32 src, dst;
17183
17184 adr = AREG(7) - 2;
17185 AREG(7) = adr;
17186 PRE_IO
c6e1e977 17187 READ_BYTE_F(adr, dst)
17188 res = -dst - ((flag_X >> M68K_SR_X_SFT) & 1);
70357ce5 17189
c6e1e977 17190 if (res != 0)
70357ce5 17191 {
c6e1e977 17192 flag_V = res;
17193 if (((res|dst) & 0x0f) == 0) res = (res & 0xf0) + 6;
17194 res = (res + 0x9a) & 0xFF;
17195 WRITE_BYTE_F(adr, res)
17196 flag_V &= ~res;
70357ce5 17197 flag_NotZ |= res;
17198 flag_X = flag_C = M68K_SR_C;
17199 }
c6e1e977 17200 else flag_V = flag_X = flag_C = 0;
70357ce5 17201 flag_N = res;
17202 POST_IO
17203RET(14)
17204}
17205
17206// PEA
17207OPCODE(0x4850)
17208{
17209 u32 adr, res;
17210 u32 src, dst;
17211
17212 adr = AREG((Opcode >> 0) & 7);
17213 PRE_IO
17214 PUSH_32_F(adr)
17215 POST_IO
17216RET(12)
17217}
17218
17219// PEA
17220OPCODE(0x4868)
17221{
17222 u32 adr, res;
17223 u32 src, dst;
17224
17225 FETCH_SWORD(adr);
17226 adr += AREG((Opcode >> 0) & 7);
17227 PRE_IO
17228 PUSH_32_F(adr)
17229 POST_IO
17230RET(16)
17231}
17232
17233// PEA
17234OPCODE(0x4870)
17235{
17236 u32 adr, res;
17237 u32 src, dst;
17238
17239 adr = AREG((Opcode >> 0) & 7);
17240 DECODE_EXT_WORD
17241 PRE_IO
17242 PUSH_32_F(adr)
17243 POST_IO
17244RET(20)
17245}
17246
17247// PEA
17248OPCODE(0x4878)
17249{
17250 u32 adr, res;
17251 u32 src, dst;
17252
17253 FETCH_SWORD(adr);
17254 PRE_IO
17255 PUSH_32_F(adr)
17256 POST_IO
17257RET(16)
17258}
17259
17260// PEA
17261OPCODE(0x4879)
17262{
17263 u32 adr, res;
17264 u32 src, dst;
17265
17266 FETCH_LONG(adr);
17267 PRE_IO
17268 PUSH_32_F(adr)
17269 POST_IO
17270RET(20)
17271}
17272
17273// PEA
17274OPCODE(0x487A)
17275{
17276 u32 adr, res;
17277 u32 src, dst;
17278
be26eb23 17279 adr = GET_SWORD + GET_PC;
70357ce5 17280 PC++;
17281 PRE_IO
17282 PUSH_32_F(adr)
17283 POST_IO
17284RET(16)
17285}
17286
17287// PEA
17288OPCODE(0x487B)
17289{
17290 u32 adr, res;
17291 u32 src, dst;
17292
be26eb23 17293 adr = GET_PC;
70357ce5 17294 DECODE_EXT_WORD
17295 PRE_IO
17296 PUSH_32_F(adr)
17297 POST_IO
17298RET(20)
17299}
17300
17301// SWAP
17302OPCODE(0x4840)
17303{
17304 u32 adr, res;
17305 u32 src, dst;
17306
17307 res = DREGu32((Opcode >> 0) & 7);
17308 res = (res >> 16) | (res << 16);
17309 flag_C = 0;
17310 flag_V = 0;
17311 flag_NotZ = res;
17312 flag_N = res >> 24;
17313 DREGu32((Opcode >> 0) & 7) = res;
17314RET(4)
17315}
17316
17317// MOVEMRa
17318OPCODE(0x4890)
17319{
17320 u32 adr, res;
17321 u32 src, dst;
17322
17323 u32 *psrc;
17324
17325 FETCH_WORD(res);
17326 adr = AREG((Opcode >> 0) & 7);
17327 psrc = &DREGu32(0);
17328 dst = adr;
17329 PRE_IO
17330 do
17331 {
17332 if (res & 1)
17333 {
17334 WRITE_WORD_F(adr, *psrc)
17335 adr += 2;
17336 }
17337 psrc++;
17338 } while (res >>= 1);
17339 POST_IO
17340 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17341#ifdef USE_CYCLONE_TIMING
17342RET(8)
17343#else
17344RET(12)
17345#endif
17346}
17347
17348// MOVEMRa
17349OPCODE(0x48A0)
17350{
17351 u32 adr, res;
17352 u32 src, dst;
17353
17354 u32 *psrc;
17355
17356 FETCH_WORD(res);
17357 adr = AREG((Opcode >> 0) & 7);
17358 psrc = &AREGu32(7);
17359 dst = adr;
17360 PRE_IO
17361 do
17362 {
17363 if (res & 1)
17364 {
17365 adr -= 2;
17366 WRITE_WORD_F(adr, *psrc)
17367 }
17368 psrc--;
17369 } while (res >>= 1);
17370 AREG((Opcode >> 0) & 7) = adr;
17371 POST_IO
17372 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17373RET(8)
17374}
17375
17376// MOVEMRa
17377OPCODE(0x48A8)
17378{
17379 u32 adr, res;
17380 u32 src, dst;
17381
17382 u32 *psrc;
17383
17384 FETCH_WORD(res);
17385 FETCH_SWORD(adr);
17386 adr += AREG((Opcode >> 0) & 7);
17387 psrc = &DREGu32(0);
17388 dst = adr;
17389 PRE_IO
17390 do
17391 {
17392 if (res & 1)
17393 {
17394 WRITE_WORD_F(adr, *psrc)
17395 adr += 2;
17396 }
17397 psrc++;
17398 } while (res >>= 1);
17399 POST_IO
17400 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17401#ifdef USE_CYCLONE_TIMING
17402RET(12)
17403#else
17404RET(20)
17405#endif
17406}
17407
17408// MOVEMRa
17409OPCODE(0x48B0)
17410{
17411 u32 adr, res;
17412 u32 src, dst;
17413
17414 u32 *psrc;
17415
17416 FETCH_WORD(res);
17417 adr = AREG((Opcode >> 0) & 7);
17418 DECODE_EXT_WORD
17419 psrc = &DREGu32(0);
17420 dst = adr;
17421 PRE_IO
17422 do
17423 {
17424 if (res & 1)
17425 {
17426 WRITE_WORD_F(adr, *psrc)
17427 adr += 2;
17428 }
17429 psrc++;
17430 } while (res >>= 1);
17431 POST_IO
17432 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17433#ifdef USE_CYCLONE_TIMING
17434RET(14)
17435#else
17436RET(24)
17437#endif
17438}
17439
17440// MOVEMRa
17441OPCODE(0x48B8)
17442{
17443 u32 adr, res;
17444 u32 src, dst;
17445
17446 u32 *psrc;
17447
17448 FETCH_WORD(res);
17449 FETCH_SWORD(adr);
17450 psrc = &DREGu32(0);
17451 dst = adr;
17452 PRE_IO
17453 do
17454 {
17455 if (res & 1)
17456 {
17457 WRITE_WORD_F(adr, *psrc)
17458 adr += 2;
17459 }
17460 psrc++;
17461 } while (res >>= 1);
17462 POST_IO
17463 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17464#ifdef USE_CYCLONE_TIMING
17465RET(12)
17466#else
17467RET(20)
17468#endif
17469}
17470
17471// MOVEMRa
17472OPCODE(0x48B9)
17473{
17474 u32 adr, res;
17475 u32 src, dst;
17476
17477 u32 *psrc;
17478
17479 FETCH_WORD(res);
17480 FETCH_LONG(adr);
17481 psrc = &DREGu32(0);
17482 dst = adr;
17483 PRE_IO
17484 do
17485 {
17486 if (res & 1)
17487 {
17488 WRITE_WORD_F(adr, *psrc)
17489 adr += 2;
17490 }
17491 psrc++;
17492 } while (res >>= 1);
17493 POST_IO
17494 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17495#ifdef USE_CYCLONE_TIMING
17496RET(16)
17497#else
17498RET(28)
17499#endif
17500}
17501
17502// MOVEMRa
17503OPCODE(0x48A7)
17504{
17505 u32 adr, res;
17506 u32 src, dst;
17507
17508 u32 *psrc;
17509
17510 FETCH_WORD(res);
17511 adr = AREG(7);
17512 psrc = &AREGu32(7);
17513 dst = adr;
17514 PRE_IO
17515 do
17516 {
17517 if (res & 1)
17518 {
17519 adr -= 2;
17520 WRITE_WORD_F(adr, *psrc)
17521 }
17522 psrc--;
17523 } while (res >>= 1);
17524 AREG(7) = adr;
17525 POST_IO
17526 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17527RET(8)
17528}
17529
17530// MOVEMRa
17531OPCODE(0x48D0)
17532{
17533 u32 adr, res;
17534 u32 src, dst;
17535
17536 u32 *psrc;
17537
17538 FETCH_WORD(res);
17539 adr = AREG((Opcode >> 0) & 7);
17540 psrc = &DREGu32(0);
17541 dst = adr;
17542 PRE_IO
17543 do
17544 {
17545 if (res & 1)
17546 {
17547 WRITE_LONG_F(adr, *psrc)
17548 adr += 4;
17549 }
17550 psrc++;
17551 } while (res >>= 1);
17552 POST_IO
17553 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17554#ifdef USE_CYCLONE_TIMING
17555RET(8)
17556#else
17557RET(16)
17558#endif
17559}
17560
17561// MOVEMRa
17562OPCODE(0x48E0)
17563{
17564 u32 adr, res;
17565 u32 src, dst;
17566
17567 u32 *psrc;
17568
17569 FETCH_WORD(res);
17570 adr = AREG((Opcode >> 0) & 7);
17571 psrc = &AREGu32(7);
17572 dst = adr;
17573 PRE_IO
17574 do
17575 {
17576 if (res & 1)
17577 {
17578 adr -= 4;
17579 WRITE_LONG_DEC_F(adr, *psrc)
17580 }
17581 psrc--;
17582 } while (res >>= 1);
17583 AREG((Opcode >> 0) & 7) = adr;
17584 POST_IO
17585 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17586RET(8)
17587}
17588
17589// MOVEMRa
17590OPCODE(0x48E8)
17591{
17592 u32 adr, res;
17593 u32 src, dst;
17594
17595 u32 *psrc;
17596
17597 FETCH_WORD(res);
17598 FETCH_SWORD(adr);
17599 adr += AREG((Opcode >> 0) & 7);
17600 psrc = &DREGu32(0);
17601 dst = adr;
17602 PRE_IO
17603 do
17604 {
17605 if (res & 1)
17606 {
17607 WRITE_LONG_F(adr, *psrc)
17608 adr += 4;
17609 }
17610 psrc++;
17611 } while (res >>= 1);
17612 POST_IO
17613 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17614#ifdef USE_CYCLONE_TIMING
17615RET(12)
17616#else
17617RET(24)
17618#endif
17619}
17620
17621// MOVEMRa
17622OPCODE(0x48F0)
17623{
17624 u32 adr, res;
17625 u32 src, dst;
17626
17627 u32 *psrc;
17628
17629 FETCH_WORD(res);
17630 adr = AREG((Opcode >> 0) & 7);
17631 DECODE_EXT_WORD
17632 psrc = &DREGu32(0);
17633 dst = adr;
17634 PRE_IO
17635 do
17636 {
17637 if (res & 1)
17638 {
17639 WRITE_LONG_F(adr, *psrc)
17640 adr += 4;
17641 }
17642 psrc++;
17643 } while (res >>= 1);
17644 POST_IO
17645 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17646#ifdef USE_CYCLONE_TIMING
17647RET(14)
17648#else
17649RET(28)
17650#endif
17651}
17652
17653// MOVEMRa
17654OPCODE(0x48F8)
17655{
17656 u32 adr, res;
17657 u32 src, dst;
17658
17659 u32 *psrc;
17660
17661 FETCH_WORD(res);
17662 FETCH_SWORD(adr);
17663 psrc = &DREGu32(0);
17664 dst = adr;
17665 PRE_IO
17666 do
17667 {
17668 if (res & 1)
17669 {
17670 WRITE_LONG_F(adr, *psrc)
17671 adr += 4;
17672 }
17673 psrc++;
17674 } while (res >>= 1);
17675 POST_IO
17676 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17677#ifdef USE_CYCLONE_TIMING
17678RET(12)
17679#else
17680RET(24)
17681#endif
17682}
17683
17684// MOVEMRa
17685OPCODE(0x48F9)
17686{
17687 u32 adr, res;
17688 u32 src, dst;
17689
17690 u32 *psrc;
17691
17692 FETCH_WORD(res);
17693 FETCH_LONG(adr);
17694 psrc = &DREGu32(0);
17695 dst = adr;
17696 PRE_IO
17697 do
17698 {
17699 if (res & 1)
17700 {
17701 WRITE_LONG_F(adr, *psrc)
17702 adr += 4;
17703 }
17704 psrc++;
17705 } while (res >>= 1);
17706 POST_IO
17707 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17708#ifdef USE_CYCLONE_TIMING
17709RET(16)
17710#else
17711RET(32)
17712#endif
17713}
17714
17715// MOVEMRa
17716OPCODE(0x48E7)
17717{
17718 u32 adr, res;
17719 u32 src, dst;
17720
17721 u32 *psrc;
17722
17723 FETCH_WORD(res);
17724 adr = AREG(7);
17725 psrc = &AREGu32(7);
17726 dst = adr;
17727 PRE_IO
17728 do
17729 {
17730 if (res & 1)
17731 {
17732 adr -= 4;
17733 WRITE_LONG_DEC_F(adr, *psrc)
17734 }
17735 psrc--;
17736 } while (res >>= 1);
17737 AREG(7) = adr;
17738 POST_IO
17739 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17740RET(8)
17741}
17742
17743// EXT
17744OPCODE(0x4880)
17745{
17746 u32 adr, res;
17747 u32 src, dst;
17748
17749 res = (s32)DREGs8((Opcode >> 0) & 7);
17750 flag_C = 0;
17751 flag_V = 0;
17752 flag_NotZ = res;
17753 flag_N = res;
17754 DREGu16((Opcode >> 0) & 7) = res;
17755RET(4)
17756}
17757
17758// EXT
17759OPCODE(0x48C0)
17760{
17761 u32 adr, res;
17762 u32 src, dst;
17763
17764 res = (s32)DREGs16((Opcode >> 0) & 7);
17765 flag_C = 0;
17766 flag_V = 0;
17767 flag_NotZ = res;
17768 flag_N = res >> 8;
17769 DREGu32((Opcode >> 0) & 7) = res;
17770RET(4)
17771}
17772
17773// TST
17774OPCODE(0x4A00)
17775{
17776 u32 adr, res;
17777 u32 src, dst;
17778
17779 res = DREGu8((Opcode >> 0) & 7);
17780 flag_C = 0;
17781 flag_V = 0;
17782 flag_NotZ = res;
17783 flag_N = res;
17784RET(4)
17785}
17786
17787// TST
17788OPCODE(0x4A10)
17789{
17790 u32 adr, res;
17791 u32 src, dst;
17792
17793 adr = AREG((Opcode >> 0) & 7);
17794 PRE_IO
17795 READ_BYTE_F(adr, res)
17796 flag_C = 0;
17797 flag_V = 0;
17798 flag_NotZ = res;
17799 flag_N = res;
17800 POST_IO
17801RET(8)
17802}
17803
17804// TST
17805OPCODE(0x4A18)
17806{
17807 u32 adr, res;
17808 u32 src, dst;
17809
17810 adr = AREG((Opcode >> 0) & 7);
17811 AREG((Opcode >> 0) & 7) += 1;
17812 PRE_IO
17813 READ_BYTE_F(adr, res)
17814 flag_C = 0;
17815 flag_V = 0;
17816 flag_NotZ = res;
17817 flag_N = res;
17818 POST_IO
17819RET(8)
17820}
17821
17822// TST
17823OPCODE(0x4A20)
17824{
17825 u32 adr, res;
17826 u32 src, dst;
17827
17828 adr = AREG((Opcode >> 0) & 7) - 1;
17829 AREG((Opcode >> 0) & 7) = adr;
17830 PRE_IO
17831 READ_BYTE_F(adr, res)
17832 flag_C = 0;
17833 flag_V = 0;
17834 flag_NotZ = res;
17835 flag_N = res;
17836 POST_IO
17837RET(10)
17838}
17839
17840// TST
17841OPCODE(0x4A28)
17842{
17843 u32 adr, res;
17844 u32 src, dst;
17845
17846 FETCH_SWORD(adr);
17847 adr += AREG((Opcode >> 0) & 7);
17848 PRE_IO
17849 READ_BYTE_F(adr, res)
17850 flag_C = 0;
17851 flag_V = 0;
17852 flag_NotZ = res;
17853 flag_N = res;
17854 POST_IO
17855RET(12)
17856}
17857
17858// TST
17859OPCODE(0x4A30)
17860{
17861 u32 adr, res;
17862 u32 src, dst;
17863
17864 adr = AREG((Opcode >> 0) & 7);
17865 DECODE_EXT_WORD
17866 PRE_IO
17867 READ_BYTE_F(adr, res)
17868 flag_C = 0;
17869 flag_V = 0;
17870 flag_NotZ = res;
17871 flag_N = res;
17872 POST_IO
17873RET(14)
17874}
17875
17876// TST
17877OPCODE(0x4A38)
17878{
17879 u32 adr, res;
17880 u32 src, dst;
17881
17882 FETCH_SWORD(adr);
17883 PRE_IO
17884 READ_BYTE_F(adr, res)
17885 flag_C = 0;
17886 flag_V = 0;
17887 flag_NotZ = res;
17888 flag_N = res;
17889 POST_IO
17890RET(12)
17891}
17892
17893// TST
17894OPCODE(0x4A39)
17895{
17896 u32 adr, res;
17897 u32 src, dst;
17898
17899 FETCH_LONG(adr);
17900 PRE_IO
17901 READ_BYTE_F(adr, res)
17902 flag_C = 0;
17903 flag_V = 0;
17904 flag_NotZ = res;
17905 flag_N = res;
17906 POST_IO
17907RET(16)
17908}
17909
17910// TST
17911OPCODE(0x4A1F)
17912{
17913 u32 adr, res;
17914 u32 src, dst;
17915
17916 adr = AREG(7);
17917 AREG(7) += 2;
17918 PRE_IO
17919 READ_BYTE_F(adr, res)
17920 flag_C = 0;
17921 flag_V = 0;
17922 flag_NotZ = res;
17923 flag_N = res;
17924 POST_IO
17925RET(8)
17926}
17927
17928// TST
17929OPCODE(0x4A27)
17930{
17931 u32 adr, res;
17932 u32 src, dst;
17933
17934 adr = AREG(7) - 2;
17935 AREG(7) = adr;
17936 PRE_IO
17937 READ_BYTE_F(adr, res)
17938 flag_C = 0;
17939 flag_V = 0;
17940 flag_NotZ = res;
17941 flag_N = res;
17942 POST_IO
17943RET(10)
17944}
17945
17946// TST
17947OPCODE(0x4A40)
17948{
17949 u32 adr, res;
17950 u32 src, dst;
17951
17952 res = DREGu16((Opcode >> 0) & 7);
17953 flag_C = 0;
17954 flag_V = 0;
17955 flag_NotZ = res;
17956 flag_N = res >> 8;
17957RET(4)
17958}
17959
17960// TST
17961OPCODE(0x4A50)
17962{
17963 u32 adr, res;
17964 u32 src, dst;
17965
17966 adr = AREG((Opcode >> 0) & 7);
17967 PRE_IO
17968 READ_WORD_F(adr, res)
17969 flag_C = 0;
17970 flag_V = 0;
17971 flag_NotZ = res;
17972 flag_N = res >> 8;
17973 POST_IO
17974RET(8)
17975}
17976
17977// TST
17978OPCODE(0x4A58)
17979{
17980 u32 adr, res;
17981 u32 src, dst;
17982
17983 adr = AREG((Opcode >> 0) & 7);
17984 AREG((Opcode >> 0) & 7) += 2;
17985 PRE_IO
17986 READ_WORD_F(adr, res)
17987 flag_C = 0;
17988 flag_V = 0;
17989 flag_NotZ = res;
17990 flag_N = res >> 8;
17991 POST_IO
17992RET(8)
17993}
17994
17995// TST
17996OPCODE(0x4A60)
17997{
17998 u32 adr, res;
17999 u32 src, dst;
18000
18001 adr = AREG((Opcode >> 0) & 7) - 2;
18002 AREG((Opcode >> 0) & 7) = adr;
18003 PRE_IO
18004 READ_WORD_F(adr, res)
18005 flag_C = 0;
18006 flag_V = 0;
18007 flag_NotZ = res;
18008 flag_N = res >> 8;
18009 POST_IO
18010RET(10)
18011}
18012
18013// TST
18014OPCODE(0x4A68)
18015{
18016 u32 adr, res;
18017 u32 src, dst;
18018
18019 FETCH_SWORD(adr);
18020 adr += AREG((Opcode >> 0) & 7);
18021 PRE_IO
18022 READ_WORD_F(adr, res)
18023 flag_C = 0;
18024 flag_V = 0;
18025 flag_NotZ = res;
18026 flag_N = res >> 8;
18027 POST_IO
18028RET(12)
18029}
18030
18031// TST
18032OPCODE(0x4A70)
18033{
18034 u32 adr, res;
18035 u32 src, dst;
18036
18037 adr = AREG((Opcode >> 0) & 7);
18038 DECODE_EXT_WORD
18039 PRE_IO
18040 READ_WORD_F(adr, res)
18041 flag_C = 0;
18042 flag_V = 0;
18043 flag_NotZ = res;
18044 flag_N = res >> 8;
18045 POST_IO
18046RET(14)
18047}
18048
18049// TST
18050OPCODE(0x4A78)
18051{
18052 u32 adr, res;
18053 u32 src, dst;
18054
18055 FETCH_SWORD(adr);
18056 PRE_IO
18057 READ_WORD_F(adr, res)
18058 flag_C = 0;
18059 flag_V = 0;
18060 flag_NotZ = res;
18061 flag_N = res >> 8;
18062 POST_IO
18063RET(12)
18064}
18065
18066// TST
18067OPCODE(0x4A79)
18068{
18069 u32 adr, res;
18070 u32 src, dst;
18071
18072 FETCH_LONG(adr);
18073 PRE_IO
18074 READ_WORD_F(adr, res)
18075 flag_C = 0;
18076 flag_V = 0;
18077 flag_NotZ = res;
18078 flag_N = res >> 8;
18079 POST_IO
18080RET(16)
18081}
18082
18083// TST
18084OPCODE(0x4A5F)
18085{
18086 u32 adr, res;
18087 u32 src, dst;
18088
18089 adr = AREG(7);
18090 AREG(7) += 2;
18091 PRE_IO
18092 READ_WORD_F(adr, res)
18093 flag_C = 0;
18094 flag_V = 0;
18095 flag_NotZ = res;
18096 flag_N = res >> 8;
18097 POST_IO
18098RET(8)
18099}
18100
18101// TST
18102OPCODE(0x4A67)
18103{
18104 u32 adr, res;
18105 u32 src, dst;
18106
18107 adr = AREG(7) - 2;
18108 AREG(7) = adr;
18109 PRE_IO
18110 READ_WORD_F(adr, res)
18111 flag_C = 0;
18112 flag_V = 0;
18113 flag_NotZ = res;
18114 flag_N = res >> 8;
18115 POST_IO
18116RET(10)
18117}
18118
18119// TST
18120OPCODE(0x4A80)
18121{
18122 u32 adr, res;
18123 u32 src, dst;
18124
18125 res = DREGu32((Opcode >> 0) & 7);
18126 flag_C = 0;
18127 flag_V = 0;
18128 flag_NotZ = res;
18129 flag_N = res >> 24;
18130RET(4)
18131}
18132
18133// TST
18134OPCODE(0x4A90)
18135{
18136 u32 adr, res;
18137 u32 src, dst;
18138
18139 adr = AREG((Opcode >> 0) & 7);
18140 PRE_IO
18141 READ_LONG_F(adr, res)
18142 flag_C = 0;
18143 flag_V = 0;
18144 flag_NotZ = res;
18145 flag_N = res >> 24;
18146 POST_IO
18147RET(12)
18148}
18149
18150// TST
18151OPCODE(0x4A98)
18152{
18153 u32 adr, res;
18154 u32 src, dst;
18155
18156 adr = AREG((Opcode >> 0) & 7);
18157 AREG((Opcode >> 0) & 7) += 4;
18158 PRE_IO
18159 READ_LONG_F(adr, res)
18160 flag_C = 0;
18161 flag_V = 0;
18162 flag_NotZ = res;
18163 flag_N = res >> 24;
18164 POST_IO
18165RET(12)
18166}
18167
18168// TST
18169OPCODE(0x4AA0)
18170{
18171 u32 adr, res;
18172 u32 src, dst;
18173
18174 adr = AREG((Opcode >> 0) & 7) - 4;
18175 AREG((Opcode >> 0) & 7) = adr;
18176 PRE_IO
18177 READ_LONG_F(adr, res)
18178 flag_C = 0;
18179 flag_V = 0;
18180 flag_NotZ = res;
18181 flag_N = res >> 24;
18182 POST_IO
18183RET(14)
18184}
18185
18186// TST
18187OPCODE(0x4AA8)
18188{
18189 u32 adr, res;
18190 u32 src, dst;
18191
18192 FETCH_SWORD(adr);
18193 adr += AREG((Opcode >> 0) & 7);
18194 PRE_IO
18195 READ_LONG_F(adr, res)
18196 flag_C = 0;
18197 flag_V = 0;
18198 flag_NotZ = res;
18199 flag_N = res >> 24;
18200 POST_IO
18201RET(16)
18202}
18203
18204// TST
18205OPCODE(0x4AB0)
18206{
18207 u32 adr, res;
18208 u32 src, dst;
18209
18210 adr = AREG((Opcode >> 0) & 7);
18211 DECODE_EXT_WORD
18212 PRE_IO
18213 READ_LONG_F(adr, res)
18214 flag_C = 0;
18215 flag_V = 0;
18216 flag_NotZ = res;
18217 flag_N = res >> 24;
18218 POST_IO
18219RET(18)
18220}
18221
18222// TST
18223OPCODE(0x4AB8)
18224{
18225 u32 adr, res;
18226 u32 src, dst;
18227
18228 FETCH_SWORD(adr);
18229 PRE_IO
18230 READ_LONG_F(adr, res)
18231 flag_C = 0;
18232 flag_V = 0;
18233 flag_NotZ = res;
18234 flag_N = res >> 24;
18235 POST_IO
18236RET(16)
18237}
18238
18239// TST
18240OPCODE(0x4AB9)
18241{
18242 u32 adr, res;
18243 u32 src, dst;
18244
18245 FETCH_LONG(adr);
18246 PRE_IO
18247 READ_LONG_F(adr, res)
18248 flag_C = 0;
18249 flag_V = 0;
18250 flag_NotZ = res;
18251 flag_N = res >> 24;
18252 POST_IO
18253RET(20)
18254}
18255
18256// TST
18257OPCODE(0x4A9F)
18258{
18259 u32 adr, res;
18260 u32 src, dst;
18261
18262 adr = AREG(7);
18263 AREG(7) += 4;
18264 PRE_IO
18265 READ_LONG_F(adr, res)
18266 flag_C = 0;
18267 flag_V = 0;
18268 flag_NotZ = res;
18269 flag_N = res >> 24;
18270 POST_IO
18271RET(12)
18272}
18273
18274// TST
18275OPCODE(0x4AA7)
18276{
18277 u32 adr, res;
18278 u32 src, dst;
18279
18280 adr = AREG(7) - 4;
18281 AREG(7) = adr;
18282 PRE_IO
18283 READ_LONG_F(adr, res)
18284 flag_C = 0;
18285 flag_V = 0;
18286 flag_NotZ = res;
18287 flag_N = res >> 24;
18288 POST_IO
18289RET(14)
18290}
18291
18292// TAS
18293OPCODE(0x4AC0)
18294{
18295 u32 adr, res;
18296 u32 src, dst;
18297
18298 res = DREGu8((Opcode >> 0) & 7);
18299 flag_C = 0;
18300 flag_V = 0;
18301 flag_NotZ = res;
18302 flag_N = res;
18303 res |= 0x80;
18304 DREGu8((Opcode >> 0) & 7) = res;
18305RET(4)
18306}
18307
18308// TAS
18309OPCODE(0x4AD0)
18310{
18311 u32 adr, res;
18312 u32 src, dst;
18313
18314 adr = AREG((Opcode >> 0) & 7);
18315 PRE_IO
18316 READ_BYTE_F(adr, res)
18317 flag_C = 0;
18318 flag_V = 0;
18319 flag_NotZ = res;
18320 flag_N = res;
b5e5172d 18321#ifdef PICODRIVE_HACK
18322 if (g_m68kcontext == &PicoCpuFS68k) {
18323 res |= 0x80;
18324 WRITE_BYTE_F(adr, res);
18325 }
18326#endif
18327
70357ce5 18328 POST_IO
b5e5172d 18329#ifdef USE_CYCLONE_TIMING
18330RET(18)
18331#else
70357ce5 18332RET(8)
b5e5172d 18333#endif
70357ce5 18334}
18335
18336// TAS
18337OPCODE(0x4AD8)
18338{
18339 u32 adr, res;
18340 u32 src, dst;
18341
18342 adr = AREG((Opcode >> 0) & 7);
18343 AREG((Opcode >> 0) & 7) += 1;
18344 PRE_IO
18345 READ_BYTE_F(adr, res)
18346 flag_C = 0;
18347 flag_V = 0;
18348 flag_NotZ = res;
18349 flag_N = res;
b5e5172d 18350
18351#ifdef PICODRIVE_HACK
18352 if (g_m68kcontext == &PicoCpuFS68k) {
18353 res |= 0x80;
18354 WRITE_BYTE_F(adr, res);
18355 }
18356#endif
18357
70357ce5 18358 POST_IO
b5e5172d 18359#ifdef USE_CYCLONE_TIMING
18360RET(18)
18361#else
70357ce5 18362RET(8)
b5e5172d 18363#endif
70357ce5 18364}
18365
18366// TAS
18367OPCODE(0x4AE0)
18368{
18369 u32 adr, res;
18370 u32 src, dst;
18371
18372 adr = AREG((Opcode >> 0) & 7) - 1;
18373 AREG((Opcode >> 0) & 7) = adr;
18374 PRE_IO
18375 READ_BYTE_F(adr, res)
18376 flag_C = 0;
18377 flag_V = 0;
18378 flag_NotZ = res;
18379 flag_N = res;
b5e5172d 18380
18381#ifdef PICODRIVE_HACK
18382 if (g_m68kcontext == &PicoCpuFS68k) {
18383 res |= 0x80;
18384 WRITE_BYTE_F(adr, res);
18385 }
18386#endif
18387
70357ce5 18388 POST_IO
b5e5172d 18389#ifdef USE_CYCLONE_TIMING
18390RET(20)
18391#else
70357ce5 18392RET(10)
b5e5172d 18393#endif
70357ce5 18394}
18395
18396// TAS
18397OPCODE(0x4AE8)
18398{
18399 u32 adr, res;
18400 u32 src, dst;
18401
18402 FETCH_SWORD(adr);
18403 adr += AREG((Opcode >> 0) & 7);
18404 PRE_IO
18405 READ_BYTE_F(adr, res)
18406 flag_C = 0;
18407 flag_V = 0;
18408 flag_NotZ = res;
18409 flag_N = res;
b5e5172d 18410
18411#ifdef PICODRIVE_HACK
18412 if (g_m68kcontext == &PicoCpuFS68k) {
18413 res |= 0x80;
18414 WRITE_BYTE_F(adr, res);
18415 }
18416#endif
18417
70357ce5 18418 POST_IO
b5e5172d 18419#ifdef USE_CYCLONE_TIMING
18420RET(22)
18421#else
70357ce5 18422RET(12)
b5e5172d 18423#endif
70357ce5 18424}
18425
18426// TAS
18427OPCODE(0x4AF0)
18428{
18429 u32 adr, res;
18430 u32 src, dst;
18431
18432 adr = AREG((Opcode >> 0) & 7);
18433 DECODE_EXT_WORD
18434 PRE_IO
18435 READ_BYTE_F(adr, res)
18436 flag_C = 0;
18437 flag_V = 0;
18438 flag_NotZ = res;
18439 flag_N = res;
b5e5172d 18440
18441#ifdef PICODRIVE_HACK
18442 if (g_m68kcontext == &PicoCpuFS68k) {
18443 res |= 0x80;
18444 WRITE_BYTE_F(adr, res);
18445 }
18446#endif
18447
70357ce5 18448 POST_IO
b5e5172d 18449#ifdef USE_CYCLONE_TIMING
18450RET(24)
18451#else
70357ce5 18452RET(14)
b5e5172d 18453#endif
70357ce5 18454}
18455
18456// TAS
18457OPCODE(0x4AF8)
18458{
18459 u32 adr, res;
18460 u32 src, dst;
18461
18462 FETCH_SWORD(adr);
18463 PRE_IO
18464 READ_BYTE_F(adr, res)
18465 flag_C = 0;
18466 flag_V = 0;
18467 flag_NotZ = res;
18468 flag_N = res;
b5e5172d 18469
18470#ifdef PICODRIVE_HACK
18471 if (g_m68kcontext == &PicoCpuFS68k) {
18472 res |= 0x80;
18473 WRITE_BYTE_F(adr, res);
18474 }
18475#endif
18476
70357ce5 18477 POST_IO
b5e5172d 18478#ifdef USE_CYCLONE_TIMING
18479RET(22)
18480#else
70357ce5 18481RET(12)
b5e5172d 18482#endif
70357ce5 18483}
18484
18485// TAS
18486OPCODE(0x4AF9)
18487{
18488 u32 adr, res;
18489 u32 src, dst;
18490
18491 FETCH_LONG(adr);
18492 PRE_IO
18493 READ_BYTE_F(adr, res)
18494 flag_C = 0;
18495 flag_V = 0;
18496 flag_NotZ = res;
18497 flag_N = res;
b5e5172d 18498
18499#ifdef PICODRIVE_HACK
18500 if (g_m68kcontext == &PicoCpuFS68k) {
18501 res |= 0x80;
18502 WRITE_BYTE_F(adr, res);
18503 }
18504#endif
18505
70357ce5 18506 POST_IO
b5e5172d 18507#ifdef USE_CYCLONE_TIMING
18508RET(26)
18509#else
70357ce5 18510RET(16)
b5e5172d 18511#endif
70357ce5 18512}
18513
18514// TAS
18515OPCODE(0x4ADF)
18516{
18517 u32 adr, res;
18518 u32 src, dst;
18519
18520 adr = AREG(7);
18521 AREG(7) += 2;
18522 PRE_IO
18523 READ_BYTE_F(adr, res)
18524 flag_C = 0;
18525 flag_V = 0;
18526 flag_NotZ = res;
18527 flag_N = res;
b5e5172d 18528
18529#ifdef PICODRIVE_HACK
18530 if (g_m68kcontext == &PicoCpuFS68k) {
18531 res |= 0x80;
18532 WRITE_BYTE_F(adr, res);
18533 }
18534#endif
18535
70357ce5 18536 POST_IO
b5e5172d 18537#ifdef USE_CYCLONE_TIMING
18538RET(18)
18539#else
70357ce5 18540RET(8)
b5e5172d 18541#endif
70357ce5 18542}
18543
18544// TAS
18545OPCODE(0x4AE7)
18546{
18547 u32 adr, res;
18548 u32 src, dst;
18549
18550 adr = AREG(7) - 2;
18551 AREG(7) = adr;
18552 PRE_IO
18553 READ_BYTE_F(adr, res)
18554 flag_C = 0;
18555 flag_V = 0;
18556 flag_NotZ = res;
18557 flag_N = res;
b5e5172d 18558
18559#ifdef PICODRIVE_HACK
18560 if (g_m68kcontext == &PicoCpuFS68k) {
18561 res |= 0x80;
18562 WRITE_BYTE_F(adr, res);
18563 }
18564#endif
18565
70357ce5 18566 POST_IO
b5e5172d 18567#ifdef USE_CYCLONE_TIMING
18568RET(20)
18569#else
18570RET(8)
18571#endif
70357ce5 18572}
18573
18574// ILLEGAL
18575OPCODE(0x4AFC)
18576{
d0ae0cb4 18577 SET_PC(execute_exception(M68K_ILLEGAL_INSTRUCTION_EX, GET_PC-2, GET_SR));
03e4f2a3 18578RET(0)
70357ce5 18579}
18580
18581// ILLEGAL A000-AFFF
18582OPCODE(0xA000)
18583{
d0ae0cb4 18584 SET_PC(execute_exception(M68K_1010_EX, GET_PC-2, GET_SR));
03e4f2a3 18585RET(0)
70357ce5 18586}
18587
18588// ILLEGAL F000-FFFF
18589OPCODE(0xF000)
18590{
d0ae0cb4 18591 SET_PC(execute_exception(M68K_1111_EX, GET_PC-2, GET_SR));
03e4f2a3 18592RET(0) // 4 already taken by exc. handler
70357ce5 18593}
18594
18595// MOVEMaR
18596OPCODE(0x4C90)
18597{
18598 u32 adr, res;
18599 u32 src, dst;
18600
18601 s32 *psrc;
18602
18603 FETCH_WORD(res);
18604 adr = AREG((Opcode >> 0) & 7);
18605 psrc = &DREGs32(0);
18606 dst = adr;
18607 PRE_IO
18608 do
18609 {
18610 if (res & 1)
18611 {
18612 READSX_WORD_F(adr, *psrc)
18613 adr += 2;
18614 }
18615 psrc++;
18616 } while (res >>= 1);
18617 POST_IO
18618 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18619#ifdef USE_CYCLONE_TIMING
18620RET(12)
18621#else
18622RET(16)
18623#endif
18624}
18625
18626// MOVEMaR
18627OPCODE(0x4C98)
18628{
18629 u32 adr, res;
18630 u32 src, dst;
18631
18632 s32 *psrc;
18633
18634 FETCH_WORD(res);
18635 adr = AREG((Opcode >> 0) & 7);
18636 psrc = &DREGs32(0);
18637 dst = adr;
18638 PRE_IO
18639 do
18640 {
18641 if (res & 1)
18642 {
18643 READSX_WORD_F(adr, *psrc)
18644 adr += 2;
18645 }
18646 psrc++;
18647 } while (res >>= 1);
18648 AREG((Opcode >> 0) & 7) = adr;
18649 POST_IO
18650 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18651RET(12)
18652}
18653
18654// MOVEMaR
18655OPCODE(0x4CA8)
18656{
18657 u32 adr, res;
18658 u32 src, dst;
18659
18660 s32 *psrc;
18661
18662 FETCH_WORD(res);
18663 FETCH_SWORD(adr);
18664 adr += AREG((Opcode >> 0) & 7);
18665 psrc = &DREGs32(0);
18666 dst = adr;
18667 PRE_IO
18668 do
18669 {
18670 if (res & 1)
18671 {
18672 READSX_WORD_F(adr, *psrc)
18673 adr += 2;
18674 }
18675 psrc++;
18676 } while (res >>= 1);
18677 POST_IO
18678 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18679#ifdef USE_CYCLONE_TIMING
18680RET(16)
18681#else
18682RET(24)
18683#endif
18684}
18685
18686// MOVEMaR
18687OPCODE(0x4CB0)
18688{
18689 u32 adr, res;
18690 u32 src, dst;
18691
18692 s32 *psrc;
18693
18694 FETCH_WORD(res);
18695 adr = AREG((Opcode >> 0) & 7);
18696 DECODE_EXT_WORD
18697 psrc = &DREGs32(0);
18698 dst = adr;
18699 PRE_IO
18700 do
18701 {
18702 if (res & 1)
18703 {
18704 READSX_WORD_F(adr, *psrc)
18705 adr += 2;
18706 }
18707 psrc++;
18708 } while (res >>= 1);
18709 POST_IO
18710 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18711#ifdef USE_CYCLONE_TIMING
18712RET(18)
18713#else
18714RET(28)
18715#endif
18716}
18717
18718// MOVEMaR
18719OPCODE(0x4CB8)
18720{
18721 u32 adr, res;
18722 u32 src, dst;
18723
18724 s32 *psrc;
18725
18726 FETCH_WORD(res);
18727 FETCH_SWORD(adr);
18728 psrc = &DREGs32(0);
18729 dst = adr;
18730 PRE_IO
18731 do
18732 {
18733 if (res & 1)
18734 {
18735 READSX_WORD_F(adr, *psrc)
18736 adr += 2;
18737 }
18738 psrc++;
18739 } while (res >>= 1);
18740 POST_IO
18741 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18742#ifdef USE_CYCLONE_TIMING
18743RET(16)
18744#else
18745RET(24)
18746#endif
18747}
18748
18749// MOVEMaR
18750OPCODE(0x4CB9)
18751{
18752 u32 adr, res;
18753 u32 src, dst;
18754
18755 s32 *psrc;
18756
18757 FETCH_WORD(res);
18758 FETCH_LONG(adr);
18759 psrc = &DREGs32(0);
18760 dst = adr;
18761 PRE_IO
18762 do
18763 {
18764 if (res & 1)
18765 {
18766 READSX_WORD_F(adr, *psrc)
18767 adr += 2;
18768 }
18769 psrc++;
18770 } while (res >>= 1);
18771 POST_IO
18772 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18773#ifdef USE_CYCLONE_TIMING
18774RET(20)
18775#else
18776RET(32)
18777#endif
18778}
18779
18780// MOVEMaR
18781OPCODE(0x4CBA)
18782{
18783 u32 adr, res;
18784 u32 src, dst;
18785
18786 s32 *psrc;
18787
18788 FETCH_WORD(res);
be26eb23 18789 adr = GET_SWORD + GET_PC;
70357ce5 18790 PC++;
18791 psrc = &DREGs32(0);
18792 dst = adr;
18793 PRE_IO
18794 do
18795 {
18796 if (res & 1)
18797 {
18798 READSX_WORD_F(adr, *psrc)
18799 adr += 2;
18800 }
18801 psrc++;
18802 } while (res >>= 1);
18803 POST_IO
18804 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18805#ifdef USE_CYCLONE_TIMING
18806RET(16)
18807#else
18808RET(24)
18809#endif
18810}
18811
18812// MOVEMaR
18813OPCODE(0x4CBB)
18814{
18815 u32 adr, res;
18816 u32 src, dst;
18817
18818 s32 *psrc;
18819
18820 FETCH_WORD(res);
be26eb23 18821 adr = GET_PC;
70357ce5 18822 DECODE_EXT_WORD
18823 psrc = &DREGs32(0);
18824 dst = adr;
18825 PRE_IO
18826 do
18827 {
18828 if (res & 1)
18829 {
18830 READSX_WORD_F(adr, *psrc)
18831 adr += 2;
18832 }
18833 psrc++;
18834 } while (res >>= 1);
18835 POST_IO
18836 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18837#ifdef USE_CYCLONE_TIMING
18838RET(18)
18839#else
18840RET(28)
18841#endif
18842}
18843
18844// MOVEMaR
18845OPCODE(0x4C9F)
18846{
18847 u32 adr, res;
18848 u32 src, dst;
18849
18850 s32 *psrc;
18851
18852 FETCH_WORD(res);
18853 adr = AREG(7);
18854 psrc = &DREGs32(0);
18855 dst = adr;
18856 PRE_IO
18857 do
18858 {
18859 if (res & 1)
18860 {
18861 READSX_WORD_F(adr, *psrc)
18862 adr += 2;
18863 }
18864 psrc++;
18865 } while (res >>= 1);
18866 AREG(7) = adr;
18867 POST_IO
18868 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18869RET(12)
18870}
18871
18872// MOVEMaR
18873OPCODE(0x4CD0)
18874{
18875 u32 adr, res;
18876 u32 src, dst;
18877
18878 u32 *psrc;
18879
18880 FETCH_WORD(res);
18881 adr = AREG((Opcode >> 0) & 7);
18882 psrc = &DREGu32(0);
18883 dst = adr;
18884 PRE_IO
18885 do
18886 {
18887 if (res & 1)
18888 {
18889 READ_LONG_F(adr, *psrc)
18890 adr += 4;
18891 }
18892 psrc++;
18893 } while (res >>= 1);
18894 POST_IO
18895 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18896#ifdef USE_CYCLONE_TIMING
18897RET(12)
18898#else
18899RET(20)
18900#endif
18901}
18902
18903// MOVEMaR
18904OPCODE(0x4CD8)
18905{
18906 u32 adr, res;
18907 u32 src, dst;
18908
18909 u32 *psrc;
18910
18911 FETCH_WORD(res);
18912 adr = AREG((Opcode >> 0) & 7);
18913 psrc = &DREGu32(0);
18914 dst = adr;
18915 PRE_IO
18916 do
18917 {
18918 if (res & 1)
18919 {
18920 READ_LONG_F(adr, *psrc)
18921 adr += 4;
18922 }
18923 psrc++;
18924 } while (res >>= 1);
18925 AREG((Opcode >> 0) & 7) = adr;
18926 POST_IO
18927 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18928RET(12)
18929}
18930
18931// MOVEMaR
18932OPCODE(0x4CE8)
18933{
18934 u32 adr, res;
18935 u32 src, dst;
18936
18937 u32 *psrc;
18938
18939 FETCH_WORD(res);
18940 FETCH_SWORD(adr);
18941 adr += AREG((Opcode >> 0) & 7);
18942 psrc = &DREGu32(0);
18943 dst = adr;
18944 PRE_IO
18945 do
18946 {
18947 if (res & 1)
18948 {
18949 READ_LONG_F(adr, *psrc)
18950 adr += 4;
18951 }
18952 psrc++;
18953 } while (res >>= 1);
18954 POST_IO
18955 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18956#ifdef USE_CYCLONE_TIMING
18957RET(16)
18958#else
18959RET(28)
18960#endif
18961}
18962
18963// MOVEMaR
18964OPCODE(0x4CF0)
18965{
18966 u32 adr, res;
18967 u32 src, dst;
18968
18969 u32 *psrc;
18970
18971 FETCH_WORD(res);
18972 adr = AREG((Opcode >> 0) & 7);
18973 DECODE_EXT_WORD
18974 psrc = &DREGu32(0);
18975 dst = adr;
18976 PRE_IO
18977 do
18978 {
18979 if (res & 1)
18980 {
18981 READ_LONG_F(adr, *psrc)
18982 adr += 4;
18983 }
18984 psrc++;
18985 } while (res >>= 1);
18986 POST_IO
18987 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18988#ifdef USE_CYCLONE_TIMING
18989RET(18)
18990#else
18991RET(32)
18992#endif
18993}
18994
18995// MOVEMaR
18996OPCODE(0x4CF8)
18997{
18998 u32 adr, res;
18999 u32 src, dst;
19000
19001 u32 *psrc;
19002
19003 FETCH_WORD(res);
19004 FETCH_SWORD(adr);
19005 psrc = &DREGu32(0);
19006 dst = adr;
19007 PRE_IO
19008 do
19009 {
19010 if (res & 1)
19011 {
19012 READ_LONG_F(adr, *psrc)
19013 adr += 4;
19014 }
19015 psrc++;
19016 } while (res >>= 1);
19017 POST_IO
19018 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19019#ifdef USE_CYCLONE_TIMING
19020RET(16)
19021#else
19022RET(28)
19023#endif
19024}
19025
19026// MOVEMaR
19027OPCODE(0x4CF9)
19028{
19029 u32 adr, res;
19030 u32 src, dst;
19031
19032 u32 *psrc;
19033
19034 FETCH_WORD(res);
19035 FETCH_LONG(adr);
19036 psrc = &DREGu32(0);
19037 dst = adr;
19038 PRE_IO
19039 do
19040 {
19041 if (res & 1)
19042 {
19043 READ_LONG_F(adr, *psrc)
19044 adr += 4;
19045 }
19046 psrc++;
19047 } while (res >>= 1);
19048 POST_IO
19049 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19050#ifdef USE_CYCLONE_TIMING
19051RET(20)
19052#else
19053RET(36)
19054#endif
19055}
19056
19057// MOVEMaR
19058OPCODE(0x4CFA)
19059{
19060 u32 adr, res;
19061 u32 src, dst;
19062
19063 u32 *psrc;
19064
19065 FETCH_WORD(res);
be26eb23 19066 adr = GET_SWORD + GET_PC;
70357ce5 19067 PC++;
19068 psrc = &DREGu32(0);
19069 dst = adr;
19070 PRE_IO
19071 do
19072 {
19073 if (res & 1)
19074 {
19075 READ_LONG_F(adr, *psrc)
19076 adr += 4;
19077 }
19078 psrc++;
19079 } while (res >>= 1);
19080 POST_IO
19081 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19082#ifdef USE_CYCLONE_TIMING
19083RET(16)
19084#else
19085RET(28)
19086#endif
19087}
19088
19089// MOVEMaR
19090OPCODE(0x4CFB)
19091{
19092 u32 adr, res;
19093 u32 src, dst;
19094
19095 u32 *psrc;
19096
19097 FETCH_WORD(res);
be26eb23 19098 adr = GET_PC;
70357ce5 19099 DECODE_EXT_WORD
19100 psrc = &DREGu32(0);
19101 dst = adr;
19102 PRE_IO
19103 do
19104 {
19105 if (res & 1)
19106 {
19107 READ_LONG_F(adr, *psrc)
19108 adr += 4;
19109 }
19110 psrc++;
19111 } while (res >>= 1);
19112 POST_IO
19113 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19114#ifdef USE_CYCLONE_TIMING
19115RET(18)
19116#else
19117RET(32)
19118#endif
19119}
19120
19121// MOVEMaR
19122OPCODE(0x4CDF)
19123{
19124 u32 adr, res;
19125 u32 src, dst;
19126
19127 u32 *psrc;
19128
19129 FETCH_WORD(res);
19130 adr = AREG(7);
19131 psrc = &DREGu32(0);
19132 dst = adr;
19133 PRE_IO
19134 do
19135 {
19136 if (res & 1)
19137 {
19138 READ_LONG_F(adr, *psrc)
19139 adr += 4;
19140 }
19141 psrc++;
19142 } while (res >>= 1);
19143 AREG(7) = adr;
19144 POST_IO
19145 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19146RET(12)
19147}
19148
19149// TRAP
19150OPCODE(0x4E40)
19151{
d0ae0cb4 19152 SET_PC(execute_exception(M68K_TRAP_BASE_EX + (Opcode & 0xF), GET_PC, GET_SR));
70357ce5 19153RET(4)
19154}
19155
19156// LINK
19157OPCODE(0x4E50)
19158{
19159 u32 adr, res;
19160 u32 src, dst;
19161
19162 res = AREGu32((Opcode >> 0) & 7);
19163 PRE_IO
19164 PUSH_32_F(res)
19165 res = AREG(7);
19166 AREG((Opcode >> 0) & 7) = res;
19167 FETCH_SWORD(res);
19168 AREG(7) += res;
19169 POST_IO
19170RET(16)
19171}
19172
19173// LINKA7
19174OPCODE(0x4E57)
19175{
19176 u32 adr, res;
19177 u32 src, dst;
19178
19179 AREG(7) -= 4;
19180 PRE_IO
19181 WRITE_LONG_DEC_F(AREG(7), AREG(7))
19182 FETCH_SWORD(res);
19183 AREG(7) += res;
19184 POST_IO
19185RET(16)
19186}
19187
19188// ULNK
19189OPCODE(0x4E58)
19190{
19191 u32 adr, res;
19192 u32 src, dst;
19193
19194 src = AREGu32((Opcode >> 0) & 7);
19195 AREG(7) = src + 4;
19196 PRE_IO
19197 READ_LONG_F(src, res)
19198 AREG((Opcode >> 0) & 7) = res;
19199 POST_IO
19200RET(12)
19201}
19202
19203// ULNKA7
19204OPCODE(0x4E5F)
19205{
19206 u32 adr, res;
19207 u32 src, dst;
19208
19209 PRE_IO
19210 READ_LONG_F(AREG(7), AREG(7))
19211 POST_IO
19212RET(12)
19213}
19214
19215// MOVEAUSP
19216OPCODE(0x4E60)
19217{
19218 u32 adr, res;
19219 u32 src, dst;
19220
19221 if (!flag_S)
19222 {
d0ae0cb4 19223 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19224 RET(4)
19225 }
19226 res = AREGu32((Opcode >> 0) & 7);
19227 ASP = res;
19228RET(4)
19229}
19230
19231// MOVEUSPA
19232OPCODE(0x4E68)
19233{
19234 u32 adr, res;
19235 u32 src, dst;
19236
19237 if (!flag_S)
19238 {
d0ae0cb4 19239 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19240 RET(4)
19241 }
19242 res = ASP;
19243 AREG((Opcode >> 0) & 7) = res;
19244RET(4)
19245}
19246
19247// RESET
19248OPCODE(0x4E70)
19249{
19250 u32 adr, res;
19251 u32 src, dst;
19252
19253 if (!flag_S)
19254 {
d0ae0cb4 19255 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19256 RET(4)
19257 }
19258 PRE_IO
19259 if (m68kcontext.reset_handler) m68kcontext.reset_handler();
19260// CPU->Reset_CallBack();
19261 POST_IO
19262RET(132)
19263}
19264
19265// NOP
19266OPCODE(0x4E71)
19267{
19268RET(4)
19269}
19270
19271// STOP
19272OPCODE(0x4E72)
19273{
19274 u32 adr, res;
19275 u32 src, dst;
19276
19277 if (!flag_S)
19278 {
d0ae0cb4 19279 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19280 RET(4)
19281 }
19282 FETCH_WORD(res);
19283 res &= M68K_SR_MASK;
19284 SET_SR(res)
19285 if (!flag_S)
19286 {
19287 res = AREG(7);
19288 AREG(7) = ASP;
19289 ASP = res;
19290 }
03e4f2a3 19291 m68kcontext.execinfo |= FM68K_HALTED;
fcf94fcc 19292RET0()
70357ce5 19293}
19294
19295// RTE
19296OPCODE(0x4E73)
19297{
19298 u32 adr, res;
19299 u32 src, dst;
19300
19301 if (!flag_S)
19302 {
d0ae0cb4 19303 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19304 RET(4)
19305 }
19306 PRE_IO
19307 POP_16_F(res)
19308 SET_SR(res)
19309 POP_32_F(res)
19310 SET_PC(res)
19311 if (!flag_S)
19312 {
19313 res = AREG(7);
19314 AREG(7) = ASP;
19315 ASP = res;
19316 }
19317 POST_IO
03e4f2a3 19318 m68kcontext.execinfo &= ~(FM68K_EMULATE_GROUP_0|FM68K_EMULATE_TRACE|FM68K_DO_TRACE);
70357ce5 19319 CHECK_INT_TO_JUMP(20)
19320RET(20)
19321}
19322
19323// RTS
19324OPCODE(0x4E75)
19325{
19326 u32 adr, res;
19327 u32 src, dst;
19328
19329 PRE_IO
19330 POP_32_F(res)
19331 SET_PC(res)
19332 CHECK_BRANCH_EXCEPTION(res)
19333 POST_IO
19334RET(16)
19335}
19336
19337// TRAPV
19338OPCODE(0x4E76)
19339{
19340 if (flag_V & 0x80)
d0ae0cb4 19341 SET_PC(execute_exception(M68K_TRAPV_EX, GET_PC, GET_SR));
70357ce5 19342RET(4)
19343}
19344
19345// RTR
19346OPCODE(0x4E77)
19347{
19348 u32 adr, res;
19349 u32 src, dst;
19350
19351 PRE_IO
19352 POP_16_F(res)
19353 SET_CCR(res)
19354 POP_32_F(res)
19355 SET_PC(res)
19356 CHECK_BRANCH_EXCEPTION(res)
19357 POST_IO
19358RET(20)
19359}
19360
19361// JSR
19362OPCODE(0x4E90)
19363{
19364 u32 adr, res;
19365 u32 src, dst;
19366
19367 adr = AREG((Opcode >> 0) & 7);
19368 {
19369 u32 oldPC;
19370
be26eb23 19371 oldPC = GET_PC;
70357ce5 19372 PRE_IO
19373 PUSH_32_F(oldPC)
19374 }
19375 SET_PC(adr)
19376 CHECK_BRANCH_EXCEPTION(adr)
19377 POST_IO
19378RET(16)
19379}
19380
19381// JSR
19382OPCODE(0x4EA8)
19383{
19384 u32 adr, res;
19385 u32 src, dst;
19386
19387 FETCH_SWORD(adr);
19388 adr += AREG((Opcode >> 0) & 7);
19389 {
19390 u32 oldPC;
19391
be26eb23 19392 oldPC = GET_PC;
70357ce5 19393 PRE_IO
19394 PUSH_32_F(oldPC)
19395 }
19396 SET_PC(adr)
19397 CHECK_BRANCH_EXCEPTION(adr)
19398 POST_IO
19399RET(18)
19400}
19401
19402// JSR
19403OPCODE(0x4EB0)
19404{
19405 u32 adr, res;
19406 u32 src, dst;
19407
19408 adr = AREG((Opcode >> 0) & 7);
19409 DECODE_EXT_WORD
19410 {
19411 u32 oldPC;
19412
be26eb23 19413 oldPC = GET_PC;
70357ce5 19414 PRE_IO
19415 PUSH_32_F(oldPC)
19416 }
19417 SET_PC(adr)
19418 CHECK_BRANCH_EXCEPTION(adr)
19419 POST_IO
19420RET(22)
19421}
19422
19423// JSR
19424OPCODE(0x4EB8)
19425{
19426 u32 adr, res;
19427 u32 src, dst;
19428
19429 FETCH_SWORD(adr);
19430 {
19431 u32 oldPC;
19432
be26eb23 19433 oldPC = GET_PC;
70357ce5 19434 PRE_IO
19435 PUSH_32_F(oldPC)
19436 }
19437 SET_PC(adr)
19438 CHECK_BRANCH_EXCEPTION(adr)
19439 POST_IO
19440RET(18)
19441}
19442
19443// JSR
19444OPCODE(0x4EB9)
19445{
19446 u32 adr, res;
19447 u32 src, dst;
19448
19449 FETCH_LONG(adr);
19450 {
19451 u32 oldPC;
19452
be26eb23 19453 oldPC = GET_PC;
70357ce5 19454 PRE_IO
19455 PUSH_32_F(oldPC)
19456 }
19457 SET_PC(adr)
19458 CHECK_BRANCH_EXCEPTION(adr)
19459 POST_IO
19460RET(20)
19461}
19462
19463// JSR
19464OPCODE(0x4EBA)
19465{
19466 u32 adr, res;
19467 u32 src, dst;
19468
be26eb23 19469 adr = GET_SWORD + GET_PC;
70357ce5 19470 PC++;
19471 {
19472 u32 oldPC;
19473
be26eb23 19474 oldPC = GET_PC;
70357ce5 19475 PRE_IO
19476 PUSH_32_F(oldPC)
19477 }
19478 SET_PC(adr)
19479 CHECK_BRANCH_EXCEPTION(adr)
19480 POST_IO
19481RET(18)
19482}
19483
19484// JSR
19485OPCODE(0x4EBB)
19486{
19487 u32 adr, res;
19488 u32 src, dst;
19489
be26eb23 19490 adr = GET_PC;
70357ce5 19491 DECODE_EXT_WORD
19492 {
19493 u32 oldPC;
19494
be26eb23 19495 oldPC = GET_PC;
70357ce5 19496 PRE_IO
19497 PUSH_32_F(oldPC)
19498 }
19499 SET_PC(adr)
19500 CHECK_BRANCH_EXCEPTION(adr)
19501 POST_IO
19502RET(22)
19503}
19504
19505// JMP
19506OPCODE(0x4ED0)
19507{
19508 u32 adr, res;
19509 u32 src, dst;
19510
19511 adr = AREG((Opcode >> 0) & 7);
19512 SET_PC(adr)
19513 CHECK_BRANCH_EXCEPTION(adr)
19514RET(8)
19515}
19516
19517// JMP
19518OPCODE(0x4EE8)
19519{
19520 u32 adr, res;
19521 u32 src, dst;
19522
19523 FETCH_SWORD(adr);
19524 adr += AREG((Opcode >> 0) & 7);
19525 SET_PC(adr)
19526 CHECK_BRANCH_EXCEPTION(adr)
19527RET(10)
19528}
19529
19530// JMP
19531OPCODE(0x4EF0)
19532{
19533 u32 adr, res;
19534 u32 src, dst;
19535
19536 adr = AREG((Opcode >> 0) & 7);
19537 DECODE_EXT_WORD
19538 SET_PC(adr)
19539 CHECK_BRANCH_EXCEPTION(adr)
19540RET(14)
19541}
19542
19543// JMP
19544OPCODE(0x4EF8)
19545{
19546 u32 adr, res;
19547 u32 src, dst;
19548
19549 FETCH_SWORD(adr);
19550 SET_PC(adr)
19551 CHECK_BRANCH_EXCEPTION(adr)
19552RET(10)
19553}
19554
19555// JMP
19556OPCODE(0x4EF9)
19557{
19558 u32 adr, res;
19559 u32 src, dst;
19560
19561 FETCH_LONG(adr);
19562 SET_PC(adr)
19563 CHECK_BRANCH_EXCEPTION(adr)
19564RET(12)
19565}
19566
19567// JMP
19568OPCODE(0x4EFA)
19569{
19570 u32 adr, res;
19571 u32 src, dst;
19572
be26eb23 19573 adr = GET_SWORD + GET_PC;
70357ce5 19574 PC++;
19575 SET_PC(adr)
19576 CHECK_BRANCH_EXCEPTION(adr)
19577RET(10)
19578}
19579
19580// JMP
19581OPCODE(0x4EFB)
19582{
19583 u32 adr, res;
19584 u32 src, dst;
19585
be26eb23 19586 adr = GET_PC;
70357ce5 19587 DECODE_EXT_WORD
19588 SET_PC(adr)
19589 CHECK_BRANCH_EXCEPTION(adr)
19590RET(14)
19591}
19592
19593// CHK
19594OPCODE(0x4180)
19595{
5c5d89ad 19596 s32 src, res;
70357ce5 19597
5c5d89ad 19598 src = DREGs16((Opcode >> 0) & 7);
19599 res = DREGs16((Opcode >> 9) & 7);
19600 if ((res < 0) || (res > src))
70357ce5 19601 {
19602 flag_N = res >> 8;
d0ae0cb4 19603 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19604 }
19605RET(10)
19606}
19607
19608// CHK
19609OPCODE(0x4190)
19610{
5c5d89ad 19611 s32 src, res;
19612 u32 adr;
70357ce5 19613
19614 adr = AREG((Opcode >> 0) & 7);
19615 PRE_IO
5c5d89ad 19616 READSX_WORD_F(adr, src)
19617 res = DREGs16((Opcode >> 9) & 7);
19618 if ((res < 0) || (res > src))
70357ce5 19619 {
19620 flag_N = res >> 8;
d0ae0cb4 19621 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19622 }
19623 POST_IO
19624RET(14)
19625}
19626
19627// CHK
19628OPCODE(0x4198)
19629{
5c5d89ad 19630 s32 src, res;
19631 u32 adr;
70357ce5 19632
19633 adr = AREG((Opcode >> 0) & 7);
19634 AREG((Opcode >> 0) & 7) += 2;
19635 PRE_IO
5c5d89ad 19636 READSX_WORD_F(adr, src)
19637 res = DREGs16((Opcode >> 9) & 7);
19638 if ((res < 0) || (res > src))
70357ce5 19639 {
19640 flag_N = res >> 8;
d0ae0cb4 19641 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19642 }
19643 POST_IO
19644RET(14)
19645}
19646
19647// CHK
19648OPCODE(0x41A0)
19649{
5c5d89ad 19650 s32 src, res;
19651 u32 adr;
70357ce5 19652
19653 adr = AREG((Opcode >> 0) & 7) - 2;
19654 AREG((Opcode >> 0) & 7) = adr;
19655 PRE_IO
5c5d89ad 19656 READSX_WORD_F(adr, src)
19657 res = DREGs16((Opcode >> 9) & 7);
19658 if ((res < 0) || (res > src))
70357ce5 19659 {
19660 flag_N = res >> 8;
d0ae0cb4 19661 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19662 }
19663 POST_IO
19664RET(16)
19665}
19666
19667// CHK
19668OPCODE(0x41A8)
19669{
5c5d89ad 19670 s32 src, res;
19671 u32 adr;
70357ce5 19672
19673 FETCH_SWORD(adr);
19674 adr += AREG((Opcode >> 0) & 7);
19675 PRE_IO
5c5d89ad 19676 READSX_WORD_F(adr, src)
19677 res = DREGs16((Opcode >> 9) & 7);
19678 if ((res < 0) || (res > src))
70357ce5 19679 {
19680 flag_N = res >> 8;
d0ae0cb4 19681 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19682 }
19683 POST_IO
19684RET(18)
19685}
19686
19687// CHK
19688OPCODE(0x41B0)
19689{
5c5d89ad 19690 s32 src, res;
19691 u32 adr;
70357ce5 19692
19693 adr = AREG((Opcode >> 0) & 7);
19694 DECODE_EXT_WORD
19695 PRE_IO
5c5d89ad 19696 READSX_WORD_F(adr, src)
19697 res = DREGs16((Opcode >> 9) & 7);
19698 if ((res < 0) || (res > src))
70357ce5 19699 {
19700 flag_N = res >> 8;
d0ae0cb4 19701 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19702 }
19703 POST_IO
19704RET(20)
19705}
19706
19707// CHK
19708OPCODE(0x41B8)
19709{
5c5d89ad 19710 s32 src, res;
19711 u32 adr;
70357ce5 19712
19713 FETCH_SWORD(adr);
19714 PRE_IO
5c5d89ad 19715 READSX_WORD_F(adr, src)
19716 res = DREGs16((Opcode >> 9) & 7);
19717 if ((res < 0) || (res > src))
70357ce5 19718 {
19719 flag_N = res >> 8;
d0ae0cb4 19720 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19721 }
19722 POST_IO
19723RET(18)
19724}
19725
19726// CHK
19727OPCODE(0x41B9)
19728{
5c5d89ad 19729 s32 src, res;
19730 u32 adr;
70357ce5 19731
19732 FETCH_LONG(adr);
19733 PRE_IO
5c5d89ad 19734 READSX_WORD_F(adr, src)
19735 res = DREGs16((Opcode >> 9) & 7);
19736 if ((res < 0) || (res > src))
70357ce5 19737 {
19738 flag_N = res >> 8;
d0ae0cb4 19739 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19740 }
19741 POST_IO
19742RET(22)
19743}
19744
19745// CHK
19746OPCODE(0x41BA)
19747{
5c5d89ad 19748 s32 src, res;
19749 u32 adr;
70357ce5 19750
be26eb23 19751 adr = GET_SWORD + GET_PC;
70357ce5 19752 PC++;
19753 PRE_IO
5c5d89ad 19754 READSX_WORD_F(adr, src)
19755 res = DREGs16((Opcode >> 9) & 7);
19756 if ((res < 0) || (res > src))
70357ce5 19757 {
19758 flag_N = res >> 8;
d0ae0cb4 19759 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19760 }
19761 POST_IO
19762RET(18)
19763}
19764
19765// CHK
19766OPCODE(0x41BB)
19767{
5c5d89ad 19768 s32 src, res;
19769 u32 adr;
70357ce5 19770
be26eb23 19771 adr = GET_PC;
70357ce5 19772 DECODE_EXT_WORD
19773 PRE_IO
5c5d89ad 19774 READSX_WORD_F(adr, src)
19775 res = DREGs16((Opcode >> 9) & 7);
19776 if ((res < 0) || (res > src))
70357ce5 19777 {
19778 flag_N = res >> 8;
d0ae0cb4 19779 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19780 }
19781 POST_IO
19782RET(20)
19783}
19784
19785// CHK
19786OPCODE(0x41BC)
19787{
5c5d89ad 19788 s32 src, res;
19789 u32 adr;
70357ce5 19790
5c5d89ad 19791 FETCH_SWORD(src);
19792 res = DREGs16((Opcode >> 9) & 7);
19793 if ((res < 0) || (res > src))
70357ce5 19794 {
19795 flag_N = res >> 8;
d0ae0cb4 19796 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19797 }
19798 POST_IO
19799RET(14)
19800}
19801
19802// CHK
19803OPCODE(0x419F)
19804{
5c5d89ad 19805 s32 src, res;
19806 u32 adr;
70357ce5 19807
19808 adr = AREG(7);
19809 AREG(7) += 2;
19810 PRE_IO
5c5d89ad 19811 READSX_WORD_F(adr, src)
19812 res = DREGs16((Opcode >> 9) & 7);
19813 if ((res < 0) || (res > src))
70357ce5 19814 {
19815 flag_N = res >> 8;
d0ae0cb4 19816 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19817 }
19818 POST_IO
19819RET(14)
19820}
19821
19822// CHK
19823OPCODE(0x41A7)
19824{
5c5d89ad 19825 s32 src, res;
19826 u32 adr;
70357ce5 19827
19828 adr = AREG(7) - 2;
19829 AREG(7) = adr;
19830 PRE_IO
5c5d89ad 19831 READSX_WORD_F(adr, src)
19832 res = DREGs16((Opcode >> 9) & 7);
19833 if ((res < 0) || (res > src))
70357ce5 19834 {
19835 flag_N = res >> 8;
d0ae0cb4 19836 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19837 }
19838 POST_IO
19839RET(16)
19840}
19841
19842// LEA
19843OPCODE(0x41D0)
19844{
19845 u32 adr, res;
19846 u32 src, dst;
19847
19848 adr = AREG((Opcode >> 0) & 7);
19849 res = adr;
19850 AREG((Opcode >> 9) & 7) = res;
19851RET(4)
19852}
19853
19854// LEA
19855OPCODE(0x41E8)
19856{
19857 u32 adr, res;
19858 u32 src, dst;
19859
19860 FETCH_SWORD(adr);
19861 adr += AREG((Opcode >> 0) & 7);
19862 res = adr;
19863 AREG((Opcode >> 9) & 7) = res;
19864RET(8)
19865}
19866
19867// LEA
19868OPCODE(0x41F0)
19869{
19870 u32 adr, res;
19871 u32 src, dst;
19872
19873 adr = AREG((Opcode >> 0) & 7);
19874 DECODE_EXT_WORD
19875 res = adr;
19876 AREG((Opcode >> 9) & 7) = res;
19877RET(12)
19878}
19879
19880// LEA
19881OPCODE(0x41F8)
19882{
19883 u32 adr, res;
19884 u32 src, dst;
19885
19886 FETCH_SWORD(adr);
19887 res = adr;
19888 AREG((Opcode >> 9) & 7) = res;
19889RET(8)
19890}
19891
19892// LEA
19893OPCODE(0x41F9)
19894{
19895 u32 adr, res;
19896 u32 src, dst;
19897
19898 FETCH_LONG(adr);
19899 res = adr;
19900 AREG((Opcode >> 9) & 7) = res;
19901RET(12)
19902}
19903
19904// LEA
19905OPCODE(0x41FA)
19906{
19907 u32 adr, res;
19908 u32 src, dst;
19909
be26eb23 19910 adr = GET_SWORD + GET_PC;
70357ce5 19911 PC++;
19912 res = adr;
19913 AREG((Opcode >> 9) & 7) = res;
19914RET(8)
19915}
19916
19917// LEA
19918OPCODE(0x41FB)
19919{
19920 u32 adr, res;
19921 u32 src, dst;
19922
be26eb23 19923 adr = GET_PC;
70357ce5 19924 DECODE_EXT_WORD
19925 res = adr;
19926 AREG((Opcode >> 9) & 7) = res;
19927RET(12)
19928}
19929
19930// STCC
19931OPCODE(0x50C0)
19932{
19933 u32 adr, res;
19934 u32 src, dst;
19935
19936 res = 0xFF;
19937 DREGu8((Opcode >> 0) & 7) = res;
19938 RET(6)
19939}
19940
19941// STCC
19942OPCODE(0x51C0)
19943{
19944 u32 adr, res;
19945 u32 src, dst;
19946
19947 res = 0;
19948 DREGu8((Opcode >> 0) & 7) = res;
19949 RET(4)
19950}
19951
19952// STCC
19953OPCODE(0x52C0)
19954{
19955 u32 adr, res;
19956 u32 src, dst;
19957
19958 if (flag_NotZ && (!(flag_C & 0x100)))
19959 {
19960 res = 0xFF;
19961 DREGu8((Opcode >> 0) & 7) = res;
19962 RET(6)
19963 }
19964 res = 0;
19965 DREGu8((Opcode >> 0) & 7) = res;
19966 RET(4)
19967}
19968
19969// STCC
19970OPCODE(0x53C0)
19971{
19972 u32 adr, res;
19973 u32 src, dst;
19974
19975 if ((!flag_NotZ) || (flag_C & 0x100))
19976 {
19977 res = 0xFF;
19978 DREGu8((Opcode >> 0) & 7) = res;
19979 RET(6)
19980 }
19981 res = 0;
19982 DREGu8((Opcode >> 0) & 7) = res;
19983 RET(4)
19984}
19985
19986// STCC
19987OPCODE(0x54C0)
19988{
19989 u32 adr, res;
19990 u32 src, dst;
19991
19992 if (!(flag_C & 0x100))
19993 {
19994 res = 0xFF;
19995 DREGu8((Opcode >> 0) & 7) = res;
19996 RET(6)
19997 }
19998 res = 0;
19999 DREGu8((Opcode >> 0) & 7) = res;
20000 RET(4)
20001}
20002
20003// STCC
20004OPCODE(0x55C0)
20005{
20006 u32 adr, res;
20007 u32 src, dst;
20008
20009 if (flag_C & 0x100)
20010 {
20011 res = 0xFF;
20012 DREGu8((Opcode >> 0) & 7) = res;
20013 RET(6)
20014 }
20015 res = 0;
20016 DREGu8((Opcode >> 0) & 7) = res;
20017 RET(4)
20018}
20019
20020// STCC
20021OPCODE(0x56C0)
20022{
20023 u32 adr, res;
20024 u32 src, dst;
20025
20026 if (flag_NotZ)
20027 {
20028 res = 0xFF;
20029 DREGu8((Opcode >> 0) & 7) = res;
20030 RET(6)
20031 }
20032 res = 0;
20033 DREGu8((Opcode >> 0) & 7) = res;
20034 RET(4)
20035}
20036
20037// STCC
20038OPCODE(0x57C0)
20039{
20040 u32 adr, res;
20041 u32 src, dst;
20042
20043 if (!flag_NotZ)
20044 {
20045 res = 0xFF;
20046 DREGu8((Opcode >> 0) & 7) = res;
20047 RET(6)
20048 }
20049 res = 0;
20050 DREGu8((Opcode >> 0) & 7) = res;
20051 RET(4)
20052}
20053
20054// STCC
20055OPCODE(0x58C0)
20056{
20057 u32 adr, res;
20058 u32 src, dst;
20059
20060 if (!(flag_V & 0x80))
20061 {
20062 res = 0xFF;
20063 DREGu8((Opcode >> 0) & 7) = res;
20064 RET(6)
20065 }
20066 res = 0;
20067 DREGu8((Opcode >> 0) & 7) = res;
20068 RET(4)
20069}
20070
20071// STCC
20072OPCODE(0x59C0)
20073{
20074 u32 adr, res;
20075 u32 src, dst;
20076
20077 if (flag_V & 0x80)
20078 {
20079 res = 0xFF;
20080 DREGu8((Opcode >> 0) & 7) = res;
20081 RET(6)
20082 }
20083 res = 0;
20084 DREGu8((Opcode >> 0) & 7) = res;
20085 RET(4)
20086}
20087
20088// STCC
20089OPCODE(0x5AC0)
20090{
20091 u32 adr, res;
20092 u32 src, dst;
20093
20094 if (!(flag_N & 0x80))
20095 {
20096 res = 0xFF;
20097 DREGu8((Opcode >> 0) & 7) = res;
20098 RET(6)
20099 }
20100 res = 0;
20101 DREGu8((Opcode >> 0) & 7) = res;
20102 RET(4)
20103}
20104
20105// STCC
20106OPCODE(0x5BC0)
20107{
20108 u32 adr, res;
20109 u32 src, dst;
20110
20111 if (flag_N & 0x80)
20112 {
20113 res = 0xFF;
20114 DREGu8((Opcode >> 0) & 7) = res;
20115 RET(6)
20116 }
20117 res = 0;
20118 DREGu8((Opcode >> 0) & 7) = res;
20119 RET(4)
20120}
20121
20122// STCC
20123OPCODE(0x5CC0)
20124{
20125 u32 adr, res;
20126 u32 src, dst;
20127
20128 if (!((flag_N ^ flag_V) & 0x80))
20129 {
20130 res = 0xFF;
20131 DREGu8((Opcode >> 0) & 7) = res;
20132 RET(6)
20133 }
20134 res = 0;
20135 DREGu8((Opcode >> 0) & 7) = res;
20136 RET(4)
20137}
20138
20139// STCC
20140OPCODE(0x5DC0)
20141{
20142 u32 adr, res;
20143 u32 src, dst;
20144
20145 if ((flag_N ^ flag_V) & 0x80)
20146 {
20147 res = 0xFF;
20148 DREGu8((Opcode >> 0) & 7) = res;
20149 RET(6)
20150 }
20151 res = 0;
20152 DREGu8((Opcode >> 0) & 7) = res;
20153 RET(4)
20154}
20155
20156// STCC
20157OPCODE(0x5EC0)
20158{
20159 u32 adr, res;
20160 u32 src, dst;
20161
20162 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20163 {
20164 res = 0xFF;
20165 DREGu8((Opcode >> 0) & 7) = res;
20166 RET(6)
20167 }
20168 res = 0;
20169 DREGu8((Opcode >> 0) & 7) = res;
20170 RET(4)
20171}
20172
20173// STCC
20174OPCODE(0x5FC0)
20175{
20176 u32 adr, res;
20177 u32 src, dst;
20178
20179 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20180 {
20181 res = 0xFF;
20182 DREGu8((Opcode >> 0) & 7) = res;
20183 RET(6)
20184 }
20185 res = 0;
20186 DREGu8((Opcode >> 0) & 7) = res;
20187 RET(4)
20188}
20189
20190// STCC
20191OPCODE(0x50D0)
20192{
20193 u32 adr, res;
20194 u32 src, dst;
20195
20196 adr = AREG((Opcode >> 0) & 7);
20197 res = 0xFF;
20198 PRE_IO
20199 WRITE_BYTE_F(adr, res)
20200 POST_IO
20201 RET(12)
20202}
20203
20204// STCC
20205OPCODE(0x51D0)
20206{
20207 u32 adr, res;
20208 u32 src, dst;
20209
20210 adr = AREG((Opcode >> 0) & 7);
20211 res = 0;
20212 PRE_IO
20213 WRITE_BYTE_F(adr, res)
20214 POST_IO
20215 RET(12)
20216}
20217
20218// STCC
20219OPCODE(0x52D0)
20220{
20221 u32 adr, res;
20222 u32 src, dst;
20223
20224 adr = AREG((Opcode >> 0) & 7);
20225 if (flag_NotZ && (!(flag_C & 0x100)))
20226 {
20227 res = 0xFF;
20228 PRE_IO
20229 WRITE_BYTE_F(adr, res)
20230 POST_IO
20231 RET(12)
20232 }
20233 res = 0;
20234 PRE_IO
20235 WRITE_BYTE_F(adr, res)
20236 POST_IO
20237 RET(12)
20238}
20239
20240// STCC
20241OPCODE(0x53D0)
20242{
20243 u32 adr, res;
20244 u32 src, dst;
20245
20246 adr = AREG((Opcode >> 0) & 7);
20247 if ((!flag_NotZ) || (flag_C & 0x100))
20248 {
20249 res = 0xFF;
20250 PRE_IO
20251 WRITE_BYTE_F(adr, res)
20252 POST_IO
20253 RET(12)
20254 }
20255 res = 0;
20256 PRE_IO
20257 WRITE_BYTE_F(adr, res)
20258 POST_IO
20259 RET(12)
20260}
20261
20262// STCC
20263OPCODE(0x54D0)
20264{
20265 u32 adr, res;
20266 u32 src, dst;
20267
20268 adr = AREG((Opcode >> 0) & 7);
20269 if (!(flag_C & 0x100))
20270 {
20271 res = 0xFF;
20272 PRE_IO
20273 WRITE_BYTE_F(adr, res)
20274 POST_IO
20275 RET(12)
20276 }
20277 res = 0;
20278 PRE_IO
20279 WRITE_BYTE_F(adr, res)
20280 POST_IO
20281 RET(12)
20282}
20283
20284// STCC
20285OPCODE(0x55D0)
20286{
20287 u32 adr, res;
20288 u32 src, dst;
20289
20290 adr = AREG((Opcode >> 0) & 7);
20291 if (flag_C & 0x100)
20292 {
20293 res = 0xFF;
20294 PRE_IO
20295 WRITE_BYTE_F(adr, res)
20296 POST_IO
20297 RET(12)
20298 }
20299 res = 0;
20300 PRE_IO
20301 WRITE_BYTE_F(adr, res)
20302 POST_IO
20303 RET(12)
20304}
20305
20306// STCC
20307OPCODE(0x56D0)
20308{
20309 u32 adr, res;
20310 u32 src, dst;
20311
20312 adr = AREG((Opcode >> 0) & 7);
20313 if (flag_NotZ)
20314 {
20315 res = 0xFF;
20316 PRE_IO
20317 WRITE_BYTE_F(adr, res)
20318 POST_IO
20319 RET(12)
20320 }
20321 res = 0;
20322 PRE_IO
20323 WRITE_BYTE_F(adr, res)
20324 POST_IO
20325 RET(12)
20326}
20327
20328// STCC
20329OPCODE(0x57D0)
20330{
20331 u32 adr, res;
20332 u32 src, dst;
20333
20334 adr = AREG((Opcode >> 0) & 7);
20335 if (!flag_NotZ)
20336 {
20337 res = 0xFF;
20338 PRE_IO
20339 WRITE_BYTE_F(adr, res)
20340 POST_IO
20341 RET(12)
20342 }
20343 res = 0;
20344 PRE_IO
20345 WRITE_BYTE_F(adr, res)
20346 POST_IO
20347 RET(12)
20348}
20349
20350// STCC
20351OPCODE(0x58D0)
20352{
20353 u32 adr, res;
20354 u32 src, dst;
20355
20356 adr = AREG((Opcode >> 0) & 7);
20357 if (!(flag_V & 0x80))
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(0x59D0)
20374{
20375 u32 adr, res;
20376 u32 src, dst;
20377
20378 adr = AREG((Opcode >> 0) & 7);
20379 if (flag_V & 0x80)
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(0x5AD0)
20396{
20397 u32 adr, res;
20398 u32 src, dst;
20399
20400 adr = AREG((Opcode >> 0) & 7);
20401 if (!(flag_N & 0x80))
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(0x5BD0)
20418{
20419 u32 adr, res;
20420 u32 src, dst;
20421
20422 adr = AREG((Opcode >> 0) & 7);
20423 if (flag_N & 0x80)
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(0x5CD0)
20440{
20441 u32 adr, res;
20442 u32 src, dst;
20443
20444 adr = AREG((Opcode >> 0) & 7);
20445 if (!((flag_N ^ flag_V) & 0x80))
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(0x5DD0)
20462{
20463 u32 adr, res;
20464 u32 src, dst;
20465
20466 adr = AREG((Opcode >> 0) & 7);
20467 if ((flag_N ^ flag_V) & 0x80)
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(0x5ED0)
20484{
20485 u32 adr, res;
20486 u32 src, dst;
20487
20488 adr = AREG((Opcode >> 0) & 7);
20489 if (flag_NotZ && (!((flag_N ^ 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(0x5FD0)
20506{
20507 u32 adr, res;
20508 u32 src, dst;
20509
20510 adr = AREG((Opcode >> 0) & 7);
20511 if ((!flag_NotZ) || ((flag_N ^ 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(0x50D8)
20528{
20529 u32 adr, res;
20530 u32 src, dst;
20531
20532 adr = AREG((Opcode >> 0) & 7);
20533 AREG((Opcode >> 0) & 7) += 1;
20534 res = 0xFF;
20535 PRE_IO
20536 WRITE_BYTE_F(adr, res)
20537 POST_IO
20538 RET(12)
20539}
20540
20541// STCC
20542OPCODE(0x51D8)
20543{
20544 u32 adr, res;
20545 u32 src, dst;
20546
20547 adr = AREG((Opcode >> 0) & 7);
20548 AREG((Opcode >> 0) & 7) += 1;
20549 res = 0;
20550 PRE_IO
20551 WRITE_BYTE_F(adr, res)
20552 POST_IO
20553 RET(12)
20554}
20555
20556// STCC
20557OPCODE(0x52D8)
20558{
20559 u32 adr, res;
20560 u32 src, dst;
20561
20562 adr = AREG((Opcode >> 0) & 7);
20563 AREG((Opcode >> 0) & 7) += 1;
20564 if (flag_NotZ && (!(flag_C & 0x100)))
20565 {
20566 res = 0xFF;
20567 PRE_IO
20568 WRITE_BYTE_F(adr, res)
20569 POST_IO
20570 RET(12)
20571 }
20572 res = 0;
20573 PRE_IO
20574 WRITE_BYTE_F(adr, res)
20575 POST_IO
20576 RET(12)
20577}
20578
20579// STCC
20580OPCODE(0x53D8)
20581{
20582 u32 adr, res;
20583 u32 src, dst;
20584
20585 adr = AREG((Opcode >> 0) & 7);
20586 AREG((Opcode >> 0) & 7) += 1;
20587 if ((!flag_NotZ) || (flag_C & 0x100))
20588 {
20589 res = 0xFF;
20590 PRE_IO
20591 WRITE_BYTE_F(adr, res)
20592 POST_IO
20593 RET(12)
20594 }
20595 res = 0;
20596 PRE_IO
20597 WRITE_BYTE_F(adr, res)
20598 POST_IO
20599 RET(12)
20600}
20601
20602// STCC
20603OPCODE(0x54D8)
20604{
20605 u32 adr, res;
20606 u32 src, dst;
20607
20608 adr = AREG((Opcode >> 0) & 7);
20609 AREG((Opcode >> 0) & 7) += 1;
20610 if (!(flag_C & 0x100))
20611 {
20612 res = 0xFF;
20613 PRE_IO
20614 WRITE_BYTE_F(adr, res)
20615 POST_IO
20616 RET(12)
20617 }
20618 res = 0;
20619 PRE_IO
20620 WRITE_BYTE_F(adr, res)
20621 POST_IO
20622 RET(12)
20623}
20624
20625// STCC
20626OPCODE(0x55D8)
20627{
20628 u32 adr, res;
20629 u32 src, dst;
20630
20631 adr = AREG((Opcode >> 0) & 7);
20632 AREG((Opcode >> 0) & 7) += 1;
20633 if (flag_C & 0x100)
20634 {
20635 res = 0xFF;
20636 PRE_IO
20637 WRITE_BYTE_F(adr, res)
20638 POST_IO
20639 RET(12)
20640 }
20641 res = 0;
20642 PRE_IO
20643 WRITE_BYTE_F(adr, res)
20644 POST_IO
20645 RET(12)
20646}
20647
20648// STCC
20649OPCODE(0x56D8)
20650{
20651 u32 adr, res;
20652 u32 src, dst;
20653
20654 adr = AREG((Opcode >> 0) & 7);
20655 AREG((Opcode >> 0) & 7) += 1;
20656 if (flag_NotZ)
20657 {
20658 res = 0xFF;
20659 PRE_IO
20660 WRITE_BYTE_F(adr, res)
20661 POST_IO
20662 RET(12)
20663 }
20664 res = 0;
20665 PRE_IO
20666 WRITE_BYTE_F(adr, res)
20667 POST_IO
20668 RET(12)
20669}
20670
20671// STCC
20672OPCODE(0x57D8)
20673{
20674 u32 adr, res;
20675 u32 src, dst;
20676
20677 adr = AREG((Opcode >> 0) & 7);
20678 AREG((Opcode >> 0) & 7) += 1;
20679 if (!flag_NotZ)
20680 {
20681 res = 0xFF;
20682 PRE_IO
20683 WRITE_BYTE_F(adr, res)
20684 POST_IO
20685 RET(12)
20686 }
20687 res = 0;
20688 PRE_IO
20689 WRITE_BYTE_F(adr, res)
20690 POST_IO
20691 RET(12)
20692}
20693
20694// STCC
20695OPCODE(0x58D8)
20696{
20697 u32 adr, res;
20698 u32 src, dst;
20699
20700 adr = AREG((Opcode >> 0) & 7);
20701 AREG((Opcode >> 0) & 7) += 1;
20702 if (!(flag_V & 0x80))
20703 {
20704 res = 0xFF;
20705 PRE_IO
20706 WRITE_BYTE_F(adr, res)
20707 POST_IO
20708 RET(12)
20709 }
20710 res = 0;
20711 PRE_IO
20712 WRITE_BYTE_F(adr, res)
20713 POST_IO
20714 RET(12)
20715}
20716
20717// STCC
20718OPCODE(0x59D8)
20719{
20720 u32 adr, res;
20721 u32 src, dst;
20722
20723 adr = AREG((Opcode >> 0) & 7);
20724 AREG((Opcode >> 0) & 7) += 1;
20725 if (flag_V & 0x80)
20726 {
20727 res = 0xFF;
20728 PRE_IO
20729 WRITE_BYTE_F(adr, res)
20730 POST_IO
20731 RET(12)
20732 }
20733 res = 0;
20734 PRE_IO
20735 WRITE_BYTE_F(adr, res)
20736 POST_IO
20737 RET(12)
20738}
20739
20740// STCC
20741OPCODE(0x5AD8)
20742{
20743 u32 adr, res;
20744 u32 src, dst;
20745
20746 adr = AREG((Opcode >> 0) & 7);
20747 AREG((Opcode >> 0) & 7) += 1;
20748 if (!(flag_N & 0x80))
20749 {
20750 res = 0xFF;
20751 PRE_IO
20752 WRITE_BYTE_F(adr, res)
20753 POST_IO
20754 RET(12)
20755 }
20756 res = 0;
20757 PRE_IO
20758 WRITE_BYTE_F(adr, res)
20759 POST_IO
20760 RET(12)
20761}
20762
20763// STCC
20764OPCODE(0x5BD8)
20765{
20766 u32 adr, res;
20767 u32 src, dst;
20768
20769 adr = AREG((Opcode >> 0) & 7);
20770 AREG((Opcode >> 0) & 7) += 1;
20771 if (flag_N & 0x80)
20772 {
20773 res = 0xFF;
20774 PRE_IO
20775 WRITE_BYTE_F(adr, res)
20776 POST_IO
20777 RET(12)
20778 }
20779 res = 0;
20780 PRE_IO
20781 WRITE_BYTE_F(adr, res)
20782 POST_IO
20783 RET(12)
20784}
20785
20786// STCC
20787OPCODE(0x5CD8)
20788{
20789 u32 adr, res;
20790 u32 src, dst;
20791
20792 adr = AREG((Opcode >> 0) & 7);
20793 AREG((Opcode >> 0) & 7) += 1;
20794 if (!((flag_N ^ flag_V) & 0x80))
20795 {
20796 res = 0xFF;
20797 PRE_IO
20798 WRITE_BYTE_F(adr, res)
20799 POST_IO
20800 RET(12)
20801 }
20802 res = 0;
20803 PRE_IO
20804 WRITE_BYTE_F(adr, res)
20805 POST_IO
20806 RET(12)
20807}
20808
20809// STCC
20810OPCODE(0x5DD8)
20811{
20812 u32 adr, res;
20813 u32 src, dst;
20814
20815 adr = AREG((Opcode >> 0) & 7);
20816 AREG((Opcode >> 0) & 7) += 1;
20817 if ((flag_N ^ flag_V) & 0x80)
20818 {
20819 res = 0xFF;
20820 PRE_IO
20821 WRITE_BYTE_F(adr, res)
20822 POST_IO
20823 RET(12)
20824 }
20825 res = 0;
20826 PRE_IO
20827 WRITE_BYTE_F(adr, res)
20828 POST_IO
20829 RET(12)
20830}
20831
20832// STCC
20833OPCODE(0x5ED8)
20834{
20835 u32 adr, res;
20836 u32 src, dst;
20837
20838 adr = AREG((Opcode >> 0) & 7);
20839 AREG((Opcode >> 0) & 7) += 1;
20840 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20841 {
20842 res = 0xFF;
20843 PRE_IO
20844 WRITE_BYTE_F(adr, res)
20845 POST_IO
20846 RET(12)
20847 }
20848 res = 0;
20849 PRE_IO
20850 WRITE_BYTE_F(adr, res)
20851 POST_IO
20852 RET(12)
20853}
20854
20855// STCC
20856OPCODE(0x5FD8)
20857{
20858 u32 adr, res;
20859 u32 src, dst;
20860
20861 adr = AREG((Opcode >> 0) & 7);
20862 AREG((Opcode >> 0) & 7) += 1;
20863 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20864 {
20865 res = 0xFF;
20866 PRE_IO
20867 WRITE_BYTE_F(adr, res)
20868 POST_IO
20869 RET(12)
20870 }
20871 res = 0;
20872 PRE_IO
20873 WRITE_BYTE_F(adr, res)
20874 POST_IO
20875 RET(12)
20876}
20877
20878// STCC
20879OPCODE(0x50E0)
20880{
20881 u32 adr, res;
20882 u32 src, dst;
20883
20884 adr = AREG((Opcode >> 0) & 7) - 1;
20885 AREG((Opcode >> 0) & 7) = adr;
20886 res = 0xFF;
20887 PRE_IO
20888 WRITE_BYTE_F(adr, res)
20889 POST_IO
20890 RET(14)
20891}
20892
20893// STCC
20894OPCODE(0x51E0)
20895{
20896 u32 adr, res;
20897 u32 src, dst;
20898
20899 adr = AREG((Opcode >> 0) & 7) - 1;
20900 AREG((Opcode >> 0) & 7) = adr;
20901 res = 0;
20902 PRE_IO
20903 WRITE_BYTE_F(adr, res)
20904 POST_IO
20905 RET(14)
20906}
20907
20908// STCC
20909OPCODE(0x52E0)
20910{
20911 u32 adr, res;
20912 u32 src, dst;
20913
20914 adr = AREG((Opcode >> 0) & 7) - 1;
20915 AREG((Opcode >> 0) & 7) = adr;
20916 if (flag_NotZ && (!(flag_C & 0x100)))
20917 {
20918 res = 0xFF;
20919 PRE_IO
20920 WRITE_BYTE_F(adr, res)
20921 POST_IO
20922 RET(14)
20923 }
20924 res = 0;
20925 PRE_IO
20926 WRITE_BYTE_F(adr, res)
20927 POST_IO
20928 RET(14)
20929}
20930
20931// STCC
20932OPCODE(0x53E0)
20933{
20934 u32 adr, res;
20935 u32 src, dst;
20936
20937 adr = AREG((Opcode >> 0) & 7) - 1;
20938 AREG((Opcode >> 0) & 7) = adr;
20939 if ((!flag_NotZ) || (flag_C & 0x100))
20940 {
20941 res = 0xFF;
20942 PRE_IO
20943 WRITE_BYTE_F(adr, res)
20944 POST_IO
20945 RET(14)
20946 }
20947 res = 0;
20948 PRE_IO
20949 WRITE_BYTE_F(adr, res)
20950 POST_IO
20951 RET(14)
20952}
20953
20954// STCC
20955OPCODE(0x54E0)
20956{
20957 u32 adr, res;
20958 u32 src, dst;
20959
20960 adr = AREG((Opcode >> 0) & 7) - 1;
20961 AREG((Opcode >> 0) & 7) = adr;
20962 if (!(flag_C & 0x100))
20963 {
20964 res = 0xFF;
20965 PRE_IO
20966 WRITE_BYTE_F(adr, res)
20967 POST_IO
20968 RET(14)
20969 }
20970 res = 0;
20971 PRE_IO
20972 WRITE_BYTE_F(adr, res)
20973 POST_IO
20974 RET(14)
20975}
20976
20977// STCC
20978OPCODE(0x55E0)
20979{
20980 u32 adr, res;
20981 u32 src, dst;
20982
20983 adr = AREG((Opcode >> 0) & 7) - 1;
20984 AREG((Opcode >> 0) & 7) = adr;
20985 if (flag_C & 0x100)
20986 {
20987 res = 0xFF;
20988 PRE_IO
20989 WRITE_BYTE_F(adr, res)
20990 POST_IO
20991 RET(14)
20992 }
20993 res = 0;
20994 PRE_IO
20995 WRITE_BYTE_F(adr, res)
20996 POST_IO
20997 RET(14)
20998}
20999
21000// STCC
21001OPCODE(0x56E0)
21002{
21003 u32 adr, res;
21004 u32 src, dst;
21005
21006 adr = AREG((Opcode >> 0) & 7) - 1;
21007 AREG((Opcode >> 0) & 7) = adr;
21008 if (flag_NotZ)
21009 {
21010 res = 0xFF;
21011 PRE_IO
21012 WRITE_BYTE_F(adr, res)
21013 POST_IO
21014 RET(14)
21015 }
21016 res = 0;
21017 PRE_IO
21018 WRITE_BYTE_F(adr, res)
21019 POST_IO
21020 RET(14)
21021}
21022
21023// STCC
21024OPCODE(0x57E0)
21025{
21026 u32 adr, res;
21027 u32 src, dst;
21028
21029 adr = AREG((Opcode >> 0) & 7) - 1;
21030 AREG((Opcode >> 0) & 7) = adr;
21031 if (!flag_NotZ)
21032 {
21033 res = 0xFF;
21034 PRE_IO
21035 WRITE_BYTE_F(adr, res)
21036 POST_IO
21037 RET(14)
21038 }
21039 res = 0;
21040 PRE_IO
21041 WRITE_BYTE_F(adr, res)
21042 POST_IO
21043 RET(14)
21044}
21045
21046// STCC
21047OPCODE(0x58E0)
21048{
21049 u32 adr, res;
21050 u32 src, dst;
21051
21052 adr = AREG((Opcode >> 0) & 7) - 1;
21053 AREG((Opcode >> 0) & 7) = adr;
21054 if (!(flag_V & 0x80))
21055 {
21056 res = 0xFF;
21057 PRE_IO
21058 WRITE_BYTE_F(adr, res)
21059 POST_IO
21060 RET(14)
21061 }
21062 res = 0;
21063 PRE_IO
21064 WRITE_BYTE_F(adr, res)
21065 POST_IO
21066 RET(14)
21067}
21068
21069// STCC
21070OPCODE(0x59E0)
21071{
21072 u32 adr, res;
21073 u32 src, dst;
21074
21075 adr = AREG((Opcode >> 0) & 7) - 1;
21076 AREG((Opcode >> 0) & 7) = adr;
21077 if (flag_V & 0x80)
21078 {
21079 res = 0xFF;
21080 PRE_IO
21081 WRITE_BYTE_F(adr, res)
21082 POST_IO
21083 RET(14)
21084 }
21085 res = 0;
21086 PRE_IO
21087 WRITE_BYTE_F(adr, res)
21088 POST_IO
21089 RET(14)
21090}
21091
21092// STCC
21093OPCODE(0x5AE0)
21094{
21095 u32 adr, res;
21096 u32 src, dst;
21097
21098 adr = AREG((Opcode >> 0) & 7) - 1;
21099 AREG((Opcode >> 0) & 7) = adr;
21100 if (!(flag_N & 0x80))
21101 {
21102 res = 0xFF;
21103 PRE_IO
21104 WRITE_BYTE_F(adr, res)
21105 POST_IO
21106 RET(14)
21107 }
21108 res = 0;
21109 PRE_IO
21110 WRITE_BYTE_F(adr, res)
21111 POST_IO
21112 RET(14)
21113}
21114
21115// STCC
21116OPCODE(0x5BE0)
21117{
21118 u32 adr, res;
21119 u32 src, dst;
21120
21121 adr = AREG((Opcode >> 0) & 7) - 1;
21122 AREG((Opcode >> 0) & 7) = adr;
21123 if (flag_N & 0x80)
21124 {
21125 res = 0xFF;
21126 PRE_IO
21127 WRITE_BYTE_F(adr, res)
21128 POST_IO
21129 RET(14)
21130 }
21131 res = 0;
21132 PRE_IO
21133 WRITE_BYTE_F(adr, res)
21134 POST_IO
21135 RET(14)
21136}
21137
21138// STCC
21139OPCODE(0x5CE0)
21140{
21141 u32 adr, res;
21142 u32 src, dst;
21143
21144 adr = AREG((Opcode >> 0) & 7) - 1;
21145 AREG((Opcode >> 0) & 7) = adr;
21146 if (!((flag_N ^ flag_V) & 0x80))
21147 {
21148 res = 0xFF;
21149 PRE_IO
21150 WRITE_BYTE_F(adr, res)
21151 POST_IO
21152 RET(14)
21153 }
21154 res = 0;
21155 PRE_IO
21156 WRITE_BYTE_F(adr, res)
21157 POST_IO
21158 RET(14)
21159}
21160
21161// STCC
21162OPCODE(0x5DE0)
21163{
21164 u32 adr, res;
21165 u32 src, dst;
21166
21167 adr = AREG((Opcode >> 0) & 7) - 1;
21168 AREG((Opcode >> 0) & 7) = adr;
21169 if ((flag_N ^ flag_V) & 0x80)
21170 {
21171 res = 0xFF;
21172 PRE_IO
21173 WRITE_BYTE_F(adr, res)
21174 POST_IO
21175 RET(14)
21176 }
21177 res = 0;
21178 PRE_IO
21179 WRITE_BYTE_F(adr, res)
21180 POST_IO
21181 RET(14)
21182}
21183
21184// STCC
21185OPCODE(0x5EE0)
21186{
21187 u32 adr, res;
21188 u32 src, dst;
21189
21190 adr = AREG((Opcode >> 0) & 7) - 1;
21191 AREG((Opcode >> 0) & 7) = adr;
21192 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21193 {
21194 res = 0xFF;
21195 PRE_IO
21196 WRITE_BYTE_F(adr, res)
21197 POST_IO
21198 RET(14)
21199 }
21200 res = 0;
21201 PRE_IO
21202 WRITE_BYTE_F(adr, res)
21203 POST_IO
21204 RET(14)
21205}
21206
21207// STCC
21208OPCODE(0x5FE0)
21209{
21210 u32 adr, res;
21211 u32 src, dst;
21212
21213 adr = AREG((Opcode >> 0) & 7) - 1;
21214 AREG((Opcode >> 0) & 7) = adr;
21215 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21216 {
21217 res = 0xFF;
21218 PRE_IO
21219 WRITE_BYTE_F(adr, res)
21220 POST_IO
21221 RET(14)
21222 }
21223 res = 0;
21224 PRE_IO
21225 WRITE_BYTE_F(adr, res)
21226 POST_IO
21227 RET(14)
21228}
21229
21230// STCC
21231OPCODE(0x50E8)
21232{
21233 u32 adr, res;
21234 u32 src, dst;
21235
21236 FETCH_SWORD(adr);
21237 adr += AREG((Opcode >> 0) & 7);
21238 res = 0xFF;
21239 PRE_IO
21240 WRITE_BYTE_F(adr, res)
21241 POST_IO
21242 RET(16)
21243}
21244
21245// STCC
21246OPCODE(0x51E8)
21247{
21248 u32 adr, res;
21249 u32 src, dst;
21250
21251 FETCH_SWORD(adr);
21252 adr += AREG((Opcode >> 0) & 7);
21253 res = 0;
21254 PRE_IO
21255 WRITE_BYTE_F(adr, res)
21256 POST_IO
21257 RET(16)
21258}
21259
21260// STCC
21261OPCODE(0x52E8)
21262{
21263 u32 adr, res;
21264 u32 src, dst;
21265
21266 FETCH_SWORD(adr);
21267 adr += AREG((Opcode >> 0) & 7);
21268 if (flag_NotZ && (!(flag_C & 0x100)))
21269 {
21270 res = 0xFF;
21271 PRE_IO
21272 WRITE_BYTE_F(adr, res)
21273 POST_IO
21274 RET(16)
21275 }
21276 res = 0;
21277 PRE_IO
21278 WRITE_BYTE_F(adr, res)
21279 POST_IO
21280 RET(16)
21281}
21282
21283// STCC
21284OPCODE(0x53E8)
21285{
21286 u32 adr, res;
21287 u32 src, dst;
21288
21289 FETCH_SWORD(adr);
21290 adr += AREG((Opcode >> 0) & 7);
21291 if ((!flag_NotZ) || (flag_C & 0x100))
21292 {
21293 res = 0xFF;
21294 PRE_IO
21295 WRITE_BYTE_F(adr, res)
21296 POST_IO
21297 RET(16)
21298 }
21299 res = 0;
21300 PRE_IO
21301 WRITE_BYTE_F(adr, res)
21302 POST_IO
21303 RET(16)
21304}
21305
21306// STCC
21307OPCODE(0x54E8)
21308{
21309 u32 adr, res;
21310 u32 src, dst;
21311
21312 FETCH_SWORD(adr);
21313 adr += AREG((Opcode >> 0) & 7);
21314 if (!(flag_C & 0x100))
21315 {
21316 res = 0xFF;
21317 PRE_IO
21318 WRITE_BYTE_F(adr, res)
21319 POST_IO
21320 RET(16)
21321 }
21322 res = 0;
21323 PRE_IO
21324 WRITE_BYTE_F(adr, res)
21325 POST_IO
21326 RET(16)
21327}
21328
21329// STCC
21330OPCODE(0x55E8)
21331{
21332 u32 adr, res;
21333 u32 src, dst;
21334
21335 FETCH_SWORD(adr);
21336 adr += AREG((Opcode >> 0) & 7);
21337 if (flag_C & 0x100)
21338 {
21339 res = 0xFF;
21340 PRE_IO
21341 WRITE_BYTE_F(adr, res)
21342 POST_IO
21343 RET(16)
21344 }
21345 res = 0;
21346 PRE_IO
21347 WRITE_BYTE_F(adr, res)
21348 POST_IO
21349 RET(16)
21350}
21351
21352// STCC
21353OPCODE(0x56E8)
21354{
21355 u32 adr, res;
21356 u32 src, dst;
21357
21358 FETCH_SWORD(adr);
21359 adr += AREG((Opcode >> 0) & 7);
21360 if (flag_NotZ)
21361 {
21362 res = 0xFF;
21363 PRE_IO
21364 WRITE_BYTE_F(adr, res)
21365 POST_IO
21366 RET(16)
21367 }
21368 res = 0;
21369 PRE_IO
21370 WRITE_BYTE_F(adr, res)
21371 POST_IO
21372 RET(16)
21373}
21374
21375// STCC
21376OPCODE(0x57E8)
21377{
21378 u32 adr, res;
21379 u32 src, dst;
21380
21381 FETCH_SWORD(adr);
21382 adr += AREG((Opcode >> 0) & 7);
21383 if (!flag_NotZ)
21384 {
21385 res = 0xFF;
21386 PRE_IO
21387 WRITE_BYTE_F(adr, res)
21388 POST_IO
21389 RET(16)
21390 }
21391 res = 0;
21392 PRE_IO
21393 WRITE_BYTE_F(adr, res)
21394 POST_IO
21395 RET(16)
21396}
21397
21398// STCC
21399OPCODE(0x58E8)
21400{
21401 u32 adr, res;
21402 u32 src, dst;
21403
21404 FETCH_SWORD(adr);
21405 adr += AREG((Opcode >> 0) & 7);
21406 if (!(flag_V & 0x80))
21407 {
21408 res = 0xFF;
21409 PRE_IO
21410 WRITE_BYTE_F(adr, res)
21411 POST_IO
21412 RET(16)
21413 }
21414 res = 0;
21415 PRE_IO
21416 WRITE_BYTE_F(adr, res)
21417 POST_IO
21418 RET(16)
21419}
21420
21421// STCC
21422OPCODE(0x59E8)
21423{
21424 u32 adr, res;
21425 u32 src, dst;
21426
21427 FETCH_SWORD(adr);
21428 adr += AREG((Opcode >> 0) & 7);
21429 if (flag_V & 0x80)
21430 {
21431 res = 0xFF;
21432 PRE_IO
21433 WRITE_BYTE_F(adr, res)
21434 POST_IO
21435 RET(16)
21436 }
21437 res = 0;
21438 PRE_IO
21439 WRITE_BYTE_F(adr, res)
21440 POST_IO
21441 RET(16)
21442}
21443
21444// STCC
21445OPCODE(0x5AE8)
21446{
21447 u32 adr, res;
21448 u32 src, dst;
21449
21450 FETCH_SWORD(adr);
21451 adr += AREG((Opcode >> 0) & 7);
21452 if (!(flag_N & 0x80))
21453 {
21454 res = 0xFF;
21455 PRE_IO
21456 WRITE_BYTE_F(adr, res)
21457 POST_IO
21458 RET(16)
21459 }
21460 res = 0;
21461 PRE_IO
21462 WRITE_BYTE_F(adr, res)
21463 POST_IO
21464 RET(16)
21465}
21466
21467// STCC
21468OPCODE(0x5BE8)
21469{
21470 u32 adr, res;
21471 u32 src, dst;
21472
21473 FETCH_SWORD(adr);
21474 adr += AREG((Opcode >> 0) & 7);
21475 if (flag_N & 0x80)
21476 {
21477 res = 0xFF;
21478 PRE_IO
21479 WRITE_BYTE_F(adr, res)
21480 POST_IO
21481 RET(16)
21482 }
21483 res = 0;
21484 PRE_IO
21485 WRITE_BYTE_F(adr, res)
21486 POST_IO
21487 RET(16)
21488}
21489
21490// STCC
21491OPCODE(0x5CE8)
21492{
21493 u32 adr, res;
21494 u32 src, dst;
21495
21496 FETCH_SWORD(adr);
21497 adr += AREG((Opcode >> 0) & 7);
21498 if (!((flag_N ^ flag_V) & 0x80))
21499 {
21500 res = 0xFF;
21501 PRE_IO
21502 WRITE_BYTE_F(adr, res)
21503 POST_IO
21504 RET(16)
21505 }
21506 res = 0;
21507 PRE_IO
21508 WRITE_BYTE_F(adr, res)
21509 POST_IO
21510 RET(16)
21511}
21512
21513// STCC
21514OPCODE(0x5DE8)
21515{
21516 u32 adr, res;
21517 u32 src, dst;
21518
21519 FETCH_SWORD(adr);
21520 adr += AREG((Opcode >> 0) & 7);
21521 if ((flag_N ^ flag_V) & 0x80)
21522 {
21523 res = 0xFF;
21524 PRE_IO
21525 WRITE_BYTE_F(adr, res)
21526 POST_IO
21527 RET(16)
21528 }
21529 res = 0;
21530 PRE_IO
21531 WRITE_BYTE_F(adr, res)
21532 POST_IO
21533 RET(16)
21534}
21535
21536// STCC
21537OPCODE(0x5EE8)
21538{
21539 u32 adr, res;
21540 u32 src, dst;
21541
21542 FETCH_SWORD(adr);
21543 adr += AREG((Opcode >> 0) & 7);
21544 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21545 {
21546 res = 0xFF;
21547 PRE_IO
21548 WRITE_BYTE_F(adr, res)
21549 POST_IO
21550 RET(16)
21551 }
21552 res = 0;
21553 PRE_IO
21554 WRITE_BYTE_F(adr, res)
21555 POST_IO
21556 RET(16)
21557}
21558
21559// STCC
21560OPCODE(0x5FE8)
21561{
21562 u32 adr, res;
21563 u32 src, dst;
21564
21565 FETCH_SWORD(adr);
21566 adr += AREG((Opcode >> 0) & 7);
21567 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21568 {
21569 res = 0xFF;
21570 PRE_IO
21571 WRITE_BYTE_F(adr, res)
21572 POST_IO
21573 RET(16)
21574 }
21575 res = 0;
21576 PRE_IO
21577 WRITE_BYTE_F(adr, res)
21578 POST_IO
21579 RET(16)
21580}
21581
21582// STCC
21583OPCODE(0x50F0)
21584{
21585 u32 adr, res;
21586 u32 src, dst;
21587
21588 adr = AREG((Opcode >> 0) & 7);
21589 DECODE_EXT_WORD
21590 res = 0xFF;
21591 PRE_IO
21592 WRITE_BYTE_F(adr, res)
21593 POST_IO
21594 RET(18)
21595}
21596
21597// STCC
21598OPCODE(0x51F0)
21599{
21600 u32 adr, res;
21601 u32 src, dst;
21602
21603 adr = AREG((Opcode >> 0) & 7);
21604 DECODE_EXT_WORD
21605 res = 0;
21606 PRE_IO
21607 WRITE_BYTE_F(adr, res)
21608 POST_IO
21609 RET(18)
21610}
21611
21612// STCC
21613OPCODE(0x52F0)
21614{
21615 u32 adr, res;
21616 u32 src, dst;
21617
21618 adr = AREG((Opcode >> 0) & 7);
21619 DECODE_EXT_WORD
21620 if (flag_NotZ && (!(flag_C & 0x100)))
21621 {
21622 res = 0xFF;
21623 PRE_IO
21624 WRITE_BYTE_F(adr, res)
21625 POST_IO
21626 RET(18)
21627 }
21628 res = 0;
21629 PRE_IO
21630 WRITE_BYTE_F(adr, res)
21631 POST_IO
21632 RET(18)
21633}
21634
21635// STCC
21636OPCODE(0x53F0)
21637{
21638 u32 adr, res;
21639 u32 src, dst;
21640
21641 adr = AREG((Opcode >> 0) & 7);
21642 DECODE_EXT_WORD
21643 if ((!flag_NotZ) || (flag_C & 0x100))
21644 {
21645 res = 0xFF;
21646 PRE_IO
21647 WRITE_BYTE_F(adr, res)
21648 POST_IO
21649 RET(18)
21650 }
21651 res = 0;
21652 PRE_IO
21653 WRITE_BYTE_F(adr, res)
21654 POST_IO
21655 RET(18)
21656}
21657
21658// STCC
21659OPCODE(0x54F0)
21660{
21661 u32 adr, res;
21662 u32 src, dst;
21663
21664 adr = AREG((Opcode >> 0) & 7);
21665 DECODE_EXT_WORD
21666 if (!(flag_C & 0x100))
21667 {
21668 res = 0xFF;
21669 PRE_IO
21670 WRITE_BYTE_F(adr, res)
21671 POST_IO
21672 RET(18)
21673 }
21674 res = 0;
21675 PRE_IO
21676 WRITE_BYTE_F(adr, res)
21677 POST_IO
21678 RET(18)
21679}
21680
21681// STCC
21682OPCODE(0x55F0)
21683{
21684 u32 adr, res;
21685 u32 src, dst;
21686
21687 adr = AREG((Opcode >> 0) & 7);
21688 DECODE_EXT_WORD
21689 if (flag_C & 0x100)
21690 {
21691 res = 0xFF;
21692 PRE_IO
21693 WRITE_BYTE_F(adr, res)
21694 POST_IO
21695 RET(18)
21696 }
21697 res = 0;
21698 PRE_IO
21699 WRITE_BYTE_F(adr, res)
21700 POST_IO
21701 RET(18)
21702}
21703
21704// STCC
21705OPCODE(0x56F0)
21706{
21707 u32 adr, res;
21708 u32 src, dst;
21709
21710 adr = AREG((Opcode >> 0) & 7);
21711 DECODE_EXT_WORD
21712 if (flag_NotZ)
21713 {
21714 res = 0xFF;
21715 PRE_IO
21716 WRITE_BYTE_F(adr, res)
21717 POST_IO
21718 RET(18)
21719 }
21720 res = 0;
21721 PRE_IO
21722 WRITE_BYTE_F(adr, res)
21723 POST_IO
21724 RET(18)
21725}
21726
21727// STCC
21728OPCODE(0x57F0)
21729{
21730 u32 adr, res;
21731 u32 src, dst;
21732
21733 adr = AREG((Opcode >> 0) & 7);
21734 DECODE_EXT_WORD
21735 if (!flag_NotZ)
21736 {
21737 res = 0xFF;
21738 PRE_IO
21739 WRITE_BYTE_F(adr, res)
21740 POST_IO
21741 RET(18)
21742 }
21743 res = 0;
21744 PRE_IO
21745 WRITE_BYTE_F(adr, res)
21746 POST_IO
21747 RET(18)
21748}
21749
21750// STCC
21751OPCODE(0x58F0)
21752{
21753 u32 adr, res;
21754 u32 src, dst;
21755
21756 adr = AREG((Opcode >> 0) & 7);
21757 DECODE_EXT_WORD
21758 if (!(flag_V & 0x80))
21759 {
21760 res = 0xFF;
21761 PRE_IO
21762 WRITE_BYTE_F(adr, res)
21763 POST_IO
21764 RET(18)
21765 }
21766 res = 0;
21767 PRE_IO
21768 WRITE_BYTE_F(adr, res)
21769 POST_IO
21770 RET(18)
21771}
21772
21773// STCC
21774OPCODE(0x59F0)
21775{
21776 u32 adr, res;
21777 u32 src, dst;
21778
21779 adr = AREG((Opcode >> 0) & 7);
21780 DECODE_EXT_WORD
21781 if (flag_V & 0x80)
21782 {
21783 res = 0xFF;
21784 PRE_IO
21785 WRITE_BYTE_F(adr, res)
21786 POST_IO
21787 RET(18)
21788 }
21789 res = 0;
21790 PRE_IO
21791 WRITE_BYTE_F(adr, res)
21792 POST_IO
21793 RET(18)
21794}
21795
21796// STCC
21797OPCODE(0x5AF0)
21798{
21799 u32 adr, res;
21800 u32 src, dst;
21801
21802 adr = AREG((Opcode >> 0) & 7);
21803 DECODE_EXT_WORD
21804 if (!(flag_N & 0x80))
21805 {
21806 res = 0xFF;
21807 PRE_IO
21808 WRITE_BYTE_F(adr, res)
21809 POST_IO
21810 RET(18)
21811 }
21812 res = 0;
21813 PRE_IO
21814 WRITE_BYTE_F(adr, res)
21815 POST_IO
21816 RET(18)
21817}
21818
21819// STCC
21820OPCODE(0x5BF0)
21821{
21822 u32 adr, res;
21823 u32 src, dst;
21824
21825 adr = AREG((Opcode >> 0) & 7);
21826 DECODE_EXT_WORD
21827 if (flag_N & 0x80)
21828 {
21829 res = 0xFF;
21830 PRE_IO
21831 WRITE_BYTE_F(adr, res)
21832 POST_IO
21833 RET(18)
21834 }
21835 res = 0;
21836 PRE_IO
21837 WRITE_BYTE_F(adr, res)
21838 POST_IO
21839 RET(18)
21840}
21841
21842// STCC
21843OPCODE(0x5CF0)
21844{
21845 u32 adr, res;
21846 u32 src, dst;
21847
21848 adr = AREG((Opcode >> 0) & 7);
21849 DECODE_EXT_WORD
21850 if (!((flag_N ^ flag_V) & 0x80))
21851 {
21852 res = 0xFF;
21853 PRE_IO
21854 WRITE_BYTE_F(adr, res)
21855 POST_IO
21856 RET(18)
21857 }
21858 res = 0;
21859 PRE_IO
21860 WRITE_BYTE_F(adr, res)
21861 POST_IO
21862 RET(18)
21863}
21864
21865// STCC
21866OPCODE(0x5DF0)
21867{
21868 u32 adr, res;
21869 u32 src, dst;
21870
21871 adr = AREG((Opcode >> 0) & 7);
21872 DECODE_EXT_WORD
21873 if ((flag_N ^ flag_V) & 0x80)
21874 {
21875 res = 0xFF;
21876 PRE_IO
21877 WRITE_BYTE_F(adr, res)
21878 POST_IO
21879 RET(18)
21880 }
21881 res = 0;
21882 PRE_IO
21883 WRITE_BYTE_F(adr, res)
21884 POST_IO
21885 RET(18)
21886}
21887
21888// STCC
21889OPCODE(0x5EF0)
21890{
21891 u32 adr, res;
21892 u32 src, dst;
21893
21894 adr = AREG((Opcode >> 0) & 7);
21895 DECODE_EXT_WORD
21896 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21897 {
21898 res = 0xFF;
21899 PRE_IO
21900 WRITE_BYTE_F(adr, res)
21901 POST_IO
21902 RET(18)
21903 }
21904 res = 0;
21905 PRE_IO
21906 WRITE_BYTE_F(adr, res)
21907 POST_IO
21908 RET(18)
21909}
21910
21911// STCC
21912OPCODE(0x5FF0)
21913{
21914 u32 adr, res;
21915 u32 src, dst;
21916
21917 adr = AREG((Opcode >> 0) & 7);
21918 DECODE_EXT_WORD
21919 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21920 {
21921 res = 0xFF;
21922 PRE_IO
21923 WRITE_BYTE_F(adr, res)
21924 POST_IO
21925 RET(18)
21926 }
21927 res = 0;
21928 PRE_IO
21929 WRITE_BYTE_F(adr, res)
21930 POST_IO
21931 RET(18)
21932}
21933
21934// STCC
21935OPCODE(0x50F8)
21936{
21937 u32 adr, res;
21938 u32 src, dst;
21939
21940 FETCH_SWORD(adr);
21941 res = 0xFF;
21942 PRE_IO
21943 WRITE_BYTE_F(adr, res)
21944 POST_IO
21945 RET(16)
21946}
21947
21948// STCC
21949OPCODE(0x51F8)
21950{
21951 u32 adr, res;
21952 u32 src, dst;
21953
21954 FETCH_SWORD(adr);
21955 res = 0;
21956 PRE_IO
21957 WRITE_BYTE_F(adr, res)
21958 POST_IO
21959 RET(16)
21960}
21961
21962// STCC
21963OPCODE(0x52F8)
21964{
21965 u32 adr, res;
21966 u32 src, dst;
21967
21968 FETCH_SWORD(adr);
21969 if (flag_NotZ && (!(flag_C & 0x100)))
21970 {
21971 res = 0xFF;
21972 PRE_IO
21973 WRITE_BYTE_F(adr, res)
21974 POST_IO
21975 RET(16)
21976 }
21977 res = 0;
21978 PRE_IO
21979 WRITE_BYTE_F(adr, res)
21980 POST_IO
21981 RET(16)
21982}
21983
21984// STCC
21985OPCODE(0x53F8)
21986{
21987 u32 adr, res;
21988 u32 src, dst;
21989
21990 FETCH_SWORD(adr);
21991 if ((!flag_NotZ) || (flag_C & 0x100))
21992 {
21993 res = 0xFF;
21994 PRE_IO
21995 WRITE_BYTE_F(adr, res)
21996 POST_IO
21997 RET(16)
21998 }
21999 res = 0;
22000 PRE_IO
22001 WRITE_BYTE_F(adr, res)
22002 POST_IO
22003 RET(16)
22004}
22005
22006// STCC
22007OPCODE(0x54F8)
22008{
22009 u32 adr, res;
22010 u32 src, dst;
22011
22012 FETCH_SWORD(adr);
22013 if (!(flag_C & 0x100))
22014 {
22015 res = 0xFF;
22016 PRE_IO
22017 WRITE_BYTE_F(adr, res)
22018 POST_IO
22019 RET(16)
22020 }
22021 res = 0;
22022 PRE_IO
22023 WRITE_BYTE_F(adr, res)
22024 POST_IO
22025 RET(16)
22026}
22027
22028// STCC
22029OPCODE(0x55F8)
22030{
22031 u32 adr, res;
22032 u32 src, dst;
22033
22034 FETCH_SWORD(adr);
22035 if (flag_C & 0x100)
22036 {
22037 res = 0xFF;
22038 PRE_IO
22039 WRITE_BYTE_F(adr, res)
22040 POST_IO
22041 RET(16)
22042 }
22043 res = 0;
22044 PRE_IO
22045 WRITE_BYTE_F(adr, res)
22046 POST_IO
22047 RET(16)
22048}
22049
22050// STCC
22051OPCODE(0x56F8)
22052{
22053 u32 adr, res;
22054 u32 src, dst;
22055
22056 FETCH_SWORD(adr);
22057 if (flag_NotZ)
22058 {
22059 res = 0xFF;
22060 PRE_IO
22061 WRITE_BYTE_F(adr, res)
22062 POST_IO
22063 RET(16)
22064 }
22065 res = 0;
22066 PRE_IO
22067 WRITE_BYTE_F(adr, res)
22068 POST_IO
22069 RET(16)
22070}
22071
22072// STCC
22073OPCODE(0x57F8)
22074{
22075 u32 adr, res;
22076 u32 src, dst;
22077
22078 FETCH_SWORD(adr);
22079 if (!flag_NotZ)
22080 {
22081 res = 0xFF;
22082 PRE_IO
22083 WRITE_BYTE_F(adr, res)
22084 POST_IO
22085 RET(16)
22086 }
22087 res = 0;
22088 PRE_IO
22089 WRITE_BYTE_F(adr, res)
22090 POST_IO
22091 RET(16)
22092}
22093
22094// STCC
22095OPCODE(0x58F8)
22096{
22097 u32 adr, res;
22098 u32 src, dst;
22099
22100 FETCH_SWORD(adr);
22101 if (!(flag_V & 0x80))
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(0x59F8)
22118{
22119 u32 adr, res;
22120 u32 src, dst;
22121
22122 FETCH_SWORD(adr);
22123 if (flag_V & 0x80)
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(0x5AF8)
22140{
22141 u32 adr, res;
22142 u32 src, dst;
22143
22144 FETCH_SWORD(adr);
22145 if (!(flag_N & 0x80))
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(0x5BF8)
22162{
22163 u32 adr, res;
22164 u32 src, dst;
22165
22166 FETCH_SWORD(adr);
22167 if (flag_N & 0x80)
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(0x5CF8)
22184{
22185 u32 adr, res;
22186 u32 src, dst;
22187
22188 FETCH_SWORD(adr);
22189 if (!((flag_N ^ flag_V) & 0x80))
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(0x5DF8)
22206{
22207 u32 adr, res;
22208 u32 src, dst;
22209
22210 FETCH_SWORD(adr);
22211 if ((flag_N ^ flag_V) & 0x80)
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(0x5EF8)
22228{
22229 u32 adr, res;
22230 u32 src, dst;
22231
22232 FETCH_SWORD(adr);
22233 if (flag_NotZ && (!((flag_N ^ 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(0x5FF8)
22250{
22251 u32 adr, res;
22252 u32 src, dst;
22253
22254 FETCH_SWORD(adr);
22255 if ((!flag_NotZ) || ((flag_N ^ 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(0x50F9)
22272{
22273 u32 adr, res;
22274 u32 src, dst;
22275
22276 FETCH_LONG(adr);
22277 res = 0xFF;
22278 PRE_IO
22279 WRITE_BYTE_F(adr, res)
22280 POST_IO
22281 RET(20)
22282}
22283
22284// STCC
22285OPCODE(0x51F9)
22286{
22287 u32 adr, res;
22288 u32 src, dst;
22289
22290 FETCH_LONG(adr);
22291 res = 0;
22292 PRE_IO
22293 WRITE_BYTE_F(adr, res)
22294 POST_IO
22295 RET(20)
22296}
22297
22298// STCC
22299OPCODE(0x52F9)
22300{
22301 u32 adr, res;
22302 u32 src, dst;
22303
22304 FETCH_LONG(adr);
22305 if (flag_NotZ && (!(flag_C & 0x100)))
22306 {
22307 res = 0xFF;
22308 PRE_IO
22309 WRITE_BYTE_F(adr, res)
22310 POST_IO
22311 RET(20)
22312 }
22313 res = 0;
22314 PRE_IO
22315 WRITE_BYTE_F(adr, res)
22316 POST_IO
22317 RET(20)
22318}
22319
22320// STCC
22321OPCODE(0x53F9)
22322{
22323 u32 adr, res;
22324 u32 src, dst;
22325
22326 FETCH_LONG(adr);
22327 if ((!flag_NotZ) || (flag_C & 0x100))
22328 {
22329 res = 0xFF;
22330 PRE_IO
22331 WRITE_BYTE_F(adr, res)
22332 POST_IO
22333 RET(20)
22334 }
22335 res = 0;
22336 PRE_IO
22337 WRITE_BYTE_F(adr, res)
22338 POST_IO
22339 RET(20)
22340}
22341
22342// STCC
22343OPCODE(0x54F9)
22344{
22345 u32 adr, res;
22346 u32 src, dst;
22347
22348 FETCH_LONG(adr);
22349 if (!(flag_C & 0x100))
22350 {
22351 res = 0xFF;
22352 PRE_IO
22353 WRITE_BYTE_F(adr, res)
22354 POST_IO
22355 RET(20)
22356 }
22357 res = 0;
22358 PRE_IO
22359 WRITE_BYTE_F(adr, res)
22360 POST_IO
22361 RET(20)
22362}
22363
22364// STCC
22365OPCODE(0x55F9)
22366{
22367 u32 adr, res;
22368 u32 src, dst;
22369
22370 FETCH_LONG(adr);
22371 if (flag_C & 0x100)
22372 {
22373 res = 0xFF;
22374 PRE_IO
22375 WRITE_BYTE_F(adr, res)
22376 POST_IO
22377 RET(20)
22378 }
22379 res = 0;
22380 PRE_IO
22381 WRITE_BYTE_F(adr, res)
22382 POST_IO
22383 RET(20)
22384}
22385
22386// STCC
22387OPCODE(0x56F9)
22388{
22389 u32 adr, res;
22390 u32 src, dst;
22391
22392 FETCH_LONG(adr);
22393 if (flag_NotZ)
22394 {
22395 res = 0xFF;
22396 PRE_IO
22397 WRITE_BYTE_F(adr, res)
22398 POST_IO
22399 RET(20)
22400 }
22401 res = 0;
22402 PRE_IO
22403 WRITE_BYTE_F(adr, res)
22404 POST_IO
22405 RET(20)
22406}
22407
22408// STCC
22409OPCODE(0x57F9)
22410{
22411 u32 adr, res;
22412 u32 src, dst;
22413
22414 FETCH_LONG(adr);
22415 if (!flag_NotZ)
22416 {
22417 res = 0xFF;
22418 PRE_IO
22419 WRITE_BYTE_F(adr, res)
22420 POST_IO
22421 RET(20)
22422 }
22423 res = 0;
22424 PRE_IO
22425 WRITE_BYTE_F(adr, res)
22426 POST_IO
22427 RET(20)
22428}
22429
22430// STCC
22431OPCODE(0x58F9)
22432{
22433 u32 adr, res;
22434 u32 src, dst;
22435
22436 FETCH_LONG(adr);
22437 if (!(flag_V & 0x80))
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(0x59F9)
22454{
22455 u32 adr, res;
22456 u32 src, dst;
22457
22458 FETCH_LONG(adr);
22459 if (flag_V & 0x80)
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(0x5AF9)
22476{
22477 u32 adr, res;
22478 u32 src, dst;
22479
22480 FETCH_LONG(adr);
22481 if (!(flag_N & 0x80))
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(0x5BF9)
22498{
22499 u32 adr, res;
22500 u32 src, dst;
22501
22502 FETCH_LONG(adr);
22503 if (flag_N & 0x80)
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(0x5CF9)
22520{
22521 u32 adr, res;
22522 u32 src, dst;
22523
22524 FETCH_LONG(adr);
22525 if (!((flag_N ^ flag_V) & 0x80))
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(0x5DF9)
22542{
22543 u32 adr, res;
22544 u32 src, dst;
22545
22546 FETCH_LONG(adr);
22547 if ((flag_N ^ flag_V) & 0x80)
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(0x5EF9)
22564{
22565 u32 adr, res;
22566 u32 src, dst;
22567
22568 FETCH_LONG(adr);
22569 if (flag_NotZ && (!((flag_N ^ 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(0x5FF9)
22586{
22587 u32 adr, res;
22588 u32 src, dst;
22589
22590 FETCH_LONG(adr);
22591 if ((!flag_NotZ) || ((flag_N ^ 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(0x50DF)
22608{
22609 u32 adr, res;
22610 u32 src, dst;
22611
22612 adr = AREG(7);
22613 AREG(7) += 2;
22614 res = 0xFF;
22615 PRE_IO
22616 WRITE_BYTE_F(adr, res)
22617 POST_IO
22618 RET(12)
22619}
22620
22621// STCC
22622OPCODE(0x51DF)
22623{
22624 u32 adr, res;
22625 u32 src, dst;
22626
22627 adr = AREG(7);
22628 AREG(7) += 2;
22629 res = 0;
22630 PRE_IO
22631 WRITE_BYTE_F(adr, res)
22632 POST_IO
22633 RET(12)
22634}
22635
22636// STCC
22637OPCODE(0x52DF)
22638{
22639 u32 adr, res;
22640 u32 src, dst;
22641
22642 adr = AREG(7);
22643 AREG(7) += 2;
22644 if (flag_NotZ && (!(flag_C & 0x100)))
22645 {
22646 res = 0xFF;
22647 PRE_IO
22648 WRITE_BYTE_F(adr, res)
22649 POST_IO
22650 RET(12)
22651 }
22652 res = 0;
22653 PRE_IO
22654 WRITE_BYTE_F(adr, res)
22655 POST_IO
22656 RET(12)
22657}
22658
22659// STCC
22660OPCODE(0x53DF)
22661{
22662 u32 adr, res;
22663 u32 src, dst;
22664
22665 adr = AREG(7);
22666 AREG(7) += 2;
22667 if ((!flag_NotZ) || (flag_C & 0x100))
22668 {
22669 res = 0xFF;
22670 PRE_IO
22671 WRITE_BYTE_F(adr, res)
22672 POST_IO
22673 RET(12)
22674 }
22675 res = 0;
22676 PRE_IO
22677 WRITE_BYTE_F(adr, res)
22678 POST_IO
22679 RET(12)
22680}
22681
22682// STCC
22683OPCODE(0x54DF)
22684{
22685 u32 adr, res;
22686 u32 src, dst;
22687
22688 adr = AREG(7);
22689 AREG(7) += 2;
22690 if (!(flag_C & 0x100))
22691 {
22692 res = 0xFF;
22693 PRE_IO
22694 WRITE_BYTE_F(adr, res)
22695 POST_IO
22696 RET(12)
22697 }
22698 res = 0;
22699 PRE_IO
22700 WRITE_BYTE_F(adr, res)
22701 POST_IO
22702 RET(12)
22703}
22704
22705// STCC
22706OPCODE(0x55DF)
22707{
22708 u32 adr, res;
22709 u32 src, dst;
22710
22711 adr = AREG(7);
22712 AREG(7) += 2;
22713 if (flag_C & 0x100)
22714 {
22715 res = 0xFF;
22716 PRE_IO
22717 WRITE_BYTE_F(adr, res)
22718 POST_IO
22719 RET(12)
22720 }
22721 res = 0;
22722 PRE_IO
22723 WRITE_BYTE_F(adr, res)
22724 POST_IO
22725 RET(12)
22726}
22727
22728// STCC
22729OPCODE(0x56DF)
22730{
22731 u32 adr, res;
22732 u32 src, dst;
22733
22734 adr = AREG(7);
22735 AREG(7) += 2;
22736 if (flag_NotZ)
22737 {
22738 res = 0xFF;
22739 PRE_IO
22740 WRITE_BYTE_F(adr, res)
22741 POST_IO
22742 RET(12)
22743 }
22744 res = 0;
22745 PRE_IO
22746 WRITE_BYTE_F(adr, res)
22747 POST_IO
22748 RET(12)
22749}
22750
22751// STCC
22752OPCODE(0x57DF)
22753{
22754 u32 adr, res;
22755 u32 src, dst;
22756
22757 adr = AREG(7);
22758 AREG(7) += 2;
22759 if (!flag_NotZ)
22760 {
22761 res = 0xFF;
22762 PRE_IO
22763 WRITE_BYTE_F(adr, res)
22764 POST_IO
22765 RET(12)
22766 }
22767 res = 0;
22768 PRE_IO
22769 WRITE_BYTE_F(adr, res)
22770 POST_IO
22771 RET(12)
22772}
22773
22774// STCC
22775OPCODE(0x58DF)
22776{
22777 u32 adr, res;
22778 u32 src, dst;
22779
22780 adr = AREG(7);
22781 AREG(7) += 2;
22782 if (!(flag_V & 0x80))
22783 {
22784 res = 0xFF;
22785 PRE_IO
22786 WRITE_BYTE_F(adr, res)
22787 POST_IO
22788 RET(12)
22789 }
22790 res = 0;
22791 PRE_IO
22792 WRITE_BYTE_F(adr, res)
22793 POST_IO
22794 RET(12)
22795}
22796
22797// STCC
22798OPCODE(0x59DF)
22799{
22800 u32 adr, res;
22801 u32 src, dst;
22802
22803 adr = AREG(7);
22804 AREG(7) += 2;
22805 if (flag_V & 0x80)
22806 {
22807 res = 0xFF;
22808 PRE_IO
22809 WRITE_BYTE_F(adr, res)
22810 POST_IO
22811 RET(12)
22812 }
22813 res = 0;
22814 PRE_IO
22815 WRITE_BYTE_F(adr, res)
22816 POST_IO
22817 RET(12)
22818}
22819
22820// STCC
22821OPCODE(0x5ADF)
22822{
22823 u32 adr, res;
22824 u32 src, dst;
22825
22826 adr = AREG(7);
22827 AREG(7) += 2;
22828 if (!(flag_N & 0x80))
22829 {
22830 res = 0xFF;
22831 PRE_IO
22832 WRITE_BYTE_F(adr, res)
22833 POST_IO
22834 RET(12)
22835 }
22836 res = 0;
22837 PRE_IO
22838 WRITE_BYTE_F(adr, res)
22839 POST_IO
22840 RET(12)
22841}
22842
22843// STCC
22844OPCODE(0x5BDF)
22845{
22846 u32 adr, res;
22847 u32 src, dst;
22848
22849 adr = AREG(7);
22850 AREG(7) += 2;
22851 if (flag_N & 0x80)
22852 {
22853 res = 0xFF;
22854 PRE_IO
22855 WRITE_BYTE_F(adr, res)
22856 POST_IO
22857 RET(12)
22858 }
22859 res = 0;
22860 PRE_IO
22861 WRITE_BYTE_F(adr, res)
22862 POST_IO
22863 RET(12)
22864}
22865
22866// STCC
22867OPCODE(0x5CDF)
22868{
22869 u32 adr, res;
22870 u32 src, dst;
22871
22872 adr = AREG(7);
22873 AREG(7) += 2;
22874 if (!((flag_N ^ flag_V) & 0x80))
22875 {
22876 res = 0xFF;
22877 PRE_IO
22878 WRITE_BYTE_F(adr, res)
22879 POST_IO
22880 RET(12)
22881 }
22882 res = 0;
22883 PRE_IO
22884 WRITE_BYTE_F(adr, res)
22885 POST_IO
22886 RET(12)
22887}
22888
22889// STCC
22890OPCODE(0x5DDF)
22891{
22892 u32 adr, res;
22893 u32 src, dst;
22894
22895 adr = AREG(7);
22896 AREG(7) += 2;
22897 if ((flag_N ^ flag_V) & 0x80)
22898 {
22899 res = 0xFF;
22900 PRE_IO
22901 WRITE_BYTE_F(adr, res)
22902 POST_IO
22903 RET(12)
22904 }
22905 res = 0;
22906 PRE_IO
22907 WRITE_BYTE_F(adr, res)
22908 POST_IO
22909 RET(12)
22910}
22911
22912// STCC
22913OPCODE(0x5EDF)
22914{
22915 u32 adr, res;
22916 u32 src, dst;
22917
22918 adr = AREG(7);
22919 AREG(7) += 2;
22920 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22921 {
22922 res = 0xFF;
22923 PRE_IO
22924 WRITE_BYTE_F(adr, res)
22925 POST_IO
22926 RET(12)
22927 }
22928 res = 0;
22929 PRE_IO
22930 WRITE_BYTE_F(adr, res)
22931 POST_IO
22932 RET(12)
22933}
22934
22935// STCC
22936OPCODE(0x5FDF)
22937{
22938 u32 adr, res;
22939 u32 src, dst;
22940
22941 adr = AREG(7);
22942 AREG(7) += 2;
22943 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22944 {
22945 res = 0xFF;
22946 PRE_IO
22947 WRITE_BYTE_F(adr, res)
22948 POST_IO
22949 RET(12)
22950 }
22951 res = 0;
22952 PRE_IO
22953 WRITE_BYTE_F(adr, res)
22954 POST_IO
22955 RET(12)
22956}
22957
22958// STCC
22959OPCODE(0x50E7)
22960{
22961 u32 adr, res;
22962 u32 src, dst;
22963
22964 adr = AREG(7) - 2;
22965 AREG(7) = adr;
22966 res = 0xFF;
22967 PRE_IO
22968 WRITE_BYTE_F(adr, res)
22969 POST_IO
22970 RET(14)
22971}
22972
22973// STCC
22974OPCODE(0x51E7)
22975{
22976 u32 adr, res;
22977 u32 src, dst;
22978
22979 adr = AREG(7) - 2;
22980 AREG(7) = adr;
22981 res = 0;
22982 PRE_IO
22983 WRITE_BYTE_F(adr, res)
22984 POST_IO
22985 RET(14)
22986}
22987
22988// STCC
22989OPCODE(0x52E7)
22990{
22991 u32 adr, res;
22992 u32 src, dst;
22993
22994 adr = AREG(7) - 2;
22995 AREG(7) = adr;
22996 if (flag_NotZ && (!(flag_C & 0x100)))
22997 {
22998 res = 0xFF;
22999 PRE_IO
23000 WRITE_BYTE_F(adr, res)
23001 POST_IO
23002 RET(14)
23003 }
23004 res = 0;
23005 PRE_IO
23006 WRITE_BYTE_F(adr, res)
23007 POST_IO
23008 RET(14)
23009}
23010
23011// STCC
23012OPCODE(0x53E7)
23013{
23014 u32 adr, res;
23015 u32 src, dst;
23016
23017 adr = AREG(7) - 2;
23018 AREG(7) = adr;
23019 if ((!flag_NotZ) || (flag_C & 0x100))
23020 {
23021 res = 0xFF;
23022 PRE_IO
23023 WRITE_BYTE_F(adr, res)
23024 POST_IO
23025 RET(14)
23026 }
23027 res = 0;
23028 PRE_IO
23029 WRITE_BYTE_F(adr, res)
23030 POST_IO
23031 RET(14)
23032}
23033
23034// STCC
23035OPCODE(0x54E7)
23036{
23037 u32 adr, res;
23038 u32 src, dst;
23039
23040 adr = AREG(7) - 2;
23041 AREG(7) = adr;
23042 if (!(flag_C & 0x100))
23043 {
23044 res = 0xFF;
23045 PRE_IO
23046 WRITE_BYTE_F(adr, res)
23047 POST_IO
23048 RET(14)
23049 }
23050 res = 0;
23051 PRE_IO
23052 WRITE_BYTE_F(adr, res)
23053 POST_IO
23054 RET(14)
23055}
23056
23057// STCC
23058OPCODE(0x55E7)
23059{
23060 u32 adr, res;
23061 u32 src, dst;
23062
23063 adr = AREG(7) - 2;
23064 AREG(7) = adr;
23065 if (flag_C & 0x100)
23066 {
23067 res = 0xFF;
23068 PRE_IO
23069 WRITE_BYTE_F(adr, res)
23070 POST_IO
23071 RET(14)
23072 }
23073 res = 0;
23074 PRE_IO
23075 WRITE_BYTE_F(adr, res)
23076 POST_IO
23077 RET(14)
23078}
23079
23080// STCC
23081OPCODE(0x56E7)
23082{
23083 u32 adr, res;
23084 u32 src, dst;
23085
23086 adr = AREG(7) - 2;
23087 AREG(7) = adr;
23088 if (flag_NotZ)
23089 {
23090 res = 0xFF;
23091 PRE_IO
23092 WRITE_BYTE_F(adr, res)
23093 POST_IO
23094 RET(14)
23095 }
23096 res = 0;
23097 PRE_IO
23098 WRITE_BYTE_F(adr, res)
23099 POST_IO
23100 RET(14)
23101}
23102
23103// STCC
23104OPCODE(0x57E7)
23105{
23106 u32 adr, res;
23107 u32 src, dst;
23108
23109 adr = AREG(7) - 2;
23110 AREG(7) = adr;
23111 if (!flag_NotZ)
23112 {
23113 res = 0xFF;
23114 PRE_IO
23115 WRITE_BYTE_F(adr, res)
23116 POST_IO
23117 RET(14)
23118 }
23119 res = 0;
23120 PRE_IO
23121 WRITE_BYTE_F(adr, res)
23122 POST_IO
23123 RET(14)
23124}
23125
23126// STCC
23127OPCODE(0x58E7)
23128{
23129 u32 adr, res;
23130 u32 src, dst;
23131
23132 adr = AREG(7) - 2;
23133 AREG(7) = adr;
23134 if (!(flag_V & 0x80))
23135 {
23136 res = 0xFF;
23137 PRE_IO
23138 WRITE_BYTE_F(adr, res)
23139 POST_IO
23140 RET(14)
23141 }
23142 res = 0;
23143 PRE_IO
23144 WRITE_BYTE_F(adr, res)
23145 POST_IO
23146 RET(14)
23147}
23148
23149// STCC
23150OPCODE(0x59E7)
23151{
23152 u32 adr, res;
23153 u32 src, dst;
23154
23155 adr = AREG(7) - 2;
23156 AREG(7) = adr;
23157 if (flag_V & 0x80)
23158 {
23159 res = 0xFF;
23160 PRE_IO
23161 WRITE_BYTE_F(adr, res)
23162 POST_IO
23163 RET(14)
23164 }
23165 res = 0;
23166 PRE_IO
23167 WRITE_BYTE_F(adr, res)
23168 POST_IO
23169 RET(14)
23170}
23171
23172// STCC
23173OPCODE(0x5AE7)
23174{
23175 u32 adr, res;
23176 u32 src, dst;
23177
23178 adr = AREG(7) - 2;
23179 AREG(7) = adr;
23180 if (!(flag_N & 0x80))
23181 {
23182 res = 0xFF;
23183 PRE_IO
23184 WRITE_BYTE_F(adr, res)
23185 POST_IO
23186 RET(14)
23187 }
23188 res = 0;
23189 PRE_IO
23190 WRITE_BYTE_F(adr, res)
23191 POST_IO
23192 RET(14)
23193}
23194
23195// STCC
23196OPCODE(0x5BE7)
23197{
23198 u32 adr, res;
23199 u32 src, dst;
23200
23201 adr = AREG(7) - 2;
23202 AREG(7) = adr;
23203 if (flag_N & 0x80)
23204 {
23205 res = 0xFF;
23206 PRE_IO
23207 WRITE_BYTE_F(adr, res)
23208 POST_IO
23209 RET(14)
23210 }
23211 res = 0;
23212 PRE_IO
23213 WRITE_BYTE_F(adr, res)
23214 POST_IO
23215 RET(14)
23216}
23217
23218// STCC
23219OPCODE(0x5CE7)
23220{
23221 u32 adr, res;
23222 u32 src, dst;
23223
23224 adr = AREG(7) - 2;
23225 AREG(7) = adr;
23226 if (!((flag_N ^ flag_V) & 0x80))
23227 {
23228 res = 0xFF;
23229 PRE_IO
23230 WRITE_BYTE_F(adr, res)
23231 POST_IO
23232 RET(14)
23233 }
23234 res = 0;
23235 PRE_IO
23236 WRITE_BYTE_F(adr, res)
23237 POST_IO
23238 RET(14)
23239}
23240
23241// STCC
23242OPCODE(0x5DE7)
23243{
23244 u32 adr, res;
23245 u32 src, dst;
23246
23247 adr = AREG(7) - 2;
23248 AREG(7) = adr;
23249 if ((flag_N ^ flag_V) & 0x80)
23250 {
23251 res = 0xFF;
23252 PRE_IO
23253 WRITE_BYTE_F(adr, res)
23254 POST_IO
23255 RET(14)
23256 }
23257 res = 0;
23258 PRE_IO
23259 WRITE_BYTE_F(adr, res)
23260 POST_IO
23261 RET(14)
23262}
23263
23264// STCC
23265OPCODE(0x5EE7)
23266{
23267 u32 adr, res;
23268 u32 src, dst;
23269
23270 adr = AREG(7) - 2;
23271 AREG(7) = adr;
23272 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23273 {
23274 res = 0xFF;
23275 PRE_IO
23276 WRITE_BYTE_F(adr, res)
23277 POST_IO
23278 RET(14)
23279 }
23280 res = 0;
23281 PRE_IO
23282 WRITE_BYTE_F(adr, res)
23283 POST_IO
23284 RET(14)
23285}
23286
23287// STCC
23288OPCODE(0x5FE7)
23289{
23290 u32 adr, res;
23291 u32 src, dst;
23292
23293 adr = AREG(7) - 2;
23294 AREG(7) = adr;
23295 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23296 {
23297 res = 0xFF;
23298 PRE_IO
23299 WRITE_BYTE_F(adr, res)
23300 POST_IO
23301 RET(14)
23302 }
23303 res = 0;
23304 PRE_IO
23305 WRITE_BYTE_F(adr, res)
23306 POST_IO
23307 RET(14)
23308}
23309
23310// DBCC
23311OPCODE(0x50C8)
23312{
23313 u32 adr, res;
23314 u32 src, dst;
23315
23316 PC++;
23317RET(12)
23318}
23319
23320// DBCC
23321OPCODE(0x51C8)
23322{
23323 u32 adr, res;
23324 u32 src, dst;
23325
ecc8036e 23326 NOT_POLLING
23327
70357ce5 23328 res = DREGu16((Opcode >> 0) & 7);
23329 res--;
23330 DREGu16((Opcode >> 0) & 7) = res;
23331 if ((s32)res != -1)
23332 {
23333 u32 newPC;
23334
be26eb23 23335 newPC = GET_PC;
70357ce5 23336 newPC += GET_SWORD;
23337 SET_PC(newPC);
23338 CHECK_BRANCH_EXCEPTION(newPC)
23339 RET(10)
23340 }
23341 PC++;
23342RET(14)
23343}
23344
23345// DBCC
23346OPCODE(0x52C8)
23347{
23348 u32 adr, res;
23349 u32 src, dst;
23350
ecc8036e 23351 NOT_POLLING
23352
70357ce5 23353 if ((!flag_NotZ) || (flag_C & 0x100))
23354 {
23355 res = DREGu16((Opcode >> 0) & 7);
23356 res--;
23357 DREGu16((Opcode >> 0) & 7) = res;
23358 if ((s32)res != -1)
23359 {
23360 u32 newPC;
23361
be26eb23 23362 newPC = GET_PC;
70357ce5 23363 newPC += GET_SWORD;
23364 SET_PC(newPC);
23365 CHECK_BRANCH_EXCEPTION(newPC)
23366 RET(10)
23367 }
23368 }
23369 else
23370 {
23371 PC++;
23372 RET(12)
23373 }
23374 PC++;
23375RET(14)
23376}
23377
23378// DBCC
23379OPCODE(0x53C8)
23380{
23381 u32 adr, res;
23382 u32 src, dst;
23383
ecc8036e 23384 NOT_POLLING
23385
70357ce5 23386 if (flag_NotZ && (!(flag_C & 0x100)))
23387 {
23388 res = DREGu16((Opcode >> 0) & 7);
23389 res--;
23390 DREGu16((Opcode >> 0) & 7) = res;
23391 if ((s32)res != -1)
23392 {
23393 u32 newPC;
23394
be26eb23 23395 newPC = GET_PC;
70357ce5 23396 newPC += GET_SWORD;
23397 SET_PC(newPC);
23398 CHECK_BRANCH_EXCEPTION(newPC)
23399 RET(10)
23400 }
23401 }
23402 else
23403 {
23404 PC++;
23405 RET(12)
23406 }
23407 PC++;
23408RET(14)
23409}
23410
23411// DBCC
23412OPCODE(0x54C8)
23413{
23414 u32 adr, res;
23415 u32 src, dst;
23416
ecc8036e 23417 NOT_POLLING
23418
70357ce5 23419 if (flag_C & 0x100)
23420 {
23421 res = DREGu16((Opcode >> 0) & 7);
23422 res--;
23423 DREGu16((Opcode >> 0) & 7) = res;
23424 if ((s32)res != -1)
23425 {
23426 u32 newPC;
23427
be26eb23 23428 newPC = GET_PC;
70357ce5 23429 newPC += GET_SWORD;
23430 SET_PC(newPC);
23431 CHECK_BRANCH_EXCEPTION(newPC)
23432 RET(10)
23433 }
23434 }
23435 else
23436 {
23437 PC++;
23438 RET(12)
23439 }
23440 PC++;
23441RET(14)
23442}
23443
23444// DBCC
23445OPCODE(0x55C8)
23446{
23447 u32 adr, res;
23448 u32 src, dst;
23449
ecc8036e 23450 NOT_POLLING
23451
70357ce5 23452 if (!(flag_C & 0x100))
23453 {
23454 res = DREGu16((Opcode >> 0) & 7);
23455 res--;
23456 DREGu16((Opcode >> 0) & 7) = res;
23457 if ((s32)res != -1)
23458 {
23459 u32 newPC;
23460
be26eb23 23461 newPC = GET_PC;
70357ce5 23462 newPC += GET_SWORD;
23463 SET_PC(newPC);
23464 CHECK_BRANCH_EXCEPTION(newPC)
23465 RET(10)
23466 }
23467 }
23468 else
23469 {
23470 PC++;
23471 RET(12)
23472 }
23473 PC++;
23474RET(14)
23475}
23476
23477// DBCC
23478OPCODE(0x56C8)
23479{
23480 u32 adr, res;
23481 u32 src, dst;
23482
ecc8036e 23483 NOT_POLLING
23484
70357ce5 23485 if (!flag_NotZ)
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
be26eb23 23494 newPC = GET_PC;
70357ce5 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(0x57C8)
23512{
23513 u32 adr, res;
23514 u32 src, dst;
23515
ecc8036e 23516 NOT_POLLING
23517
70357ce5 23518 if (flag_NotZ)
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
be26eb23 23527 newPC = GET_PC;
70357ce5 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(0x58C8)
23545{
23546 u32 adr, res;
23547 u32 src, dst;
23548
ecc8036e 23549 NOT_POLLING
23550
70357ce5 23551 if (flag_V & 0x80)
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
be26eb23 23560 newPC = GET_PC;
70357ce5 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(0x59C8)
23578{
23579 u32 adr, res;
23580 u32 src, dst;
23581
ecc8036e 23582 NOT_POLLING
23583
70357ce5 23584 if (!(flag_V & 0x80))
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
be26eb23 23593 newPC = GET_PC;
70357ce5 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(0x5AC8)
23611{
23612 u32 adr, res;
23613 u32 src, dst;
23614
ecc8036e 23615 NOT_POLLING
23616
70357ce5 23617 if (flag_N & 0x80)
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
be26eb23 23626 newPC = GET_PC;
70357ce5 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(0x5BC8)
23644{
23645 u32 adr, res;
23646 u32 src, dst;
23647
ecc8036e 23648 NOT_POLLING
23649
70357ce5 23650 if (!(flag_N & 0x80))
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
be26eb23 23659 newPC = GET_PC;
70357ce5 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(0x5CC8)
23677{
23678 u32 adr, res;
23679 u32 src, dst;
23680
ecc8036e 23681 NOT_POLLING
23682
70357ce5 23683 if ((flag_N ^ 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
be26eb23 23692 newPC = GET_PC;
70357ce5 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(0x5DC8)
23710{
23711 u32 adr, res;
23712 u32 src, dst;
23713
ecc8036e 23714 NOT_POLLING
23715
70357ce5 23716 if (!((flag_N ^ 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
be26eb23 23725 newPC = GET_PC;
70357ce5 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(0x5EC8)
23743{
23744 u32 adr, res;
23745 u32 src, dst;
23746
ecc8036e 23747 NOT_POLLING
23748
70357ce5 23749 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 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
be26eb23 23758 newPC = GET_PC;
70357ce5 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(0x5FC8)
23776{
23777 u32 adr, res;
23778 u32 src, dst;
23779
ecc8036e 23780 NOT_POLLING
23781
70357ce5 23782 if (flag_NotZ && (!((flag_N ^ flag_V) & 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
be26eb23 23791 newPC = GET_PC;
70357ce5 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// ADDQ
23808OPCODE(0x5000)
23809{
23810 u32 adr, res;
23811 u32 src, dst;
23812
23813 src = (((Opcode >> 9) - 1) & 7) + 1;
23814 dst = DREGu8((Opcode >> 0) & 7);
23815 res = dst + src;
23816 flag_N = flag_X = flag_C = res;
23817 flag_V = (src ^ res) & (dst ^ res);
23818 flag_NotZ = res & 0xFF;
23819 DREGu8((Opcode >> 0) & 7) = res;
23820RET(4)
23821}
23822
23823// ADDQ
23824OPCODE(0x5010)
23825{
23826 u32 adr, res;
23827 u32 src, dst;
23828
23829 src = (((Opcode >> 9) - 1) & 7) + 1;
23830 adr = AREG((Opcode >> 0) & 7);
23831 PRE_IO
23832 READ_BYTE_F(adr, dst)
23833 res = dst + src;
23834 flag_N = flag_X = flag_C = res;
23835 flag_V = (src ^ res) & (dst ^ res);
23836 flag_NotZ = res & 0xFF;
23837 WRITE_BYTE_F(adr, res)
23838 POST_IO
23839RET(12)
23840}
23841
23842// ADDQ
23843OPCODE(0x5018)
23844{
23845 u32 adr, res;
23846 u32 src, dst;
23847
23848 src = (((Opcode >> 9) - 1) & 7) + 1;
23849 adr = AREG((Opcode >> 0) & 7);
23850 AREG((Opcode >> 0) & 7) += 1;
23851 PRE_IO
23852 READ_BYTE_F(adr, dst)
23853 res = dst + src;
23854 flag_N = flag_X = flag_C = res;
23855 flag_V = (src ^ res) & (dst ^ res);
23856 flag_NotZ = res & 0xFF;
23857 WRITE_BYTE_F(adr, res)
23858 POST_IO
23859RET(12)
23860}
23861
23862// ADDQ
23863OPCODE(0x5020)
23864{
23865 u32 adr, res;
23866 u32 src, dst;
23867
23868 src = (((Opcode >> 9) - 1) & 7) + 1;
23869 adr = AREG((Opcode >> 0) & 7) - 1;
23870 AREG((Opcode >> 0) & 7) = adr;
23871 PRE_IO
23872 READ_BYTE_F(adr, dst)
23873 res = dst + src;
23874 flag_N = flag_X = flag_C = res;
23875 flag_V = (src ^ res) & (dst ^ res);
23876 flag_NotZ = res & 0xFF;
23877 WRITE_BYTE_F(adr, res)
23878 POST_IO
23879RET(14)
23880}
23881
23882// ADDQ
23883OPCODE(0x5028)
23884{
23885 u32 adr, res;
23886 u32 src, dst;
23887
23888 src = (((Opcode >> 9) - 1) & 7) + 1;
23889 FETCH_SWORD(adr);
23890 adr += AREG((Opcode >> 0) & 7);
23891 PRE_IO
23892 READ_BYTE_F(adr, dst)
23893 res = dst + src;
23894 flag_N = flag_X = flag_C = res;
23895 flag_V = (src ^ res) & (dst ^ res);
23896 flag_NotZ = res & 0xFF;
23897 WRITE_BYTE_F(adr, res)
23898 POST_IO
23899RET(16)
23900}
23901
23902// ADDQ
23903OPCODE(0x5030)
23904{
23905 u32 adr, res;
23906 u32 src, dst;
23907
23908 src = (((Opcode >> 9) - 1) & 7) + 1;
23909 adr = AREG((Opcode >> 0) & 7);
23910 DECODE_EXT_WORD
23911 PRE_IO
23912 READ_BYTE_F(adr, dst)
23913 res = dst + src;
23914 flag_N = flag_X = flag_C = res;
23915 flag_V = (src ^ res) & (dst ^ res);
23916 flag_NotZ = res & 0xFF;
23917 WRITE_BYTE_F(adr, res)
23918 POST_IO
23919RET(18)
23920}
23921
23922// ADDQ
23923OPCODE(0x5038)
23924{
23925 u32 adr, res;
23926 u32 src, dst;
23927
23928 src = (((Opcode >> 9) - 1) & 7) + 1;
23929 FETCH_SWORD(adr);
23930 PRE_IO
23931 READ_BYTE_F(adr, dst)
23932 res = dst + src;
23933 flag_N = flag_X = flag_C = res;
23934 flag_V = (src ^ res) & (dst ^ res);
23935 flag_NotZ = res & 0xFF;
23936 WRITE_BYTE_F(adr, res)
23937 POST_IO
23938RET(16)
23939}
23940
23941// ADDQ
23942OPCODE(0x5039)
23943{
23944 u32 adr, res;
23945 u32 src, dst;
23946
23947 src = (((Opcode >> 9) - 1) & 7) + 1;
23948 FETCH_LONG(adr);
23949 PRE_IO
23950 READ_BYTE_F(adr, dst)
23951 res = dst + src;
23952 flag_N = flag_X = flag_C = res;
23953 flag_V = (src ^ res) & (dst ^ res);
23954 flag_NotZ = res & 0xFF;
23955 WRITE_BYTE_F(adr, res)
23956 POST_IO
23957RET(20)
23958}
23959
23960// ADDQ
23961OPCODE(0x501F)
23962{
23963 u32 adr, res;
23964 u32 src, dst;
23965
23966 src = (((Opcode >> 9) - 1) & 7) + 1;
23967 adr = AREG(7);
23968 AREG(7) += 2;
23969 PRE_IO
23970 READ_BYTE_F(adr, dst)
23971 res = dst + src;
23972 flag_N = flag_X = flag_C = res;
23973 flag_V = (src ^ res) & (dst ^ res);
23974 flag_NotZ = res & 0xFF;
23975 WRITE_BYTE_F(adr, res)
23976 POST_IO
23977RET(12)
23978}
23979
23980// ADDQ
23981OPCODE(0x5027)
23982{
23983 u32 adr, res;
23984 u32 src, dst;
23985
23986 src = (((Opcode >> 9) - 1) & 7) + 1;
23987 adr = AREG(7) - 2;
23988 AREG(7) = adr;
23989 PRE_IO
23990 READ_BYTE_F(adr, dst)
23991 res = dst + src;
23992 flag_N = flag_X = flag_C = res;
23993 flag_V = (src ^ res) & (dst ^ res);
23994 flag_NotZ = res & 0xFF;
23995 WRITE_BYTE_F(adr, res)
23996 POST_IO
23997RET(14)
23998}
23999
24000// ADDQ
24001OPCODE(0x5040)
24002{
24003 u32 adr, res;
24004 u32 src, dst;
24005
24006 src = (((Opcode >> 9) - 1) & 7) + 1;
24007 dst = DREGu16((Opcode >> 0) & 7);
24008 res = dst + src;
24009 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24010 flag_N = flag_X = flag_C = res >> 8;
24011 flag_NotZ = res & 0xFFFF;
24012 DREGu16((Opcode >> 0) & 7) = res;
24013RET(4)
24014}
24015
24016// ADDQ
24017OPCODE(0x5048)
24018{
24019 u32 adr, res;
24020 u32 src, dst;
24021
24022 src = (((Opcode >> 9) - 1) & 7) + 1;
24023 dst = AREGu32((Opcode >> 0) & 7);
24024 res = dst + src;
24025 AREG((Opcode >> 0) & 7) = res;
03e4f2a3 24026#ifdef USE_CYCLONE_TIMING
70357ce5 24027RET(4)
24028#else
24029RET(8)
24030#endif
24031}
24032
24033// ADDQ
24034OPCODE(0x5050)
24035{
24036 u32 adr, res;
24037 u32 src, dst;
24038
24039 src = (((Opcode >> 9) - 1) & 7) + 1;
24040 adr = AREG((Opcode >> 0) & 7);
24041 PRE_IO
24042 READ_WORD_F(adr, dst)
24043 res = dst + src;
24044 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24045 flag_N = flag_X = flag_C = res >> 8;
24046 flag_NotZ = res & 0xFFFF;
24047 WRITE_WORD_F(adr, res)
24048 POST_IO
24049RET(12)
24050}
24051
24052// ADDQ
24053OPCODE(0x5058)
24054{
24055 u32 adr, res;
24056 u32 src, dst;
24057
24058 src = (((Opcode >> 9) - 1) & 7) + 1;
24059 adr = AREG((Opcode >> 0) & 7);
24060 AREG((Opcode >> 0) & 7) += 2;
24061 PRE_IO
24062 READ_WORD_F(adr, dst)
24063 res = dst + src;
24064 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24065 flag_N = flag_X = flag_C = res >> 8;
24066 flag_NotZ = res & 0xFFFF;
24067 WRITE_WORD_F(adr, res)
24068 POST_IO
24069RET(12)
24070}
24071
24072// ADDQ
24073OPCODE(0x5060)
24074{
24075 u32 adr, res;
24076 u32 src, dst;
24077
24078 src = (((Opcode >> 9) - 1) & 7) + 1;
24079 adr = AREG((Opcode >> 0) & 7) - 2;
24080 AREG((Opcode >> 0) & 7) = adr;
24081 PRE_IO
24082 READ_WORD_F(adr, dst)
24083 res = dst + src;
24084 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24085 flag_N = flag_X = flag_C = res >> 8;
24086 flag_NotZ = res & 0xFFFF;
24087 WRITE_WORD_F(adr, res)
24088 POST_IO
24089RET(14)
24090}
24091
24092// ADDQ
24093OPCODE(0x5068)
24094{
24095 u32 adr, res;
24096 u32 src, dst;
24097
24098 src = (((Opcode >> 9) - 1) & 7) + 1;
24099 FETCH_SWORD(adr);
24100 adr += AREG((Opcode >> 0) & 7);
24101 PRE_IO
24102 READ_WORD_F(adr, dst)
24103 res = dst + src;
24104 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24105 flag_N = flag_X = flag_C = res >> 8;
24106 flag_NotZ = res & 0xFFFF;
24107 WRITE_WORD_F(adr, res)
24108 POST_IO
24109RET(16)
24110}
24111
24112// ADDQ
24113OPCODE(0x5070)
24114{
24115 u32 adr, res;
24116 u32 src, dst;
24117
24118 src = (((Opcode >> 9) - 1) & 7) + 1;
24119 adr = AREG((Opcode >> 0) & 7);
24120 DECODE_EXT_WORD
24121 PRE_IO
24122 READ_WORD_F(adr, dst)
24123 res = dst + src;
24124 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24125 flag_N = flag_X = flag_C = res >> 8;
24126 flag_NotZ = res & 0xFFFF;
24127 WRITE_WORD_F(adr, res)
24128 POST_IO
24129RET(18)
24130}
24131
24132// ADDQ
24133OPCODE(0x5078)
24134{
24135 u32 adr, res;
24136 u32 src, dst;
24137
24138 src = (((Opcode >> 9) - 1) & 7) + 1;
24139 FETCH_SWORD(adr);
24140 PRE_IO
24141 READ_WORD_F(adr, dst)
24142 res = dst + src;
24143 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24144 flag_N = flag_X = flag_C = res >> 8;
24145 flag_NotZ = res & 0xFFFF;
24146 WRITE_WORD_F(adr, res)
24147 POST_IO
24148RET(16)
24149}
24150
24151// ADDQ
24152OPCODE(0x5079)
24153{
24154 u32 adr, res;
24155 u32 src, dst;
24156
24157 src = (((Opcode >> 9) - 1) & 7) + 1;
24158 FETCH_LONG(adr);
24159 PRE_IO
24160 READ_WORD_F(adr, dst)
24161 res = dst + src;
24162 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24163 flag_N = flag_X = flag_C = res >> 8;
24164 flag_NotZ = res & 0xFFFF;
24165 WRITE_WORD_F(adr, res)
24166 POST_IO
24167RET(20)
24168}
24169
24170// ADDQ
24171OPCODE(0x505F)
24172{
24173 u32 adr, res;
24174 u32 src, dst;
24175
24176 src = (((Opcode >> 9) - 1) & 7) + 1;
24177 adr = AREG(7);
24178 AREG(7) += 2;
24179 PRE_IO
24180 READ_WORD_F(adr, dst)
24181 res = dst + src;
24182 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24183 flag_N = flag_X = flag_C = res >> 8;
24184 flag_NotZ = res & 0xFFFF;
24185 WRITE_WORD_F(adr, res)
24186 POST_IO
24187RET(12)
24188}
24189
24190// ADDQ
24191OPCODE(0x5067)
24192{
24193 u32 adr, res;
24194 u32 src, dst;
24195
24196 src = (((Opcode >> 9) - 1) & 7) + 1;
24197 adr = AREG(7) - 2;
24198 AREG(7) = adr;
24199 PRE_IO
24200 READ_WORD_F(adr, dst)
24201 res = dst + src;
24202 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24203 flag_N = flag_X = flag_C = res >> 8;
24204 flag_NotZ = res & 0xFFFF;
24205 WRITE_WORD_F(adr, res)
24206 POST_IO
24207RET(14)
24208}
24209
24210// ADDQ
24211OPCODE(0x5080)
24212{
24213 u32 adr, res;
24214 u32 src, dst;
24215
24216 src = (((Opcode >> 9) - 1) & 7) + 1;
24217 dst = DREGu32((Opcode >> 0) & 7);
24218 res = dst + src;
24219 flag_NotZ = res;
24220 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24221 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24222 flag_N = res >> 24;
24223 DREGu32((Opcode >> 0) & 7) = res;
24224RET(8)
24225}
24226
24227// ADDQ
24228OPCODE(0x5088)
24229{
24230 u32 adr, res;
24231 u32 src, dst;
24232
24233 src = (((Opcode >> 9) - 1) & 7) + 1;
24234 dst = AREGu32((Opcode >> 0) & 7);
24235 res = dst + src;
24236 AREG((Opcode >> 0) & 7) = res;
24237RET(8)
24238}
24239
24240// ADDQ
24241OPCODE(0x5090)
24242{
24243 u32 adr, res;
24244 u32 src, dst;
24245
24246 src = (((Opcode >> 9) - 1) & 7) + 1;
24247 adr = AREG((Opcode >> 0) & 7);
24248 PRE_IO
24249 READ_LONG_F(adr, dst)
24250 res = dst + src;
24251 flag_NotZ = res;
24252 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24253 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24254 flag_N = res >> 24;
24255 WRITE_LONG_F(adr, res)
24256 POST_IO
24257RET(20)
24258}
24259
24260// ADDQ
24261OPCODE(0x5098)
24262{
24263 u32 adr, res;
24264 u32 src, dst;
24265
24266 src = (((Opcode >> 9) - 1) & 7) + 1;
24267 adr = AREG((Opcode >> 0) & 7);
24268 AREG((Opcode >> 0) & 7) += 4;
24269 PRE_IO
24270 READ_LONG_F(adr, dst)
24271 res = dst + src;
24272 flag_NotZ = res;
24273 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24274 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24275 flag_N = res >> 24;
24276 WRITE_LONG_F(adr, res)
24277 POST_IO
24278RET(20)
24279}
24280
24281// ADDQ
24282OPCODE(0x50A0)
24283{
24284 u32 adr, res;
24285 u32 src, dst;
24286
24287 src = (((Opcode >> 9) - 1) & 7) + 1;
24288 adr = AREG((Opcode >> 0) & 7) - 4;
24289 AREG((Opcode >> 0) & 7) = adr;
24290 PRE_IO
24291 READ_LONG_F(adr, dst)
24292 res = dst + src;
24293 flag_NotZ = res;
24294 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24295 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24296 flag_N = res >> 24;
24297 WRITE_LONG_F(adr, res)
24298 POST_IO
24299RET(22)
24300}
24301
24302// ADDQ
24303OPCODE(0x50A8)
24304{
24305 u32 adr, res;
24306 u32 src, dst;
24307
24308 src = (((Opcode >> 9) - 1) & 7) + 1;
24309 FETCH_SWORD(adr);
24310 adr += AREG((Opcode >> 0) & 7);
24311 PRE_IO
24312 READ_LONG_F(adr, dst)
24313 res = dst + src;
24314 flag_NotZ = res;
24315 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24316 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24317 flag_N = res >> 24;
24318 WRITE_LONG_F(adr, res)
24319 POST_IO
24320RET(24)
24321}
24322
24323// ADDQ
24324OPCODE(0x50B0)
24325{
24326 u32 adr, res;
24327 u32 src, dst;
24328
24329 src = (((Opcode >> 9) - 1) & 7) + 1;
24330 adr = AREG((Opcode >> 0) & 7);
24331 DECODE_EXT_WORD
24332 PRE_IO
24333 READ_LONG_F(adr, dst)
24334 res = dst + src;
24335 flag_NotZ = res;
24336 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24337 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24338 flag_N = res >> 24;
24339 WRITE_LONG_F(adr, res)
24340 POST_IO
24341RET(26)
24342}
24343
24344// ADDQ
24345OPCODE(0x50B8)
24346{
24347 u32 adr, res;
24348 u32 src, dst;
24349
24350 src = (((Opcode >> 9) - 1) & 7) + 1;
24351 FETCH_SWORD(adr);
24352 PRE_IO
24353 READ_LONG_F(adr, dst)
24354 res = dst + src;
24355 flag_NotZ = res;
24356 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24357 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24358 flag_N = res >> 24;
24359 WRITE_LONG_F(adr, res)
24360 POST_IO
24361RET(24)
24362}
24363
24364// ADDQ
24365OPCODE(0x50B9)
24366{
24367 u32 adr, res;
24368 u32 src, dst;
24369
24370 src = (((Opcode >> 9) - 1) & 7) + 1;
24371 FETCH_LONG(adr);
24372 PRE_IO
24373 READ_LONG_F(adr, dst)
24374 res = dst + src;
24375 flag_NotZ = res;
24376 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24377 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24378 flag_N = res >> 24;
24379 WRITE_LONG_F(adr, res)
24380 POST_IO
24381RET(28)
24382}
24383
24384// ADDQ
24385OPCODE(0x509F)
24386{
24387 u32 adr, res;
24388 u32 src, dst;
24389
24390 src = (((Opcode >> 9) - 1) & 7) + 1;
24391 adr = AREG(7);
24392 AREG(7) += 4;
24393 PRE_IO
24394 READ_LONG_F(adr, dst)
24395 res = dst + src;
24396 flag_NotZ = res;
24397 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24398 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24399 flag_N = res >> 24;
24400 WRITE_LONG_F(adr, res)
24401 POST_IO
24402RET(20)
24403}
24404
24405// ADDQ
24406OPCODE(0x50A7)
24407{
24408 u32 adr, res;
24409 u32 src, dst;
24410
24411 src = (((Opcode >> 9) - 1) & 7) + 1;
24412 adr = AREG(7) - 4;
24413 AREG(7) = adr;
24414 PRE_IO
24415 READ_LONG_F(adr, dst)
24416 res = dst + src;
24417 flag_NotZ = res;
24418 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24419 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24420 flag_N = res >> 24;
24421 WRITE_LONG_F(adr, res)
24422 POST_IO
24423RET(22)
24424}
24425
24426// SUBQ
24427OPCODE(0x5100)
24428{
24429 u32 adr, res;
24430 u32 src, dst;
24431
24432 src = (((Opcode >> 9) - 1) & 7) + 1;
24433 dst = DREGu8((Opcode >> 0) & 7);
24434 res = dst - src;
24435 flag_N = flag_X = flag_C = res;
24436 flag_V = (src ^ dst) & (res ^ dst);
24437 flag_NotZ = res & 0xFF;
24438 DREGu8((Opcode >> 0) & 7) = res;
24439RET(4)
24440}
24441
24442// SUBQ
24443OPCODE(0x5110)
24444{
24445 u32 adr, res;
24446 u32 src, dst;
24447
24448 src = (((Opcode >> 9) - 1) & 7) + 1;
24449 adr = AREG((Opcode >> 0) & 7);
24450 PRE_IO
24451 READ_BYTE_F(adr, dst)
24452 res = dst - src;
24453 flag_N = flag_X = flag_C = res;
24454 flag_V = (src ^ dst) & (res ^ dst);
24455 flag_NotZ = res & 0xFF;
24456 WRITE_BYTE_F(adr, res)
24457 POST_IO
24458RET(12)
24459}
24460
24461// SUBQ
24462OPCODE(0x5118)
24463{
24464 u32 adr, res;
24465 u32 src, dst;
24466
24467 src = (((Opcode >> 9) - 1) & 7) + 1;
24468 adr = AREG((Opcode >> 0) & 7);
24469 AREG((Opcode >> 0) & 7) += 1;
24470 PRE_IO
24471 READ_BYTE_F(adr, dst)
24472 res = dst - src;
24473 flag_N = flag_X = flag_C = res;
24474 flag_V = (src ^ dst) & (res ^ dst);
24475 flag_NotZ = res & 0xFF;
24476 WRITE_BYTE_F(adr, res)
24477 POST_IO
24478RET(12)
24479}
24480
24481// SUBQ
24482OPCODE(0x5120)
24483{
24484 u32 adr, res;
24485 u32 src, dst;
24486
24487 src = (((Opcode >> 9) - 1) & 7) + 1;
24488 adr = AREG((Opcode >> 0) & 7) - 1;
24489 AREG((Opcode >> 0) & 7) = adr;
24490 PRE_IO
24491 READ_BYTE_F(adr, dst)
24492 res = dst - src;
24493 flag_N = flag_X = flag_C = res;
24494 flag_V = (src ^ dst) & (res ^ dst);
24495 flag_NotZ = res & 0xFF;
24496 WRITE_BYTE_F(adr, res)
24497 POST_IO
24498RET(14)
24499}
24500
24501// SUBQ
24502OPCODE(0x5128)
24503{
24504 u32 adr, res;
24505 u32 src, dst;
24506
24507 src = (((Opcode >> 9) - 1) & 7) + 1;
24508 FETCH_SWORD(adr);
24509 adr += AREG((Opcode >> 0) & 7);
24510 PRE_IO
24511 READ_BYTE_F(adr, dst)
24512 res = dst - src;
24513 flag_N = flag_X = flag_C = res;
24514 flag_V = (src ^ dst) & (res ^ dst);
24515 flag_NotZ = res & 0xFF;
24516 WRITE_BYTE_F(adr, res)
24517 POST_IO
24518RET(16)
24519}
24520
24521// SUBQ
24522OPCODE(0x5130)
24523{
24524 u32 adr, res;
24525 u32 src, dst;
24526
24527 src = (((Opcode >> 9) - 1) & 7) + 1;
24528 adr = AREG((Opcode >> 0) & 7);
24529 DECODE_EXT_WORD
24530 PRE_IO
24531 READ_BYTE_F(adr, dst)
24532 res = dst - src;
24533 flag_N = flag_X = flag_C = res;
24534 flag_V = (src ^ dst) & (res ^ dst);
24535 flag_NotZ = res & 0xFF;
24536 WRITE_BYTE_F(adr, res)
24537 POST_IO
24538RET(18)
24539}
24540
24541// SUBQ
24542OPCODE(0x5138)
24543{
24544 u32 adr, res;
24545 u32 src, dst;
24546
24547 src = (((Opcode >> 9) - 1) & 7) + 1;
24548 FETCH_SWORD(adr);
24549 PRE_IO
24550 READ_BYTE_F(adr, dst)
24551 res = dst - src;
24552 flag_N = flag_X = flag_C = res;
24553 flag_V = (src ^ dst) & (res ^ dst);
24554 flag_NotZ = res & 0xFF;
24555 WRITE_BYTE_F(adr, res)
24556 POST_IO
24557RET(16)
24558}
24559
24560// SUBQ
24561OPCODE(0x5139)
24562{
24563 u32 adr, res;
24564 u32 src, dst;
24565
24566 src = (((Opcode >> 9) - 1) & 7) + 1;
24567 FETCH_LONG(adr);
24568 PRE_IO
24569 READ_BYTE_F(adr, dst)
24570 res = dst - src;
24571 flag_N = flag_X = flag_C = res;
24572 flag_V = (src ^ dst) & (res ^ dst);
24573 flag_NotZ = res & 0xFF;
24574 WRITE_BYTE_F(adr, res)
24575 POST_IO
24576RET(20)
24577}
24578
24579// SUBQ
24580OPCODE(0x511F)
24581{
24582 u32 adr, res;
24583 u32 src, dst;
24584
24585 src = (((Opcode >> 9) - 1) & 7) + 1;
24586 adr = AREG(7);
24587 AREG(7) += 2;
24588 PRE_IO
24589 READ_BYTE_F(adr, dst)
24590 res = dst - src;
24591 flag_N = flag_X = flag_C = res;
24592 flag_V = (src ^ dst) & (res ^ dst);
24593 flag_NotZ = res & 0xFF;
24594 WRITE_BYTE_F(adr, res)
24595 POST_IO
24596RET(12)
24597}
24598
24599// SUBQ
24600OPCODE(0x5127)
24601{
24602 u32 adr, res;
24603 u32 src, dst;
24604
24605 src = (((Opcode >> 9) - 1) & 7) + 1;
24606 adr = AREG(7) - 2;
24607 AREG(7) = adr;
24608 PRE_IO
24609 READ_BYTE_F(adr, dst)
24610 res = dst - src;
24611 flag_N = flag_X = flag_C = res;
24612 flag_V = (src ^ dst) & (res ^ dst);
24613 flag_NotZ = res & 0xFF;
24614 WRITE_BYTE_F(adr, res)
24615 POST_IO
24616RET(14)
24617}
24618
24619// SUBQ
24620OPCODE(0x5140)
24621{
24622 u32 adr, res;
24623 u32 src, dst;
24624
24625 src = (((Opcode >> 9) - 1) & 7) + 1;
24626 dst = DREGu16((Opcode >> 0) & 7);
24627 res = dst - src;
24628 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24629 flag_N = flag_X = flag_C = res >> 8;
24630 flag_NotZ = res & 0xFFFF;
24631 DREGu16((Opcode >> 0) & 7) = res;
24632RET(4)
24633}
24634
24635// SUBQ
24636OPCODE(0x5148)
24637{
24638 u32 adr, res;
24639 u32 src, dst;
24640
24641 src = (((Opcode >> 9) - 1) & 7) + 1;
24642 dst = AREGu32((Opcode >> 0) & 7);
24643 res = dst - src;
24644 AREG((Opcode >> 0) & 7) = res;
24645RET(8)
24646}
24647
24648// SUBQ
24649OPCODE(0x5150)
24650{
24651 u32 adr, res;
24652 u32 src, dst;
24653
24654 src = (((Opcode >> 9) - 1) & 7) + 1;
24655 adr = AREG((Opcode >> 0) & 7);
24656 PRE_IO
24657 READ_WORD_F(adr, dst)
24658 res = dst - src;
24659 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24660 flag_N = flag_X = flag_C = res >> 8;
24661 flag_NotZ = res & 0xFFFF;
24662 WRITE_WORD_F(adr, res)
24663 POST_IO
24664RET(12)
24665}
24666
24667// SUBQ
24668OPCODE(0x5158)
24669{
24670 u32 adr, res;
24671 u32 src, dst;
24672
24673 src = (((Opcode >> 9) - 1) & 7) + 1;
24674 adr = AREG((Opcode >> 0) & 7);
24675 AREG((Opcode >> 0) & 7) += 2;
24676 PRE_IO
24677 READ_WORD_F(adr, dst)
24678 res = dst - src;
24679 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24680 flag_N = flag_X = flag_C = res >> 8;
24681 flag_NotZ = res & 0xFFFF;
24682 WRITE_WORD_F(adr, res)
24683 POST_IO
24684RET(12)
24685}
24686
24687// SUBQ
24688OPCODE(0x5160)
24689{
24690 u32 adr, res;
24691 u32 src, dst;
24692
24693 src = (((Opcode >> 9) - 1) & 7) + 1;
24694 adr = AREG((Opcode >> 0) & 7) - 2;
24695 AREG((Opcode >> 0) & 7) = adr;
24696 PRE_IO
24697 READ_WORD_F(adr, dst)
24698 res = dst - src;
24699 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24700 flag_N = flag_X = flag_C = res >> 8;
24701 flag_NotZ = res & 0xFFFF;
24702 WRITE_WORD_F(adr, res)
24703 POST_IO
24704RET(14)
24705}
24706
24707// SUBQ
24708OPCODE(0x5168)
24709{
24710 u32 adr, res;
24711 u32 src, dst;
24712
24713 src = (((Opcode >> 9) - 1) & 7) + 1;
24714 FETCH_SWORD(adr);
24715 adr += AREG((Opcode >> 0) & 7);
24716 PRE_IO
24717 READ_WORD_F(adr, dst)
24718 res = dst - src;
24719 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24720 flag_N = flag_X = flag_C = res >> 8;
24721 flag_NotZ = res & 0xFFFF;
24722 WRITE_WORD_F(adr, res)
24723 POST_IO
24724RET(16)
24725}
24726
24727// SUBQ
24728OPCODE(0x5170)
24729{
24730 u32 adr, res;
24731 u32 src, dst;
24732
24733 src = (((Opcode >> 9) - 1) & 7) + 1;
24734 adr = AREG((Opcode >> 0) & 7);
24735 DECODE_EXT_WORD
24736 PRE_IO
24737 READ_WORD_F(adr, dst)
24738 res = dst - src;
24739 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24740 flag_N = flag_X = flag_C = res >> 8;
24741 flag_NotZ = res & 0xFFFF;
24742 WRITE_WORD_F(adr, res)
24743 POST_IO
24744RET(18)
24745}
24746
24747// SUBQ
24748OPCODE(0x5178)
24749{
24750 u32 adr, res;
24751 u32 src, dst;
24752
24753 src = (((Opcode >> 9) - 1) & 7) + 1;
24754 FETCH_SWORD(adr);
24755 PRE_IO
24756 READ_WORD_F(adr, dst)
24757 res = dst - src;
24758 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24759 flag_N = flag_X = flag_C = res >> 8;
24760 flag_NotZ = res & 0xFFFF;
24761 WRITE_WORD_F(adr, res)
24762 POST_IO
24763RET(16)
24764}
24765
24766// SUBQ
24767OPCODE(0x5179)
24768{
24769 u32 adr, res;
24770 u32 src, dst;
24771
24772 src = (((Opcode >> 9) - 1) & 7) + 1;
24773 FETCH_LONG(adr);
24774 PRE_IO
24775 READ_WORD_F(adr, dst)
24776 res = dst - src;
24777 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24778 flag_N = flag_X = flag_C = res >> 8;
24779 flag_NotZ = res & 0xFFFF;
24780 WRITE_WORD_F(adr, res)
24781 POST_IO
24782RET(20)
24783}
24784
24785// SUBQ
24786OPCODE(0x515F)
24787{
24788 u32 adr, res;
24789 u32 src, dst;
24790
24791 src = (((Opcode >> 9) - 1) & 7) + 1;
24792 adr = AREG(7);
24793 AREG(7) += 2;
24794 PRE_IO
24795 READ_WORD_F(adr, dst)
24796 res = dst - src;
24797 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24798 flag_N = flag_X = flag_C = res >> 8;
24799 flag_NotZ = res & 0xFFFF;
24800 WRITE_WORD_F(adr, res)
24801 POST_IO
24802RET(12)
24803}
24804
24805// SUBQ
24806OPCODE(0x5167)
24807{
24808 u32 adr, res;
24809 u32 src, dst;
24810
24811 src = (((Opcode >> 9) - 1) & 7) + 1;
24812 adr = AREG(7) - 2;
24813 AREG(7) = adr;
24814 PRE_IO
24815 READ_WORD_F(adr, dst)
24816 res = dst - src;
24817 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24818 flag_N = flag_X = flag_C = res >> 8;
24819 flag_NotZ = res & 0xFFFF;
24820 WRITE_WORD_F(adr, res)
24821 POST_IO
24822RET(14)
24823}
24824
24825// SUBQ
24826OPCODE(0x5180)
24827{
24828 u32 adr, res;
24829 u32 src, dst;
24830
24831 src = (((Opcode >> 9) - 1) & 7) + 1;
24832 dst = DREGu32((Opcode >> 0) & 7);
24833 res = dst - src;
24834 flag_NotZ = res;
24835 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24836 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24837 flag_N = res >> 24;
24838 DREGu32((Opcode >> 0) & 7) = res;
24839RET(8)
24840}
24841
24842// SUBQ
24843OPCODE(0x5188)
24844{
24845 u32 adr, res;
24846 u32 src, dst;
24847
24848 src = (((Opcode >> 9) - 1) & 7) + 1;
24849 dst = AREGu32((Opcode >> 0) & 7);
24850 res = dst - src;
24851 AREG((Opcode >> 0) & 7) = res;
24852RET(8)
24853}
24854
24855// SUBQ
24856OPCODE(0x5190)
24857{
24858 u32 adr, res;
24859 u32 src, dst;
24860
24861 src = (((Opcode >> 9) - 1) & 7) + 1;
24862 adr = AREG((Opcode >> 0) & 7);
24863 PRE_IO
24864 READ_LONG_F(adr, dst)
24865 res = dst - src;
24866 flag_NotZ = res;
24867 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24868 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24869 flag_N = res >> 24;
24870 WRITE_LONG_F(adr, res)
24871 POST_IO
24872RET(20)
24873}
24874
24875// SUBQ
24876OPCODE(0x5198)
24877{
24878 u32 adr, res;
24879 u32 src, dst;
24880
24881 src = (((Opcode >> 9) - 1) & 7) + 1;
24882 adr = AREG((Opcode >> 0) & 7);
24883 AREG((Opcode >> 0) & 7) += 4;
24884 PRE_IO
24885 READ_LONG_F(adr, dst)
24886 res = dst - src;
24887 flag_NotZ = res;
24888 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24889 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24890 flag_N = res >> 24;
24891 WRITE_LONG_F(adr, res)
24892 POST_IO
24893RET(20)
24894}
24895
24896// SUBQ
24897OPCODE(0x51A0)
24898{
24899 u32 adr, res;
24900 u32 src, dst;
24901
24902 src = (((Opcode >> 9) - 1) & 7) + 1;
24903 adr = AREG((Opcode >> 0) & 7) - 4;
24904 AREG((Opcode >> 0) & 7) = adr;
24905 PRE_IO
24906 READ_LONG_F(adr, dst)
24907 res = dst - src;
24908 flag_NotZ = res;
24909 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24910 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24911 flag_N = res >> 24;
24912 WRITE_LONG_F(adr, res)
24913 POST_IO
24914RET(22)
24915}
24916
24917// SUBQ
24918OPCODE(0x51A8)
24919{
24920 u32 adr, res;
24921 u32 src, dst;
24922
24923 src = (((Opcode >> 9) - 1) & 7) + 1;
24924 FETCH_SWORD(adr);
24925 adr += AREG((Opcode >> 0) & 7);
24926 PRE_IO
24927 READ_LONG_F(adr, dst)
24928 res = dst - src;
24929 flag_NotZ = res;
24930 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24931 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24932 flag_N = res >> 24;
24933 WRITE_LONG_F(adr, res)
24934 POST_IO
24935RET(24)
24936}
24937
24938// SUBQ
24939OPCODE(0x51B0)
24940{
24941 u32 adr, res;
24942 u32 src, dst;
24943
24944 src = (((Opcode >> 9) - 1) & 7) + 1;
24945 adr = AREG((Opcode >> 0) & 7);
24946 DECODE_EXT_WORD
24947 PRE_IO
24948 READ_LONG_F(adr, dst)
24949 res = dst - src;
24950 flag_NotZ = res;
24951 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24952 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24953 flag_N = res >> 24;
24954 WRITE_LONG_F(adr, res)
24955 POST_IO
24956RET(26)
24957}
24958
24959// SUBQ
24960OPCODE(0x51B8)
24961{
24962 u32 adr, res;
24963 u32 src, dst;
24964
24965 src = (((Opcode >> 9) - 1) & 7) + 1;
24966 FETCH_SWORD(adr);
24967 PRE_IO
24968 READ_LONG_F(adr, dst)
24969 res = dst - src;
24970 flag_NotZ = res;
24971 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24972 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24973 flag_N = res >> 24;
24974 WRITE_LONG_F(adr, res)
24975 POST_IO
24976RET(24)
24977}
24978
24979// SUBQ
24980OPCODE(0x51B9)
24981{
24982 u32 adr, res;
24983 u32 src, dst;
24984
24985 src = (((Opcode >> 9) - 1) & 7) + 1;
24986 FETCH_LONG(adr);
24987 PRE_IO
24988 READ_LONG_F(adr, dst)
24989 res = dst - src;
24990 flag_NotZ = res;
24991 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24992 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24993 flag_N = res >> 24;
24994 WRITE_LONG_F(adr, res)
24995 POST_IO
24996RET(28)
24997}
24998
24999// SUBQ
25000OPCODE(0x519F)
25001{
25002 u32 adr, res;
25003 u32 src, dst;
25004
25005 src = (((Opcode >> 9) - 1) & 7) + 1;
25006 adr = AREG(7);
25007 AREG(7) += 4;
25008 PRE_IO
25009 READ_LONG_F(adr, dst)
25010 res = dst - src;
25011 flag_NotZ = res;
25012 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25013 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25014 flag_N = res >> 24;
25015 WRITE_LONG_F(adr, res)
25016 POST_IO
25017RET(20)
25018}
25019
25020// SUBQ
25021OPCODE(0x51A7)
25022{
25023 u32 adr, res;
25024 u32 src, dst;
25025
25026 src = (((Opcode >> 9) - 1) & 7) + 1;
25027 adr = AREG(7) - 4;
25028 AREG(7) = adr;
25029 PRE_IO
25030 READ_LONG_F(adr, dst)
25031 res = dst - src;
25032 flag_NotZ = res;
25033 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25034 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25035 flag_N = res >> 24;
25036 WRITE_LONG_F(adr, res)
25037 POST_IO
25038RET(22)
25039}
25040
25041// BCC
25042OPCODE(0x6201)
25043{
25044 u32 adr, res;
25045 u32 src, dst;
25046
25047 if (flag_NotZ && (!(flag_C & 0x100)))
25048 {
25049 PC += ((s8)(Opcode & 0xFE)) >> 1;
25050 m68kcontext.io_cycle_counter -= 2;
25051 }
25052RET(8)
25053}
25054
25055// BCC
25056OPCODE(0x6301)
25057{
25058 u32 adr, res;
25059 u32 src, dst;
25060
25061 if ((!flag_NotZ) || (flag_C & 0x100))
25062 {
25063 PC += ((s8)(Opcode & 0xFE)) >> 1;
25064 m68kcontext.io_cycle_counter -= 2;
25065 }
25066RET(8)
25067}
25068
25069// BCC
25070OPCODE(0x6401)
25071{
25072 u32 adr, res;
25073 u32 src, dst;
25074
25075 if (!(flag_C & 0x100))
25076 {
25077 PC += ((s8)(Opcode & 0xFE)) >> 1;
25078 m68kcontext.io_cycle_counter -= 2;
25079 }
25080RET(8)
25081}
25082
25083// BCC
25084OPCODE(0x6501)
25085{
25086 u32 adr, res;
25087 u32 src, dst;
25088
25089 if (flag_C & 0x100)
25090 {
25091 PC += ((s8)(Opcode & 0xFE)) >> 1;
25092 m68kcontext.io_cycle_counter -= 2;
25093 }
25094RET(8)
25095}
25096
25097// BCC
25098OPCODE(0x6601)
25099{
25100 u32 adr, res;
25101 u32 src, dst;
25102
25103 if (flag_NotZ)
25104 {
25105 PC += ((s8)(Opcode & 0xFE)) >> 1;
25106 m68kcontext.io_cycle_counter -= 2;
25107 }
25108RET(8)
25109}
25110
25111// BCC
25112OPCODE(0x6701)
25113{
25114 u32 adr, res;
25115 u32 src, dst;
25116
25117 if (!flag_NotZ)
25118 {
25119 PC += ((s8)(Opcode & 0xFE)) >> 1;
25120 m68kcontext.io_cycle_counter -= 2;
25121 }
25122RET(8)
25123}
25124
25125// BCC
25126OPCODE(0x6801)
25127{
25128 u32 adr, res;
25129 u32 src, dst;
25130
25131 if (!(flag_V & 0x80))
25132 {
25133 PC += ((s8)(Opcode & 0xFE)) >> 1;
25134 m68kcontext.io_cycle_counter -= 2;
25135 }
25136RET(8)
25137}
25138
25139// BCC
25140OPCODE(0x6901)
25141{
25142 u32 adr, res;
25143 u32 src, dst;
25144
25145 if (flag_V & 0x80)
25146 {
25147 PC += ((s8)(Opcode & 0xFE)) >> 1;
25148 m68kcontext.io_cycle_counter -= 2;
25149 }
25150RET(8)
25151}
25152
25153// BCC
25154OPCODE(0x6A01)
25155{
25156 u32 adr, res;
25157 u32 src, dst;
25158
25159 if (!(flag_N & 0x80))
25160 {
25161 PC += ((s8)(Opcode & 0xFE)) >> 1;
25162 m68kcontext.io_cycle_counter -= 2;
25163 }
25164RET(8)
25165}
25166
25167// BCC
25168OPCODE(0x6B01)
25169{
25170 u32 adr, res;
25171 u32 src, dst;
25172
25173 if (flag_N & 0x80)
25174 {
25175 PC += ((s8)(Opcode & 0xFE)) >> 1;
25176 m68kcontext.io_cycle_counter -= 2;
25177 }
25178RET(8)
25179}
25180
25181// BCC
25182OPCODE(0x6C01)
25183{
25184 u32 adr, res;
25185 u32 src, dst;
25186
25187 if (!((flag_N ^ flag_V) & 0x80))
25188 {
25189 PC += ((s8)(Opcode & 0xFE)) >> 1;
25190 m68kcontext.io_cycle_counter -= 2;
25191 }
25192RET(8)
25193}
25194
25195// BCC
25196OPCODE(0x6D01)
25197{
25198 u32 adr, res;
25199 u32 src, dst;
25200
25201 if ((flag_N ^ flag_V) & 0x80)
25202 {
25203 PC += ((s8)(Opcode & 0xFE)) >> 1;
25204 m68kcontext.io_cycle_counter -= 2;
25205 }
25206RET(8)
25207}
25208
25209// BCC
25210OPCODE(0x6E01)
25211{
25212 u32 adr, res;
25213 u32 src, dst;
25214
25215 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25216 {
25217 PC += ((s8)(Opcode & 0xFE)) >> 1;
25218 m68kcontext.io_cycle_counter -= 2;
25219 }
25220RET(8)
25221}
25222
25223// BCC
25224OPCODE(0x6F01)
25225{
25226 u32 adr, res;
25227 u32 src, dst;
25228
25229 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25230 {
25231 PC += ((s8)(Opcode & 0xFE)) >> 1;
25232 m68kcontext.io_cycle_counter -= 2;
25233 }
25234RET(8)
25235}
25236
25237// BCC16
25238OPCODE(0x6200)
25239{
25240 u32 adr, res;
25241 u32 src, dst;
25242
25243 if (flag_NotZ && (!(flag_C & 0x100)))
25244 {
25245 u32 newPC;
25246
be26eb23 25247 newPC = GET_PC;
70357ce5 25248 newPC += GET_SWORD;
25249 SET_PC(newPC);
25250 CHECK_BRANCH_EXCEPTION(newPC)
25251 RET(10)
25252 }
25253 PC++;
25254RET(12)
25255}
25256
25257// BCC16
25258OPCODE(0x6300)
25259{
25260 u32 adr, res;
25261 u32 src, dst;
25262
25263 if ((!flag_NotZ) || (flag_C & 0x100))
25264 {
25265 u32 newPC;
25266
be26eb23 25267 newPC = GET_PC;
70357ce5 25268 newPC += GET_SWORD;
25269 SET_PC(newPC);
25270 CHECK_BRANCH_EXCEPTION(newPC)
25271 RET(10)
25272 }
25273 PC++;
25274RET(12)
25275}
25276
25277// BCC16
25278OPCODE(0x6400)
25279{
25280 u32 adr, res;
25281 u32 src, dst;
25282
25283 if (!(flag_C & 0x100))
25284 {
25285 u32 newPC;
25286
be26eb23 25287 newPC = GET_PC;
70357ce5 25288 newPC += GET_SWORD;
25289 SET_PC(newPC);
25290 CHECK_BRANCH_EXCEPTION(newPC)
25291 RET(10)
25292 }
25293 PC++;
25294RET(12)
25295}
25296
25297// BCC16
25298OPCODE(0x6500)
25299{
25300 u32 adr, res;
25301 u32 src, dst;
25302
25303 if (flag_C & 0x100)
25304 {
25305 u32 newPC;
25306
be26eb23 25307 newPC = GET_PC;
70357ce5 25308 newPC += GET_SWORD;
25309 SET_PC(newPC);
25310 CHECK_BRANCH_EXCEPTION(newPC)
25311 RET(10)
25312 }
25313 PC++;
25314RET(12)
25315}
25316
25317// BCC16
25318OPCODE(0x6600)
25319{
25320 u32 adr, res;
25321 u32 src, dst;
25322
25323 if (flag_NotZ)
25324 {
25325 u32 newPC;
25326
be26eb23 25327 newPC = GET_PC;
70357ce5 25328 newPC += GET_SWORD;
25329 SET_PC(newPC);
25330 CHECK_BRANCH_EXCEPTION(newPC)
25331 RET(10)
25332 }
25333 PC++;
25334RET(12)
25335}
25336
25337// BCC16
25338OPCODE(0x6700)
25339{
25340 u32 adr, res;
25341 u32 src, dst;
25342
25343 if (!flag_NotZ)
25344 {
25345 u32 newPC;
25346
be26eb23 25347 newPC = GET_PC;
70357ce5 25348 newPC += GET_SWORD;
25349 SET_PC(newPC);
25350 CHECK_BRANCH_EXCEPTION(newPC)
25351 RET(10)
25352 }
25353 PC++;
25354RET(12)
25355}
25356
25357// BCC16
25358OPCODE(0x6800)
25359{
25360 u32 adr, res;
25361 u32 src, dst;
25362
25363 if (!(flag_V & 0x80))
25364 {
25365 u32 newPC;
25366
be26eb23 25367 newPC = GET_PC;
70357ce5 25368 newPC += GET_SWORD;
25369 SET_PC(newPC);
25370 CHECK_BRANCH_EXCEPTION(newPC)
25371 RET(10)
25372 }
25373 PC++;
25374RET(12)
25375}
25376
25377// BCC16
25378OPCODE(0x6900)
25379{
25380 u32 adr, res;
25381 u32 src, dst;
25382
25383 if (flag_V & 0x80)
25384 {
25385 u32 newPC;
25386
be26eb23 25387 newPC = GET_PC;
70357ce5 25388 newPC += GET_SWORD;
25389 SET_PC(newPC);
25390 CHECK_BRANCH_EXCEPTION(newPC)
25391 RET(10)
25392 }
25393 PC++;
25394RET(12)
25395}
25396
25397// BCC16
25398OPCODE(0x6A00)
25399{
25400 u32 adr, res;
25401 u32 src, dst;
25402
25403 if (!(flag_N & 0x80))
25404 {
25405 u32 newPC;
25406
be26eb23 25407 newPC = GET_PC;
70357ce5 25408 newPC += GET_SWORD;
25409 SET_PC(newPC);
25410 CHECK_BRANCH_EXCEPTION(newPC)
25411 RET(10)
25412 }
25413 PC++;
25414RET(12)
25415}
25416
25417// BCC16
25418OPCODE(0x6B00)
25419{
25420 u32 adr, res;
25421 u32 src, dst;
25422
25423 if (flag_N & 0x80)
25424 {
25425 u32 newPC;
25426
be26eb23 25427 newPC = GET_PC;
70357ce5 25428 newPC += GET_SWORD;
25429 SET_PC(newPC);
25430 CHECK_BRANCH_EXCEPTION(newPC)
25431 RET(10)
25432 }
25433 PC++;
25434RET(12)
25435}
25436
25437// BCC16
25438OPCODE(0x6C00)
25439{
25440 u32 adr, res;
25441 u32 src, dst;
25442
25443 if (!((flag_N ^ flag_V) & 0x80))
25444 {
25445 u32 newPC;
25446
be26eb23 25447 newPC = GET_PC;
70357ce5 25448 newPC += GET_SWORD;
25449 SET_PC(newPC);
25450 CHECK_BRANCH_EXCEPTION(newPC)
25451 RET(10)
25452 }
25453 PC++;
25454RET(12)
25455}
25456
25457// BCC16
25458OPCODE(0x6D00)
25459{
25460 u32 adr, res;
25461 u32 src, dst;
25462
25463 if ((flag_N ^ flag_V) & 0x80)
25464 {
25465 u32 newPC;
25466
be26eb23 25467 newPC = GET_PC;
70357ce5 25468 newPC += GET_SWORD;
25469 SET_PC(newPC);
25470 CHECK_BRANCH_EXCEPTION(newPC)
25471 RET(10)
25472 }
25473 PC++;
25474RET(12)
25475}
25476
25477// BCC16
25478OPCODE(0x6E00)
25479{
25480 u32 adr, res;
25481 u32 src, dst;
25482
25483 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25484 {
25485 u32 newPC;
25486
be26eb23 25487 newPC = GET_PC;
70357ce5 25488 newPC += GET_SWORD;
25489 SET_PC(newPC);
25490 CHECK_BRANCH_EXCEPTION(newPC)
25491 RET(10)
25492 }
25493 PC++;
25494RET(12)
25495}
25496
25497// BCC16
25498OPCODE(0x6F00)
25499{
25500 u32 adr, res;
25501 u32 src, dst;
25502
25503 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25504 {
25505 u32 newPC;
25506
be26eb23 25507 newPC = GET_PC;
70357ce5 25508 newPC += GET_SWORD;
25509 SET_PC(newPC);
25510 CHECK_BRANCH_EXCEPTION(newPC)
25511 RET(10)
25512 }
25513 PC++;
25514RET(12)
25515}
25516
25517// BRA
25518OPCODE(0x6001)
25519{
25520#ifdef FAMEC_CHECK_BRANCHES
be26eb23 25521 u32 newPC = GET_PC;
70357ce5 25522 s8 offs=Opcode;
25523 newPC += offs;
25524 SET_PC(newPC);
25525 CHECK_BRANCH_EXCEPTION(offs)
25526#else
25527 PC += ((s8)(Opcode & 0xFE)) >> 1;
25528#endif
25529RET(10)
25530}
25531
25532// BRA16
25533OPCODE(0x6000)
25534{
25535 u32 adr, res;
25536 u32 src, dst;
25537
25538 {
25539 u32 newPC;
25540
be26eb23 25541 newPC = GET_PC;
70357ce5 25542 newPC += GET_SWORD;
25543 SET_PC(newPC);
25544 CHECK_BRANCH_EXCEPTION(newPC)
25545 }
25546RET(10)
25547}
25548
25549// BSR
25550OPCODE(0x6101)
25551{
25552 u32 adr, res;
25553 u32 src, dst;
25554 u32 oldPC;
25555 s8 offs;
25556
25557 PRE_IO
25558
be26eb23 25559 oldPC = GET_PC;
70357ce5 25560 PUSH_32_F(oldPC)
25561#ifdef FAMEC_CHECK_BRANCHES
25562 offs = Opcode;
25563 oldPC += offs;
25564 SET_PC(oldPC);
25565 CHECK_BRANCH_EXCEPTION(offs)
25566#else
25567 PC += ((s8)(Opcode & 0xFE)) >> 1;
25568#endif
25569 POST_IO
25570RET(18)
25571}
25572
25573// BSR16
25574OPCODE(0x6100)
25575{
25576 u32 adr, res;
25577 u32 src, dst;
25578
25579 PRE_IO
25580 {
25581 u32 oldPC, newPC;
25582
be26eb23 25583 newPC = GET_PC;
70357ce5 25584 oldPC = newPC + 2;
25585 PUSH_32_F(oldPC)
25586 newPC += GET_SWORD;
25587 SET_PC(newPC);
25588 CHECK_BRANCH_EXCEPTION(newPC)
25589 }
25590 POST_IO
25591RET(18)
25592}
25593
25594// MOVEQ
25595OPCODE(0x7000)
25596{
25597 u32 adr, res;
25598 u32 src, dst;
25599
25600 res = (s32)(s8)Opcode;
25601 flag_C = flag_V = 0;
25602 flag_N = flag_NotZ = res;
25603 DREGu32((Opcode >> 9) & 7) = res;
25604RET(4)
25605}
25606
25607// ORaD
25608OPCODE(0x8000)
25609{
25610 u32 adr, res;
25611 u32 src, dst;
25612
25613 src = DREGu8((Opcode >> 0) & 7);
25614 res = DREGu8((Opcode >> 9) & 7);
25615 res |= src;
25616 flag_C = 0;
25617 flag_V = 0;
25618 flag_NotZ = res;
25619 flag_N = res;
25620 DREGu8((Opcode >> 9) & 7) = res;
25621RET(4)
25622}
25623
25624// ORaD
25625OPCODE(0x8010)
25626{
25627 u32 adr, res;
25628 u32 src, dst;
25629
25630 adr = AREG((Opcode >> 0) & 7);
25631 PRE_IO
25632 READ_BYTE_F(adr, src)
25633 res = DREGu8((Opcode >> 9) & 7);
25634 res |= src;
25635 flag_C = 0;
25636 flag_V = 0;
25637 flag_NotZ = res;
25638 flag_N = res;
25639 DREGu8((Opcode >> 9) & 7) = res;
25640 POST_IO
25641RET(8)
25642}
25643
25644// ORaD
25645OPCODE(0x8018)
25646{
25647 u32 adr, res;
25648 u32 src, dst;
25649
25650 adr = AREG((Opcode >> 0) & 7);
25651 AREG((Opcode >> 0) & 7) += 1;
25652 PRE_IO
25653 READ_BYTE_F(adr, src)
25654 res = DREGu8((Opcode >> 9) & 7);
25655 res |= src;
25656 flag_C = 0;
25657 flag_V = 0;
25658 flag_NotZ = res;
25659 flag_N = res;
25660 DREGu8((Opcode >> 9) & 7) = res;
25661 POST_IO
25662RET(8)
25663}
25664
25665// ORaD
25666OPCODE(0x8020)
25667{
25668 u32 adr, res;
25669 u32 src, dst;
25670
25671 adr = AREG((Opcode >> 0) & 7) - 1;
25672 AREG((Opcode >> 0) & 7) = adr;
25673 PRE_IO
25674 READ_BYTE_F(adr, src)
25675 res = DREGu8((Opcode >> 9) & 7);
25676 res |= src;
25677 flag_C = 0;
25678 flag_V = 0;
25679 flag_NotZ = res;
25680 flag_N = res;
25681 DREGu8((Opcode >> 9) & 7) = res;
25682 POST_IO
25683RET(10)
25684}
25685
25686// ORaD
25687OPCODE(0x8028)
25688{
25689 u32 adr, res;
25690 u32 src, dst;
25691
25692 FETCH_SWORD(adr);
25693 adr += AREG((Opcode >> 0) & 7);
25694 PRE_IO
25695 READ_BYTE_F(adr, src)
25696 res = DREGu8((Opcode >> 9) & 7);
25697 res |= src;
25698 flag_C = 0;
25699 flag_V = 0;
25700 flag_NotZ = res;
25701 flag_N = res;
25702 DREGu8((Opcode >> 9) & 7) = res;
25703 POST_IO
25704RET(12)
25705}
25706
25707// ORaD
25708OPCODE(0x8030)
25709{
25710 u32 adr, res;
25711 u32 src, dst;
25712
25713 adr = AREG((Opcode >> 0) & 7);
25714 DECODE_EXT_WORD
25715 PRE_IO
25716 READ_BYTE_F(adr, src)
25717 res = DREGu8((Opcode >> 9) & 7);
25718 res |= src;
25719 flag_C = 0;
25720 flag_V = 0;
25721 flag_NotZ = res;
25722 flag_N = res;
25723 DREGu8((Opcode >> 9) & 7) = res;
25724 POST_IO
25725RET(14)
25726}
25727
25728// ORaD
25729OPCODE(0x8038)
25730{
25731 u32 adr, res;
25732 u32 src, dst;
25733
25734 FETCH_SWORD(adr);
25735 PRE_IO
25736 READ_BYTE_F(adr, src)
25737 res = DREGu8((Opcode >> 9) & 7);
25738 res |= src;
25739 flag_C = 0;
25740 flag_V = 0;
25741 flag_NotZ = res;
25742 flag_N = res;
25743 DREGu8((Opcode >> 9) & 7) = res;
25744 POST_IO
25745RET(12)
25746}
25747
25748// ORaD
25749OPCODE(0x8039)
25750{
25751 u32 adr, res;
25752 u32 src, dst;
25753
25754 FETCH_LONG(adr);
25755 PRE_IO
25756 READ_BYTE_F(adr, src)
25757 res = DREGu8((Opcode >> 9) & 7);
25758 res |= src;
25759 flag_C = 0;
25760 flag_V = 0;
25761 flag_NotZ = res;
25762 flag_N = res;
25763 DREGu8((Opcode >> 9) & 7) = res;
25764 POST_IO
25765RET(16)
25766}
25767
25768// ORaD
25769OPCODE(0x803A)
25770{
25771 u32 adr, res;
25772 u32 src, dst;
25773
be26eb23 25774 adr = GET_SWORD + GET_PC;
70357ce5 25775 PC++;
25776 PRE_IO
25777 READ_BYTE_F(adr, src)
25778 res = DREGu8((Opcode >> 9) & 7);
25779 res |= src;
25780 flag_C = 0;
25781 flag_V = 0;
25782 flag_NotZ = res;
25783 flag_N = res;
25784 DREGu8((Opcode >> 9) & 7) = res;
25785 POST_IO
25786RET(12)
25787}
25788
25789// ORaD
25790OPCODE(0x803B)
25791{
25792 u32 adr, res;
25793 u32 src, dst;
25794
be26eb23 25795 adr = GET_PC;
70357ce5 25796 DECODE_EXT_WORD
25797 PRE_IO
25798 READ_BYTE_F(adr, src)
25799 res = DREGu8((Opcode >> 9) & 7);
25800 res |= src;
25801 flag_C = 0;
25802 flag_V = 0;
25803 flag_NotZ = res;
25804 flag_N = res;
25805 DREGu8((Opcode >> 9) & 7) = res;
25806 POST_IO
25807RET(14)
25808}
25809
25810// ORaD
25811OPCODE(0x803C)
25812{
25813 u32 adr, res;
25814 u32 src, dst;
25815
25816 FETCH_BYTE(src);
25817 res = DREGu8((Opcode >> 9) & 7);
25818 res |= src;
25819 flag_C = 0;
25820 flag_V = 0;
25821 flag_NotZ = res;
25822 flag_N = res;
25823 DREGu8((Opcode >> 9) & 7) = res;
25824RET(8)
25825}
25826
25827// ORaD
25828OPCODE(0x801F)
25829{
25830 u32 adr, res;
25831 u32 src, dst;
25832
25833 adr = AREG(7);
25834 AREG(7) += 2;
25835 PRE_IO
25836 READ_BYTE_F(adr, src)
25837 res = DREGu8((Opcode >> 9) & 7);
25838 res |= src;
25839 flag_C = 0;
25840 flag_V = 0;
25841 flag_NotZ = res;
25842 flag_N = res;
25843 DREGu8((Opcode >> 9) & 7) = res;
25844 POST_IO
25845RET(8)
25846}
25847
25848// ORaD
25849OPCODE(0x8027)
25850{
25851 u32 adr, res;
25852 u32 src, dst;
25853
25854 adr = AREG(7) - 2;
25855 AREG(7) = adr;
25856 PRE_IO
25857 READ_BYTE_F(adr, src)
25858 res = DREGu8((Opcode >> 9) & 7);
25859 res |= src;
25860 flag_C = 0;
25861 flag_V = 0;
25862 flag_NotZ = res;
25863 flag_N = res;
25864 DREGu8((Opcode >> 9) & 7) = res;
25865 POST_IO
25866RET(10)
25867}
25868
25869// ORaD
25870OPCODE(0x8040)
25871{
25872 u32 adr, res;
25873 u32 src, dst;
25874
25875 src = DREGu16((Opcode >> 0) & 7);
25876 res = DREGu16((Opcode >> 9) & 7);
25877 res |= src;
25878 flag_C = 0;
25879 flag_V = 0;
25880 flag_NotZ = res;
25881 flag_N = res >> 8;
25882 DREGu16((Opcode >> 9) & 7) = res;
25883RET(4)
25884}
25885
25886// ORaD
25887OPCODE(0x8050)
25888{
25889 u32 adr, res;
25890 u32 src, dst;
25891
25892 adr = AREG((Opcode >> 0) & 7);
25893 PRE_IO
25894 READ_WORD_F(adr, src)
25895 res = DREGu16((Opcode >> 9) & 7);
25896 res |= src;
25897 flag_C = 0;
25898 flag_V = 0;
25899 flag_NotZ = res;
25900 flag_N = res >> 8;
25901 DREGu16((Opcode >> 9) & 7) = res;
25902 POST_IO
25903RET(8)
25904}
25905
25906// ORaD
25907OPCODE(0x8058)
25908{
25909 u32 adr, res;
25910 u32 src, dst;
25911
25912 adr = AREG((Opcode >> 0) & 7);
25913 AREG((Opcode >> 0) & 7) += 2;
25914 PRE_IO
25915 READ_WORD_F(adr, src)
25916 res = DREGu16((Opcode >> 9) & 7);
25917 res |= src;
25918 flag_C = 0;
25919 flag_V = 0;
25920 flag_NotZ = res;
25921 flag_N = res >> 8;
25922 DREGu16((Opcode >> 9) & 7) = res;
25923 POST_IO
25924RET(8)
25925}
25926
25927// ORaD
25928OPCODE(0x8060)
25929{
25930 u32 adr, res;
25931 u32 src, dst;
25932
25933 adr = AREG((Opcode >> 0) & 7) - 2;
25934 AREG((Opcode >> 0) & 7) = adr;
25935 PRE_IO
25936 READ_WORD_F(adr, src)
25937 res = DREGu16((Opcode >> 9) & 7);
25938 res |= src;
25939 flag_C = 0;
25940 flag_V = 0;
25941 flag_NotZ = res;
25942 flag_N = res >> 8;
25943 DREGu16((Opcode >> 9) & 7) = res;
25944 POST_IO
25945RET(10)
25946}
25947
25948// ORaD
25949OPCODE(0x8068)
25950{
25951 u32 adr, res;
25952 u32 src, dst;
25953
25954 FETCH_SWORD(adr);
25955 adr += AREG((Opcode >> 0) & 7);
25956 PRE_IO
25957 READ_WORD_F(adr, src)
25958 res = DREGu16((Opcode >> 9) & 7);
25959 res |= src;
25960 flag_C = 0;
25961 flag_V = 0;
25962 flag_NotZ = res;
25963 flag_N = res >> 8;
25964 DREGu16((Opcode >> 9) & 7) = res;
25965 POST_IO
25966RET(12)
25967}
25968
25969// ORaD
25970OPCODE(0x8070)
25971{
25972 u32 adr, res;
25973 u32 src, dst;
25974
25975 adr = AREG((Opcode >> 0) & 7);
25976 DECODE_EXT_WORD
25977 PRE_IO
25978 READ_WORD_F(adr, src)
25979 res = DREGu16((Opcode >> 9) & 7);
25980 res |= src;
25981 flag_C = 0;
25982 flag_V = 0;
25983 flag_NotZ = res;
25984 flag_N = res >> 8;
25985 DREGu16((Opcode >> 9) & 7) = res;
25986 POST_IO
25987RET(14)
25988}
25989
25990// ORaD
25991OPCODE(0x8078)
25992{
25993 u32 adr, res;
25994 u32 src, dst;
25995
25996 FETCH_SWORD(adr);
25997 PRE_IO
25998 READ_WORD_F(adr, src)
25999 res = DREGu16((Opcode >> 9) & 7);
26000 res |= src;
26001 flag_C = 0;
26002 flag_V = 0;
26003 flag_NotZ = res;
26004 flag_N = res >> 8;
26005 DREGu16((Opcode >> 9) & 7) = res;
26006 POST_IO
26007RET(12)
26008}
26009
26010// ORaD
26011OPCODE(0x8079)
26012{
26013 u32 adr, res;
26014 u32 src, dst;
26015
26016 FETCH_LONG(adr);
26017 PRE_IO
26018 READ_WORD_F(adr, src)
26019 res = DREGu16((Opcode >> 9) & 7);
26020 res |= src;
26021 flag_C = 0;
26022 flag_V = 0;
26023 flag_NotZ = res;
26024 flag_N = res >> 8;
26025 DREGu16((Opcode >> 9) & 7) = res;
26026 POST_IO
26027RET(16)
26028}
26029
26030// ORaD
26031OPCODE(0x807A)
26032{
26033 u32 adr, res;
26034 u32 src, dst;
26035
be26eb23 26036 adr = GET_SWORD + GET_PC;
70357ce5 26037 PC++;
26038 PRE_IO
26039 READ_WORD_F(adr, src)
26040 res = DREGu16((Opcode >> 9) & 7);
26041 res |= src;
26042 flag_C = 0;
26043 flag_V = 0;
26044 flag_NotZ = res;
26045 flag_N = res >> 8;
26046 DREGu16((Opcode >> 9) & 7) = res;
26047 POST_IO
26048RET(12)
26049}
26050
26051// ORaD
26052OPCODE(0x807B)
26053{
26054 u32 adr, res;
26055 u32 src, dst;
26056
be26eb23 26057 adr = GET_PC;
70357ce5 26058 DECODE_EXT_WORD
26059 PRE_IO
26060 READ_WORD_F(adr, src)
26061 res = DREGu16((Opcode >> 9) & 7);
26062 res |= src;
26063 flag_C = 0;
26064 flag_V = 0;
26065 flag_NotZ = res;
26066 flag_N = res >> 8;
26067 DREGu16((Opcode >> 9) & 7) = res;
26068 POST_IO
26069RET(14)
26070}
26071
26072// ORaD
26073OPCODE(0x807C)
26074{
26075 u32 adr, res;
26076 u32 src, dst;
26077
26078 FETCH_WORD(src);
26079 res = DREGu16((Opcode >> 9) & 7);
26080 res |= src;
26081 flag_C = 0;
26082 flag_V = 0;
26083 flag_NotZ = res;
26084 flag_N = res >> 8;
26085 DREGu16((Opcode >> 9) & 7) = res;
26086RET(8)
26087}
26088
26089// ORaD
26090OPCODE(0x805F)
26091{
26092 u32 adr, res;
26093 u32 src, dst;
26094
26095 adr = AREG(7);
26096 AREG(7) += 2;
26097 PRE_IO
26098 READ_WORD_F(adr, src)
26099 res = DREGu16((Opcode >> 9) & 7);
26100 res |= src;
26101 flag_C = 0;
26102 flag_V = 0;
26103 flag_NotZ = res;
26104 flag_N = res >> 8;
26105 DREGu16((Opcode >> 9) & 7) = res;
26106 POST_IO
26107RET(8)
26108}
26109
26110// ORaD
26111OPCODE(0x8067)
26112{
26113 u32 adr, res;
26114 u32 src, dst;
26115
26116 adr = AREG(7) - 2;
26117 AREG(7) = adr;
26118 PRE_IO
26119 READ_WORD_F(adr, src)
26120 res = DREGu16((Opcode >> 9) & 7);
26121 res |= src;
26122 flag_C = 0;
26123 flag_V = 0;
26124 flag_NotZ = res;
26125 flag_N = res >> 8;
26126 DREGu16((Opcode >> 9) & 7) = res;
26127 POST_IO
26128RET(10)
26129}
26130
26131// ORaD
26132OPCODE(0x8080)
26133{
26134 u32 adr, res;
26135 u32 src, dst;
26136
26137 src = DREGu32((Opcode >> 0) & 7);
26138 res = DREGu32((Opcode >> 9) & 7);
26139 res |= src;
26140 flag_C = 0;
26141 flag_V = 0;
26142 flag_NotZ = res;
26143 flag_N = res >> 24;
26144 DREGu32((Opcode >> 9) & 7) = res;
26145RET(8)
26146}
26147
26148// ORaD
26149OPCODE(0x8090)
26150{
26151 u32 adr, res;
26152 u32 src, dst;
26153
26154 adr = AREG((Opcode >> 0) & 7);
26155 PRE_IO
26156 READ_LONG_F(adr, src)
26157 res = DREGu32((Opcode >> 9) & 7);
26158 res |= src;
26159 flag_C = 0;
26160 flag_V = 0;
26161 flag_NotZ = res;
26162 flag_N = res >> 24;
26163 DREGu32((Opcode >> 9) & 7) = res;
26164 POST_IO
26165RET(14)
26166}
26167
26168// ORaD
26169OPCODE(0x8098)
26170{
26171 u32 adr, res;
26172 u32 src, dst;
26173
26174 adr = AREG((Opcode >> 0) & 7);
26175 AREG((Opcode >> 0) & 7) += 4;
26176 PRE_IO
26177 READ_LONG_F(adr, src)
26178 res = DREGu32((Opcode >> 9) & 7);
26179 res |= src;
26180 flag_C = 0;
26181 flag_V = 0;
26182 flag_NotZ = res;
26183 flag_N = res >> 24;
26184 DREGu32((Opcode >> 9) & 7) = res;
26185 POST_IO
26186RET(14)
26187}
26188
26189// ORaD
26190OPCODE(0x80A0)
26191{
26192 u32 adr, res;
26193 u32 src, dst;
26194
26195 adr = AREG((Opcode >> 0) & 7) - 4;
26196 AREG((Opcode >> 0) & 7) = adr;
26197 PRE_IO
26198 READ_LONG_F(adr, src)
26199 res = DREGu32((Opcode >> 9) & 7);
26200 res |= src;
26201 flag_C = 0;
26202 flag_V = 0;
26203 flag_NotZ = res;
26204 flag_N = res >> 24;
26205 DREGu32((Opcode >> 9) & 7) = res;
26206 POST_IO
26207RET(16)
26208}
26209
26210// ORaD
26211OPCODE(0x80A8)
26212{
26213 u32 adr, res;
26214 u32 src, dst;
26215
26216 FETCH_SWORD(adr);
26217 adr += AREG((Opcode >> 0) & 7);
26218 PRE_IO
26219 READ_LONG_F(adr, src)
26220 res = DREGu32((Opcode >> 9) & 7);
26221 res |= src;
26222 flag_C = 0;
26223 flag_V = 0;
26224 flag_NotZ = res;
26225 flag_N = res >> 24;
26226 DREGu32((Opcode >> 9) & 7) = res;
26227 POST_IO
26228RET(18)
26229}
26230
26231// ORaD
26232OPCODE(0x80B0)
26233{
26234 u32 adr, res;
26235 u32 src, dst;
26236
26237 adr = AREG((Opcode >> 0) & 7);
26238 DECODE_EXT_WORD
26239 PRE_IO
26240 READ_LONG_F(adr, src)
26241 res = DREGu32((Opcode >> 9) & 7);
26242 res |= src;
26243 flag_C = 0;
26244 flag_V = 0;
26245 flag_NotZ = res;
26246 flag_N = res >> 24;
26247 DREGu32((Opcode >> 9) & 7) = res;
26248 POST_IO
26249RET(20)
26250}
26251
26252// ORaD
26253OPCODE(0x80B8)
26254{
26255 u32 adr, res;
26256 u32 src, dst;
26257
26258 FETCH_SWORD(adr);
26259 PRE_IO
26260 READ_LONG_F(adr, src)
26261 res = DREGu32((Opcode >> 9) & 7);
26262 res |= src;
26263 flag_C = 0;
26264 flag_V = 0;
26265 flag_NotZ = res;
26266 flag_N = res >> 24;
26267 DREGu32((Opcode >> 9) & 7) = res;
26268 POST_IO
26269RET(18)
26270}
26271
26272// ORaD
26273OPCODE(0x80B9)
26274{
26275 u32 adr, res;
26276 u32 src, dst;
26277
26278 FETCH_LONG(adr);
26279 PRE_IO
26280 READ_LONG_F(adr, src)
26281 res = DREGu32((Opcode >> 9) & 7);
26282 res |= src;
26283 flag_C = 0;
26284 flag_V = 0;
26285 flag_NotZ = res;
26286 flag_N = res >> 24;
26287 DREGu32((Opcode >> 9) & 7) = res;
26288 POST_IO
26289RET(22)
26290}
26291
26292// ORaD
26293OPCODE(0x80BA)
26294{
26295 u32 adr, res;
26296 u32 src, dst;
26297
be26eb23 26298 adr = GET_SWORD + GET_PC;
70357ce5 26299 PC++;
26300 PRE_IO
26301 READ_LONG_F(adr, src)
26302 res = DREGu32((Opcode >> 9) & 7);
26303 res |= src;
26304 flag_C = 0;
26305 flag_V = 0;
26306 flag_NotZ = res;
26307 flag_N = res >> 24;
26308 DREGu32((Opcode >> 9) & 7) = res;
26309 POST_IO
26310RET(18)
26311}
26312
26313// ORaD
26314OPCODE(0x80BB)
26315{
26316 u32 adr, res;
26317 u32 src, dst;
26318
be26eb23 26319 adr = GET_PC;
70357ce5 26320 DECODE_EXT_WORD
26321 PRE_IO
26322 READ_LONG_F(adr, src)
26323 res = DREGu32((Opcode >> 9) & 7);
26324 res |= src;
26325 flag_C = 0;
26326 flag_V = 0;
26327 flag_NotZ = res;
26328 flag_N = res >> 24;
26329 DREGu32((Opcode >> 9) & 7) = res;
26330 POST_IO
26331RET(20)
26332}
26333
26334// ORaD
26335OPCODE(0x80BC)
26336{
26337 u32 adr, res;
26338 u32 src, dst;
26339
26340 FETCH_LONG(src);
26341 res = DREGu32((Opcode >> 9) & 7);
26342 res |= src;
26343 flag_C = 0;
26344 flag_V = 0;
26345 flag_NotZ = res;
26346 flag_N = res >> 24;
26347 DREGu32((Opcode >> 9) & 7) = res;
26348RET(16)
26349}
26350
26351// ORaD
26352OPCODE(0x809F)
26353{
26354 u32 adr, res;
26355 u32 src, dst;
26356
26357 adr = AREG(7);
26358 AREG(7) += 4;
26359 PRE_IO
26360 READ_LONG_F(adr, src)
26361 res = DREGu32((Opcode >> 9) & 7);
26362 res |= src;
26363 flag_C = 0;
26364 flag_V = 0;
26365 flag_NotZ = res;
26366 flag_N = res >> 24;
26367 DREGu32((Opcode >> 9) & 7) = res;
26368 POST_IO
26369RET(14)
26370}
26371
26372// ORaD
26373OPCODE(0x80A7)
26374{
26375 u32 adr, res;
26376 u32 src, dst;
26377
26378 adr = AREG(7) - 4;
26379 AREG(7) = adr;
26380 PRE_IO
26381 READ_LONG_F(adr, src)
26382 res = DREGu32((Opcode >> 9) & 7);
26383 res |= src;
26384 flag_C = 0;
26385 flag_V = 0;
26386 flag_NotZ = res;
26387 flag_N = res >> 24;
26388 DREGu32((Opcode >> 9) & 7) = res;
26389 POST_IO
26390RET(16)
26391}
26392
26393// ORDa
26394OPCODE(0x8110)
26395{
26396 u32 adr, res;
26397 u32 src, dst;
26398
26399 src = DREGu8((Opcode >> 9) & 7);
26400 adr = AREG((Opcode >> 0) & 7);
26401 PRE_IO
26402 READ_BYTE_F(adr, res)
26403 res |= src;
26404 flag_C = 0;
26405 flag_V = 0;
26406 flag_NotZ = res;
26407 flag_N = res;
26408 WRITE_BYTE_F(adr, res)
26409 POST_IO
26410RET(12)
26411}
26412
26413// ORDa
26414OPCODE(0x8118)
26415{
26416 u32 adr, res;
26417 u32 src, dst;
26418
26419 src = DREGu8((Opcode >> 9) & 7);
26420 adr = AREG((Opcode >> 0) & 7);
26421 AREG((Opcode >> 0) & 7) += 1;
26422 PRE_IO
26423 READ_BYTE_F(adr, res)
26424 res |= src;
26425 flag_C = 0;
26426 flag_V = 0;
26427 flag_NotZ = res;
26428 flag_N = res;
26429 WRITE_BYTE_F(adr, res)
26430 POST_IO
26431RET(12)
26432}
26433
26434// ORDa
26435OPCODE(0x8120)
26436{
26437 u32 adr, res;
26438 u32 src, dst;
26439
26440 src = DREGu8((Opcode >> 9) & 7);
26441 adr = AREG((Opcode >> 0) & 7) - 1;
26442 AREG((Opcode >> 0) & 7) = adr;
26443 PRE_IO
26444 READ_BYTE_F(adr, res)
26445 res |= src;
26446 flag_C = 0;
26447 flag_V = 0;
26448 flag_NotZ = res;
26449 flag_N = res;
26450 WRITE_BYTE_F(adr, res)
26451 POST_IO
26452RET(14)
26453}
26454
26455// ORDa
26456OPCODE(0x8128)
26457{
26458 u32 adr, res;
26459 u32 src, dst;
26460
26461 src = DREGu8((Opcode >> 9) & 7);
26462 FETCH_SWORD(adr);
26463 adr += AREG((Opcode >> 0) & 7);
26464 PRE_IO
26465 READ_BYTE_F(adr, res)
26466 res |= src;
26467 flag_C = 0;
26468 flag_V = 0;
26469 flag_NotZ = res;
26470 flag_N = res;
26471 WRITE_BYTE_F(adr, res)
26472 POST_IO
26473RET(16)
26474}
26475
26476// ORDa
26477OPCODE(0x8130)
26478{
26479 u32 adr, res;
26480 u32 src, dst;
26481
26482 src = DREGu8((Opcode >> 9) & 7);
26483 adr = AREG((Opcode >> 0) & 7);
26484 DECODE_EXT_WORD
26485 PRE_IO
26486 READ_BYTE_F(adr, res)
26487 res |= src;
26488 flag_C = 0;
26489 flag_V = 0;
26490 flag_NotZ = res;
26491 flag_N = res;
26492 WRITE_BYTE_F(adr, res)
26493 POST_IO
26494RET(18)
26495}
26496
26497// ORDa
26498OPCODE(0x8138)
26499{
26500 u32 adr, res;
26501 u32 src, dst;
26502
26503 src = DREGu8((Opcode >> 9) & 7);
26504 FETCH_SWORD(adr);
26505 PRE_IO
26506 READ_BYTE_F(adr, res)
26507 res |= src;
26508 flag_C = 0;
26509 flag_V = 0;
26510 flag_NotZ = res;
26511 flag_N = res;
26512 WRITE_BYTE_F(adr, res)
26513 POST_IO
26514RET(16)
26515}
26516
26517// ORDa
26518OPCODE(0x8139)
26519{
26520 u32 adr, res;
26521 u32 src, dst;
26522
26523 src = DREGu8((Opcode >> 9) & 7);
26524 FETCH_LONG(adr);
26525 PRE_IO
26526 READ_BYTE_F(adr, res)
26527 res |= src;
26528 flag_C = 0;
26529 flag_V = 0;
26530 flag_NotZ = res;
26531 flag_N = res;
26532 WRITE_BYTE_F(adr, res)
26533 POST_IO
26534RET(20)
26535}
26536
26537// ORDa
26538OPCODE(0x811F)
26539{
26540 u32 adr, res;
26541 u32 src, dst;
26542
26543 src = DREGu8((Opcode >> 9) & 7);
26544 adr = AREG(7);
26545 AREG(7) += 2;
26546 PRE_IO
26547 READ_BYTE_F(adr, res)
26548 res |= src;
26549 flag_C = 0;
26550 flag_V = 0;
26551 flag_NotZ = res;
26552 flag_N = res;
26553 WRITE_BYTE_F(adr, res)
26554 POST_IO
26555RET(12)
26556}
26557
26558// ORDa
26559OPCODE(0x8127)
26560{
26561 u32 adr, res;
26562 u32 src, dst;
26563
26564 src = DREGu8((Opcode >> 9) & 7);
26565 adr = AREG(7) - 2;
26566 AREG(7) = adr;
26567 PRE_IO
26568 READ_BYTE_F(adr, res)
26569 res |= src;
26570 flag_C = 0;
26571 flag_V = 0;
26572 flag_NotZ = res;
26573 flag_N = res;
26574 WRITE_BYTE_F(adr, res)
26575 POST_IO
26576RET(14)
26577}
26578
26579// ORDa
26580OPCODE(0x8150)
26581{
26582 u32 adr, res;
26583 u32 src, dst;
26584
26585 src = DREGu16((Opcode >> 9) & 7);
26586 adr = AREG((Opcode >> 0) & 7);
26587 PRE_IO
26588 READ_WORD_F(adr, res)
26589 res |= src;
26590 flag_C = 0;
26591 flag_V = 0;
26592 flag_NotZ = res;
26593 flag_N = res >> 8;
26594 WRITE_WORD_F(adr, res)
26595 POST_IO
26596RET(12)
26597}
26598
26599// ORDa
26600OPCODE(0x8158)
26601{
26602 u32 adr, res;
26603 u32 src, dst;
26604
26605 src = DREGu16((Opcode >> 9) & 7);
26606 adr = AREG((Opcode >> 0) & 7);
26607 AREG((Opcode >> 0) & 7) += 2;
26608 PRE_IO
26609 READ_WORD_F(adr, res)
26610 res |= src;
26611 flag_C = 0;
26612 flag_V = 0;
26613 flag_NotZ = res;
26614 flag_N = res >> 8;
26615 WRITE_WORD_F(adr, res)
26616 POST_IO
26617RET(12)
26618}
26619
26620// ORDa
26621OPCODE(0x8160)
26622{
26623 u32 adr, res;
26624 u32 src, dst;
26625
26626 src = DREGu16((Opcode >> 9) & 7);
26627 adr = AREG((Opcode >> 0) & 7) - 2;
26628 AREG((Opcode >> 0) & 7) = adr;
26629 PRE_IO
26630 READ_WORD_F(adr, res)
26631 res |= src;
26632 flag_C = 0;
26633 flag_V = 0;
26634 flag_NotZ = res;
26635 flag_N = res >> 8;
26636 WRITE_WORD_F(adr, res)
26637 POST_IO
26638RET(14)
26639}
26640
26641// ORDa
26642OPCODE(0x8168)
26643{
26644 u32 adr, res;
26645 u32 src, dst;
26646
26647 src = DREGu16((Opcode >> 9) & 7);
26648 FETCH_SWORD(adr);
26649 adr += AREG((Opcode >> 0) & 7);
26650 PRE_IO
26651 READ_WORD_F(adr, res)
26652 res |= src;
26653 flag_C = 0;
26654 flag_V = 0;
26655 flag_NotZ = res;
26656 flag_N = res >> 8;
26657 WRITE_WORD_F(adr, res)
26658 POST_IO
26659RET(16)
26660}
26661
26662// ORDa
26663OPCODE(0x8170)
26664{
26665 u32 adr, res;
26666 u32 src, dst;
26667
26668 src = DREGu16((Opcode >> 9) & 7);
26669 adr = AREG((Opcode >> 0) & 7);
26670 DECODE_EXT_WORD
26671 PRE_IO
26672 READ_WORD_F(adr, res)
26673 res |= src;
26674 flag_C = 0;
26675 flag_V = 0;
26676 flag_NotZ = res;
26677 flag_N = res >> 8;
26678 WRITE_WORD_F(adr, res)
26679 POST_IO
26680RET(18)
26681}
26682
26683// ORDa
26684OPCODE(0x8178)
26685{
26686 u32 adr, res;
26687 u32 src, dst;
26688
26689 src = DREGu16((Opcode >> 9) & 7);
26690 FETCH_SWORD(adr);
26691 PRE_IO
26692 READ_WORD_F(adr, res)
26693 res |= src;
26694 flag_C = 0;
26695 flag_V = 0;
26696 flag_NotZ = res;
26697 flag_N = res >> 8;
26698 WRITE_WORD_F(adr, res)
26699 POST_IO
26700RET(16)
26701}
26702
26703// ORDa
26704OPCODE(0x8179)
26705{
26706 u32 adr, res;
26707 u32 src, dst;
26708
26709 src = DREGu16((Opcode >> 9) & 7);
26710 FETCH_LONG(adr);
26711 PRE_IO
26712 READ_WORD_F(adr, res)
26713 res |= src;
26714 flag_C = 0;
26715 flag_V = 0;
26716 flag_NotZ = res;
26717 flag_N = res >> 8;
26718 WRITE_WORD_F(adr, res)
26719 POST_IO
26720RET(20)
26721}
26722
26723// ORDa
26724OPCODE(0x815F)
26725{
26726 u32 adr, res;
26727 u32 src, dst;
26728
26729 src = DREGu16((Opcode >> 9) & 7);
26730 adr = AREG(7);
26731 AREG(7) += 2;
26732 PRE_IO
26733 READ_WORD_F(adr, res)
26734 res |= src;
26735 flag_C = 0;
26736 flag_V = 0;
26737 flag_NotZ = res;
26738 flag_N = res >> 8;
26739 WRITE_WORD_F(adr, res)
26740 POST_IO
26741RET(12)
26742}
26743
26744// ORDa
26745OPCODE(0x8167)
26746{
26747 u32 adr, res;
26748 u32 src, dst;
26749
26750 src = DREGu16((Opcode >> 9) & 7);
26751 adr = AREG(7) - 2;
26752 AREG(7) = adr;
26753 PRE_IO
26754 READ_WORD_F(adr, res)
26755 res |= src;
26756 flag_C = 0;
26757 flag_V = 0;
26758 flag_NotZ = res;
26759 flag_N = res >> 8;
26760 WRITE_WORD_F(adr, res)
26761 POST_IO
26762RET(14)
26763}
26764
26765// ORDa
26766OPCODE(0x8190)
26767{
26768 u32 adr, res;
26769 u32 src, dst;
26770
26771 src = DREGu32((Opcode >> 9) & 7);
26772 adr = AREG((Opcode >> 0) & 7);
26773 PRE_IO
26774 READ_LONG_F(adr, res)
26775 res |= src;
26776 flag_C = 0;
26777 flag_V = 0;
26778 flag_NotZ = res;
26779 flag_N = res >> 24;
26780 WRITE_LONG_F(adr, res)
26781 POST_IO
26782RET(20)
26783}
26784
26785// ORDa
26786OPCODE(0x8198)
26787{
26788 u32 adr, res;
26789 u32 src, dst;
26790
26791 src = DREGu32((Opcode >> 9) & 7);
26792 adr = AREG((Opcode >> 0) & 7);
26793 AREG((Opcode >> 0) & 7) += 4;
26794 PRE_IO
26795 READ_LONG_F(adr, res)
26796 res |= src;
26797 flag_C = 0;
26798 flag_V = 0;
26799 flag_NotZ = res;
26800 flag_N = res >> 24;
26801 WRITE_LONG_F(adr, res)
26802 POST_IO
26803RET(20)
26804}
26805
26806// ORDa
26807OPCODE(0x81A0)
26808{
26809 u32 adr, res;
26810 u32 src, dst;
26811
26812 src = DREGu32((Opcode >> 9) & 7);
26813 adr = AREG((Opcode >> 0) & 7) - 4;
26814 AREG((Opcode >> 0) & 7) = adr;
26815 PRE_IO
26816 READ_LONG_F(adr, res)
26817 res |= src;
26818 flag_C = 0;
26819 flag_V = 0;
26820 flag_NotZ = res;
26821 flag_N = res >> 24;
26822 WRITE_LONG_F(adr, res)
26823 POST_IO
26824RET(22)
26825}
26826
26827// ORDa
26828OPCODE(0x81A8)
26829{
26830 u32 adr, res;
26831 u32 src, dst;
26832
26833 src = DREGu32((Opcode >> 9) & 7);
26834 FETCH_SWORD(adr);
26835 adr += AREG((Opcode >> 0) & 7);
26836 PRE_IO
26837 READ_LONG_F(adr, res)
26838 res |= src;
26839 flag_C = 0;
26840 flag_V = 0;
26841 flag_NotZ = res;
26842 flag_N = res >> 24;
26843 WRITE_LONG_F(adr, res)
26844 POST_IO
26845RET(24)
26846}
26847
26848// ORDa
26849OPCODE(0x81B0)
26850{
26851 u32 adr, res;
26852 u32 src, dst;
26853
26854 src = DREGu32((Opcode >> 9) & 7);
26855 adr = AREG((Opcode >> 0) & 7);
26856 DECODE_EXT_WORD
26857 PRE_IO
26858 READ_LONG_F(adr, res)
26859 res |= src;
26860 flag_C = 0;
26861 flag_V = 0;
26862 flag_NotZ = res;
26863 flag_N = res >> 24;
26864 WRITE_LONG_F(adr, res)
26865 POST_IO
26866RET(26)
26867}
26868
26869// ORDa
26870OPCODE(0x81B8)
26871{
26872 u32 adr, res;
26873 u32 src, dst;
26874
26875 src = DREGu32((Opcode >> 9) & 7);
26876 FETCH_SWORD(adr);
26877 PRE_IO
26878 READ_LONG_F(adr, res)
26879 res |= src;
26880 flag_C = 0;
26881 flag_V = 0;
26882 flag_NotZ = res;
26883 flag_N = res >> 24;
26884 WRITE_LONG_F(adr, res)
26885 POST_IO
26886RET(24)
26887}
26888
26889// ORDa
26890OPCODE(0x81B9)
26891{
26892 u32 adr, res;
26893 u32 src, dst;
26894
26895 src = DREGu32((Opcode >> 9) & 7);
26896 FETCH_LONG(adr);
26897 PRE_IO
26898 READ_LONG_F(adr, res)
26899 res |= src;
26900 flag_C = 0;
26901 flag_V = 0;
26902 flag_NotZ = res;
26903 flag_N = res >> 24;
26904 WRITE_LONG_F(adr, res)
26905 POST_IO
26906RET(28)
26907}
26908
26909// ORDa
26910OPCODE(0x819F)
26911{
26912 u32 adr, res;
26913 u32 src, dst;
26914
26915 src = DREGu32((Opcode >> 9) & 7);
26916 adr = AREG(7);
26917 AREG(7) += 4;
26918 PRE_IO
26919 READ_LONG_F(adr, res)
26920 res |= src;
26921 flag_C = 0;
26922 flag_V = 0;
26923 flag_NotZ = res;
26924 flag_N = res >> 24;
26925 WRITE_LONG_F(adr, res)
26926 POST_IO
26927RET(20)
26928}
26929
26930// ORDa
26931OPCODE(0x81A7)
26932{
26933 u32 adr, res;
26934 u32 src, dst;
26935
26936 src = DREGu32((Opcode >> 9) & 7);
26937 adr = AREG(7) - 4;
26938 AREG(7) = adr;
26939 PRE_IO
26940 READ_LONG_F(adr, res)
26941 res |= src;
26942 flag_C = 0;
26943 flag_V = 0;
26944 flag_NotZ = res;
26945 flag_N = res >> 24;
26946 WRITE_LONG_F(adr, res)
26947 POST_IO
26948RET(22)
26949}
26950
26951// SBCD
26952OPCODE(0x8100)
26953{
26954 u32 adr, res;
26955 u32 src, dst;
c6e1e977 26956 u32 corf = 0;
70357ce5 26957
26958 src = DREGu8((Opcode >> 0) & 7);
26959 dst = DREGu8((Opcode >> 9) & 7);
26960 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 26961 if (res > 0xF) corf = 6;
70357ce5 26962 res += (dst & 0xF0) - (src & 0xF0);
c6e1e977 26963 flag_V = res;
26964 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
26965 if (res > 0xff) res += 0xA0;
26966 res = (res - corf) & 0xFF;
26967 flag_V &= ~res;
26968 flag_NotZ |= res;
70357ce5 26969 flag_N = res;
26970 DREGu8((Opcode >> 9) & 7) = res;
26971RET(6)
26972}
26973
26974// SBCDM
26975OPCODE(0x8108)
26976{
26977 u32 adr, res;
26978 u32 src, dst;
c6e1e977 26979 u32 corf = 0;
70357ce5 26980
26981 adr = AREG((Opcode >> 0) & 7) - 1;
26982 AREG((Opcode >> 0) & 7) = adr;
26983 PRE_IO
26984 READ_BYTE_F(adr, src)
26985 adr = AREG((Opcode >> 9) & 7) - 1;
26986 AREG((Opcode >> 9) & 7) = adr;
26987 READ_BYTE_F(adr, dst)
26988 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 26989 if (res > 0xF) corf = 6;
70357ce5 26990 res += (dst & 0xF0) - (src & 0xF0);
c6e1e977 26991 flag_V = res;
26992 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
26993 if (res > 0xff) res += 0xA0;
26994 res = (res - corf) & 0xFF;
26995 flag_V &= ~res;
26996 flag_NotZ |= res;
70357ce5 26997 flag_N = res;
26998 WRITE_BYTE_F(adr, res)
26999 POST_IO
27000RET(18)
27001}
27002
27003// SBCD7M
27004OPCODE(0x810F)
27005{
27006 u32 adr, res;
27007 u32 src, dst;
c6e1e977 27008 u32 corf = 0;
70357ce5 27009
27010 adr = AREG(7) - 2;
27011 AREG(7) = adr;
27012 PRE_IO
27013 READ_BYTE_F(adr, src)
27014 adr = AREG((Opcode >> 9) & 7) - 1;
27015 AREG((Opcode >> 9) & 7) = adr;
27016 READ_BYTE_F(adr, dst)
27017 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 27018 if (res > 0xF) corf = 6;
70357ce5 27019 res += (dst & 0xF0) - (src & 0xF0);
c6e1e977 27020 flag_V = res;
27021 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27022 if (res > 0xff) res += 0xA0;
27023 res = (res - corf) & 0xFF;
27024 flag_V &= ~res;
27025 flag_NotZ |= res;
70357ce5 27026 flag_N = res;
27027 WRITE_BYTE_F(adr, res)
27028 POST_IO
27029RET(18)
27030}
27031
27032// SBCDM7
27033OPCODE(0x8F08)
27034{
27035 u32 adr, res;
27036 u32 src, dst;
c6e1e977 27037 u32 corf = 0;
70357ce5 27038
27039 adr = AREG((Opcode >> 0) & 7) - 1;
27040 AREG((Opcode >> 0) & 7) = adr;
27041 PRE_IO
27042 READ_BYTE_F(adr, src)
27043 adr = AREG(7) - 2;
27044 AREG(7) = adr;
27045 READ_BYTE_F(adr, dst)
27046 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 27047 if (res > 0xF) corf = 6;
70357ce5 27048 res += (dst & 0xF0) - (src & 0xF0);
c6e1e977 27049 flag_V = res;
27050 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27051 if (res > 0xff) res += 0xA0;
27052 res = (res - corf) & 0xFF;
27053 flag_V &= ~res;
27054 flag_NotZ |= res;
70357ce5 27055 flag_N = res;
27056 WRITE_BYTE_F(adr, res)
27057 POST_IO
27058RET(18)
27059}
27060
27061// SBCD7M7
27062OPCODE(0x8F0F)
27063{
27064 u32 adr, res;
27065 u32 src, dst;
c6e1e977 27066 u32 corf = 0;
70357ce5 27067
27068 adr = AREG(7) - 2;
27069 AREG(7) = adr;
27070 PRE_IO
27071 READ_BYTE_F(adr, src)
27072 adr = AREG(7) - 2;
27073 AREG(7) = adr;
27074 READ_BYTE_F(adr, dst)
27075 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 27076 if (res > 0xF) corf = 6;
70357ce5 27077 res += (dst & 0xF0) - (src & 0xF0);
c6e1e977 27078 flag_V = res;
27079 flag_X = flag_C = (s32)res < (s32)corf ? M68K_SR_C : 0;
27080 if (res > 0xff) res += 0xA0;
27081 res = (res - corf) & 0xFF;
27082 flag_V &= ~res;
27083 flag_NotZ |= res;
70357ce5 27084 flag_N = res;
27085 WRITE_BYTE_F(adr, res)
27086 POST_IO
27087RET(18)
27088}
27089
27090// DIVU
27091OPCODE(0x80C0)
27092{
27093 u32 adr, res;
27094 u32 src, dst;
27095
27096 src = DREGu16((Opcode >> 0) & 7);
27097 if (src == 0)
27098 {
d0ae0cb4 27099 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27100#ifdef USE_CYCLONE_TIMING_DIV
27101RET(140)
27102#else
27103RET(10)
27104#endif
27105 }
27106 dst = DREGu32((Opcode >> 9) & 7);
27107 {
27108 u32 q, r;
27109
27110 q = dst / src;
27111 r = dst % src;
27112
27113 if (q & 0xFFFF0000)
27114 {
27115 flag_V = M68K_SR_V;
27116#ifdef USE_CYCLONE_TIMING_DIV
27117RET(140)
27118#else
27119RET(70)
27120#endif
27121 }
27122 q &= 0x0000FFFF;
27123 flag_NotZ = q;
27124 flag_N = q >> 8;
27125 flag_V = flag_C = 0;
27126 res = q | (r << 16);
27127 DREGu32((Opcode >> 9) & 7) = res;
27128 }
27129#ifdef USE_CYCLONE_TIMING_DIV
27130RET(140)
27131#else
27132RET(90)
27133#endif
27134}
27135
27136// DIVU
27137OPCODE(0x80D0)
27138{
27139 u32 adr, res;
27140 u32 src, dst;
27141
27142 adr = AREG((Opcode >> 0) & 7);
27143 PRE_IO
27144 READ_WORD_F(adr, src)
27145 if (src == 0)
27146 {
d0ae0cb4 27147 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27148#ifdef USE_CYCLONE_TIMING_DIV
27149RET(144)
27150#else
27151RET(14)
27152#endif
27153 }
27154 dst = DREGu32((Opcode >> 9) & 7);
27155 {
27156 u32 q, r;
27157
27158 q = dst / src;
27159 r = dst % src;
27160
27161 if (q & 0xFFFF0000)
27162 {
27163 flag_V = M68K_SR_V;
27164#ifdef USE_CYCLONE_TIMING_DIV
27165RET(144)
27166#else
27167 RET(74)
27168#endif
27169 }
27170 q &= 0x0000FFFF;
27171 flag_NotZ = q;
27172 flag_N = q >> 8;
27173 flag_V = flag_C = 0;
27174 res = q | (r << 16);
27175 DREGu32((Opcode >> 9) & 7) = res;
27176 }
27177#ifdef USE_CYCLONE_TIMING_DIV
27178RET(144)
27179#else
27180RET(94)
27181#endif
27182}
27183
27184// DIVU
27185OPCODE(0x80D8)
27186{
27187 u32 adr, res;
27188 u32 src, dst;
27189
27190 adr = AREG((Opcode >> 0) & 7);
27191 AREG((Opcode >> 0) & 7) += 2;
27192 PRE_IO
27193 READ_WORD_F(adr, src)
27194 if (src == 0)
27195 {
d0ae0cb4 27196 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27197#ifdef USE_CYCLONE_TIMING_DIV
27198RET(144)
27199#else
27200RET(14)
27201#endif
27202 }
27203 dst = DREGu32((Opcode >> 9) & 7);
27204 {
27205 u32 q, r;
27206
27207 q = dst / src;
27208 r = dst % src;
27209
27210 if (q & 0xFFFF0000)
27211 {
27212 flag_V = M68K_SR_V;
27213#ifdef USE_CYCLONE_TIMING_DIV
27214RET(144)
27215#else
27216 RET(74)
27217#endif
27218 }
27219 q &= 0x0000FFFF;
27220 flag_NotZ = q;
27221 flag_N = q >> 8;
27222 flag_V = flag_C = 0;
27223 res = q | (r << 16);
27224 DREGu32((Opcode >> 9) & 7) = res;
27225 }
27226#ifdef USE_CYCLONE_TIMING_DIV
27227RET(144)
27228#else
27229RET(94)
27230#endif
27231}
27232
27233// DIVU
27234OPCODE(0x80E0)
27235{
27236 u32 adr, res;
27237 u32 src, dst;
27238
27239 adr = AREG((Opcode >> 0) & 7) - 2;
27240 AREG((Opcode >> 0) & 7) = adr;
27241 PRE_IO
27242 READ_WORD_F(adr, src)
27243 if (src == 0)
27244 {
d0ae0cb4 27245 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27246#ifdef USE_CYCLONE_TIMING_DIV
27247RET(146)
27248#else
27249RET(16)
27250#endif
27251 }
27252 dst = DREGu32((Opcode >> 9) & 7);
27253 {
27254 u32 q, r;
27255
27256 q = dst / src;
27257 r = dst % src;
27258
27259 if (q & 0xFFFF0000)
27260 {
27261 flag_V = M68K_SR_V;
27262#ifdef USE_CYCLONE_TIMING_DIV
27263RET(146)
27264#else
27265 RET(76)
27266#endif
27267 }
27268 q &= 0x0000FFFF;
27269 flag_NotZ = q;
27270 flag_N = q >> 8;
27271 flag_V = flag_C = 0;
27272 res = q | (r << 16);
27273 DREGu32((Opcode >> 9) & 7) = res;
27274 }
27275#ifdef USE_CYCLONE_TIMING_DIV
27276RET(146)
27277#else
27278RET(96)
27279#endif
27280}
27281
27282// DIVU
27283OPCODE(0x80E8)
27284{
27285 u32 adr, res;
27286 u32 src, dst;
27287
27288 FETCH_SWORD(adr);
27289 adr += AREG((Opcode >> 0) & 7);
27290 PRE_IO
27291 READ_WORD_F(adr, src)
27292 if (src == 0)
27293 {
d0ae0cb4 27294 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27295#ifdef USE_CYCLONE_TIMING_DIV
27296RET(148)
27297#else
27298RET(18)
27299#endif
27300 }
27301 dst = DREGu32((Opcode >> 9) & 7);
27302 {
27303 u32 q, r;
27304
27305 q = dst / src;
27306 r = dst % src;
27307
27308 if (q & 0xFFFF0000)
27309 {
27310 flag_V = M68K_SR_V;
27311#ifdef USE_CYCLONE_TIMING_DIV
27312RET(148)
27313#else
27314 RET(78)
27315#endif
27316 }
27317 q &= 0x0000FFFF;
27318 flag_NotZ = q;
27319 flag_N = q >> 8;
27320 flag_V = flag_C = 0;
27321 res = q | (r << 16);
27322 DREGu32((Opcode >> 9) & 7) = res;
27323 }
27324#ifdef USE_CYCLONE_TIMING_DIV
27325RET(148)
27326#else
27327RET(98)
27328#endif
27329}
27330
27331// DIVU
27332OPCODE(0x80F0)
27333{
27334 u32 adr, res;
27335 u32 src, dst;
27336
27337 adr = AREG((Opcode >> 0) & 7);
27338 DECODE_EXT_WORD
27339 PRE_IO
27340 READ_WORD_F(adr, src)
27341 if (src == 0)
27342 {
d0ae0cb4 27343 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27344#ifdef USE_CYCLONE_TIMING_DIV
27345RET(150)
27346#else
27347RET(20)
27348#endif
27349 }
27350 dst = DREGu32((Opcode >> 9) & 7);
27351 {
27352 u32 q, r;
27353
27354 q = dst / src;
27355 r = dst % src;
27356
27357 if (q & 0xFFFF0000)
27358 {
27359 flag_V = M68K_SR_V;
27360#ifdef USE_CYCLONE_TIMING_DIV
27361RET(150)
27362#else
27363 RET(80)
27364#endif
27365 }
27366 q &= 0x0000FFFF;
27367 flag_NotZ = q;
27368 flag_N = q >> 8;
27369 flag_V = flag_C = 0;
27370 res = q | (r << 16);
27371 DREGu32((Opcode >> 9) & 7) = res;
27372 }
27373#ifdef USE_CYCLONE_TIMING_DIV
27374RET(150)
27375#else
27376RET(100)
27377#endif
27378}
27379
27380// DIVU
27381OPCODE(0x80F8)
27382{
27383 u32 adr, res;
27384 u32 src, dst;
27385
27386 FETCH_SWORD(adr);
27387 PRE_IO
27388 READ_WORD_F(adr, src)
27389 if (src == 0)
27390 {
d0ae0cb4 27391 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27392#ifdef USE_CYCLONE_TIMING_DIV
27393RET(148)
27394#else
27395RET(18)
27396#endif
27397 }
27398 dst = DREGu32((Opcode >> 9) & 7);
27399 {
27400 u32 q, r;
27401
27402 q = dst / src;
27403 r = dst % src;
27404
27405 if (q & 0xFFFF0000)
27406 {
27407 flag_V = M68K_SR_V;
27408#ifdef USE_CYCLONE_TIMING_DIV
27409RET(148)
27410#else
27411 RET(78)
27412#endif
27413 }
27414 q &= 0x0000FFFF;
27415 flag_NotZ = q;
27416 flag_N = q >> 8;
27417 flag_V = flag_C = 0;
27418 res = q | (r << 16);
27419 DREGu32((Opcode >> 9) & 7) = res;
27420 }
27421#ifdef USE_CYCLONE_TIMING_DIV
27422RET(148)
27423#else
27424RET(98)
27425#endif
27426}
27427
27428// DIVU
27429OPCODE(0x80F9)
27430{
27431 u32 adr, res;
27432 u32 src, dst;
27433
27434 FETCH_LONG(adr);
27435 PRE_IO
27436 READ_WORD_F(adr, src)
27437 if (src == 0)
27438 {
d0ae0cb4 27439 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27440#ifdef USE_CYCLONE_TIMING_DIV
f6aa2456 27441RET(152)
70357ce5 27442#else
27443RET(22)
27444#endif
27445 }
27446 dst = DREGu32((Opcode >> 9) & 7);
27447 {
27448 u32 q, r;
27449
27450 q = dst / src;
27451 r = dst % src;
27452
27453 if (q & 0xFFFF0000)
27454 {
27455 flag_V = M68K_SR_V;
27456#ifdef USE_CYCLONE_TIMING_DIV
f6aa2456 27457RET(152)
70357ce5 27458#else
27459 RET(82)
27460#endif
27461 }
27462 q &= 0x0000FFFF;
27463 flag_NotZ = q;
27464 flag_N = q >> 8;
27465 flag_V = flag_C = 0;
27466 res = q | (r << 16);
27467 DREGu32((Opcode >> 9) & 7) = res;
27468 }
27469#ifdef USE_CYCLONE_TIMING_DIV
f6aa2456 27470RET(152)
70357ce5 27471#else
27472RET(102)
27473#endif
27474}
27475
27476// DIVU
27477OPCODE(0x80FA)
27478{
27479 u32 adr, res;
27480 u32 src, dst;
27481
be26eb23 27482 adr = GET_SWORD + GET_PC;
70357ce5 27483 PC++;
27484 PRE_IO
27485 READ_WORD_F(adr, src)
27486 if (src == 0)
27487 {
d0ae0cb4 27488 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27489#ifdef USE_CYCLONE_TIMING_DIV
27490RET(148)
27491#else
27492RET(18)
27493#endif
27494 }
27495 dst = DREGu32((Opcode >> 9) & 7);
27496 {
27497 u32 q, r;
27498
27499 q = dst / src;
27500 r = dst % src;
27501
27502 if (q & 0xFFFF0000)
27503 {
27504 flag_V = M68K_SR_V;
27505#ifdef USE_CYCLONE_TIMING_DIV
27506RET(148)
27507#else
27508 RET(78)
27509#endif
27510 }
27511 q &= 0x0000FFFF;
27512 flag_NotZ = q;
27513 flag_N = q >> 8;
27514 flag_V = flag_C = 0;
27515 res = q | (r << 16);
27516 DREGu32((Opcode >> 9) & 7) = res;
27517 }
27518#ifdef USE_CYCLONE_TIMING_DIV
27519RET(148)
27520#else
27521RET(98)
27522#endif
27523}
27524
27525// DIVU
27526OPCODE(0x80FB)
27527{
27528 u32 adr, res;
27529 u32 src, dst;
27530
be26eb23 27531 adr = GET_PC;
70357ce5 27532 DECODE_EXT_WORD
27533 PRE_IO
27534 READ_WORD_F(adr, src)
27535 if (src == 0)
27536 {
d0ae0cb4 27537 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27538#ifdef USE_CYCLONE_TIMING_DIV
f6aa2456 27539RET(150)
70357ce5 27540#else
27541RET(20)
27542#endif
27543 }
27544 dst = DREGu32((Opcode >> 9) & 7);
27545 {
27546 u32 q, r;
27547
27548 q = dst / src;
27549 r = dst % src;
27550
27551 if (q & 0xFFFF0000)
27552 {
27553 flag_V = M68K_SR_V;
27554#ifdef USE_CYCLONE_TIMING_DIV
f6aa2456 27555RET(150)
70357ce5 27556#else
27557 RET(80)
27558#endif
27559 }
27560 q &= 0x0000FFFF;
27561 flag_NotZ = q;
27562 flag_N = q >> 8;
27563 flag_V = flag_C = 0;
27564 res = q | (r << 16);
27565 DREGu32((Opcode >> 9) & 7) = res;
27566 }
27567#ifdef USE_CYCLONE_TIMING_DIV
f6aa2456 27568RET(150)
70357ce5 27569#else
27570RET(100)
27571#endif
27572}
27573
27574// DIVU
27575OPCODE(0x80FC)
27576{
27577 u32 adr, res;
27578 u32 src, dst;
27579
27580 FETCH_WORD(src);
27581 if (src == 0)
27582 {
d0ae0cb4 27583 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27584#ifdef USE_CYCLONE_TIMING_DIV
27585RET(144)
27586#else
27587RET(14)
27588#endif
27589 }
27590 dst = DREGu32((Opcode >> 9) & 7);
27591 {
27592 u32 q, r;
27593
27594 q = dst / src;
27595 r = dst % src;
27596
27597 if (q & 0xFFFF0000)
27598 {
27599 flag_V = M68K_SR_V;
27600#ifdef USE_CYCLONE_TIMING_DIV
27601RET(144)
27602#else
27603 RET(74)
27604#endif
27605 }
27606 q &= 0x0000FFFF;
27607 flag_NotZ = q;
27608 flag_N = q >> 8;
27609 flag_V = flag_C = 0;
27610 res = q | (r << 16);
27611 DREGu32((Opcode >> 9) & 7) = res;
27612 }
27613#ifdef USE_CYCLONE_TIMING_DIV
27614RET(144)
27615#else
27616RET(94)
27617#endif
27618}
27619
27620// DIVU
27621OPCODE(0x80DF)
27622{
27623 u32 adr, res;
27624 u32 src, dst;
27625
27626 adr = AREG(7);
27627 AREG(7) += 2;
27628 PRE_IO
27629 READ_WORD_F(adr, src)
27630 if (src == 0)
27631 {
d0ae0cb4 27632 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27633#ifdef USE_CYCLONE_TIMING_DIV
27634RET(144)
27635#else
27636RET(14)
27637#endif
27638 }
27639 dst = DREGu32((Opcode >> 9) & 7);
27640 {
27641 u32 q, r;
27642
27643 q = dst / src;
27644 r = dst % src;
27645
27646 if (q & 0xFFFF0000)
27647 {
27648 flag_V = M68K_SR_V;
27649#ifdef USE_CYCLONE_TIMING_DIV
27650RET(144)
27651#else
27652 RET(74)
27653#endif
27654 }
27655 q &= 0x0000FFFF;
27656 flag_NotZ = q;
27657 flag_N = q >> 8;
27658 flag_V = flag_C = 0;
27659 res = q | (r << 16);
27660 DREGu32((Opcode >> 9) & 7) = res;
27661 }
27662#ifdef USE_CYCLONE_TIMING_DIV
27663RET(144)
27664#else
27665RET(94)
27666#endif
27667}
27668
27669// DIVU
27670OPCODE(0x80E7)
27671{
27672 u32 adr, res;
27673 u32 src, dst;
27674
27675 adr = AREG(7) - 2;
27676 AREG(7) = adr;
27677 PRE_IO
27678 READ_WORD_F(adr, src)
27679 if (src == 0)
27680 {
d0ae0cb4 27681 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27682#ifdef USE_CYCLONE_TIMING_DIV
27683RET(146)
27684#else
27685RET(16)
27686#endif
27687 }
27688 dst = DREGu32((Opcode >> 9) & 7);
27689 {
27690 u32 q, r;
27691
27692 q = dst / src;
27693 r = dst % src;
27694
27695 if (q & 0xFFFF0000)
27696 {
27697 flag_V = M68K_SR_V;
27698#ifdef USE_CYCLONE_TIMING_DIV
27699RET(146)
27700#else
27701 RET(76)
27702#endif
27703 }
27704 q &= 0x0000FFFF;
27705 flag_NotZ = q;
27706 flag_N = q >> 8;
27707 flag_V = flag_C = 0;
27708 res = q | (r << 16);
27709 DREGu32((Opcode >> 9) & 7) = res;
27710 }
27711#ifdef USE_CYCLONE_TIMING_DIV
27712RET(146)
27713#else
27714RET(96)
27715#endif
27716}
27717
27718// DIVS
27719OPCODE(0x81C0)
27720{
27721 u32 adr, res;
27722 u32 src, dst;
27723
27724 src = (s32)DREGs16((Opcode >> 0) & 7);
27725 if (src == 0)
27726 {
d0ae0cb4 27727 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27728#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27729goto end81C0;
70357ce5 27730#endif
27731 RET(10)
27732 }
27733 dst = DREGu32((Opcode >> 9) & 7);
27734 if ((dst == 0x80000000) && (src == (u32)-1))
27735 {
27736 flag_NotZ = flag_N = 0;
27737 flag_V = flag_C = 0;
27738 res = 0;
27739 DREGu32((Opcode >> 9) & 7) = res;
27740#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27741goto end81C0;
70357ce5 27742#endif
27743 RET(50)
27744 }
27745 {
27746 s32 q, r;
27747
27748 q = (s32)dst / (s32)src;
27749 r = (s32)dst % (s32)src;
27750
27751 if ((q > 0x7FFF) || (q < -0x8000))
27752 {
27753 flag_V = M68K_SR_V;
27754#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27755goto end81C0;
70357ce5 27756#endif
27757 RET(80)
27758 }
27759 q &= 0x0000FFFF;
27760 flag_NotZ = q;
27761 flag_N = q >> 8;
27762 flag_V = flag_C = 0;
27763 res = q | (r << 16);
27764 DREGu32((Opcode >> 9) & 7) = res;
27765 }
27766#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27767end81C0: m68kcontext.io_cycle_counter -= 50;
70357ce5 27768#endif
27769RET(108)
27770}
27771
27772// DIVS
27773OPCODE(0x81D0)
27774{
27775 u32 adr, res;
27776 u32 src, dst;
27777
27778 adr = AREG((Opcode >> 0) & 7);
27779 PRE_IO
27780 READSX_WORD_F(adr, src)
27781 if (src == 0)
27782 {
d0ae0cb4 27783 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27784#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27785goto end81D0;
70357ce5 27786#endif
27787 RET(14)
27788 }
27789 dst = DREGu32((Opcode >> 9) & 7);
27790 if ((dst == 0x80000000) && (src == (u32)-1))
27791 {
27792 flag_NotZ = flag_N = 0;
27793 flag_V = flag_C = 0;
27794 res = 0;
27795 DREGu32((Opcode >> 9) & 7) = res;
27796#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27797goto end81D0;
70357ce5 27798#endif
27799 RET(54)
27800 }
27801 {
27802 s32 q, r;
27803
27804 q = (s32)dst / (s32)src;
27805 r = (s32)dst % (s32)src;
27806
27807 if ((q > 0x7FFF) || (q < -0x8000))
27808 {
27809 flag_V = M68K_SR_V;
27810#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27811goto end81D0;
70357ce5 27812#endif
27813 RET(84)
27814 }
27815 q &= 0x0000FFFF;
27816 flag_NotZ = q;
27817 flag_N = q >> 8;
27818 flag_V = flag_C = 0;
27819 res = q | (r << 16);
27820 DREGu32((Opcode >> 9) & 7) = res;
27821 }
27822#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27823end81D0: m68kcontext.io_cycle_counter -= 50;
70357ce5 27824#endif
27825RET(112)
27826}
27827
27828// DIVS
27829OPCODE(0x81D8)
27830{
27831 u32 adr, res;
27832 u32 src, dst;
27833
27834 adr = AREG((Opcode >> 0) & 7);
27835 AREG((Opcode >> 0) & 7) += 2;
27836 PRE_IO
27837 READSX_WORD_F(adr, src)
27838 if (src == 0)
27839 {
d0ae0cb4 27840 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27841#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27842goto end81D8;
70357ce5 27843#endif
27844 RET(14)
27845 }
27846 dst = DREGu32((Opcode >> 9) & 7);
27847 if ((dst == 0x80000000) && (src == (u32)-1))
27848 {
27849 flag_NotZ = flag_N = 0;
27850 flag_V = flag_C = 0;
27851 res = 0;
27852 DREGu32((Opcode >> 9) & 7) = res;
27853#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27854goto end81D8;
70357ce5 27855#endif
27856 RET(54)
27857 }
27858 {
27859 s32 q, r;
27860
27861 q = (s32)dst / (s32)src;
27862 r = (s32)dst % (s32)src;
27863
27864 if ((q > 0x7FFF) || (q < -0x8000))
27865 {
27866 flag_V = M68K_SR_V;
27867#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27868goto end81D8;
70357ce5 27869#endif
27870 RET(84)
27871 }
27872 q &= 0x0000FFFF;
27873 flag_NotZ = q;
27874 flag_N = q >> 8;
27875 flag_V = flag_C = 0;
27876 res = q | (r << 16);
27877 DREGu32((Opcode >> 9) & 7) = res;
27878 }
27879#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27880end81D8: m68kcontext.io_cycle_counter -= 50;
70357ce5 27881#endif
27882RET(112)
27883}
27884
27885// DIVS
27886OPCODE(0x81E0)
27887{
27888 u32 adr, res;
27889 u32 src, dst;
27890
27891 adr = AREG((Opcode >> 0) & 7) - 2;
27892 AREG((Opcode >> 0) & 7) = adr;
27893 PRE_IO
27894 READSX_WORD_F(adr, src)
27895 if (src == 0)
27896 {
d0ae0cb4 27897 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27898#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27899goto end81E0;
70357ce5 27900#endif
27901 RET(16)
27902 }
27903 dst = DREGu32((Opcode >> 9) & 7);
27904 if ((dst == 0x80000000) && (src == (u32)-1))
27905 {
27906 flag_NotZ = flag_N = 0;
27907 flag_V = flag_C = 0;
27908 res = 0;
27909 DREGu32((Opcode >> 9) & 7) = res;
27910#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27911goto end81E0;
70357ce5 27912#endif
27913 RET(56)
27914 }
27915 {
27916 s32 q, r;
27917
27918 q = (s32)dst / (s32)src;
27919 r = (s32)dst % (s32)src;
27920
27921 if ((q > 0x7FFF) || (q < -0x8000))
27922 {
27923 flag_V = M68K_SR_V;
27924#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27925goto end81E0;
70357ce5 27926#endif
27927 RET(86)
27928 }
27929 q &= 0x0000FFFF;
27930 flag_NotZ = q;
27931 flag_N = q >> 8;
27932 flag_V = flag_C = 0;
27933 res = q | (r << 16);
27934 DREGu32((Opcode >> 9) & 7) = res;
27935 }
27936#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27937end81E0: m68kcontext.io_cycle_counter -= 50;
70357ce5 27938#endif
27939RET(114)
27940}
27941
27942// DIVS
27943OPCODE(0x81E8)
27944{
27945 u32 adr, res;
27946 u32 src, dst;
27947
27948 FETCH_SWORD(adr);
27949 adr += AREG((Opcode >> 0) & 7);
27950 PRE_IO
27951 READSX_WORD_F(adr, src)
27952 if (src == 0)
27953 {
d0ae0cb4 27954 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27955#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27956goto end81E8;
70357ce5 27957#endif
27958 RET(18)
27959 }
27960 dst = DREGu32((Opcode >> 9) & 7);
27961 if ((dst == 0x80000000) && (src == (u32)-1))
27962 {
27963 flag_NotZ = flag_N = 0;
27964 flag_V = flag_C = 0;
27965 res = 0;
27966 DREGu32((Opcode >> 9) & 7) = res;
27967#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27968goto end81E8;
70357ce5 27969#endif
27970 RET(58)
27971 }
27972 {
27973 s32 q, r;
27974
27975 q = (s32)dst / (s32)src;
27976 r = (s32)dst % (s32)src;
27977
27978 if ((q > 0x7FFF) || (q < -0x8000))
27979 {
27980 flag_V = M68K_SR_V;
27981#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27982goto end81E8;
70357ce5 27983#endif
27984 RET(88)
27985 }
27986 q &= 0x0000FFFF;
27987 flag_NotZ = q;
27988 flag_N = q >> 8;
27989 flag_V = flag_C = 0;
27990 res = q | (r << 16);
27991 DREGu32((Opcode >> 9) & 7) = res;
27992 }
27993#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27994end81E8: m68kcontext.io_cycle_counter -= 50;
70357ce5 27995#endif
27996RET(116)
27997}
27998
27999// DIVS
28000OPCODE(0x81F0)
28001{
28002 u32 adr, res;
28003 u32 src, dst;
28004
28005 adr = AREG((Opcode >> 0) & 7);
28006 DECODE_EXT_WORD
28007 PRE_IO
28008 READSX_WORD_F(adr, src)
28009 if (src == 0)
28010 {
d0ae0cb4 28011 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28012#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28013goto end81F0;
70357ce5 28014#endif
28015 RET(20)
28016 }
28017 dst = DREGu32((Opcode >> 9) & 7);
28018 if ((dst == 0x80000000) && (src == (u32)-1))
28019 {
28020 flag_NotZ = flag_N = 0;
28021 flag_V = flag_C = 0;
28022 res = 0;
28023 DREGu32((Opcode >> 9) & 7) = res;
28024#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28025goto end81F0;
70357ce5 28026#endif
28027 RET(60)
28028 }
28029 {
28030 s32 q, r;
28031
28032 q = (s32)dst / (s32)src;
28033 r = (s32)dst % (s32)src;
28034
28035 if ((q > 0x7FFF) || (q < -0x8000))
28036 {
28037 flag_V = M68K_SR_V;
28038#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28039goto end81F0;
70357ce5 28040#endif
28041 RET(90)
28042 }
28043 q &= 0x0000FFFF;
28044 flag_NotZ = q;
28045 flag_N = q >> 8;
28046 flag_V = flag_C = 0;
28047 res = q | (r << 16);
28048 DREGu32((Opcode >> 9) & 7) = res;
28049 }
28050#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28051end81F0: m68kcontext.io_cycle_counter -= 50;
70357ce5 28052#endif
28053RET(118)
28054}
28055
28056// DIVS
28057OPCODE(0x81F8)
28058{
28059 u32 adr, res;
28060 u32 src, dst;
28061
28062 FETCH_SWORD(adr);
28063 PRE_IO
28064 READSX_WORD_F(adr, src)
28065 if (src == 0)
28066 {
d0ae0cb4 28067 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28068#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28069goto end81F8;
70357ce5 28070#endif
28071 RET(18)
28072 }
28073 dst = DREGu32((Opcode >> 9) & 7);
28074 if ((dst == 0x80000000) && (src == (u32)-1))
28075 {
28076 flag_NotZ = flag_N = 0;
28077 flag_V = flag_C = 0;
28078 res = 0;
28079 DREGu32((Opcode >> 9) & 7) = res;
28080#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28081goto end81F8;
70357ce5 28082#endif
28083 RET(58)
28084 }
28085 {
28086 s32 q, r;
28087
28088 q = (s32)dst / (s32)src;
28089 r = (s32)dst % (s32)src;
28090
28091 if ((q > 0x7FFF) || (q < -0x8000))
28092 {
28093 flag_V = M68K_SR_V;
28094#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28095goto end81F8;
70357ce5 28096#endif
28097 RET(88)
28098 }
28099 q &= 0x0000FFFF;
28100 flag_NotZ = q;
28101 flag_N = q >> 8;
28102 flag_V = flag_C = 0;
28103 res = q | (r << 16);
28104 DREGu32((Opcode >> 9) & 7) = res;
28105 }
28106#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28107end81F8: m68kcontext.io_cycle_counter -= 50;
70357ce5 28108#endif
28109RET(116)
28110}
28111
28112// DIVS
28113OPCODE(0x81F9)
28114{
28115 u32 adr, res;
28116 u32 src, dst;
28117
28118 FETCH_LONG(adr);
28119 PRE_IO
28120 READSX_WORD_F(adr, src)
28121 if (src == 0)
28122 {
d0ae0cb4 28123 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28124#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28125goto end81F9;
70357ce5 28126#endif
28127 RET(22)
28128 }
28129 dst = DREGu32((Opcode >> 9) & 7);
28130 if ((dst == 0x80000000) && (src == (u32)-1))
28131 {
28132 flag_NotZ = flag_N = 0;
28133 flag_V = flag_C = 0;
28134 res = 0;
28135 DREGu32((Opcode >> 9) & 7) = res;
28136#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28137goto end81F9;
70357ce5 28138#endif
28139 RET(62)
28140 }
28141 {
28142 s32 q, r;
28143
28144 q = (s32)dst / (s32)src;
28145 r = (s32)dst % (s32)src;
28146
28147 if ((q > 0x7FFF) || (q < -0x8000))
28148 {
28149 flag_V = M68K_SR_V;
28150#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28151goto end81F9;
70357ce5 28152#endif
28153 RET(92)
28154 }
28155 q &= 0x0000FFFF;
28156 flag_NotZ = q;
28157 flag_N = q >> 8;
28158 flag_V = flag_C = 0;
28159 res = q | (r << 16);
28160 DREGu32((Opcode >> 9) & 7) = res;
28161 }
28162#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28163end81F9: m68kcontext.io_cycle_counter -= 50;
70357ce5 28164#endif
28165RET(120)
28166}
28167
28168// DIVS
28169OPCODE(0x81FA)
28170{
28171 u32 adr, res;
28172 u32 src, dst;
28173
be26eb23 28174 adr = GET_SWORD + GET_PC;
70357ce5 28175 PC++;
28176 PRE_IO
28177 READSX_WORD_F(adr, src)
28178 if (src == 0)
28179 {
d0ae0cb4 28180 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28181#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28182goto end81FA;
70357ce5 28183#endif
28184 RET(18)
28185 }
28186 dst = DREGu32((Opcode >> 9) & 7);
28187 if ((dst == 0x80000000) && (src == (u32)-1))
28188 {
28189 flag_NotZ = flag_N = 0;
28190 flag_V = flag_C = 0;
28191 res = 0;
28192 DREGu32((Opcode >> 9) & 7) = res;
28193#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28194goto end81FA;
70357ce5 28195#endif
28196 RET(58)
28197 }
28198 {
28199 s32 q, r;
28200
28201 q = (s32)dst / (s32)src;
28202 r = (s32)dst % (s32)src;
28203
28204 if ((q > 0x7FFF) || (q < -0x8000))
28205 {
28206 flag_V = M68K_SR_V;
28207#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28208goto end81FA;
70357ce5 28209#endif
28210 RET(88)
28211 }
28212 q &= 0x0000FFFF;
28213 flag_NotZ = q;
28214 flag_N = q >> 8;
28215 flag_V = flag_C = 0;
28216 res = q | (r << 16);
28217 DREGu32((Opcode >> 9) & 7) = res;
28218 }
28219#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28220end81FA: m68kcontext.io_cycle_counter -= 50;
70357ce5 28221#endif
28222RET(116)
28223}
28224
28225// DIVS
28226OPCODE(0x81FB)
28227{
28228 u32 adr, res;
28229 u32 src, dst;
28230
be26eb23 28231 adr = GET_PC;
70357ce5 28232 DECODE_EXT_WORD
28233 PRE_IO
28234 READSX_WORD_F(adr, src)
28235 if (src == 0)
28236 {
d0ae0cb4 28237 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28238#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28239goto end81FB;
70357ce5 28240#endif
28241 RET(20)
28242 }
28243 dst = DREGu32((Opcode >> 9) & 7);
28244 if ((dst == 0x80000000) && (src == (u32)-1))
28245 {
28246 flag_NotZ = flag_N = 0;
28247 flag_V = flag_C = 0;
28248 res = 0;
28249 DREGu32((Opcode >> 9) & 7) = res;
28250#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28251goto end81FB;
70357ce5 28252#endif
28253 RET(60)
28254 }
28255 {
28256 s32 q, r;
28257
28258 q = (s32)dst / (s32)src;
28259 r = (s32)dst % (s32)src;
28260
28261 if ((q > 0x7FFF) || (q < -0x8000))
28262 {
28263 flag_V = M68K_SR_V;
28264#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28265goto end81FB;
70357ce5 28266#endif
28267 RET(90)
28268 }
28269 q &= 0x0000FFFF;
28270 flag_NotZ = q;
28271 flag_N = q >> 8;
28272 flag_V = flag_C = 0;
28273 res = q | (r << 16);
28274 DREGu32((Opcode >> 9) & 7) = res;
28275 }
28276#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28277end81FB: m68kcontext.io_cycle_counter -= 50;
70357ce5 28278#endif
28279RET(118)
28280}
28281
28282// DIVS
28283OPCODE(0x81FC)
28284{
28285 u32 adr, res;
28286 u32 src, dst;
28287
28288 FETCH_SWORD(src);
28289 if (src == 0)
28290 {
d0ae0cb4 28291 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28292#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28293goto end81FC;
70357ce5 28294#endif
28295 RET(14)
28296 }
28297 dst = DREGu32((Opcode >> 9) & 7);
28298 if ((dst == 0x80000000) && (src == (u32)-1))
28299 {
28300 flag_NotZ = flag_N = 0;
28301 flag_V = flag_C = 0;
28302 res = 0;
28303 DREGu32((Opcode >> 9) & 7) = res;
28304#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28305goto end81FC;
70357ce5 28306#endif
28307 RET(54)
28308 }
28309 {
28310 s32 q, r;
28311
28312 q = (s32)dst / (s32)src;
28313 r = (s32)dst % (s32)src;
28314
28315 if ((q > 0x7FFF) || (q < -0x8000))
28316 {
28317 flag_V = M68K_SR_V;
28318#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28319goto end81FC;
70357ce5 28320#endif
28321 RET(84)
28322 }
28323 q &= 0x0000FFFF;
28324 flag_NotZ = q;
28325 flag_N = q >> 8;
28326 flag_V = flag_C = 0;
28327 res = q | (r << 16);
28328 DREGu32((Opcode >> 9) & 7) = res;
28329 }
28330#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28331end81FC: m68kcontext.io_cycle_counter -= 50;
70357ce5 28332#endif
28333RET(112)
28334}
28335
28336// DIVS
28337OPCODE(0x81DF)
28338{
28339 u32 adr, res;
28340 u32 src, dst;
28341
28342 adr = AREG(7);
28343 AREG(7) += 2;
28344 PRE_IO
28345 READSX_WORD_F(adr, src)
28346 if (src == 0)
28347 {
d0ae0cb4 28348 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28349#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28350goto end81DF;
70357ce5 28351#endif
28352 RET(14)
28353 }
28354 dst = DREGu32((Opcode >> 9) & 7);
28355 if ((dst == 0x80000000) && (src == (u32)-1))
28356 {
28357 flag_NotZ = flag_N = 0;
28358 flag_V = flag_C = 0;
28359 res = 0;
28360 DREGu32((Opcode >> 9) & 7) = res;
28361#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28362goto end81DF;
70357ce5 28363#endif
28364 RET(54)
28365 }
28366 {
28367 s32 q, r;
28368
28369 q = (s32)dst / (s32)src;
28370 r = (s32)dst % (s32)src;
28371
28372 if ((q > 0x7FFF) || (q < -0x8000))
28373 {
28374 flag_V = M68K_SR_V;
28375#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28376goto end81DF;
70357ce5 28377#endif
28378 RET(84)
28379 }
28380 q &= 0x0000FFFF;
28381 flag_NotZ = q;
28382 flag_N = q >> 8;
28383 flag_V = flag_C = 0;
28384 res = q | (r << 16);
28385 DREGu32((Opcode >> 9) & 7) = res;
28386 }
28387#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28388end81DF: m68kcontext.io_cycle_counter -= 50;
70357ce5 28389#endif
28390RET(112)
28391}
28392
28393// DIVS
28394OPCODE(0x81E7)
28395{
28396 u32 adr, res;
28397 u32 src, dst;
28398
28399 adr = AREG(7) - 2;
28400 AREG(7) = adr;
28401 PRE_IO
28402 READSX_WORD_F(adr, src)
28403 if (src == 0)
28404 {
d0ae0cb4 28405 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28406#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28407goto end81E7;
70357ce5 28408#endif
28409 RET(16)
28410 }
28411 dst = DREGu32((Opcode >> 9) & 7);
28412 if ((dst == 0x80000000) && (src == (u32)-1))
28413 {
28414 flag_NotZ = flag_N = 0;
28415 flag_V = flag_C = 0;
28416 res = 0;
28417 DREGu32((Opcode >> 9) & 7) = res;
28418#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28419goto end81E7;
70357ce5 28420#endif
28421 RET(56)
28422 }
28423 {
28424 s32 q, r;
28425
28426 q = (s32)dst / (s32)src;
28427 r = (s32)dst % (s32)src;
28428
28429 if ((q > 0x7FFF) || (q < -0x8000))
28430 {
28431 flag_V = M68K_SR_V;
28432#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28433goto end81E7;
70357ce5 28434#endif
28435 RET(86)
28436 }
28437 q &= 0x0000FFFF;
28438 flag_NotZ = q;
28439 flag_N = q >> 8;
28440 flag_V = flag_C = 0;
28441 res = q | (r << 16);
28442 DREGu32((Opcode >> 9) & 7) = res;
28443 }
28444#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28445end81E7: m68kcontext.io_cycle_counter -= 50;
70357ce5 28446#endif
28447RET(114)
28448}
28449
28450// SUBaD
28451OPCODE(0x9000)
28452{
28453 u32 adr, res;
28454 u32 src, dst;
28455
28456 src = DREGu8((Opcode >> 0) & 7);
28457 dst = DREGu8((Opcode >> 9) & 7);
28458 res = dst - src;
28459 flag_N = flag_X = flag_C = res;
28460 flag_V = (src ^ dst) & (res ^ dst);
28461 flag_NotZ = res & 0xFF;
28462 DREGu8((Opcode >> 9) & 7) = res;
28463RET(4)
28464}
28465
28466// SUBaD
03e4f2a3 28467#if 0
70357ce5 28468OPCODE(0x9008)
28469{
28470 u32 adr, res;
28471 u32 src, dst;
28472
28473 // can't read byte from Ax registers !
28474 m68kcontext.execinfo |= M68K_FAULTED;
28475 m68kcontext.io_cycle_counter = 0;
28476/*
28477 goto famec_Exec_End;
28478 dst = DREGu8((Opcode >> 9) & 7);
28479 res = dst - src;
28480 flag_N = flag_X = flag_C = res;
28481 flag_V = (src ^ dst) & (res ^ dst);
28482 flag_NotZ = res & 0xFF;
28483 DREGu8((Opcode >> 9) & 7) = res;
28484*/
28485RET(4)
28486}
03e4f2a3 28487#endif
70357ce5 28488
28489// SUBaD
28490OPCODE(0x9010)
28491{
28492 u32 adr, res;
28493 u32 src, dst;
28494
28495 adr = AREG((Opcode >> 0) & 7);
28496 PRE_IO
28497 READ_BYTE_F(adr, src)
28498 dst = DREGu8((Opcode >> 9) & 7);
28499 res = dst - src;
28500 flag_N = flag_X = flag_C = res;
28501 flag_V = (src ^ dst) & (res ^ dst);
28502 flag_NotZ = res & 0xFF;
28503 DREGu8((Opcode >> 9) & 7) = res;
28504 POST_IO
28505RET(8)
28506}
28507
28508// SUBaD
28509OPCODE(0x9018)
28510{
28511 u32 adr, res;
28512 u32 src, dst;
28513
28514 adr = AREG((Opcode >> 0) & 7);
28515 AREG((Opcode >> 0) & 7) += 1;
28516 PRE_IO
28517 READ_BYTE_F(adr, src)
28518 dst = DREGu8((Opcode >> 9) & 7);
28519 res = dst - src;
28520 flag_N = flag_X = flag_C = res;
28521 flag_V = (src ^ dst) & (res ^ dst);
28522 flag_NotZ = res & 0xFF;
28523 DREGu8((Opcode >> 9) & 7) = res;
28524 POST_IO
28525RET(8)
28526}
28527
28528// SUBaD
28529OPCODE(0x9020)
28530{
28531 u32 adr, res;
28532 u32 src, dst;
28533
28534 adr = AREG((Opcode >> 0) & 7) - 1;
28535 AREG((Opcode >> 0) & 7) = adr;
28536 PRE_IO
28537 READ_BYTE_F(adr, src)
28538 dst = DREGu8((Opcode >> 9) & 7);
28539 res = dst - src;
28540 flag_N = flag_X = flag_C = res;
28541 flag_V = (src ^ dst) & (res ^ dst);
28542 flag_NotZ = res & 0xFF;
28543 DREGu8((Opcode >> 9) & 7) = res;
28544 POST_IO
28545RET(10)
28546}
28547
28548// SUBaD
28549OPCODE(0x9028)
28550{
28551 u32 adr, res;
28552 u32 src, dst;
28553
28554 FETCH_SWORD(adr);
28555 adr += AREG((Opcode >> 0) & 7);
28556 PRE_IO
28557 READ_BYTE_F(adr, src)
28558 dst = DREGu8((Opcode >> 9) & 7);
28559 res = dst - src;
28560 flag_N = flag_X = flag_C = res;
28561 flag_V = (src ^ dst) & (res ^ dst);
28562 flag_NotZ = res & 0xFF;
28563 DREGu8((Opcode >> 9) & 7) = res;
28564 POST_IO
28565RET(12)
28566}
28567
28568// SUBaD
28569OPCODE(0x9030)
28570{
28571 u32 adr, res;
28572 u32 src, dst;
28573
28574 adr = AREG((Opcode >> 0) & 7);
28575 DECODE_EXT_WORD
28576 PRE_IO
28577 READ_BYTE_F(adr, src)
28578 dst = DREGu8((Opcode >> 9) & 7);
28579 res = dst - src;
28580 flag_N = flag_X = flag_C = res;
28581 flag_V = (src ^ dst) & (res ^ dst);
28582 flag_NotZ = res & 0xFF;
28583 DREGu8((Opcode >> 9) & 7) = res;
28584 POST_IO
28585RET(14)
28586}
28587
28588// SUBaD
28589OPCODE(0x9038)
28590{
28591 u32 adr, res;
28592 u32 src, dst;
28593
28594 FETCH_SWORD(adr);
28595 PRE_IO
28596 READ_BYTE_F(adr, src)
28597 dst = DREGu8((Opcode >> 9) & 7);
28598 res = dst - src;
28599 flag_N = flag_X = flag_C = res;
28600 flag_V = (src ^ dst) & (res ^ dst);
28601 flag_NotZ = res & 0xFF;
28602 DREGu8((Opcode >> 9) & 7) = res;
28603 POST_IO
28604RET(12)
28605}
28606
28607// SUBaD
28608OPCODE(0x9039)
28609{
28610 u32 adr, res;
28611 u32 src, dst;
28612
28613 FETCH_LONG(adr);
28614 PRE_IO
28615 READ_BYTE_F(adr, src)
28616 dst = DREGu8((Opcode >> 9) & 7);
28617 res = dst - src;
28618 flag_N = flag_X = flag_C = res;
28619 flag_V = (src ^ dst) & (res ^ dst);
28620 flag_NotZ = res & 0xFF;
28621 DREGu8((Opcode >> 9) & 7) = res;
28622 POST_IO
28623RET(16)
28624}
28625
28626// SUBaD
28627OPCODE(0x903A)
28628{
28629 u32 adr, res;
28630 u32 src, dst;
28631
be26eb23 28632 adr = GET_SWORD + GET_PC;
70357ce5 28633 PC++;
28634 PRE_IO
28635 READ_BYTE_F(adr, src)
28636 dst = DREGu8((Opcode >> 9) & 7);
28637 res = dst - src;
28638 flag_N = flag_X = flag_C = res;
28639 flag_V = (src ^ dst) & (res ^ dst);
28640 flag_NotZ = res & 0xFF;
28641 DREGu8((Opcode >> 9) & 7) = res;
28642 POST_IO
28643RET(12)
28644}
28645
28646// SUBaD
28647OPCODE(0x903B)
28648{
28649 u32 adr, res;
28650 u32 src, dst;
28651
be26eb23 28652 adr = GET_PC;
70357ce5 28653 DECODE_EXT_WORD
28654 PRE_IO
28655 READ_BYTE_F(adr, src)
28656 dst = DREGu8((Opcode >> 9) & 7);
28657 res = dst - src;
28658 flag_N = flag_X = flag_C = res;
28659 flag_V = (src ^ dst) & (res ^ dst);
28660 flag_NotZ = res & 0xFF;
28661 DREGu8((Opcode >> 9) & 7) = res;
28662 POST_IO
28663RET(14)
28664}
28665
28666// SUBaD
28667OPCODE(0x903C)
28668{
28669 u32 adr, res;
28670 u32 src, dst;
28671
28672 FETCH_BYTE(src);
28673 dst = DREGu8((Opcode >> 9) & 7);
28674 res = dst - src;
28675 flag_N = flag_X = flag_C = res;
28676 flag_V = (src ^ dst) & (res ^ dst);
28677 flag_NotZ = res & 0xFF;
28678 DREGu8((Opcode >> 9) & 7) = res;
28679RET(8)
28680}
28681
28682// SUBaD
28683OPCODE(0x901F)
28684{
28685 u32 adr, res;
28686 u32 src, dst;
28687
28688 adr = AREG(7);
28689 AREG(7) += 2;
28690 PRE_IO
28691 READ_BYTE_F(adr, src)
28692 dst = DREGu8((Opcode >> 9) & 7);
28693 res = dst - src;
28694 flag_N = flag_X = flag_C = res;
28695 flag_V = (src ^ dst) & (res ^ dst);
28696 flag_NotZ = res & 0xFF;
28697 DREGu8((Opcode >> 9) & 7) = res;
28698 POST_IO
28699RET(8)
28700}
28701
28702// SUBaD
28703OPCODE(0x9027)
28704{
28705 u32 adr, res;
28706 u32 src, dst;
28707
28708 adr = AREG(7) - 2;
28709 AREG(7) = adr;
28710 PRE_IO
28711 READ_BYTE_F(adr, src)
28712 dst = DREGu8((Opcode >> 9) & 7);
28713 res = dst - src;
28714 flag_N = flag_X = flag_C = res;
28715 flag_V = (src ^ dst) & (res ^ dst);
28716 flag_NotZ = res & 0xFF;
28717 DREGu8((Opcode >> 9) & 7) = res;
28718 POST_IO
28719RET(10)
28720}
28721
28722// SUBaD
28723OPCODE(0x9040)
28724{
28725 u32 adr, res;
28726 u32 src, dst;
28727
28728 src = DREGu16((Opcode >> 0) & 7);
28729 dst = DREGu16((Opcode >> 9) & 7);
28730 res = dst - src;
28731 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28732 flag_N = flag_X = flag_C = res >> 8;
28733 flag_NotZ = res & 0xFFFF;
28734 DREGu16((Opcode >> 9) & 7) = res;
28735RET(4)
28736}
28737
28738// SUBaD
28739OPCODE(0x9048)
28740{
28741 u32 adr, res;
28742 u32 src, dst;
28743
28744 src = AREGu16((Opcode >> 0) & 7);
28745 dst = DREGu16((Opcode >> 9) & 7);
28746 res = dst - src;
28747 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28748 flag_N = flag_X = flag_C = res >> 8;
28749 flag_NotZ = res & 0xFFFF;
28750 DREGu16((Opcode >> 9) & 7) = res;
28751RET(4)
28752}
28753
28754// SUBaD
28755OPCODE(0x9050)
28756{
28757 u32 adr, res;
28758 u32 src, dst;
28759
28760 adr = AREG((Opcode >> 0) & 7);
28761 PRE_IO
28762 READ_WORD_F(adr, src)
28763 dst = DREGu16((Opcode >> 9) & 7);
28764 res = dst - src;
28765 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28766 flag_N = flag_X = flag_C = res >> 8;
28767 flag_NotZ = res & 0xFFFF;
28768 DREGu16((Opcode >> 9) & 7) = res;
28769 POST_IO
28770RET(8)
28771}
28772
28773// SUBaD
28774OPCODE(0x9058)
28775{
28776 u32 adr, res;
28777 u32 src, dst;
28778
28779 adr = AREG((Opcode >> 0) & 7);
28780 AREG((Opcode >> 0) & 7) += 2;
28781 PRE_IO
28782 READ_WORD_F(adr, src)
28783 dst = DREGu16((Opcode >> 9) & 7);
28784 res = dst - src;
28785 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28786 flag_N = flag_X = flag_C = res >> 8;
28787 flag_NotZ = res & 0xFFFF;
28788 DREGu16((Opcode >> 9) & 7) = res;
28789 POST_IO
28790RET(8)
28791}
28792
28793// SUBaD
28794OPCODE(0x9060)
28795{
28796 u32 adr, res;
28797 u32 src, dst;
28798
28799 adr = AREG((Opcode >> 0) & 7) - 2;
28800 AREG((Opcode >> 0) & 7) = adr;
28801 PRE_IO
28802 READ_WORD_F(adr, src)
28803 dst = DREGu16((Opcode >> 9) & 7);
28804 res = dst - src;
28805 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28806 flag_N = flag_X = flag_C = res >> 8;
28807 flag_NotZ = res & 0xFFFF;
28808 DREGu16((Opcode >> 9) & 7) = res;
28809 POST_IO
28810RET(10)
28811}
28812
28813// SUBaD
28814OPCODE(0x9068)
28815{
28816 u32 adr, res;
28817 u32 src, dst;
28818
28819 FETCH_SWORD(adr);
28820 adr += AREG((Opcode >> 0) & 7);
28821 PRE_IO
28822 READ_WORD_F(adr, src)
28823 dst = DREGu16((Opcode >> 9) & 7);
28824 res = dst - src;
28825 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28826 flag_N = flag_X = flag_C = res >> 8;
28827 flag_NotZ = res & 0xFFFF;
28828 DREGu16((Opcode >> 9) & 7) = res;
28829 POST_IO
28830RET(12)
28831}
28832
28833// SUBaD
28834OPCODE(0x9070)
28835{
28836 u32 adr, res;
28837 u32 src, dst;
28838
28839 adr = AREG((Opcode >> 0) & 7);
28840 DECODE_EXT_WORD
28841 PRE_IO
28842 READ_WORD_F(adr, src)
28843 dst = DREGu16((Opcode >> 9) & 7);
28844 res = dst - src;
28845 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28846 flag_N = flag_X = flag_C = res >> 8;
28847 flag_NotZ = res & 0xFFFF;
28848 DREGu16((Opcode >> 9) & 7) = res;
28849 POST_IO
28850RET(14)
28851}
28852
28853// SUBaD
28854OPCODE(0x9078)
28855{
28856 u32 adr, res;
28857 u32 src, dst;
28858
28859 FETCH_SWORD(adr);
28860 PRE_IO
28861 READ_WORD_F(adr, src)
28862 dst = DREGu16((Opcode >> 9) & 7);
28863 res = dst - src;
28864 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28865 flag_N = flag_X = flag_C = res >> 8;
28866 flag_NotZ = res & 0xFFFF;
28867 DREGu16((Opcode >> 9) & 7) = res;
28868 POST_IO
28869RET(12)
28870}
28871
28872// SUBaD
28873OPCODE(0x9079)
28874{
28875 u32 adr, res;
28876 u32 src, dst;
28877
28878 FETCH_LONG(adr);
28879 PRE_IO
28880 READ_WORD_F(adr, src)
28881 dst = DREGu16((Opcode >> 9) & 7);
28882 res = dst - src;
28883 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28884 flag_N = flag_X = flag_C = res >> 8;
28885 flag_NotZ = res & 0xFFFF;
28886 DREGu16((Opcode >> 9) & 7) = res;
28887 POST_IO
28888RET(16)
28889}
28890
28891// SUBaD
28892OPCODE(0x907A)
28893{
28894 u32 adr, res;
28895 u32 src, dst;
28896
be26eb23 28897 adr = GET_SWORD + GET_PC;
70357ce5 28898 PC++;
28899 PRE_IO
28900 READ_WORD_F(adr, src)
28901 dst = DREGu16((Opcode >> 9) & 7);
28902 res = dst - src;
28903 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28904 flag_N = flag_X = flag_C = res >> 8;
28905 flag_NotZ = res & 0xFFFF;
28906 DREGu16((Opcode >> 9) & 7) = res;
28907 POST_IO
28908RET(12)
28909}
28910
28911// SUBaD
28912OPCODE(0x907B)
28913{
28914 u32 adr, res;
28915 u32 src, dst;
28916
be26eb23 28917 adr = GET_PC;
70357ce5 28918 DECODE_EXT_WORD
28919 PRE_IO
28920 READ_WORD_F(adr, src)
28921 dst = DREGu16((Opcode >> 9) & 7);
28922 res = dst - src;
28923 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28924 flag_N = flag_X = flag_C = res >> 8;
28925 flag_NotZ = res & 0xFFFF;
28926 DREGu16((Opcode >> 9) & 7) = res;
28927 POST_IO
28928RET(14)
28929}
28930
28931// SUBaD
28932OPCODE(0x907C)
28933{
28934 u32 adr, res;
28935 u32 src, dst;
28936
28937 FETCH_WORD(src);
28938 dst = DREGu16((Opcode >> 9) & 7);
28939 res = dst - src;
28940 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28941 flag_N = flag_X = flag_C = res >> 8;
28942 flag_NotZ = res & 0xFFFF;
28943 DREGu16((Opcode >> 9) & 7) = res;
28944RET(8)
28945}
28946
28947// SUBaD
28948OPCODE(0x905F)
28949{
28950 u32 adr, res;
28951 u32 src, dst;
28952
28953 adr = AREG(7);
28954 AREG(7) += 2;
28955 PRE_IO
28956 READ_WORD_F(adr, src)
28957 dst = DREGu16((Opcode >> 9) & 7);
28958 res = dst - src;
28959 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28960 flag_N = flag_X = flag_C = res >> 8;
28961 flag_NotZ = res & 0xFFFF;
28962 DREGu16((Opcode >> 9) & 7) = res;
28963 POST_IO
28964RET(8)
28965}
28966
28967// SUBaD
28968OPCODE(0x9067)
28969{
28970 u32 adr, res;
28971 u32 src, dst;
28972
28973 adr = AREG(7) - 2;
28974 AREG(7) = adr;
28975 PRE_IO
28976 READ_WORD_F(adr, src)
28977 dst = DREGu16((Opcode >> 9) & 7);
28978 res = dst - src;
28979 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28980 flag_N = flag_X = flag_C = res >> 8;
28981 flag_NotZ = res & 0xFFFF;
28982 DREGu16((Opcode >> 9) & 7) = res;
28983 POST_IO
28984RET(10)
28985}
28986
28987// SUBaD
28988OPCODE(0x9080)
28989{
28990 u32 adr, res;
28991 u32 src, dst;
28992
28993 src = DREGu32((Opcode >> 0) & 7);
28994 dst = DREGu32((Opcode >> 9) & 7);
28995 res = dst - src;
28996 flag_NotZ = res;
28997 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
28998 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
28999 flag_N = res >> 24;
29000 DREGu32((Opcode >> 9) & 7) = res;
29001RET(8)
29002}
29003
29004// SUBaD
29005OPCODE(0x9088)
29006{
29007 u32 adr, res;
29008 u32 src, dst;
29009
29010 src = AREGu32((Opcode >> 0) & 7);
29011 dst = DREGu32((Opcode >> 9) & 7);
29012 res = dst - src;
29013 flag_NotZ = res;
29014 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29015 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29016 flag_N = res >> 24;
29017 DREGu32((Opcode >> 9) & 7) = res;
29018RET(8)
29019}
29020
29021// SUBaD
29022OPCODE(0x9090)
29023{
29024 u32 adr, res;
29025 u32 src, dst;
29026
29027 adr = AREG((Opcode >> 0) & 7);
29028 PRE_IO
29029 READ_LONG_F(adr, src)
29030 dst = DREGu32((Opcode >> 9) & 7);
29031 res = dst - src;
29032 flag_NotZ = res;
29033 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29034 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29035 flag_N = res >> 24;
29036 DREGu32((Opcode >> 9) & 7) = res;
29037 POST_IO
29038RET(14)
29039}
29040
29041// SUBaD
29042OPCODE(0x9098)
29043{
29044 u32 adr, res;
29045 u32 src, dst;
29046
29047 adr = AREG((Opcode >> 0) & 7);
29048 AREG((Opcode >> 0) & 7) += 4;
29049 PRE_IO
29050 READ_LONG_F(adr, src)
29051 dst = DREGu32((Opcode >> 9) & 7);
29052 res = dst - src;
29053 flag_NotZ = res;
29054 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29055 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29056 flag_N = res >> 24;
29057 DREGu32((Opcode >> 9) & 7) = res;
29058 POST_IO
29059RET(14)
29060}
29061
29062// SUBaD
29063OPCODE(0x90A0)
29064{
29065 u32 adr, res;
29066 u32 src, dst;
29067
29068 adr = AREG((Opcode >> 0) & 7) - 4;
29069 AREG((Opcode >> 0) & 7) = adr;
29070 PRE_IO
29071 READ_LONG_F(adr, src)
29072 dst = DREGu32((Opcode >> 9) & 7);
29073 res = dst - src;
29074 flag_NotZ = res;
29075 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29076 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29077 flag_N = res >> 24;
29078 DREGu32((Opcode >> 9) & 7) = res;
29079 POST_IO
29080RET(16)
29081}
29082
29083// SUBaD
29084OPCODE(0x90A8)
29085{
29086 u32 adr, res;
29087 u32 src, dst;
29088
29089 FETCH_SWORD(adr);
29090 adr += AREG((Opcode >> 0) & 7);
29091 PRE_IO
29092 READ_LONG_F(adr, src)
29093 dst = DREGu32((Opcode >> 9) & 7);
29094 res = dst - src;
29095 flag_NotZ = res;
29096 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29097 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29098 flag_N = res >> 24;
29099 DREGu32((Opcode >> 9) & 7) = res;
29100 POST_IO
29101RET(18)
29102}
29103
29104// SUBaD
29105OPCODE(0x90B0)
29106{
29107 u32 adr, res;
29108 u32 src, dst;
29109
29110 adr = AREG((Opcode >> 0) & 7);
29111 DECODE_EXT_WORD
29112 PRE_IO
29113 READ_LONG_F(adr, src)
29114 dst = DREGu32((Opcode >> 9) & 7);
29115 res = dst - src;
29116 flag_NotZ = res;
29117 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29118 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29119 flag_N = res >> 24;
29120 DREGu32((Opcode >> 9) & 7) = res;
29121 POST_IO
29122RET(20)
29123}
29124
29125// SUBaD
29126OPCODE(0x90B8)
29127{
29128 u32 adr, res;
29129 u32 src, dst;
29130
29131 FETCH_SWORD(adr);
29132 PRE_IO
29133 READ_LONG_F(adr, src)
29134 dst = DREGu32((Opcode >> 9) & 7);
29135 res = dst - src;
29136 flag_NotZ = res;
29137 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29138 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29139 flag_N = res >> 24;
29140 DREGu32((Opcode >> 9) & 7) = res;
29141 POST_IO
29142RET(18)
29143}
29144
29145// SUBaD
29146OPCODE(0x90B9)
29147{
29148 u32 adr, res;
29149 u32 src, dst;
29150
29151 FETCH_LONG(adr);
29152 PRE_IO
29153 READ_LONG_F(adr, src)
29154 dst = DREGu32((Opcode >> 9) & 7);
29155 res = dst - src;
29156 flag_NotZ = res;
29157 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29158 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29159 flag_N = res >> 24;
29160 DREGu32((Opcode >> 9) & 7) = res;
29161 POST_IO
29162RET(22)
29163}
29164
29165// SUBaD
29166OPCODE(0x90BA)
29167{
29168 u32 adr, res;
29169 u32 src, dst;
29170
be26eb23 29171 adr = GET_SWORD + GET_PC;
70357ce5 29172 PC++;
29173 PRE_IO
29174 READ_LONG_F(adr, src)
29175 dst = DREGu32((Opcode >> 9) & 7);
29176 res = dst - src;
29177 flag_NotZ = res;
29178 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29179 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29180 flag_N = res >> 24;
29181 DREGu32((Opcode >> 9) & 7) = res;
29182 POST_IO
29183RET(18)
29184}
29185
29186// SUBaD
29187OPCODE(0x90BB)
29188{
29189 u32 adr, res;
29190 u32 src, dst;
29191
be26eb23 29192 adr = GET_PC;
70357ce5 29193 DECODE_EXT_WORD
29194 PRE_IO
29195 READ_LONG_F(adr, src)
29196 dst = DREGu32((Opcode >> 9) & 7);
29197 res = dst - src;
29198 flag_NotZ = res;
29199 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29200 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29201 flag_N = res >> 24;
29202 DREGu32((Opcode >> 9) & 7) = res;
29203 POST_IO
29204RET(20)
29205}
29206
29207// SUBaD
29208OPCODE(0x90BC)
29209{
29210 u32 adr, res;
29211 u32 src, dst;
29212
29213 FETCH_LONG(src);
29214 dst = DREGu32((Opcode >> 9) & 7);
29215 res = dst - src;
29216 flag_NotZ = res;
29217 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29218 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29219 flag_N = res >> 24;
29220 DREGu32((Opcode >> 9) & 7) = res;
29221RET(16)
29222}
29223
29224// SUBaD
29225OPCODE(0x909F)
29226{
29227 u32 adr, res;
29228 u32 src, dst;
29229
29230 adr = AREG(7);
29231 AREG(7) += 4;
29232 PRE_IO
29233 READ_LONG_F(adr, src)
29234 dst = DREGu32((Opcode >> 9) & 7);
29235 res = dst - src;
29236 flag_NotZ = res;
29237 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29238 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29239 flag_N = res >> 24;
29240 DREGu32((Opcode >> 9) & 7) = res;
29241 POST_IO
29242RET(14)
29243}
29244
29245// SUBaD
29246OPCODE(0x90A7)
29247{
29248 u32 adr, res;
29249 u32 src, dst;
29250
29251 adr = AREG(7) - 4;
29252 AREG(7) = adr;
29253 PRE_IO
29254 READ_LONG_F(adr, src)
29255 dst = DREGu32((Opcode >> 9) & 7);
29256 res = dst - src;
29257 flag_NotZ = res;
29258 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29259 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29260 flag_N = res >> 24;
29261 DREGu32((Opcode >> 9) & 7) = res;
29262 POST_IO
29263RET(16)
29264}
29265
29266// SUBDa
29267OPCODE(0x9110)
29268{
29269 u32 adr, res;
29270 u32 src, dst;
29271
29272 src = DREGu8((Opcode >> 9) & 7);
29273 adr = AREG((Opcode >> 0) & 7);
29274 PRE_IO
29275 READ_BYTE_F(adr, dst)
29276 res = dst - src;
29277 flag_N = flag_X = flag_C = res;
29278 flag_V = (src ^ dst) & (res ^ dst);
29279 flag_NotZ = res & 0xFF;
29280 WRITE_BYTE_F(adr, res)
29281 POST_IO
29282RET(12)
29283}
29284
29285// SUBDa
29286OPCODE(0x9118)
29287{
29288 u32 adr, res;
29289 u32 src, dst;
29290
29291 src = DREGu8((Opcode >> 9) & 7);
29292 adr = AREG((Opcode >> 0) & 7);
29293 AREG((Opcode >> 0) & 7) += 1;
29294 PRE_IO
29295 READ_BYTE_F(adr, dst)
29296 res = dst - src;
29297 flag_N = flag_X = flag_C = res;
29298 flag_V = (src ^ dst) & (res ^ dst);
29299 flag_NotZ = res & 0xFF;
29300 WRITE_BYTE_F(adr, res)
29301 POST_IO
29302RET(12)
29303}
29304
29305// SUBDa
29306OPCODE(0x9120)
29307{
29308 u32 adr, res;
29309 u32 src, dst;
29310
29311 src = DREGu8((Opcode >> 9) & 7);
29312 adr = AREG((Opcode >> 0) & 7) - 1;
29313 AREG((Opcode >> 0) & 7) = adr;
29314 PRE_IO
29315 READ_BYTE_F(adr, dst)
29316 res = dst - src;
29317 flag_N = flag_X = flag_C = res;
29318 flag_V = (src ^ dst) & (res ^ dst);
29319 flag_NotZ = res & 0xFF;
29320 WRITE_BYTE_F(adr, res)
29321 POST_IO
29322RET(14)
29323}
29324
29325// SUBDa
29326OPCODE(0x9128)
29327{
29328 u32 adr, res;
29329 u32 src, dst;
29330
29331 src = DREGu8((Opcode >> 9) & 7);
29332 FETCH_SWORD(adr);
29333 adr += AREG((Opcode >> 0) & 7);
29334 PRE_IO
29335 READ_BYTE_F(adr, dst)
29336 res = dst - src;
29337 flag_N = flag_X = flag_C = res;
29338 flag_V = (src ^ dst) & (res ^ dst);
29339 flag_NotZ = res & 0xFF;
29340 WRITE_BYTE_F(adr, res)
29341 POST_IO
29342RET(16)
29343}
29344
29345// SUBDa
29346OPCODE(0x9130)
29347{
29348 u32 adr, res;
29349 u32 src, dst;
29350
29351 src = DREGu8((Opcode >> 9) & 7);
29352 adr = AREG((Opcode >> 0) & 7);
29353 DECODE_EXT_WORD
29354 PRE_IO
29355 READ_BYTE_F(adr, dst)
29356 res = dst - src;
29357 flag_N = flag_X = flag_C = res;
29358 flag_V = (src ^ dst) & (res ^ dst);
29359 flag_NotZ = res & 0xFF;
29360 WRITE_BYTE_F(adr, res)
29361 POST_IO
29362RET(18)
29363}
29364
29365// SUBDa
29366OPCODE(0x9138)
29367{
29368 u32 adr, res;
29369 u32 src, dst;
29370
29371 src = DREGu8((Opcode >> 9) & 7);
29372 FETCH_SWORD(adr);
29373 PRE_IO
29374 READ_BYTE_F(adr, dst)
29375 res = dst - src;
29376 flag_N = flag_X = flag_C = res;
29377 flag_V = (src ^ dst) & (res ^ dst);
29378 flag_NotZ = res & 0xFF;
29379 WRITE_BYTE_F(adr, res)
29380 POST_IO
29381RET(16)
29382}
29383
29384// SUBDa
29385OPCODE(0x9139)
29386{
29387 u32 adr, res;
29388 u32 src, dst;
29389
29390 src = DREGu8((Opcode >> 9) & 7);
29391 FETCH_LONG(adr);
29392 PRE_IO
29393 READ_BYTE_F(adr, dst)
29394 res = dst - src;
29395 flag_N = flag_X = flag_C = res;
29396 flag_V = (src ^ dst) & (res ^ dst);
29397 flag_NotZ = res & 0xFF;
29398 WRITE_BYTE_F(adr, res)
29399 POST_IO
29400RET(20)
29401}
29402
29403// SUBDa
29404OPCODE(0x911F)
29405{
29406 u32 adr, res;
29407 u32 src, dst;
29408
29409 src = DREGu8((Opcode >> 9) & 7);
29410 adr = AREG(7);
29411 AREG(7) += 2;
29412 PRE_IO
29413 READ_BYTE_F(adr, dst)
29414 res = dst - src;
29415 flag_N = flag_X = flag_C = res;
29416 flag_V = (src ^ dst) & (res ^ dst);
29417 flag_NotZ = res & 0xFF;
29418 WRITE_BYTE_F(adr, res)
29419 POST_IO
29420RET(12)
29421}
29422
29423// SUBDa
29424OPCODE(0x9127)
29425{
29426 u32 adr, res;
29427 u32 src, dst;
29428
29429 src = DREGu8((Opcode >> 9) & 7);
29430 adr = AREG(7) - 2;
29431 AREG(7) = adr;
29432 PRE_IO
29433 READ_BYTE_F(adr, dst)
29434 res = dst - src;
29435 flag_N = flag_X = flag_C = res;
29436 flag_V = (src ^ dst) & (res ^ dst);
29437 flag_NotZ = res & 0xFF;
29438 WRITE_BYTE_F(adr, res)
29439 POST_IO
29440RET(14)
29441}
29442
29443// SUBDa
29444OPCODE(0x9150)
29445{
29446 u32 adr, res;
29447 u32 src, dst;
29448
29449 src = DREGu16((Opcode >> 9) & 7);
29450 adr = AREG((Opcode >> 0) & 7);
29451 PRE_IO
29452 READ_WORD_F(adr, dst)
29453 res = dst - src;
29454 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29455 flag_N = flag_X = flag_C = res >> 8;
29456 flag_NotZ = res & 0xFFFF;
29457 WRITE_WORD_F(adr, res)
29458 POST_IO
29459RET(12)
29460}
29461
29462// SUBDa
29463OPCODE(0x9158)
29464{
29465 u32 adr, res;
29466 u32 src, dst;
29467
29468 src = DREGu16((Opcode >> 9) & 7);
29469 adr = AREG((Opcode >> 0) & 7);
29470 AREG((Opcode >> 0) & 7) += 2;
29471 PRE_IO
29472 READ_WORD_F(adr, dst)
29473 res = dst - src;
29474 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29475 flag_N = flag_X = flag_C = res >> 8;
29476 flag_NotZ = res & 0xFFFF;
29477 WRITE_WORD_F(adr, res)
29478 POST_IO
29479RET(12)
29480}
29481
29482// SUBDa
29483OPCODE(0x9160)
29484{
29485 u32 adr, res;
29486 u32 src, dst;
29487
29488 src = DREGu16((Opcode >> 9) & 7);
29489 adr = AREG((Opcode >> 0) & 7) - 2;
29490 AREG((Opcode >> 0) & 7) = adr;
29491 PRE_IO
29492 READ_WORD_F(adr, dst)
29493 res = dst - src;
29494 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29495 flag_N = flag_X = flag_C = res >> 8;
29496 flag_NotZ = res & 0xFFFF;
29497 WRITE_WORD_F(adr, res)
29498 POST_IO
29499RET(14)
29500}
29501
29502// SUBDa
29503OPCODE(0x9168)
29504{
29505 u32 adr, res;
29506 u32 src, dst;
29507
29508 src = DREGu16((Opcode >> 9) & 7);
29509 FETCH_SWORD(adr);
29510 adr += AREG((Opcode >> 0) & 7);
29511 PRE_IO
29512 READ_WORD_F(adr, dst)
29513 res = dst - src;
29514 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29515 flag_N = flag_X = flag_C = res >> 8;
29516 flag_NotZ = res & 0xFFFF;
29517 WRITE_WORD_F(adr, res)
29518 POST_IO
29519RET(16)
29520}
29521
29522// SUBDa
29523OPCODE(0x9170)
29524{
29525 u32 adr, res;
29526 u32 src, dst;
29527
29528 src = DREGu16((Opcode >> 9) & 7);
29529 adr = AREG((Opcode >> 0) & 7);
29530 DECODE_EXT_WORD
29531 PRE_IO
29532 READ_WORD_F(adr, dst)
29533 res = dst - src;
29534 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29535 flag_N = flag_X = flag_C = res >> 8;
29536 flag_NotZ = res & 0xFFFF;
29537 WRITE_WORD_F(adr, res)
29538 POST_IO
29539RET(18)
29540}
29541
29542// SUBDa
29543OPCODE(0x9178)
29544{
29545 u32 adr, res;
29546 u32 src, dst;
29547
29548 src = DREGu16((Opcode >> 9) & 7);
29549 FETCH_SWORD(adr);
29550 PRE_IO
29551 READ_WORD_F(adr, dst)
29552 res = dst - src;
29553 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29554 flag_N = flag_X = flag_C = res >> 8;
29555 flag_NotZ = res & 0xFFFF;
29556 WRITE_WORD_F(adr, res)
29557 POST_IO
29558RET(16)
29559}
29560
29561// SUBDa
29562OPCODE(0x9179)
29563{
29564 u32 adr, res;
29565 u32 src, dst;
29566
29567 src = DREGu16((Opcode >> 9) & 7);
29568 FETCH_LONG(adr);
29569 PRE_IO
29570 READ_WORD_F(adr, dst)
29571 res = dst - src;
29572 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29573 flag_N = flag_X = flag_C = res >> 8;
29574 flag_NotZ = res & 0xFFFF;
29575 WRITE_WORD_F(adr, res)
29576 POST_IO
29577RET(20)
29578}
29579
29580// SUBDa
29581OPCODE(0x915F)
29582{
29583 u32 adr, res;
29584 u32 src, dst;
29585
29586 src = DREGu16((Opcode >> 9) & 7);
29587 adr = AREG(7);
29588 AREG(7) += 2;
29589 PRE_IO
29590 READ_WORD_F(adr, dst)
29591 res = dst - src;
29592 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29593 flag_N = flag_X = flag_C = res >> 8;
29594 flag_NotZ = res & 0xFFFF;
29595 WRITE_WORD_F(adr, res)
29596 POST_IO
29597RET(12)
29598}
29599
29600// SUBDa
29601OPCODE(0x9167)
29602{
29603 u32 adr, res;
29604 u32 src, dst;
29605
29606 src = DREGu16((Opcode >> 9) & 7);
29607 adr = AREG(7) - 2;
29608 AREG(7) = adr;
29609 PRE_IO
29610 READ_WORD_F(adr, dst)
29611 res = dst - src;
29612 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29613 flag_N = flag_X = flag_C = res >> 8;
29614 flag_NotZ = res & 0xFFFF;
29615 WRITE_WORD_F(adr, res)
29616 POST_IO
29617RET(14)
29618}
29619
29620// SUBDa
29621OPCODE(0x9190)
29622{
29623 u32 adr, res;
29624 u32 src, dst;
29625
29626 src = DREGu32((Opcode >> 9) & 7);
29627 adr = AREG((Opcode >> 0) & 7);
29628 PRE_IO
29629 READ_LONG_F(adr, dst)
29630 res = dst - src;
29631 flag_NotZ = res;
29632 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29633 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29634 flag_N = res >> 24;
29635 WRITE_LONG_F(adr, res)
29636 POST_IO
29637RET(20)
29638}
29639
29640// SUBDa
29641OPCODE(0x9198)
29642{
29643 u32 adr, res;
29644 u32 src, dst;
29645
29646 src = DREGu32((Opcode >> 9) & 7);
29647 adr = AREG((Opcode >> 0) & 7);
29648 AREG((Opcode >> 0) & 7) += 4;
29649 PRE_IO
29650 READ_LONG_F(adr, dst)
29651 res = dst - src;
29652 flag_NotZ = res;
29653 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29654 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29655 flag_N = res >> 24;
29656 WRITE_LONG_F(adr, res)
29657 POST_IO
29658RET(20)
29659}
29660
29661// SUBDa
29662OPCODE(0x91A0)
29663{
29664 u32 adr, res;
29665 u32 src, dst;
29666
29667 src = DREGu32((Opcode >> 9) & 7);
29668 adr = AREG((Opcode >> 0) & 7) - 4;
29669 AREG((Opcode >> 0) & 7) = adr;
29670 PRE_IO
29671 READ_LONG_F(adr, dst)
29672 res = dst - src;
29673 flag_NotZ = res;
29674 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29675 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29676 flag_N = res >> 24;
29677 WRITE_LONG_F(adr, res)
29678 POST_IO
29679RET(22)
29680}
29681
29682// SUBDa
29683OPCODE(0x91A8)
29684{
29685 u32 adr, res;
29686 u32 src, dst;
29687
29688 src = DREGu32((Opcode >> 9) & 7);
29689 FETCH_SWORD(adr);
29690 adr += AREG((Opcode >> 0) & 7);
29691 PRE_IO
29692 READ_LONG_F(adr, dst)
29693 res = dst - src;
29694 flag_NotZ = res;
29695 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29696 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29697 flag_N = res >> 24;
29698 WRITE_LONG_F(adr, res)
29699 POST_IO
29700RET(24)
29701}
29702
29703// SUBDa
29704OPCODE(0x91B0)
29705{
29706 u32 adr, res;
29707 u32 src, dst;
29708
29709 src = DREGu32((Opcode >> 9) & 7);
29710 adr = AREG((Opcode >> 0) & 7);
29711 DECODE_EXT_WORD
29712 PRE_IO
29713 READ_LONG_F(adr, dst)
29714 res = dst - src;
29715 flag_NotZ = res;
29716 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29717 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29718 flag_N = res >> 24;
29719 WRITE_LONG_F(adr, res)
29720 POST_IO
29721RET(26)
29722}
29723
29724// SUBDa
29725OPCODE(0x91B8)
29726{
29727 u32 adr, res;
29728 u32 src, dst;
29729
29730 src = DREGu32((Opcode >> 9) & 7);
29731 FETCH_SWORD(adr);
29732 PRE_IO
29733 READ_LONG_F(adr, dst)
29734 res = dst - src;
29735 flag_NotZ = res;
29736 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29737 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29738 flag_N = res >> 24;
29739 WRITE_LONG_F(adr, res)
29740 POST_IO
29741RET(24)
29742}
29743
29744// SUBDa
29745OPCODE(0x91B9)
29746{
29747 u32 adr, res;
29748 u32 src, dst;
29749
29750 src = DREGu32((Opcode >> 9) & 7);
29751 FETCH_LONG(adr);
29752 PRE_IO
29753 READ_LONG_F(adr, dst)
29754 res = dst - src;
29755 flag_NotZ = res;
29756 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29757 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29758 flag_N = res >> 24;
29759 WRITE_LONG_F(adr, res)
29760 POST_IO
29761RET(28)
29762}
29763
29764// SUBDa
29765OPCODE(0x919F)
29766{
29767 u32 adr, res;
29768 u32 src, dst;
29769
29770 src = DREGu32((Opcode >> 9) & 7);
29771 adr = AREG(7);
29772 AREG(7) += 4;
29773 PRE_IO
29774 READ_LONG_F(adr, dst)
29775 res = dst - src;
29776 flag_NotZ = res;
29777 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29778 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29779 flag_N = res >> 24;
29780 WRITE_LONG_F(adr, res)
29781 POST_IO
29782RET(20)
29783}
29784
29785// SUBDa
29786OPCODE(0x91A7)
29787{
29788 u32 adr, res;
29789 u32 src, dst;
29790
29791 src = DREGu32((Opcode >> 9) & 7);
29792 adr = AREG(7) - 4;
29793 AREG(7) = adr;
29794 PRE_IO
29795 READ_LONG_F(adr, dst)
29796 res = dst - src;
29797 flag_NotZ = res;
29798 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29799 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29800 flag_N = res >> 24;
29801 WRITE_LONG_F(adr, res)
29802 POST_IO
29803RET(22)
29804}
29805
29806// SUBX
29807OPCODE(0x9100)
29808{
29809 u32 adr, res;
29810 u32 src, dst;
29811
29812 src = DREGu8((Opcode >> 0) & 7);
29813 dst = DREGu8((Opcode >> 9) & 7);
29814 res = dst - src - ((flag_X >> 8) & 1);
29815 flag_N = flag_X = flag_C = res;
29816 flag_V = (src ^ dst) & (res ^ dst);
29817 flag_NotZ |= res & 0xFF;
29818 DREGu8((Opcode >> 9) & 7) = res;
29819RET(4)
29820}
29821
29822// SUBX
29823OPCODE(0x9140)
29824{
29825 u32 adr, res;
29826 u32 src, dst;
29827
29828 src = DREGu16((Opcode >> 0) & 7);
29829 dst = DREGu16((Opcode >> 9) & 7);
29830 res = dst - src - ((flag_X >> 8) & 1);
29831 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29832 flag_N = flag_X = flag_C = res >> 8;
29833 flag_NotZ |= res & 0xFFFF;
29834 DREGu16((Opcode >> 9) & 7) = res;
29835RET(4)
29836}
29837
29838// SUBX
29839OPCODE(0x9180)
29840{
29841 u32 adr, res;
29842 u32 src, dst;
29843
29844 src = DREGu32((Opcode >> 0) & 7);
29845 dst = DREGu32((Opcode >> 9) & 7);
29846 res = dst - src - ((flag_X >> 8) & 1);
29847 flag_NotZ |= res;
29848 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29849 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29850 flag_N = res >> 24;
29851 DREGu32((Opcode >> 9) & 7) = res;
29852RET(8)
29853}
29854
29855// SUBXM
29856OPCODE(0x9108)
29857{
29858 u32 adr, res;
29859 u32 src, dst;
29860
29861 adr = AREG((Opcode >> 0) & 7) - 1;
29862 AREG((Opcode >> 0) & 7) = adr;
29863 PRE_IO
29864 READ_BYTE_F(adr, src)
29865 adr = AREG((Opcode >> 9) & 7) - 1;
29866 AREG((Opcode >> 9) & 7) = adr;
29867 READ_BYTE_F(adr, dst)
29868 res = dst - src - ((flag_X >> 8) & 1);
29869 flag_N = flag_X = flag_C = res;
29870 flag_V = (src ^ dst) & (res ^ dst);
29871 flag_NotZ |= res & 0xFF;
29872 WRITE_BYTE_F(adr, res)
29873 POST_IO
29874RET(18)
29875}
29876
29877// SUBXM
29878OPCODE(0x9148)
29879{
29880 u32 adr, res;
29881 u32 src, dst;
29882
29883 adr = AREG((Opcode >> 0) & 7) - 2;
29884 AREG((Opcode >> 0) & 7) = adr;
29885 PRE_IO
29886 READ_WORD_F(adr, src)
29887 adr = AREG((Opcode >> 9) & 7) - 2;
29888 AREG((Opcode >> 9) & 7) = adr;
29889 READ_WORD_F(adr, dst)
29890 res = dst - src - ((flag_X >> 8) & 1);
29891 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29892 flag_N = flag_X = flag_C = res >> 8;
29893 flag_NotZ |= res & 0xFFFF;
29894 WRITE_WORD_F(adr, res)
29895 POST_IO
29896RET(18)
29897}
29898
29899// SUBXM
29900OPCODE(0x9188)
29901{
29902 u32 adr, res;
29903 u32 src, dst;
29904
29905 adr = AREG((Opcode >> 0) & 7) - 4;
29906 AREG((Opcode >> 0) & 7) = adr;
29907 PRE_IO
29908 READ_LONG_F(adr, src)
29909 adr = AREG((Opcode >> 9) & 7) - 4;
29910 AREG((Opcode >> 9) & 7) = adr;
29911 READ_LONG_F(adr, dst)
29912 res = dst - src - ((flag_X >> 8) & 1);
29913 flag_NotZ |= res;
29914 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29915 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29916 flag_N = res >> 24;
29917 WRITE_LONG_F(adr, res)
29918 POST_IO
29919RET(30)
29920}
29921
29922// SUBX7M
29923OPCODE(0x910F)
29924{
29925 u32 adr, res;
29926 u32 src, dst;
29927
29928 adr = AREG(7) - 2;
29929 AREG(7) = adr;
29930 PRE_IO
29931 READ_BYTE_F(adr, src)
29932 adr = AREG((Opcode >> 9) & 7) - 1;
29933 AREG((Opcode >> 9) & 7) = adr;
29934 READ_BYTE_F(adr, dst)
29935 res = dst - src - ((flag_X >> 8) & 1);
29936 flag_N = flag_X = flag_C = res;
29937 flag_V = (src ^ dst) & (res ^ dst);
29938 flag_NotZ |= res & 0xFF;
29939 WRITE_BYTE_F(adr, res)
29940 POST_IO
29941RET(18)
29942}
29943
29944// SUBX7M
29945OPCODE(0x914F)
29946{
29947 u32 adr, res;
29948 u32 src, dst;
29949
29950 adr = AREG(7) - 2;
29951 AREG(7) = adr;
29952 PRE_IO
29953 READ_WORD_F(adr, src)
29954 adr = AREG((Opcode >> 9) & 7) - 2;
29955 AREG((Opcode >> 9) & 7) = adr;
29956 READ_WORD_F(adr, dst)
29957 res = dst - src - ((flag_X >> 8) & 1);
29958 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29959 flag_N = flag_X = flag_C = res >> 8;
29960 flag_NotZ |= res & 0xFFFF;
29961 WRITE_WORD_F(adr, res)
29962 POST_IO
29963RET(18)
29964}
29965
29966// SUBX7M
29967OPCODE(0x918F)
29968{
29969 u32 adr, res;
29970 u32 src, dst;
29971
29972 adr = AREG(7) - 4;
29973 AREG(7) = adr;
29974 PRE_IO
29975 READ_LONG_F(adr, src)
29976 adr = AREG((Opcode >> 9) & 7) - 4;
29977 AREG((Opcode >> 9) & 7) = adr;
29978 READ_LONG_F(adr, dst)
29979 res = dst - src - ((flag_X >> 8) & 1);
29980 flag_NotZ |= res;
29981 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29982 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29983 flag_N = res >> 24;
29984 WRITE_LONG_F(adr, res)
29985 POST_IO
29986RET(30)
29987}
29988
29989// SUBXM7
29990OPCODE(0x9F08)
29991{
29992 u32 adr, res;
29993 u32 src, dst;
29994
29995 adr = AREG((Opcode >> 0) & 7) - 1;
29996 AREG((Opcode >> 0) & 7) = adr;
29997 PRE_IO
29998 READ_BYTE_F(adr, src)
29999 adr = AREG(7) - 2;
30000 AREG(7) = adr;
30001 READ_BYTE_F(adr, dst)
30002 res = dst - src - ((flag_X >> 8) & 1);
30003 flag_N = flag_X = flag_C = res;
30004 flag_V = (src ^ dst) & (res ^ dst);
30005 flag_NotZ |= res & 0xFF;
30006 WRITE_BYTE_F(adr, res)
30007 POST_IO
30008RET(18)
30009}
30010
30011// SUBXM7
30012OPCODE(0x9F48)
30013{
30014 u32 adr, res;
30015 u32 src, dst;
30016
30017 adr = AREG((Opcode >> 0) & 7) - 2;
30018 AREG((Opcode >> 0) & 7) = adr;
30019 PRE_IO
30020 READ_WORD_F(adr, src)
30021 adr = AREG(7) - 2;
30022 AREG(7) = adr;
30023 READ_WORD_F(adr, dst)
30024 res = dst - src - ((flag_X >> 8) & 1);
30025 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30026 flag_N = flag_X = flag_C = res >> 8;
30027 flag_NotZ |= res & 0xFFFF;
30028 WRITE_WORD_F(adr, res)
30029 POST_IO
30030RET(18)
30031}
30032
30033// SUBXM7
30034OPCODE(0x9F88)
30035{
30036 u32 adr, res;
30037 u32 src, dst;
30038
30039 adr = AREG((Opcode >> 0) & 7) - 4;
30040 AREG((Opcode >> 0) & 7) = adr;
30041 PRE_IO
30042 READ_LONG_F(adr, src)
30043 adr = AREG(7) - 4;
30044 AREG(7) = adr;
30045 READ_LONG_F(adr, dst)
30046 res = dst - src - ((flag_X >> 8) & 1);
30047 flag_NotZ |= res;
30048 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30049 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30050 flag_N = res >> 24;
30051 WRITE_LONG_F(adr, res)
30052 POST_IO
30053RET(30)
30054}
30055
30056// SUBX7M7
30057OPCODE(0x9F0F)
30058{
30059 u32 adr, res;
30060 u32 src, dst;
30061
30062 adr = AREG(7) - 2;
30063 AREG(7) = adr;
30064 PRE_IO
30065 READ_BYTE_F(adr, src)
30066 adr = AREG(7) - 2;
30067 AREG(7) = adr;
30068 READ_BYTE_F(adr, dst)
30069 res = dst - src - ((flag_X >> 8) & 1);
30070 flag_N = flag_X = flag_C = res;
30071 flag_V = (src ^ dst) & (res ^ dst);
30072 flag_NotZ |= res & 0xFF;
30073 WRITE_BYTE_F(adr, res)
30074 POST_IO
30075RET(18)
30076}
30077
30078// SUBX7M7
30079OPCODE(0x9F4F)
30080{
30081 u32 adr, res;
30082 u32 src, dst;
30083
30084 adr = AREG(7) - 2;
30085 AREG(7) = adr;
30086 PRE_IO
30087 READ_WORD_F(adr, src)
30088 adr = AREG(7) - 2;
30089 AREG(7) = adr;
30090 READ_WORD_F(adr, dst)
30091 res = dst - src - ((flag_X >> 8) & 1);
30092 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30093 flag_N = flag_X = flag_C = res >> 8;
30094 flag_NotZ |= res & 0xFFFF;
30095 WRITE_WORD_F(adr, res)
30096 POST_IO
30097RET(18)
30098}
30099
30100// SUBX7M7
30101OPCODE(0x9F8F)
30102{
30103 u32 adr, res;
30104 u32 src, dst;
30105
30106 adr = AREG(7) - 4;
30107 AREG(7) = adr;
30108 PRE_IO
30109 READ_LONG_F(adr, src)
30110 adr = AREG(7) - 4;
30111 AREG(7) = adr;
30112 READ_LONG_F(adr, dst)
30113 res = dst - src - ((flag_X >> 8) & 1);
30114 flag_NotZ |= res;
30115 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30116 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30117 flag_N = res >> 24;
30118 WRITE_LONG_F(adr, res)
30119 POST_IO
30120RET(30)
30121}
30122
30123// SUBA
30124OPCODE(0x90C0)
30125{
30126 u32 adr, res;
30127 u32 src, dst;
30128
30129 src = (s32)DREGs16((Opcode >> 0) & 7);
30130 dst = AREGu32((Opcode >> 9) & 7);
30131 res = dst - src;
30132 AREG((Opcode >> 9) & 7) = res;
30133RET(8)
30134}
30135
30136// SUBA
30137OPCODE(0x90C8)
30138{
30139 u32 adr, res;
30140 u32 src, dst;
30141
30142 src = (s32)AREGs16((Opcode >> 0) & 7);
30143 dst = AREGu32((Opcode >> 9) & 7);
30144 res = dst - src;
30145 AREG((Opcode >> 9) & 7) = res;
30146RET(8)
30147}
30148
30149// SUBA
30150OPCODE(0x90D0)
30151{
30152 u32 adr, res;
30153 u32 src, dst;
30154
30155 adr = AREG((Opcode >> 0) & 7);
30156 PRE_IO
30157 READSX_WORD_F(adr, src)
30158 dst = AREGu32((Opcode >> 9) & 7);
30159 res = dst - src;
30160 AREG((Opcode >> 9) & 7) = res;
30161 POST_IO
9d917eea 30162#ifdef USE_CYCLONE_TIMING
30163RET(12)
30164#else
70357ce5 30165RET(10)
9d917eea 30166#endif
70357ce5 30167}
30168
30169// SUBA
30170OPCODE(0x90D8)
30171{
30172 u32 adr, res;
30173 u32 src, dst;
30174
30175 adr = AREG((Opcode >> 0) & 7);
30176 AREG((Opcode >> 0) & 7) += 2;
30177 PRE_IO
30178 READSX_WORD_F(adr, src)
30179 dst = AREGu32((Opcode >> 9) & 7);
30180 res = dst - src;
30181 AREG((Opcode >> 9) & 7) = res;
30182 POST_IO
9d917eea 30183#ifdef USE_CYCLONE_TIMING
30184RET(12)
30185#else
70357ce5 30186RET(10)
9d917eea 30187#endif
70357ce5 30188}
30189
30190// SUBA
30191OPCODE(0x90E0)
30192{
30193 u32 adr, res;
30194 u32 src, dst;
30195
30196 adr = AREG((Opcode >> 0) & 7) - 2;
30197 AREG((Opcode >> 0) & 7) = adr;
30198 PRE_IO
30199 READSX_WORD_F(adr, src)
30200 dst = AREGu32((Opcode >> 9) & 7);
30201 res = dst - src;
30202 AREG((Opcode >> 9) & 7) = res;
30203 POST_IO
9d917eea 30204#ifdef USE_CYCLONE_TIMING
30205RET(14)
30206#else
70357ce5 30207RET(12)
9d917eea 30208#endif
70357ce5 30209}
30210
30211// SUBA
30212OPCODE(0x90E8)
30213{
30214 u32 adr, res;
30215 u32 src, dst;
30216
30217 FETCH_SWORD(adr);
30218 adr += AREG((Opcode >> 0) & 7);
30219 PRE_IO
30220 READSX_WORD_F(adr, src)
30221 dst = AREGu32((Opcode >> 9) & 7);
30222 res = dst - src;
30223 AREG((Opcode >> 9) & 7) = res;
30224 POST_IO
9d917eea 30225#ifdef USE_CYCLONE_TIMING
30226RET(16)
30227#else
70357ce5 30228RET(14)
9d917eea 30229#endif
70357ce5 30230}
30231
30232// SUBA
30233OPCODE(0x90F0)
30234{
30235 u32 adr, res;
30236 u32 src, dst;
30237
30238 adr = AREG((Opcode >> 0) & 7);
30239 DECODE_EXT_WORD
30240 PRE_IO
30241 READSX_WORD_F(adr, src)
30242 dst = AREGu32((Opcode >> 9) & 7);
30243 res = dst - src;
30244 AREG((Opcode >> 9) & 7) = res;
30245 POST_IO
9d917eea 30246#ifdef USE_CYCLONE_TIMING
30247RET(18)
30248#else
70357ce5 30249RET(16)
9d917eea 30250#endif
70357ce5 30251}
30252
30253// SUBA
30254OPCODE(0x90F8)
30255{
30256 u32 adr, res;
30257 u32 src, dst;
30258
30259 FETCH_SWORD(adr);
30260 PRE_IO
30261 READSX_WORD_F(adr, src)
30262 dst = AREGu32((Opcode >> 9) & 7);
30263 res = dst - src;
30264 AREG((Opcode >> 9) & 7) = res;
30265 POST_IO
9d917eea 30266#ifdef USE_CYCLONE_TIMING
30267RET(16)
30268#else
70357ce5 30269RET(14)
9d917eea 30270#endif
70357ce5 30271}
30272
30273// SUBA
30274OPCODE(0x90F9)
30275{
30276 u32 adr, res;
30277 u32 src, dst;
30278
30279 FETCH_LONG(adr);
30280 PRE_IO
30281 READSX_WORD_F(adr, src)
30282 dst = AREGu32((Opcode >> 9) & 7);
30283 res = dst - src;
30284 AREG((Opcode >> 9) & 7) = res;
30285 POST_IO
9d917eea 30286#ifdef USE_CYCLONE_TIMING
30287RET(20)
30288#else
70357ce5 30289RET(18)
9d917eea 30290#endif
70357ce5 30291}
30292
30293// SUBA
30294OPCODE(0x90FA)
30295{
30296 u32 adr, res;
30297 u32 src, dst;
30298
be26eb23 30299 adr = GET_SWORD + GET_PC;
70357ce5 30300 PC++;
30301 PRE_IO
30302 READSX_WORD_F(adr, src)
30303 dst = AREGu32((Opcode >> 9) & 7);
30304 res = dst - src;
30305 AREG((Opcode >> 9) & 7) = res;
30306 POST_IO
9d917eea 30307#ifdef USE_CYCLONE_TIMING
30308RET(16)
30309#else
70357ce5 30310RET(14)
9d917eea 30311#endif
70357ce5 30312}
30313
30314// SUBA
30315OPCODE(0x90FB)
30316{
30317 u32 adr, res;
30318 u32 src, dst;
30319
be26eb23 30320 adr = GET_PC;
70357ce5 30321 DECODE_EXT_WORD
30322 PRE_IO
30323 READSX_WORD_F(adr, src)
30324 dst = AREGu32((Opcode >> 9) & 7);
30325 res = dst - src;
30326 AREG((Opcode >> 9) & 7) = res;
30327 POST_IO
9d917eea 30328#ifdef USE_CYCLONE_TIMING
30329RET(18)
30330#else
70357ce5 30331RET(16)
9d917eea 30332#endif
70357ce5 30333}
30334
30335// SUBA
30336OPCODE(0x90FC)
30337{
30338 u32 adr, res;
30339 u32 src, dst;
30340
30341 FETCH_SWORD(src);
30342 dst = AREGu32((Opcode >> 9) & 7);
30343 res = dst - src;
30344 AREG((Opcode >> 9) & 7) = res;
30345RET(12)
30346}
30347
30348// SUBA
30349OPCODE(0x90DF)
30350{
30351 u32 adr, res;
30352 u32 src, dst;
30353
30354 adr = AREG(7);
30355 AREG(7) += 2;
30356 PRE_IO
30357 READSX_WORD_F(adr, src)
30358 dst = AREGu32((Opcode >> 9) & 7);
30359 res = dst - src;
30360 AREG((Opcode >> 9) & 7) = res;
30361 POST_IO
9d917eea 30362#ifdef USE_CYCLONE_TIMING
30363RET(12)
30364#else
70357ce5 30365RET(10)
9d917eea 30366#endif
70357ce5 30367}
30368
30369// SUBA
30370OPCODE(0x90E7)
30371{
30372 u32 adr, res;
30373 u32 src, dst;
30374
30375 adr = AREG(7) - 2;
30376 AREG(7) = adr;
30377 PRE_IO
30378 READSX_WORD_F(adr, src)
30379 dst = AREGu32((Opcode >> 9) & 7);
30380 res = dst - src;
30381 AREG((Opcode >> 9) & 7) = res;
30382 POST_IO
9d917eea 30383#ifdef USE_CYCLONE_TIMING
30384RET(14)
30385#else
70357ce5 30386RET(12)
9d917eea 30387#endif
70357ce5 30388}
30389
30390// SUBA
30391OPCODE(0x91C0)
30392{
30393 u32 adr, res;
30394 u32 src, dst;
30395
30396 src = (s32)DREGs32((Opcode >> 0) & 7);
30397 dst = AREGu32((Opcode >> 9) & 7);
30398 res = dst - src;
30399 AREG((Opcode >> 9) & 7) = res;
30400#ifdef USE_CYCLONE_TIMING
30401RET(8)
30402#else
30403RET(6)
30404#endif
30405}
30406
30407// SUBA
30408OPCODE(0x91C8)
30409{
30410 u32 adr, res;
30411 u32 src, dst;
30412
30413 src = (s32)AREGs32((Opcode >> 0) & 7);
30414 dst = AREGu32((Opcode >> 9) & 7);
30415 res = dst - src;
30416 AREG((Opcode >> 9) & 7) = res;
30417#ifdef USE_CYCLONE_TIMING
30418RET(8)
30419#else
30420RET(6)
30421#endif
30422}
30423
30424// SUBA
30425OPCODE(0x91D0)
30426{
30427 u32 adr, res;
30428 u32 src, dst;
30429
30430 adr = AREG((Opcode >> 0) & 7);
30431 PRE_IO
30432 READSX_LONG_F(adr, src)
30433 dst = AREGu32((Opcode >> 9) & 7);
30434 res = dst - src;
30435 AREG((Opcode >> 9) & 7) = res;
30436 POST_IO
30437RET(14)
30438}
30439
30440// SUBA
30441OPCODE(0x91D8)
30442{
30443 u32 adr, res;
30444 u32 src, dst;
30445
30446 adr = AREG((Opcode >> 0) & 7);
30447 AREG((Opcode >> 0) & 7) += 4;
30448 PRE_IO
30449 READSX_LONG_F(adr, src)
30450 dst = AREGu32((Opcode >> 9) & 7);
30451 res = dst - src;
30452 AREG((Opcode >> 9) & 7) = res;
30453 POST_IO
30454RET(14)
30455}
30456
30457// SUBA
30458OPCODE(0x91E0)
30459{
30460 u32 adr, res;
30461 u32 src, dst;
30462
30463 adr = AREG((Opcode >> 0) & 7) - 4;
30464 AREG((Opcode >> 0) & 7) = adr;
30465 PRE_IO
30466 READSX_LONG_F(adr, src)
30467 dst = AREGu32((Opcode >> 9) & 7);
30468 res = dst - src;
30469 AREG((Opcode >> 9) & 7) = res;
30470 POST_IO
30471RET(16)
30472}
30473
30474// SUBA
30475OPCODE(0x91E8)
30476{
30477 u32 adr, res;
30478 u32 src, dst;
30479
30480 FETCH_SWORD(adr);
30481 adr += AREG((Opcode >> 0) & 7);
30482 PRE_IO
30483 READSX_LONG_F(adr, src)
30484 dst = AREGu32((Opcode >> 9) & 7);
30485 res = dst - src;
30486 AREG((Opcode >> 9) & 7) = res;
30487 POST_IO
30488RET(18)
30489}
30490
30491// SUBA
30492OPCODE(0x91F0)
30493{
30494 u32 adr, res;
30495 u32 src, dst;
30496
30497 adr = AREG((Opcode >> 0) & 7);
30498 DECODE_EXT_WORD
30499 PRE_IO
30500 READSX_LONG_F(adr, src)
30501 dst = AREGu32((Opcode >> 9) & 7);
30502 res = dst - src;
30503 AREG((Opcode >> 9) & 7) = res;
30504 POST_IO
30505RET(20)
30506}
30507
30508// SUBA
30509OPCODE(0x91F8)
30510{
30511 u32 adr, res;
30512 u32 src, dst;
30513
30514 FETCH_SWORD(adr);
30515 PRE_IO
30516 READSX_LONG_F(adr, src)
30517 dst = AREGu32((Opcode >> 9) & 7);
30518 res = dst - src;
30519 AREG((Opcode >> 9) & 7) = res;
30520 POST_IO
30521RET(18)
30522}
30523
30524// SUBA
30525OPCODE(0x91F9)
30526{
30527 u32 adr, res;
30528 u32 src, dst;
30529
30530 FETCH_LONG(adr);
30531 PRE_IO
30532 READSX_LONG_F(adr, src)
30533 dst = AREGu32((Opcode >> 9) & 7);
30534 res = dst - src;
30535 AREG((Opcode >> 9) & 7) = res;
30536 POST_IO
30537RET(22)
30538}
30539
30540// SUBA
30541OPCODE(0x91FA)
30542{
30543 u32 adr, res;
30544 u32 src, dst;
30545
be26eb23 30546 adr = GET_SWORD + GET_PC;
70357ce5 30547 PC++;
30548 PRE_IO
30549 READSX_LONG_F(adr, src)
30550 dst = AREGu32((Opcode >> 9) & 7);
30551 res = dst - src;
30552 AREG((Opcode >> 9) & 7) = res;
30553 POST_IO
30554RET(18)
30555}
30556
30557// SUBA
30558OPCODE(0x91FB)
30559{
30560 u32 adr, res;
30561 u32 src, dst;
30562
be26eb23 30563 adr = GET_PC;
70357ce5 30564 DECODE_EXT_WORD
30565 PRE_IO
30566 READSX_LONG_F(adr, src)
30567 dst = AREGu32((Opcode >> 9) & 7);
30568 res = dst - src;
30569 AREG((Opcode >> 9) & 7) = res;
30570 POST_IO
30571RET(20)
30572}
30573
30574// SUBA
30575OPCODE(0x91FC)
30576{
30577 u32 adr, res;
30578 u32 src, dst;
30579
30580 FETCH_LONG(src);
30581 dst = AREGu32((Opcode >> 9) & 7);
30582 res = dst - src;
30583 AREG((Opcode >> 9) & 7) = res;
30584#ifdef USE_CYCLONE_TIMING
30585RET(16)
30586#else
30587RET(14)
30588#endif
30589}
30590
30591// SUBA
30592OPCODE(0x91DF)
30593{
30594 u32 adr, res;
30595 u32 src, dst;
30596
30597 adr = AREG(7);
30598 AREG(7) += 4;
30599 PRE_IO
30600 READSX_LONG_F(adr, src)
30601 dst = AREGu32((Opcode >> 9) & 7);
30602 res = dst - src;
30603 AREG((Opcode >> 9) & 7) = res;
30604 POST_IO
30605RET(14)
30606}
30607
30608// SUBA
30609OPCODE(0x91E7)
30610{
30611 u32 adr, res;
30612 u32 src, dst;
30613
30614 adr = AREG(7) - 4;
30615 AREG(7) = adr;
30616 PRE_IO
30617 READSX_LONG_F(adr, src)
30618 dst = AREGu32((Opcode >> 9) & 7);
30619 res = dst - src;
30620 AREG((Opcode >> 9) & 7) = res;
30621 POST_IO
30622RET(16)
30623}
30624
30625// CMP
30626OPCODE(0xB000)
30627{
30628 u32 adr, res;
30629 u32 src, dst;
30630
30631 src = DREGu8((Opcode >> 0) & 7);
30632 dst = DREGu8((Opcode >> 9) & 7);
30633 res = dst - src;
30634 flag_N = flag_C = res;
30635 flag_V = (src ^ dst) & (res ^ dst);
30636 flag_NotZ = res & 0xFF;
30637RET(4)
30638}
30639
30640// CMP
03e4f2a3 30641#if 0
70357ce5 30642OPCODE(0xB008)
30643{
30644 u32 adr, res;
30645 u32 src, dst;
30646
30647 // can't read byte from Ax registers !
30648 m68kcontext.execinfo |= M68K_FAULTED;
30649 m68kcontext.io_cycle_counter = 0;
30650/*
30651 goto famec_Exec_End;
30652 dst = DREGu8((Opcode >> 9) & 7);
30653 res = dst - src;
30654 flag_N = flag_C = res;
30655 flag_V = (src ^ dst) & (res ^ dst);
30656 flag_NotZ = res & 0xFF;
30657*/
30658RET(4)
30659}
03e4f2a3 30660#endif
70357ce5 30661
30662// CMP
30663OPCODE(0xB010)
30664{
30665 u32 adr, res;
30666 u32 src, dst;
30667
30668 adr = AREG((Opcode >> 0) & 7);
30669 PRE_IO
30670 READ_BYTE_F(adr, src)
30671 dst = DREGu8((Opcode >> 9) & 7);
30672 res = dst - src;
30673 flag_N = flag_C = res;
30674 flag_V = (src ^ dst) & (res ^ dst);
30675 flag_NotZ = res & 0xFF;
30676 POST_IO
30677RET(8)
30678}
30679
30680// CMP
30681OPCODE(0xB018)
30682{
30683 u32 adr, res;
30684 u32 src, dst;
30685
30686 adr = AREG((Opcode >> 0) & 7);
30687 AREG((Opcode >> 0) & 7) += 1;
30688 PRE_IO
30689 READ_BYTE_F(adr, src)
30690 dst = DREGu8((Opcode >> 9) & 7);
30691 res = dst - src;
30692 flag_N = flag_C = res;
30693 flag_V = (src ^ dst) & (res ^ dst);
30694 flag_NotZ = res & 0xFF;
30695 POST_IO
30696RET(8)
30697}
30698
30699// CMP
30700OPCODE(0xB020)
30701{
30702 u32 adr, res;
30703 u32 src, dst;
30704
30705 adr = AREG((Opcode >> 0) & 7) - 1;
30706 AREG((Opcode >> 0) & 7) = adr;
30707 PRE_IO
30708 READ_BYTE_F(adr, src)
30709 dst = DREGu8((Opcode >> 9) & 7);
30710 res = dst - src;
30711 flag_N = flag_C = res;
30712 flag_V = (src ^ dst) & (res ^ dst);
30713 flag_NotZ = res & 0xFF;
30714 POST_IO
30715RET(10)
30716}
30717
30718// CMP
30719OPCODE(0xB028)
30720{
30721 u32 adr, res;
30722 u32 src, dst;
30723
30724 FETCH_SWORD(adr);
30725 adr += AREG((Opcode >> 0) & 7);
30726 PRE_IO
30727 READ_BYTE_F(adr, src)
30728 dst = DREGu8((Opcode >> 9) & 7);
30729 res = dst - src;
30730 flag_N = flag_C = res;
30731 flag_V = (src ^ dst) & (res ^ dst);
30732 flag_NotZ = res & 0xFF;
30733 POST_IO
30734RET(12)
30735}
30736
30737// CMP
30738OPCODE(0xB030)
30739{
30740 u32 adr, res;
30741 u32 src, dst;
30742
30743 adr = AREG((Opcode >> 0) & 7);
30744 DECODE_EXT_WORD
30745 PRE_IO
30746 READ_BYTE_F(adr, src)
30747 dst = DREGu8((Opcode >> 9) & 7);
30748 res = dst - src;
30749 flag_N = flag_C = res;
30750 flag_V = (src ^ dst) & (res ^ dst);
30751 flag_NotZ = res & 0xFF;
30752 POST_IO
30753RET(14)
30754}
30755
30756// CMP
30757OPCODE(0xB038)
30758{
30759 u32 adr, res;
30760 u32 src, dst;
30761
30762 FETCH_SWORD(adr);
30763 PRE_IO
30764 READ_BYTE_F(adr, src)
30765 dst = DREGu8((Opcode >> 9) & 7);
30766 res = dst - src;
30767 flag_N = flag_C = res;
30768 flag_V = (src ^ dst) & (res ^ dst);
30769 flag_NotZ = res & 0xFF;
30770 POST_IO
30771RET(12)
30772}
30773
30774// CMP
30775OPCODE(0xB039)
30776{
30777 u32 adr, res;
30778 u32 src, dst;
30779
30780 FETCH_LONG(adr);
30781 PRE_IO
30782 READ_BYTE_F(adr, src)
30783 dst = DREGu8((Opcode >> 9) & 7);
30784 res = dst - src;
30785 flag_N = flag_C = res;
30786 flag_V = (src ^ dst) & (res ^ dst);
30787 flag_NotZ = res & 0xFF;
30788 POST_IO
30789RET(16)
30790}
30791
30792// CMP
30793OPCODE(0xB03A)
30794{
30795 u32 adr, res;
30796 u32 src, dst;
30797
be26eb23 30798 adr = GET_SWORD + GET_PC;
70357ce5 30799 PC++;
30800 PRE_IO
30801 READ_BYTE_F(adr, src)
30802 dst = DREGu8((Opcode >> 9) & 7);
30803 res = dst - src;
30804 flag_N = flag_C = res;
30805 flag_V = (src ^ dst) & (res ^ dst);
30806 flag_NotZ = res & 0xFF;
30807 POST_IO
30808RET(12)
30809}
30810
30811// CMP
30812OPCODE(0xB03B)
30813{
30814 u32 adr, res;
30815 u32 src, dst;
30816
be26eb23 30817 adr = GET_PC;
70357ce5 30818 DECODE_EXT_WORD
30819 PRE_IO
30820 READ_BYTE_F(adr, src)
30821 dst = DREGu8((Opcode >> 9) & 7);
30822 res = dst - src;
30823 flag_N = flag_C = res;
30824 flag_V = (src ^ dst) & (res ^ dst);
30825 flag_NotZ = res & 0xFF;
30826 POST_IO
30827RET(14)
30828}
30829
30830// CMP
30831OPCODE(0xB03C)
30832{
30833 u32 adr, res;
30834 u32 src, dst;
30835
30836 FETCH_BYTE(src);
30837 dst = DREGu8((Opcode >> 9) & 7);
30838 res = dst - src;
30839 flag_N = flag_C = res;
30840 flag_V = (src ^ dst) & (res ^ dst);
30841 flag_NotZ = res & 0xFF;
30842RET(8)
30843}
30844
30845// CMP
30846OPCODE(0xB01F)
30847{
30848 u32 adr, res;
30849 u32 src, dst;
30850
30851 adr = AREG(7);
30852 AREG(7) += 2;
30853 PRE_IO
30854 READ_BYTE_F(adr, src)
30855 dst = DREGu8((Opcode >> 9) & 7);
30856 res = dst - src;
30857 flag_N = flag_C = res;
30858 flag_V = (src ^ dst) & (res ^ dst);
30859 flag_NotZ = res & 0xFF;
30860 POST_IO
30861RET(8)
30862}
30863
30864// CMP
30865OPCODE(0xB027)
30866{
30867 u32 adr, res;
30868 u32 src, dst;
30869
30870 adr = AREG(7) - 2;
30871 AREG(7) = adr;
30872 PRE_IO
30873 READ_BYTE_F(adr, src)
30874 dst = DREGu8((Opcode >> 9) & 7);
30875 res = dst - src;
30876 flag_N = flag_C = res;
30877 flag_V = (src ^ dst) & (res ^ dst);
30878 flag_NotZ = res & 0xFF;
30879 POST_IO
30880RET(10)
30881}
30882
30883// CMP
30884OPCODE(0xB040)
30885{
30886 u32 adr, res;
30887 u32 src, dst;
30888
30889 src = DREGu16((Opcode >> 0) & 7);
30890 dst = DREGu16((Opcode >> 9) & 7);
30891 res = dst - src;
30892 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30893 flag_N = flag_C = res >> 8;
30894 flag_NotZ = res & 0xFFFF;
30895RET(4)
30896}
30897
30898// CMP
30899OPCODE(0xB048)
30900{
30901 u32 adr, res;
30902 u32 src, dst;
30903
30904 src = AREGu16((Opcode >> 0) & 7);
30905 dst = DREGu16((Opcode >> 9) & 7);
30906 res = dst - src;
30907 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30908 flag_N = flag_C = res >> 8;
30909 flag_NotZ = res & 0xFFFF;
30910RET(4)
30911}
30912
30913// CMP
30914OPCODE(0xB050)
30915{
30916 u32 adr, res;
30917 u32 src, dst;
30918
30919 adr = AREG((Opcode >> 0) & 7);
30920 PRE_IO
30921 READ_WORD_F(adr, src)
30922 dst = DREGu16((Opcode >> 9) & 7);
30923 res = dst - src;
30924 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30925 flag_N = flag_C = res >> 8;
30926 flag_NotZ = res & 0xFFFF;
30927 POST_IO
30928RET(8)
30929}
30930
30931// CMP
30932OPCODE(0xB058)
30933{
30934 u32 adr, res;
30935 u32 src, dst;
30936
30937 adr = AREG((Opcode >> 0) & 7);
30938 AREG((Opcode >> 0) & 7) += 2;
30939 PRE_IO
30940 READ_WORD_F(adr, src)
30941 dst = DREGu16((Opcode >> 9) & 7);
30942 res = dst - src;
30943 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30944 flag_N = flag_C = res >> 8;
30945 flag_NotZ = res & 0xFFFF;
30946 POST_IO
30947RET(8)
30948}
30949
30950// CMP
30951OPCODE(0xB060)
30952{
30953 u32 adr, res;
30954 u32 src, dst;
30955
30956 adr = AREG((Opcode >> 0) & 7) - 2;
30957 AREG((Opcode >> 0) & 7) = adr;
30958 PRE_IO
30959 READ_WORD_F(adr, src)
30960 dst = DREGu16((Opcode >> 9) & 7);
30961 res = dst - src;
30962 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30963 flag_N = flag_C = res >> 8;
30964 flag_NotZ = res & 0xFFFF;
30965 POST_IO
30966RET(10)
30967}
30968
30969// CMP
30970OPCODE(0xB068)
30971{
30972 u32 adr, res;
30973 u32 src, dst;
30974
30975 FETCH_SWORD(adr);
30976 adr += AREG((Opcode >> 0) & 7);
30977 PRE_IO
30978 READ_WORD_F(adr, src)
30979 dst = DREGu16((Opcode >> 9) & 7);
30980 res = dst - src;
30981 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30982 flag_N = flag_C = res >> 8;
30983 flag_NotZ = res & 0xFFFF;
30984 POST_IO
30985RET(12)
30986}
30987
30988// CMP
30989OPCODE(0xB070)
30990{
30991 u32 adr, res;
30992 u32 src, dst;
30993
30994 adr = AREG((Opcode >> 0) & 7);
30995 DECODE_EXT_WORD
30996 PRE_IO
30997 READ_WORD_F(adr, src)
30998 dst = DREGu16((Opcode >> 9) & 7);
30999 res = dst - src;
31000 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31001 flag_N = flag_C = res >> 8;
31002 flag_NotZ = res & 0xFFFF;
31003 POST_IO
31004RET(14)
31005}
31006
31007// CMP
31008OPCODE(0xB078)
31009{
31010 u32 adr, res;
31011 u32 src, dst;
31012
31013 FETCH_SWORD(adr);
31014 PRE_IO
31015 READ_WORD_F(adr, src)
31016 dst = DREGu16((Opcode >> 9) & 7);
31017 res = dst - src;
31018 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31019 flag_N = flag_C = res >> 8;
31020 flag_NotZ = res & 0xFFFF;
31021 POST_IO
31022RET(12)
31023}
31024
31025// CMP
31026OPCODE(0xB079)
31027{
31028 u32 adr, res;
31029 u32 src, dst;
31030
31031 FETCH_LONG(adr);
31032 PRE_IO
31033 READ_WORD_F(adr, src)
31034 dst = DREGu16((Opcode >> 9) & 7);
31035 res = dst - src;
31036 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31037 flag_N = flag_C = res >> 8;
31038 flag_NotZ = res & 0xFFFF;
31039 POST_IO
31040RET(16)
31041}
31042
31043// CMP
31044OPCODE(0xB07A)
31045{
31046 u32 adr, res;
31047 u32 src, dst;
31048
be26eb23 31049 adr = GET_SWORD + GET_PC;
70357ce5 31050 PC++;
31051 PRE_IO
31052 READ_WORD_F(adr, src)
31053 dst = DREGu16((Opcode >> 9) & 7);
31054 res = dst - src;
31055 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31056 flag_N = flag_C = res >> 8;
31057 flag_NotZ = res & 0xFFFF;
31058 POST_IO
31059RET(12)
31060}
31061
31062// CMP
31063OPCODE(0xB07B)
31064{
31065 u32 adr, res;
31066 u32 src, dst;
31067
be26eb23 31068 adr = GET_PC;
70357ce5 31069 DECODE_EXT_WORD
31070 PRE_IO
31071 READ_WORD_F(adr, src)
31072 dst = DREGu16((Opcode >> 9) & 7);
31073 res = dst - src;
31074 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31075 flag_N = flag_C = res >> 8;
31076 flag_NotZ = res & 0xFFFF;
31077 POST_IO
31078RET(14)
31079}
31080
31081// CMP
31082OPCODE(0xB07C)
31083{
31084 u32 adr, res;
31085 u32 src, dst;
31086
31087 FETCH_WORD(src);
31088 dst = DREGu16((Opcode >> 9) & 7);
31089 res = dst - src;
31090 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31091 flag_N = flag_C = res >> 8;
31092 flag_NotZ = res & 0xFFFF;
31093RET(8)
31094}
31095
31096// CMP
31097OPCODE(0xB05F)
31098{
31099 u32 adr, res;
31100 u32 src, dst;
31101
31102 adr = AREG(7);
31103 AREG(7) += 2;
31104 PRE_IO
31105 READ_WORD_F(adr, src)
31106 dst = DREGu16((Opcode >> 9) & 7);
31107 res = dst - src;
31108 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31109 flag_N = flag_C = res >> 8;
31110 flag_NotZ = res & 0xFFFF;
31111 POST_IO
31112RET(8)
31113}
31114
31115// CMP
31116OPCODE(0xB067)
31117{
31118 u32 adr, res;
31119 u32 src, dst;
31120
31121 adr = AREG(7) - 2;
31122 AREG(7) = adr;
31123 PRE_IO
31124 READ_WORD_F(adr, src)
31125 dst = DREGu16((Opcode >> 9) & 7);
31126 res = dst - src;
31127 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31128 flag_N = flag_C = res >> 8;
31129 flag_NotZ = res & 0xFFFF;
31130 POST_IO
31131RET(10)
31132}
31133
31134// CMP
31135OPCODE(0xB080)
31136{
31137 u32 adr, res;
31138 u32 src, dst;
31139
31140 src = DREGu32((Opcode >> 0) & 7);
31141 dst = DREGu32((Opcode >> 9) & 7);
31142 res = dst - src;
31143 flag_NotZ = res;
31144 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31145 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31146 flag_N = res >> 24;
31147RET(6)
31148}
31149
31150// CMP
31151OPCODE(0xB088)
31152{
31153 u32 adr, res;
31154 u32 src, dst;
31155
31156 src = AREGu32((Opcode >> 0) & 7);
31157 dst = DREGu32((Opcode >> 9) & 7);
31158 res = dst - src;
31159 flag_NotZ = res;
31160 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31161 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31162 flag_N = res >> 24;
31163RET(6)
31164}
31165
31166// CMP
31167OPCODE(0xB090)
31168{
31169 u32 adr, res;
31170 u32 src, dst;
31171
31172 adr = AREG((Opcode >> 0) & 7);
31173 PRE_IO
31174 READ_LONG_F(adr, src)
31175 dst = DREGu32((Opcode >> 9) & 7);
31176 res = dst - src;
31177 flag_NotZ = res;
31178 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31179 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31180 flag_N = res >> 24;
31181 POST_IO
31182RET(14)
31183}
31184
31185// CMP
31186OPCODE(0xB098)
31187{
31188 u32 adr, res;
31189 u32 src, dst;
31190
31191 adr = AREG((Opcode >> 0) & 7);
31192 AREG((Opcode >> 0) & 7) += 4;
31193 PRE_IO
31194 READ_LONG_F(adr, src)
31195 dst = DREGu32((Opcode >> 9) & 7);
31196 res = dst - src;
31197 flag_NotZ = res;
31198 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31199 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31200 flag_N = res >> 24;
31201 POST_IO
31202RET(14)
31203}
31204
31205// CMP
31206OPCODE(0xB0A0)
31207{
31208 u32 adr, res;
31209 u32 src, dst;
31210
31211 adr = AREG((Opcode >> 0) & 7) - 4;
31212 AREG((Opcode >> 0) & 7) = adr;
31213 PRE_IO
31214 READ_LONG_F(adr, src)
31215 dst = DREGu32((Opcode >> 9) & 7);
31216 res = dst - src;
31217 flag_NotZ = res;
31218 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31219 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31220 flag_N = res >> 24;
31221 POST_IO
31222RET(16)
31223}
31224
31225// CMP
31226OPCODE(0xB0A8)
31227{
31228 u32 adr, res;
31229 u32 src, dst;
31230
31231 FETCH_SWORD(adr);
31232 adr += AREG((Opcode >> 0) & 7);
31233 PRE_IO
31234 READ_LONG_F(adr, src)
31235 dst = DREGu32((Opcode >> 9) & 7);
31236 res = dst - src;
31237 flag_NotZ = res;
31238 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31239 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31240 flag_N = res >> 24;
31241 POST_IO
31242RET(18)
31243}
31244
31245// CMP
31246OPCODE(0xB0B0)
31247{
31248 u32 adr, res;
31249 u32 src, dst;
31250
31251 adr = AREG((Opcode >> 0) & 7);
31252 DECODE_EXT_WORD
31253 PRE_IO
31254 READ_LONG_F(adr, src)
31255 dst = DREGu32((Opcode >> 9) & 7);
31256 res = dst - src;
31257 flag_NotZ = res;
31258 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31259 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31260 flag_N = res >> 24;
31261 POST_IO
31262RET(20)
31263}
31264
31265// CMP
31266OPCODE(0xB0B8)
31267{
31268 u32 adr, res;
31269 u32 src, dst;
31270
31271 FETCH_SWORD(adr);
31272 PRE_IO
31273 READ_LONG_F(adr, src)
31274 dst = DREGu32((Opcode >> 9) & 7);
31275 res = dst - src;
31276 flag_NotZ = res;
31277 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31278 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31279 flag_N = res >> 24;
31280 POST_IO
31281RET(18)
31282}
31283
31284// CMP
31285OPCODE(0xB0B9)
31286{
31287 u32 adr, res;
31288 u32 src, dst;
31289
31290 FETCH_LONG(adr);
31291 PRE_IO
31292 READ_LONG_F(adr, src)
31293 dst = DREGu32((Opcode >> 9) & 7);
31294 res = dst - src;
31295 flag_NotZ = res;
31296 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31297 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31298 flag_N = res >> 24;
31299 POST_IO
31300RET(22)
31301}
31302
31303// CMP
31304OPCODE(0xB0BA)
31305{
31306 u32 adr, res;
31307 u32 src, dst;
31308
be26eb23 31309 adr = GET_SWORD + GET_PC;
70357ce5 31310 PC++;
31311 PRE_IO
31312 READ_LONG_F(adr, src)
31313 dst = DREGu32((Opcode >> 9) & 7);
31314 res = dst - src;
31315 flag_NotZ = res;
31316 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31317 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31318 flag_N = res >> 24;
31319 POST_IO
31320RET(18)
31321}
31322
31323// CMP
31324OPCODE(0xB0BB)
31325{
31326 u32 adr, res;
31327 u32 src, dst;
31328
be26eb23 31329 adr = GET_PC;
70357ce5 31330 DECODE_EXT_WORD
31331 PRE_IO
31332 READ_LONG_F(adr, src)
31333 dst = DREGu32((Opcode >> 9) & 7);
31334 res = dst - src;
31335 flag_NotZ = res;
31336 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31337 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31338 flag_N = res >> 24;
31339 POST_IO
31340RET(20)
31341}
31342
31343// CMP
31344OPCODE(0xB0BC)
31345{
31346 u32 adr, res;
31347 u32 src, dst;
31348
31349 FETCH_LONG(src);
31350 dst = DREGu32((Opcode >> 9) & 7);
31351 res = dst - src;
31352 flag_NotZ = res;
31353 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31354 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31355 flag_N = res >> 24;
31356RET(14)
31357}
31358
31359// CMP
31360OPCODE(0xB09F)
31361{
31362 u32 adr, res;
31363 u32 src, dst;
31364
31365 adr = AREG(7);
31366 AREG(7) += 4;
31367 PRE_IO
31368 READ_LONG_F(adr, src)
31369 dst = DREGu32((Opcode >> 9) & 7);
31370 res = dst - src;
31371 flag_NotZ = res;
31372 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31373 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31374 flag_N = res >> 24;
31375 POST_IO
31376RET(14)
31377}
31378
31379// CMP
31380OPCODE(0xB0A7)
31381{
31382 u32 adr, res;
31383 u32 src, dst;
31384
31385 adr = AREG(7) - 4;
31386 AREG(7) = adr;
31387 PRE_IO
31388 READ_LONG_F(adr, src)
31389 dst = DREGu32((Opcode >> 9) & 7);
31390 res = dst - src;
31391 flag_NotZ = res;
31392 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31393 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31394 flag_N = res >> 24;
31395 POST_IO
31396RET(16)
31397}
31398
31399// CMPM
31400OPCODE(0xB108)
31401{
31402 u32 adr, res;
31403 u32 src, dst;
31404
31405 adr = AREG((Opcode >> 0) & 7);
31406 AREG((Opcode >> 0) & 7) += 1;
31407 PRE_IO
31408 READ_BYTE_F(adr, src)
31409 adr = AREG((Opcode >> 9) & 7);
31410 AREG((Opcode >> 9) & 7) += 1;
31411 READ_BYTE_F(adr, dst)
31412 res = dst - src;
31413 flag_N = flag_C = res;
31414 flag_V = (src ^ dst) & (res ^ dst);
31415 flag_NotZ = res & 0xFF;
31416 POST_IO
31417RET(12)
31418}
31419
31420// CMPM
31421OPCODE(0xB148)
31422{
31423 u32 adr, res;
31424 u32 src, dst;
31425
31426 adr = AREG((Opcode >> 0) & 7);
31427 AREG((Opcode >> 0) & 7) += 2;
31428 PRE_IO
31429 READ_WORD_F(adr, src)
31430 adr = AREG((Opcode >> 9) & 7);
31431 AREG((Opcode >> 9) & 7) += 2;
31432 READ_WORD_F(adr, dst)
31433 res = dst - src;
31434 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31435 flag_N = flag_C = res >> 8;
31436 flag_NotZ = res & 0xFFFF;
31437 POST_IO
31438RET(12)
31439}
31440
31441// CMPM
31442OPCODE(0xB188)
31443{
31444 u32 adr, res;
31445 u32 src, dst;
31446
31447 adr = AREG((Opcode >> 0) & 7);
31448 AREG((Opcode >> 0) & 7) += 4;
31449 PRE_IO
31450 READ_LONG_F(adr, src)
31451 adr = AREG((Opcode >> 9) & 7);
31452 AREG((Opcode >> 9) & 7) += 4;
31453 READ_LONG_F(adr, dst)
31454 res = dst - src;
31455 flag_NotZ = res;
31456 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31457 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31458 flag_N = res >> 24;
31459 POST_IO
31460RET(20)
31461}
31462
31463// CMP7M
31464OPCODE(0xB10F)
31465{
31466 u32 adr, res;
31467 u32 src, dst;
31468
31469 adr = AREG(7);
31470 AREG(7) += 2;
31471 PRE_IO
31472 READ_BYTE_F(adr, src)
31473 adr = AREG((Opcode >> 9) & 7);
31474 AREG((Opcode >> 9) & 7) += 1;
31475 READ_BYTE_F(adr, dst)
31476 res = dst - src;
31477 flag_N = flag_C = res;
31478 flag_V = (src ^ dst) & (res ^ dst);
31479 flag_NotZ = res & 0xFF;
31480 POST_IO
31481RET(12)
31482}
31483
31484// CMP7M
31485OPCODE(0xB14F)
31486{
31487 u32 adr, res;
31488 u32 src, dst;
31489
31490 adr = AREG(7);
31491 AREG(7) += 2;
31492 PRE_IO
31493 READ_WORD_F(adr, src)
31494 adr = AREG((Opcode >> 9) & 7);
31495 AREG((Opcode >> 9) & 7) += 2;
31496 READ_WORD_F(adr, dst)
31497 res = dst - src;
31498 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31499 flag_N = flag_C = res >> 8;
31500 flag_NotZ = res & 0xFFFF;
31501 POST_IO
31502RET(12)
31503}
31504
31505// CMP7M
31506OPCODE(0xB18F)
31507{
31508 u32 adr, res;
31509 u32 src, dst;
31510
31511 adr = AREG(7);
31512 AREG(7) += 4;
31513 PRE_IO
31514 READ_LONG_F(adr, src)
31515 adr = AREG((Opcode >> 9) & 7);
31516 AREG((Opcode >> 9) & 7) += 4;
31517 READ_LONG_F(adr, dst)
31518 res = dst - src;
31519 flag_NotZ = res;
31520 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31521 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31522 flag_N = res >> 24;
31523 POST_IO
31524RET(20)
31525}
31526
31527// CMPM7
31528OPCODE(0xBF08)
31529{
31530 u32 adr, res;
31531 u32 src, dst;
31532
31533 adr = AREG((Opcode >> 0) & 7);
31534 AREG((Opcode >> 0) & 7) += 1;
31535 PRE_IO
31536 READ_BYTE_F(adr, src)
31537 adr = AREG(7);
31538 AREG(7) += 2;
31539 READ_BYTE_F(adr, dst)
31540 res = dst - src;
31541 flag_N = flag_C = res;
31542 flag_V = (src ^ dst) & (res ^ dst);
31543 flag_NotZ = res & 0xFF;
31544 POST_IO
31545RET(12)
31546}
31547
31548// CMPM7
31549OPCODE(0xBF48)
31550{
31551 u32 adr, res;
31552 u32 src, dst;
31553
31554 adr = AREG((Opcode >> 0) & 7);
31555 AREG((Opcode >> 0) & 7) += 2;
31556 PRE_IO
31557 READ_WORD_F(adr, src)
31558 adr = AREG(7);
31559 AREG(7) += 2;
31560 READ_WORD_F(adr, dst)
31561 res = dst - src;
31562 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31563 flag_N = flag_C = res >> 8;
31564 flag_NotZ = res & 0xFFFF;
31565 POST_IO
31566RET(12)
31567}
31568
31569// CMPM7
31570OPCODE(0xBF88)
31571{
31572 u32 adr, res;
31573 u32 src, dst;
31574
31575 adr = AREG((Opcode >> 0) & 7);
31576 AREG((Opcode >> 0) & 7) += 4;
31577 PRE_IO
31578 READ_LONG_F(adr, src)
31579 adr = AREG(7);
31580 AREG(7) += 4;
31581 READ_LONG_F(adr, dst)
31582 res = dst - src;
31583 flag_NotZ = res;
31584 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31585 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31586 flag_N = res >> 24;
31587 POST_IO
31588RET(20)
31589}
31590
31591// CMP7M7
31592OPCODE(0xBF0F)
31593{
31594 u32 adr, res;
31595 u32 src, dst;
31596
31597 adr = AREG(7);
31598 AREG(7) += 2;
31599 PRE_IO
31600 READ_BYTE_F(adr, src)
31601 adr = AREG(7);
31602 AREG(7) += 2;
31603 READ_BYTE_F(adr, dst)
31604 res = dst - src;
31605 flag_N = flag_C = res;
31606 flag_V = (src ^ dst) & (res ^ dst);
31607 flag_NotZ = res & 0xFF;
31608 POST_IO
31609RET(12)
31610}
31611
31612// CMP7M7
31613OPCODE(0xBF4F)
31614{
31615 u32 adr, res;
31616 u32 src, dst;
31617
31618 adr = AREG(7);
31619 AREG(7) += 2;
31620 PRE_IO
31621 READ_WORD_F(adr, src)
31622 adr = AREG(7);
31623 AREG(7) += 2;
31624 READ_WORD_F(adr, dst)
31625 res = dst - src;
31626 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31627 flag_N = flag_C = res >> 8;
31628 flag_NotZ = res & 0xFFFF;
31629 POST_IO
31630RET(12)
31631}
31632
31633// CMP7M7
31634OPCODE(0xBF8F)
31635{
31636 u32 adr, res;
31637 u32 src, dst;
31638
31639 adr = AREG(7);
31640 AREG(7) += 4;
31641 PRE_IO
31642 READ_LONG_F(adr, src)
31643 adr = AREG(7);
31644 AREG(7) += 4;
31645 READ_LONG_F(adr, dst)
31646 res = dst - src;
31647 flag_NotZ = res;
31648 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31649 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31650 flag_N = res >> 24;
31651 POST_IO
31652RET(20)
31653}
31654
31655// EORDa
31656OPCODE(0xB100)
31657{
31658 u32 adr, res;
31659 u32 src, dst;
31660
31661 src = DREGu8((Opcode >> 9) & 7);
31662 res = DREGu8((Opcode >> 0) & 7);
31663 res ^= src;
31664 flag_C = 0;
31665 flag_V = 0;
31666 flag_NotZ = res;
31667 flag_N = res;
31668 DREGu8((Opcode >> 0) & 7) = res;
31669RET(4)
31670}
31671
31672// EORDa
31673OPCODE(0xB110)
31674{
31675 u32 adr, res;
31676 u32 src, dst;
31677
31678 src = DREGu8((Opcode >> 9) & 7);
31679 adr = AREG((Opcode >> 0) & 7);
31680 PRE_IO
31681 READ_BYTE_F(adr, res)
31682 res ^= src;
31683 flag_C = 0;
31684 flag_V = 0;
31685 flag_NotZ = res;
31686 flag_N = res;
31687 WRITE_BYTE_F(adr, res)
31688 POST_IO
31689RET(12)
31690}
31691
31692// EORDa
31693OPCODE(0xB118)
31694{
31695 u32 adr, res;
31696 u32 src, dst;
31697
31698 src = DREGu8((Opcode >> 9) & 7);
31699 adr = AREG((Opcode >> 0) & 7);
31700 AREG((Opcode >> 0) & 7) += 1;
31701 PRE_IO
31702 READ_BYTE_F(adr, res)
31703 res ^= src;
31704 flag_C = 0;
31705 flag_V = 0;
31706 flag_NotZ = res;
31707 flag_N = res;
31708 WRITE_BYTE_F(adr, res)
31709 POST_IO
31710RET(12)
31711}
31712
31713// EORDa
31714OPCODE(0xB120)
31715{
31716 u32 adr, res;
31717 u32 src, dst;
31718
31719 src = DREGu8((Opcode >> 9) & 7);
31720 adr = AREG((Opcode >> 0) & 7) - 1;
31721 AREG((Opcode >> 0) & 7) = adr;
31722 PRE_IO
31723 READ_BYTE_F(adr, res)
31724 res ^= src;
31725 flag_C = 0;
31726 flag_V = 0;
31727 flag_NotZ = res;
31728 flag_N = res;
31729 WRITE_BYTE_F(adr, res)
31730 POST_IO
31731RET(14)
31732}
31733
31734// EORDa
31735OPCODE(0xB128)
31736{
31737 u32 adr, res;
31738 u32 src, dst;
31739
31740 src = DREGu8((Opcode >> 9) & 7);
31741 FETCH_SWORD(adr);
31742 adr += AREG((Opcode >> 0) & 7);
31743 PRE_IO
31744 READ_BYTE_F(adr, res)
31745 res ^= src;
31746 flag_C = 0;
31747 flag_V = 0;
31748 flag_NotZ = res;
31749 flag_N = res;
31750 WRITE_BYTE_F(adr, res)
31751 POST_IO
31752RET(16)
31753}
31754
31755// EORDa
31756OPCODE(0xB130)
31757{
31758 u32 adr, res;
31759 u32 src, dst;
31760
31761 src = DREGu8((Opcode >> 9) & 7);
31762 adr = AREG((Opcode >> 0) & 7);
31763 DECODE_EXT_WORD
31764 PRE_IO
31765 READ_BYTE_F(adr, res)
31766 res ^= src;
31767 flag_C = 0;
31768 flag_V = 0;
31769 flag_NotZ = res;
31770 flag_N = res;
31771 WRITE_BYTE_F(adr, res)
31772 POST_IO
31773RET(18)
31774}
31775
31776// EORDa
31777OPCODE(0xB138)
31778{
31779 u32 adr, res;
31780 u32 src, dst;
31781
31782 src = DREGu8((Opcode >> 9) & 7);
31783 FETCH_SWORD(adr);
31784 PRE_IO
31785 READ_BYTE_F(adr, res)
31786 res ^= src;
31787 flag_C = 0;
31788 flag_V = 0;
31789 flag_NotZ = res;
31790 flag_N = res;
31791 WRITE_BYTE_F(adr, res)
31792 POST_IO
31793RET(16)
31794}
31795
31796// EORDa
31797OPCODE(0xB139)
31798{
31799 u32 adr, res;
31800 u32 src, dst;
31801
31802 src = DREGu8((Opcode >> 9) & 7);
31803 FETCH_LONG(adr);
31804 PRE_IO
31805 READ_BYTE_F(adr, res)
31806 res ^= src;
31807 flag_C = 0;
31808 flag_V = 0;
31809 flag_NotZ = res;
31810 flag_N = res;
31811 WRITE_BYTE_F(adr, res)
31812 POST_IO
31813RET(20)
31814}
31815
31816// EORDa
31817OPCODE(0xB11F)
31818{
31819 u32 adr, res;
31820 u32 src, dst;
31821
31822 src = DREGu8((Opcode >> 9) & 7);
31823 adr = AREG(7);
31824 AREG(7) += 2;
31825 PRE_IO
31826 READ_BYTE_F(adr, res)
31827 res ^= src;
31828 flag_C = 0;
31829 flag_V = 0;
31830 flag_NotZ = res;
31831 flag_N = res;
31832 WRITE_BYTE_F(adr, res)
31833 POST_IO
31834RET(12)
31835}
31836
31837// EORDa
31838OPCODE(0xB127)
31839{
31840 u32 adr, res;
31841 u32 src, dst;
31842
31843 src = DREGu8((Opcode >> 9) & 7);
31844 adr = AREG(7) - 2;
31845 AREG(7) = adr;
31846 PRE_IO
31847 READ_BYTE_F(adr, res)
31848 res ^= src;
31849 flag_C = 0;
31850 flag_V = 0;
31851 flag_NotZ = res;
31852 flag_N = res;
31853 WRITE_BYTE_F(adr, res)
31854 POST_IO
31855RET(14)
31856}
31857
31858// EORDa
31859OPCODE(0xB140)
31860{
31861 u32 adr, res;
31862 u32 src, dst;
31863
31864 src = DREGu16((Opcode >> 9) & 7);
31865 res = DREGu16((Opcode >> 0) & 7);
31866 res ^= src;
31867 flag_C = 0;
31868 flag_V = 0;
31869 flag_NotZ = res;
31870 flag_N = res >> 8;
31871 DREGu16((Opcode >> 0) & 7) = res;
31872RET(4)
31873}
31874
31875// EORDa
31876OPCODE(0xB150)
31877{
31878 u32 adr, res;
31879 u32 src, dst;
31880
31881 src = DREGu16((Opcode >> 9) & 7);
31882 adr = AREG((Opcode >> 0) & 7);
31883 PRE_IO
31884 READ_WORD_F(adr, res)
31885 res ^= src;
31886 flag_C = 0;
31887 flag_V = 0;
31888 flag_NotZ = res;
31889 flag_N = res >> 8;
31890 WRITE_WORD_F(adr, res)
31891 POST_IO
31892RET(12)
31893}
31894
31895// EORDa
31896OPCODE(0xB158)
31897{
31898 u32 adr, res;
31899 u32 src, dst;
31900
31901 src = DREGu16((Opcode >> 9) & 7);
31902 adr = AREG((Opcode >> 0) & 7);
31903 AREG((Opcode >> 0) & 7) += 2;
31904 PRE_IO
31905 READ_WORD_F(adr, res)
31906 res ^= src;
31907 flag_C = 0;
31908 flag_V = 0;
31909 flag_NotZ = res;
31910 flag_N = res >> 8;
31911 WRITE_WORD_F(adr, res)
31912 POST_IO
31913RET(12)
31914}
31915
31916// EORDa
31917OPCODE(0xB160)
31918{
31919 u32 adr, res;
31920 u32 src, dst;
31921
31922 src = DREGu16((Opcode >> 9) & 7);
31923 adr = AREG((Opcode >> 0) & 7) - 2;
31924 AREG((Opcode >> 0) & 7) = adr;
31925 PRE_IO
31926 READ_WORD_F(adr, res)
31927 res ^= src;
31928 flag_C = 0;
31929 flag_V = 0;
31930 flag_NotZ = res;
31931 flag_N = res >> 8;
31932 WRITE_WORD_F(adr, res)
31933 POST_IO
31934RET(14)
31935}
31936
31937// EORDa
31938OPCODE(0xB168)
31939{
31940 u32 adr, res;
31941 u32 src, dst;
31942
31943 src = DREGu16((Opcode >> 9) & 7);
31944 FETCH_SWORD(adr);
31945 adr += AREG((Opcode >> 0) & 7);
31946 PRE_IO
31947 READ_WORD_F(adr, res)
31948 res ^= src;
31949 flag_C = 0;
31950 flag_V = 0;
31951 flag_NotZ = res;
31952 flag_N = res >> 8;
31953 WRITE_WORD_F(adr, res)
31954 POST_IO
31955RET(16)
31956}
31957
31958// EORDa
31959OPCODE(0xB170)
31960{
31961 u32 adr, res;
31962 u32 src, dst;
31963
31964 src = DREGu16((Opcode >> 9) & 7);
31965 adr = AREG((Opcode >> 0) & 7);
31966 DECODE_EXT_WORD
31967 PRE_IO
31968 READ_WORD_F(adr, res)
31969 res ^= src;
31970 flag_C = 0;
31971 flag_V = 0;
31972 flag_NotZ = res;
31973 flag_N = res >> 8;
31974 WRITE_WORD_F(adr, res)
31975 POST_IO
31976RET(18)
31977}
31978
31979// EORDa
31980OPCODE(0xB178)
31981{
31982 u32 adr, res;
31983 u32 src, dst;
31984
31985 src = DREGu16((Opcode >> 9) & 7);
31986 FETCH_SWORD(adr);
31987 PRE_IO
31988 READ_WORD_F(adr, res)
31989 res ^= src;
31990 flag_C = 0;
31991 flag_V = 0;
31992 flag_NotZ = res;
31993 flag_N = res >> 8;
31994 WRITE_WORD_F(adr, res)
31995 POST_IO
31996RET(16)
31997}
31998
31999// EORDa
32000OPCODE(0xB179)
32001{
32002 u32 adr, res;
32003 u32 src, dst;
32004
32005 src = DREGu16((Opcode >> 9) & 7);
32006 FETCH_LONG(adr);
32007 PRE_IO
32008 READ_WORD_F(adr, res)
32009 res ^= src;
32010 flag_C = 0;
32011 flag_V = 0;
32012 flag_NotZ = res;
32013 flag_N = res >> 8;
32014 WRITE_WORD_F(adr, res)
32015 POST_IO
32016RET(20)
32017}
32018
32019// EORDa
32020OPCODE(0xB15F)
32021{
32022 u32 adr, res;
32023 u32 src, dst;
32024
32025 src = DREGu16((Opcode >> 9) & 7);
32026 adr = AREG(7);
32027 AREG(7) += 2;
32028 PRE_IO
32029 READ_WORD_F(adr, res)
32030 res ^= src;
32031 flag_C = 0;
32032 flag_V = 0;
32033 flag_NotZ = res;
32034 flag_N = res >> 8;
32035 WRITE_WORD_F(adr, res)
32036 POST_IO
32037RET(12)
32038}
32039
32040// EORDa
32041OPCODE(0xB167)
32042{
32043 u32 adr, res;
32044 u32 src, dst;
32045
32046 src = DREGu16((Opcode >> 9) & 7);
32047 adr = AREG(7) - 2;
32048 AREG(7) = adr;
32049 PRE_IO
32050 READ_WORD_F(adr, res)
32051 res ^= src;
32052 flag_C = 0;
32053 flag_V = 0;
32054 flag_NotZ = res;
32055 flag_N = res >> 8;
32056 WRITE_WORD_F(adr, res)
32057 POST_IO
32058RET(14)
32059}
32060
32061// EORDa
32062OPCODE(0xB180)
32063{
32064 u32 adr, res;
32065 u32 src, dst;
32066
32067 src = DREGu32((Opcode >> 9) & 7);
32068 res = DREGu32((Opcode >> 0) & 7);
32069 res ^= src;
32070 flag_C = 0;
32071 flag_V = 0;
32072 flag_NotZ = res;
32073 flag_N = res >> 24;
32074 DREGu32((Opcode >> 0) & 7) = res;
32075RET(8)
32076}
32077
32078// EORDa
32079OPCODE(0xB190)
32080{
32081 u32 adr, res;
32082 u32 src, dst;
32083
32084 src = DREGu32((Opcode >> 9) & 7);
32085 adr = AREG((Opcode >> 0) & 7);
32086 PRE_IO
32087 READ_LONG_F(adr, res)
32088 res ^= src;
32089 flag_C = 0;
32090 flag_V = 0;
32091 flag_NotZ = res;
32092 flag_N = res >> 24;
32093 WRITE_LONG_F(adr, res)
32094 POST_IO
32095RET(20)
32096}
32097
32098// EORDa
32099OPCODE(0xB198)
32100{
32101 u32 adr, res;
32102 u32 src, dst;
32103
32104 src = DREGu32((Opcode >> 9) & 7);
32105 adr = AREG((Opcode >> 0) & 7);
32106 AREG((Opcode >> 0) & 7) += 4;
32107 PRE_IO
32108 READ_LONG_F(adr, res)
32109 res ^= src;
32110 flag_C = 0;
32111 flag_V = 0;
32112 flag_NotZ = res;
32113 flag_N = res >> 24;
32114 WRITE_LONG_F(adr, res)
32115 POST_IO
32116RET(20)
32117}
32118
32119// EORDa
32120OPCODE(0xB1A0)
32121{
32122 u32 adr, res;
32123 u32 src, dst;
32124
32125 src = DREGu32((Opcode >> 9) & 7);
32126 adr = AREG((Opcode >> 0) & 7) - 4;
32127 AREG((Opcode >> 0) & 7) = adr;
32128 PRE_IO
32129 READ_LONG_F(adr, res)
32130 res ^= src;
32131 flag_C = 0;
32132 flag_V = 0;
32133 flag_NotZ = res;
32134 flag_N = res >> 24;
32135 WRITE_LONG_F(adr, res)
32136 POST_IO
32137RET(22)
32138}
32139
32140// EORDa
32141OPCODE(0xB1A8)
32142{
32143 u32 adr, res;
32144 u32 src, dst;
32145
32146 src = DREGu32((Opcode >> 9) & 7);
32147 FETCH_SWORD(adr);
32148 adr += AREG((Opcode >> 0) & 7);
32149 PRE_IO
32150 READ_LONG_F(adr, res)
32151 res ^= src;
32152 flag_C = 0;
32153 flag_V = 0;
32154 flag_NotZ = res;
32155 flag_N = res >> 24;
32156 WRITE_LONG_F(adr, res)
32157 POST_IO
32158RET(24)
32159}
32160
32161// EORDa
32162OPCODE(0xB1B0)
32163{
32164 u32 adr, res;
32165 u32 src, dst;
32166
32167 src = DREGu32((Opcode >> 9) & 7);
32168 adr = AREG((Opcode >> 0) & 7);
32169 DECODE_EXT_WORD
32170 PRE_IO
32171 READ_LONG_F(adr, res)
32172 res ^= src;
32173 flag_C = 0;
32174 flag_V = 0;
32175 flag_NotZ = res;
32176 flag_N = res >> 24;
32177 WRITE_LONG_F(adr, res)
32178 POST_IO
32179RET(26)
32180}
32181
32182// EORDa
32183OPCODE(0xB1B8)
32184{
32185 u32 adr, res;
32186 u32 src, dst;
32187
32188 src = DREGu32((Opcode >> 9) & 7);
32189 FETCH_SWORD(adr);
32190 PRE_IO
32191 READ_LONG_F(adr, res)
32192 res ^= src;
32193 flag_C = 0;
32194 flag_V = 0;
32195 flag_NotZ = res;
32196 flag_N = res >> 24;
32197 WRITE_LONG_F(adr, res)
32198 POST_IO
32199RET(24)
32200}
32201
32202// EORDa
32203OPCODE(0xB1B9)
32204{
32205 u32 adr, res;
32206 u32 src, dst;
32207
32208 src = DREGu32((Opcode >> 9) & 7);
32209 FETCH_LONG(adr);
32210 PRE_IO
32211 READ_LONG_F(adr, res)
32212 res ^= src;
32213 flag_C = 0;
32214 flag_V = 0;
32215 flag_NotZ = res;
32216 flag_N = res >> 24;
32217 WRITE_LONG_F(adr, res)
32218 POST_IO
32219RET(28)
32220}
32221
32222// EORDa
32223OPCODE(0xB19F)
32224{
32225 u32 adr, res;
32226 u32 src, dst;
32227
32228 src = DREGu32((Opcode >> 9) & 7);
32229 adr = AREG(7);
32230 AREG(7) += 4;
32231 PRE_IO
32232 READ_LONG_F(adr, res)
32233 res ^= src;
32234 flag_C = 0;
32235 flag_V = 0;
32236 flag_NotZ = res;
32237 flag_N = res >> 24;
32238 WRITE_LONG_F(adr, res)
32239 POST_IO
32240RET(20)
32241}
32242
32243// EORDa
32244OPCODE(0xB1A7)
32245{
32246 u32 adr, res;
32247 u32 src, dst;
32248
32249 src = DREGu32((Opcode >> 9) & 7);
32250 adr = AREG(7) - 4;
32251 AREG(7) = adr;
32252 PRE_IO
32253 READ_LONG_F(adr, res)
32254 res ^= src;
32255 flag_C = 0;
32256 flag_V = 0;
32257 flag_NotZ = res;
32258 flag_N = res >> 24;
32259 WRITE_LONG_F(adr, res)
32260 POST_IO
32261RET(22)
32262}
32263
32264// CMPA
32265OPCODE(0xB0C0)
32266{
32267 u32 adr, res;
32268 u32 src, dst;
32269
32270 src = (s32)DREGs16((Opcode >> 0) & 7);
32271 dst = AREGu32((Opcode >> 9) & 7);
32272 res = dst - src;
32273 flag_NotZ = res;
32274 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32275 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32276 flag_N = res >> 24;
32277RET(6)
32278}
32279
32280// CMPA
32281OPCODE(0xB0C8)
32282{
32283 u32 adr, res;
32284 u32 src, dst;
32285
32286 src = (s32)AREGs16((Opcode >> 0) & 7);
32287 dst = AREGu32((Opcode >> 9) & 7);
32288 res = dst - src;
32289 flag_NotZ = res;
32290 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32291 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32292 flag_N = res >> 24;
32293RET(6)
32294}
32295
32296// CMPA
32297OPCODE(0xB0D0)
32298{
32299 u32 adr, res;
32300 u32 src, dst;
32301
32302 adr = AREG((Opcode >> 0) & 7);
32303 PRE_IO
32304 READSX_WORD_F(adr, src)
32305 dst = AREGu32((Opcode >> 9) & 7);
32306 res = dst - src;
32307 flag_NotZ = res;
32308 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32309 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32310 flag_N = res >> 24;
32311 POST_IO
32312RET(10)
32313}
32314
32315// CMPA
32316OPCODE(0xB0D8)
32317{
32318 u32 adr, res;
32319 u32 src, dst;
32320
32321 adr = AREG((Opcode >> 0) & 7);
32322 AREG((Opcode >> 0) & 7) += 2;
32323 PRE_IO
32324 READSX_WORD_F(adr, src)
32325 dst = AREGu32((Opcode >> 9) & 7);
32326 res = dst - src;
32327 flag_NotZ = res;
32328 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32329 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32330 flag_N = res >> 24;
32331 POST_IO
32332RET(10)
32333}
32334
32335// CMPA
32336OPCODE(0xB0E0)
32337{
32338 u32 adr, res;
32339 u32 src, dst;
32340
32341 adr = AREG((Opcode >> 0) & 7) - 2;
32342 AREG((Opcode >> 0) & 7) = adr;
32343 PRE_IO
32344 READSX_WORD_F(adr, src)
32345 dst = AREGu32((Opcode >> 9) & 7);
32346 res = dst - src;
32347 flag_NotZ = res;
32348 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32349 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32350 flag_N = res >> 24;
32351 POST_IO
32352RET(12)
32353}
32354
32355// CMPA
32356OPCODE(0xB0E8)
32357{
32358 u32 adr, res;
32359 u32 src, dst;
32360
32361 FETCH_SWORD(adr);
32362 adr += AREG((Opcode >> 0) & 7);
32363 PRE_IO
32364 READSX_WORD_F(adr, src)
32365 dst = AREGu32((Opcode >> 9) & 7);
32366 res = dst - src;
32367 flag_NotZ = res;
32368 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32369 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32370 flag_N = res >> 24;
32371 POST_IO
32372RET(14)
32373}
32374
32375// CMPA
32376OPCODE(0xB0F0)
32377{
32378 u32 adr, res;
32379 u32 src, dst;
32380
32381 adr = AREG((Opcode >> 0) & 7);
32382 DECODE_EXT_WORD
32383 PRE_IO
32384 READSX_WORD_F(adr, src)
32385 dst = AREGu32((Opcode >> 9) & 7);
32386 res = dst - src;
32387 flag_NotZ = res;
32388 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32389 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32390 flag_N = res >> 24;
32391 POST_IO
32392RET(16)
32393}
32394
32395// CMPA
32396OPCODE(0xB0F8)
32397{
32398 u32 adr, res;
32399 u32 src, dst;
32400
32401 FETCH_SWORD(adr);
32402 PRE_IO
32403 READSX_WORD_F(adr, src)
32404 dst = AREGu32((Opcode >> 9) & 7);
32405 res = dst - src;
32406 flag_NotZ = res;
32407 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32408 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32409 flag_N = res >> 24;
32410 POST_IO
32411RET(14)
32412}
32413
32414// CMPA
32415OPCODE(0xB0F9)
32416{
32417 u32 adr, res;
32418 u32 src, dst;
32419
32420 FETCH_LONG(adr);
32421 PRE_IO
32422 READSX_WORD_F(adr, src)
32423 dst = AREGu32((Opcode >> 9) & 7);
32424 res = dst - src;
32425 flag_NotZ = res;
32426 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32427 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32428 flag_N = res >> 24;
32429 POST_IO
32430RET(18)
32431}
32432
32433// CMPA
32434OPCODE(0xB0FA)
32435{
32436 u32 adr, res;
32437 u32 src, dst;
32438
be26eb23 32439 adr = GET_SWORD + GET_PC;
70357ce5 32440 PC++;
32441 PRE_IO
32442 READSX_WORD_F(adr, src)
32443 dst = AREGu32((Opcode >> 9) & 7);
32444 res = dst - src;
32445 flag_NotZ = res;
32446 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32447 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32448 flag_N = res >> 24;
32449 POST_IO
32450RET(14)
32451}
32452
32453// CMPA
32454OPCODE(0xB0FB)
32455{
32456 u32 adr, res;
32457 u32 src, dst;
32458
be26eb23 32459 adr = GET_PC;
70357ce5 32460 DECODE_EXT_WORD
32461 PRE_IO
32462 READSX_WORD_F(adr, src)
32463 dst = AREGu32((Opcode >> 9) & 7);
32464 res = dst - src;
32465 flag_NotZ = res;
32466 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32467 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32468 flag_N = res >> 24;
32469 POST_IO
32470RET(16)
32471}
32472
32473// CMPA
32474OPCODE(0xB0FC)
32475{
32476 u32 adr, res;
32477 u32 src, dst;
32478
32479 FETCH_SWORD(src);
32480 dst = AREGu32((Opcode >> 9) & 7);
32481 res = dst - src;
32482 flag_NotZ = res;
32483 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32484 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32485 flag_N = res >> 24;
32486RET(10)
32487}
32488
32489// CMPA
32490OPCODE(0xB0DF)
32491{
32492 u32 adr, res;
32493 u32 src, dst;
32494
32495 adr = AREG(7);
32496 AREG(7) += 2;
32497 PRE_IO
32498 READSX_WORD_F(adr, src)
32499 dst = AREGu32((Opcode >> 9) & 7);
32500 res = dst - src;
32501 flag_NotZ = res;
32502 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32503 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32504 flag_N = res >> 24;
32505 POST_IO
32506RET(10)
32507}
32508
32509// CMPA
32510OPCODE(0xB0E7)
32511{
32512 u32 adr, res;
32513 u32 src, dst;
32514
32515 adr = AREG(7) - 2;
32516 AREG(7) = adr;
32517 PRE_IO
32518 READSX_WORD_F(adr, src)
32519 dst = AREGu32((Opcode >> 9) & 7);
32520 res = dst - src;
32521 flag_NotZ = res;
32522 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32523 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32524 flag_N = res >> 24;
32525 POST_IO
32526RET(12)
32527}
32528
32529// CMPA
32530OPCODE(0xB1C0)
32531{
32532 u32 adr, res;
32533 u32 src, dst;
32534
32535 src = (s32)DREGs32((Opcode >> 0) & 7);
32536 dst = AREGu32((Opcode >> 9) & 7);
32537 res = dst - src;
32538 flag_NotZ = res;
32539 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32540 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32541 flag_N = res >> 24;
32542RET(6)
32543}
32544
32545// CMPA
32546OPCODE(0xB1C8)
32547{
32548 u32 adr, res;
32549 u32 src, dst;
32550
32551 src = (s32)AREGs32((Opcode >> 0) & 7);
32552 dst = AREGu32((Opcode >> 9) & 7);
32553 res = dst - src;
32554 flag_NotZ = res;
32555 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32556 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32557 flag_N = res >> 24;
32558RET(6)
32559}
32560
32561// CMPA
32562OPCODE(0xB1D0)
32563{
32564 u32 adr, res;
32565 u32 src, dst;
32566
32567 adr = AREG((Opcode >> 0) & 7);
32568 PRE_IO
32569 READSX_LONG_F(adr, src)
32570 dst = AREGu32((Opcode >> 9) & 7);
32571 res = dst - src;
32572 flag_NotZ = res;
32573 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32574 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32575 flag_N = res >> 24;
32576 POST_IO
32577RET(14)
32578}
32579
32580// CMPA
32581OPCODE(0xB1D8)
32582{
32583 u32 adr, res;
32584 u32 src, dst;
32585
32586 adr = AREG((Opcode >> 0) & 7);
32587 AREG((Opcode >> 0) & 7) += 4;
32588 PRE_IO
32589 READSX_LONG_F(adr, src)
32590 dst = AREGu32((Opcode >> 9) & 7);
32591 res = dst - src;
32592 flag_NotZ = res;
32593 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32594 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32595 flag_N = res >> 24;
32596 POST_IO
32597RET(14)
32598}
32599
32600// CMPA
32601OPCODE(0xB1E0)
32602{
32603 u32 adr, res;
32604 u32 src, dst;
32605
32606 adr = AREG((Opcode >> 0) & 7) - 4;
32607 AREG((Opcode >> 0) & 7) = adr;
32608 PRE_IO
32609 READSX_LONG_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(16)
32618}
32619
32620// CMPA
32621OPCODE(0xB1E8)
32622{
32623 u32 adr, res;
32624 u32 src, dst;
32625
32626 FETCH_SWORD(adr);
32627 adr += AREG((Opcode >> 0) & 7);
32628 PRE_IO
32629 READSX_LONG_F(adr, src)
32630 dst = AREGu32((Opcode >> 9) & 7);
32631 res = dst - src;
32632 flag_NotZ = res;
32633 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32634 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32635 flag_N = res >> 24;
32636 POST_IO
32637RET(18)
32638}
32639
32640// CMPA
32641OPCODE(0xB1F0)
32642{
32643 u32 adr, res;
32644 u32 src, dst;
32645
32646 adr = AREG((Opcode >> 0) & 7);
32647 DECODE_EXT_WORD
32648 PRE_IO
32649 READSX_LONG_F(adr, src)
32650 dst = AREGu32((Opcode >> 9) & 7);
32651 res = dst - src;
32652 flag_NotZ = res;
32653 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32654 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32655 flag_N = res >> 24;
32656 POST_IO
32657RET(20)
32658}
32659
32660// CMPA
32661OPCODE(0xB1F8)
32662{
32663 u32 adr, res;
32664 u32 src, dst;
32665
32666 FETCH_SWORD(adr);
32667 PRE_IO
32668 READSX_LONG_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(18)
32677}
32678
32679// CMPA
32680OPCODE(0xB1F9)
32681{
32682 u32 adr, res;
32683 u32 src, dst;
32684
32685 FETCH_LONG(adr);
32686 PRE_IO
32687 READSX_LONG_F(adr, src)
32688 dst = AREGu32((Opcode >> 9) & 7);
32689 res = dst - src;
32690 flag_NotZ = res;
32691 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32692 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32693 flag_N = res >> 24;
32694 POST_IO
32695RET(22)
32696}
32697
32698// CMPA
32699OPCODE(0xB1FA)
32700{
32701 u32 adr, res;
32702 u32 src, dst;
32703
be26eb23 32704 adr = GET_SWORD + GET_PC;
70357ce5 32705 PC++;
32706 PRE_IO
32707 READSX_LONG_F(adr, src)
32708 dst = AREGu32((Opcode >> 9) & 7);
32709 res = dst - src;
32710 flag_NotZ = res;
32711 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32712 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32713 flag_N = res >> 24;
32714 POST_IO
32715RET(18)
32716}
32717
32718// CMPA
32719OPCODE(0xB1FB)
32720{
32721 u32 adr, res;
32722 u32 src, dst;
32723
be26eb23 32724 adr = GET_PC;
70357ce5 32725 DECODE_EXT_WORD
32726 PRE_IO
32727 READSX_LONG_F(adr, src)
32728 dst = AREGu32((Opcode >> 9) & 7);
32729 res = dst - src;
32730 flag_NotZ = res;
32731 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32732 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32733 flag_N = res >> 24;
32734 POST_IO
32735RET(20)
32736}
32737
32738// CMPA
32739OPCODE(0xB1FC)
32740{
32741 u32 adr, res;
32742 u32 src, dst;
32743
32744 FETCH_LONG(src);
32745 dst = AREGu32((Opcode >> 9) & 7);
32746 res = dst - src;
32747 flag_NotZ = res;
32748 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32749 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32750 flag_N = res >> 24;
32751RET(14)
32752}
32753
32754// CMPA
32755OPCODE(0xB1DF)
32756{
32757 u32 adr, res;
32758 u32 src, dst;
32759
32760 adr = AREG(7);
32761 AREG(7) += 4;
32762 PRE_IO
32763 READSX_LONG_F(adr, src)
32764 dst = AREGu32((Opcode >> 9) & 7);
32765 res = dst - src;
32766 flag_NotZ = res;
32767 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32768 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32769 flag_N = res >> 24;
32770 POST_IO
32771RET(14)
32772}
32773
32774// CMPA
32775OPCODE(0xB1E7)
32776{
32777 u32 adr, res;
32778 u32 src, dst;
32779
32780 adr = AREG(7) - 4;
32781 AREG(7) = adr;
32782 PRE_IO
32783 READSX_LONG_F(adr, src)
32784 dst = AREGu32((Opcode >> 9) & 7);
32785 res = dst - src;
32786 flag_NotZ = res;
32787 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32788 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32789 flag_N = res >> 24;
32790 POST_IO
32791RET(16)
32792}
32793
32794// ANDaD
32795OPCODE(0xC000)
32796{
32797 u32 adr, res;
32798 u32 src, dst;
32799
32800 src = DREGu8((Opcode >> 0) & 7);
32801 res = DREGu8((Opcode >> 9) & 7);
32802 res &= src;
32803 flag_C = 0;
32804 flag_V = 0;
32805 flag_NotZ = res;
32806 flag_N = res;
32807 DREGu8((Opcode >> 9) & 7) = res;
32808RET(4)
32809}
32810
32811// ANDaD
32812OPCODE(0xC010)
32813{
32814 u32 adr, res;
32815 u32 src, dst;
32816
32817 adr = AREG((Opcode >> 0) & 7);
32818 PRE_IO
32819 READ_BYTE_F(adr, src)
32820 res = DREGu8((Opcode >> 9) & 7);
32821 res &= src;
32822 flag_C = 0;
32823 flag_V = 0;
32824 flag_NotZ = res;
32825 flag_N = res;
32826 DREGu8((Opcode >> 9) & 7) = res;
32827 POST_IO
32828RET(8)
32829}
32830
32831// ANDaD
32832OPCODE(0xC018)
32833{
32834 u32 adr, res;
32835 u32 src, dst;
32836
32837 adr = AREG((Opcode >> 0) & 7);
32838 AREG((Opcode >> 0) & 7) += 1;
32839 PRE_IO
32840 READ_BYTE_F(adr, src)
32841 res = DREGu8((Opcode >> 9) & 7);
32842 res &= src;
32843 flag_C = 0;
32844 flag_V = 0;
32845 flag_NotZ = res;
32846 flag_N = res;
32847 DREGu8((Opcode >> 9) & 7) = res;
32848 POST_IO
32849RET(8)
32850}
32851
32852// ANDaD
32853OPCODE(0xC020)
32854{
32855 u32 adr, res;
32856 u32 src, dst;
32857
32858 adr = AREG((Opcode >> 0) & 7) - 1;
32859 AREG((Opcode >> 0) & 7) = adr;
32860 PRE_IO
32861 READ_BYTE_F(adr, src)
32862 res = DREGu8((Opcode >> 9) & 7);
32863 res &= src;
32864 flag_C = 0;
32865 flag_V = 0;
32866 flag_NotZ = res;
32867 flag_N = res;
32868 DREGu8((Opcode >> 9) & 7) = res;
32869 POST_IO
32870RET(10)
32871}
32872
32873// ANDaD
32874OPCODE(0xC028)
32875{
32876 u32 adr, res;
32877 u32 src, dst;
32878
32879 FETCH_SWORD(adr);
32880 adr += AREG((Opcode >> 0) & 7);
32881 PRE_IO
32882 READ_BYTE_F(adr, src)
32883 res = DREGu8((Opcode >> 9) & 7);
32884 res &= src;
32885 flag_C = 0;
32886 flag_V = 0;
32887 flag_NotZ = res;
32888 flag_N = res;
32889 DREGu8((Opcode >> 9) & 7) = res;
32890 POST_IO
32891RET(12)
32892}
32893
32894// ANDaD
32895OPCODE(0xC030)
32896{
32897 u32 adr, res;
32898 u32 src, dst;
32899
32900 adr = AREG((Opcode >> 0) & 7);
32901 DECODE_EXT_WORD
32902 PRE_IO
32903 READ_BYTE_F(adr, src)
32904 res = DREGu8((Opcode >> 9) & 7);
32905 res &= src;
32906 flag_C = 0;
32907 flag_V = 0;
32908 flag_NotZ = res;
32909 flag_N = res;
32910 DREGu8((Opcode >> 9) & 7) = res;
32911 POST_IO
32912RET(14)
32913}
32914
32915// ANDaD
32916OPCODE(0xC038)
32917{
32918 u32 adr, res;
32919 u32 src, dst;
32920
32921 FETCH_SWORD(adr);
32922 PRE_IO
32923 READ_BYTE_F(adr, src)
32924 res = DREGu8((Opcode >> 9) & 7);
32925 res &= src;
32926 flag_C = 0;
32927 flag_V = 0;
32928 flag_NotZ = res;
32929 flag_N = res;
32930 DREGu8((Opcode >> 9) & 7) = res;
32931 POST_IO
32932RET(12)
32933}
32934
32935// ANDaD
32936OPCODE(0xC039)
32937{
32938 u32 adr, res;
32939 u32 src, dst;
32940
32941 FETCH_LONG(adr);
32942 PRE_IO
32943 READ_BYTE_F(adr, src)
32944 res = DREGu8((Opcode >> 9) & 7);
32945 res &= src;
32946 flag_C = 0;
32947 flag_V = 0;
32948 flag_NotZ = res;
32949 flag_N = res;
32950 DREGu8((Opcode >> 9) & 7) = res;
32951 POST_IO
32952RET(16)
32953}
32954
32955// ANDaD
32956OPCODE(0xC03A)
32957{
32958 u32 adr, res;
32959 u32 src, dst;
32960
be26eb23 32961 adr = GET_SWORD + GET_PC;
70357ce5 32962 PC++;
32963 PRE_IO
32964 READ_BYTE_F(adr, src)
32965 res = DREGu8((Opcode >> 9) & 7);
32966 res &= src;
32967 flag_C = 0;
32968 flag_V = 0;
32969 flag_NotZ = res;
32970 flag_N = res;
32971 DREGu8((Opcode >> 9) & 7) = res;
32972 POST_IO
32973RET(12)
32974}
32975
32976// ANDaD
32977OPCODE(0xC03B)
32978{
32979 u32 adr, res;
32980 u32 src, dst;
32981
be26eb23 32982 adr = GET_PC;
70357ce5 32983 DECODE_EXT_WORD
32984 PRE_IO
32985 READ_BYTE_F(adr, src)
32986 res = DREGu8((Opcode >> 9) & 7);
32987 res &= src;
32988 flag_C = 0;
32989 flag_V = 0;
32990 flag_NotZ = res;
32991 flag_N = res;
32992 DREGu8((Opcode >> 9) & 7) = res;
32993 POST_IO
32994RET(14)
32995}
32996
32997// ANDaD
32998OPCODE(0xC03C)
32999{
33000 u32 adr, res;
33001 u32 src, dst;
33002
33003 FETCH_BYTE(src);
33004 res = DREGu8((Opcode >> 9) & 7);
33005 res &= src;
33006 flag_C = 0;
33007 flag_V = 0;
33008 flag_NotZ = res;
33009 flag_N = res;
33010 DREGu8((Opcode >> 9) & 7) = res;
33011RET(8)
33012}
33013
33014// ANDaD
33015OPCODE(0xC01F)
33016{
33017 u32 adr, res;
33018 u32 src, dst;
33019
33020 adr = AREG(7);
33021 AREG(7) += 2;
33022 PRE_IO
33023 READ_BYTE_F(adr, src)
33024 res = DREGu8((Opcode >> 9) & 7);
33025 res &= src;
33026 flag_C = 0;
33027 flag_V = 0;
33028 flag_NotZ = res;
33029 flag_N = res;
33030 DREGu8((Opcode >> 9) & 7) = res;
33031 POST_IO
33032RET(8)
33033}
33034
33035// ANDaD
33036OPCODE(0xC027)
33037{
33038 u32 adr, res;
33039 u32 src, dst;
33040
33041 adr = AREG(7) - 2;
33042 AREG(7) = adr;
33043 PRE_IO
33044 READ_BYTE_F(adr, src)
33045 res = DREGu8((Opcode >> 9) & 7);
33046 res &= src;
33047 flag_C = 0;
33048 flag_V = 0;
33049 flag_NotZ = res;
33050 flag_N = res;
33051 DREGu8((Opcode >> 9) & 7) = res;
33052 POST_IO
33053RET(10)
33054}
33055
33056// ANDaD
33057OPCODE(0xC040)
33058{
33059 u32 adr, res;
33060 u32 src, dst;
33061
33062 src = DREGu16((Opcode >> 0) & 7);
33063 res = DREGu16((Opcode >> 9) & 7);
33064 res &= src;
33065 flag_C = 0;
33066 flag_V = 0;
33067 flag_NotZ = res;
33068 flag_N = res >> 8;
33069 DREGu16((Opcode >> 9) & 7) = res;
33070RET(4)
33071}
33072
33073// ANDaD
33074OPCODE(0xC050)
33075{
33076 u32 adr, res;
33077 u32 src, dst;
33078
33079 adr = AREG((Opcode >> 0) & 7);
33080 PRE_IO
33081 READ_WORD_F(adr, src)
33082 res = DREGu16((Opcode >> 9) & 7);
33083 res &= src;
33084 flag_C = 0;
33085 flag_V = 0;
33086 flag_NotZ = res;
33087 flag_N = res >> 8;
33088 DREGu16((Opcode >> 9) & 7) = res;
33089 POST_IO
33090RET(8)
33091}
33092
33093// ANDaD
33094OPCODE(0xC058)
33095{
33096 u32 adr, res;
33097 u32 src, dst;
33098
33099 adr = AREG((Opcode >> 0) & 7);
33100 AREG((Opcode >> 0) & 7) += 2;
33101 PRE_IO
33102 READ_WORD_F(adr, src)
33103 res = DREGu16((Opcode >> 9) & 7);
33104 res &= src;
33105 flag_C = 0;
33106 flag_V = 0;
33107 flag_NotZ = res;
33108 flag_N = res >> 8;
33109 DREGu16((Opcode >> 9) & 7) = res;
33110 POST_IO
33111RET(8)
33112}
33113
33114// ANDaD
33115OPCODE(0xC060)
33116{
33117 u32 adr, res;
33118 u32 src, dst;
33119
33120 adr = AREG((Opcode >> 0) & 7) - 2;
33121 AREG((Opcode >> 0) & 7) = adr;
33122 PRE_IO
33123 READ_WORD_F(adr, src)
33124 res = DREGu16((Opcode >> 9) & 7);
33125 res &= src;
33126 flag_C = 0;
33127 flag_V = 0;
33128 flag_NotZ = res;
33129 flag_N = res >> 8;
33130 DREGu16((Opcode >> 9) & 7) = res;
33131 POST_IO
33132RET(10)
33133}
33134
33135// ANDaD
33136OPCODE(0xC068)
33137{
33138 u32 adr, res;
33139 u32 src, dst;
33140
33141 FETCH_SWORD(adr);
33142 adr += AREG((Opcode >> 0) & 7);
33143 PRE_IO
33144 READ_WORD_F(adr, src)
33145 res = DREGu16((Opcode >> 9) & 7);
33146 res &= src;
33147 flag_C = 0;
33148 flag_V = 0;
33149 flag_NotZ = res;
33150 flag_N = res >> 8;
33151 DREGu16((Opcode >> 9) & 7) = res;
33152 POST_IO
33153RET(12)
33154}
33155
33156// ANDaD
33157OPCODE(0xC070)
33158{
33159 u32 adr, res;
33160 u32 src, dst;
33161
33162 adr = AREG((Opcode >> 0) & 7);
33163 DECODE_EXT_WORD
33164 PRE_IO
33165 READ_WORD_F(adr, src)
33166 res = DREGu16((Opcode >> 9) & 7);
33167 res &= src;
33168 flag_C = 0;
33169 flag_V = 0;
33170 flag_NotZ = res;
33171 flag_N = res >> 8;
33172 DREGu16((Opcode >> 9) & 7) = res;
33173 POST_IO
33174RET(14)
33175}
33176
33177// ANDaD
33178OPCODE(0xC078)
33179{
33180 u32 adr, res;
33181 u32 src, dst;
33182
33183 FETCH_SWORD(adr);
33184 PRE_IO
33185 READ_WORD_F(adr, src)
33186 res = DREGu16((Opcode >> 9) & 7);
33187 res &= src;
33188 flag_C = 0;
33189 flag_V = 0;
33190 flag_NotZ = res;
33191 flag_N = res >> 8;
33192 DREGu16((Opcode >> 9) & 7) = res;
33193 POST_IO
33194RET(12)
33195}
33196
33197// ANDaD
33198OPCODE(0xC079)
33199{
33200 u32 adr, res;
33201 u32 src, dst;
33202
33203 FETCH_LONG(adr);
33204 PRE_IO
33205 READ_WORD_F(adr, src)
33206 res = DREGu16((Opcode >> 9) & 7);
33207 res &= src;
33208 flag_C = 0;
33209 flag_V = 0;
33210 flag_NotZ = res;
33211 flag_N = res >> 8;
33212 DREGu16((Opcode >> 9) & 7) = res;
33213 POST_IO
33214RET(16)
33215}
33216
33217// ANDaD
33218OPCODE(0xC07A)
33219{
33220 u32 adr, res;
33221 u32 src, dst;
33222
be26eb23 33223 adr = GET_SWORD + GET_PC;
70357ce5 33224 PC++;
33225 PRE_IO
33226 READ_WORD_F(adr, src)
33227 res = DREGu16((Opcode >> 9) & 7);
33228 res &= src;
33229 flag_C = 0;
33230 flag_V = 0;
33231 flag_NotZ = res;
33232 flag_N = res >> 8;
33233 DREGu16((Opcode >> 9) & 7) = res;
33234 POST_IO
33235RET(12)
33236}
33237
33238// ANDaD
33239OPCODE(0xC07B)
33240{
33241 u32 adr, res;
33242 u32 src, dst;
33243
be26eb23 33244 adr = GET_PC;
70357ce5 33245 DECODE_EXT_WORD
33246 PRE_IO
33247 READ_WORD_F(adr, src)
33248 res = DREGu16((Opcode >> 9) & 7);
33249 res &= src;
33250 flag_C = 0;
33251 flag_V = 0;
33252 flag_NotZ = res;
33253 flag_N = res >> 8;
33254 DREGu16((Opcode >> 9) & 7) = res;
33255 POST_IO
33256RET(14)
33257}
33258
33259// ANDaD
33260OPCODE(0xC07C)
33261{
33262 u32 adr, res;
33263 u32 src, dst;
33264
33265 FETCH_WORD(src);
33266 res = DREGu16((Opcode >> 9) & 7);
33267 res &= src;
33268 flag_C = 0;
33269 flag_V = 0;
33270 flag_NotZ = res;
33271 flag_N = res >> 8;
33272 DREGu16((Opcode >> 9) & 7) = res;
33273RET(8)
33274}
33275
33276// ANDaD
33277OPCODE(0xC05F)
33278{
33279 u32 adr, res;
33280 u32 src, dst;
33281
33282 adr = AREG(7);
33283 AREG(7) += 2;
33284 PRE_IO
33285 READ_WORD_F(adr, src)
33286 res = DREGu16((Opcode >> 9) & 7);
33287 res &= src;
33288 flag_C = 0;
33289 flag_V = 0;
33290 flag_NotZ = res;
33291 flag_N = res >> 8;
33292 DREGu16((Opcode >> 9) & 7) = res;
33293 POST_IO
33294RET(8)
33295}
33296
33297// ANDaD
33298OPCODE(0xC067)
33299{
33300 u32 adr, res;
33301 u32 src, dst;
33302
33303 adr = AREG(7) - 2;
33304 AREG(7) = adr;
33305 PRE_IO
33306 READ_WORD_F(adr, src)
33307 res = DREGu16((Opcode >> 9) & 7);
33308 res &= src;
33309 flag_C = 0;
33310 flag_V = 0;
33311 flag_NotZ = res;
33312 flag_N = res >> 8;
33313 DREGu16((Opcode >> 9) & 7) = res;
33314 POST_IO
33315RET(10)
33316}
33317
33318// ANDaD
33319OPCODE(0xC080)
33320{
33321 u32 adr, res;
33322 u32 src, dst;
33323
33324 src = DREGu32((Opcode >> 0) & 7);
33325 res = DREGu32((Opcode >> 9) & 7);
33326 res &= src;
33327 flag_C = 0;
33328 flag_V = 0;
33329 flag_NotZ = res;
33330 flag_N = res >> 24;
33331 DREGu32((Opcode >> 9) & 7) = res;
33332RET(8)
33333}
33334
33335// ANDaD
33336OPCODE(0xC090)
33337{
33338 u32 adr, res;
33339 u32 src, dst;
33340
33341 adr = AREG((Opcode >> 0) & 7);
33342 PRE_IO
33343 READ_LONG_F(adr, src)
33344 res = DREGu32((Opcode >> 9) & 7);
33345 res &= src;
33346 flag_C = 0;
33347 flag_V = 0;
33348 flag_NotZ = res;
33349 flag_N = res >> 24;
33350 DREGu32((Opcode >> 9) & 7) = res;
33351 POST_IO
33352RET(14)
33353}
33354
33355// ANDaD
33356OPCODE(0xC098)
33357{
33358 u32 adr, res;
33359 u32 src, dst;
33360
33361 adr = AREG((Opcode >> 0) & 7);
33362 AREG((Opcode >> 0) & 7) += 4;
33363 PRE_IO
33364 READ_LONG_F(adr, src)
33365 res = DREGu32((Opcode >> 9) & 7);
33366 res &= src;
33367 flag_C = 0;
33368 flag_V = 0;
33369 flag_NotZ = res;
33370 flag_N = res >> 24;
33371 DREGu32((Opcode >> 9) & 7) = res;
33372 POST_IO
33373RET(14)
33374}
33375
33376// ANDaD
33377OPCODE(0xC0A0)
33378{
33379 u32 adr, res;
33380 u32 src, dst;
33381
33382 adr = AREG((Opcode >> 0) & 7) - 4;
33383 AREG((Opcode >> 0) & 7) = adr;
33384 PRE_IO
33385 READ_LONG_F(adr, src)
33386 res = DREGu32((Opcode >> 9) & 7);
33387 res &= src;
33388 flag_C = 0;
33389 flag_V = 0;
33390 flag_NotZ = res;
33391 flag_N = res >> 24;
33392 DREGu32((Opcode >> 9) & 7) = res;
33393 POST_IO
33394RET(16)
33395}
33396
33397// ANDaD
33398OPCODE(0xC0A8)
33399{
33400 u32 adr, res;
33401 u32 src, dst;
33402
33403 FETCH_SWORD(adr);
33404 adr += AREG((Opcode >> 0) & 7);
33405 PRE_IO
33406 READ_LONG_F(adr, src)
33407 res = DREGu32((Opcode >> 9) & 7);
33408 res &= src;
33409 flag_C = 0;
33410 flag_V = 0;
33411 flag_NotZ = res;
33412 flag_N = res >> 24;
33413 DREGu32((Opcode >> 9) & 7) = res;
33414 POST_IO
33415RET(18)
33416}
33417
33418// ANDaD
33419OPCODE(0xC0B0)
33420{
33421 u32 adr, res;
33422 u32 src, dst;
33423
33424 adr = AREG((Opcode >> 0) & 7);
33425 DECODE_EXT_WORD
33426 PRE_IO
33427 READ_LONG_F(adr, src)
33428 res = DREGu32((Opcode >> 9) & 7);
33429 res &= src;
33430 flag_C = 0;
33431 flag_V = 0;
33432 flag_NotZ = res;
33433 flag_N = res >> 24;
33434 DREGu32((Opcode >> 9) & 7) = res;
33435 POST_IO
33436RET(20)
33437}
33438
33439// ANDaD
33440OPCODE(0xC0B8)
33441{
33442 u32 adr, res;
33443 u32 src, dst;
33444
33445 FETCH_SWORD(adr);
33446 PRE_IO
33447 READ_LONG_F(adr, src)
33448 res = DREGu32((Opcode >> 9) & 7);
33449 res &= src;
33450 flag_C = 0;
33451 flag_V = 0;
33452 flag_NotZ = res;
33453 flag_N = res >> 24;
33454 DREGu32((Opcode >> 9) & 7) = res;
33455 POST_IO
33456RET(18)
33457}
33458
33459// ANDaD
33460OPCODE(0xC0B9)
33461{
33462 u32 adr, res;
33463 u32 src, dst;
33464
33465 FETCH_LONG(adr);
33466 PRE_IO
33467 READ_LONG_F(adr, src)
33468 res = DREGu32((Opcode >> 9) & 7);
33469 res &= src;
33470 flag_C = 0;
33471 flag_V = 0;
33472 flag_NotZ = res;
33473 flag_N = res >> 24;
33474 DREGu32((Opcode >> 9) & 7) = res;
33475 POST_IO
33476RET(22)
33477}
33478
33479// ANDaD
33480OPCODE(0xC0BA)
33481{
33482 u32 adr, res;
33483 u32 src, dst;
33484
be26eb23 33485 adr = GET_SWORD + GET_PC;
70357ce5 33486 PC++;
33487 PRE_IO
33488 READ_LONG_F(adr, src)
33489 res = DREGu32((Opcode >> 9) & 7);
33490 res &= src;
33491 flag_C = 0;
33492 flag_V = 0;
33493 flag_NotZ = res;
33494 flag_N = res >> 24;
33495 DREGu32((Opcode >> 9) & 7) = res;
33496 POST_IO
33497RET(18)
33498}
33499
33500// ANDaD
33501OPCODE(0xC0BB)
33502{
33503 u32 adr, res;
33504 u32 src, dst;
33505
be26eb23 33506 adr = GET_PC;
70357ce5 33507 DECODE_EXT_WORD
33508 PRE_IO
33509 READ_LONG_F(adr, src)
33510 res = DREGu32((Opcode >> 9) & 7);
33511 res &= src;
33512 flag_C = 0;
33513 flag_V = 0;
33514 flag_NotZ = res;
33515 flag_N = res >> 24;
33516 DREGu32((Opcode >> 9) & 7) = res;
33517 POST_IO
33518RET(20)
33519}
33520
33521// ANDaD
33522OPCODE(0xC0BC)
33523{
33524 u32 adr, res;
33525 u32 src, dst;
33526
33527 FETCH_LONG(src);
33528 res = DREGu32((Opcode >> 9) & 7);
33529 res &= src;
33530 flag_C = 0;
33531 flag_V = 0;
33532 flag_NotZ = res;
33533 flag_N = res >> 24;
33534 DREGu32((Opcode >> 9) & 7) = res;
33535RET(16)
33536}
33537
33538// ANDaD
33539OPCODE(0xC09F)
33540{
33541 u32 adr, res;
33542 u32 src, dst;
33543
33544 adr = AREG(7);
33545 AREG(7) += 4;
33546 PRE_IO
33547 READ_LONG_F(adr, src)
33548 res = DREGu32((Opcode >> 9) & 7);
33549 res &= src;
33550 flag_C = 0;
33551 flag_V = 0;
33552 flag_NotZ = res;
33553 flag_N = res >> 24;
33554 DREGu32((Opcode >> 9) & 7) = res;
33555 POST_IO
33556RET(14)
33557}
33558
33559// ANDaD
33560OPCODE(0xC0A7)
33561{
33562 u32 adr, res;
33563 u32 src, dst;
33564
33565 adr = AREG(7) - 4;
33566 AREG(7) = adr;
33567 PRE_IO
33568 READ_LONG_F(adr, src)
33569 res = DREGu32((Opcode >> 9) & 7);
33570 res &= src;
33571 flag_C = 0;
33572 flag_V = 0;
33573 flag_NotZ = res;
33574 flag_N = res >> 24;
33575 DREGu32((Opcode >> 9) & 7) = res;
33576 POST_IO
33577RET(16)
33578}
33579
33580// ANDDa
33581OPCODE(0xC110)
33582{
33583 u32 adr, res;
33584 u32 src, dst;
33585
33586 src = DREGu8((Opcode >> 9) & 7);
33587 adr = AREG((Opcode >> 0) & 7);
33588 PRE_IO
33589 READ_BYTE_F(adr, res)
33590 res &= src;
33591 flag_C = 0;
33592 flag_V = 0;
33593 flag_NotZ = res;
33594 flag_N = res;
33595 WRITE_BYTE_F(adr, res)
33596 POST_IO
33597RET(12)
33598}
33599
33600// ANDDa
33601OPCODE(0xC118)
33602{
33603 u32 adr, res;
33604 u32 src, dst;
33605
33606 src = DREGu8((Opcode >> 9) & 7);
33607 adr = AREG((Opcode >> 0) & 7);
33608 AREG((Opcode >> 0) & 7) += 1;
33609 PRE_IO
33610 READ_BYTE_F(adr, res)
33611 res &= src;
33612 flag_C = 0;
33613 flag_V = 0;
33614 flag_NotZ = res;
33615 flag_N = res;
33616 WRITE_BYTE_F(adr, res)
33617 POST_IO
33618RET(12)
33619}
33620
33621// ANDDa
33622OPCODE(0xC120)
33623{
33624 u32 adr, res;
33625 u32 src, dst;
33626
33627 src = DREGu8((Opcode >> 9) & 7);
33628 adr = AREG((Opcode >> 0) & 7) - 1;
33629 AREG((Opcode >> 0) & 7) = adr;
33630 PRE_IO
33631 READ_BYTE_F(adr, res)
33632 res &= src;
33633 flag_C = 0;
33634 flag_V = 0;
33635 flag_NotZ = res;
33636 flag_N = res;
33637 WRITE_BYTE_F(adr, res)
33638 POST_IO
33639RET(14)
33640}
33641
33642// ANDDa
33643OPCODE(0xC128)
33644{
33645 u32 adr, res;
33646 u32 src, dst;
33647
33648 src = DREGu8((Opcode >> 9) & 7);
33649 FETCH_SWORD(adr);
33650 adr += AREG((Opcode >> 0) & 7);
33651 PRE_IO
33652 READ_BYTE_F(adr, res)
33653 res &= src;
33654 flag_C = 0;
33655 flag_V = 0;
33656 flag_NotZ = res;
33657 flag_N = res;
33658 WRITE_BYTE_F(adr, res)
33659 POST_IO
33660RET(16)
33661}
33662
33663// ANDDa
33664OPCODE(0xC130)
33665{
33666 u32 adr, res;
33667 u32 src, dst;
33668
33669 src = DREGu8((Opcode >> 9) & 7);
33670 adr = AREG((Opcode >> 0) & 7);
33671 DECODE_EXT_WORD
33672 PRE_IO
33673 READ_BYTE_F(adr, res)
33674 res &= src;
33675 flag_C = 0;
33676 flag_V = 0;
33677 flag_NotZ = res;
33678 flag_N = res;
33679 WRITE_BYTE_F(adr, res)
33680 POST_IO
33681RET(18)
33682}
33683
33684// ANDDa
33685OPCODE(0xC138)
33686{
33687 u32 adr, res;
33688 u32 src, dst;
33689
33690 src = DREGu8((Opcode >> 9) & 7);
33691 FETCH_SWORD(adr);
33692 PRE_IO
33693 READ_BYTE_F(adr, res)
33694 res &= src;
33695 flag_C = 0;
33696 flag_V = 0;
33697 flag_NotZ = res;
33698 flag_N = res;
33699 WRITE_BYTE_F(adr, res)
33700 POST_IO
33701RET(16)
33702}
33703
33704// ANDDa
33705OPCODE(0xC139)
33706{
33707 u32 adr, res;
33708 u32 src, dst;
33709
33710 src = DREGu8((Opcode >> 9) & 7);
33711 FETCH_LONG(adr);
33712 PRE_IO
33713 READ_BYTE_F(adr, res)
33714 res &= src;
33715 flag_C = 0;
33716 flag_V = 0;
33717 flag_NotZ = res;
33718 flag_N = res;
33719 WRITE_BYTE_F(adr, res)
33720 POST_IO
33721RET(20)
33722}
33723
33724// ANDDa
33725OPCODE(0xC11F)
33726{
33727 u32 adr, res;
33728 u32 src, dst;
33729
33730 src = DREGu8((Opcode >> 9) & 7);
33731 adr = AREG(7);
33732 AREG(7) += 2;
33733 PRE_IO
33734 READ_BYTE_F(adr, res)
33735 res &= src;
33736 flag_C = 0;
33737 flag_V = 0;
33738 flag_NotZ = res;
33739 flag_N = res;
33740 WRITE_BYTE_F(adr, res)
33741 POST_IO
33742RET(12)
33743}
33744
33745// ANDDa
33746OPCODE(0xC127)
33747{
33748 u32 adr, res;
33749 u32 src, dst;
33750
33751 src = DREGu8((Opcode >> 9) & 7);
33752 adr = AREG(7) - 2;
33753 AREG(7) = adr;
33754 PRE_IO
33755 READ_BYTE_F(adr, res)
33756 res &= src;
33757 flag_C = 0;
33758 flag_V = 0;
33759 flag_NotZ = res;
33760 flag_N = res;
33761 WRITE_BYTE_F(adr, res)
33762 POST_IO
33763RET(14)
33764}
33765
33766// ANDDa
33767OPCODE(0xC150)
33768{
33769 u32 adr, res;
33770 u32 src, dst;
33771
33772 src = DREGu16((Opcode >> 9) & 7);
33773 adr = AREG((Opcode >> 0) & 7);
33774 PRE_IO
33775 READ_WORD_F(adr, res)
33776 res &= src;
33777 flag_C = 0;
33778 flag_V = 0;
33779 flag_NotZ = res;
33780 flag_N = res >> 8;
33781 WRITE_WORD_F(adr, res)
33782 POST_IO
33783RET(12)
33784}
33785
33786// ANDDa
33787OPCODE(0xC158)
33788{
33789 u32 adr, res;
33790 u32 src, dst;
33791
33792 src = DREGu16((Opcode >> 9) & 7);
33793 adr = AREG((Opcode >> 0) & 7);
33794 AREG((Opcode >> 0) & 7) += 2;
33795 PRE_IO
33796 READ_WORD_F(adr, res)
33797 res &= src;
33798 flag_C = 0;
33799 flag_V = 0;
33800 flag_NotZ = res;
33801 flag_N = res >> 8;
33802 WRITE_WORD_F(adr, res)
33803 POST_IO
33804RET(12)
33805}
33806
33807// ANDDa
33808OPCODE(0xC160)
33809{
33810 u32 adr, res;
33811 u32 src, dst;
33812
33813 src = DREGu16((Opcode >> 9) & 7);
33814 adr = AREG((Opcode >> 0) & 7) - 2;
33815 AREG((Opcode >> 0) & 7) = adr;
33816 PRE_IO
33817 READ_WORD_F(adr, res)
33818 res &= src;
33819 flag_C = 0;
33820 flag_V = 0;
33821 flag_NotZ = res;
33822 flag_N = res >> 8;
33823 WRITE_WORD_F(adr, res)
33824 POST_IO
33825RET(14)
33826}
33827
33828// ANDDa
33829OPCODE(0xC168)
33830{
33831 u32 adr, res;
33832 u32 src, dst;
33833
33834 src = DREGu16((Opcode >> 9) & 7);
33835 FETCH_SWORD(adr);
33836 adr += AREG((Opcode >> 0) & 7);
33837 PRE_IO
33838 READ_WORD_F(adr, res)
33839 res &= src;
33840 flag_C = 0;
33841 flag_V = 0;
33842 flag_NotZ = res;
33843 flag_N = res >> 8;
33844 WRITE_WORD_F(adr, res)
33845 POST_IO
33846RET(16)
33847}
33848
33849// ANDDa
33850OPCODE(0xC170)
33851{
33852 u32 adr, res;
33853 u32 src, dst;
33854
33855 src = DREGu16((Opcode >> 9) & 7);
33856 adr = AREG((Opcode >> 0) & 7);
33857 DECODE_EXT_WORD
33858 PRE_IO
33859 READ_WORD_F(adr, res)
33860 res &= src;
33861 flag_C = 0;
33862 flag_V = 0;
33863 flag_NotZ = res;
33864 flag_N = res >> 8;
33865 WRITE_WORD_F(adr, res)
33866 POST_IO
33867RET(18)
33868}
33869
33870// ANDDa
33871OPCODE(0xC178)
33872{
33873 u32 adr, res;
33874 u32 src, dst;
33875
33876 src = DREGu16((Opcode >> 9) & 7);
33877 FETCH_SWORD(adr);
33878 PRE_IO
33879 READ_WORD_F(adr, res)
33880 res &= src;
33881 flag_C = 0;
33882 flag_V = 0;
33883 flag_NotZ = res;
33884 flag_N = res >> 8;
33885 WRITE_WORD_F(adr, res)
33886 POST_IO
33887RET(16)
33888}
33889
33890// ANDDa
33891OPCODE(0xC179)
33892{
33893 u32 adr, res;
33894 u32 src, dst;
33895
33896 src = DREGu16((Opcode >> 9) & 7);
33897 FETCH_LONG(adr);
33898 PRE_IO
33899 READ_WORD_F(adr, res)
33900 res &= src;
33901 flag_C = 0;
33902 flag_V = 0;
33903 flag_NotZ = res;
33904 flag_N = res >> 8;
33905 WRITE_WORD_F(adr, res)
33906 POST_IO
33907RET(20)
33908}
33909
33910// ANDDa
33911OPCODE(0xC15F)
33912{
33913 u32 adr, res;
33914 u32 src, dst;
33915
33916 src = DREGu16((Opcode >> 9) & 7);
33917 adr = AREG(7);
33918 AREG(7) += 2;
33919 PRE_IO
33920 READ_WORD_F(adr, res)
33921 res &= src;
33922 flag_C = 0;
33923 flag_V = 0;
33924 flag_NotZ = res;
33925 flag_N = res >> 8;
33926 WRITE_WORD_F(adr, res)
33927 POST_IO
33928RET(12)
33929}
33930
33931// ANDDa
33932OPCODE(0xC167)
33933{
33934 u32 adr, res;
33935 u32 src, dst;
33936
33937 src = DREGu16((Opcode >> 9) & 7);
33938 adr = AREG(7) - 2;
33939 AREG(7) = adr;
33940 PRE_IO
33941 READ_WORD_F(adr, res)
33942 res &= src;
33943 flag_C = 0;
33944 flag_V = 0;
33945 flag_NotZ = res;
33946 flag_N = res >> 8;
33947 WRITE_WORD_F(adr, res)
33948 POST_IO
33949RET(14)
33950}
33951
33952// ANDDa
33953OPCODE(0xC190)
33954{
33955 u32 adr, res;
33956 u32 src, dst;
33957
33958 src = DREGu32((Opcode >> 9) & 7);
33959 adr = AREG((Opcode >> 0) & 7);
33960 PRE_IO
33961 READ_LONG_F(adr, res)
33962 res &= src;
33963 flag_C = 0;
33964 flag_V = 0;
33965 flag_NotZ = res;
33966 flag_N = res >> 24;
33967 WRITE_LONG_F(adr, res)
33968 POST_IO
33969RET(20)
33970}
33971
33972// ANDDa
33973OPCODE(0xC198)
33974{
33975 u32 adr, res;
33976 u32 src, dst;
33977
33978 src = DREGu32((Opcode >> 9) & 7);
33979 adr = AREG((Opcode >> 0) & 7);
33980 AREG((Opcode >> 0) & 7) += 4;
33981 PRE_IO
33982 READ_LONG_F(adr, res)
33983 res &= src;
33984 flag_C = 0;
33985 flag_V = 0;
33986 flag_NotZ = res;
33987 flag_N = res >> 24;
33988 WRITE_LONG_F(adr, res)
33989 POST_IO
33990RET(20)
33991}
33992
33993// ANDDa
33994OPCODE(0xC1A0)
33995{
33996 u32 adr, res;
33997 u32 src, dst;
33998
33999 src = DREGu32((Opcode >> 9) & 7);
34000 adr = AREG((Opcode >> 0) & 7) - 4;
34001 AREG((Opcode >> 0) & 7) = adr;
34002 PRE_IO
34003 READ_LONG_F(adr, res)
34004 res &= src;
34005 flag_C = 0;
34006 flag_V = 0;
34007 flag_NotZ = res;
34008 flag_N = res >> 24;
34009 WRITE_LONG_F(adr, res)
34010 POST_IO
34011RET(22)
34012}
34013
34014// ANDDa
34015OPCODE(0xC1A8)
34016{
34017 u32 adr, res;
34018 u32 src, dst;
34019
34020 src = DREGu32((Opcode >> 9) & 7);
34021 FETCH_SWORD(adr);
34022 adr += AREG((Opcode >> 0) & 7);
34023 PRE_IO
34024 READ_LONG_F(adr, res)
34025 res &= src;
34026 flag_C = 0;
34027 flag_V = 0;
34028 flag_NotZ = res;
34029 flag_N = res >> 24;
34030 WRITE_LONG_F(adr, res)
34031 POST_IO
34032RET(24)
34033}
34034
34035// ANDDa
34036OPCODE(0xC1B0)
34037{
34038 u32 adr, res;
34039 u32 src, dst;
34040
34041 src = DREGu32((Opcode >> 9) & 7);
34042 adr = AREG((Opcode >> 0) & 7);
34043 DECODE_EXT_WORD
34044 PRE_IO
34045 READ_LONG_F(adr, res)
34046 res &= src;
34047 flag_C = 0;
34048 flag_V = 0;
34049 flag_NotZ = res;
34050 flag_N = res >> 24;
34051 WRITE_LONG_F(adr, res)
34052 POST_IO
34053RET(26)
34054}
34055
34056// ANDDa
34057OPCODE(0xC1B8)
34058{
34059 u32 adr, res;
34060 u32 src, dst;
34061
34062 src = DREGu32((Opcode >> 9) & 7);
34063 FETCH_SWORD(adr);
34064 PRE_IO
34065 READ_LONG_F(adr, res)
34066 res &= src;
34067 flag_C = 0;
34068 flag_V = 0;
34069 flag_NotZ = res;
34070 flag_N = res >> 24;
34071 WRITE_LONG_F(adr, res)
34072 POST_IO
34073RET(24)
34074}
34075
34076// ANDDa
34077OPCODE(0xC1B9)
34078{
34079 u32 adr, res;
34080 u32 src, dst;
34081
34082 src = DREGu32((Opcode >> 9) & 7);
34083 FETCH_LONG(adr);
34084 PRE_IO
34085 READ_LONG_F(adr, res)
34086 res &= src;
34087 flag_C = 0;
34088 flag_V = 0;
34089 flag_NotZ = res;
34090 flag_N = res >> 24;
34091 WRITE_LONG_F(adr, res)
34092 POST_IO
34093RET(28)
34094}
34095
34096// ANDDa
34097OPCODE(0xC19F)
34098{
34099 u32 adr, res;
34100 u32 src, dst;
34101
34102 src = DREGu32((Opcode >> 9) & 7);
34103 adr = AREG(7);
34104 AREG(7) += 4;
34105 PRE_IO
34106 READ_LONG_F(adr, res)
34107 res &= src;
34108 flag_C = 0;
34109 flag_V = 0;
34110 flag_NotZ = res;
34111 flag_N = res >> 24;
34112 WRITE_LONG_F(adr, res)
34113 POST_IO
34114RET(20)
34115}
34116
34117// ANDDa
34118OPCODE(0xC1A7)
34119{
34120 u32 adr, res;
34121 u32 src, dst;
34122
34123 src = DREGu32((Opcode >> 9) & 7);
34124 adr = AREG(7) - 4;
34125 AREG(7) = adr;
34126 PRE_IO
34127 READ_LONG_F(adr, res)
34128 res &= src;
34129 flag_C = 0;
34130 flag_V = 0;
34131 flag_NotZ = res;
34132 flag_N = res >> 24;
34133 WRITE_LONG_F(adr, res)
34134 POST_IO
34135RET(22)
34136}
34137
34138// ABCD
34139OPCODE(0xC100)
34140{
34141 u32 adr, res;
34142 u32 src, dst;
c6e1e977 34143 u32 corf = 0;
70357ce5 34144
34145 src = DREGu8((Opcode >> 0) & 7);
34146 dst = DREGu8((Opcode >> 9) & 7);
34147 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 34148 if (res > 9) corf = 6;
70357ce5 34149 res += (dst & 0xF0) + (src & 0xF0);
c6e1e977 34150 flag_V = ~res;
34151 res += corf;
34152 if (res > 0x9F)
70357ce5 34153 {
34154 res -= 0xA0;
34155 flag_X = flag_C = M68K_SR_C;
34156 }
34157 else flag_X = flag_C = 0;
c6e1e977 34158 flag_V &= res;
70357ce5 34159 flag_NotZ |= res & 0xFF;
34160 flag_N = res;
34161 DREGu8((Opcode >> 9) & 7) = res;
34162RET(6)
34163}
34164
34165// ABCDM
34166OPCODE(0xC108)
34167{
34168 u32 adr, res;
34169 u32 src, dst;
c6e1e977 34170 u32 corf = 0;
70357ce5 34171
34172 adr = AREG((Opcode >> 0) & 7) - 1;
34173 AREG((Opcode >> 0) & 7) = adr;
34174 PRE_IO
34175 READ_BYTE_F(adr, src)
34176 adr = AREG((Opcode >> 9) & 7) - 1;
34177 AREG((Opcode >> 9) & 7) = adr;
34178 READ_BYTE_F(adr, dst)
34179 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 34180 if (res > 9) corf = 6;
70357ce5 34181 res += (dst & 0xF0) + (src & 0xF0);
c6e1e977 34182 flag_V = ~res;
34183 res += corf;
34184 if (res > 0x9F)
70357ce5 34185 {
34186 res -= 0xA0;
34187 flag_X = flag_C = M68K_SR_C;
34188 }
34189 else flag_X = flag_C = 0;
c6e1e977 34190 flag_V &= res;
70357ce5 34191 flag_NotZ |= res & 0xFF;
34192 flag_N = res;
34193 WRITE_BYTE_F(adr, res)
34194 POST_IO
34195RET(18)
34196}
34197
34198// ABCD7M
34199OPCODE(0xC10F)
34200{
34201 u32 adr, res;
34202 u32 src, dst;
c6e1e977 34203 u32 corf = 0;
70357ce5 34204
34205 adr = AREG(7) - 2;
34206 AREG(7) = adr;
34207 PRE_IO
34208 READ_BYTE_F(adr, src)
34209 adr = AREG((Opcode >> 9) & 7) - 1;
34210 AREG((Opcode >> 9) & 7) = adr;
34211 READ_BYTE_F(adr, dst)
34212 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 34213 if (res > 9) corf = 6;
70357ce5 34214 res += (dst & 0xF0) + (src & 0xF0);
c6e1e977 34215 flag_V = ~res;
34216 res += corf;
34217 if (res > 0x9F)
70357ce5 34218 {
34219 res -= 0xA0;
34220 flag_X = flag_C = M68K_SR_C;
34221 }
34222 else flag_X = flag_C = 0;
c6e1e977 34223 flag_V &= res;
70357ce5 34224 flag_NotZ |= res & 0xFF;
34225 flag_N = res;
34226 WRITE_BYTE_F(adr, res)
34227 POST_IO
34228RET(18)
34229}
34230
34231// ABCDM7
34232OPCODE(0xCF08)
34233{
34234 u32 adr, res;
34235 u32 src, dst;
c6e1e977 34236 u32 corf = 0;
70357ce5 34237
34238 adr = AREG((Opcode >> 0) & 7) - 1;
34239 AREG((Opcode >> 0) & 7) = adr;
34240 PRE_IO
34241 READ_BYTE_F(adr, src)
34242 adr = AREG(7) - 2;
34243 AREG(7) = adr;
34244 READ_BYTE_F(adr, dst)
34245 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 34246 if (res > 9) corf = 6;
70357ce5 34247 res += (dst & 0xF0) + (src & 0xF0);
c6e1e977 34248 flag_V = ~res;
34249 res += corf;
34250 if (res > 0x9F)
70357ce5 34251 {
34252 res -= 0xA0;
34253 flag_X = flag_C = M68K_SR_C;
34254 }
34255 else flag_X = flag_C = 0;
c6e1e977 34256 flag_V &= res;
70357ce5 34257 flag_NotZ |= res & 0xFF;
34258 flag_N = res;
34259 WRITE_BYTE_F(adr, res)
34260 POST_IO
34261RET(18)
34262}
34263
34264// ABCD7M7
34265OPCODE(0xCF0F)
34266{
34267 u32 adr, res;
34268 u32 src, dst;
c6e1e977 34269 u32 corf = 0;
70357ce5 34270
34271 adr = AREG(7) - 2;
34272 AREG(7) = adr;
34273 PRE_IO
34274 READ_BYTE_F(adr, src)
34275 adr = AREG(7) - 2;
34276 AREG(7) = adr;
34277 READ_BYTE_F(adr, dst)
34278 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
c6e1e977 34279 if (res > 9) corf = 6;
70357ce5 34280 res += (dst & 0xF0) + (src & 0xF0);
c6e1e977 34281 flag_V = ~res;
34282 res += corf;
34283 if (res > 0x9F)
70357ce5 34284 {
34285 res -= 0xA0;
34286 flag_X = flag_C = M68K_SR_C;
34287 }
34288 else flag_X = flag_C = 0;
c6e1e977 34289 flag_V &= res;
70357ce5 34290 flag_NotZ |= res & 0xFF;
34291 flag_N = res;
34292 WRITE_BYTE_F(adr, res)
34293 POST_IO
34294RET(18)
34295}
34296
34297// MULU
34298OPCODE(0xC0C0)
34299{
34300 u32 adr, res;
34301 u32 src, dst;
34302
34303 src = DREGu16((Opcode >> 0) & 7);
34304 res = DREGu16((Opcode >> 9) & 7);
34305 res *= src;
34306 flag_N = res >> 24;
34307 flag_NotZ = res;
34308 flag_V = flag_C = 0;
34309 DREGu32((Opcode >> 9) & 7) = res;
34310#ifdef USE_CYCLONE_TIMING
34311RET(54)
34312#else
34313RET(50)
34314#endif
34315}
34316
34317// MULU
34318OPCODE(0xC0D0)
34319{
34320 u32 adr, res;
34321 u32 src, dst;
34322
34323 adr = AREG((Opcode >> 0) & 7);
34324 PRE_IO
34325 READ_WORD_F(adr, src)
34326 res = DREGu16((Opcode >> 9) & 7);
34327 res *= src;
34328 flag_N = res >> 24;
34329 flag_NotZ = res;
34330 flag_V = flag_C = 0;
34331 DREGu32((Opcode >> 9) & 7) = res;
34332 POST_IO
34333#ifdef USE_CYCLONE_TIMING
34334RET(58)
34335#else
34336RET(54)
34337#endif
34338}
34339
34340// MULU
34341OPCODE(0xC0D8)
34342{
34343 u32 adr, res;
34344 u32 src, dst;
34345
34346 adr = AREG((Opcode >> 0) & 7);
34347 AREG((Opcode >> 0) & 7) += 2;
34348 PRE_IO
34349 READ_WORD_F(adr, src)
34350 res = DREGu16((Opcode >> 9) & 7);
34351 res *= src;
34352 flag_N = res >> 24;
34353 flag_NotZ = res;
34354 flag_V = flag_C = 0;
34355 DREGu32((Opcode >> 9) & 7) = res;
34356 POST_IO
34357#ifdef USE_CYCLONE_TIMING
34358RET(58)
34359#else
34360RET(54)
34361#endif
34362}
34363
34364// MULU
34365OPCODE(0xC0E0)
34366{
34367 u32 adr, res;
34368 u32 src, dst;
34369
34370 adr = AREG((Opcode >> 0) & 7) - 2;
34371 AREG((Opcode >> 0) & 7) = adr;
34372 PRE_IO
34373 READ_WORD_F(adr, src)
34374 res = DREGu16((Opcode >> 9) & 7);
34375 res *= src;
34376 flag_N = res >> 24;
34377 flag_NotZ = res;
34378 flag_V = flag_C = 0;
34379 DREGu32((Opcode >> 9) & 7) = res;
34380 POST_IO
34381#ifdef USE_CYCLONE_TIMING
34382RET(60)
34383#else
34384RET(56)
34385#endif
34386}
34387
34388// MULU
34389OPCODE(0xC0E8)
34390{
34391 u32 adr, res;
34392 u32 src, dst;
34393
34394 FETCH_SWORD(adr);
34395 adr += AREG((Opcode >> 0) & 7);
34396 PRE_IO
34397 READ_WORD_F(adr, src)
34398 res = DREGu16((Opcode >> 9) & 7);
34399 res *= src;
34400 flag_N = res >> 24;
34401 flag_NotZ = res;
34402 flag_V = flag_C = 0;
34403 DREGu32((Opcode >> 9) & 7) = res;
34404 POST_IO
34405#ifdef USE_CYCLONE_TIMING
34406RET(62)
34407#else
34408RET(58)
34409#endif
34410}
34411
34412// MULU
34413OPCODE(0xC0F0)
34414{
34415 u32 adr, res;
34416 u32 src, dst;
34417
34418 adr = AREG((Opcode >> 0) & 7);
34419 DECODE_EXT_WORD
34420 PRE_IO
34421 READ_WORD_F(adr, src)
34422 res = DREGu16((Opcode >> 9) & 7);
34423 res *= src;
34424 flag_N = res >> 24;
34425 flag_NotZ = res;
34426 flag_V = flag_C = 0;
34427 DREGu32((Opcode >> 9) & 7) = res;
34428 POST_IO
34429#ifdef USE_CYCLONE_TIMING
34430RET(64)
34431#else
34432RET(60)
34433#endif
34434}
34435
34436// MULU
34437OPCODE(0xC0F8)
34438{
34439 u32 adr, res;
34440 u32 src, dst;
34441
34442 FETCH_SWORD(adr);
34443 PRE_IO
34444 READ_WORD_F(adr, src)
34445 res = DREGu16((Opcode >> 9) & 7);
34446 res *= src;
34447 flag_N = res >> 24;
34448 flag_NotZ = res;
34449 flag_V = flag_C = 0;
34450 DREGu32((Opcode >> 9) & 7) = res;
34451 POST_IO
34452#ifdef USE_CYCLONE_TIMING
34453RET(62)
34454#else
34455RET(58)
34456#endif
34457}
34458
34459// MULU
34460OPCODE(0xC0F9)
34461{
34462 u32 adr, res;
34463 u32 src, dst;
34464
34465 FETCH_LONG(adr);
34466 PRE_IO
34467 READ_WORD_F(adr, src)
34468 res = DREGu16((Opcode >> 9) & 7);
34469 res *= src;
34470 flag_N = res >> 24;
34471 flag_NotZ = res;
34472 flag_V = flag_C = 0;
34473 DREGu32((Opcode >> 9) & 7) = res;
34474 POST_IO
34475#ifdef USE_CYCLONE_TIMING
34476RET(66)
34477#else
34478RET(62)
34479#endif
34480}
34481
34482// MULU
34483OPCODE(0xC0FA)
34484{
34485 u32 adr, res;
34486 u32 src, dst;
34487
be26eb23 34488 adr = GET_SWORD + GET_PC;
70357ce5 34489 PC++;
34490 PRE_IO
34491 READ_WORD_F(adr, src)
34492 res = DREGu16((Opcode >> 9) & 7);
34493 res *= src;
34494 flag_N = res >> 24;
34495 flag_NotZ = res;
34496 flag_V = flag_C = 0;
34497 DREGu32((Opcode >> 9) & 7) = res;
34498 POST_IO
34499#ifdef USE_CYCLONE_TIMING
34500RET(62)
34501#else
34502RET(58)
34503#endif
34504}
34505
34506// MULU
34507OPCODE(0xC0FB)
34508{
34509 u32 adr, res;
34510 u32 src, dst;
34511
be26eb23 34512 adr = GET_PC;
70357ce5 34513 DECODE_EXT_WORD
34514 PRE_IO
34515 READ_WORD_F(adr, src)
34516 res = DREGu16((Opcode >> 9) & 7);
34517 res *= src;
34518 flag_N = res >> 24;
34519 flag_NotZ = res;
34520 flag_V = flag_C = 0;
34521 DREGu32((Opcode >> 9) & 7) = res;
34522 POST_IO
34523#ifdef USE_CYCLONE_TIMING
34524RET(64)
34525#else
34526RET(60)
34527#endif
34528}
34529
34530// MULU
34531OPCODE(0xC0FC)
34532{
34533 u32 adr, res;
34534 u32 src, dst;
34535
34536 FETCH_WORD(src);
34537 res = DREGu16((Opcode >> 9) & 7);
34538 res *= src;
34539 flag_N = res >> 24;
34540 flag_NotZ = res;
34541 flag_V = flag_C = 0;
34542 DREGu32((Opcode >> 9) & 7) = res;
34543#ifdef USE_CYCLONE_TIMING
34544RET(58)
34545#else
34546RET(54)
34547#endif
34548}
34549
34550// MULU
34551OPCODE(0xC0DF)
34552{
34553 u32 adr, res;
34554 u32 src, dst;
34555
34556 adr = AREG(7);
34557 AREG(7) += 2;
34558 PRE_IO
34559 READ_WORD_F(adr, src)
34560 res = DREGu16((Opcode >> 9) & 7);
34561 res *= src;
34562 flag_N = res >> 24;
34563 flag_NotZ = res;
34564 flag_V = flag_C = 0;
34565 DREGu32((Opcode >> 9) & 7) = res;
34566 POST_IO
34567#ifdef USE_CYCLONE_TIMING
34568RET(58)
34569#else
34570RET(54)
34571#endif
34572}
34573
34574// MULU
34575OPCODE(0xC0E7)
34576{
34577 u32 adr, res;
34578 u32 src, dst;
34579
34580 adr = AREG(7) - 2;
34581 AREG(7) = adr;
34582 PRE_IO
34583 READ_WORD_F(adr, src)
34584 res = DREGu16((Opcode >> 9) & 7);
34585 res *= src;
34586 flag_N = res >> 24;
34587 flag_NotZ = res;
34588 flag_V = flag_C = 0;
34589 DREGu32((Opcode >> 9) & 7) = res;
34590 POST_IO
34591#ifdef USE_CYCLONE_TIMING
34592RET(60)
34593#else
34594RET(56)
34595#endif
34596}
34597
34598// MULS
34599OPCODE(0xC1C0)
34600{
34601 u32 adr, res;
34602 u32 src, dst;
34603
34604 src = (s32)DREGs16((Opcode >> 0) & 7);
34605 res = (s32)DREGs16((Opcode >> 9) & 7);
34606 res = ((s32)res) * ((s32)src);
34607 flag_N = res >> 24;
34608 flag_NotZ = res;
34609 flag_V = flag_C = 0;
34610 DREGu32((Opcode >> 9) & 7) = res;
34611#ifdef USE_CYCLONE_TIMING
34612RET(54)
34613#else
34614RET(50)
34615#endif
34616}
34617
34618// MULS
34619OPCODE(0xC1D0)
34620{
34621 u32 adr, res;
34622 u32 src, dst;
34623
34624 adr = AREG((Opcode >> 0) & 7);
34625 PRE_IO
34626 READSX_WORD_F(adr, src)
34627 res = (s32)DREGs16((Opcode >> 9) & 7);
34628 res = ((s32)res) * ((s32)src);
34629 flag_N = res >> 24;
34630 flag_NotZ = res;
34631 flag_V = flag_C = 0;
34632 DREGu32((Opcode >> 9) & 7) = res;
34633 POST_IO
34634#ifdef USE_CYCLONE_TIMING
34635RET(58)
34636#else
34637RET(54)
34638#endif
34639}
34640
34641// MULS
34642OPCODE(0xC1D8)
34643{
34644 u32 adr, res;
34645 u32 src, dst;
34646
34647 adr = AREG((Opcode >> 0) & 7);
34648 AREG((Opcode >> 0) & 7) += 2;
34649 PRE_IO
34650 READSX_WORD_F(adr, src)
34651 res = (s32)DREGs16((Opcode >> 9) & 7);
34652 res = ((s32)res) * ((s32)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(58)
34660#else
34661RET(54)
34662#endif
34663}
34664
34665// MULS
34666OPCODE(0xC1E0)
34667{
34668 u32 adr, res;
34669 u32 src, dst;
34670
34671 adr = AREG((Opcode >> 0) & 7) - 2;
34672 AREG((Opcode >> 0) & 7) = adr;
34673 PRE_IO
34674 READSX_WORD_F(adr, src)
34675 res = (s32)DREGs16((Opcode >> 9) & 7);
34676 res = ((s32)res) * ((s32)src);
34677 flag_N = res >> 24;
34678 flag_NotZ = res;
34679 flag_V = flag_C = 0;
34680 DREGu32((Opcode >> 9) & 7) = res;
34681 POST_IO
34682#ifdef USE_CYCLONE_TIMING
34683RET(60)
34684#else
34685RET(56)
34686#endif
34687}
34688
34689// MULS
34690OPCODE(0xC1E8)
34691{
34692 u32 adr, res;
34693 u32 src, dst;
34694
34695 FETCH_SWORD(adr);
34696 adr += AREG((Opcode >> 0) & 7);
34697 PRE_IO
34698 READSX_WORD_F(adr, src)
34699 res = (s32)DREGs16((Opcode >> 9) & 7);
34700 res = ((s32)res) * ((s32)src);
34701 flag_N = res >> 24;
34702 flag_NotZ = res;
34703 flag_V = flag_C = 0;
34704 DREGu32((Opcode >> 9) & 7) = res;
34705 POST_IO
34706#ifdef USE_CYCLONE_TIMING
34707RET(62)
34708#else
34709RET(58)
34710#endif
34711}
34712
34713// MULS
34714OPCODE(0xC1F0)
34715{
34716 u32 adr, res;
34717 u32 src, dst;
34718
34719 adr = AREG((Opcode >> 0) & 7);
34720 DECODE_EXT_WORD
34721 PRE_IO
34722 READSX_WORD_F(adr, src)
34723 res = (s32)DREGs16((Opcode >> 9) & 7);
34724 res = ((s32)res) * ((s32)src);
34725 flag_N = res >> 24;
34726 flag_NotZ = res;
34727 flag_V = flag_C = 0;
34728 DREGu32((Opcode >> 9) & 7) = res;
34729 POST_IO
34730#ifdef USE_CYCLONE_TIMING
34731RET(64)
34732#else
34733RET(60)
34734#endif
34735}
34736
34737// MULS
34738OPCODE(0xC1F8)
34739{
34740 u32 adr, res;
34741 u32 src, dst;
34742
34743 FETCH_SWORD(adr);
34744 PRE_IO
34745 READSX_WORD_F(adr, src)
34746 res = (s32)DREGs16((Opcode >> 9) & 7);
34747 res = ((s32)res) * ((s32)src);
34748 flag_N = res >> 24;
34749 flag_NotZ = res;
34750 flag_V = flag_C = 0;
34751 DREGu32((Opcode >> 9) & 7) = res;
34752 POST_IO
34753#ifdef USE_CYCLONE_TIMING
34754RET(62)
34755#else
34756RET(58)
34757#endif
34758}
34759
34760// MULS
34761OPCODE(0xC1F9)
34762{
34763 u32 adr, res;
34764 u32 src, dst;
34765
34766 FETCH_LONG(adr);
34767 PRE_IO
34768 READSX_WORD_F(adr, src)
34769 res = (s32)DREGs16((Opcode >> 9) & 7);
34770 res = ((s32)res) * ((s32)src);
34771 flag_N = res >> 24;
34772 flag_NotZ = res;
34773 flag_V = flag_C = 0;
34774 DREGu32((Opcode >> 9) & 7) = res;
34775 POST_IO
34776#ifdef USE_CYCLONE_TIMING
34777RET(66)
34778#else
34779RET(62)
34780#endif
34781}
34782
34783// MULS
34784OPCODE(0xC1FA)
34785{
34786 u32 adr, res;
34787 u32 src, dst;
34788
be26eb23 34789 adr = GET_SWORD + GET_PC;
70357ce5 34790 PC++;
34791 PRE_IO
34792 READSX_WORD_F(adr, src)
34793 res = (s32)DREGs16((Opcode >> 9) & 7);
34794 res = ((s32)res) * ((s32)src);
34795 flag_N = res >> 24;
34796 flag_NotZ = res;
34797 flag_V = flag_C = 0;
34798 DREGu32((Opcode >> 9) & 7) = res;
34799 POST_IO
34800#ifdef USE_CYCLONE_TIMING
34801RET(62)
34802#else
34803RET(58)
34804#endif
34805}
34806
34807// MULS
34808OPCODE(0xC1FB)
34809{
34810 u32 adr, res;
34811 u32 src, dst;
34812
be26eb23 34813 adr = GET_PC;
70357ce5 34814 DECODE_EXT_WORD
34815 PRE_IO
34816 READSX_WORD_F(adr, src)
34817 res = (s32)DREGs16((Opcode >> 9) & 7);
34818 res = ((s32)res) * ((s32)src);
34819 flag_N = res >> 24;
34820 flag_NotZ = res;
34821 flag_V = flag_C = 0;
34822 DREGu32((Opcode >> 9) & 7) = res;
34823 POST_IO
34824#ifdef USE_CYCLONE_TIMING
34825RET(64)
34826#else
34827RET(60)
34828#endif
34829}
34830
34831// MULS
34832OPCODE(0xC1FC)
34833{
34834 u32 adr, res;
34835 u32 src, dst;
34836
34837 FETCH_SWORD(src);
34838 res = (s32)DREGs16((Opcode >> 9) & 7);
34839 res = ((s32)res) * ((s32)src);
34840 flag_N = res >> 24;
34841 flag_NotZ = res;
34842 flag_V = flag_C = 0;
34843 DREGu32((Opcode >> 9) & 7) = res;
34844#ifdef USE_CYCLONE_TIMING
34845RET(58)
34846#else
34847RET(54)
34848#endif
34849}
34850
34851// MULS
34852OPCODE(0xC1DF)
34853{
34854 u32 adr, res;
34855 u32 src, dst;
34856
34857 adr = AREG(7);
34858 AREG(7) += 2;
34859 PRE_IO
34860 READSX_WORD_F(adr, src)
34861 res = (s32)DREGs16((Opcode >> 9) & 7);
34862 res = ((s32)res) * ((s32)src);
34863 flag_N = res >> 24;
34864 flag_NotZ = res;
34865 flag_V = flag_C = 0;
34866 DREGu32((Opcode >> 9) & 7) = res;
34867 POST_IO
34868#ifdef USE_CYCLONE_TIMING
34869RET(58)
34870#else
34871RET(54)
34872#endif
34873}
34874
34875// MULS
34876OPCODE(0xC1E7)
34877{
34878 u32 adr, res;
34879 u32 src, dst;
34880
34881 adr = AREG(7) - 2;
34882 AREG(7) = adr;
34883 PRE_IO
34884 READSX_WORD_F(adr, src)
34885 res = (s32)DREGs16((Opcode >> 9) & 7);
34886 res = ((s32)res) * ((s32)src);
34887 flag_N = res >> 24;
34888 flag_NotZ = res;
34889 flag_V = flag_C = 0;
34890 DREGu32((Opcode >> 9) & 7) = res;
34891 POST_IO
34892#ifdef USE_CYCLONE_TIMING
34893RET(60)
34894#else
34895RET(56)
34896#endif
34897}
34898
34899// EXGDD
34900OPCODE(0xC140)
34901{
34902 u32 adr, res;
34903 u32 src, dst;
34904
34905 res = DREGu32((Opcode >> 0) & 7);
34906 src = DREGu32((Opcode >> 9) & 7);
34907 DREGu32((Opcode >> 9) & 7) = res;
34908 res = src;
34909 DREGu32((Opcode >> 0) & 7) = res;
34910RET(6)
34911}
34912
34913// EXGAA
34914OPCODE(0xC148)
34915{
34916 u32 adr, res;
34917 u32 src, dst;
34918
34919 res = AREGu32((Opcode >> 0) & 7);
34920 src = AREGu32((Opcode >> 9) & 7);
34921 AREG((Opcode >> 9) & 7) = res;
34922 res = src;
34923 AREG((Opcode >> 0) & 7) = res;
34924RET(6)
34925}
34926
34927// EXGAD
34928OPCODE(0xC188)
34929{
34930 u32 adr, res;
34931 u32 src, dst;
34932
34933 res = AREGu32((Opcode >> 0) & 7);
34934 src = DREGu32((Opcode >> 9) & 7);
34935 DREGu32((Opcode >> 9) & 7) = res;
34936 res = src;
34937 AREG((Opcode >> 0) & 7) = res;
34938RET(6)
34939}
34940
34941// ADDaD
34942OPCODE(0xD000)
34943{
34944 u32 adr, res;
34945 u32 src, dst;
34946
34947 src = DREGu8((Opcode >> 0) & 7);
34948 dst = DREGu8((Opcode >> 9) & 7);
34949 res = dst + src;
34950 flag_N = flag_X = flag_C = res;
34951 flag_V = (src ^ res) & (dst ^ res);
34952 flag_NotZ = res & 0xFF;
34953 DREGu8((Opcode >> 9) & 7) = res;
34954RET(4)
34955}
34956
34957// ADDaD
03e4f2a3 34958#if 0
70357ce5 34959OPCODE(0xD008)
34960{
34961 u32 adr, res;
34962 u32 src, dst;
34963
34964 // can't read byte from Ax registers !
34965 m68kcontext.execinfo |= M68K_FAULTED;
34966 m68kcontext.io_cycle_counter = 0;
34967/*
34968 goto famec_Exec_End;
34969 dst = DREGu8((Opcode >> 9) & 7);
34970 res = dst + src;
34971 flag_N = flag_X = flag_C = res;
34972 flag_V = (src ^ res) & (dst ^ res);
34973 flag_NotZ = res & 0xFF;
34974 DREGu8((Opcode >> 9) & 7) = res;
34975*/
34976RET(4)
34977}
03e4f2a3 34978#endif
70357ce5 34979
34980// ADDaD
34981OPCODE(0xD010)
34982{
34983 u32 adr, res;
34984 u32 src, dst;
34985
34986 adr = AREG((Opcode >> 0) & 7);
34987 PRE_IO
34988 READ_BYTE_F(adr, src)
34989 dst = DREGu8((Opcode >> 9) & 7);
34990 res = dst + src;
34991 flag_N = flag_X = flag_C = res;
34992 flag_V = (src ^ res) & (dst ^ res);
34993 flag_NotZ = res & 0xFF;
34994 DREGu8((Opcode >> 9) & 7) = res;
34995 POST_IO
34996RET(8)
34997}
34998
34999// ADDaD
35000OPCODE(0xD018)
35001{
35002 u32 adr, res;
35003 u32 src, dst;
35004
35005 adr = AREG((Opcode >> 0) & 7);
35006 AREG((Opcode >> 0) & 7) += 1;
35007 PRE_IO
35008 READ_BYTE_F(adr, src)
35009 dst = DREGu8((Opcode >> 9) & 7);
35010 res = dst + src;
35011 flag_N = flag_X = flag_C = res;
35012 flag_V = (src ^ res) & (dst ^ res);
35013 flag_NotZ = res & 0xFF;
35014 DREGu8((Opcode >> 9) & 7) = res;
35015 POST_IO
35016RET(8)
35017}
35018
35019// ADDaD
35020OPCODE(0xD020)
35021{
35022 u32 adr, res;
35023 u32 src, dst;
35024
35025 adr = AREG((Opcode >> 0) & 7) - 1;
35026 AREG((Opcode >> 0) & 7) = adr;
35027 PRE_IO
35028 READ_BYTE_F(adr, src)
35029 dst = DREGu8((Opcode >> 9) & 7);
35030 res = dst + src;
35031 flag_N = flag_X = flag_C = res;
35032 flag_V = (src ^ res) & (dst ^ res);
35033 flag_NotZ = res & 0xFF;
35034 DREGu8((Opcode >> 9) & 7) = res;
35035 POST_IO
35036RET(10)
35037}
35038
35039// ADDaD
35040OPCODE(0xD028)
35041{
35042 u32 adr, res;
35043 u32 src, dst;
35044
35045 FETCH_SWORD(adr);
35046 adr += AREG((Opcode >> 0) & 7);
35047 PRE_IO
35048 READ_BYTE_F(adr, src)
35049 dst = DREGu8((Opcode >> 9) & 7);
35050 res = dst + src;
35051 flag_N = flag_X = flag_C = res;
35052 flag_V = (src ^ res) & (dst ^ res);
35053 flag_NotZ = res & 0xFF;
35054 DREGu8((Opcode >> 9) & 7) = res;
35055 POST_IO
35056RET(12)
35057}
35058
35059// ADDaD
35060OPCODE(0xD030)
35061{
35062 u32 adr, res;
35063 u32 src, dst;
35064
35065 adr = AREG((Opcode >> 0) & 7);
35066 DECODE_EXT_WORD
35067 PRE_IO
35068 READ_BYTE_F(adr, src)
35069 dst = DREGu8((Opcode >> 9) & 7);
35070 res = dst + src;
35071 flag_N = flag_X = flag_C = res;
35072 flag_V = (src ^ res) & (dst ^ res);
35073 flag_NotZ = res & 0xFF;
35074 DREGu8((Opcode >> 9) & 7) = res;
35075 POST_IO
35076RET(14)
35077}
35078
35079// ADDaD
35080OPCODE(0xD038)
35081{
35082 u32 adr, res;
35083 u32 src, dst;
35084
35085 FETCH_SWORD(adr);
35086 PRE_IO
35087 READ_BYTE_F(adr, src)
35088 dst = DREGu8((Opcode >> 9) & 7);
35089 res = dst + src;
35090 flag_N = flag_X = flag_C = res;
35091 flag_V = (src ^ res) & (dst ^ res);
35092 flag_NotZ = res & 0xFF;
35093 DREGu8((Opcode >> 9) & 7) = res;
35094 POST_IO
35095RET(12)
35096}
35097
35098// ADDaD
35099OPCODE(0xD039)
35100{
35101 u32 adr, res;
35102 u32 src, dst;
35103
35104 FETCH_LONG(adr);
35105 PRE_IO
35106 READ_BYTE_F(adr, src)
35107 dst = DREGu8((Opcode >> 9) & 7);
35108 res = dst + src;
35109 flag_N = flag_X = flag_C = res;
35110 flag_V = (src ^ res) & (dst ^ res);
35111 flag_NotZ = res & 0xFF;
35112 DREGu8((Opcode >> 9) & 7) = res;
35113 POST_IO
35114RET(16)
35115}
35116
35117// ADDaD
35118OPCODE(0xD03A)
35119{
35120 u32 adr, res;
35121 u32 src, dst;
35122
be26eb23 35123 adr = GET_SWORD + GET_PC;
70357ce5 35124 PC++;
35125 PRE_IO
35126 READ_BYTE_F(adr, src)
35127 dst = DREGu8((Opcode >> 9) & 7);
35128 res = dst + src;
35129 flag_N = flag_X = flag_C = res;
35130 flag_V = (src ^ res) & (dst ^ res);
35131 flag_NotZ = res & 0xFF;
35132 DREGu8((Opcode >> 9) & 7) = res;
35133 POST_IO
35134RET(12)
35135}
35136
35137// ADDaD
35138OPCODE(0xD03B)
35139{
35140 u32 adr, res;
35141 u32 src, dst;
35142
be26eb23 35143 adr = GET_PC;
70357ce5 35144 DECODE_EXT_WORD
35145 PRE_IO
35146 READ_BYTE_F(adr, src)
35147 dst = DREGu8((Opcode >> 9) & 7);
35148 res = dst + src;
35149 flag_N = flag_X = flag_C = res;
35150 flag_V = (src ^ res) & (dst ^ res);
35151 flag_NotZ = res & 0xFF;
35152 DREGu8((Opcode >> 9) & 7) = res;
35153 POST_IO
35154RET(14)
35155}
35156
35157// ADDaD
35158OPCODE(0xD03C)
35159{
35160 u32 adr, res;
35161 u32 src, dst;
35162
35163 FETCH_BYTE(src);
35164 dst = DREGu8((Opcode >> 9) & 7);
35165 res = dst + src;
35166 flag_N = flag_X = flag_C = res;
35167 flag_V = (src ^ res) & (dst ^ res);
35168 flag_NotZ = res & 0xFF;
35169 DREGu8((Opcode >> 9) & 7) = res;
35170RET(8)
35171}
35172
35173// ADDaD
35174OPCODE(0xD01F)
35175{
35176 u32 adr, res;
35177 u32 src, dst;
35178
35179 adr = AREG(7);
35180 AREG(7) += 2;
35181 PRE_IO
35182 READ_BYTE_F(adr, src)
35183 dst = DREGu8((Opcode >> 9) & 7);
35184 res = dst + src;
35185 flag_N = flag_X = flag_C = res;
35186 flag_V = (src ^ res) & (dst ^ res);
35187 flag_NotZ = res & 0xFF;
35188 DREGu8((Opcode >> 9) & 7) = res;
35189 POST_IO
35190RET(8)
35191}
35192
35193// ADDaD
35194OPCODE(0xD027)
35195{
35196 u32 adr, res;
35197 u32 src, dst;
35198
35199 adr = AREG(7) - 2;
35200 AREG(7) = adr;
35201 PRE_IO
35202 READ_BYTE_F(adr, src)
35203 dst = DREGu8((Opcode >> 9) & 7);
35204 res = dst + src;
35205 flag_N = flag_X = flag_C = res;
35206 flag_V = (src ^ res) & (dst ^ res);
35207 flag_NotZ = res & 0xFF;
35208 DREGu8((Opcode >> 9) & 7) = res;
35209 POST_IO
35210RET(10)
35211}
35212
35213// ADDaD
35214OPCODE(0xD040)
35215{
35216 u32 adr, res;
35217 u32 src, dst;
35218
35219 src = DREGu16((Opcode >> 0) & 7);
35220 dst = DREGu16((Opcode >> 9) & 7);
35221 res = dst + src;
35222 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35223 flag_N = flag_X = flag_C = res >> 8;
35224 flag_NotZ = res & 0xFFFF;
35225 DREGu16((Opcode >> 9) & 7) = res;
35226RET(4)
35227}
35228
35229// ADDaD
35230OPCODE(0xD048)
35231{
35232 u32 adr, res;
35233 u32 src, dst;
35234
35235 src = AREGu16((Opcode >> 0) & 7);
35236 dst = DREGu16((Opcode >> 9) & 7);
35237 res = dst + src;
35238 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35239 flag_N = flag_X = flag_C = res >> 8;
35240 flag_NotZ = res & 0xFFFF;
35241 DREGu16((Opcode >> 9) & 7) = res;
35242RET(4)
35243}
35244
35245// ADDaD
35246OPCODE(0xD050)
35247{
35248 u32 adr, res;
35249 u32 src, dst;
35250
35251 adr = AREG((Opcode >> 0) & 7);
35252 PRE_IO
35253 READ_WORD_F(adr, src)
35254 dst = DREGu16((Opcode >> 9) & 7);
35255 res = dst + src;
35256 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35257 flag_N = flag_X = flag_C = res >> 8;
35258 flag_NotZ = res & 0xFFFF;
35259 DREGu16((Opcode >> 9) & 7) = res;
35260 POST_IO
35261RET(8)
35262}
35263
35264// ADDaD
35265OPCODE(0xD058)
35266{
35267 u32 adr, res;
35268 u32 src, dst;
35269
35270 adr = AREG((Opcode >> 0) & 7);
35271 AREG((Opcode >> 0) & 7) += 2;
35272 PRE_IO
35273 READ_WORD_F(adr, src)
35274 dst = DREGu16((Opcode >> 9) & 7);
35275 res = dst + src;
35276 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35277 flag_N = flag_X = flag_C = res >> 8;
35278 flag_NotZ = res & 0xFFFF;
35279 DREGu16((Opcode >> 9) & 7) = res;
35280 POST_IO
35281RET(8)
35282}
35283
35284// ADDaD
35285OPCODE(0xD060)
35286{
35287 u32 adr, res;
35288 u32 src, dst;
35289
35290 adr = AREG((Opcode >> 0) & 7) - 2;
35291 AREG((Opcode >> 0) & 7) = adr;
35292 PRE_IO
35293 READ_WORD_F(adr, src)
35294 dst = DREGu16((Opcode >> 9) & 7);
35295 res = dst + src;
35296 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35297 flag_N = flag_X = flag_C = res >> 8;
35298 flag_NotZ = res & 0xFFFF;
35299 DREGu16((Opcode >> 9) & 7) = res;
35300 POST_IO
35301RET(10)
35302}
35303
35304// ADDaD
35305OPCODE(0xD068)
35306{
35307 u32 adr, res;
35308 u32 src, dst;
35309
35310 FETCH_SWORD(adr);
35311 adr += AREG((Opcode >> 0) & 7);
35312 PRE_IO
35313 READ_WORD_F(adr, src)
35314 dst = DREGu16((Opcode >> 9) & 7);
35315 res = dst + src;
35316 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35317 flag_N = flag_X = flag_C = res >> 8;
35318 flag_NotZ = res & 0xFFFF;
35319 DREGu16((Opcode >> 9) & 7) = res;
35320 POST_IO
35321RET(12)
35322}
35323
35324// ADDaD
35325OPCODE(0xD070)
35326{
35327 u32 adr, res;
35328 u32 src, dst;
35329
35330 adr = AREG((Opcode >> 0) & 7);
35331 DECODE_EXT_WORD
35332 PRE_IO
35333 READ_WORD_F(adr, src)
35334 dst = DREGu16((Opcode >> 9) & 7);
35335 res = dst + src;
35336 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35337 flag_N = flag_X = flag_C = res >> 8;
35338 flag_NotZ = res & 0xFFFF;
35339 DREGu16((Opcode >> 9) & 7) = res;
35340 POST_IO
35341RET(14)
35342}
35343
35344// ADDaD
35345OPCODE(0xD078)
35346{
35347 u32 adr, res;
35348 u32 src, dst;
35349
35350 FETCH_SWORD(adr);
35351 PRE_IO
35352 READ_WORD_F(adr, src)
35353 dst = DREGu16((Opcode >> 9) & 7);
35354 res = dst + src;
35355 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35356 flag_N = flag_X = flag_C = res >> 8;
35357 flag_NotZ = res & 0xFFFF;
35358 DREGu16((Opcode >> 9) & 7) = res;
35359 POST_IO
35360RET(12)
35361}
35362
35363// ADDaD
35364OPCODE(0xD079)
35365{
35366 u32 adr, res;
35367 u32 src, dst;
35368
35369 FETCH_LONG(adr);
35370 PRE_IO
35371 READ_WORD_F(adr, src)
35372 dst = DREGu16((Opcode >> 9) & 7);
35373 res = dst + src;
35374 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35375 flag_N = flag_X = flag_C = res >> 8;
35376 flag_NotZ = res & 0xFFFF;
35377 DREGu16((Opcode >> 9) & 7) = res;
35378 POST_IO
35379RET(16)
35380}
35381
35382// ADDaD
35383OPCODE(0xD07A)
35384{
35385 u32 adr, res;
35386 u32 src, dst;
35387
be26eb23 35388 adr = GET_SWORD + GET_PC;
70357ce5 35389 PC++;
35390 PRE_IO
35391 READ_WORD_F(adr, src)
35392 dst = DREGu16((Opcode >> 9) & 7);
35393 res = dst + src;
35394 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35395 flag_N = flag_X = flag_C = res >> 8;
35396 flag_NotZ = res & 0xFFFF;
35397 DREGu16((Opcode >> 9) & 7) = res;
35398 POST_IO
35399RET(12)
35400}
35401
35402// ADDaD
35403OPCODE(0xD07B)
35404{
35405 u32 adr, res;
35406 u32 src, dst;
35407
be26eb23 35408 adr = GET_PC;
70357ce5 35409 DECODE_EXT_WORD
35410 PRE_IO
35411 READ_WORD_F(adr, src)
35412 dst = DREGu16((Opcode >> 9) & 7);
35413 res = dst + src;
35414 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35415 flag_N = flag_X = flag_C = res >> 8;
35416 flag_NotZ = res & 0xFFFF;
35417 DREGu16((Opcode >> 9) & 7) = res;
35418 POST_IO
35419RET(14)
35420}
35421
35422// ADDaD
35423OPCODE(0xD07C)
35424{
35425 u32 adr, res;
35426 u32 src, dst;
35427
35428 FETCH_WORD(src);
35429 dst = DREGu16((Opcode >> 9) & 7);
35430 res = dst + src;
35431 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35432 flag_N = flag_X = flag_C = res >> 8;
35433 flag_NotZ = res & 0xFFFF;
35434 DREGu16((Opcode >> 9) & 7) = res;
35435RET(8)
35436}
35437
35438// ADDaD
35439OPCODE(0xD05F)
35440{
35441 u32 adr, res;
35442 u32 src, dst;
35443
35444 adr = AREG(7);
35445 AREG(7) += 2;
35446 PRE_IO
35447 READ_WORD_F(adr, src)
35448 dst = DREGu16((Opcode >> 9) & 7);
35449 res = dst + src;
35450 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35451 flag_N = flag_X = flag_C = res >> 8;
35452 flag_NotZ = res & 0xFFFF;
35453 DREGu16((Opcode >> 9) & 7) = res;
35454 POST_IO
35455RET(8)
35456}
35457
35458// ADDaD
35459OPCODE(0xD067)
35460{
35461 u32 adr, res;
35462 u32 src, dst;
35463
35464 adr = AREG(7) - 2;
35465 AREG(7) = adr;
35466 PRE_IO
35467 READ_WORD_F(adr, src)
35468 dst = DREGu16((Opcode >> 9) & 7);
35469 res = dst + src;
35470 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35471 flag_N = flag_X = flag_C = res >> 8;
35472 flag_NotZ = res & 0xFFFF;
35473 DREGu16((Opcode >> 9) & 7) = res;
35474 POST_IO
35475RET(10)
35476}
35477
35478// ADDaD
35479OPCODE(0xD080)
35480{
35481 u32 adr, res;
35482 u32 src, dst;
35483
35484 src = DREGu32((Opcode >> 0) & 7);
35485 dst = DREGu32((Opcode >> 9) & 7);
35486 res = dst + src;
35487 flag_NotZ = res;
35488 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35489 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35490 flag_N = res >> 24;
35491 DREGu32((Opcode >> 9) & 7) = res;
35492RET(8)
35493}
35494
35495// ADDaD
35496OPCODE(0xD088)
35497{
35498 u32 adr, res;
35499 u32 src, dst;
35500
35501 src = AREGu32((Opcode >> 0) & 7);
35502 dst = DREGu32((Opcode >> 9) & 7);
35503 res = dst + src;
35504 flag_NotZ = res;
35505 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35506 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35507 flag_N = res >> 24;
35508 DREGu32((Opcode >> 9) & 7) = res;
35509RET(8)
35510}
35511
35512// ADDaD
35513OPCODE(0xD090)
35514{
35515 u32 adr, res;
35516 u32 src, dst;
35517
35518 adr = AREG((Opcode >> 0) & 7);
35519 PRE_IO
35520 READ_LONG_F(adr, src)
35521 dst = DREGu32((Opcode >> 9) & 7);
35522 res = dst + src;
35523 flag_NotZ = res;
35524 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35525 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35526 flag_N = res >> 24;
35527 DREGu32((Opcode >> 9) & 7) = res;
35528 POST_IO
35529RET(14)
35530}
35531
35532// ADDaD
35533OPCODE(0xD098)
35534{
35535 u32 adr, res;
35536 u32 src, dst;
35537
35538 adr = AREG((Opcode >> 0) & 7);
35539 AREG((Opcode >> 0) & 7) += 4;
35540 PRE_IO
35541 READ_LONG_F(adr, src)
35542 dst = DREGu32((Opcode >> 9) & 7);
35543 res = dst + src;
35544 flag_NotZ = res;
35545 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35546 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35547 flag_N = res >> 24;
35548 DREGu32((Opcode >> 9) & 7) = res;
35549 POST_IO
35550RET(14)
35551}
35552
35553// ADDaD
35554OPCODE(0xD0A0)
35555{
35556 u32 adr, res;
35557 u32 src, dst;
35558
35559 adr = AREG((Opcode >> 0) & 7) - 4;
35560 AREG((Opcode >> 0) & 7) = adr;
35561 PRE_IO
35562 READ_LONG_F(adr, src)
35563 dst = DREGu32((Opcode >> 9) & 7);
35564 res = dst + src;
35565 flag_NotZ = res;
35566 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35567 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35568 flag_N = res >> 24;
35569 DREGu32((Opcode >> 9) & 7) = res;
35570 POST_IO
35571RET(16)
35572}
35573
35574// ADDaD
35575OPCODE(0xD0A8)
35576{
35577 u32 adr, res;
35578 u32 src, dst;
35579
35580 FETCH_SWORD(adr);
35581 adr += AREG((Opcode >> 0) & 7);
35582 PRE_IO
35583 READ_LONG_F(adr, src)
35584 dst = DREGu32((Opcode >> 9) & 7);
35585 res = dst + src;
35586 flag_NotZ = res;
35587 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35588 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35589 flag_N = res >> 24;
35590 DREGu32((Opcode >> 9) & 7) = res;
35591 POST_IO
35592RET(18)
35593}
35594
35595// ADDaD
35596OPCODE(0xD0B0)
35597{
35598 u32 adr, res;
35599 u32 src, dst;
35600
35601 adr = AREG((Opcode >> 0) & 7);
35602 DECODE_EXT_WORD
35603 PRE_IO
35604 READ_LONG_F(adr, src)
35605 dst = DREGu32((Opcode >> 9) & 7);
35606 res = dst + src;
35607 flag_NotZ = res;
35608 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35609 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35610 flag_N = res >> 24;
35611 DREGu32((Opcode >> 9) & 7) = res;
35612 POST_IO
35613RET(20)
35614}
35615
35616// ADDaD
35617OPCODE(0xD0B8)
35618{
35619 u32 adr, res;
35620 u32 src, dst;
35621
35622 FETCH_SWORD(adr);
35623 PRE_IO
35624 READ_LONG_F(adr, src)
35625 dst = DREGu32((Opcode >> 9) & 7);
35626 res = dst + src;
35627 flag_NotZ = res;
35628 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35629 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35630 flag_N = res >> 24;
35631 DREGu32((Opcode >> 9) & 7) = res;
35632 POST_IO
35633RET(18)
35634}
35635
35636// ADDaD
35637OPCODE(0xD0B9)
35638{
35639 u32 adr, res;
35640 u32 src, dst;
35641
35642 FETCH_LONG(adr);
35643 PRE_IO
35644 READ_LONG_F(adr, src)
35645 dst = DREGu32((Opcode >> 9) & 7);
35646 res = dst + src;
35647 flag_NotZ = res;
35648 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35649 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35650 flag_N = res >> 24;
35651 DREGu32((Opcode >> 9) & 7) = res;
35652 POST_IO
35653RET(22)
35654}
35655
35656// ADDaD
35657OPCODE(0xD0BA)
35658{
35659 u32 adr, res;
35660 u32 src, dst;
35661
be26eb23 35662 adr = GET_SWORD + GET_PC;
70357ce5 35663 PC++;
35664 PRE_IO
35665 READ_LONG_F(adr, src)
35666 dst = DREGu32((Opcode >> 9) & 7);
35667 res = dst + src;
35668 flag_NotZ = res;
35669 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35670 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35671 flag_N = res >> 24;
35672 DREGu32((Opcode >> 9) & 7) = res;
35673 POST_IO
35674RET(18)
35675}
35676
35677// ADDaD
35678OPCODE(0xD0BB)
35679{
35680 u32 adr, res;
35681 u32 src, dst;
35682
be26eb23 35683 adr = GET_PC;
70357ce5 35684 DECODE_EXT_WORD
35685 PRE_IO
35686 READ_LONG_F(adr, src)
35687 dst = DREGu32((Opcode >> 9) & 7);
35688 res = dst + src;
35689 flag_NotZ = res;
35690 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35691 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35692 flag_N = res >> 24;
35693 DREGu32((Opcode >> 9) & 7) = res;
35694 POST_IO
35695RET(20)
35696}
35697
35698// ADDaD
35699OPCODE(0xD0BC)
35700{
35701 u32 adr, res;
35702 u32 src, dst;
35703
35704 FETCH_LONG(src);
35705 dst = DREGu32((Opcode >> 9) & 7);
35706 res = dst + src;
35707 flag_NotZ = res;
35708 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35709 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35710 flag_N = res >> 24;
35711 DREGu32((Opcode >> 9) & 7) = res;
35712RET(16)
35713}
35714
35715// ADDaD
35716OPCODE(0xD09F)
35717{
35718 u32 adr, res;
35719 u32 src, dst;
35720
35721 adr = AREG(7);
35722 AREG(7) += 4;
35723 PRE_IO
35724 READ_LONG_F(adr, src)
35725 dst = DREGu32((Opcode >> 9) & 7);
35726 res = dst + src;
35727 flag_NotZ = res;
35728 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35729 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35730 flag_N = res >> 24;
35731 DREGu32((Opcode >> 9) & 7) = res;
35732 POST_IO
35733RET(14)
35734}
35735
35736// ADDaD
35737OPCODE(0xD0A7)
35738{
35739 u32 adr, res;
35740 u32 src, dst;
35741
35742 adr = AREG(7) - 4;
35743 AREG(7) = adr;
35744 PRE_IO
35745 READ_LONG_F(adr, src)
35746 dst = DREGu32((Opcode >> 9) & 7);
35747 res = dst + src;
35748 flag_NotZ = res;
35749 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35750 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35751 flag_N = res >> 24;
35752 DREGu32((Opcode >> 9) & 7) = res;
35753 POST_IO
35754RET(16)
35755}
35756
35757// ADDDa
35758OPCODE(0xD110)
35759{
35760 u32 adr, res;
35761 u32 src, dst;
35762
35763 src = DREGu8((Opcode >> 9) & 7);
35764 adr = AREG((Opcode >> 0) & 7);
35765 PRE_IO
35766 READ_BYTE_F(adr, dst)
35767 res = dst + src;
35768 flag_N = flag_X = flag_C = res;
35769 flag_V = (src ^ res) & (dst ^ res);
35770 flag_NotZ = res & 0xFF;
35771 WRITE_BYTE_F(adr, res)
35772 POST_IO
35773RET(12)
35774}
35775
35776// ADDDa
35777OPCODE(0xD118)
35778{
35779 u32 adr, res;
35780 u32 src, dst;
35781
35782 src = DREGu8((Opcode >> 9) & 7);
35783 adr = AREG((Opcode >> 0) & 7);
35784 AREG((Opcode >> 0) & 7) += 1;
35785 PRE_IO
35786 READ_BYTE_F(adr, dst)
35787 res = dst + src;
35788 flag_N = flag_X = flag_C = res;
35789 flag_V = (src ^ res) & (dst ^ res);
35790 flag_NotZ = res & 0xFF;
35791 WRITE_BYTE_F(adr, res)
35792 POST_IO
35793RET(12)
35794}
35795
35796// ADDDa
35797OPCODE(0xD120)
35798{
35799 u32 adr, res;
35800 u32 src, dst;
35801
35802 src = DREGu8((Opcode >> 9) & 7);
35803 adr = AREG((Opcode >> 0) & 7) - 1;
35804 AREG((Opcode >> 0) & 7) = adr;
35805 PRE_IO
35806 READ_BYTE_F(adr, dst)
35807 res = dst + src;
35808 flag_N = flag_X = flag_C = res;
35809 flag_V = (src ^ res) & (dst ^ res);
35810 flag_NotZ = res & 0xFF;
35811 WRITE_BYTE_F(adr, res)
35812 POST_IO
35813RET(14)
35814}
35815
35816// ADDDa
35817OPCODE(0xD128)
35818{
35819 u32 adr, res;
35820 u32 src, dst;
35821
35822 src = DREGu8((Opcode >> 9) & 7);
35823 FETCH_SWORD(adr);
35824 adr += AREG((Opcode >> 0) & 7);
35825 PRE_IO
35826 READ_BYTE_F(adr, dst)
35827 res = dst + src;
35828 flag_N = flag_X = flag_C = res;
35829 flag_V = (src ^ res) & (dst ^ res);
35830 flag_NotZ = res & 0xFF;
35831 WRITE_BYTE_F(adr, res)
35832 POST_IO
35833RET(16)
35834}
35835
35836// ADDDa
35837OPCODE(0xD130)
35838{
35839 u32 adr, res;
35840 u32 src, dst;
35841
35842 src = DREGu8((Opcode >> 9) & 7);
35843 adr = AREG((Opcode >> 0) & 7);
35844 DECODE_EXT_WORD
35845 PRE_IO
35846 READ_BYTE_F(adr, dst)
35847 res = dst + src;
35848 flag_N = flag_X = flag_C = res;
35849 flag_V = (src ^ res) & (dst ^ res);
35850 flag_NotZ = res & 0xFF;
35851 WRITE_BYTE_F(adr, res)
35852 POST_IO
35853RET(18)
35854}
35855
35856// ADDDa
35857OPCODE(0xD138)
35858{
35859 u32 adr, res;
35860 u32 src, dst;
35861
35862 src = DREGu8((Opcode >> 9) & 7);
35863 FETCH_SWORD(adr);
35864 PRE_IO
35865 READ_BYTE_F(adr, dst)
35866 res = dst + src;
35867 flag_N = flag_X = flag_C = res;
35868 flag_V = (src ^ res) & (dst ^ res);
35869 flag_NotZ = res & 0xFF;
35870 WRITE_BYTE_F(adr, res)
35871 POST_IO
35872RET(16)
35873}
35874
35875// ADDDa
35876OPCODE(0xD139)
35877{
35878 u32 adr, res;
35879 u32 src, dst;
35880
35881 src = DREGu8((Opcode >> 9) & 7);
35882 FETCH_LONG(adr);
35883 PRE_IO
35884 READ_BYTE_F(adr, dst)
35885 res = dst + src;
35886 flag_N = flag_X = flag_C = res;
35887 flag_V = (src ^ res) & (dst ^ res);
35888 flag_NotZ = res & 0xFF;
35889 WRITE_BYTE_F(adr, res)
35890 POST_IO
35891RET(20)
35892}
35893
35894// ADDDa
35895OPCODE(0xD11F)
35896{
35897 u32 adr, res;
35898 u32 src, dst;
35899
35900 src = DREGu8((Opcode >> 9) & 7);
35901 adr = AREG(7);
35902 AREG(7) += 2;
35903 PRE_IO
35904 READ_BYTE_F(adr, dst)
35905 res = dst + src;
35906 flag_N = flag_X = flag_C = res;
35907 flag_V = (src ^ res) & (dst ^ res);
35908 flag_NotZ = res & 0xFF;
35909 WRITE_BYTE_F(adr, res)
35910 POST_IO
35911RET(12)
35912}
35913
35914// ADDDa
35915OPCODE(0xD127)
35916{
35917 u32 adr, res;
35918 u32 src, dst;
35919
35920 src = DREGu8((Opcode >> 9) & 7);
35921 adr = AREG(7) - 2;
35922 AREG(7) = adr;
35923 PRE_IO
35924 READ_BYTE_F(adr, dst)
35925 res = dst + src;
35926 flag_N = flag_X = flag_C = res;
35927 flag_V = (src ^ res) & (dst ^ res);
35928 flag_NotZ = res & 0xFF;
35929 WRITE_BYTE_F(adr, res)
35930 POST_IO
35931RET(14)
35932}
35933
35934// ADDDa
35935OPCODE(0xD150)
35936{
35937 u32 adr, res;
35938 u32 src, dst;
35939
35940 src = DREGu16((Opcode >> 9) & 7);
35941 adr = AREG((Opcode >> 0) & 7);
35942 PRE_IO
35943 READ_WORD_F(adr, dst)
35944 res = dst + src;
35945 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35946 flag_N = flag_X = flag_C = res >> 8;
35947 flag_NotZ = res & 0xFFFF;
35948 WRITE_WORD_F(adr, res)
35949 POST_IO
35950RET(12)
35951}
35952
35953// ADDDa
35954OPCODE(0xD158)
35955{
35956 u32 adr, res;
35957 u32 src, dst;
35958
35959 src = DREGu16((Opcode >> 9) & 7);
35960 adr = AREG((Opcode >> 0) & 7);
35961 AREG((Opcode >> 0) & 7) += 2;
35962 PRE_IO
35963 READ_WORD_F(adr, dst)
35964 res = dst + src;
35965 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35966 flag_N = flag_X = flag_C = res >> 8;
35967 flag_NotZ = res & 0xFFFF;
35968 WRITE_WORD_F(adr, res)
35969 POST_IO
35970RET(12)
35971}
35972
35973// ADDDa
35974OPCODE(0xD160)
35975{
35976 u32 adr, res;
35977 u32 src, dst;
35978
35979 src = DREGu16((Opcode >> 9) & 7);
35980 adr = AREG((Opcode >> 0) & 7) - 2;
35981 AREG((Opcode >> 0) & 7) = adr;
35982 PRE_IO
35983 READ_WORD_F(adr, dst)
35984 res = dst + src;
35985 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35986 flag_N = flag_X = flag_C = res >> 8;
35987 flag_NotZ = res & 0xFFFF;
35988 WRITE_WORD_F(adr, res)
35989 POST_IO
35990RET(14)
35991}
35992
35993// ADDDa
35994OPCODE(0xD168)
35995{
35996 u32 adr, res;
35997 u32 src, dst;
35998
35999 src = DREGu16((Opcode >> 9) & 7);
36000 FETCH_SWORD(adr);
36001 adr += AREG((Opcode >> 0) & 7);
36002 PRE_IO
36003 READ_WORD_F(adr, dst)
36004 res = dst + src;
36005 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36006 flag_N = flag_X = flag_C = res >> 8;
36007 flag_NotZ = res & 0xFFFF;
36008 WRITE_WORD_F(adr, res)
36009 POST_IO
36010RET(16)
36011}
36012
36013// ADDDa
36014OPCODE(0xD170)
36015{
36016 u32 adr, res;
36017 u32 src, dst;
36018
36019 src = DREGu16((Opcode >> 9) & 7);
36020 adr = AREG((Opcode >> 0) & 7);
36021 DECODE_EXT_WORD
36022 PRE_IO
36023 READ_WORD_F(adr, dst)
36024 res = dst + src;
36025 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36026 flag_N = flag_X = flag_C = res >> 8;
36027 flag_NotZ = res & 0xFFFF;
36028 WRITE_WORD_F(adr, res)
36029 POST_IO
36030RET(18)
36031}
36032
36033// ADDDa
36034OPCODE(0xD178)
36035{
36036 u32 adr, res;
36037 u32 src, dst;
36038
36039 src = DREGu16((Opcode >> 9) & 7);
36040 FETCH_SWORD(adr);
36041 PRE_IO
36042 READ_WORD_F(adr, dst)
36043 res = dst + src;
36044 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36045 flag_N = flag_X = flag_C = res >> 8;
36046 flag_NotZ = res & 0xFFFF;
36047 WRITE_WORD_F(adr, res)
36048 POST_IO
36049RET(16)
36050}
36051
36052// ADDDa
36053OPCODE(0xD179)
36054{
36055 u32 adr, res;
36056 u32 src, dst;
36057
36058 src = DREGu16((Opcode >> 9) & 7);
36059 FETCH_LONG(adr);
36060 PRE_IO
36061 READ_WORD_F(adr, dst)
36062 res = dst + src;
36063 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36064 flag_N = flag_X = flag_C = res >> 8;
36065 flag_NotZ = res & 0xFFFF;
36066 WRITE_WORD_F(adr, res)
36067 POST_IO
36068RET(20)
36069}
36070
36071// ADDDa
36072OPCODE(0xD15F)
36073{
36074 u32 adr, res;
36075 u32 src, dst;
36076
36077 src = DREGu16((Opcode >> 9) & 7);
36078 adr = AREG(7);
36079 AREG(7) += 2;
36080 PRE_IO
36081 READ_WORD_F(adr, dst)
36082 res = dst + src;
36083 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36084 flag_N = flag_X = flag_C = res >> 8;
36085 flag_NotZ = res & 0xFFFF;
36086 WRITE_WORD_F(adr, res)
36087 POST_IO
36088RET(12)
36089}
36090
36091// ADDDa
36092OPCODE(0xD167)
36093{
36094 u32 adr, res;
36095 u32 src, dst;
36096
36097 src = DREGu16((Opcode >> 9) & 7);
36098 adr = AREG(7) - 2;
36099 AREG(7) = adr;
36100 PRE_IO
36101 READ_WORD_F(adr, dst)
36102 res = dst + src;
36103 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36104 flag_N = flag_X = flag_C = res >> 8;
36105 flag_NotZ = res & 0xFFFF;
36106 WRITE_WORD_F(adr, res)
36107 POST_IO
36108RET(14)
36109}
36110
36111// ADDDa
36112OPCODE(0xD190)
36113{
36114 u32 adr, res;
36115 u32 src, dst;
36116
36117 src = DREGu32((Opcode >> 9) & 7);
36118 adr = AREG((Opcode >> 0) & 7);
36119 PRE_IO
36120 READ_LONG_F(adr, dst)
36121 res = dst + src;
36122 flag_NotZ = res;
36123 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36124 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36125 flag_N = res >> 24;
36126 WRITE_LONG_F(adr, res)
36127 POST_IO
36128RET(20)
36129}
36130
36131// ADDDa
36132OPCODE(0xD198)
36133{
36134 u32 adr, res;
36135 u32 src, dst;
36136
36137 src = DREGu32((Opcode >> 9) & 7);
36138 adr = AREG((Opcode >> 0) & 7);
36139 AREG((Opcode >> 0) & 7) += 4;
36140 PRE_IO
36141 READ_LONG_F(adr, dst)
36142 res = dst + src;
36143 flag_NotZ = res;
36144 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36145 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36146 flag_N = res >> 24;
36147 WRITE_LONG_F(adr, res)
36148 POST_IO
36149RET(20)
36150}
36151
36152// ADDDa
36153OPCODE(0xD1A0)
36154{
36155 u32 adr, res;
36156 u32 src, dst;
36157
36158 src = DREGu32((Opcode >> 9) & 7);
36159 adr = AREG((Opcode >> 0) & 7) - 4;
36160 AREG((Opcode >> 0) & 7) = adr;
36161 PRE_IO
36162 READ_LONG_F(adr, dst)
36163 res = dst + src;
36164 flag_NotZ = res;
36165 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36166 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36167 flag_N = res >> 24;
36168 WRITE_LONG_F(adr, res)
36169 POST_IO
36170RET(22)
36171}
36172
36173// ADDDa
36174OPCODE(0xD1A8)
36175{
36176 u32 adr, res;
36177 u32 src, dst;
36178
36179 src = DREGu32((Opcode >> 9) & 7);
36180 FETCH_SWORD(adr);
36181 adr += AREG((Opcode >> 0) & 7);
36182 PRE_IO
36183 READ_LONG_F(adr, dst)
36184 res = dst + src;
36185 flag_NotZ = res;
36186 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36187 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36188 flag_N = res >> 24;
36189 WRITE_LONG_F(adr, res)
36190 POST_IO
36191RET(24)
36192}
36193
36194// ADDDa
36195OPCODE(0xD1B0)
36196{
36197 u32 adr, res;
36198 u32 src, dst;
36199
36200 src = DREGu32((Opcode >> 9) & 7);
36201 adr = AREG((Opcode >> 0) & 7);
36202 DECODE_EXT_WORD
36203 PRE_IO
36204 READ_LONG_F(adr, dst)
36205 res = dst + src;
36206 flag_NotZ = res;
36207 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36208 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36209 flag_N = res >> 24;
36210 WRITE_LONG_F(adr, res)
36211 POST_IO
36212RET(26)
36213}
36214
36215// ADDDa
36216OPCODE(0xD1B8)
36217{
36218 u32 adr, res;
36219 u32 src, dst;
36220
36221 src = DREGu32((Opcode >> 9) & 7);
36222 FETCH_SWORD(adr);
36223 PRE_IO
36224 READ_LONG_F(adr, dst)
36225 res = dst + src;
36226 flag_NotZ = res;
36227 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36228 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36229 flag_N = res >> 24;
36230 WRITE_LONG_F(adr, res)
36231 POST_IO
36232RET(24)
36233}
36234
36235// ADDDa
36236OPCODE(0xD1B9)
36237{
36238 u32 adr, res;
36239 u32 src, dst;
36240
36241 src = DREGu32((Opcode >> 9) & 7);
36242 FETCH_LONG(adr);
36243 PRE_IO
36244 READ_LONG_F(adr, dst)
36245 res = dst + src;
36246 flag_NotZ = res;
36247 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36248 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36249 flag_N = res >> 24;
36250 WRITE_LONG_F(adr, res)
36251 POST_IO
36252RET(28)
36253}
36254
36255// ADDDa
36256OPCODE(0xD19F)
36257{
36258 u32 adr, res;
36259 u32 src, dst;
36260
36261 src = DREGu32((Opcode >> 9) & 7);
36262 adr = AREG(7);
36263 AREG(7) += 4;
36264 PRE_IO
36265 READ_LONG_F(adr, dst)
36266 res = dst + src;
36267 flag_NotZ = res;
36268 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36269 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36270 flag_N = res >> 24;
36271 WRITE_LONG_F(adr, res)
36272 POST_IO
36273RET(20)
36274}
36275
36276// ADDDa
36277OPCODE(0xD1A7)
36278{
36279 u32 adr, res;
36280 u32 src, dst;
36281
36282 src = DREGu32((Opcode >> 9) & 7);
36283 adr = AREG(7) - 4;
36284 AREG(7) = adr;
36285 PRE_IO
36286 READ_LONG_F(adr, dst)
36287 res = dst + src;
36288 flag_NotZ = res;
36289 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36290 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36291 flag_N = res >> 24;
36292 WRITE_LONG_F(adr, res)
36293 POST_IO
36294RET(22)
36295}
36296
36297// ADDX
36298OPCODE(0xD100)
36299{
36300 u32 adr, res;
36301 u32 src, dst;
36302
36303 src = DREGu8((Opcode >> 0) & 7);
36304 dst = DREGu8((Opcode >> 9) & 7);
36305 res = dst + src + ((flag_X >> 8) & 1);
36306 flag_N = flag_X = flag_C = res;
36307 flag_V = (src ^ res) & (dst ^ res);
36308 flag_NotZ |= res & 0xFF;
36309 DREGu8((Opcode >> 9) & 7) = res;
36310RET(4)
36311}
36312
36313// ADDX
36314OPCODE(0xD140)
36315{
36316 u32 adr, res;
36317 u32 src, dst;
36318
36319 src = DREGu16((Opcode >> 0) & 7);
36320 dst = DREGu16((Opcode >> 9) & 7);
36321 res = dst + src + ((flag_X >> 8) & 1);
36322 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36323 flag_N = flag_X = flag_C = res >> 8;
36324 flag_NotZ |= res & 0xFFFF;
36325 DREGu16((Opcode >> 9) & 7) = res;
36326RET(4)
36327}
36328
36329// ADDX
36330OPCODE(0xD180)
36331{
36332 u32 adr, res;
36333 u32 src, dst;
36334
36335 src = DREGu32((Opcode >> 0) & 7);
36336 dst = DREGu32((Opcode >> 9) & 7);
36337 res = dst + src + ((flag_X >> 8) & 1);
36338 flag_NotZ |= res;
36339 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36340 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36341 flag_N = res >> 24;
36342 DREGu32((Opcode >> 9) & 7) = res;
36343RET(8)
36344}
36345
36346// ADDXM
36347OPCODE(0xD108)
36348{
36349 u32 adr, res;
36350 u32 src, dst;
36351
36352 adr = AREG((Opcode >> 0) & 7) - 1;
36353 AREG((Opcode >> 0) & 7) = adr;
36354 PRE_IO
36355 READ_BYTE_F(adr, src)
36356 adr = AREG((Opcode >> 9) & 7) - 1;
36357 AREG((Opcode >> 9) & 7) = adr;
36358 READ_BYTE_F(adr, dst)
36359 res = dst + src + ((flag_X >> 8) & 1);
36360 flag_N = flag_X = flag_C = res;
36361 flag_V = (src ^ res) & (dst ^ res);
36362 flag_NotZ |= res & 0xFF;
36363 WRITE_BYTE_F(adr, res)
36364 POST_IO
36365RET(18)
36366}
36367
36368// ADDXM
36369OPCODE(0xD148)
36370{
36371 u32 adr, res;
36372 u32 src, dst;
36373
36374 adr = AREG((Opcode >> 0) & 7) - 2;
36375 AREG((Opcode >> 0) & 7) = adr;
36376 PRE_IO
36377 READ_WORD_F(adr, src)
36378 adr = AREG((Opcode >> 9) & 7) - 2;
36379 AREG((Opcode >> 9) & 7) = adr;
36380 READ_WORD_F(adr, dst)
36381 res = dst + src + ((flag_X >> 8) & 1);
36382 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36383 flag_N = flag_X = flag_C = res >> 8;
36384 flag_NotZ |= res & 0xFFFF;
36385 WRITE_WORD_F(adr, res)
36386 POST_IO
36387RET(18)
36388}
36389
36390// ADDXM
36391OPCODE(0xD188)
36392{
36393 u32 adr, res;
36394 u32 src, dst;
36395
36396 adr = AREG((Opcode >> 0) & 7) - 4;
36397 AREG((Opcode >> 0) & 7) = adr;
36398 PRE_IO
36399 READ_LONG_F(adr, src)
36400 adr = AREG((Opcode >> 9) & 7) - 4;
36401 AREG((Opcode >> 9) & 7) = adr;
36402 READ_LONG_F(adr, dst)
36403 res = dst + src + ((flag_X >> 8) & 1);
36404 flag_NotZ |= res;
36405 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36406 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36407 flag_N = res >> 24;
36408 WRITE_LONG_F(adr, res)
36409 POST_IO
36410RET(30)
36411}
36412
36413// ADDX7M
36414OPCODE(0xD10F)
36415{
36416 u32 adr, res;
36417 u32 src, dst;
36418
36419 adr = AREG(7) - 2;
36420 AREG(7) = adr;
36421 PRE_IO
36422 READ_BYTE_F(adr, src)
36423 adr = AREG((Opcode >> 9) & 7) - 1;
36424 AREG((Opcode >> 9) & 7) = adr;
36425 READ_BYTE_F(adr, dst)
36426 res = dst + src + ((flag_X >> 8) & 1);
36427 flag_N = flag_X = flag_C = res;
36428 flag_V = (src ^ res) & (dst ^ res);
36429 flag_NotZ |= res & 0xFF;
36430 WRITE_BYTE_F(adr, res)
36431 POST_IO
36432RET(18)
36433}
36434
36435// ADDX7M
36436OPCODE(0xD14F)
36437{
36438 u32 adr, res;
36439 u32 src, dst;
36440
36441 adr = AREG(7) - 2;
36442 AREG(7) = adr;
36443 PRE_IO
36444 READ_WORD_F(adr, src)
36445 adr = AREG((Opcode >> 9) & 7) - 2;
36446 AREG((Opcode >> 9) & 7) = adr;
36447 READ_WORD_F(adr, dst)
36448 res = dst + src + ((flag_X >> 8) & 1);
36449 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36450 flag_N = flag_X = flag_C = res >> 8;
36451 flag_NotZ |= res & 0xFFFF;
36452 WRITE_WORD_F(adr, res)
36453 POST_IO
36454RET(18)
36455}
36456
36457// ADDX7M
36458OPCODE(0xD18F)
36459{
36460 u32 adr, res;
36461 u32 src, dst;
36462
36463 adr = AREG(7) - 4;
36464 AREG(7) = adr;
36465 PRE_IO
36466 READ_LONG_F(adr, src)
36467 adr = AREG((Opcode >> 9) & 7) - 4;
36468 AREG((Opcode >> 9) & 7) = adr;
36469 READ_LONG_F(adr, dst)
36470 res = dst + src + ((flag_X >> 8) & 1);
36471 flag_NotZ |= res;
36472 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36473 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36474 flag_N = res >> 24;
36475 WRITE_LONG_F(adr, res)
36476 POST_IO
36477RET(30)
36478}
36479
36480// ADDXM7
36481OPCODE(0xDF08)
36482{
36483 u32 adr, res;
36484 u32 src, dst;
36485
36486 adr = AREG((Opcode >> 0) & 7) - 1;
36487 AREG((Opcode >> 0) & 7) = adr;
36488 PRE_IO
36489 READ_BYTE_F(adr, src)
36490 adr = AREG(7) - 2;
36491 AREG(7) = adr;
36492 READ_BYTE_F(adr, dst)
36493 res = dst + src + ((flag_X >> 8) & 1);
36494 flag_N = flag_X = flag_C = res;
36495 flag_V = (src ^ res) & (dst ^ res);
36496 flag_NotZ |= res & 0xFF;
36497 WRITE_BYTE_F(adr, res)
36498 POST_IO
36499RET(18)
36500}
36501
36502// ADDXM7
36503OPCODE(0xDF48)
36504{
36505 u32 adr, res;
36506 u32 src, dst;
36507
36508 adr = AREG((Opcode >> 0) & 7) - 2;
36509 AREG((Opcode >> 0) & 7) = adr;
36510 PRE_IO
36511 READ_WORD_F(adr, src)
36512 adr = AREG(7) - 2;
36513 AREG(7) = adr;
36514 READ_WORD_F(adr, dst)
36515 res = dst + src + ((flag_X >> 8) & 1);
36516 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36517 flag_N = flag_X = flag_C = res >> 8;
36518 flag_NotZ |= res & 0xFFFF;
36519 WRITE_WORD_F(adr, res)
36520 POST_IO
36521RET(18)
36522}
36523
36524// ADDXM7
36525OPCODE(0xDF88)
36526{
36527 u32 adr, res;
36528 u32 src, dst;
36529
36530 adr = AREG((Opcode >> 0) & 7) - 4;
36531 AREG((Opcode >> 0) & 7) = adr;
36532 PRE_IO
36533 READ_LONG_F(adr, src)
36534 adr = AREG(7) - 4;
36535 AREG(7) = adr;
36536 READ_LONG_F(adr, dst)
36537 res = dst + src + ((flag_X >> 8) & 1);
36538 flag_NotZ |= res;
36539 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36540 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36541 flag_N = res >> 24;
36542 WRITE_LONG_F(adr, res)
36543 POST_IO
36544RET(30)
36545}
36546
36547// ADDX7M7
36548OPCODE(0xDF0F)
36549{
36550 u32 adr, res;
36551 u32 src, dst;
36552
36553 adr = AREG(7) - 2;
36554 AREG(7) = adr;
36555 PRE_IO
36556 READ_BYTE_F(adr, src)
36557 adr = AREG(7) - 2;
36558 AREG(7) = adr;
36559 READ_BYTE_F(adr, dst)
36560 res = dst + src + ((flag_X >> 8) & 1);
36561 flag_N = flag_X = flag_C = res;
36562 flag_V = (src ^ res) & (dst ^ res);
36563 flag_NotZ |= res & 0xFF;
36564 WRITE_BYTE_F(adr, res)
36565 POST_IO
36566RET(18)
36567}
36568
36569// ADDX7M7
36570OPCODE(0xDF4F)
36571{
36572 u32 adr, res;
36573 u32 src, dst;
36574
36575 adr = AREG(7) - 2;
36576 AREG(7) = adr;
36577 PRE_IO
36578 READ_WORD_F(adr, src)
36579 adr = AREG(7) - 2;
36580 AREG(7) = adr;
36581 READ_WORD_F(adr, dst)
36582 res = dst + src + ((flag_X >> 8) & 1);
36583 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36584 flag_N = flag_X = flag_C = res >> 8;
36585 flag_NotZ |= res & 0xFFFF;
36586 WRITE_WORD_F(adr, res)
36587 POST_IO
36588RET(18)
36589}
36590
36591// ADDX7M7
36592OPCODE(0xDF8F)
36593{
36594 u32 adr, res;
36595 u32 src, dst;
36596
36597 adr = AREG(7) - 4;
36598 AREG(7) = adr;
36599 PRE_IO
36600 READ_LONG_F(adr, src)
36601 adr = AREG(7) - 4;
36602 AREG(7) = adr;
36603 READ_LONG_F(adr, dst)
36604 res = dst + src + ((flag_X >> 8) & 1);
36605 flag_NotZ |= res;
36606 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36607 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36608 flag_N = res >> 24;
36609 WRITE_LONG_F(adr, res)
36610 POST_IO
36611RET(30)
36612}
36613
36614// ADDA
36615OPCODE(0xD0C0)
36616{
36617 u32 adr, res;
36618 u32 src, dst;
36619
36620 src = (s32)DREGs16((Opcode >> 0) & 7);
36621 dst = AREGu32((Opcode >> 9) & 7);
36622 res = dst + src;
36623 AREG((Opcode >> 9) & 7) = res;
36624RET(8)
36625}
36626
36627// ADDA
36628OPCODE(0xD0C8)
36629{
36630 u32 adr, res;
36631 u32 src, dst;
36632
36633 src = (s32)AREGs16((Opcode >> 0) & 7);
36634 dst = AREGu32((Opcode >> 9) & 7);
36635 res = dst + src;
36636 AREG((Opcode >> 9) & 7) = res;
36637RET(8)
36638}
36639
36640// ADDA
36641OPCODE(0xD0D0)
36642{
36643 u32 adr, res;
36644 u32 src, dst;
36645
36646 adr = AREG((Opcode >> 0) & 7);
36647 PRE_IO
36648 READSX_WORD_F(adr, src)
36649 dst = AREGu32((Opcode >> 9) & 7);
36650 res = dst + src;
36651 AREG((Opcode >> 9) & 7) = res;
36652 POST_IO
03e4f2a3 36653#ifdef USE_CYCLONE_TIMING
36654RET(12)
36655#else
70357ce5 36656RET(10)
03e4f2a3 36657#endif
70357ce5 36658}
36659
36660// ADDA
36661OPCODE(0xD0D8)
36662{
36663 u32 adr, res;
36664 u32 src, dst;
36665
36666 adr = AREG((Opcode >> 0) & 7);
36667 AREG((Opcode >> 0) & 7) += 2;
36668 PRE_IO
36669 READSX_WORD_F(adr, src)
36670 dst = AREGu32((Opcode >> 9) & 7);
36671 res = dst + src;
36672 AREG((Opcode >> 9) & 7) = res;
36673 POST_IO
03e4f2a3 36674#ifdef USE_CYCLONE_TIMING
36675RET(12)
36676#else
70357ce5 36677RET(10)
03e4f2a3 36678#endif
70357ce5 36679}
36680
36681// ADDA
36682OPCODE(0xD0E0)
36683{
36684 u32 adr, res;
36685 u32 src, dst;
36686
36687 adr = AREG((Opcode >> 0) & 7) - 2;
36688 AREG((Opcode >> 0) & 7) = adr;
36689 PRE_IO
36690 READSX_WORD_F(adr, src)
36691 dst = AREGu32((Opcode >> 9) & 7);
36692 res = dst + src;
36693 AREG((Opcode >> 9) & 7) = res;
36694 POST_IO
03e4f2a3 36695#ifdef USE_CYCLONE_TIMING
36696RET(14)
36697#else
70357ce5 36698RET(12)
03e4f2a3 36699#endif
70357ce5 36700}
36701
36702// ADDA
36703OPCODE(0xD0E8)
36704{
36705 u32 adr, res;
36706 u32 src, dst;
36707
36708 FETCH_SWORD(adr);
36709 adr += AREG((Opcode >> 0) & 7);
36710 PRE_IO
36711 READSX_WORD_F(adr, src)
36712 dst = AREGu32((Opcode >> 9) & 7);
36713 res = dst + src;
36714 AREG((Opcode >> 9) & 7) = res;
36715 POST_IO
03e4f2a3 36716#ifdef USE_CYCLONE_TIMING
36717RET(16)
36718#else
70357ce5 36719RET(14)
03e4f2a3 36720#endif
70357ce5 36721}
36722
36723// ADDA
36724OPCODE(0xD0F0)
36725{
36726 u32 adr, res;
36727 u32 src, dst;
36728
36729 adr = AREG((Opcode >> 0) & 7);
36730 DECODE_EXT_WORD
36731 PRE_IO
36732 READSX_WORD_F(adr, src)
36733 dst = AREGu32((Opcode >> 9) & 7);
36734 res = dst + src;
36735 AREG((Opcode >> 9) & 7) = res;
36736 POST_IO
03e4f2a3 36737#ifdef USE_CYCLONE_TIMING
36738RET(18)
36739#else
70357ce5 36740RET(16)
03e4f2a3 36741#endif
70357ce5 36742}
36743
36744// ADDA
36745OPCODE(0xD0F8)
36746{
36747 u32 adr, res;
36748 u32 src, dst;
36749
36750 FETCH_SWORD(adr);
36751 PRE_IO
36752 READSX_WORD_F(adr, src)
36753 dst = AREGu32((Opcode >> 9) & 7);
36754 res = dst + src;
36755 AREG((Opcode >> 9) & 7) = res;
36756 POST_IO
03e4f2a3 36757#ifdef USE_CYCLONE_TIMING
36758RET(16)
36759#else
70357ce5 36760RET(14)
03e4f2a3 36761#endif
70357ce5 36762}
36763
36764// ADDA
36765OPCODE(0xD0F9)
36766{
36767 u32 adr, res;
36768 u32 src, dst;
36769
36770 FETCH_LONG(adr);
36771 PRE_IO
36772 READSX_WORD_F(adr, src)
36773 dst = AREGu32((Opcode >> 9) & 7);
36774 res = dst + src;
36775 AREG((Opcode >> 9) & 7) = res;
36776 POST_IO
03e4f2a3 36777#ifdef USE_CYCLONE_TIMING
36778RET(20)
36779#else
70357ce5 36780RET(18)
03e4f2a3 36781#endif
70357ce5 36782}
36783
36784// ADDA
36785OPCODE(0xD0FA)
36786{
36787 u32 adr, res;
36788 u32 src, dst;
36789
be26eb23 36790 adr = GET_SWORD + GET_PC;
70357ce5 36791 PC++;
36792 PRE_IO
36793 READSX_WORD_F(adr, src)
36794 dst = AREGu32((Opcode >> 9) & 7);
36795 res = dst + src;
36796 AREG((Opcode >> 9) & 7) = res;
36797 POST_IO
03e4f2a3 36798#ifdef USE_CYCLONE_TIMING
36799RET(16)
36800#else
70357ce5 36801RET(14)
03e4f2a3 36802#endif
70357ce5 36803}
36804
36805// ADDA
36806OPCODE(0xD0FB)
36807{
36808 u32 adr, res;
36809 u32 src, dst;
36810
be26eb23 36811 adr = GET_PC;
70357ce5 36812 DECODE_EXT_WORD
36813 PRE_IO
36814 READSX_WORD_F(adr, src)
36815 dst = AREGu32((Opcode >> 9) & 7);
36816 res = dst + src;
36817 AREG((Opcode >> 9) & 7) = res;
36818 POST_IO
03e4f2a3 36819#ifdef USE_CYCLONE_TIMING
36820RET(18)
36821#else
70357ce5 36822RET(16)
03e4f2a3 36823#endif
70357ce5 36824}
36825
36826// ADDA
36827OPCODE(0xD0FC)
36828{
36829 u32 adr, res;
36830 u32 src, dst;
36831
36832 FETCH_SWORD(src);
36833 dst = AREGu32((Opcode >> 9) & 7);
36834 res = dst + src;
36835 AREG((Opcode >> 9) & 7) = res;
36836RET(12)
36837}
36838
36839// ADDA
36840OPCODE(0xD0DF)
36841{
36842 u32 adr, res;
36843 u32 src, dst;
36844
36845 adr = AREG(7);
36846 AREG(7) += 2;
36847 PRE_IO
36848 READSX_WORD_F(adr, src)
36849 dst = AREGu32((Opcode >> 9) & 7);
36850 res = dst + src;
36851 AREG((Opcode >> 9) & 7) = res;
36852 POST_IO
03e4f2a3 36853#ifdef USE_CYCLONE_TIMING
36854RET(12)
36855#else
70357ce5 36856RET(10)
03e4f2a3 36857#endif
70357ce5 36858}
36859
36860// ADDA
36861OPCODE(0xD0E7)
36862{
36863 u32 adr, res;
36864 u32 src, dst;
36865
36866 adr = AREG(7) - 2;
36867 AREG(7) = adr;
36868 PRE_IO
36869 READSX_WORD_F(adr, src)
36870 dst = AREGu32((Opcode >> 9) & 7);
36871 res = dst + src;
36872 AREG((Opcode >> 9) & 7) = res;
36873 POST_IO
03e4f2a3 36874#ifdef USE_CYCLONE_TIMING
36875RET(14)
36876#else
70357ce5 36877RET(12)
03e4f2a3 36878#endif
70357ce5 36879}
36880
36881// ADDA
36882OPCODE(0xD1C0)
36883{
36884 u32 adr, res;
36885 u32 src, dst;
36886
36887 src = (s32)DREGs32((Opcode >> 0) & 7);
36888 dst = AREGu32((Opcode >> 9) & 7);
36889 res = dst + src;
36890 AREG((Opcode >> 9) & 7) = res;
36891#ifdef USE_CYCLONE_TIMING
36892RET(8)
36893#else
36894RET(6)
36895#endif
36896}
36897
36898// ADDA
36899OPCODE(0xD1C8)
36900{
36901 u32 adr, res;
36902 u32 src, dst;
36903
36904 src = (s32)AREGs32((Opcode >> 0) & 7);
36905 dst = AREGu32((Opcode >> 9) & 7);
36906 res = dst + src;
36907 AREG((Opcode >> 9) & 7) = res;
36908#ifdef USE_CYCLONE_TIMING
36909RET(8)
36910#else
36911RET(6)
36912#endif
36913}
36914
36915// ADDA
36916OPCODE(0xD1D0)
36917{
36918 u32 adr, res;
36919 u32 src, dst;
36920
36921 adr = AREG((Opcode >> 0) & 7);
36922 PRE_IO
36923 READSX_LONG_F(adr, src)
36924 dst = AREGu32((Opcode >> 9) & 7);
36925 res = dst + src;
36926 AREG((Opcode >> 9) & 7) = res;
36927 POST_IO
36928RET(14)
36929}
36930
36931// ADDA
36932OPCODE(0xD1D8)
36933{
36934 u32 adr, res;
36935 u32 src, dst;
36936
36937 adr = AREG((Opcode >> 0) & 7);
36938 AREG((Opcode >> 0) & 7) += 4;
36939 PRE_IO
36940 READSX_LONG_F(adr, src)
36941 dst = AREGu32((Opcode >> 9) & 7);
36942 res = dst + src;
36943 AREG((Opcode >> 9) & 7) = res;
36944 POST_IO
36945RET(14)
36946}
36947
36948// ADDA
36949OPCODE(0xD1E0)
36950{
36951 u32 adr, res;
36952 u32 src, dst;
36953
36954 adr = AREG((Opcode >> 0) & 7) - 4;
36955 AREG((Opcode >> 0) & 7) = adr;
36956 PRE_IO
36957 READSX_LONG_F(adr, src)
36958 dst = AREGu32((Opcode >> 9) & 7);
36959 res = dst + src;
36960 AREG((Opcode >> 9) & 7) = res;
36961 POST_IO
36962RET(16)
36963}
36964
36965// ADDA
36966OPCODE(0xD1E8)
36967{
36968 u32 adr, res;
36969 u32 src, dst;
36970
36971 FETCH_SWORD(adr);
36972 adr += AREG((Opcode >> 0) & 7);
36973 PRE_IO
36974 READSX_LONG_F(adr, src)
36975 dst = AREGu32((Opcode >> 9) & 7);
36976 res = dst + src;
36977 AREG((Opcode >> 9) & 7) = res;
36978 POST_IO
36979RET(18)
36980}
36981
36982// ADDA
36983OPCODE(0xD1F0)
36984{
36985 u32 adr, res;
36986 u32 src, dst;
36987
36988 adr = AREG((Opcode >> 0) & 7);
36989 DECODE_EXT_WORD
36990 PRE_IO
36991 READSX_LONG_F(adr, src)
36992 dst = AREGu32((Opcode >> 9) & 7);
36993 res = dst + src;
36994 AREG((Opcode >> 9) & 7) = res;
36995 POST_IO
36996RET(20)
36997}
36998
36999// ADDA
37000OPCODE(0xD1F8)
37001{
37002 u32 adr, res;
37003 u32 src, dst;
37004
37005 FETCH_SWORD(adr);
37006 PRE_IO
37007 READSX_LONG_F(adr, src)
37008 dst = AREGu32((Opcode >> 9) & 7);
37009 res = dst + src;
37010 AREG((Opcode >> 9) & 7) = res;
37011 POST_IO
37012RET(18)
37013}
37014
37015// ADDA
37016OPCODE(0xD1F9)
37017{
37018 u32 adr, res;
37019 u32 src, dst;
37020
37021 FETCH_LONG(adr);
37022 PRE_IO
37023 READSX_LONG_F(adr, src)
37024 dst = AREGu32((Opcode >> 9) & 7);
37025 res = dst + src;
37026 AREG((Opcode >> 9) & 7) = res;
37027 POST_IO
37028RET(22)
37029}
37030
37031// ADDA
37032OPCODE(0xD1FA)
37033{
37034 u32 adr, res;
37035 u32 src, dst;
37036
be26eb23 37037 adr = GET_SWORD + GET_PC;
70357ce5 37038 PC++;
37039 PRE_IO
37040 READSX_LONG_F(adr, src)
37041 dst = AREGu32((Opcode >> 9) & 7);
37042 res = dst + src;
37043 AREG((Opcode >> 9) & 7) = res;
37044 POST_IO
37045RET(18)
37046}
37047
37048// ADDA
37049OPCODE(0xD1FB)
37050{
37051 u32 adr, res;
37052 u32 src, dst;
37053
be26eb23 37054 adr = GET_PC;
70357ce5 37055 DECODE_EXT_WORD
37056 PRE_IO
37057 READSX_LONG_F(adr, src)
37058 dst = AREGu32((Opcode >> 9) & 7);
37059 res = dst + src;
37060 AREG((Opcode >> 9) & 7) = res;
37061 POST_IO
37062RET(20)
37063}
37064
37065// ADDA
37066OPCODE(0xD1FC)
37067{
37068 u32 adr, res;
37069 u32 src, dst;
37070
37071 FETCH_LONG(src);
37072 dst = AREGu32((Opcode >> 9) & 7);
37073 res = dst + src;
37074 AREG((Opcode >> 9) & 7) = res;
37075#ifdef USE_CYCLONE_TIMING
37076RET(16)
37077#else
37078RET(14)
37079#endif
37080}
37081
37082// ADDA
37083OPCODE(0xD1DF)
37084{
37085 u32 adr, res;
37086 u32 src, dst;
37087
37088 adr = AREG(7);
37089 AREG(7) += 4;
37090 PRE_IO
37091 READSX_LONG_F(adr, src)
37092 dst = AREGu32((Opcode >> 9) & 7);
37093 res = dst + src;
37094 AREG((Opcode >> 9) & 7) = res;
37095 POST_IO
37096RET(14)
37097}
37098
37099// ADDA
37100OPCODE(0xD1E7)
37101{
37102 u32 adr, res;
37103 u32 src, dst;
37104
37105 adr = AREG(7) - 4;
37106 AREG(7) = adr;
37107 PRE_IO
37108 READSX_LONG_F(adr, src)
37109 dst = AREGu32((Opcode >> 9) & 7);
37110 res = dst + src;
37111 AREG((Opcode >> 9) & 7) = res;
37112 POST_IO
37113RET(16)
37114}
37115
37116// ASRk
37117OPCODE(0xE000)
37118{
37119 u32 adr, res;
37120 u32 src, dst;
37121
37122 u32 sft;
37123
37124 sft = (((Opcode >> 9) - 1) & 7) + 1;
37125 m68kcontext.io_cycle_counter -= sft * 2;
37126 src = (s32)DREGs8((Opcode >> 0) & 7);
37127 flag_V = 0;
37128 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37129 res = ((s32)src) >> sft;
37130 flag_N = res >> 0;
37131 flag_NotZ = res;
37132 DREGu8((Opcode >> 0) & 7) = res;
37133RET(6)
37134}
37135
37136// ASRk
37137OPCODE(0xE040)
37138{
37139 u32 adr, res;
37140 u32 src, dst;
37141
37142 u32 sft;
37143
37144 sft = (((Opcode >> 9) - 1) & 7) + 1;
37145 m68kcontext.io_cycle_counter -= sft * 2;
37146 src = (s32)DREGs16((Opcode >> 0) & 7);
37147 flag_V = 0;
37148 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37149 res = ((s32)src) >> sft;
37150 flag_N = res >> 8;
37151 flag_NotZ = res;
37152 DREGu16((Opcode >> 0) & 7) = res;
37153RET(6)
37154}
37155
37156// ASRk
37157OPCODE(0xE080)
37158{
37159 u32 adr, res;
37160 u32 src, dst;
37161
37162 u32 sft;
37163
37164 sft = (((Opcode >> 9) - 1) & 7) + 1;
37165 m68kcontext.io_cycle_counter -= sft * 2;
37166 src = (s32)DREGs32((Opcode >> 0) & 7);
37167 flag_V = 0;
37168 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37169 res = ((s32)src) >> sft;
37170 flag_N = res >> 24;
37171 flag_NotZ = res;
37172 DREGu32((Opcode >> 0) & 7) = res;
37173RET(8)
37174}
37175
37176// LSRk
37177OPCODE(0xE008)
37178{
37179 u32 adr, res;
37180 u32 src, dst;
37181
37182 u32 sft;
37183
37184 sft = (((Opcode >> 9) - 1) & 7) + 1;
37185 m68kcontext.io_cycle_counter -= sft * 2;
37186 src = DREGu8((Opcode >> 0) & 7);
37187 flag_N = flag_V = 0;
37188 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37189 res = src >> sft;
37190 flag_NotZ = res;
37191 DREGu8((Opcode >> 0) & 7) = res;
37192RET(6)
37193}
37194
37195// LSRk
37196OPCODE(0xE048)
37197{
37198 u32 adr, res;
37199 u32 src, dst;
37200
37201 u32 sft;
37202
37203 sft = (((Opcode >> 9) - 1) & 7) + 1;
37204 m68kcontext.io_cycle_counter -= sft * 2;
37205 src = DREGu16((Opcode >> 0) & 7);
37206 flag_N = flag_V = 0;
37207 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37208 res = src >> sft;
37209 flag_NotZ = res;
37210 DREGu16((Opcode >> 0) & 7) = res;
37211RET(6)
37212}
37213
37214// LSRk
37215OPCODE(0xE088)
37216{
37217 u32 adr, res;
37218 u32 src, dst;
37219
37220 u32 sft;
37221
37222 sft = (((Opcode >> 9) - 1) & 7) + 1;
37223 m68kcontext.io_cycle_counter -= sft * 2;
37224 src = DREGu32((Opcode >> 0) & 7);
37225 flag_N = flag_V = 0;
37226 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37227 res = src >> sft;
37228 flag_NotZ = res;
37229 DREGu32((Opcode >> 0) & 7) = res;
37230RET(8)
37231}
37232
37233// ROXRk
37234OPCODE(0xE010)
37235{
37236 u32 adr, res;
37237 u32 src, dst;
37238
37239 u32 sft;
37240
37241 sft = (((Opcode >> 9) - 1) & 7) + 1;
37242 m68kcontext.io_cycle_counter -= sft * 2;
37243 src = DREGu8((Opcode >> 0) & 7);
37244 src |= (flag_X & M68K_SR_X) << 0;
37245 res = (src >> sft) | (src << (9 - sft));
37246 flag_X = flag_C = res >> 0;
37247 flag_V = 0;
37248 flag_N = res >> 0;
37249 flag_NotZ = res & 0x000000FF;
37250 DREGu8((Opcode >> 0) & 7) = res;
37251RET(6)
37252}
37253
37254// ROXRk
37255OPCODE(0xE050)
37256{
37257 u32 adr, res;
37258 u32 src, dst;
37259
37260 u32 sft;
37261
37262 sft = (((Opcode >> 9) - 1) & 7) + 1;
37263 m68kcontext.io_cycle_counter -= sft * 2;
37264 src = DREGu16((Opcode >> 0) & 7);
37265 src |= (flag_X & M68K_SR_X) << 8;
37266 res = (src >> sft) | (src << (17 - sft));
37267 flag_X = flag_C = res >> 8;
37268 flag_V = 0;
37269 flag_N = res >> 8;
37270 flag_NotZ = res & 0x0000FFFF;
37271 DREGu16((Opcode >> 0) & 7) = res;
37272RET(6)
37273}
37274
37275// ROXRk
37276OPCODE(0xE090)
37277{
37278 u32 adr, res;
37279 u32 src, dst;
37280
37281 u32 sft;
37282
37283 sft = (((Opcode >> 9) - 1) & 7) + 1;
37284 m68kcontext.io_cycle_counter -= sft * 2;
37285 src = DREGu32((Opcode >> 0) & 7);
37286 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37287 if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
37288 else res = (src >> sft) | (src << (33 - sft)) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + sft)));
37289 flag_X = flag_C;
37290 flag_V = 0;
37291 flag_N = res >> 24;
37292 flag_NotZ = res;
37293 DREGu32((Opcode >> 0) & 7) = res;
37294RET(8)
37295}
37296
37297// RORk
37298OPCODE(0xE018)
37299{
37300 u32 adr, res;
37301 u32 src, dst;
37302
37303 u32 sft;
37304
37305 sft = (((Opcode >> 9) - 1) & 7) + 1;
37306 m68kcontext.io_cycle_counter -= sft * 2;
37307 src = DREGu8((Opcode >> 0) & 7);
37308 flag_V = 0;
37309 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37310 res = (src >> sft) | (src << (8 - sft));
37311 flag_N = res >> 0;
37312 flag_NotZ = res & 0x000000FF;
37313 DREGu8((Opcode >> 0) & 7) = res;
37314RET(6)
37315}
37316
37317// RORk
37318OPCODE(0xE058)
37319{
37320 u32 adr, res;
37321 u32 src, dst;
37322
37323 u32 sft;
37324
37325 sft = (((Opcode >> 9) - 1) & 7) + 1;
37326 m68kcontext.io_cycle_counter -= sft * 2;
37327 src = DREGu16((Opcode >> 0) & 7);
37328 flag_V = 0;
37329 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37330 res = (src >> sft) | (src << (16 - sft));
37331 flag_N = res >> 8;
37332 flag_NotZ = res & 0x0000FFFF;
37333 DREGu16((Opcode >> 0) & 7) = res;
37334RET(6)
37335}
37336
37337// RORk
37338OPCODE(0xE098)
37339{
37340 u32 adr, res;
37341 u32 src, dst;
37342
37343 u32 sft;
37344
37345 sft = (((Opcode >> 9) - 1) & 7) + 1;
37346 m68kcontext.io_cycle_counter -= sft * 2;
37347 src = DREGu32((Opcode >> 0) & 7);
37348 flag_V = 0;
37349 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37350 res = (src >> sft) | (src << (32 - sft));
37351 flag_N = res >> 24;
37352 flag_NotZ = res;
37353 DREGu32((Opcode >> 0) & 7) = res;
37354RET(8)
37355}
37356
37357// ASLk
37358OPCODE(0xE100)
37359{
37360 u32 adr, res;
37361 u32 src, dst;
37362
37363 u32 sft;
37364
37365 sft = (((Opcode >> 9) - 1) & 7) + 1;
37366 m68kcontext.io_cycle_counter -= sft * 2;
37367 src = DREGu8((Opcode >> 0) & 7);
37368 if (sft < 8)
37369 {
37370 flag_X = flag_C = src << (0 + sft);
37371 res = src << sft;
37372 flag_N = res >> 0;
37373 flag_NotZ = res & 0x000000FF;
37374 DREGu8((Opcode >> 0) & 7) = res;
37375 flag_V = 0;
37376 if ((sft > 7) && (src)) flag_V = M68K_SR_V;
37377 else
37378 {
37379 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
37380 src &= msk;
37381 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37382 }
37383 RET(6)
37384 }
37385
37386 if (src) flag_V = M68K_SR_V;
37387 else flag_V = 0;
37388 flag_X = flag_C = src << M68K_SR_C_SFT;
37389 res = 0;
37390 DREGu8((Opcode >> 0) & 7) = res;
37391 flag_N = 0;
37392 flag_NotZ = 0;
37393RET(6)
37394}
37395
37396// ASLk
37397OPCODE(0xE140)
37398{
37399 u32 adr, res;
37400 u32 src, dst;
37401
37402 u32 sft;
37403
37404 sft = (((Opcode >> 9) - 1) & 7) + 1;
37405 m68kcontext.io_cycle_counter -= sft * 2;
37406 src = DREGu16((Opcode >> 0) & 7);
37407 flag_X = flag_C = src >> (8 - sft);
37408 res = src << sft;
37409 flag_N = res >> 8;
37410 flag_NotZ = res & 0x0000FFFF;
37411 DREGu16((Opcode >> 0) & 7) = res;
37412 flag_V = 0;
37413 {
37414 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
37415 src &= msk;
37416 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37417 }
37418RET(6)
37419}
37420
37421// ASLk
37422OPCODE(0xE180)
37423{
37424 u32 adr, res;
37425 u32 src, dst;
37426
37427 u32 sft;
37428
37429 sft = (((Opcode >> 9) - 1) & 7) + 1;
37430 m68kcontext.io_cycle_counter -= sft * 2;
37431 src = DREGu32((Opcode >> 0) & 7);
37432 flag_X = flag_C = src >> (24 - sft);
37433 res = src << sft;
37434 flag_N = res >> 24;
37435 flag_NotZ = res & 0xFFFFFFFF;
37436 DREGu32((Opcode >> 0) & 7) = res;
37437 flag_V = 0;
37438 {
37439 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
37440 src &= msk;
37441 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37442 }
37443RET(8)
37444}
37445
37446// LSLk
37447OPCODE(0xE108)
37448{
37449 u32 adr, res;
37450 u32 src, dst;
37451
37452 u32 sft;
37453
37454 sft = (((Opcode >> 9) - 1) & 7) + 1;
37455 m68kcontext.io_cycle_counter -= sft * 2;
37456 src = DREGu8((Opcode >> 0) & 7);
37457 flag_V = 0;
37458 flag_X = flag_C = src << (0 + sft);
37459 res = src << sft;
37460 flag_N = res >> 0;
37461 flag_NotZ = res & 0x000000FF;
37462 DREGu8((Opcode >> 0) & 7) = res;
37463RET(6)
37464}
37465
37466// LSLk
37467OPCODE(0xE148)
37468{
37469 u32 adr, res;
37470 u32 src, dst;
37471
37472 u32 sft;
37473
37474 sft = (((Opcode >> 9) - 1) & 7) + 1;
37475 m68kcontext.io_cycle_counter -= sft * 2;
37476 src = DREGu16((Opcode >> 0) & 7);
37477 flag_V = 0;
37478 flag_X = flag_C = src >> (8 - sft);
37479 res = src << sft;
37480 flag_N = res >> 8;
37481 flag_NotZ = res & 0x0000FFFF;
37482 DREGu16((Opcode >> 0) & 7) = res;
37483RET(6)
37484}
37485
37486// LSLk
37487OPCODE(0xE188)
37488{
37489 u32 adr, res;
37490 u32 src, dst;
37491
37492 u32 sft;
37493
37494 sft = (((Opcode >> 9) - 1) & 7) + 1;
37495 m68kcontext.io_cycle_counter -= sft * 2;
37496 src = DREGu32((Opcode >> 0) & 7);
37497 flag_V = 0;
37498 flag_X = flag_C = src >> (24 - sft);
37499 res = src << sft;
37500 flag_N = res >> 24;
37501 flag_NotZ = res & 0xFFFFFFFF;
37502 DREGu32((Opcode >> 0) & 7) = res;
37503RET(8)
37504}
37505
37506// ROXLk
37507OPCODE(0xE110)
37508{
37509 u32 adr, res;
37510 u32 src, dst;
37511
37512 u32 sft;
37513
37514 sft = (((Opcode >> 9) - 1) & 7) + 1;
37515 m68kcontext.io_cycle_counter -= sft * 2;
37516 src = DREGu8((Opcode >> 0) & 7);
37517 src |= (flag_X & M68K_SR_X) << 0;
37518 res = (src << sft) | (src >> (9 - sft));
37519 flag_X = flag_C = res >> 0;
37520 flag_V = 0;
37521 flag_N = res >> 0;
37522 flag_NotZ = res & 0x000000FF;
37523 DREGu8((Opcode >> 0) & 7) = res;
37524RET(6)
37525}
37526
37527// ROXLk
37528OPCODE(0xE150)
37529{
37530 u32 adr, res;
37531 u32 src, dst;
37532
37533 u32 sft;
37534
37535 sft = (((Opcode >> 9) - 1) & 7) + 1;
37536 m68kcontext.io_cycle_counter -= sft * 2;
37537 src = DREGu16((Opcode >> 0) & 7);
37538 src |= (flag_X & M68K_SR_X) << 8;
37539 res = (src << sft) | (src >> (17 - sft));
37540 flag_X = flag_C = res >> 8;
37541 flag_V = 0;
37542 flag_N = res >> 8;
37543 flag_NotZ = res & 0x0000FFFF;
37544 DREGu16((Opcode >> 0) & 7) = res;
37545RET(6)
37546}
37547
37548// ROXLk
37549OPCODE(0xE190)
37550{
37551 u32 adr, res;
37552 u32 src, dst;
37553
37554 u32 sft;
37555
37556 sft = (((Opcode >> 9) - 1) & 7) + 1;
37557 m68kcontext.io_cycle_counter -= sft * 2;
37558 src = DREGu32((Opcode >> 0) & 7);
37559 flag_C = src >> ((32 - M68K_SR_C_SFT) - sft);
37560 if (sft == 1) res = (src << 1) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - 1));
37561 else res = (src << sft) | (src >> (33 - sft)) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - sft));
37562 flag_X = flag_C;
37563 flag_V = 0;
37564 flag_N = res >> 24;
37565 flag_NotZ = res;
37566 DREGu32((Opcode >> 0) & 7) = res;
37567RET(8)
37568}
37569
37570// ROLk
37571OPCODE(0xE118)
37572{
37573 u32 adr, res;
37574 u32 src, dst;
37575
37576 u32 sft;
37577
37578 sft = (((Opcode >> 9) - 1) & 7) + 1;
37579 m68kcontext.io_cycle_counter -= sft * 2;
37580 src = DREGu8((Opcode >> 0) & 7);
37581 flag_V = 0;
37582 flag_C = src << (0 + sft);
37583 res = (src << sft) | (src >> (8 - sft));
37584 flag_N = res >> 0;
37585 flag_NotZ = res & 0x000000FF;
37586 DREGu8((Opcode >> 0) & 7) = res;
37587RET(6)
37588}
37589
37590// ROLk
37591OPCODE(0xE158)
37592{
37593 u32 adr, res;
37594 u32 src, dst;
37595
37596 u32 sft;
37597
37598 sft = (((Opcode >> 9) - 1) & 7) + 1;
37599 m68kcontext.io_cycle_counter -= sft * 2;
37600 src = DREGu16((Opcode >> 0) & 7);
37601 flag_V = 0;
37602 flag_C = src >> (8 - sft);
37603 res = (src << sft) | (src >> (16 - sft));
37604 flag_N = res >> 8;
37605 flag_NotZ = res & 0x0000FFFF;
37606 DREGu16((Opcode >> 0) & 7) = res;
37607RET(6)
37608}
37609
37610// ROLk
37611OPCODE(0xE198)
37612{
37613 u32 adr, res;
37614 u32 src, dst;
37615
37616 u32 sft;
37617
37618 sft = (((Opcode >> 9) - 1) & 7) + 1;
37619 m68kcontext.io_cycle_counter -= sft * 2;
37620 src = DREGu32((Opcode >> 0) & 7);
37621 flag_V = 0;
37622 flag_C = src >> (24 - sft);
37623 res = (src << sft) | (src >> (32 - sft));
37624 flag_N = res >> 24;
37625 flag_NotZ = res;
37626 DREGu32((Opcode >> 0) & 7) = res;
37627RET(8)
37628}
37629
37630// ASRD
37631OPCODE(0xE020)
37632{
37633 u32 adr, res;
37634 u32 src, dst;
37635
37636 u32 sft;
37637
37638 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37639 src = (s32)DREGs8((Opcode >> 0) & 7);
37640 if (sft)
37641 {
37642 m68kcontext.io_cycle_counter -= sft * 2;
37643 if (sft < 8)
37644 {
37645 flag_V = 0;
37646 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37647 res = ((s32)src) >> sft;
37648 flag_N = res >> 0;
37649 flag_NotZ = res;
37650 DREGu8((Opcode >> 0) & 7) = res;
37651 RET(6)
37652 }
37653
37654 if (src & (1 << 7))
37655 {
37656 flag_N = M68K_SR_N;
37657 flag_NotZ = 1;
37658 flag_V = 0;
37659 flag_C = M68K_SR_C;
37660 flag_X = M68K_SR_X;
37661 res = 0x000000FF;
37662 DREGu8((Opcode >> 0) & 7) = res;
37663 RET(6)
37664 }
37665
37666 flag_N = 0;
37667 flag_NotZ = 0;
37668 flag_V = 0;
37669 flag_C = 0;
37670 flag_X = 0;
37671 res = 0;
37672 DREGu8((Opcode >> 0) & 7) = res;
37673 RET(6)
37674 }
37675
37676 flag_V = 0;
37677 flag_C = 0;
37678 flag_N = src >> 0;
37679 flag_NotZ = src;
37680RET(6)
37681}
37682
37683// ASRD
37684OPCODE(0xE060)
37685{
37686 u32 adr, res;
37687 u32 src, dst;
37688
37689 u32 sft;
37690
37691 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37692 src = (s32)DREGs16((Opcode >> 0) & 7);
37693 if (sft)
37694 {
37695 m68kcontext.io_cycle_counter -= sft * 2;
37696 if (sft < 16)
37697 {
37698 flag_V = 0;
37699 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37700 res = ((s32)src) >> sft;
37701 flag_N = res >> 8;
37702 flag_NotZ = res;
37703 DREGu16((Opcode >> 0) & 7) = res;
37704 RET(6)
37705 }
37706
37707 if (src & (1 << 15))
37708 {
37709 flag_N = M68K_SR_N;
37710 flag_NotZ = 1;
37711 flag_V = 0;
37712 flag_C = M68K_SR_C;
37713 flag_X = M68K_SR_X;
37714 res = 0x0000FFFF;
37715 DREGu16((Opcode >> 0) & 7) = res;
37716 RET(6)
37717 }
37718
37719 flag_N = 0;
37720 flag_NotZ = 0;
37721 flag_V = 0;
37722 flag_C = 0;
37723 flag_X = 0;
37724 res = 0;
37725 DREGu16((Opcode >> 0) & 7) = res;
37726 RET(6)
37727 }
37728
37729 flag_V = 0;
37730 flag_C = 0;
37731 flag_N = src >> 8;
37732 flag_NotZ = src;
37733RET(6)
37734}
37735
37736// ASRD
37737OPCODE(0xE0A0)
37738{
37739#ifdef USE_CYCLONE_TIMING
37740#define CYC 8
37741#else
37742#define CYC 6
37743#endif
37744 u32 adr, res;
37745 u32 src, dst;
37746
37747 u32 sft;
37748
37749 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37750 src = (s32)DREGs32((Opcode >> 0) & 7);
37751 if (sft)
37752 {
37753 m68kcontext.io_cycle_counter -= sft * 2;
37754 if (sft < 32)
37755 {
37756 flag_V = 0;
37757 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37758 res = ((s32)src) >> sft;
37759 flag_N = res >> 24;
37760 flag_NotZ = res;
37761 DREGu32((Opcode >> 0) & 7) = res;
37762 RET(CYC)
37763 }
37764
37765 if (src & (1 << 31))
37766 {
37767 flag_N = M68K_SR_N;
37768 flag_NotZ = 1;
37769 flag_V = 0;
37770 flag_C = M68K_SR_C;
37771 flag_X = M68K_SR_X;
37772 res = 0xFFFFFFFF;
37773 DREGu32((Opcode >> 0) & 7) = res;
37774 RET(CYC)
37775 }
37776
37777 flag_N = 0;
37778 flag_NotZ = 0;
37779 flag_V = 0;
37780 flag_C = 0;
37781 flag_X = 0;
37782 res = 0;
37783 DREGu32((Opcode >> 0) & 7) = res;
37784 RET(CYC)
37785 }
37786
37787 flag_V = 0;
37788 flag_C = 0;
37789 flag_N = src >> 24;
37790 flag_NotZ = src;
37791RET(CYC)
37792#undef CYC
37793}
37794
37795// LSRD
37796OPCODE(0xE028)
37797{
37798 u32 adr, res;
37799 u32 src, dst;
37800
37801 u32 sft;
37802
37803 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37804 src = DREGu8((Opcode >> 0) & 7);
37805 if (sft)
37806 {
37807 m68kcontext.io_cycle_counter -= sft * 2;
37808 if (sft <= 8)
37809 {
37810 flag_N = flag_V = 0;
37811 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37812 res = src >> sft;
37813 flag_NotZ = res;
37814 DREGu8((Opcode >> 0) & 7) = res;
37815 RET(6)
37816 }
37817
37818 flag_X = flag_C = 0;
37819 flag_N = 0;
37820 flag_NotZ = 0;
37821 flag_V = 0;
37822 res = 0;
37823 DREGu8((Opcode >> 0) & 7) = res;
37824 RET(6)
37825 }
37826
37827 flag_V = 0;
37828 flag_C = 0;
37829 flag_N = src >> 0;
37830 flag_NotZ = src;
37831RET(6)
37832}
37833
37834// LSRD
37835OPCODE(0xE068)
37836{
37837 u32 adr, res;
37838 u32 src, dst;
37839
37840 u32 sft;
37841
37842 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37843 src = DREGu16((Opcode >> 0) & 7);
37844 if (sft)
37845 {
37846 m68kcontext.io_cycle_counter -= sft * 2;
37847 if (sft <= 16)
37848 {
37849 flag_N = flag_V = 0;
37850 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37851 res = src >> sft;
37852 flag_NotZ = res;
37853 DREGu16((Opcode >> 0) & 7) = res;
37854 RET(6)
37855 }
37856
37857 flag_X = flag_C = 0;
37858 flag_N = 0;
37859 flag_NotZ = 0;
37860 flag_V = 0;
37861 res = 0;
37862 DREGu16((Opcode >> 0) & 7) = res;
37863 RET(6)
37864 }
37865
37866 flag_V = 0;
37867 flag_C = 0;
37868 flag_N = src >> 8;
37869 flag_NotZ = src;
37870RET(6)
37871}
37872
37873// LSRD
37874OPCODE(0xE0A8)
37875{
37876#ifdef USE_CYCLONE_TIMING
37877#define CYC 8
37878#else
37879#define CYC 6
37880#endif
37881 u32 adr, res;
37882 u32 src, dst;
37883
37884 u32 sft;
37885
37886 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37887 src = DREGu32((Opcode >> 0) & 7);
37888 if (sft)
37889 {
37890 m68kcontext.io_cycle_counter -= sft * 2;
37891 if (sft < 32)
37892 {
37893 flag_N = flag_V = 0;
37894 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37895 res = src >> sft;
37896 flag_NotZ = res;
37897 DREGu32((Opcode >> 0) & 7) = res;
37898 RET(CYC)
37899 }
37900
37901 if (sft == 32) flag_C = src >> (31 - M68K_SR_C_SFT);
37902 else flag_C = 0;
37903 flag_X = flag_C;
37904 flag_N = 0;
37905 flag_NotZ = 0;
37906 flag_V = 0;
37907 res = 0;
37908 DREGu32((Opcode >> 0) & 7) = res;
37909 RET(CYC)
37910 }
37911
37912 flag_V = 0;
37913 flag_C = 0;
37914 flag_N = src >> 24;
37915 flag_NotZ = src;
37916RET(CYC)
37917#undef CYC
37918}
37919
37920// ROXRD
37921OPCODE(0xE030)
37922{
37923 u32 adr, res;
37924 u32 src, dst;
37925
37926 u32 sft;
37927
37928 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37929 src = DREGu8((Opcode >> 0) & 7);
37930 if (sft)
37931 {
37932 m68kcontext.io_cycle_counter -= sft * 2;
37933 sft %= 9;
37934
37935 src |= (flag_X & M68K_SR_X) << 0;
37936 res = (src >> sft) | (src << (9 - sft));
37937 flag_X = flag_C = res >> 0;
37938 flag_V = 0;
37939 flag_N = res >> 0;
37940 flag_NotZ = res & 0x000000FF;
37941 DREGu8((Opcode >> 0) & 7) = res;
37942 RET(6)
37943 }
37944
37945 flag_V = 0;
37946 flag_C = flag_X;
37947 flag_N = src >> 0;
37948 flag_NotZ = src;
37949RET(6)
37950}
37951
37952// ROXRD
37953OPCODE(0xE070)
37954{
37955 u32 adr, res;
37956 u32 src, dst;
37957
37958 u32 sft;
37959
37960 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37961 src = DREGu16((Opcode >> 0) & 7);
37962 if (sft)
37963 {
37964 m68kcontext.io_cycle_counter -= sft * 2;
37965 sft %= 17;
37966
37967 src |= (flag_X & M68K_SR_X) << 8;
37968 res = (src >> sft) | (src << (17 - sft));
37969 flag_X = flag_C = res >> 8;
37970 flag_V = 0;
37971 flag_N = res >> 8;
37972 flag_NotZ = res & 0x0000FFFF;
37973 DREGu16((Opcode >> 0) & 7) = res;
37974 RET(6)
37975 }
37976
37977 flag_V = 0;
37978 flag_C = flag_X;
37979 flag_N = src >> 8;
37980 flag_NotZ = src;
37981RET(6)
37982}
37983
37984// ROXRD
37985OPCODE(0xE0B0)
37986{
37987#ifdef USE_CYCLONE_TIMING
37988#define CYC 8
37989#else
37990#define CYC 6
37991#endif
37992 u32 adr, res;
37993 u32 src, dst;
37994
37995 u32 sft;
37996
37997 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37998 src = DREGu32((Opcode >> 0) & 7);
37999 if (sft)
38000 {
38001 m68kcontext.io_cycle_counter -= sft * 2;
38002 sft %= 33;
38003
38004 if (sft != 0)
38005 {
38006 if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
38007 else res = (src >> sft) | (src << (33 - sft)) | (((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1))) >> (sft - 1));
38008 flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
38009 }
38010 else res = src;
38011 flag_C = flag_X;
38012 flag_V = 0;
38013 flag_N = res >> 24;
38014 flag_NotZ = res;
38015 DREGu32((Opcode >> 0) & 7) = res;
38016 RET(CYC)
38017 }
38018
38019 flag_V = 0;
38020 flag_C = flag_X;
38021 flag_N = src >> 24;
38022 flag_NotZ = src;
38023RET(CYC)
38024#undef CYC
38025}
38026
38027// RORD
38028OPCODE(0xE038)
38029{
38030 u32 adr, res;
38031 u32 src, dst;
38032
38033 u32 sft;
38034
38035 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38036 src = DREGu8((Opcode >> 0) & 7);
38037 if (sft)
38038 {
38039 m68kcontext.io_cycle_counter -= sft * 2;
38040 sft &= 0x07;
38041
38042 flag_C = src << (M68K_SR_C_SFT - ((sft - 1) & 7));
38043 res = (src >> sft) | (src << (8 - sft));
38044 flag_V = 0;
38045 flag_N = res >> 0;
38046 flag_NotZ = res & 0x000000FF;
38047 DREGu8((Opcode >> 0) & 7) = res;
38048 RET(6)
38049 }
38050
38051 flag_V = 0;
38052 flag_C = 0;
38053 flag_N = src >> 0;
38054 flag_NotZ = src;
38055RET(6)
38056}
38057
38058// RORD
38059OPCODE(0xE078)
38060{
38061 u32 adr, res;
38062 u32 src, dst;
38063
38064 u32 sft;
38065
38066 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38067 src = DREGu16((Opcode >> 0) & 7);
38068 if (sft)
38069 {
38070 m68kcontext.io_cycle_counter -= sft * 2;
38071 sft &= 0x0F;
38072
38073 flag_C = (src >> ((sft - 1) & 15)) << M68K_SR_C_SFT;
38074 res = (src >> sft) | (src << (16 - sft));
38075 flag_V = 0;
38076 flag_N = res >> 8;
38077 flag_NotZ = res & 0x0000FFFF;
38078 DREGu16((Opcode >> 0) & 7) = res;
38079 RET(6)
38080 }
38081
38082 flag_V = 0;
38083 flag_C = 0;
38084 flag_N = src >> 8;
38085 flag_NotZ = src;
38086RET(6)
38087}
38088
38089// RORD
38090OPCODE(0xE0B8)
38091{
38092#ifdef USE_CYCLONE_TIMING
38093#define CYC 8
38094#else
38095#define CYC 6
38096#endif
38097 u32 adr, res;
38098 u32 src, dst;
38099
38100 u32 sft;
38101
38102 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38103 src = DREGu32((Opcode >> 0) & 7);
38104 if (sft)
38105 {
38106 m68kcontext.io_cycle_counter -= sft * 2;
38107 sft &= 0x1F;
38108
38109 flag_C = (src >> ((sft - 1) & 31)) << M68K_SR_C_SFT;
38110 res = (src >> sft) | (src << (32 - sft));
38111 flag_V = 0;
38112 flag_N = res >> 24;
38113 flag_NotZ = res;
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// ASLD
38127OPCODE(0xE120)
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 m68kcontext.io_cycle_counter -= sft * 2;
38139 if (sft < 8)
38140 {
38141 flag_X = flag_C = (src << sft) >> 0;
38142 res = (src << sft) & 0x000000FF;
38143 flag_N = res >> 0;
38144 flag_NotZ = res;
38145 DREGu8((Opcode >> 0) & 7) = res;
38146 flag_V = 0;
38147 {
38148 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
38149 src &= msk;
38150 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38151 }
38152 RET(6)
38153 }
38154
38155 if (sft == 256) flag_C = src << M68K_SR_C_SFT;
38156 else flag_C = 0;
38157 flag_X = flag_C;
38158 if (src) flag_V = M68K_SR_V;
38159 else flag_V = 0;
38160 res = 0;
38161 DREGu8((Opcode >> 0) & 7) = res;
38162 flag_N = 0;
38163 flag_NotZ = 0;
38164 RET(6)
38165 }
38166
38167 flag_V = 0;
38168 flag_C = 0;
38169 flag_N = src >> 0;
38170 flag_NotZ = src;
38171RET(6)
38172}
38173
38174// ASLD
38175OPCODE(0xE160)
38176{
38177 u32 adr, res;
38178 u32 src, dst;
38179
38180 u32 sft;
38181
38182 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38183 src = DREGu16((Opcode >> 0) & 7);
38184 if (sft)
38185 {
38186 m68kcontext.io_cycle_counter -= sft * 2;
38187 if (sft < 16)
38188 {
38189 flag_X = flag_C = (src << sft) >> 8;
38190 res = (src << sft) & 0x0000FFFF;
38191 flag_N = res >> 8;
38192 flag_NotZ = res;
38193 DREGu16((Opcode >> 0) & 7) = res;
38194 flag_V = 0;
38195 {
38196 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
38197 src &= msk;
38198 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38199 }
38200 RET(6)
38201 }
38202
38203 if (sft == 65536) flag_C = src << M68K_SR_C_SFT;
38204 else flag_C = 0;
38205 flag_X = flag_C;
38206 if (src) flag_V = M68K_SR_V;
38207 else flag_V = 0;
38208 res = 0;
38209 DREGu16((Opcode >> 0) & 7) = res;
38210 flag_N = 0;
38211 flag_NotZ = 0;
38212 RET(6)
38213 }
38214
38215 flag_V = 0;
38216 flag_C = 0;
38217 flag_N = src >> 8;
38218 flag_NotZ = src;
38219RET(6)
38220}
38221
38222// ASLD
38223OPCODE(0xE1A0)
38224{
38225#ifdef USE_CYCLONE_TIMING
38226#define CYC 8
38227#else
38228#define CYC 6
38229#endif
38230 u32 adr, res;
38231 u32 src, dst;
38232
38233 u32 sft;
38234
38235 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38236 src = DREGu32((Opcode >> 0) & 7);
38237 if (sft)
38238 {
38239 m68kcontext.io_cycle_counter -= sft * 2;
38240 if (sft < 32)
38241 {
38242 flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38243 res = src << sft;
38244 flag_N = res >> 24;
38245 flag_NotZ = res;
38246 DREGu32((Opcode >> 0) & 7) = res;
38247 flag_V = 0;
38248 {
38249 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
38250 src &= msk;
38251 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38252 }
38253 RET(CYC)
38254 }
38255
38256 if (sft == 0) flag_C = src << M68K_SR_C_SFT;
38257 else flag_C = 0;
38258 flag_X = flag_C;
38259 if (src) flag_V = M68K_SR_V;
38260 else flag_V = 0;
38261 res = 0;
38262 DREGu32((Opcode >> 0) & 7) = res;
38263 flag_N = 0;
38264 flag_NotZ = 0;
38265 RET(CYC)
38266 }
38267
38268 flag_V = 0;
38269 flag_C = 0;
38270 flag_N = src >> 24;
38271 flag_NotZ = src;
38272RET(CYC)
38273#undef CYC
38274}
38275
38276// LSLD
38277OPCODE(0xE128)
38278{
38279 u32 adr, res;
38280 u32 src, dst;
38281
38282 u32 sft;
38283
38284 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38285 src = DREGu8((Opcode >> 0) & 7);
38286 if (sft)
38287 {
38288 m68kcontext.io_cycle_counter -= sft * 2;
38289 if (sft <= 8)
38290 {
38291 flag_X = flag_C = (src << sft) >> 0;
38292 res = (src << sft) & 0x000000FF;
38293 flag_V = 0;
38294 flag_N = res >> 0;
38295 flag_NotZ = res;
38296 DREGu8((Opcode >> 0) & 7) = res;
38297 RET(6)
38298 }
38299
38300 flag_X = flag_C = 0;
38301 flag_N = 0;
38302 flag_NotZ = 0;
38303 flag_V = 0;
38304 res = 0;
38305 DREGu8((Opcode >> 0) & 7) = res;
38306 RET(6)
38307 }
38308
38309 flag_V = 0;
38310 flag_C = 0;
38311 flag_N = src >> 0;
38312 flag_NotZ = src;
38313RET(6)
38314}
38315
38316// LSLD
38317OPCODE(0xE168)
38318{
38319 u32 adr, res;
38320 u32 src, dst;
38321
38322 u32 sft;
38323
38324 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38325 src = DREGu16((Opcode >> 0) & 7);
38326 if (sft)
38327 {
38328 m68kcontext.io_cycle_counter -= sft * 2;
38329 if (sft <= 16)
38330 {
38331 flag_X = flag_C = (src << sft) >> 8;
38332 res = (src << sft) & 0x0000FFFF;
38333 flag_V = 0;
38334 flag_N = res >> 8;
38335 flag_NotZ = res;
38336 DREGu16((Opcode >> 0) & 7) = res;
38337 RET(6)
38338 }
38339
38340 flag_X = flag_C = 0;
38341 flag_N = 0;
38342 flag_NotZ = 0;
38343 flag_V = 0;
38344 res = 0;
38345 DREGu16((Opcode >> 0) & 7) = res;
38346 RET(6)
38347 }
38348
38349 flag_V = 0;
38350 flag_C = 0;
38351 flag_N = src >> 8;
38352 flag_NotZ = src;
38353RET(6)
38354}
38355
38356// LSLD
38357OPCODE(0xE1A8)
38358{
38359#ifdef USE_CYCLONE_TIMING
38360#define CYC 8
38361#else
38362#define CYC 6
38363#endif
38364 u32 adr, res;
38365 u32 src, dst;
38366
38367 u32 sft;
38368
38369 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38370 src = DREGu32((Opcode >> 0) & 7);
38371 if (sft)
38372 {
38373 m68kcontext.io_cycle_counter -= sft * 2;
38374 if (sft < 32)
38375 {
38376 flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38377 res = src << sft;
38378 flag_V = 0;
38379 flag_N = res >> 24;
38380 flag_NotZ = res;
38381 DREGu32((Opcode >> 0) & 7) = res;
38382 RET(CYC)
38383 }
38384
38385 if (sft == 32) flag_C = src << M68K_SR_C_SFT;
38386 else flag_C = 0;
38387 flag_X = flag_C;
38388 flag_N = 0;
38389 flag_NotZ = 0;
38390 flag_V = 0;
38391 res = 0;
38392 DREGu32((Opcode >> 0) & 7) = res;
38393 RET(CYC)
38394 }
38395
38396 flag_V = 0;
38397 flag_C = 0;
38398 flag_N = src >> 24;
38399 flag_NotZ = src;
38400RET(CYC)
38401#undef CYC
38402}
38403
38404// ROXLD
38405OPCODE(0xE130)
38406{
38407 u32 adr, res;
38408 u32 src, dst;
38409
38410 u32 sft;
38411
38412 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38413 src = DREGu8((Opcode >> 0) & 7);
38414 if (sft)
38415 {
38416 m68kcontext.io_cycle_counter -= sft * 2;
38417 sft %= 9;
38418
38419 src |= (flag_X & M68K_SR_X) << 0;
38420 res = (src << sft) | (src >> (9 - sft));
38421 flag_X = flag_C = res >> 0;
38422 flag_V = 0;
38423 flag_N = res >> 0;
38424 flag_NotZ = res & 0x000000FF;
38425 DREGu8((Opcode >> 0) & 7) = res;
38426 RET(6)
38427 }
38428
38429 flag_V = 0;
38430 flag_C = flag_X;
38431 flag_N = src >> 0;
38432 flag_NotZ = src;
38433RET(6)
38434}
38435
38436// ROXLD
38437OPCODE(0xE170)
38438{
38439 u32 adr, res;
38440 u32 src, dst;
38441
38442 u32 sft;
38443
38444 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38445 src = DREGu16((Opcode >> 0) & 7);
38446 if (sft)
38447 {
38448 m68kcontext.io_cycle_counter -= sft * 2;
38449 sft %= 17;
38450
38451 src |= (flag_X & M68K_SR_X) << 8;
38452 res = (src << sft) | (src >> (17 - sft));
38453 flag_X = flag_C = res >> 8;
38454 flag_V = 0;
38455 flag_N = res >> 8;
38456 flag_NotZ = res & 0x0000FFFF;
38457 DREGu16((Opcode >> 0) & 7) = res;
38458 RET(6)
38459 }
38460
38461 flag_V = 0;
38462 flag_C = flag_X;
38463 flag_N = src >> 8;
38464 flag_NotZ = src;
38465RET(6)
38466}
38467
38468// ROXLD
38469OPCODE(0xE1B0)
38470{
38471#ifdef USE_CYCLONE_TIMING
38472#define CYC 8
38473#else
38474#define CYC 6
38475#endif
38476 u32 adr, res;
38477 u32 src, dst;
38478
38479 u32 sft;
38480
38481 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38482 src = DREGu32((Opcode >> 0) & 7);
38483 if (sft)
38484 {
38485 m68kcontext.io_cycle_counter -= sft * 2;
38486 sft %= 33;
38487
38488 if (sft != 0)
38489 {
38490 if (sft == 1) res = (src << 1) | ((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1);
38491 else res = (src << sft) | (src >> (33 - sft)) | (((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1));
38492 flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
38493 }
38494 else res = src;
38495 flag_C = flag_X;
38496 flag_V = 0;
38497 flag_N = res >> 24;
38498 flag_NotZ = res;
38499 DREGu32((Opcode >> 0) & 7) = res;
38500 RET(CYC)
38501 }
38502
38503 flag_V = 0;
38504 flag_C = flag_X;
38505 flag_N = src >> 24;
38506 flag_NotZ = src;
38507RET(CYC)
38508#undef CYC
38509}
38510
38511// ROLD
38512OPCODE(0xE138)
38513{
38514 u32 adr, res;
38515 u32 src, dst;
38516
38517 u32 sft;
38518
38519 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38520 src = DREGu8((Opcode >> 0) & 7);
38521 if (sft)
38522 {
38523 m68kcontext.io_cycle_counter -= sft * 2;
38524 if (sft &= 0x07)
38525 {
38526 flag_C = (src << sft) >> 0;
38527 res = ((src << sft) | (src >> (8 - sft))) & 0x000000FF;
38528 flag_V = 0;
38529 flag_N = res >> 0;
38530 flag_NotZ = res;
38531 DREGu8((Opcode >> 0) & 7) = res;
38532 RET(6)
38533 }
38534
38535 flag_V = 0;
38536 flag_C = src << M68K_SR_C_SFT;
38537 flag_N = src >> 0;
38538 flag_NotZ = src;
38539 RET(6)
38540 }
38541
38542 flag_V = 0;
38543 flag_C = 0;
38544 flag_N = src >> 0;
38545 flag_NotZ = src;
38546RET(6)
38547}
38548
38549// ROLD
38550OPCODE(0xE178)
38551{
38552 u32 adr, res;
38553 u32 src, dst;
38554
38555 u32 sft;
38556
38557 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38558 src = DREGu16((Opcode >> 0) & 7);
38559 if (sft)
38560 {
38561 m68kcontext.io_cycle_counter -= sft * 2;
38562 if (sft &= 0x0F)
38563 {
38564 flag_C = (src << sft) >> 8;
38565 res = ((src << sft) | (src >> (16 - sft))) & 0x0000FFFF;
38566 flag_V = 0;
38567 flag_N = res >> 8;
38568 flag_NotZ = res;
38569 DREGu16((Opcode >> 0) & 7) = res;
38570 RET(6)
38571 }
38572
38573 flag_V = 0;
38574 flag_C = src << M68K_SR_C_SFT;
38575 flag_N = src >> 8;
38576 flag_NotZ = src;
38577 RET(6)
38578 }
38579
38580 flag_V = 0;
38581 flag_C = 0;
38582 flag_N = src >> 8;
38583 flag_NotZ = src;
38584RET(6)
38585}
38586
38587// ROLD
38588OPCODE(0xE1B8)
38589{
38590#ifdef USE_CYCLONE_TIMING
38591#define CYC 8
38592#else
38593#define CYC 6
38594#endif
38595 u32 adr, res;
38596 u32 src, dst;
38597
38598 u32 sft;
38599
38600 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38601 src = DREGu32((Opcode >> 0) & 7);
38602 if (sft)
38603 {
38604 m68kcontext.io_cycle_counter -= sft * 2;
38605 if (sft &= 0x1F)
38606 {
38607 flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38608 res = (src << sft) | (src >> (32 - sft));
38609 flag_V = 0;
38610 flag_N = res >> 24;
38611 flag_NotZ = res;
38612 DREGu32((Opcode >> 0) & 7) = res;
38613 RET(CYC)
38614 }
38615
38616 flag_V = 0;
38617 flag_C = src << M68K_SR_C_SFT;
38618 flag_N = src >> 24;
38619 flag_NotZ = src;
38620 RET(CYC)
38621 }
38622
38623 flag_V = 0;
38624 flag_C = 0;
38625 flag_N = src >> 24;
38626 flag_NotZ = src;
38627RET(CYC)
38628#undef CYC
38629}
38630
38631// ASR
38632OPCODE(0xE0D0)
38633{
38634 u32 adr, res;
38635 u32 src, dst;
38636
38637 adr = AREG((Opcode >> 0) & 7);
38638 PRE_IO
38639 READ_WORD_F(adr, src)
38640 flag_V = 0;
38641 flag_X = flag_C = src << M68K_SR_C_SFT;
38642 res = (src >> 1) | (src & (1 << 15));
38643 flag_N = res >> 8;
38644 flag_NotZ = res;
38645 WRITE_WORD_F(adr, res)
38646 POST_IO
38647RET(12)
38648}
38649
38650// ASR
38651OPCODE(0xE0D8)
38652{
38653 u32 adr, res;
38654 u32 src, dst;
38655
38656 adr = AREG((Opcode >> 0) & 7);
38657 AREG((Opcode >> 0) & 7) += 2;
38658 PRE_IO
38659 READ_WORD_F(adr, src)
38660 flag_V = 0;
38661 flag_X = flag_C = src << M68K_SR_C_SFT;
38662 res = (src >> 1) | (src & (1 << 15));
38663 flag_N = res >> 8;
38664 flag_NotZ = res;
38665 WRITE_WORD_F(adr, res)
38666 POST_IO
38667RET(12)
38668}
38669
38670// ASR
38671OPCODE(0xE0E0)
38672{
38673 u32 adr, res;
38674 u32 src, dst;
38675
38676 adr = AREG((Opcode >> 0) & 7) - 2;
38677 AREG((Opcode >> 0) & 7) = adr;
38678 PRE_IO
38679 READ_WORD_F(adr, src)
38680 flag_V = 0;
38681 flag_X = flag_C = src << M68K_SR_C_SFT;
38682 res = (src >> 1) | (src & (1 << 15));
38683 flag_N = res >> 8;
38684 flag_NotZ = res;
38685 WRITE_WORD_F(adr, res)
38686 POST_IO
38687RET(14)
38688}
38689
38690// ASR
38691OPCODE(0xE0E8)
38692{
38693 u32 adr, res;
38694 u32 src, dst;
38695
38696 FETCH_SWORD(adr);
38697 adr += AREG((Opcode >> 0) & 7);
38698 PRE_IO
38699 READ_WORD_F(adr, src)
38700 flag_V = 0;
38701 flag_X = flag_C = src << M68K_SR_C_SFT;
38702 res = (src >> 1) | (src & (1 << 15));
38703 flag_N = res >> 8;
38704 flag_NotZ = res;
38705 WRITE_WORD_F(adr, res)
38706 POST_IO
38707RET(16)
38708}
38709
38710// ASR
38711OPCODE(0xE0F0)
38712{
38713 u32 adr, res;
38714 u32 src, dst;
38715
38716 adr = AREG((Opcode >> 0) & 7);
38717 DECODE_EXT_WORD
38718 PRE_IO
38719 READ_WORD_F(adr, src)
38720 flag_V = 0;
38721 flag_X = flag_C = src << M68K_SR_C_SFT;
38722 res = (src >> 1) | (src & (1 << 15));
38723 flag_N = res >> 8;
38724 flag_NotZ = res;
38725 WRITE_WORD_F(adr, res)
38726 POST_IO
38727RET(18)
38728}
38729
38730// ASR
38731OPCODE(0xE0F8)
38732{
38733 u32 adr, res;
38734 u32 src, dst;
38735
38736 FETCH_SWORD(adr);
38737 PRE_IO
38738 READ_WORD_F(adr, src)
38739 flag_V = 0;
38740 flag_X = flag_C = src << M68K_SR_C_SFT;
38741 res = (src >> 1) | (src & (1 << 15));
38742 flag_N = res >> 8;
38743 flag_NotZ = res;
38744 WRITE_WORD_F(adr, res)
38745 POST_IO
38746RET(16)
38747}
38748
38749// ASR
38750OPCODE(0xE0F9)
38751{
38752 u32 adr, res;
38753 u32 src, dst;
38754
38755 FETCH_LONG(adr);
38756 PRE_IO
38757 READ_WORD_F(adr, src)
38758 flag_V = 0;
38759 flag_X = flag_C = src << M68K_SR_C_SFT;
38760 res = (src >> 1) | (src & (1 << 15));
38761 flag_N = res >> 8;
38762 flag_NotZ = res;
38763 WRITE_WORD_F(adr, res)
38764 POST_IO
38765RET(20)
38766}
38767
38768// ASR
38769OPCODE(0xE0DF)
38770{
38771 u32 adr, res;
38772 u32 src, dst;
38773
38774 adr = AREG(7);
38775 AREG(7) += 2;
38776 PRE_IO
38777 READ_WORD_F(adr, src)
38778 flag_V = 0;
38779 flag_X = flag_C = src << M68K_SR_C_SFT;
38780 res = (src >> 1) | (src & (1 << 15));
38781 flag_N = res >> 8;
38782 flag_NotZ = res;
38783 WRITE_WORD_F(adr, res)
38784 POST_IO
38785RET(12)
38786}
38787
38788// ASR
38789OPCODE(0xE0E7)
38790{
38791 u32 adr, res;
38792 u32 src, dst;
38793
38794 adr = AREG(7) - 2;
38795 AREG(7) = adr;
38796 PRE_IO
38797 READ_WORD_F(adr, src)
38798 flag_V = 0;
38799 flag_X = flag_C = src << M68K_SR_C_SFT;
38800 res = (src >> 1) | (src & (1 << 15));
38801 flag_N = res >> 8;
38802 flag_NotZ = res;
38803 WRITE_WORD_F(adr, res)
38804 POST_IO
38805RET(14)
38806}
38807
38808// LSR
38809OPCODE(0xE2D0)
38810{
38811 u32 adr, res;
38812 u32 src, dst;
38813
38814 adr = AREG((Opcode >> 0) & 7);
38815 PRE_IO
38816 READ_WORD_F(adr, src)
38817 flag_N = flag_V = 0;
38818 flag_X = flag_C = src << M68K_SR_C_SFT;
38819 res = src >> 1;
38820 flag_NotZ = res;
38821 WRITE_WORD_F(adr, res)
38822 POST_IO
38823RET(12)
38824}
38825
38826// LSR
38827OPCODE(0xE2D8)
38828{
38829 u32 adr, res;
38830 u32 src, dst;
38831
38832 adr = AREG((Opcode >> 0) & 7);
38833 AREG((Opcode >> 0) & 7) += 2;
38834 PRE_IO
38835 READ_WORD_F(adr, src)
38836 flag_N = flag_V = 0;
38837 flag_X = flag_C = src << M68K_SR_C_SFT;
38838 res = src >> 1;
38839 flag_NotZ = res;
38840 WRITE_WORD_F(adr, res)
38841 POST_IO
38842RET(12)
38843}
38844
38845// LSR
38846OPCODE(0xE2E0)
38847{
38848 u32 adr, res;
38849 u32 src, dst;
38850
38851 adr = AREG((Opcode >> 0) & 7) - 2;
38852 AREG((Opcode >> 0) & 7) = adr;
38853 PRE_IO
38854 READ_WORD_F(adr, src)
38855 flag_N = flag_V = 0;
38856 flag_X = flag_C = src << M68K_SR_C_SFT;
38857 res = src >> 1;
38858 flag_NotZ = res;
38859 WRITE_WORD_F(adr, res)
38860 POST_IO
38861RET(14)
38862}
38863
38864// LSR
38865OPCODE(0xE2E8)
38866{
38867 u32 adr, res;
38868 u32 src, dst;
38869
38870 FETCH_SWORD(adr);
38871 adr += AREG((Opcode >> 0) & 7);
38872 PRE_IO
38873 READ_WORD_F(adr, src)
38874 flag_N = flag_V = 0;
38875 flag_X = flag_C = src << M68K_SR_C_SFT;
38876 res = src >> 1;
38877 flag_NotZ = res;
38878 WRITE_WORD_F(adr, res)
38879 POST_IO
38880RET(16)
38881}
38882
38883// LSR
38884OPCODE(0xE2F0)
38885{
38886 u32 adr, res;
38887 u32 src, dst;
38888
38889 adr = AREG((Opcode >> 0) & 7);
38890 DECODE_EXT_WORD
38891 PRE_IO
38892 READ_WORD_F(adr, src)
38893 flag_N = flag_V = 0;
38894 flag_X = flag_C = src << M68K_SR_C_SFT;
38895 res = src >> 1;
38896 flag_NotZ = res;
38897 WRITE_WORD_F(adr, res)
38898 POST_IO
38899RET(18)
38900}
38901
38902// LSR
38903OPCODE(0xE2F8)
38904{
38905 u32 adr, res;
38906 u32 src, dst;
38907
38908 FETCH_SWORD(adr);
38909 PRE_IO
38910 READ_WORD_F(adr, src)
38911 flag_N = flag_V = 0;
38912 flag_X = flag_C = src << M68K_SR_C_SFT;
38913 res = src >> 1;
38914 flag_NotZ = res;
38915 WRITE_WORD_F(adr, res)
38916 POST_IO
38917RET(16)
38918}
38919
38920// LSR
38921OPCODE(0xE2F9)
38922{
38923 u32 adr, res;
38924 u32 src, dst;
38925
38926 FETCH_LONG(adr);
38927 PRE_IO
38928 READ_WORD_F(adr, src)
38929 flag_N = flag_V = 0;
38930 flag_X = flag_C = src << M68K_SR_C_SFT;
38931 res = src >> 1;
38932 flag_NotZ = res;
38933 WRITE_WORD_F(adr, res)
38934 POST_IO
38935RET(20)
38936}
38937
38938// LSR
38939OPCODE(0xE2DF)
38940{
38941 u32 adr, res;
38942 u32 src, dst;
38943
38944 adr = AREG(7);
38945 AREG(7) += 2;
38946 PRE_IO
38947 READ_WORD_F(adr, src)
38948 flag_N = flag_V = 0;
38949 flag_X = flag_C = src << M68K_SR_C_SFT;
38950 res = src >> 1;
38951 flag_NotZ = res;
38952 WRITE_WORD_F(adr, res)
38953 POST_IO
38954RET(12)
38955}
38956
38957// LSR
38958OPCODE(0xE2E7)
38959{
38960 u32 adr, res;
38961 u32 src, dst;
38962
38963 adr = AREG(7) - 2;
38964 AREG(7) = adr;
38965 PRE_IO
38966 READ_WORD_F(adr, src)
38967 flag_N = flag_V = 0;
38968 flag_X = flag_C = src << M68K_SR_C_SFT;
38969 res = src >> 1;
38970 flag_NotZ = res;
38971 WRITE_WORD_F(adr, res)
38972 POST_IO
38973RET(14)
38974}
38975
38976// ROXR
38977OPCODE(0xE4D0)
38978{
38979 u32 adr, res;
38980 u32 src, dst;
38981
38982 adr = AREG((Opcode >> 0) & 7);
38983 PRE_IO
38984 READ_WORD_F(adr, src)
38985 flag_V = 0;
38986 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38987 flag_C = flag_X = src << M68K_SR_C_SFT;
38988 flag_N = res >> 8;
38989 flag_NotZ = res;
38990 WRITE_WORD_F(adr, res)
38991 POST_IO
38992RET(12)
38993}
38994
38995// ROXR
38996OPCODE(0xE4D8)
38997{
38998 u32 adr, res;
38999 u32 src, dst;
39000
39001 adr = AREG((Opcode >> 0) & 7);
39002 AREG((Opcode >> 0) & 7) += 2;
39003 PRE_IO
39004 READ_WORD_F(adr, src)
39005 flag_V = 0;
39006 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39007 flag_C = flag_X = src << M68K_SR_C_SFT;
39008 flag_N = res >> 8;
39009 flag_NotZ = res;
39010 WRITE_WORD_F(adr, res)
39011 POST_IO
39012RET(12)
39013}
39014
39015// ROXR
39016OPCODE(0xE4E0)
39017{
39018 u32 adr, res;
39019 u32 src, dst;
39020
39021 adr = AREG((Opcode >> 0) & 7) - 2;
39022 AREG((Opcode >> 0) & 7) = adr;
39023 PRE_IO
39024 READ_WORD_F(adr, src)
39025 flag_V = 0;
39026 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39027 flag_C = flag_X = src << M68K_SR_C_SFT;
39028 flag_N = res >> 8;
39029 flag_NotZ = res;
39030 WRITE_WORD_F(adr, res)
39031 POST_IO
39032RET(14)
39033}
39034
39035// ROXR
39036OPCODE(0xE4E8)
39037{
39038 u32 adr, res;
39039 u32 src, dst;
39040
39041 FETCH_SWORD(adr);
39042 adr += AREG((Opcode >> 0) & 7);
39043 PRE_IO
39044 READ_WORD_F(adr, src)
39045 flag_V = 0;
39046 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39047 flag_C = flag_X = src << M68K_SR_C_SFT;
39048 flag_N = res >> 8;
39049 flag_NotZ = res;
39050 WRITE_WORD_F(adr, res)
39051 POST_IO
39052RET(16)
39053}
39054
39055// ROXR
39056OPCODE(0xE4F0)
39057{
39058 u32 adr, res;
39059 u32 src, dst;
39060
39061 adr = AREG((Opcode >> 0) & 7);
39062 DECODE_EXT_WORD
39063 PRE_IO
39064 READ_WORD_F(adr, src)
39065 flag_V = 0;
39066 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39067 flag_C = flag_X = src << M68K_SR_C_SFT;
39068 flag_N = res >> 8;
39069 flag_NotZ = res;
39070 WRITE_WORD_F(adr, res)
39071 POST_IO
39072RET(18)
39073}
39074
39075// ROXR
39076OPCODE(0xE4F8)
39077{
39078 u32 adr, res;
39079 u32 src, dst;
39080
39081 FETCH_SWORD(adr);
39082 PRE_IO
39083 READ_WORD_F(adr, src)
39084 flag_V = 0;
39085 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39086 flag_C = flag_X = src << M68K_SR_C_SFT;
39087 flag_N = res >> 8;
39088 flag_NotZ = res;
39089 WRITE_WORD_F(adr, res)
39090 POST_IO
39091RET(16)
39092}
39093
39094// ROXR
39095OPCODE(0xE4F9)
39096{
39097 u32 adr, res;
39098 u32 src, dst;
39099
39100 FETCH_LONG(adr);
39101 PRE_IO
39102 READ_WORD_F(adr, src)
39103 flag_V = 0;
39104 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39105 flag_C = flag_X = src << M68K_SR_C_SFT;
39106 flag_N = res >> 8;
39107 flag_NotZ = res;
39108 WRITE_WORD_F(adr, res)
39109 POST_IO
39110RET(20)
39111}
39112
39113// ROXR
39114OPCODE(0xE4DF)
39115{
39116 u32 adr, res;
39117 u32 src, dst;
39118
39119 adr = AREG(7);
39120 AREG(7) += 2;
39121 PRE_IO
39122 READ_WORD_F(adr, src)
39123 flag_V = 0;
39124 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39125 flag_C = flag_X = src << M68K_SR_C_SFT;
39126 flag_N = res >> 8;
39127 flag_NotZ = res;
39128 WRITE_WORD_F(adr, res)
39129 POST_IO
39130RET(12)
39131}
39132
39133// ROXR
39134OPCODE(0xE4E7)
39135{
39136 u32 adr, res;
39137 u32 src, dst;
39138
39139 adr = AREG(7) - 2;
39140 AREG(7) = adr;
39141 PRE_IO
39142 READ_WORD_F(adr, src)
39143 flag_V = 0;
39144 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39145 flag_C = flag_X = src << M68K_SR_C_SFT;
39146 flag_N = res >> 8;
39147 flag_NotZ = res;
39148 WRITE_WORD_F(adr, res)
39149 POST_IO
39150RET(14)
39151}
39152
39153// ROR
39154OPCODE(0xE6D0)
39155{
39156 u32 adr, res;
39157 u32 src, dst;
39158
39159 adr = AREG((Opcode >> 0) & 7);
39160 PRE_IO
39161 READ_WORD_F(adr, src)
39162 flag_V = 0;
39163 flag_C = src << M68K_SR_C_SFT;
39164 res = (src >> 1) | (src << 15);
39165 flag_N = res >> 8;
39166 flag_NotZ = res & 0x0000FFFF;
39167 WRITE_WORD_F(adr, res)
39168 POST_IO
39169RET(12)
39170}
39171
39172// ROR
39173OPCODE(0xE6D8)
39174{
39175 u32 adr, res;
39176 u32 src, dst;
39177
39178 adr = AREG((Opcode >> 0) & 7);
39179 AREG((Opcode >> 0) & 7) += 2;
39180 PRE_IO
39181 READ_WORD_F(adr, src)
39182 flag_V = 0;
39183 flag_C = src << M68K_SR_C_SFT;
39184 res = (src >> 1) | (src << 15);
39185 flag_N = res >> 8;
39186 flag_NotZ = res & 0x0000FFFF;
39187 WRITE_WORD_F(adr, res)
39188 POST_IO
39189RET(12)
39190}
39191
39192// ROR
39193OPCODE(0xE6E0)
39194{
39195 u32 adr, res;
39196 u32 src, dst;
39197
39198 adr = AREG((Opcode >> 0) & 7) - 2;
39199 AREG((Opcode >> 0) & 7) = adr;
39200 PRE_IO
39201 READ_WORD_F(adr, src)
39202 flag_V = 0;
39203 flag_C = src << M68K_SR_C_SFT;
39204 res = (src >> 1) | (src << 15);
39205 flag_N = res >> 8;
39206 flag_NotZ = res & 0x0000FFFF;
39207 WRITE_WORD_F(adr, res)
39208 POST_IO
39209RET(14)
39210}
39211
39212// ROR
39213OPCODE(0xE6E8)
39214{
39215 u32 adr, res;
39216 u32 src, dst;
39217
39218 FETCH_SWORD(adr);
39219 adr += AREG((Opcode >> 0) & 7);
39220 PRE_IO
39221 READ_WORD_F(adr, src)
39222 flag_V = 0;
39223 flag_C = src << M68K_SR_C_SFT;
39224 res = (src >> 1) | (src << 15);
39225 flag_N = res >> 8;
39226 flag_NotZ = res & 0x0000FFFF;
39227 WRITE_WORD_F(adr, res)
39228 POST_IO
39229RET(16)
39230}
39231
39232// ROR
39233OPCODE(0xE6F0)
39234{
39235 u32 adr, res;
39236 u32 src, dst;
39237
39238 adr = AREG((Opcode >> 0) & 7);
39239 DECODE_EXT_WORD
39240 PRE_IO
39241 READ_WORD_F(adr, src)
39242 flag_V = 0;
39243 flag_C = src << M68K_SR_C_SFT;
39244 res = (src >> 1) | (src << 15);
39245 flag_N = res >> 8;
39246 flag_NotZ = res & 0x0000FFFF;
39247 WRITE_WORD_F(adr, res)
39248 POST_IO
39249RET(18)
39250}
39251
39252// ROR
39253OPCODE(0xE6F8)
39254{
39255 u32 adr, res;
39256 u32 src, dst;
39257
39258 FETCH_SWORD(adr);
39259 PRE_IO
39260 READ_WORD_F(adr, src)
39261 flag_V = 0;
39262 flag_C = src << M68K_SR_C_SFT;
39263 res = (src >> 1) | (src << 15);
39264 flag_N = res >> 8;
39265 flag_NotZ = res & 0x0000FFFF;
39266 WRITE_WORD_F(adr, res)
39267 POST_IO
39268RET(16)
39269}
39270
39271// ROR
39272OPCODE(0xE6F9)
39273{
39274 u32 adr, res;
39275 u32 src, dst;
39276
39277 FETCH_LONG(adr);
39278 PRE_IO
39279 READ_WORD_F(adr, src)
39280 flag_V = 0;
39281 flag_C = src << M68K_SR_C_SFT;
39282 res = (src >> 1) | (src << 15);
39283 flag_N = res >> 8;
39284 flag_NotZ = res & 0x0000FFFF;
39285 WRITE_WORD_F(adr, res)
39286 POST_IO
39287RET(20)
39288}
39289
39290// ROR
39291OPCODE(0xE6DF)
39292{
39293 u32 adr, res;
39294 u32 src, dst;
39295
39296 adr = AREG(7);
39297 AREG(7) += 2;
39298 PRE_IO
39299 READ_WORD_F(adr, src)
39300 flag_V = 0;
39301 flag_C = src << M68K_SR_C_SFT;
39302 res = (src >> 1) | (src << 15);
39303 flag_N = res >> 8;
39304 flag_NotZ = res & 0x0000FFFF;
39305 WRITE_WORD_F(adr, res)
39306 POST_IO
39307RET(12)
39308}
39309
39310// ROR
39311OPCODE(0xE6E7)
39312{
39313 u32 adr, res;
39314 u32 src, dst;
39315
39316 adr = AREG(7) - 2;
39317 AREG(7) = adr;
39318 PRE_IO
39319 READ_WORD_F(adr, src)
39320 flag_V = 0;
39321 flag_C = src << M68K_SR_C_SFT;
39322 res = (src >> 1) | (src << 15);
39323 flag_N = res >> 8;
39324 flag_NotZ = res & 0x0000FFFF;
39325 WRITE_WORD_F(adr, res)
39326 POST_IO
39327RET(14)
39328}
39329
39330// ASL
39331OPCODE(0xE1D0)
39332{
39333 u32 adr, res;
39334 u32 src, dst;
39335
39336 adr = AREG((Opcode >> 0) & 7);
39337 PRE_IO
39338 READ_WORD_F(adr, src)
39339 flag_X = flag_C = src >> 7;
39340 res = src << 1;
39341 flag_V = (src ^ res) >> 8;
39342 flag_N = res >> 8;
39343 flag_NotZ = res & 0x0000FFFF;
39344 WRITE_WORD_F(adr, res)
39345 POST_IO
39346RET(12)
39347}
39348
39349// ASL
39350OPCODE(0xE1D8)
39351{
39352 u32 adr, res;
39353 u32 src, dst;
39354
39355 adr = AREG((Opcode >> 0) & 7);
39356 AREG((Opcode >> 0) & 7) += 2;
39357 PRE_IO
39358 READ_WORD_F(adr, src)
39359 flag_X = flag_C = src >> 7;
39360 res = src << 1;
39361 flag_V = (src ^ res) >> 8;
39362 flag_N = res >> 8;
39363 flag_NotZ = res & 0x0000FFFF;
39364 WRITE_WORD_F(adr, res)
39365 POST_IO
39366RET(12)
39367}
39368
39369// ASL
39370OPCODE(0xE1E0)
39371{
39372 u32 adr, res;
39373 u32 src, dst;
39374
39375 adr = AREG((Opcode >> 0) & 7) - 2;
39376 AREG((Opcode >> 0) & 7) = adr;
39377 PRE_IO
39378 READ_WORD_F(adr, src)
39379 flag_X = flag_C = src >> 7;
39380 res = src << 1;
39381 flag_V = (src ^ res) >> 8;
39382 flag_N = res >> 8;
39383 flag_NotZ = res & 0x0000FFFF;
39384 WRITE_WORD_F(adr, res)
39385 POST_IO
39386RET(14)
39387}
39388
39389// ASL
39390OPCODE(0xE1E8)
39391{
39392 u32 adr, res;
39393 u32 src, dst;
39394
39395 FETCH_SWORD(adr);
39396 adr += AREG((Opcode >> 0) & 7);
39397 PRE_IO
39398 READ_WORD_F(adr, src)
39399 flag_X = flag_C = src >> 7;
39400 res = src << 1;
39401 flag_V = (src ^ res) >> 8;
39402 flag_N = res >> 8;
39403 flag_NotZ = res & 0x0000FFFF;
39404 WRITE_WORD_F(adr, res)
39405 POST_IO
39406RET(16)
39407}
39408
39409// ASL
39410OPCODE(0xE1F0)
39411{
39412 u32 adr, res;
39413 u32 src, dst;
39414
39415 adr = AREG((Opcode >> 0) & 7);
39416 DECODE_EXT_WORD
39417 PRE_IO
39418 READ_WORD_F(adr, src)
39419 flag_X = flag_C = src >> 7;
39420 res = src << 1;
39421 flag_V = (src ^ res) >> 8;
39422 flag_N = res >> 8;
39423 flag_NotZ = res & 0x0000FFFF;
39424 WRITE_WORD_F(adr, res)
39425 POST_IO
39426RET(18)
39427}
39428
39429// ASL
39430OPCODE(0xE1F8)
39431{
39432 u32 adr, res;
39433 u32 src, dst;
39434
39435 FETCH_SWORD(adr);
39436 PRE_IO
39437 READ_WORD_F(adr, src)
39438 flag_X = flag_C = src >> 7;
39439 res = src << 1;
39440 flag_V = (src ^ res) >> 8;
39441 flag_N = res >> 8;
39442 flag_NotZ = res & 0x0000FFFF;
39443 WRITE_WORD_F(adr, res)
39444 POST_IO
39445RET(16)
39446}
39447
39448// ASL
39449OPCODE(0xE1F9)
39450{
39451 u32 adr, res;
39452 u32 src, dst;
39453
39454 FETCH_LONG(adr);
39455 PRE_IO
39456 READ_WORD_F(adr, src)
39457 flag_X = flag_C = src >> 7;
39458 res = src << 1;
39459 flag_V = (src ^ res) >> 8;
39460 flag_N = res >> 8;
39461 flag_NotZ = res & 0x0000FFFF;
39462 WRITE_WORD_F(adr, res)
39463 POST_IO
39464RET(20)
39465}
39466
39467// ASL
39468OPCODE(0xE1DF)
39469{
39470 u32 adr, res;
39471 u32 src, dst;
39472
39473 adr = AREG(7);
39474 AREG(7) += 2;
39475 PRE_IO
39476 READ_WORD_F(adr, src)
39477 flag_X = flag_C = src >> 7;
39478 res = src << 1;
39479 flag_V = (src ^ res) >> 8;
39480 flag_N = res >> 8;
39481 flag_NotZ = res & 0x0000FFFF;
39482 WRITE_WORD_F(adr, res)
39483 POST_IO
39484RET(12)
39485}
39486
39487// ASL
39488OPCODE(0xE1E7)
39489{
39490 u32 adr, res;
39491 u32 src, dst;
39492
39493 adr = AREG(7) - 2;
39494 AREG(7) = adr;
39495 PRE_IO
39496 READ_WORD_F(adr, src)
39497 flag_X = flag_C = src >> 7;
39498 res = src << 1;
39499 flag_V = (src ^ res) >> 8;
39500 flag_N = res >> 8;
39501 flag_NotZ = res & 0x0000FFFF;
39502 WRITE_WORD_F(adr, res)
39503 POST_IO
39504RET(14)
39505}
39506
39507// LSL
39508OPCODE(0xE3D0)
39509{
39510 u32 adr, res;
39511 u32 src, dst;
39512
39513 adr = AREG((Opcode >> 0) & 7);
39514 PRE_IO
39515 READ_WORD_F(adr, src)
39516 flag_V = 0;
39517 flag_X = flag_C = src >> 7;
39518 res = src << 1;
39519 flag_N = res >> 8;
39520 flag_NotZ = res & 0x0000FFFF;
39521 WRITE_WORD_F(adr, res)
39522 POST_IO
39523RET(12)
39524}
39525
39526// LSL
39527OPCODE(0xE3D8)
39528{
39529 u32 adr, res;
39530 u32 src, dst;
39531
39532 adr = AREG((Opcode >> 0) & 7);
39533 AREG((Opcode >> 0) & 7) += 2;
39534 PRE_IO
39535 READ_WORD_F(adr, src)
39536 flag_V = 0;
39537 flag_X = flag_C = src >> 7;
39538 res = src << 1;
39539 flag_N = res >> 8;
39540 flag_NotZ = res & 0x0000FFFF;
39541 WRITE_WORD_F(adr, res)
39542 POST_IO
39543RET(12)
39544}
39545
39546// LSL
39547OPCODE(0xE3E0)
39548{
39549 u32 adr, res;
39550 u32 src, dst;
39551
39552 adr = AREG((Opcode >> 0) & 7) - 2;
39553 AREG((Opcode >> 0) & 7) = adr;
39554 PRE_IO
39555 READ_WORD_F(adr, src)
39556 flag_V = 0;
39557 flag_X = flag_C = src >> 7;
39558 res = src << 1;
39559 flag_N = res >> 8;
39560 flag_NotZ = res & 0x0000FFFF;
39561 WRITE_WORD_F(adr, res)
39562 POST_IO
39563RET(14)
39564}
39565
39566// LSL
39567OPCODE(0xE3E8)
39568{
39569 u32 adr, res;
39570 u32 src, dst;
39571
39572 FETCH_SWORD(adr);
39573 adr += AREG((Opcode >> 0) & 7);
39574 PRE_IO
39575 READ_WORD_F(adr, src)
39576 flag_V = 0;
39577 flag_X = flag_C = src >> 7;
39578 res = src << 1;
39579 flag_N = res >> 8;
39580 flag_NotZ = res & 0x0000FFFF;
39581 WRITE_WORD_F(adr, res)
39582 POST_IO
39583RET(16)
39584}
39585
39586// LSL
39587OPCODE(0xE3F0)
39588{
39589 u32 adr, res;
39590 u32 src, dst;
39591
39592 adr = AREG((Opcode >> 0) & 7);
39593 DECODE_EXT_WORD
39594 PRE_IO
39595 READ_WORD_F(adr, src)
39596 flag_V = 0;
39597 flag_X = flag_C = src >> 7;
39598 res = src << 1;
39599 flag_N = res >> 8;
39600 flag_NotZ = res & 0x0000FFFF;
39601 WRITE_WORD_F(adr, res)
39602 POST_IO
39603RET(18)
39604}
39605
39606// LSL
39607OPCODE(0xE3F8)
39608{
39609 u32 adr, res;
39610 u32 src, dst;
39611
39612 FETCH_SWORD(adr);
39613 PRE_IO
39614 READ_WORD_F(adr, src)
39615 flag_V = 0;
39616 flag_X = flag_C = src >> 7;
39617 res = src << 1;
39618 flag_N = res >> 8;
39619 flag_NotZ = res & 0x0000FFFF;
39620 WRITE_WORD_F(adr, res)
39621 POST_IO
39622RET(16)
39623}
39624
39625// LSL
39626OPCODE(0xE3F9)
39627{
39628 u32 adr, res;
39629 u32 src, dst;
39630
39631 FETCH_LONG(adr);
39632 PRE_IO
39633 READ_WORD_F(adr, src)
39634 flag_V = 0;
39635 flag_X = flag_C = src >> 7;
39636 res = src << 1;
39637 flag_N = res >> 8;
39638 flag_NotZ = res & 0x0000FFFF;
39639 WRITE_WORD_F(adr, res)
39640 POST_IO
39641RET(20)
39642}
39643
39644// LSL
39645OPCODE(0xE3DF)
39646{
39647 u32 adr, res;
39648 u32 src, dst;
39649
39650 adr = AREG(7);
39651 AREG(7) += 2;
39652 PRE_IO
39653 READ_WORD_F(adr, src)
39654 flag_V = 0;
39655 flag_X = flag_C = src >> 7;
39656 res = src << 1;
39657 flag_N = res >> 8;
39658 flag_NotZ = res & 0x0000FFFF;
39659 WRITE_WORD_F(adr, res)
39660 POST_IO
39661RET(12)
39662}
39663
39664// LSL
39665OPCODE(0xE3E7)
39666{
39667 u32 adr, res;
39668 u32 src, dst;
39669
39670 adr = AREG(7) - 2;
39671 AREG(7) = adr;
39672 PRE_IO
39673 READ_WORD_F(adr, src)
39674 flag_V = 0;
39675 flag_X = flag_C = src >> 7;
39676 res = src << 1;
39677 flag_N = res >> 8;
39678 flag_NotZ = res & 0x0000FFFF;
39679 WRITE_WORD_F(adr, res)
39680 POST_IO
39681RET(14)
39682}
39683
39684// ROXL
39685OPCODE(0xE5D0)
39686{
39687 u32 adr, res;
39688 u32 src, dst;
39689
39690 adr = AREG((Opcode >> 0) & 7);
39691 PRE_IO
39692 READ_WORD_F(adr, src)
39693 flag_V = 0;
39694 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39695 flag_X = flag_C = src >> 7;
39696 flag_N = res >> 8;
39697 flag_NotZ = res & 0x0000FFFF;
39698 WRITE_WORD_F(adr, res)
39699 POST_IO
39700RET(12)
39701}
39702
39703// ROXL
39704OPCODE(0xE5D8)
39705{
39706 u32 adr, res;
39707 u32 src, dst;
39708
39709 adr = AREG((Opcode >> 0) & 7);
39710 AREG((Opcode >> 0) & 7) += 2;
39711 PRE_IO
39712 READ_WORD_F(adr, src)
39713 flag_V = 0;
39714 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39715 flag_X = flag_C = src >> 7;
39716 flag_N = res >> 8;
39717 flag_NotZ = res & 0x0000FFFF;
39718 WRITE_WORD_F(adr, res)
39719 POST_IO
39720RET(12)
39721}
39722
39723// ROXL
39724OPCODE(0xE5E0)
39725{
39726 u32 adr, res;
39727 u32 src, dst;
39728
39729 adr = AREG((Opcode >> 0) & 7) - 2;
39730 AREG((Opcode >> 0) & 7) = adr;
39731 PRE_IO
39732 READ_WORD_F(adr, src)
39733 flag_V = 0;
39734 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39735 flag_X = flag_C = src >> 7;
39736 flag_N = res >> 8;
39737 flag_NotZ = res & 0x0000FFFF;
39738 WRITE_WORD_F(adr, res)
39739 POST_IO
39740RET(14)
39741}
39742
39743// ROXL
39744OPCODE(0xE5E8)
39745{
39746 u32 adr, res;
39747 u32 src, dst;
39748
39749 FETCH_SWORD(adr);
39750 adr += AREG((Opcode >> 0) & 7);
39751 PRE_IO
39752 READ_WORD_F(adr, src)
39753 flag_V = 0;
39754 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39755 flag_X = flag_C = src >> 7;
39756 flag_N = res >> 8;
39757 flag_NotZ = res & 0x0000FFFF;
39758 WRITE_WORD_F(adr, res)
39759 POST_IO
39760RET(16)
39761}
39762
39763// ROXL
39764OPCODE(0xE5F0)
39765{
39766 u32 adr, res;
39767 u32 src, dst;
39768
39769 adr = AREG((Opcode >> 0) & 7);
39770 DECODE_EXT_WORD
39771 PRE_IO
39772 READ_WORD_F(adr, src)
39773 flag_V = 0;
39774 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39775 flag_X = flag_C = src >> 7;
39776 flag_N = res >> 8;
39777 flag_NotZ = res & 0x0000FFFF;
39778 WRITE_WORD_F(adr, res)
39779 POST_IO
39780RET(18)
39781}
39782
39783// ROXL
39784OPCODE(0xE5F8)
39785{
39786 u32 adr, res;
39787 u32 src, dst;
39788
39789 FETCH_SWORD(adr);
39790 PRE_IO
39791 READ_WORD_F(adr, src)
39792 flag_V = 0;
39793 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39794 flag_X = flag_C = src >> 7;
39795 flag_N = res >> 8;
39796 flag_NotZ = res & 0x0000FFFF;
39797 WRITE_WORD_F(adr, res)
39798 POST_IO
39799RET(16)
39800}
39801
39802// ROXL
39803OPCODE(0xE5F9)
39804{
39805 u32 adr, res;
39806 u32 src, dst;
39807
39808 FETCH_LONG(adr);
39809 PRE_IO
39810 READ_WORD_F(adr, src)
39811 flag_V = 0;
39812 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39813 flag_X = flag_C = src >> 7;
39814 flag_N = res >> 8;
39815 flag_NotZ = res & 0x0000FFFF;
39816 WRITE_WORD_F(adr, res)
39817 POST_IO
39818RET(20)
39819}
39820
39821// ROXL
39822OPCODE(0xE5DF)
39823{
39824 u32 adr, res;
39825 u32 src, dst;
39826
39827 adr = AREG(7);
39828 AREG(7) += 2;
39829 PRE_IO
39830 READ_WORD_F(adr, src)
39831 flag_V = 0;
39832 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39833 flag_X = flag_C = src >> 7;
39834 flag_N = res >> 8;
39835 flag_NotZ = res & 0x0000FFFF;
39836 WRITE_WORD_F(adr, res)
39837 POST_IO
39838RET(12)
39839}
39840
39841// ROXL
39842OPCODE(0xE5E7)
39843{
39844 u32 adr, res;
39845 u32 src, dst;
39846
39847 adr = AREG(7) - 2;
39848 AREG(7) = adr;
39849 PRE_IO
39850 READ_WORD_F(adr, src)
39851 flag_V = 0;
39852 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39853 flag_X = flag_C = src >> 7;
39854 flag_N = res >> 8;
39855 flag_NotZ = res & 0x0000FFFF;
39856 WRITE_WORD_F(adr, res)
39857 POST_IO
39858RET(14)
39859}
39860
39861// ROL
39862OPCODE(0xE7D0)
39863{
39864 u32 adr, res;
39865 u32 src, dst;
39866
39867 adr = AREG((Opcode >> 0) & 7);
39868 PRE_IO
39869 READ_WORD_F(adr, src)
39870 flag_V = 0;
39871 flag_C = src >> 7;
39872 res = (src << 1) | (src >> 15);
39873 flag_N = res >> 8;
39874 flag_NotZ = res & 0x0000FFFF;
39875 WRITE_WORD_F(adr, res)
39876 POST_IO
39877RET(12)
39878}
39879
39880// ROL
39881OPCODE(0xE7D8)
39882{
39883 u32 adr, res;
39884 u32 src, dst;
39885
39886 adr = AREG((Opcode >> 0) & 7);
39887 AREG((Opcode >> 0) & 7) += 2;
39888 PRE_IO
39889 READ_WORD_F(adr, src)
39890 flag_V = 0;
39891 flag_C = src >> 7;
39892 res = (src << 1) | (src >> 15);
39893 flag_N = res >> 8;
39894 flag_NotZ = res & 0x0000FFFF;
39895 WRITE_WORD_F(adr, res)
39896 POST_IO
39897RET(12)
39898}
39899
39900// ROL
39901OPCODE(0xE7E0)
39902{
39903 u32 adr, res;
39904 u32 src, dst;
39905
39906 adr = AREG((Opcode >> 0) & 7) - 2;
39907 AREG((Opcode >> 0) & 7) = adr;
39908 PRE_IO
39909 READ_WORD_F(adr, src)
39910 flag_V = 0;
39911 flag_C = src >> 7;
39912 res = (src << 1) | (src >> 15);
39913 flag_N = res >> 8;
39914 flag_NotZ = res & 0x0000FFFF;
39915 WRITE_WORD_F(adr, res)
39916 POST_IO
39917RET(14)
39918}
39919
39920// ROL
39921OPCODE(0xE7E8)
39922{
39923 u32 adr, res;
39924 u32 src, dst;
39925
39926 FETCH_SWORD(adr);
39927 adr += AREG((Opcode >> 0) & 7);
39928 PRE_IO
39929 READ_WORD_F(adr, src)
39930 flag_V = 0;
39931 flag_C = src >> 7;
39932 res = (src << 1) | (src >> 15);
39933 flag_N = res >> 8;
39934 flag_NotZ = res & 0x0000FFFF;
39935 WRITE_WORD_F(adr, res)
39936 POST_IO
39937RET(16)
39938}
39939
39940// ROL
39941OPCODE(0xE7F0)
39942{
39943 u32 adr, res;
39944 u32 src, dst;
39945
39946 adr = AREG((Opcode >> 0) & 7);
39947 DECODE_EXT_WORD
39948 PRE_IO
39949 READ_WORD_F(adr, src)
39950 flag_V = 0;
39951 flag_C = src >> 7;
39952 res = (src << 1) | (src >> 15);
39953 flag_N = res >> 8;
39954 flag_NotZ = res & 0x0000FFFF;
39955 WRITE_WORD_F(adr, res)
39956 POST_IO
39957RET(18)
39958}
39959
39960// ROL
39961OPCODE(0xE7F8)
39962{
39963 u32 adr, res;
39964 u32 src, dst;
39965
39966 FETCH_SWORD(adr);
39967 PRE_IO
39968 READ_WORD_F(adr, src)
39969 flag_V = 0;
39970 flag_C = src >> 7;
39971 res = (src << 1) | (src >> 15);
39972 flag_N = res >> 8;
39973 flag_NotZ = res & 0x0000FFFF;
39974 WRITE_WORD_F(adr, res)
39975 POST_IO
39976RET(16)
39977}
39978
39979// ROL
39980OPCODE(0xE7F9)
39981{
39982 u32 adr, res;
39983 u32 src, dst;
39984
39985 FETCH_LONG(adr);
39986 PRE_IO
39987 READ_WORD_F(adr, src)
39988 flag_V = 0;
39989 flag_C = src >> 7;
39990 res = (src << 1) | (src >> 15);
39991 flag_N = res >> 8;
39992 flag_NotZ = res & 0x0000FFFF;
39993 WRITE_WORD_F(adr, res)
39994 POST_IO
39995RET(20)
39996}
39997
39998// ROL
39999OPCODE(0xE7DF)
40000{
40001 u32 adr, res;
40002 u32 src, dst;
40003
40004 adr = AREG(7);
40005 AREG(7) += 2;
40006 PRE_IO
40007 READ_WORD_F(adr, src)
40008 flag_V = 0;
40009 flag_C = src >> 7;
40010 res = (src << 1) | (src >> 15);
40011 flag_N = res >> 8;
40012 flag_NotZ = res & 0x0000FFFF;
40013 WRITE_WORD_F(adr, res)
40014 POST_IO
40015RET(12)
40016}
40017
40018// ROL
40019OPCODE(0xE7E7)
40020{
40021 u32 adr, res;
40022 u32 src, dst;
40023
40024 adr = AREG(7) - 2;
40025 AREG(7) = adr;
40026 PRE_IO
40027 READ_WORD_F(adr, src)
40028 flag_V = 0;
40029 flag_C = src >> 7;
40030 res = (src << 1) | (src >> 15);
40031 flag_N = res >> 8;
40032 flag_NotZ = res & 0x0000FFFF;
40033 WRITE_WORD_F(adr, res)
40034 POST_IO
40035RET(14)
40036}
40037
c060a9ab 40038#ifdef PICODRIVE_HACK
8187ba84 40039#if 0
40040#define UPDATE_IDLE_COUNT { \
40041 extern int idle_hit_counter; \
40042 idle_hit_counter++; \
40043}
40044#else
40045#define UPDATE_IDLE_COUNT
40046#endif
40047
c060a9ab 40048// BRA
40049OPCODE(0x6001_idle)
40050{
40051#ifdef FAMEC_CHECK_BRANCHES
be26eb23 40052 u32 newPC = GET_PC;
c060a9ab 40053 s8 offs=Opcode;
40054 newPC += offs;
40055 SET_PC(newPC);
40056 CHECK_BRANCH_EXCEPTION(offs)
40057#else
40058 PC += ((s8)(Opcode & 0xFE)) >> 1;
40059#endif
8187ba84 40060 UPDATE_IDLE_COUNT
fcf94fcc 40061RET0()
c060a9ab 40062}
40063
40064// BCC
40065OPCODE(0x6601_idle)
40066{
40067 if (flag_NotZ)
40068 {
8187ba84 40069 UPDATE_IDLE_COUNT
c060a9ab 40070 PC += ((s8)(Opcode & 0xFE)) >> 1;
fcf94fcc 40071 //if (idle_hit)
40072 RET0()
c060a9ab 40073 }
40074RET(8)
40075}
40076
40077OPCODE(0x6701_idle)
40078{
40079 if (!flag_NotZ)
40080 {
8187ba84 40081 UPDATE_IDLE_COUNT
c060a9ab 40082 PC += ((s8)(Opcode & 0xFE)) >> 1;
fcf94fcc 40083 //if (idle_hit)
40084 RET0()
c060a9ab 40085 }
40086RET(8)
40087}
40088
40089
0219d379 40090extern int SekIsIdleReady(void);
c060a9ab 40091extern int SekIsIdleCode(unsigned short *dst, int bytes);
5ed2a20e 40092extern int SekRegisterIdlePatch(unsigned int pc, int oldop, int newop, void *ctx);
c060a9ab 40093
40094OPCODE(idle_detector_bcc8)
40095{
c060a9ab 40096 int frame_count, cond_true, bytes, ret, newop;
40097 u16 *dest_pc;
40098
40099 dest_pc = PC + (((s8)(Opcode & 0xFE)) >> 1);
40100
0219d379 40101 if (!SekIsIdleReady())
c060a9ab 40102 goto end;
40103
40104 bytes = 0 - (s8)(Opcode & 0xFE) - 2;
40105 ret = SekIsIdleCode(dest_pc, bytes);
40106 newop = (Opcode & 0xfe) | 0x7100;
40107 if (!ret) newop |= 0x200;
5ed2a20e 40108 if ( Opcode & 0x0100) newop |= 0x400; // beq
40109 if (!(Opcode & 0x0f00)) newop |= 0xc00; // bra
c060a9ab 40110
5ed2a20e 40111 ret = SekRegisterIdlePatch(GET_PC - 2, Opcode, newop, &m68kcontext);
c060a9ab 40112 switch (ret)
40113 {
40114 case 0: PC[-1] = newop; break;
40115 case 1: break;
5ed2a20e 40116 case 2: JumpTable[Opcode] = (Opcode & 0x0f00) ?
40117 ((Opcode & 0x0100) ? CAST_OP(0x6701) : CAST_OP(0x6601)) :
40118 CAST_OP(0x6001); break;
c060a9ab 40119 }
40120
40121end:
5ed2a20e 40122 if ((Opcode & 0xff00) == 0x6000) cond_true = 1;
40123 else cond_true = (Opcode & 0x0100) ? !flag_NotZ : flag_NotZ; // beq?
c060a9ab 40124 if (cond_true)
40125 {
40126 PC = dest_pc;
40127 m68kcontext.io_cycle_counter -= 2;
40128 }
40129RET(8)
40130}
40131
c060a9ab 40132#endif // PICODRIVE_HACK
fast MegaDrive/MegaCD/32X emulator