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