notaz.gp2x.de / picodrive.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
handle dbra wait loops, update cyclone
[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
16939 res = DREGu8((Opcode >> 0) & 7);
16940 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
16941
16942 if (res != 0x9a)
16943 {
16944 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
16945 res &= 0xFF;
16946 DREGu8((Opcode >> 0) & 7) = res;
16947 flag_NotZ |= res;
16948 flag_X = flag_C = M68K_SR_C;
16949 }
16950 else flag_X = flag_C = 0;
16951 flag_N = res;
16952RET(6)
16953}
16954
16955// NBCD
16956OPCODE(0x4810)
16957{
16958 u32 adr, res;
16959 u32 src, dst;
16960
16961 adr = AREG((Opcode >> 0) & 7);
16962 PRE_IO
16963 READ_BYTE_F(adr, res)
16964 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
16965
16966 if (res != 0x9a)
16967 {
16968 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
16969 res &= 0xFF;
16970 WRITE_BYTE_F(adr, res)
16971 flag_NotZ |= res;
16972 flag_X = flag_C = M68K_SR_C;
16973 }
16974 else flag_X = flag_C = 0;
16975 flag_N = res;
16976 POST_IO
16977RET(12)
16978}
16979
16980// NBCD
16981OPCODE(0x4818)
16982{
16983 u32 adr, res;
16984 u32 src, dst;
16985
16986 adr = AREG((Opcode >> 0) & 7);
16987 AREG((Opcode >> 0) & 7) += 1;
16988 PRE_IO
16989 READ_BYTE_F(adr, res)
16990 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
16991
16992 if (res != 0x9a)
16993 {
16994 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
16995 res &= 0xFF;
16996 WRITE_BYTE_F(adr, res)
16997 flag_NotZ |= res;
16998 flag_X = flag_C = M68K_SR_C;
16999 }
17000 else flag_X = flag_C = 0;
17001 flag_N = res;
17002 POST_IO
17003RET(12)
17004}
17005
17006// NBCD
17007OPCODE(0x4820)
17008{
17009 u32 adr, res;
17010 u32 src, dst;
17011
17012 adr = AREG((Opcode >> 0) & 7) - 1;
17013 AREG((Opcode >> 0) & 7) = adr;
17014 PRE_IO
17015 READ_BYTE_F(adr, res)
17016 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17017
17018 if (res != 0x9a)
17019 {
17020 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17021 res &= 0xFF;
17022 WRITE_BYTE_F(adr, res)
17023 flag_NotZ |= res;
17024 flag_X = flag_C = M68K_SR_C;
17025 }
17026 else flag_X = flag_C = 0;
17027 flag_N = res;
17028 POST_IO
17029RET(14)
17030}
17031
17032// NBCD
17033OPCODE(0x4828)
17034{
17035 u32 adr, res;
17036 u32 src, dst;
17037
17038 FETCH_SWORD(adr);
17039 adr += AREG((Opcode >> 0) & 7);
17040 PRE_IO
17041 READ_BYTE_F(adr, res)
17042 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17043
17044 if (res != 0x9a)
17045 {
17046 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17047 res &= 0xFF;
17048 WRITE_BYTE_F(adr, res)
17049 flag_NotZ |= res;
17050 flag_X = flag_C = M68K_SR_C;
17051 }
17052 else flag_X = flag_C = 0;
17053 flag_N = res;
17054 POST_IO
17055RET(16)
17056}
17057
17058// NBCD
17059OPCODE(0x4830)
17060{
17061 u32 adr, res;
17062 u32 src, dst;
17063
17064 adr = AREG((Opcode >> 0) & 7);
17065 DECODE_EXT_WORD
17066 PRE_IO
17067 READ_BYTE_F(adr, res)
17068 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17069
17070 if (res != 0x9a)
17071 {
17072 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17073 res &= 0xFF;
17074 WRITE_BYTE_F(adr, res)
17075 flag_NotZ |= res;
17076 flag_X = flag_C = M68K_SR_C;
17077 }
17078 else flag_X = flag_C = 0;
17079 flag_N = res;
17080 POST_IO
17081RET(18)
17082}
17083
17084// NBCD
17085OPCODE(0x4838)
17086{
17087 u32 adr, res;
17088 u32 src, dst;
17089
17090 FETCH_SWORD(adr);
17091 PRE_IO
17092 READ_BYTE_F(adr, res)
17093 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17094
17095 if (res != 0x9a)
17096 {
17097 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17098 res &= 0xFF;
17099 WRITE_BYTE_F(adr, res)
17100 flag_NotZ |= res;
17101 flag_X = flag_C = M68K_SR_C;
17102 }
17103 else flag_X = flag_C = 0;
17104 flag_N = res;
17105 POST_IO
17106RET(16)
17107}
17108
17109// NBCD
17110OPCODE(0x4839)
17111{
17112 u32 adr, res;
17113 u32 src, dst;
17114
17115 FETCH_LONG(adr);
17116 PRE_IO
17117 READ_BYTE_F(adr, res)
17118 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17119
17120 if (res != 0x9a)
17121 {
17122 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17123 res &= 0xFF;
17124 WRITE_BYTE_F(adr, res)
17125 flag_NotZ |= res;
17126 flag_X = flag_C = M68K_SR_C;
17127 }
17128 else flag_X = flag_C = 0;
17129 flag_N = res;
17130 POST_IO
17131RET(20)
17132}
17133
17134// NBCD
17135OPCODE(0x481F)
17136{
17137 u32 adr, res;
17138 u32 src, dst;
17139
17140 adr = AREG(7);
17141 AREG(7) += 2;
17142 PRE_IO
17143 READ_BYTE_F(adr, res)
17144 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17145
17146 if (res != 0x9a)
17147 {
17148 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17149 res &= 0xFF;
17150 WRITE_BYTE_F(adr, res)
17151 flag_NotZ |= res;
17152 flag_X = flag_C = M68K_SR_C;
17153 }
17154 else flag_X = flag_C = 0;
17155 flag_N = res;
17156 POST_IO
17157RET(12)
17158}
17159
17160// NBCD
17161OPCODE(0x4827)
17162{
17163 u32 adr, res;
17164 u32 src, dst;
17165
17166 adr = AREG(7) - 2;
17167 AREG(7) = adr;
17168 PRE_IO
17169 READ_BYTE_F(adr, res)
17170 res = 0x9a - res - ((flag_X >> M68K_SR_X_SFT) & 1);
17171
17172 if (res != 0x9a)
17173 {
17174 if ((res & 0x0f) == 0xa) res = (res & 0xf0) + 0x10;
17175 res &= 0xFF;
17176 WRITE_BYTE_F(adr, res)
17177 flag_NotZ |= res;
17178 flag_X = flag_C = M68K_SR_C;
17179 }
17180 else flag_X = flag_C = 0;
17181 flag_N = res;
17182 POST_IO
17183RET(14)
17184}
17185
17186// PEA
17187OPCODE(0x4850)
17188{
17189 u32 adr, res;
17190 u32 src, dst;
17191
17192 adr = AREG((Opcode >> 0) & 7);
17193 PRE_IO
17194 PUSH_32_F(adr)
17195 POST_IO
17196RET(12)
17197}
17198
17199// PEA
17200OPCODE(0x4868)
17201{
17202 u32 adr, res;
17203 u32 src, dst;
17204
17205 FETCH_SWORD(adr);
17206 adr += AREG((Opcode >> 0) & 7);
17207 PRE_IO
17208 PUSH_32_F(adr)
17209 POST_IO
17210RET(16)
17211}
17212
17213// PEA
17214OPCODE(0x4870)
17215{
17216 u32 adr, res;
17217 u32 src, dst;
17218
17219 adr = AREG((Opcode >> 0) & 7);
17220 DECODE_EXT_WORD
17221 PRE_IO
17222 PUSH_32_F(adr)
17223 POST_IO
17224RET(20)
17225}
17226
17227// PEA
17228OPCODE(0x4878)
17229{
17230 u32 adr, res;
17231 u32 src, dst;
17232
17233 FETCH_SWORD(adr);
17234 PRE_IO
17235 PUSH_32_F(adr)
17236 POST_IO
17237RET(16)
17238}
17239
17240// PEA
17241OPCODE(0x4879)
17242{
17243 u32 adr, res;
17244 u32 src, dst;
17245
17246 FETCH_LONG(adr);
17247 PRE_IO
17248 PUSH_32_F(adr)
17249 POST_IO
17250RET(20)
17251}
17252
17253// PEA
17254OPCODE(0x487A)
17255{
17256 u32 adr, res;
17257 u32 src, dst;
17258
be26eb23 17259 adr = GET_SWORD + GET_PC;
70357ce5 17260 PC++;
17261 PRE_IO
17262 PUSH_32_F(adr)
17263 POST_IO
17264RET(16)
17265}
17266
17267// PEA
17268OPCODE(0x487B)
17269{
17270 u32 adr, res;
17271 u32 src, dst;
17272
be26eb23 17273 adr = GET_PC;
70357ce5 17274 DECODE_EXT_WORD
17275 PRE_IO
17276 PUSH_32_F(adr)
17277 POST_IO
17278RET(20)
17279}
17280
17281// SWAP
17282OPCODE(0x4840)
17283{
17284 u32 adr, res;
17285 u32 src, dst;
17286
17287 res = DREGu32((Opcode >> 0) & 7);
17288 res = (res >> 16) | (res << 16);
17289 flag_C = 0;
17290 flag_V = 0;
17291 flag_NotZ = res;
17292 flag_N = res >> 24;
17293 DREGu32((Opcode >> 0) & 7) = res;
17294RET(4)
17295}
17296
17297// MOVEMRa
17298OPCODE(0x4890)
17299{
17300 u32 adr, res;
17301 u32 src, dst;
17302
17303 u32 *psrc;
17304
17305 FETCH_WORD(res);
17306 adr = AREG((Opcode >> 0) & 7);
17307 psrc = &DREGu32(0);
17308 dst = adr;
17309 PRE_IO
17310 do
17311 {
17312 if (res & 1)
17313 {
17314 WRITE_WORD_F(adr, *psrc)
17315 adr += 2;
17316 }
17317 psrc++;
17318 } while (res >>= 1);
17319 POST_IO
17320 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17321#ifdef USE_CYCLONE_TIMING
17322RET(8)
17323#else
17324RET(12)
17325#endif
17326}
17327
17328// MOVEMRa
17329OPCODE(0x48A0)
17330{
17331 u32 adr, res;
17332 u32 src, dst;
17333
17334 u32 *psrc;
17335
17336 FETCH_WORD(res);
17337 adr = AREG((Opcode >> 0) & 7);
17338 psrc = &AREGu32(7);
17339 dst = adr;
17340 PRE_IO
17341 do
17342 {
17343 if (res & 1)
17344 {
17345 adr -= 2;
17346 WRITE_WORD_F(adr, *psrc)
17347 }
17348 psrc--;
17349 } while (res >>= 1);
17350 AREG((Opcode >> 0) & 7) = adr;
17351 POST_IO
17352 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17353RET(8)
17354}
17355
17356// MOVEMRa
17357OPCODE(0x48A8)
17358{
17359 u32 adr, res;
17360 u32 src, dst;
17361
17362 u32 *psrc;
17363
17364 FETCH_WORD(res);
17365 FETCH_SWORD(adr);
17366 adr += AREG((Opcode >> 0) & 7);
17367 psrc = &DREGu32(0);
17368 dst = adr;
17369 PRE_IO
17370 do
17371 {
17372 if (res & 1)
17373 {
17374 WRITE_WORD_F(adr, *psrc)
17375 adr += 2;
17376 }
17377 psrc++;
17378 } while (res >>= 1);
17379 POST_IO
17380 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17381#ifdef USE_CYCLONE_TIMING
17382RET(12)
17383#else
17384RET(20)
17385#endif
17386}
17387
17388// MOVEMRa
17389OPCODE(0x48B0)
17390{
17391 u32 adr, res;
17392 u32 src, dst;
17393
17394 u32 *psrc;
17395
17396 FETCH_WORD(res);
17397 adr = AREG((Opcode >> 0) & 7);
17398 DECODE_EXT_WORD
17399 psrc = &DREGu32(0);
17400 dst = adr;
17401 PRE_IO
17402 do
17403 {
17404 if (res & 1)
17405 {
17406 WRITE_WORD_F(adr, *psrc)
17407 adr += 2;
17408 }
17409 psrc++;
17410 } while (res >>= 1);
17411 POST_IO
17412 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17413#ifdef USE_CYCLONE_TIMING
17414RET(14)
17415#else
17416RET(24)
17417#endif
17418}
17419
17420// MOVEMRa
17421OPCODE(0x48B8)
17422{
17423 u32 adr, res;
17424 u32 src, dst;
17425
17426 u32 *psrc;
17427
17428 FETCH_WORD(res);
17429 FETCH_SWORD(adr);
17430 psrc = &DREGu32(0);
17431 dst = adr;
17432 PRE_IO
17433 do
17434 {
17435 if (res & 1)
17436 {
17437 WRITE_WORD_F(adr, *psrc)
17438 adr += 2;
17439 }
17440 psrc++;
17441 } while (res >>= 1);
17442 POST_IO
17443 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17444#ifdef USE_CYCLONE_TIMING
17445RET(12)
17446#else
17447RET(20)
17448#endif
17449}
17450
17451// MOVEMRa
17452OPCODE(0x48B9)
17453{
17454 u32 adr, res;
17455 u32 src, dst;
17456
17457 u32 *psrc;
17458
17459 FETCH_WORD(res);
17460 FETCH_LONG(adr);
17461 psrc = &DREGu32(0);
17462 dst = adr;
17463 PRE_IO
17464 do
17465 {
17466 if (res & 1)
17467 {
17468 WRITE_WORD_F(adr, *psrc)
17469 adr += 2;
17470 }
17471 psrc++;
17472 } while (res >>= 1);
17473 POST_IO
17474 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17475#ifdef USE_CYCLONE_TIMING
17476RET(16)
17477#else
17478RET(28)
17479#endif
17480}
17481
17482// MOVEMRa
17483OPCODE(0x48A7)
17484{
17485 u32 adr, res;
17486 u32 src, dst;
17487
17488 u32 *psrc;
17489
17490 FETCH_WORD(res);
17491 adr = AREG(7);
17492 psrc = &AREGu32(7);
17493 dst = adr;
17494 PRE_IO
17495 do
17496 {
17497 if (res & 1)
17498 {
17499 adr -= 2;
17500 WRITE_WORD_F(adr, *psrc)
17501 }
17502 psrc--;
17503 } while (res >>= 1);
17504 AREG(7) = adr;
17505 POST_IO
17506 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17507RET(8)
17508}
17509
17510// MOVEMRa
17511OPCODE(0x48D0)
17512{
17513 u32 adr, res;
17514 u32 src, dst;
17515
17516 u32 *psrc;
17517
17518 FETCH_WORD(res);
17519 adr = AREG((Opcode >> 0) & 7);
17520 psrc = &DREGu32(0);
17521 dst = adr;
17522 PRE_IO
17523 do
17524 {
17525 if (res & 1)
17526 {
17527 WRITE_LONG_F(adr, *psrc)
17528 adr += 4;
17529 }
17530 psrc++;
17531 } while (res >>= 1);
17532 POST_IO
17533 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17534#ifdef USE_CYCLONE_TIMING
17535RET(8)
17536#else
17537RET(16)
17538#endif
17539}
17540
17541// MOVEMRa
17542OPCODE(0x48E0)
17543{
17544 u32 adr, res;
17545 u32 src, dst;
17546
17547 u32 *psrc;
17548
17549 FETCH_WORD(res);
17550 adr = AREG((Opcode >> 0) & 7);
17551 psrc = &AREGu32(7);
17552 dst = adr;
17553 PRE_IO
17554 do
17555 {
17556 if (res & 1)
17557 {
17558 adr -= 4;
17559 WRITE_LONG_DEC_F(adr, *psrc)
17560 }
17561 psrc--;
17562 } while (res >>= 1);
17563 AREG((Opcode >> 0) & 7) = adr;
17564 POST_IO
17565 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17566RET(8)
17567}
17568
17569// MOVEMRa
17570OPCODE(0x48E8)
17571{
17572 u32 adr, res;
17573 u32 src, dst;
17574
17575 u32 *psrc;
17576
17577 FETCH_WORD(res);
17578 FETCH_SWORD(adr);
17579 adr += AREG((Opcode >> 0) & 7);
17580 psrc = &DREGu32(0);
17581 dst = adr;
17582 PRE_IO
17583 do
17584 {
17585 if (res & 1)
17586 {
17587 WRITE_LONG_F(adr, *psrc)
17588 adr += 4;
17589 }
17590 psrc++;
17591 } while (res >>= 1);
17592 POST_IO
17593 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17594#ifdef USE_CYCLONE_TIMING
17595RET(12)
17596#else
17597RET(24)
17598#endif
17599}
17600
17601// MOVEMRa
17602OPCODE(0x48F0)
17603{
17604 u32 adr, res;
17605 u32 src, dst;
17606
17607 u32 *psrc;
17608
17609 FETCH_WORD(res);
17610 adr = AREG((Opcode >> 0) & 7);
17611 DECODE_EXT_WORD
17612 psrc = &DREGu32(0);
17613 dst = adr;
17614 PRE_IO
17615 do
17616 {
17617 if (res & 1)
17618 {
17619 WRITE_LONG_F(adr, *psrc)
17620 adr += 4;
17621 }
17622 psrc++;
17623 } while (res >>= 1);
17624 POST_IO
17625 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17626#ifdef USE_CYCLONE_TIMING
17627RET(14)
17628#else
17629RET(28)
17630#endif
17631}
17632
17633// MOVEMRa
17634OPCODE(0x48F8)
17635{
17636 u32 adr, res;
17637 u32 src, dst;
17638
17639 u32 *psrc;
17640
17641 FETCH_WORD(res);
17642 FETCH_SWORD(adr);
17643 psrc = &DREGu32(0);
17644 dst = adr;
17645 PRE_IO
17646 do
17647 {
17648 if (res & 1)
17649 {
17650 WRITE_LONG_F(adr, *psrc)
17651 adr += 4;
17652 }
17653 psrc++;
17654 } while (res >>= 1);
17655 POST_IO
17656 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17657#ifdef USE_CYCLONE_TIMING
17658RET(12)
17659#else
17660RET(24)
17661#endif
17662}
17663
17664// MOVEMRa
17665OPCODE(0x48F9)
17666{
17667 u32 adr, res;
17668 u32 src, dst;
17669
17670 u32 *psrc;
17671
17672 FETCH_WORD(res);
17673 FETCH_LONG(adr);
17674 psrc = &DREGu32(0);
17675 dst = adr;
17676 PRE_IO
17677 do
17678 {
17679 if (res & 1)
17680 {
17681 WRITE_LONG_F(adr, *psrc)
17682 adr += 4;
17683 }
17684 psrc++;
17685 } while (res >>= 1);
17686 POST_IO
17687 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
17688#ifdef USE_CYCLONE_TIMING
17689RET(16)
17690#else
17691RET(32)
17692#endif
17693}
17694
17695// MOVEMRa
17696OPCODE(0x48E7)
17697{
17698 u32 adr, res;
17699 u32 src, dst;
17700
17701 u32 *psrc;
17702
17703 FETCH_WORD(res);
17704 adr = AREG(7);
17705 psrc = &AREGu32(7);
17706 dst = adr;
17707 PRE_IO
17708 do
17709 {
17710 if (res & 1)
17711 {
17712 adr -= 4;
17713 WRITE_LONG_DEC_F(adr, *psrc)
17714 }
17715 psrc--;
17716 } while (res >>= 1);
17717 AREG(7) = adr;
17718 POST_IO
17719 m68kcontext.io_cycle_counter -= (dst - adr) * 2;
17720RET(8)
17721}
17722
17723// EXT
17724OPCODE(0x4880)
17725{
17726 u32 adr, res;
17727 u32 src, dst;
17728
17729 res = (s32)DREGs8((Opcode >> 0) & 7);
17730 flag_C = 0;
17731 flag_V = 0;
17732 flag_NotZ = res;
17733 flag_N = res;
17734 DREGu16((Opcode >> 0) & 7) = res;
17735RET(4)
17736}
17737
17738// EXT
17739OPCODE(0x48C0)
17740{
17741 u32 adr, res;
17742 u32 src, dst;
17743
17744 res = (s32)DREGs16((Opcode >> 0) & 7);
17745 flag_C = 0;
17746 flag_V = 0;
17747 flag_NotZ = res;
17748 flag_N = res >> 8;
17749 DREGu32((Opcode >> 0) & 7) = res;
17750RET(4)
17751}
17752
17753// TST
17754OPCODE(0x4A00)
17755{
17756 u32 adr, res;
17757 u32 src, dst;
17758
17759 res = DREGu8((Opcode >> 0) & 7);
17760 flag_C = 0;
17761 flag_V = 0;
17762 flag_NotZ = res;
17763 flag_N = res;
17764RET(4)
17765}
17766
17767// TST
17768OPCODE(0x4A10)
17769{
17770 u32 adr, res;
17771 u32 src, dst;
17772
17773 adr = AREG((Opcode >> 0) & 7);
17774 PRE_IO
17775 READ_BYTE_F(adr, res)
17776 flag_C = 0;
17777 flag_V = 0;
17778 flag_NotZ = res;
17779 flag_N = res;
17780 POST_IO
17781RET(8)
17782}
17783
17784// TST
17785OPCODE(0x4A18)
17786{
17787 u32 adr, res;
17788 u32 src, dst;
17789
17790 adr = AREG((Opcode >> 0) & 7);
17791 AREG((Opcode >> 0) & 7) += 1;
17792 PRE_IO
17793 READ_BYTE_F(adr, res)
17794 flag_C = 0;
17795 flag_V = 0;
17796 flag_NotZ = res;
17797 flag_N = res;
17798 POST_IO
17799RET(8)
17800}
17801
17802// TST
17803OPCODE(0x4A20)
17804{
17805 u32 adr, res;
17806 u32 src, dst;
17807
17808 adr = AREG((Opcode >> 0) & 7) - 1;
17809 AREG((Opcode >> 0) & 7) = adr;
17810 PRE_IO
17811 READ_BYTE_F(adr, res)
17812 flag_C = 0;
17813 flag_V = 0;
17814 flag_NotZ = res;
17815 flag_N = res;
17816 POST_IO
17817RET(10)
17818}
17819
17820// TST
17821OPCODE(0x4A28)
17822{
17823 u32 adr, res;
17824 u32 src, dst;
17825
17826 FETCH_SWORD(adr);
17827 adr += AREG((Opcode >> 0) & 7);
17828 PRE_IO
17829 READ_BYTE_F(adr, res)
17830 flag_C = 0;
17831 flag_V = 0;
17832 flag_NotZ = res;
17833 flag_N = res;
17834 POST_IO
17835RET(12)
17836}
17837
17838// TST
17839OPCODE(0x4A30)
17840{
17841 u32 adr, res;
17842 u32 src, dst;
17843
17844 adr = AREG((Opcode >> 0) & 7);
17845 DECODE_EXT_WORD
17846 PRE_IO
17847 READ_BYTE_F(adr, res)
17848 flag_C = 0;
17849 flag_V = 0;
17850 flag_NotZ = res;
17851 flag_N = res;
17852 POST_IO
17853RET(14)
17854}
17855
17856// TST
17857OPCODE(0x4A38)
17858{
17859 u32 adr, res;
17860 u32 src, dst;
17861
17862 FETCH_SWORD(adr);
17863 PRE_IO
17864 READ_BYTE_F(adr, res)
17865 flag_C = 0;
17866 flag_V = 0;
17867 flag_NotZ = res;
17868 flag_N = res;
17869 POST_IO
17870RET(12)
17871}
17872
17873// TST
17874OPCODE(0x4A39)
17875{
17876 u32 adr, res;
17877 u32 src, dst;
17878
17879 FETCH_LONG(adr);
17880 PRE_IO
17881 READ_BYTE_F(adr, res)
17882 flag_C = 0;
17883 flag_V = 0;
17884 flag_NotZ = res;
17885 flag_N = res;
17886 POST_IO
17887RET(16)
17888}
17889
17890// TST
17891OPCODE(0x4A1F)
17892{
17893 u32 adr, res;
17894 u32 src, dst;
17895
17896 adr = AREG(7);
17897 AREG(7) += 2;
17898 PRE_IO
17899 READ_BYTE_F(adr, res)
17900 flag_C = 0;
17901 flag_V = 0;
17902 flag_NotZ = res;
17903 flag_N = res;
17904 POST_IO
17905RET(8)
17906}
17907
17908// TST
17909OPCODE(0x4A27)
17910{
17911 u32 adr, res;
17912 u32 src, dst;
17913
17914 adr = AREG(7) - 2;
17915 AREG(7) = adr;
17916 PRE_IO
17917 READ_BYTE_F(adr, res)
17918 flag_C = 0;
17919 flag_V = 0;
17920 flag_NotZ = res;
17921 flag_N = res;
17922 POST_IO
17923RET(10)
17924}
17925
17926// TST
17927OPCODE(0x4A40)
17928{
17929 u32 adr, res;
17930 u32 src, dst;
17931
17932 res = DREGu16((Opcode >> 0) & 7);
17933 flag_C = 0;
17934 flag_V = 0;
17935 flag_NotZ = res;
17936 flag_N = res >> 8;
17937RET(4)
17938}
17939
17940// TST
17941OPCODE(0x4A50)
17942{
17943 u32 adr, res;
17944 u32 src, dst;
17945
17946 adr = AREG((Opcode >> 0) & 7);
17947 PRE_IO
17948 READ_WORD_F(adr, res)
17949 flag_C = 0;
17950 flag_V = 0;
17951 flag_NotZ = res;
17952 flag_N = res >> 8;
17953 POST_IO
17954RET(8)
17955}
17956
17957// TST
17958OPCODE(0x4A58)
17959{
17960 u32 adr, res;
17961 u32 src, dst;
17962
17963 adr = AREG((Opcode >> 0) & 7);
17964 AREG((Opcode >> 0) & 7) += 2;
17965 PRE_IO
17966 READ_WORD_F(adr, res)
17967 flag_C = 0;
17968 flag_V = 0;
17969 flag_NotZ = res;
17970 flag_N = res >> 8;
17971 POST_IO
17972RET(8)
17973}
17974
17975// TST
17976OPCODE(0x4A60)
17977{
17978 u32 adr, res;
17979 u32 src, dst;
17980
17981 adr = AREG((Opcode >> 0) & 7) - 2;
17982 AREG((Opcode >> 0) & 7) = adr;
17983 PRE_IO
17984 READ_WORD_F(adr, res)
17985 flag_C = 0;
17986 flag_V = 0;
17987 flag_NotZ = res;
17988 flag_N = res >> 8;
17989 POST_IO
17990RET(10)
17991}
17992
17993// TST
17994OPCODE(0x4A68)
17995{
17996 u32 adr, res;
17997 u32 src, dst;
17998
17999 FETCH_SWORD(adr);
18000 adr += AREG((Opcode >> 0) & 7);
18001 PRE_IO
18002 READ_WORD_F(adr, res)
18003 flag_C = 0;
18004 flag_V = 0;
18005 flag_NotZ = res;
18006 flag_N = res >> 8;
18007 POST_IO
18008RET(12)
18009}
18010
18011// TST
18012OPCODE(0x4A70)
18013{
18014 u32 adr, res;
18015 u32 src, dst;
18016
18017 adr = AREG((Opcode >> 0) & 7);
18018 DECODE_EXT_WORD
18019 PRE_IO
18020 READ_WORD_F(adr, res)
18021 flag_C = 0;
18022 flag_V = 0;
18023 flag_NotZ = res;
18024 flag_N = res >> 8;
18025 POST_IO
18026RET(14)
18027}
18028
18029// TST
18030OPCODE(0x4A78)
18031{
18032 u32 adr, res;
18033 u32 src, dst;
18034
18035 FETCH_SWORD(adr);
18036 PRE_IO
18037 READ_WORD_F(adr, res)
18038 flag_C = 0;
18039 flag_V = 0;
18040 flag_NotZ = res;
18041 flag_N = res >> 8;
18042 POST_IO
18043RET(12)
18044}
18045
18046// TST
18047OPCODE(0x4A79)
18048{
18049 u32 adr, res;
18050 u32 src, dst;
18051
18052 FETCH_LONG(adr);
18053 PRE_IO
18054 READ_WORD_F(adr, res)
18055 flag_C = 0;
18056 flag_V = 0;
18057 flag_NotZ = res;
18058 flag_N = res >> 8;
18059 POST_IO
18060RET(16)
18061}
18062
18063// TST
18064OPCODE(0x4A5F)
18065{
18066 u32 adr, res;
18067 u32 src, dst;
18068
18069 adr = AREG(7);
18070 AREG(7) += 2;
18071 PRE_IO
18072 READ_WORD_F(adr, res)
18073 flag_C = 0;
18074 flag_V = 0;
18075 flag_NotZ = res;
18076 flag_N = res >> 8;
18077 POST_IO
18078RET(8)
18079}
18080
18081// TST
18082OPCODE(0x4A67)
18083{
18084 u32 adr, res;
18085 u32 src, dst;
18086
18087 adr = AREG(7) - 2;
18088 AREG(7) = adr;
18089 PRE_IO
18090 READ_WORD_F(adr, res)
18091 flag_C = 0;
18092 flag_V = 0;
18093 flag_NotZ = res;
18094 flag_N = res >> 8;
18095 POST_IO
18096RET(10)
18097}
18098
18099// TST
18100OPCODE(0x4A80)
18101{
18102 u32 adr, res;
18103 u32 src, dst;
18104
18105 res = DREGu32((Opcode >> 0) & 7);
18106 flag_C = 0;
18107 flag_V = 0;
18108 flag_NotZ = res;
18109 flag_N = res >> 24;
18110RET(4)
18111}
18112
18113// TST
18114OPCODE(0x4A90)
18115{
18116 u32 adr, res;
18117 u32 src, dst;
18118
18119 adr = AREG((Opcode >> 0) & 7);
18120 PRE_IO
18121 READ_LONG_F(adr, res)
18122 flag_C = 0;
18123 flag_V = 0;
18124 flag_NotZ = res;
18125 flag_N = res >> 24;
18126 POST_IO
18127RET(12)
18128}
18129
18130// TST
18131OPCODE(0x4A98)
18132{
18133 u32 adr, res;
18134 u32 src, dst;
18135
18136 adr = AREG((Opcode >> 0) & 7);
18137 AREG((Opcode >> 0) & 7) += 4;
18138 PRE_IO
18139 READ_LONG_F(adr, res)
18140 flag_C = 0;
18141 flag_V = 0;
18142 flag_NotZ = res;
18143 flag_N = res >> 24;
18144 POST_IO
18145RET(12)
18146}
18147
18148// TST
18149OPCODE(0x4AA0)
18150{
18151 u32 adr, res;
18152 u32 src, dst;
18153
18154 adr = AREG((Opcode >> 0) & 7) - 4;
18155 AREG((Opcode >> 0) & 7) = adr;
18156 PRE_IO
18157 READ_LONG_F(adr, res)
18158 flag_C = 0;
18159 flag_V = 0;
18160 flag_NotZ = res;
18161 flag_N = res >> 24;
18162 POST_IO
18163RET(14)
18164}
18165
18166// TST
18167OPCODE(0x4AA8)
18168{
18169 u32 adr, res;
18170 u32 src, dst;
18171
18172 FETCH_SWORD(adr);
18173 adr += AREG((Opcode >> 0) & 7);
18174 PRE_IO
18175 READ_LONG_F(adr, res)
18176 flag_C = 0;
18177 flag_V = 0;
18178 flag_NotZ = res;
18179 flag_N = res >> 24;
18180 POST_IO
18181RET(16)
18182}
18183
18184// TST
18185OPCODE(0x4AB0)
18186{
18187 u32 adr, res;
18188 u32 src, dst;
18189
18190 adr = AREG((Opcode >> 0) & 7);
18191 DECODE_EXT_WORD
18192 PRE_IO
18193 READ_LONG_F(adr, res)
18194 flag_C = 0;
18195 flag_V = 0;
18196 flag_NotZ = res;
18197 flag_N = res >> 24;
18198 POST_IO
18199RET(18)
18200}
18201
18202// TST
18203OPCODE(0x4AB8)
18204{
18205 u32 adr, res;
18206 u32 src, dst;
18207
18208 FETCH_SWORD(adr);
18209 PRE_IO
18210 READ_LONG_F(adr, res)
18211 flag_C = 0;
18212 flag_V = 0;
18213 flag_NotZ = res;
18214 flag_N = res >> 24;
18215 POST_IO
18216RET(16)
18217}
18218
18219// TST
18220OPCODE(0x4AB9)
18221{
18222 u32 adr, res;
18223 u32 src, dst;
18224
18225 FETCH_LONG(adr);
18226 PRE_IO
18227 READ_LONG_F(adr, res)
18228 flag_C = 0;
18229 flag_V = 0;
18230 flag_NotZ = res;
18231 flag_N = res >> 24;
18232 POST_IO
18233RET(20)
18234}
18235
18236// TST
18237OPCODE(0x4A9F)
18238{
18239 u32 adr, res;
18240 u32 src, dst;
18241
18242 adr = AREG(7);
18243 AREG(7) += 4;
18244 PRE_IO
18245 READ_LONG_F(adr, res)
18246 flag_C = 0;
18247 flag_V = 0;
18248 flag_NotZ = res;
18249 flag_N = res >> 24;
18250 POST_IO
18251RET(12)
18252}
18253
18254// TST
18255OPCODE(0x4AA7)
18256{
18257 u32 adr, res;
18258 u32 src, dst;
18259
18260 adr = AREG(7) - 4;
18261 AREG(7) = adr;
18262 PRE_IO
18263 READ_LONG_F(adr, res)
18264 flag_C = 0;
18265 flag_V = 0;
18266 flag_NotZ = res;
18267 flag_N = res >> 24;
18268 POST_IO
18269RET(14)
18270}
18271
18272// TAS
18273OPCODE(0x4AC0)
18274{
18275 u32 adr, res;
18276 u32 src, dst;
18277
18278 res = DREGu8((Opcode >> 0) & 7);
18279 flag_C = 0;
18280 flag_V = 0;
18281 flag_NotZ = res;
18282 flag_N = res;
18283 res |= 0x80;
18284 DREGu8((Opcode >> 0) & 7) = res;
18285RET(4)
18286}
18287
18288// TAS
18289OPCODE(0x4AD0)
18290{
18291 u32 adr, res;
18292 u32 src, dst;
18293
18294 adr = AREG((Opcode >> 0) & 7);
18295 PRE_IO
18296 READ_BYTE_F(adr, res)
18297 flag_C = 0;
18298 flag_V = 0;
18299 flag_NotZ = res;
18300 flag_N = res;
b5e5172d 18301#ifdef PICODRIVE_HACK
18302 if (g_m68kcontext == &PicoCpuFS68k) {
18303 res |= 0x80;
18304 WRITE_BYTE_F(adr, res);
18305 }
18306#endif
18307
70357ce5 18308 POST_IO
b5e5172d 18309#ifdef USE_CYCLONE_TIMING
18310RET(18)
18311#else
70357ce5 18312RET(8)
b5e5172d 18313#endif
70357ce5 18314}
18315
18316// TAS
18317OPCODE(0x4AD8)
18318{
18319 u32 adr, res;
18320 u32 src, dst;
18321
18322 adr = AREG((Opcode >> 0) & 7);
18323 AREG((Opcode >> 0) & 7) += 1;
18324 PRE_IO
18325 READ_BYTE_F(adr, res)
18326 flag_C = 0;
18327 flag_V = 0;
18328 flag_NotZ = res;
18329 flag_N = res;
b5e5172d 18330
18331#ifdef PICODRIVE_HACK
18332 if (g_m68kcontext == &PicoCpuFS68k) {
18333 res |= 0x80;
18334 WRITE_BYTE_F(adr, res);
18335 }
18336#endif
18337
70357ce5 18338 POST_IO
b5e5172d 18339#ifdef USE_CYCLONE_TIMING
18340RET(18)
18341#else
70357ce5 18342RET(8)
b5e5172d 18343#endif
70357ce5 18344}
18345
18346// TAS
18347OPCODE(0x4AE0)
18348{
18349 u32 adr, res;
18350 u32 src, dst;
18351
18352 adr = AREG((Opcode >> 0) & 7) - 1;
18353 AREG((Opcode >> 0) & 7) = adr;
18354 PRE_IO
18355 READ_BYTE_F(adr, res)
18356 flag_C = 0;
18357 flag_V = 0;
18358 flag_NotZ = res;
18359 flag_N = res;
b5e5172d 18360
18361#ifdef PICODRIVE_HACK
18362 if (g_m68kcontext == &PicoCpuFS68k) {
18363 res |= 0x80;
18364 WRITE_BYTE_F(adr, res);
18365 }
18366#endif
18367
70357ce5 18368 POST_IO
b5e5172d 18369#ifdef USE_CYCLONE_TIMING
18370RET(20)
18371#else
70357ce5 18372RET(10)
b5e5172d 18373#endif
70357ce5 18374}
18375
18376// TAS
18377OPCODE(0x4AE8)
18378{
18379 u32 adr, res;
18380 u32 src, dst;
18381
18382 FETCH_SWORD(adr);
18383 adr += AREG((Opcode >> 0) & 7);
18384 PRE_IO
18385 READ_BYTE_F(adr, res)
18386 flag_C = 0;
18387 flag_V = 0;
18388 flag_NotZ = res;
18389 flag_N = res;
b5e5172d 18390
18391#ifdef PICODRIVE_HACK
18392 if (g_m68kcontext == &PicoCpuFS68k) {
18393 res |= 0x80;
18394 WRITE_BYTE_F(adr, res);
18395 }
18396#endif
18397
70357ce5 18398 POST_IO
b5e5172d 18399#ifdef USE_CYCLONE_TIMING
18400RET(22)
18401#else
70357ce5 18402RET(12)
b5e5172d 18403#endif
70357ce5 18404}
18405
18406// TAS
18407OPCODE(0x4AF0)
18408{
18409 u32 adr, res;
18410 u32 src, dst;
18411
18412 adr = AREG((Opcode >> 0) & 7);
18413 DECODE_EXT_WORD
18414 PRE_IO
18415 READ_BYTE_F(adr, res)
18416 flag_C = 0;
18417 flag_V = 0;
18418 flag_NotZ = res;
18419 flag_N = res;
b5e5172d 18420
18421#ifdef PICODRIVE_HACK
18422 if (g_m68kcontext == &PicoCpuFS68k) {
18423 res |= 0x80;
18424 WRITE_BYTE_F(adr, res);
18425 }
18426#endif
18427
70357ce5 18428 POST_IO
b5e5172d 18429#ifdef USE_CYCLONE_TIMING
18430RET(24)
18431#else
70357ce5 18432RET(14)
b5e5172d 18433#endif
70357ce5 18434}
18435
18436// TAS
18437OPCODE(0x4AF8)
18438{
18439 u32 adr, res;
18440 u32 src, dst;
18441
18442 FETCH_SWORD(adr);
18443 PRE_IO
18444 READ_BYTE_F(adr, res)
18445 flag_C = 0;
18446 flag_V = 0;
18447 flag_NotZ = res;
18448 flag_N = res;
b5e5172d 18449
18450#ifdef PICODRIVE_HACK
18451 if (g_m68kcontext == &PicoCpuFS68k) {
18452 res |= 0x80;
18453 WRITE_BYTE_F(adr, res);
18454 }
18455#endif
18456
70357ce5 18457 POST_IO
b5e5172d 18458#ifdef USE_CYCLONE_TIMING
18459RET(22)
18460#else
70357ce5 18461RET(12)
b5e5172d 18462#endif
70357ce5 18463}
18464
18465// TAS
18466OPCODE(0x4AF9)
18467{
18468 u32 adr, res;
18469 u32 src, dst;
18470
18471 FETCH_LONG(adr);
18472 PRE_IO
18473 READ_BYTE_F(adr, res)
18474 flag_C = 0;
18475 flag_V = 0;
18476 flag_NotZ = res;
18477 flag_N = res;
b5e5172d 18478
18479#ifdef PICODRIVE_HACK
18480 if (g_m68kcontext == &PicoCpuFS68k) {
18481 res |= 0x80;
18482 WRITE_BYTE_F(adr, res);
18483 }
18484#endif
18485
70357ce5 18486 POST_IO
b5e5172d 18487#ifdef USE_CYCLONE_TIMING
18488RET(26)
18489#else
70357ce5 18490RET(16)
b5e5172d 18491#endif
70357ce5 18492}
18493
18494// TAS
18495OPCODE(0x4ADF)
18496{
18497 u32 adr, res;
18498 u32 src, dst;
18499
18500 adr = AREG(7);
18501 AREG(7) += 2;
18502 PRE_IO
18503 READ_BYTE_F(adr, res)
18504 flag_C = 0;
18505 flag_V = 0;
18506 flag_NotZ = res;
18507 flag_N = res;
b5e5172d 18508
18509#ifdef PICODRIVE_HACK
18510 if (g_m68kcontext == &PicoCpuFS68k) {
18511 res |= 0x80;
18512 WRITE_BYTE_F(adr, res);
18513 }
18514#endif
18515
70357ce5 18516 POST_IO
b5e5172d 18517#ifdef USE_CYCLONE_TIMING
18518RET(18)
18519#else
70357ce5 18520RET(8)
b5e5172d 18521#endif
70357ce5 18522}
18523
18524// TAS
18525OPCODE(0x4AE7)
18526{
18527 u32 adr, res;
18528 u32 src, dst;
18529
18530 adr = AREG(7) - 2;
18531 AREG(7) = adr;
18532 PRE_IO
18533 READ_BYTE_F(adr, res)
18534 flag_C = 0;
18535 flag_V = 0;
18536 flag_NotZ = res;
18537 flag_N = res;
b5e5172d 18538
18539#ifdef PICODRIVE_HACK
18540 if (g_m68kcontext == &PicoCpuFS68k) {
18541 res |= 0x80;
18542 WRITE_BYTE_F(adr, res);
18543 }
18544#endif
18545
70357ce5 18546 POST_IO
b5e5172d 18547#ifdef USE_CYCLONE_TIMING
18548RET(20)
18549#else
18550RET(8)
18551#endif
70357ce5 18552}
18553
18554// ILLEGAL
18555OPCODE(0x4AFC)
18556{
d0ae0cb4 18557 SET_PC(execute_exception(M68K_ILLEGAL_INSTRUCTION_EX, GET_PC-2, GET_SR));
03e4f2a3 18558RET(0)
70357ce5 18559}
18560
18561// ILLEGAL A000-AFFF
18562OPCODE(0xA000)
18563{
d0ae0cb4 18564 SET_PC(execute_exception(M68K_1010_EX, GET_PC-2, GET_SR));
03e4f2a3 18565RET(0)
70357ce5 18566}
18567
18568// ILLEGAL F000-FFFF
18569OPCODE(0xF000)
18570{
d0ae0cb4 18571 SET_PC(execute_exception(M68K_1111_EX, GET_PC-2, GET_SR));
03e4f2a3 18572RET(0) // 4 already taken by exc. handler
70357ce5 18573}
18574
18575// MOVEMaR
18576OPCODE(0x4C90)
18577{
18578 u32 adr, res;
18579 u32 src, dst;
18580
18581 s32 *psrc;
18582
18583 FETCH_WORD(res);
18584 adr = AREG((Opcode >> 0) & 7);
18585 psrc = &DREGs32(0);
18586 dst = adr;
18587 PRE_IO
18588 do
18589 {
18590 if (res & 1)
18591 {
18592 READSX_WORD_F(adr, *psrc)
18593 adr += 2;
18594 }
18595 psrc++;
18596 } while (res >>= 1);
18597 POST_IO
18598 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18599#ifdef USE_CYCLONE_TIMING
18600RET(12)
18601#else
18602RET(16)
18603#endif
18604}
18605
18606// MOVEMaR
18607OPCODE(0x4C98)
18608{
18609 u32 adr, res;
18610 u32 src, dst;
18611
18612 s32 *psrc;
18613
18614 FETCH_WORD(res);
18615 adr = AREG((Opcode >> 0) & 7);
18616 psrc = &DREGs32(0);
18617 dst = adr;
18618 PRE_IO
18619 do
18620 {
18621 if (res & 1)
18622 {
18623 READSX_WORD_F(adr, *psrc)
18624 adr += 2;
18625 }
18626 psrc++;
18627 } while (res >>= 1);
18628 AREG((Opcode >> 0) & 7) = adr;
18629 POST_IO
18630 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18631RET(12)
18632}
18633
18634// MOVEMaR
18635OPCODE(0x4CA8)
18636{
18637 u32 adr, res;
18638 u32 src, dst;
18639
18640 s32 *psrc;
18641
18642 FETCH_WORD(res);
18643 FETCH_SWORD(adr);
18644 adr += AREG((Opcode >> 0) & 7);
18645 psrc = &DREGs32(0);
18646 dst = adr;
18647 PRE_IO
18648 do
18649 {
18650 if (res & 1)
18651 {
18652 READSX_WORD_F(adr, *psrc)
18653 adr += 2;
18654 }
18655 psrc++;
18656 } while (res >>= 1);
18657 POST_IO
18658 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18659#ifdef USE_CYCLONE_TIMING
18660RET(16)
18661#else
18662RET(24)
18663#endif
18664}
18665
18666// MOVEMaR
18667OPCODE(0x4CB0)
18668{
18669 u32 adr, res;
18670 u32 src, dst;
18671
18672 s32 *psrc;
18673
18674 FETCH_WORD(res);
18675 adr = AREG((Opcode >> 0) & 7);
18676 DECODE_EXT_WORD
18677 psrc = &DREGs32(0);
18678 dst = adr;
18679 PRE_IO
18680 do
18681 {
18682 if (res & 1)
18683 {
18684 READSX_WORD_F(adr, *psrc)
18685 adr += 2;
18686 }
18687 psrc++;
18688 } while (res >>= 1);
18689 POST_IO
18690 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18691#ifdef USE_CYCLONE_TIMING
18692RET(18)
18693#else
18694RET(28)
18695#endif
18696}
18697
18698// MOVEMaR
18699OPCODE(0x4CB8)
18700{
18701 u32 adr, res;
18702 u32 src, dst;
18703
18704 s32 *psrc;
18705
18706 FETCH_WORD(res);
18707 FETCH_SWORD(adr);
18708 psrc = &DREGs32(0);
18709 dst = adr;
18710 PRE_IO
18711 do
18712 {
18713 if (res & 1)
18714 {
18715 READSX_WORD_F(adr, *psrc)
18716 adr += 2;
18717 }
18718 psrc++;
18719 } while (res >>= 1);
18720 POST_IO
18721 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18722#ifdef USE_CYCLONE_TIMING
18723RET(16)
18724#else
18725RET(24)
18726#endif
18727}
18728
18729// MOVEMaR
18730OPCODE(0x4CB9)
18731{
18732 u32 adr, res;
18733 u32 src, dst;
18734
18735 s32 *psrc;
18736
18737 FETCH_WORD(res);
18738 FETCH_LONG(adr);
18739 psrc = &DREGs32(0);
18740 dst = adr;
18741 PRE_IO
18742 do
18743 {
18744 if (res & 1)
18745 {
18746 READSX_WORD_F(adr, *psrc)
18747 adr += 2;
18748 }
18749 psrc++;
18750 } while (res >>= 1);
18751 POST_IO
18752 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18753#ifdef USE_CYCLONE_TIMING
18754RET(20)
18755#else
18756RET(32)
18757#endif
18758}
18759
18760// MOVEMaR
18761OPCODE(0x4CBA)
18762{
18763 u32 adr, res;
18764 u32 src, dst;
18765
18766 s32 *psrc;
18767
18768 FETCH_WORD(res);
be26eb23 18769 adr = GET_SWORD + GET_PC;
70357ce5 18770 PC++;
18771 psrc = &DREGs32(0);
18772 dst = adr;
18773 PRE_IO
18774 do
18775 {
18776 if (res & 1)
18777 {
18778 READSX_WORD_F(adr, *psrc)
18779 adr += 2;
18780 }
18781 psrc++;
18782 } while (res >>= 1);
18783 POST_IO
18784 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18785#ifdef USE_CYCLONE_TIMING
18786RET(16)
18787#else
18788RET(24)
18789#endif
18790}
18791
18792// MOVEMaR
18793OPCODE(0x4CBB)
18794{
18795 u32 adr, res;
18796 u32 src, dst;
18797
18798 s32 *psrc;
18799
18800 FETCH_WORD(res);
be26eb23 18801 adr = GET_PC;
70357ce5 18802 DECODE_EXT_WORD
18803 psrc = &DREGs32(0);
18804 dst = adr;
18805 PRE_IO
18806 do
18807 {
18808 if (res & 1)
18809 {
18810 READSX_WORD_F(adr, *psrc)
18811 adr += 2;
18812 }
18813 psrc++;
18814 } while (res >>= 1);
18815 POST_IO
18816 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18817#ifdef USE_CYCLONE_TIMING
18818RET(18)
18819#else
18820RET(28)
18821#endif
18822}
18823
18824// MOVEMaR
18825OPCODE(0x4C9F)
18826{
18827 u32 adr, res;
18828 u32 src, dst;
18829
18830 s32 *psrc;
18831
18832 FETCH_WORD(res);
18833 adr = AREG(7);
18834 psrc = &DREGs32(0);
18835 dst = adr;
18836 PRE_IO
18837 do
18838 {
18839 if (res & 1)
18840 {
18841 READSX_WORD_F(adr, *psrc)
18842 adr += 2;
18843 }
18844 psrc++;
18845 } while (res >>= 1);
18846 AREG(7) = adr;
18847 POST_IO
18848 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18849RET(12)
18850}
18851
18852// MOVEMaR
18853OPCODE(0x4CD0)
18854{
18855 u32 adr, res;
18856 u32 src, dst;
18857
18858 u32 *psrc;
18859
18860 FETCH_WORD(res);
18861 adr = AREG((Opcode >> 0) & 7);
18862 psrc = &DREGu32(0);
18863 dst = adr;
18864 PRE_IO
18865 do
18866 {
18867 if (res & 1)
18868 {
18869 READ_LONG_F(adr, *psrc)
18870 adr += 4;
18871 }
18872 psrc++;
18873 } while (res >>= 1);
18874 POST_IO
18875 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18876#ifdef USE_CYCLONE_TIMING
18877RET(12)
18878#else
18879RET(20)
18880#endif
18881}
18882
18883// MOVEMaR
18884OPCODE(0x4CD8)
18885{
18886 u32 adr, res;
18887 u32 src, dst;
18888
18889 u32 *psrc;
18890
18891 FETCH_WORD(res);
18892 adr = AREG((Opcode >> 0) & 7);
18893 psrc = &DREGu32(0);
18894 dst = adr;
18895 PRE_IO
18896 do
18897 {
18898 if (res & 1)
18899 {
18900 READ_LONG_F(adr, *psrc)
18901 adr += 4;
18902 }
18903 psrc++;
18904 } while (res >>= 1);
18905 AREG((Opcode >> 0) & 7) = adr;
18906 POST_IO
18907 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18908RET(12)
18909}
18910
18911// MOVEMaR
18912OPCODE(0x4CE8)
18913{
18914 u32 adr, res;
18915 u32 src, dst;
18916
18917 u32 *psrc;
18918
18919 FETCH_WORD(res);
18920 FETCH_SWORD(adr);
18921 adr += AREG((Opcode >> 0) & 7);
18922 psrc = &DREGu32(0);
18923 dst = adr;
18924 PRE_IO
18925 do
18926 {
18927 if (res & 1)
18928 {
18929 READ_LONG_F(adr, *psrc)
18930 adr += 4;
18931 }
18932 psrc++;
18933 } while (res >>= 1);
18934 POST_IO
18935 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18936#ifdef USE_CYCLONE_TIMING
18937RET(16)
18938#else
18939RET(28)
18940#endif
18941}
18942
18943// MOVEMaR
18944OPCODE(0x4CF0)
18945{
18946 u32 adr, res;
18947 u32 src, dst;
18948
18949 u32 *psrc;
18950
18951 FETCH_WORD(res);
18952 adr = AREG((Opcode >> 0) & 7);
18953 DECODE_EXT_WORD
18954 psrc = &DREGu32(0);
18955 dst = adr;
18956 PRE_IO
18957 do
18958 {
18959 if (res & 1)
18960 {
18961 READ_LONG_F(adr, *psrc)
18962 adr += 4;
18963 }
18964 psrc++;
18965 } while (res >>= 1);
18966 POST_IO
18967 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18968#ifdef USE_CYCLONE_TIMING
18969RET(18)
18970#else
18971RET(32)
18972#endif
18973}
18974
18975// MOVEMaR
18976OPCODE(0x4CF8)
18977{
18978 u32 adr, res;
18979 u32 src, dst;
18980
18981 u32 *psrc;
18982
18983 FETCH_WORD(res);
18984 FETCH_SWORD(adr);
18985 psrc = &DREGu32(0);
18986 dst = adr;
18987 PRE_IO
18988 do
18989 {
18990 if (res & 1)
18991 {
18992 READ_LONG_F(adr, *psrc)
18993 adr += 4;
18994 }
18995 psrc++;
18996 } while (res >>= 1);
18997 POST_IO
18998 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
18999#ifdef USE_CYCLONE_TIMING
19000RET(16)
19001#else
19002RET(28)
19003#endif
19004}
19005
19006// MOVEMaR
19007OPCODE(0x4CF9)
19008{
19009 u32 adr, res;
19010 u32 src, dst;
19011
19012 u32 *psrc;
19013
19014 FETCH_WORD(res);
19015 FETCH_LONG(adr);
19016 psrc = &DREGu32(0);
19017 dst = adr;
19018 PRE_IO
19019 do
19020 {
19021 if (res & 1)
19022 {
19023 READ_LONG_F(adr, *psrc)
19024 adr += 4;
19025 }
19026 psrc++;
19027 } while (res >>= 1);
19028 POST_IO
19029 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19030#ifdef USE_CYCLONE_TIMING
19031RET(20)
19032#else
19033RET(36)
19034#endif
19035}
19036
19037// MOVEMaR
19038OPCODE(0x4CFA)
19039{
19040 u32 adr, res;
19041 u32 src, dst;
19042
19043 u32 *psrc;
19044
19045 FETCH_WORD(res);
be26eb23 19046 adr = GET_SWORD + GET_PC;
70357ce5 19047 PC++;
19048 psrc = &DREGu32(0);
19049 dst = adr;
19050 PRE_IO
19051 do
19052 {
19053 if (res & 1)
19054 {
19055 READ_LONG_F(adr, *psrc)
19056 adr += 4;
19057 }
19058 psrc++;
19059 } while (res >>= 1);
19060 POST_IO
19061 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19062#ifdef USE_CYCLONE_TIMING
19063RET(16)
19064#else
19065RET(28)
19066#endif
19067}
19068
19069// MOVEMaR
19070OPCODE(0x4CFB)
19071{
19072 u32 adr, res;
19073 u32 src, dst;
19074
19075 u32 *psrc;
19076
19077 FETCH_WORD(res);
be26eb23 19078 adr = GET_PC;
70357ce5 19079 DECODE_EXT_WORD
19080 psrc = &DREGu32(0);
19081 dst = adr;
19082 PRE_IO
19083 do
19084 {
19085 if (res & 1)
19086 {
19087 READ_LONG_F(adr, *psrc)
19088 adr += 4;
19089 }
19090 psrc++;
19091 } while (res >>= 1);
19092 POST_IO
19093 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19094#ifdef USE_CYCLONE_TIMING
19095RET(18)
19096#else
19097RET(32)
19098#endif
19099}
19100
19101// MOVEMaR
19102OPCODE(0x4CDF)
19103{
19104 u32 adr, res;
19105 u32 src, dst;
19106
19107 u32 *psrc;
19108
19109 FETCH_WORD(res);
19110 adr = AREG(7);
19111 psrc = &DREGu32(0);
19112 dst = adr;
19113 PRE_IO
19114 do
19115 {
19116 if (res & 1)
19117 {
19118 READ_LONG_F(adr, *psrc)
19119 adr += 4;
19120 }
19121 psrc++;
19122 } while (res >>= 1);
19123 AREG(7) = adr;
19124 POST_IO
19125 m68kcontext.io_cycle_counter -= (adr - dst) * 2;
19126RET(12)
19127}
19128
19129// TRAP
19130OPCODE(0x4E40)
19131{
d0ae0cb4 19132 SET_PC(execute_exception(M68K_TRAP_BASE_EX + (Opcode & 0xF), GET_PC, GET_SR));
70357ce5 19133RET(4)
19134}
19135
19136// LINK
19137OPCODE(0x4E50)
19138{
19139 u32 adr, res;
19140 u32 src, dst;
19141
19142 res = AREGu32((Opcode >> 0) & 7);
19143 PRE_IO
19144 PUSH_32_F(res)
19145 res = AREG(7);
19146 AREG((Opcode >> 0) & 7) = res;
19147 FETCH_SWORD(res);
19148 AREG(7) += res;
19149 POST_IO
19150RET(16)
19151}
19152
19153// LINKA7
19154OPCODE(0x4E57)
19155{
19156 u32 adr, res;
19157 u32 src, dst;
19158
19159 AREG(7) -= 4;
19160 PRE_IO
19161 WRITE_LONG_DEC_F(AREG(7), AREG(7))
19162 FETCH_SWORD(res);
19163 AREG(7) += res;
19164 POST_IO
19165RET(16)
19166}
19167
19168// ULNK
19169OPCODE(0x4E58)
19170{
19171 u32 adr, res;
19172 u32 src, dst;
19173
19174 src = AREGu32((Opcode >> 0) & 7);
19175 AREG(7) = src + 4;
19176 PRE_IO
19177 READ_LONG_F(src, res)
19178 AREG((Opcode >> 0) & 7) = res;
19179 POST_IO
19180RET(12)
19181}
19182
19183// ULNKA7
19184OPCODE(0x4E5F)
19185{
19186 u32 adr, res;
19187 u32 src, dst;
19188
19189 PRE_IO
19190 READ_LONG_F(AREG(7), AREG(7))
19191 POST_IO
19192RET(12)
19193}
19194
19195// MOVEAUSP
19196OPCODE(0x4E60)
19197{
19198 u32 adr, res;
19199 u32 src, dst;
19200
19201 if (!flag_S)
19202 {
d0ae0cb4 19203 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19204 RET(4)
19205 }
19206 res = AREGu32((Opcode >> 0) & 7);
19207 ASP = res;
19208RET(4)
19209}
19210
19211// MOVEUSPA
19212OPCODE(0x4E68)
19213{
19214 u32 adr, res;
19215 u32 src, dst;
19216
19217 if (!flag_S)
19218 {
d0ae0cb4 19219 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19220 RET(4)
19221 }
19222 res = ASP;
19223 AREG((Opcode >> 0) & 7) = res;
19224RET(4)
19225}
19226
19227// RESET
19228OPCODE(0x4E70)
19229{
19230 u32 adr, res;
19231 u32 src, dst;
19232
19233 if (!flag_S)
19234 {
d0ae0cb4 19235 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19236 RET(4)
19237 }
19238 PRE_IO
19239 if (m68kcontext.reset_handler) m68kcontext.reset_handler();
19240// CPU->Reset_CallBack();
19241 POST_IO
19242RET(132)
19243}
19244
19245// NOP
19246OPCODE(0x4E71)
19247{
19248RET(4)
19249}
19250
19251// STOP
19252OPCODE(0x4E72)
19253{
19254 u32 adr, res;
19255 u32 src, dst;
19256
19257 if (!flag_S)
19258 {
d0ae0cb4 19259 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19260 RET(4)
19261 }
19262 FETCH_WORD(res);
19263 res &= M68K_SR_MASK;
19264 SET_SR(res)
19265 if (!flag_S)
19266 {
19267 res = AREG(7);
19268 AREG(7) = ASP;
19269 ASP = res;
19270 }
03e4f2a3 19271 m68kcontext.execinfo |= FM68K_HALTED;
fcf94fcc 19272RET0()
70357ce5 19273}
19274
19275// RTE
19276OPCODE(0x4E73)
19277{
19278 u32 adr, res;
19279 u32 src, dst;
19280
19281 if (!flag_S)
19282 {
d0ae0cb4 19283 SET_PC(execute_exception(M68K_PRIVILEGE_VIOLATION_EX, GET_PC-2, GET_SR));
70357ce5 19284 RET(4)
19285 }
19286 PRE_IO
19287 POP_16_F(res)
19288 SET_SR(res)
19289 POP_32_F(res)
19290 SET_PC(res)
19291 if (!flag_S)
19292 {
19293 res = AREG(7);
19294 AREG(7) = ASP;
19295 ASP = res;
19296 }
19297 POST_IO
03e4f2a3 19298 m68kcontext.execinfo &= ~(FM68K_EMULATE_GROUP_0|FM68K_EMULATE_TRACE|FM68K_DO_TRACE);
70357ce5 19299 CHECK_INT_TO_JUMP(20)
19300RET(20)
19301}
19302
19303// RTS
19304OPCODE(0x4E75)
19305{
19306 u32 adr, res;
19307 u32 src, dst;
19308
19309 PRE_IO
19310 POP_32_F(res)
19311 SET_PC(res)
19312 CHECK_BRANCH_EXCEPTION(res)
19313 POST_IO
19314RET(16)
19315}
19316
19317// TRAPV
19318OPCODE(0x4E76)
19319{
19320 if (flag_V & 0x80)
d0ae0cb4 19321 SET_PC(execute_exception(M68K_TRAPV_EX, GET_PC, GET_SR));
70357ce5 19322RET(4)
19323}
19324
19325// RTR
19326OPCODE(0x4E77)
19327{
19328 u32 adr, res;
19329 u32 src, dst;
19330
19331 PRE_IO
19332 POP_16_F(res)
19333 SET_CCR(res)
19334 POP_32_F(res)
19335 SET_PC(res)
19336 CHECK_BRANCH_EXCEPTION(res)
19337 POST_IO
19338RET(20)
19339}
19340
19341// JSR
19342OPCODE(0x4E90)
19343{
19344 u32 adr, res;
19345 u32 src, dst;
19346
19347 adr = AREG((Opcode >> 0) & 7);
19348 {
19349 u32 oldPC;
19350
be26eb23 19351 oldPC = GET_PC;
70357ce5 19352 PRE_IO
19353 PUSH_32_F(oldPC)
19354 }
19355 SET_PC(adr)
19356 CHECK_BRANCH_EXCEPTION(adr)
19357 POST_IO
19358RET(16)
19359}
19360
19361// JSR
19362OPCODE(0x4EA8)
19363{
19364 u32 adr, res;
19365 u32 src, dst;
19366
19367 FETCH_SWORD(adr);
19368 adr += AREG((Opcode >> 0) & 7);
19369 {
19370 u32 oldPC;
19371
be26eb23 19372 oldPC = GET_PC;
70357ce5 19373 PRE_IO
19374 PUSH_32_F(oldPC)
19375 }
19376 SET_PC(adr)
19377 CHECK_BRANCH_EXCEPTION(adr)
19378 POST_IO
19379RET(18)
19380}
19381
19382// JSR
19383OPCODE(0x4EB0)
19384{
19385 u32 adr, res;
19386 u32 src, dst;
19387
19388 adr = AREG((Opcode >> 0) & 7);
19389 DECODE_EXT_WORD
19390 {
19391 u32 oldPC;
19392
be26eb23 19393 oldPC = GET_PC;
70357ce5 19394 PRE_IO
19395 PUSH_32_F(oldPC)
19396 }
19397 SET_PC(adr)
19398 CHECK_BRANCH_EXCEPTION(adr)
19399 POST_IO
19400RET(22)
19401}
19402
19403// JSR
19404OPCODE(0x4EB8)
19405{
19406 u32 adr, res;
19407 u32 src, dst;
19408
19409 FETCH_SWORD(adr);
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(18)
19421}
19422
19423// JSR
19424OPCODE(0x4EB9)
19425{
19426 u32 adr, res;
19427 u32 src, dst;
19428
19429 FETCH_LONG(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(20)
19441}
19442
19443// JSR
19444OPCODE(0x4EBA)
19445{
19446 u32 adr, res;
19447 u32 src, dst;
19448
be26eb23 19449 adr = GET_SWORD + GET_PC;
70357ce5 19450 PC++;
19451 {
19452 u32 oldPC;
19453
be26eb23 19454 oldPC = GET_PC;
70357ce5 19455 PRE_IO
19456 PUSH_32_F(oldPC)
19457 }
19458 SET_PC(adr)
19459 CHECK_BRANCH_EXCEPTION(adr)
19460 POST_IO
19461RET(18)
19462}
19463
19464// JSR
19465OPCODE(0x4EBB)
19466{
19467 u32 adr, res;
19468 u32 src, dst;
19469
be26eb23 19470 adr = GET_PC;
70357ce5 19471 DECODE_EXT_WORD
19472 {
19473 u32 oldPC;
19474
be26eb23 19475 oldPC = GET_PC;
70357ce5 19476 PRE_IO
19477 PUSH_32_F(oldPC)
19478 }
19479 SET_PC(adr)
19480 CHECK_BRANCH_EXCEPTION(adr)
19481 POST_IO
19482RET(22)
19483}
19484
19485// JMP
19486OPCODE(0x4ED0)
19487{
19488 u32 adr, res;
19489 u32 src, dst;
19490
19491 adr = AREG((Opcode >> 0) & 7);
19492 SET_PC(adr)
19493 CHECK_BRANCH_EXCEPTION(adr)
19494RET(8)
19495}
19496
19497// JMP
19498OPCODE(0x4EE8)
19499{
19500 u32 adr, res;
19501 u32 src, dst;
19502
19503 FETCH_SWORD(adr);
19504 adr += AREG((Opcode >> 0) & 7);
19505 SET_PC(adr)
19506 CHECK_BRANCH_EXCEPTION(adr)
19507RET(10)
19508}
19509
19510// JMP
19511OPCODE(0x4EF0)
19512{
19513 u32 adr, res;
19514 u32 src, dst;
19515
19516 adr = AREG((Opcode >> 0) & 7);
19517 DECODE_EXT_WORD
19518 SET_PC(adr)
19519 CHECK_BRANCH_EXCEPTION(adr)
19520RET(14)
19521}
19522
19523// JMP
19524OPCODE(0x4EF8)
19525{
19526 u32 adr, res;
19527 u32 src, dst;
19528
19529 FETCH_SWORD(adr);
19530 SET_PC(adr)
19531 CHECK_BRANCH_EXCEPTION(adr)
19532RET(10)
19533}
19534
19535// JMP
19536OPCODE(0x4EF9)
19537{
19538 u32 adr, res;
19539 u32 src, dst;
19540
19541 FETCH_LONG(adr);
19542 SET_PC(adr)
19543 CHECK_BRANCH_EXCEPTION(adr)
19544RET(12)
19545}
19546
19547// JMP
19548OPCODE(0x4EFA)
19549{
19550 u32 adr, res;
19551 u32 src, dst;
19552
be26eb23 19553 adr = GET_SWORD + GET_PC;
70357ce5 19554 PC++;
19555 SET_PC(adr)
19556 CHECK_BRANCH_EXCEPTION(adr)
19557RET(10)
19558}
19559
19560// JMP
19561OPCODE(0x4EFB)
19562{
19563 u32 adr, res;
19564 u32 src, dst;
19565
be26eb23 19566 adr = GET_PC;
70357ce5 19567 DECODE_EXT_WORD
19568 SET_PC(adr)
19569 CHECK_BRANCH_EXCEPTION(adr)
19570RET(14)
19571}
19572
19573// CHK
19574OPCODE(0x4180)
19575{
19576 u32 adr, res;
19577 u32 src, dst;
19578
19579 src = DREGu16((Opcode >> 0) & 7);
19580 res = DREGu16((Opcode >> 9) & 7);
19581 if (((s32)res < 0) || (res > src))
19582 {
19583 flag_N = res >> 8;
d0ae0cb4 19584 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19585 }
19586RET(10)
19587}
19588
19589// CHK
19590OPCODE(0x4190)
19591{
19592 u32 adr, res;
19593 u32 src, dst;
19594
19595 adr = AREG((Opcode >> 0) & 7);
19596 PRE_IO
19597 READ_WORD_F(adr, src)
19598 res = DREGu16((Opcode >> 9) & 7);
19599 if (((s32)res < 0) || (res > src))
19600 {
19601 flag_N = res >> 8;
d0ae0cb4 19602 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19603 }
19604 POST_IO
19605RET(14)
19606}
19607
19608// CHK
19609OPCODE(0x4198)
19610{
19611 u32 adr, res;
19612 u32 src, dst;
19613
19614 adr = AREG((Opcode >> 0) & 7);
19615 AREG((Opcode >> 0) & 7) += 2;
19616 PRE_IO
19617 READ_WORD_F(adr, src)
19618 res = DREGu16((Opcode >> 9) & 7);
19619 if (((s32)res < 0) || (res > src))
19620 {
19621 flag_N = res >> 8;
d0ae0cb4 19622 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19623 }
19624 POST_IO
19625RET(14)
19626}
19627
19628// CHK
19629OPCODE(0x41A0)
19630{
19631 u32 adr, res;
19632 u32 src, dst;
19633
19634 adr = AREG((Opcode >> 0) & 7) - 2;
19635 AREG((Opcode >> 0) & 7) = adr;
19636 PRE_IO
19637 READ_WORD_F(adr, src)
19638 res = DREGu16((Opcode >> 9) & 7);
19639 if (((s32)res < 0) || (res > src))
19640 {
19641 flag_N = res >> 8;
d0ae0cb4 19642 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19643 }
19644 POST_IO
19645RET(16)
19646}
19647
19648// CHK
19649OPCODE(0x41A8)
19650{
19651 u32 adr, res;
19652 u32 src, dst;
19653
19654 FETCH_SWORD(adr);
19655 adr += AREG((Opcode >> 0) & 7);
19656 PRE_IO
19657 READ_WORD_F(adr, src)
19658 res = DREGu16((Opcode >> 9) & 7);
19659 if (((s32)res < 0) || (res > src))
19660 {
19661 flag_N = res >> 8;
d0ae0cb4 19662 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19663 }
19664 POST_IO
19665RET(18)
19666}
19667
19668// CHK
19669OPCODE(0x41B0)
19670{
19671 u32 adr, res;
19672 u32 src, dst;
19673
19674 adr = AREG((Opcode >> 0) & 7);
19675 DECODE_EXT_WORD
19676 PRE_IO
19677 READ_WORD_F(adr, src)
19678 res = DREGu16((Opcode >> 9) & 7);
19679 if (((s32)res < 0) || (res > src))
19680 {
19681 flag_N = res >> 8;
d0ae0cb4 19682 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19683 }
19684 POST_IO
19685RET(20)
19686}
19687
19688// CHK
19689OPCODE(0x41B8)
19690{
19691 u32 adr, res;
19692 u32 src, dst;
19693
19694 FETCH_SWORD(adr);
19695 PRE_IO
19696 READ_WORD_F(adr, src)
19697 res = DREGu16((Opcode >> 9) & 7);
19698 if (((s32)res < 0) || (res > src))
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(18)
19705}
19706
19707// CHK
19708OPCODE(0x41B9)
19709{
19710 u32 adr, res;
19711 u32 src, dst;
19712
19713 FETCH_LONG(adr);
19714 PRE_IO
19715 READ_WORD_F(adr, src)
19716 res = DREGu16((Opcode >> 9) & 7);
19717 if (((s32)res < 0) || (res > src))
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(22)
19724}
19725
19726// CHK
19727OPCODE(0x41BA)
19728{
19729 u32 adr, res;
19730 u32 src, dst;
19731
be26eb23 19732 adr = GET_SWORD + GET_PC;
70357ce5 19733 PC++;
19734 PRE_IO
19735 READ_WORD_F(adr, src)
19736 res = DREGu16((Opcode >> 9) & 7);
19737 if (((s32)res < 0) || (res > src))
19738 {
19739 flag_N = res >> 8;
d0ae0cb4 19740 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19741 }
19742 POST_IO
19743RET(18)
19744}
19745
19746// CHK
19747OPCODE(0x41BB)
19748{
19749 u32 adr, res;
19750 u32 src, dst;
19751
be26eb23 19752 adr = GET_PC;
70357ce5 19753 DECODE_EXT_WORD
19754 PRE_IO
19755 READ_WORD_F(adr, src)
19756 res = DREGu16((Opcode >> 9) & 7);
19757 if (((s32)res < 0) || (res > src))
19758 {
19759 flag_N = res >> 8;
d0ae0cb4 19760 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19761 }
19762 POST_IO
19763RET(20)
19764}
19765
19766// CHK
19767OPCODE(0x41BC)
19768{
19769 u32 adr, res;
19770 u32 src, dst;
19771
19772 FETCH_WORD(src);
19773 res = DREGu16((Opcode >> 9) & 7);
19774 if (((s32)res < 0) || (res > src))
19775 {
19776 flag_N = res >> 8;
d0ae0cb4 19777 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19778 }
19779 POST_IO
19780RET(14)
19781}
19782
19783// CHK
19784OPCODE(0x419F)
19785{
19786 u32 adr, res;
19787 u32 src, dst;
19788
19789 adr = AREG(7);
19790 AREG(7) += 2;
19791 PRE_IO
19792 READ_WORD_F(adr, src)
19793 res = DREGu16((Opcode >> 9) & 7);
19794 if (((s32)res < 0) || (res > src))
19795 {
19796 flag_N = res >> 8;
d0ae0cb4 19797 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19798 }
19799 POST_IO
19800RET(14)
19801}
19802
19803// CHK
19804OPCODE(0x41A7)
19805{
19806 u32 adr, res;
19807 u32 src, dst;
19808
19809 adr = AREG(7) - 2;
19810 AREG(7) = adr;
19811 PRE_IO
19812 READ_WORD_F(adr, src)
19813 res = DREGu16((Opcode >> 9) & 7);
19814 if (((s32)res < 0) || (res > src))
19815 {
19816 flag_N = res >> 8;
d0ae0cb4 19817 SET_PC(execute_exception(M68K_CHK_EX, GET_PC, GET_SR));
70357ce5 19818 }
19819 POST_IO
19820RET(16)
19821}
19822
19823// LEA
19824OPCODE(0x41D0)
19825{
19826 u32 adr, res;
19827 u32 src, dst;
19828
19829 adr = AREG((Opcode >> 0) & 7);
19830 res = adr;
19831 AREG((Opcode >> 9) & 7) = res;
19832RET(4)
19833}
19834
19835// LEA
19836OPCODE(0x41E8)
19837{
19838 u32 adr, res;
19839 u32 src, dst;
19840
19841 FETCH_SWORD(adr);
19842 adr += AREG((Opcode >> 0) & 7);
19843 res = adr;
19844 AREG((Opcode >> 9) & 7) = res;
19845RET(8)
19846}
19847
19848// LEA
19849OPCODE(0x41F0)
19850{
19851 u32 adr, res;
19852 u32 src, dst;
19853
19854 adr = AREG((Opcode >> 0) & 7);
19855 DECODE_EXT_WORD
19856 res = adr;
19857 AREG((Opcode >> 9) & 7) = res;
19858RET(12)
19859}
19860
19861// LEA
19862OPCODE(0x41F8)
19863{
19864 u32 adr, res;
19865 u32 src, dst;
19866
19867 FETCH_SWORD(adr);
19868 res = adr;
19869 AREG((Opcode >> 9) & 7) = res;
19870RET(8)
19871}
19872
19873// LEA
19874OPCODE(0x41F9)
19875{
19876 u32 adr, res;
19877 u32 src, dst;
19878
19879 FETCH_LONG(adr);
19880 res = adr;
19881 AREG((Opcode >> 9) & 7) = res;
19882RET(12)
19883}
19884
19885// LEA
19886OPCODE(0x41FA)
19887{
19888 u32 adr, res;
19889 u32 src, dst;
19890
be26eb23 19891 adr = GET_SWORD + GET_PC;
70357ce5 19892 PC++;
19893 res = adr;
19894 AREG((Opcode >> 9) & 7) = res;
19895RET(8)
19896}
19897
19898// LEA
19899OPCODE(0x41FB)
19900{
19901 u32 adr, res;
19902 u32 src, dst;
19903
be26eb23 19904 adr = GET_PC;
70357ce5 19905 DECODE_EXT_WORD
19906 res = adr;
19907 AREG((Opcode >> 9) & 7) = res;
19908RET(12)
19909}
19910
19911// STCC
19912OPCODE(0x50C0)
19913{
19914 u32 adr, res;
19915 u32 src, dst;
19916
19917 res = 0xFF;
19918 DREGu8((Opcode >> 0) & 7) = res;
19919 RET(6)
19920}
19921
19922// STCC
19923OPCODE(0x51C0)
19924{
19925 u32 adr, res;
19926 u32 src, dst;
19927
19928 res = 0;
19929 DREGu8((Opcode >> 0) & 7) = res;
19930 RET(4)
19931}
19932
19933// STCC
19934OPCODE(0x52C0)
19935{
19936 u32 adr, res;
19937 u32 src, dst;
19938
19939 if (flag_NotZ && (!(flag_C & 0x100)))
19940 {
19941 res = 0xFF;
19942 DREGu8((Opcode >> 0) & 7) = res;
19943 RET(6)
19944 }
19945 res = 0;
19946 DREGu8((Opcode >> 0) & 7) = res;
19947 RET(4)
19948}
19949
19950// STCC
19951OPCODE(0x53C0)
19952{
19953 u32 adr, res;
19954 u32 src, dst;
19955
19956 if ((!flag_NotZ) || (flag_C & 0x100))
19957 {
19958 res = 0xFF;
19959 DREGu8((Opcode >> 0) & 7) = res;
19960 RET(6)
19961 }
19962 res = 0;
19963 DREGu8((Opcode >> 0) & 7) = res;
19964 RET(4)
19965}
19966
19967// STCC
19968OPCODE(0x54C0)
19969{
19970 u32 adr, res;
19971 u32 src, dst;
19972
19973 if (!(flag_C & 0x100))
19974 {
19975 res = 0xFF;
19976 DREGu8((Opcode >> 0) & 7) = res;
19977 RET(6)
19978 }
19979 res = 0;
19980 DREGu8((Opcode >> 0) & 7) = res;
19981 RET(4)
19982}
19983
19984// STCC
19985OPCODE(0x55C0)
19986{
19987 u32 adr, res;
19988 u32 src, dst;
19989
19990 if (flag_C & 0x100)
19991 {
19992 res = 0xFF;
19993 DREGu8((Opcode >> 0) & 7) = res;
19994 RET(6)
19995 }
19996 res = 0;
19997 DREGu8((Opcode >> 0) & 7) = res;
19998 RET(4)
19999}
20000
20001// STCC
20002OPCODE(0x56C0)
20003{
20004 u32 adr, res;
20005 u32 src, dst;
20006
20007 if (flag_NotZ)
20008 {
20009 res = 0xFF;
20010 DREGu8((Opcode >> 0) & 7) = res;
20011 RET(6)
20012 }
20013 res = 0;
20014 DREGu8((Opcode >> 0) & 7) = res;
20015 RET(4)
20016}
20017
20018// STCC
20019OPCODE(0x57C0)
20020{
20021 u32 adr, res;
20022 u32 src, dst;
20023
20024 if (!flag_NotZ)
20025 {
20026 res = 0xFF;
20027 DREGu8((Opcode >> 0) & 7) = res;
20028 RET(6)
20029 }
20030 res = 0;
20031 DREGu8((Opcode >> 0) & 7) = res;
20032 RET(4)
20033}
20034
20035// STCC
20036OPCODE(0x58C0)
20037{
20038 u32 adr, res;
20039 u32 src, dst;
20040
20041 if (!(flag_V & 0x80))
20042 {
20043 res = 0xFF;
20044 DREGu8((Opcode >> 0) & 7) = res;
20045 RET(6)
20046 }
20047 res = 0;
20048 DREGu8((Opcode >> 0) & 7) = res;
20049 RET(4)
20050}
20051
20052// STCC
20053OPCODE(0x59C0)
20054{
20055 u32 adr, res;
20056 u32 src, dst;
20057
20058 if (flag_V & 0x80)
20059 {
20060 res = 0xFF;
20061 DREGu8((Opcode >> 0) & 7) = res;
20062 RET(6)
20063 }
20064 res = 0;
20065 DREGu8((Opcode >> 0) & 7) = res;
20066 RET(4)
20067}
20068
20069// STCC
20070OPCODE(0x5AC0)
20071{
20072 u32 adr, res;
20073 u32 src, dst;
20074
20075 if (!(flag_N & 0x80))
20076 {
20077 res = 0xFF;
20078 DREGu8((Opcode >> 0) & 7) = res;
20079 RET(6)
20080 }
20081 res = 0;
20082 DREGu8((Opcode >> 0) & 7) = res;
20083 RET(4)
20084}
20085
20086// STCC
20087OPCODE(0x5BC0)
20088{
20089 u32 adr, res;
20090 u32 src, dst;
20091
20092 if (flag_N & 0x80)
20093 {
20094 res = 0xFF;
20095 DREGu8((Opcode >> 0) & 7) = res;
20096 RET(6)
20097 }
20098 res = 0;
20099 DREGu8((Opcode >> 0) & 7) = res;
20100 RET(4)
20101}
20102
20103// STCC
20104OPCODE(0x5CC0)
20105{
20106 u32 adr, res;
20107 u32 src, dst;
20108
20109 if (!((flag_N ^ flag_V) & 0x80))
20110 {
20111 res = 0xFF;
20112 DREGu8((Opcode >> 0) & 7) = res;
20113 RET(6)
20114 }
20115 res = 0;
20116 DREGu8((Opcode >> 0) & 7) = res;
20117 RET(4)
20118}
20119
20120// STCC
20121OPCODE(0x5DC0)
20122{
20123 u32 adr, res;
20124 u32 src, dst;
20125
20126 if ((flag_N ^ flag_V) & 0x80)
20127 {
20128 res = 0xFF;
20129 DREGu8((Opcode >> 0) & 7) = res;
20130 RET(6)
20131 }
20132 res = 0;
20133 DREGu8((Opcode >> 0) & 7) = res;
20134 RET(4)
20135}
20136
20137// STCC
20138OPCODE(0x5EC0)
20139{
20140 u32 adr, res;
20141 u32 src, dst;
20142
20143 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20144 {
20145 res = 0xFF;
20146 DREGu8((Opcode >> 0) & 7) = res;
20147 RET(6)
20148 }
20149 res = 0;
20150 DREGu8((Opcode >> 0) & 7) = res;
20151 RET(4)
20152}
20153
20154// STCC
20155OPCODE(0x5FC0)
20156{
20157 u32 adr, res;
20158 u32 src, dst;
20159
20160 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20161 {
20162 res = 0xFF;
20163 DREGu8((Opcode >> 0) & 7) = res;
20164 RET(6)
20165 }
20166 res = 0;
20167 DREGu8((Opcode >> 0) & 7) = res;
20168 RET(4)
20169}
20170
20171// STCC
20172OPCODE(0x50D0)
20173{
20174 u32 adr, res;
20175 u32 src, dst;
20176
20177 adr = AREG((Opcode >> 0) & 7);
20178 res = 0xFF;
20179 PRE_IO
20180 WRITE_BYTE_F(adr, res)
20181 POST_IO
20182 RET(12)
20183}
20184
20185// STCC
20186OPCODE(0x51D0)
20187{
20188 u32 adr, res;
20189 u32 src, dst;
20190
20191 adr = AREG((Opcode >> 0) & 7);
20192 res = 0;
20193 PRE_IO
20194 WRITE_BYTE_F(adr, res)
20195 POST_IO
20196 RET(12)
20197}
20198
20199// STCC
20200OPCODE(0x52D0)
20201{
20202 u32 adr, res;
20203 u32 src, dst;
20204
20205 adr = AREG((Opcode >> 0) & 7);
20206 if (flag_NotZ && (!(flag_C & 0x100)))
20207 {
20208 res = 0xFF;
20209 PRE_IO
20210 WRITE_BYTE_F(adr, res)
20211 POST_IO
20212 RET(12)
20213 }
20214 res = 0;
20215 PRE_IO
20216 WRITE_BYTE_F(adr, res)
20217 POST_IO
20218 RET(12)
20219}
20220
20221// STCC
20222OPCODE(0x53D0)
20223{
20224 u32 adr, res;
20225 u32 src, dst;
20226
20227 adr = AREG((Opcode >> 0) & 7);
20228 if ((!flag_NotZ) || (flag_C & 0x100))
20229 {
20230 res = 0xFF;
20231 PRE_IO
20232 WRITE_BYTE_F(adr, res)
20233 POST_IO
20234 RET(12)
20235 }
20236 res = 0;
20237 PRE_IO
20238 WRITE_BYTE_F(adr, res)
20239 POST_IO
20240 RET(12)
20241}
20242
20243// STCC
20244OPCODE(0x54D0)
20245{
20246 u32 adr, res;
20247 u32 src, dst;
20248
20249 adr = AREG((Opcode >> 0) & 7);
20250 if (!(flag_C & 0x100))
20251 {
20252 res = 0xFF;
20253 PRE_IO
20254 WRITE_BYTE_F(adr, res)
20255 POST_IO
20256 RET(12)
20257 }
20258 res = 0;
20259 PRE_IO
20260 WRITE_BYTE_F(adr, res)
20261 POST_IO
20262 RET(12)
20263}
20264
20265// STCC
20266OPCODE(0x55D0)
20267{
20268 u32 adr, res;
20269 u32 src, dst;
20270
20271 adr = AREG((Opcode >> 0) & 7);
20272 if (flag_C & 0x100)
20273 {
20274 res = 0xFF;
20275 PRE_IO
20276 WRITE_BYTE_F(adr, res)
20277 POST_IO
20278 RET(12)
20279 }
20280 res = 0;
20281 PRE_IO
20282 WRITE_BYTE_F(adr, res)
20283 POST_IO
20284 RET(12)
20285}
20286
20287// STCC
20288OPCODE(0x56D0)
20289{
20290 u32 adr, res;
20291 u32 src, dst;
20292
20293 adr = AREG((Opcode >> 0) & 7);
20294 if (flag_NotZ)
20295 {
20296 res = 0xFF;
20297 PRE_IO
20298 WRITE_BYTE_F(adr, res)
20299 POST_IO
20300 RET(12)
20301 }
20302 res = 0;
20303 PRE_IO
20304 WRITE_BYTE_F(adr, res)
20305 POST_IO
20306 RET(12)
20307}
20308
20309// STCC
20310OPCODE(0x57D0)
20311{
20312 u32 adr, res;
20313 u32 src, dst;
20314
20315 adr = AREG((Opcode >> 0) & 7);
20316 if (!flag_NotZ)
20317 {
20318 res = 0xFF;
20319 PRE_IO
20320 WRITE_BYTE_F(adr, res)
20321 POST_IO
20322 RET(12)
20323 }
20324 res = 0;
20325 PRE_IO
20326 WRITE_BYTE_F(adr, res)
20327 POST_IO
20328 RET(12)
20329}
20330
20331// STCC
20332OPCODE(0x58D0)
20333{
20334 u32 adr, res;
20335 u32 src, dst;
20336
20337 adr = AREG((Opcode >> 0) & 7);
20338 if (!(flag_V & 0x80))
20339 {
20340 res = 0xFF;
20341 PRE_IO
20342 WRITE_BYTE_F(adr, res)
20343 POST_IO
20344 RET(12)
20345 }
20346 res = 0;
20347 PRE_IO
20348 WRITE_BYTE_F(adr, res)
20349 POST_IO
20350 RET(12)
20351}
20352
20353// STCC
20354OPCODE(0x59D0)
20355{
20356 u32 adr, res;
20357 u32 src, dst;
20358
20359 adr = AREG((Opcode >> 0) & 7);
20360 if (flag_V & 0x80)
20361 {
20362 res = 0xFF;
20363 PRE_IO
20364 WRITE_BYTE_F(adr, res)
20365 POST_IO
20366 RET(12)
20367 }
20368 res = 0;
20369 PRE_IO
20370 WRITE_BYTE_F(adr, res)
20371 POST_IO
20372 RET(12)
20373}
20374
20375// STCC
20376OPCODE(0x5AD0)
20377{
20378 u32 adr, res;
20379 u32 src, dst;
20380
20381 adr = AREG((Opcode >> 0) & 7);
20382 if (!(flag_N & 0x80))
20383 {
20384 res = 0xFF;
20385 PRE_IO
20386 WRITE_BYTE_F(adr, res)
20387 POST_IO
20388 RET(12)
20389 }
20390 res = 0;
20391 PRE_IO
20392 WRITE_BYTE_F(adr, res)
20393 POST_IO
20394 RET(12)
20395}
20396
20397// STCC
20398OPCODE(0x5BD0)
20399{
20400 u32 adr, res;
20401 u32 src, dst;
20402
20403 adr = AREG((Opcode >> 0) & 7);
20404 if (flag_N & 0x80)
20405 {
20406 res = 0xFF;
20407 PRE_IO
20408 WRITE_BYTE_F(adr, res)
20409 POST_IO
20410 RET(12)
20411 }
20412 res = 0;
20413 PRE_IO
20414 WRITE_BYTE_F(adr, res)
20415 POST_IO
20416 RET(12)
20417}
20418
20419// STCC
20420OPCODE(0x5CD0)
20421{
20422 u32 adr, res;
20423 u32 src, dst;
20424
20425 adr = AREG((Opcode >> 0) & 7);
20426 if (!((flag_N ^ flag_V) & 0x80))
20427 {
20428 res = 0xFF;
20429 PRE_IO
20430 WRITE_BYTE_F(adr, res)
20431 POST_IO
20432 RET(12)
20433 }
20434 res = 0;
20435 PRE_IO
20436 WRITE_BYTE_F(adr, res)
20437 POST_IO
20438 RET(12)
20439}
20440
20441// STCC
20442OPCODE(0x5DD0)
20443{
20444 u32 adr, res;
20445 u32 src, dst;
20446
20447 adr = AREG((Opcode >> 0) & 7);
20448 if ((flag_N ^ flag_V) & 0x80)
20449 {
20450 res = 0xFF;
20451 PRE_IO
20452 WRITE_BYTE_F(adr, res)
20453 POST_IO
20454 RET(12)
20455 }
20456 res = 0;
20457 PRE_IO
20458 WRITE_BYTE_F(adr, res)
20459 POST_IO
20460 RET(12)
20461}
20462
20463// STCC
20464OPCODE(0x5ED0)
20465{
20466 u32 adr, res;
20467 u32 src, dst;
20468
20469 adr = AREG((Opcode >> 0) & 7);
20470 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20471 {
20472 res = 0xFF;
20473 PRE_IO
20474 WRITE_BYTE_F(adr, res)
20475 POST_IO
20476 RET(12)
20477 }
20478 res = 0;
20479 PRE_IO
20480 WRITE_BYTE_F(adr, res)
20481 POST_IO
20482 RET(12)
20483}
20484
20485// STCC
20486OPCODE(0x5FD0)
20487{
20488 u32 adr, res;
20489 u32 src, dst;
20490
20491 adr = AREG((Opcode >> 0) & 7);
20492 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20493 {
20494 res = 0xFF;
20495 PRE_IO
20496 WRITE_BYTE_F(adr, res)
20497 POST_IO
20498 RET(12)
20499 }
20500 res = 0;
20501 PRE_IO
20502 WRITE_BYTE_F(adr, res)
20503 POST_IO
20504 RET(12)
20505}
20506
20507// STCC
20508OPCODE(0x50D8)
20509{
20510 u32 adr, res;
20511 u32 src, dst;
20512
20513 adr = AREG((Opcode >> 0) & 7);
20514 AREG((Opcode >> 0) & 7) += 1;
20515 res = 0xFF;
20516 PRE_IO
20517 WRITE_BYTE_F(adr, res)
20518 POST_IO
20519 RET(12)
20520}
20521
20522// STCC
20523OPCODE(0x51D8)
20524{
20525 u32 adr, res;
20526 u32 src, dst;
20527
20528 adr = AREG((Opcode >> 0) & 7);
20529 AREG((Opcode >> 0) & 7) += 1;
20530 res = 0;
20531 PRE_IO
20532 WRITE_BYTE_F(adr, res)
20533 POST_IO
20534 RET(12)
20535}
20536
20537// STCC
20538OPCODE(0x52D8)
20539{
20540 u32 adr, res;
20541 u32 src, dst;
20542
20543 adr = AREG((Opcode >> 0) & 7);
20544 AREG((Opcode >> 0) & 7) += 1;
20545 if (flag_NotZ && (!(flag_C & 0x100)))
20546 {
20547 res = 0xFF;
20548 PRE_IO
20549 WRITE_BYTE_F(adr, res)
20550 POST_IO
20551 RET(12)
20552 }
20553 res = 0;
20554 PRE_IO
20555 WRITE_BYTE_F(adr, res)
20556 POST_IO
20557 RET(12)
20558}
20559
20560// STCC
20561OPCODE(0x53D8)
20562{
20563 u32 adr, res;
20564 u32 src, dst;
20565
20566 adr = AREG((Opcode >> 0) & 7);
20567 AREG((Opcode >> 0) & 7) += 1;
20568 if ((!flag_NotZ) || (flag_C & 0x100))
20569 {
20570 res = 0xFF;
20571 PRE_IO
20572 WRITE_BYTE_F(adr, res)
20573 POST_IO
20574 RET(12)
20575 }
20576 res = 0;
20577 PRE_IO
20578 WRITE_BYTE_F(adr, res)
20579 POST_IO
20580 RET(12)
20581}
20582
20583// STCC
20584OPCODE(0x54D8)
20585{
20586 u32 adr, res;
20587 u32 src, dst;
20588
20589 adr = AREG((Opcode >> 0) & 7);
20590 AREG((Opcode >> 0) & 7) += 1;
20591 if (!(flag_C & 0x100))
20592 {
20593 res = 0xFF;
20594 PRE_IO
20595 WRITE_BYTE_F(adr, res)
20596 POST_IO
20597 RET(12)
20598 }
20599 res = 0;
20600 PRE_IO
20601 WRITE_BYTE_F(adr, res)
20602 POST_IO
20603 RET(12)
20604}
20605
20606// STCC
20607OPCODE(0x55D8)
20608{
20609 u32 adr, res;
20610 u32 src, dst;
20611
20612 adr = AREG((Opcode >> 0) & 7);
20613 AREG((Opcode >> 0) & 7) += 1;
20614 if (flag_C & 0x100)
20615 {
20616 res = 0xFF;
20617 PRE_IO
20618 WRITE_BYTE_F(adr, res)
20619 POST_IO
20620 RET(12)
20621 }
20622 res = 0;
20623 PRE_IO
20624 WRITE_BYTE_F(adr, res)
20625 POST_IO
20626 RET(12)
20627}
20628
20629// STCC
20630OPCODE(0x56D8)
20631{
20632 u32 adr, res;
20633 u32 src, dst;
20634
20635 adr = AREG((Opcode >> 0) & 7);
20636 AREG((Opcode >> 0) & 7) += 1;
20637 if (flag_NotZ)
20638 {
20639 res = 0xFF;
20640 PRE_IO
20641 WRITE_BYTE_F(adr, res)
20642 POST_IO
20643 RET(12)
20644 }
20645 res = 0;
20646 PRE_IO
20647 WRITE_BYTE_F(adr, res)
20648 POST_IO
20649 RET(12)
20650}
20651
20652// STCC
20653OPCODE(0x57D8)
20654{
20655 u32 adr, res;
20656 u32 src, dst;
20657
20658 adr = AREG((Opcode >> 0) & 7);
20659 AREG((Opcode >> 0) & 7) += 1;
20660 if (!flag_NotZ)
20661 {
20662 res = 0xFF;
20663 PRE_IO
20664 WRITE_BYTE_F(adr, res)
20665 POST_IO
20666 RET(12)
20667 }
20668 res = 0;
20669 PRE_IO
20670 WRITE_BYTE_F(adr, res)
20671 POST_IO
20672 RET(12)
20673}
20674
20675// STCC
20676OPCODE(0x58D8)
20677{
20678 u32 adr, res;
20679 u32 src, dst;
20680
20681 adr = AREG((Opcode >> 0) & 7);
20682 AREG((Opcode >> 0) & 7) += 1;
20683 if (!(flag_V & 0x80))
20684 {
20685 res = 0xFF;
20686 PRE_IO
20687 WRITE_BYTE_F(adr, res)
20688 POST_IO
20689 RET(12)
20690 }
20691 res = 0;
20692 PRE_IO
20693 WRITE_BYTE_F(adr, res)
20694 POST_IO
20695 RET(12)
20696}
20697
20698// STCC
20699OPCODE(0x59D8)
20700{
20701 u32 adr, res;
20702 u32 src, dst;
20703
20704 adr = AREG((Opcode >> 0) & 7);
20705 AREG((Opcode >> 0) & 7) += 1;
20706 if (flag_V & 0x80)
20707 {
20708 res = 0xFF;
20709 PRE_IO
20710 WRITE_BYTE_F(adr, res)
20711 POST_IO
20712 RET(12)
20713 }
20714 res = 0;
20715 PRE_IO
20716 WRITE_BYTE_F(adr, res)
20717 POST_IO
20718 RET(12)
20719}
20720
20721// STCC
20722OPCODE(0x5AD8)
20723{
20724 u32 adr, res;
20725 u32 src, dst;
20726
20727 adr = AREG((Opcode >> 0) & 7);
20728 AREG((Opcode >> 0) & 7) += 1;
20729 if (!(flag_N & 0x80))
20730 {
20731 res = 0xFF;
20732 PRE_IO
20733 WRITE_BYTE_F(adr, res)
20734 POST_IO
20735 RET(12)
20736 }
20737 res = 0;
20738 PRE_IO
20739 WRITE_BYTE_F(adr, res)
20740 POST_IO
20741 RET(12)
20742}
20743
20744// STCC
20745OPCODE(0x5BD8)
20746{
20747 u32 adr, res;
20748 u32 src, dst;
20749
20750 adr = AREG((Opcode >> 0) & 7);
20751 AREG((Opcode >> 0) & 7) += 1;
20752 if (flag_N & 0x80)
20753 {
20754 res = 0xFF;
20755 PRE_IO
20756 WRITE_BYTE_F(adr, res)
20757 POST_IO
20758 RET(12)
20759 }
20760 res = 0;
20761 PRE_IO
20762 WRITE_BYTE_F(adr, res)
20763 POST_IO
20764 RET(12)
20765}
20766
20767// STCC
20768OPCODE(0x5CD8)
20769{
20770 u32 adr, res;
20771 u32 src, dst;
20772
20773 adr = AREG((Opcode >> 0) & 7);
20774 AREG((Opcode >> 0) & 7) += 1;
20775 if (!((flag_N ^ flag_V) & 0x80))
20776 {
20777 res = 0xFF;
20778 PRE_IO
20779 WRITE_BYTE_F(adr, res)
20780 POST_IO
20781 RET(12)
20782 }
20783 res = 0;
20784 PRE_IO
20785 WRITE_BYTE_F(adr, res)
20786 POST_IO
20787 RET(12)
20788}
20789
20790// STCC
20791OPCODE(0x5DD8)
20792{
20793 u32 adr, res;
20794 u32 src, dst;
20795
20796 adr = AREG((Opcode >> 0) & 7);
20797 AREG((Opcode >> 0) & 7) += 1;
20798 if ((flag_N ^ flag_V) & 0x80)
20799 {
20800 res = 0xFF;
20801 PRE_IO
20802 WRITE_BYTE_F(adr, res)
20803 POST_IO
20804 RET(12)
20805 }
20806 res = 0;
20807 PRE_IO
20808 WRITE_BYTE_F(adr, res)
20809 POST_IO
20810 RET(12)
20811}
20812
20813// STCC
20814OPCODE(0x5ED8)
20815{
20816 u32 adr, res;
20817 u32 src, dst;
20818
20819 adr = AREG((Opcode >> 0) & 7);
20820 AREG((Opcode >> 0) & 7) += 1;
20821 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
20822 {
20823 res = 0xFF;
20824 PRE_IO
20825 WRITE_BYTE_F(adr, res)
20826 POST_IO
20827 RET(12)
20828 }
20829 res = 0;
20830 PRE_IO
20831 WRITE_BYTE_F(adr, res)
20832 POST_IO
20833 RET(12)
20834}
20835
20836// STCC
20837OPCODE(0x5FD8)
20838{
20839 u32 adr, res;
20840 u32 src, dst;
20841
20842 adr = AREG((Opcode >> 0) & 7);
20843 AREG((Opcode >> 0) & 7) += 1;
20844 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
20845 {
20846 res = 0xFF;
20847 PRE_IO
20848 WRITE_BYTE_F(adr, res)
20849 POST_IO
20850 RET(12)
20851 }
20852 res = 0;
20853 PRE_IO
20854 WRITE_BYTE_F(adr, res)
20855 POST_IO
20856 RET(12)
20857}
20858
20859// STCC
20860OPCODE(0x50E0)
20861{
20862 u32 adr, res;
20863 u32 src, dst;
20864
20865 adr = AREG((Opcode >> 0) & 7) - 1;
20866 AREG((Opcode >> 0) & 7) = adr;
20867 res = 0xFF;
20868 PRE_IO
20869 WRITE_BYTE_F(adr, res)
20870 POST_IO
20871 RET(14)
20872}
20873
20874// STCC
20875OPCODE(0x51E0)
20876{
20877 u32 adr, res;
20878 u32 src, dst;
20879
20880 adr = AREG((Opcode >> 0) & 7) - 1;
20881 AREG((Opcode >> 0) & 7) = adr;
20882 res = 0;
20883 PRE_IO
20884 WRITE_BYTE_F(adr, res)
20885 POST_IO
20886 RET(14)
20887}
20888
20889// STCC
20890OPCODE(0x52E0)
20891{
20892 u32 adr, res;
20893 u32 src, dst;
20894
20895 adr = AREG((Opcode >> 0) & 7) - 1;
20896 AREG((Opcode >> 0) & 7) = adr;
20897 if (flag_NotZ && (!(flag_C & 0x100)))
20898 {
20899 res = 0xFF;
20900 PRE_IO
20901 WRITE_BYTE_F(adr, res)
20902 POST_IO
20903 RET(14)
20904 }
20905 res = 0;
20906 PRE_IO
20907 WRITE_BYTE_F(adr, res)
20908 POST_IO
20909 RET(14)
20910}
20911
20912// STCC
20913OPCODE(0x53E0)
20914{
20915 u32 adr, res;
20916 u32 src, dst;
20917
20918 adr = AREG((Opcode >> 0) & 7) - 1;
20919 AREG((Opcode >> 0) & 7) = adr;
20920 if ((!flag_NotZ) || (flag_C & 0x100))
20921 {
20922 res = 0xFF;
20923 PRE_IO
20924 WRITE_BYTE_F(adr, res)
20925 POST_IO
20926 RET(14)
20927 }
20928 res = 0;
20929 PRE_IO
20930 WRITE_BYTE_F(adr, res)
20931 POST_IO
20932 RET(14)
20933}
20934
20935// STCC
20936OPCODE(0x54E0)
20937{
20938 u32 adr, res;
20939 u32 src, dst;
20940
20941 adr = AREG((Opcode >> 0) & 7) - 1;
20942 AREG((Opcode >> 0) & 7) = adr;
20943 if (!(flag_C & 0x100))
20944 {
20945 res = 0xFF;
20946 PRE_IO
20947 WRITE_BYTE_F(adr, res)
20948 POST_IO
20949 RET(14)
20950 }
20951 res = 0;
20952 PRE_IO
20953 WRITE_BYTE_F(adr, res)
20954 POST_IO
20955 RET(14)
20956}
20957
20958// STCC
20959OPCODE(0x55E0)
20960{
20961 u32 adr, res;
20962 u32 src, dst;
20963
20964 adr = AREG((Opcode >> 0) & 7) - 1;
20965 AREG((Opcode >> 0) & 7) = adr;
20966 if (flag_C & 0x100)
20967 {
20968 res = 0xFF;
20969 PRE_IO
20970 WRITE_BYTE_F(adr, res)
20971 POST_IO
20972 RET(14)
20973 }
20974 res = 0;
20975 PRE_IO
20976 WRITE_BYTE_F(adr, res)
20977 POST_IO
20978 RET(14)
20979}
20980
20981// STCC
20982OPCODE(0x56E0)
20983{
20984 u32 adr, res;
20985 u32 src, dst;
20986
20987 adr = AREG((Opcode >> 0) & 7) - 1;
20988 AREG((Opcode >> 0) & 7) = adr;
20989 if (flag_NotZ)
20990 {
20991 res = 0xFF;
20992 PRE_IO
20993 WRITE_BYTE_F(adr, res)
20994 POST_IO
20995 RET(14)
20996 }
20997 res = 0;
20998 PRE_IO
20999 WRITE_BYTE_F(adr, res)
21000 POST_IO
21001 RET(14)
21002}
21003
21004// STCC
21005OPCODE(0x57E0)
21006{
21007 u32 adr, res;
21008 u32 src, dst;
21009
21010 adr = AREG((Opcode >> 0) & 7) - 1;
21011 AREG((Opcode >> 0) & 7) = adr;
21012 if (!flag_NotZ)
21013 {
21014 res = 0xFF;
21015 PRE_IO
21016 WRITE_BYTE_F(adr, res)
21017 POST_IO
21018 RET(14)
21019 }
21020 res = 0;
21021 PRE_IO
21022 WRITE_BYTE_F(adr, res)
21023 POST_IO
21024 RET(14)
21025}
21026
21027// STCC
21028OPCODE(0x58E0)
21029{
21030 u32 adr, res;
21031 u32 src, dst;
21032
21033 adr = AREG((Opcode >> 0) & 7) - 1;
21034 AREG((Opcode >> 0) & 7) = adr;
21035 if (!(flag_V & 0x80))
21036 {
21037 res = 0xFF;
21038 PRE_IO
21039 WRITE_BYTE_F(adr, res)
21040 POST_IO
21041 RET(14)
21042 }
21043 res = 0;
21044 PRE_IO
21045 WRITE_BYTE_F(adr, res)
21046 POST_IO
21047 RET(14)
21048}
21049
21050// STCC
21051OPCODE(0x59E0)
21052{
21053 u32 adr, res;
21054 u32 src, dst;
21055
21056 adr = AREG((Opcode >> 0) & 7) - 1;
21057 AREG((Opcode >> 0) & 7) = adr;
21058 if (flag_V & 0x80)
21059 {
21060 res = 0xFF;
21061 PRE_IO
21062 WRITE_BYTE_F(adr, res)
21063 POST_IO
21064 RET(14)
21065 }
21066 res = 0;
21067 PRE_IO
21068 WRITE_BYTE_F(adr, res)
21069 POST_IO
21070 RET(14)
21071}
21072
21073// STCC
21074OPCODE(0x5AE0)
21075{
21076 u32 adr, res;
21077 u32 src, dst;
21078
21079 adr = AREG((Opcode >> 0) & 7) - 1;
21080 AREG((Opcode >> 0) & 7) = adr;
21081 if (!(flag_N & 0x80))
21082 {
21083 res = 0xFF;
21084 PRE_IO
21085 WRITE_BYTE_F(adr, res)
21086 POST_IO
21087 RET(14)
21088 }
21089 res = 0;
21090 PRE_IO
21091 WRITE_BYTE_F(adr, res)
21092 POST_IO
21093 RET(14)
21094}
21095
21096// STCC
21097OPCODE(0x5BE0)
21098{
21099 u32 adr, res;
21100 u32 src, dst;
21101
21102 adr = AREG((Opcode >> 0) & 7) - 1;
21103 AREG((Opcode >> 0) & 7) = adr;
21104 if (flag_N & 0x80)
21105 {
21106 res = 0xFF;
21107 PRE_IO
21108 WRITE_BYTE_F(adr, res)
21109 POST_IO
21110 RET(14)
21111 }
21112 res = 0;
21113 PRE_IO
21114 WRITE_BYTE_F(adr, res)
21115 POST_IO
21116 RET(14)
21117}
21118
21119// STCC
21120OPCODE(0x5CE0)
21121{
21122 u32 adr, res;
21123 u32 src, dst;
21124
21125 adr = AREG((Opcode >> 0) & 7) - 1;
21126 AREG((Opcode >> 0) & 7) = adr;
21127 if (!((flag_N ^ flag_V) & 0x80))
21128 {
21129 res = 0xFF;
21130 PRE_IO
21131 WRITE_BYTE_F(adr, res)
21132 POST_IO
21133 RET(14)
21134 }
21135 res = 0;
21136 PRE_IO
21137 WRITE_BYTE_F(adr, res)
21138 POST_IO
21139 RET(14)
21140}
21141
21142// STCC
21143OPCODE(0x5DE0)
21144{
21145 u32 adr, res;
21146 u32 src, dst;
21147
21148 adr = AREG((Opcode >> 0) & 7) - 1;
21149 AREG((Opcode >> 0) & 7) = adr;
21150 if ((flag_N ^ flag_V) & 0x80)
21151 {
21152 res = 0xFF;
21153 PRE_IO
21154 WRITE_BYTE_F(adr, res)
21155 POST_IO
21156 RET(14)
21157 }
21158 res = 0;
21159 PRE_IO
21160 WRITE_BYTE_F(adr, res)
21161 POST_IO
21162 RET(14)
21163}
21164
21165// STCC
21166OPCODE(0x5EE0)
21167{
21168 u32 adr, res;
21169 u32 src, dst;
21170
21171 adr = AREG((Opcode >> 0) & 7) - 1;
21172 AREG((Opcode >> 0) & 7) = adr;
21173 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21174 {
21175 res = 0xFF;
21176 PRE_IO
21177 WRITE_BYTE_F(adr, res)
21178 POST_IO
21179 RET(14)
21180 }
21181 res = 0;
21182 PRE_IO
21183 WRITE_BYTE_F(adr, res)
21184 POST_IO
21185 RET(14)
21186}
21187
21188// STCC
21189OPCODE(0x5FE0)
21190{
21191 u32 adr, res;
21192 u32 src, dst;
21193
21194 adr = AREG((Opcode >> 0) & 7) - 1;
21195 AREG((Opcode >> 0) & 7) = adr;
21196 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21197 {
21198 res = 0xFF;
21199 PRE_IO
21200 WRITE_BYTE_F(adr, res)
21201 POST_IO
21202 RET(14)
21203 }
21204 res = 0;
21205 PRE_IO
21206 WRITE_BYTE_F(adr, res)
21207 POST_IO
21208 RET(14)
21209}
21210
21211// STCC
21212OPCODE(0x50E8)
21213{
21214 u32 adr, res;
21215 u32 src, dst;
21216
21217 FETCH_SWORD(adr);
21218 adr += AREG((Opcode >> 0) & 7);
21219 res = 0xFF;
21220 PRE_IO
21221 WRITE_BYTE_F(adr, res)
21222 POST_IO
21223 RET(16)
21224}
21225
21226// STCC
21227OPCODE(0x51E8)
21228{
21229 u32 adr, res;
21230 u32 src, dst;
21231
21232 FETCH_SWORD(adr);
21233 adr += AREG((Opcode >> 0) & 7);
21234 res = 0;
21235 PRE_IO
21236 WRITE_BYTE_F(adr, res)
21237 POST_IO
21238 RET(16)
21239}
21240
21241// STCC
21242OPCODE(0x52E8)
21243{
21244 u32 adr, res;
21245 u32 src, dst;
21246
21247 FETCH_SWORD(adr);
21248 adr += AREG((Opcode >> 0) & 7);
21249 if (flag_NotZ && (!(flag_C & 0x100)))
21250 {
21251 res = 0xFF;
21252 PRE_IO
21253 WRITE_BYTE_F(adr, res)
21254 POST_IO
21255 RET(16)
21256 }
21257 res = 0;
21258 PRE_IO
21259 WRITE_BYTE_F(adr, res)
21260 POST_IO
21261 RET(16)
21262}
21263
21264// STCC
21265OPCODE(0x53E8)
21266{
21267 u32 adr, res;
21268 u32 src, dst;
21269
21270 FETCH_SWORD(adr);
21271 adr += AREG((Opcode >> 0) & 7);
21272 if ((!flag_NotZ) || (flag_C & 0x100))
21273 {
21274 res = 0xFF;
21275 PRE_IO
21276 WRITE_BYTE_F(adr, res)
21277 POST_IO
21278 RET(16)
21279 }
21280 res = 0;
21281 PRE_IO
21282 WRITE_BYTE_F(adr, res)
21283 POST_IO
21284 RET(16)
21285}
21286
21287// STCC
21288OPCODE(0x54E8)
21289{
21290 u32 adr, res;
21291 u32 src, dst;
21292
21293 FETCH_SWORD(adr);
21294 adr += AREG((Opcode >> 0) & 7);
21295 if (!(flag_C & 0x100))
21296 {
21297 res = 0xFF;
21298 PRE_IO
21299 WRITE_BYTE_F(adr, res)
21300 POST_IO
21301 RET(16)
21302 }
21303 res = 0;
21304 PRE_IO
21305 WRITE_BYTE_F(adr, res)
21306 POST_IO
21307 RET(16)
21308}
21309
21310// STCC
21311OPCODE(0x55E8)
21312{
21313 u32 adr, res;
21314 u32 src, dst;
21315
21316 FETCH_SWORD(adr);
21317 adr += AREG((Opcode >> 0) & 7);
21318 if (flag_C & 0x100)
21319 {
21320 res = 0xFF;
21321 PRE_IO
21322 WRITE_BYTE_F(adr, res)
21323 POST_IO
21324 RET(16)
21325 }
21326 res = 0;
21327 PRE_IO
21328 WRITE_BYTE_F(adr, res)
21329 POST_IO
21330 RET(16)
21331}
21332
21333// STCC
21334OPCODE(0x56E8)
21335{
21336 u32 adr, res;
21337 u32 src, dst;
21338
21339 FETCH_SWORD(adr);
21340 adr += AREG((Opcode >> 0) & 7);
21341 if (flag_NotZ)
21342 {
21343 res = 0xFF;
21344 PRE_IO
21345 WRITE_BYTE_F(adr, res)
21346 POST_IO
21347 RET(16)
21348 }
21349 res = 0;
21350 PRE_IO
21351 WRITE_BYTE_F(adr, res)
21352 POST_IO
21353 RET(16)
21354}
21355
21356// STCC
21357OPCODE(0x57E8)
21358{
21359 u32 adr, res;
21360 u32 src, dst;
21361
21362 FETCH_SWORD(adr);
21363 adr += AREG((Opcode >> 0) & 7);
21364 if (!flag_NotZ)
21365 {
21366 res = 0xFF;
21367 PRE_IO
21368 WRITE_BYTE_F(adr, res)
21369 POST_IO
21370 RET(16)
21371 }
21372 res = 0;
21373 PRE_IO
21374 WRITE_BYTE_F(adr, res)
21375 POST_IO
21376 RET(16)
21377}
21378
21379// STCC
21380OPCODE(0x58E8)
21381{
21382 u32 adr, res;
21383 u32 src, dst;
21384
21385 FETCH_SWORD(adr);
21386 adr += AREG((Opcode >> 0) & 7);
21387 if (!(flag_V & 0x80))
21388 {
21389 res = 0xFF;
21390 PRE_IO
21391 WRITE_BYTE_F(adr, res)
21392 POST_IO
21393 RET(16)
21394 }
21395 res = 0;
21396 PRE_IO
21397 WRITE_BYTE_F(adr, res)
21398 POST_IO
21399 RET(16)
21400}
21401
21402// STCC
21403OPCODE(0x59E8)
21404{
21405 u32 adr, res;
21406 u32 src, dst;
21407
21408 FETCH_SWORD(adr);
21409 adr += AREG((Opcode >> 0) & 7);
21410 if (flag_V & 0x80)
21411 {
21412 res = 0xFF;
21413 PRE_IO
21414 WRITE_BYTE_F(adr, res)
21415 POST_IO
21416 RET(16)
21417 }
21418 res = 0;
21419 PRE_IO
21420 WRITE_BYTE_F(adr, res)
21421 POST_IO
21422 RET(16)
21423}
21424
21425// STCC
21426OPCODE(0x5AE8)
21427{
21428 u32 adr, res;
21429 u32 src, dst;
21430
21431 FETCH_SWORD(adr);
21432 adr += AREG((Opcode >> 0) & 7);
21433 if (!(flag_N & 0x80))
21434 {
21435 res = 0xFF;
21436 PRE_IO
21437 WRITE_BYTE_F(adr, res)
21438 POST_IO
21439 RET(16)
21440 }
21441 res = 0;
21442 PRE_IO
21443 WRITE_BYTE_F(adr, res)
21444 POST_IO
21445 RET(16)
21446}
21447
21448// STCC
21449OPCODE(0x5BE8)
21450{
21451 u32 adr, res;
21452 u32 src, dst;
21453
21454 FETCH_SWORD(adr);
21455 adr += AREG((Opcode >> 0) & 7);
21456 if (flag_N & 0x80)
21457 {
21458 res = 0xFF;
21459 PRE_IO
21460 WRITE_BYTE_F(adr, res)
21461 POST_IO
21462 RET(16)
21463 }
21464 res = 0;
21465 PRE_IO
21466 WRITE_BYTE_F(adr, res)
21467 POST_IO
21468 RET(16)
21469}
21470
21471// STCC
21472OPCODE(0x5CE8)
21473{
21474 u32 adr, res;
21475 u32 src, dst;
21476
21477 FETCH_SWORD(adr);
21478 adr += AREG((Opcode >> 0) & 7);
21479 if (!((flag_N ^ flag_V) & 0x80))
21480 {
21481 res = 0xFF;
21482 PRE_IO
21483 WRITE_BYTE_F(adr, res)
21484 POST_IO
21485 RET(16)
21486 }
21487 res = 0;
21488 PRE_IO
21489 WRITE_BYTE_F(adr, res)
21490 POST_IO
21491 RET(16)
21492}
21493
21494// STCC
21495OPCODE(0x5DE8)
21496{
21497 u32 adr, res;
21498 u32 src, dst;
21499
21500 FETCH_SWORD(adr);
21501 adr += AREG((Opcode >> 0) & 7);
21502 if ((flag_N ^ flag_V) & 0x80)
21503 {
21504 res = 0xFF;
21505 PRE_IO
21506 WRITE_BYTE_F(adr, res)
21507 POST_IO
21508 RET(16)
21509 }
21510 res = 0;
21511 PRE_IO
21512 WRITE_BYTE_F(adr, res)
21513 POST_IO
21514 RET(16)
21515}
21516
21517// STCC
21518OPCODE(0x5EE8)
21519{
21520 u32 adr, res;
21521 u32 src, dst;
21522
21523 FETCH_SWORD(adr);
21524 adr += AREG((Opcode >> 0) & 7);
21525 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21526 {
21527 res = 0xFF;
21528 PRE_IO
21529 WRITE_BYTE_F(adr, res)
21530 POST_IO
21531 RET(16)
21532 }
21533 res = 0;
21534 PRE_IO
21535 WRITE_BYTE_F(adr, res)
21536 POST_IO
21537 RET(16)
21538}
21539
21540// STCC
21541OPCODE(0x5FE8)
21542{
21543 u32 adr, res;
21544 u32 src, dst;
21545
21546 FETCH_SWORD(adr);
21547 adr += AREG((Opcode >> 0) & 7);
21548 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21549 {
21550 res = 0xFF;
21551 PRE_IO
21552 WRITE_BYTE_F(adr, res)
21553 POST_IO
21554 RET(16)
21555 }
21556 res = 0;
21557 PRE_IO
21558 WRITE_BYTE_F(adr, res)
21559 POST_IO
21560 RET(16)
21561}
21562
21563// STCC
21564OPCODE(0x50F0)
21565{
21566 u32 adr, res;
21567 u32 src, dst;
21568
21569 adr = AREG((Opcode >> 0) & 7);
21570 DECODE_EXT_WORD
21571 res = 0xFF;
21572 PRE_IO
21573 WRITE_BYTE_F(adr, res)
21574 POST_IO
21575 RET(18)
21576}
21577
21578// STCC
21579OPCODE(0x51F0)
21580{
21581 u32 adr, res;
21582 u32 src, dst;
21583
21584 adr = AREG((Opcode >> 0) & 7);
21585 DECODE_EXT_WORD
21586 res = 0;
21587 PRE_IO
21588 WRITE_BYTE_F(adr, res)
21589 POST_IO
21590 RET(18)
21591}
21592
21593// STCC
21594OPCODE(0x52F0)
21595{
21596 u32 adr, res;
21597 u32 src, dst;
21598
21599 adr = AREG((Opcode >> 0) & 7);
21600 DECODE_EXT_WORD
21601 if (flag_NotZ && (!(flag_C & 0x100)))
21602 {
21603 res = 0xFF;
21604 PRE_IO
21605 WRITE_BYTE_F(adr, res)
21606 POST_IO
21607 RET(18)
21608 }
21609 res = 0;
21610 PRE_IO
21611 WRITE_BYTE_F(adr, res)
21612 POST_IO
21613 RET(18)
21614}
21615
21616// STCC
21617OPCODE(0x53F0)
21618{
21619 u32 adr, res;
21620 u32 src, dst;
21621
21622 adr = AREG((Opcode >> 0) & 7);
21623 DECODE_EXT_WORD
21624 if ((!flag_NotZ) || (flag_C & 0x100))
21625 {
21626 res = 0xFF;
21627 PRE_IO
21628 WRITE_BYTE_F(adr, res)
21629 POST_IO
21630 RET(18)
21631 }
21632 res = 0;
21633 PRE_IO
21634 WRITE_BYTE_F(adr, res)
21635 POST_IO
21636 RET(18)
21637}
21638
21639// STCC
21640OPCODE(0x54F0)
21641{
21642 u32 adr, res;
21643 u32 src, dst;
21644
21645 adr = AREG((Opcode >> 0) & 7);
21646 DECODE_EXT_WORD
21647 if (!(flag_C & 0x100))
21648 {
21649 res = 0xFF;
21650 PRE_IO
21651 WRITE_BYTE_F(adr, res)
21652 POST_IO
21653 RET(18)
21654 }
21655 res = 0;
21656 PRE_IO
21657 WRITE_BYTE_F(adr, res)
21658 POST_IO
21659 RET(18)
21660}
21661
21662// STCC
21663OPCODE(0x55F0)
21664{
21665 u32 adr, res;
21666 u32 src, dst;
21667
21668 adr = AREG((Opcode >> 0) & 7);
21669 DECODE_EXT_WORD
21670 if (flag_C & 0x100)
21671 {
21672 res = 0xFF;
21673 PRE_IO
21674 WRITE_BYTE_F(adr, res)
21675 POST_IO
21676 RET(18)
21677 }
21678 res = 0;
21679 PRE_IO
21680 WRITE_BYTE_F(adr, res)
21681 POST_IO
21682 RET(18)
21683}
21684
21685// STCC
21686OPCODE(0x56F0)
21687{
21688 u32 adr, res;
21689 u32 src, dst;
21690
21691 adr = AREG((Opcode >> 0) & 7);
21692 DECODE_EXT_WORD
21693 if (flag_NotZ)
21694 {
21695 res = 0xFF;
21696 PRE_IO
21697 WRITE_BYTE_F(adr, res)
21698 POST_IO
21699 RET(18)
21700 }
21701 res = 0;
21702 PRE_IO
21703 WRITE_BYTE_F(adr, res)
21704 POST_IO
21705 RET(18)
21706}
21707
21708// STCC
21709OPCODE(0x57F0)
21710{
21711 u32 adr, res;
21712 u32 src, dst;
21713
21714 adr = AREG((Opcode >> 0) & 7);
21715 DECODE_EXT_WORD
21716 if (!flag_NotZ)
21717 {
21718 res = 0xFF;
21719 PRE_IO
21720 WRITE_BYTE_F(adr, res)
21721 POST_IO
21722 RET(18)
21723 }
21724 res = 0;
21725 PRE_IO
21726 WRITE_BYTE_F(adr, res)
21727 POST_IO
21728 RET(18)
21729}
21730
21731// STCC
21732OPCODE(0x58F0)
21733{
21734 u32 adr, res;
21735 u32 src, dst;
21736
21737 adr = AREG((Opcode >> 0) & 7);
21738 DECODE_EXT_WORD
21739 if (!(flag_V & 0x80))
21740 {
21741 res = 0xFF;
21742 PRE_IO
21743 WRITE_BYTE_F(adr, res)
21744 POST_IO
21745 RET(18)
21746 }
21747 res = 0;
21748 PRE_IO
21749 WRITE_BYTE_F(adr, res)
21750 POST_IO
21751 RET(18)
21752}
21753
21754// STCC
21755OPCODE(0x59F0)
21756{
21757 u32 adr, res;
21758 u32 src, dst;
21759
21760 adr = AREG((Opcode >> 0) & 7);
21761 DECODE_EXT_WORD
21762 if (flag_V & 0x80)
21763 {
21764 res = 0xFF;
21765 PRE_IO
21766 WRITE_BYTE_F(adr, res)
21767 POST_IO
21768 RET(18)
21769 }
21770 res = 0;
21771 PRE_IO
21772 WRITE_BYTE_F(adr, res)
21773 POST_IO
21774 RET(18)
21775}
21776
21777// STCC
21778OPCODE(0x5AF0)
21779{
21780 u32 adr, res;
21781 u32 src, dst;
21782
21783 adr = AREG((Opcode >> 0) & 7);
21784 DECODE_EXT_WORD
21785 if (!(flag_N & 0x80))
21786 {
21787 res = 0xFF;
21788 PRE_IO
21789 WRITE_BYTE_F(adr, res)
21790 POST_IO
21791 RET(18)
21792 }
21793 res = 0;
21794 PRE_IO
21795 WRITE_BYTE_F(adr, res)
21796 POST_IO
21797 RET(18)
21798}
21799
21800// STCC
21801OPCODE(0x5BF0)
21802{
21803 u32 adr, res;
21804 u32 src, dst;
21805
21806 adr = AREG((Opcode >> 0) & 7);
21807 DECODE_EXT_WORD
21808 if (flag_N & 0x80)
21809 {
21810 res = 0xFF;
21811 PRE_IO
21812 WRITE_BYTE_F(adr, res)
21813 POST_IO
21814 RET(18)
21815 }
21816 res = 0;
21817 PRE_IO
21818 WRITE_BYTE_F(adr, res)
21819 POST_IO
21820 RET(18)
21821}
21822
21823// STCC
21824OPCODE(0x5CF0)
21825{
21826 u32 adr, res;
21827 u32 src, dst;
21828
21829 adr = AREG((Opcode >> 0) & 7);
21830 DECODE_EXT_WORD
21831 if (!((flag_N ^ flag_V) & 0x80))
21832 {
21833 res = 0xFF;
21834 PRE_IO
21835 WRITE_BYTE_F(adr, res)
21836 POST_IO
21837 RET(18)
21838 }
21839 res = 0;
21840 PRE_IO
21841 WRITE_BYTE_F(adr, res)
21842 POST_IO
21843 RET(18)
21844}
21845
21846// STCC
21847OPCODE(0x5DF0)
21848{
21849 u32 adr, res;
21850 u32 src, dst;
21851
21852 adr = AREG((Opcode >> 0) & 7);
21853 DECODE_EXT_WORD
21854 if ((flag_N ^ flag_V) & 0x80)
21855 {
21856 res = 0xFF;
21857 PRE_IO
21858 WRITE_BYTE_F(adr, res)
21859 POST_IO
21860 RET(18)
21861 }
21862 res = 0;
21863 PRE_IO
21864 WRITE_BYTE_F(adr, res)
21865 POST_IO
21866 RET(18)
21867}
21868
21869// STCC
21870OPCODE(0x5EF0)
21871{
21872 u32 adr, res;
21873 u32 src, dst;
21874
21875 adr = AREG((Opcode >> 0) & 7);
21876 DECODE_EXT_WORD
21877 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
21878 {
21879 res = 0xFF;
21880 PRE_IO
21881 WRITE_BYTE_F(adr, res)
21882 POST_IO
21883 RET(18)
21884 }
21885 res = 0;
21886 PRE_IO
21887 WRITE_BYTE_F(adr, res)
21888 POST_IO
21889 RET(18)
21890}
21891
21892// STCC
21893OPCODE(0x5FF0)
21894{
21895 u32 adr, res;
21896 u32 src, dst;
21897
21898 adr = AREG((Opcode >> 0) & 7);
21899 DECODE_EXT_WORD
21900 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
21901 {
21902 res = 0xFF;
21903 PRE_IO
21904 WRITE_BYTE_F(adr, res)
21905 POST_IO
21906 RET(18)
21907 }
21908 res = 0;
21909 PRE_IO
21910 WRITE_BYTE_F(adr, res)
21911 POST_IO
21912 RET(18)
21913}
21914
21915// STCC
21916OPCODE(0x50F8)
21917{
21918 u32 adr, res;
21919 u32 src, dst;
21920
21921 FETCH_SWORD(adr);
21922 res = 0xFF;
21923 PRE_IO
21924 WRITE_BYTE_F(adr, res)
21925 POST_IO
21926 RET(16)
21927}
21928
21929// STCC
21930OPCODE(0x51F8)
21931{
21932 u32 adr, res;
21933 u32 src, dst;
21934
21935 FETCH_SWORD(adr);
21936 res = 0;
21937 PRE_IO
21938 WRITE_BYTE_F(adr, res)
21939 POST_IO
21940 RET(16)
21941}
21942
21943// STCC
21944OPCODE(0x52F8)
21945{
21946 u32 adr, res;
21947 u32 src, dst;
21948
21949 FETCH_SWORD(adr);
21950 if (flag_NotZ && (!(flag_C & 0x100)))
21951 {
21952 res = 0xFF;
21953 PRE_IO
21954 WRITE_BYTE_F(adr, res)
21955 POST_IO
21956 RET(16)
21957 }
21958 res = 0;
21959 PRE_IO
21960 WRITE_BYTE_F(adr, res)
21961 POST_IO
21962 RET(16)
21963}
21964
21965// STCC
21966OPCODE(0x53F8)
21967{
21968 u32 adr, res;
21969 u32 src, dst;
21970
21971 FETCH_SWORD(adr);
21972 if ((!flag_NotZ) || (flag_C & 0x100))
21973 {
21974 res = 0xFF;
21975 PRE_IO
21976 WRITE_BYTE_F(adr, res)
21977 POST_IO
21978 RET(16)
21979 }
21980 res = 0;
21981 PRE_IO
21982 WRITE_BYTE_F(adr, res)
21983 POST_IO
21984 RET(16)
21985}
21986
21987// STCC
21988OPCODE(0x54F8)
21989{
21990 u32 adr, res;
21991 u32 src, dst;
21992
21993 FETCH_SWORD(adr);
21994 if (!(flag_C & 0x100))
21995 {
21996 res = 0xFF;
21997 PRE_IO
21998 WRITE_BYTE_F(adr, res)
21999 POST_IO
22000 RET(16)
22001 }
22002 res = 0;
22003 PRE_IO
22004 WRITE_BYTE_F(adr, res)
22005 POST_IO
22006 RET(16)
22007}
22008
22009// STCC
22010OPCODE(0x55F8)
22011{
22012 u32 adr, res;
22013 u32 src, dst;
22014
22015 FETCH_SWORD(adr);
22016 if (flag_C & 0x100)
22017 {
22018 res = 0xFF;
22019 PRE_IO
22020 WRITE_BYTE_F(adr, res)
22021 POST_IO
22022 RET(16)
22023 }
22024 res = 0;
22025 PRE_IO
22026 WRITE_BYTE_F(adr, res)
22027 POST_IO
22028 RET(16)
22029}
22030
22031// STCC
22032OPCODE(0x56F8)
22033{
22034 u32 adr, res;
22035 u32 src, dst;
22036
22037 FETCH_SWORD(adr);
22038 if (flag_NotZ)
22039 {
22040 res = 0xFF;
22041 PRE_IO
22042 WRITE_BYTE_F(adr, res)
22043 POST_IO
22044 RET(16)
22045 }
22046 res = 0;
22047 PRE_IO
22048 WRITE_BYTE_F(adr, res)
22049 POST_IO
22050 RET(16)
22051}
22052
22053// STCC
22054OPCODE(0x57F8)
22055{
22056 u32 adr, res;
22057 u32 src, dst;
22058
22059 FETCH_SWORD(adr);
22060 if (!flag_NotZ)
22061 {
22062 res = 0xFF;
22063 PRE_IO
22064 WRITE_BYTE_F(adr, res)
22065 POST_IO
22066 RET(16)
22067 }
22068 res = 0;
22069 PRE_IO
22070 WRITE_BYTE_F(adr, res)
22071 POST_IO
22072 RET(16)
22073}
22074
22075// STCC
22076OPCODE(0x58F8)
22077{
22078 u32 adr, res;
22079 u32 src, dst;
22080
22081 FETCH_SWORD(adr);
22082 if (!(flag_V & 0x80))
22083 {
22084 res = 0xFF;
22085 PRE_IO
22086 WRITE_BYTE_F(adr, res)
22087 POST_IO
22088 RET(16)
22089 }
22090 res = 0;
22091 PRE_IO
22092 WRITE_BYTE_F(adr, res)
22093 POST_IO
22094 RET(16)
22095}
22096
22097// STCC
22098OPCODE(0x59F8)
22099{
22100 u32 adr, res;
22101 u32 src, dst;
22102
22103 FETCH_SWORD(adr);
22104 if (flag_V & 0x80)
22105 {
22106 res = 0xFF;
22107 PRE_IO
22108 WRITE_BYTE_F(adr, res)
22109 POST_IO
22110 RET(16)
22111 }
22112 res = 0;
22113 PRE_IO
22114 WRITE_BYTE_F(adr, res)
22115 POST_IO
22116 RET(16)
22117}
22118
22119// STCC
22120OPCODE(0x5AF8)
22121{
22122 u32 adr, res;
22123 u32 src, dst;
22124
22125 FETCH_SWORD(adr);
22126 if (!(flag_N & 0x80))
22127 {
22128 res = 0xFF;
22129 PRE_IO
22130 WRITE_BYTE_F(adr, res)
22131 POST_IO
22132 RET(16)
22133 }
22134 res = 0;
22135 PRE_IO
22136 WRITE_BYTE_F(adr, res)
22137 POST_IO
22138 RET(16)
22139}
22140
22141// STCC
22142OPCODE(0x5BF8)
22143{
22144 u32 adr, res;
22145 u32 src, dst;
22146
22147 FETCH_SWORD(adr);
22148 if (flag_N & 0x80)
22149 {
22150 res = 0xFF;
22151 PRE_IO
22152 WRITE_BYTE_F(adr, res)
22153 POST_IO
22154 RET(16)
22155 }
22156 res = 0;
22157 PRE_IO
22158 WRITE_BYTE_F(adr, res)
22159 POST_IO
22160 RET(16)
22161}
22162
22163// STCC
22164OPCODE(0x5CF8)
22165{
22166 u32 adr, res;
22167 u32 src, dst;
22168
22169 FETCH_SWORD(adr);
22170 if (!((flag_N ^ flag_V) & 0x80))
22171 {
22172 res = 0xFF;
22173 PRE_IO
22174 WRITE_BYTE_F(adr, res)
22175 POST_IO
22176 RET(16)
22177 }
22178 res = 0;
22179 PRE_IO
22180 WRITE_BYTE_F(adr, res)
22181 POST_IO
22182 RET(16)
22183}
22184
22185// STCC
22186OPCODE(0x5DF8)
22187{
22188 u32 adr, res;
22189 u32 src, dst;
22190
22191 FETCH_SWORD(adr);
22192 if ((flag_N ^ flag_V) & 0x80)
22193 {
22194 res = 0xFF;
22195 PRE_IO
22196 WRITE_BYTE_F(adr, res)
22197 POST_IO
22198 RET(16)
22199 }
22200 res = 0;
22201 PRE_IO
22202 WRITE_BYTE_F(adr, res)
22203 POST_IO
22204 RET(16)
22205}
22206
22207// STCC
22208OPCODE(0x5EF8)
22209{
22210 u32 adr, res;
22211 u32 src, dst;
22212
22213 FETCH_SWORD(adr);
22214 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22215 {
22216 res = 0xFF;
22217 PRE_IO
22218 WRITE_BYTE_F(adr, res)
22219 POST_IO
22220 RET(16)
22221 }
22222 res = 0;
22223 PRE_IO
22224 WRITE_BYTE_F(adr, res)
22225 POST_IO
22226 RET(16)
22227}
22228
22229// STCC
22230OPCODE(0x5FF8)
22231{
22232 u32 adr, res;
22233 u32 src, dst;
22234
22235 FETCH_SWORD(adr);
22236 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22237 {
22238 res = 0xFF;
22239 PRE_IO
22240 WRITE_BYTE_F(adr, res)
22241 POST_IO
22242 RET(16)
22243 }
22244 res = 0;
22245 PRE_IO
22246 WRITE_BYTE_F(adr, res)
22247 POST_IO
22248 RET(16)
22249}
22250
22251// STCC
22252OPCODE(0x50F9)
22253{
22254 u32 adr, res;
22255 u32 src, dst;
22256
22257 FETCH_LONG(adr);
22258 res = 0xFF;
22259 PRE_IO
22260 WRITE_BYTE_F(adr, res)
22261 POST_IO
22262 RET(20)
22263}
22264
22265// STCC
22266OPCODE(0x51F9)
22267{
22268 u32 adr, res;
22269 u32 src, dst;
22270
22271 FETCH_LONG(adr);
22272 res = 0;
22273 PRE_IO
22274 WRITE_BYTE_F(adr, res)
22275 POST_IO
22276 RET(20)
22277}
22278
22279// STCC
22280OPCODE(0x52F9)
22281{
22282 u32 adr, res;
22283 u32 src, dst;
22284
22285 FETCH_LONG(adr);
22286 if (flag_NotZ && (!(flag_C & 0x100)))
22287 {
22288 res = 0xFF;
22289 PRE_IO
22290 WRITE_BYTE_F(adr, res)
22291 POST_IO
22292 RET(20)
22293 }
22294 res = 0;
22295 PRE_IO
22296 WRITE_BYTE_F(adr, res)
22297 POST_IO
22298 RET(20)
22299}
22300
22301// STCC
22302OPCODE(0x53F9)
22303{
22304 u32 adr, res;
22305 u32 src, dst;
22306
22307 FETCH_LONG(adr);
22308 if ((!flag_NotZ) || (flag_C & 0x100))
22309 {
22310 res = 0xFF;
22311 PRE_IO
22312 WRITE_BYTE_F(adr, res)
22313 POST_IO
22314 RET(20)
22315 }
22316 res = 0;
22317 PRE_IO
22318 WRITE_BYTE_F(adr, res)
22319 POST_IO
22320 RET(20)
22321}
22322
22323// STCC
22324OPCODE(0x54F9)
22325{
22326 u32 adr, res;
22327 u32 src, dst;
22328
22329 FETCH_LONG(adr);
22330 if (!(flag_C & 0x100))
22331 {
22332 res = 0xFF;
22333 PRE_IO
22334 WRITE_BYTE_F(adr, res)
22335 POST_IO
22336 RET(20)
22337 }
22338 res = 0;
22339 PRE_IO
22340 WRITE_BYTE_F(adr, res)
22341 POST_IO
22342 RET(20)
22343}
22344
22345// STCC
22346OPCODE(0x55F9)
22347{
22348 u32 adr, res;
22349 u32 src, dst;
22350
22351 FETCH_LONG(adr);
22352 if (flag_C & 0x100)
22353 {
22354 res = 0xFF;
22355 PRE_IO
22356 WRITE_BYTE_F(adr, res)
22357 POST_IO
22358 RET(20)
22359 }
22360 res = 0;
22361 PRE_IO
22362 WRITE_BYTE_F(adr, res)
22363 POST_IO
22364 RET(20)
22365}
22366
22367// STCC
22368OPCODE(0x56F9)
22369{
22370 u32 adr, res;
22371 u32 src, dst;
22372
22373 FETCH_LONG(adr);
22374 if (flag_NotZ)
22375 {
22376 res = 0xFF;
22377 PRE_IO
22378 WRITE_BYTE_F(adr, res)
22379 POST_IO
22380 RET(20)
22381 }
22382 res = 0;
22383 PRE_IO
22384 WRITE_BYTE_F(adr, res)
22385 POST_IO
22386 RET(20)
22387}
22388
22389// STCC
22390OPCODE(0x57F9)
22391{
22392 u32 adr, res;
22393 u32 src, dst;
22394
22395 FETCH_LONG(adr);
22396 if (!flag_NotZ)
22397 {
22398 res = 0xFF;
22399 PRE_IO
22400 WRITE_BYTE_F(adr, res)
22401 POST_IO
22402 RET(20)
22403 }
22404 res = 0;
22405 PRE_IO
22406 WRITE_BYTE_F(adr, res)
22407 POST_IO
22408 RET(20)
22409}
22410
22411// STCC
22412OPCODE(0x58F9)
22413{
22414 u32 adr, res;
22415 u32 src, dst;
22416
22417 FETCH_LONG(adr);
22418 if (!(flag_V & 0x80))
22419 {
22420 res = 0xFF;
22421 PRE_IO
22422 WRITE_BYTE_F(adr, res)
22423 POST_IO
22424 RET(20)
22425 }
22426 res = 0;
22427 PRE_IO
22428 WRITE_BYTE_F(adr, res)
22429 POST_IO
22430 RET(20)
22431}
22432
22433// STCC
22434OPCODE(0x59F9)
22435{
22436 u32 adr, res;
22437 u32 src, dst;
22438
22439 FETCH_LONG(adr);
22440 if (flag_V & 0x80)
22441 {
22442 res = 0xFF;
22443 PRE_IO
22444 WRITE_BYTE_F(adr, res)
22445 POST_IO
22446 RET(20)
22447 }
22448 res = 0;
22449 PRE_IO
22450 WRITE_BYTE_F(adr, res)
22451 POST_IO
22452 RET(20)
22453}
22454
22455// STCC
22456OPCODE(0x5AF9)
22457{
22458 u32 adr, res;
22459 u32 src, dst;
22460
22461 FETCH_LONG(adr);
22462 if (!(flag_N & 0x80))
22463 {
22464 res = 0xFF;
22465 PRE_IO
22466 WRITE_BYTE_F(adr, res)
22467 POST_IO
22468 RET(20)
22469 }
22470 res = 0;
22471 PRE_IO
22472 WRITE_BYTE_F(adr, res)
22473 POST_IO
22474 RET(20)
22475}
22476
22477// STCC
22478OPCODE(0x5BF9)
22479{
22480 u32 adr, res;
22481 u32 src, dst;
22482
22483 FETCH_LONG(adr);
22484 if (flag_N & 0x80)
22485 {
22486 res = 0xFF;
22487 PRE_IO
22488 WRITE_BYTE_F(adr, res)
22489 POST_IO
22490 RET(20)
22491 }
22492 res = 0;
22493 PRE_IO
22494 WRITE_BYTE_F(adr, res)
22495 POST_IO
22496 RET(20)
22497}
22498
22499// STCC
22500OPCODE(0x5CF9)
22501{
22502 u32 adr, res;
22503 u32 src, dst;
22504
22505 FETCH_LONG(adr);
22506 if (!((flag_N ^ flag_V) & 0x80))
22507 {
22508 res = 0xFF;
22509 PRE_IO
22510 WRITE_BYTE_F(adr, res)
22511 POST_IO
22512 RET(20)
22513 }
22514 res = 0;
22515 PRE_IO
22516 WRITE_BYTE_F(adr, res)
22517 POST_IO
22518 RET(20)
22519}
22520
22521// STCC
22522OPCODE(0x5DF9)
22523{
22524 u32 adr, res;
22525 u32 src, dst;
22526
22527 FETCH_LONG(adr);
22528 if ((flag_N ^ flag_V) & 0x80)
22529 {
22530 res = 0xFF;
22531 PRE_IO
22532 WRITE_BYTE_F(adr, res)
22533 POST_IO
22534 RET(20)
22535 }
22536 res = 0;
22537 PRE_IO
22538 WRITE_BYTE_F(adr, res)
22539 POST_IO
22540 RET(20)
22541}
22542
22543// STCC
22544OPCODE(0x5EF9)
22545{
22546 u32 adr, res;
22547 u32 src, dst;
22548
22549 FETCH_LONG(adr);
22550 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22551 {
22552 res = 0xFF;
22553 PRE_IO
22554 WRITE_BYTE_F(adr, res)
22555 POST_IO
22556 RET(20)
22557 }
22558 res = 0;
22559 PRE_IO
22560 WRITE_BYTE_F(adr, res)
22561 POST_IO
22562 RET(20)
22563}
22564
22565// STCC
22566OPCODE(0x5FF9)
22567{
22568 u32 adr, res;
22569 u32 src, dst;
22570
22571 FETCH_LONG(adr);
22572 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22573 {
22574 res = 0xFF;
22575 PRE_IO
22576 WRITE_BYTE_F(adr, res)
22577 POST_IO
22578 RET(20)
22579 }
22580 res = 0;
22581 PRE_IO
22582 WRITE_BYTE_F(adr, res)
22583 POST_IO
22584 RET(20)
22585}
22586
22587// STCC
22588OPCODE(0x50DF)
22589{
22590 u32 adr, res;
22591 u32 src, dst;
22592
22593 adr = AREG(7);
22594 AREG(7) += 2;
22595 res = 0xFF;
22596 PRE_IO
22597 WRITE_BYTE_F(adr, res)
22598 POST_IO
22599 RET(12)
22600}
22601
22602// STCC
22603OPCODE(0x51DF)
22604{
22605 u32 adr, res;
22606 u32 src, dst;
22607
22608 adr = AREG(7);
22609 AREG(7) += 2;
22610 res = 0;
22611 PRE_IO
22612 WRITE_BYTE_F(adr, res)
22613 POST_IO
22614 RET(12)
22615}
22616
22617// STCC
22618OPCODE(0x52DF)
22619{
22620 u32 adr, res;
22621 u32 src, dst;
22622
22623 adr = AREG(7);
22624 AREG(7) += 2;
22625 if (flag_NotZ && (!(flag_C & 0x100)))
22626 {
22627 res = 0xFF;
22628 PRE_IO
22629 WRITE_BYTE_F(adr, res)
22630 POST_IO
22631 RET(12)
22632 }
22633 res = 0;
22634 PRE_IO
22635 WRITE_BYTE_F(adr, res)
22636 POST_IO
22637 RET(12)
22638}
22639
22640// STCC
22641OPCODE(0x53DF)
22642{
22643 u32 adr, res;
22644 u32 src, dst;
22645
22646 adr = AREG(7);
22647 AREG(7) += 2;
22648 if ((!flag_NotZ) || (flag_C & 0x100))
22649 {
22650 res = 0xFF;
22651 PRE_IO
22652 WRITE_BYTE_F(adr, res)
22653 POST_IO
22654 RET(12)
22655 }
22656 res = 0;
22657 PRE_IO
22658 WRITE_BYTE_F(adr, res)
22659 POST_IO
22660 RET(12)
22661}
22662
22663// STCC
22664OPCODE(0x54DF)
22665{
22666 u32 adr, res;
22667 u32 src, dst;
22668
22669 adr = AREG(7);
22670 AREG(7) += 2;
22671 if (!(flag_C & 0x100))
22672 {
22673 res = 0xFF;
22674 PRE_IO
22675 WRITE_BYTE_F(adr, res)
22676 POST_IO
22677 RET(12)
22678 }
22679 res = 0;
22680 PRE_IO
22681 WRITE_BYTE_F(adr, res)
22682 POST_IO
22683 RET(12)
22684}
22685
22686// STCC
22687OPCODE(0x55DF)
22688{
22689 u32 adr, res;
22690 u32 src, dst;
22691
22692 adr = AREG(7);
22693 AREG(7) += 2;
22694 if (flag_C & 0x100)
22695 {
22696 res = 0xFF;
22697 PRE_IO
22698 WRITE_BYTE_F(adr, res)
22699 POST_IO
22700 RET(12)
22701 }
22702 res = 0;
22703 PRE_IO
22704 WRITE_BYTE_F(adr, res)
22705 POST_IO
22706 RET(12)
22707}
22708
22709// STCC
22710OPCODE(0x56DF)
22711{
22712 u32 adr, res;
22713 u32 src, dst;
22714
22715 adr = AREG(7);
22716 AREG(7) += 2;
22717 if (flag_NotZ)
22718 {
22719 res = 0xFF;
22720 PRE_IO
22721 WRITE_BYTE_F(adr, res)
22722 POST_IO
22723 RET(12)
22724 }
22725 res = 0;
22726 PRE_IO
22727 WRITE_BYTE_F(adr, res)
22728 POST_IO
22729 RET(12)
22730}
22731
22732// STCC
22733OPCODE(0x57DF)
22734{
22735 u32 adr, res;
22736 u32 src, dst;
22737
22738 adr = AREG(7);
22739 AREG(7) += 2;
22740 if (!flag_NotZ)
22741 {
22742 res = 0xFF;
22743 PRE_IO
22744 WRITE_BYTE_F(adr, res)
22745 POST_IO
22746 RET(12)
22747 }
22748 res = 0;
22749 PRE_IO
22750 WRITE_BYTE_F(adr, res)
22751 POST_IO
22752 RET(12)
22753}
22754
22755// STCC
22756OPCODE(0x58DF)
22757{
22758 u32 adr, res;
22759 u32 src, dst;
22760
22761 adr = AREG(7);
22762 AREG(7) += 2;
22763 if (!(flag_V & 0x80))
22764 {
22765 res = 0xFF;
22766 PRE_IO
22767 WRITE_BYTE_F(adr, res)
22768 POST_IO
22769 RET(12)
22770 }
22771 res = 0;
22772 PRE_IO
22773 WRITE_BYTE_F(adr, res)
22774 POST_IO
22775 RET(12)
22776}
22777
22778// STCC
22779OPCODE(0x59DF)
22780{
22781 u32 adr, res;
22782 u32 src, dst;
22783
22784 adr = AREG(7);
22785 AREG(7) += 2;
22786 if (flag_V & 0x80)
22787 {
22788 res = 0xFF;
22789 PRE_IO
22790 WRITE_BYTE_F(adr, res)
22791 POST_IO
22792 RET(12)
22793 }
22794 res = 0;
22795 PRE_IO
22796 WRITE_BYTE_F(adr, res)
22797 POST_IO
22798 RET(12)
22799}
22800
22801// STCC
22802OPCODE(0x5ADF)
22803{
22804 u32 adr, res;
22805 u32 src, dst;
22806
22807 adr = AREG(7);
22808 AREG(7) += 2;
22809 if (!(flag_N & 0x80))
22810 {
22811 res = 0xFF;
22812 PRE_IO
22813 WRITE_BYTE_F(adr, res)
22814 POST_IO
22815 RET(12)
22816 }
22817 res = 0;
22818 PRE_IO
22819 WRITE_BYTE_F(adr, res)
22820 POST_IO
22821 RET(12)
22822}
22823
22824// STCC
22825OPCODE(0x5BDF)
22826{
22827 u32 adr, res;
22828 u32 src, dst;
22829
22830 adr = AREG(7);
22831 AREG(7) += 2;
22832 if (flag_N & 0x80)
22833 {
22834 res = 0xFF;
22835 PRE_IO
22836 WRITE_BYTE_F(adr, res)
22837 POST_IO
22838 RET(12)
22839 }
22840 res = 0;
22841 PRE_IO
22842 WRITE_BYTE_F(adr, res)
22843 POST_IO
22844 RET(12)
22845}
22846
22847// STCC
22848OPCODE(0x5CDF)
22849{
22850 u32 adr, res;
22851 u32 src, dst;
22852
22853 adr = AREG(7);
22854 AREG(7) += 2;
22855 if (!((flag_N ^ flag_V) & 0x80))
22856 {
22857 res = 0xFF;
22858 PRE_IO
22859 WRITE_BYTE_F(adr, res)
22860 POST_IO
22861 RET(12)
22862 }
22863 res = 0;
22864 PRE_IO
22865 WRITE_BYTE_F(adr, res)
22866 POST_IO
22867 RET(12)
22868}
22869
22870// STCC
22871OPCODE(0x5DDF)
22872{
22873 u32 adr, res;
22874 u32 src, dst;
22875
22876 adr = AREG(7);
22877 AREG(7) += 2;
22878 if ((flag_N ^ flag_V) & 0x80)
22879 {
22880 res = 0xFF;
22881 PRE_IO
22882 WRITE_BYTE_F(adr, res)
22883 POST_IO
22884 RET(12)
22885 }
22886 res = 0;
22887 PRE_IO
22888 WRITE_BYTE_F(adr, res)
22889 POST_IO
22890 RET(12)
22891}
22892
22893// STCC
22894OPCODE(0x5EDF)
22895{
22896 u32 adr, res;
22897 u32 src, dst;
22898
22899 adr = AREG(7);
22900 AREG(7) += 2;
22901 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
22902 {
22903 res = 0xFF;
22904 PRE_IO
22905 WRITE_BYTE_F(adr, res)
22906 POST_IO
22907 RET(12)
22908 }
22909 res = 0;
22910 PRE_IO
22911 WRITE_BYTE_F(adr, res)
22912 POST_IO
22913 RET(12)
22914}
22915
22916// STCC
22917OPCODE(0x5FDF)
22918{
22919 u32 adr, res;
22920 u32 src, dst;
22921
22922 adr = AREG(7);
22923 AREG(7) += 2;
22924 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
22925 {
22926 res = 0xFF;
22927 PRE_IO
22928 WRITE_BYTE_F(adr, res)
22929 POST_IO
22930 RET(12)
22931 }
22932 res = 0;
22933 PRE_IO
22934 WRITE_BYTE_F(adr, res)
22935 POST_IO
22936 RET(12)
22937}
22938
22939// STCC
22940OPCODE(0x50E7)
22941{
22942 u32 adr, res;
22943 u32 src, dst;
22944
22945 adr = AREG(7) - 2;
22946 AREG(7) = adr;
22947 res = 0xFF;
22948 PRE_IO
22949 WRITE_BYTE_F(adr, res)
22950 POST_IO
22951 RET(14)
22952}
22953
22954// STCC
22955OPCODE(0x51E7)
22956{
22957 u32 adr, res;
22958 u32 src, dst;
22959
22960 adr = AREG(7) - 2;
22961 AREG(7) = adr;
22962 res = 0;
22963 PRE_IO
22964 WRITE_BYTE_F(adr, res)
22965 POST_IO
22966 RET(14)
22967}
22968
22969// STCC
22970OPCODE(0x52E7)
22971{
22972 u32 adr, res;
22973 u32 src, dst;
22974
22975 adr = AREG(7) - 2;
22976 AREG(7) = adr;
22977 if (flag_NotZ && (!(flag_C & 0x100)))
22978 {
22979 res = 0xFF;
22980 PRE_IO
22981 WRITE_BYTE_F(adr, res)
22982 POST_IO
22983 RET(14)
22984 }
22985 res = 0;
22986 PRE_IO
22987 WRITE_BYTE_F(adr, res)
22988 POST_IO
22989 RET(14)
22990}
22991
22992// STCC
22993OPCODE(0x53E7)
22994{
22995 u32 adr, res;
22996 u32 src, dst;
22997
22998 adr = AREG(7) - 2;
22999 AREG(7) = adr;
23000 if ((!flag_NotZ) || (flag_C & 0x100))
23001 {
23002 res = 0xFF;
23003 PRE_IO
23004 WRITE_BYTE_F(adr, res)
23005 POST_IO
23006 RET(14)
23007 }
23008 res = 0;
23009 PRE_IO
23010 WRITE_BYTE_F(adr, res)
23011 POST_IO
23012 RET(14)
23013}
23014
23015// STCC
23016OPCODE(0x54E7)
23017{
23018 u32 adr, res;
23019 u32 src, dst;
23020
23021 adr = AREG(7) - 2;
23022 AREG(7) = adr;
23023 if (!(flag_C & 0x100))
23024 {
23025 res = 0xFF;
23026 PRE_IO
23027 WRITE_BYTE_F(adr, res)
23028 POST_IO
23029 RET(14)
23030 }
23031 res = 0;
23032 PRE_IO
23033 WRITE_BYTE_F(adr, res)
23034 POST_IO
23035 RET(14)
23036}
23037
23038// STCC
23039OPCODE(0x55E7)
23040{
23041 u32 adr, res;
23042 u32 src, dst;
23043
23044 adr = AREG(7) - 2;
23045 AREG(7) = adr;
23046 if (flag_C & 0x100)
23047 {
23048 res = 0xFF;
23049 PRE_IO
23050 WRITE_BYTE_F(adr, res)
23051 POST_IO
23052 RET(14)
23053 }
23054 res = 0;
23055 PRE_IO
23056 WRITE_BYTE_F(adr, res)
23057 POST_IO
23058 RET(14)
23059}
23060
23061// STCC
23062OPCODE(0x56E7)
23063{
23064 u32 adr, res;
23065 u32 src, dst;
23066
23067 adr = AREG(7) - 2;
23068 AREG(7) = adr;
23069 if (flag_NotZ)
23070 {
23071 res = 0xFF;
23072 PRE_IO
23073 WRITE_BYTE_F(adr, res)
23074 POST_IO
23075 RET(14)
23076 }
23077 res = 0;
23078 PRE_IO
23079 WRITE_BYTE_F(adr, res)
23080 POST_IO
23081 RET(14)
23082}
23083
23084// STCC
23085OPCODE(0x57E7)
23086{
23087 u32 adr, res;
23088 u32 src, dst;
23089
23090 adr = AREG(7) - 2;
23091 AREG(7) = adr;
23092 if (!flag_NotZ)
23093 {
23094 res = 0xFF;
23095 PRE_IO
23096 WRITE_BYTE_F(adr, res)
23097 POST_IO
23098 RET(14)
23099 }
23100 res = 0;
23101 PRE_IO
23102 WRITE_BYTE_F(adr, res)
23103 POST_IO
23104 RET(14)
23105}
23106
23107// STCC
23108OPCODE(0x58E7)
23109{
23110 u32 adr, res;
23111 u32 src, dst;
23112
23113 adr = AREG(7) - 2;
23114 AREG(7) = adr;
23115 if (!(flag_V & 0x80))
23116 {
23117 res = 0xFF;
23118 PRE_IO
23119 WRITE_BYTE_F(adr, res)
23120 POST_IO
23121 RET(14)
23122 }
23123 res = 0;
23124 PRE_IO
23125 WRITE_BYTE_F(adr, res)
23126 POST_IO
23127 RET(14)
23128}
23129
23130// STCC
23131OPCODE(0x59E7)
23132{
23133 u32 adr, res;
23134 u32 src, dst;
23135
23136 adr = AREG(7) - 2;
23137 AREG(7) = adr;
23138 if (flag_V & 0x80)
23139 {
23140 res = 0xFF;
23141 PRE_IO
23142 WRITE_BYTE_F(adr, res)
23143 POST_IO
23144 RET(14)
23145 }
23146 res = 0;
23147 PRE_IO
23148 WRITE_BYTE_F(adr, res)
23149 POST_IO
23150 RET(14)
23151}
23152
23153// STCC
23154OPCODE(0x5AE7)
23155{
23156 u32 adr, res;
23157 u32 src, dst;
23158
23159 adr = AREG(7) - 2;
23160 AREG(7) = adr;
23161 if (!(flag_N & 0x80))
23162 {
23163 res = 0xFF;
23164 PRE_IO
23165 WRITE_BYTE_F(adr, res)
23166 POST_IO
23167 RET(14)
23168 }
23169 res = 0;
23170 PRE_IO
23171 WRITE_BYTE_F(adr, res)
23172 POST_IO
23173 RET(14)
23174}
23175
23176// STCC
23177OPCODE(0x5BE7)
23178{
23179 u32 adr, res;
23180 u32 src, dst;
23181
23182 adr = AREG(7) - 2;
23183 AREG(7) = adr;
23184 if (flag_N & 0x80)
23185 {
23186 res = 0xFF;
23187 PRE_IO
23188 WRITE_BYTE_F(adr, res)
23189 POST_IO
23190 RET(14)
23191 }
23192 res = 0;
23193 PRE_IO
23194 WRITE_BYTE_F(adr, res)
23195 POST_IO
23196 RET(14)
23197}
23198
23199// STCC
23200OPCODE(0x5CE7)
23201{
23202 u32 adr, res;
23203 u32 src, dst;
23204
23205 adr = AREG(7) - 2;
23206 AREG(7) = adr;
23207 if (!((flag_N ^ flag_V) & 0x80))
23208 {
23209 res = 0xFF;
23210 PRE_IO
23211 WRITE_BYTE_F(adr, res)
23212 POST_IO
23213 RET(14)
23214 }
23215 res = 0;
23216 PRE_IO
23217 WRITE_BYTE_F(adr, res)
23218 POST_IO
23219 RET(14)
23220}
23221
23222// STCC
23223OPCODE(0x5DE7)
23224{
23225 u32 adr, res;
23226 u32 src, dst;
23227
23228 adr = AREG(7) - 2;
23229 AREG(7) = adr;
23230 if ((flag_N ^ flag_V) & 0x80)
23231 {
23232 res = 0xFF;
23233 PRE_IO
23234 WRITE_BYTE_F(adr, res)
23235 POST_IO
23236 RET(14)
23237 }
23238 res = 0;
23239 PRE_IO
23240 WRITE_BYTE_F(adr, res)
23241 POST_IO
23242 RET(14)
23243}
23244
23245// STCC
23246OPCODE(0x5EE7)
23247{
23248 u32 adr, res;
23249 u32 src, dst;
23250
23251 adr = AREG(7) - 2;
23252 AREG(7) = adr;
23253 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23254 {
23255 res = 0xFF;
23256 PRE_IO
23257 WRITE_BYTE_F(adr, res)
23258 POST_IO
23259 RET(14)
23260 }
23261 res = 0;
23262 PRE_IO
23263 WRITE_BYTE_F(adr, res)
23264 POST_IO
23265 RET(14)
23266}
23267
23268// STCC
23269OPCODE(0x5FE7)
23270{
23271 u32 adr, res;
23272 u32 src, dst;
23273
23274 adr = AREG(7) - 2;
23275 AREG(7) = adr;
23276 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23277 {
23278 res = 0xFF;
23279 PRE_IO
23280 WRITE_BYTE_F(adr, res)
23281 POST_IO
23282 RET(14)
23283 }
23284 res = 0;
23285 PRE_IO
23286 WRITE_BYTE_F(adr, res)
23287 POST_IO
23288 RET(14)
23289}
23290
23291// DBCC
23292OPCODE(0x50C8)
23293{
23294 u32 adr, res;
23295 u32 src, dst;
23296
23297 PC++;
23298RET(12)
23299}
23300
23301// DBCC
23302OPCODE(0x51C8)
23303{
23304 u32 adr, res;
23305 u32 src, dst;
23306
ecc8036e 23307 NOT_POLLING
23308
70357ce5 23309 res = DREGu16((Opcode >> 0) & 7);
23310 res--;
23311 DREGu16((Opcode >> 0) & 7) = res;
23312 if ((s32)res != -1)
23313 {
23314 u32 newPC;
23315
be26eb23 23316 newPC = GET_PC;
70357ce5 23317 newPC += GET_SWORD;
23318 SET_PC(newPC);
23319 CHECK_BRANCH_EXCEPTION(newPC)
23320 RET(10)
23321 }
23322 PC++;
23323RET(14)
23324}
23325
23326// DBCC
23327OPCODE(0x52C8)
23328{
23329 u32 adr, res;
23330 u32 src, dst;
23331
ecc8036e 23332 NOT_POLLING
23333
70357ce5 23334 if ((!flag_NotZ) || (flag_C & 0x100))
23335 {
23336 res = DREGu16((Opcode >> 0) & 7);
23337 res--;
23338 DREGu16((Opcode >> 0) & 7) = res;
23339 if ((s32)res != -1)
23340 {
23341 u32 newPC;
23342
be26eb23 23343 newPC = GET_PC;
70357ce5 23344 newPC += GET_SWORD;
23345 SET_PC(newPC);
23346 CHECK_BRANCH_EXCEPTION(newPC)
23347 RET(10)
23348 }
23349 }
23350 else
23351 {
23352 PC++;
23353 RET(12)
23354 }
23355 PC++;
23356RET(14)
23357}
23358
23359// DBCC
23360OPCODE(0x53C8)
23361{
23362 u32 adr, res;
23363 u32 src, dst;
23364
ecc8036e 23365 NOT_POLLING
23366
70357ce5 23367 if (flag_NotZ && (!(flag_C & 0x100)))
23368 {
23369 res = DREGu16((Opcode >> 0) & 7);
23370 res--;
23371 DREGu16((Opcode >> 0) & 7) = res;
23372 if ((s32)res != -1)
23373 {
23374 u32 newPC;
23375
be26eb23 23376 newPC = GET_PC;
70357ce5 23377 newPC += GET_SWORD;
23378 SET_PC(newPC);
23379 CHECK_BRANCH_EXCEPTION(newPC)
23380 RET(10)
23381 }
23382 }
23383 else
23384 {
23385 PC++;
23386 RET(12)
23387 }
23388 PC++;
23389RET(14)
23390}
23391
23392// DBCC
23393OPCODE(0x54C8)
23394{
23395 u32 adr, res;
23396 u32 src, dst;
23397
ecc8036e 23398 NOT_POLLING
23399
70357ce5 23400 if (flag_C & 0x100)
23401 {
23402 res = DREGu16((Opcode >> 0) & 7);
23403 res--;
23404 DREGu16((Opcode >> 0) & 7) = res;
23405 if ((s32)res != -1)
23406 {
23407 u32 newPC;
23408
be26eb23 23409 newPC = GET_PC;
70357ce5 23410 newPC += GET_SWORD;
23411 SET_PC(newPC);
23412 CHECK_BRANCH_EXCEPTION(newPC)
23413 RET(10)
23414 }
23415 }
23416 else
23417 {
23418 PC++;
23419 RET(12)
23420 }
23421 PC++;
23422RET(14)
23423}
23424
23425// DBCC
23426OPCODE(0x55C8)
23427{
23428 u32 adr, res;
23429 u32 src, dst;
23430
ecc8036e 23431 NOT_POLLING
23432
70357ce5 23433 if (!(flag_C & 0x100))
23434 {
23435 res = DREGu16((Opcode >> 0) & 7);
23436 res--;
23437 DREGu16((Opcode >> 0) & 7) = res;
23438 if ((s32)res != -1)
23439 {
23440 u32 newPC;
23441
be26eb23 23442 newPC = GET_PC;
70357ce5 23443 newPC += GET_SWORD;
23444 SET_PC(newPC);
23445 CHECK_BRANCH_EXCEPTION(newPC)
23446 RET(10)
23447 }
23448 }
23449 else
23450 {
23451 PC++;
23452 RET(12)
23453 }
23454 PC++;
23455RET(14)
23456}
23457
23458// DBCC
23459OPCODE(0x56C8)
23460{
23461 u32 adr, res;
23462 u32 src, dst;
23463
ecc8036e 23464 NOT_POLLING
23465
70357ce5 23466 if (!flag_NotZ)
23467 {
23468 res = DREGu16((Opcode >> 0) & 7);
23469 res--;
23470 DREGu16((Opcode >> 0) & 7) = res;
23471 if ((s32)res != -1)
23472 {
23473 u32 newPC;
23474
be26eb23 23475 newPC = GET_PC;
70357ce5 23476 newPC += GET_SWORD;
23477 SET_PC(newPC);
23478 CHECK_BRANCH_EXCEPTION(newPC)
23479 RET(10)
23480 }
23481 }
23482 else
23483 {
23484 PC++;
23485 RET(12)
23486 }
23487 PC++;
23488RET(14)
23489}
23490
23491// DBCC
23492OPCODE(0x57C8)
23493{
23494 u32 adr, res;
23495 u32 src, dst;
23496
ecc8036e 23497 NOT_POLLING
23498
70357ce5 23499 if (flag_NotZ)
23500 {
23501 res = DREGu16((Opcode >> 0) & 7);
23502 res--;
23503 DREGu16((Opcode >> 0) & 7) = res;
23504 if ((s32)res != -1)
23505 {
23506 u32 newPC;
23507
be26eb23 23508 newPC = GET_PC;
70357ce5 23509 newPC += GET_SWORD;
23510 SET_PC(newPC);
23511 CHECK_BRANCH_EXCEPTION(newPC)
23512 RET(10)
23513 }
23514 }
23515 else
23516 {
23517 PC++;
23518 RET(12)
23519 }
23520 PC++;
23521RET(14)
23522}
23523
23524// DBCC
23525OPCODE(0x58C8)
23526{
23527 u32 adr, res;
23528 u32 src, dst;
23529
ecc8036e 23530 NOT_POLLING
23531
70357ce5 23532 if (flag_V & 0x80)
23533 {
23534 res = DREGu16((Opcode >> 0) & 7);
23535 res--;
23536 DREGu16((Opcode >> 0) & 7) = res;
23537 if ((s32)res != -1)
23538 {
23539 u32 newPC;
23540
be26eb23 23541 newPC = GET_PC;
70357ce5 23542 newPC += GET_SWORD;
23543 SET_PC(newPC);
23544 CHECK_BRANCH_EXCEPTION(newPC)
23545 RET(10)
23546 }
23547 }
23548 else
23549 {
23550 PC++;
23551 RET(12)
23552 }
23553 PC++;
23554RET(14)
23555}
23556
23557// DBCC
23558OPCODE(0x59C8)
23559{
23560 u32 adr, res;
23561 u32 src, dst;
23562
ecc8036e 23563 NOT_POLLING
23564
70357ce5 23565 if (!(flag_V & 0x80))
23566 {
23567 res = DREGu16((Opcode >> 0) & 7);
23568 res--;
23569 DREGu16((Opcode >> 0) & 7) = res;
23570 if ((s32)res != -1)
23571 {
23572 u32 newPC;
23573
be26eb23 23574 newPC = GET_PC;
70357ce5 23575 newPC += GET_SWORD;
23576 SET_PC(newPC);
23577 CHECK_BRANCH_EXCEPTION(newPC)
23578 RET(10)
23579 }
23580 }
23581 else
23582 {
23583 PC++;
23584 RET(12)
23585 }
23586 PC++;
23587RET(14)
23588}
23589
23590// DBCC
23591OPCODE(0x5AC8)
23592{
23593 u32 adr, res;
23594 u32 src, dst;
23595
ecc8036e 23596 NOT_POLLING
23597
70357ce5 23598 if (flag_N & 0x80)
23599 {
23600 res = DREGu16((Opcode >> 0) & 7);
23601 res--;
23602 DREGu16((Opcode >> 0) & 7) = res;
23603 if ((s32)res != -1)
23604 {
23605 u32 newPC;
23606
be26eb23 23607 newPC = GET_PC;
70357ce5 23608 newPC += GET_SWORD;
23609 SET_PC(newPC);
23610 CHECK_BRANCH_EXCEPTION(newPC)
23611 RET(10)
23612 }
23613 }
23614 else
23615 {
23616 PC++;
23617 RET(12)
23618 }
23619 PC++;
23620RET(14)
23621}
23622
23623// DBCC
23624OPCODE(0x5BC8)
23625{
23626 u32 adr, res;
23627 u32 src, dst;
23628
ecc8036e 23629 NOT_POLLING
23630
70357ce5 23631 if (!(flag_N & 0x80))
23632 {
23633 res = DREGu16((Opcode >> 0) & 7);
23634 res--;
23635 DREGu16((Opcode >> 0) & 7) = res;
23636 if ((s32)res != -1)
23637 {
23638 u32 newPC;
23639
be26eb23 23640 newPC = GET_PC;
70357ce5 23641 newPC += GET_SWORD;
23642 SET_PC(newPC);
23643 CHECK_BRANCH_EXCEPTION(newPC)
23644 RET(10)
23645 }
23646 }
23647 else
23648 {
23649 PC++;
23650 RET(12)
23651 }
23652 PC++;
23653RET(14)
23654}
23655
23656// DBCC
23657OPCODE(0x5CC8)
23658{
23659 u32 adr, res;
23660 u32 src, dst;
23661
ecc8036e 23662 NOT_POLLING
23663
70357ce5 23664 if ((flag_N ^ flag_V) & 0x80)
23665 {
23666 res = DREGu16((Opcode >> 0) & 7);
23667 res--;
23668 DREGu16((Opcode >> 0) & 7) = res;
23669 if ((s32)res != -1)
23670 {
23671 u32 newPC;
23672
be26eb23 23673 newPC = GET_PC;
70357ce5 23674 newPC += GET_SWORD;
23675 SET_PC(newPC);
23676 CHECK_BRANCH_EXCEPTION(newPC)
23677 RET(10)
23678 }
23679 }
23680 else
23681 {
23682 PC++;
23683 RET(12)
23684 }
23685 PC++;
23686RET(14)
23687}
23688
23689// DBCC
23690OPCODE(0x5DC8)
23691{
23692 u32 adr, res;
23693 u32 src, dst;
23694
ecc8036e 23695 NOT_POLLING
23696
70357ce5 23697 if (!((flag_N ^ flag_V) & 0x80))
23698 {
23699 res = DREGu16((Opcode >> 0) & 7);
23700 res--;
23701 DREGu16((Opcode >> 0) & 7) = res;
23702 if ((s32)res != -1)
23703 {
23704 u32 newPC;
23705
be26eb23 23706 newPC = GET_PC;
70357ce5 23707 newPC += GET_SWORD;
23708 SET_PC(newPC);
23709 CHECK_BRANCH_EXCEPTION(newPC)
23710 RET(10)
23711 }
23712 }
23713 else
23714 {
23715 PC++;
23716 RET(12)
23717 }
23718 PC++;
23719RET(14)
23720}
23721
23722// DBCC
23723OPCODE(0x5EC8)
23724{
23725 u32 adr, res;
23726 u32 src, dst;
23727
ecc8036e 23728 NOT_POLLING
23729
70357ce5 23730 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
23731 {
23732 res = DREGu16((Opcode >> 0) & 7);
23733 res--;
23734 DREGu16((Opcode >> 0) & 7) = res;
23735 if ((s32)res != -1)
23736 {
23737 u32 newPC;
23738
be26eb23 23739 newPC = GET_PC;
70357ce5 23740 newPC += GET_SWORD;
23741 SET_PC(newPC);
23742 CHECK_BRANCH_EXCEPTION(newPC)
23743 RET(10)
23744 }
23745 }
23746 else
23747 {
23748 PC++;
23749 RET(12)
23750 }
23751 PC++;
23752RET(14)
23753}
23754
23755// DBCC
23756OPCODE(0x5FC8)
23757{
23758 u32 adr, res;
23759 u32 src, dst;
23760
ecc8036e 23761 NOT_POLLING
23762
70357ce5 23763 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
23764 {
23765 res = DREGu16((Opcode >> 0) & 7);
23766 res--;
23767 DREGu16((Opcode >> 0) & 7) = res;
23768 if ((s32)res != -1)
23769 {
23770 u32 newPC;
23771
be26eb23 23772 newPC = GET_PC;
70357ce5 23773 newPC += GET_SWORD;
23774 SET_PC(newPC);
23775 CHECK_BRANCH_EXCEPTION(newPC)
23776 RET(10)
23777 }
23778 }
23779 else
23780 {
23781 PC++;
23782 RET(12)
23783 }
23784 PC++;
23785RET(14)
23786}
23787
23788// ADDQ
23789OPCODE(0x5000)
23790{
23791 u32 adr, res;
23792 u32 src, dst;
23793
23794 src = (((Opcode >> 9) - 1) & 7) + 1;
23795 dst = DREGu8((Opcode >> 0) & 7);
23796 res = dst + src;
23797 flag_N = flag_X = flag_C = res;
23798 flag_V = (src ^ res) & (dst ^ res);
23799 flag_NotZ = res & 0xFF;
23800 DREGu8((Opcode >> 0) & 7) = res;
23801RET(4)
23802}
23803
23804// ADDQ
23805OPCODE(0x5010)
23806{
23807 u32 adr, res;
23808 u32 src, dst;
23809
23810 src = (((Opcode >> 9) - 1) & 7) + 1;
23811 adr = AREG((Opcode >> 0) & 7);
23812 PRE_IO
23813 READ_BYTE_F(adr, dst)
23814 res = dst + src;
23815 flag_N = flag_X = flag_C = res;
23816 flag_V = (src ^ res) & (dst ^ res);
23817 flag_NotZ = res & 0xFF;
23818 WRITE_BYTE_F(adr, res)
23819 POST_IO
23820RET(12)
23821}
23822
23823// ADDQ
23824OPCODE(0x5018)
23825{
23826 u32 adr, res;
23827 u32 src, dst;
23828
23829 src = (((Opcode >> 9) - 1) & 7) + 1;
23830 adr = AREG((Opcode >> 0) & 7);
23831 AREG((Opcode >> 0) & 7) += 1;
23832 PRE_IO
23833 READ_BYTE_F(adr, dst)
23834 res = dst + src;
23835 flag_N = flag_X = flag_C = res;
23836 flag_V = (src ^ res) & (dst ^ res);
23837 flag_NotZ = res & 0xFF;
23838 WRITE_BYTE_F(adr, res)
23839 POST_IO
23840RET(12)
23841}
23842
23843// ADDQ
23844OPCODE(0x5020)
23845{
23846 u32 adr, res;
23847 u32 src, dst;
23848
23849 src = (((Opcode >> 9) - 1) & 7) + 1;
23850 adr = AREG((Opcode >> 0) & 7) - 1;
23851 AREG((Opcode >> 0) & 7) = adr;
23852 PRE_IO
23853 READ_BYTE_F(adr, dst)
23854 res = dst + src;
23855 flag_N = flag_X = flag_C = res;
23856 flag_V = (src ^ res) & (dst ^ res);
23857 flag_NotZ = res & 0xFF;
23858 WRITE_BYTE_F(adr, res)
23859 POST_IO
23860RET(14)
23861}
23862
23863// ADDQ
23864OPCODE(0x5028)
23865{
23866 u32 adr, res;
23867 u32 src, dst;
23868
23869 src = (((Opcode >> 9) - 1) & 7) + 1;
23870 FETCH_SWORD(adr);
23871 adr += AREG((Opcode >> 0) & 7);
23872 PRE_IO
23873 READ_BYTE_F(adr, dst)
23874 res = dst + src;
23875 flag_N = flag_X = flag_C = res;
23876 flag_V = (src ^ res) & (dst ^ res);
23877 flag_NotZ = res & 0xFF;
23878 WRITE_BYTE_F(adr, res)
23879 POST_IO
23880RET(16)
23881}
23882
23883// ADDQ
23884OPCODE(0x5030)
23885{
23886 u32 adr, res;
23887 u32 src, dst;
23888
23889 src = (((Opcode >> 9) - 1) & 7) + 1;
23890 adr = AREG((Opcode >> 0) & 7);
23891 DECODE_EXT_WORD
23892 PRE_IO
23893 READ_BYTE_F(adr, dst)
23894 res = dst + src;
23895 flag_N = flag_X = flag_C = res;
23896 flag_V = (src ^ res) & (dst ^ res);
23897 flag_NotZ = res & 0xFF;
23898 WRITE_BYTE_F(adr, res)
23899 POST_IO
23900RET(18)
23901}
23902
23903// ADDQ
23904OPCODE(0x5038)
23905{
23906 u32 adr, res;
23907 u32 src, dst;
23908
23909 src = (((Opcode >> 9) - 1) & 7) + 1;
23910 FETCH_SWORD(adr);
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(16)
23920}
23921
23922// ADDQ
23923OPCODE(0x5039)
23924{
23925 u32 adr, res;
23926 u32 src, dst;
23927
23928 src = (((Opcode >> 9) - 1) & 7) + 1;
23929 FETCH_LONG(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(20)
23939}
23940
23941// ADDQ
23942OPCODE(0x501F)
23943{
23944 u32 adr, res;
23945 u32 src, dst;
23946
23947 src = (((Opcode >> 9) - 1) & 7) + 1;
23948 adr = AREG(7);
23949 AREG(7) += 2;
23950 PRE_IO
23951 READ_BYTE_F(adr, dst)
23952 res = dst + src;
23953 flag_N = flag_X = flag_C = res;
23954 flag_V = (src ^ res) & (dst ^ res);
23955 flag_NotZ = res & 0xFF;
23956 WRITE_BYTE_F(adr, res)
23957 POST_IO
23958RET(12)
23959}
23960
23961// ADDQ
23962OPCODE(0x5027)
23963{
23964 u32 adr, res;
23965 u32 src, dst;
23966
23967 src = (((Opcode >> 9) - 1) & 7) + 1;
23968 adr = AREG(7) - 2;
23969 AREG(7) = adr;
23970 PRE_IO
23971 READ_BYTE_F(adr, dst)
23972 res = dst + src;
23973 flag_N = flag_X = flag_C = res;
23974 flag_V = (src ^ res) & (dst ^ res);
23975 flag_NotZ = res & 0xFF;
23976 WRITE_BYTE_F(adr, res)
23977 POST_IO
23978RET(14)
23979}
23980
23981// ADDQ
23982OPCODE(0x5040)
23983{
23984 u32 adr, res;
23985 u32 src, dst;
23986
23987 src = (((Opcode >> 9) - 1) & 7) + 1;
23988 dst = DREGu16((Opcode >> 0) & 7);
23989 res = dst + src;
23990 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
23991 flag_N = flag_X = flag_C = res >> 8;
23992 flag_NotZ = res & 0xFFFF;
23993 DREGu16((Opcode >> 0) & 7) = res;
23994RET(4)
23995}
23996
23997// ADDQ
23998OPCODE(0x5048)
23999{
24000 u32 adr, res;
24001 u32 src, dst;
24002
24003 src = (((Opcode >> 9) - 1) & 7) + 1;
24004 dst = AREGu32((Opcode >> 0) & 7);
24005 res = dst + src;
24006 AREG((Opcode >> 0) & 7) = res;
03e4f2a3 24007#ifdef USE_CYCLONE_TIMING
70357ce5 24008RET(4)
24009#else
24010RET(8)
24011#endif
24012}
24013
24014// ADDQ
24015OPCODE(0x5050)
24016{
24017 u32 adr, res;
24018 u32 src, dst;
24019
24020 src = (((Opcode >> 9) - 1) & 7) + 1;
24021 adr = AREG((Opcode >> 0) & 7);
24022 PRE_IO
24023 READ_WORD_F(adr, dst)
24024 res = dst + src;
24025 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24026 flag_N = flag_X = flag_C = res >> 8;
24027 flag_NotZ = res & 0xFFFF;
24028 WRITE_WORD_F(adr, res)
24029 POST_IO
24030RET(12)
24031}
24032
24033// ADDQ
24034OPCODE(0x5058)
24035{
24036 u32 adr, res;
24037 u32 src, dst;
24038
24039 src = (((Opcode >> 9) - 1) & 7) + 1;
24040 adr = AREG((Opcode >> 0) & 7);
24041 AREG((Opcode >> 0) & 7) += 2;
24042 PRE_IO
24043 READ_WORD_F(adr, dst)
24044 res = dst + src;
24045 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24046 flag_N = flag_X = flag_C = res >> 8;
24047 flag_NotZ = res & 0xFFFF;
24048 WRITE_WORD_F(adr, res)
24049 POST_IO
24050RET(12)
24051}
24052
24053// ADDQ
24054OPCODE(0x5060)
24055{
24056 u32 adr, res;
24057 u32 src, dst;
24058
24059 src = (((Opcode >> 9) - 1) & 7) + 1;
24060 adr = AREG((Opcode >> 0) & 7) - 2;
24061 AREG((Opcode >> 0) & 7) = adr;
24062 PRE_IO
24063 READ_WORD_F(adr, dst)
24064 res = dst + src;
24065 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24066 flag_N = flag_X = flag_C = res >> 8;
24067 flag_NotZ = res & 0xFFFF;
24068 WRITE_WORD_F(adr, res)
24069 POST_IO
24070RET(14)
24071}
24072
24073// ADDQ
24074OPCODE(0x5068)
24075{
24076 u32 adr, res;
24077 u32 src, dst;
24078
24079 src = (((Opcode >> 9) - 1) & 7) + 1;
24080 FETCH_SWORD(adr);
24081 adr += AREG((Opcode >> 0) & 7);
24082 PRE_IO
24083 READ_WORD_F(adr, dst)
24084 res = dst + src;
24085 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24086 flag_N = flag_X = flag_C = res >> 8;
24087 flag_NotZ = res & 0xFFFF;
24088 WRITE_WORD_F(adr, res)
24089 POST_IO
24090RET(16)
24091}
24092
24093// ADDQ
24094OPCODE(0x5070)
24095{
24096 u32 adr, res;
24097 u32 src, dst;
24098
24099 src = (((Opcode >> 9) - 1) & 7) + 1;
24100 adr = AREG((Opcode >> 0) & 7);
24101 DECODE_EXT_WORD
24102 PRE_IO
24103 READ_WORD_F(adr, dst)
24104 res = dst + src;
24105 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24106 flag_N = flag_X = flag_C = res >> 8;
24107 flag_NotZ = res & 0xFFFF;
24108 WRITE_WORD_F(adr, res)
24109 POST_IO
24110RET(18)
24111}
24112
24113// ADDQ
24114OPCODE(0x5078)
24115{
24116 u32 adr, res;
24117 u32 src, dst;
24118
24119 src = (((Opcode >> 9) - 1) & 7) + 1;
24120 FETCH_SWORD(adr);
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(16)
24130}
24131
24132// ADDQ
24133OPCODE(0x5079)
24134{
24135 u32 adr, res;
24136 u32 src, dst;
24137
24138 src = (((Opcode >> 9) - 1) & 7) + 1;
24139 FETCH_LONG(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(20)
24149}
24150
24151// ADDQ
24152OPCODE(0x505F)
24153{
24154 u32 adr, res;
24155 u32 src, dst;
24156
24157 src = (((Opcode >> 9) - 1) & 7) + 1;
24158 adr = AREG(7);
24159 AREG(7) += 2;
24160 PRE_IO
24161 READ_WORD_F(adr, dst)
24162 res = dst + src;
24163 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24164 flag_N = flag_X = flag_C = res >> 8;
24165 flag_NotZ = res & 0xFFFF;
24166 WRITE_WORD_F(adr, res)
24167 POST_IO
24168RET(12)
24169}
24170
24171// ADDQ
24172OPCODE(0x5067)
24173{
24174 u32 adr, res;
24175 u32 src, dst;
24176
24177 src = (((Opcode >> 9) - 1) & 7) + 1;
24178 adr = AREG(7) - 2;
24179 AREG(7) = adr;
24180 PRE_IO
24181 READ_WORD_F(adr, dst)
24182 res = dst + src;
24183 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
24184 flag_N = flag_X = flag_C = res >> 8;
24185 flag_NotZ = res & 0xFFFF;
24186 WRITE_WORD_F(adr, res)
24187 POST_IO
24188RET(14)
24189}
24190
24191// ADDQ
24192OPCODE(0x5080)
24193{
24194 u32 adr, res;
24195 u32 src, dst;
24196
24197 src = (((Opcode >> 9) - 1) & 7) + 1;
24198 dst = DREGu32((Opcode >> 0) & 7);
24199 res = dst + src;
24200 flag_NotZ = res;
24201 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24202 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24203 flag_N = res >> 24;
24204 DREGu32((Opcode >> 0) & 7) = res;
24205RET(8)
24206}
24207
24208// ADDQ
24209OPCODE(0x5088)
24210{
24211 u32 adr, res;
24212 u32 src, dst;
24213
24214 src = (((Opcode >> 9) - 1) & 7) + 1;
24215 dst = AREGu32((Opcode >> 0) & 7);
24216 res = dst + src;
24217 AREG((Opcode >> 0) & 7) = res;
24218RET(8)
24219}
24220
24221// ADDQ
24222OPCODE(0x5090)
24223{
24224 u32 adr, res;
24225 u32 src, dst;
24226
24227 src = (((Opcode >> 9) - 1) & 7) + 1;
24228 adr = AREG((Opcode >> 0) & 7);
24229 PRE_IO
24230 READ_LONG_F(adr, dst)
24231 res = dst + src;
24232 flag_NotZ = res;
24233 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24234 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24235 flag_N = res >> 24;
24236 WRITE_LONG_F(adr, res)
24237 POST_IO
24238RET(20)
24239}
24240
24241// ADDQ
24242OPCODE(0x5098)
24243{
24244 u32 adr, res;
24245 u32 src, dst;
24246
24247 src = (((Opcode >> 9) - 1) & 7) + 1;
24248 adr = AREG((Opcode >> 0) & 7);
24249 AREG((Opcode >> 0) & 7) += 4;
24250 PRE_IO
24251 READ_LONG_F(adr, dst)
24252 res = dst + src;
24253 flag_NotZ = res;
24254 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24255 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24256 flag_N = res >> 24;
24257 WRITE_LONG_F(adr, res)
24258 POST_IO
24259RET(20)
24260}
24261
24262// ADDQ
24263OPCODE(0x50A0)
24264{
24265 u32 adr, res;
24266 u32 src, dst;
24267
24268 src = (((Opcode >> 9) - 1) & 7) + 1;
24269 adr = AREG((Opcode >> 0) & 7) - 4;
24270 AREG((Opcode >> 0) & 7) = adr;
24271 PRE_IO
24272 READ_LONG_F(adr, dst)
24273 res = dst + src;
24274 flag_NotZ = res;
24275 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24276 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24277 flag_N = res >> 24;
24278 WRITE_LONG_F(adr, res)
24279 POST_IO
24280RET(22)
24281}
24282
24283// ADDQ
24284OPCODE(0x50A8)
24285{
24286 u32 adr, res;
24287 u32 src, dst;
24288
24289 src = (((Opcode >> 9) - 1) & 7) + 1;
24290 FETCH_SWORD(adr);
24291 adr += AREG((Opcode >> 0) & 7);
24292 PRE_IO
24293 READ_LONG_F(adr, dst)
24294 res = dst + src;
24295 flag_NotZ = res;
24296 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24297 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24298 flag_N = res >> 24;
24299 WRITE_LONG_F(adr, res)
24300 POST_IO
24301RET(24)
24302}
24303
24304// ADDQ
24305OPCODE(0x50B0)
24306{
24307 u32 adr, res;
24308 u32 src, dst;
24309
24310 src = (((Opcode >> 9) - 1) & 7) + 1;
24311 adr = AREG((Opcode >> 0) & 7);
24312 DECODE_EXT_WORD
24313 PRE_IO
24314 READ_LONG_F(adr, dst)
24315 res = dst + src;
24316 flag_NotZ = res;
24317 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24318 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24319 flag_N = res >> 24;
24320 WRITE_LONG_F(adr, res)
24321 POST_IO
24322RET(26)
24323}
24324
24325// ADDQ
24326OPCODE(0x50B8)
24327{
24328 u32 adr, res;
24329 u32 src, dst;
24330
24331 src = (((Opcode >> 9) - 1) & 7) + 1;
24332 FETCH_SWORD(adr);
24333 PRE_IO
24334 READ_LONG_F(adr, dst)
24335 res = dst + src;
24336 flag_NotZ = res;
24337 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24338 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24339 flag_N = res >> 24;
24340 WRITE_LONG_F(adr, res)
24341 POST_IO
24342RET(24)
24343}
24344
24345// ADDQ
24346OPCODE(0x50B9)
24347{
24348 u32 adr, res;
24349 u32 src, dst;
24350
24351 src = (((Opcode >> 9) - 1) & 7) + 1;
24352 FETCH_LONG(adr);
24353 PRE_IO
24354 READ_LONG_F(adr, dst)
24355 res = dst + src;
24356 flag_NotZ = res;
24357 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24358 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24359 flag_N = res >> 24;
24360 WRITE_LONG_F(adr, res)
24361 POST_IO
24362RET(28)
24363}
24364
24365// ADDQ
24366OPCODE(0x509F)
24367{
24368 u32 adr, res;
24369 u32 src, dst;
24370
24371 src = (((Opcode >> 9) - 1) & 7) + 1;
24372 adr = AREG(7);
24373 AREG(7) += 4;
24374 PRE_IO
24375 READ_LONG_F(adr, dst)
24376 res = dst + src;
24377 flag_NotZ = res;
24378 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24379 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24380 flag_N = res >> 24;
24381 WRITE_LONG_F(adr, res)
24382 POST_IO
24383RET(20)
24384}
24385
24386// ADDQ
24387OPCODE(0x50A7)
24388{
24389 u32 adr, res;
24390 u32 src, dst;
24391
24392 src = (((Opcode >> 9) - 1) & 7) + 1;
24393 adr = AREG(7) - 4;
24394 AREG(7) = adr;
24395 PRE_IO
24396 READ_LONG_F(adr, dst)
24397 res = dst + src;
24398 flag_NotZ = res;
24399 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
24400 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
24401 flag_N = res >> 24;
24402 WRITE_LONG_F(adr, res)
24403 POST_IO
24404RET(22)
24405}
24406
24407// SUBQ
24408OPCODE(0x5100)
24409{
24410 u32 adr, res;
24411 u32 src, dst;
24412
24413 src = (((Opcode >> 9) - 1) & 7) + 1;
24414 dst = DREGu8((Opcode >> 0) & 7);
24415 res = dst - src;
24416 flag_N = flag_X = flag_C = res;
24417 flag_V = (src ^ dst) & (res ^ dst);
24418 flag_NotZ = res & 0xFF;
24419 DREGu8((Opcode >> 0) & 7) = res;
24420RET(4)
24421}
24422
24423// SUBQ
24424OPCODE(0x5110)
24425{
24426 u32 adr, res;
24427 u32 src, dst;
24428
24429 src = (((Opcode >> 9) - 1) & 7) + 1;
24430 adr = AREG((Opcode >> 0) & 7);
24431 PRE_IO
24432 READ_BYTE_F(adr, dst)
24433 res = dst - src;
24434 flag_N = flag_X = flag_C = res;
24435 flag_V = (src ^ dst) & (res ^ dst);
24436 flag_NotZ = res & 0xFF;
24437 WRITE_BYTE_F(adr, res)
24438 POST_IO
24439RET(12)
24440}
24441
24442// SUBQ
24443OPCODE(0x5118)
24444{
24445 u32 adr, res;
24446 u32 src, dst;
24447
24448 src = (((Opcode >> 9) - 1) & 7) + 1;
24449 adr = AREG((Opcode >> 0) & 7);
24450 AREG((Opcode >> 0) & 7) += 1;
24451 PRE_IO
24452 READ_BYTE_F(adr, dst)
24453 res = dst - src;
24454 flag_N = flag_X = flag_C = res;
24455 flag_V = (src ^ dst) & (res ^ dst);
24456 flag_NotZ = res & 0xFF;
24457 WRITE_BYTE_F(adr, res)
24458 POST_IO
24459RET(12)
24460}
24461
24462// SUBQ
24463OPCODE(0x5120)
24464{
24465 u32 adr, res;
24466 u32 src, dst;
24467
24468 src = (((Opcode >> 9) - 1) & 7) + 1;
24469 adr = AREG((Opcode >> 0) & 7) - 1;
24470 AREG((Opcode >> 0) & 7) = adr;
24471 PRE_IO
24472 READ_BYTE_F(adr, dst)
24473 res = dst - src;
24474 flag_N = flag_X = flag_C = res;
24475 flag_V = (src ^ dst) & (res ^ dst);
24476 flag_NotZ = res & 0xFF;
24477 WRITE_BYTE_F(adr, res)
24478 POST_IO
24479RET(14)
24480}
24481
24482// SUBQ
24483OPCODE(0x5128)
24484{
24485 u32 adr, res;
24486 u32 src, dst;
24487
24488 src = (((Opcode >> 9) - 1) & 7) + 1;
24489 FETCH_SWORD(adr);
24490 adr += AREG((Opcode >> 0) & 7);
24491 PRE_IO
24492 READ_BYTE_F(adr, dst)
24493 res = dst - src;
24494 flag_N = flag_X = flag_C = res;
24495 flag_V = (src ^ dst) & (res ^ dst);
24496 flag_NotZ = res & 0xFF;
24497 WRITE_BYTE_F(adr, res)
24498 POST_IO
24499RET(16)
24500}
24501
24502// SUBQ
24503OPCODE(0x5130)
24504{
24505 u32 adr, res;
24506 u32 src, dst;
24507
24508 src = (((Opcode >> 9) - 1) & 7) + 1;
24509 adr = AREG((Opcode >> 0) & 7);
24510 DECODE_EXT_WORD
24511 PRE_IO
24512 READ_BYTE_F(adr, dst)
24513 res = dst - src;
24514 flag_N = flag_X = flag_C = res;
24515 flag_V = (src ^ dst) & (res ^ dst);
24516 flag_NotZ = res & 0xFF;
24517 WRITE_BYTE_F(adr, res)
24518 POST_IO
24519RET(18)
24520}
24521
24522// SUBQ
24523OPCODE(0x5138)
24524{
24525 u32 adr, res;
24526 u32 src, dst;
24527
24528 src = (((Opcode >> 9) - 1) & 7) + 1;
24529 FETCH_SWORD(adr);
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(16)
24539}
24540
24541// SUBQ
24542OPCODE(0x5139)
24543{
24544 u32 adr, res;
24545 u32 src, dst;
24546
24547 src = (((Opcode >> 9) - 1) & 7) + 1;
24548 FETCH_LONG(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(20)
24558}
24559
24560// SUBQ
24561OPCODE(0x511F)
24562{
24563 u32 adr, res;
24564 u32 src, dst;
24565
24566 src = (((Opcode >> 9) - 1) & 7) + 1;
24567 adr = AREG(7);
24568 AREG(7) += 2;
24569 PRE_IO
24570 READ_BYTE_F(adr, dst)
24571 res = dst - src;
24572 flag_N = flag_X = flag_C = res;
24573 flag_V = (src ^ dst) & (res ^ dst);
24574 flag_NotZ = res & 0xFF;
24575 WRITE_BYTE_F(adr, res)
24576 POST_IO
24577RET(12)
24578}
24579
24580// SUBQ
24581OPCODE(0x5127)
24582{
24583 u32 adr, res;
24584 u32 src, dst;
24585
24586 src = (((Opcode >> 9) - 1) & 7) + 1;
24587 adr = AREG(7) - 2;
24588 AREG(7) = adr;
24589 PRE_IO
24590 READ_BYTE_F(adr, dst)
24591 res = dst - src;
24592 flag_N = flag_X = flag_C = res;
24593 flag_V = (src ^ dst) & (res ^ dst);
24594 flag_NotZ = res & 0xFF;
24595 WRITE_BYTE_F(adr, res)
24596 POST_IO
24597RET(14)
24598}
24599
24600// SUBQ
24601OPCODE(0x5140)
24602{
24603 u32 adr, res;
24604 u32 src, dst;
24605
24606 src = (((Opcode >> 9) - 1) & 7) + 1;
24607 dst = DREGu16((Opcode >> 0) & 7);
24608 res = dst - src;
24609 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24610 flag_N = flag_X = flag_C = res >> 8;
24611 flag_NotZ = res & 0xFFFF;
24612 DREGu16((Opcode >> 0) & 7) = res;
24613RET(4)
24614}
24615
24616// SUBQ
24617OPCODE(0x5148)
24618{
24619 u32 adr, res;
24620 u32 src, dst;
24621
24622 src = (((Opcode >> 9) - 1) & 7) + 1;
24623 dst = AREGu32((Opcode >> 0) & 7);
24624 res = dst - src;
24625 AREG((Opcode >> 0) & 7) = res;
24626RET(8)
24627}
24628
24629// SUBQ
24630OPCODE(0x5150)
24631{
24632 u32 adr, res;
24633 u32 src, dst;
24634
24635 src = (((Opcode >> 9) - 1) & 7) + 1;
24636 adr = AREG((Opcode >> 0) & 7);
24637 PRE_IO
24638 READ_WORD_F(adr, dst)
24639 res = dst - src;
24640 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24641 flag_N = flag_X = flag_C = res >> 8;
24642 flag_NotZ = res & 0xFFFF;
24643 WRITE_WORD_F(adr, res)
24644 POST_IO
24645RET(12)
24646}
24647
24648// SUBQ
24649OPCODE(0x5158)
24650{
24651 u32 adr, res;
24652 u32 src, dst;
24653
24654 src = (((Opcode >> 9) - 1) & 7) + 1;
24655 adr = AREG((Opcode >> 0) & 7);
24656 AREG((Opcode >> 0) & 7) += 2;
24657 PRE_IO
24658 READ_WORD_F(adr, dst)
24659 res = dst - src;
24660 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24661 flag_N = flag_X = flag_C = res >> 8;
24662 flag_NotZ = res & 0xFFFF;
24663 WRITE_WORD_F(adr, res)
24664 POST_IO
24665RET(12)
24666}
24667
24668// SUBQ
24669OPCODE(0x5160)
24670{
24671 u32 adr, res;
24672 u32 src, dst;
24673
24674 src = (((Opcode >> 9) - 1) & 7) + 1;
24675 adr = AREG((Opcode >> 0) & 7) - 2;
24676 AREG((Opcode >> 0) & 7) = adr;
24677 PRE_IO
24678 READ_WORD_F(adr, dst)
24679 res = dst - src;
24680 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24681 flag_N = flag_X = flag_C = res >> 8;
24682 flag_NotZ = res & 0xFFFF;
24683 WRITE_WORD_F(adr, res)
24684 POST_IO
24685RET(14)
24686}
24687
24688// SUBQ
24689OPCODE(0x5168)
24690{
24691 u32 adr, res;
24692 u32 src, dst;
24693
24694 src = (((Opcode >> 9) - 1) & 7) + 1;
24695 FETCH_SWORD(adr);
24696 adr += AREG((Opcode >> 0) & 7);
24697 PRE_IO
24698 READ_WORD_F(adr, dst)
24699 res = dst - src;
24700 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24701 flag_N = flag_X = flag_C = res >> 8;
24702 flag_NotZ = res & 0xFFFF;
24703 WRITE_WORD_F(adr, res)
24704 POST_IO
24705RET(16)
24706}
24707
24708// SUBQ
24709OPCODE(0x5170)
24710{
24711 u32 adr, res;
24712 u32 src, dst;
24713
24714 src = (((Opcode >> 9) - 1) & 7) + 1;
24715 adr = AREG((Opcode >> 0) & 7);
24716 DECODE_EXT_WORD
24717 PRE_IO
24718 READ_WORD_F(adr, dst)
24719 res = dst - src;
24720 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24721 flag_N = flag_X = flag_C = res >> 8;
24722 flag_NotZ = res & 0xFFFF;
24723 WRITE_WORD_F(adr, res)
24724 POST_IO
24725RET(18)
24726}
24727
24728// SUBQ
24729OPCODE(0x5178)
24730{
24731 u32 adr, res;
24732 u32 src, dst;
24733
24734 src = (((Opcode >> 9) - 1) & 7) + 1;
24735 FETCH_SWORD(adr);
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(16)
24745}
24746
24747// SUBQ
24748OPCODE(0x5179)
24749{
24750 u32 adr, res;
24751 u32 src, dst;
24752
24753 src = (((Opcode >> 9) - 1) & 7) + 1;
24754 FETCH_LONG(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(20)
24764}
24765
24766// SUBQ
24767OPCODE(0x515F)
24768{
24769 u32 adr, res;
24770 u32 src, dst;
24771
24772 src = (((Opcode >> 9) - 1) & 7) + 1;
24773 adr = AREG(7);
24774 AREG(7) += 2;
24775 PRE_IO
24776 READ_WORD_F(adr, dst)
24777 res = dst - src;
24778 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24779 flag_N = flag_X = flag_C = res >> 8;
24780 flag_NotZ = res & 0xFFFF;
24781 WRITE_WORD_F(adr, res)
24782 POST_IO
24783RET(12)
24784}
24785
24786// SUBQ
24787OPCODE(0x5167)
24788{
24789 u32 adr, res;
24790 u32 src, dst;
24791
24792 src = (((Opcode >> 9) - 1) & 7) + 1;
24793 adr = AREG(7) - 2;
24794 AREG(7) = adr;
24795 PRE_IO
24796 READ_WORD_F(adr, dst)
24797 res = dst - src;
24798 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
24799 flag_N = flag_X = flag_C = res >> 8;
24800 flag_NotZ = res & 0xFFFF;
24801 WRITE_WORD_F(adr, res)
24802 POST_IO
24803RET(14)
24804}
24805
24806// SUBQ
24807OPCODE(0x5180)
24808{
24809 u32 adr, res;
24810 u32 src, dst;
24811
24812 src = (((Opcode >> 9) - 1) & 7) + 1;
24813 dst = DREGu32((Opcode >> 0) & 7);
24814 res = dst - src;
24815 flag_NotZ = res;
24816 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24817 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24818 flag_N = res >> 24;
24819 DREGu32((Opcode >> 0) & 7) = res;
24820RET(8)
24821}
24822
24823// SUBQ
24824OPCODE(0x5188)
24825{
24826 u32 adr, res;
24827 u32 src, dst;
24828
24829 src = (((Opcode >> 9) - 1) & 7) + 1;
24830 dst = AREGu32((Opcode >> 0) & 7);
24831 res = dst - src;
24832 AREG((Opcode >> 0) & 7) = res;
24833RET(8)
24834}
24835
24836// SUBQ
24837OPCODE(0x5190)
24838{
24839 u32 adr, res;
24840 u32 src, dst;
24841
24842 src = (((Opcode >> 9) - 1) & 7) + 1;
24843 adr = AREG((Opcode >> 0) & 7);
24844 PRE_IO
24845 READ_LONG_F(adr, dst)
24846 res = dst - src;
24847 flag_NotZ = res;
24848 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24849 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24850 flag_N = res >> 24;
24851 WRITE_LONG_F(adr, res)
24852 POST_IO
24853RET(20)
24854}
24855
24856// SUBQ
24857OPCODE(0x5198)
24858{
24859 u32 adr, res;
24860 u32 src, dst;
24861
24862 src = (((Opcode >> 9) - 1) & 7) + 1;
24863 adr = AREG((Opcode >> 0) & 7);
24864 AREG((Opcode >> 0) & 7) += 4;
24865 PRE_IO
24866 READ_LONG_F(adr, dst)
24867 res = dst - src;
24868 flag_NotZ = res;
24869 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24870 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24871 flag_N = res >> 24;
24872 WRITE_LONG_F(adr, res)
24873 POST_IO
24874RET(20)
24875}
24876
24877// SUBQ
24878OPCODE(0x51A0)
24879{
24880 u32 adr, res;
24881 u32 src, dst;
24882
24883 src = (((Opcode >> 9) - 1) & 7) + 1;
24884 adr = AREG((Opcode >> 0) & 7) - 4;
24885 AREG((Opcode >> 0) & 7) = adr;
24886 PRE_IO
24887 READ_LONG_F(adr, dst)
24888 res = dst - src;
24889 flag_NotZ = res;
24890 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24891 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24892 flag_N = res >> 24;
24893 WRITE_LONG_F(adr, res)
24894 POST_IO
24895RET(22)
24896}
24897
24898// SUBQ
24899OPCODE(0x51A8)
24900{
24901 u32 adr, res;
24902 u32 src, dst;
24903
24904 src = (((Opcode >> 9) - 1) & 7) + 1;
24905 FETCH_SWORD(adr);
24906 adr += AREG((Opcode >> 0) & 7);
24907 PRE_IO
24908 READ_LONG_F(adr, dst)
24909 res = dst - src;
24910 flag_NotZ = res;
24911 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24912 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24913 flag_N = res >> 24;
24914 WRITE_LONG_F(adr, res)
24915 POST_IO
24916RET(24)
24917}
24918
24919// SUBQ
24920OPCODE(0x51B0)
24921{
24922 u32 adr, res;
24923 u32 src, dst;
24924
24925 src = (((Opcode >> 9) - 1) & 7) + 1;
24926 adr = AREG((Opcode >> 0) & 7);
24927 DECODE_EXT_WORD
24928 PRE_IO
24929 READ_LONG_F(adr, dst)
24930 res = dst - src;
24931 flag_NotZ = res;
24932 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24933 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24934 flag_N = res >> 24;
24935 WRITE_LONG_F(adr, res)
24936 POST_IO
24937RET(26)
24938}
24939
24940// SUBQ
24941OPCODE(0x51B8)
24942{
24943 u32 adr, res;
24944 u32 src, dst;
24945
24946 src = (((Opcode >> 9) - 1) & 7) + 1;
24947 FETCH_SWORD(adr);
24948 PRE_IO
24949 READ_LONG_F(adr, dst)
24950 res = dst - src;
24951 flag_NotZ = res;
24952 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24953 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24954 flag_N = res >> 24;
24955 WRITE_LONG_F(adr, res)
24956 POST_IO
24957RET(24)
24958}
24959
24960// SUBQ
24961OPCODE(0x51B9)
24962{
24963 u32 adr, res;
24964 u32 src, dst;
24965
24966 src = (((Opcode >> 9) - 1) & 7) + 1;
24967 FETCH_LONG(adr);
24968 PRE_IO
24969 READ_LONG_F(adr, dst)
24970 res = dst - src;
24971 flag_NotZ = res;
24972 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24973 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24974 flag_N = res >> 24;
24975 WRITE_LONG_F(adr, res)
24976 POST_IO
24977RET(28)
24978}
24979
24980// SUBQ
24981OPCODE(0x519F)
24982{
24983 u32 adr, res;
24984 u32 src, dst;
24985
24986 src = (((Opcode >> 9) - 1) & 7) + 1;
24987 adr = AREG(7);
24988 AREG(7) += 4;
24989 PRE_IO
24990 READ_LONG_F(adr, dst)
24991 res = dst - src;
24992 flag_NotZ = res;
24993 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
24994 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
24995 flag_N = res >> 24;
24996 WRITE_LONG_F(adr, res)
24997 POST_IO
24998RET(20)
24999}
25000
25001// SUBQ
25002OPCODE(0x51A7)
25003{
25004 u32 adr, res;
25005 u32 src, dst;
25006
25007 src = (((Opcode >> 9) - 1) & 7) + 1;
25008 adr = AREG(7) - 4;
25009 AREG(7) = adr;
25010 PRE_IO
25011 READ_LONG_F(adr, dst)
25012 res = dst - src;
25013 flag_NotZ = res;
25014 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
25015 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
25016 flag_N = res >> 24;
25017 WRITE_LONG_F(adr, res)
25018 POST_IO
25019RET(22)
25020}
25021
25022// BCC
25023OPCODE(0x6201)
25024{
25025 u32 adr, res;
25026 u32 src, dst;
25027
25028 if (flag_NotZ && (!(flag_C & 0x100)))
25029 {
25030 PC += ((s8)(Opcode & 0xFE)) >> 1;
25031 m68kcontext.io_cycle_counter -= 2;
25032 }
25033RET(8)
25034}
25035
25036// BCC
25037OPCODE(0x6301)
25038{
25039 u32 adr, res;
25040 u32 src, dst;
25041
25042 if ((!flag_NotZ) || (flag_C & 0x100))
25043 {
25044 PC += ((s8)(Opcode & 0xFE)) >> 1;
25045 m68kcontext.io_cycle_counter -= 2;
25046 }
25047RET(8)
25048}
25049
25050// BCC
25051OPCODE(0x6401)
25052{
25053 u32 adr, res;
25054 u32 src, dst;
25055
25056 if (!(flag_C & 0x100))
25057 {
25058 PC += ((s8)(Opcode & 0xFE)) >> 1;
25059 m68kcontext.io_cycle_counter -= 2;
25060 }
25061RET(8)
25062}
25063
25064// BCC
25065OPCODE(0x6501)
25066{
25067 u32 adr, res;
25068 u32 src, dst;
25069
25070 if (flag_C & 0x100)
25071 {
25072 PC += ((s8)(Opcode & 0xFE)) >> 1;
25073 m68kcontext.io_cycle_counter -= 2;
25074 }
25075RET(8)
25076}
25077
25078// BCC
25079OPCODE(0x6601)
25080{
25081 u32 adr, res;
25082 u32 src, dst;
25083
25084 if (flag_NotZ)
25085 {
25086 PC += ((s8)(Opcode & 0xFE)) >> 1;
25087 m68kcontext.io_cycle_counter -= 2;
25088 }
25089RET(8)
25090}
25091
25092// BCC
25093OPCODE(0x6701)
25094{
25095 u32 adr, res;
25096 u32 src, dst;
25097
25098 if (!flag_NotZ)
25099 {
25100 PC += ((s8)(Opcode & 0xFE)) >> 1;
25101 m68kcontext.io_cycle_counter -= 2;
25102 }
25103RET(8)
25104}
25105
25106// BCC
25107OPCODE(0x6801)
25108{
25109 u32 adr, res;
25110 u32 src, dst;
25111
25112 if (!(flag_V & 0x80))
25113 {
25114 PC += ((s8)(Opcode & 0xFE)) >> 1;
25115 m68kcontext.io_cycle_counter -= 2;
25116 }
25117RET(8)
25118}
25119
25120// BCC
25121OPCODE(0x6901)
25122{
25123 u32 adr, res;
25124 u32 src, dst;
25125
25126 if (flag_V & 0x80)
25127 {
25128 PC += ((s8)(Opcode & 0xFE)) >> 1;
25129 m68kcontext.io_cycle_counter -= 2;
25130 }
25131RET(8)
25132}
25133
25134// BCC
25135OPCODE(0x6A01)
25136{
25137 u32 adr, res;
25138 u32 src, dst;
25139
25140 if (!(flag_N & 0x80))
25141 {
25142 PC += ((s8)(Opcode & 0xFE)) >> 1;
25143 m68kcontext.io_cycle_counter -= 2;
25144 }
25145RET(8)
25146}
25147
25148// BCC
25149OPCODE(0x6B01)
25150{
25151 u32 adr, res;
25152 u32 src, dst;
25153
25154 if (flag_N & 0x80)
25155 {
25156 PC += ((s8)(Opcode & 0xFE)) >> 1;
25157 m68kcontext.io_cycle_counter -= 2;
25158 }
25159RET(8)
25160}
25161
25162// BCC
25163OPCODE(0x6C01)
25164{
25165 u32 adr, res;
25166 u32 src, dst;
25167
25168 if (!((flag_N ^ flag_V) & 0x80))
25169 {
25170 PC += ((s8)(Opcode & 0xFE)) >> 1;
25171 m68kcontext.io_cycle_counter -= 2;
25172 }
25173RET(8)
25174}
25175
25176// BCC
25177OPCODE(0x6D01)
25178{
25179 u32 adr, res;
25180 u32 src, dst;
25181
25182 if ((flag_N ^ flag_V) & 0x80)
25183 {
25184 PC += ((s8)(Opcode & 0xFE)) >> 1;
25185 m68kcontext.io_cycle_counter -= 2;
25186 }
25187RET(8)
25188}
25189
25190// BCC
25191OPCODE(0x6E01)
25192{
25193 u32 adr, res;
25194 u32 src, dst;
25195
25196 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25197 {
25198 PC += ((s8)(Opcode & 0xFE)) >> 1;
25199 m68kcontext.io_cycle_counter -= 2;
25200 }
25201RET(8)
25202}
25203
25204// BCC
25205OPCODE(0x6F01)
25206{
25207 u32 adr, res;
25208 u32 src, dst;
25209
25210 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25211 {
25212 PC += ((s8)(Opcode & 0xFE)) >> 1;
25213 m68kcontext.io_cycle_counter -= 2;
25214 }
25215RET(8)
25216}
25217
25218// BCC16
25219OPCODE(0x6200)
25220{
25221 u32 adr, res;
25222 u32 src, dst;
25223
25224 if (flag_NotZ && (!(flag_C & 0x100)))
25225 {
25226 u32 newPC;
25227
be26eb23 25228 newPC = GET_PC;
70357ce5 25229 newPC += GET_SWORD;
25230 SET_PC(newPC);
25231 CHECK_BRANCH_EXCEPTION(newPC)
25232 RET(10)
25233 }
25234 PC++;
25235RET(12)
25236}
25237
25238// BCC16
25239OPCODE(0x6300)
25240{
25241 u32 adr, res;
25242 u32 src, dst;
25243
25244 if ((!flag_NotZ) || (flag_C & 0x100))
25245 {
25246 u32 newPC;
25247
be26eb23 25248 newPC = GET_PC;
70357ce5 25249 newPC += GET_SWORD;
25250 SET_PC(newPC);
25251 CHECK_BRANCH_EXCEPTION(newPC)
25252 RET(10)
25253 }
25254 PC++;
25255RET(12)
25256}
25257
25258// BCC16
25259OPCODE(0x6400)
25260{
25261 u32 adr, res;
25262 u32 src, dst;
25263
25264 if (!(flag_C & 0x100))
25265 {
25266 u32 newPC;
25267
be26eb23 25268 newPC = GET_PC;
70357ce5 25269 newPC += GET_SWORD;
25270 SET_PC(newPC);
25271 CHECK_BRANCH_EXCEPTION(newPC)
25272 RET(10)
25273 }
25274 PC++;
25275RET(12)
25276}
25277
25278// BCC16
25279OPCODE(0x6500)
25280{
25281 u32 adr, res;
25282 u32 src, dst;
25283
25284 if (flag_C & 0x100)
25285 {
25286 u32 newPC;
25287
be26eb23 25288 newPC = GET_PC;
70357ce5 25289 newPC += GET_SWORD;
25290 SET_PC(newPC);
25291 CHECK_BRANCH_EXCEPTION(newPC)
25292 RET(10)
25293 }
25294 PC++;
25295RET(12)
25296}
25297
25298// BCC16
25299OPCODE(0x6600)
25300{
25301 u32 adr, res;
25302 u32 src, dst;
25303
25304 if (flag_NotZ)
25305 {
25306 u32 newPC;
25307
be26eb23 25308 newPC = GET_PC;
70357ce5 25309 newPC += GET_SWORD;
25310 SET_PC(newPC);
25311 CHECK_BRANCH_EXCEPTION(newPC)
25312 RET(10)
25313 }
25314 PC++;
25315RET(12)
25316}
25317
25318// BCC16
25319OPCODE(0x6700)
25320{
25321 u32 adr, res;
25322 u32 src, dst;
25323
25324 if (!flag_NotZ)
25325 {
25326 u32 newPC;
25327
be26eb23 25328 newPC = GET_PC;
70357ce5 25329 newPC += GET_SWORD;
25330 SET_PC(newPC);
25331 CHECK_BRANCH_EXCEPTION(newPC)
25332 RET(10)
25333 }
25334 PC++;
25335RET(12)
25336}
25337
25338// BCC16
25339OPCODE(0x6800)
25340{
25341 u32 adr, res;
25342 u32 src, dst;
25343
25344 if (!(flag_V & 0x80))
25345 {
25346 u32 newPC;
25347
be26eb23 25348 newPC = GET_PC;
70357ce5 25349 newPC += GET_SWORD;
25350 SET_PC(newPC);
25351 CHECK_BRANCH_EXCEPTION(newPC)
25352 RET(10)
25353 }
25354 PC++;
25355RET(12)
25356}
25357
25358// BCC16
25359OPCODE(0x6900)
25360{
25361 u32 adr, res;
25362 u32 src, dst;
25363
25364 if (flag_V & 0x80)
25365 {
25366 u32 newPC;
25367
be26eb23 25368 newPC = GET_PC;
70357ce5 25369 newPC += GET_SWORD;
25370 SET_PC(newPC);
25371 CHECK_BRANCH_EXCEPTION(newPC)
25372 RET(10)
25373 }
25374 PC++;
25375RET(12)
25376}
25377
25378// BCC16
25379OPCODE(0x6A00)
25380{
25381 u32 adr, res;
25382 u32 src, dst;
25383
25384 if (!(flag_N & 0x80))
25385 {
25386 u32 newPC;
25387
be26eb23 25388 newPC = GET_PC;
70357ce5 25389 newPC += GET_SWORD;
25390 SET_PC(newPC);
25391 CHECK_BRANCH_EXCEPTION(newPC)
25392 RET(10)
25393 }
25394 PC++;
25395RET(12)
25396}
25397
25398// BCC16
25399OPCODE(0x6B00)
25400{
25401 u32 adr, res;
25402 u32 src, dst;
25403
25404 if (flag_N & 0x80)
25405 {
25406 u32 newPC;
25407
be26eb23 25408 newPC = GET_PC;
70357ce5 25409 newPC += GET_SWORD;
25410 SET_PC(newPC);
25411 CHECK_BRANCH_EXCEPTION(newPC)
25412 RET(10)
25413 }
25414 PC++;
25415RET(12)
25416}
25417
25418// BCC16
25419OPCODE(0x6C00)
25420{
25421 u32 adr, res;
25422 u32 src, dst;
25423
25424 if (!((flag_N ^ flag_V) & 0x80))
25425 {
25426 u32 newPC;
25427
be26eb23 25428 newPC = GET_PC;
70357ce5 25429 newPC += GET_SWORD;
25430 SET_PC(newPC);
25431 CHECK_BRANCH_EXCEPTION(newPC)
25432 RET(10)
25433 }
25434 PC++;
25435RET(12)
25436}
25437
25438// BCC16
25439OPCODE(0x6D00)
25440{
25441 u32 adr, res;
25442 u32 src, dst;
25443
25444 if ((flag_N ^ flag_V) & 0x80)
25445 {
25446 u32 newPC;
25447
be26eb23 25448 newPC = GET_PC;
70357ce5 25449 newPC += GET_SWORD;
25450 SET_PC(newPC);
25451 CHECK_BRANCH_EXCEPTION(newPC)
25452 RET(10)
25453 }
25454 PC++;
25455RET(12)
25456}
25457
25458// BCC16
25459OPCODE(0x6E00)
25460{
25461 u32 adr, res;
25462 u32 src, dst;
25463
25464 if (flag_NotZ && (!((flag_N ^ flag_V) & 0x80)))
25465 {
25466 u32 newPC;
25467
be26eb23 25468 newPC = GET_PC;
70357ce5 25469 newPC += GET_SWORD;
25470 SET_PC(newPC);
25471 CHECK_BRANCH_EXCEPTION(newPC)
25472 RET(10)
25473 }
25474 PC++;
25475RET(12)
25476}
25477
25478// BCC16
25479OPCODE(0x6F00)
25480{
25481 u32 adr, res;
25482 u32 src, dst;
25483
25484 if ((!flag_NotZ) || ((flag_N ^ flag_V) & 0x80))
25485 {
25486 u32 newPC;
25487
be26eb23 25488 newPC = GET_PC;
70357ce5 25489 newPC += GET_SWORD;
25490 SET_PC(newPC);
25491 CHECK_BRANCH_EXCEPTION(newPC)
25492 RET(10)
25493 }
25494 PC++;
25495RET(12)
25496}
25497
25498// BRA
25499OPCODE(0x6001)
25500{
25501#ifdef FAMEC_CHECK_BRANCHES
be26eb23 25502 u32 newPC = GET_PC;
70357ce5 25503 s8 offs=Opcode;
25504 newPC += offs;
25505 SET_PC(newPC);
25506 CHECK_BRANCH_EXCEPTION(offs)
25507#else
25508 PC += ((s8)(Opcode & 0xFE)) >> 1;
25509#endif
25510RET(10)
25511}
25512
25513// BRA16
25514OPCODE(0x6000)
25515{
25516 u32 adr, res;
25517 u32 src, dst;
25518
25519 {
25520 u32 newPC;
25521
be26eb23 25522 newPC = GET_PC;
70357ce5 25523 newPC += GET_SWORD;
25524 SET_PC(newPC);
25525 CHECK_BRANCH_EXCEPTION(newPC)
25526 }
25527RET(10)
25528}
25529
25530// BSR
25531OPCODE(0x6101)
25532{
25533 u32 adr, res;
25534 u32 src, dst;
25535 u32 oldPC;
25536 s8 offs;
25537
25538 PRE_IO
25539
be26eb23 25540 oldPC = GET_PC;
70357ce5 25541 PUSH_32_F(oldPC)
25542#ifdef FAMEC_CHECK_BRANCHES
25543 offs = Opcode;
25544 oldPC += offs;
25545 SET_PC(oldPC);
25546 CHECK_BRANCH_EXCEPTION(offs)
25547#else
25548 PC += ((s8)(Opcode & 0xFE)) >> 1;
25549#endif
25550 POST_IO
25551RET(18)
25552}
25553
25554// BSR16
25555OPCODE(0x6100)
25556{
25557 u32 adr, res;
25558 u32 src, dst;
25559
25560 PRE_IO
25561 {
25562 u32 oldPC, newPC;
25563
be26eb23 25564 newPC = GET_PC;
70357ce5 25565 oldPC = newPC + 2;
25566 PUSH_32_F(oldPC)
25567 newPC += GET_SWORD;
25568 SET_PC(newPC);
25569 CHECK_BRANCH_EXCEPTION(newPC)
25570 }
25571 POST_IO
25572RET(18)
25573}
25574
25575// MOVEQ
25576OPCODE(0x7000)
25577{
25578 u32 adr, res;
25579 u32 src, dst;
25580
25581 res = (s32)(s8)Opcode;
25582 flag_C = flag_V = 0;
25583 flag_N = flag_NotZ = res;
25584 DREGu32((Opcode >> 9) & 7) = res;
25585RET(4)
25586}
25587
25588// ORaD
25589OPCODE(0x8000)
25590{
25591 u32 adr, res;
25592 u32 src, dst;
25593
25594 src = DREGu8((Opcode >> 0) & 7);
25595 res = DREGu8((Opcode >> 9) & 7);
25596 res |= src;
25597 flag_C = 0;
25598 flag_V = 0;
25599 flag_NotZ = res;
25600 flag_N = res;
25601 DREGu8((Opcode >> 9) & 7) = res;
25602RET(4)
25603}
25604
25605// ORaD
25606OPCODE(0x8010)
25607{
25608 u32 adr, res;
25609 u32 src, dst;
25610
25611 adr = AREG((Opcode >> 0) & 7);
25612 PRE_IO
25613 READ_BYTE_F(adr, src)
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;
25621 POST_IO
25622RET(8)
25623}
25624
25625// ORaD
25626OPCODE(0x8018)
25627{
25628 u32 adr, res;
25629 u32 src, dst;
25630
25631 adr = AREG((Opcode >> 0) & 7);
25632 AREG((Opcode >> 0) & 7) += 1;
25633 PRE_IO
25634 READ_BYTE_F(adr, src)
25635 res = DREGu8((Opcode >> 9) & 7);
25636 res |= src;
25637 flag_C = 0;
25638 flag_V = 0;
25639 flag_NotZ = res;
25640 flag_N = res;
25641 DREGu8((Opcode >> 9) & 7) = res;
25642 POST_IO
25643RET(8)
25644}
25645
25646// ORaD
25647OPCODE(0x8020)
25648{
25649 u32 adr, res;
25650 u32 src, dst;
25651
25652 adr = AREG((Opcode >> 0) & 7) - 1;
25653 AREG((Opcode >> 0) & 7) = adr;
25654 PRE_IO
25655 READ_BYTE_F(adr, src)
25656 res = DREGu8((Opcode >> 9) & 7);
25657 res |= src;
25658 flag_C = 0;
25659 flag_V = 0;
25660 flag_NotZ = res;
25661 flag_N = res;
25662 DREGu8((Opcode >> 9) & 7) = res;
25663 POST_IO
25664RET(10)
25665}
25666
25667// ORaD
25668OPCODE(0x8028)
25669{
25670 u32 adr, res;
25671 u32 src, dst;
25672
25673 FETCH_SWORD(adr);
25674 adr += AREG((Opcode >> 0) & 7);
25675 PRE_IO
25676 READ_BYTE_F(adr, src)
25677 res = DREGu8((Opcode >> 9) & 7);
25678 res |= src;
25679 flag_C = 0;
25680 flag_V = 0;
25681 flag_NotZ = res;
25682 flag_N = res;
25683 DREGu8((Opcode >> 9) & 7) = res;
25684 POST_IO
25685RET(12)
25686}
25687
25688// ORaD
25689OPCODE(0x8030)
25690{
25691 u32 adr, res;
25692 u32 src, dst;
25693
25694 adr = AREG((Opcode >> 0) & 7);
25695 DECODE_EXT_WORD
25696 PRE_IO
25697 READ_BYTE_F(adr, src)
25698 res = DREGu8((Opcode >> 9) & 7);
25699 res |= src;
25700 flag_C = 0;
25701 flag_V = 0;
25702 flag_NotZ = res;
25703 flag_N = res;
25704 DREGu8((Opcode >> 9) & 7) = res;
25705 POST_IO
25706RET(14)
25707}
25708
25709// ORaD
25710OPCODE(0x8038)
25711{
25712 u32 adr, res;
25713 u32 src, dst;
25714
25715 FETCH_SWORD(adr);
25716 PRE_IO
25717 READ_BYTE_F(adr, src)
25718 res = DREGu8((Opcode >> 9) & 7);
25719 res |= src;
25720 flag_C = 0;
25721 flag_V = 0;
25722 flag_NotZ = res;
25723 flag_N = res;
25724 DREGu8((Opcode >> 9) & 7) = res;
25725 POST_IO
25726RET(12)
25727}
25728
25729// ORaD
25730OPCODE(0x8039)
25731{
25732 u32 adr, res;
25733 u32 src, dst;
25734
25735 FETCH_LONG(adr);
25736 PRE_IO
25737 READ_BYTE_F(adr, src)
25738 res = DREGu8((Opcode >> 9) & 7);
25739 res |= src;
25740 flag_C = 0;
25741 flag_V = 0;
25742 flag_NotZ = res;
25743 flag_N = res;
25744 DREGu8((Opcode >> 9) & 7) = res;
25745 POST_IO
25746RET(16)
25747}
25748
25749// ORaD
25750OPCODE(0x803A)
25751{
25752 u32 adr, res;
25753 u32 src, dst;
25754
be26eb23 25755 adr = GET_SWORD + GET_PC;
70357ce5 25756 PC++;
25757 PRE_IO
25758 READ_BYTE_F(adr, src)
25759 res = DREGu8((Opcode >> 9) & 7);
25760 res |= src;
25761 flag_C = 0;
25762 flag_V = 0;
25763 flag_NotZ = res;
25764 flag_N = res;
25765 DREGu8((Opcode >> 9) & 7) = res;
25766 POST_IO
25767RET(12)
25768}
25769
25770// ORaD
25771OPCODE(0x803B)
25772{
25773 u32 adr, res;
25774 u32 src, dst;
25775
be26eb23 25776 adr = GET_PC;
70357ce5 25777 DECODE_EXT_WORD
25778 PRE_IO
25779 READ_BYTE_F(adr, src)
25780 res = DREGu8((Opcode >> 9) & 7);
25781 res |= src;
25782 flag_C = 0;
25783 flag_V = 0;
25784 flag_NotZ = res;
25785 flag_N = res;
25786 DREGu8((Opcode >> 9) & 7) = res;
25787 POST_IO
25788RET(14)
25789}
25790
25791// ORaD
25792OPCODE(0x803C)
25793{
25794 u32 adr, res;
25795 u32 src, dst;
25796
25797 FETCH_BYTE(src);
25798 res = DREGu8((Opcode >> 9) & 7);
25799 res |= src;
25800 flag_C = 0;
25801 flag_V = 0;
25802 flag_NotZ = res;
25803 flag_N = res;
25804 DREGu8((Opcode >> 9) & 7) = res;
25805RET(8)
25806}
25807
25808// ORaD
25809OPCODE(0x801F)
25810{
25811 u32 adr, res;
25812 u32 src, dst;
25813
25814 adr = AREG(7);
25815 AREG(7) += 2;
25816 PRE_IO
25817 READ_BYTE_F(adr, src)
25818 res = DREGu8((Opcode >> 9) & 7);
25819 res |= src;
25820 flag_C = 0;
25821 flag_V = 0;
25822 flag_NotZ = res;
25823 flag_N = res;
25824 DREGu8((Opcode >> 9) & 7) = res;
25825 POST_IO
25826RET(8)
25827}
25828
25829// ORaD
25830OPCODE(0x8027)
25831{
25832 u32 adr, res;
25833 u32 src, dst;
25834
25835 adr = AREG(7) - 2;
25836 AREG(7) = adr;
25837 PRE_IO
25838 READ_BYTE_F(adr, src)
25839 res = DREGu8((Opcode >> 9) & 7);
25840 res |= src;
25841 flag_C = 0;
25842 flag_V = 0;
25843 flag_NotZ = res;
25844 flag_N = res;
25845 DREGu8((Opcode >> 9) & 7) = res;
25846 POST_IO
25847RET(10)
25848}
25849
25850// ORaD
25851OPCODE(0x8040)
25852{
25853 u32 adr, res;
25854 u32 src, dst;
25855
25856 src = DREGu16((Opcode >> 0) & 7);
25857 res = DREGu16((Opcode >> 9) & 7);
25858 res |= src;
25859 flag_C = 0;
25860 flag_V = 0;
25861 flag_NotZ = res;
25862 flag_N = res >> 8;
25863 DREGu16((Opcode >> 9) & 7) = res;
25864RET(4)
25865}
25866
25867// ORaD
25868OPCODE(0x8050)
25869{
25870 u32 adr, res;
25871 u32 src, dst;
25872
25873 adr = AREG((Opcode >> 0) & 7);
25874 PRE_IO
25875 READ_WORD_F(adr, src)
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;
25883 POST_IO
25884RET(8)
25885}
25886
25887// ORaD
25888OPCODE(0x8058)
25889{
25890 u32 adr, res;
25891 u32 src, dst;
25892
25893 adr = AREG((Opcode >> 0) & 7);
25894 AREG((Opcode >> 0) & 7) += 2;
25895 PRE_IO
25896 READ_WORD_F(adr, src)
25897 res = DREGu16((Opcode >> 9) & 7);
25898 res |= src;
25899 flag_C = 0;
25900 flag_V = 0;
25901 flag_NotZ = res;
25902 flag_N = res >> 8;
25903 DREGu16((Opcode >> 9) & 7) = res;
25904 POST_IO
25905RET(8)
25906}
25907
25908// ORaD
25909OPCODE(0x8060)
25910{
25911 u32 adr, res;
25912 u32 src, dst;
25913
25914 adr = AREG((Opcode >> 0) & 7) - 2;
25915 AREG((Opcode >> 0) & 7) = adr;
25916 PRE_IO
25917 READ_WORD_F(adr, src)
25918 res = DREGu16((Opcode >> 9) & 7);
25919 res |= src;
25920 flag_C = 0;
25921 flag_V = 0;
25922 flag_NotZ = res;
25923 flag_N = res >> 8;
25924 DREGu16((Opcode >> 9) & 7) = res;
25925 POST_IO
25926RET(10)
25927}
25928
25929// ORaD
25930OPCODE(0x8068)
25931{
25932 u32 adr, res;
25933 u32 src, dst;
25934
25935 FETCH_SWORD(adr);
25936 adr += AREG((Opcode >> 0) & 7);
25937 PRE_IO
25938 READ_WORD_F(adr, src)
25939 res = DREGu16((Opcode >> 9) & 7);
25940 res |= src;
25941 flag_C = 0;
25942 flag_V = 0;
25943 flag_NotZ = res;
25944 flag_N = res >> 8;
25945 DREGu16((Opcode >> 9) & 7) = res;
25946 POST_IO
25947RET(12)
25948}
25949
25950// ORaD
25951OPCODE(0x8070)
25952{
25953 u32 adr, res;
25954 u32 src, dst;
25955
25956 adr = AREG((Opcode >> 0) & 7);
25957 DECODE_EXT_WORD
25958 PRE_IO
25959 READ_WORD_F(adr, src)
25960 res = DREGu16((Opcode >> 9) & 7);
25961 res |= src;
25962 flag_C = 0;
25963 flag_V = 0;
25964 flag_NotZ = res;
25965 flag_N = res >> 8;
25966 DREGu16((Opcode >> 9) & 7) = res;
25967 POST_IO
25968RET(14)
25969}
25970
25971// ORaD
25972OPCODE(0x8078)
25973{
25974 u32 adr, res;
25975 u32 src, dst;
25976
25977 FETCH_SWORD(adr);
25978 PRE_IO
25979 READ_WORD_F(adr, src)
25980 res = DREGu16((Opcode >> 9) & 7);
25981 res |= src;
25982 flag_C = 0;
25983 flag_V = 0;
25984 flag_NotZ = res;
25985 flag_N = res >> 8;
25986 DREGu16((Opcode >> 9) & 7) = res;
25987 POST_IO
25988RET(12)
25989}
25990
25991// ORaD
25992OPCODE(0x8079)
25993{
25994 u32 adr, res;
25995 u32 src, dst;
25996
25997 FETCH_LONG(adr);
25998 PRE_IO
25999 READ_WORD_F(adr, src)
26000 res = DREGu16((Opcode >> 9) & 7);
26001 res |= src;
26002 flag_C = 0;
26003 flag_V = 0;
26004 flag_NotZ = res;
26005 flag_N = res >> 8;
26006 DREGu16((Opcode >> 9) & 7) = res;
26007 POST_IO
26008RET(16)
26009}
26010
26011// ORaD
26012OPCODE(0x807A)
26013{
26014 u32 adr, res;
26015 u32 src, dst;
26016
be26eb23 26017 adr = GET_SWORD + GET_PC;
70357ce5 26018 PC++;
26019 PRE_IO
26020 READ_WORD_F(adr, src)
26021 res = DREGu16((Opcode >> 9) & 7);
26022 res |= src;
26023 flag_C = 0;
26024 flag_V = 0;
26025 flag_NotZ = res;
26026 flag_N = res >> 8;
26027 DREGu16((Opcode >> 9) & 7) = res;
26028 POST_IO
26029RET(12)
26030}
26031
26032// ORaD
26033OPCODE(0x807B)
26034{
26035 u32 adr, res;
26036 u32 src, dst;
26037
be26eb23 26038 adr = GET_PC;
70357ce5 26039 DECODE_EXT_WORD
26040 PRE_IO
26041 READ_WORD_F(adr, src)
26042 res = DREGu16((Opcode >> 9) & 7);
26043 res |= src;
26044 flag_C = 0;
26045 flag_V = 0;
26046 flag_NotZ = res;
26047 flag_N = res >> 8;
26048 DREGu16((Opcode >> 9) & 7) = res;
26049 POST_IO
26050RET(14)
26051}
26052
26053// ORaD
26054OPCODE(0x807C)
26055{
26056 u32 adr, res;
26057 u32 src, dst;
26058
26059 FETCH_WORD(src);
26060 res = DREGu16((Opcode >> 9) & 7);
26061 res |= src;
26062 flag_C = 0;
26063 flag_V = 0;
26064 flag_NotZ = res;
26065 flag_N = res >> 8;
26066 DREGu16((Opcode >> 9) & 7) = res;
26067RET(8)
26068}
26069
26070// ORaD
26071OPCODE(0x805F)
26072{
26073 u32 adr, res;
26074 u32 src, dst;
26075
26076 adr = AREG(7);
26077 AREG(7) += 2;
26078 PRE_IO
26079 READ_WORD_F(adr, src)
26080 res = DREGu16((Opcode >> 9) & 7);
26081 res |= src;
26082 flag_C = 0;
26083 flag_V = 0;
26084 flag_NotZ = res;
26085 flag_N = res >> 8;
26086 DREGu16((Opcode >> 9) & 7) = res;
26087 POST_IO
26088RET(8)
26089}
26090
26091// ORaD
26092OPCODE(0x8067)
26093{
26094 u32 adr, res;
26095 u32 src, dst;
26096
26097 adr = AREG(7) - 2;
26098 AREG(7) = adr;
26099 PRE_IO
26100 READ_WORD_F(adr, src)
26101 res = DREGu16((Opcode >> 9) & 7);
26102 res |= src;
26103 flag_C = 0;
26104 flag_V = 0;
26105 flag_NotZ = res;
26106 flag_N = res >> 8;
26107 DREGu16((Opcode >> 9) & 7) = res;
26108 POST_IO
26109RET(10)
26110}
26111
26112// ORaD
26113OPCODE(0x8080)
26114{
26115 u32 adr, res;
26116 u32 src, dst;
26117
26118 src = DREGu32((Opcode >> 0) & 7);
26119 res = DREGu32((Opcode >> 9) & 7);
26120 res |= src;
26121 flag_C = 0;
26122 flag_V = 0;
26123 flag_NotZ = res;
26124 flag_N = res >> 24;
26125 DREGu32((Opcode >> 9) & 7) = res;
26126RET(8)
26127}
26128
26129// ORaD
26130OPCODE(0x8090)
26131{
26132 u32 adr, res;
26133 u32 src, dst;
26134
26135 adr = AREG((Opcode >> 0) & 7);
26136 PRE_IO
26137 READ_LONG_F(adr, src)
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;
26145 POST_IO
26146RET(14)
26147}
26148
26149// ORaD
26150OPCODE(0x8098)
26151{
26152 u32 adr, res;
26153 u32 src, dst;
26154
26155 adr = AREG((Opcode >> 0) & 7);
26156 AREG((Opcode >> 0) & 7) += 4;
26157 PRE_IO
26158 READ_LONG_F(adr, src)
26159 res = DREGu32((Opcode >> 9) & 7);
26160 res |= src;
26161 flag_C = 0;
26162 flag_V = 0;
26163 flag_NotZ = res;
26164 flag_N = res >> 24;
26165 DREGu32((Opcode >> 9) & 7) = res;
26166 POST_IO
26167RET(14)
26168}
26169
26170// ORaD
26171OPCODE(0x80A0)
26172{
26173 u32 adr, res;
26174 u32 src, dst;
26175
26176 adr = AREG((Opcode >> 0) & 7) - 4;
26177 AREG((Opcode >> 0) & 7) = adr;
26178 PRE_IO
26179 READ_LONG_F(adr, src)
26180 res = DREGu32((Opcode >> 9) & 7);
26181 res |= src;
26182 flag_C = 0;
26183 flag_V = 0;
26184 flag_NotZ = res;
26185 flag_N = res >> 24;
26186 DREGu32((Opcode >> 9) & 7) = res;
26187 POST_IO
26188RET(16)
26189}
26190
26191// ORaD
26192OPCODE(0x80A8)
26193{
26194 u32 adr, res;
26195 u32 src, dst;
26196
26197 FETCH_SWORD(adr);
26198 adr += AREG((Opcode >> 0) & 7);
26199 PRE_IO
26200 READ_LONG_F(adr, src)
26201 res = DREGu32((Opcode >> 9) & 7);
26202 res |= src;
26203 flag_C = 0;
26204 flag_V = 0;
26205 flag_NotZ = res;
26206 flag_N = res >> 24;
26207 DREGu32((Opcode >> 9) & 7) = res;
26208 POST_IO
26209RET(18)
26210}
26211
26212// ORaD
26213OPCODE(0x80B0)
26214{
26215 u32 adr, res;
26216 u32 src, dst;
26217
26218 adr = AREG((Opcode >> 0) & 7);
26219 DECODE_EXT_WORD
26220 PRE_IO
26221 READ_LONG_F(adr, src)
26222 res = DREGu32((Opcode >> 9) & 7);
26223 res |= src;
26224 flag_C = 0;
26225 flag_V = 0;
26226 flag_NotZ = res;
26227 flag_N = res >> 24;
26228 DREGu32((Opcode >> 9) & 7) = res;
26229 POST_IO
26230RET(20)
26231}
26232
26233// ORaD
26234OPCODE(0x80B8)
26235{
26236 u32 adr, res;
26237 u32 src, dst;
26238
26239 FETCH_SWORD(adr);
26240 PRE_IO
26241 READ_LONG_F(adr, src)
26242 res = DREGu32((Opcode >> 9) & 7);
26243 res |= src;
26244 flag_C = 0;
26245 flag_V = 0;
26246 flag_NotZ = res;
26247 flag_N = res >> 24;
26248 DREGu32((Opcode >> 9) & 7) = res;
26249 POST_IO
26250RET(18)
26251}
26252
26253// ORaD
26254OPCODE(0x80B9)
26255{
26256 u32 adr, res;
26257 u32 src, dst;
26258
26259 FETCH_LONG(adr);
26260 PRE_IO
26261 READ_LONG_F(adr, src)
26262 res = DREGu32((Opcode >> 9) & 7);
26263 res |= src;
26264 flag_C = 0;
26265 flag_V = 0;
26266 flag_NotZ = res;
26267 flag_N = res >> 24;
26268 DREGu32((Opcode >> 9) & 7) = res;
26269 POST_IO
26270RET(22)
26271}
26272
26273// ORaD
26274OPCODE(0x80BA)
26275{
26276 u32 adr, res;
26277 u32 src, dst;
26278
be26eb23 26279 adr = GET_SWORD + GET_PC;
70357ce5 26280 PC++;
26281 PRE_IO
26282 READ_LONG_F(adr, src)
26283 res = DREGu32((Opcode >> 9) & 7);
26284 res |= src;
26285 flag_C = 0;
26286 flag_V = 0;
26287 flag_NotZ = res;
26288 flag_N = res >> 24;
26289 DREGu32((Opcode >> 9) & 7) = res;
26290 POST_IO
26291RET(18)
26292}
26293
26294// ORaD
26295OPCODE(0x80BB)
26296{
26297 u32 adr, res;
26298 u32 src, dst;
26299
be26eb23 26300 adr = GET_PC;
70357ce5 26301 DECODE_EXT_WORD
26302 PRE_IO
26303 READ_LONG_F(adr, src)
26304 res = DREGu32((Opcode >> 9) & 7);
26305 res |= src;
26306 flag_C = 0;
26307 flag_V = 0;
26308 flag_NotZ = res;
26309 flag_N = res >> 24;
26310 DREGu32((Opcode >> 9) & 7) = res;
26311 POST_IO
26312RET(20)
26313}
26314
26315// ORaD
26316OPCODE(0x80BC)
26317{
26318 u32 adr, res;
26319 u32 src, dst;
26320
26321 FETCH_LONG(src);
26322 res = DREGu32((Opcode >> 9) & 7);
26323 res |= src;
26324 flag_C = 0;
26325 flag_V = 0;
26326 flag_NotZ = res;
26327 flag_N = res >> 24;
26328 DREGu32((Opcode >> 9) & 7) = res;
26329RET(16)
26330}
26331
26332// ORaD
26333OPCODE(0x809F)
26334{
26335 u32 adr, res;
26336 u32 src, dst;
26337
26338 adr = AREG(7);
26339 AREG(7) += 4;
26340 PRE_IO
26341 READ_LONG_F(adr, src)
26342 res = DREGu32((Opcode >> 9) & 7);
26343 res |= src;
26344 flag_C = 0;
26345 flag_V = 0;
26346 flag_NotZ = res;
26347 flag_N = res >> 24;
26348 DREGu32((Opcode >> 9) & 7) = res;
26349 POST_IO
26350RET(14)
26351}
26352
26353// ORaD
26354OPCODE(0x80A7)
26355{
26356 u32 adr, res;
26357 u32 src, dst;
26358
26359 adr = AREG(7) - 4;
26360 AREG(7) = adr;
26361 PRE_IO
26362 READ_LONG_F(adr, src)
26363 res = DREGu32((Opcode >> 9) & 7);
26364 res |= src;
26365 flag_C = 0;
26366 flag_V = 0;
26367 flag_NotZ = res;
26368 flag_N = res >> 24;
26369 DREGu32((Opcode >> 9) & 7) = res;
26370 POST_IO
26371RET(16)
26372}
26373
26374// ORDa
26375OPCODE(0x8110)
26376{
26377 u32 adr, res;
26378 u32 src, dst;
26379
26380 src = DREGu8((Opcode >> 9) & 7);
26381 adr = AREG((Opcode >> 0) & 7);
26382 PRE_IO
26383 READ_BYTE_F(adr, res)
26384 res |= src;
26385 flag_C = 0;
26386 flag_V = 0;
26387 flag_NotZ = res;
26388 flag_N = res;
26389 WRITE_BYTE_F(adr, res)
26390 POST_IO
26391RET(12)
26392}
26393
26394// ORDa
26395OPCODE(0x8118)
26396{
26397 u32 adr, res;
26398 u32 src, dst;
26399
26400 src = DREGu8((Opcode >> 9) & 7);
26401 adr = AREG((Opcode >> 0) & 7);
26402 AREG((Opcode >> 0) & 7) += 1;
26403 PRE_IO
26404 READ_BYTE_F(adr, res)
26405 res |= src;
26406 flag_C = 0;
26407 flag_V = 0;
26408 flag_NotZ = res;
26409 flag_N = res;
26410 WRITE_BYTE_F(adr, res)
26411 POST_IO
26412RET(12)
26413}
26414
26415// ORDa
26416OPCODE(0x8120)
26417{
26418 u32 adr, res;
26419 u32 src, dst;
26420
26421 src = DREGu8((Opcode >> 9) & 7);
26422 adr = AREG((Opcode >> 0) & 7) - 1;
26423 AREG((Opcode >> 0) & 7) = adr;
26424 PRE_IO
26425 READ_BYTE_F(adr, res)
26426 res |= src;
26427 flag_C = 0;
26428 flag_V = 0;
26429 flag_NotZ = res;
26430 flag_N = res;
26431 WRITE_BYTE_F(adr, res)
26432 POST_IO
26433RET(14)
26434}
26435
26436// ORDa
26437OPCODE(0x8128)
26438{
26439 u32 adr, res;
26440 u32 src, dst;
26441
26442 src = DREGu8((Opcode >> 9) & 7);
26443 FETCH_SWORD(adr);
26444 adr += AREG((Opcode >> 0) & 7);
26445 PRE_IO
26446 READ_BYTE_F(adr, res)
26447 res |= src;
26448 flag_C = 0;
26449 flag_V = 0;
26450 flag_NotZ = res;
26451 flag_N = res;
26452 WRITE_BYTE_F(adr, res)
26453 POST_IO
26454RET(16)
26455}
26456
26457// ORDa
26458OPCODE(0x8130)
26459{
26460 u32 adr, res;
26461 u32 src, dst;
26462
26463 src = DREGu8((Opcode >> 9) & 7);
26464 adr = AREG((Opcode >> 0) & 7);
26465 DECODE_EXT_WORD
26466 PRE_IO
26467 READ_BYTE_F(adr, res)
26468 res |= src;
26469 flag_C = 0;
26470 flag_V = 0;
26471 flag_NotZ = res;
26472 flag_N = res;
26473 WRITE_BYTE_F(adr, res)
26474 POST_IO
26475RET(18)
26476}
26477
26478// ORDa
26479OPCODE(0x8138)
26480{
26481 u32 adr, res;
26482 u32 src, dst;
26483
26484 src = DREGu8((Opcode >> 9) & 7);
26485 FETCH_SWORD(adr);
26486 PRE_IO
26487 READ_BYTE_F(adr, res)
26488 res |= src;
26489 flag_C = 0;
26490 flag_V = 0;
26491 flag_NotZ = res;
26492 flag_N = res;
26493 WRITE_BYTE_F(adr, res)
26494 POST_IO
26495RET(16)
26496}
26497
26498// ORDa
26499OPCODE(0x8139)
26500{
26501 u32 adr, res;
26502 u32 src, dst;
26503
26504 src = DREGu8((Opcode >> 9) & 7);
26505 FETCH_LONG(adr);
26506 PRE_IO
26507 READ_BYTE_F(adr, res)
26508 res |= src;
26509 flag_C = 0;
26510 flag_V = 0;
26511 flag_NotZ = res;
26512 flag_N = res;
26513 WRITE_BYTE_F(adr, res)
26514 POST_IO
26515RET(20)
26516}
26517
26518// ORDa
26519OPCODE(0x811F)
26520{
26521 u32 adr, res;
26522 u32 src, dst;
26523
26524 src = DREGu8((Opcode >> 9) & 7);
26525 adr = AREG(7);
26526 AREG(7) += 2;
26527 PRE_IO
26528 READ_BYTE_F(adr, res)
26529 res |= src;
26530 flag_C = 0;
26531 flag_V = 0;
26532 flag_NotZ = res;
26533 flag_N = res;
26534 WRITE_BYTE_F(adr, res)
26535 POST_IO
26536RET(12)
26537}
26538
26539// ORDa
26540OPCODE(0x8127)
26541{
26542 u32 adr, res;
26543 u32 src, dst;
26544
26545 src = DREGu8((Opcode >> 9) & 7);
26546 adr = AREG(7) - 2;
26547 AREG(7) = adr;
26548 PRE_IO
26549 READ_BYTE_F(adr, res)
26550 res |= src;
26551 flag_C = 0;
26552 flag_V = 0;
26553 flag_NotZ = res;
26554 flag_N = res;
26555 WRITE_BYTE_F(adr, res)
26556 POST_IO
26557RET(14)
26558}
26559
26560// ORDa
26561OPCODE(0x8150)
26562{
26563 u32 adr, res;
26564 u32 src, dst;
26565
26566 src = DREGu16((Opcode >> 9) & 7);
26567 adr = AREG((Opcode >> 0) & 7);
26568 PRE_IO
26569 READ_WORD_F(adr, res)
26570 res |= src;
26571 flag_C = 0;
26572 flag_V = 0;
26573 flag_NotZ = res;
26574 flag_N = res >> 8;
26575 WRITE_WORD_F(adr, res)
26576 POST_IO
26577RET(12)
26578}
26579
26580// ORDa
26581OPCODE(0x8158)
26582{
26583 u32 adr, res;
26584 u32 src, dst;
26585
26586 src = DREGu16((Opcode >> 9) & 7);
26587 adr = AREG((Opcode >> 0) & 7);
26588 AREG((Opcode >> 0) & 7) += 2;
26589 PRE_IO
26590 READ_WORD_F(adr, res)
26591 res |= src;
26592 flag_C = 0;
26593 flag_V = 0;
26594 flag_NotZ = res;
26595 flag_N = res >> 8;
26596 WRITE_WORD_F(adr, res)
26597 POST_IO
26598RET(12)
26599}
26600
26601// ORDa
26602OPCODE(0x8160)
26603{
26604 u32 adr, res;
26605 u32 src, dst;
26606
26607 src = DREGu16((Opcode >> 9) & 7);
26608 adr = AREG((Opcode >> 0) & 7) - 2;
26609 AREG((Opcode >> 0) & 7) = adr;
26610 PRE_IO
26611 READ_WORD_F(adr, res)
26612 res |= src;
26613 flag_C = 0;
26614 flag_V = 0;
26615 flag_NotZ = res;
26616 flag_N = res >> 8;
26617 WRITE_WORD_F(adr, res)
26618 POST_IO
26619RET(14)
26620}
26621
26622// ORDa
26623OPCODE(0x8168)
26624{
26625 u32 adr, res;
26626 u32 src, dst;
26627
26628 src = DREGu16((Opcode >> 9) & 7);
26629 FETCH_SWORD(adr);
26630 adr += AREG((Opcode >> 0) & 7);
26631 PRE_IO
26632 READ_WORD_F(adr, res)
26633 res |= src;
26634 flag_C = 0;
26635 flag_V = 0;
26636 flag_NotZ = res;
26637 flag_N = res >> 8;
26638 WRITE_WORD_F(adr, res)
26639 POST_IO
26640RET(16)
26641}
26642
26643// ORDa
26644OPCODE(0x8170)
26645{
26646 u32 adr, res;
26647 u32 src, dst;
26648
26649 src = DREGu16((Opcode >> 9) & 7);
26650 adr = AREG((Opcode >> 0) & 7);
26651 DECODE_EXT_WORD
26652 PRE_IO
26653 READ_WORD_F(adr, res)
26654 res |= src;
26655 flag_C = 0;
26656 flag_V = 0;
26657 flag_NotZ = res;
26658 flag_N = res >> 8;
26659 WRITE_WORD_F(adr, res)
26660 POST_IO
26661RET(18)
26662}
26663
26664// ORDa
26665OPCODE(0x8178)
26666{
26667 u32 adr, res;
26668 u32 src, dst;
26669
26670 src = DREGu16((Opcode >> 9) & 7);
26671 FETCH_SWORD(adr);
26672 PRE_IO
26673 READ_WORD_F(adr, res)
26674 res |= src;
26675 flag_C = 0;
26676 flag_V = 0;
26677 flag_NotZ = res;
26678 flag_N = res >> 8;
26679 WRITE_WORD_F(adr, res)
26680 POST_IO
26681RET(16)
26682}
26683
26684// ORDa
26685OPCODE(0x8179)
26686{
26687 u32 adr, res;
26688 u32 src, dst;
26689
26690 src = DREGu16((Opcode >> 9) & 7);
26691 FETCH_LONG(adr);
26692 PRE_IO
26693 READ_WORD_F(adr, res)
26694 res |= src;
26695 flag_C = 0;
26696 flag_V = 0;
26697 flag_NotZ = res;
26698 flag_N = res >> 8;
26699 WRITE_WORD_F(adr, res)
26700 POST_IO
26701RET(20)
26702}
26703
26704// ORDa
26705OPCODE(0x815F)
26706{
26707 u32 adr, res;
26708 u32 src, dst;
26709
26710 src = DREGu16((Opcode >> 9) & 7);
26711 adr = AREG(7);
26712 AREG(7) += 2;
26713 PRE_IO
26714 READ_WORD_F(adr, res)
26715 res |= src;
26716 flag_C = 0;
26717 flag_V = 0;
26718 flag_NotZ = res;
26719 flag_N = res >> 8;
26720 WRITE_WORD_F(adr, res)
26721 POST_IO
26722RET(12)
26723}
26724
26725// ORDa
26726OPCODE(0x8167)
26727{
26728 u32 adr, res;
26729 u32 src, dst;
26730
26731 src = DREGu16((Opcode >> 9) & 7);
26732 adr = AREG(7) - 2;
26733 AREG(7) = adr;
26734 PRE_IO
26735 READ_WORD_F(adr, res)
26736 res |= src;
26737 flag_C = 0;
26738 flag_V = 0;
26739 flag_NotZ = res;
26740 flag_N = res >> 8;
26741 WRITE_WORD_F(adr, res)
26742 POST_IO
26743RET(14)
26744}
26745
26746// ORDa
26747OPCODE(0x8190)
26748{
26749 u32 adr, res;
26750 u32 src, dst;
26751
26752 src = DREGu32((Opcode >> 9) & 7);
26753 adr = AREG((Opcode >> 0) & 7);
26754 PRE_IO
26755 READ_LONG_F(adr, res)
26756 res |= src;
26757 flag_C = 0;
26758 flag_V = 0;
26759 flag_NotZ = res;
26760 flag_N = res >> 24;
26761 WRITE_LONG_F(adr, res)
26762 POST_IO
26763RET(20)
26764}
26765
26766// ORDa
26767OPCODE(0x8198)
26768{
26769 u32 adr, res;
26770 u32 src, dst;
26771
26772 src = DREGu32((Opcode >> 9) & 7);
26773 adr = AREG((Opcode >> 0) & 7);
26774 AREG((Opcode >> 0) & 7) += 4;
26775 PRE_IO
26776 READ_LONG_F(adr, res)
26777 res |= src;
26778 flag_C = 0;
26779 flag_V = 0;
26780 flag_NotZ = res;
26781 flag_N = res >> 24;
26782 WRITE_LONG_F(adr, res)
26783 POST_IO
26784RET(20)
26785}
26786
26787// ORDa
26788OPCODE(0x81A0)
26789{
26790 u32 adr, res;
26791 u32 src, dst;
26792
26793 src = DREGu32((Opcode >> 9) & 7);
26794 adr = AREG((Opcode >> 0) & 7) - 4;
26795 AREG((Opcode >> 0) & 7) = adr;
26796 PRE_IO
26797 READ_LONG_F(adr, res)
26798 res |= src;
26799 flag_C = 0;
26800 flag_V = 0;
26801 flag_NotZ = res;
26802 flag_N = res >> 24;
26803 WRITE_LONG_F(adr, res)
26804 POST_IO
26805RET(22)
26806}
26807
26808// ORDa
26809OPCODE(0x81A8)
26810{
26811 u32 adr, res;
26812 u32 src, dst;
26813
26814 src = DREGu32((Opcode >> 9) & 7);
26815 FETCH_SWORD(adr);
26816 adr += AREG((Opcode >> 0) & 7);
26817 PRE_IO
26818 READ_LONG_F(adr, res)
26819 res |= src;
26820 flag_C = 0;
26821 flag_V = 0;
26822 flag_NotZ = res;
26823 flag_N = res >> 24;
26824 WRITE_LONG_F(adr, res)
26825 POST_IO
26826RET(24)
26827}
26828
26829// ORDa
26830OPCODE(0x81B0)
26831{
26832 u32 adr, res;
26833 u32 src, dst;
26834
26835 src = DREGu32((Opcode >> 9) & 7);
26836 adr = AREG((Opcode >> 0) & 7);
26837 DECODE_EXT_WORD
26838 PRE_IO
26839 READ_LONG_F(adr, res)
26840 res |= src;
26841 flag_C = 0;
26842 flag_V = 0;
26843 flag_NotZ = res;
26844 flag_N = res >> 24;
26845 WRITE_LONG_F(adr, res)
26846 POST_IO
26847RET(26)
26848}
26849
26850// ORDa
26851OPCODE(0x81B8)
26852{
26853 u32 adr, res;
26854 u32 src, dst;
26855
26856 src = DREGu32((Opcode >> 9) & 7);
26857 FETCH_SWORD(adr);
26858 PRE_IO
26859 READ_LONG_F(adr, res)
26860 res |= src;
26861 flag_C = 0;
26862 flag_V = 0;
26863 flag_NotZ = res;
26864 flag_N = res >> 24;
26865 WRITE_LONG_F(adr, res)
26866 POST_IO
26867RET(24)
26868}
26869
26870// ORDa
26871OPCODE(0x81B9)
26872{
26873 u32 adr, res;
26874 u32 src, dst;
26875
26876 src = DREGu32((Opcode >> 9) & 7);
26877 FETCH_LONG(adr);
26878 PRE_IO
26879 READ_LONG_F(adr, res)
26880 res |= src;
26881 flag_C = 0;
26882 flag_V = 0;
26883 flag_NotZ = res;
26884 flag_N = res >> 24;
26885 WRITE_LONG_F(adr, res)
26886 POST_IO
26887RET(28)
26888}
26889
26890// ORDa
26891OPCODE(0x819F)
26892{
26893 u32 adr, res;
26894 u32 src, dst;
26895
26896 src = DREGu32((Opcode >> 9) & 7);
26897 adr = AREG(7);
26898 AREG(7) += 4;
26899 PRE_IO
26900 READ_LONG_F(adr, res)
26901 res |= src;
26902 flag_C = 0;
26903 flag_V = 0;
26904 flag_NotZ = res;
26905 flag_N = res >> 24;
26906 WRITE_LONG_F(adr, res)
26907 POST_IO
26908RET(20)
26909}
26910
26911// ORDa
26912OPCODE(0x81A7)
26913{
26914 u32 adr, res;
26915 u32 src, dst;
26916
26917 src = DREGu32((Opcode >> 9) & 7);
26918 adr = AREG(7) - 4;
26919 AREG(7) = adr;
26920 PRE_IO
26921 READ_LONG_F(adr, res)
26922 res |= src;
26923 flag_C = 0;
26924 flag_V = 0;
26925 flag_NotZ = res;
26926 flag_N = res >> 24;
26927 WRITE_LONG_F(adr, res)
26928 POST_IO
26929RET(22)
26930}
26931
26932// SBCD
26933OPCODE(0x8100)
26934{
26935 u32 adr, res;
26936 u32 src, dst;
26937
26938 src = DREGu8((Opcode >> 0) & 7);
26939 dst = DREGu8((Opcode >> 9) & 7);
26940 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26941 if (res > 9) res -= 6;
26942 res += (dst & 0xF0) - (src & 0xF0);
26943 if (res > 0x99)
26944 {
26945 res += 0xA0;
26946 flag_X = flag_C = M68K_SR_C;
26947 }
26948 else flag_X = flag_C = 0;
26949 flag_NotZ |= res & 0xFF;
26950 flag_N = res;
26951 DREGu8((Opcode >> 9) & 7) = res;
26952RET(6)
26953}
26954
26955// SBCDM
26956OPCODE(0x8108)
26957{
26958 u32 adr, res;
26959 u32 src, dst;
26960
26961 adr = AREG((Opcode >> 0) & 7) - 1;
26962 AREG((Opcode >> 0) & 7) = adr;
26963 PRE_IO
26964 READ_BYTE_F(adr, src)
26965 adr = AREG((Opcode >> 9) & 7) - 1;
26966 AREG((Opcode >> 9) & 7) = adr;
26967 READ_BYTE_F(adr, dst)
26968 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26969 if (res > 9) res -= 6;
26970 res += (dst & 0xF0) - (src & 0xF0);
26971 if (res > 0x99)
26972 {
26973 res += 0xA0;
26974 flag_X = flag_C = M68K_SR_C;
26975 }
26976 else flag_X = flag_C = 0;
26977 flag_NotZ |= res & 0xFF;
26978 flag_N = res;
26979 WRITE_BYTE_F(adr, res)
26980 POST_IO
26981RET(18)
26982}
26983
26984// SBCD7M
26985OPCODE(0x810F)
26986{
26987 u32 adr, res;
26988 u32 src, dst;
26989
26990 adr = AREG(7) - 2;
26991 AREG(7) = adr;
26992 PRE_IO
26993 READ_BYTE_F(adr, src)
26994 adr = AREG((Opcode >> 9) & 7) - 1;
26995 AREG((Opcode >> 9) & 7) = adr;
26996 READ_BYTE_F(adr, dst)
26997 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
26998 if (res > 9) res -= 6;
26999 res += (dst & 0xF0) - (src & 0xF0);
27000 if (res > 0x99)
27001 {
27002 res += 0xA0;
27003 flag_X = flag_C = M68K_SR_C;
27004 }
27005 else flag_X = flag_C = 0;
27006 flag_NotZ |= res & 0xFF;
27007 flag_N = res;
27008 WRITE_BYTE_F(adr, res)
27009 POST_IO
27010RET(18)
27011}
27012
27013// SBCDM7
27014OPCODE(0x8F08)
27015{
27016 u32 adr, res;
27017 u32 src, dst;
27018
27019 adr = AREG((Opcode >> 0) & 7) - 1;
27020 AREG((Opcode >> 0) & 7) = adr;
27021 PRE_IO
27022 READ_BYTE_F(adr, src)
27023 adr = AREG(7) - 2;
27024 AREG(7) = adr;
27025 READ_BYTE_F(adr, dst)
27026 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27027 if (res > 9) res -= 6;
27028 res += (dst & 0xF0) - (src & 0xF0);
27029 if (res > 0x99)
27030 {
27031 res += 0xA0;
27032 flag_X = flag_C = M68K_SR_C;
27033 }
27034 else flag_X = flag_C = 0;
27035 flag_NotZ |= res & 0xFF;
27036 flag_N = res;
27037 WRITE_BYTE_F(adr, res)
27038 POST_IO
27039RET(18)
27040}
27041
27042// SBCD7M7
27043OPCODE(0x8F0F)
27044{
27045 u32 adr, res;
27046 u32 src, dst;
27047
27048 adr = AREG(7) - 2;
27049 AREG(7) = adr;
27050 PRE_IO
27051 READ_BYTE_F(adr, src)
27052 adr = AREG(7) - 2;
27053 AREG(7) = adr;
27054 READ_BYTE_F(adr, dst)
27055 res = (dst & 0xF) - (src & 0xF) - ((flag_X >> M68K_SR_X_SFT) & 1);
27056 if (res > 9) res -= 6;
27057 res += (dst & 0xF0) - (src & 0xF0);
27058 if (res > 0x99)
27059 {
27060 res += 0xA0;
27061 flag_X = flag_C = M68K_SR_C;
27062 }
27063 else flag_X = flag_C = 0;
27064 flag_NotZ |= res & 0xFF;
27065 flag_N = res;
27066 WRITE_BYTE_F(adr, res)
27067 POST_IO
27068RET(18)
27069}
27070
27071// DIVU
27072OPCODE(0x80C0)
27073{
27074 u32 adr, res;
27075 u32 src, dst;
27076
27077 src = DREGu16((Opcode >> 0) & 7);
27078 if (src == 0)
27079 {
d0ae0cb4 27080 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27081#ifdef USE_CYCLONE_TIMING_DIV
27082RET(140)
27083#else
27084RET(10)
27085#endif
27086 }
27087 dst = DREGu32((Opcode >> 9) & 7);
27088 {
27089 u32 q, r;
27090
27091 q = dst / src;
27092 r = dst % src;
27093
27094 if (q & 0xFFFF0000)
27095 {
27096 flag_V = M68K_SR_V;
27097#ifdef USE_CYCLONE_TIMING_DIV
27098RET(140)
27099#else
27100RET(70)
27101#endif
27102 }
27103 q &= 0x0000FFFF;
27104 flag_NotZ = q;
27105 flag_N = q >> 8;
27106 flag_V = flag_C = 0;
27107 res = q | (r << 16);
27108 DREGu32((Opcode >> 9) & 7) = res;
27109 }
27110#ifdef USE_CYCLONE_TIMING_DIV
27111RET(140)
27112#else
27113RET(90)
27114#endif
27115}
27116
27117// DIVU
27118OPCODE(0x80D0)
27119{
27120 u32 adr, res;
27121 u32 src, dst;
27122
27123 adr = AREG((Opcode >> 0) & 7);
27124 PRE_IO
27125 READ_WORD_F(adr, src)
27126 if (src == 0)
27127 {
d0ae0cb4 27128 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27129#ifdef USE_CYCLONE_TIMING_DIV
27130RET(144)
27131#else
27132RET(14)
27133#endif
27134 }
27135 dst = DREGu32((Opcode >> 9) & 7);
27136 {
27137 u32 q, r;
27138
27139 q = dst / src;
27140 r = dst % src;
27141
27142 if (q & 0xFFFF0000)
27143 {
27144 flag_V = M68K_SR_V;
27145#ifdef USE_CYCLONE_TIMING_DIV
27146RET(144)
27147#else
27148 RET(74)
27149#endif
27150 }
27151 q &= 0x0000FFFF;
27152 flag_NotZ = q;
27153 flag_N = q >> 8;
27154 flag_V = flag_C = 0;
27155 res = q | (r << 16);
27156 DREGu32((Opcode >> 9) & 7) = res;
27157 }
27158#ifdef USE_CYCLONE_TIMING_DIV
27159RET(144)
27160#else
27161RET(94)
27162#endif
27163}
27164
27165// DIVU
27166OPCODE(0x80D8)
27167{
27168 u32 adr, res;
27169 u32 src, dst;
27170
27171 adr = AREG((Opcode >> 0) & 7);
27172 AREG((Opcode >> 0) & 7) += 2;
27173 PRE_IO
27174 READ_WORD_F(adr, src)
27175 if (src == 0)
27176 {
d0ae0cb4 27177 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27178#ifdef USE_CYCLONE_TIMING_DIV
27179RET(144)
27180#else
27181RET(14)
27182#endif
27183 }
27184 dst = DREGu32((Opcode >> 9) & 7);
27185 {
27186 u32 q, r;
27187
27188 q = dst / src;
27189 r = dst % src;
27190
27191 if (q & 0xFFFF0000)
27192 {
27193 flag_V = M68K_SR_V;
27194#ifdef USE_CYCLONE_TIMING_DIV
27195RET(144)
27196#else
27197 RET(74)
27198#endif
27199 }
27200 q &= 0x0000FFFF;
27201 flag_NotZ = q;
27202 flag_N = q >> 8;
27203 flag_V = flag_C = 0;
27204 res = q | (r << 16);
27205 DREGu32((Opcode >> 9) & 7) = res;
27206 }
27207#ifdef USE_CYCLONE_TIMING_DIV
27208RET(144)
27209#else
27210RET(94)
27211#endif
27212}
27213
27214// DIVU
27215OPCODE(0x80E0)
27216{
27217 u32 adr, res;
27218 u32 src, dst;
27219
27220 adr = AREG((Opcode >> 0) & 7) - 2;
27221 AREG((Opcode >> 0) & 7) = adr;
27222 PRE_IO
27223 READ_WORD_F(adr, src)
27224 if (src == 0)
27225 {
d0ae0cb4 27226 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27227#ifdef USE_CYCLONE_TIMING_DIV
27228RET(146)
27229#else
27230RET(16)
27231#endif
27232 }
27233 dst = DREGu32((Opcode >> 9) & 7);
27234 {
27235 u32 q, r;
27236
27237 q = dst / src;
27238 r = dst % src;
27239
27240 if (q & 0xFFFF0000)
27241 {
27242 flag_V = M68K_SR_V;
27243#ifdef USE_CYCLONE_TIMING_DIV
27244RET(146)
27245#else
27246 RET(76)
27247#endif
27248 }
27249 q &= 0x0000FFFF;
27250 flag_NotZ = q;
27251 flag_N = q >> 8;
27252 flag_V = flag_C = 0;
27253 res = q | (r << 16);
27254 DREGu32((Opcode >> 9) & 7) = res;
27255 }
27256#ifdef USE_CYCLONE_TIMING_DIV
27257RET(146)
27258#else
27259RET(96)
27260#endif
27261}
27262
27263// DIVU
27264OPCODE(0x80E8)
27265{
27266 u32 adr, res;
27267 u32 src, dst;
27268
27269 FETCH_SWORD(adr);
27270 adr += AREG((Opcode >> 0) & 7);
27271 PRE_IO
27272 READ_WORD_F(adr, src)
27273 if (src == 0)
27274 {
d0ae0cb4 27275 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27276#ifdef USE_CYCLONE_TIMING_DIV
27277RET(148)
27278#else
27279RET(18)
27280#endif
27281 }
27282 dst = DREGu32((Opcode >> 9) & 7);
27283 {
27284 u32 q, r;
27285
27286 q = dst / src;
27287 r = dst % src;
27288
27289 if (q & 0xFFFF0000)
27290 {
27291 flag_V = M68K_SR_V;
27292#ifdef USE_CYCLONE_TIMING_DIV
27293RET(148)
27294#else
27295 RET(78)
27296#endif
27297 }
27298 q &= 0x0000FFFF;
27299 flag_NotZ = q;
27300 flag_N = q >> 8;
27301 flag_V = flag_C = 0;
27302 res = q | (r << 16);
27303 DREGu32((Opcode >> 9) & 7) = res;
27304 }
27305#ifdef USE_CYCLONE_TIMING_DIV
27306RET(148)
27307#else
27308RET(98)
27309#endif
27310}
27311
27312// DIVU
27313OPCODE(0x80F0)
27314{
27315 u32 adr, res;
27316 u32 src, dst;
27317
27318 adr = AREG((Opcode >> 0) & 7);
27319 DECODE_EXT_WORD
27320 PRE_IO
27321 READ_WORD_F(adr, src)
27322 if (src == 0)
27323 {
d0ae0cb4 27324 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27325#ifdef USE_CYCLONE_TIMING_DIV
27326RET(150)
27327#else
27328RET(20)
27329#endif
27330 }
27331 dst = DREGu32((Opcode >> 9) & 7);
27332 {
27333 u32 q, r;
27334
27335 q = dst / src;
27336 r = dst % src;
27337
27338 if (q & 0xFFFF0000)
27339 {
27340 flag_V = M68K_SR_V;
27341#ifdef USE_CYCLONE_TIMING_DIV
27342RET(150)
27343#else
27344 RET(80)
27345#endif
27346 }
27347 q &= 0x0000FFFF;
27348 flag_NotZ = q;
27349 flag_N = q >> 8;
27350 flag_V = flag_C = 0;
27351 res = q | (r << 16);
27352 DREGu32((Opcode >> 9) & 7) = res;
27353 }
27354#ifdef USE_CYCLONE_TIMING_DIV
27355RET(150)
27356#else
27357RET(100)
27358#endif
27359}
27360
27361// DIVU
27362OPCODE(0x80F8)
27363{
27364 u32 adr, res;
27365 u32 src, dst;
27366
27367 FETCH_SWORD(adr);
27368 PRE_IO
27369 READ_WORD_F(adr, src)
27370 if (src == 0)
27371 {
d0ae0cb4 27372 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27373#ifdef USE_CYCLONE_TIMING_DIV
27374RET(148)
27375#else
27376RET(18)
27377#endif
27378 }
27379 dst = DREGu32((Opcode >> 9) & 7);
27380 {
27381 u32 q, r;
27382
27383 q = dst / src;
27384 r = dst % src;
27385
27386 if (q & 0xFFFF0000)
27387 {
27388 flag_V = M68K_SR_V;
27389#ifdef USE_CYCLONE_TIMING_DIV
27390RET(148)
27391#else
27392 RET(78)
27393#endif
27394 }
27395 q &= 0x0000FFFF;
27396 flag_NotZ = q;
27397 flag_N = q >> 8;
27398 flag_V = flag_C = 0;
27399 res = q | (r << 16);
27400 DREGu32((Opcode >> 9) & 7) = res;
27401 }
27402#ifdef USE_CYCLONE_TIMING_DIV
27403RET(148)
27404#else
27405RET(98)
27406#endif
27407}
27408
27409// DIVU
27410OPCODE(0x80F9)
27411{
27412 u32 adr, res;
27413 u32 src, dst;
27414
27415 FETCH_LONG(adr);
27416 PRE_IO
27417 READ_WORD_F(adr, src)
27418 if (src == 0)
27419 {
d0ae0cb4 27420 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27421#ifdef USE_CYCLONE_TIMING_DIV
27422RET(162)
27423#else
27424RET(22)
27425#endif
27426 }
27427 dst = DREGu32((Opcode >> 9) & 7);
27428 {
27429 u32 q, r;
27430
27431 q = dst / src;
27432 r = dst % src;
27433
27434 if (q & 0xFFFF0000)
27435 {
27436 flag_V = M68K_SR_V;
27437#ifdef USE_CYCLONE_TIMING_DIV
27438RET(162)
27439#else
27440 RET(82)
27441#endif
27442 }
27443 q &= 0x0000FFFF;
27444 flag_NotZ = q;
27445 flag_N = q >> 8;
27446 flag_V = flag_C = 0;
27447 res = q | (r << 16);
27448 DREGu32((Opcode >> 9) & 7) = res;
27449 }
27450#ifdef USE_CYCLONE_TIMING_DIV
27451RET(162)
27452#else
27453RET(102)
27454#endif
27455}
27456
27457// DIVU
27458OPCODE(0x80FA)
27459{
27460 u32 adr, res;
27461 u32 src, dst;
27462
be26eb23 27463 adr = GET_SWORD + GET_PC;
70357ce5 27464 PC++;
27465 PRE_IO
27466 READ_WORD_F(adr, src)
27467 if (src == 0)
27468 {
d0ae0cb4 27469 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27470#ifdef USE_CYCLONE_TIMING_DIV
27471RET(148)
27472#else
27473RET(18)
27474#endif
27475 }
27476 dst = DREGu32((Opcode >> 9) & 7);
27477 {
27478 u32 q, r;
27479
27480 q = dst / src;
27481 r = dst % src;
27482
27483 if (q & 0xFFFF0000)
27484 {
27485 flag_V = M68K_SR_V;
27486#ifdef USE_CYCLONE_TIMING_DIV
27487RET(148)
27488#else
27489 RET(78)
27490#endif
27491 }
27492 q &= 0x0000FFFF;
27493 flag_NotZ = q;
27494 flag_N = q >> 8;
27495 flag_V = flag_C = 0;
27496 res = q | (r << 16);
27497 DREGu32((Opcode >> 9) & 7) = res;
27498 }
27499#ifdef USE_CYCLONE_TIMING_DIV
27500RET(148)
27501#else
27502RET(98)
27503#endif
27504}
27505
27506// DIVU
27507OPCODE(0x80FB)
27508{
27509 u32 adr, res;
27510 u32 src, dst;
27511
be26eb23 27512 adr = GET_PC;
70357ce5 27513 DECODE_EXT_WORD
27514 PRE_IO
27515 READ_WORD_F(adr, src)
27516 if (src == 0)
27517 {
d0ae0cb4 27518 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27519#ifdef USE_CYCLONE_TIMING_DIV
27520RET(160)
27521#else
27522RET(20)
27523#endif
27524 }
27525 dst = DREGu32((Opcode >> 9) & 7);
27526 {
27527 u32 q, r;
27528
27529 q = dst / src;
27530 r = dst % src;
27531
27532 if (q & 0xFFFF0000)
27533 {
27534 flag_V = M68K_SR_V;
27535#ifdef USE_CYCLONE_TIMING_DIV
27536RET(160)
27537#else
27538 RET(80)
27539#endif
27540 }
27541 q &= 0x0000FFFF;
27542 flag_NotZ = q;
27543 flag_N = q >> 8;
27544 flag_V = flag_C = 0;
27545 res = q | (r << 16);
27546 DREGu32((Opcode >> 9) & 7) = res;
27547 }
27548#ifdef USE_CYCLONE_TIMING_DIV
27549RET(160)
27550#else
27551RET(100)
27552#endif
27553}
27554
27555// DIVU
27556OPCODE(0x80FC)
27557{
27558 u32 adr, res;
27559 u32 src, dst;
27560
27561 FETCH_WORD(src);
27562 if (src == 0)
27563 {
d0ae0cb4 27564 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27565#ifdef USE_CYCLONE_TIMING_DIV
27566RET(144)
27567#else
27568RET(14)
27569#endif
27570 }
27571 dst = DREGu32((Opcode >> 9) & 7);
27572 {
27573 u32 q, r;
27574
27575 q = dst / src;
27576 r = dst % src;
27577
27578 if (q & 0xFFFF0000)
27579 {
27580 flag_V = M68K_SR_V;
27581#ifdef USE_CYCLONE_TIMING_DIV
27582RET(144)
27583#else
27584 RET(74)
27585#endif
27586 }
27587 q &= 0x0000FFFF;
27588 flag_NotZ = q;
27589 flag_N = q >> 8;
27590 flag_V = flag_C = 0;
27591 res = q | (r << 16);
27592 DREGu32((Opcode >> 9) & 7) = res;
27593 }
27594#ifdef USE_CYCLONE_TIMING_DIV
27595RET(144)
27596#else
27597RET(94)
27598#endif
27599}
27600
27601// DIVU
27602OPCODE(0x80DF)
27603{
27604 u32 adr, res;
27605 u32 src, dst;
27606
27607 adr = AREG(7);
27608 AREG(7) += 2;
27609 PRE_IO
27610 READ_WORD_F(adr, src)
27611 if (src == 0)
27612 {
d0ae0cb4 27613 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27614#ifdef USE_CYCLONE_TIMING_DIV
27615RET(144)
27616#else
27617RET(14)
27618#endif
27619 }
27620 dst = DREGu32((Opcode >> 9) & 7);
27621 {
27622 u32 q, r;
27623
27624 q = dst / src;
27625 r = dst % src;
27626
27627 if (q & 0xFFFF0000)
27628 {
27629 flag_V = M68K_SR_V;
27630#ifdef USE_CYCLONE_TIMING_DIV
27631RET(144)
27632#else
27633 RET(74)
27634#endif
27635 }
27636 q &= 0x0000FFFF;
27637 flag_NotZ = q;
27638 flag_N = q >> 8;
27639 flag_V = flag_C = 0;
27640 res = q | (r << 16);
27641 DREGu32((Opcode >> 9) & 7) = res;
27642 }
27643#ifdef USE_CYCLONE_TIMING_DIV
27644RET(144)
27645#else
27646RET(94)
27647#endif
27648}
27649
27650// DIVU
27651OPCODE(0x80E7)
27652{
27653 u32 adr, res;
27654 u32 src, dst;
27655
27656 adr = AREG(7) - 2;
27657 AREG(7) = adr;
27658 PRE_IO
27659 READ_WORD_F(adr, src)
27660 if (src == 0)
27661 {
d0ae0cb4 27662 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27663#ifdef USE_CYCLONE_TIMING_DIV
27664RET(146)
27665#else
27666RET(16)
27667#endif
27668 }
27669 dst = DREGu32((Opcode >> 9) & 7);
27670 {
27671 u32 q, r;
27672
27673 q = dst / src;
27674 r = dst % src;
27675
27676 if (q & 0xFFFF0000)
27677 {
27678 flag_V = M68K_SR_V;
27679#ifdef USE_CYCLONE_TIMING_DIV
27680RET(146)
27681#else
27682 RET(76)
27683#endif
27684 }
27685 q &= 0x0000FFFF;
27686 flag_NotZ = q;
27687 flag_N = q >> 8;
27688 flag_V = flag_C = 0;
27689 res = q | (r << 16);
27690 DREGu32((Opcode >> 9) & 7) = res;
27691 }
27692#ifdef USE_CYCLONE_TIMING_DIV
27693RET(146)
27694#else
27695RET(96)
27696#endif
27697}
27698
27699// DIVS
27700OPCODE(0x81C0)
27701{
27702 u32 adr, res;
27703 u32 src, dst;
27704
27705 src = (s32)DREGs16((Opcode >> 0) & 7);
27706 if (src == 0)
27707 {
d0ae0cb4 27708 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27709#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27710goto end81C0;
70357ce5 27711#endif
27712 RET(10)
27713 }
27714 dst = DREGu32((Opcode >> 9) & 7);
27715 if ((dst == 0x80000000) && (src == (u32)-1))
27716 {
27717 flag_NotZ = flag_N = 0;
27718 flag_V = flag_C = 0;
27719 res = 0;
27720 DREGu32((Opcode >> 9) & 7) = res;
27721#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27722goto end81C0;
70357ce5 27723#endif
27724 RET(50)
27725 }
27726 {
27727 s32 q, r;
27728
27729 q = (s32)dst / (s32)src;
27730 r = (s32)dst % (s32)src;
27731
27732 if ((q > 0x7FFF) || (q < -0x8000))
27733 {
27734 flag_V = M68K_SR_V;
27735#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27736goto end81C0;
70357ce5 27737#endif
27738 RET(80)
27739 }
27740 q &= 0x0000FFFF;
27741 flag_NotZ = q;
27742 flag_N = q >> 8;
27743 flag_V = flag_C = 0;
27744 res = q | (r << 16);
27745 DREGu32((Opcode >> 9) & 7) = res;
27746 }
27747#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27748end81C0: m68kcontext.io_cycle_counter -= 50;
70357ce5 27749#endif
27750RET(108)
27751}
27752
27753// DIVS
27754OPCODE(0x81D0)
27755{
27756 u32 adr, res;
27757 u32 src, dst;
27758
27759 adr = AREG((Opcode >> 0) & 7);
27760 PRE_IO
27761 READSX_WORD_F(adr, src)
27762 if (src == 0)
27763 {
d0ae0cb4 27764 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27765#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27766goto end81D0;
70357ce5 27767#endif
27768 RET(14)
27769 }
27770 dst = DREGu32((Opcode >> 9) & 7);
27771 if ((dst == 0x80000000) && (src == (u32)-1))
27772 {
27773 flag_NotZ = flag_N = 0;
27774 flag_V = flag_C = 0;
27775 res = 0;
27776 DREGu32((Opcode >> 9) & 7) = res;
27777#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27778goto end81D0;
70357ce5 27779#endif
27780 RET(54)
27781 }
27782 {
27783 s32 q, r;
27784
27785 q = (s32)dst / (s32)src;
27786 r = (s32)dst % (s32)src;
27787
27788 if ((q > 0x7FFF) || (q < -0x8000))
27789 {
27790 flag_V = M68K_SR_V;
27791#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27792goto end81D0;
70357ce5 27793#endif
27794 RET(84)
27795 }
27796 q &= 0x0000FFFF;
27797 flag_NotZ = q;
27798 flag_N = q >> 8;
27799 flag_V = flag_C = 0;
27800 res = q | (r << 16);
27801 DREGu32((Opcode >> 9) & 7) = res;
27802 }
27803#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27804end81D0: m68kcontext.io_cycle_counter -= 50;
70357ce5 27805#endif
27806RET(112)
27807}
27808
27809// DIVS
27810OPCODE(0x81D8)
27811{
27812 u32 adr, res;
27813 u32 src, dst;
27814
27815 adr = AREG((Opcode >> 0) & 7);
27816 AREG((Opcode >> 0) & 7) += 2;
27817 PRE_IO
27818 READSX_WORD_F(adr, src)
27819 if (src == 0)
27820 {
d0ae0cb4 27821 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27822#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27823goto end81D8;
70357ce5 27824#endif
27825 RET(14)
27826 }
27827 dst = DREGu32((Opcode >> 9) & 7);
27828 if ((dst == 0x80000000) && (src == (u32)-1))
27829 {
27830 flag_NotZ = flag_N = 0;
27831 flag_V = flag_C = 0;
27832 res = 0;
27833 DREGu32((Opcode >> 9) & 7) = res;
27834#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27835goto end81D8;
70357ce5 27836#endif
27837 RET(54)
27838 }
27839 {
27840 s32 q, r;
27841
27842 q = (s32)dst / (s32)src;
27843 r = (s32)dst % (s32)src;
27844
27845 if ((q > 0x7FFF) || (q < -0x8000))
27846 {
27847 flag_V = M68K_SR_V;
27848#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27849goto end81D8;
70357ce5 27850#endif
27851 RET(84)
27852 }
27853 q &= 0x0000FFFF;
27854 flag_NotZ = q;
27855 flag_N = q >> 8;
27856 flag_V = flag_C = 0;
27857 res = q | (r << 16);
27858 DREGu32((Opcode >> 9) & 7) = res;
27859 }
27860#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27861end81D8: m68kcontext.io_cycle_counter -= 50;
70357ce5 27862#endif
27863RET(112)
27864}
27865
27866// DIVS
27867OPCODE(0x81E0)
27868{
27869 u32 adr, res;
27870 u32 src, dst;
27871
27872 adr = AREG((Opcode >> 0) & 7) - 2;
27873 AREG((Opcode >> 0) & 7) = adr;
27874 PRE_IO
27875 READSX_WORD_F(adr, src)
27876 if (src == 0)
27877 {
d0ae0cb4 27878 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27879#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27880goto end81E0;
70357ce5 27881#endif
27882 RET(16)
27883 }
27884 dst = DREGu32((Opcode >> 9) & 7);
27885 if ((dst == 0x80000000) && (src == (u32)-1))
27886 {
27887 flag_NotZ = flag_N = 0;
27888 flag_V = flag_C = 0;
27889 res = 0;
27890 DREGu32((Opcode >> 9) & 7) = res;
27891#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27892goto end81E0;
70357ce5 27893#endif
27894 RET(56)
27895 }
27896 {
27897 s32 q, r;
27898
27899 q = (s32)dst / (s32)src;
27900 r = (s32)dst % (s32)src;
27901
27902 if ((q > 0x7FFF) || (q < -0x8000))
27903 {
27904 flag_V = M68K_SR_V;
27905#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27906goto end81E0;
70357ce5 27907#endif
27908 RET(86)
27909 }
27910 q &= 0x0000FFFF;
27911 flag_NotZ = q;
27912 flag_N = q >> 8;
27913 flag_V = flag_C = 0;
27914 res = q | (r << 16);
27915 DREGu32((Opcode >> 9) & 7) = res;
27916 }
27917#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27918end81E0: m68kcontext.io_cycle_counter -= 50;
70357ce5 27919#endif
27920RET(114)
27921}
27922
27923// DIVS
27924OPCODE(0x81E8)
27925{
27926 u32 adr, res;
27927 u32 src, dst;
27928
27929 FETCH_SWORD(adr);
27930 adr += AREG((Opcode >> 0) & 7);
27931 PRE_IO
27932 READSX_WORD_F(adr, src)
27933 if (src == 0)
27934 {
d0ae0cb4 27935 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27936#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27937goto end81E8;
70357ce5 27938#endif
27939 RET(18)
27940 }
27941 dst = DREGu32((Opcode >> 9) & 7);
27942 if ((dst == 0x80000000) && (src == (u32)-1))
27943 {
27944 flag_NotZ = flag_N = 0;
27945 flag_V = flag_C = 0;
27946 res = 0;
27947 DREGu32((Opcode >> 9) & 7) = res;
27948#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27949goto end81E8;
70357ce5 27950#endif
27951 RET(58)
27952 }
27953 {
27954 s32 q, r;
27955
27956 q = (s32)dst / (s32)src;
27957 r = (s32)dst % (s32)src;
27958
27959 if ((q > 0x7FFF) || (q < -0x8000))
27960 {
27961 flag_V = M68K_SR_V;
27962#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27963goto end81E8;
70357ce5 27964#endif
27965 RET(88)
27966 }
27967 q &= 0x0000FFFF;
27968 flag_NotZ = q;
27969 flag_N = q >> 8;
27970 flag_V = flag_C = 0;
27971 res = q | (r << 16);
27972 DREGu32((Opcode >> 9) & 7) = res;
27973 }
27974#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27975end81E8: m68kcontext.io_cycle_counter -= 50;
70357ce5 27976#endif
27977RET(116)
27978}
27979
27980// DIVS
27981OPCODE(0x81F0)
27982{
27983 u32 adr, res;
27984 u32 src, dst;
27985
27986 adr = AREG((Opcode >> 0) & 7);
27987 DECODE_EXT_WORD
27988 PRE_IO
27989 READSX_WORD_F(adr, src)
27990 if (src == 0)
27991 {
d0ae0cb4 27992 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 27993#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 27994goto end81F0;
70357ce5 27995#endif
27996 RET(20)
27997 }
27998 dst = DREGu32((Opcode >> 9) & 7);
27999 if ((dst == 0x80000000) && (src == (u32)-1))
28000 {
28001 flag_NotZ = flag_N = 0;
28002 flag_V = flag_C = 0;
28003 res = 0;
28004 DREGu32((Opcode >> 9) & 7) = res;
28005#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28006goto end81F0;
70357ce5 28007#endif
28008 RET(60)
28009 }
28010 {
28011 s32 q, r;
28012
28013 q = (s32)dst / (s32)src;
28014 r = (s32)dst % (s32)src;
28015
28016 if ((q > 0x7FFF) || (q < -0x8000))
28017 {
28018 flag_V = M68K_SR_V;
28019#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28020goto end81F0;
70357ce5 28021#endif
28022 RET(90)
28023 }
28024 q &= 0x0000FFFF;
28025 flag_NotZ = q;
28026 flag_N = q >> 8;
28027 flag_V = flag_C = 0;
28028 res = q | (r << 16);
28029 DREGu32((Opcode >> 9) & 7) = res;
28030 }
28031#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28032end81F0: m68kcontext.io_cycle_counter -= 50;
70357ce5 28033#endif
28034RET(118)
28035}
28036
28037// DIVS
28038OPCODE(0x81F8)
28039{
28040 u32 adr, res;
28041 u32 src, dst;
28042
28043 FETCH_SWORD(adr);
28044 PRE_IO
28045 READSX_WORD_F(adr, src)
28046 if (src == 0)
28047 {
d0ae0cb4 28048 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28049#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28050goto end81F8;
70357ce5 28051#endif
28052 RET(18)
28053 }
28054 dst = DREGu32((Opcode >> 9) & 7);
28055 if ((dst == 0x80000000) && (src == (u32)-1))
28056 {
28057 flag_NotZ = flag_N = 0;
28058 flag_V = flag_C = 0;
28059 res = 0;
28060 DREGu32((Opcode >> 9) & 7) = res;
28061#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28062goto end81F8;
70357ce5 28063#endif
28064 RET(58)
28065 }
28066 {
28067 s32 q, r;
28068
28069 q = (s32)dst / (s32)src;
28070 r = (s32)dst % (s32)src;
28071
28072 if ((q > 0x7FFF) || (q < -0x8000))
28073 {
28074 flag_V = M68K_SR_V;
28075#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28076goto end81F8;
70357ce5 28077#endif
28078 RET(88)
28079 }
28080 q &= 0x0000FFFF;
28081 flag_NotZ = q;
28082 flag_N = q >> 8;
28083 flag_V = flag_C = 0;
28084 res = q | (r << 16);
28085 DREGu32((Opcode >> 9) & 7) = res;
28086 }
28087#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28088end81F8: m68kcontext.io_cycle_counter -= 50;
70357ce5 28089#endif
28090RET(116)
28091}
28092
28093// DIVS
28094OPCODE(0x81F9)
28095{
28096 u32 adr, res;
28097 u32 src, dst;
28098
28099 FETCH_LONG(adr);
28100 PRE_IO
28101 READSX_WORD_F(adr, src)
28102 if (src == 0)
28103 {
d0ae0cb4 28104 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28105#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28106goto end81F9;
70357ce5 28107#endif
28108 RET(22)
28109 }
28110 dst = DREGu32((Opcode >> 9) & 7);
28111 if ((dst == 0x80000000) && (src == (u32)-1))
28112 {
28113 flag_NotZ = flag_N = 0;
28114 flag_V = flag_C = 0;
28115 res = 0;
28116 DREGu32((Opcode >> 9) & 7) = res;
28117#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28118goto end81F9;
70357ce5 28119#endif
28120 RET(62)
28121 }
28122 {
28123 s32 q, r;
28124
28125 q = (s32)dst / (s32)src;
28126 r = (s32)dst % (s32)src;
28127
28128 if ((q > 0x7FFF) || (q < -0x8000))
28129 {
28130 flag_V = M68K_SR_V;
28131#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28132goto end81F9;
70357ce5 28133#endif
28134 RET(92)
28135 }
28136 q &= 0x0000FFFF;
28137 flag_NotZ = q;
28138 flag_N = q >> 8;
28139 flag_V = flag_C = 0;
28140 res = q | (r << 16);
28141 DREGu32((Opcode >> 9) & 7) = res;
28142 }
28143#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28144end81F9: m68kcontext.io_cycle_counter -= 50;
70357ce5 28145#endif
28146RET(120)
28147}
28148
28149// DIVS
28150OPCODE(0x81FA)
28151{
28152 u32 adr, res;
28153 u32 src, dst;
28154
be26eb23 28155 adr = GET_SWORD + GET_PC;
70357ce5 28156 PC++;
28157 PRE_IO
28158 READSX_WORD_F(adr, src)
28159 if (src == 0)
28160 {
d0ae0cb4 28161 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28162#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28163goto end81FA;
70357ce5 28164#endif
28165 RET(18)
28166 }
28167 dst = DREGu32((Opcode >> 9) & 7);
28168 if ((dst == 0x80000000) && (src == (u32)-1))
28169 {
28170 flag_NotZ = flag_N = 0;
28171 flag_V = flag_C = 0;
28172 res = 0;
28173 DREGu32((Opcode >> 9) & 7) = res;
28174#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28175goto end81FA;
70357ce5 28176#endif
28177 RET(58)
28178 }
28179 {
28180 s32 q, r;
28181
28182 q = (s32)dst / (s32)src;
28183 r = (s32)dst % (s32)src;
28184
28185 if ((q > 0x7FFF) || (q < -0x8000))
28186 {
28187 flag_V = M68K_SR_V;
28188#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28189goto end81FA;
70357ce5 28190#endif
28191 RET(88)
28192 }
28193 q &= 0x0000FFFF;
28194 flag_NotZ = q;
28195 flag_N = q >> 8;
28196 flag_V = flag_C = 0;
28197 res = q | (r << 16);
28198 DREGu32((Opcode >> 9) & 7) = res;
28199 }
28200#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28201end81FA: m68kcontext.io_cycle_counter -= 50;
70357ce5 28202#endif
28203RET(116)
28204}
28205
28206// DIVS
28207OPCODE(0x81FB)
28208{
28209 u32 adr, res;
28210 u32 src, dst;
28211
be26eb23 28212 adr = GET_PC;
70357ce5 28213 DECODE_EXT_WORD
28214 PRE_IO
28215 READSX_WORD_F(adr, src)
28216 if (src == 0)
28217 {
d0ae0cb4 28218 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28219#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28220goto end81FB;
70357ce5 28221#endif
28222 RET(20)
28223 }
28224 dst = DREGu32((Opcode >> 9) & 7);
28225 if ((dst == 0x80000000) && (src == (u32)-1))
28226 {
28227 flag_NotZ = flag_N = 0;
28228 flag_V = flag_C = 0;
28229 res = 0;
28230 DREGu32((Opcode >> 9) & 7) = res;
28231#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28232goto end81FB;
70357ce5 28233#endif
28234 RET(60)
28235 }
28236 {
28237 s32 q, r;
28238
28239 q = (s32)dst / (s32)src;
28240 r = (s32)dst % (s32)src;
28241
28242 if ((q > 0x7FFF) || (q < -0x8000))
28243 {
28244 flag_V = M68K_SR_V;
28245#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28246goto end81FB;
70357ce5 28247#endif
28248 RET(90)
28249 }
28250 q &= 0x0000FFFF;
28251 flag_NotZ = q;
28252 flag_N = q >> 8;
28253 flag_V = flag_C = 0;
28254 res = q | (r << 16);
28255 DREGu32((Opcode >> 9) & 7) = res;
28256 }
28257#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28258end81FB: m68kcontext.io_cycle_counter -= 50;
70357ce5 28259#endif
28260RET(118)
28261}
28262
28263// DIVS
28264OPCODE(0x81FC)
28265{
28266 u32 adr, res;
28267 u32 src, dst;
28268
28269 FETCH_SWORD(src);
28270 if (src == 0)
28271 {
d0ae0cb4 28272 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28273#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28274goto end81FC;
70357ce5 28275#endif
28276 RET(14)
28277 }
28278 dst = DREGu32((Opcode >> 9) & 7);
28279 if ((dst == 0x80000000) && (src == (u32)-1))
28280 {
28281 flag_NotZ = flag_N = 0;
28282 flag_V = flag_C = 0;
28283 res = 0;
28284 DREGu32((Opcode >> 9) & 7) = res;
28285#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28286goto end81FC;
70357ce5 28287#endif
28288 RET(54)
28289 }
28290 {
28291 s32 q, r;
28292
28293 q = (s32)dst / (s32)src;
28294 r = (s32)dst % (s32)src;
28295
28296 if ((q > 0x7FFF) || (q < -0x8000))
28297 {
28298 flag_V = M68K_SR_V;
28299#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28300goto end81FC;
70357ce5 28301#endif
28302 RET(84)
28303 }
28304 q &= 0x0000FFFF;
28305 flag_NotZ = q;
28306 flag_N = q >> 8;
28307 flag_V = flag_C = 0;
28308 res = q | (r << 16);
28309 DREGu32((Opcode >> 9) & 7) = res;
28310 }
28311#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28312end81FC: m68kcontext.io_cycle_counter -= 50;
70357ce5 28313#endif
28314RET(112)
28315}
28316
28317// DIVS
28318OPCODE(0x81DF)
28319{
28320 u32 adr, res;
28321 u32 src, dst;
28322
28323 adr = AREG(7);
28324 AREG(7) += 2;
28325 PRE_IO
28326 READSX_WORD_F(adr, src)
28327 if (src == 0)
28328 {
d0ae0cb4 28329 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28330#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28331goto end81DF;
70357ce5 28332#endif
28333 RET(14)
28334 }
28335 dst = DREGu32((Opcode >> 9) & 7);
28336 if ((dst == 0x80000000) && (src == (u32)-1))
28337 {
28338 flag_NotZ = flag_N = 0;
28339 flag_V = flag_C = 0;
28340 res = 0;
28341 DREGu32((Opcode >> 9) & 7) = res;
28342#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28343goto end81DF;
70357ce5 28344#endif
28345 RET(54)
28346 }
28347 {
28348 s32 q, r;
28349
28350 q = (s32)dst / (s32)src;
28351 r = (s32)dst % (s32)src;
28352
28353 if ((q > 0x7FFF) || (q < -0x8000))
28354 {
28355 flag_V = M68K_SR_V;
28356#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28357goto end81DF;
70357ce5 28358#endif
28359 RET(84)
28360 }
28361 q &= 0x0000FFFF;
28362 flag_NotZ = q;
28363 flag_N = q >> 8;
28364 flag_V = flag_C = 0;
28365 res = q | (r << 16);
28366 DREGu32((Opcode >> 9) & 7) = res;
28367 }
28368#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28369end81DF: m68kcontext.io_cycle_counter -= 50;
70357ce5 28370#endif
28371RET(112)
28372}
28373
28374// DIVS
28375OPCODE(0x81E7)
28376{
28377 u32 adr, res;
28378 u32 src, dst;
28379
28380 adr = AREG(7) - 2;
28381 AREG(7) = adr;
28382 PRE_IO
28383 READSX_WORD_F(adr, src)
28384 if (src == 0)
28385 {
d0ae0cb4 28386 SET_PC(execute_exception(M68K_ZERO_DIVIDE_EX, GET_PC, GET_SR));
70357ce5 28387#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28388goto end81E7;
70357ce5 28389#endif
28390 RET(16)
28391 }
28392 dst = DREGu32((Opcode >> 9) & 7);
28393 if ((dst == 0x80000000) && (src == (u32)-1))
28394 {
28395 flag_NotZ = flag_N = 0;
28396 flag_V = flag_C = 0;
28397 res = 0;
28398 DREGu32((Opcode >> 9) & 7) = res;
28399#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28400goto end81E7;
70357ce5 28401#endif
28402 RET(56)
28403 }
28404 {
28405 s32 q, r;
28406
28407 q = (s32)dst / (s32)src;
28408 r = (s32)dst % (s32)src;
28409
28410 if ((q > 0x7FFF) || (q < -0x8000))
28411 {
28412 flag_V = M68K_SR_V;
28413#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28414goto end81E7;
70357ce5 28415#endif
28416 RET(86)
28417 }
28418 q &= 0x0000FFFF;
28419 flag_NotZ = q;
28420 flag_N = q >> 8;
28421 flag_V = flag_C = 0;
28422 res = q | (r << 16);
28423 DREGu32((Opcode >> 9) & 7) = res;
28424 }
28425#ifdef USE_CYCLONE_TIMING_DIV
9112b6ce 28426end81E7: m68kcontext.io_cycle_counter -= 50;
70357ce5 28427#endif
28428RET(114)
28429}
28430
28431// SUBaD
28432OPCODE(0x9000)
28433{
28434 u32 adr, res;
28435 u32 src, dst;
28436
28437 src = DREGu8((Opcode >> 0) & 7);
28438 dst = DREGu8((Opcode >> 9) & 7);
28439 res = dst - src;
28440 flag_N = flag_X = flag_C = res;
28441 flag_V = (src ^ dst) & (res ^ dst);
28442 flag_NotZ = res & 0xFF;
28443 DREGu8((Opcode >> 9) & 7) = res;
28444RET(4)
28445}
28446
28447// SUBaD
03e4f2a3 28448#if 0
70357ce5 28449OPCODE(0x9008)
28450{
28451 u32 adr, res;
28452 u32 src, dst;
28453
28454 // can't read byte from Ax registers !
28455 m68kcontext.execinfo |= M68K_FAULTED;
28456 m68kcontext.io_cycle_counter = 0;
28457/*
28458 goto famec_Exec_End;
28459 dst = DREGu8((Opcode >> 9) & 7);
28460 res = dst - src;
28461 flag_N = flag_X = flag_C = res;
28462 flag_V = (src ^ dst) & (res ^ dst);
28463 flag_NotZ = res & 0xFF;
28464 DREGu8((Opcode >> 9) & 7) = res;
28465*/
28466RET(4)
28467}
03e4f2a3 28468#endif
70357ce5 28469
28470// SUBaD
28471OPCODE(0x9010)
28472{
28473 u32 adr, res;
28474 u32 src, dst;
28475
28476 adr = AREG((Opcode >> 0) & 7);
28477 PRE_IO
28478 READ_BYTE_F(adr, src)
28479 dst = DREGu8((Opcode >> 9) & 7);
28480 res = dst - src;
28481 flag_N = flag_X = flag_C = res;
28482 flag_V = (src ^ dst) & (res ^ dst);
28483 flag_NotZ = res & 0xFF;
28484 DREGu8((Opcode >> 9) & 7) = res;
28485 POST_IO
28486RET(8)
28487}
28488
28489// SUBaD
28490OPCODE(0x9018)
28491{
28492 u32 adr, res;
28493 u32 src, dst;
28494
28495 adr = AREG((Opcode >> 0) & 7);
28496 AREG((Opcode >> 0) & 7) += 1;
28497 PRE_IO
28498 READ_BYTE_F(adr, src)
28499 dst = DREGu8((Opcode >> 9) & 7);
28500 res = dst - src;
28501 flag_N = flag_X = flag_C = res;
28502 flag_V = (src ^ dst) & (res ^ dst);
28503 flag_NotZ = res & 0xFF;
28504 DREGu8((Opcode >> 9) & 7) = res;
28505 POST_IO
28506RET(8)
28507}
28508
28509// SUBaD
28510OPCODE(0x9020)
28511{
28512 u32 adr, res;
28513 u32 src, dst;
28514
28515 adr = AREG((Opcode >> 0) & 7) - 1;
28516 AREG((Opcode >> 0) & 7) = adr;
28517 PRE_IO
28518 READ_BYTE_F(adr, src)
28519 dst = DREGu8((Opcode >> 9) & 7);
28520 res = dst - src;
28521 flag_N = flag_X = flag_C = res;
28522 flag_V = (src ^ dst) & (res ^ dst);
28523 flag_NotZ = res & 0xFF;
28524 DREGu8((Opcode >> 9) & 7) = res;
28525 POST_IO
28526RET(10)
28527}
28528
28529// SUBaD
28530OPCODE(0x9028)
28531{
28532 u32 adr, res;
28533 u32 src, dst;
28534
28535 FETCH_SWORD(adr);
28536 adr += AREG((Opcode >> 0) & 7);
28537 PRE_IO
28538 READ_BYTE_F(adr, src)
28539 dst = DREGu8((Opcode >> 9) & 7);
28540 res = dst - src;
28541 flag_N = flag_X = flag_C = res;
28542 flag_V = (src ^ dst) & (res ^ dst);
28543 flag_NotZ = res & 0xFF;
28544 DREGu8((Opcode >> 9) & 7) = res;
28545 POST_IO
28546RET(12)
28547}
28548
28549// SUBaD
28550OPCODE(0x9030)
28551{
28552 u32 adr, res;
28553 u32 src, dst;
28554
28555 adr = AREG((Opcode >> 0) & 7);
28556 DECODE_EXT_WORD
28557 PRE_IO
28558 READ_BYTE_F(adr, src)
28559 dst = DREGu8((Opcode >> 9) & 7);
28560 res = dst - src;
28561 flag_N = flag_X = flag_C = res;
28562 flag_V = (src ^ dst) & (res ^ dst);
28563 flag_NotZ = res & 0xFF;
28564 DREGu8((Opcode >> 9) & 7) = res;
28565 POST_IO
28566RET(14)
28567}
28568
28569// SUBaD
28570OPCODE(0x9038)
28571{
28572 u32 adr, res;
28573 u32 src, dst;
28574
28575 FETCH_SWORD(adr);
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(12)
28586}
28587
28588// SUBaD
28589OPCODE(0x9039)
28590{
28591 u32 adr, res;
28592 u32 src, dst;
28593
28594 FETCH_LONG(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(16)
28605}
28606
28607// SUBaD
28608OPCODE(0x903A)
28609{
28610 u32 adr, res;
28611 u32 src, dst;
28612
be26eb23 28613 adr = GET_SWORD + GET_PC;
70357ce5 28614 PC++;
28615 PRE_IO
28616 READ_BYTE_F(adr, src)
28617 dst = DREGu8((Opcode >> 9) & 7);
28618 res = dst - src;
28619 flag_N = flag_X = flag_C = res;
28620 flag_V = (src ^ dst) & (res ^ dst);
28621 flag_NotZ = res & 0xFF;
28622 DREGu8((Opcode >> 9) & 7) = res;
28623 POST_IO
28624RET(12)
28625}
28626
28627// SUBaD
28628OPCODE(0x903B)
28629{
28630 u32 adr, res;
28631 u32 src, dst;
28632
be26eb23 28633 adr = GET_PC;
70357ce5 28634 DECODE_EXT_WORD
28635 PRE_IO
28636 READ_BYTE_F(adr, src)
28637 dst = DREGu8((Opcode >> 9) & 7);
28638 res = dst - src;
28639 flag_N = flag_X = flag_C = res;
28640 flag_V = (src ^ dst) & (res ^ dst);
28641 flag_NotZ = res & 0xFF;
28642 DREGu8((Opcode >> 9) & 7) = res;
28643 POST_IO
28644RET(14)
28645}
28646
28647// SUBaD
28648OPCODE(0x903C)
28649{
28650 u32 adr, res;
28651 u32 src, dst;
28652
28653 FETCH_BYTE(src);
28654 dst = DREGu8((Opcode >> 9) & 7);
28655 res = dst - src;
28656 flag_N = flag_X = flag_C = res;
28657 flag_V = (src ^ dst) & (res ^ dst);
28658 flag_NotZ = res & 0xFF;
28659 DREGu8((Opcode >> 9) & 7) = res;
28660RET(8)
28661}
28662
28663// SUBaD
28664OPCODE(0x901F)
28665{
28666 u32 adr, res;
28667 u32 src, dst;
28668
28669 adr = AREG(7);
28670 AREG(7) += 2;
28671 PRE_IO
28672 READ_BYTE_F(adr, 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;
28679 POST_IO
28680RET(8)
28681}
28682
28683// SUBaD
28684OPCODE(0x9027)
28685{
28686 u32 adr, res;
28687 u32 src, dst;
28688
28689 adr = AREG(7) - 2;
28690 AREG(7) = adr;
28691 PRE_IO
28692 READ_BYTE_F(adr, src)
28693 dst = DREGu8((Opcode >> 9) & 7);
28694 res = dst - src;
28695 flag_N = flag_X = flag_C = res;
28696 flag_V = (src ^ dst) & (res ^ dst);
28697 flag_NotZ = res & 0xFF;
28698 DREGu8((Opcode >> 9) & 7) = res;
28699 POST_IO
28700RET(10)
28701}
28702
28703// SUBaD
28704OPCODE(0x9040)
28705{
28706 u32 adr, res;
28707 u32 src, dst;
28708
28709 src = DREGu16((Opcode >> 0) & 7);
28710 dst = DREGu16((Opcode >> 9) & 7);
28711 res = dst - src;
28712 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28713 flag_N = flag_X = flag_C = res >> 8;
28714 flag_NotZ = res & 0xFFFF;
28715 DREGu16((Opcode >> 9) & 7) = res;
28716RET(4)
28717}
28718
28719// SUBaD
28720OPCODE(0x9048)
28721{
28722 u32 adr, res;
28723 u32 src, dst;
28724
28725 src = AREGu16((Opcode >> 0) & 7);
28726 dst = DREGu16((Opcode >> 9) & 7);
28727 res = dst - src;
28728 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28729 flag_N = flag_X = flag_C = res >> 8;
28730 flag_NotZ = res & 0xFFFF;
28731 DREGu16((Opcode >> 9) & 7) = res;
28732RET(4)
28733}
28734
28735// SUBaD
28736OPCODE(0x9050)
28737{
28738 u32 adr, res;
28739 u32 src, dst;
28740
28741 adr = AREG((Opcode >> 0) & 7);
28742 PRE_IO
28743 READ_WORD_F(adr, src)
28744 dst = DREGu16((Opcode >> 9) & 7);
28745 res = dst - src;
28746 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28747 flag_N = flag_X = flag_C = res >> 8;
28748 flag_NotZ = res & 0xFFFF;
28749 DREGu16((Opcode >> 9) & 7) = res;
28750 POST_IO
28751RET(8)
28752}
28753
28754// SUBaD
28755OPCODE(0x9058)
28756{
28757 u32 adr, res;
28758 u32 src, dst;
28759
28760 adr = AREG((Opcode >> 0) & 7);
28761 AREG((Opcode >> 0) & 7) += 2;
28762 PRE_IO
28763 READ_WORD_F(adr, src)
28764 dst = DREGu16((Opcode >> 9) & 7);
28765 res = dst - src;
28766 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28767 flag_N = flag_X = flag_C = res >> 8;
28768 flag_NotZ = res & 0xFFFF;
28769 DREGu16((Opcode >> 9) & 7) = res;
28770 POST_IO
28771RET(8)
28772}
28773
28774// SUBaD
28775OPCODE(0x9060)
28776{
28777 u32 adr, res;
28778 u32 src, dst;
28779
28780 adr = AREG((Opcode >> 0) & 7) - 2;
28781 AREG((Opcode >> 0) & 7) = adr;
28782 PRE_IO
28783 READ_WORD_F(adr, src)
28784 dst = DREGu16((Opcode >> 9) & 7);
28785 res = dst - src;
28786 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28787 flag_N = flag_X = flag_C = res >> 8;
28788 flag_NotZ = res & 0xFFFF;
28789 DREGu16((Opcode >> 9) & 7) = res;
28790 POST_IO
28791RET(10)
28792}
28793
28794// SUBaD
28795OPCODE(0x9068)
28796{
28797 u32 adr, res;
28798 u32 src, dst;
28799
28800 FETCH_SWORD(adr);
28801 adr += AREG((Opcode >> 0) & 7);
28802 PRE_IO
28803 READ_WORD_F(adr, src)
28804 dst = DREGu16((Opcode >> 9) & 7);
28805 res = dst - src;
28806 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28807 flag_N = flag_X = flag_C = res >> 8;
28808 flag_NotZ = res & 0xFFFF;
28809 DREGu16((Opcode >> 9) & 7) = res;
28810 POST_IO
28811RET(12)
28812}
28813
28814// SUBaD
28815OPCODE(0x9070)
28816{
28817 u32 adr, res;
28818 u32 src, dst;
28819
28820 adr = AREG((Opcode >> 0) & 7);
28821 DECODE_EXT_WORD
28822 PRE_IO
28823 READ_WORD_F(adr, src)
28824 dst = DREGu16((Opcode >> 9) & 7);
28825 res = dst - src;
28826 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28827 flag_N = flag_X = flag_C = res >> 8;
28828 flag_NotZ = res & 0xFFFF;
28829 DREGu16((Opcode >> 9) & 7) = res;
28830 POST_IO
28831RET(14)
28832}
28833
28834// SUBaD
28835OPCODE(0x9078)
28836{
28837 u32 adr, res;
28838 u32 src, dst;
28839
28840 FETCH_SWORD(adr);
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(12)
28851}
28852
28853// SUBaD
28854OPCODE(0x9079)
28855{
28856 u32 adr, res;
28857 u32 src, dst;
28858
28859 FETCH_LONG(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(16)
28870}
28871
28872// SUBaD
28873OPCODE(0x907A)
28874{
28875 u32 adr, res;
28876 u32 src, dst;
28877
be26eb23 28878 adr = GET_SWORD + GET_PC;
70357ce5 28879 PC++;
28880 PRE_IO
28881 READ_WORD_F(adr, src)
28882 dst = DREGu16((Opcode >> 9) & 7);
28883 res = dst - src;
28884 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28885 flag_N = flag_X = flag_C = res >> 8;
28886 flag_NotZ = res & 0xFFFF;
28887 DREGu16((Opcode >> 9) & 7) = res;
28888 POST_IO
28889RET(12)
28890}
28891
28892// SUBaD
28893OPCODE(0x907B)
28894{
28895 u32 adr, res;
28896 u32 src, dst;
28897
be26eb23 28898 adr = GET_PC;
70357ce5 28899 DECODE_EXT_WORD
28900 PRE_IO
28901 READ_WORD_F(adr, src)
28902 dst = DREGu16((Opcode >> 9) & 7);
28903 res = dst - src;
28904 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28905 flag_N = flag_X = flag_C = res >> 8;
28906 flag_NotZ = res & 0xFFFF;
28907 DREGu16((Opcode >> 9) & 7) = res;
28908 POST_IO
28909RET(14)
28910}
28911
28912// SUBaD
28913OPCODE(0x907C)
28914{
28915 u32 adr, res;
28916 u32 src, dst;
28917
28918 FETCH_WORD(src);
28919 dst = DREGu16((Opcode >> 9) & 7);
28920 res = dst - src;
28921 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28922 flag_N = flag_X = flag_C = res >> 8;
28923 flag_NotZ = res & 0xFFFF;
28924 DREGu16((Opcode >> 9) & 7) = res;
28925RET(8)
28926}
28927
28928// SUBaD
28929OPCODE(0x905F)
28930{
28931 u32 adr, res;
28932 u32 src, dst;
28933
28934 adr = AREG(7);
28935 AREG(7) += 2;
28936 PRE_IO
28937 READ_WORD_F(adr, 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;
28944 POST_IO
28945RET(8)
28946}
28947
28948// SUBaD
28949OPCODE(0x9067)
28950{
28951 u32 adr, res;
28952 u32 src, dst;
28953
28954 adr = AREG(7) - 2;
28955 AREG(7) = adr;
28956 PRE_IO
28957 READ_WORD_F(adr, src)
28958 dst = DREGu16((Opcode >> 9) & 7);
28959 res = dst - src;
28960 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
28961 flag_N = flag_X = flag_C = res >> 8;
28962 flag_NotZ = res & 0xFFFF;
28963 DREGu16((Opcode >> 9) & 7) = res;
28964 POST_IO
28965RET(10)
28966}
28967
28968// SUBaD
28969OPCODE(0x9080)
28970{
28971 u32 adr, res;
28972 u32 src, dst;
28973
28974 src = DREGu32((Opcode >> 0) & 7);
28975 dst = DREGu32((Opcode >> 9) & 7);
28976 res = dst - src;
28977 flag_NotZ = res;
28978 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
28979 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
28980 flag_N = res >> 24;
28981 DREGu32((Opcode >> 9) & 7) = res;
28982RET(8)
28983}
28984
28985// SUBaD
28986OPCODE(0x9088)
28987{
28988 u32 adr, res;
28989 u32 src, dst;
28990
28991 src = AREGu32((Opcode >> 0) & 7);
28992 dst = DREGu32((Opcode >> 9) & 7);
28993 res = dst - src;
28994 flag_NotZ = res;
28995 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
28996 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
28997 flag_N = res >> 24;
28998 DREGu32((Opcode >> 9) & 7) = res;
28999RET(8)
29000}
29001
29002// SUBaD
29003OPCODE(0x9090)
29004{
29005 u32 adr, res;
29006 u32 src, dst;
29007
29008 adr = AREG((Opcode >> 0) & 7);
29009 PRE_IO
29010 READ_LONG_F(adr, src)
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;
29018 POST_IO
29019RET(14)
29020}
29021
29022// SUBaD
29023OPCODE(0x9098)
29024{
29025 u32 adr, res;
29026 u32 src, dst;
29027
29028 adr = AREG((Opcode >> 0) & 7);
29029 AREG((Opcode >> 0) & 7) += 4;
29030 PRE_IO
29031 READ_LONG_F(adr, src)
29032 dst = DREGu32((Opcode >> 9) & 7);
29033 res = dst - src;
29034 flag_NotZ = res;
29035 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29036 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29037 flag_N = res >> 24;
29038 DREGu32((Opcode >> 9) & 7) = res;
29039 POST_IO
29040RET(14)
29041}
29042
29043// SUBaD
29044OPCODE(0x90A0)
29045{
29046 u32 adr, res;
29047 u32 src, dst;
29048
29049 adr = AREG((Opcode >> 0) & 7) - 4;
29050 AREG((Opcode >> 0) & 7) = adr;
29051 PRE_IO
29052 READ_LONG_F(adr, src)
29053 dst = DREGu32((Opcode >> 9) & 7);
29054 res = dst - src;
29055 flag_NotZ = res;
29056 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29057 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29058 flag_N = res >> 24;
29059 DREGu32((Opcode >> 9) & 7) = res;
29060 POST_IO
29061RET(16)
29062}
29063
29064// SUBaD
29065OPCODE(0x90A8)
29066{
29067 u32 adr, res;
29068 u32 src, dst;
29069
29070 FETCH_SWORD(adr);
29071 adr += AREG((Opcode >> 0) & 7);
29072 PRE_IO
29073 READ_LONG_F(adr, src)
29074 dst = DREGu32((Opcode >> 9) & 7);
29075 res = dst - src;
29076 flag_NotZ = res;
29077 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29078 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29079 flag_N = res >> 24;
29080 DREGu32((Opcode >> 9) & 7) = res;
29081 POST_IO
29082RET(18)
29083}
29084
29085// SUBaD
29086OPCODE(0x90B0)
29087{
29088 u32 adr, res;
29089 u32 src, dst;
29090
29091 adr = AREG((Opcode >> 0) & 7);
29092 DECODE_EXT_WORD
29093 PRE_IO
29094 READ_LONG_F(adr, src)
29095 dst = DREGu32((Opcode >> 9) & 7);
29096 res = dst - src;
29097 flag_NotZ = res;
29098 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29099 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29100 flag_N = res >> 24;
29101 DREGu32((Opcode >> 9) & 7) = res;
29102 POST_IO
29103RET(20)
29104}
29105
29106// SUBaD
29107OPCODE(0x90B8)
29108{
29109 u32 adr, res;
29110 u32 src, dst;
29111
29112 FETCH_SWORD(adr);
29113 PRE_IO
29114 READ_LONG_F(adr, src)
29115 dst = DREGu32((Opcode >> 9) & 7);
29116 res = dst - src;
29117 flag_NotZ = res;
29118 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29119 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29120 flag_N = res >> 24;
29121 DREGu32((Opcode >> 9) & 7) = res;
29122 POST_IO
29123RET(18)
29124}
29125
29126// SUBaD
29127OPCODE(0x90B9)
29128{
29129 u32 adr, res;
29130 u32 src, dst;
29131
29132 FETCH_LONG(adr);
29133 PRE_IO
29134 READ_LONG_F(adr, src)
29135 dst = DREGu32((Opcode >> 9) & 7);
29136 res = dst - src;
29137 flag_NotZ = res;
29138 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29139 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29140 flag_N = res >> 24;
29141 DREGu32((Opcode >> 9) & 7) = res;
29142 POST_IO
29143RET(22)
29144}
29145
29146// SUBaD
29147OPCODE(0x90BA)
29148{
29149 u32 adr, res;
29150 u32 src, dst;
29151
be26eb23 29152 adr = GET_SWORD + GET_PC;
70357ce5 29153 PC++;
29154 PRE_IO
29155 READ_LONG_F(adr, src)
29156 dst = DREGu32((Opcode >> 9) & 7);
29157 res = dst - src;
29158 flag_NotZ = res;
29159 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29160 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29161 flag_N = res >> 24;
29162 DREGu32((Opcode >> 9) & 7) = res;
29163 POST_IO
29164RET(18)
29165}
29166
29167// SUBaD
29168OPCODE(0x90BB)
29169{
29170 u32 adr, res;
29171 u32 src, dst;
29172
be26eb23 29173 adr = GET_PC;
70357ce5 29174 DECODE_EXT_WORD
29175 PRE_IO
29176 READ_LONG_F(adr, src)
29177 dst = DREGu32((Opcode >> 9) & 7);
29178 res = dst - src;
29179 flag_NotZ = res;
29180 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29181 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29182 flag_N = res >> 24;
29183 DREGu32((Opcode >> 9) & 7) = res;
29184 POST_IO
29185RET(20)
29186}
29187
29188// SUBaD
29189OPCODE(0x90BC)
29190{
29191 u32 adr, res;
29192 u32 src, dst;
29193
29194 FETCH_LONG(src);
29195 dst = DREGu32((Opcode >> 9) & 7);
29196 res = dst - src;
29197 flag_NotZ = res;
29198 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29199 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29200 flag_N = res >> 24;
29201 DREGu32((Opcode >> 9) & 7) = res;
29202RET(16)
29203}
29204
29205// SUBaD
29206OPCODE(0x909F)
29207{
29208 u32 adr, res;
29209 u32 src, dst;
29210
29211 adr = AREG(7);
29212 AREG(7) += 4;
29213 PRE_IO
29214 READ_LONG_F(adr, src)
29215 dst = DREGu32((Opcode >> 9) & 7);
29216 res = dst - src;
29217 flag_NotZ = res;
29218 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29219 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29220 flag_N = res >> 24;
29221 DREGu32((Opcode >> 9) & 7) = res;
29222 POST_IO
29223RET(14)
29224}
29225
29226// SUBaD
29227OPCODE(0x90A7)
29228{
29229 u32 adr, res;
29230 u32 src, dst;
29231
29232 adr = AREG(7) - 4;
29233 AREG(7) = adr;
29234 PRE_IO
29235 READ_LONG_F(adr, src)
29236 dst = DREGu32((Opcode >> 9) & 7);
29237 res = dst - src;
29238 flag_NotZ = res;
29239 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29240 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29241 flag_N = res >> 24;
29242 DREGu32((Opcode >> 9) & 7) = res;
29243 POST_IO
29244RET(16)
29245}
29246
29247// SUBDa
29248OPCODE(0x9110)
29249{
29250 u32 adr, res;
29251 u32 src, dst;
29252
29253 src = DREGu8((Opcode >> 9) & 7);
29254 adr = AREG((Opcode >> 0) & 7);
29255 PRE_IO
29256 READ_BYTE_F(adr, dst)
29257 res = dst - src;
29258 flag_N = flag_X = flag_C = res;
29259 flag_V = (src ^ dst) & (res ^ dst);
29260 flag_NotZ = res & 0xFF;
29261 WRITE_BYTE_F(adr, res)
29262 POST_IO
29263RET(12)
29264}
29265
29266// SUBDa
29267OPCODE(0x9118)
29268{
29269 u32 adr, res;
29270 u32 src, dst;
29271
29272 src = DREGu8((Opcode >> 9) & 7);
29273 adr = AREG((Opcode >> 0) & 7);
29274 AREG((Opcode >> 0) & 7) += 1;
29275 PRE_IO
29276 READ_BYTE_F(adr, dst)
29277 res = dst - src;
29278 flag_N = flag_X = flag_C = res;
29279 flag_V = (src ^ dst) & (res ^ dst);
29280 flag_NotZ = res & 0xFF;
29281 WRITE_BYTE_F(adr, res)
29282 POST_IO
29283RET(12)
29284}
29285
29286// SUBDa
29287OPCODE(0x9120)
29288{
29289 u32 adr, res;
29290 u32 src, dst;
29291
29292 src = DREGu8((Opcode >> 9) & 7);
29293 adr = AREG((Opcode >> 0) & 7) - 1;
29294 AREG((Opcode >> 0) & 7) = adr;
29295 PRE_IO
29296 READ_BYTE_F(adr, dst)
29297 res = dst - src;
29298 flag_N = flag_X = flag_C = res;
29299 flag_V = (src ^ dst) & (res ^ dst);
29300 flag_NotZ = res & 0xFF;
29301 WRITE_BYTE_F(adr, res)
29302 POST_IO
29303RET(14)
29304}
29305
29306// SUBDa
29307OPCODE(0x9128)
29308{
29309 u32 adr, res;
29310 u32 src, dst;
29311
29312 src = DREGu8((Opcode >> 9) & 7);
29313 FETCH_SWORD(adr);
29314 adr += AREG((Opcode >> 0) & 7);
29315 PRE_IO
29316 READ_BYTE_F(adr, dst)
29317 res = dst - src;
29318 flag_N = flag_X = flag_C = res;
29319 flag_V = (src ^ dst) & (res ^ dst);
29320 flag_NotZ = res & 0xFF;
29321 WRITE_BYTE_F(adr, res)
29322 POST_IO
29323RET(16)
29324}
29325
29326// SUBDa
29327OPCODE(0x9130)
29328{
29329 u32 adr, res;
29330 u32 src, dst;
29331
29332 src = DREGu8((Opcode >> 9) & 7);
29333 adr = AREG((Opcode >> 0) & 7);
29334 DECODE_EXT_WORD
29335 PRE_IO
29336 READ_BYTE_F(adr, dst)
29337 res = dst - src;
29338 flag_N = flag_X = flag_C = res;
29339 flag_V = (src ^ dst) & (res ^ dst);
29340 flag_NotZ = res & 0xFF;
29341 WRITE_BYTE_F(adr, res)
29342 POST_IO
29343RET(18)
29344}
29345
29346// SUBDa
29347OPCODE(0x9138)
29348{
29349 u32 adr, res;
29350 u32 src, dst;
29351
29352 src = DREGu8((Opcode >> 9) & 7);
29353 FETCH_SWORD(adr);
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(16)
29363}
29364
29365// SUBDa
29366OPCODE(0x9139)
29367{
29368 u32 adr, res;
29369 u32 src, dst;
29370
29371 src = DREGu8((Opcode >> 9) & 7);
29372 FETCH_LONG(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(20)
29382}
29383
29384// SUBDa
29385OPCODE(0x911F)
29386{
29387 u32 adr, res;
29388 u32 src, dst;
29389
29390 src = DREGu8((Opcode >> 9) & 7);
29391 adr = AREG(7);
29392 AREG(7) += 2;
29393 PRE_IO
29394 READ_BYTE_F(adr, dst)
29395 res = dst - src;
29396 flag_N = flag_X = flag_C = res;
29397 flag_V = (src ^ dst) & (res ^ dst);
29398 flag_NotZ = res & 0xFF;
29399 WRITE_BYTE_F(adr, res)
29400 POST_IO
29401RET(12)
29402}
29403
29404// SUBDa
29405OPCODE(0x9127)
29406{
29407 u32 adr, res;
29408 u32 src, dst;
29409
29410 src = DREGu8((Opcode >> 9) & 7);
29411 adr = AREG(7) - 2;
29412 AREG(7) = adr;
29413 PRE_IO
29414 READ_BYTE_F(adr, dst)
29415 res = dst - src;
29416 flag_N = flag_X = flag_C = res;
29417 flag_V = (src ^ dst) & (res ^ dst);
29418 flag_NotZ = res & 0xFF;
29419 WRITE_BYTE_F(adr, res)
29420 POST_IO
29421RET(14)
29422}
29423
29424// SUBDa
29425OPCODE(0x9150)
29426{
29427 u32 adr, res;
29428 u32 src, dst;
29429
29430 src = DREGu16((Opcode >> 9) & 7);
29431 adr = AREG((Opcode >> 0) & 7);
29432 PRE_IO
29433 READ_WORD_F(adr, dst)
29434 res = dst - src;
29435 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29436 flag_N = flag_X = flag_C = res >> 8;
29437 flag_NotZ = res & 0xFFFF;
29438 WRITE_WORD_F(adr, res)
29439 POST_IO
29440RET(12)
29441}
29442
29443// SUBDa
29444OPCODE(0x9158)
29445{
29446 u32 adr, res;
29447 u32 src, dst;
29448
29449 src = DREGu16((Opcode >> 9) & 7);
29450 adr = AREG((Opcode >> 0) & 7);
29451 AREG((Opcode >> 0) & 7) += 2;
29452 PRE_IO
29453 READ_WORD_F(adr, dst)
29454 res = dst - src;
29455 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29456 flag_N = flag_X = flag_C = res >> 8;
29457 flag_NotZ = res & 0xFFFF;
29458 WRITE_WORD_F(adr, res)
29459 POST_IO
29460RET(12)
29461}
29462
29463// SUBDa
29464OPCODE(0x9160)
29465{
29466 u32 adr, res;
29467 u32 src, dst;
29468
29469 src = DREGu16((Opcode >> 9) & 7);
29470 adr = AREG((Opcode >> 0) & 7) - 2;
29471 AREG((Opcode >> 0) & 7) = adr;
29472 PRE_IO
29473 READ_WORD_F(adr, dst)
29474 res = dst - src;
29475 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29476 flag_N = flag_X = flag_C = res >> 8;
29477 flag_NotZ = res & 0xFFFF;
29478 WRITE_WORD_F(adr, res)
29479 POST_IO
29480RET(14)
29481}
29482
29483// SUBDa
29484OPCODE(0x9168)
29485{
29486 u32 adr, res;
29487 u32 src, dst;
29488
29489 src = DREGu16((Opcode >> 9) & 7);
29490 FETCH_SWORD(adr);
29491 adr += AREG((Opcode >> 0) & 7);
29492 PRE_IO
29493 READ_WORD_F(adr, dst)
29494 res = dst - src;
29495 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29496 flag_N = flag_X = flag_C = res >> 8;
29497 flag_NotZ = res & 0xFFFF;
29498 WRITE_WORD_F(adr, res)
29499 POST_IO
29500RET(16)
29501}
29502
29503// SUBDa
29504OPCODE(0x9170)
29505{
29506 u32 adr, res;
29507 u32 src, dst;
29508
29509 src = DREGu16((Opcode >> 9) & 7);
29510 adr = AREG((Opcode >> 0) & 7);
29511 DECODE_EXT_WORD
29512 PRE_IO
29513 READ_WORD_F(adr, dst)
29514 res = dst - src;
29515 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29516 flag_N = flag_X = flag_C = res >> 8;
29517 flag_NotZ = res & 0xFFFF;
29518 WRITE_WORD_F(adr, res)
29519 POST_IO
29520RET(18)
29521}
29522
29523// SUBDa
29524OPCODE(0x9178)
29525{
29526 u32 adr, res;
29527 u32 src, dst;
29528
29529 src = DREGu16((Opcode >> 9) & 7);
29530 FETCH_SWORD(adr);
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(16)
29540}
29541
29542// SUBDa
29543OPCODE(0x9179)
29544{
29545 u32 adr, res;
29546 u32 src, dst;
29547
29548 src = DREGu16((Opcode >> 9) & 7);
29549 FETCH_LONG(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(20)
29559}
29560
29561// SUBDa
29562OPCODE(0x915F)
29563{
29564 u32 adr, res;
29565 u32 src, dst;
29566
29567 src = DREGu16((Opcode >> 9) & 7);
29568 adr = AREG(7);
29569 AREG(7) += 2;
29570 PRE_IO
29571 READ_WORD_F(adr, dst)
29572 res = dst - src;
29573 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29574 flag_N = flag_X = flag_C = res >> 8;
29575 flag_NotZ = res & 0xFFFF;
29576 WRITE_WORD_F(adr, res)
29577 POST_IO
29578RET(12)
29579}
29580
29581// SUBDa
29582OPCODE(0x9167)
29583{
29584 u32 adr, res;
29585 u32 src, dst;
29586
29587 src = DREGu16((Opcode >> 9) & 7);
29588 adr = AREG(7) - 2;
29589 AREG(7) = adr;
29590 PRE_IO
29591 READ_WORD_F(adr, dst)
29592 res = dst - src;
29593 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29594 flag_N = flag_X = flag_C = res >> 8;
29595 flag_NotZ = res & 0xFFFF;
29596 WRITE_WORD_F(adr, res)
29597 POST_IO
29598RET(14)
29599}
29600
29601// SUBDa
29602OPCODE(0x9190)
29603{
29604 u32 adr, res;
29605 u32 src, dst;
29606
29607 src = DREGu32((Opcode >> 9) & 7);
29608 adr = AREG((Opcode >> 0) & 7);
29609 PRE_IO
29610 READ_LONG_F(adr, dst)
29611 res = dst - src;
29612 flag_NotZ = res;
29613 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29614 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29615 flag_N = res >> 24;
29616 WRITE_LONG_F(adr, res)
29617 POST_IO
29618RET(20)
29619}
29620
29621// SUBDa
29622OPCODE(0x9198)
29623{
29624 u32 adr, res;
29625 u32 src, dst;
29626
29627 src = DREGu32((Opcode >> 9) & 7);
29628 adr = AREG((Opcode >> 0) & 7);
29629 AREG((Opcode >> 0) & 7) += 4;
29630 PRE_IO
29631 READ_LONG_F(adr, dst)
29632 res = dst - src;
29633 flag_NotZ = res;
29634 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29635 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29636 flag_N = res >> 24;
29637 WRITE_LONG_F(adr, res)
29638 POST_IO
29639RET(20)
29640}
29641
29642// SUBDa
29643OPCODE(0x91A0)
29644{
29645 u32 adr, res;
29646 u32 src, dst;
29647
29648 src = DREGu32((Opcode >> 9) & 7);
29649 adr = AREG((Opcode >> 0) & 7) - 4;
29650 AREG((Opcode >> 0) & 7) = adr;
29651 PRE_IO
29652 READ_LONG_F(adr, dst)
29653 res = dst - src;
29654 flag_NotZ = res;
29655 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29656 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29657 flag_N = res >> 24;
29658 WRITE_LONG_F(adr, res)
29659 POST_IO
29660RET(22)
29661}
29662
29663// SUBDa
29664OPCODE(0x91A8)
29665{
29666 u32 adr, res;
29667 u32 src, dst;
29668
29669 src = DREGu32((Opcode >> 9) & 7);
29670 FETCH_SWORD(adr);
29671 adr += AREG((Opcode >> 0) & 7);
29672 PRE_IO
29673 READ_LONG_F(adr, dst)
29674 res = dst - src;
29675 flag_NotZ = res;
29676 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29677 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29678 flag_N = res >> 24;
29679 WRITE_LONG_F(adr, res)
29680 POST_IO
29681RET(24)
29682}
29683
29684// SUBDa
29685OPCODE(0x91B0)
29686{
29687 u32 adr, res;
29688 u32 src, dst;
29689
29690 src = DREGu32((Opcode >> 9) & 7);
29691 adr = AREG((Opcode >> 0) & 7);
29692 DECODE_EXT_WORD
29693 PRE_IO
29694 READ_LONG_F(adr, dst)
29695 res = dst - src;
29696 flag_NotZ = res;
29697 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29698 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29699 flag_N = res >> 24;
29700 WRITE_LONG_F(adr, res)
29701 POST_IO
29702RET(26)
29703}
29704
29705// SUBDa
29706OPCODE(0x91B8)
29707{
29708 u32 adr, res;
29709 u32 src, dst;
29710
29711 src = DREGu32((Opcode >> 9) & 7);
29712 FETCH_SWORD(adr);
29713 PRE_IO
29714 READ_LONG_F(adr, dst)
29715 res = dst - src;
29716 flag_NotZ = res;
29717 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29718 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29719 flag_N = res >> 24;
29720 WRITE_LONG_F(adr, res)
29721 POST_IO
29722RET(24)
29723}
29724
29725// SUBDa
29726OPCODE(0x91B9)
29727{
29728 u32 adr, res;
29729 u32 src, dst;
29730
29731 src = DREGu32((Opcode >> 9) & 7);
29732 FETCH_LONG(adr);
29733 PRE_IO
29734 READ_LONG_F(adr, dst)
29735 res = dst - src;
29736 flag_NotZ = res;
29737 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29738 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29739 flag_N = res >> 24;
29740 WRITE_LONG_F(adr, res)
29741 POST_IO
29742RET(28)
29743}
29744
29745// SUBDa
29746OPCODE(0x919F)
29747{
29748 u32 adr, res;
29749 u32 src, dst;
29750
29751 src = DREGu32((Opcode >> 9) & 7);
29752 adr = AREG(7);
29753 AREG(7) += 4;
29754 PRE_IO
29755 READ_LONG_F(adr, dst)
29756 res = dst - src;
29757 flag_NotZ = res;
29758 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29759 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29760 flag_N = res >> 24;
29761 WRITE_LONG_F(adr, res)
29762 POST_IO
29763RET(20)
29764}
29765
29766// SUBDa
29767OPCODE(0x91A7)
29768{
29769 u32 adr, res;
29770 u32 src, dst;
29771
29772 src = DREGu32((Opcode >> 9) & 7);
29773 adr = AREG(7) - 4;
29774 AREG(7) = adr;
29775 PRE_IO
29776 READ_LONG_F(adr, dst)
29777 res = dst - src;
29778 flag_NotZ = res;
29779 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29780 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29781 flag_N = res >> 24;
29782 WRITE_LONG_F(adr, res)
29783 POST_IO
29784RET(22)
29785}
29786
29787// SUBX
29788OPCODE(0x9100)
29789{
29790 u32 adr, res;
29791 u32 src, dst;
29792
29793 src = DREGu8((Opcode >> 0) & 7);
29794 dst = DREGu8((Opcode >> 9) & 7);
29795 res = dst - src - ((flag_X >> 8) & 1);
29796 flag_N = flag_X = flag_C = res;
29797 flag_V = (src ^ dst) & (res ^ dst);
29798 flag_NotZ |= res & 0xFF;
29799 DREGu8((Opcode >> 9) & 7) = res;
29800RET(4)
29801}
29802
29803// SUBX
29804OPCODE(0x9140)
29805{
29806 u32 adr, res;
29807 u32 src, dst;
29808
29809 src = DREGu16((Opcode >> 0) & 7);
29810 dst = DREGu16((Opcode >> 9) & 7);
29811 res = dst - src - ((flag_X >> 8) & 1);
29812 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29813 flag_N = flag_X = flag_C = res >> 8;
29814 flag_NotZ |= res & 0xFFFF;
29815 DREGu16((Opcode >> 9) & 7) = res;
29816RET(4)
29817}
29818
29819// SUBX
29820OPCODE(0x9180)
29821{
29822 u32 adr, res;
29823 u32 src, dst;
29824
29825 src = DREGu32((Opcode >> 0) & 7);
29826 dst = DREGu32((Opcode >> 9) & 7);
29827 res = dst - src - ((flag_X >> 8) & 1);
29828 flag_NotZ |= res;
29829 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29830 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29831 flag_N = res >> 24;
29832 DREGu32((Opcode >> 9) & 7) = res;
29833RET(8)
29834}
29835
29836// SUBXM
29837OPCODE(0x9108)
29838{
29839 u32 adr, res;
29840 u32 src, dst;
29841
29842 adr = AREG((Opcode >> 0) & 7) - 1;
29843 AREG((Opcode >> 0) & 7) = adr;
29844 PRE_IO
29845 READ_BYTE_F(adr, src)
29846 adr = AREG((Opcode >> 9) & 7) - 1;
29847 AREG((Opcode >> 9) & 7) = adr;
29848 READ_BYTE_F(adr, dst)
29849 res = dst - src - ((flag_X >> 8) & 1);
29850 flag_N = flag_X = flag_C = res;
29851 flag_V = (src ^ dst) & (res ^ dst);
29852 flag_NotZ |= res & 0xFF;
29853 WRITE_BYTE_F(adr, res)
29854 POST_IO
29855RET(18)
29856}
29857
29858// SUBXM
29859OPCODE(0x9148)
29860{
29861 u32 adr, res;
29862 u32 src, dst;
29863
29864 adr = AREG((Opcode >> 0) & 7) - 2;
29865 AREG((Opcode >> 0) & 7) = adr;
29866 PRE_IO
29867 READ_WORD_F(adr, src)
29868 adr = AREG((Opcode >> 9) & 7) - 2;
29869 AREG((Opcode >> 9) & 7) = adr;
29870 READ_WORD_F(adr, dst)
29871 res = dst - src - ((flag_X >> 8) & 1);
29872 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29873 flag_N = flag_X = flag_C = res >> 8;
29874 flag_NotZ |= res & 0xFFFF;
29875 WRITE_WORD_F(adr, res)
29876 POST_IO
29877RET(18)
29878}
29879
29880// SUBXM
29881OPCODE(0x9188)
29882{
29883 u32 adr, res;
29884 u32 src, dst;
29885
29886 adr = AREG((Opcode >> 0) & 7) - 4;
29887 AREG((Opcode >> 0) & 7) = adr;
29888 PRE_IO
29889 READ_LONG_F(adr, src)
29890 adr = AREG((Opcode >> 9) & 7) - 4;
29891 AREG((Opcode >> 9) & 7) = adr;
29892 READ_LONG_F(adr, dst)
29893 res = dst - src - ((flag_X >> 8) & 1);
29894 flag_NotZ |= res;
29895 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29896 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29897 flag_N = res >> 24;
29898 WRITE_LONG_F(adr, res)
29899 POST_IO
29900RET(30)
29901}
29902
29903// SUBX7M
29904OPCODE(0x910F)
29905{
29906 u32 adr, res;
29907 u32 src, dst;
29908
29909 adr = AREG(7) - 2;
29910 AREG(7) = adr;
29911 PRE_IO
29912 READ_BYTE_F(adr, src)
29913 adr = AREG((Opcode >> 9) & 7) - 1;
29914 AREG((Opcode >> 9) & 7) = adr;
29915 READ_BYTE_F(adr, dst)
29916 res = dst - src - ((flag_X >> 8) & 1);
29917 flag_N = flag_X = flag_C = res;
29918 flag_V = (src ^ dst) & (res ^ dst);
29919 flag_NotZ |= res & 0xFF;
29920 WRITE_BYTE_F(adr, res)
29921 POST_IO
29922RET(18)
29923}
29924
29925// SUBX7M
29926OPCODE(0x914F)
29927{
29928 u32 adr, res;
29929 u32 src, dst;
29930
29931 adr = AREG(7) - 2;
29932 AREG(7) = adr;
29933 PRE_IO
29934 READ_WORD_F(adr, src)
29935 adr = AREG((Opcode >> 9) & 7) - 2;
29936 AREG((Opcode >> 9) & 7) = adr;
29937 READ_WORD_F(adr, dst)
29938 res = dst - src - ((flag_X >> 8) & 1);
29939 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
29940 flag_N = flag_X = flag_C = res >> 8;
29941 flag_NotZ |= res & 0xFFFF;
29942 WRITE_WORD_F(adr, res)
29943 POST_IO
29944RET(18)
29945}
29946
29947// SUBX7M
29948OPCODE(0x918F)
29949{
29950 u32 adr, res;
29951 u32 src, dst;
29952
29953 adr = AREG(7) - 4;
29954 AREG(7) = adr;
29955 PRE_IO
29956 READ_LONG_F(adr, src)
29957 adr = AREG((Opcode >> 9) & 7) - 4;
29958 AREG((Opcode >> 9) & 7) = adr;
29959 READ_LONG_F(adr, dst)
29960 res = dst - src - ((flag_X >> 8) & 1);
29961 flag_NotZ |= res;
29962 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
29963 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
29964 flag_N = res >> 24;
29965 WRITE_LONG_F(adr, res)
29966 POST_IO
29967RET(30)
29968}
29969
29970// SUBXM7
29971OPCODE(0x9F08)
29972{
29973 u32 adr, res;
29974 u32 src, dst;
29975
29976 adr = AREG((Opcode >> 0) & 7) - 1;
29977 AREG((Opcode >> 0) & 7) = adr;
29978 PRE_IO
29979 READ_BYTE_F(adr, src)
29980 adr = AREG(7) - 2;
29981 AREG(7) = adr;
29982 READ_BYTE_F(adr, dst)
29983 res = dst - src - ((flag_X >> 8) & 1);
29984 flag_N = flag_X = flag_C = res;
29985 flag_V = (src ^ dst) & (res ^ dst);
29986 flag_NotZ |= res & 0xFF;
29987 WRITE_BYTE_F(adr, res)
29988 POST_IO
29989RET(18)
29990}
29991
29992// SUBXM7
29993OPCODE(0x9F48)
29994{
29995 u32 adr, res;
29996 u32 src, dst;
29997
29998 adr = AREG((Opcode >> 0) & 7) - 2;
29999 AREG((Opcode >> 0) & 7) = adr;
30000 PRE_IO
30001 READ_WORD_F(adr, src)
30002 adr = AREG(7) - 2;
30003 AREG(7) = adr;
30004 READ_WORD_F(adr, dst)
30005 res = dst - src - ((flag_X >> 8) & 1);
30006 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30007 flag_N = flag_X = flag_C = res >> 8;
30008 flag_NotZ |= res & 0xFFFF;
30009 WRITE_WORD_F(adr, res)
30010 POST_IO
30011RET(18)
30012}
30013
30014// SUBXM7
30015OPCODE(0x9F88)
30016{
30017 u32 adr, res;
30018 u32 src, dst;
30019
30020 adr = AREG((Opcode >> 0) & 7) - 4;
30021 AREG((Opcode >> 0) & 7) = adr;
30022 PRE_IO
30023 READ_LONG_F(adr, src)
30024 adr = AREG(7) - 4;
30025 AREG(7) = adr;
30026 READ_LONG_F(adr, dst)
30027 res = dst - src - ((flag_X >> 8) & 1);
30028 flag_NotZ |= res;
30029 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30030 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30031 flag_N = res >> 24;
30032 WRITE_LONG_F(adr, res)
30033 POST_IO
30034RET(30)
30035}
30036
30037// SUBX7M7
30038OPCODE(0x9F0F)
30039{
30040 u32 adr, res;
30041 u32 src, dst;
30042
30043 adr = AREG(7) - 2;
30044 AREG(7) = adr;
30045 PRE_IO
30046 READ_BYTE_F(adr, src)
30047 adr = AREG(7) - 2;
30048 AREG(7) = adr;
30049 READ_BYTE_F(adr, dst)
30050 res = dst - src - ((flag_X >> 8) & 1);
30051 flag_N = flag_X = flag_C = res;
30052 flag_V = (src ^ dst) & (res ^ dst);
30053 flag_NotZ |= res & 0xFF;
30054 WRITE_BYTE_F(adr, res)
30055 POST_IO
30056RET(18)
30057}
30058
30059// SUBX7M7
30060OPCODE(0x9F4F)
30061{
30062 u32 adr, res;
30063 u32 src, dst;
30064
30065 adr = AREG(7) - 2;
30066 AREG(7) = adr;
30067 PRE_IO
30068 READ_WORD_F(adr, src)
30069 adr = AREG(7) - 2;
30070 AREG(7) = adr;
30071 READ_WORD_F(adr, dst)
30072 res = dst - src - ((flag_X >> 8) & 1);
30073 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30074 flag_N = flag_X = flag_C = res >> 8;
30075 flag_NotZ |= res & 0xFFFF;
30076 WRITE_WORD_F(adr, res)
30077 POST_IO
30078RET(18)
30079}
30080
30081// SUBX7M7
30082OPCODE(0x9F8F)
30083{
30084 u32 adr, res;
30085 u32 src, dst;
30086
30087 adr = AREG(7) - 4;
30088 AREG(7) = adr;
30089 PRE_IO
30090 READ_LONG_F(adr, src)
30091 adr = AREG(7) - 4;
30092 AREG(7) = adr;
30093 READ_LONG_F(adr, dst)
30094 res = dst - src - ((flag_X >> 8) & 1);
30095 flag_NotZ |= res;
30096 flag_X = flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
30097 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
30098 flag_N = res >> 24;
30099 WRITE_LONG_F(adr, res)
30100 POST_IO
30101RET(30)
30102}
30103
30104// SUBA
30105OPCODE(0x90C0)
30106{
30107 u32 adr, res;
30108 u32 src, dst;
30109
30110 src = (s32)DREGs16((Opcode >> 0) & 7);
30111 dst = AREGu32((Opcode >> 9) & 7);
30112 res = dst - src;
30113 AREG((Opcode >> 9) & 7) = res;
30114RET(8)
30115}
30116
30117// SUBA
30118OPCODE(0x90C8)
30119{
30120 u32 adr, res;
30121 u32 src, dst;
30122
30123 src = (s32)AREGs16((Opcode >> 0) & 7);
30124 dst = AREGu32((Opcode >> 9) & 7);
30125 res = dst - src;
30126 AREG((Opcode >> 9) & 7) = res;
30127RET(8)
30128}
30129
30130// SUBA
30131OPCODE(0x90D0)
30132{
30133 u32 adr, res;
30134 u32 src, dst;
30135
30136 adr = AREG((Opcode >> 0) & 7);
30137 PRE_IO
30138 READSX_WORD_F(adr, src)
30139 dst = AREGu32((Opcode >> 9) & 7);
30140 res = dst - src;
30141 AREG((Opcode >> 9) & 7) = res;
30142 POST_IO
9d917eea 30143#ifdef USE_CYCLONE_TIMING
30144RET(12)
30145#else
70357ce5 30146RET(10)
9d917eea 30147#endif
70357ce5 30148}
30149
30150// SUBA
30151OPCODE(0x90D8)
30152{
30153 u32 adr, res;
30154 u32 src, dst;
30155
30156 adr = AREG((Opcode >> 0) & 7);
30157 AREG((Opcode >> 0) & 7) += 2;
30158 PRE_IO
30159 READSX_WORD_F(adr, src)
30160 dst = AREGu32((Opcode >> 9) & 7);
30161 res = dst - src;
30162 AREG((Opcode >> 9) & 7) = res;
30163 POST_IO
9d917eea 30164#ifdef USE_CYCLONE_TIMING
30165RET(12)
30166#else
70357ce5 30167RET(10)
9d917eea 30168#endif
70357ce5 30169}
30170
30171// SUBA
30172OPCODE(0x90E0)
30173{
30174 u32 adr, res;
30175 u32 src, dst;
30176
30177 adr = AREG((Opcode >> 0) & 7) - 2;
30178 AREG((Opcode >> 0) & 7) = adr;
30179 PRE_IO
30180 READSX_WORD_F(adr, src)
30181 dst = AREGu32((Opcode >> 9) & 7);
30182 res = dst - src;
30183 AREG((Opcode >> 9) & 7) = res;
30184 POST_IO
9d917eea 30185#ifdef USE_CYCLONE_TIMING
30186RET(14)
30187#else
70357ce5 30188RET(12)
9d917eea 30189#endif
70357ce5 30190}
30191
30192// SUBA
30193OPCODE(0x90E8)
30194{
30195 u32 adr, res;
30196 u32 src, dst;
30197
30198 FETCH_SWORD(adr);
30199 adr += AREG((Opcode >> 0) & 7);
30200 PRE_IO
30201 READSX_WORD_F(adr, src)
30202 dst = AREGu32((Opcode >> 9) & 7);
30203 res = dst - src;
30204 AREG((Opcode >> 9) & 7) = res;
30205 POST_IO
9d917eea 30206#ifdef USE_CYCLONE_TIMING
30207RET(16)
30208#else
70357ce5 30209RET(14)
9d917eea 30210#endif
70357ce5 30211}
30212
30213// SUBA
30214OPCODE(0x90F0)
30215{
30216 u32 adr, res;
30217 u32 src, dst;
30218
30219 adr = AREG((Opcode >> 0) & 7);
30220 DECODE_EXT_WORD
30221 PRE_IO
30222 READSX_WORD_F(adr, src)
30223 dst = AREGu32((Opcode >> 9) & 7);
30224 res = dst - src;
30225 AREG((Opcode >> 9) & 7) = res;
30226 POST_IO
9d917eea 30227#ifdef USE_CYCLONE_TIMING
30228RET(18)
30229#else
70357ce5 30230RET(16)
9d917eea 30231#endif
70357ce5 30232}
30233
30234// SUBA
30235OPCODE(0x90F8)
30236{
30237 u32 adr, res;
30238 u32 src, dst;
30239
30240 FETCH_SWORD(adr);
30241 PRE_IO
30242 READSX_WORD_F(adr, src)
30243 dst = AREGu32((Opcode >> 9) & 7);
30244 res = dst - src;
30245 AREG((Opcode >> 9) & 7) = res;
30246 POST_IO
9d917eea 30247#ifdef USE_CYCLONE_TIMING
30248RET(16)
30249#else
70357ce5 30250RET(14)
9d917eea 30251#endif
70357ce5 30252}
30253
30254// SUBA
30255OPCODE(0x90F9)
30256{
30257 u32 adr, res;
30258 u32 src, dst;
30259
30260 FETCH_LONG(adr);
30261 PRE_IO
30262 READSX_WORD_F(adr, src)
30263 dst = AREGu32((Opcode >> 9) & 7);
30264 res = dst - src;
30265 AREG((Opcode >> 9) & 7) = res;
30266 POST_IO
9d917eea 30267#ifdef USE_CYCLONE_TIMING
30268RET(20)
30269#else
70357ce5 30270RET(18)
9d917eea 30271#endif
70357ce5 30272}
30273
30274// SUBA
30275OPCODE(0x90FA)
30276{
30277 u32 adr, res;
30278 u32 src, dst;
30279
be26eb23 30280 adr = GET_SWORD + GET_PC;
70357ce5 30281 PC++;
30282 PRE_IO
30283 READSX_WORD_F(adr, src)
30284 dst = AREGu32((Opcode >> 9) & 7);
30285 res = dst - src;
30286 AREG((Opcode >> 9) & 7) = res;
30287 POST_IO
9d917eea 30288#ifdef USE_CYCLONE_TIMING
30289RET(16)
30290#else
70357ce5 30291RET(14)
9d917eea 30292#endif
70357ce5 30293}
30294
30295// SUBA
30296OPCODE(0x90FB)
30297{
30298 u32 adr, res;
30299 u32 src, dst;
30300
be26eb23 30301 adr = GET_PC;
70357ce5 30302 DECODE_EXT_WORD
30303 PRE_IO
30304 READSX_WORD_F(adr, src)
30305 dst = AREGu32((Opcode >> 9) & 7);
30306 res = dst - src;
30307 AREG((Opcode >> 9) & 7) = res;
30308 POST_IO
9d917eea 30309#ifdef USE_CYCLONE_TIMING
30310RET(18)
30311#else
70357ce5 30312RET(16)
9d917eea 30313#endif
70357ce5 30314}
30315
30316// SUBA
30317OPCODE(0x90FC)
30318{
30319 u32 adr, res;
30320 u32 src, dst;
30321
30322 FETCH_SWORD(src);
30323 dst = AREGu32((Opcode >> 9) & 7);
30324 res = dst - src;
30325 AREG((Opcode >> 9) & 7) = res;
30326RET(12)
30327}
30328
30329// SUBA
30330OPCODE(0x90DF)
30331{
30332 u32 adr, res;
30333 u32 src, dst;
30334
30335 adr = AREG(7);
30336 AREG(7) += 2;
30337 PRE_IO
30338 READSX_WORD_F(adr, src)
30339 dst = AREGu32((Opcode >> 9) & 7);
30340 res = dst - src;
30341 AREG((Opcode >> 9) & 7) = res;
30342 POST_IO
9d917eea 30343#ifdef USE_CYCLONE_TIMING
30344RET(12)
30345#else
70357ce5 30346RET(10)
9d917eea 30347#endif
70357ce5 30348}
30349
30350// SUBA
30351OPCODE(0x90E7)
30352{
30353 u32 adr, res;
30354 u32 src, dst;
30355
30356 adr = AREG(7) - 2;
30357 AREG(7) = adr;
30358 PRE_IO
30359 READSX_WORD_F(adr, src)
30360 dst = AREGu32((Opcode >> 9) & 7);
30361 res = dst - src;
30362 AREG((Opcode >> 9) & 7) = res;
30363 POST_IO
9d917eea 30364#ifdef USE_CYCLONE_TIMING
30365RET(14)
30366#else
70357ce5 30367RET(12)
9d917eea 30368#endif
70357ce5 30369}
30370
30371// SUBA
30372OPCODE(0x91C0)
30373{
30374 u32 adr, res;
30375 u32 src, dst;
30376
30377 src = (s32)DREGs32((Opcode >> 0) & 7);
30378 dst = AREGu32((Opcode >> 9) & 7);
30379 res = dst - src;
30380 AREG((Opcode >> 9) & 7) = res;
30381#ifdef USE_CYCLONE_TIMING
30382RET(8)
30383#else
30384RET(6)
30385#endif
30386}
30387
30388// SUBA
30389OPCODE(0x91C8)
30390{
30391 u32 adr, res;
30392 u32 src, dst;
30393
30394 src = (s32)AREGs32((Opcode >> 0) & 7);
30395 dst = AREGu32((Opcode >> 9) & 7);
30396 res = dst - src;
30397 AREG((Opcode >> 9) & 7) = res;
30398#ifdef USE_CYCLONE_TIMING
30399RET(8)
30400#else
30401RET(6)
30402#endif
30403}
30404
30405// SUBA
30406OPCODE(0x91D0)
30407{
30408 u32 adr, res;
30409 u32 src, dst;
30410
30411 adr = AREG((Opcode >> 0) & 7);
30412 PRE_IO
30413 READSX_LONG_F(adr, src)
30414 dst = AREGu32((Opcode >> 9) & 7);
30415 res = dst - src;
30416 AREG((Opcode >> 9) & 7) = res;
30417 POST_IO
30418RET(14)
30419}
30420
30421// SUBA
30422OPCODE(0x91D8)
30423{
30424 u32 adr, res;
30425 u32 src, dst;
30426
30427 adr = AREG((Opcode >> 0) & 7);
30428 AREG((Opcode >> 0) & 7) += 4;
30429 PRE_IO
30430 READSX_LONG_F(adr, src)
30431 dst = AREGu32((Opcode >> 9) & 7);
30432 res = dst - src;
30433 AREG((Opcode >> 9) & 7) = res;
30434 POST_IO
30435RET(14)
30436}
30437
30438// SUBA
30439OPCODE(0x91E0)
30440{
30441 u32 adr, res;
30442 u32 src, dst;
30443
30444 adr = AREG((Opcode >> 0) & 7) - 4;
30445 AREG((Opcode >> 0) & 7) = adr;
30446 PRE_IO
30447 READSX_LONG_F(adr, src)
30448 dst = AREGu32((Opcode >> 9) & 7);
30449 res = dst - src;
30450 AREG((Opcode >> 9) & 7) = res;
30451 POST_IO
30452RET(16)
30453}
30454
30455// SUBA
30456OPCODE(0x91E8)
30457{
30458 u32 adr, res;
30459 u32 src, dst;
30460
30461 FETCH_SWORD(adr);
30462 adr += AREG((Opcode >> 0) & 7);
30463 PRE_IO
30464 READSX_LONG_F(adr, src)
30465 dst = AREGu32((Opcode >> 9) & 7);
30466 res = dst - src;
30467 AREG((Opcode >> 9) & 7) = res;
30468 POST_IO
30469RET(18)
30470}
30471
30472// SUBA
30473OPCODE(0x91F0)
30474{
30475 u32 adr, res;
30476 u32 src, dst;
30477
30478 adr = AREG((Opcode >> 0) & 7);
30479 DECODE_EXT_WORD
30480 PRE_IO
30481 READSX_LONG_F(adr, src)
30482 dst = AREGu32((Opcode >> 9) & 7);
30483 res = dst - src;
30484 AREG((Opcode >> 9) & 7) = res;
30485 POST_IO
30486RET(20)
30487}
30488
30489// SUBA
30490OPCODE(0x91F8)
30491{
30492 u32 adr, res;
30493 u32 src, dst;
30494
30495 FETCH_SWORD(adr);
30496 PRE_IO
30497 READSX_LONG_F(adr, src)
30498 dst = AREGu32((Opcode >> 9) & 7);
30499 res = dst - src;
30500 AREG((Opcode >> 9) & 7) = res;
30501 POST_IO
30502RET(18)
30503}
30504
30505// SUBA
30506OPCODE(0x91F9)
30507{
30508 u32 adr, res;
30509 u32 src, dst;
30510
30511 FETCH_LONG(adr);
30512 PRE_IO
30513 READSX_LONG_F(adr, src)
30514 dst = AREGu32((Opcode >> 9) & 7);
30515 res = dst - src;
30516 AREG((Opcode >> 9) & 7) = res;
30517 POST_IO
30518RET(22)
30519}
30520
30521// SUBA
30522OPCODE(0x91FA)
30523{
30524 u32 adr, res;
30525 u32 src, dst;
30526
be26eb23 30527 adr = GET_SWORD + GET_PC;
70357ce5 30528 PC++;
30529 PRE_IO
30530 READSX_LONG_F(adr, src)
30531 dst = AREGu32((Opcode >> 9) & 7);
30532 res = dst - src;
30533 AREG((Opcode >> 9) & 7) = res;
30534 POST_IO
30535RET(18)
30536}
30537
30538// SUBA
30539OPCODE(0x91FB)
30540{
30541 u32 adr, res;
30542 u32 src, dst;
30543
be26eb23 30544 adr = GET_PC;
70357ce5 30545 DECODE_EXT_WORD
30546 PRE_IO
30547 READSX_LONG_F(adr, src)
30548 dst = AREGu32((Opcode >> 9) & 7);
30549 res = dst - src;
30550 AREG((Opcode >> 9) & 7) = res;
30551 POST_IO
30552RET(20)
30553}
30554
30555// SUBA
30556OPCODE(0x91FC)
30557{
30558 u32 adr, res;
30559 u32 src, dst;
30560
30561 FETCH_LONG(src);
30562 dst = AREGu32((Opcode >> 9) & 7);
30563 res = dst - src;
30564 AREG((Opcode >> 9) & 7) = res;
30565#ifdef USE_CYCLONE_TIMING
30566RET(16)
30567#else
30568RET(14)
30569#endif
30570}
30571
30572// SUBA
30573OPCODE(0x91DF)
30574{
30575 u32 adr, res;
30576 u32 src, dst;
30577
30578 adr = AREG(7);
30579 AREG(7) += 4;
30580 PRE_IO
30581 READSX_LONG_F(adr, src)
30582 dst = AREGu32((Opcode >> 9) & 7);
30583 res = dst - src;
30584 AREG((Opcode >> 9) & 7) = res;
30585 POST_IO
30586RET(14)
30587}
30588
30589// SUBA
30590OPCODE(0x91E7)
30591{
30592 u32 adr, res;
30593 u32 src, dst;
30594
30595 adr = AREG(7) - 4;
30596 AREG(7) = adr;
30597 PRE_IO
30598 READSX_LONG_F(adr, src)
30599 dst = AREGu32((Opcode >> 9) & 7);
30600 res = dst - src;
30601 AREG((Opcode >> 9) & 7) = res;
30602 POST_IO
30603RET(16)
30604}
30605
30606// CMP
30607OPCODE(0xB000)
30608{
30609 u32 adr, res;
30610 u32 src, dst;
30611
30612 src = DREGu8((Opcode >> 0) & 7);
30613 dst = DREGu8((Opcode >> 9) & 7);
30614 res = dst - src;
30615 flag_N = flag_C = res;
30616 flag_V = (src ^ dst) & (res ^ dst);
30617 flag_NotZ = res & 0xFF;
30618RET(4)
30619}
30620
30621// CMP
03e4f2a3 30622#if 0
70357ce5 30623OPCODE(0xB008)
30624{
30625 u32 adr, res;
30626 u32 src, dst;
30627
30628 // can't read byte from Ax registers !
30629 m68kcontext.execinfo |= M68K_FAULTED;
30630 m68kcontext.io_cycle_counter = 0;
30631/*
30632 goto famec_Exec_End;
30633 dst = DREGu8((Opcode >> 9) & 7);
30634 res = dst - src;
30635 flag_N = flag_C = res;
30636 flag_V = (src ^ dst) & (res ^ dst);
30637 flag_NotZ = res & 0xFF;
30638*/
30639RET(4)
30640}
03e4f2a3 30641#endif
70357ce5 30642
30643// CMP
30644OPCODE(0xB010)
30645{
30646 u32 adr, res;
30647 u32 src, dst;
30648
30649 adr = AREG((Opcode >> 0) & 7);
30650 PRE_IO
30651 READ_BYTE_F(adr, src)
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 POST_IO
30658RET(8)
30659}
30660
30661// CMP
30662OPCODE(0xB018)
30663{
30664 u32 adr, res;
30665 u32 src, dst;
30666
30667 adr = AREG((Opcode >> 0) & 7);
30668 AREG((Opcode >> 0) & 7) += 1;
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(0xB020)
30682{
30683 u32 adr, res;
30684 u32 src, dst;
30685
30686 adr = AREG((Opcode >> 0) & 7) - 1;
30687 AREG((Opcode >> 0) & 7) = adr;
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(10)
30697}
30698
30699// CMP
30700OPCODE(0xB028)
30701{
30702 u32 adr, res;
30703 u32 src, dst;
30704
30705 FETCH_SWORD(adr);
30706 adr += AREG((Opcode >> 0) & 7);
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(12)
30716}
30717
30718// CMP
30719OPCODE(0xB030)
30720{
30721 u32 adr, res;
30722 u32 src, dst;
30723
30724 adr = AREG((Opcode >> 0) & 7);
30725 DECODE_EXT_WORD
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(14)
30735}
30736
30737// CMP
30738OPCODE(0xB038)
30739{
30740 u32 adr, res;
30741 u32 src, dst;
30742
30743 FETCH_SWORD(adr);
30744 PRE_IO
30745 READ_BYTE_F(adr, src)
30746 dst = DREGu8((Opcode >> 9) & 7);
30747 res = dst - src;
30748 flag_N = flag_C = res;
30749 flag_V = (src ^ dst) & (res ^ dst);
30750 flag_NotZ = res & 0xFF;
30751 POST_IO
30752RET(12)
30753}
30754
30755// CMP
30756OPCODE(0xB039)
30757{
30758 u32 adr, res;
30759 u32 src, dst;
30760
30761 FETCH_LONG(adr);
30762 PRE_IO
30763 READ_BYTE_F(adr, src)
30764 dst = DREGu8((Opcode >> 9) & 7);
30765 res = dst - src;
30766 flag_N = flag_C = res;
30767 flag_V = (src ^ dst) & (res ^ dst);
30768 flag_NotZ = res & 0xFF;
30769 POST_IO
30770RET(16)
30771}
30772
30773// CMP
30774OPCODE(0xB03A)
30775{
30776 u32 adr, res;
30777 u32 src, dst;
30778
be26eb23 30779 adr = GET_SWORD + GET_PC;
70357ce5 30780 PC++;
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(12)
30790}
30791
30792// CMP
30793OPCODE(0xB03B)
30794{
30795 u32 adr, res;
30796 u32 src, dst;
30797
be26eb23 30798 adr = GET_PC;
70357ce5 30799 DECODE_EXT_WORD
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(14)
30809}
30810
30811// CMP
30812OPCODE(0xB03C)
30813{
30814 u32 adr, res;
30815 u32 src, dst;
30816
30817 FETCH_BYTE(src);
30818 dst = DREGu8((Opcode >> 9) & 7);
30819 res = dst - src;
30820 flag_N = flag_C = res;
30821 flag_V = (src ^ dst) & (res ^ dst);
30822 flag_NotZ = res & 0xFF;
30823RET(8)
30824}
30825
30826// CMP
30827OPCODE(0xB01F)
30828{
30829 u32 adr, res;
30830 u32 src, dst;
30831
30832 adr = AREG(7);
30833 AREG(7) += 2;
30834 PRE_IO
30835 READ_BYTE_F(adr, src)
30836 dst = DREGu8((Opcode >> 9) & 7);
30837 res = dst - src;
30838 flag_N = flag_C = res;
30839 flag_V = (src ^ dst) & (res ^ dst);
30840 flag_NotZ = res & 0xFF;
30841 POST_IO
30842RET(8)
30843}
30844
30845// CMP
30846OPCODE(0xB027)
30847{
30848 u32 adr, res;
30849 u32 src, dst;
30850
30851 adr = AREG(7) - 2;
30852 AREG(7) = adr;
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(10)
30862}
30863
30864// CMP
30865OPCODE(0xB040)
30866{
30867 u32 adr, res;
30868 u32 src, dst;
30869
30870 src = DREGu16((Opcode >> 0) & 7);
30871 dst = DREGu16((Opcode >> 9) & 7);
30872 res = dst - src;
30873 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30874 flag_N = flag_C = res >> 8;
30875 flag_NotZ = res & 0xFFFF;
30876RET(4)
30877}
30878
30879// CMP
30880OPCODE(0xB048)
30881{
30882 u32 adr, res;
30883 u32 src, dst;
30884
30885 src = AREGu16((Opcode >> 0) & 7);
30886 dst = DREGu16((Opcode >> 9) & 7);
30887 res = dst - src;
30888 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30889 flag_N = flag_C = res >> 8;
30890 flag_NotZ = res & 0xFFFF;
30891RET(4)
30892}
30893
30894// CMP
30895OPCODE(0xB050)
30896{
30897 u32 adr, res;
30898 u32 src, dst;
30899
30900 adr = AREG((Opcode >> 0) & 7);
30901 PRE_IO
30902 READ_WORD_F(adr, src)
30903 dst = DREGu16((Opcode >> 9) & 7);
30904 res = dst - src;
30905 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
30906 flag_N = flag_C = res >> 8;
30907 flag_NotZ = res & 0xFFFF;
30908 POST_IO
30909RET(8)
30910}
30911
30912// CMP
30913OPCODE(0xB058)
30914{
30915 u32 adr, res;
30916 u32 src, dst;
30917
30918 adr = AREG((Opcode >> 0) & 7);
30919 AREG((Opcode >> 0) & 7) += 2;
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(0xB060)
30933{
30934 u32 adr, res;
30935 u32 src, dst;
30936
30937 adr = AREG((Opcode >> 0) & 7) - 2;
30938 AREG((Opcode >> 0) & 7) = adr;
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(10)
30948}
30949
30950// CMP
30951OPCODE(0xB068)
30952{
30953 u32 adr, res;
30954 u32 src, dst;
30955
30956 FETCH_SWORD(adr);
30957 adr += AREG((Opcode >> 0) & 7);
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(12)
30967}
30968
30969// CMP
30970OPCODE(0xB070)
30971{
30972 u32 adr, res;
30973 u32 src, dst;
30974
30975 adr = AREG((Opcode >> 0) & 7);
30976 DECODE_EXT_WORD
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(14)
30986}
30987
30988// CMP
30989OPCODE(0xB078)
30990{
30991 u32 adr, res;
30992 u32 src, dst;
30993
30994 FETCH_SWORD(adr);
30995 PRE_IO
30996 READ_WORD_F(adr, src)
30997 dst = DREGu16((Opcode >> 9) & 7);
30998 res = dst - src;
30999 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31000 flag_N = flag_C = res >> 8;
31001 flag_NotZ = res & 0xFFFF;
31002 POST_IO
31003RET(12)
31004}
31005
31006// CMP
31007OPCODE(0xB079)
31008{
31009 u32 adr, res;
31010 u32 src, dst;
31011
31012 FETCH_LONG(adr);
31013 PRE_IO
31014 READ_WORD_F(adr, src)
31015 dst = DREGu16((Opcode >> 9) & 7);
31016 res = dst - src;
31017 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31018 flag_N = flag_C = res >> 8;
31019 flag_NotZ = res & 0xFFFF;
31020 POST_IO
31021RET(16)
31022}
31023
31024// CMP
31025OPCODE(0xB07A)
31026{
31027 u32 adr, res;
31028 u32 src, dst;
31029
be26eb23 31030 adr = GET_SWORD + GET_PC;
70357ce5 31031 PC++;
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(12)
31041}
31042
31043// CMP
31044OPCODE(0xB07B)
31045{
31046 u32 adr, res;
31047 u32 src, dst;
31048
be26eb23 31049 adr = GET_PC;
70357ce5 31050 DECODE_EXT_WORD
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(14)
31060}
31061
31062// CMP
31063OPCODE(0xB07C)
31064{
31065 u32 adr, res;
31066 u32 src, dst;
31067
31068 FETCH_WORD(src);
31069 dst = DREGu16((Opcode >> 9) & 7);
31070 res = dst - src;
31071 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31072 flag_N = flag_C = res >> 8;
31073 flag_NotZ = res & 0xFFFF;
31074RET(8)
31075}
31076
31077// CMP
31078OPCODE(0xB05F)
31079{
31080 u32 adr, res;
31081 u32 src, dst;
31082
31083 adr = AREG(7);
31084 AREG(7) += 2;
31085 PRE_IO
31086 READ_WORD_F(adr, src)
31087 dst = DREGu16((Opcode >> 9) & 7);
31088 res = dst - src;
31089 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31090 flag_N = flag_C = res >> 8;
31091 flag_NotZ = res & 0xFFFF;
31092 POST_IO
31093RET(8)
31094}
31095
31096// CMP
31097OPCODE(0xB067)
31098{
31099 u32 adr, res;
31100 u32 src, dst;
31101
31102 adr = AREG(7) - 2;
31103 AREG(7) = adr;
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(10)
31113}
31114
31115// CMP
31116OPCODE(0xB080)
31117{
31118 u32 adr, res;
31119 u32 src, dst;
31120
31121 src = DREGu32((Opcode >> 0) & 7);
31122 dst = DREGu32((Opcode >> 9) & 7);
31123 res = dst - src;
31124 flag_NotZ = res;
31125 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31126 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31127 flag_N = res >> 24;
31128RET(6)
31129}
31130
31131// CMP
31132OPCODE(0xB088)
31133{
31134 u32 adr, res;
31135 u32 src, dst;
31136
31137 src = AREGu32((Opcode >> 0) & 7);
31138 dst = DREGu32((Opcode >> 9) & 7);
31139 res = dst - src;
31140 flag_NotZ = res;
31141 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31142 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31143 flag_N = res >> 24;
31144RET(6)
31145}
31146
31147// CMP
31148OPCODE(0xB090)
31149{
31150 u32 adr, res;
31151 u32 src, dst;
31152
31153 adr = AREG((Opcode >> 0) & 7);
31154 PRE_IO
31155 READ_LONG_F(adr, src)
31156 dst = DREGu32((Opcode >> 9) & 7);
31157 res = dst - src;
31158 flag_NotZ = res;
31159 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31160 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31161 flag_N = res >> 24;
31162 POST_IO
31163RET(14)
31164}
31165
31166// CMP
31167OPCODE(0xB098)
31168{
31169 u32 adr, res;
31170 u32 src, dst;
31171
31172 adr = AREG((Opcode >> 0) & 7);
31173 AREG((Opcode >> 0) & 7) += 4;
31174 PRE_IO
31175 READ_LONG_F(adr, src)
31176 dst = DREGu32((Opcode >> 9) & 7);
31177 res = dst - src;
31178 flag_NotZ = res;
31179 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31180 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31181 flag_N = res >> 24;
31182 POST_IO
31183RET(14)
31184}
31185
31186// CMP
31187OPCODE(0xB0A0)
31188{
31189 u32 adr, res;
31190 u32 src, dst;
31191
31192 adr = AREG((Opcode >> 0) & 7) - 4;
31193 AREG((Opcode >> 0) & 7) = adr;
31194 PRE_IO
31195 READ_LONG_F(adr, src)
31196 dst = DREGu32((Opcode >> 9) & 7);
31197 res = dst - src;
31198 flag_NotZ = res;
31199 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31200 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31201 flag_N = res >> 24;
31202 POST_IO
31203RET(16)
31204}
31205
31206// CMP
31207OPCODE(0xB0A8)
31208{
31209 u32 adr, res;
31210 u32 src, dst;
31211
31212 FETCH_SWORD(adr);
31213 adr += AREG((Opcode >> 0) & 7);
31214 PRE_IO
31215 READ_LONG_F(adr, src)
31216 dst = DREGu32((Opcode >> 9) & 7);
31217 res = dst - src;
31218 flag_NotZ = res;
31219 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31220 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31221 flag_N = res >> 24;
31222 POST_IO
31223RET(18)
31224}
31225
31226// CMP
31227OPCODE(0xB0B0)
31228{
31229 u32 adr, res;
31230 u32 src, dst;
31231
31232 adr = AREG((Opcode >> 0) & 7);
31233 DECODE_EXT_WORD
31234 PRE_IO
31235 READ_LONG_F(adr, src)
31236 dst = DREGu32((Opcode >> 9) & 7);
31237 res = dst - src;
31238 flag_NotZ = res;
31239 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31240 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31241 flag_N = res >> 24;
31242 POST_IO
31243RET(20)
31244}
31245
31246// CMP
31247OPCODE(0xB0B8)
31248{
31249 u32 adr, res;
31250 u32 src, dst;
31251
31252 FETCH_SWORD(adr);
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(18)
31263}
31264
31265// CMP
31266OPCODE(0xB0B9)
31267{
31268 u32 adr, res;
31269 u32 src, dst;
31270
31271 FETCH_LONG(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(22)
31282}
31283
31284// CMP
31285OPCODE(0xB0BA)
31286{
31287 u32 adr, res;
31288 u32 src, dst;
31289
be26eb23 31290 adr = GET_SWORD + GET_PC;
70357ce5 31291 PC++;
31292 PRE_IO
31293 READ_LONG_F(adr, src)
31294 dst = DREGu32((Opcode >> 9) & 7);
31295 res = dst - src;
31296 flag_NotZ = res;
31297 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31298 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31299 flag_N = res >> 24;
31300 POST_IO
31301RET(18)
31302}
31303
31304// CMP
31305OPCODE(0xB0BB)
31306{
31307 u32 adr, res;
31308 u32 src, dst;
31309
be26eb23 31310 adr = GET_PC;
70357ce5 31311 DECODE_EXT_WORD
31312 PRE_IO
31313 READ_LONG_F(adr, src)
31314 dst = DREGu32((Opcode >> 9) & 7);
31315 res = dst - src;
31316 flag_NotZ = res;
31317 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31318 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31319 flag_N = res >> 24;
31320 POST_IO
31321RET(20)
31322}
31323
31324// CMP
31325OPCODE(0xB0BC)
31326{
31327 u32 adr, res;
31328 u32 src, dst;
31329
31330 FETCH_LONG(src);
31331 dst = DREGu32((Opcode >> 9) & 7);
31332 res = dst - src;
31333 flag_NotZ = res;
31334 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31335 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31336 flag_N = res >> 24;
31337RET(14)
31338}
31339
31340// CMP
31341OPCODE(0xB09F)
31342{
31343 u32 adr, res;
31344 u32 src, dst;
31345
31346 adr = AREG(7);
31347 AREG(7) += 4;
31348 PRE_IO
31349 READ_LONG_F(adr, 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;
31356 POST_IO
31357RET(14)
31358}
31359
31360// CMP
31361OPCODE(0xB0A7)
31362{
31363 u32 adr, res;
31364 u32 src, dst;
31365
31366 adr = AREG(7) - 4;
31367 AREG(7) = adr;
31368 PRE_IO
31369 READ_LONG_F(adr, src)
31370 dst = DREGu32((Opcode >> 9) & 7);
31371 res = dst - src;
31372 flag_NotZ = res;
31373 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31374 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31375 flag_N = res >> 24;
31376 POST_IO
31377RET(16)
31378}
31379
31380// CMPM
31381OPCODE(0xB108)
31382{
31383 u32 adr, res;
31384 u32 src, dst;
31385
31386 adr = AREG((Opcode >> 0) & 7);
31387 AREG((Opcode >> 0) & 7) += 1;
31388 PRE_IO
31389 READ_BYTE_F(adr, src)
31390 adr = AREG((Opcode >> 9) & 7);
31391 AREG((Opcode >> 9) & 7) += 1;
31392 READ_BYTE_F(adr, dst)
31393 res = dst - src;
31394 flag_N = flag_C = res;
31395 flag_V = (src ^ dst) & (res ^ dst);
31396 flag_NotZ = res & 0xFF;
31397 POST_IO
31398RET(12)
31399}
31400
31401// CMPM
31402OPCODE(0xB148)
31403{
31404 u32 adr, res;
31405 u32 src, dst;
31406
31407 adr = AREG((Opcode >> 0) & 7);
31408 AREG((Opcode >> 0) & 7) += 2;
31409 PRE_IO
31410 READ_WORD_F(adr, src)
31411 adr = AREG((Opcode >> 9) & 7);
31412 AREG((Opcode >> 9) & 7) += 2;
31413 READ_WORD_F(adr, dst)
31414 res = dst - src;
31415 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31416 flag_N = flag_C = res >> 8;
31417 flag_NotZ = res & 0xFFFF;
31418 POST_IO
31419RET(12)
31420}
31421
31422// CMPM
31423OPCODE(0xB188)
31424{
31425 u32 adr, res;
31426 u32 src, dst;
31427
31428 adr = AREG((Opcode >> 0) & 7);
31429 AREG((Opcode >> 0) & 7) += 4;
31430 PRE_IO
31431 READ_LONG_F(adr, src)
31432 adr = AREG((Opcode >> 9) & 7);
31433 AREG((Opcode >> 9) & 7) += 4;
31434 READ_LONG_F(adr, dst)
31435 res = dst - src;
31436 flag_NotZ = res;
31437 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31438 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31439 flag_N = res >> 24;
31440 POST_IO
31441RET(20)
31442}
31443
31444// CMP7M
31445OPCODE(0xB10F)
31446{
31447 u32 adr, res;
31448 u32 src, dst;
31449
31450 adr = AREG(7);
31451 AREG(7) += 2;
31452 PRE_IO
31453 READ_BYTE_F(adr, src)
31454 adr = AREG((Opcode >> 9) & 7);
31455 AREG((Opcode >> 9) & 7) += 1;
31456 READ_BYTE_F(adr, dst)
31457 res = dst - src;
31458 flag_N = flag_C = res;
31459 flag_V = (src ^ dst) & (res ^ dst);
31460 flag_NotZ = res & 0xFF;
31461 POST_IO
31462RET(12)
31463}
31464
31465// CMP7M
31466OPCODE(0xB14F)
31467{
31468 u32 adr, res;
31469 u32 src, dst;
31470
31471 adr = AREG(7);
31472 AREG(7) += 2;
31473 PRE_IO
31474 READ_WORD_F(adr, src)
31475 adr = AREG((Opcode >> 9) & 7);
31476 AREG((Opcode >> 9) & 7) += 2;
31477 READ_WORD_F(adr, dst)
31478 res = dst - src;
31479 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31480 flag_N = flag_C = res >> 8;
31481 flag_NotZ = res & 0xFFFF;
31482 POST_IO
31483RET(12)
31484}
31485
31486// CMP7M
31487OPCODE(0xB18F)
31488{
31489 u32 adr, res;
31490 u32 src, dst;
31491
31492 adr = AREG(7);
31493 AREG(7) += 4;
31494 PRE_IO
31495 READ_LONG_F(adr, src)
31496 adr = AREG((Opcode >> 9) & 7);
31497 AREG((Opcode >> 9) & 7) += 4;
31498 READ_LONG_F(adr, dst)
31499 res = dst - src;
31500 flag_NotZ = res;
31501 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31502 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31503 flag_N = res >> 24;
31504 POST_IO
31505RET(20)
31506}
31507
31508// CMPM7
31509OPCODE(0xBF08)
31510{
31511 u32 adr, res;
31512 u32 src, dst;
31513
31514 adr = AREG((Opcode >> 0) & 7);
31515 AREG((Opcode >> 0) & 7) += 1;
31516 PRE_IO
31517 READ_BYTE_F(adr, src)
31518 adr = AREG(7);
31519 AREG(7) += 2;
31520 READ_BYTE_F(adr, dst)
31521 res = dst - src;
31522 flag_N = flag_C = res;
31523 flag_V = (src ^ dst) & (res ^ dst);
31524 flag_NotZ = res & 0xFF;
31525 POST_IO
31526RET(12)
31527}
31528
31529// CMPM7
31530OPCODE(0xBF48)
31531{
31532 u32 adr, res;
31533 u32 src, dst;
31534
31535 adr = AREG((Opcode >> 0) & 7);
31536 AREG((Opcode >> 0) & 7) += 2;
31537 PRE_IO
31538 READ_WORD_F(adr, src)
31539 adr = AREG(7);
31540 AREG(7) += 2;
31541 READ_WORD_F(adr, dst)
31542 res = dst - src;
31543 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31544 flag_N = flag_C = res >> 8;
31545 flag_NotZ = res & 0xFFFF;
31546 POST_IO
31547RET(12)
31548}
31549
31550// CMPM7
31551OPCODE(0xBF88)
31552{
31553 u32 adr, res;
31554 u32 src, dst;
31555
31556 adr = AREG((Opcode >> 0) & 7);
31557 AREG((Opcode >> 0) & 7) += 4;
31558 PRE_IO
31559 READ_LONG_F(adr, src)
31560 adr = AREG(7);
31561 AREG(7) += 4;
31562 READ_LONG_F(adr, dst)
31563 res = dst - src;
31564 flag_NotZ = res;
31565 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31566 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31567 flag_N = res >> 24;
31568 POST_IO
31569RET(20)
31570}
31571
31572// CMP7M7
31573OPCODE(0xBF0F)
31574{
31575 u32 adr, res;
31576 u32 src, dst;
31577
31578 adr = AREG(7);
31579 AREG(7) += 2;
31580 PRE_IO
31581 READ_BYTE_F(adr, src)
31582 adr = AREG(7);
31583 AREG(7) += 2;
31584 READ_BYTE_F(adr, dst)
31585 res = dst - src;
31586 flag_N = flag_C = res;
31587 flag_V = (src ^ dst) & (res ^ dst);
31588 flag_NotZ = res & 0xFF;
31589 POST_IO
31590RET(12)
31591}
31592
31593// CMP7M7
31594OPCODE(0xBF4F)
31595{
31596 u32 adr, res;
31597 u32 src, dst;
31598
31599 adr = AREG(7);
31600 AREG(7) += 2;
31601 PRE_IO
31602 READ_WORD_F(adr, src)
31603 adr = AREG(7);
31604 AREG(7) += 2;
31605 READ_WORD_F(adr, dst)
31606 res = dst - src;
31607 flag_V = ((src ^ dst) & (res ^ dst)) >> 8;
31608 flag_N = flag_C = res >> 8;
31609 flag_NotZ = res & 0xFFFF;
31610 POST_IO
31611RET(12)
31612}
31613
31614// CMP7M7
31615OPCODE(0xBF8F)
31616{
31617 u32 adr, res;
31618 u32 src, dst;
31619
31620 adr = AREG(7);
31621 AREG(7) += 4;
31622 PRE_IO
31623 READ_LONG_F(adr, src)
31624 adr = AREG(7);
31625 AREG(7) += 4;
31626 READ_LONG_F(adr, dst)
31627 res = dst - src;
31628 flag_NotZ = res;
31629 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
31630 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
31631 flag_N = res >> 24;
31632 POST_IO
31633RET(20)
31634}
31635
31636// EORDa
31637OPCODE(0xB100)
31638{
31639 u32 adr, res;
31640 u32 src, dst;
31641
31642 src = DREGu8((Opcode >> 9) & 7);
31643 res = DREGu8((Opcode >> 0) & 7);
31644 res ^= src;
31645 flag_C = 0;
31646 flag_V = 0;
31647 flag_NotZ = res;
31648 flag_N = res;
31649 DREGu8((Opcode >> 0) & 7) = res;
31650RET(4)
31651}
31652
31653// EORDa
31654OPCODE(0xB110)
31655{
31656 u32 adr, res;
31657 u32 src, dst;
31658
31659 src = DREGu8((Opcode >> 9) & 7);
31660 adr = AREG((Opcode >> 0) & 7);
31661 PRE_IO
31662 READ_BYTE_F(adr, res)
31663 res ^= src;
31664 flag_C = 0;
31665 flag_V = 0;
31666 flag_NotZ = res;
31667 flag_N = res;
31668 WRITE_BYTE_F(adr, res)
31669 POST_IO
31670RET(12)
31671}
31672
31673// EORDa
31674OPCODE(0xB118)
31675{
31676 u32 adr, res;
31677 u32 src, dst;
31678
31679 src = DREGu8((Opcode >> 9) & 7);
31680 adr = AREG((Opcode >> 0) & 7);
31681 AREG((Opcode >> 0) & 7) += 1;
31682 PRE_IO
31683 READ_BYTE_F(adr, res)
31684 res ^= src;
31685 flag_C = 0;
31686 flag_V = 0;
31687 flag_NotZ = res;
31688 flag_N = res;
31689 WRITE_BYTE_F(adr, res)
31690 POST_IO
31691RET(12)
31692}
31693
31694// EORDa
31695OPCODE(0xB120)
31696{
31697 u32 adr, res;
31698 u32 src, dst;
31699
31700 src = DREGu8((Opcode >> 9) & 7);
31701 adr = AREG((Opcode >> 0) & 7) - 1;
31702 AREG((Opcode >> 0) & 7) = adr;
31703 PRE_IO
31704 READ_BYTE_F(adr, res)
31705 res ^= src;
31706 flag_C = 0;
31707 flag_V = 0;
31708 flag_NotZ = res;
31709 flag_N = res;
31710 WRITE_BYTE_F(adr, res)
31711 POST_IO
31712RET(14)
31713}
31714
31715// EORDa
31716OPCODE(0xB128)
31717{
31718 u32 adr, res;
31719 u32 src, dst;
31720
31721 src = DREGu8((Opcode >> 9) & 7);
31722 FETCH_SWORD(adr);
31723 adr += AREG((Opcode >> 0) & 7);
31724 PRE_IO
31725 READ_BYTE_F(adr, res)
31726 res ^= src;
31727 flag_C = 0;
31728 flag_V = 0;
31729 flag_NotZ = res;
31730 flag_N = res;
31731 WRITE_BYTE_F(adr, res)
31732 POST_IO
31733RET(16)
31734}
31735
31736// EORDa
31737OPCODE(0xB130)
31738{
31739 u32 adr, res;
31740 u32 src, dst;
31741
31742 src = DREGu8((Opcode >> 9) & 7);
31743 adr = AREG((Opcode >> 0) & 7);
31744 DECODE_EXT_WORD
31745 PRE_IO
31746 READ_BYTE_F(adr, res)
31747 res ^= src;
31748 flag_C = 0;
31749 flag_V = 0;
31750 flag_NotZ = res;
31751 flag_N = res;
31752 WRITE_BYTE_F(adr, res)
31753 POST_IO
31754RET(18)
31755}
31756
31757// EORDa
31758OPCODE(0xB138)
31759{
31760 u32 adr, res;
31761 u32 src, dst;
31762
31763 src = DREGu8((Opcode >> 9) & 7);
31764 FETCH_SWORD(adr);
31765 PRE_IO
31766 READ_BYTE_F(adr, res)
31767 res ^= src;
31768 flag_C = 0;
31769 flag_V = 0;
31770 flag_NotZ = res;
31771 flag_N = res;
31772 WRITE_BYTE_F(adr, res)
31773 POST_IO
31774RET(16)
31775}
31776
31777// EORDa
31778OPCODE(0xB139)
31779{
31780 u32 adr, res;
31781 u32 src, dst;
31782
31783 src = DREGu8((Opcode >> 9) & 7);
31784 FETCH_LONG(adr);
31785 PRE_IO
31786 READ_BYTE_F(adr, res)
31787 res ^= src;
31788 flag_C = 0;
31789 flag_V = 0;
31790 flag_NotZ = res;
31791 flag_N = res;
31792 WRITE_BYTE_F(adr, res)
31793 POST_IO
31794RET(20)
31795}
31796
31797// EORDa
31798OPCODE(0xB11F)
31799{
31800 u32 adr, res;
31801 u32 src, dst;
31802
31803 src = DREGu8((Opcode >> 9) & 7);
31804 adr = AREG(7);
31805 AREG(7) += 2;
31806 PRE_IO
31807 READ_BYTE_F(adr, res)
31808 res ^= src;
31809 flag_C = 0;
31810 flag_V = 0;
31811 flag_NotZ = res;
31812 flag_N = res;
31813 WRITE_BYTE_F(adr, res)
31814 POST_IO
31815RET(12)
31816}
31817
31818// EORDa
31819OPCODE(0xB127)
31820{
31821 u32 adr, res;
31822 u32 src, dst;
31823
31824 src = DREGu8((Opcode >> 9) & 7);
31825 adr = AREG(7) - 2;
31826 AREG(7) = adr;
31827 PRE_IO
31828 READ_BYTE_F(adr, res)
31829 res ^= src;
31830 flag_C = 0;
31831 flag_V = 0;
31832 flag_NotZ = res;
31833 flag_N = res;
31834 WRITE_BYTE_F(adr, res)
31835 POST_IO
31836RET(14)
31837}
31838
31839// EORDa
31840OPCODE(0xB140)
31841{
31842 u32 adr, res;
31843 u32 src, dst;
31844
31845 src = DREGu16((Opcode >> 9) & 7);
31846 res = DREGu16((Opcode >> 0) & 7);
31847 res ^= src;
31848 flag_C = 0;
31849 flag_V = 0;
31850 flag_NotZ = res;
31851 flag_N = res >> 8;
31852 DREGu16((Opcode >> 0) & 7) = res;
31853RET(4)
31854}
31855
31856// EORDa
31857OPCODE(0xB150)
31858{
31859 u32 adr, res;
31860 u32 src, dst;
31861
31862 src = DREGu16((Opcode >> 9) & 7);
31863 adr = AREG((Opcode >> 0) & 7);
31864 PRE_IO
31865 READ_WORD_F(adr, res)
31866 res ^= src;
31867 flag_C = 0;
31868 flag_V = 0;
31869 flag_NotZ = res;
31870 flag_N = res >> 8;
31871 WRITE_WORD_F(adr, res)
31872 POST_IO
31873RET(12)
31874}
31875
31876// EORDa
31877OPCODE(0xB158)
31878{
31879 u32 adr, res;
31880 u32 src, dst;
31881
31882 src = DREGu16((Opcode >> 9) & 7);
31883 adr = AREG((Opcode >> 0) & 7);
31884 AREG((Opcode >> 0) & 7) += 2;
31885 PRE_IO
31886 READ_WORD_F(adr, res)
31887 res ^= src;
31888 flag_C = 0;
31889 flag_V = 0;
31890 flag_NotZ = res;
31891 flag_N = res >> 8;
31892 WRITE_WORD_F(adr, res)
31893 POST_IO
31894RET(12)
31895}
31896
31897// EORDa
31898OPCODE(0xB160)
31899{
31900 u32 adr, res;
31901 u32 src, dst;
31902
31903 src = DREGu16((Opcode >> 9) & 7);
31904 adr = AREG((Opcode >> 0) & 7) - 2;
31905 AREG((Opcode >> 0) & 7) = adr;
31906 PRE_IO
31907 READ_WORD_F(adr, res)
31908 res ^= src;
31909 flag_C = 0;
31910 flag_V = 0;
31911 flag_NotZ = res;
31912 flag_N = res >> 8;
31913 WRITE_WORD_F(adr, res)
31914 POST_IO
31915RET(14)
31916}
31917
31918// EORDa
31919OPCODE(0xB168)
31920{
31921 u32 adr, res;
31922 u32 src, dst;
31923
31924 src = DREGu16((Opcode >> 9) & 7);
31925 FETCH_SWORD(adr);
31926 adr += AREG((Opcode >> 0) & 7);
31927 PRE_IO
31928 READ_WORD_F(adr, res)
31929 res ^= src;
31930 flag_C = 0;
31931 flag_V = 0;
31932 flag_NotZ = res;
31933 flag_N = res >> 8;
31934 WRITE_WORD_F(adr, res)
31935 POST_IO
31936RET(16)
31937}
31938
31939// EORDa
31940OPCODE(0xB170)
31941{
31942 u32 adr, res;
31943 u32 src, dst;
31944
31945 src = DREGu16((Opcode >> 9) & 7);
31946 adr = AREG((Opcode >> 0) & 7);
31947 DECODE_EXT_WORD
31948 PRE_IO
31949 READ_WORD_F(adr, res)
31950 res ^= src;
31951 flag_C = 0;
31952 flag_V = 0;
31953 flag_NotZ = res;
31954 flag_N = res >> 8;
31955 WRITE_WORD_F(adr, res)
31956 POST_IO
31957RET(18)
31958}
31959
31960// EORDa
31961OPCODE(0xB178)
31962{
31963 u32 adr, res;
31964 u32 src, dst;
31965
31966 src = DREGu16((Opcode >> 9) & 7);
31967 FETCH_SWORD(adr);
31968 PRE_IO
31969 READ_WORD_F(adr, res)
31970 res ^= src;
31971 flag_C = 0;
31972 flag_V = 0;
31973 flag_NotZ = res;
31974 flag_N = res >> 8;
31975 WRITE_WORD_F(adr, res)
31976 POST_IO
31977RET(16)
31978}
31979
31980// EORDa
31981OPCODE(0xB179)
31982{
31983 u32 adr, res;
31984 u32 src, dst;
31985
31986 src = DREGu16((Opcode >> 9) & 7);
31987 FETCH_LONG(adr);
31988 PRE_IO
31989 READ_WORD_F(adr, res)
31990 res ^= src;
31991 flag_C = 0;
31992 flag_V = 0;
31993 flag_NotZ = res;
31994 flag_N = res >> 8;
31995 WRITE_WORD_F(adr, res)
31996 POST_IO
31997RET(20)
31998}
31999
32000// EORDa
32001OPCODE(0xB15F)
32002{
32003 u32 adr, res;
32004 u32 src, dst;
32005
32006 src = DREGu16((Opcode >> 9) & 7);
32007 adr = AREG(7);
32008 AREG(7) += 2;
32009 PRE_IO
32010 READ_WORD_F(adr, res)
32011 res ^= src;
32012 flag_C = 0;
32013 flag_V = 0;
32014 flag_NotZ = res;
32015 flag_N = res >> 8;
32016 WRITE_WORD_F(adr, res)
32017 POST_IO
32018RET(12)
32019}
32020
32021// EORDa
32022OPCODE(0xB167)
32023{
32024 u32 adr, res;
32025 u32 src, dst;
32026
32027 src = DREGu16((Opcode >> 9) & 7);
32028 adr = AREG(7) - 2;
32029 AREG(7) = adr;
32030 PRE_IO
32031 READ_WORD_F(adr, res)
32032 res ^= src;
32033 flag_C = 0;
32034 flag_V = 0;
32035 flag_NotZ = res;
32036 flag_N = res >> 8;
32037 WRITE_WORD_F(adr, res)
32038 POST_IO
32039RET(14)
32040}
32041
32042// EORDa
32043OPCODE(0xB180)
32044{
32045 u32 adr, res;
32046 u32 src, dst;
32047
32048 src = DREGu32((Opcode >> 9) & 7);
32049 res = DREGu32((Opcode >> 0) & 7);
32050 res ^= src;
32051 flag_C = 0;
32052 flag_V = 0;
32053 flag_NotZ = res;
32054 flag_N = res >> 24;
32055 DREGu32((Opcode >> 0) & 7) = res;
32056RET(8)
32057}
32058
32059// EORDa
32060OPCODE(0xB190)
32061{
32062 u32 adr, res;
32063 u32 src, dst;
32064
32065 src = DREGu32((Opcode >> 9) & 7);
32066 adr = AREG((Opcode >> 0) & 7);
32067 PRE_IO
32068 READ_LONG_F(adr, res)
32069 res ^= src;
32070 flag_C = 0;
32071 flag_V = 0;
32072 flag_NotZ = res;
32073 flag_N = res >> 24;
32074 WRITE_LONG_F(adr, res)
32075 POST_IO
32076RET(20)
32077}
32078
32079// EORDa
32080OPCODE(0xB198)
32081{
32082 u32 adr, res;
32083 u32 src, dst;
32084
32085 src = DREGu32((Opcode >> 9) & 7);
32086 adr = AREG((Opcode >> 0) & 7);
32087 AREG((Opcode >> 0) & 7) += 4;
32088 PRE_IO
32089 READ_LONG_F(adr, res)
32090 res ^= src;
32091 flag_C = 0;
32092 flag_V = 0;
32093 flag_NotZ = res;
32094 flag_N = res >> 24;
32095 WRITE_LONG_F(adr, res)
32096 POST_IO
32097RET(20)
32098}
32099
32100// EORDa
32101OPCODE(0xB1A0)
32102{
32103 u32 adr, res;
32104 u32 src, dst;
32105
32106 src = DREGu32((Opcode >> 9) & 7);
32107 adr = AREG((Opcode >> 0) & 7) - 4;
32108 AREG((Opcode >> 0) & 7) = adr;
32109 PRE_IO
32110 READ_LONG_F(adr, res)
32111 res ^= src;
32112 flag_C = 0;
32113 flag_V = 0;
32114 flag_NotZ = res;
32115 flag_N = res >> 24;
32116 WRITE_LONG_F(adr, res)
32117 POST_IO
32118RET(22)
32119}
32120
32121// EORDa
32122OPCODE(0xB1A8)
32123{
32124 u32 adr, res;
32125 u32 src, dst;
32126
32127 src = DREGu32((Opcode >> 9) & 7);
32128 FETCH_SWORD(adr);
32129 adr += AREG((Opcode >> 0) & 7);
32130 PRE_IO
32131 READ_LONG_F(adr, res)
32132 res ^= src;
32133 flag_C = 0;
32134 flag_V = 0;
32135 flag_NotZ = res;
32136 flag_N = res >> 24;
32137 WRITE_LONG_F(adr, res)
32138 POST_IO
32139RET(24)
32140}
32141
32142// EORDa
32143OPCODE(0xB1B0)
32144{
32145 u32 adr, res;
32146 u32 src, dst;
32147
32148 src = DREGu32((Opcode >> 9) & 7);
32149 adr = AREG((Opcode >> 0) & 7);
32150 DECODE_EXT_WORD
32151 PRE_IO
32152 READ_LONG_F(adr, res)
32153 res ^= src;
32154 flag_C = 0;
32155 flag_V = 0;
32156 flag_NotZ = res;
32157 flag_N = res >> 24;
32158 WRITE_LONG_F(adr, res)
32159 POST_IO
32160RET(26)
32161}
32162
32163// EORDa
32164OPCODE(0xB1B8)
32165{
32166 u32 adr, res;
32167 u32 src, dst;
32168
32169 src = DREGu32((Opcode >> 9) & 7);
32170 FETCH_SWORD(adr);
32171 PRE_IO
32172 READ_LONG_F(adr, res)
32173 res ^= src;
32174 flag_C = 0;
32175 flag_V = 0;
32176 flag_NotZ = res;
32177 flag_N = res >> 24;
32178 WRITE_LONG_F(adr, res)
32179 POST_IO
32180RET(24)
32181}
32182
32183// EORDa
32184OPCODE(0xB1B9)
32185{
32186 u32 adr, res;
32187 u32 src, dst;
32188
32189 src = DREGu32((Opcode >> 9) & 7);
32190 FETCH_LONG(adr);
32191 PRE_IO
32192 READ_LONG_F(adr, res)
32193 res ^= src;
32194 flag_C = 0;
32195 flag_V = 0;
32196 flag_NotZ = res;
32197 flag_N = res >> 24;
32198 WRITE_LONG_F(adr, res)
32199 POST_IO
32200RET(28)
32201}
32202
32203// EORDa
32204OPCODE(0xB19F)
32205{
32206 u32 adr, res;
32207 u32 src, dst;
32208
32209 src = DREGu32((Opcode >> 9) & 7);
32210 adr = AREG(7);
32211 AREG(7) += 4;
32212 PRE_IO
32213 READ_LONG_F(adr, res)
32214 res ^= src;
32215 flag_C = 0;
32216 flag_V = 0;
32217 flag_NotZ = res;
32218 flag_N = res >> 24;
32219 WRITE_LONG_F(adr, res)
32220 POST_IO
32221RET(20)
32222}
32223
32224// EORDa
32225OPCODE(0xB1A7)
32226{
32227 u32 adr, res;
32228 u32 src, dst;
32229
32230 src = DREGu32((Opcode >> 9) & 7);
32231 adr = AREG(7) - 4;
32232 AREG(7) = adr;
32233 PRE_IO
32234 READ_LONG_F(adr, res)
32235 res ^= src;
32236 flag_C = 0;
32237 flag_V = 0;
32238 flag_NotZ = res;
32239 flag_N = res >> 24;
32240 WRITE_LONG_F(adr, res)
32241 POST_IO
32242RET(22)
32243}
32244
32245// CMPA
32246OPCODE(0xB0C0)
32247{
32248 u32 adr, res;
32249 u32 src, dst;
32250
32251 src = (s32)DREGs16((Opcode >> 0) & 7);
32252 dst = AREGu32((Opcode >> 9) & 7);
32253 res = dst - src;
32254 flag_NotZ = res;
32255 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32256 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32257 flag_N = res >> 24;
32258RET(6)
32259}
32260
32261// CMPA
32262OPCODE(0xB0C8)
32263{
32264 u32 adr, res;
32265 u32 src, dst;
32266
32267 src = (s32)AREGs16((Opcode >> 0) & 7);
32268 dst = AREGu32((Opcode >> 9) & 7);
32269 res = dst - src;
32270 flag_NotZ = res;
32271 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32272 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32273 flag_N = res >> 24;
32274RET(6)
32275}
32276
32277// CMPA
32278OPCODE(0xB0D0)
32279{
32280 u32 adr, res;
32281 u32 src, dst;
32282
32283 adr = AREG((Opcode >> 0) & 7);
32284 PRE_IO
32285 READSX_WORD_F(adr, src)
32286 dst = AREGu32((Opcode >> 9) & 7);
32287 res = dst - src;
32288 flag_NotZ = res;
32289 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32290 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32291 flag_N = res >> 24;
32292 POST_IO
32293RET(10)
32294}
32295
32296// CMPA
32297OPCODE(0xB0D8)
32298{
32299 u32 adr, res;
32300 u32 src, dst;
32301
32302 adr = AREG((Opcode >> 0) & 7);
32303 AREG((Opcode >> 0) & 7) += 2;
32304 PRE_IO
32305 READSX_WORD_F(adr, src)
32306 dst = AREGu32((Opcode >> 9) & 7);
32307 res = dst - src;
32308 flag_NotZ = res;
32309 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32310 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32311 flag_N = res >> 24;
32312 POST_IO
32313RET(10)
32314}
32315
32316// CMPA
32317OPCODE(0xB0E0)
32318{
32319 u32 adr, res;
32320 u32 src, dst;
32321
32322 adr = AREG((Opcode >> 0) & 7) - 2;
32323 AREG((Opcode >> 0) & 7) = adr;
32324 PRE_IO
32325 READSX_WORD_F(adr, src)
32326 dst = AREGu32((Opcode >> 9) & 7);
32327 res = dst - src;
32328 flag_NotZ = res;
32329 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32330 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32331 flag_N = res >> 24;
32332 POST_IO
32333RET(12)
32334}
32335
32336// CMPA
32337OPCODE(0xB0E8)
32338{
32339 u32 adr, res;
32340 u32 src, dst;
32341
32342 FETCH_SWORD(adr);
32343 adr += AREG((Opcode >> 0) & 7);
32344 PRE_IO
32345 READSX_WORD_F(adr, src)
32346 dst = AREGu32((Opcode >> 9) & 7);
32347 res = dst - src;
32348 flag_NotZ = res;
32349 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32350 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32351 flag_N = res >> 24;
32352 POST_IO
32353RET(14)
32354}
32355
32356// CMPA
32357OPCODE(0xB0F0)
32358{
32359 u32 adr, res;
32360 u32 src, dst;
32361
32362 adr = AREG((Opcode >> 0) & 7);
32363 DECODE_EXT_WORD
32364 PRE_IO
32365 READSX_WORD_F(adr, src)
32366 dst = AREGu32((Opcode >> 9) & 7);
32367 res = dst - src;
32368 flag_NotZ = res;
32369 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32370 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32371 flag_N = res >> 24;
32372 POST_IO
32373RET(16)
32374}
32375
32376// CMPA
32377OPCODE(0xB0F8)
32378{
32379 u32 adr, res;
32380 u32 src, dst;
32381
32382 FETCH_SWORD(adr);
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(14)
32393}
32394
32395// CMPA
32396OPCODE(0xB0F9)
32397{
32398 u32 adr, res;
32399 u32 src, dst;
32400
32401 FETCH_LONG(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(18)
32412}
32413
32414// CMPA
32415OPCODE(0xB0FA)
32416{
32417 u32 adr, res;
32418 u32 src, dst;
32419
be26eb23 32420 adr = GET_SWORD + GET_PC;
70357ce5 32421 PC++;
32422 PRE_IO
32423 READSX_WORD_F(adr, src)
32424 dst = AREGu32((Opcode >> 9) & 7);
32425 res = dst - src;
32426 flag_NotZ = res;
32427 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32428 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32429 flag_N = res >> 24;
32430 POST_IO
32431RET(14)
32432}
32433
32434// CMPA
32435OPCODE(0xB0FB)
32436{
32437 u32 adr, res;
32438 u32 src, dst;
32439
be26eb23 32440 adr = GET_PC;
70357ce5 32441 DECODE_EXT_WORD
32442 PRE_IO
32443 READSX_WORD_F(adr, src)
32444 dst = AREGu32((Opcode >> 9) & 7);
32445 res = dst - src;
32446 flag_NotZ = res;
32447 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32448 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32449 flag_N = res >> 24;
32450 POST_IO
32451RET(16)
32452}
32453
32454// CMPA
32455OPCODE(0xB0FC)
32456{
32457 u32 adr, res;
32458 u32 src, dst;
32459
32460 FETCH_SWORD(src);
32461 dst = AREGu32((Opcode >> 9) & 7);
32462 res = dst - src;
32463 flag_NotZ = res;
32464 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32465 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32466 flag_N = res >> 24;
32467RET(10)
32468}
32469
32470// CMPA
32471OPCODE(0xB0DF)
32472{
32473 u32 adr, res;
32474 u32 src, dst;
32475
32476 adr = AREG(7);
32477 AREG(7) += 2;
32478 PRE_IO
32479 READSX_WORD_F(adr, 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;
32486 POST_IO
32487RET(10)
32488}
32489
32490// CMPA
32491OPCODE(0xB0E7)
32492{
32493 u32 adr, res;
32494 u32 src, dst;
32495
32496 adr = AREG(7) - 2;
32497 AREG(7) = adr;
32498 PRE_IO
32499 READSX_WORD_F(adr, src)
32500 dst = AREGu32((Opcode >> 9) & 7);
32501 res = dst - src;
32502 flag_NotZ = res;
32503 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32504 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32505 flag_N = res >> 24;
32506 POST_IO
32507RET(12)
32508}
32509
32510// CMPA
32511OPCODE(0xB1C0)
32512{
32513 u32 adr, res;
32514 u32 src, dst;
32515
32516 src = (s32)DREGs32((Opcode >> 0) & 7);
32517 dst = AREGu32((Opcode >> 9) & 7);
32518 res = dst - src;
32519 flag_NotZ = res;
32520 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32521 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32522 flag_N = res >> 24;
32523RET(6)
32524}
32525
32526// CMPA
32527OPCODE(0xB1C8)
32528{
32529 u32 adr, res;
32530 u32 src, dst;
32531
32532 src = (s32)AREGs32((Opcode >> 0) & 7);
32533 dst = AREGu32((Opcode >> 9) & 7);
32534 res = dst - src;
32535 flag_NotZ = res;
32536 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32537 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32538 flag_N = res >> 24;
32539RET(6)
32540}
32541
32542// CMPA
32543OPCODE(0xB1D0)
32544{
32545 u32 adr, res;
32546 u32 src, dst;
32547
32548 adr = AREG((Opcode >> 0) & 7);
32549 PRE_IO
32550 READSX_LONG_F(adr, src)
32551 dst = AREGu32((Opcode >> 9) & 7);
32552 res = dst - src;
32553 flag_NotZ = res;
32554 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32555 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32556 flag_N = res >> 24;
32557 POST_IO
32558RET(14)
32559}
32560
32561// CMPA
32562OPCODE(0xB1D8)
32563{
32564 u32 adr, res;
32565 u32 src, dst;
32566
32567 adr = AREG((Opcode >> 0) & 7);
32568 AREG((Opcode >> 0) & 7) += 4;
32569 PRE_IO
32570 READSX_LONG_F(adr, src)
32571 dst = AREGu32((Opcode >> 9) & 7);
32572 res = dst - src;
32573 flag_NotZ = res;
32574 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32575 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32576 flag_N = res >> 24;
32577 POST_IO
32578RET(14)
32579}
32580
32581// CMPA
32582OPCODE(0xB1E0)
32583{
32584 u32 adr, res;
32585 u32 src, dst;
32586
32587 adr = AREG((Opcode >> 0) & 7) - 4;
32588 AREG((Opcode >> 0) & 7) = adr;
32589 PRE_IO
32590 READSX_LONG_F(adr, src)
32591 dst = AREGu32((Opcode >> 9) & 7);
32592 res = dst - src;
32593 flag_NotZ = res;
32594 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32595 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32596 flag_N = res >> 24;
32597 POST_IO
32598RET(16)
32599}
32600
32601// CMPA
32602OPCODE(0xB1E8)
32603{
32604 u32 adr, res;
32605 u32 src, dst;
32606
32607 FETCH_SWORD(adr);
32608 adr += AREG((Opcode >> 0) & 7);
32609 PRE_IO
32610 READSX_LONG_F(adr, src)
32611 dst = AREGu32((Opcode >> 9) & 7);
32612 res = dst - src;
32613 flag_NotZ = res;
32614 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32615 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32616 flag_N = res >> 24;
32617 POST_IO
32618RET(18)
32619}
32620
32621// CMPA
32622OPCODE(0xB1F0)
32623{
32624 u32 adr, res;
32625 u32 src, dst;
32626
32627 adr = AREG((Opcode >> 0) & 7);
32628 DECODE_EXT_WORD
32629 PRE_IO
32630 READSX_LONG_F(adr, src)
32631 dst = AREGu32((Opcode >> 9) & 7);
32632 res = dst - src;
32633 flag_NotZ = res;
32634 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32635 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32636 flag_N = res >> 24;
32637 POST_IO
32638RET(20)
32639}
32640
32641// CMPA
32642OPCODE(0xB1F8)
32643{
32644 u32 adr, res;
32645 u32 src, dst;
32646
32647 FETCH_SWORD(adr);
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(18)
32658}
32659
32660// CMPA
32661OPCODE(0xB1F9)
32662{
32663 u32 adr, res;
32664 u32 src, dst;
32665
32666 FETCH_LONG(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(22)
32677}
32678
32679// CMPA
32680OPCODE(0xB1FA)
32681{
32682 u32 adr, res;
32683 u32 src, dst;
32684
be26eb23 32685 adr = GET_SWORD + GET_PC;
70357ce5 32686 PC++;
32687 PRE_IO
32688 READSX_LONG_F(adr, src)
32689 dst = AREGu32((Opcode >> 9) & 7);
32690 res = dst - src;
32691 flag_NotZ = res;
32692 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32693 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32694 flag_N = res >> 24;
32695 POST_IO
32696RET(18)
32697}
32698
32699// CMPA
32700OPCODE(0xB1FB)
32701{
32702 u32 adr, res;
32703 u32 src, dst;
32704
be26eb23 32705 adr = GET_PC;
70357ce5 32706 DECODE_EXT_WORD
32707 PRE_IO
32708 READSX_LONG_F(adr, src)
32709 dst = AREGu32((Opcode >> 9) & 7);
32710 res = dst - src;
32711 flag_NotZ = res;
32712 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32713 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32714 flag_N = res >> 24;
32715 POST_IO
32716RET(20)
32717}
32718
32719// CMPA
32720OPCODE(0xB1FC)
32721{
32722 u32 adr, res;
32723 u32 src, dst;
32724
32725 FETCH_LONG(src);
32726 dst = AREGu32((Opcode >> 9) & 7);
32727 res = dst - src;
32728 flag_NotZ = res;
32729 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32730 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32731 flag_N = res >> 24;
32732RET(14)
32733}
32734
32735// CMPA
32736OPCODE(0xB1DF)
32737{
32738 u32 adr, res;
32739 u32 src, dst;
32740
32741 adr = AREG(7);
32742 AREG(7) += 4;
32743 PRE_IO
32744 READSX_LONG_F(adr, 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;
32751 POST_IO
32752RET(14)
32753}
32754
32755// CMPA
32756OPCODE(0xB1E7)
32757{
32758 u32 adr, res;
32759 u32 src, dst;
32760
32761 adr = AREG(7) - 4;
32762 AREG(7) = adr;
32763 PRE_IO
32764 READSX_LONG_F(adr, src)
32765 dst = AREGu32((Opcode >> 9) & 7);
32766 res = dst - src;
32767 flag_NotZ = res;
32768 flag_C = ((src & res & 1) + (src >> 1) + (res >> 1)) >> 23;
32769 flag_V = ((src ^ dst) & (res ^ dst)) >> 24;
32770 flag_N = res >> 24;
32771 POST_IO
32772RET(16)
32773}
32774
32775// ANDaD
32776OPCODE(0xC000)
32777{
32778 u32 adr, res;
32779 u32 src, dst;
32780
32781 src = DREGu8((Opcode >> 0) & 7);
32782 res = DREGu8((Opcode >> 9) & 7);
32783 res &= src;
32784 flag_C = 0;
32785 flag_V = 0;
32786 flag_NotZ = res;
32787 flag_N = res;
32788 DREGu8((Opcode >> 9) & 7) = res;
32789RET(4)
32790}
32791
32792// ANDaD
32793OPCODE(0xC010)
32794{
32795 u32 adr, res;
32796 u32 src, dst;
32797
32798 adr = AREG((Opcode >> 0) & 7);
32799 PRE_IO
32800 READ_BYTE_F(adr, src)
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;
32808 POST_IO
32809RET(8)
32810}
32811
32812// ANDaD
32813OPCODE(0xC018)
32814{
32815 u32 adr, res;
32816 u32 src, dst;
32817
32818 adr = AREG((Opcode >> 0) & 7);
32819 AREG((Opcode >> 0) & 7) += 1;
32820 PRE_IO
32821 READ_BYTE_F(adr, src)
32822 res = DREGu8((Opcode >> 9) & 7);
32823 res &= src;
32824 flag_C = 0;
32825 flag_V = 0;
32826 flag_NotZ = res;
32827 flag_N = res;
32828 DREGu8((Opcode >> 9) & 7) = res;
32829 POST_IO
32830RET(8)
32831}
32832
32833// ANDaD
32834OPCODE(0xC020)
32835{
32836 u32 adr, res;
32837 u32 src, dst;
32838
32839 adr = AREG((Opcode >> 0) & 7) - 1;
32840 AREG((Opcode >> 0) & 7) = adr;
32841 PRE_IO
32842 READ_BYTE_F(adr, src)
32843 res = DREGu8((Opcode >> 9) & 7);
32844 res &= src;
32845 flag_C = 0;
32846 flag_V = 0;
32847 flag_NotZ = res;
32848 flag_N = res;
32849 DREGu8((Opcode >> 9) & 7) = res;
32850 POST_IO
32851RET(10)
32852}
32853
32854// ANDaD
32855OPCODE(0xC028)
32856{
32857 u32 adr, res;
32858 u32 src, dst;
32859
32860 FETCH_SWORD(adr);
32861 adr += AREG((Opcode >> 0) & 7);
32862 PRE_IO
32863 READ_BYTE_F(adr, src)
32864 res = DREGu8((Opcode >> 9) & 7);
32865 res &= src;
32866 flag_C = 0;
32867 flag_V = 0;
32868 flag_NotZ = res;
32869 flag_N = res;
32870 DREGu8((Opcode >> 9) & 7) = res;
32871 POST_IO
32872RET(12)
32873}
32874
32875// ANDaD
32876OPCODE(0xC030)
32877{
32878 u32 adr, res;
32879 u32 src, dst;
32880
32881 adr = AREG((Opcode >> 0) & 7);
32882 DECODE_EXT_WORD
32883 PRE_IO
32884 READ_BYTE_F(adr, src)
32885 res = DREGu8((Opcode >> 9) & 7);
32886 res &= src;
32887 flag_C = 0;
32888 flag_V = 0;
32889 flag_NotZ = res;
32890 flag_N = res;
32891 DREGu8((Opcode >> 9) & 7) = res;
32892 POST_IO
32893RET(14)
32894}
32895
32896// ANDaD
32897OPCODE(0xC038)
32898{
32899 u32 adr, res;
32900 u32 src, dst;
32901
32902 FETCH_SWORD(adr);
32903 PRE_IO
32904 READ_BYTE_F(adr, src)
32905 res = DREGu8((Opcode >> 9) & 7);
32906 res &= src;
32907 flag_C = 0;
32908 flag_V = 0;
32909 flag_NotZ = res;
32910 flag_N = res;
32911 DREGu8((Opcode >> 9) & 7) = res;
32912 POST_IO
32913RET(12)
32914}
32915
32916// ANDaD
32917OPCODE(0xC039)
32918{
32919 u32 adr, res;
32920 u32 src, dst;
32921
32922 FETCH_LONG(adr);
32923 PRE_IO
32924 READ_BYTE_F(adr, src)
32925 res = DREGu8((Opcode >> 9) & 7);
32926 res &= src;
32927 flag_C = 0;
32928 flag_V = 0;
32929 flag_NotZ = res;
32930 flag_N = res;
32931 DREGu8((Opcode >> 9) & 7) = res;
32932 POST_IO
32933RET(16)
32934}
32935
32936// ANDaD
32937OPCODE(0xC03A)
32938{
32939 u32 adr, res;
32940 u32 src, dst;
32941
be26eb23 32942 adr = GET_SWORD + GET_PC;
70357ce5 32943 PC++;
32944 PRE_IO
32945 READ_BYTE_F(adr, src)
32946 res = DREGu8((Opcode >> 9) & 7);
32947 res &= src;
32948 flag_C = 0;
32949 flag_V = 0;
32950 flag_NotZ = res;
32951 flag_N = res;
32952 DREGu8((Opcode >> 9) & 7) = res;
32953 POST_IO
32954RET(12)
32955}
32956
32957// ANDaD
32958OPCODE(0xC03B)
32959{
32960 u32 adr, res;
32961 u32 src, dst;
32962
be26eb23 32963 adr = GET_PC;
70357ce5 32964 DECODE_EXT_WORD
32965 PRE_IO
32966 READ_BYTE_F(adr, src)
32967 res = DREGu8((Opcode >> 9) & 7);
32968 res &= src;
32969 flag_C = 0;
32970 flag_V = 0;
32971 flag_NotZ = res;
32972 flag_N = res;
32973 DREGu8((Opcode >> 9) & 7) = res;
32974 POST_IO
32975RET(14)
32976}
32977
32978// ANDaD
32979OPCODE(0xC03C)
32980{
32981 u32 adr, res;
32982 u32 src, dst;
32983
32984 FETCH_BYTE(src);
32985 res = DREGu8((Opcode >> 9) & 7);
32986 res &= src;
32987 flag_C = 0;
32988 flag_V = 0;
32989 flag_NotZ = res;
32990 flag_N = res;
32991 DREGu8((Opcode >> 9) & 7) = res;
32992RET(8)
32993}
32994
32995// ANDaD
32996OPCODE(0xC01F)
32997{
32998 u32 adr, res;
32999 u32 src, dst;
33000
33001 adr = AREG(7);
33002 AREG(7) += 2;
33003 PRE_IO
33004 READ_BYTE_F(adr, src)
33005 res = DREGu8((Opcode >> 9) & 7);
33006 res &= src;
33007 flag_C = 0;
33008 flag_V = 0;
33009 flag_NotZ = res;
33010 flag_N = res;
33011 DREGu8((Opcode >> 9) & 7) = res;
33012 POST_IO
33013RET(8)
33014}
33015
33016// ANDaD
33017OPCODE(0xC027)
33018{
33019 u32 adr, res;
33020 u32 src, dst;
33021
33022 adr = AREG(7) - 2;
33023 AREG(7) = adr;
33024 PRE_IO
33025 READ_BYTE_F(adr, src)
33026 res = DREGu8((Opcode >> 9) & 7);
33027 res &= src;
33028 flag_C = 0;
33029 flag_V = 0;
33030 flag_NotZ = res;
33031 flag_N = res;
33032 DREGu8((Opcode >> 9) & 7) = res;
33033 POST_IO
33034RET(10)
33035}
33036
33037// ANDaD
33038OPCODE(0xC040)
33039{
33040 u32 adr, res;
33041 u32 src, dst;
33042
33043 src = DREGu16((Opcode >> 0) & 7);
33044 res = DREGu16((Opcode >> 9) & 7);
33045 res &= src;
33046 flag_C = 0;
33047 flag_V = 0;
33048 flag_NotZ = res;
33049 flag_N = res >> 8;
33050 DREGu16((Opcode >> 9) & 7) = res;
33051RET(4)
33052}
33053
33054// ANDaD
33055OPCODE(0xC050)
33056{
33057 u32 adr, res;
33058 u32 src, dst;
33059
33060 adr = AREG((Opcode >> 0) & 7);
33061 PRE_IO
33062 READ_WORD_F(adr, src)
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;
33070 POST_IO
33071RET(8)
33072}
33073
33074// ANDaD
33075OPCODE(0xC058)
33076{
33077 u32 adr, res;
33078 u32 src, dst;
33079
33080 adr = AREG((Opcode >> 0) & 7);
33081 AREG((Opcode >> 0) & 7) += 2;
33082 PRE_IO
33083 READ_WORD_F(adr, src)
33084 res = DREGu16((Opcode >> 9) & 7);
33085 res &= src;
33086 flag_C = 0;
33087 flag_V = 0;
33088 flag_NotZ = res;
33089 flag_N = res >> 8;
33090 DREGu16((Opcode >> 9) & 7) = res;
33091 POST_IO
33092RET(8)
33093}
33094
33095// ANDaD
33096OPCODE(0xC060)
33097{
33098 u32 adr, res;
33099 u32 src, dst;
33100
33101 adr = AREG((Opcode >> 0) & 7) - 2;
33102 AREG((Opcode >> 0) & 7) = adr;
33103 PRE_IO
33104 READ_WORD_F(adr, src)
33105 res = DREGu16((Opcode >> 9) & 7);
33106 res &= src;
33107 flag_C = 0;
33108 flag_V = 0;
33109 flag_NotZ = res;
33110 flag_N = res >> 8;
33111 DREGu16((Opcode >> 9) & 7) = res;
33112 POST_IO
33113RET(10)
33114}
33115
33116// ANDaD
33117OPCODE(0xC068)
33118{
33119 u32 adr, res;
33120 u32 src, dst;
33121
33122 FETCH_SWORD(adr);
33123 adr += AREG((Opcode >> 0) & 7);
33124 PRE_IO
33125 READ_WORD_F(adr, src)
33126 res = DREGu16((Opcode >> 9) & 7);
33127 res &= src;
33128 flag_C = 0;
33129 flag_V = 0;
33130 flag_NotZ = res;
33131 flag_N = res >> 8;
33132 DREGu16((Opcode >> 9) & 7) = res;
33133 POST_IO
33134RET(12)
33135}
33136
33137// ANDaD
33138OPCODE(0xC070)
33139{
33140 u32 adr, res;
33141 u32 src, dst;
33142
33143 adr = AREG((Opcode >> 0) & 7);
33144 DECODE_EXT_WORD
33145 PRE_IO
33146 READ_WORD_F(adr, src)
33147 res = DREGu16((Opcode >> 9) & 7);
33148 res &= src;
33149 flag_C = 0;
33150 flag_V = 0;
33151 flag_NotZ = res;
33152 flag_N = res >> 8;
33153 DREGu16((Opcode >> 9) & 7) = res;
33154 POST_IO
33155RET(14)
33156}
33157
33158// ANDaD
33159OPCODE(0xC078)
33160{
33161 u32 adr, res;
33162 u32 src, dst;
33163
33164 FETCH_SWORD(adr);
33165 PRE_IO
33166 READ_WORD_F(adr, src)
33167 res = DREGu16((Opcode >> 9) & 7);
33168 res &= src;
33169 flag_C = 0;
33170 flag_V = 0;
33171 flag_NotZ = res;
33172 flag_N = res >> 8;
33173 DREGu16((Opcode >> 9) & 7) = res;
33174 POST_IO
33175RET(12)
33176}
33177
33178// ANDaD
33179OPCODE(0xC079)
33180{
33181 u32 adr, res;
33182 u32 src, dst;
33183
33184 FETCH_LONG(adr);
33185 PRE_IO
33186 READ_WORD_F(adr, src)
33187 res = DREGu16((Opcode >> 9) & 7);
33188 res &= src;
33189 flag_C = 0;
33190 flag_V = 0;
33191 flag_NotZ = res;
33192 flag_N = res >> 8;
33193 DREGu16((Opcode >> 9) & 7) = res;
33194 POST_IO
33195RET(16)
33196}
33197
33198// ANDaD
33199OPCODE(0xC07A)
33200{
33201 u32 adr, res;
33202 u32 src, dst;
33203
be26eb23 33204 adr = GET_SWORD + GET_PC;
70357ce5 33205 PC++;
33206 PRE_IO
33207 READ_WORD_F(adr, src)
33208 res = DREGu16((Opcode >> 9) & 7);
33209 res &= src;
33210 flag_C = 0;
33211 flag_V = 0;
33212 flag_NotZ = res;
33213 flag_N = res >> 8;
33214 DREGu16((Opcode >> 9) & 7) = res;
33215 POST_IO
33216RET(12)
33217}
33218
33219// ANDaD
33220OPCODE(0xC07B)
33221{
33222 u32 adr, res;
33223 u32 src, dst;
33224
be26eb23 33225 adr = GET_PC;
70357ce5 33226 DECODE_EXT_WORD
33227 PRE_IO
33228 READ_WORD_F(adr, src)
33229 res = DREGu16((Opcode >> 9) & 7);
33230 res &= src;
33231 flag_C = 0;
33232 flag_V = 0;
33233 flag_NotZ = res;
33234 flag_N = res >> 8;
33235 DREGu16((Opcode >> 9) & 7) = res;
33236 POST_IO
33237RET(14)
33238}
33239
33240// ANDaD
33241OPCODE(0xC07C)
33242{
33243 u32 adr, res;
33244 u32 src, dst;
33245
33246 FETCH_WORD(src);
33247 res = DREGu16((Opcode >> 9) & 7);
33248 res &= src;
33249 flag_C = 0;
33250 flag_V = 0;
33251 flag_NotZ = res;
33252 flag_N = res >> 8;
33253 DREGu16((Opcode >> 9) & 7) = res;
33254RET(8)
33255}
33256
33257// ANDaD
33258OPCODE(0xC05F)
33259{
33260 u32 adr, res;
33261 u32 src, dst;
33262
33263 adr = AREG(7);
33264 AREG(7) += 2;
33265 PRE_IO
33266 READ_WORD_F(adr, src)
33267 res = DREGu16((Opcode >> 9) & 7);
33268 res &= src;
33269 flag_C = 0;
33270 flag_V = 0;
33271 flag_NotZ = res;
33272 flag_N = res >> 8;
33273 DREGu16((Opcode >> 9) & 7) = res;
33274 POST_IO
33275RET(8)
33276}
33277
33278// ANDaD
33279OPCODE(0xC067)
33280{
33281 u32 adr, res;
33282 u32 src, dst;
33283
33284 adr = AREG(7) - 2;
33285 AREG(7) = adr;
33286 PRE_IO
33287 READ_WORD_F(adr, src)
33288 res = DREGu16((Opcode >> 9) & 7);
33289 res &= src;
33290 flag_C = 0;
33291 flag_V = 0;
33292 flag_NotZ = res;
33293 flag_N = res >> 8;
33294 DREGu16((Opcode >> 9) & 7) = res;
33295 POST_IO
33296RET(10)
33297}
33298
33299// ANDaD
33300OPCODE(0xC080)
33301{
33302 u32 adr, res;
33303 u32 src, dst;
33304
33305 src = DREGu32((Opcode >> 0) & 7);
33306 res = DREGu32((Opcode >> 9) & 7);
33307 res &= src;
33308 flag_C = 0;
33309 flag_V = 0;
33310 flag_NotZ = res;
33311 flag_N = res >> 24;
33312 DREGu32((Opcode >> 9) & 7) = res;
33313RET(8)
33314}
33315
33316// ANDaD
33317OPCODE(0xC090)
33318{
33319 u32 adr, res;
33320 u32 src, dst;
33321
33322 adr = AREG((Opcode >> 0) & 7);
33323 PRE_IO
33324 READ_LONG_F(adr, src)
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;
33332 POST_IO
33333RET(14)
33334}
33335
33336// ANDaD
33337OPCODE(0xC098)
33338{
33339 u32 adr, res;
33340 u32 src, dst;
33341
33342 adr = AREG((Opcode >> 0) & 7);
33343 AREG((Opcode >> 0) & 7) += 4;
33344 PRE_IO
33345 READ_LONG_F(adr, src)
33346 res = DREGu32((Opcode >> 9) & 7);
33347 res &= src;
33348 flag_C = 0;
33349 flag_V = 0;
33350 flag_NotZ = res;
33351 flag_N = res >> 24;
33352 DREGu32((Opcode >> 9) & 7) = res;
33353 POST_IO
33354RET(14)
33355}
33356
33357// ANDaD
33358OPCODE(0xC0A0)
33359{
33360 u32 adr, res;
33361 u32 src, dst;
33362
33363 adr = AREG((Opcode >> 0) & 7) - 4;
33364 AREG((Opcode >> 0) & 7) = adr;
33365 PRE_IO
33366 READ_LONG_F(adr, src)
33367 res = DREGu32((Opcode >> 9) & 7);
33368 res &= src;
33369 flag_C = 0;
33370 flag_V = 0;
33371 flag_NotZ = res;
33372 flag_N = res >> 24;
33373 DREGu32((Opcode >> 9) & 7) = res;
33374 POST_IO
33375RET(16)
33376}
33377
33378// ANDaD
33379OPCODE(0xC0A8)
33380{
33381 u32 adr, res;
33382 u32 src, dst;
33383
33384 FETCH_SWORD(adr);
33385 adr += AREG((Opcode >> 0) & 7);
33386 PRE_IO
33387 READ_LONG_F(adr, src)
33388 res = DREGu32((Opcode >> 9) & 7);
33389 res &= src;
33390 flag_C = 0;
33391 flag_V = 0;
33392 flag_NotZ = res;
33393 flag_N = res >> 24;
33394 DREGu32((Opcode >> 9) & 7) = res;
33395 POST_IO
33396RET(18)
33397}
33398
33399// ANDaD
33400OPCODE(0xC0B0)
33401{
33402 u32 adr, res;
33403 u32 src, dst;
33404
33405 adr = AREG((Opcode >> 0) & 7);
33406 DECODE_EXT_WORD
33407 PRE_IO
33408 READ_LONG_F(adr, src)
33409 res = DREGu32((Opcode >> 9) & 7);
33410 res &= src;
33411 flag_C = 0;
33412 flag_V = 0;
33413 flag_NotZ = res;
33414 flag_N = res >> 24;
33415 DREGu32((Opcode >> 9) & 7) = res;
33416 POST_IO
33417RET(20)
33418}
33419
33420// ANDaD
33421OPCODE(0xC0B8)
33422{
33423 u32 adr, res;
33424 u32 src, dst;
33425
33426 FETCH_SWORD(adr);
33427 PRE_IO
33428 READ_LONG_F(adr, src)
33429 res = DREGu32((Opcode >> 9) & 7);
33430 res &= src;
33431 flag_C = 0;
33432 flag_V = 0;
33433 flag_NotZ = res;
33434 flag_N = res >> 24;
33435 DREGu32((Opcode >> 9) & 7) = res;
33436 POST_IO
33437RET(18)
33438}
33439
33440// ANDaD
33441OPCODE(0xC0B9)
33442{
33443 u32 adr, res;
33444 u32 src, dst;
33445
33446 FETCH_LONG(adr);
33447 PRE_IO
33448 READ_LONG_F(adr, src)
33449 res = DREGu32((Opcode >> 9) & 7);
33450 res &= src;
33451 flag_C = 0;
33452 flag_V = 0;
33453 flag_NotZ = res;
33454 flag_N = res >> 24;
33455 DREGu32((Opcode >> 9) & 7) = res;
33456 POST_IO
33457RET(22)
33458}
33459
33460// ANDaD
33461OPCODE(0xC0BA)
33462{
33463 u32 adr, res;
33464 u32 src, dst;
33465
be26eb23 33466 adr = GET_SWORD + GET_PC;
70357ce5 33467 PC++;
33468 PRE_IO
33469 READ_LONG_F(adr, src)
33470 res = DREGu32((Opcode >> 9) & 7);
33471 res &= src;
33472 flag_C = 0;
33473 flag_V = 0;
33474 flag_NotZ = res;
33475 flag_N = res >> 24;
33476 DREGu32((Opcode >> 9) & 7) = res;
33477 POST_IO
33478RET(18)
33479}
33480
33481// ANDaD
33482OPCODE(0xC0BB)
33483{
33484 u32 adr, res;
33485 u32 src, dst;
33486
be26eb23 33487 adr = GET_PC;
70357ce5 33488 DECODE_EXT_WORD
33489 PRE_IO
33490 READ_LONG_F(adr, src)
33491 res = DREGu32((Opcode >> 9) & 7);
33492 res &= src;
33493 flag_C = 0;
33494 flag_V = 0;
33495 flag_NotZ = res;
33496 flag_N = res >> 24;
33497 DREGu32((Opcode >> 9) & 7) = res;
33498 POST_IO
33499RET(20)
33500}
33501
33502// ANDaD
33503OPCODE(0xC0BC)
33504{
33505 u32 adr, res;
33506 u32 src, dst;
33507
33508 FETCH_LONG(src);
33509 res = DREGu32((Opcode >> 9) & 7);
33510 res &= src;
33511 flag_C = 0;
33512 flag_V = 0;
33513 flag_NotZ = res;
33514 flag_N = res >> 24;
33515 DREGu32((Opcode >> 9) & 7) = res;
33516RET(16)
33517}
33518
33519// ANDaD
33520OPCODE(0xC09F)
33521{
33522 u32 adr, res;
33523 u32 src, dst;
33524
33525 adr = AREG(7);
33526 AREG(7) += 4;
33527 PRE_IO
33528 READ_LONG_F(adr, src)
33529 res = DREGu32((Opcode >> 9) & 7);
33530 res &= src;
33531 flag_C = 0;
33532 flag_V = 0;
33533 flag_NotZ = res;
33534 flag_N = res >> 24;
33535 DREGu32((Opcode >> 9) & 7) = res;
33536 POST_IO
33537RET(14)
33538}
33539
33540// ANDaD
33541OPCODE(0xC0A7)
33542{
33543 u32 adr, res;
33544 u32 src, dst;
33545
33546 adr = AREG(7) - 4;
33547 AREG(7) = adr;
33548 PRE_IO
33549 READ_LONG_F(adr, src)
33550 res = DREGu32((Opcode >> 9) & 7);
33551 res &= src;
33552 flag_C = 0;
33553 flag_V = 0;
33554 flag_NotZ = res;
33555 flag_N = res >> 24;
33556 DREGu32((Opcode >> 9) & 7) = res;
33557 POST_IO
33558RET(16)
33559}
33560
33561// ANDDa
33562OPCODE(0xC110)
33563{
33564 u32 adr, res;
33565 u32 src, dst;
33566
33567 src = DREGu8((Opcode >> 9) & 7);
33568 adr = AREG((Opcode >> 0) & 7);
33569 PRE_IO
33570 READ_BYTE_F(adr, res)
33571 res &= src;
33572 flag_C = 0;
33573 flag_V = 0;
33574 flag_NotZ = res;
33575 flag_N = res;
33576 WRITE_BYTE_F(adr, res)
33577 POST_IO
33578RET(12)
33579}
33580
33581// ANDDa
33582OPCODE(0xC118)
33583{
33584 u32 adr, res;
33585 u32 src, dst;
33586
33587 src = DREGu8((Opcode >> 9) & 7);
33588 adr = AREG((Opcode >> 0) & 7);
33589 AREG((Opcode >> 0) & 7) += 1;
33590 PRE_IO
33591 READ_BYTE_F(adr, res)
33592 res &= src;
33593 flag_C = 0;
33594 flag_V = 0;
33595 flag_NotZ = res;
33596 flag_N = res;
33597 WRITE_BYTE_F(adr, res)
33598 POST_IO
33599RET(12)
33600}
33601
33602// ANDDa
33603OPCODE(0xC120)
33604{
33605 u32 adr, res;
33606 u32 src, dst;
33607
33608 src = DREGu8((Opcode >> 9) & 7);
33609 adr = AREG((Opcode >> 0) & 7) - 1;
33610 AREG((Opcode >> 0) & 7) = adr;
33611 PRE_IO
33612 READ_BYTE_F(adr, res)
33613 res &= src;
33614 flag_C = 0;
33615 flag_V = 0;
33616 flag_NotZ = res;
33617 flag_N = res;
33618 WRITE_BYTE_F(adr, res)
33619 POST_IO
33620RET(14)
33621}
33622
33623// ANDDa
33624OPCODE(0xC128)
33625{
33626 u32 adr, res;
33627 u32 src, dst;
33628
33629 src = DREGu8((Opcode >> 9) & 7);
33630 FETCH_SWORD(adr);
33631 adr += AREG((Opcode >> 0) & 7);
33632 PRE_IO
33633 READ_BYTE_F(adr, res)
33634 res &= src;
33635 flag_C = 0;
33636 flag_V = 0;
33637 flag_NotZ = res;
33638 flag_N = res;
33639 WRITE_BYTE_F(adr, res)
33640 POST_IO
33641RET(16)
33642}
33643
33644// ANDDa
33645OPCODE(0xC130)
33646{
33647 u32 adr, res;
33648 u32 src, dst;
33649
33650 src = DREGu8((Opcode >> 9) & 7);
33651 adr = AREG((Opcode >> 0) & 7);
33652 DECODE_EXT_WORD
33653 PRE_IO
33654 READ_BYTE_F(adr, res)
33655 res &= src;
33656 flag_C = 0;
33657 flag_V = 0;
33658 flag_NotZ = res;
33659 flag_N = res;
33660 WRITE_BYTE_F(adr, res)
33661 POST_IO
33662RET(18)
33663}
33664
33665// ANDDa
33666OPCODE(0xC138)
33667{
33668 u32 adr, res;
33669 u32 src, dst;
33670
33671 src = DREGu8((Opcode >> 9) & 7);
33672 FETCH_SWORD(adr);
33673 PRE_IO
33674 READ_BYTE_F(adr, res)
33675 res &= src;
33676 flag_C = 0;
33677 flag_V = 0;
33678 flag_NotZ = res;
33679 flag_N = res;
33680 WRITE_BYTE_F(adr, res)
33681 POST_IO
33682RET(16)
33683}
33684
33685// ANDDa
33686OPCODE(0xC139)
33687{
33688 u32 adr, res;
33689 u32 src, dst;
33690
33691 src = DREGu8((Opcode >> 9) & 7);
33692 FETCH_LONG(adr);
33693 PRE_IO
33694 READ_BYTE_F(adr, res)
33695 res &= src;
33696 flag_C = 0;
33697 flag_V = 0;
33698 flag_NotZ = res;
33699 flag_N = res;
33700 WRITE_BYTE_F(adr, res)
33701 POST_IO
33702RET(20)
33703}
33704
33705// ANDDa
33706OPCODE(0xC11F)
33707{
33708 u32 adr, res;
33709 u32 src, dst;
33710
33711 src = DREGu8((Opcode >> 9) & 7);
33712 adr = AREG(7);
33713 AREG(7) += 2;
33714 PRE_IO
33715 READ_BYTE_F(adr, res)
33716 res &= src;
33717 flag_C = 0;
33718 flag_V = 0;
33719 flag_NotZ = res;
33720 flag_N = res;
33721 WRITE_BYTE_F(adr, res)
33722 POST_IO
33723RET(12)
33724}
33725
33726// ANDDa
33727OPCODE(0xC127)
33728{
33729 u32 adr, res;
33730 u32 src, dst;
33731
33732 src = DREGu8((Opcode >> 9) & 7);
33733 adr = AREG(7) - 2;
33734 AREG(7) = adr;
33735 PRE_IO
33736 READ_BYTE_F(adr, res)
33737 res &= src;
33738 flag_C = 0;
33739 flag_V = 0;
33740 flag_NotZ = res;
33741 flag_N = res;
33742 WRITE_BYTE_F(adr, res)
33743 POST_IO
33744RET(14)
33745}
33746
33747// ANDDa
33748OPCODE(0xC150)
33749{
33750 u32 adr, res;
33751 u32 src, dst;
33752
33753 src = DREGu16((Opcode >> 9) & 7);
33754 adr = AREG((Opcode >> 0) & 7);
33755 PRE_IO
33756 READ_WORD_F(adr, res)
33757 res &= src;
33758 flag_C = 0;
33759 flag_V = 0;
33760 flag_NotZ = res;
33761 flag_N = res >> 8;
33762 WRITE_WORD_F(adr, res)
33763 POST_IO
33764RET(12)
33765}
33766
33767// ANDDa
33768OPCODE(0xC158)
33769{
33770 u32 adr, res;
33771 u32 src, dst;
33772
33773 src = DREGu16((Opcode >> 9) & 7);
33774 adr = AREG((Opcode >> 0) & 7);
33775 AREG((Opcode >> 0) & 7) += 2;
33776 PRE_IO
33777 READ_WORD_F(adr, res)
33778 res &= src;
33779 flag_C = 0;
33780 flag_V = 0;
33781 flag_NotZ = res;
33782 flag_N = res >> 8;
33783 WRITE_WORD_F(adr, res)
33784 POST_IO
33785RET(12)
33786}
33787
33788// ANDDa
33789OPCODE(0xC160)
33790{
33791 u32 adr, res;
33792 u32 src, dst;
33793
33794 src = DREGu16((Opcode >> 9) & 7);
33795 adr = AREG((Opcode >> 0) & 7) - 2;
33796 AREG((Opcode >> 0) & 7) = adr;
33797 PRE_IO
33798 READ_WORD_F(adr, res)
33799 res &= src;
33800 flag_C = 0;
33801 flag_V = 0;
33802 flag_NotZ = res;
33803 flag_N = res >> 8;
33804 WRITE_WORD_F(adr, res)
33805 POST_IO
33806RET(14)
33807}
33808
33809// ANDDa
33810OPCODE(0xC168)
33811{
33812 u32 adr, res;
33813 u32 src, dst;
33814
33815 src = DREGu16((Opcode >> 9) & 7);
33816 FETCH_SWORD(adr);
33817 adr += AREG((Opcode >> 0) & 7);
33818 PRE_IO
33819 READ_WORD_F(adr, res)
33820 res &= src;
33821 flag_C = 0;
33822 flag_V = 0;
33823 flag_NotZ = res;
33824 flag_N = res >> 8;
33825 WRITE_WORD_F(adr, res)
33826 POST_IO
33827RET(16)
33828}
33829
33830// ANDDa
33831OPCODE(0xC170)
33832{
33833 u32 adr, res;
33834 u32 src, dst;
33835
33836 src = DREGu16((Opcode >> 9) & 7);
33837 adr = AREG((Opcode >> 0) & 7);
33838 DECODE_EXT_WORD
33839 PRE_IO
33840 READ_WORD_F(adr, res)
33841 res &= src;
33842 flag_C = 0;
33843 flag_V = 0;
33844 flag_NotZ = res;
33845 flag_N = res >> 8;
33846 WRITE_WORD_F(adr, res)
33847 POST_IO
33848RET(18)
33849}
33850
33851// ANDDa
33852OPCODE(0xC178)
33853{
33854 u32 adr, res;
33855 u32 src, dst;
33856
33857 src = DREGu16((Opcode >> 9) & 7);
33858 FETCH_SWORD(adr);
33859 PRE_IO
33860 READ_WORD_F(adr, res)
33861 res &= src;
33862 flag_C = 0;
33863 flag_V = 0;
33864 flag_NotZ = res;
33865 flag_N = res >> 8;
33866 WRITE_WORD_F(adr, res)
33867 POST_IO
33868RET(16)
33869}
33870
33871// ANDDa
33872OPCODE(0xC179)
33873{
33874 u32 adr, res;
33875 u32 src, dst;
33876
33877 src = DREGu16((Opcode >> 9) & 7);
33878 FETCH_LONG(adr);
33879 PRE_IO
33880 READ_WORD_F(adr, res)
33881 res &= src;
33882 flag_C = 0;
33883 flag_V = 0;
33884 flag_NotZ = res;
33885 flag_N = res >> 8;
33886 WRITE_WORD_F(adr, res)
33887 POST_IO
33888RET(20)
33889}
33890
33891// ANDDa
33892OPCODE(0xC15F)
33893{
33894 u32 adr, res;
33895 u32 src, dst;
33896
33897 src = DREGu16((Opcode >> 9) & 7);
33898 adr = AREG(7);
33899 AREG(7) += 2;
33900 PRE_IO
33901 READ_WORD_F(adr, res)
33902 res &= src;
33903 flag_C = 0;
33904 flag_V = 0;
33905 flag_NotZ = res;
33906 flag_N = res >> 8;
33907 WRITE_WORD_F(adr, res)
33908 POST_IO
33909RET(12)
33910}
33911
33912// ANDDa
33913OPCODE(0xC167)
33914{
33915 u32 adr, res;
33916 u32 src, dst;
33917
33918 src = DREGu16((Opcode >> 9) & 7);
33919 adr = AREG(7) - 2;
33920 AREG(7) = adr;
33921 PRE_IO
33922 READ_WORD_F(adr, res)
33923 res &= src;
33924 flag_C = 0;
33925 flag_V = 0;
33926 flag_NotZ = res;
33927 flag_N = res >> 8;
33928 WRITE_WORD_F(adr, res)
33929 POST_IO
33930RET(14)
33931}
33932
33933// ANDDa
33934OPCODE(0xC190)
33935{
33936 u32 adr, res;
33937 u32 src, dst;
33938
33939 src = DREGu32((Opcode >> 9) & 7);
33940 adr = AREG((Opcode >> 0) & 7);
33941 PRE_IO
33942 READ_LONG_F(adr, res)
33943 res &= src;
33944 flag_C = 0;
33945 flag_V = 0;
33946 flag_NotZ = res;
33947 flag_N = res >> 24;
33948 WRITE_LONG_F(adr, res)
33949 POST_IO
33950RET(20)
33951}
33952
33953// ANDDa
33954OPCODE(0xC198)
33955{
33956 u32 adr, res;
33957 u32 src, dst;
33958
33959 src = DREGu32((Opcode >> 9) & 7);
33960 adr = AREG((Opcode >> 0) & 7);
33961 AREG((Opcode >> 0) & 7) += 4;
33962 PRE_IO
33963 READ_LONG_F(adr, res)
33964 res &= src;
33965 flag_C = 0;
33966 flag_V = 0;
33967 flag_NotZ = res;
33968 flag_N = res >> 24;
33969 WRITE_LONG_F(adr, res)
33970 POST_IO
33971RET(20)
33972}
33973
33974// ANDDa
33975OPCODE(0xC1A0)
33976{
33977 u32 adr, res;
33978 u32 src, dst;
33979
33980 src = DREGu32((Opcode >> 9) & 7);
33981 adr = AREG((Opcode >> 0) & 7) - 4;
33982 AREG((Opcode >> 0) & 7) = adr;
33983 PRE_IO
33984 READ_LONG_F(adr, res)
33985 res &= src;
33986 flag_C = 0;
33987 flag_V = 0;
33988 flag_NotZ = res;
33989 flag_N = res >> 24;
33990 WRITE_LONG_F(adr, res)
33991 POST_IO
33992RET(22)
33993}
33994
33995// ANDDa
33996OPCODE(0xC1A8)
33997{
33998 u32 adr, res;
33999 u32 src, dst;
34000
34001 src = DREGu32((Opcode >> 9) & 7);
34002 FETCH_SWORD(adr);
34003 adr += AREG((Opcode >> 0) & 7);
34004 PRE_IO
34005 READ_LONG_F(adr, res)
34006 res &= src;
34007 flag_C = 0;
34008 flag_V = 0;
34009 flag_NotZ = res;
34010 flag_N = res >> 24;
34011 WRITE_LONG_F(adr, res)
34012 POST_IO
34013RET(24)
34014}
34015
34016// ANDDa
34017OPCODE(0xC1B0)
34018{
34019 u32 adr, res;
34020 u32 src, dst;
34021
34022 src = DREGu32((Opcode >> 9) & 7);
34023 adr = AREG((Opcode >> 0) & 7);
34024 DECODE_EXT_WORD
34025 PRE_IO
34026 READ_LONG_F(adr, res)
34027 res &= src;
34028 flag_C = 0;
34029 flag_V = 0;
34030 flag_NotZ = res;
34031 flag_N = res >> 24;
34032 WRITE_LONG_F(adr, res)
34033 POST_IO
34034RET(26)
34035}
34036
34037// ANDDa
34038OPCODE(0xC1B8)
34039{
34040 u32 adr, res;
34041 u32 src, dst;
34042
34043 src = DREGu32((Opcode >> 9) & 7);
34044 FETCH_SWORD(adr);
34045 PRE_IO
34046 READ_LONG_F(adr, res)
34047 res &= src;
34048 flag_C = 0;
34049 flag_V = 0;
34050 flag_NotZ = res;
34051 flag_N = res >> 24;
34052 WRITE_LONG_F(adr, res)
34053 POST_IO
34054RET(24)
34055}
34056
34057// ANDDa
34058OPCODE(0xC1B9)
34059{
34060 u32 adr, res;
34061 u32 src, dst;
34062
34063 src = DREGu32((Opcode >> 9) & 7);
34064 FETCH_LONG(adr);
34065 PRE_IO
34066 READ_LONG_F(adr, res)
34067 res &= src;
34068 flag_C = 0;
34069 flag_V = 0;
34070 flag_NotZ = res;
34071 flag_N = res >> 24;
34072 WRITE_LONG_F(adr, res)
34073 POST_IO
34074RET(28)
34075}
34076
34077// ANDDa
34078OPCODE(0xC19F)
34079{
34080 u32 adr, res;
34081 u32 src, dst;
34082
34083 src = DREGu32((Opcode >> 9) & 7);
34084 adr = AREG(7);
34085 AREG(7) += 4;
34086 PRE_IO
34087 READ_LONG_F(adr, res)
34088 res &= src;
34089 flag_C = 0;
34090 flag_V = 0;
34091 flag_NotZ = res;
34092 flag_N = res >> 24;
34093 WRITE_LONG_F(adr, res)
34094 POST_IO
34095RET(20)
34096}
34097
34098// ANDDa
34099OPCODE(0xC1A7)
34100{
34101 u32 adr, res;
34102 u32 src, dst;
34103
34104 src = DREGu32((Opcode >> 9) & 7);
34105 adr = AREG(7) - 4;
34106 AREG(7) = adr;
34107 PRE_IO
34108 READ_LONG_F(adr, res)
34109 res &= src;
34110 flag_C = 0;
34111 flag_V = 0;
34112 flag_NotZ = res;
34113 flag_N = res >> 24;
34114 WRITE_LONG_F(adr, res)
34115 POST_IO
34116RET(22)
34117}
34118
34119// ABCD
34120OPCODE(0xC100)
34121{
34122 u32 adr, res;
34123 u32 src, dst;
34124
34125 src = DREGu8((Opcode >> 0) & 7);
34126 dst = DREGu8((Opcode >> 9) & 7);
34127 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34128 if (res > 9) res += 6;
34129 res += (dst & 0xF0) + (src & 0xF0);
34130 if (res > 0x99)
34131 {
34132 res -= 0xA0;
34133 flag_X = flag_C = M68K_SR_C;
34134 }
34135 else flag_X = flag_C = 0;
34136 flag_NotZ |= res & 0xFF;
34137 flag_N = res;
34138 DREGu8((Opcode >> 9) & 7) = res;
34139RET(6)
34140}
34141
34142// ABCDM
34143OPCODE(0xC108)
34144{
34145 u32 adr, res;
34146 u32 src, dst;
34147
34148 adr = AREG((Opcode >> 0) & 7) - 1;
34149 AREG((Opcode >> 0) & 7) = adr;
34150 PRE_IO
34151 READ_BYTE_F(adr, src)
34152 adr = AREG((Opcode >> 9) & 7) - 1;
34153 AREG((Opcode >> 9) & 7) = adr;
34154 READ_BYTE_F(adr, dst)
34155 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34156 if (res > 9) res += 6;
34157 res += (dst & 0xF0) + (src & 0xF0);
34158 if (res > 0x99)
34159 {
34160 res -= 0xA0;
34161 flag_X = flag_C = M68K_SR_C;
34162 }
34163 else flag_X = flag_C = 0;
34164 flag_NotZ |= res & 0xFF;
34165 flag_N = res;
34166 WRITE_BYTE_F(adr, res)
34167 POST_IO
34168RET(18)
34169}
34170
34171// ABCD7M
34172OPCODE(0xC10F)
34173{
34174 u32 adr, res;
34175 u32 src, dst;
34176
34177 adr = AREG(7) - 2;
34178 AREG(7) = adr;
34179 PRE_IO
34180 READ_BYTE_F(adr, src)
34181 adr = AREG((Opcode >> 9) & 7) - 1;
34182 AREG((Opcode >> 9) & 7) = adr;
34183 READ_BYTE_F(adr, dst)
34184 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34185 if (res > 9) res += 6;
34186 res += (dst & 0xF0) + (src & 0xF0);
34187 if (res > 0x99)
34188 {
34189 res -= 0xA0;
34190 flag_X = flag_C = M68K_SR_C;
34191 }
34192 else flag_X = flag_C = 0;
34193 flag_NotZ |= res & 0xFF;
34194 flag_N = res;
34195 WRITE_BYTE_F(adr, res)
34196 POST_IO
34197RET(18)
34198}
34199
34200// ABCDM7
34201OPCODE(0xCF08)
34202{
34203 u32 adr, res;
34204 u32 src, dst;
34205
34206 adr = AREG((Opcode >> 0) & 7) - 1;
34207 AREG((Opcode >> 0) & 7) = adr;
34208 PRE_IO
34209 READ_BYTE_F(adr, src)
34210 adr = AREG(7) - 2;
34211 AREG(7) = adr;
34212 READ_BYTE_F(adr, dst)
34213 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34214 if (res > 9) res += 6;
34215 res += (dst & 0xF0) + (src & 0xF0);
34216 if (res > 0x99)
34217 {
34218 res -= 0xA0;
34219 flag_X = flag_C = M68K_SR_C;
34220 }
34221 else flag_X = flag_C = 0;
34222 flag_NotZ |= res & 0xFF;
34223 flag_N = res;
34224 WRITE_BYTE_F(adr, res)
34225 POST_IO
34226RET(18)
34227}
34228
34229// ABCD7M7
34230OPCODE(0xCF0F)
34231{
34232 u32 adr, res;
34233 u32 src, dst;
34234
34235 adr = AREG(7) - 2;
34236 AREG(7) = adr;
34237 PRE_IO
34238 READ_BYTE_F(adr, src)
34239 adr = AREG(7) - 2;
34240 AREG(7) = adr;
34241 READ_BYTE_F(adr, dst)
34242 res = (dst & 0xF) + (src & 0xF) + ((flag_X >> M68K_SR_X_SFT) & 1);
34243 if (res > 9) res += 6;
34244 res += (dst & 0xF0) + (src & 0xF0);
34245 if (res > 0x99)
34246 {
34247 res -= 0xA0;
34248 flag_X = flag_C = M68K_SR_C;
34249 }
34250 else flag_X = flag_C = 0;
34251 flag_NotZ |= res & 0xFF;
34252 flag_N = res;
34253 WRITE_BYTE_F(adr, res)
34254 POST_IO
34255RET(18)
34256}
34257
34258// MULU
34259OPCODE(0xC0C0)
34260{
34261 u32 adr, res;
34262 u32 src, dst;
34263
34264 src = DREGu16((Opcode >> 0) & 7);
34265 res = DREGu16((Opcode >> 9) & 7);
34266 res *= src;
34267 flag_N = res >> 24;
34268 flag_NotZ = res;
34269 flag_V = flag_C = 0;
34270 DREGu32((Opcode >> 9) & 7) = res;
34271#ifdef USE_CYCLONE_TIMING
34272RET(54)
34273#else
34274RET(50)
34275#endif
34276}
34277
34278// MULU
34279OPCODE(0xC0D0)
34280{
34281 u32 adr, res;
34282 u32 src, dst;
34283
34284 adr = AREG((Opcode >> 0) & 7);
34285 PRE_IO
34286 READ_WORD_F(adr, src)
34287 res = DREGu16((Opcode >> 9) & 7);
34288 res *= src;
34289 flag_N = res >> 24;
34290 flag_NotZ = res;
34291 flag_V = flag_C = 0;
34292 DREGu32((Opcode >> 9) & 7) = res;
34293 POST_IO
34294#ifdef USE_CYCLONE_TIMING
34295RET(58)
34296#else
34297RET(54)
34298#endif
34299}
34300
34301// MULU
34302OPCODE(0xC0D8)
34303{
34304 u32 adr, res;
34305 u32 src, dst;
34306
34307 adr = AREG((Opcode >> 0) & 7);
34308 AREG((Opcode >> 0) & 7) += 2;
34309 PRE_IO
34310 READ_WORD_F(adr, src)
34311 res = DREGu16((Opcode >> 9) & 7);
34312 res *= src;
34313 flag_N = res >> 24;
34314 flag_NotZ = res;
34315 flag_V = flag_C = 0;
34316 DREGu32((Opcode >> 9) & 7) = res;
34317 POST_IO
34318#ifdef USE_CYCLONE_TIMING
34319RET(58)
34320#else
34321RET(54)
34322#endif
34323}
34324
34325// MULU
34326OPCODE(0xC0E0)
34327{
34328 u32 adr, res;
34329 u32 src, dst;
34330
34331 adr = AREG((Opcode >> 0) & 7) - 2;
34332 AREG((Opcode >> 0) & 7) = adr;
34333 PRE_IO
34334 READ_WORD_F(adr, src)
34335 res = DREGu16((Opcode >> 9) & 7);
34336 res *= src;
34337 flag_N = res >> 24;
34338 flag_NotZ = res;
34339 flag_V = flag_C = 0;
34340 DREGu32((Opcode >> 9) & 7) = res;
34341 POST_IO
34342#ifdef USE_CYCLONE_TIMING
34343RET(60)
34344#else
34345RET(56)
34346#endif
34347}
34348
34349// MULU
34350OPCODE(0xC0E8)
34351{
34352 u32 adr, res;
34353 u32 src, dst;
34354
34355 FETCH_SWORD(adr);
34356 adr += AREG((Opcode >> 0) & 7);
34357 PRE_IO
34358 READ_WORD_F(adr, src)
34359 res = DREGu16((Opcode >> 9) & 7);
34360 res *= src;
34361 flag_N = res >> 24;
34362 flag_NotZ = res;
34363 flag_V = flag_C = 0;
34364 DREGu32((Opcode >> 9) & 7) = res;
34365 POST_IO
34366#ifdef USE_CYCLONE_TIMING
34367RET(62)
34368#else
34369RET(58)
34370#endif
34371}
34372
34373// MULU
34374OPCODE(0xC0F0)
34375{
34376 u32 adr, res;
34377 u32 src, dst;
34378
34379 adr = AREG((Opcode >> 0) & 7);
34380 DECODE_EXT_WORD
34381 PRE_IO
34382 READ_WORD_F(adr, src)
34383 res = DREGu16((Opcode >> 9) & 7);
34384 res *= src;
34385 flag_N = res >> 24;
34386 flag_NotZ = res;
34387 flag_V = flag_C = 0;
34388 DREGu32((Opcode >> 9) & 7) = res;
34389 POST_IO
34390#ifdef USE_CYCLONE_TIMING
34391RET(64)
34392#else
34393RET(60)
34394#endif
34395}
34396
34397// MULU
34398OPCODE(0xC0F8)
34399{
34400 u32 adr, res;
34401 u32 src, dst;
34402
34403 FETCH_SWORD(adr);
34404 PRE_IO
34405 READ_WORD_F(adr, src)
34406 res = DREGu16((Opcode >> 9) & 7);
34407 res *= src;
34408 flag_N = res >> 24;
34409 flag_NotZ = res;
34410 flag_V = flag_C = 0;
34411 DREGu32((Opcode >> 9) & 7) = res;
34412 POST_IO
34413#ifdef USE_CYCLONE_TIMING
34414RET(62)
34415#else
34416RET(58)
34417#endif
34418}
34419
34420// MULU
34421OPCODE(0xC0F9)
34422{
34423 u32 adr, res;
34424 u32 src, dst;
34425
34426 FETCH_LONG(adr);
34427 PRE_IO
34428 READ_WORD_F(adr, src)
34429 res = DREGu16((Opcode >> 9) & 7);
34430 res *= src;
34431 flag_N = res >> 24;
34432 flag_NotZ = res;
34433 flag_V = flag_C = 0;
34434 DREGu32((Opcode >> 9) & 7) = res;
34435 POST_IO
34436#ifdef USE_CYCLONE_TIMING
34437RET(66)
34438#else
34439RET(62)
34440#endif
34441}
34442
34443// MULU
34444OPCODE(0xC0FA)
34445{
34446 u32 adr, res;
34447 u32 src, dst;
34448
be26eb23 34449 adr = GET_SWORD + GET_PC;
70357ce5 34450 PC++;
34451 PRE_IO
34452 READ_WORD_F(adr, src)
34453 res = DREGu16((Opcode >> 9) & 7);
34454 res *= src;
34455 flag_N = res >> 24;
34456 flag_NotZ = res;
34457 flag_V = flag_C = 0;
34458 DREGu32((Opcode >> 9) & 7) = res;
34459 POST_IO
34460#ifdef USE_CYCLONE_TIMING
34461RET(62)
34462#else
34463RET(58)
34464#endif
34465}
34466
34467// MULU
34468OPCODE(0xC0FB)
34469{
34470 u32 adr, res;
34471 u32 src, dst;
34472
be26eb23 34473 adr = GET_PC;
70357ce5 34474 DECODE_EXT_WORD
34475 PRE_IO
34476 READ_WORD_F(adr, src)
34477 res = DREGu16((Opcode >> 9) & 7);
34478 res *= src;
34479 flag_N = res >> 24;
34480 flag_NotZ = res;
34481 flag_V = flag_C = 0;
34482 DREGu32((Opcode >> 9) & 7) = res;
34483 POST_IO
34484#ifdef USE_CYCLONE_TIMING
34485RET(64)
34486#else
34487RET(60)
34488#endif
34489}
34490
34491// MULU
34492OPCODE(0xC0FC)
34493{
34494 u32 adr, res;
34495 u32 src, dst;
34496
34497 FETCH_WORD(src);
34498 res = DREGu16((Opcode >> 9) & 7);
34499 res *= src;
34500 flag_N = res >> 24;
34501 flag_NotZ = res;
34502 flag_V = flag_C = 0;
34503 DREGu32((Opcode >> 9) & 7) = res;
34504#ifdef USE_CYCLONE_TIMING
34505RET(58)
34506#else
34507RET(54)
34508#endif
34509}
34510
34511// MULU
34512OPCODE(0xC0DF)
34513{
34514 u32 adr, res;
34515 u32 src, dst;
34516
34517 adr = AREG(7);
34518 AREG(7) += 2;
34519 PRE_IO
34520 READ_WORD_F(adr, src)
34521 res = DREGu16((Opcode >> 9) & 7);
34522 res *= src;
34523 flag_N = res >> 24;
34524 flag_NotZ = res;
34525 flag_V = flag_C = 0;
34526 DREGu32((Opcode >> 9) & 7) = res;
34527 POST_IO
34528#ifdef USE_CYCLONE_TIMING
34529RET(58)
34530#else
34531RET(54)
34532#endif
34533}
34534
34535// MULU
34536OPCODE(0xC0E7)
34537{
34538 u32 adr, res;
34539 u32 src, dst;
34540
34541 adr = AREG(7) - 2;
34542 AREG(7) = adr;
34543 PRE_IO
34544 READ_WORD_F(adr, src)
34545 res = DREGu16((Opcode >> 9) & 7);
34546 res *= src;
34547 flag_N = res >> 24;
34548 flag_NotZ = res;
34549 flag_V = flag_C = 0;
34550 DREGu32((Opcode >> 9) & 7) = res;
34551 POST_IO
34552#ifdef USE_CYCLONE_TIMING
34553RET(60)
34554#else
34555RET(56)
34556#endif
34557}
34558
34559// MULS
34560OPCODE(0xC1C0)
34561{
34562 u32 adr, res;
34563 u32 src, dst;
34564
34565 src = (s32)DREGs16((Opcode >> 0) & 7);
34566 res = (s32)DREGs16((Opcode >> 9) & 7);
34567 res = ((s32)res) * ((s32)src);
34568 flag_N = res >> 24;
34569 flag_NotZ = res;
34570 flag_V = flag_C = 0;
34571 DREGu32((Opcode >> 9) & 7) = res;
34572#ifdef USE_CYCLONE_TIMING
34573RET(54)
34574#else
34575RET(50)
34576#endif
34577}
34578
34579// MULS
34580OPCODE(0xC1D0)
34581{
34582 u32 adr, res;
34583 u32 src, dst;
34584
34585 adr = AREG((Opcode >> 0) & 7);
34586 PRE_IO
34587 READSX_WORD_F(adr, src)
34588 res = (s32)DREGs16((Opcode >> 9) & 7);
34589 res = ((s32)res) * ((s32)src);
34590 flag_N = res >> 24;
34591 flag_NotZ = res;
34592 flag_V = flag_C = 0;
34593 DREGu32((Opcode >> 9) & 7) = res;
34594 POST_IO
34595#ifdef USE_CYCLONE_TIMING
34596RET(58)
34597#else
34598RET(54)
34599#endif
34600}
34601
34602// MULS
34603OPCODE(0xC1D8)
34604{
34605 u32 adr, res;
34606 u32 src, dst;
34607
34608 adr = AREG((Opcode >> 0) & 7);
34609 AREG((Opcode >> 0) & 7) += 2;
34610 PRE_IO
34611 READSX_WORD_F(adr, src)
34612 res = (s32)DREGs16((Opcode >> 9) & 7);
34613 res = ((s32)res) * ((s32)src);
34614 flag_N = res >> 24;
34615 flag_NotZ = res;
34616 flag_V = flag_C = 0;
34617 DREGu32((Opcode >> 9) & 7) = res;
34618 POST_IO
34619#ifdef USE_CYCLONE_TIMING
34620RET(58)
34621#else
34622RET(54)
34623#endif
34624}
34625
34626// MULS
34627OPCODE(0xC1E0)
34628{
34629 u32 adr, res;
34630 u32 src, dst;
34631
34632 adr = AREG((Opcode >> 0) & 7) - 2;
34633 AREG((Opcode >> 0) & 7) = adr;
34634 PRE_IO
34635 READSX_WORD_F(adr, src)
34636 res = (s32)DREGs16((Opcode >> 9) & 7);
34637 res = ((s32)res) * ((s32)src);
34638 flag_N = res >> 24;
34639 flag_NotZ = res;
34640 flag_V = flag_C = 0;
34641 DREGu32((Opcode >> 9) & 7) = res;
34642 POST_IO
34643#ifdef USE_CYCLONE_TIMING
34644RET(60)
34645#else
34646RET(56)
34647#endif
34648}
34649
34650// MULS
34651OPCODE(0xC1E8)
34652{
34653 u32 adr, res;
34654 u32 src, dst;
34655
34656 FETCH_SWORD(adr);
34657 adr += AREG((Opcode >> 0) & 7);
34658 PRE_IO
34659 READSX_WORD_F(adr, src)
34660 res = (s32)DREGs16((Opcode >> 9) & 7);
34661 res = ((s32)res) * ((s32)src);
34662 flag_N = res >> 24;
34663 flag_NotZ = res;
34664 flag_V = flag_C = 0;
34665 DREGu32((Opcode >> 9) & 7) = res;
34666 POST_IO
34667#ifdef USE_CYCLONE_TIMING
34668RET(62)
34669#else
34670RET(58)
34671#endif
34672}
34673
34674// MULS
34675OPCODE(0xC1F0)
34676{
34677 u32 adr, res;
34678 u32 src, dst;
34679
34680 adr = AREG((Opcode >> 0) & 7);
34681 DECODE_EXT_WORD
34682 PRE_IO
34683 READSX_WORD_F(adr, src)
34684 res = (s32)DREGs16((Opcode >> 9) & 7);
34685 res = ((s32)res) * ((s32)src);
34686 flag_N = res >> 24;
34687 flag_NotZ = res;
34688 flag_V = flag_C = 0;
34689 DREGu32((Opcode >> 9) & 7) = res;
34690 POST_IO
34691#ifdef USE_CYCLONE_TIMING
34692RET(64)
34693#else
34694RET(60)
34695#endif
34696}
34697
34698// MULS
34699OPCODE(0xC1F8)
34700{
34701 u32 adr, res;
34702 u32 src, dst;
34703
34704 FETCH_SWORD(adr);
34705 PRE_IO
34706 READSX_WORD_F(adr, src)
34707 res = (s32)DREGs16((Opcode >> 9) & 7);
34708 res = ((s32)res) * ((s32)src);
34709 flag_N = res >> 24;
34710 flag_NotZ = res;
34711 flag_V = flag_C = 0;
34712 DREGu32((Opcode >> 9) & 7) = res;
34713 POST_IO
34714#ifdef USE_CYCLONE_TIMING
34715RET(62)
34716#else
34717RET(58)
34718#endif
34719}
34720
34721// MULS
34722OPCODE(0xC1F9)
34723{
34724 u32 adr, res;
34725 u32 src, dst;
34726
34727 FETCH_LONG(adr);
34728 PRE_IO
34729 READSX_WORD_F(adr, src)
34730 res = (s32)DREGs16((Opcode >> 9) & 7);
34731 res = ((s32)res) * ((s32)src);
34732 flag_N = res >> 24;
34733 flag_NotZ = res;
34734 flag_V = flag_C = 0;
34735 DREGu32((Opcode >> 9) & 7) = res;
34736 POST_IO
34737#ifdef USE_CYCLONE_TIMING
34738RET(66)
34739#else
34740RET(62)
34741#endif
34742}
34743
34744// MULS
34745OPCODE(0xC1FA)
34746{
34747 u32 adr, res;
34748 u32 src, dst;
34749
be26eb23 34750 adr = GET_SWORD + GET_PC;
70357ce5 34751 PC++;
34752 PRE_IO
34753 READSX_WORD_F(adr, src)
34754 res = (s32)DREGs16((Opcode >> 9) & 7);
34755 res = ((s32)res) * ((s32)src);
34756 flag_N = res >> 24;
34757 flag_NotZ = res;
34758 flag_V = flag_C = 0;
34759 DREGu32((Opcode >> 9) & 7) = res;
34760 POST_IO
34761#ifdef USE_CYCLONE_TIMING
34762RET(62)
34763#else
34764RET(58)
34765#endif
34766}
34767
34768// MULS
34769OPCODE(0xC1FB)
34770{
34771 u32 adr, res;
34772 u32 src, dst;
34773
be26eb23 34774 adr = GET_PC;
70357ce5 34775 DECODE_EXT_WORD
34776 PRE_IO
34777 READSX_WORD_F(adr, src)
34778 res = (s32)DREGs16((Opcode >> 9) & 7);
34779 res = ((s32)res) * ((s32)src);
34780 flag_N = res >> 24;
34781 flag_NotZ = res;
34782 flag_V = flag_C = 0;
34783 DREGu32((Opcode >> 9) & 7) = res;
34784 POST_IO
34785#ifdef USE_CYCLONE_TIMING
34786RET(64)
34787#else
34788RET(60)
34789#endif
34790}
34791
34792// MULS
34793OPCODE(0xC1FC)
34794{
34795 u32 adr, res;
34796 u32 src, dst;
34797
34798 FETCH_SWORD(src);
34799 res = (s32)DREGs16((Opcode >> 9) & 7);
34800 res = ((s32)res) * ((s32)src);
34801 flag_N = res >> 24;
34802 flag_NotZ = res;
34803 flag_V = flag_C = 0;
34804 DREGu32((Opcode >> 9) & 7) = res;
34805#ifdef USE_CYCLONE_TIMING
34806RET(58)
34807#else
34808RET(54)
34809#endif
34810}
34811
34812// MULS
34813OPCODE(0xC1DF)
34814{
34815 u32 adr, res;
34816 u32 src, dst;
34817
34818 adr = AREG(7);
34819 AREG(7) += 2;
34820 PRE_IO
34821 READSX_WORD_F(adr, src)
34822 res = (s32)DREGs16((Opcode >> 9) & 7);
34823 res = ((s32)res) * ((s32)src);
34824 flag_N = res >> 24;
34825 flag_NotZ = res;
34826 flag_V = flag_C = 0;
34827 DREGu32((Opcode >> 9) & 7) = res;
34828 POST_IO
34829#ifdef USE_CYCLONE_TIMING
34830RET(58)
34831#else
34832RET(54)
34833#endif
34834}
34835
34836// MULS
34837OPCODE(0xC1E7)
34838{
34839 u32 adr, res;
34840 u32 src, dst;
34841
34842 adr = AREG(7) - 2;
34843 AREG(7) = adr;
34844 PRE_IO
34845 READSX_WORD_F(adr, src)
34846 res = (s32)DREGs16((Opcode >> 9) & 7);
34847 res = ((s32)res) * ((s32)src);
34848 flag_N = res >> 24;
34849 flag_NotZ = res;
34850 flag_V = flag_C = 0;
34851 DREGu32((Opcode >> 9) & 7) = res;
34852 POST_IO
34853#ifdef USE_CYCLONE_TIMING
34854RET(60)
34855#else
34856RET(56)
34857#endif
34858}
34859
34860// EXGDD
34861OPCODE(0xC140)
34862{
34863 u32 adr, res;
34864 u32 src, dst;
34865
34866 res = DREGu32((Opcode >> 0) & 7);
34867 src = DREGu32((Opcode >> 9) & 7);
34868 DREGu32((Opcode >> 9) & 7) = res;
34869 res = src;
34870 DREGu32((Opcode >> 0) & 7) = res;
34871RET(6)
34872}
34873
34874// EXGAA
34875OPCODE(0xC148)
34876{
34877 u32 adr, res;
34878 u32 src, dst;
34879
34880 res = AREGu32((Opcode >> 0) & 7);
34881 src = AREGu32((Opcode >> 9) & 7);
34882 AREG((Opcode >> 9) & 7) = res;
34883 res = src;
34884 AREG((Opcode >> 0) & 7) = res;
34885RET(6)
34886}
34887
34888// EXGAD
34889OPCODE(0xC188)
34890{
34891 u32 adr, res;
34892 u32 src, dst;
34893
34894 res = AREGu32((Opcode >> 0) & 7);
34895 src = DREGu32((Opcode >> 9) & 7);
34896 DREGu32((Opcode >> 9) & 7) = res;
34897 res = src;
34898 AREG((Opcode >> 0) & 7) = res;
34899RET(6)
34900}
34901
34902// ADDaD
34903OPCODE(0xD000)
34904{
34905 u32 adr, res;
34906 u32 src, dst;
34907
34908 src = DREGu8((Opcode >> 0) & 7);
34909 dst = DREGu8((Opcode >> 9) & 7);
34910 res = dst + src;
34911 flag_N = flag_X = flag_C = res;
34912 flag_V = (src ^ res) & (dst ^ res);
34913 flag_NotZ = res & 0xFF;
34914 DREGu8((Opcode >> 9) & 7) = res;
34915RET(4)
34916}
34917
34918// ADDaD
03e4f2a3 34919#if 0
70357ce5 34920OPCODE(0xD008)
34921{
34922 u32 adr, res;
34923 u32 src, dst;
34924
34925 // can't read byte from Ax registers !
34926 m68kcontext.execinfo |= M68K_FAULTED;
34927 m68kcontext.io_cycle_counter = 0;
34928/*
34929 goto famec_Exec_End;
34930 dst = DREGu8((Opcode >> 9) & 7);
34931 res = dst + src;
34932 flag_N = flag_X = flag_C = res;
34933 flag_V = (src ^ res) & (dst ^ res);
34934 flag_NotZ = res & 0xFF;
34935 DREGu8((Opcode >> 9) & 7) = res;
34936*/
34937RET(4)
34938}
03e4f2a3 34939#endif
70357ce5 34940
34941// ADDaD
34942OPCODE(0xD010)
34943{
34944 u32 adr, res;
34945 u32 src, dst;
34946
34947 adr = AREG((Opcode >> 0) & 7);
34948 PRE_IO
34949 READ_BYTE_F(adr, src)
34950 dst = DREGu8((Opcode >> 9) & 7);
34951 res = dst + src;
34952 flag_N = flag_X = flag_C = res;
34953 flag_V = (src ^ res) & (dst ^ res);
34954 flag_NotZ = res & 0xFF;
34955 DREGu8((Opcode >> 9) & 7) = res;
34956 POST_IO
34957RET(8)
34958}
34959
34960// ADDaD
34961OPCODE(0xD018)
34962{
34963 u32 adr, res;
34964 u32 src, dst;
34965
34966 adr = AREG((Opcode >> 0) & 7);
34967 AREG((Opcode >> 0) & 7) += 1;
34968 PRE_IO
34969 READ_BYTE_F(adr, src)
34970 dst = DREGu8((Opcode >> 9) & 7);
34971 res = dst + src;
34972 flag_N = flag_X = flag_C = res;
34973 flag_V = (src ^ res) & (dst ^ res);
34974 flag_NotZ = res & 0xFF;
34975 DREGu8((Opcode >> 9) & 7) = res;
34976 POST_IO
34977RET(8)
34978}
34979
34980// ADDaD
34981OPCODE(0xD020)
34982{
34983 u32 adr, res;
34984 u32 src, dst;
34985
34986 adr = AREG((Opcode >> 0) & 7) - 1;
34987 AREG((Opcode >> 0) & 7) = adr;
34988 PRE_IO
34989 READ_BYTE_F(adr, src)
34990 dst = DREGu8((Opcode >> 9) & 7);
34991 res = dst + src;
34992 flag_N = flag_X = flag_C = res;
34993 flag_V = (src ^ res) & (dst ^ res);
34994 flag_NotZ = res & 0xFF;
34995 DREGu8((Opcode >> 9) & 7) = res;
34996 POST_IO
34997RET(10)
34998}
34999
35000// ADDaD
35001OPCODE(0xD028)
35002{
35003 u32 adr, res;
35004 u32 src, dst;
35005
35006 FETCH_SWORD(adr);
35007 adr += AREG((Opcode >> 0) & 7);
35008 PRE_IO
35009 READ_BYTE_F(adr, src)
35010 dst = DREGu8((Opcode >> 9) & 7);
35011 res = dst + src;
35012 flag_N = flag_X = flag_C = res;
35013 flag_V = (src ^ res) & (dst ^ res);
35014 flag_NotZ = res & 0xFF;
35015 DREGu8((Opcode >> 9) & 7) = res;
35016 POST_IO
35017RET(12)
35018}
35019
35020// ADDaD
35021OPCODE(0xD030)
35022{
35023 u32 adr, res;
35024 u32 src, dst;
35025
35026 adr = AREG((Opcode >> 0) & 7);
35027 DECODE_EXT_WORD
35028 PRE_IO
35029 READ_BYTE_F(adr, src)
35030 dst = DREGu8((Opcode >> 9) & 7);
35031 res = dst + src;
35032 flag_N = flag_X = flag_C = res;
35033 flag_V = (src ^ res) & (dst ^ res);
35034 flag_NotZ = res & 0xFF;
35035 DREGu8((Opcode >> 9) & 7) = res;
35036 POST_IO
35037RET(14)
35038}
35039
35040// ADDaD
35041OPCODE(0xD038)
35042{
35043 u32 adr, res;
35044 u32 src, dst;
35045
35046 FETCH_SWORD(adr);
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(0xD039)
35061{
35062 u32 adr, res;
35063 u32 src, dst;
35064
35065 FETCH_LONG(adr);
35066 PRE_IO
35067 READ_BYTE_F(adr, src)
35068 dst = DREGu8((Opcode >> 9) & 7);
35069 res = dst + src;
35070 flag_N = flag_X = flag_C = res;
35071 flag_V = (src ^ res) & (dst ^ res);
35072 flag_NotZ = res & 0xFF;
35073 DREGu8((Opcode >> 9) & 7) = res;
35074 POST_IO
35075RET(16)
35076}
35077
35078// ADDaD
35079OPCODE(0xD03A)
35080{
35081 u32 adr, res;
35082 u32 src, dst;
35083
be26eb23 35084 adr = GET_SWORD + GET_PC;
70357ce5 35085 PC++;
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(0xD03B)
35100{
35101 u32 adr, res;
35102 u32 src, dst;
35103
be26eb23 35104 adr = GET_PC;
70357ce5 35105 DECODE_EXT_WORD
35106 PRE_IO
35107 READ_BYTE_F(adr, src)
35108 dst = DREGu8((Opcode >> 9) & 7);
35109 res = dst + src;
35110 flag_N = flag_X = flag_C = res;
35111 flag_V = (src ^ res) & (dst ^ res);
35112 flag_NotZ = res & 0xFF;
35113 DREGu8((Opcode >> 9) & 7) = res;
35114 POST_IO
35115RET(14)
35116}
35117
35118// ADDaD
35119OPCODE(0xD03C)
35120{
35121 u32 adr, res;
35122 u32 src, dst;
35123
35124 FETCH_BYTE(src);
35125 dst = DREGu8((Opcode >> 9) & 7);
35126 res = dst + src;
35127 flag_N = flag_X = flag_C = res;
35128 flag_V = (src ^ res) & (dst ^ res);
35129 flag_NotZ = res & 0xFF;
35130 DREGu8((Opcode >> 9) & 7) = res;
35131RET(8)
35132}
35133
35134// ADDaD
35135OPCODE(0xD01F)
35136{
35137 u32 adr, res;
35138 u32 src, dst;
35139
35140 adr = AREG(7);
35141 AREG(7) += 2;
35142 PRE_IO
35143 READ_BYTE_F(adr, src)
35144 dst = DREGu8((Opcode >> 9) & 7);
35145 res = dst + src;
35146 flag_N = flag_X = flag_C = res;
35147 flag_V = (src ^ res) & (dst ^ res);
35148 flag_NotZ = res & 0xFF;
35149 DREGu8((Opcode >> 9) & 7) = res;
35150 POST_IO
35151RET(8)
35152}
35153
35154// ADDaD
35155OPCODE(0xD027)
35156{
35157 u32 adr, res;
35158 u32 src, dst;
35159
35160 adr = AREG(7) - 2;
35161 AREG(7) = adr;
35162 PRE_IO
35163 READ_BYTE_F(adr, 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;
35170 POST_IO
35171RET(10)
35172}
35173
35174// ADDaD
35175OPCODE(0xD040)
35176{
35177 u32 adr, res;
35178 u32 src, dst;
35179
35180 src = DREGu16((Opcode >> 0) & 7);
35181 dst = DREGu16((Opcode >> 9) & 7);
35182 res = dst + src;
35183 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35184 flag_N = flag_X = flag_C = res >> 8;
35185 flag_NotZ = res & 0xFFFF;
35186 DREGu16((Opcode >> 9) & 7) = res;
35187RET(4)
35188}
35189
35190// ADDaD
35191OPCODE(0xD048)
35192{
35193 u32 adr, res;
35194 u32 src, dst;
35195
35196 src = AREGu16((Opcode >> 0) & 7);
35197 dst = DREGu16((Opcode >> 9) & 7);
35198 res = dst + src;
35199 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35200 flag_N = flag_X = flag_C = res >> 8;
35201 flag_NotZ = res & 0xFFFF;
35202 DREGu16((Opcode >> 9) & 7) = res;
35203RET(4)
35204}
35205
35206// ADDaD
35207OPCODE(0xD050)
35208{
35209 u32 adr, res;
35210 u32 src, dst;
35211
35212 adr = AREG((Opcode >> 0) & 7);
35213 PRE_IO
35214 READ_WORD_F(adr, src)
35215 dst = DREGu16((Opcode >> 9) & 7);
35216 res = dst + src;
35217 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35218 flag_N = flag_X = flag_C = res >> 8;
35219 flag_NotZ = res & 0xFFFF;
35220 DREGu16((Opcode >> 9) & 7) = res;
35221 POST_IO
35222RET(8)
35223}
35224
35225// ADDaD
35226OPCODE(0xD058)
35227{
35228 u32 adr, res;
35229 u32 src, dst;
35230
35231 adr = AREG((Opcode >> 0) & 7);
35232 AREG((Opcode >> 0) & 7) += 2;
35233 PRE_IO
35234 READ_WORD_F(adr, src)
35235 dst = DREGu16((Opcode >> 9) & 7);
35236 res = dst + src;
35237 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35238 flag_N = flag_X = flag_C = res >> 8;
35239 flag_NotZ = res & 0xFFFF;
35240 DREGu16((Opcode >> 9) & 7) = res;
35241 POST_IO
35242RET(8)
35243}
35244
35245// ADDaD
35246OPCODE(0xD060)
35247{
35248 u32 adr, res;
35249 u32 src, dst;
35250
35251 adr = AREG((Opcode >> 0) & 7) - 2;
35252 AREG((Opcode >> 0) & 7) = adr;
35253 PRE_IO
35254 READ_WORD_F(adr, src)
35255 dst = DREGu16((Opcode >> 9) & 7);
35256 res = dst + src;
35257 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35258 flag_N = flag_X = flag_C = res >> 8;
35259 flag_NotZ = res & 0xFFFF;
35260 DREGu16((Opcode >> 9) & 7) = res;
35261 POST_IO
35262RET(10)
35263}
35264
35265// ADDaD
35266OPCODE(0xD068)
35267{
35268 u32 adr, res;
35269 u32 src, dst;
35270
35271 FETCH_SWORD(adr);
35272 adr += AREG((Opcode >> 0) & 7);
35273 PRE_IO
35274 READ_WORD_F(adr, src)
35275 dst = DREGu16((Opcode >> 9) & 7);
35276 res = dst + src;
35277 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35278 flag_N = flag_X = flag_C = res >> 8;
35279 flag_NotZ = res & 0xFFFF;
35280 DREGu16((Opcode >> 9) & 7) = res;
35281 POST_IO
35282RET(12)
35283}
35284
35285// ADDaD
35286OPCODE(0xD070)
35287{
35288 u32 adr, res;
35289 u32 src, dst;
35290
35291 adr = AREG((Opcode >> 0) & 7);
35292 DECODE_EXT_WORD
35293 PRE_IO
35294 READ_WORD_F(adr, src)
35295 dst = DREGu16((Opcode >> 9) & 7);
35296 res = dst + src;
35297 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35298 flag_N = flag_X = flag_C = res >> 8;
35299 flag_NotZ = res & 0xFFFF;
35300 DREGu16((Opcode >> 9) & 7) = res;
35301 POST_IO
35302RET(14)
35303}
35304
35305// ADDaD
35306OPCODE(0xD078)
35307{
35308 u32 adr, res;
35309 u32 src, dst;
35310
35311 FETCH_SWORD(adr);
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(0xD079)
35326{
35327 u32 adr, res;
35328 u32 src, dst;
35329
35330 FETCH_LONG(adr);
35331 PRE_IO
35332 READ_WORD_F(adr, src)
35333 dst = DREGu16((Opcode >> 9) & 7);
35334 res = dst + src;
35335 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35336 flag_N = flag_X = flag_C = res >> 8;
35337 flag_NotZ = res & 0xFFFF;
35338 DREGu16((Opcode >> 9) & 7) = res;
35339 POST_IO
35340RET(16)
35341}
35342
35343// ADDaD
35344OPCODE(0xD07A)
35345{
35346 u32 adr, res;
35347 u32 src, dst;
35348
be26eb23 35349 adr = GET_SWORD + GET_PC;
70357ce5 35350 PC++;
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(0xD07B)
35365{
35366 u32 adr, res;
35367 u32 src, dst;
35368
be26eb23 35369 adr = GET_PC;
70357ce5 35370 DECODE_EXT_WORD
35371 PRE_IO
35372 READ_WORD_F(adr, src)
35373 dst = DREGu16((Opcode >> 9) & 7);
35374 res = dst + src;
35375 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35376 flag_N = flag_X = flag_C = res >> 8;
35377 flag_NotZ = res & 0xFFFF;
35378 DREGu16((Opcode >> 9) & 7) = res;
35379 POST_IO
35380RET(14)
35381}
35382
35383// ADDaD
35384OPCODE(0xD07C)
35385{
35386 u32 adr, res;
35387 u32 src, dst;
35388
35389 FETCH_WORD(src);
35390 dst = DREGu16((Opcode >> 9) & 7);
35391 res = dst + src;
35392 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35393 flag_N = flag_X = flag_C = res >> 8;
35394 flag_NotZ = res & 0xFFFF;
35395 DREGu16((Opcode >> 9) & 7) = res;
35396RET(8)
35397}
35398
35399// ADDaD
35400OPCODE(0xD05F)
35401{
35402 u32 adr, res;
35403 u32 src, dst;
35404
35405 adr = AREG(7);
35406 AREG(7) += 2;
35407 PRE_IO
35408 READ_WORD_F(adr, src)
35409 dst = DREGu16((Opcode >> 9) & 7);
35410 res = dst + src;
35411 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35412 flag_N = flag_X = flag_C = res >> 8;
35413 flag_NotZ = res & 0xFFFF;
35414 DREGu16((Opcode >> 9) & 7) = res;
35415 POST_IO
35416RET(8)
35417}
35418
35419// ADDaD
35420OPCODE(0xD067)
35421{
35422 u32 adr, res;
35423 u32 src, dst;
35424
35425 adr = AREG(7) - 2;
35426 AREG(7) = adr;
35427 PRE_IO
35428 READ_WORD_F(adr, 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;
35435 POST_IO
35436RET(10)
35437}
35438
35439// ADDaD
35440OPCODE(0xD080)
35441{
35442 u32 adr, res;
35443 u32 src, dst;
35444
35445 src = DREGu32((Opcode >> 0) & 7);
35446 dst = DREGu32((Opcode >> 9) & 7);
35447 res = dst + src;
35448 flag_NotZ = res;
35449 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35450 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35451 flag_N = res >> 24;
35452 DREGu32((Opcode >> 9) & 7) = res;
35453RET(8)
35454}
35455
35456// ADDaD
35457OPCODE(0xD088)
35458{
35459 u32 adr, res;
35460 u32 src, dst;
35461
35462 src = AREGu32((Opcode >> 0) & 7);
35463 dst = DREGu32((Opcode >> 9) & 7);
35464 res = dst + src;
35465 flag_NotZ = res;
35466 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35467 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35468 flag_N = res >> 24;
35469 DREGu32((Opcode >> 9) & 7) = res;
35470RET(8)
35471}
35472
35473// ADDaD
35474OPCODE(0xD090)
35475{
35476 u32 adr, res;
35477 u32 src, dst;
35478
35479 adr = AREG((Opcode >> 0) & 7);
35480 PRE_IO
35481 READ_LONG_F(adr, src)
35482 dst = DREGu32((Opcode >> 9) & 7);
35483 res = dst + src;
35484 flag_NotZ = res;
35485 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35486 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35487 flag_N = res >> 24;
35488 DREGu32((Opcode >> 9) & 7) = res;
35489 POST_IO
35490RET(14)
35491}
35492
35493// ADDaD
35494OPCODE(0xD098)
35495{
35496 u32 adr, res;
35497 u32 src, dst;
35498
35499 adr = AREG((Opcode >> 0) & 7);
35500 AREG((Opcode >> 0) & 7) += 4;
35501 PRE_IO
35502 READ_LONG_F(adr, src)
35503 dst = DREGu32((Opcode >> 9) & 7);
35504 res = dst + src;
35505 flag_NotZ = res;
35506 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35507 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35508 flag_N = res >> 24;
35509 DREGu32((Opcode >> 9) & 7) = res;
35510 POST_IO
35511RET(14)
35512}
35513
35514// ADDaD
35515OPCODE(0xD0A0)
35516{
35517 u32 adr, res;
35518 u32 src, dst;
35519
35520 adr = AREG((Opcode >> 0) & 7) - 4;
35521 AREG((Opcode >> 0) & 7) = adr;
35522 PRE_IO
35523 READ_LONG_F(adr, src)
35524 dst = DREGu32((Opcode >> 9) & 7);
35525 res = dst + src;
35526 flag_NotZ = res;
35527 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35528 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35529 flag_N = res >> 24;
35530 DREGu32((Opcode >> 9) & 7) = res;
35531 POST_IO
35532RET(16)
35533}
35534
35535// ADDaD
35536OPCODE(0xD0A8)
35537{
35538 u32 adr, res;
35539 u32 src, dst;
35540
35541 FETCH_SWORD(adr);
35542 adr += AREG((Opcode >> 0) & 7);
35543 PRE_IO
35544 READ_LONG_F(adr, src)
35545 dst = DREGu32((Opcode >> 9) & 7);
35546 res = dst + src;
35547 flag_NotZ = res;
35548 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35549 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35550 flag_N = res >> 24;
35551 DREGu32((Opcode >> 9) & 7) = res;
35552 POST_IO
35553RET(18)
35554}
35555
35556// ADDaD
35557OPCODE(0xD0B0)
35558{
35559 u32 adr, res;
35560 u32 src, dst;
35561
35562 adr = AREG((Opcode >> 0) & 7);
35563 DECODE_EXT_WORD
35564 PRE_IO
35565 READ_LONG_F(adr, src)
35566 dst = DREGu32((Opcode >> 9) & 7);
35567 res = dst + src;
35568 flag_NotZ = res;
35569 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35570 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35571 flag_N = res >> 24;
35572 DREGu32((Opcode >> 9) & 7) = res;
35573 POST_IO
35574RET(20)
35575}
35576
35577// ADDaD
35578OPCODE(0xD0B8)
35579{
35580 u32 adr, res;
35581 u32 src, dst;
35582
35583 FETCH_SWORD(adr);
35584 PRE_IO
35585 READ_LONG_F(adr, src)
35586 dst = DREGu32((Opcode >> 9) & 7);
35587 res = dst + src;
35588 flag_NotZ = res;
35589 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35590 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35591 flag_N = res >> 24;
35592 DREGu32((Opcode >> 9) & 7) = res;
35593 POST_IO
35594RET(18)
35595}
35596
35597// ADDaD
35598OPCODE(0xD0B9)
35599{
35600 u32 adr, res;
35601 u32 src, dst;
35602
35603 FETCH_LONG(adr);
35604 PRE_IO
35605 READ_LONG_F(adr, src)
35606 dst = DREGu32((Opcode >> 9) & 7);
35607 res = dst + src;
35608 flag_NotZ = res;
35609 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35610 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35611 flag_N = res >> 24;
35612 DREGu32((Opcode >> 9) & 7) = res;
35613 POST_IO
35614RET(22)
35615}
35616
35617// ADDaD
35618OPCODE(0xD0BA)
35619{
35620 u32 adr, res;
35621 u32 src, dst;
35622
be26eb23 35623 adr = GET_SWORD + GET_PC;
70357ce5 35624 PC++;
35625 PRE_IO
35626 READ_LONG_F(adr, src)
35627 dst = DREGu32((Opcode >> 9) & 7);
35628 res = dst + src;
35629 flag_NotZ = res;
35630 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35631 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35632 flag_N = res >> 24;
35633 DREGu32((Opcode >> 9) & 7) = res;
35634 POST_IO
35635RET(18)
35636}
35637
35638// ADDaD
35639OPCODE(0xD0BB)
35640{
35641 u32 adr, res;
35642 u32 src, dst;
35643
be26eb23 35644 adr = GET_PC;
70357ce5 35645 DECODE_EXT_WORD
35646 PRE_IO
35647 READ_LONG_F(adr, src)
35648 dst = DREGu32((Opcode >> 9) & 7);
35649 res = dst + src;
35650 flag_NotZ = res;
35651 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35652 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35653 flag_N = res >> 24;
35654 DREGu32((Opcode >> 9) & 7) = res;
35655 POST_IO
35656RET(20)
35657}
35658
35659// ADDaD
35660OPCODE(0xD0BC)
35661{
35662 u32 adr, res;
35663 u32 src, dst;
35664
35665 FETCH_LONG(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;
35673RET(16)
35674}
35675
35676// ADDaD
35677OPCODE(0xD09F)
35678{
35679 u32 adr, res;
35680 u32 src, dst;
35681
35682 adr = AREG(7);
35683 AREG(7) += 4;
35684 PRE_IO
35685 READ_LONG_F(adr, src)
35686 dst = DREGu32((Opcode >> 9) & 7);
35687 res = dst + src;
35688 flag_NotZ = res;
35689 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35690 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35691 flag_N = res >> 24;
35692 DREGu32((Opcode >> 9) & 7) = res;
35693 POST_IO
35694RET(14)
35695}
35696
35697// ADDaD
35698OPCODE(0xD0A7)
35699{
35700 u32 adr, res;
35701 u32 src, dst;
35702
35703 adr = AREG(7) - 4;
35704 AREG(7) = adr;
35705 PRE_IO
35706 READ_LONG_F(adr, src)
35707 dst = DREGu32((Opcode >> 9) & 7);
35708 res = dst + src;
35709 flag_NotZ = res;
35710 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
35711 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
35712 flag_N = res >> 24;
35713 DREGu32((Opcode >> 9) & 7) = res;
35714 POST_IO
35715RET(16)
35716}
35717
35718// ADDDa
35719OPCODE(0xD110)
35720{
35721 u32 adr, res;
35722 u32 src, dst;
35723
35724 src = DREGu8((Opcode >> 9) & 7);
35725 adr = AREG((Opcode >> 0) & 7);
35726 PRE_IO
35727 READ_BYTE_F(adr, dst)
35728 res = dst + src;
35729 flag_N = flag_X = flag_C = res;
35730 flag_V = (src ^ res) & (dst ^ res);
35731 flag_NotZ = res & 0xFF;
35732 WRITE_BYTE_F(adr, res)
35733 POST_IO
35734RET(12)
35735}
35736
35737// ADDDa
35738OPCODE(0xD118)
35739{
35740 u32 adr, res;
35741 u32 src, dst;
35742
35743 src = DREGu8((Opcode >> 9) & 7);
35744 adr = AREG((Opcode >> 0) & 7);
35745 AREG((Opcode >> 0) & 7) += 1;
35746 PRE_IO
35747 READ_BYTE_F(adr, dst)
35748 res = dst + src;
35749 flag_N = flag_X = flag_C = res;
35750 flag_V = (src ^ res) & (dst ^ res);
35751 flag_NotZ = res & 0xFF;
35752 WRITE_BYTE_F(adr, res)
35753 POST_IO
35754RET(12)
35755}
35756
35757// ADDDa
35758OPCODE(0xD120)
35759{
35760 u32 adr, res;
35761 u32 src, dst;
35762
35763 src = DREGu8((Opcode >> 9) & 7);
35764 adr = AREG((Opcode >> 0) & 7) - 1;
35765 AREG((Opcode >> 0) & 7) = adr;
35766 PRE_IO
35767 READ_BYTE_F(adr, dst)
35768 res = dst + src;
35769 flag_N = flag_X = flag_C = res;
35770 flag_V = (src ^ res) & (dst ^ res);
35771 flag_NotZ = res & 0xFF;
35772 WRITE_BYTE_F(adr, res)
35773 POST_IO
35774RET(14)
35775}
35776
35777// ADDDa
35778OPCODE(0xD128)
35779{
35780 u32 adr, res;
35781 u32 src, dst;
35782
35783 src = DREGu8((Opcode >> 9) & 7);
35784 FETCH_SWORD(adr);
35785 adr += AREG((Opcode >> 0) & 7);
35786 PRE_IO
35787 READ_BYTE_F(adr, dst)
35788 res = dst + src;
35789 flag_N = flag_X = flag_C = res;
35790 flag_V = (src ^ res) & (dst ^ res);
35791 flag_NotZ = res & 0xFF;
35792 WRITE_BYTE_F(adr, res)
35793 POST_IO
35794RET(16)
35795}
35796
35797// ADDDa
35798OPCODE(0xD130)
35799{
35800 u32 adr, res;
35801 u32 src, dst;
35802
35803 src = DREGu8((Opcode >> 9) & 7);
35804 adr = AREG((Opcode >> 0) & 7);
35805 DECODE_EXT_WORD
35806 PRE_IO
35807 READ_BYTE_F(adr, dst)
35808 res = dst + src;
35809 flag_N = flag_X = flag_C = res;
35810 flag_V = (src ^ res) & (dst ^ res);
35811 flag_NotZ = res & 0xFF;
35812 WRITE_BYTE_F(adr, res)
35813 POST_IO
35814RET(18)
35815}
35816
35817// ADDDa
35818OPCODE(0xD138)
35819{
35820 u32 adr, res;
35821 u32 src, dst;
35822
35823 src = DREGu8((Opcode >> 9) & 7);
35824 FETCH_SWORD(adr);
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(0xD139)
35838{
35839 u32 adr, res;
35840 u32 src, dst;
35841
35842 src = DREGu8((Opcode >> 9) & 7);
35843 FETCH_LONG(adr);
35844 PRE_IO
35845 READ_BYTE_F(adr, dst)
35846 res = dst + src;
35847 flag_N = flag_X = flag_C = res;
35848 flag_V = (src ^ res) & (dst ^ res);
35849 flag_NotZ = res & 0xFF;
35850 WRITE_BYTE_F(adr, res)
35851 POST_IO
35852RET(20)
35853}
35854
35855// ADDDa
35856OPCODE(0xD11F)
35857{
35858 u32 adr, res;
35859 u32 src, dst;
35860
35861 src = DREGu8((Opcode >> 9) & 7);
35862 adr = AREG(7);
35863 AREG(7) += 2;
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(12)
35873}
35874
35875// ADDDa
35876OPCODE(0xD127)
35877{
35878 u32 adr, res;
35879 u32 src, dst;
35880
35881 src = DREGu8((Opcode >> 9) & 7);
35882 adr = AREG(7) - 2;
35883 AREG(7) = adr;
35884 PRE_IO
35885 READ_BYTE_F(adr, dst)
35886 res = dst + src;
35887 flag_N = flag_X = flag_C = res;
35888 flag_V = (src ^ res) & (dst ^ res);
35889 flag_NotZ = res & 0xFF;
35890 WRITE_BYTE_F(adr, res)
35891 POST_IO
35892RET(14)
35893}
35894
35895// ADDDa
35896OPCODE(0xD150)
35897{
35898 u32 adr, res;
35899 u32 src, dst;
35900
35901 src = DREGu16((Opcode >> 9) & 7);
35902 adr = AREG((Opcode >> 0) & 7);
35903 PRE_IO
35904 READ_WORD_F(adr, dst)
35905 res = dst + src;
35906 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35907 flag_N = flag_X = flag_C = res >> 8;
35908 flag_NotZ = res & 0xFFFF;
35909 WRITE_WORD_F(adr, res)
35910 POST_IO
35911RET(12)
35912}
35913
35914// ADDDa
35915OPCODE(0xD158)
35916{
35917 u32 adr, res;
35918 u32 src, dst;
35919
35920 src = DREGu16((Opcode >> 9) & 7);
35921 adr = AREG((Opcode >> 0) & 7);
35922 AREG((Opcode >> 0) & 7) += 2;
35923 PRE_IO
35924 READ_WORD_F(adr, dst)
35925 res = dst + src;
35926 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35927 flag_N = flag_X = flag_C = res >> 8;
35928 flag_NotZ = res & 0xFFFF;
35929 WRITE_WORD_F(adr, res)
35930 POST_IO
35931RET(12)
35932}
35933
35934// ADDDa
35935OPCODE(0xD160)
35936{
35937 u32 adr, res;
35938 u32 src, dst;
35939
35940 src = DREGu16((Opcode >> 9) & 7);
35941 adr = AREG((Opcode >> 0) & 7) - 2;
35942 AREG((Opcode >> 0) & 7) = adr;
35943 PRE_IO
35944 READ_WORD_F(adr, dst)
35945 res = dst + src;
35946 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35947 flag_N = flag_X = flag_C = res >> 8;
35948 flag_NotZ = res & 0xFFFF;
35949 WRITE_WORD_F(adr, res)
35950 POST_IO
35951RET(14)
35952}
35953
35954// ADDDa
35955OPCODE(0xD168)
35956{
35957 u32 adr, res;
35958 u32 src, dst;
35959
35960 src = DREGu16((Opcode >> 9) & 7);
35961 FETCH_SWORD(adr);
35962 adr += AREG((Opcode >> 0) & 7);
35963 PRE_IO
35964 READ_WORD_F(adr, dst)
35965 res = dst + src;
35966 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35967 flag_N = flag_X = flag_C = res >> 8;
35968 flag_NotZ = res & 0xFFFF;
35969 WRITE_WORD_F(adr, res)
35970 POST_IO
35971RET(16)
35972}
35973
35974// ADDDa
35975OPCODE(0xD170)
35976{
35977 u32 adr, res;
35978 u32 src, dst;
35979
35980 src = DREGu16((Opcode >> 9) & 7);
35981 adr = AREG((Opcode >> 0) & 7);
35982 DECODE_EXT_WORD
35983 PRE_IO
35984 READ_WORD_F(adr, dst)
35985 res = dst + src;
35986 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
35987 flag_N = flag_X = flag_C = res >> 8;
35988 flag_NotZ = res & 0xFFFF;
35989 WRITE_WORD_F(adr, res)
35990 POST_IO
35991RET(18)
35992}
35993
35994// ADDDa
35995OPCODE(0xD178)
35996{
35997 u32 adr, res;
35998 u32 src, dst;
35999
36000 src = DREGu16((Opcode >> 9) & 7);
36001 FETCH_SWORD(adr);
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(0xD179)
36015{
36016 u32 adr, res;
36017 u32 src, dst;
36018
36019 src = DREGu16((Opcode >> 9) & 7);
36020 FETCH_LONG(adr);
36021 PRE_IO
36022 READ_WORD_F(adr, dst)
36023 res = dst + src;
36024 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36025 flag_N = flag_X = flag_C = res >> 8;
36026 flag_NotZ = res & 0xFFFF;
36027 WRITE_WORD_F(adr, res)
36028 POST_IO
36029RET(20)
36030}
36031
36032// ADDDa
36033OPCODE(0xD15F)
36034{
36035 u32 adr, res;
36036 u32 src, dst;
36037
36038 src = DREGu16((Opcode >> 9) & 7);
36039 adr = AREG(7);
36040 AREG(7) += 2;
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(12)
36050}
36051
36052// ADDDa
36053OPCODE(0xD167)
36054{
36055 u32 adr, res;
36056 u32 src, dst;
36057
36058 src = DREGu16((Opcode >> 9) & 7);
36059 adr = AREG(7) - 2;
36060 AREG(7) = adr;
36061 PRE_IO
36062 READ_WORD_F(adr, dst)
36063 res = dst + src;
36064 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36065 flag_N = flag_X = flag_C = res >> 8;
36066 flag_NotZ = res & 0xFFFF;
36067 WRITE_WORD_F(adr, res)
36068 POST_IO
36069RET(14)
36070}
36071
36072// ADDDa
36073OPCODE(0xD190)
36074{
36075 u32 adr, res;
36076 u32 src, dst;
36077
36078 src = DREGu32((Opcode >> 9) & 7);
36079 adr = AREG((Opcode >> 0) & 7);
36080 PRE_IO
36081 READ_LONG_F(adr, dst)
36082 res = dst + src;
36083 flag_NotZ = res;
36084 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36085 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36086 flag_N = res >> 24;
36087 WRITE_LONG_F(adr, res)
36088 POST_IO
36089RET(20)
36090}
36091
36092// ADDDa
36093OPCODE(0xD198)
36094{
36095 u32 adr, res;
36096 u32 src, dst;
36097
36098 src = DREGu32((Opcode >> 9) & 7);
36099 adr = AREG((Opcode >> 0) & 7);
36100 AREG((Opcode >> 0) & 7) += 4;
36101 PRE_IO
36102 READ_LONG_F(adr, dst)
36103 res = dst + src;
36104 flag_NotZ = res;
36105 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36106 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36107 flag_N = res >> 24;
36108 WRITE_LONG_F(adr, res)
36109 POST_IO
36110RET(20)
36111}
36112
36113// ADDDa
36114OPCODE(0xD1A0)
36115{
36116 u32 adr, res;
36117 u32 src, dst;
36118
36119 src = DREGu32((Opcode >> 9) & 7);
36120 adr = AREG((Opcode >> 0) & 7) - 4;
36121 AREG((Opcode >> 0) & 7) = adr;
36122 PRE_IO
36123 READ_LONG_F(adr, dst)
36124 res = dst + src;
36125 flag_NotZ = res;
36126 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36127 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36128 flag_N = res >> 24;
36129 WRITE_LONG_F(adr, res)
36130 POST_IO
36131RET(22)
36132}
36133
36134// ADDDa
36135OPCODE(0xD1A8)
36136{
36137 u32 adr, res;
36138 u32 src, dst;
36139
36140 src = DREGu32((Opcode >> 9) & 7);
36141 FETCH_SWORD(adr);
36142 adr += AREG((Opcode >> 0) & 7);
36143 PRE_IO
36144 READ_LONG_F(adr, dst)
36145 res = dst + src;
36146 flag_NotZ = res;
36147 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36148 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36149 flag_N = res >> 24;
36150 WRITE_LONG_F(adr, res)
36151 POST_IO
36152RET(24)
36153}
36154
36155// ADDDa
36156OPCODE(0xD1B0)
36157{
36158 u32 adr, res;
36159 u32 src, dst;
36160
36161 src = DREGu32((Opcode >> 9) & 7);
36162 adr = AREG((Opcode >> 0) & 7);
36163 DECODE_EXT_WORD
36164 PRE_IO
36165 READ_LONG_F(adr, dst)
36166 res = dst + src;
36167 flag_NotZ = res;
36168 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36169 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36170 flag_N = res >> 24;
36171 WRITE_LONG_F(adr, res)
36172 POST_IO
36173RET(26)
36174}
36175
36176// ADDDa
36177OPCODE(0xD1B8)
36178{
36179 u32 adr, res;
36180 u32 src, dst;
36181
36182 src = DREGu32((Opcode >> 9) & 7);
36183 FETCH_SWORD(adr);
36184 PRE_IO
36185 READ_LONG_F(adr, dst)
36186 res = dst + src;
36187 flag_NotZ = res;
36188 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36189 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36190 flag_N = res >> 24;
36191 WRITE_LONG_F(adr, res)
36192 POST_IO
36193RET(24)
36194}
36195
36196// ADDDa
36197OPCODE(0xD1B9)
36198{
36199 u32 adr, res;
36200 u32 src, dst;
36201
36202 src = DREGu32((Opcode >> 9) & 7);
36203 FETCH_LONG(adr);
36204 PRE_IO
36205 READ_LONG_F(adr, dst)
36206 res = dst + src;
36207 flag_NotZ = res;
36208 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36209 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36210 flag_N = res >> 24;
36211 WRITE_LONG_F(adr, res)
36212 POST_IO
36213RET(28)
36214}
36215
36216// ADDDa
36217OPCODE(0xD19F)
36218{
36219 u32 adr, res;
36220 u32 src, dst;
36221
36222 src = DREGu32((Opcode >> 9) & 7);
36223 adr = AREG(7);
36224 AREG(7) += 4;
36225 PRE_IO
36226 READ_LONG_F(adr, dst)
36227 res = dst + src;
36228 flag_NotZ = res;
36229 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36230 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36231 flag_N = res >> 24;
36232 WRITE_LONG_F(adr, res)
36233 POST_IO
36234RET(20)
36235}
36236
36237// ADDDa
36238OPCODE(0xD1A7)
36239{
36240 u32 adr, res;
36241 u32 src, dst;
36242
36243 src = DREGu32((Opcode >> 9) & 7);
36244 adr = AREG(7) - 4;
36245 AREG(7) = adr;
36246 PRE_IO
36247 READ_LONG_F(adr, dst)
36248 res = dst + src;
36249 flag_NotZ = res;
36250 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36251 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36252 flag_N = res >> 24;
36253 WRITE_LONG_F(adr, res)
36254 POST_IO
36255RET(22)
36256}
36257
36258// ADDX
36259OPCODE(0xD100)
36260{
36261 u32 adr, res;
36262 u32 src, dst;
36263
36264 src = DREGu8((Opcode >> 0) & 7);
36265 dst = DREGu8((Opcode >> 9) & 7);
36266 res = dst + src + ((flag_X >> 8) & 1);
36267 flag_N = flag_X = flag_C = res;
36268 flag_V = (src ^ res) & (dst ^ res);
36269 flag_NotZ |= res & 0xFF;
36270 DREGu8((Opcode >> 9) & 7) = res;
36271RET(4)
36272}
36273
36274// ADDX
36275OPCODE(0xD140)
36276{
36277 u32 adr, res;
36278 u32 src, dst;
36279
36280 src = DREGu16((Opcode >> 0) & 7);
36281 dst = DREGu16((Opcode >> 9) & 7);
36282 res = dst + src + ((flag_X >> 8) & 1);
36283 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36284 flag_N = flag_X = flag_C = res >> 8;
36285 flag_NotZ |= res & 0xFFFF;
36286 DREGu16((Opcode >> 9) & 7) = res;
36287RET(4)
36288}
36289
36290// ADDX
36291OPCODE(0xD180)
36292{
36293 u32 adr, res;
36294 u32 src, dst;
36295
36296 src = DREGu32((Opcode >> 0) & 7);
36297 dst = DREGu32((Opcode >> 9) & 7);
36298 res = dst + src + ((flag_X >> 8) & 1);
36299 flag_NotZ |= res;
36300 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36301 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36302 flag_N = res >> 24;
36303 DREGu32((Opcode >> 9) & 7) = res;
36304RET(8)
36305}
36306
36307// ADDXM
36308OPCODE(0xD108)
36309{
36310 u32 adr, res;
36311 u32 src, dst;
36312
36313 adr = AREG((Opcode >> 0) & 7) - 1;
36314 AREG((Opcode >> 0) & 7) = adr;
36315 PRE_IO
36316 READ_BYTE_F(adr, src)
36317 adr = AREG((Opcode >> 9) & 7) - 1;
36318 AREG((Opcode >> 9) & 7) = adr;
36319 READ_BYTE_F(adr, dst)
36320 res = dst + src + ((flag_X >> 8) & 1);
36321 flag_N = flag_X = flag_C = res;
36322 flag_V = (src ^ res) & (dst ^ res);
36323 flag_NotZ |= res & 0xFF;
36324 WRITE_BYTE_F(adr, res)
36325 POST_IO
36326RET(18)
36327}
36328
36329// ADDXM
36330OPCODE(0xD148)
36331{
36332 u32 adr, res;
36333 u32 src, dst;
36334
36335 adr = AREG((Opcode >> 0) & 7) - 2;
36336 AREG((Opcode >> 0) & 7) = adr;
36337 PRE_IO
36338 READ_WORD_F(adr, src)
36339 adr = AREG((Opcode >> 9) & 7) - 2;
36340 AREG((Opcode >> 9) & 7) = adr;
36341 READ_WORD_F(adr, dst)
36342 res = dst + src + ((flag_X >> 8) & 1);
36343 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36344 flag_N = flag_X = flag_C = res >> 8;
36345 flag_NotZ |= res & 0xFFFF;
36346 WRITE_WORD_F(adr, res)
36347 POST_IO
36348RET(18)
36349}
36350
36351// ADDXM
36352OPCODE(0xD188)
36353{
36354 u32 adr, res;
36355 u32 src, dst;
36356
36357 adr = AREG((Opcode >> 0) & 7) - 4;
36358 AREG((Opcode >> 0) & 7) = adr;
36359 PRE_IO
36360 READ_LONG_F(adr, src)
36361 adr = AREG((Opcode >> 9) & 7) - 4;
36362 AREG((Opcode >> 9) & 7) = adr;
36363 READ_LONG_F(adr, dst)
36364 res = dst + src + ((flag_X >> 8) & 1);
36365 flag_NotZ |= res;
36366 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36367 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36368 flag_N = res >> 24;
36369 WRITE_LONG_F(adr, res)
36370 POST_IO
36371RET(30)
36372}
36373
36374// ADDX7M
36375OPCODE(0xD10F)
36376{
36377 u32 adr, res;
36378 u32 src, dst;
36379
36380 adr = AREG(7) - 2;
36381 AREG(7) = adr;
36382 PRE_IO
36383 READ_BYTE_F(adr, src)
36384 adr = AREG((Opcode >> 9) & 7) - 1;
36385 AREG((Opcode >> 9) & 7) = adr;
36386 READ_BYTE_F(adr, dst)
36387 res = dst + src + ((flag_X >> 8) & 1);
36388 flag_N = flag_X = flag_C = res;
36389 flag_V = (src ^ res) & (dst ^ res);
36390 flag_NotZ |= res & 0xFF;
36391 WRITE_BYTE_F(adr, res)
36392 POST_IO
36393RET(18)
36394}
36395
36396// ADDX7M
36397OPCODE(0xD14F)
36398{
36399 u32 adr, res;
36400 u32 src, dst;
36401
36402 adr = AREG(7) - 2;
36403 AREG(7) = adr;
36404 PRE_IO
36405 READ_WORD_F(adr, src)
36406 adr = AREG((Opcode >> 9) & 7) - 2;
36407 AREG((Opcode >> 9) & 7) = adr;
36408 READ_WORD_F(adr, dst)
36409 res = dst + src + ((flag_X >> 8) & 1);
36410 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36411 flag_N = flag_X = flag_C = res >> 8;
36412 flag_NotZ |= res & 0xFFFF;
36413 WRITE_WORD_F(adr, res)
36414 POST_IO
36415RET(18)
36416}
36417
36418// ADDX7M
36419OPCODE(0xD18F)
36420{
36421 u32 adr, res;
36422 u32 src, dst;
36423
36424 adr = AREG(7) - 4;
36425 AREG(7) = adr;
36426 PRE_IO
36427 READ_LONG_F(adr, src)
36428 adr = AREG((Opcode >> 9) & 7) - 4;
36429 AREG((Opcode >> 9) & 7) = adr;
36430 READ_LONG_F(adr, dst)
36431 res = dst + src + ((flag_X >> 8) & 1);
36432 flag_NotZ |= res;
36433 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36434 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36435 flag_N = res >> 24;
36436 WRITE_LONG_F(adr, res)
36437 POST_IO
36438RET(30)
36439}
36440
36441// ADDXM7
36442OPCODE(0xDF08)
36443{
36444 u32 adr, res;
36445 u32 src, dst;
36446
36447 adr = AREG((Opcode >> 0) & 7) - 1;
36448 AREG((Opcode >> 0) & 7) = adr;
36449 PRE_IO
36450 READ_BYTE_F(adr, src)
36451 adr = AREG(7) - 2;
36452 AREG(7) = adr;
36453 READ_BYTE_F(adr, dst)
36454 res = dst + src + ((flag_X >> 8) & 1);
36455 flag_N = flag_X = flag_C = res;
36456 flag_V = (src ^ res) & (dst ^ res);
36457 flag_NotZ |= res & 0xFF;
36458 WRITE_BYTE_F(adr, res)
36459 POST_IO
36460RET(18)
36461}
36462
36463// ADDXM7
36464OPCODE(0xDF48)
36465{
36466 u32 adr, res;
36467 u32 src, dst;
36468
36469 adr = AREG((Opcode >> 0) & 7) - 2;
36470 AREG((Opcode >> 0) & 7) = adr;
36471 PRE_IO
36472 READ_WORD_F(adr, src)
36473 adr = AREG(7) - 2;
36474 AREG(7) = adr;
36475 READ_WORD_F(adr, dst)
36476 res = dst + src + ((flag_X >> 8) & 1);
36477 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36478 flag_N = flag_X = flag_C = res >> 8;
36479 flag_NotZ |= res & 0xFFFF;
36480 WRITE_WORD_F(adr, res)
36481 POST_IO
36482RET(18)
36483}
36484
36485// ADDXM7
36486OPCODE(0xDF88)
36487{
36488 u32 adr, res;
36489 u32 src, dst;
36490
36491 adr = AREG((Opcode >> 0) & 7) - 4;
36492 AREG((Opcode >> 0) & 7) = adr;
36493 PRE_IO
36494 READ_LONG_F(adr, src)
36495 adr = AREG(7) - 4;
36496 AREG(7) = adr;
36497 READ_LONG_F(adr, dst)
36498 res = dst + src + ((flag_X >> 8) & 1);
36499 flag_NotZ |= res;
36500 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36501 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36502 flag_N = res >> 24;
36503 WRITE_LONG_F(adr, res)
36504 POST_IO
36505RET(30)
36506}
36507
36508// ADDX7M7
36509OPCODE(0xDF0F)
36510{
36511 u32 adr, res;
36512 u32 src, dst;
36513
36514 adr = AREG(7) - 2;
36515 AREG(7) = adr;
36516 PRE_IO
36517 READ_BYTE_F(adr, src)
36518 adr = AREG(7) - 2;
36519 AREG(7) = adr;
36520 READ_BYTE_F(adr, dst)
36521 res = dst + src + ((flag_X >> 8) & 1);
36522 flag_N = flag_X = flag_C = res;
36523 flag_V = (src ^ res) & (dst ^ res);
36524 flag_NotZ |= res & 0xFF;
36525 WRITE_BYTE_F(adr, res)
36526 POST_IO
36527RET(18)
36528}
36529
36530// ADDX7M7
36531OPCODE(0xDF4F)
36532{
36533 u32 adr, res;
36534 u32 src, dst;
36535
36536 adr = AREG(7) - 2;
36537 AREG(7) = adr;
36538 PRE_IO
36539 READ_WORD_F(adr, src)
36540 adr = AREG(7) - 2;
36541 AREG(7) = adr;
36542 READ_WORD_F(adr, dst)
36543 res = dst + src + ((flag_X >> 8) & 1);
36544 flag_V = ((src ^ res) & (dst ^ res)) >> 8;
36545 flag_N = flag_X = flag_C = res >> 8;
36546 flag_NotZ |= res & 0xFFFF;
36547 WRITE_WORD_F(adr, res)
36548 POST_IO
36549RET(18)
36550}
36551
36552// ADDX7M7
36553OPCODE(0xDF8F)
36554{
36555 u32 adr, res;
36556 u32 src, dst;
36557
36558 adr = AREG(7) - 4;
36559 AREG(7) = adr;
36560 PRE_IO
36561 READ_LONG_F(adr, src)
36562 adr = AREG(7) - 4;
36563 AREG(7) = adr;
36564 READ_LONG_F(adr, dst)
36565 res = dst + src + ((flag_X >> 8) & 1);
36566 flag_NotZ |= res;
36567 flag_X = flag_C = ((src & dst & 1) + (src >> 1) + (dst >> 1)) >> 23;
36568 flag_V = ((src ^ res) & (dst ^ res)) >> 24;
36569 flag_N = res >> 24;
36570 WRITE_LONG_F(adr, res)
36571 POST_IO
36572RET(30)
36573}
36574
36575// ADDA
36576OPCODE(0xD0C0)
36577{
36578 u32 adr, res;
36579 u32 src, dst;
36580
36581 src = (s32)DREGs16((Opcode >> 0) & 7);
36582 dst = AREGu32((Opcode >> 9) & 7);
36583 res = dst + src;
36584 AREG((Opcode >> 9) & 7) = res;
36585RET(8)
36586}
36587
36588// ADDA
36589OPCODE(0xD0C8)
36590{
36591 u32 adr, res;
36592 u32 src, dst;
36593
36594 src = (s32)AREGs16((Opcode >> 0) & 7);
36595 dst = AREGu32((Opcode >> 9) & 7);
36596 res = dst + src;
36597 AREG((Opcode >> 9) & 7) = res;
36598RET(8)
36599}
36600
36601// ADDA
36602OPCODE(0xD0D0)
36603{
36604 u32 adr, res;
36605 u32 src, dst;
36606
36607 adr = AREG((Opcode >> 0) & 7);
36608 PRE_IO
36609 READSX_WORD_F(adr, src)
36610 dst = AREGu32((Opcode >> 9) & 7);
36611 res = dst + src;
36612 AREG((Opcode >> 9) & 7) = res;
36613 POST_IO
03e4f2a3 36614#ifdef USE_CYCLONE_TIMING
36615RET(12)
36616#else
70357ce5 36617RET(10)
03e4f2a3 36618#endif
70357ce5 36619}
36620
36621// ADDA
36622OPCODE(0xD0D8)
36623{
36624 u32 adr, res;
36625 u32 src, dst;
36626
36627 adr = AREG((Opcode >> 0) & 7);
36628 AREG((Opcode >> 0) & 7) += 2;
36629 PRE_IO
36630 READSX_WORD_F(adr, src)
36631 dst = AREGu32((Opcode >> 9) & 7);
36632 res = dst + src;
36633 AREG((Opcode >> 9) & 7) = res;
36634 POST_IO
03e4f2a3 36635#ifdef USE_CYCLONE_TIMING
36636RET(12)
36637#else
70357ce5 36638RET(10)
03e4f2a3 36639#endif
70357ce5 36640}
36641
36642// ADDA
36643OPCODE(0xD0E0)
36644{
36645 u32 adr, res;
36646 u32 src, dst;
36647
36648 adr = AREG((Opcode >> 0) & 7) - 2;
36649 AREG((Opcode >> 0) & 7) = adr;
36650 PRE_IO
36651 READSX_WORD_F(adr, src)
36652 dst = AREGu32((Opcode >> 9) & 7);
36653 res = dst + src;
36654 AREG((Opcode >> 9) & 7) = res;
36655 POST_IO
03e4f2a3 36656#ifdef USE_CYCLONE_TIMING
36657RET(14)
36658#else
70357ce5 36659RET(12)
03e4f2a3 36660#endif
70357ce5 36661}
36662
36663// ADDA
36664OPCODE(0xD0E8)
36665{
36666 u32 adr, res;
36667 u32 src, dst;
36668
36669 FETCH_SWORD(adr);
36670 adr += AREG((Opcode >> 0) & 7);
36671 PRE_IO
36672 READSX_WORD_F(adr, src)
36673 dst = AREGu32((Opcode >> 9) & 7);
36674 res = dst + src;
36675 AREG((Opcode >> 9) & 7) = res;
36676 POST_IO
03e4f2a3 36677#ifdef USE_CYCLONE_TIMING
36678RET(16)
36679#else
70357ce5 36680RET(14)
03e4f2a3 36681#endif
70357ce5 36682}
36683
36684// ADDA
36685OPCODE(0xD0F0)
36686{
36687 u32 adr, res;
36688 u32 src, dst;
36689
36690 adr = AREG((Opcode >> 0) & 7);
36691 DECODE_EXT_WORD
36692 PRE_IO
36693 READSX_WORD_F(adr, src)
36694 dst = AREGu32((Opcode >> 9) & 7);
36695 res = dst + src;
36696 AREG((Opcode >> 9) & 7) = res;
36697 POST_IO
03e4f2a3 36698#ifdef USE_CYCLONE_TIMING
36699RET(18)
36700#else
70357ce5 36701RET(16)
03e4f2a3 36702#endif
70357ce5 36703}
36704
36705// ADDA
36706OPCODE(0xD0F8)
36707{
36708 u32 adr, res;
36709 u32 src, dst;
36710
36711 FETCH_SWORD(adr);
36712 PRE_IO
36713 READSX_WORD_F(adr, src)
36714 dst = AREGu32((Opcode >> 9) & 7);
36715 res = dst + src;
36716 AREG((Opcode >> 9) & 7) = res;
36717 POST_IO
03e4f2a3 36718#ifdef USE_CYCLONE_TIMING
36719RET(16)
36720#else
70357ce5 36721RET(14)
03e4f2a3 36722#endif
70357ce5 36723}
36724
36725// ADDA
36726OPCODE(0xD0F9)
36727{
36728 u32 adr, res;
36729 u32 src, dst;
36730
36731 FETCH_LONG(adr);
36732 PRE_IO
36733 READSX_WORD_F(adr, src)
36734 dst = AREGu32((Opcode >> 9) & 7);
36735 res = dst + src;
36736 AREG((Opcode >> 9) & 7) = res;
36737 POST_IO
03e4f2a3 36738#ifdef USE_CYCLONE_TIMING
36739RET(20)
36740#else
70357ce5 36741RET(18)
03e4f2a3 36742#endif
70357ce5 36743}
36744
36745// ADDA
36746OPCODE(0xD0FA)
36747{
36748 u32 adr, res;
36749 u32 src, dst;
36750
be26eb23 36751 adr = GET_SWORD + GET_PC;
70357ce5 36752 PC++;
36753 PRE_IO
36754 READSX_WORD_F(adr, src)
36755 dst = AREGu32((Opcode >> 9) & 7);
36756 res = dst + src;
36757 AREG((Opcode >> 9) & 7) = res;
36758 POST_IO
03e4f2a3 36759#ifdef USE_CYCLONE_TIMING
36760RET(16)
36761#else
70357ce5 36762RET(14)
03e4f2a3 36763#endif
70357ce5 36764}
36765
36766// ADDA
36767OPCODE(0xD0FB)
36768{
36769 u32 adr, res;
36770 u32 src, dst;
36771
be26eb23 36772 adr = GET_PC;
70357ce5 36773 DECODE_EXT_WORD
36774 PRE_IO
36775 READSX_WORD_F(adr, src)
36776 dst = AREGu32((Opcode >> 9) & 7);
36777 res = dst + src;
36778 AREG((Opcode >> 9) & 7) = res;
36779 POST_IO
03e4f2a3 36780#ifdef USE_CYCLONE_TIMING
36781RET(18)
36782#else
70357ce5 36783RET(16)
03e4f2a3 36784#endif
70357ce5 36785}
36786
36787// ADDA
36788OPCODE(0xD0FC)
36789{
36790 u32 adr, res;
36791 u32 src, dst;
36792
36793 FETCH_SWORD(src);
36794 dst = AREGu32((Opcode >> 9) & 7);
36795 res = dst + src;
36796 AREG((Opcode >> 9) & 7) = res;
36797RET(12)
36798}
36799
36800// ADDA
36801OPCODE(0xD0DF)
36802{
36803 u32 adr, res;
36804 u32 src, dst;
36805
36806 adr = AREG(7);
36807 AREG(7) += 2;
36808 PRE_IO
36809 READSX_WORD_F(adr, src)
36810 dst = AREGu32((Opcode >> 9) & 7);
36811 res = dst + src;
36812 AREG((Opcode >> 9) & 7) = res;
36813 POST_IO
03e4f2a3 36814#ifdef USE_CYCLONE_TIMING
36815RET(12)
36816#else
70357ce5 36817RET(10)
03e4f2a3 36818#endif
70357ce5 36819}
36820
36821// ADDA
36822OPCODE(0xD0E7)
36823{
36824 u32 adr, res;
36825 u32 src, dst;
36826
36827 adr = AREG(7) - 2;
36828 AREG(7) = adr;
36829 PRE_IO
36830 READSX_WORD_F(adr, src)
36831 dst = AREGu32((Opcode >> 9) & 7);
36832 res = dst + src;
36833 AREG((Opcode >> 9) & 7) = res;
36834 POST_IO
03e4f2a3 36835#ifdef USE_CYCLONE_TIMING
36836RET(14)
36837#else
70357ce5 36838RET(12)
03e4f2a3 36839#endif
70357ce5 36840}
36841
36842// ADDA
36843OPCODE(0xD1C0)
36844{
36845 u32 adr, res;
36846 u32 src, dst;
36847
36848 src = (s32)DREGs32((Opcode >> 0) & 7);
36849 dst = AREGu32((Opcode >> 9) & 7);
36850 res = dst + src;
36851 AREG((Opcode >> 9) & 7) = res;
36852#ifdef USE_CYCLONE_TIMING
36853RET(8)
36854#else
36855RET(6)
36856#endif
36857}
36858
36859// ADDA
36860OPCODE(0xD1C8)
36861{
36862 u32 adr, res;
36863 u32 src, dst;
36864
36865 src = (s32)AREGs32((Opcode >> 0) & 7);
36866 dst = AREGu32((Opcode >> 9) & 7);
36867 res = dst + src;
36868 AREG((Opcode >> 9) & 7) = res;
36869#ifdef USE_CYCLONE_TIMING
36870RET(8)
36871#else
36872RET(6)
36873#endif
36874}
36875
36876// ADDA
36877OPCODE(0xD1D0)
36878{
36879 u32 adr, res;
36880 u32 src, dst;
36881
36882 adr = AREG((Opcode >> 0) & 7);
36883 PRE_IO
36884 READSX_LONG_F(adr, src)
36885 dst = AREGu32((Opcode >> 9) & 7);
36886 res = dst + src;
36887 AREG((Opcode >> 9) & 7) = res;
36888 POST_IO
36889RET(14)
36890}
36891
36892// ADDA
36893OPCODE(0xD1D8)
36894{
36895 u32 adr, res;
36896 u32 src, dst;
36897
36898 adr = AREG((Opcode >> 0) & 7);
36899 AREG((Opcode >> 0) & 7) += 4;
36900 PRE_IO
36901 READSX_LONG_F(adr, src)
36902 dst = AREGu32((Opcode >> 9) & 7);
36903 res = dst + src;
36904 AREG((Opcode >> 9) & 7) = res;
36905 POST_IO
36906RET(14)
36907}
36908
36909// ADDA
36910OPCODE(0xD1E0)
36911{
36912 u32 adr, res;
36913 u32 src, dst;
36914
36915 adr = AREG((Opcode >> 0) & 7) - 4;
36916 AREG((Opcode >> 0) & 7) = adr;
36917 PRE_IO
36918 READSX_LONG_F(adr, src)
36919 dst = AREGu32((Opcode >> 9) & 7);
36920 res = dst + src;
36921 AREG((Opcode >> 9) & 7) = res;
36922 POST_IO
36923RET(16)
36924}
36925
36926// ADDA
36927OPCODE(0xD1E8)
36928{
36929 u32 adr, res;
36930 u32 src, dst;
36931
36932 FETCH_SWORD(adr);
36933 adr += AREG((Opcode >> 0) & 7);
36934 PRE_IO
36935 READSX_LONG_F(adr, src)
36936 dst = AREGu32((Opcode >> 9) & 7);
36937 res = dst + src;
36938 AREG((Opcode >> 9) & 7) = res;
36939 POST_IO
36940RET(18)
36941}
36942
36943// ADDA
36944OPCODE(0xD1F0)
36945{
36946 u32 adr, res;
36947 u32 src, dst;
36948
36949 adr = AREG((Opcode >> 0) & 7);
36950 DECODE_EXT_WORD
36951 PRE_IO
36952 READSX_LONG_F(adr, src)
36953 dst = AREGu32((Opcode >> 9) & 7);
36954 res = dst + src;
36955 AREG((Opcode >> 9) & 7) = res;
36956 POST_IO
36957RET(20)
36958}
36959
36960// ADDA
36961OPCODE(0xD1F8)
36962{
36963 u32 adr, res;
36964 u32 src, dst;
36965
36966 FETCH_SWORD(adr);
36967 PRE_IO
36968 READSX_LONG_F(adr, src)
36969 dst = AREGu32((Opcode >> 9) & 7);
36970 res = dst + src;
36971 AREG((Opcode >> 9) & 7) = res;
36972 POST_IO
36973RET(18)
36974}
36975
36976// ADDA
36977OPCODE(0xD1F9)
36978{
36979 u32 adr, res;
36980 u32 src, dst;
36981
36982 FETCH_LONG(adr);
36983 PRE_IO
36984 READSX_LONG_F(adr, src)
36985 dst = AREGu32((Opcode >> 9) & 7);
36986 res = dst + src;
36987 AREG((Opcode >> 9) & 7) = res;
36988 POST_IO
36989RET(22)
36990}
36991
36992// ADDA
36993OPCODE(0xD1FA)
36994{
36995 u32 adr, res;
36996 u32 src, dst;
36997
be26eb23 36998 adr = GET_SWORD + GET_PC;
70357ce5 36999 PC++;
37000 PRE_IO
37001 READSX_LONG_F(adr, src)
37002 dst = AREGu32((Opcode >> 9) & 7);
37003 res = dst + src;
37004 AREG((Opcode >> 9) & 7) = res;
37005 POST_IO
37006RET(18)
37007}
37008
37009// ADDA
37010OPCODE(0xD1FB)
37011{
37012 u32 adr, res;
37013 u32 src, dst;
37014
be26eb23 37015 adr = GET_PC;
70357ce5 37016 DECODE_EXT_WORD
37017 PRE_IO
37018 READSX_LONG_F(adr, src)
37019 dst = AREGu32((Opcode >> 9) & 7);
37020 res = dst + src;
37021 AREG((Opcode >> 9) & 7) = res;
37022 POST_IO
37023RET(20)
37024}
37025
37026// ADDA
37027OPCODE(0xD1FC)
37028{
37029 u32 adr, res;
37030 u32 src, dst;
37031
37032 FETCH_LONG(src);
37033 dst = AREGu32((Opcode >> 9) & 7);
37034 res = dst + src;
37035 AREG((Opcode >> 9) & 7) = res;
37036#ifdef USE_CYCLONE_TIMING
37037RET(16)
37038#else
37039RET(14)
37040#endif
37041}
37042
37043// ADDA
37044OPCODE(0xD1DF)
37045{
37046 u32 adr, res;
37047 u32 src, dst;
37048
37049 adr = AREG(7);
37050 AREG(7) += 4;
37051 PRE_IO
37052 READSX_LONG_F(adr, src)
37053 dst = AREGu32((Opcode >> 9) & 7);
37054 res = dst + src;
37055 AREG((Opcode >> 9) & 7) = res;
37056 POST_IO
37057RET(14)
37058}
37059
37060// ADDA
37061OPCODE(0xD1E7)
37062{
37063 u32 adr, res;
37064 u32 src, dst;
37065
37066 adr = AREG(7) - 4;
37067 AREG(7) = adr;
37068 PRE_IO
37069 READSX_LONG_F(adr, src)
37070 dst = AREGu32((Opcode >> 9) & 7);
37071 res = dst + src;
37072 AREG((Opcode >> 9) & 7) = res;
37073 POST_IO
37074RET(16)
37075}
37076
37077// ASRk
37078OPCODE(0xE000)
37079{
37080 u32 adr, res;
37081 u32 src, dst;
37082
37083 u32 sft;
37084
37085 sft = (((Opcode >> 9) - 1) & 7) + 1;
37086 m68kcontext.io_cycle_counter -= sft * 2;
37087 src = (s32)DREGs8((Opcode >> 0) & 7);
37088 flag_V = 0;
37089 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37090 res = ((s32)src) >> sft;
37091 flag_N = res >> 0;
37092 flag_NotZ = res;
37093 DREGu8((Opcode >> 0) & 7) = res;
37094RET(6)
37095}
37096
37097// ASRk
37098OPCODE(0xE040)
37099{
37100 u32 adr, res;
37101 u32 src, dst;
37102
37103 u32 sft;
37104
37105 sft = (((Opcode >> 9) - 1) & 7) + 1;
37106 m68kcontext.io_cycle_counter -= sft * 2;
37107 src = (s32)DREGs16((Opcode >> 0) & 7);
37108 flag_V = 0;
37109 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37110 res = ((s32)src) >> sft;
37111 flag_N = res >> 8;
37112 flag_NotZ = res;
37113 DREGu16((Opcode >> 0) & 7) = res;
37114RET(6)
37115}
37116
37117// ASRk
37118OPCODE(0xE080)
37119{
37120 u32 adr, res;
37121 u32 src, dst;
37122
37123 u32 sft;
37124
37125 sft = (((Opcode >> 9) - 1) & 7) + 1;
37126 m68kcontext.io_cycle_counter -= sft * 2;
37127 src = (s32)DREGs32((Opcode >> 0) & 7);
37128 flag_V = 0;
37129 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37130 res = ((s32)src) >> sft;
37131 flag_N = res >> 24;
37132 flag_NotZ = res;
37133 DREGu32((Opcode >> 0) & 7) = res;
37134RET(8)
37135}
37136
37137// LSRk
37138OPCODE(0xE008)
37139{
37140 u32 adr, res;
37141 u32 src, dst;
37142
37143 u32 sft;
37144
37145 sft = (((Opcode >> 9) - 1) & 7) + 1;
37146 m68kcontext.io_cycle_counter -= sft * 2;
37147 src = DREGu8((Opcode >> 0) & 7);
37148 flag_N = flag_V = 0;
37149 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37150 res = src >> sft;
37151 flag_NotZ = res;
37152 DREGu8((Opcode >> 0) & 7) = res;
37153RET(6)
37154}
37155
37156// LSRk
37157OPCODE(0xE048)
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 = DREGu16((Opcode >> 0) & 7);
37167 flag_N = flag_V = 0;
37168 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37169 res = src >> sft;
37170 flag_NotZ = res;
37171 DREGu16((Opcode >> 0) & 7) = res;
37172RET(6)
37173}
37174
37175// LSRk
37176OPCODE(0xE088)
37177{
37178 u32 adr, res;
37179 u32 src, dst;
37180
37181 u32 sft;
37182
37183 sft = (((Opcode >> 9) - 1) & 7) + 1;
37184 m68kcontext.io_cycle_counter -= sft * 2;
37185 src = DREGu32((Opcode >> 0) & 7);
37186 flag_N = flag_V = 0;
37187 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37188 res = src >> sft;
37189 flag_NotZ = res;
37190 DREGu32((Opcode >> 0) & 7) = res;
37191RET(8)
37192}
37193
37194// ROXRk
37195OPCODE(0xE010)
37196{
37197 u32 adr, res;
37198 u32 src, dst;
37199
37200 u32 sft;
37201
37202 sft = (((Opcode >> 9) - 1) & 7) + 1;
37203 m68kcontext.io_cycle_counter -= sft * 2;
37204 src = DREGu8((Opcode >> 0) & 7);
37205 src |= (flag_X & M68K_SR_X) << 0;
37206 res = (src >> sft) | (src << (9 - sft));
37207 flag_X = flag_C = res >> 0;
37208 flag_V = 0;
37209 flag_N = res >> 0;
37210 flag_NotZ = res & 0x000000FF;
37211 DREGu8((Opcode >> 0) & 7) = res;
37212RET(6)
37213}
37214
37215// ROXRk
37216OPCODE(0xE050)
37217{
37218 u32 adr, res;
37219 u32 src, dst;
37220
37221 u32 sft;
37222
37223 sft = (((Opcode >> 9) - 1) & 7) + 1;
37224 m68kcontext.io_cycle_counter -= sft * 2;
37225 src = DREGu16((Opcode >> 0) & 7);
37226 src |= (flag_X & M68K_SR_X) << 8;
37227 res = (src >> sft) | (src << (17 - sft));
37228 flag_X = flag_C = res >> 8;
37229 flag_V = 0;
37230 flag_N = res >> 8;
37231 flag_NotZ = res & 0x0000FFFF;
37232 DREGu16((Opcode >> 0) & 7) = res;
37233RET(6)
37234}
37235
37236// ROXRk
37237OPCODE(0xE090)
37238{
37239 u32 adr, res;
37240 u32 src, dst;
37241
37242 u32 sft;
37243
37244 sft = (((Opcode >> 9) - 1) & 7) + 1;
37245 m68kcontext.io_cycle_counter -= sft * 2;
37246 src = DREGu32((Opcode >> 0) & 7);
37247 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37248 if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
37249 else res = (src >> sft) | (src << (33 - sft)) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + sft)));
37250 flag_X = flag_C;
37251 flag_V = 0;
37252 flag_N = res >> 24;
37253 flag_NotZ = res;
37254 DREGu32((Opcode >> 0) & 7) = res;
37255RET(8)
37256}
37257
37258// RORk
37259OPCODE(0xE018)
37260{
37261 u32 adr, res;
37262 u32 src, dst;
37263
37264 u32 sft;
37265
37266 sft = (((Opcode >> 9) - 1) & 7) + 1;
37267 m68kcontext.io_cycle_counter -= sft * 2;
37268 src = DREGu8((Opcode >> 0) & 7);
37269 flag_V = 0;
37270 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37271 res = (src >> sft) | (src << (8 - sft));
37272 flag_N = res >> 0;
37273 flag_NotZ = res & 0x000000FF;
37274 DREGu8((Opcode >> 0) & 7) = res;
37275RET(6)
37276}
37277
37278// RORk
37279OPCODE(0xE058)
37280{
37281 u32 adr, res;
37282 u32 src, dst;
37283
37284 u32 sft;
37285
37286 sft = (((Opcode >> 9) - 1) & 7) + 1;
37287 m68kcontext.io_cycle_counter -= sft * 2;
37288 src = DREGu16((Opcode >> 0) & 7);
37289 flag_V = 0;
37290 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37291 res = (src >> sft) | (src << (16 - sft));
37292 flag_N = res >> 8;
37293 flag_NotZ = res & 0x0000FFFF;
37294 DREGu16((Opcode >> 0) & 7) = res;
37295RET(6)
37296}
37297
37298// RORk
37299OPCODE(0xE098)
37300{
37301 u32 adr, res;
37302 u32 src, dst;
37303
37304 u32 sft;
37305
37306 sft = (((Opcode >> 9) - 1) & 7) + 1;
37307 m68kcontext.io_cycle_counter -= sft * 2;
37308 src = DREGu32((Opcode >> 0) & 7);
37309 flag_V = 0;
37310 flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37311 res = (src >> sft) | (src << (32 - sft));
37312 flag_N = res >> 24;
37313 flag_NotZ = res;
37314 DREGu32((Opcode >> 0) & 7) = res;
37315RET(8)
37316}
37317
37318// ASLk
37319OPCODE(0xE100)
37320{
37321 u32 adr, res;
37322 u32 src, dst;
37323
37324 u32 sft;
37325
37326 sft = (((Opcode >> 9) - 1) & 7) + 1;
37327 m68kcontext.io_cycle_counter -= sft * 2;
37328 src = DREGu8((Opcode >> 0) & 7);
37329 if (sft < 8)
37330 {
37331 flag_X = flag_C = src << (0 + sft);
37332 res = src << sft;
37333 flag_N = res >> 0;
37334 flag_NotZ = res & 0x000000FF;
37335 DREGu8((Opcode >> 0) & 7) = res;
37336 flag_V = 0;
37337 if ((sft > 7) && (src)) flag_V = M68K_SR_V;
37338 else
37339 {
37340 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
37341 src &= msk;
37342 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37343 }
37344 RET(6)
37345 }
37346
37347 if (src) flag_V = M68K_SR_V;
37348 else flag_V = 0;
37349 flag_X = flag_C = src << M68K_SR_C_SFT;
37350 res = 0;
37351 DREGu8((Opcode >> 0) & 7) = res;
37352 flag_N = 0;
37353 flag_NotZ = 0;
37354RET(6)
37355}
37356
37357// ASLk
37358OPCODE(0xE140)
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 = DREGu16((Opcode >> 0) & 7);
37368 flag_X = flag_C = src >> (8 - sft);
37369 res = src << sft;
37370 flag_N = res >> 8;
37371 flag_NotZ = res & 0x0000FFFF;
37372 DREGu16((Opcode >> 0) & 7) = res;
37373 flag_V = 0;
37374 {
37375 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
37376 src &= msk;
37377 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37378 }
37379RET(6)
37380}
37381
37382// ASLk
37383OPCODE(0xE180)
37384{
37385 u32 adr, res;
37386 u32 src, dst;
37387
37388 u32 sft;
37389
37390 sft = (((Opcode >> 9) - 1) & 7) + 1;
37391 m68kcontext.io_cycle_counter -= sft * 2;
37392 src = DREGu32((Opcode >> 0) & 7);
37393 flag_X = flag_C = src >> (24 - sft);
37394 res = src << sft;
37395 flag_N = res >> 24;
37396 flag_NotZ = res & 0xFFFFFFFF;
37397 DREGu32((Opcode >> 0) & 7) = res;
37398 flag_V = 0;
37399 {
37400 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
37401 src &= msk;
37402 if ((src) && (src != msk)) flag_V = M68K_SR_V;
37403 }
37404RET(8)
37405}
37406
37407// LSLk
37408OPCODE(0xE108)
37409{
37410 u32 adr, res;
37411 u32 src, dst;
37412
37413 u32 sft;
37414
37415 sft = (((Opcode >> 9) - 1) & 7) + 1;
37416 m68kcontext.io_cycle_counter -= sft * 2;
37417 src = DREGu8((Opcode >> 0) & 7);
37418 flag_V = 0;
37419 flag_X = flag_C = src << (0 + sft);
37420 res = src << sft;
37421 flag_N = res >> 0;
37422 flag_NotZ = res & 0x000000FF;
37423 DREGu8((Opcode >> 0) & 7) = res;
37424RET(6)
37425}
37426
37427// LSLk
37428OPCODE(0xE148)
37429{
37430 u32 adr, res;
37431 u32 src, dst;
37432
37433 u32 sft;
37434
37435 sft = (((Opcode >> 9) - 1) & 7) + 1;
37436 m68kcontext.io_cycle_counter -= sft * 2;
37437 src = DREGu16((Opcode >> 0) & 7);
37438 flag_V = 0;
37439 flag_X = flag_C = src >> (8 - sft);
37440 res = src << sft;
37441 flag_N = res >> 8;
37442 flag_NotZ = res & 0x0000FFFF;
37443 DREGu16((Opcode >> 0) & 7) = res;
37444RET(6)
37445}
37446
37447// LSLk
37448OPCODE(0xE188)
37449{
37450 u32 adr, res;
37451 u32 src, dst;
37452
37453 u32 sft;
37454
37455 sft = (((Opcode >> 9) - 1) & 7) + 1;
37456 m68kcontext.io_cycle_counter -= sft * 2;
37457 src = DREGu32((Opcode >> 0) & 7);
37458 flag_V = 0;
37459 flag_X = flag_C = src >> (24 - sft);
37460 res = src << sft;
37461 flag_N = res >> 24;
37462 flag_NotZ = res & 0xFFFFFFFF;
37463 DREGu32((Opcode >> 0) & 7) = res;
37464RET(8)
37465}
37466
37467// ROXLk
37468OPCODE(0xE110)
37469{
37470 u32 adr, res;
37471 u32 src, dst;
37472
37473 u32 sft;
37474
37475 sft = (((Opcode >> 9) - 1) & 7) + 1;
37476 m68kcontext.io_cycle_counter -= sft * 2;
37477 src = DREGu8((Opcode >> 0) & 7);
37478 src |= (flag_X & M68K_SR_X) << 0;
37479 res = (src << sft) | (src >> (9 - sft));
37480 flag_X = flag_C = res >> 0;
37481 flag_V = 0;
37482 flag_N = res >> 0;
37483 flag_NotZ = res & 0x000000FF;
37484 DREGu8((Opcode >> 0) & 7) = res;
37485RET(6)
37486}
37487
37488// ROXLk
37489OPCODE(0xE150)
37490{
37491 u32 adr, res;
37492 u32 src, dst;
37493
37494 u32 sft;
37495
37496 sft = (((Opcode >> 9) - 1) & 7) + 1;
37497 m68kcontext.io_cycle_counter -= sft * 2;
37498 src = DREGu16((Opcode >> 0) & 7);
37499 src |= (flag_X & M68K_SR_X) << 8;
37500 res = (src << sft) | (src >> (17 - sft));
37501 flag_X = flag_C = res >> 8;
37502 flag_V = 0;
37503 flag_N = res >> 8;
37504 flag_NotZ = res & 0x0000FFFF;
37505 DREGu16((Opcode >> 0) & 7) = res;
37506RET(6)
37507}
37508
37509// ROXLk
37510OPCODE(0xE190)
37511{
37512 u32 adr, res;
37513 u32 src, dst;
37514
37515 u32 sft;
37516
37517 sft = (((Opcode >> 9) - 1) & 7) + 1;
37518 m68kcontext.io_cycle_counter -= sft * 2;
37519 src = DREGu32((Opcode >> 0) & 7);
37520 flag_C = src >> ((32 - M68K_SR_C_SFT) - sft);
37521 if (sft == 1) res = (src << 1) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - 1));
37522 else res = (src << sft) | (src >> (33 - sft)) | ((flag_X & M68K_SR_X) >> ((M68K_SR_X_SFT + 1) - sft));
37523 flag_X = flag_C;
37524 flag_V = 0;
37525 flag_N = res >> 24;
37526 flag_NotZ = res;
37527 DREGu32((Opcode >> 0) & 7) = res;
37528RET(8)
37529}
37530
37531// ROLk
37532OPCODE(0xE118)
37533{
37534 u32 adr, res;
37535 u32 src, dst;
37536
37537 u32 sft;
37538
37539 sft = (((Opcode >> 9) - 1) & 7) + 1;
37540 m68kcontext.io_cycle_counter -= sft * 2;
37541 src = DREGu8((Opcode >> 0) & 7);
37542 flag_V = 0;
37543 flag_C = src << (0 + sft);
37544 res = (src << sft) | (src >> (8 - sft));
37545 flag_N = res >> 0;
37546 flag_NotZ = res & 0x000000FF;
37547 DREGu8((Opcode >> 0) & 7) = res;
37548RET(6)
37549}
37550
37551// ROLk
37552OPCODE(0xE158)
37553{
37554 u32 adr, res;
37555 u32 src, dst;
37556
37557 u32 sft;
37558
37559 sft = (((Opcode >> 9) - 1) & 7) + 1;
37560 m68kcontext.io_cycle_counter -= sft * 2;
37561 src = DREGu16((Opcode >> 0) & 7);
37562 flag_V = 0;
37563 flag_C = src >> (8 - sft);
37564 res = (src << sft) | (src >> (16 - sft));
37565 flag_N = res >> 8;
37566 flag_NotZ = res & 0x0000FFFF;
37567 DREGu16((Opcode >> 0) & 7) = res;
37568RET(6)
37569}
37570
37571// ROLk
37572OPCODE(0xE198)
37573{
37574 u32 adr, res;
37575 u32 src, dst;
37576
37577 u32 sft;
37578
37579 sft = (((Opcode >> 9) - 1) & 7) + 1;
37580 m68kcontext.io_cycle_counter -= sft * 2;
37581 src = DREGu32((Opcode >> 0) & 7);
37582 flag_V = 0;
37583 flag_C = src >> (24 - sft);
37584 res = (src << sft) | (src >> (32 - sft));
37585 flag_N = res >> 24;
37586 flag_NotZ = res;
37587 DREGu32((Opcode >> 0) & 7) = res;
37588RET(8)
37589}
37590
37591// ASRD
37592OPCODE(0xE020)
37593{
37594 u32 adr, res;
37595 u32 src, dst;
37596
37597 u32 sft;
37598
37599 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37600 src = (s32)DREGs8((Opcode >> 0) & 7);
37601 if (sft)
37602 {
37603 m68kcontext.io_cycle_counter -= sft * 2;
37604 if (sft < 8)
37605 {
37606 flag_V = 0;
37607 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37608 res = ((s32)src) >> sft;
37609 flag_N = res >> 0;
37610 flag_NotZ = res;
37611 DREGu8((Opcode >> 0) & 7) = res;
37612 RET(6)
37613 }
37614
37615 if (src & (1 << 7))
37616 {
37617 flag_N = M68K_SR_N;
37618 flag_NotZ = 1;
37619 flag_V = 0;
37620 flag_C = M68K_SR_C;
37621 flag_X = M68K_SR_X;
37622 res = 0x000000FF;
37623 DREGu8((Opcode >> 0) & 7) = res;
37624 RET(6)
37625 }
37626
37627 flag_N = 0;
37628 flag_NotZ = 0;
37629 flag_V = 0;
37630 flag_C = 0;
37631 flag_X = 0;
37632 res = 0;
37633 DREGu8((Opcode >> 0) & 7) = res;
37634 RET(6)
37635 }
37636
37637 flag_V = 0;
37638 flag_C = 0;
37639 flag_N = src >> 0;
37640 flag_NotZ = src;
37641RET(6)
37642}
37643
37644// ASRD
37645OPCODE(0xE060)
37646{
37647 u32 adr, res;
37648 u32 src, dst;
37649
37650 u32 sft;
37651
37652 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37653 src = (s32)DREGs16((Opcode >> 0) & 7);
37654 if (sft)
37655 {
37656 m68kcontext.io_cycle_counter -= sft * 2;
37657 if (sft < 16)
37658 {
37659 flag_V = 0;
37660 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37661 res = ((s32)src) >> sft;
37662 flag_N = res >> 8;
37663 flag_NotZ = res;
37664 DREGu16((Opcode >> 0) & 7) = res;
37665 RET(6)
37666 }
37667
37668 if (src & (1 << 15))
37669 {
37670 flag_N = M68K_SR_N;
37671 flag_NotZ = 1;
37672 flag_V = 0;
37673 flag_C = M68K_SR_C;
37674 flag_X = M68K_SR_X;
37675 res = 0x0000FFFF;
37676 DREGu16((Opcode >> 0) & 7) = res;
37677 RET(6)
37678 }
37679
37680 flag_N = 0;
37681 flag_NotZ = 0;
37682 flag_V = 0;
37683 flag_C = 0;
37684 flag_X = 0;
37685 res = 0;
37686 DREGu16((Opcode >> 0) & 7) = res;
37687 RET(6)
37688 }
37689
37690 flag_V = 0;
37691 flag_C = 0;
37692 flag_N = src >> 8;
37693 flag_NotZ = src;
37694RET(6)
37695}
37696
37697// ASRD
37698OPCODE(0xE0A0)
37699{
37700#ifdef USE_CYCLONE_TIMING
37701#define CYC 8
37702#else
37703#define CYC 6
37704#endif
37705 u32 adr, res;
37706 u32 src, dst;
37707
37708 u32 sft;
37709
37710 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37711 src = (s32)DREGs32((Opcode >> 0) & 7);
37712 if (sft)
37713 {
37714 m68kcontext.io_cycle_counter -= sft * 2;
37715 if (sft < 32)
37716 {
37717 flag_V = 0;
37718 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37719 res = ((s32)src) >> sft;
37720 flag_N = res >> 24;
37721 flag_NotZ = res;
37722 DREGu32((Opcode >> 0) & 7) = res;
37723 RET(CYC)
37724 }
37725
37726 if (src & (1 << 31))
37727 {
37728 flag_N = M68K_SR_N;
37729 flag_NotZ = 1;
37730 flag_V = 0;
37731 flag_C = M68K_SR_C;
37732 flag_X = M68K_SR_X;
37733 res = 0xFFFFFFFF;
37734 DREGu32((Opcode >> 0) & 7) = res;
37735 RET(CYC)
37736 }
37737
37738 flag_N = 0;
37739 flag_NotZ = 0;
37740 flag_V = 0;
37741 flag_C = 0;
37742 flag_X = 0;
37743 res = 0;
37744 DREGu32((Opcode >> 0) & 7) = res;
37745 RET(CYC)
37746 }
37747
37748 flag_V = 0;
37749 flag_C = 0;
37750 flag_N = src >> 24;
37751 flag_NotZ = src;
37752RET(CYC)
37753#undef CYC
37754}
37755
37756// LSRD
37757OPCODE(0xE028)
37758{
37759 u32 adr, res;
37760 u32 src, dst;
37761
37762 u32 sft;
37763
37764 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37765 src = DREGu8((Opcode >> 0) & 7);
37766 if (sft)
37767 {
37768 m68kcontext.io_cycle_counter -= sft * 2;
37769 if (sft <= 8)
37770 {
37771 flag_N = flag_V = 0;
37772 flag_X = flag_C = src << ((M68K_SR_C_SFT + 1) - sft);
37773 res = src >> sft;
37774 flag_NotZ = res;
37775 DREGu8((Opcode >> 0) & 7) = res;
37776 RET(6)
37777 }
37778
37779 flag_X = flag_C = 0;
37780 flag_N = 0;
37781 flag_NotZ = 0;
37782 flag_V = 0;
37783 res = 0;
37784 DREGu8((Opcode >> 0) & 7) = res;
37785 RET(6)
37786 }
37787
37788 flag_V = 0;
37789 flag_C = 0;
37790 flag_N = src >> 0;
37791 flag_NotZ = src;
37792RET(6)
37793}
37794
37795// LSRD
37796OPCODE(0xE068)
37797{
37798 u32 adr, res;
37799 u32 src, dst;
37800
37801 u32 sft;
37802
37803 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37804 src = DREGu16((Opcode >> 0) & 7);
37805 if (sft)
37806 {
37807 m68kcontext.io_cycle_counter -= sft * 2;
37808 if (sft <= 16)
37809 {
37810 flag_N = flag_V = 0;
37811 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37812 res = src >> sft;
37813 flag_NotZ = res;
37814 DREGu16((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 DREGu16((Opcode >> 0) & 7) = res;
37824 RET(6)
37825 }
37826
37827 flag_V = 0;
37828 flag_C = 0;
37829 flag_N = src >> 8;
37830 flag_NotZ = src;
37831RET(6)
37832}
37833
37834// LSRD
37835OPCODE(0xE0A8)
37836{
37837#ifdef USE_CYCLONE_TIMING
37838#define CYC 8
37839#else
37840#define CYC 6
37841#endif
37842 u32 adr, res;
37843 u32 src, dst;
37844
37845 u32 sft;
37846
37847 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37848 src = DREGu32((Opcode >> 0) & 7);
37849 if (sft)
37850 {
37851 m68kcontext.io_cycle_counter -= sft * 2;
37852 if (sft < 32)
37853 {
37854 flag_N = flag_V = 0;
37855 flag_X = flag_C = (src >> (sft - 1)) << M68K_SR_C_SFT;
37856 res = src >> sft;
37857 flag_NotZ = res;
37858 DREGu32((Opcode >> 0) & 7) = res;
37859 RET(CYC)
37860 }
37861
37862 if (sft == 32) flag_C = src >> (31 - M68K_SR_C_SFT);
37863 else flag_C = 0;
37864 flag_X = flag_C;
37865 flag_N = 0;
37866 flag_NotZ = 0;
37867 flag_V = 0;
37868 res = 0;
37869 DREGu32((Opcode >> 0) & 7) = res;
37870 RET(CYC)
37871 }
37872
37873 flag_V = 0;
37874 flag_C = 0;
37875 flag_N = src >> 24;
37876 flag_NotZ = src;
37877RET(CYC)
37878#undef CYC
37879}
37880
37881// ROXRD
37882OPCODE(0xE030)
37883{
37884 u32 adr, res;
37885 u32 src, dst;
37886
37887 u32 sft;
37888
37889 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37890 src = DREGu8((Opcode >> 0) & 7);
37891 if (sft)
37892 {
37893 m68kcontext.io_cycle_counter -= sft * 2;
37894 sft %= 9;
37895
37896 src |= (flag_X & M68K_SR_X) << 0;
37897 res = (src >> sft) | (src << (9 - sft));
37898 flag_X = flag_C = res >> 0;
37899 flag_V = 0;
37900 flag_N = res >> 0;
37901 flag_NotZ = res & 0x000000FF;
37902 DREGu8((Opcode >> 0) & 7) = res;
37903 RET(6)
37904 }
37905
37906 flag_V = 0;
37907 flag_C = flag_X;
37908 flag_N = src >> 0;
37909 flag_NotZ = src;
37910RET(6)
37911}
37912
37913// ROXRD
37914OPCODE(0xE070)
37915{
37916 u32 adr, res;
37917 u32 src, dst;
37918
37919 u32 sft;
37920
37921 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37922 src = DREGu16((Opcode >> 0) & 7);
37923 if (sft)
37924 {
37925 m68kcontext.io_cycle_counter -= sft * 2;
37926 sft %= 17;
37927
37928 src |= (flag_X & M68K_SR_X) << 8;
37929 res = (src >> sft) | (src << (17 - sft));
37930 flag_X = flag_C = res >> 8;
37931 flag_V = 0;
37932 flag_N = res >> 8;
37933 flag_NotZ = res & 0x0000FFFF;
37934 DREGu16((Opcode >> 0) & 7) = res;
37935 RET(6)
37936 }
37937
37938 flag_V = 0;
37939 flag_C = flag_X;
37940 flag_N = src >> 8;
37941 flag_NotZ = src;
37942RET(6)
37943}
37944
37945// ROXRD
37946OPCODE(0xE0B0)
37947{
37948#ifdef USE_CYCLONE_TIMING
37949#define CYC 8
37950#else
37951#define CYC 6
37952#endif
37953 u32 adr, res;
37954 u32 src, dst;
37955
37956 u32 sft;
37957
37958 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37959 src = DREGu32((Opcode >> 0) & 7);
37960 if (sft)
37961 {
37962 m68kcontext.io_cycle_counter -= sft * 2;
37963 sft %= 33;
37964
37965 if (sft != 0)
37966 {
37967 if (sft == 1) res = (src >> 1) | ((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1)));
37968 else res = (src >> sft) | (src << (33 - sft)) | (((flag_X & M68K_SR_X) << (32 - (M68K_SR_X_SFT + 1))) >> (sft - 1));
37969 flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
37970 }
37971 else res = src;
37972 flag_C = flag_X;
37973 flag_V = 0;
37974 flag_N = res >> 24;
37975 flag_NotZ = res;
37976 DREGu32((Opcode >> 0) & 7) = res;
37977 RET(CYC)
37978 }
37979
37980 flag_V = 0;
37981 flag_C = flag_X;
37982 flag_N = src >> 24;
37983 flag_NotZ = src;
37984RET(CYC)
37985#undef CYC
37986}
37987
37988// RORD
37989OPCODE(0xE038)
37990{
37991 u32 adr, res;
37992 u32 src, dst;
37993
37994 u32 sft;
37995
37996 sft = DREG((Opcode >> 9) & 7) & 0x3F;
37997 src = DREGu8((Opcode >> 0) & 7);
37998 if (sft)
37999 {
38000 m68kcontext.io_cycle_counter -= sft * 2;
38001 sft &= 0x07;
38002
38003 flag_C = src << (M68K_SR_C_SFT - ((sft - 1) & 7));
38004 res = (src >> sft) | (src << (8 - sft));
38005 flag_V = 0;
38006 flag_N = res >> 0;
38007 flag_NotZ = res & 0x000000FF;
38008 DREGu8((Opcode >> 0) & 7) = res;
38009 RET(6)
38010 }
38011
38012 flag_V = 0;
38013 flag_C = 0;
38014 flag_N = src >> 0;
38015 flag_NotZ = src;
38016RET(6)
38017}
38018
38019// RORD
38020OPCODE(0xE078)
38021{
38022 u32 adr, res;
38023 u32 src, dst;
38024
38025 u32 sft;
38026
38027 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38028 src = DREGu16((Opcode >> 0) & 7);
38029 if (sft)
38030 {
38031 m68kcontext.io_cycle_counter -= sft * 2;
38032 sft &= 0x0F;
38033
38034 flag_C = (src >> ((sft - 1) & 15)) << M68K_SR_C_SFT;
38035 res = (src >> sft) | (src << (16 - sft));
38036 flag_V = 0;
38037 flag_N = res >> 8;
38038 flag_NotZ = res & 0x0000FFFF;
38039 DREGu16((Opcode >> 0) & 7) = res;
38040 RET(6)
38041 }
38042
38043 flag_V = 0;
38044 flag_C = 0;
38045 flag_N = src >> 8;
38046 flag_NotZ = src;
38047RET(6)
38048}
38049
38050// RORD
38051OPCODE(0xE0B8)
38052{
38053#ifdef USE_CYCLONE_TIMING
38054#define CYC 8
38055#else
38056#define CYC 6
38057#endif
38058 u32 adr, res;
38059 u32 src, dst;
38060
38061 u32 sft;
38062
38063 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38064 src = DREGu32((Opcode >> 0) & 7);
38065 if (sft)
38066 {
38067 m68kcontext.io_cycle_counter -= sft * 2;
38068 sft &= 0x1F;
38069
38070 flag_C = (src >> ((sft - 1) & 31)) << M68K_SR_C_SFT;
38071 res = (src >> sft) | (src << (32 - sft));
38072 flag_V = 0;
38073 flag_N = res >> 24;
38074 flag_NotZ = res;
38075 DREGu32((Opcode >> 0) & 7) = res;
38076 RET(CYC)
38077 }
38078
38079 flag_V = 0;
38080 flag_C = 0;
38081 flag_N = src >> 24;
38082 flag_NotZ = src;
38083RET(CYC)
38084#undef CYC
38085}
38086
38087// ASLD
38088OPCODE(0xE120)
38089{
38090 u32 adr, res;
38091 u32 src, dst;
38092
38093 u32 sft;
38094
38095 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38096 src = DREGu8((Opcode >> 0) & 7);
38097 if (sft)
38098 {
38099 m68kcontext.io_cycle_counter -= sft * 2;
38100 if (sft < 8)
38101 {
38102 flag_X = flag_C = (src << sft) >> 0;
38103 res = (src << sft) & 0x000000FF;
38104 flag_N = res >> 0;
38105 flag_NotZ = res;
38106 DREGu8((Opcode >> 0) & 7) = res;
38107 flag_V = 0;
38108 {
38109 u32 msk = (((s32)0x80000000) >> (sft + 24)) & 0x000000FF;
38110 src &= msk;
38111 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38112 }
38113 RET(6)
38114 }
38115
38116 if (sft == 256) flag_C = src << M68K_SR_C_SFT;
38117 else flag_C = 0;
38118 flag_X = flag_C;
38119 if (src) flag_V = M68K_SR_V;
38120 else flag_V = 0;
38121 res = 0;
38122 DREGu8((Opcode >> 0) & 7) = res;
38123 flag_N = 0;
38124 flag_NotZ = 0;
38125 RET(6)
38126 }
38127
38128 flag_V = 0;
38129 flag_C = 0;
38130 flag_N = src >> 0;
38131 flag_NotZ = src;
38132RET(6)
38133}
38134
38135// ASLD
38136OPCODE(0xE160)
38137{
38138 u32 adr, res;
38139 u32 src, dst;
38140
38141 u32 sft;
38142
38143 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38144 src = DREGu16((Opcode >> 0) & 7);
38145 if (sft)
38146 {
38147 m68kcontext.io_cycle_counter -= sft * 2;
38148 if (sft < 16)
38149 {
38150 flag_X = flag_C = (src << sft) >> 8;
38151 res = (src << sft) & 0x0000FFFF;
38152 flag_N = res >> 8;
38153 flag_NotZ = res;
38154 DREGu16((Opcode >> 0) & 7) = res;
38155 flag_V = 0;
38156 {
38157 u32 msk = (((s32)0x80000000) >> (sft + 16)) & 0x0000FFFF;
38158 src &= msk;
38159 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38160 }
38161 RET(6)
38162 }
38163
38164 if (sft == 65536) flag_C = src << M68K_SR_C_SFT;
38165 else flag_C = 0;
38166 flag_X = flag_C;
38167 if (src) flag_V = M68K_SR_V;
38168 else flag_V = 0;
38169 res = 0;
38170 DREGu16((Opcode >> 0) & 7) = res;
38171 flag_N = 0;
38172 flag_NotZ = 0;
38173 RET(6)
38174 }
38175
38176 flag_V = 0;
38177 flag_C = 0;
38178 flag_N = src >> 8;
38179 flag_NotZ = src;
38180RET(6)
38181}
38182
38183// ASLD
38184OPCODE(0xE1A0)
38185{
38186#ifdef USE_CYCLONE_TIMING
38187#define CYC 8
38188#else
38189#define CYC 6
38190#endif
38191 u32 adr, res;
38192 u32 src, dst;
38193
38194 u32 sft;
38195
38196 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38197 src = DREGu32((Opcode >> 0) & 7);
38198 if (sft)
38199 {
38200 m68kcontext.io_cycle_counter -= sft * 2;
38201 if (sft < 32)
38202 {
38203 flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38204 res = src << sft;
38205 flag_N = res >> 24;
38206 flag_NotZ = res;
38207 DREGu32((Opcode >> 0) & 7) = res;
38208 flag_V = 0;
38209 {
38210 u32 msk = (((s32)0x80000000) >> (sft + 0)) & 0xFFFFFFFF;
38211 src &= msk;
38212 if ((src) && (src != msk)) flag_V = M68K_SR_V;
38213 }
38214 RET(CYC)
38215 }
38216
38217 if (sft == 0) flag_C = src << M68K_SR_C_SFT;
38218 else flag_C = 0;
38219 flag_X = flag_C;
38220 if (src) flag_V = M68K_SR_V;
38221 else flag_V = 0;
38222 res = 0;
38223 DREGu32((Opcode >> 0) & 7) = res;
38224 flag_N = 0;
38225 flag_NotZ = 0;
38226 RET(CYC)
38227 }
38228
38229 flag_V = 0;
38230 flag_C = 0;
38231 flag_N = src >> 24;
38232 flag_NotZ = src;
38233RET(CYC)
38234#undef CYC
38235}
38236
38237// LSLD
38238OPCODE(0xE128)
38239{
38240 u32 adr, res;
38241 u32 src, dst;
38242
38243 u32 sft;
38244
38245 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38246 src = DREGu8((Opcode >> 0) & 7);
38247 if (sft)
38248 {
38249 m68kcontext.io_cycle_counter -= sft * 2;
38250 if (sft <= 8)
38251 {
38252 flag_X = flag_C = (src << sft) >> 0;
38253 res = (src << sft) & 0x000000FF;
38254 flag_V = 0;
38255 flag_N = res >> 0;
38256 flag_NotZ = res;
38257 DREGu8((Opcode >> 0) & 7) = res;
38258 RET(6)
38259 }
38260
38261 flag_X = flag_C = 0;
38262 flag_N = 0;
38263 flag_NotZ = 0;
38264 flag_V = 0;
38265 res = 0;
38266 DREGu8((Opcode >> 0) & 7) = res;
38267 RET(6)
38268 }
38269
38270 flag_V = 0;
38271 flag_C = 0;
38272 flag_N = src >> 0;
38273 flag_NotZ = src;
38274RET(6)
38275}
38276
38277// LSLD
38278OPCODE(0xE168)
38279{
38280 u32 adr, res;
38281 u32 src, dst;
38282
38283 u32 sft;
38284
38285 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38286 src = DREGu16((Opcode >> 0) & 7);
38287 if (sft)
38288 {
38289 m68kcontext.io_cycle_counter -= sft * 2;
38290 if (sft <= 16)
38291 {
38292 flag_X = flag_C = (src << sft) >> 8;
38293 res = (src << sft) & 0x0000FFFF;
38294 flag_V = 0;
38295 flag_N = res >> 8;
38296 flag_NotZ = res;
38297 DREGu16((Opcode >> 0) & 7) = res;
38298 RET(6)
38299 }
38300
38301 flag_X = flag_C = 0;
38302 flag_N = 0;
38303 flag_NotZ = 0;
38304 flag_V = 0;
38305 res = 0;
38306 DREGu16((Opcode >> 0) & 7) = res;
38307 RET(6)
38308 }
38309
38310 flag_V = 0;
38311 flag_C = 0;
38312 flag_N = src >> 8;
38313 flag_NotZ = src;
38314RET(6)
38315}
38316
38317// LSLD
38318OPCODE(0xE1A8)
38319{
38320#ifdef USE_CYCLONE_TIMING
38321#define CYC 8
38322#else
38323#define CYC 6
38324#endif
38325 u32 adr, res;
38326 u32 src, dst;
38327
38328 u32 sft;
38329
38330 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38331 src = DREGu32((Opcode >> 0) & 7);
38332 if (sft)
38333 {
38334 m68kcontext.io_cycle_counter -= sft * 2;
38335 if (sft < 32)
38336 {
38337 flag_X = flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38338 res = src << sft;
38339 flag_V = 0;
38340 flag_N = res >> 24;
38341 flag_NotZ = res;
38342 DREGu32((Opcode >> 0) & 7) = res;
38343 RET(CYC)
38344 }
38345
38346 if (sft == 32) flag_C = src << M68K_SR_C_SFT;
38347 else flag_C = 0;
38348 flag_X = flag_C;
38349 flag_N = 0;
38350 flag_NotZ = 0;
38351 flag_V = 0;
38352 res = 0;
38353 DREGu32((Opcode >> 0) & 7) = res;
38354 RET(CYC)
38355 }
38356
38357 flag_V = 0;
38358 flag_C = 0;
38359 flag_N = src >> 24;
38360 flag_NotZ = src;
38361RET(CYC)
38362#undef CYC
38363}
38364
38365// ROXLD
38366OPCODE(0xE130)
38367{
38368 u32 adr, res;
38369 u32 src, dst;
38370
38371 u32 sft;
38372
38373 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38374 src = DREGu8((Opcode >> 0) & 7);
38375 if (sft)
38376 {
38377 m68kcontext.io_cycle_counter -= sft * 2;
38378 sft %= 9;
38379
38380 src |= (flag_X & M68K_SR_X) << 0;
38381 res = (src << sft) | (src >> (9 - sft));
38382 flag_X = flag_C = res >> 0;
38383 flag_V = 0;
38384 flag_N = res >> 0;
38385 flag_NotZ = res & 0x000000FF;
38386 DREGu8((Opcode >> 0) & 7) = res;
38387 RET(6)
38388 }
38389
38390 flag_V = 0;
38391 flag_C = flag_X;
38392 flag_N = src >> 0;
38393 flag_NotZ = src;
38394RET(6)
38395}
38396
38397// ROXLD
38398OPCODE(0xE170)
38399{
38400 u32 adr, res;
38401 u32 src, dst;
38402
38403 u32 sft;
38404
38405 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38406 src = DREGu16((Opcode >> 0) & 7);
38407 if (sft)
38408 {
38409 m68kcontext.io_cycle_counter -= sft * 2;
38410 sft %= 17;
38411
38412 src |= (flag_X & M68K_SR_X) << 8;
38413 res = (src << sft) | (src >> (17 - sft));
38414 flag_X = flag_C = res >> 8;
38415 flag_V = 0;
38416 flag_N = res >> 8;
38417 flag_NotZ = res & 0x0000FFFF;
38418 DREGu16((Opcode >> 0) & 7) = res;
38419 RET(6)
38420 }
38421
38422 flag_V = 0;
38423 flag_C = flag_X;
38424 flag_N = src >> 8;
38425 flag_NotZ = src;
38426RET(6)
38427}
38428
38429// ROXLD
38430OPCODE(0xE1B0)
38431{
38432#ifdef USE_CYCLONE_TIMING
38433#define CYC 8
38434#else
38435#define CYC 6
38436#endif
38437 u32 adr, res;
38438 u32 src, dst;
38439
38440 u32 sft;
38441
38442 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38443 src = DREGu32((Opcode >> 0) & 7);
38444 if (sft)
38445 {
38446 m68kcontext.io_cycle_counter -= sft * 2;
38447 sft %= 33;
38448
38449 if (sft != 0)
38450 {
38451 if (sft == 1) res = (src << 1) | ((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1);
38452 else res = (src << sft) | (src >> (33 - sft)) | (((flag_X >> ((M68K_SR_X_SFT + 1) - 1)) & 1) << (sft - 1));
38453 flag_X = (src >> (32 - sft)) << M68K_SR_X_SFT;
38454 }
38455 else res = src;
38456 flag_C = flag_X;
38457 flag_V = 0;
38458 flag_N = res >> 24;
38459 flag_NotZ = res;
38460 DREGu32((Opcode >> 0) & 7) = res;
38461 RET(CYC)
38462 }
38463
38464 flag_V = 0;
38465 flag_C = flag_X;
38466 flag_N = src >> 24;
38467 flag_NotZ = src;
38468RET(CYC)
38469#undef CYC
38470}
38471
38472// ROLD
38473OPCODE(0xE138)
38474{
38475 u32 adr, res;
38476 u32 src, dst;
38477
38478 u32 sft;
38479
38480 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38481 src = DREGu8((Opcode >> 0) & 7);
38482 if (sft)
38483 {
38484 m68kcontext.io_cycle_counter -= sft * 2;
38485 if (sft &= 0x07)
38486 {
38487 flag_C = (src << sft) >> 0;
38488 res = ((src << sft) | (src >> (8 - sft))) & 0x000000FF;
38489 flag_V = 0;
38490 flag_N = res >> 0;
38491 flag_NotZ = res;
38492 DREGu8((Opcode >> 0) & 7) = res;
38493 RET(6)
38494 }
38495
38496 flag_V = 0;
38497 flag_C = src << M68K_SR_C_SFT;
38498 flag_N = src >> 0;
38499 flag_NotZ = src;
38500 RET(6)
38501 }
38502
38503 flag_V = 0;
38504 flag_C = 0;
38505 flag_N = src >> 0;
38506 flag_NotZ = src;
38507RET(6)
38508}
38509
38510// ROLD
38511OPCODE(0xE178)
38512{
38513 u32 adr, res;
38514 u32 src, dst;
38515
38516 u32 sft;
38517
38518 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38519 src = DREGu16((Opcode >> 0) & 7);
38520 if (sft)
38521 {
38522 m68kcontext.io_cycle_counter -= sft * 2;
38523 if (sft &= 0x0F)
38524 {
38525 flag_C = (src << sft) >> 8;
38526 res = ((src << sft) | (src >> (16 - sft))) & 0x0000FFFF;
38527 flag_V = 0;
38528 flag_N = res >> 8;
38529 flag_NotZ = res;
38530 DREGu16((Opcode >> 0) & 7) = res;
38531 RET(6)
38532 }
38533
38534 flag_V = 0;
38535 flag_C = src << M68K_SR_C_SFT;
38536 flag_N = src >> 8;
38537 flag_NotZ = src;
38538 RET(6)
38539 }
38540
38541 flag_V = 0;
38542 flag_C = 0;
38543 flag_N = src >> 8;
38544 flag_NotZ = src;
38545RET(6)
38546}
38547
38548// ROLD
38549OPCODE(0xE1B8)
38550{
38551#ifdef USE_CYCLONE_TIMING
38552#define CYC 8
38553#else
38554#define CYC 6
38555#endif
38556 u32 adr, res;
38557 u32 src, dst;
38558
38559 u32 sft;
38560
38561 sft = DREG((Opcode >> 9) & 7) & 0x3F;
38562 src = DREGu32((Opcode >> 0) & 7);
38563 if (sft)
38564 {
38565 m68kcontext.io_cycle_counter -= sft * 2;
38566 if (sft &= 0x1F)
38567 {
38568 flag_C = (src >> (32 - sft)) << M68K_SR_C_SFT;
38569 res = (src << sft) | (src >> (32 - sft));
38570 flag_V = 0;
38571 flag_N = res >> 24;
38572 flag_NotZ = res;
38573 DREGu32((Opcode >> 0) & 7) = res;
38574 RET(CYC)
38575 }
38576
38577 flag_V = 0;
38578 flag_C = src << M68K_SR_C_SFT;
38579 flag_N = src >> 24;
38580 flag_NotZ = src;
38581 RET(CYC)
38582 }
38583
38584 flag_V = 0;
38585 flag_C = 0;
38586 flag_N = src >> 24;
38587 flag_NotZ = src;
38588RET(CYC)
38589#undef CYC
38590}
38591
38592// ASR
38593OPCODE(0xE0D0)
38594{
38595 u32 adr, res;
38596 u32 src, dst;
38597
38598 adr = AREG((Opcode >> 0) & 7);
38599 PRE_IO
38600 READ_WORD_F(adr, src)
38601 flag_V = 0;
38602 flag_X = flag_C = src << M68K_SR_C_SFT;
38603 res = (src >> 1) | (src & (1 << 15));
38604 flag_N = res >> 8;
38605 flag_NotZ = res;
38606 WRITE_WORD_F(adr, res)
38607 POST_IO
38608RET(12)
38609}
38610
38611// ASR
38612OPCODE(0xE0D8)
38613{
38614 u32 adr, res;
38615 u32 src, dst;
38616
38617 adr = AREG((Opcode >> 0) & 7);
38618 AREG((Opcode >> 0) & 7) += 2;
38619 PRE_IO
38620 READ_WORD_F(adr, src)
38621 flag_V = 0;
38622 flag_X = flag_C = src << M68K_SR_C_SFT;
38623 res = (src >> 1) | (src & (1 << 15));
38624 flag_N = res >> 8;
38625 flag_NotZ = res;
38626 WRITE_WORD_F(adr, res)
38627 POST_IO
38628RET(12)
38629}
38630
38631// ASR
38632OPCODE(0xE0E0)
38633{
38634 u32 adr, res;
38635 u32 src, dst;
38636
38637 adr = AREG((Opcode >> 0) & 7) - 2;
38638 AREG((Opcode >> 0) & 7) = adr;
38639 PRE_IO
38640 READ_WORD_F(adr, src)
38641 flag_V = 0;
38642 flag_X = flag_C = src << M68K_SR_C_SFT;
38643 res = (src >> 1) | (src & (1 << 15));
38644 flag_N = res >> 8;
38645 flag_NotZ = res;
38646 WRITE_WORD_F(adr, res)
38647 POST_IO
38648RET(14)
38649}
38650
38651// ASR
38652OPCODE(0xE0E8)
38653{
38654 u32 adr, res;
38655 u32 src, dst;
38656
38657 FETCH_SWORD(adr);
38658 adr += AREG((Opcode >> 0) & 7);
38659 PRE_IO
38660 READ_WORD_F(adr, src)
38661 flag_V = 0;
38662 flag_X = flag_C = src << M68K_SR_C_SFT;
38663 res = (src >> 1) | (src & (1 << 15));
38664 flag_N = res >> 8;
38665 flag_NotZ = res;
38666 WRITE_WORD_F(adr, res)
38667 POST_IO
38668RET(16)
38669}
38670
38671// ASR
38672OPCODE(0xE0F0)
38673{
38674 u32 adr, res;
38675 u32 src, dst;
38676
38677 adr = AREG((Opcode >> 0) & 7);
38678 DECODE_EXT_WORD
38679 PRE_IO
38680 READ_WORD_F(adr, src)
38681 flag_V = 0;
38682 flag_X = flag_C = src << M68K_SR_C_SFT;
38683 res = (src >> 1) | (src & (1 << 15));
38684 flag_N = res >> 8;
38685 flag_NotZ = res;
38686 WRITE_WORD_F(adr, res)
38687 POST_IO
38688RET(18)
38689}
38690
38691// ASR
38692OPCODE(0xE0F8)
38693{
38694 u32 adr, res;
38695 u32 src, dst;
38696
38697 FETCH_SWORD(adr);
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(0xE0F9)
38712{
38713 u32 adr, res;
38714 u32 src, dst;
38715
38716 FETCH_LONG(adr);
38717 PRE_IO
38718 READ_WORD_F(adr, src)
38719 flag_V = 0;
38720 flag_X = flag_C = src << M68K_SR_C_SFT;
38721 res = (src >> 1) | (src & (1 << 15));
38722 flag_N = res >> 8;
38723 flag_NotZ = res;
38724 WRITE_WORD_F(adr, res)
38725 POST_IO
38726RET(20)
38727}
38728
38729// ASR
38730OPCODE(0xE0DF)
38731{
38732 u32 adr, res;
38733 u32 src, dst;
38734
38735 adr = AREG(7);
38736 AREG(7) += 2;
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(12)
38747}
38748
38749// ASR
38750OPCODE(0xE0E7)
38751{
38752 u32 adr, res;
38753 u32 src, dst;
38754
38755 adr = AREG(7) - 2;
38756 AREG(7) = adr;
38757 PRE_IO
38758 READ_WORD_F(adr, src)
38759 flag_V = 0;
38760 flag_X = flag_C = src << M68K_SR_C_SFT;
38761 res = (src >> 1) | (src & (1 << 15));
38762 flag_N = res >> 8;
38763 flag_NotZ = res;
38764 WRITE_WORD_F(adr, res)
38765 POST_IO
38766RET(14)
38767}
38768
38769// LSR
38770OPCODE(0xE2D0)
38771{
38772 u32 adr, res;
38773 u32 src, dst;
38774
38775 adr = AREG((Opcode >> 0) & 7);
38776 PRE_IO
38777 READ_WORD_F(adr, src)
38778 flag_N = flag_V = 0;
38779 flag_X = flag_C = src << M68K_SR_C_SFT;
38780 res = src >> 1;
38781 flag_NotZ = res;
38782 WRITE_WORD_F(adr, res)
38783 POST_IO
38784RET(12)
38785}
38786
38787// LSR
38788OPCODE(0xE2D8)
38789{
38790 u32 adr, res;
38791 u32 src, dst;
38792
38793 adr = AREG((Opcode >> 0) & 7);
38794 AREG((Opcode >> 0) & 7) += 2;
38795 PRE_IO
38796 READ_WORD_F(adr, src)
38797 flag_N = flag_V = 0;
38798 flag_X = flag_C = src << M68K_SR_C_SFT;
38799 res = src >> 1;
38800 flag_NotZ = res;
38801 WRITE_WORD_F(adr, res)
38802 POST_IO
38803RET(12)
38804}
38805
38806// LSR
38807OPCODE(0xE2E0)
38808{
38809 u32 adr, res;
38810 u32 src, dst;
38811
38812 adr = AREG((Opcode >> 0) & 7) - 2;
38813 AREG((Opcode >> 0) & 7) = adr;
38814 PRE_IO
38815 READ_WORD_F(adr, src)
38816 flag_N = flag_V = 0;
38817 flag_X = flag_C = src << M68K_SR_C_SFT;
38818 res = src >> 1;
38819 flag_NotZ = res;
38820 WRITE_WORD_F(adr, res)
38821 POST_IO
38822RET(14)
38823}
38824
38825// LSR
38826OPCODE(0xE2E8)
38827{
38828 u32 adr, res;
38829 u32 src, dst;
38830
38831 FETCH_SWORD(adr);
38832 adr += AREG((Opcode >> 0) & 7);
38833 PRE_IO
38834 READ_WORD_F(adr, src)
38835 flag_N = flag_V = 0;
38836 flag_X = flag_C = src << M68K_SR_C_SFT;
38837 res = src >> 1;
38838 flag_NotZ = res;
38839 WRITE_WORD_F(adr, res)
38840 POST_IO
38841RET(16)
38842}
38843
38844// LSR
38845OPCODE(0xE2F0)
38846{
38847 u32 adr, res;
38848 u32 src, dst;
38849
38850 adr = AREG((Opcode >> 0) & 7);
38851 DECODE_EXT_WORD
38852 PRE_IO
38853 READ_WORD_F(adr, src)
38854 flag_N = flag_V = 0;
38855 flag_X = flag_C = src << M68K_SR_C_SFT;
38856 res = src >> 1;
38857 flag_NotZ = res;
38858 WRITE_WORD_F(adr, res)
38859 POST_IO
38860RET(18)
38861}
38862
38863// LSR
38864OPCODE(0xE2F8)
38865{
38866 u32 adr, res;
38867 u32 src, dst;
38868
38869 FETCH_SWORD(adr);
38870 PRE_IO
38871 READ_WORD_F(adr, src)
38872 flag_N = flag_V = 0;
38873 flag_X = flag_C = src << M68K_SR_C_SFT;
38874 res = src >> 1;
38875 flag_NotZ = res;
38876 WRITE_WORD_F(adr, res)
38877 POST_IO
38878RET(16)
38879}
38880
38881// LSR
38882OPCODE(0xE2F9)
38883{
38884 u32 adr, res;
38885 u32 src, dst;
38886
38887 FETCH_LONG(adr);
38888 PRE_IO
38889 READ_WORD_F(adr, src)
38890 flag_N = flag_V = 0;
38891 flag_X = flag_C = src << M68K_SR_C_SFT;
38892 res = src >> 1;
38893 flag_NotZ = res;
38894 WRITE_WORD_F(adr, res)
38895 POST_IO
38896RET(20)
38897}
38898
38899// LSR
38900OPCODE(0xE2DF)
38901{
38902 u32 adr, res;
38903 u32 src, dst;
38904
38905 adr = AREG(7);
38906 AREG(7) += 2;
38907 PRE_IO
38908 READ_WORD_F(adr, src)
38909 flag_N = flag_V = 0;
38910 flag_X = flag_C = src << M68K_SR_C_SFT;
38911 res = src >> 1;
38912 flag_NotZ = res;
38913 WRITE_WORD_F(adr, res)
38914 POST_IO
38915RET(12)
38916}
38917
38918// LSR
38919OPCODE(0xE2E7)
38920{
38921 u32 adr, res;
38922 u32 src, dst;
38923
38924 adr = AREG(7) - 2;
38925 AREG(7) = adr;
38926 PRE_IO
38927 READ_WORD_F(adr, src)
38928 flag_N = flag_V = 0;
38929 flag_X = flag_C = src << M68K_SR_C_SFT;
38930 res = src >> 1;
38931 flag_NotZ = res;
38932 WRITE_WORD_F(adr, res)
38933 POST_IO
38934RET(14)
38935}
38936
38937// ROXR
38938OPCODE(0xE4D0)
38939{
38940 u32 adr, res;
38941 u32 src, dst;
38942
38943 adr = AREG((Opcode >> 0) & 7);
38944 PRE_IO
38945 READ_WORD_F(adr, src)
38946 flag_V = 0;
38947 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38948 flag_C = flag_X = src << M68K_SR_C_SFT;
38949 flag_N = res >> 8;
38950 flag_NotZ = res;
38951 WRITE_WORD_F(adr, res)
38952 POST_IO
38953RET(12)
38954}
38955
38956// ROXR
38957OPCODE(0xE4D8)
38958{
38959 u32 adr, res;
38960 u32 src, dst;
38961
38962 adr = AREG((Opcode >> 0) & 7);
38963 AREG((Opcode >> 0) & 7) += 2;
38964 PRE_IO
38965 READ_WORD_F(adr, src)
38966 flag_V = 0;
38967 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38968 flag_C = flag_X = src << M68K_SR_C_SFT;
38969 flag_N = res >> 8;
38970 flag_NotZ = res;
38971 WRITE_WORD_F(adr, res)
38972 POST_IO
38973RET(12)
38974}
38975
38976// ROXR
38977OPCODE(0xE4E0)
38978{
38979 u32 adr, res;
38980 u32 src, dst;
38981
38982 adr = AREG((Opcode >> 0) & 7) - 2;
38983 AREG((Opcode >> 0) & 7) = adr;
38984 PRE_IO
38985 READ_WORD_F(adr, src)
38986 flag_V = 0;
38987 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
38988 flag_C = flag_X = src << M68K_SR_C_SFT;
38989 flag_N = res >> 8;
38990 flag_NotZ = res;
38991 WRITE_WORD_F(adr, res)
38992 POST_IO
38993RET(14)
38994}
38995
38996// ROXR
38997OPCODE(0xE4E8)
38998{
38999 u32 adr, res;
39000 u32 src, dst;
39001
39002 FETCH_SWORD(adr);
39003 adr += AREG((Opcode >> 0) & 7);
39004 PRE_IO
39005 READ_WORD_F(adr, src)
39006 flag_V = 0;
39007 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39008 flag_C = flag_X = src << M68K_SR_C_SFT;
39009 flag_N = res >> 8;
39010 flag_NotZ = res;
39011 WRITE_WORD_F(adr, res)
39012 POST_IO
39013RET(16)
39014}
39015
39016// ROXR
39017OPCODE(0xE4F0)
39018{
39019 u32 adr, res;
39020 u32 src, dst;
39021
39022 adr = AREG((Opcode >> 0) & 7);
39023 DECODE_EXT_WORD
39024 PRE_IO
39025 READ_WORD_F(adr, src)
39026 flag_V = 0;
39027 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39028 flag_C = flag_X = src << M68K_SR_C_SFT;
39029 flag_N = res >> 8;
39030 flag_NotZ = res;
39031 WRITE_WORD_F(adr, res)
39032 POST_IO
39033RET(18)
39034}
39035
39036// ROXR
39037OPCODE(0xE4F8)
39038{
39039 u32 adr, res;
39040 u32 src, dst;
39041
39042 FETCH_SWORD(adr);
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(0xE4F9)
39057{
39058 u32 adr, res;
39059 u32 src, dst;
39060
39061 FETCH_LONG(adr);
39062 PRE_IO
39063 READ_WORD_F(adr, src)
39064 flag_V = 0;
39065 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39066 flag_C = flag_X = src << M68K_SR_C_SFT;
39067 flag_N = res >> 8;
39068 flag_NotZ = res;
39069 WRITE_WORD_F(adr, res)
39070 POST_IO
39071RET(20)
39072}
39073
39074// ROXR
39075OPCODE(0xE4DF)
39076{
39077 u32 adr, res;
39078 u32 src, dst;
39079
39080 adr = AREG(7);
39081 AREG(7) += 2;
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(12)
39092}
39093
39094// ROXR
39095OPCODE(0xE4E7)
39096{
39097 u32 adr, res;
39098 u32 src, dst;
39099
39100 adr = AREG(7) - 2;
39101 AREG(7) = adr;
39102 PRE_IO
39103 READ_WORD_F(adr, src)
39104 flag_V = 0;
39105 res = (src >> 1) | ((flag_X & M68K_SR_X) << 7);
39106 flag_C = flag_X = src << M68K_SR_C_SFT;
39107 flag_N = res >> 8;
39108 flag_NotZ = res;
39109 WRITE_WORD_F(adr, res)
39110 POST_IO
39111RET(14)
39112}
39113
39114// ROR
39115OPCODE(0xE6D0)
39116{
39117 u32 adr, res;
39118 u32 src, dst;
39119
39120 adr = AREG((Opcode >> 0) & 7);
39121 PRE_IO
39122 READ_WORD_F(adr, src)
39123 flag_V = 0;
39124 flag_C = src << M68K_SR_C_SFT;
39125 res = (src >> 1) | (src << 15);
39126 flag_N = res >> 8;
39127 flag_NotZ = res & 0x0000FFFF;
39128 WRITE_WORD_F(adr, res)
39129 POST_IO
39130RET(12)
39131}
39132
39133// ROR
39134OPCODE(0xE6D8)
39135{
39136 u32 adr, res;
39137 u32 src, dst;
39138
39139 adr = AREG((Opcode >> 0) & 7);
39140 AREG((Opcode >> 0) & 7) += 2;
39141 PRE_IO
39142 READ_WORD_F(adr, src)
39143 flag_V = 0;
39144 flag_C = src << M68K_SR_C_SFT;
39145 res = (src >> 1) | (src << 15);
39146 flag_N = res >> 8;
39147 flag_NotZ = res & 0x0000FFFF;
39148 WRITE_WORD_F(adr, res)
39149 POST_IO
39150RET(12)
39151}
39152
39153// ROR
39154OPCODE(0xE6E0)
39155{
39156 u32 adr, res;
39157 u32 src, dst;
39158
39159 adr = AREG((Opcode >> 0) & 7) - 2;
39160 AREG((Opcode >> 0) & 7) = adr;
39161 PRE_IO
39162 READ_WORD_F(adr, src)
39163 flag_V = 0;
39164 flag_C = src << M68K_SR_C_SFT;
39165 res = (src >> 1) | (src << 15);
39166 flag_N = res >> 8;
39167 flag_NotZ = res & 0x0000FFFF;
39168 WRITE_WORD_F(adr, res)
39169 POST_IO
39170RET(14)
39171}
39172
39173// ROR
39174OPCODE(0xE6E8)
39175{
39176 u32 adr, res;
39177 u32 src, dst;
39178
39179 FETCH_SWORD(adr);
39180 adr += AREG((Opcode >> 0) & 7);
39181 PRE_IO
39182 READ_WORD_F(adr, src)
39183 flag_V = 0;
39184 flag_C = src << M68K_SR_C_SFT;
39185 res = (src >> 1) | (src << 15);
39186 flag_N = res >> 8;
39187 flag_NotZ = res & 0x0000FFFF;
39188 WRITE_WORD_F(adr, res)
39189 POST_IO
39190RET(16)
39191}
39192
39193// ROR
39194OPCODE(0xE6F0)
39195{
39196 u32 adr, res;
39197 u32 src, dst;
39198
39199 adr = AREG((Opcode >> 0) & 7);
39200 DECODE_EXT_WORD
39201 PRE_IO
39202 READ_WORD_F(adr, src)
39203 flag_V = 0;
39204 flag_C = src << M68K_SR_C_SFT;
39205 res = (src >> 1) | (src << 15);
39206 flag_N = res >> 8;
39207 flag_NotZ = res & 0x0000FFFF;
39208 WRITE_WORD_F(adr, res)
39209 POST_IO
39210RET(18)
39211}
39212
39213// ROR
39214OPCODE(0xE6F8)
39215{
39216 u32 adr, res;
39217 u32 src, dst;
39218
39219 FETCH_SWORD(adr);
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(0xE6F9)
39234{
39235 u32 adr, res;
39236 u32 src, dst;
39237
39238 FETCH_LONG(adr);
39239 PRE_IO
39240 READ_WORD_F(adr, src)
39241 flag_V = 0;
39242 flag_C = src << M68K_SR_C_SFT;
39243 res = (src >> 1) | (src << 15);
39244 flag_N = res >> 8;
39245 flag_NotZ = res & 0x0000FFFF;
39246 WRITE_WORD_F(adr, res)
39247 POST_IO
39248RET(20)
39249}
39250
39251// ROR
39252OPCODE(0xE6DF)
39253{
39254 u32 adr, res;
39255 u32 src, dst;
39256
39257 adr = AREG(7);
39258 AREG(7) += 2;
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(12)
39269}
39270
39271// ROR
39272OPCODE(0xE6E7)
39273{
39274 u32 adr, res;
39275 u32 src, dst;
39276
39277 adr = AREG(7) - 2;
39278 AREG(7) = adr;
39279 PRE_IO
39280 READ_WORD_F(adr, src)
39281 flag_V = 0;
39282 flag_C = src << M68K_SR_C_SFT;
39283 res = (src >> 1) | (src << 15);
39284 flag_N = res >> 8;
39285 flag_NotZ = res & 0x0000FFFF;
39286 WRITE_WORD_F(adr, res)
39287 POST_IO
39288RET(14)
39289}
39290
39291// ASL
39292OPCODE(0xE1D0)
39293{
39294 u32 adr, res;
39295 u32 src, dst;
39296
39297 adr = AREG((Opcode >> 0) & 7);
39298 PRE_IO
39299 READ_WORD_F(adr, src)
39300 flag_X = flag_C = src >> 7;
39301 res = src << 1;
39302 flag_V = (src ^ res) >> 8;
39303 flag_N = res >> 8;
39304 flag_NotZ = res & 0x0000FFFF;
39305 WRITE_WORD_F(adr, res)
39306 POST_IO
39307RET(12)
39308}
39309
39310// ASL
39311OPCODE(0xE1D8)
39312{
39313 u32 adr, res;
39314 u32 src, dst;
39315
39316 adr = AREG((Opcode >> 0) & 7);
39317 AREG((Opcode >> 0) & 7) += 2;
39318 PRE_IO
39319 READ_WORD_F(adr, src)
39320 flag_X = flag_C = src >> 7;
39321 res = src << 1;
39322 flag_V = (src ^ res) >> 8;
39323 flag_N = res >> 8;
39324 flag_NotZ = res & 0x0000FFFF;
39325 WRITE_WORD_F(adr, res)
39326 POST_IO
39327RET(12)
39328}
39329
39330// ASL
39331OPCODE(0xE1E0)
39332{
39333 u32 adr, res;
39334 u32 src, dst;
39335
39336 adr = AREG((Opcode >> 0) & 7) - 2;
39337 AREG((Opcode >> 0) & 7) = adr;
39338 PRE_IO
39339 READ_WORD_F(adr, src)
39340 flag_X = flag_C = src >> 7;
39341 res = src << 1;
39342 flag_V = (src ^ res) >> 8;
39343 flag_N = res >> 8;
39344 flag_NotZ = res & 0x0000FFFF;
39345 WRITE_WORD_F(adr, res)
39346 POST_IO
39347RET(14)
39348}
39349
39350// ASL
39351OPCODE(0xE1E8)
39352{
39353 u32 adr, res;
39354 u32 src, dst;
39355
39356 FETCH_SWORD(adr);
39357 adr += AREG((Opcode >> 0) & 7);
39358 PRE_IO
39359 READ_WORD_F(adr, src)
39360 flag_X = flag_C = src >> 7;
39361 res = src << 1;
39362 flag_V = (src ^ res) >> 8;
39363 flag_N = res >> 8;
39364 flag_NotZ = res & 0x0000FFFF;
39365 WRITE_WORD_F(adr, res)
39366 POST_IO
39367RET(16)
39368}
39369
39370// ASL
39371OPCODE(0xE1F0)
39372{
39373 u32 adr, res;
39374 u32 src, dst;
39375
39376 adr = AREG((Opcode >> 0) & 7);
39377 DECODE_EXT_WORD
39378 PRE_IO
39379 READ_WORD_F(adr, src)
39380 flag_X = flag_C = src >> 7;
39381 res = src << 1;
39382 flag_V = (src ^ res) >> 8;
39383 flag_N = res >> 8;
39384 flag_NotZ = res & 0x0000FFFF;
39385 WRITE_WORD_F(adr, res)
39386 POST_IO
39387RET(18)
39388}
39389
39390// ASL
39391OPCODE(0xE1F8)
39392{
39393 u32 adr, res;
39394 u32 src, dst;
39395
39396 FETCH_SWORD(adr);
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(0xE1F9)
39411{
39412 u32 adr, res;
39413 u32 src, dst;
39414
39415 FETCH_LONG(adr);
39416 PRE_IO
39417 READ_WORD_F(adr, src)
39418 flag_X = flag_C = src >> 7;
39419 res = src << 1;
39420 flag_V = (src ^ res) >> 8;
39421 flag_N = res >> 8;
39422 flag_NotZ = res & 0x0000FFFF;
39423 WRITE_WORD_F(adr, res)
39424 POST_IO
39425RET(20)
39426}
39427
39428// ASL
39429OPCODE(0xE1DF)
39430{
39431 u32 adr, res;
39432 u32 src, dst;
39433
39434 adr = AREG(7);
39435 AREG(7) += 2;
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(12)
39446}
39447
39448// ASL
39449OPCODE(0xE1E7)
39450{
39451 u32 adr, res;
39452 u32 src, dst;
39453
39454 adr = AREG(7) - 2;
39455 AREG(7) = adr;
39456 PRE_IO
39457 READ_WORD_F(adr, src)
39458 flag_X = flag_C = src >> 7;
39459 res = src << 1;
39460 flag_V = (src ^ res) >> 8;
39461 flag_N = res >> 8;
39462 flag_NotZ = res & 0x0000FFFF;
39463 WRITE_WORD_F(adr, res)
39464 POST_IO
39465RET(14)
39466}
39467
39468// LSL
39469OPCODE(0xE3D0)
39470{
39471 u32 adr, res;
39472 u32 src, dst;
39473
39474 adr = AREG((Opcode >> 0) & 7);
39475 PRE_IO
39476 READ_WORD_F(adr, src)
39477 flag_V = 0;
39478 flag_X = flag_C = src >> 7;
39479 res = src << 1;
39480 flag_N = res >> 8;
39481 flag_NotZ = res & 0x0000FFFF;
39482 WRITE_WORD_F(adr, res)
39483 POST_IO
39484RET(12)
39485}
39486
39487// LSL
39488OPCODE(0xE3D8)
39489{
39490 u32 adr, res;
39491 u32 src, dst;
39492
39493 adr = AREG((Opcode >> 0) & 7);
39494 AREG((Opcode >> 0) & 7) += 2;
39495 PRE_IO
39496 READ_WORD_F(adr, src)
39497 flag_V = 0;
39498 flag_X = flag_C = src >> 7;
39499 res = src << 1;
39500 flag_N = res >> 8;
39501 flag_NotZ = res & 0x0000FFFF;
39502 WRITE_WORD_F(adr, res)
39503 POST_IO
39504RET(12)
39505}
39506
39507// LSL
39508OPCODE(0xE3E0)
39509{
39510 u32 adr, res;
39511 u32 src, dst;
39512
39513 adr = AREG((Opcode >> 0) & 7) - 2;
39514 AREG((Opcode >> 0) & 7) = adr;
39515 PRE_IO
39516 READ_WORD_F(adr, src)
39517 flag_V = 0;
39518 flag_X = flag_C = src >> 7;
39519 res = src << 1;
39520 flag_N = res >> 8;
39521 flag_NotZ = res & 0x0000FFFF;
39522 WRITE_WORD_F(adr, res)
39523 POST_IO
39524RET(14)
39525}
39526
39527// LSL
39528OPCODE(0xE3E8)
39529{
39530 u32 adr, res;
39531 u32 src, dst;
39532
39533 FETCH_SWORD(adr);
39534 adr += AREG((Opcode >> 0) & 7);
39535 PRE_IO
39536 READ_WORD_F(adr, src)
39537 flag_V = 0;
39538 flag_X = flag_C = src >> 7;
39539 res = src << 1;
39540 flag_N = res >> 8;
39541 flag_NotZ = res & 0x0000FFFF;
39542 WRITE_WORD_F(adr, res)
39543 POST_IO
39544RET(16)
39545}
39546
39547// LSL
39548OPCODE(0xE3F0)
39549{
39550 u32 adr, res;
39551 u32 src, dst;
39552
39553 adr = AREG((Opcode >> 0) & 7);
39554 DECODE_EXT_WORD
39555 PRE_IO
39556 READ_WORD_F(adr, src)
39557 flag_V = 0;
39558 flag_X = flag_C = src >> 7;
39559 res = src << 1;
39560 flag_N = res >> 8;
39561 flag_NotZ = res & 0x0000FFFF;
39562 WRITE_WORD_F(adr, res)
39563 POST_IO
39564RET(18)
39565}
39566
39567// LSL
39568OPCODE(0xE3F8)
39569{
39570 u32 adr, res;
39571 u32 src, dst;
39572
39573 FETCH_SWORD(adr);
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(0xE3F9)
39588{
39589 u32 adr, res;
39590 u32 src, dst;
39591
39592 FETCH_LONG(adr);
39593 PRE_IO
39594 READ_WORD_F(adr, src)
39595 flag_V = 0;
39596 flag_X = flag_C = src >> 7;
39597 res = src << 1;
39598 flag_N = res >> 8;
39599 flag_NotZ = res & 0x0000FFFF;
39600 WRITE_WORD_F(adr, res)
39601 POST_IO
39602RET(20)
39603}
39604
39605// LSL
39606OPCODE(0xE3DF)
39607{
39608 u32 adr, res;
39609 u32 src, dst;
39610
39611 adr = AREG(7);
39612 AREG(7) += 2;
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(12)
39623}
39624
39625// LSL
39626OPCODE(0xE3E7)
39627{
39628 u32 adr, res;
39629 u32 src, dst;
39630
39631 adr = AREG(7) - 2;
39632 AREG(7) = adr;
39633 PRE_IO
39634 READ_WORD_F(adr, src)
39635 flag_V = 0;
39636 flag_X = flag_C = src >> 7;
39637 res = src << 1;
39638 flag_N = res >> 8;
39639 flag_NotZ = res & 0x0000FFFF;
39640 WRITE_WORD_F(adr, res)
39641 POST_IO
39642RET(14)
39643}
39644
39645// ROXL
39646OPCODE(0xE5D0)
39647{
39648 u32 adr, res;
39649 u32 src, dst;
39650
39651 adr = AREG((Opcode >> 0) & 7);
39652 PRE_IO
39653 READ_WORD_F(adr, src)
39654 flag_V = 0;
39655 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39656 flag_X = flag_C = src >> 7;
39657 flag_N = res >> 8;
39658 flag_NotZ = res & 0x0000FFFF;
39659 WRITE_WORD_F(adr, res)
39660 POST_IO
39661RET(12)
39662}
39663
39664// ROXL
39665OPCODE(0xE5D8)
39666{
39667 u32 adr, res;
39668 u32 src, dst;
39669
39670 adr = AREG((Opcode >> 0) & 7);
39671 AREG((Opcode >> 0) & 7) += 2;
39672 PRE_IO
39673 READ_WORD_F(adr, src)
39674 flag_V = 0;
39675 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39676 flag_X = flag_C = src >> 7;
39677 flag_N = res >> 8;
39678 flag_NotZ = res & 0x0000FFFF;
39679 WRITE_WORD_F(adr, res)
39680 POST_IO
39681RET(12)
39682}
39683
39684// ROXL
39685OPCODE(0xE5E0)
39686{
39687 u32 adr, res;
39688 u32 src, dst;
39689
39690 adr = AREG((Opcode >> 0) & 7) - 2;
39691 AREG((Opcode >> 0) & 7) = adr;
39692 PRE_IO
39693 READ_WORD_F(adr, src)
39694 flag_V = 0;
39695 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39696 flag_X = flag_C = src >> 7;
39697 flag_N = res >> 8;
39698 flag_NotZ = res & 0x0000FFFF;
39699 WRITE_WORD_F(adr, res)
39700 POST_IO
39701RET(14)
39702}
39703
39704// ROXL
39705OPCODE(0xE5E8)
39706{
39707 u32 adr, res;
39708 u32 src, dst;
39709
39710 FETCH_SWORD(adr);
39711 adr += AREG((Opcode >> 0) & 7);
39712 PRE_IO
39713 READ_WORD_F(adr, src)
39714 flag_V = 0;
39715 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39716 flag_X = flag_C = src >> 7;
39717 flag_N = res >> 8;
39718 flag_NotZ = res & 0x0000FFFF;
39719 WRITE_WORD_F(adr, res)
39720 POST_IO
39721RET(16)
39722}
39723
39724// ROXL
39725OPCODE(0xE5F0)
39726{
39727 u32 adr, res;
39728 u32 src, dst;
39729
39730 adr = AREG((Opcode >> 0) & 7);
39731 DECODE_EXT_WORD
39732 PRE_IO
39733 READ_WORD_F(adr, src)
39734 flag_V = 0;
39735 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39736 flag_X = flag_C = src >> 7;
39737 flag_N = res >> 8;
39738 flag_NotZ = res & 0x0000FFFF;
39739 WRITE_WORD_F(adr, res)
39740 POST_IO
39741RET(18)
39742}
39743
39744// ROXL
39745OPCODE(0xE5F8)
39746{
39747 u32 adr, res;
39748 u32 src, dst;
39749
39750 FETCH_SWORD(adr);
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(0xE5F9)
39765{
39766 u32 adr, res;
39767 u32 src, dst;
39768
39769 FETCH_LONG(adr);
39770 PRE_IO
39771 READ_WORD_F(adr, src)
39772 flag_V = 0;
39773 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39774 flag_X = flag_C = src >> 7;
39775 flag_N = res >> 8;
39776 flag_NotZ = res & 0x0000FFFF;
39777 WRITE_WORD_F(adr, res)
39778 POST_IO
39779RET(20)
39780}
39781
39782// ROXL
39783OPCODE(0xE5DF)
39784{
39785 u32 adr, res;
39786 u32 src, dst;
39787
39788 adr = AREG(7);
39789 AREG(7) += 2;
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(12)
39800}
39801
39802// ROXL
39803OPCODE(0xE5E7)
39804{
39805 u32 adr, res;
39806 u32 src, dst;
39807
39808 adr = AREG(7) - 2;
39809 AREG(7) = adr;
39810 PRE_IO
39811 READ_WORD_F(adr, src)
39812 flag_V = 0;
39813 res = (src << 1) | ((flag_X & M68K_SR_X) >> 8);
39814 flag_X = flag_C = src >> 7;
39815 flag_N = res >> 8;
39816 flag_NotZ = res & 0x0000FFFF;
39817 WRITE_WORD_F(adr, res)
39818 POST_IO
39819RET(14)
39820}
39821
39822// ROL
39823OPCODE(0xE7D0)
39824{
39825 u32 adr, res;
39826 u32 src, dst;
39827
39828 adr = AREG((Opcode >> 0) & 7);
39829 PRE_IO
39830 READ_WORD_F(adr, src)
39831 flag_V = 0;
39832 flag_C = src >> 7;
39833 res = (src << 1) | (src >> 15);
39834 flag_N = res >> 8;
39835 flag_NotZ = res & 0x0000FFFF;
39836 WRITE_WORD_F(adr, res)
39837 POST_IO
39838RET(12)
39839}
39840
39841// ROL
39842OPCODE(0xE7D8)
39843{
39844 u32 adr, res;
39845 u32 src, dst;
39846
39847 adr = AREG((Opcode >> 0) & 7);
39848 AREG((Opcode >> 0) & 7) += 2;
39849 PRE_IO
39850 READ_WORD_F(adr, src)
39851 flag_V = 0;
39852 flag_C = src >> 7;
39853 res = (src << 1) | (src >> 15);
39854 flag_N = res >> 8;
39855 flag_NotZ = res & 0x0000FFFF;
39856 WRITE_WORD_F(adr, res)
39857 POST_IO
39858RET(12)
39859}
39860
39861// ROL
39862OPCODE(0xE7E0)
39863{
39864 u32 adr, res;
39865 u32 src, dst;
39866
39867 adr = AREG((Opcode >> 0) & 7) - 2;
39868 AREG((Opcode >> 0) & 7) = adr;
39869 PRE_IO
39870 READ_WORD_F(adr, src)
39871 flag_V = 0;
39872 flag_C = src >> 7;
39873 res = (src << 1) | (src >> 15);
39874 flag_N = res >> 8;
39875 flag_NotZ = res & 0x0000FFFF;
39876 WRITE_WORD_F(adr, res)
39877 POST_IO
39878RET(14)
39879}
39880
39881// ROL
39882OPCODE(0xE7E8)
39883{
39884 u32 adr, res;
39885 u32 src, dst;
39886
39887 FETCH_SWORD(adr);
39888 adr += AREG((Opcode >> 0) & 7);
39889 PRE_IO
39890 READ_WORD_F(adr, src)
39891 flag_V = 0;
39892 flag_C = src >> 7;
39893 res = (src << 1) | (src >> 15);
39894 flag_N = res >> 8;
39895 flag_NotZ = res & 0x0000FFFF;
39896 WRITE_WORD_F(adr, res)
39897 POST_IO
39898RET(16)
39899}
39900
39901// ROL
39902OPCODE(0xE7F0)
39903{
39904 u32 adr, res;
39905 u32 src, dst;
39906
39907 adr = AREG((Opcode >> 0) & 7);
39908 DECODE_EXT_WORD
39909 PRE_IO
39910 READ_WORD_F(adr, src)
39911 flag_V = 0;
39912 flag_C = src >> 7;
39913 res = (src << 1) | (src >> 15);
39914 flag_N = res >> 8;
39915 flag_NotZ = res & 0x0000FFFF;
39916 WRITE_WORD_F(adr, res)
39917 POST_IO
39918RET(18)
39919}
39920
39921// ROL
39922OPCODE(0xE7F8)
39923{
39924 u32 adr, res;
39925 u32 src, dst;
39926
39927 FETCH_SWORD(adr);
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(0xE7F9)
39942{
39943 u32 adr, res;
39944 u32 src, dst;
39945
39946 FETCH_LONG(adr);
39947 PRE_IO
39948 READ_WORD_F(adr, src)
39949 flag_V = 0;
39950 flag_C = src >> 7;
39951 res = (src << 1) | (src >> 15);
39952 flag_N = res >> 8;
39953 flag_NotZ = res & 0x0000FFFF;
39954 WRITE_WORD_F(adr, res)
39955 POST_IO
39956RET(20)
39957}
39958
39959// ROL
39960OPCODE(0xE7DF)
39961{
39962 u32 adr, res;
39963 u32 src, dst;
39964
39965 adr = AREG(7);
39966 AREG(7) += 2;
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(12)
39977}
39978
39979// ROL
39980OPCODE(0xE7E7)
39981{
39982 u32 adr, res;
39983 u32 src, dst;
39984
39985 adr = AREG(7) - 2;
39986 AREG(7) = adr;
39987 PRE_IO
39988 READ_WORD_F(adr, src)
39989 flag_V = 0;
39990 flag_C = src >> 7;
39991 res = (src << 1) | (src >> 15);
39992 flag_N = res >> 8;
39993 flag_NotZ = res & 0x0000FFFF;
39994 WRITE_WORD_F(adr, res)
39995 POST_IO
39996RET(14)
39997}
39998
c060a9ab 39999#ifdef PICODRIVE_HACK
8187ba84 40000#if 0
40001#define UPDATE_IDLE_COUNT { \
40002 extern int idle_hit_counter; \
40003 idle_hit_counter++; \
40004}
40005#else
40006#define UPDATE_IDLE_COUNT
40007#endif
40008
c060a9ab 40009// BRA
40010OPCODE(0x6001_idle)
40011{
40012#ifdef FAMEC_CHECK_BRANCHES
be26eb23 40013 u32 newPC = GET_PC;
c060a9ab 40014 s8 offs=Opcode;
40015 newPC += offs;
40016 SET_PC(newPC);
40017 CHECK_BRANCH_EXCEPTION(offs)
40018#else
40019 PC += ((s8)(Opcode & 0xFE)) >> 1;
40020#endif
8187ba84 40021 UPDATE_IDLE_COUNT
fcf94fcc 40022RET0()
c060a9ab 40023}
40024
40025// BCC
40026OPCODE(0x6601_idle)
40027{
40028 if (flag_NotZ)
40029 {
8187ba84 40030 UPDATE_IDLE_COUNT
c060a9ab 40031 PC += ((s8)(Opcode & 0xFE)) >> 1;
fcf94fcc 40032 //if (idle_hit)
40033 RET0()
c060a9ab 40034 }
40035RET(8)
40036}
40037
40038OPCODE(0x6701_idle)
40039{
40040 if (!flag_NotZ)
40041 {
8187ba84 40042 UPDATE_IDLE_COUNT
c060a9ab 40043 PC += ((s8)(Opcode & 0xFE)) >> 1;
fcf94fcc 40044 //if (idle_hit)
40045 RET0()
c060a9ab 40046 }
40047RET(8)
40048}
40049
40050
0219d379 40051extern int SekIsIdleReady(void);
c060a9ab 40052extern int SekIsIdleCode(unsigned short *dst, int bytes);
5ed2a20e 40053extern int SekRegisterIdlePatch(unsigned int pc, int oldop, int newop, void *ctx);
c060a9ab 40054
40055OPCODE(idle_detector_bcc8)
40056{
c060a9ab 40057 int frame_count, cond_true, bytes, ret, newop;
40058 u16 *dest_pc;
40059
40060 dest_pc = PC + (((s8)(Opcode & 0xFE)) >> 1);
40061
0219d379 40062 if (!SekIsIdleReady())
c060a9ab 40063 goto end;
40064
40065 bytes = 0 - (s8)(Opcode & 0xFE) - 2;
40066 ret = SekIsIdleCode(dest_pc, bytes);
40067 newop = (Opcode & 0xfe) | 0x7100;
40068 if (!ret) newop |= 0x200;
5ed2a20e 40069 if ( Opcode & 0x0100) newop |= 0x400; // beq
40070 if (!(Opcode & 0x0f00)) newop |= 0xc00; // bra
c060a9ab 40071
5ed2a20e 40072 ret = SekRegisterIdlePatch(GET_PC - 2, Opcode, newop, &m68kcontext);
c060a9ab 40073 switch (ret)
40074 {
40075 case 0: PC[-1] = newop; break;
40076 case 1: break;
5ed2a20e 40077 case 2: JumpTable[Opcode] = (Opcode & 0x0f00) ?
40078 ((Opcode & 0x0100) ? CAST_OP(0x6701) : CAST_OP(0x6601)) :
40079 CAST_OP(0x6001); break;
c060a9ab 40080 }
40081
40082end:
5ed2a20e 40083 if ((Opcode & 0xff00) == 0x6000) cond_true = 1;
40084 else cond_true = (Opcode & 0x0100) ? !flag_NotZ : flag_NotZ; // beq?
c060a9ab 40085 if (cond_true)
40086 {
40087 PC = dest_pc;
40088 m68kcontext.io_cycle_counter -= 2;
40089 }
40090RET(8)
40091}
40092
c060a9ab 40093#endif // PICODRIVE_HACK
fast MegaDrive/MegaCD/32X emulator