3 // Given an extended register number, translate it into an index into the
4 // register array. This is necessary as the upper 8 extended registers are
5 // actually synonyms for the d0-d3/a0-a3 registers.
9 :function:::int:translate_rreg:int rreg
12 /* The higher register numbers actually correspond to the
13 basic machine's address and data registers. */
14 if (rreg > 7 && rreg < 12)
15 return REG_A0 + rreg - 8;
16 else if (rreg > 11 && rreg < 16)
17 return REG_D0 + rreg - 12;
22 // 1111 0000 0010 00An; mov USP,An
23 8.0xf0+4.0x2,00,2.AN0:D0m:::mov
28 State.regs[REG_A0 + AN0] = State.regs[REG_USP];
32 // 1111 0000 0010 01An; mov SSP,An
33 8.0xf0+4.0x2,01,2.AN0:D0n:::mov
38 State.regs[REG_A0 + AN0] = State.regs[REG_SSP];
42 // 1111 0000 0010 10An; mov MSP,An
43 8.0xf0+4.0x2,10,2.AN0:D0o:::mov
48 State.regs[REG_A0 + AN0] = State.regs[REG_MSP];
52 // 1111 0000 0010 11An; mov PC,An
53 8.0xf0+4.0x2,11,2.AN0:D0p:::mov
58 State.regs[REG_A0 + AN0] = PC;
62 // 1111 0000 0011 Am00; mov Am,USP
63 8.0xf0+4.0x3,2.AM1,00:D0q:::mov
68 State.regs[REG_USP] = State.regs[REG_A0 + AM1];
71 // 1111 0000 0011 Am01; mov Am,SSP
72 8.0xf0+4.0x3,2.AM1,01:D0r:::mov
77 State.regs[REG_SSP] = State.regs[REG_A0 + AM1];
80 // 1111 0000 0011 Am10; mov Am,MSP
81 8.0xf0+4.0x3,2.AM1,10:D0s:::mov
86 State.regs[REG_MSP] = State.regs[REG_A0 + AM1];
90 // 1111 0000 1110 imm4; syscall
91 8.0xf0+4.0xe,IMM4:D0t:::syscall
95 unsigned int sp, next_pc;
98 sp = State.regs[REG_SP];
99 next_pc = State.regs[REG_PC] + 2;
100 store_word (sp - 4, next_pc);
101 store_word (sp - 8, PSW);
102 State.regs[REG_PC] = 0x40000000 + IMM4 * 8;
107 // 1111 0010 1110 11Dn; mov EPSW,Dn
108 8.0xf2+4.0xe,11,2.DN0:D0u:::mov
113 State.regs[REG_D0 + DN0] = PSW;
117 // 1111 0010 1111 Dm01; mov Dm,EPSW
118 8.0xf2+4.0xf,2.DM1,01:D0v:::mov
123 PSW = State.regs[REG_D0 + DM1];
126 // 1111 0101 00Am Rn; mov Am,Rn
127 8.0xf5+00,2.AM1,4.RN0:D0w:::mov
131 int destreg = translate_rreg (SD_, RN0);
134 State.regs[destreg] = State.regs[REG_A0 + AM1];
137 // 1111 0101 01Dm Rn; mov Dm,Rn
138 8.0xf5+01,2.DM1,4.RN0:D0x:::mov
142 int destreg = translate_rreg (SD_, RN0);
145 State.regs[destreg] = State.regs[REG_D0 + DM1];
148 // 1111 0101 10Rm An; mov Rm,An
149 8.0xf5+10,4.RM1,2.AN0:D0y:::mov
153 int destreg = translate_rreg (SD_, RM1);
156 State.regs[REG_A0 + AN0] = State.regs[destreg];
159 // 1111 0101 11Rm Dn; mov Rm,Dn
160 8.0xf5+11,4.RM1,2.DN0:D0z:::mov
164 int destreg = translate_rreg (SD_, RM1);
167 State.regs[REG_D0 + DN0] = State.regs[destreg];
171 // 1111 1000 1100 1110 regs....; movm (USP),regs
172 8.0xf8+8.0xce+8.REGS:D1a:::movm
176 unsigned long usp = State.regs[REG_USP];
185 State.regs[REG_LAR] = load_word (usp);
187 State.regs[REG_LIR] = load_word (usp);
189 State.regs[REG_MDR] = load_word (usp);
191 State.regs[REG_A0 + 1] = load_word (usp);
193 State.regs[REG_A0] = load_word (usp);
195 State.regs[REG_D0 + 1] = load_word (usp);
197 State.regs[REG_D0] = load_word (usp);
203 State.regs[REG_A0 + 3] = load_word (usp);
209 State.regs[REG_A0 + 2] = load_word (usp);
215 State.regs[REG_D0 + 3] = load_word (usp);
221 State.regs[REG_D0 + 2] = load_word (usp);
225 /* start-sanitize-am33 */
226 if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_am33)
230 /* Need to restore MDQR, MCRH, MCRL, and MCVF */
232 State.regs[REG_E0 + 1] = load_word (usp);
234 State.regs[REG_E0 + 0] = load_word (usp);
240 State.regs[REG_E0 + 7] = load_word (usp);
242 State.regs[REG_E0 + 6] = load_word (usp);
244 State.regs[REG_E0 + 5] = load_word (usp);
246 State.regs[REG_E0 + 4] = load_word (usp);
252 State.regs[REG_E0 + 3] = load_word (usp);
254 State.regs[REG_E0 + 2] = load_word (usp);
258 /* end-sanitize-am33 */
260 /* And make sure to update the stack pointer. */
261 State.regs[REG_USP] = usp;
264 // 1111 1000 1100 1111 regs....; movm (USP),regs
265 8.0xf8+8.0xcf+8.REGS:D1b:::movm
269 unsigned long usp = State.regs[REG_USP];
272 if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_am33)
277 store_word (usp, State.regs[REG_E0 + 2]);
279 store_word (usp, State.regs[REG_E0 + 3]);
285 store_word (usp, State.regs[REG_E0 + 4]);
287 store_word (usp, State.regs[REG_E0 + 5]);
289 store_word (usp, State.regs[REG_E0 + 6]);
291 store_word (usp, State.regs[REG_E0 + 7]);
297 store_word (usp, State.regs[REG_E0 + 0]);
299 store_word (usp, State.regs[REG_E0 + 1]);
301 /* Need to save MDQR, MCRH, MCRL, and MCVF */
304 /* end-sanitize-am33 */
309 store_word (usp, State.regs[REG_D0 + 2]);
315 store_word (usp, State.regs[REG_D0 + 3]);
321 store_word (usp, State.regs[REG_A0 + 2]);
327 store_word (usp, State.regs[REG_A0 + 3]);
333 store_word (usp, State.regs[REG_D0]);
335 store_word (usp, State.regs[REG_D0 + 1]);
337 store_word (usp, State.regs[REG_A0]);
339 store_word (usp, State.regs[REG_A0 + 1]);
341 store_word (usp, State.regs[REG_MDR]);
343 store_word (usp, State.regs[REG_LIR]);
345 store_word (usp, State.regs[REG_LAR]);
349 /* And make sure to update the stack pointer. */
350 State.regs[REG_USP] = usp;
353 // 1111 1100 1111 1100 imm32...; and imm32,EPSW
354 8.0xfc+8.0xfc+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:4a:::and
359 PSW &= FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
362 // 1111 1100 1111 1101 imm32...; or imm32,EPSW
363 8.0xfc+8.0xfd+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D4a:::or
368 PSW |= FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
371 // 1111 1001 0000 1000 Rm Rn; mov Rm,Rn (Rm != Rn)
372 8.0xf9+8.0x08+4.RM2,4.RN0!RM2:D1g:::mov
380 srcreg = translate_rreg (SD_, RM2);
381 dstreg = translate_rreg (SD_, RN0);
382 State.regs[dstreg] = State.regs[srcreg];
385 // 1111 1001 0001 1000 Rn Rn; ext Rn
386 8.0xf9+8.0x18+4.RN0,4.RN2=RN0:D1:::ext
393 srcreg = translate_rreg (SD_, RN0);
394 if (State.regs[srcreg] & 0x80000000)
395 State.regs[REG_MDR] = -1;
397 State.regs[REG_MDR] = 0;
400 // 1111 1001 0010 1000 Rm Rn; extb Rm,Rn
401 8.0xf9+8.0x28+4.RM2,4.RN0!RM2:D1:::extb
408 srcreg = translate_rreg (SD_, RM2);
409 dstreg = translate_rreg (SD_, RN0);
410 State.regs[dstreg] = EXTEND8 (State.regs[srcreg]);
413 // 1111 1001 0011 1000 Rm Rn; extbu Rm,Rn
414 8.0xf9+8.0x38+4.RM2,4.RN0!RM2:D1:::extbu
421 srcreg = translate_rreg (SD_, RM2);
422 dstreg = translate_rreg (SD_, RN0);
423 State.regs[dstreg] = State.regs[srcreg] & 0xff;
426 // 1111 1001 0100 1000 Rm Rn; exth Rm,Rn
427 8.0xf9+8.0x48+4.RM2,4.RN0!RM2:D1:::exth
434 srcreg = translate_rreg (SD_, RM2);
435 dstreg = translate_rreg (SD_, RN0);
436 State.regs[dstreg] = EXTEND16 (State.regs[srcreg]);
439 // 1111 1001 0101 1000 Rm Rn; exthu Rm,Rn
440 8.0xf9+8.0x58+4.RM2,4.RN0!RM2:D1:::exthu
447 srcreg = translate_rreg (SD_, RM2);
448 dstreg = translate_rreg (SD_, RN0);
449 State.regs[dstreg] = State.regs[srcreg] & 0xffff;
452 // 1111 1001 0110 1000 Rn Rn; clr Rn
453 8.0xf9+8.0x68+4.RM2,4.RN0=RM2:D1:::clr
460 dstreg = translate_rreg (SD_, RN0);
461 State.regs[dstreg] = 0;
463 PSW &= ~(PSW_V | PSW_C | PSW_N);
466 // 1111 1001 0111 1000 Rm Rn; add Rm,Rn
467 8.0xf9+8.0x78+4.RM2,4.RN0:D1b:::add
474 srcreg = translate_rreg (SD_, RM2);
475 dstreg = translate_rreg (SD_, RN0);
476 genericAdd (State.regs[srcreg], dstreg);
479 // 1111 1001 1000 1000 Rm Rn; addc Rm,Rn
480 8.0xf9+8.0x88+4.RM2,4.RN0:D1b:::addc
486 unsigned long reg1, reg2, sum;
489 srcreg = translate_rreg (SD_, RM2);
490 dstreg = translate_rreg (SD_, RN0);
492 reg1 = State.regs[srcreg];
493 reg2 = State.regs[dstreg];
494 sum = reg1 + reg2 + ((PSW & PSW_C) != 0);
495 State.regs[dstreg] = sum;
497 z = ((PSW & PSW_Z) != 0) && (sum == 0);
498 n = (sum & 0x80000000);
499 c = (sum < reg1) || (sum < reg2);
500 v = ((reg2 & 0x80000000) == (reg1 & 0x80000000)
501 && (reg2 & 0x80000000) != (sum & 0x80000000));
503 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
504 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
505 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
508 // 1111 1001 1001 1000 Rm Rn; sub Rm,Rn
509 8.0xf9+8.0x98+4.RM2,4.RN0:D1b:::sub
516 srcreg = translate_rreg (SD_, RM2);
517 dstreg = translate_rreg (SD_, RN0);
518 genericSub (State.regs[srcreg], dstreg);
521 // 1111 1001 1010 1000 Rm Rn; subc Rm,Rn
522 8.0xf9+8.0xa8+4.RM2,4.RN0:D1b:::subc
528 unsigned long reg1, reg2, difference;
531 srcreg = translate_rreg (SD_, RM2);
532 dstreg = translate_rreg (SD_, RN0);
534 reg1 = State.regs[srcreg];
535 reg2 = State.regs[dstreg];
536 difference = reg2 - reg1 - ((PSW & PSW_C) != 0);
537 State.regs[dstreg] = difference;
539 z = ((PSW & PSW_Z) != 0) && (difference == 0);
540 n = (difference & 0x80000000);
542 v = ((reg2 & 0x80000000) == (reg1 & 0x80000000)
543 && (reg2 & 0x80000000) != (difference & 0x80000000));
545 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
546 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
547 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
550 // 1111 1001 1011 1000 Rn Rn; inc Rn
551 8.0xf9+8.0xb8+4.RN0,4.RN2=RN0:D1:::inc
558 dstreg = translate_rreg (SD_, RN0);
559 genericAdd (1, dstreg);
562 // 1111 1001 1101 1000 Rn Rn; inc Rn
563 8.0xf9+8.0xc8+4.RN0,4.RN2=RN0:D1:::inc4
570 dstreg = translate_rreg (SD_, RN0);
571 State.regs[dstreg] += 4;
574 // 1111 1001 1101 1000 Rm Rn; cmp Rm,Rn
575 8.0xf9+8.0xd8+4.RM2,4.RN0:D1:::cmp
579 int srcreg1, srcreg2;
582 srcreg1 = translate_rreg (SD_, RN0);
583 srcreg2 = translate_rreg (SD_, RM2);
584 genericCmp (State.regs[srcreg2], State.regs[srcreg1]);
587 // 1111 1001 1110 1000 XRm Rn; mov XRm,Rn
588 8.0xf9+8.0xe8+4.XRM2,4.RN0:D1l:::mov
595 dstreg = translate_rreg (SD_, RN0);
599 State.regs[dstreg] = State.regs[REG_SP];
605 // 1111 1001 1111 1000 Rm XRn; mov Rm,XRn
606 8.0xf9+8.0xf8+4.RM2,4.XRN0:D1m:::mov
613 srcreg = translate_rreg (SD_, RM2);
617 State.regs[REG_SP] = State.regs[srcreg];
623 // 1111 1001 0000 1001 Rm Rn; and Rm,Rn
624 8.0xf9+8.0x09+4.RM2,4.RN0:D1a:::and
633 srcreg = translate_rreg (SD_, RM2);
634 dstreg = translate_rreg (SD_, RN0);
636 State.regs[dstreg] &= State.regs[srcreg];
637 z = (State.regs[dstreg] == 0);
638 n = (State.regs[dstreg] & 0x80000000) != 0;
639 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
640 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
643 // 1111 1001 0001 1001 Rm Rn; or Rm,Rn
644 8.0xf9+8.0x19+4.RM2,4.RN0:D1a:::or
652 srcreg = translate_rreg (SD_, RM2);
653 dstreg = translate_rreg (SD_, RN0);
655 State.regs[dstreg] |= State.regs[srcreg];
656 z = (State.regs[dstreg] == 0);
657 n = (State.regs[dstreg] & 0x80000000) != 0;
658 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
659 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
662 // 1111 1001 0010 1001 Rm Rn; xor Rm,Rn
663 8.0xf9+8.0x29+4.RM2,4.RN0:D1a:::xor
671 srcreg = translate_rreg (SD_, RM2);
672 dstreg = translate_rreg (SD_, RN0);
674 State.regs[dstreg] ^= State.regs[srcreg];
675 z = (State.regs[dstreg] == 0);
676 n = (State.regs[dstreg] & 0x80000000) != 0;
677 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
678 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
681 // 1111 1001 0011 1001 Rn Rn; not Rn
682 8.0xf9+8.0x39+4.RM2,4.RN0=RM2:D1:::not
690 dstreg = translate_rreg (SD_, RN0);
692 State.regs[dstreg] = ~State.regs[dstreg];
693 z = (State.regs[dstreg] == 0);
694 n = (State.regs[dstreg] & 0x80000000) != 0;
695 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
696 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
699 // 1111 1001 0100 1001 Rm Rn; asr Rm,Rn
700 8.0xf9+8.0x49+4.RM2,4.RN0:D1a:::asr
709 srcreg = translate_rreg (SD_, RM2);
710 dstreg = translate_rreg (SD_, RN0);
712 temp = State.regs[dstreg];
714 temp >>= State.regs[srcreg];
715 State.regs[dstreg] = temp;
716 z = (State.regs[dstreg] == 0);
717 n = (State.regs[dstreg] & 0x80000000) != 0;
718 PSW &= ~(PSW_Z | PSW_N | PSW_C);
719 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
722 // 1111 1001 0101 1001 Rm Rn; lsr Rm,Rn
723 8.0xf9+8.0x59+4.RM2,4.RN0:D1a:::lsr
732 srcreg = translate_rreg (SD_, RM2);
733 dstreg = translate_rreg (SD_, RN0);
735 c = State.regs[dstreg] & 1;
736 State.regs[dstreg] >>= State.regs[srcreg];
737 z = (State.regs[dstreg] == 0);
738 n = (State.regs[dstreg] & 0x80000000) != 0;
739 PSW &= ~(PSW_Z | PSW_N | PSW_C);
740 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
743 // 1111 1001 0110 1001 Rm Rn; asl Rm,Rn
744 8.0xf9+8.0x69+4.RM2,4.RN0:D1a:::asl
752 srcreg = translate_rreg (SD_, RM2);
753 dstreg = translate_rreg (SD_, RN0);
755 State.regs[dstreg] <<= State.regs[srcreg];
756 z = (State.regs[dstreg] == 0);
757 n = (State.regs[dstreg] & 0x80000000) != 0;
758 PSW &= ~(PSW_Z | PSW_N);
759 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
762 // 1111 1001 0111 1001 Rn Rn; asl2 Rn
763 8.0xf9+8.0x79+4.RM2,4.RN0=RM2:D1:::asl2
771 dstreg = translate_rreg (SD_, RN0);
773 State.regs[dstreg] <<= 2;
774 z = (State.regs[dstreg] == 0);
775 n = (State.regs[dstreg] & 0x80000000) != 0;
776 PSW &= ~(PSW_Z | PSW_N);
777 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
780 // 1111 1001 1000 1001 Rn Rn; ror Rn
781 8.0xf9+8.0x89+4.RM2,4.RN0=RM2:D1:::ror
790 dstreg = translate_rreg (SD_, RN0);
792 value = State.regs[dstreg];
796 value |= ((PSW & PSW_C) != 0) ? 0x80000000 : 0;
797 State.regs[dstreg] = value;
799 n = (value & 0x80000000) != 0;
800 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
801 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
804 // 1111 1001 1001 1001 Rn Rn; rol Rn
805 8.0xf9+8.0x99+4.RM2,4.RN0=RM2:D1:::rol
814 dstreg = translate_rreg (SD_, RN0);
816 value = State.regs[dstreg];
817 c = (value & 0x80000000) ? 1 : 0;
820 value |= ((PSW & PSW_C) != 0);
821 State.regs[dstreg] = value;
823 n = (value & 0x80000000) != 0;
824 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
825 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
828 // 1111 1001 1010 1001 Rm Rn; mul Rm,Rn
829 8.0xf9+8.0xa9+4.RM2,4.RN0:D1b:::mul
834 unsigned long long temp;
838 srcreg = translate_rreg (SD_, RM2);
839 dstreg = translate_rreg (SD_, RN0);
841 temp = ((signed64)(signed32)State.regs[dstreg]
842 * (signed64)(signed32)State.regs[srcreg]);
843 State.regs[dstreg] = temp & 0xffffffff;
844 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;;
845 z = (State.regs[dstreg] == 0);
846 n = (State.regs[dstreg] & 0x80000000) != 0;
847 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
848 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
851 // 1111 1001 1011 1001 Rm Rn; mulu Rm,Rn
852 8.0xf9+8.0xb9+4.RM2,4.RN0:D1b:::mulu
857 unsigned long long temp;
861 srcreg = translate_rreg (SD_, RM2);
862 dstreg = translate_rreg (SD_, RN0);
864 temp = ((unsigned64)State.regs[dstreg]
865 * (unsigned64)State.regs[srcreg]);
866 State.regs[dstreg] = temp & 0xffffffff;
867 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
868 z = (State.regs[dstreg] == 0);
869 n = (State.regs[dstreg] & 0x80000000) != 0;
870 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
871 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
874 // 1111 1001 1100 1001 Rm Rn; div Rm,Rn
875 8.0xf9+8.0xc9+4.RM2,4.RN0:D1b:::div
884 srcreg = translate_rreg (SD_, RM2);
885 dstreg = translate_rreg (SD_, RN0);
887 temp = State.regs[REG_MDR];
889 temp |= State.regs[dstreg];
890 State.regs[REG_MDR] = temp % (signed32)State.regs[srcreg];
891 temp /= (signed32)State.regs[srcreg];
892 State.regs[dstreg] = temp & 0xffffffff;
893 z = (State.regs[dstreg] == 0);
894 n = (State.regs[dstreg] & 0x80000000) != 0;
895 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
896 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
899 // 1111 1001 1101 1001 Rm Rn; divu Rm,Rn
900 8.0xf9+8.0xd9+4.RM2,4.RN0:D1b:::divu
905 unsigned long long temp;
909 srcreg = translate_rreg (SD_, RM2);
910 dstreg = translate_rreg (SD_, RN0);
912 temp = State.regs[REG_MDR];
914 temp |= State.regs[dstreg];
915 State.regs[REG_MDR] = temp % State.regs[srcreg];
916 temp /= State.regs[srcreg];
917 State.regs[dstreg] = temp & 0xffffffff;
918 z = (State.regs[dstreg] == 0);
919 n = (State.regs[dstreg] & 0x80000000) != 0;
920 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
921 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
925 // 1111 1001 0000 1010 Rm Rn; mov (Rm),Rn
926 8.0xf9+8.0x0a+4.RN2,4.RM0:D1h:::mov
933 srcreg = translate_rreg (SD_, RM0);
934 dstreg = translate_rreg (SD_, RN2);
935 State.regs[dstreg] = load_word (State.regs[srcreg]);
938 // 1111 1001 0001 1010 Rm Rn; mov Rm,(Rn)
939 8.0xf9+8.0x1a+4.RM2,4.RN0:D1i:::mov
946 srcreg = translate_rreg (SD_, RM2);
947 dstreg = translate_rreg (SD_, RN0);
948 store_word (State.regs[dstreg], State.regs[srcreg]);
951 // 1111 1001 0010 1010 Rm Rn; movbu (Rm),Rn
952 8.0xf9+8.0x2a+4.RN2,4.RM0:D1g:::movbu
959 srcreg = translate_rreg (SD_, RM0);
960 dstreg = translate_rreg (SD_, RN2);
961 State.regs[dstreg] = load_byte (State.regs[srcreg]);
964 // 1111 1001 0011 1010 Rm Rn; movbu Rm,(Rn)
965 8.0xf9+8.0x3a+4.RM2,4.RN0:D1i:::movbu
972 srcreg = translate_rreg (SD_, RM2);
973 dstreg = translate_rreg (SD_, RN0);
974 store_byte (State.regs[dstreg], State.regs[srcreg]);
977 // 1111 1001 0100 1010 Rm Rn; movhu (Rm),Rn
978 8.0xf9+8.0x4a+4.RN2,4.RM0:D1g:::movhu
985 srcreg = translate_rreg (SD_, RM0);
986 dstreg = translate_rreg (SD_, RN2);
987 State.regs[dstreg] = load_half (State.regs[srcreg]);
990 // 1111 1001 0101 1010 Rm Rn; movhu Rm,(Rn)
991 8.0xf9+8.0x5a+4.RM2,4.RN0:D1i:::movhu
998 srcreg = translate_rreg (SD_, RM2);
999 dstreg = translate_rreg (SD_, RN0);
1000 store_half (State.regs[dstreg], State.regs[srcreg]);
1003 // 1111 1001 0110 1010 Rm Rn; mov (Rm+),Rn
1004 8.0xf9+8.0x6a+4.RN2,4.RM0:D1y:::mov
1011 srcreg = translate_rreg (SD_, RM0);
1012 dstreg = translate_rreg (SD_, RN2);
1013 State.regs[dstreg] = load_word (State.regs[srcreg]);
1014 State.regs[srcreg] += 4;
1017 // 1111 1001 0111 1010 Rm Rn; mov Rm,(Rn+)
1018 8.0xf9+8.0x7a+4.RM2,4.RN0:D1z:::mov
1025 srcreg = translate_rreg (SD_, RM2);
1026 dstreg = translate_rreg (SD_, RN0);
1027 store_word (State.regs[dstreg], State.regs[srcreg]);
1028 State.regs[dstreg] += 4;
1031 // 1111 1001 1000 1010 Rn 0000; mov (sp),Rn
1032 8.0xf9+8.0x8a+4.RN2,4.0000:D1j:::mov
1039 dstreg = translate_rreg (SD_, RN2);
1040 State.regs[dstreg] = load_word (State.regs[REG_SP]);
1043 // 1111 1001 1001 1010 Rm 0000; mov Rm, (sp)
1044 8.0xf9+8.0x9a+4.RM2,4.0000:D1k:::mov
1051 srcreg = translate_rreg (SD_, RM2);
1052 store_word (State.regs[REG_SP], State.regs[srcreg]);
1055 // 1111 1001 1010 1010 Rn 0000; mobvu (sp),Rn
1056 8.0xf9+8.0xaa+4.RN2,4.0000:D1j:::movbu
1063 dstreg = translate_rreg (SD_, RN2);
1064 State.regs[dstreg] = load_byte (State.regs[REG_SP]);
1067 // 1111 1001 1011 1010 Rm 0000; movbu Rm, (sp)
1068 8.0xf9+8.0xba+4.RM2,4.0000:D1k:::movbu
1075 srcreg = translate_rreg (SD_, RM2);
1076 store_byte (State.regs[REG_SP], State.regs[srcreg]);
1079 // 1111 1001 1000 1100 Rn 0000; movhu (sp),Rn
1080 8.0xf9+8.0xca+4.RN2,4.0000:D1j:::movhu
1087 dstreg = translate_rreg (SD_, RN2);
1088 State.regs[dstreg] = load_half (State.regs[REG_SP]);
1091 // 1111 1001 1001 1101 Rm 0000; movhu Rm, (sp)
1092 8.0xf9+8.0xda+4.RM2,4.0000:D1k:::movhu
1099 srcreg = translate_rreg (SD_, RM2);
1100 store_half (State.regs[REG_SP], State.regs[srcreg]);
1103 // 1111 1001 1110 1010 Rm Rn; movhu (Rm+),Rn
1104 8.0xf9+8.0xea+4.RN2,4.RM0:D1y:::movhu
1111 srcreg = translate_rreg (SD_, RM0);
1112 dstreg = translate_rreg (SD_, RN2);
1113 State.regs[dstreg] = load_half (State.regs[srcreg]);
1114 State.regs[srcreg] += 2;
1117 // 1111 1001 1111 1010 Rm Rn; movhu Rm,(Rn+)
1118 8.0xf9+8.0xfa+4.RM2,4.RN0:D1z:::movhu
1125 srcreg = translate_rreg (SD_, RM2);
1126 dstreg = translate_rreg (SD_, RN0);
1127 store_half (State.regs[dstreg], State.regs[srcreg]);
1128 State.regs[dstreg] += 2;
1132 // 1111 1001 0000 1011 Rm Rn; mac Rm,Rn
1133 8.0xf9+8.0x0b+4.RM2,4.RN0:D1:::mac
1137 int srcreg1, srcreg2;
1138 long long temp, sum;
1142 srcreg1 = translate_rreg (SD_, RM2);
1143 srcreg2 = translate_rreg (SD_, RN0);
1145 temp = ((signed64)(signed32)State.regs[srcreg2]
1146 * (signed64)(signed32)State.regs[srcreg1]);
1147 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1148 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1149 State.regs[REG_MCRL] = sum;
1152 sum = State.regs[REG_MCRH] + temp + c;
1153 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1154 && (temp & 0x80000000) != (sum & 0x80000000));
1155 State.regs[REG_MCRH] = sum;
1157 State.regs[REG_MCVF] = 1;
1160 // 1111 1001 0001 1011 Rm Rn; macu Rm,Rn
1161 8.0xf9+8.0x1b+4.RM2,4.RN0:D1:::macu
1165 int srcreg1, srcreg2;
1166 unsigned long long temp, sum;
1170 srcreg1 = translate_rreg (SD_, RM2);
1171 srcreg2 = translate_rreg (SD_, RN0);
1173 temp = ((unsigned64)State.regs[srcreg2]
1174 * (unsigned64)State.regs[srcreg1]);
1175 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1176 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1177 State.regs[REG_MCRL] = sum;
1180 sum = State.regs[REG_MCRH] + temp + c;
1181 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1182 && (temp & 0x80000000) != (sum & 0x80000000));
1183 State.regs[REG_MCRH] = sum;
1185 State.regs[REG_MCVF] = 1;
1188 // 1111 1001 0010 1011 Rm Rn; macb Rm,Rn
1189 8.0xf9+8.0x2b+4.RM2,4.RN0:D1:::macb
1193 int srcreg1, srcreg2;
1198 srcreg1 = translate_rreg (SD_, RM2);
1199 srcreg2 = translate_rreg (SD_, RN0);
1201 temp = ((signed32)(signed8)(State.regs[srcreg2] & 0xff)
1202 * (signed32)(signed8)(State.regs[srcreg1] & 0xff));
1203 sum = State.regs[REG_MCRL] + temp;
1204 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1205 && (temp & 0x80000000) != (sum & 0x80000000));
1206 State.regs[REG_MCRL] = sum;
1208 State.regs[REG_MCVF] = 1;
1211 // 1111 1001 0011 1011 Rm Rn; macbu Rm,Rn
1212 8.0xf9+8.0x3b+4.RM2,4.RN0:D1:::macbu
1216 int srcreg1, srcreg2;
1217 long long temp, sum;
1221 srcreg1 = translate_rreg (SD_, RM2);
1222 srcreg2 = translate_rreg (SD_, RN0);
1224 temp = ((unsigned32)(State.regs[srcreg2] & 0xff)
1225 * (unsigned32)(State.regs[srcreg1] & 0xff));
1226 sum = State.regs[REG_MCRL] + temp;
1227 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1228 && (temp & 0x80000000) != (sum & 0x80000000));
1229 State.regs[REG_MCRL] = sum;
1231 State.regs[REG_MCVF] = 1;
1234 // 1111 1001 0100 1011 Rm Rn; mach Rm,Rn
1235 8.0xf9+8.0x4b+4.RM2,4.RN0:D1:::mach
1239 int srcreg1, srcreg2;
1240 long long temp, sum;
1244 srcreg1 = translate_rreg (SD_, RM2);
1245 srcreg2 = translate_rreg (SD_, RN0);
1247 temp = ((unsigned64)(signed16)(State.regs[srcreg2] & 0xffff)
1248 * (unsigned64)(signed16)(State.regs[srcreg1] & 0xffff));
1249 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1250 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1251 State.regs[REG_MCRL] = sum;
1254 sum = State.regs[REG_MCRH] + temp + c;
1255 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1256 && (temp & 0x80000000) != (sum & 0x80000000));
1257 State.regs[REG_MCRH] = sum;
1259 State.regs[REG_MCVF] = 1;
1262 // 1111 1001 0101 1011 Rm Rn; machu Rm,Rn
1263 8.0xf9+8.0x5b+4.RM2,4.RN0:D1:::machu
1267 int srcreg1, srcreg2;
1268 long long temp, sum;
1272 srcreg1 = translate_rreg (SD_, RM2);
1273 srcreg2 = translate_rreg (SD_, RN0);
1275 temp = ((unsigned64)(State.regs[srcreg2] & 0xffff)
1276 * (unsigned64)(State.regs[srcreg1] & 0xffff));
1277 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1278 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1279 State.regs[REG_MCRL] = sum;
1282 sum = State.regs[REG_MCRH] + temp + c;
1283 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1284 && (temp & 0x80000000) != (sum & 0x80000000));
1285 State.regs[REG_MCRH] = sum;
1287 State.regs[REG_MCVF] = 1;
1290 // 1111 1001 0110 1011 Rm Rn; dmach Rm,Rn
1291 8.0xf9+8.0x6b+4.RM2,4.RN0:D1:::dmach
1295 int srcreg1, srcreg2;
1296 long temp, temp2, sum;
1300 srcreg1 = translate_rreg (SD_, RM2);
1301 srcreg2 = translate_rreg (SD_, RN0);
1303 temp = ((signed32)(signed16)(State.regs[srcreg2] & 0xffff)
1304 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
1305 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
1306 * (signed32)(signed16)((State.regs[srcreg2] >> 16) & 0xffff));
1307 sum = temp + temp2 + State.regs[REG_MCRL];
1308 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1309 && (temp & 0x80000000) != (sum & 0x80000000));
1310 State.regs[REG_MCRL] = sum;
1312 State.regs[REG_MCVF] = 1;
1315 // 1111 1001 0111 1011 Rm Rn; dmachu Rm,Rn
1316 8.0xf9+8.0x7b+4.RM2,4.RN0:D1:::dmachu
1320 int srcreg1, srcreg2;
1321 unsigned long temp, temp2, sum;
1325 srcreg1 = translate_rreg (SD_, RM2);
1326 srcreg2 = translate_rreg (SD_, RN0);
1328 temp = ((unsigned32)(State.regs[srcreg2] & 0xffff)
1329 * (unsigned32)(State.regs[srcreg1] & 0xffff));
1330 temp2 = ((unsigned32)((State.regs[srcreg1] >> 16) & 0xffff)
1331 * (unsigned32)((State.regs[srcreg2] >> 16) & 0xffff));
1332 sum = temp + temp2 + State.regs[REG_MCRL];
1333 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1334 && (temp & 0x80000000) != (sum & 0x80000000));
1335 State.regs[REG_MCRL] = sum;
1337 State.regs[REG_MCVF] = 1;
1340 // 1111 1001 1000 1011 Rm Rn; dmulh Rm,Rn
1341 8.0xf9+8.0x8b+4.RM2,4.RN0:D1:::dmulh
1349 srcreg = translate_rreg (SD_, RM2);
1350 dstreg = translate_rreg (SD_, RN0);
1352 temp = ((signed32)(signed16)(State.regs[dstreg] & 0xffff)
1353 * (signed32)(signed16)(State.regs[srcreg] & 0xffff));
1354 State.regs[REG_MDRQ] = temp;
1355 temp = ((signed32)(signed16)((State.regs[dstreg] >> 16) & 0xffff)
1356 * (signed32)(signed16)((State.regs[srcreg] >>16) & 0xffff));
1357 State.regs[dstreg] = temp;
1360 // 1111 1001 1001 1011 Rm Rn; dmulhu Rm,Rn
1361 8.0xf9+8.0x9b+4.RM2,4.RN0:D1:::dumachu
1369 srcreg = translate_rreg (SD_, RM2);
1370 dstreg = translate_rreg (SD_, RN0);
1372 temp = ((unsigned32)(State.regs[dstreg] & 0xffff)
1373 * (unsigned32)(State.regs[srcreg] & 0xffff));
1374 State.regs[REG_MDRQ] = temp;
1375 temp = ((unsigned32)((State.regs[dstreg] >> 16) & 0xffff)
1376 * (unsigned32)((State.regs[srcreg] >>16) & 0xffff));
1377 State.regs[dstreg] = temp;
1380 // 1111 1001 1010 1011 Rm Rn; sat16 Rm,Rn
1381 8.0xf9+8.0xab+4.RM2,4.RN0:D1:::sat16
1389 srcreg = translate_rreg (SD_, RM2);
1390 dstreg = translate_rreg (SD_, RN0);
1392 value = State.regs[srcreg];
1394 if (value >= 0x7fff)
1395 State.regs[dstreg] = 0x7fff;
1396 else if (value <= 0xffff8000)
1397 State.regs[dstreg] = 0xffff8000;
1399 State.regs[dstreg] = value;
1401 n = (State.regs[dstreg] & 0x8000) != 0;
1402 z = (State.regs[dstreg] == 0);
1403 PSW &= ~(PSW_Z | PSW_N);
1404 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1407 // 1111 1001 1011 1011 Rm Rn; mcste Rm,Rn
1408 8.0xf9+8.0xbb+4.RM2,4.RN0:D1:::mcste
1415 srcreg = translate_rreg (SD_, RM2);
1416 dstreg = translate_rreg (SD_, RN0);
1418 PSW &= ~(PSW_V | PSW_C);
1419 PSW |= (State.regs[REG_MCVF] ? PSW_V : 0);
1421 /* 32bit saturation. */
1422 if (State.regs[srcreg] == 0x20)
1426 tmp = State.regs[REG_MCRH];
1428 tmp += State.regs[REG_MCRL];
1430 if (tmp > 0x7fffffff)
1431 State.regs[dstreg] = 0x7fffffff;
1432 else if (tmp < 0xffffffff80000000LL)
1433 State.regs[dstreg] = 0x80000000;
1435 State.regs[dstreg] = tmp;
1437 /* 16bit saturation */
1438 else if (State.regs[srcreg] == 0x10)
1442 tmp = State.regs[REG_MCRH];
1444 tmp += State.regs[REG_MCRL];
1447 State.regs[dstreg] = 0x7fff;
1448 else if (tmp < 0xffffffffffff8000LL)
1449 State.regs[dstreg] = 0x8000;
1451 State.regs[dstreg] = tmp;
1453 /* 8 bit saturation */
1454 else if (State.regs[srcreg] == 0x8)
1458 tmp = State.regs[REG_MCRH];
1460 tmp += State.regs[REG_MCRL];
1463 State.regs[dstreg] = 0x7f;
1464 else if (tmp < 0xffffffffffffff80LL)
1465 State.regs[dstreg] = 0x80;
1467 State.regs[dstreg] = tmp;
1469 /* 9 bit saturation */
1470 else if (State.regs[srcreg] == 0x9)
1474 tmp = State.regs[REG_MCRH];
1476 tmp += State.regs[REG_MCRL];
1479 State.regs[dstreg] = 0x80;
1480 else if (tmp < 0xffffffffffffff81LL)
1481 State.regs[dstreg] = 0x81;
1483 State.regs[dstreg] = tmp;
1485 /* 9 bit saturation */
1486 else if (State.regs[srcreg] == 0x30)
1490 tmp = State.regs[REG_MCRH];
1492 tmp += State.regs[REG_MCRL];
1494 if (tmp > 0x7fffffffffffLL)
1495 tmp = 0x7fffffffffffLL;
1496 else if (tmp < 0xffff800000000000LL)
1497 tmp = 0xffff800000000000LL;
1500 State.regs[dstreg] = tmp;
1504 // 1111 1001 1100 1011 Rm Rn; swap Rm,Rn
1505 8.0xf9+8.0xcb+4.RM2,4.RN0:D1:::swap
1512 srcreg = translate_rreg (SD_, RM2);
1513 dstreg = translate_rreg (SD_, RN0);
1515 State.regs[dstreg] = (((State.regs[srcreg] & 0xff) << 24)
1516 | (((State.regs[srcreg] >> 8) & 0xff) << 16)
1517 | (((State.regs[srcreg] >> 16) & 0xff) << 8)
1518 | ((State.regs[srcreg] >> 24) & 0xff));
1521 // 1111 1101 1101 1011 Rm Rn; swaph Rm,Rn
1522 8.0xf9+8.0xdb+4.RM2,4.RN0:D1:::swaph
1529 srcreg = translate_rreg (SD_, RM2);
1530 dstreg = translate_rreg (SD_, RN0);
1532 State.regs[dstreg] = (((State.regs[srcreg] & 0xff) << 8)
1533 | ((State.regs[srcreg] >> 8) & 0xff)
1534 | (((State.regs[srcreg] >> 16) & 0xff) << 24)
1535 | (((State.regs[srcreg] >> 24) & 0xff) << 16));
1538 // 1111 1001 1110 1011 Rm Rn; swhw Rm,Rn
1539 8.0xf9+8.0xeb+4.RM2,4.RN0:D1:::swhw
1546 srcreg = translate_rreg (SD_, RM2);
1547 dstreg = translate_rreg (SD_, RN0);
1549 State.regs[dstreg] = (((State.regs[srcreg] & 0xffff) << 16)
1550 | ((State.regs[srcreg] >> 16) & 0xffff));
1553 // 1111 1001 1111 1011 Rm Rn; bsch Rm,Rn
1554 8.0xf9+8.0xfb+4.RM2,4.RN0:D1:::bsch
1563 srcreg = translate_rreg (SD_, RM2);
1564 dstreg = translate_rreg (SD_, RN0);
1566 temp = State.regs[srcreg];
1567 start = (State.regs[dstreg] & 0x1f) - 1;
1571 for (i = start; i >= 0; i--)
1573 if (temp & (1 << i))
1576 State.regs[dstreg] = i;
1584 State.regs[dstreg] = 0;
1587 PSW |= (c ? PSW_C : 0);
1591 // 1111 1011 0000 1000 Rn Rn IMM8; mov IMM8,Rn
1592 8.0xfb+8.0x08+4.RM2,4.RN0=RM2+8.IMM8:D2j:::mov
1599 dstreg = translate_rreg (SD_, RN0);
1600 State.regs[dstreg] = EXTEND8 (IMM8);
1603 // 1111 1011 0001 1000 Rn Rn IMM8; movu IMM8,Rn
1604 8.0xfb+8.0x18+4.RM2,4.RN0=RM2+8.IMM8:D2:::movu
1611 dstreg = translate_rreg (SD_, RN0);
1612 State.regs[dstreg] = IMM8 & 0xff;
1615 // 1111 1011 0111 1000 Rn Rn IMM8; add IMM8,Rn
1616 8.0xfb+8.0x78+4.RM2,4.RN0=RM2+8.IMM8:D2d:::add
1623 dstreg = translate_rreg (SD_, RN0);
1624 genericAdd (EXTEND8 (IMM8), dstreg);
1627 // 1111 1011 1000 1000 Rn Rn IMM8; addc IMM8,Rn
1628 8.0xfb+8.0x88+4.RM2,4.RN0=RM2+8.IMM8:D2d:::addc
1634 unsigned long reg1, reg2, sum;
1637 dstreg = translate_rreg (SD_, RN0);
1639 imm = EXTEND8 (IMM8);
1640 reg2 = State.regs[dstreg];
1641 sum = imm + reg2 + ((PSW & PSW_C) != 0);
1642 State.regs[dstreg] = sum;
1644 z = ((PSW & PSW_Z) != 0) && (sum == 0);
1645 n = (sum & 0x80000000);
1646 c = (sum < imm) || (sum < reg2);
1647 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
1648 && (reg2 & 0x80000000) != (sum & 0x80000000));
1650 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1651 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
1652 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
1655 // 1111 1011 1001 1000 Rn Rn IMM8; sub IMM8,Rn
1656 8.0xfb+8.0x98+4.RM2,4.RN0=RM2+8.IMM8:D2d:::sub
1663 dstreg = translate_rreg (SD_, RN0);
1665 genericSub (EXTEND8 (IMM8), dstreg);
1668 // 1111 1011 1010 1000 Rn Rn IMM8; subc IMM8,Rn
1669 8.0xfb+8.0xa8+4.RM2,4.RN0=RM2+8.IMM8:D2d:::subc
1675 unsigned long reg1, reg2, difference;
1678 dstreg = translate_rreg (SD_, RN0);
1680 imm = EXTEND8 (IMM8);
1681 reg2 = State.regs[dstreg];
1682 difference = reg2 - imm - ((PSW & PSW_C) != 0);
1683 State.regs[dstreg] = difference;
1685 z = ((PSW & PSW_Z) != 0) && (difference == 0);
1686 n = (difference & 0x80000000);
1688 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
1689 && (reg2 & 0x80000000) != (difference & 0x80000000));
1691 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1692 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
1693 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
1696 // 1111 1011 1101 1000 Rn Rn IMM8; cmp IMM8,Rn
1697 8.0xfb+8.0xd8+4.RM2,4.RN0=RM2+8.IMM8:D2b:::cmp
1704 srcreg = translate_rreg (SD_, RN0);
1705 genericCmp (EXTEND8 (IMM8), State.regs[srcreg]);
1708 // 1111 1011 1111 1000 XRn XRn IMM8; mov IMM8,XRn
1709 8.0xfb+8.0xf8+4.XRM2,4.XRN0=XRM2+8.IMM8:D2k:::mov
1718 State.regs[REG_SP] = IMM8;
1723 // 1111 1011 0000 1001 Rn Rn IMM8; and IMM8,Rn
1724 8.0xfb+8.0x09+4.RM2,4.RN0=RM2+8.IMM8:D2d:::and
1732 dstreg = translate_rreg (SD_, RN0);
1734 State.regs[dstreg] &= (IMM8 & 0xff);
1735 z = (State.regs[dstreg] == 0);
1736 n = (State.regs[dstreg] & 0x80000000) != 0;
1737 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1738 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1741 // 1111 1011 0001 1001 Rn Rn IMM8; or IMM8,Rn
1742 8.0xfb+8.0x19+4.RM2,4.RN0=RM2+8.IMM8:D2d:::or
1750 dstreg = translate_rreg (SD_, RN0);
1752 State.regs[dstreg] |= (IMM8 & 0xff);
1753 z = (State.regs[dstreg] == 0);
1754 n = (State.regs[dstreg] & 0x80000000) != 0;
1755 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1756 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1759 // 1111 1011 0010 1001 Rn Rn IMM8; xor IMM8,Rn
1760 8.0xfb+8.0x29+4.RM2,4.RN0=RM2+8.IMM8:D2d:::xor
1768 dstreg = translate_rreg (SD_, RN0);
1770 State.regs[dstreg] ^= (IMM8 & 0xff);
1771 z = (State.regs[dstreg] == 0);
1772 n = (State.regs[dstreg] & 0x80000000) != 0;
1773 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1774 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1777 // 1111 1011 0100 1001 Rn Rn IMM8; asr IMM8,Rn
1778 8.0xfb+8.0x49+4.RM2,4.RN0=RM2+8.IMM8:D2a:::asr
1787 dstreg = translate_rreg (SD_, RN0);
1789 temp = State.regs[dstreg];
1791 temp >>= (IMM8 & 0xff);
1792 State.regs[dstreg] = temp;
1793 z = (State.regs[dstreg] == 0);
1794 n = (State.regs[dstreg] & 0x80000000) != 0;
1795 PSW &= ~(PSW_Z | PSW_N | PSW_C);
1796 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
1799 // 1111 1011 0101 1001 Rn Rn IMM8; lsr IMM8,Rn
1800 8.0xfb+8.0x59+4.RM2,4.RN0=RM2+8.IMM8:D2a:::lsr
1808 dstreg = translate_rreg (SD_, RN0);
1810 c = State.regs[dstreg] & 1;
1811 State.regs[dstreg] >>= (IMM8 & 0xff);
1812 z = (State.regs[dstreg] == 0);
1813 n = (State.regs[dstreg] & 0x80000000) != 0;
1814 PSW &= ~(PSW_Z | PSW_N | PSW_C);
1815 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
1818 // 1111 1011 0110 1001 Rn Rn IMM8; asl IMM8,Rn
1819 8.0xfb+8.0x69+4.RM2,4.RN0=RM2+8.IMM8:D2a:::asl
1827 dstreg = translate_rreg (SD_, RN0);
1829 State.regs[dstreg] <<= (IMM8 & 0xff);
1830 z = (State.regs[dstreg] == 0);
1831 n = (State.regs[dstreg] & 0x80000000) != 0;
1832 PSW &= ~(PSW_Z | PSW_N);
1833 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1836 // 1111 1011 1010 1001 Rn Rn IMM8; mul IMM8,Rn
1837 8.0xfb+8.0xa9+4.RM2,4.RN0=RM2+8.IMM8:D2a:::mul
1842 unsigned long long temp;
1846 dstreg = translate_rreg (SD_, RN0);
1848 temp = ((signed64)(signed32)State.regs[dstreg]
1849 * (signed64)(signed32)EXTEND8 (IMM8));
1850 State.regs[dstreg] = temp & 0xffffffff;
1851 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;;
1852 z = (State.regs[dstreg] == 0);
1853 n = (State.regs[dstreg] & 0x80000000) != 0;
1854 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1855 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1858 // 1111 1011 1011 1001 Rn Rn IMM8; mulu IMM8,Rn
1859 8.0xfb+8.0xb9+4.RM2,4.RN0=RM2+8.IMM8:D2a:::mulu
1864 unsigned long long temp;
1868 dstreg = translate_rreg (SD_, RN0);
1870 temp = ((unsigned64)State.regs[dstreg]
1871 * (unsigned64)(IMM8 & 0xff));
1872 State.regs[dstreg] = temp & 0xffffffff;
1873 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
1874 z = (State.regs[dstreg] == 0);
1875 n = (State.regs[dstreg] & 0x80000000) != 0;
1876 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1877 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1880 // 1111 1011 1110 1001 Rn Rn IMM8; btst imm8,Rn
1881 8.0xfb+8.0xe9+4.RN2,4.RM0=RN2+8.IMM8:D2l:::btst
1888 srcreg = translate_rreg (SD_, RM0);
1889 genericBtst(IMM8, State.regs[srcreg]);
1892 // 1111 1011 0000 1010 Rn Rm IMM8; mov (d8,Rm),Rn
1893 8.0xfb+8.0x0a+4.RN2,4.RM0+8.IMM8:D2l:::mov
1900 srcreg = translate_rreg (SD_, RM0);
1901 dstreg = translate_rreg (SD_, RN2);
1902 State.regs[dstreg] = load_word (State.regs[srcreg] + EXTEND8 (IMM8));
1905 // 1111 1011 0001 1010 Rn Rm IMM8; mov Rm,(d8,Rn)
1906 8.0xfb+8.0x1a+4.RM2,4.RN0+8.IMM8:D2m:::mov
1912 srcreg = translate_rreg (SD_, RM2);
1913 dstreg = translate_rreg (SD_, RN0);
1914 store_word (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
1917 // 1111 1011 0010 1010 Rn Rm IMM8; movbu (d8,Rm),Rn
1918 8.0xfb+8.0x2a+4.RN2,4.RM0+8.IMM8:D2l:::movbu
1924 srcreg = translate_rreg (SD_, RM0);
1925 dstreg = translate_rreg (SD_, RN2);
1926 State.regs[dstreg] = load_byte (State.regs[srcreg] + EXTEND8 (IMM8));
1929 // 1111 1011 0011 1010 Rn Rm IMM8; movbu Rm,(d8,Rn)
1930 8.0xfb+8.0x3a+4.RM2,4.RN0+8.IMM8:D2m:::movbu
1936 srcreg = translate_rreg (SD_, RM2);
1937 dstreg = translate_rreg (SD_, RN0);
1938 store_byte (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
1941 // 1111 1011 0100 1010 Rn Rm IMM8; movhu (d8,Rm),Rn
1942 8.0xfb+8.0x4a+4.RN2,4.RM0+8.IMM8:D2l:::movhu
1948 srcreg = translate_rreg (SD_, RM0);
1949 dstreg = translate_rreg (SD_, RN2);
1950 State.regs[dstreg] = load_half (State.regs[srcreg] + EXTEND8 (IMM8));
1953 // 1111 1011 0101 1010 Rn Rm IMM8; movhu Rm,(d8,Rn)
1954 8.0xfb+8.0x5a+4.RM2,4.RN0+8.IMM8:D2m:::movhu
1960 srcreg = translate_rreg (SD_, RM2);
1961 dstreg = translate_rreg (SD_, RN0);
1962 store_half (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
1965 // 1111 1011 0110 1010 Rn Rm IMM8; mov (d8,Rm+),Rn
1966 8.0xfb+8.0x6a+4.RN2,4.RM0+8.IMM8:D2y:::mov
1973 srcreg = translate_rreg (SD_, RM0);
1974 dstreg = translate_rreg (SD_, RN2);
1975 State.regs[dstreg] = load_word (State.regs[srcreg] + EXTEND8 (IMM8));
1976 State.regs[srcreg] += 4;
1979 // 1111 1011 0111 1010 Rn Rm IMM8; mov Rm,(d8,Rn+)
1980 8.0xfb+8.0x7a+4.RM2,4.RN0+8.IMM8:D2z:::mov
1986 srcreg = translate_rreg (SD_, RM2);
1987 dstreg = translate_rreg (SD_, RN0);
1988 store_word (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
1989 State.regs[dstreg] += 4;
1993 // 1111 1011 1000 1010 Rn 0000 IMM8; mov (d8,sp),Rn
1994 8.0xfb+8.0x8a+4.RN2,4.0x0+8.IMM8:D2n:::mov
2000 dstreg = translate_rreg (SD_, RN2);
2001 State.regs[dstreg] = load_word (State.regs[REG_SP] + EXTEND8 (IMM8));
2004 // 1111 1011 1001 1010 Rm 0000 IMM8; mov Rm,(d8,Rn)
2005 8.0xfb+8.0x9a+4.RM2,4.0x0+8.IMM8:D2o:::mov
2011 srcreg = translate_rreg (SD_, RM2);
2012 store_word (State.regs[REG_SP] + EXTEND8 (IMM8), State.regs[srcreg]);
2015 // 1111 1011 1010 1010 Rn Rm IMM8; movbu (d8,sp),Rn
2016 8.0xfb+8.0xaa+4.RN2,4.0x0+8.IMM8:D2n:::movbu
2022 dstreg = translate_rreg (SD_, RN2);
2023 State.regs[dstreg] = load_byte (State.regs[REG_SP] + EXTEND8 (IMM8));
2026 // 1111 1011 1011 1010 Rn Rm IMM8; movbu Rm,(sp,Rn)
2027 8.0xfb+8.0xba+4.RM2,4.0x0+8.IMM8:D2o:::movbu
2033 srcreg = translate_rreg (SD_, RM2);
2034 store_byte (State.regs[REG_SP] + EXTEND8 (IMM8), State.regs[srcreg]);
2037 // 1111 1011 1100 1010 Rn Rm IMM8; movhu (d8,sp),Rn
2038 8.0xfb+8.0xca+4.RN2,4.0x0+8.IMM8:D2n:::movhu
2044 dstreg = translate_rreg (SD_, RN2);
2045 State.regs[dstreg] = load_half (State.regs[REG_SP] + EXTEND8 (IMM8));
2048 // 1111 1011 1101 1010 Rn Rm IMM8; movhu Rm,(d8,sp)
2049 8.0xfb+8.0xda+4.RM2,4.0x0+8.IMM8:D2o:::movhu
2055 srcreg = translate_rreg (SD_, RM2);
2056 store_half (State.regs[REG_SP] + EXTEND8 (IMM8), State.regs[srcreg]);
2059 // 1111 1011 1110 1010 Rn Rm IMM8; movhu (d8,Rm+),Rn
2060 8.0xfb+8.0xea+4.RN2,4.RM0+8.IMM8:D2y:::movhu
2067 srcreg = translate_rreg (SD_, RM0);
2068 dstreg = translate_rreg (SD_, RN2);
2069 State.regs[dstreg] = load_half (State.regs[srcreg] + EXTEND8 (IMM8));
2070 State.regs[srcreg] += 2;
2073 // 1111 1011 1111 1010 Rn Rm IMM8; movhu Rm,(d8,Rn+)
2074 8.0xfb+8.0xfa+4.RM2,4.RN0+8.IMM8:D2z:::movhu
2080 srcreg = translate_rreg (SD_, RM2);
2081 dstreg = translate_rreg (SD_, RN0);
2082 store_half (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
2083 State.regs[dstreg] += 2;
2087 // 1111 1011 0000 1011 Rn Rn IMM8; mac imm8,Rn
2088 8.0xfb+8.0x0b+4.RN2,4.RN0=RN2+8.IMM8:D2:::mac
2092 long long temp, sum;
2096 srcreg = translate_rreg (SD_, RN2);
2098 temp = ((signed64)(signed32)EXTEND8 (IMM8)
2099 * (signed64)(signed32)State.regs[srcreg]);
2100 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2101 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2102 State.regs[REG_MCRL] = sum;
2105 sum = State.regs[REG_MCRH] + temp + c;
2106 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2107 && (temp & 0x80000000) != (sum & 0x80000000));
2108 State.regs[REG_MCRH] = sum;
2110 State.regs[REG_MCVF] = 1;
2113 // 1111 1011 0001 1011 Rn Rn IMM8; macu imm8,Rn
2114 8.0xfb+8.0x1b+4.RN2,4.RN0=RN2+8.IMM8:D2:::macu
2118 long long temp, sum;
2122 srcreg = translate_rreg (SD_, RN2);
2124 temp = ((unsigned64) (IMM8)
2125 * (unsigned64)State.regs[srcreg]);
2126 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2127 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2128 State.regs[REG_MCRL] = sum;
2131 sum = State.regs[REG_MCRH] + temp + c;
2132 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2133 && (temp & 0x80000000) != (sum & 0x80000000));
2134 State.regs[REG_MCRH] = sum;
2136 State.regs[REG_MCVF] = 1;
2139 // 1111 1011 0010 1011 Rn Rn IMM8; macb imm8,Rn
2140 8.0xfb+8.0x2b+4.RN2,4.RN0=RN2+8.IMM8:D2:::macb
2144 long long temp, sum;
2148 srcreg = translate_rreg (SD_, RN2);
2150 temp = ((signed64)(signed8)EXTEND8 (IMM8)
2151 * (signed64)(signed8)State.regs[srcreg] & 0xff);
2152 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2153 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2154 State.regs[REG_MCRL] = sum;
2157 sum = State.regs[REG_MCRH] + temp + c;
2158 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2159 && (temp & 0x80000000) != (sum & 0x80000000));
2160 State.regs[REG_MCRH] = sum;
2162 State.regs[REG_MCVF] = 1;
2165 // 1111 1011 0011 1011 Rn Rn IMM8; macbu imm8,Rn
2166 8.0xfb+8.0x3b+4.RN2,4.RN0=RN2+8.IMM8:D2:::macbu
2170 long long temp, sum;
2174 srcreg = translate_rreg (SD_, RN2);
2176 temp = ((unsigned64) (IMM8)
2177 * (unsigned64)State.regs[srcreg] & 0xff);
2178 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2179 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2180 State.regs[REG_MCRL] = sum;
2183 sum = State.regs[REG_MCRH] + temp + c;
2184 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2185 && (temp & 0x80000000) != (sum & 0x80000000));
2186 State.regs[REG_MCRH] = sum;
2188 State.regs[REG_MCVF] = 1;
2191 // 1111 1011 0100 1011 Rn Rn IMM8; mach imm8,Rn
2192 8.0xfb+8.0x4b+4.RN2,4.RN0=RN2+8.IMM8:D2:::mach
2196 long long temp, sum;
2200 srcreg = translate_rreg (SD_, RN2);
2202 temp = ((signed64)(signed16)EXTEND8 (IMM8)
2203 * (signed64)(signed16)State.regs[srcreg] & 0xffff);
2204 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2205 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2206 State.regs[REG_MCRL] = sum;
2209 sum = State.regs[REG_MCRH] + temp + c;
2210 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2211 && (temp & 0x80000000) != (sum & 0x80000000));
2212 State.regs[REG_MCRH] = sum;
2214 State.regs[REG_MCVF] = 1;
2217 // 1111 1011 0101 1011 Rn Rn IMM8; machu imm8,Rn
2218 8.0xfb+8.0x5b+4.RN2,4.RN0=RN2+8.IMM8:D2:::machu
2222 long long temp, sum;
2226 srcreg = translate_rreg (SD_, RN2);
2228 temp = ((unsigned64) (IMM8)
2229 * (unsigned64)State.regs[srcreg] & 0xffff);
2230 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2231 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2232 State.regs[REG_MCRL] = sum;
2235 sum = State.regs[REG_MCRH] + temp + c;
2236 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2237 && (temp & 0x80000000) != (sum & 0x80000000));
2238 State.regs[REG_MCRH] = sum;
2240 State.regs[REG_MCVF] = 1;
2243 // 1111 1011 1011 1011 Rn Rn IMM8; mcste imm8,Rn
2244 8.0xfb+8.0xbb+4.RN2,4.RN0=RN2+8.IMM8:D2:::mcste
2250 dstreg = translate_rreg (SD_, RN0);
2252 PSW &= ~(PSW_V | PSW_C);
2253 PSW |= (State.regs[REG_MCVF] ? PSW_V : 0);
2255 /* 32bit saturation. */
2260 tmp = State.regs[REG_MCRH];
2262 tmp += State.regs[REG_MCRL];
2264 if (tmp > 0x7fffffff)
2265 State.regs[dstreg] = 0x7fffffff;
2266 else if (tmp < 0xffffffff80000000LL)
2267 State.regs[dstreg] = 0x80000000;
2269 State.regs[dstreg] = tmp;
2271 /* 16bit saturation */
2272 else if (IMM8 == 0x10)
2276 tmp = State.regs[REG_MCRH];
2278 tmp += State.regs[REG_MCRL];
2281 State.regs[dstreg] = 0x7fff;
2282 else if (tmp < 0xffffffffffff8000LL)
2283 State.regs[dstreg] = 0x8000;
2285 State.regs[dstreg] = tmp;
2287 /* 8 bit saturation */
2288 else if (IMM8 == 0x8)
2292 tmp = State.regs[REG_MCRH];
2294 tmp += State.regs[REG_MCRL];
2297 State.regs[dstreg] = 0x7f;
2298 else if (tmp < 0xffffffffffffff80LL)
2299 State.regs[dstreg] = 0x80;
2301 State.regs[dstreg] = tmp;
2303 /* 9 bit saturation */
2304 else if (IMM8 == 0x9)
2308 tmp = State.regs[REG_MCRH];
2310 tmp += State.regs[REG_MCRL];
2313 State.regs[dstreg] = 0x80;
2314 else if (tmp < 0xffffffffffffff81LL)
2315 State.regs[dstreg] = 0x81;
2317 State.regs[dstreg] = tmp;
2319 /* 9 bit saturation */
2320 else if (IMM8 == 0x30)
2324 tmp = State.regs[REG_MCRH];
2326 tmp += State.regs[REG_MCRL];
2328 if (tmp > 0x7fffffffffffLL)
2329 tmp = 0x7fffffffffffLL;
2330 else if (tmp < 0xffff800000000000LL)
2331 tmp = 0xffff800000000000LL;
2334 State.regs[dstreg] = tmp;
2338 // 1111 1011 0111 1100 Rm Rn Rd; add Rm,Rn,Rd
2339 8.0xfb+8.0x7c+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::add
2344 unsigned long sum, source1, source2;
2345 int srcreg1, srcreg2, dstreg;
2348 srcreg1 = translate_rreg (SD_, RM2);
2349 srcreg2 = translate_rreg (SD_, RN0);
2350 dstreg = translate_rreg (SD_, RD0);
2352 source1 = State.regs[srcreg1];
2353 source2 = State.regs[srcreg2];
2354 sum = source1 + source2;
2355 State.regs[dstreg] = sum;
2358 n = (sum & 0x80000000);
2359 c = (sum < source1) || (sum < source2);
2360 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2361 && (source1 & 0x80000000) != (sum & 0x80000000));
2363 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2364 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2365 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2368 // 1111 1011 1000 1100 Rm Rn Rd; addc Rm,Rn,Rd
2369 8.0xfb+8.0x8c+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::addc
2374 unsigned long sum, source1, source2;
2375 int srcreg1, srcreg2, dstreg;
2378 srcreg1 = translate_rreg (SD_, RM2);
2379 srcreg2 = translate_rreg (SD_, RN0);
2380 dstreg = translate_rreg (SD_, RD0);
2382 source1 = State.regs[srcreg1];
2383 source2 = State.regs[srcreg2];
2384 sum = source1 + source2 + ((PSW & PSW_C) != 0);
2385 State.regs[dstreg] = sum;
2387 z = ((PSW & PSW_Z) != 0) && (sum == 0);
2388 n = (sum & 0x80000000);
2389 c = (sum < source1) || (sum < source2);
2390 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2391 && (source1 & 0x80000000) != (sum & 0x80000000));
2393 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2394 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2395 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2398 // 1111 1011 1001 1100 Rm Rn Rd; sub Rm,Rn,Rd
2399 8.0xfb+8.0x9c+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::sub
2404 unsigned long difference, source1, source2;
2405 int srcreg1, srcreg2, dstreg;
2408 srcreg1 = translate_rreg (SD_, RM2);
2409 srcreg2 = translate_rreg (SD_, RN0);
2410 dstreg = translate_rreg (SD_, RD0);
2412 source1 = State.regs[srcreg1];
2413 source2 = State.regs[srcreg2];
2414 difference = source2 - source1;
2415 State.regs[dstreg] = difference;
2417 z = (difference == 0);
2418 n = (difference & 0x80000000);
2419 c = (source1 > source1);
2420 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2421 && (source1 & 0x80000000) != (difference & 0x80000000));
2423 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2424 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2425 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2428 // 1111 1011 1010 1100 Rm Rn Rd; subc Rm,Rn,Rd
2429 8.0xfb+8.0xac+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::subc
2434 unsigned long difference, source1, source2;
2435 int srcreg1, srcreg2, dstreg;
2438 srcreg1 = translate_rreg (SD_, RM2);
2439 srcreg2 = translate_rreg (SD_, RN0);
2440 dstreg = translate_rreg (SD_, RD0);
2442 source1 = State.regs[srcreg1];
2443 source2 = State.regs[srcreg2];
2444 difference = source2 - source1 - ((PSW & PSW_C) != 0);
2445 State.regs[dstreg] = difference;
2447 z = ((PSW & PSW_Z) != 0) && (difference == 0);
2448 n = (difference & 0x80000000);
2449 c = (source1 > source2);
2450 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2451 && (source1 & 0x80000000) != (difference & 0x80000000));
2453 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2454 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2455 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2458 // 1111 1011 0000 1101 Rm Rn Rd; and Rm,Rn,Rd
2459 8.0xfb+8.0x0d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::and
2464 int srcreg1, srcreg2, dstreg;
2467 srcreg1 = translate_rreg (SD_, RM2);
2468 srcreg2 = translate_rreg (SD_, RN0);
2469 dstreg = translate_rreg (SD_, RD0);
2471 State.regs[dstreg] = State.regs[srcreg1] & State.regs[srcreg2];
2473 z = (State.regs[dstreg] == 0);
2474 n = (State.regs[dstreg] & 0x80000000);
2476 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2477 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2480 // 1111 1011 0001 1101 Rm Rn Rd; or Rm,Rn,Rd
2481 8.0xfb+8.0x1d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::or
2486 int srcreg1, srcreg2, dstreg;
2489 srcreg1 = translate_rreg (SD_, RM2);
2490 srcreg2 = translate_rreg (SD_, RN0);
2491 dstreg = translate_rreg (SD_, RD0);
2493 State.regs[dstreg] = State.regs[srcreg1] | State.regs[srcreg2];
2495 z = (State.regs[dstreg] == 0);
2496 n = (State.regs[dstreg] & 0x80000000);
2498 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2499 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2502 // 1111 1011 0010 1101 Rm Rn Rd; xor Rm,Rn,Rd
2503 8.0xfb+8.0x2d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::xor
2508 int srcreg1, srcreg2, dstreg;
2511 srcreg1 = translate_rreg (SD_, RM2);
2512 srcreg2 = translate_rreg (SD_, RN0);
2513 dstreg = translate_rreg (SD_, RD0);
2515 State.regs[dstreg] = State.regs[srcreg1] ^ State.regs[srcreg2];
2517 z = (State.regs[dstreg] == 0);
2518 n = (State.regs[dstreg] & 0x80000000);
2520 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2521 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2524 // 1111 1011 0100 1101 Rm Rn Rd; asr Rm,Rn,Rd
2525 8.0xfb+8.0x4d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::asr
2531 int srcreg1, srcreg2, dstreg;
2534 srcreg1 = translate_rreg (SD_, RM2);
2535 srcreg2 = translate_rreg (SD_, RN0);
2536 dstreg = translate_rreg (SD_, RD0);
2538 temp = State.regs[srcreg2];
2540 temp >>= State.regs[srcreg1];
2541 State.regs[dstreg] = temp;
2543 z = (State.regs[dstreg] == 0);
2544 n = (State.regs[dstreg] & 0x80000000);
2546 PSW &= ~(PSW_Z | PSW_N | PSW_C);
2547 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2550 // 1111 1011 0101 1101 Rm Rn Rd; lsr Rm,Rn,Rd
2551 8.0xfb+8.0x5d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::lsr
2556 int srcreg1, srcreg2, dstreg;
2559 srcreg1 = translate_rreg (SD_, RM2);
2560 srcreg2 = translate_rreg (SD_, RN0);
2561 dstreg = translate_rreg (SD_, RD0);
2563 c = State.regs[srcreg2] & 1;
2564 State.regs[dstreg] = State.regs[srcreg2] >> State.regs[srcreg1];
2566 z = (State.regs[dstreg] == 0);
2567 n = (State.regs[dstreg] & 0x80000000);
2569 PSW &= ~(PSW_Z | PSW_N | PSW_C);
2570 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2573 // 1111 1011 0110 1101 Rm Rn Rd; asl Rm,Rn,Rd
2574 8.0xfb+8.0x6d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::asl
2579 int srcreg1, srcreg2, dstreg;
2582 srcreg1 = translate_rreg (SD_, RM2);
2583 srcreg2 = translate_rreg (SD_, RN0);
2584 dstreg = translate_rreg (SD_, RD0);
2586 State.regs[dstreg] = State.regs[srcreg2] << State.regs[srcreg1];;
2588 z = (State.regs[dstreg] == 0);
2589 n = (State.regs[dstreg] & 0x80000000);
2591 PSW &= ~(PSW_Z | PSW_N | PSW_C);
2592 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2595 // 1111 1011 1010 1101 Rm Rn Rd1 Rd2; mul Rm,Rn,Rd1,Rd2
2596 8.0xfb+8.0xad+4.RM2,4.RN0+4.RD0,4.RD2:D2c:::mul
2600 int srcreg1, srcreg2, dstreg1, dstreg2;
2601 signed long long temp;
2604 srcreg1 = translate_rreg (SD_, RM2);
2605 srcreg2 = translate_rreg (SD_, RN0);
2606 dstreg1 = translate_rreg (SD_, RD0);
2607 dstreg2 = translate_rreg (SD_, RD2);
2609 temp = ((signed64)(signed32)State.regs[srcreg1]
2610 * (signed64)(signed32)State.regs[srcreg2]);
2611 State.regs[dstreg1] = temp & 0xffffffff;
2612 State.regs[dstreg2] = (temp & 0xffffffff00000000LL) >> 32;;
2615 // 1111 1011 1011 1101 Rm Rn Rd1 Rd2; mulu Rm,Rn,Rd1,Rd2
2616 8.0xfb+8.0xbd+4.RM2,4.RN0+4.RD0,4.RD2:D2c:::mulu
2620 int srcreg1, srcreg2, dstreg1, dstreg2;
2621 signed long long temp;
2624 srcreg1 = translate_rreg (SD_, RM2);
2625 srcreg2 = translate_rreg (SD_, RN0);
2626 dstreg1 = translate_rreg (SD_, RD0);
2627 dstreg2 = translate_rreg (SD_, RD2);
2629 temp = ((unsigned64)State.regs[srcreg1]
2630 * (unsigned64)State.regs[srcreg2]);
2631 State.regs[dstreg1] = temp & 0xffffffff;
2632 State.regs[dstreg2] = (temp & 0xffffffff00000000LL) >> 32;;
2635 // 1111 1011 0000 1110 Rn 0000 abs8 ; mov (abs8),Rn
2636 8.0xfb+8.0x0e+4.RN2,4.0x0+8.IMM8:D2p:::mov
2643 dstreg = translate_rreg (SD_, RN2);
2644 State.regs[dstreg] = load_word (IMM8);
2647 // 1111 1011 0001 1110 Rm 0000 abs8 ; mov Rn,(abs8)
2648 8.0xfb+8.0x1e+4.RM2,4.0x0+8.IMM8:D2q:::mov
2655 srcreg = translate_rreg (SD_, RM2);
2656 store_word (IMM8, State.regs[srcreg]);
2659 // 1111 1011 0010 1110 Rn 0000 abs8 ; movbu (abs8),Rn
2660 8.0xfb+8.0x2e+4.RN2,4.0x0+8.IMM8:D2p:::movbu
2667 dstreg = translate_rreg (SD_, RN2);
2668 State.regs[dstreg] = load_byte (IMM8);
2671 // 1111 1011 0011 1110 Rm 0000 abs8 ; movbu Rn,(abs8)
2672 8.0xfb+8.0x3e+4.RM2,4.0x0+8.IMM8:D2q:::movbu
2679 srcreg = translate_rreg (SD_, RM2);
2680 store_byte (IMM8, State.regs[srcreg]);
2683 // 1111 1011 0100 1110 Rn 0000 abs8 ; movhu (abs8),Rn
2684 8.0xfb+8.0x4e+4.RN2,4.0x0+8.IMM8:D2p:::movhu
2691 dstreg = translate_rreg (SD_, RN2);
2692 State.regs[dstreg] = load_half (IMM8);
2695 // 1111 1011 0101 1110 Rm 0000 abs8 ; movhu Rn,(abs8)
2696 8.0xfb+8.0x5e+4.RM2,4.0x0+8.IMM8:D2q:::movhu
2703 srcreg = translate_rreg (SD_, RM2);
2704 store_half (IMM8, State.regs[srcreg]);
2707 // 1111 1011 1000 1110 Ri Rm Rn; mov (Ri,Rm),Rn
2708 8.0xfb+8.0x8e+4.RI0,4.RM0+4.RN0,4.0x0:D2r:::mov
2712 int srcreg1, srcreg2, dstreg;
2715 srcreg1 = translate_rreg (SD_, RM0);
2716 srcreg1 = translate_rreg (SD_, RI0);
2717 dstreg = translate_rreg (SD_, RN0);
2718 State.regs[dstreg] = load_word (State.regs[srcreg1] + State.regs[srcreg2]);
2721 // 1111 1011 1001 1110 Ri Rm Rn; mov Rn,(Ri,Rm)
2722 8.0xfb+8.0x9e+4.RI0,4.RN0+4.RM0,4.0x0:D2s:::mov
2726 int srcreg, dstreg1, dstreg2;
2729 srcreg = translate_rreg (SD_, RM0);
2730 dstreg1 = translate_rreg (SD_, RI0);
2731 dstreg2 = translate_rreg (SD_, RN0);
2732 store_word (State.regs[dstreg1] + State.regs[dstreg2], State.regs[srcreg]);
2735 // 1111 1011 1010 1110 Ri Rm Rn; movbu (Ri,Rm),Rn
2736 8.0xfb+8.0xae+4.RI0,4.RM0+4.RN0,4.0x0:D2r:::movbu
2740 int srcreg1, srcreg2, dstreg;
2743 srcreg1 = translate_rreg (SD_, RM0);
2744 srcreg1 = translate_rreg (SD_, RI0);
2745 dstreg = translate_rreg (SD_, RN0);
2746 State.regs[dstreg] = load_byte (State.regs[srcreg1] + State.regs[srcreg2]);
2749 // 1111 1011 1011 1110 Ri Rm Rn; movbu Rn,(Ri,Rm)
2750 8.0xfb+8.0xbe+4.RI0,4.RN0+4.RM0,4.0x0:D2s:::movbu
2754 int srcreg, dstreg1, dstreg2;
2757 srcreg = translate_rreg (SD_, RM0);
2758 dstreg1 = translate_rreg (SD_, RI0);
2759 dstreg2 = translate_rreg (SD_, RN0);
2760 store_byte (State.regs[dstreg1] + State.regs[dstreg2], State.regs[srcreg]);
2763 // 1111 1011 1100 1110 Ri Rm Rn; movhu (Ri,Rm),Rn
2764 8.0xfb+8.0xce+4.RI0,4.RM0+4.RN0,4.0x0:D2r:::movhu
2768 int srcreg1, srcreg2, dstreg;
2771 srcreg1 = translate_rreg (SD_, RM0);
2772 srcreg1 = translate_rreg (SD_, RI0);
2773 dstreg = translate_rreg (SD_, RN0);
2774 State.regs[dstreg] = load_half (State.regs[srcreg1] + State.regs[srcreg2]);
2777 // 1111 1011 1101 1110 Ri Rm Rn; movhu Rn,(Ri,Rm)
2778 8.0xfb+8.0xde+4.RI0,4.RN0+4.RM0,4.0x0:D2s:::movhu
2782 int srcreg, dstreg1, dstreg2;
2785 srcreg = translate_rreg (SD_, RM0);
2786 dstreg1 = translate_rreg (SD_, RI0);
2787 dstreg2 = translate_rreg (SD_, RN0);
2788 store_half (State.regs[dstreg1] + State.regs[dstreg2], State.regs[srcreg]);
2791 // 1111 1011 0000 1111 Rm Rn Rd1 Rd2; mac Rm,Rn,Rd1,Rd2
2792 8.0xfb+8.0x0f+4.RM2,4.RN0+4.RD0,4.RD2:D2c:::mac
2796 int srcreg1, srcreg2, dstreg1, dstreg2;
2797 signed long long temp;
2802 srcreg1 = translate_rreg (SD_, RM2);
2803 srcreg2 = translate_rreg (SD_, RN0);
2804 dstreg1 = translate_rreg (SD_, RD0);
2805 dstreg2 = translate_rreg (SD_, RD2);
2807 temp = ((signed64)(signed32)State.regs[srcreg1]
2808 * (signed64)(signed32)State.regs[srcreg2]);
2810 sum = State.regs[dstreg2] + (temp & 0xffffffff);
2811 c = (sum < State.regs[dstreg2]) || (sum < (temp & 0xffffffff));
2812 State.regs[dstreg2] = sum;
2815 sum = State.regs[dstreg1] + temp + c;
2816 v = ((State.regs[dstreg1] & 0x80000000) == (temp & 0x80000000)
2817 && (temp & 0x80000000) != (sum & 0x80000000));
2818 State.regs[dstreg1] = sum;
2820 State.regs[REG_MCVF] = 1;
2823 // 1111 1011 0001 1111 Rm Rn Rd1 Rd2; macu Rm,Rn,Rd1,Rd2
2824 8.0xfb+8.0x1f+4.RM2,4.RN0+4.RD0,4.RD2:D2c:::macu
2828 int srcreg1, srcreg2, dstreg1, dstreg2;
2829 signed long long temp;
2834 srcreg1 = translate_rreg (SD_, RM2);
2835 srcreg2 = translate_rreg (SD_, RN0);
2836 dstreg1 = translate_rreg (SD_, RD0);
2837 dstreg2 = translate_rreg (SD_, RD2);
2839 temp = ((unsigned64)State.regs[srcreg1]
2840 * (unsigned64)State.regs[srcreg2]);
2842 sum = State.regs[dstreg2] + (temp & 0xffffffff);
2843 c = (sum < State.regs[dstreg2]) || (sum < (temp & 0xffffffff));
2844 State.regs[dstreg2] = sum;
2847 sum = State.regs[dstreg1] + temp + c;
2848 v = ((State.regs[dstreg1] & 0x80000000) == (temp & 0x80000000)
2849 && (temp & 0x80000000) != (sum & 0x80000000));
2850 State.regs[dstreg1] = sum;
2852 State.regs[REG_MCVF] = 1;
2855 // 1111 1011 0010 1111 Rm Rn Rd1; macb Rm,Rn,Rd1
2856 8.0xfb+8.0x2f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::macb
2860 int srcreg1, srcreg2, dstreg;
2865 srcreg1 = translate_rreg (SD_, RM2);
2866 srcreg2 = translate_rreg (SD_, RN0);
2867 dstreg = translate_rreg (SD_, RD0);
2869 temp = ((signed32)(State.regs[srcreg2] & 0xff)
2870 * (signed32)(State.regs[srcreg1] & 0xff));
2871 sum = State.regs[dstreg] + temp;
2872 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2873 && (temp & 0x80000000) != (sum & 0x80000000));
2874 State.regs[dstreg] = sum;
2876 State.regs[REG_MCVF] = 1;
2879 // 1111 1011 0011 1111 Rm Rn Rd1; macbu Rm,Rn,Rd1
2880 8.0xfb+8.0x3f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::macbu
2884 int srcreg1, srcreg2, dstreg;
2889 srcreg1 = translate_rreg (SD_, RM2);
2890 srcreg2 = translate_rreg (SD_, RN0);
2891 dstreg = translate_rreg (SD_, RD0);
2893 temp = ((unsigned32)(State.regs[srcreg2] & 0xff)
2894 * (unsigned32)(State.regs[srcreg1] & 0xff));
2895 sum = State.regs[dstreg] + temp;
2896 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2897 && (temp & 0x80000000) != (sum & 0x80000000));
2898 State.regs[dstreg] = sum;
2900 State.regs[REG_MCVF] = 1;
2903 // 1111 1011 0100 1111 Rm Rn Rd1; mach Rm,Rn,Rd1
2904 8.0xfb+8.0x4f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::mach
2908 int srcreg1, srcreg2, dstreg;
2913 srcreg1 = translate_rreg (SD_, RM2);
2914 srcreg2 = translate_rreg (SD_, RN0);
2915 dstreg = translate_rreg (SD_, RD0);
2917 temp = ((signed32)(State.regs[srcreg2] & 0xffff)
2918 * (signed32)(State.regs[srcreg1] & 0xffff));
2919 sum = State.regs[dstreg] + temp;
2920 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2921 && (temp & 0x80000000) != (sum & 0x80000000));
2922 State.regs[dstreg] = sum;
2924 State.regs[REG_MCVF] = 1;
2927 // 1111 1011 0101 1111 Rm Rn Rd1; machu Rm,Rn,Rd1
2928 8.0xfb+8.0x5f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::machu
2932 int srcreg1, srcreg2, dstreg;
2937 srcreg1 = translate_rreg (SD_, RM2);
2938 srcreg2 = translate_rreg (SD_, RN0);
2939 dstreg = translate_rreg (SD_, RD0);
2941 temp = ((unsigned32)(State.regs[srcreg2] & 0xffff)
2942 * (unsigned32)(State.regs[srcreg1] & 0xffff));
2943 sum = State.regs[dstreg] + temp;
2944 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2945 && (temp & 0x80000000) != (sum & 0x80000000));
2946 State.regs[dstreg] = sum;
2948 State.regs[REG_MCVF] = 1;
2951 // 1111 1011 0110 1111 Rm Rn Rd1; dmach Rm,Rn,Rd1
2952 8.0xfb+8.0x6f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::dmach
2956 int srcreg1, srcreg2, dstreg;
2957 long temp, temp2, sum;
2961 srcreg1 = translate_rreg (SD_, RM2);
2962 srcreg2 = translate_rreg (SD_, RN0);
2963 dstreg = translate_rreg (SD_, RD0);
2965 temp = ((signed32)(State.regs[srcreg2] & 0xffff)
2966 * (signed32)(State.regs[srcreg1] & 0xffff));
2967 temp2 = ((signed32)((State.regs[srcreg1] >> 16) & 0xffff)
2968 * (signed32)((State.regs[srcreg2] >> 16) & 0xffff));
2969 sum = temp + temp2 + State.regs[dstreg];
2970 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2971 && (temp & 0x80000000) != (sum & 0x80000000));
2972 State.regs[dstreg] = sum;
2974 State.regs[REG_MCVF] = 1;
2977 // 1111 1011 0111 1111 Rm Rn Rd1; dmachu Rm,Rn,Rd1
2978 8.0xfb+8.0x7f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::dmachu
2982 int srcreg1, srcreg2, dstreg;
2983 long temp, temp2, sum;
2987 srcreg1 = translate_rreg (SD_, RM2);
2988 srcreg2 = translate_rreg (SD_, RN0);
2989 dstreg = translate_rreg (SD_, RD0);
2991 temp = ((unsigned32)(State.regs[srcreg2] & 0xffff)
2992 * (unsigned32)(State.regs[srcreg1] & 0xffff));
2993 temp2 = ((unsigned32)((State.regs[srcreg1] >> 16) & 0xffff)
2994 * (unsigned32)((State.regs[srcreg2] >> 16) & 0xffff));
2995 sum = temp + temp2 + State.regs[dstreg];
2996 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2997 && (temp & 0x80000000) != (sum & 0x80000000));
2998 State.regs[dstreg] = sum;
3000 State.regs[REG_MCVF] = 1;
3003 // 1111 1011 1000 1111 Rm Rn Rd1 Rd2; dmulh Rm,Rn,Rd1,Rd2
3004 8.0xfb+8.0x8f+4.RM2,4.RN0+4.RD0,4.RD2:D2c:::dmulh
3008 int srcreg1, srcreg2, dstreg1, dstreg2;
3009 signed long long temp;
3012 srcreg1 = translate_rreg (SD_, RM2);
3013 srcreg2 = translate_rreg (SD_, RN0);
3014 dstreg1 = translate_rreg (SD_, RD0);
3015 dstreg2 = translate_rreg (SD_, RD2);
3017 temp = ((signed32)(State.regs[srcreg1] & 0xffff)
3018 * (signed32)(State.regs[srcreg1] & 0xffff));
3019 State.regs[dstreg2] = temp;
3020 temp = ((signed32)((State.regs[srcreg1] >> 16) & 0xffff)
3021 * (signed32)((State.regs[srcreg1] >>16) & 0xffff));
3022 State.regs[dstreg1] = temp;
3025 // 1111 1011 1001 1111 Rm Rn Rd1 Rd2; dmulhu Rm,Rn,Rd1,Rd2
3026 8.0xfb+8.0x9f+4.RM2,4.RN0+4.RD0,4.RD2:D2c:::dmulhu
3030 int srcreg1, srcreg2, dstreg1, dstreg2;
3031 signed long long temp;
3034 srcreg1 = translate_rreg (SD_, RM2);
3035 srcreg2 = translate_rreg (SD_, RN0);
3036 dstreg1 = translate_rreg (SD_, RD0);
3037 dstreg2 = translate_rreg (SD_, RD2);
3039 temp = ((unsigned32)(State.regs[srcreg1] & 0xffff)
3040 * (unsigned32)(State.regs[srcreg1] & 0xffff));
3041 State.regs[dstreg2] = temp;
3042 temp = ((unsigned32)((State.regs[srcreg1] >> 16) & 0xffff)
3043 * (unsigned32)((State.regs[srcreg1] >>16) & 0xffff));
3044 State.regs[dstreg1] = temp;
3047 // 1111 1011 1010 1111 Rm Rn; sat24 Rm,Rn
3048 8.0xfb+8.0xaf+4.RM2,4.RN0+8.0x0:D2:::sat24
3056 srcreg = translate_rreg (SD_, RM2);
3057 dstreg = translate_rreg (SD_, RN0);
3059 value = State.regs[srcreg];
3061 if (value >= 0x7fffff)
3062 State.regs[dstreg] = 0x7fffff;
3063 else if (value <= 0xff800000)
3064 State.regs[dstreg] = 0xff800000;
3066 State.regs[dstreg] = value;
3069 // 1111 1011 1111 1111 Rm Rn Rd1; bsch Rm,Rn,Rd1
3070 8.0xfb+8.0xff+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::bsch
3075 int srcreg1, srcreg2, dstreg;
3079 srcreg1 = translate_rreg (SD_, RM2);
3080 srcreg2 = translate_rreg (SD_, RN0);
3081 dstreg = translate_rreg (SD_, RD0);
3083 temp = State.regs[srcreg1];
3084 start = (State.regs[srcreg2] & 0x1f) - 1;
3088 for (i = start; i >= 0; i--)
3090 if (temp & (1 << i))
3093 State.regs[dstreg] = i;
3101 State.regs[dstreg] = 0;
3104 PSW |= (c ? PSW_C : 0);
3107 // 1111 1101 0000 1000 Rn Rn IMM32; mov imm24,Rn
3108 8.0xfd+8.0x08+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4t:::mov
3115 dstreg = translate_rreg (SD_, RN0);
3116 State.regs[dstreg] = EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3119 // 1111 1101 0001 1000 Rn Rn IMM32; movu imm24,Rn
3120 8.0xfd+8.0x18+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4k:::movu
3127 dstreg = translate_rreg (SD_, RN0);
3128 State.regs[dstreg] = FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff;
3131 // 1111 1101 0111 1000 Rn Rn IMM32; add imm24,Rn
3132 8.0xfd+8.0x78+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4c:::add
3139 dstreg = translate_rreg (SD_, RN0);
3140 genericAdd (EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)), dstreg);
3143 // 1111 1101 1000 1000 Rn Rn IMM32; addc imm24,Rn
3144 8.0xfd+8.0x88+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::addc
3148 int dstreg, z, n, c, v;
3149 unsigned long sum, imm, reg2;
3152 dstreg = translate_rreg (SD_, RN0);
3154 imm = EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3155 reg2 = State.regs[dstreg];
3156 sum = imm + reg2 + ((PSW & PSW_C) != 0);
3157 State.regs[dstreg] = sum;
3159 z = ((PSW & PSW_Z) != 0) && (sum == 0);
3160 n = (sum & 0x80000000);
3161 c = (sum < imm) || (sum < reg2);
3162 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
3163 && (reg2 & 0x80000000) != (sum & 0x80000000));
3165 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3166 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
3167 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
3170 // 1111 1101 1001 1000 Rn Rn IMM32; sub imm24,Rn
3171 8.0xfd+8.0x98+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::sub
3178 dstreg = translate_rreg (SD_, RN0);
3179 genericSub (EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)), dstreg);
3182 // 1111 1101 1010 1000 Rn Rn IMM32; subc imm24,Rn
3183 8.0xfd+8.0xa8+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::subc
3187 int dstreg, z, n, c, v;
3188 unsigned long difference, imm, reg2;
3191 dstreg = translate_rreg (SD_, RN0);
3193 imm = EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3194 reg2 = State.regs[dstreg];
3195 difference = reg2 - imm - ((PSW & PSW_C) != 0);
3196 State.regs[dstreg] = difference;
3198 z = ((PSW & PSW_Z) != 0) && (difference == 0);
3199 n = (difference & 0x80000000);
3201 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
3202 && (reg2 & 0x80000000) != (difference & 0x80000000));
3204 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3205 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
3206 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
3209 // 1111 1101 1101 1000 Rn Rn IMM32; cmp imm24,Rn
3210 8.0xfd+8.0xd8+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::cmp
3217 srcreg = translate_rreg (SD_, RN0);
3218 genericCmp (EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)), State.regs[srcreg]);
3221 // 1111 1101 1111 1000 XRn XRn IMM32; mov imm24,XRn
3222 8.0xfd+8.0xf8+4.XRM2,4.XRN0=XRM2+8.IMM24A+8.IMM24B+8.IMM24C:D4o:::mov
3230 State.regs[REG_SP] = FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff;
3236 // 1111 1101 0000 1001 Rn Rn IMM24; and imm24,Rn
3237 8.0xfd+8.0x09+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::and
3245 dstreg = translate_rreg (SD_, RN0);
3247 State.regs[dstreg] &= (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff);
3248 z = (State.regs[dstreg] == 0);
3249 n = (State.regs[dstreg] & 0x80000000) != 0;
3250 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3251 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3254 // 1111 1101 0001 1001 Rn Rn IMM24; or imm24,Rn
3255 8.0xfd+8.0x19+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::or
3263 dstreg = translate_rreg (SD_, RN0);
3265 State.regs[dstreg] |= (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff);
3266 z = (State.regs[dstreg] == 0);
3267 n = (State.regs[dstreg] & 0x80000000) != 0;
3268 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3269 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3272 // 1111 1101 0010 1001 Rn Rn IMM24; xor imm24,Rn
3273 8.0xfd+8.0x29+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::xor
3281 dstreg = translate_rreg (SD_, RN0);
3283 State.regs[dstreg] ^= (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff);
3284 z = (State.regs[dstreg] == 0);
3285 n = (State.regs[dstreg] & 0x80000000) != 0;
3286 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3287 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3290 // 1111 1101 0100 1001 Rn Rn IMM24; asr imm24,Rn
3291 8.0xfd+8.0x49+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::asr
3300 dstreg = translate_rreg (SD_, RN0);
3302 temp = State.regs[dstreg];
3304 temp >>= (FETCH24 (IMM24A, IMM24B, IMM24C));
3305 State.regs[dstreg] = temp;
3306 z = (State.regs[dstreg] == 0);
3307 n = (State.regs[dstreg] & 0x80000000) != 0;
3308 PSW &= ~(PSW_Z | PSW_N | PSW_C);
3309 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
3313 // 1111 1101 0101 1001 Rn Rn IMM24; lsr imm24,Rn
3314 8.0xfd+8.0x59+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::lsr
3322 dstreg = translate_rreg (SD_, RN0);
3324 c = State.regs[dstreg] & 1;
3325 State.regs[dstreg] >>= (FETCH24 (IMM24A, IMM24B, IMM24C));
3326 z = (State.regs[dstreg] == 0);
3327 n = (State.regs[dstreg] & 0x80000000) != 0;
3328 PSW &= ~(PSW_Z | PSW_N | PSW_C);
3329 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
3332 // 1111 1101 0110 1001 Rn Rn IMM24; asl imm24,Rn
3333 8.0xfd+8.0x69+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::asl
3341 dstreg = translate_rreg (SD_, RN0);
3343 State.regs[dstreg] <<= (FETCH24 (IMM24A, IMM24B, IMM24C));
3344 z = (State.regs[dstreg] == 0);
3345 n = (State.regs[dstreg] & 0x80000000) != 0;
3346 PSW &= ~(PSW_Z | PSW_N);
3347 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3350 // 1111 1101 1010 1001 Rn Rn IMM24; mul imm24,Rn
3351 8.0xfd+8.0xa9+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::mul
3356 unsigned long long temp;
3360 dstreg = translate_rreg (SD_, RN0);
3362 temp = ((signed64)(signed32)State.regs[dstreg]
3363 * (signed64)(signed32)EXTEND8 (FETCH24 (IMM24A, IMM24B, IMM24C)));
3364 State.regs[dstreg] = temp & 0xffffffff;
3365 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;;
3366 z = (State.regs[dstreg] == 0);
3367 n = (State.regs[dstreg] & 0x80000000) != 0;
3368 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3369 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3372 // 1111 1101 1011 1001 Rn Rn IMM24; mulu imm24,Rn
3373 8.0xfd+8.0xb9+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::mulu
3378 unsigned long long temp;
3382 dstreg = translate_rreg (SD_, RN0);
3384 temp = ((unsigned64)State.regs[dstreg]
3385 * (unsigned64)EXTEND8 (FETCH24 (IMM24A, IMM24B, IMM24C)));
3386 State.regs[dstreg] = temp & 0xffffffff;
3387 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;;
3388 z = (State.regs[dstreg] == 0);
3389 n = (State.regs[dstreg] & 0x80000000) != 0;
3390 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3391 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3394 // 1111 1101 1110 1001 Rn Rn IMM24; btst imm24,,Rn
3395 8.0xfd+8.0xe9+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::btst
3402 srcreg = translate_rreg (SD_, RN0);
3403 genericBtst (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3406 // 1111 1101 0000 1010 Rn Rm IMM24; mov (d24,Rm),Rn
3407 8.0xfd+8.0x0a+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::mov
3414 srcreg = translate_rreg (SD_, RM0);
3415 dstreg = translate_rreg (SD_, RN2);
3416 State.regs[dstreg] = load_word (State.regs[srcreg]
3417 + EXTEND24 (FETCH24 (IMM24A,
3421 // 1111 1101 0001 1010 Rm Rn IMM24; mov Rm,(d24,Rn)
3422 8.0xfd+8.0x1a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4q:::mov
3429 srcreg = translate_rreg (SD_, RM2);
3430 dstreg = translate_rreg (SD_, RN0);
3431 store_word (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3432 State.regs[srcreg]);
3435 // 1111 1101 0010 1010 Rn Rm IMM24; movbu (d24,Rm),Rn
3436 8.0xfd+8.0x2a+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::movbu
3443 srcreg = translate_rreg (SD_, RM0);
3444 dstreg = translate_rreg (SD_, RN2);
3445 State.regs[dstreg] = load_byte (State.regs[srcreg]
3446 + EXTEND24 (FETCH24 (IMM24A,
3450 // 1111 1101 0011 1010 Rm Rn IMM24; movbu Rm,(d24,Rn)
3451 8.0xfd+8.0x3a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4q:::movbu
3458 srcreg = translate_rreg (SD_, RM2);
3459 dstreg = translate_rreg (SD_, RN0);
3460 store_byte (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3461 State.regs[srcreg]);
3464 // 1111 1101 0100 1010 Rn Rm IMM24; movhu (d24,Rm),Rn
3465 8.0xfd+8.0x4a+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::movhu
3472 srcreg = translate_rreg (SD_, RM0);
3473 dstreg = translate_rreg (SD_, RN2);
3474 State.regs[dstreg] = load_half (State.regs[srcreg]
3475 + EXTEND24 (FETCH24 (IMM24A,
3479 // 1111 1101 0101 1010 Rm Rn IMM24; movhu Rm,(d24,Rn)
3480 8.0xfd+8.0x5a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4q:::movhu
3487 srcreg = translate_rreg (SD_, RM2);
3488 dstreg = translate_rreg (SD_, RN0);
3489 store_half (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3490 State.regs[srcreg]);
3493 // 1111 1101 0110 1010 Rn Rm IMM24; mov (d24,Rm+),Rn
3494 8.0xfd+8.0x6a+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4y:::mov
3501 srcreg = translate_rreg (SD_, RM0);
3502 dstreg = translate_rreg (SD_, RN2);
3503 State.regs[dstreg] = load_word (State.regs[srcreg]
3504 + EXTEND24 (FETCH24 (IMM24A,
3506 State.regs[srcreg] += 4;
3509 // 1111 1101 0111 1010 Rm Rn IMM24; mov Rm,(d24,Rn+)
3510 8.0xfd+8.0x7a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::mov
3517 srcreg = translate_rreg (SD_, RM2);
3518 dstreg = translate_rreg (SD_, RN0);
3519 store_word (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3520 State.regs[srcreg]);
3521 State.regs[dstreg] += 4;
3525 // 1111 1101 1000 1010 Rn 0000 IMM24; mov (d24,sp),Rn
3526 8.0xfd+8.0x8a+4.RN2,4.0x0+IMM24A+8.IMM24B+8.IMM24C:D4r:::mov
3533 dstreg = translate_rreg (SD_, RN2);
3534 State.regs[dstreg] = load_word (State.regs[REG_SP]
3535 + EXTEND24 (FETCH24 (IMM24A,
3539 // 1111 1101 1001 1010 Rm 0000 IMM24; mov Rm,(d24,sp)
3540 8.0xfd+8.0x9a+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4s:::mov
3547 srcreg = translate_rreg (SD_, RM2);
3548 store_word (State.regs[REG_SP] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3549 State.regs[srcreg]);
3552 // 1111 1101 1010 1010 Rn 0000 IMM24; movbu (d24,Rm),Rn
3553 8.0xfd+8.0xaa+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4r:::movbu
3560 dstreg = translate_rreg (SD_, RN2);
3561 State.regs[dstreg] = load_byte (State.regs[REG_SP]
3562 + EXTEND24 (FETCH24 (IMM24A,
3566 // 1111 1101 1011 1010 Rm 0000 IMM24; movbu Rm,(d24,sp)
3567 8.0xfd+8.0xba+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4s:::movbu
3574 srcreg = translate_rreg (SD_, RM2);
3575 store_byte (State.regs[REG_SP] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3576 State.regs[srcreg]);
3579 // 1111 1101 1100 1010 Rn 0000 IMM24; movhu (d24,sp),Rn
3580 8.0xfd+8.0xca+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4r:::movhu
3587 dstreg = translate_rreg (SD_, RN2);
3588 State.regs[dstreg] = load_half (State.regs[REG_SP]
3589 + EXTEND24 (FETCH24 (IMM24A,
3593 // 1111 1101 1101 1010 Rm Rn IMM24; movhu Rm,(d24,sp)
3594 8.0xfd+8.0xda+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4s:::movhu
3601 srcreg = translate_rreg (SD_, RM2);
3602 store_half (State.regs[REG_SP] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3603 State.regs[srcreg]);
3606 // 1111 1101 1110 1010 Rn Rm IMM24; movhu (d24,Rm+),Rn
3607 8.0xfd+8.0xea+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4y:::movhu
3614 srcreg = translate_rreg (SD_, RM0);
3615 dstreg = translate_rreg (SD_, RN2);
3616 State.regs[dstreg] = load_half (State.regs[srcreg]
3617 + EXTEND24 (FETCH24 (IMM24A,
3619 State.regs[dstreg] += 2;
3622 // 1111 1101 1111 1010 Rm Rn IMM24; movhu Rm,(d24,Rn+)
3623 8.0xfd+8.0xfa+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::movhu
3630 srcreg = translate_rreg (SD_, RM2);
3631 dstreg = translate_rreg (SD_, RN0);
3632 store_half (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3633 State.regs[srcreg]);
3634 State.regs[srcreg] += 2;
3637 // 1111 1101 0000 1011 Rn IMM24; mac imm24,Rn
3638 8.0xfd+8.0x0b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::mac
3643 long long temp, sum;
3647 srcreg = translate_rreg (SD_, RN2);
3649 temp = ((signed64)EXTEND8 (FETCH24 (IMM24A, IMM24B, IMM24C))
3650 * (signed64)State.regs[srcreg]);
3651 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3652 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3653 State.regs[REG_MCRL] = sum;
3656 sum = State.regs[REG_MCRH] + temp + c;
3657 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3658 && (temp & 0x80000000) != (sum & 0x80000000));
3659 State.regs[REG_MCRH] = sum;
3661 State.regs[REG_MCVF] = 1;
3664 // 1111 1101 0001 1011 Rn IMM24; macu imm24,Rn
3665 8.0xfd+8.0x1b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::macu
3670 long long temp, sum;
3674 srcreg = translate_rreg (SD_, RN2);
3676 temp = ((unsigned64) (FETCH24 (IMM24A, IMM24B, IMM24C))
3677 * (unsigned64)State.regs[srcreg]);
3678 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3679 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3680 State.regs[REG_MCRL] = sum;
3683 sum = State.regs[REG_MCRH] + temp + c;
3684 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3685 && (temp & 0x80000000) != (sum & 0x80000000));
3686 State.regs[REG_MCRH] = sum;
3688 State.regs[REG_MCVF] = 1;
3691 // 1111 1101 0010 1011 Rn IMM24; macb imm24,Rn
3692 8.0xfd+8.0x2b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::macb
3697 long long temp, sum;
3701 srcreg = translate_rreg (SD_, RN2);
3703 temp = ((signed64)EXTEND8 (FETCH24 (IMM24A, IMM24B, IMM24C))
3704 * (signed64)State.regs[srcreg] & 0xff);
3705 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3706 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3707 State.regs[REG_MCRL] = sum;
3710 sum = State.regs[REG_MCRH] + temp + c;
3711 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3712 && (temp & 0x80000000) != (sum & 0x80000000));
3713 State.regs[REG_MCRH] = sum;
3715 State.regs[REG_MCVF] = 1;
3718 // 1111 1101 0011 1011 Rn IMM24; macbu imm24,Rn
3719 8.0xfd+8.0x3b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::macbu
3724 long long temp, sum;
3728 srcreg = translate_rreg (SD_, RN2);
3730 temp = ((unsigned64) (FETCH24 (IMM24A, IMM24B, IMM24C))
3731 * (unsigned64)State.regs[srcreg] & 0xff);
3732 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3733 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3734 State.regs[REG_MCRL] = sum;
3737 sum = State.regs[REG_MCRH] + temp + c;
3738 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3739 && (temp & 0x80000000) != (sum & 0x80000000));
3740 State.regs[REG_MCRH] = sum;
3742 State.regs[REG_MCVF] = 1;
3745 // 1111 1101 0100 1011 Rn IMM24; mach imm24,Rn
3746 8.0xfd+8.0x4b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::mach
3751 long long temp, sum;
3755 srcreg = translate_rreg (SD_, RN2);
3757 temp = ((signed64)EXTEND16 (FETCH24 (IMM24A, IMM24B, IMM24C))
3758 * (signed64)State.regs[srcreg] & 0xffff);
3759 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3760 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3761 State.regs[REG_MCRL] = sum;
3764 sum = State.regs[REG_MCRH] + temp + c;
3765 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3766 && (temp & 0x80000000) != (sum & 0x80000000));
3767 State.regs[REG_MCRH] = sum;
3769 State.regs[REG_MCVF] = 1;
3772 // 1111 1101 0101 1011 Rn IMM24; machu imm24,Rn
3773 8.0xfd+8.0x5b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::machu
3778 long long temp, sum;
3782 srcreg = translate_rreg (SD_, RN2);
3784 temp = ((unsigned64) (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffff)
3785 * (unsigned64)State.regs[srcreg] & 0xffff);
3786 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3787 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3788 State.regs[REG_MCRL] = sum;
3791 sum = State.regs[REG_MCRH] + temp + c;
3792 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3793 && (temp & 0x80000000) != (sum & 0x80000000));
3794 State.regs[REG_MCRH] = sum;
3796 State.regs[REG_MCVF] = 1;
3799 // 1111 1101 0000 1110 Rn 0000 ABS24; mov (abs24),Rn
3800 8.0xfd+8.0x0e+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4u:::mov
3807 dstreg = translate_rreg (SD_, RN2);
3808 State.regs[dstreg] = load_word (FETCH24 (IMM24A, IMM24B, IMM24C));
3811 // 1111 1101 0001 1110 Rm 0000 ABS24; mov Rm,(abs24)
3812 8.0xfd+8.0x1e+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4v:::mov
3819 srcreg = translate_rreg (SD_, RM2);
3820 store_word (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3824 // 1111 1101 0010 1110 Rn 0000 ABS24; movbu (abs24),Rn
3825 8.0xfd+8.0x2e+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4t:::movbu
3832 dstreg = translate_rreg (SD_, RN2);
3833 State.regs[dstreg] = load_byte (FETCH24 (IMM24A, IMM24B, IMM24C));
3836 // 1111 1101 0011 1110 Rm 0000 ABS24; movbu Rm,(abs24)
3837 8.0xfd+8.0x3e+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4u:::movbu
3844 srcreg = translate_rreg (SD_, RM2);
3845 store_byte (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3849 // 1111 1101 0100 1110 Rn 0000 ABS24; movhu (abs24),Rn
3850 8.0xfd+8.0x4e+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4t:::movhu
3857 dstreg = translate_rreg (SD_, RN2);
3858 State.regs[dstreg] = load_half (FETCH24 (IMM24A, IMM24B, IMM24C));
3861 // 1111 1101 0101 1110 Rm 0000 ABS24; movhu Rm,(abs24)
3862 8.0xfd+8.0x5e+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4u:::movhu
3869 srcreg = translate_rreg (SD_, RM2);
3870 store_half (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3874 // 1111 1110 0000 1000 Rn Rn IMM32; mov imm32,Rn
3875 8.0xfe+8.0x08+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::mov
3882 dstreg = translate_rreg (SD_, RN0);
3883 State.regs[dstreg] = FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
3886 // 1111 1110 0001 1000 Rn Rn IMM32; movu imm32,Rn
3887 8.0xfe+8.0x18+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::movu
3894 dstreg = translate_rreg (SD_, RN0);
3895 State.regs[dstreg] = FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
3898 // 1111 1110 0111 1000 Rn Rn IMM32; add imm32,Rn
3899 8.0xfe+8.0x78+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::add
3906 dstreg = translate_rreg (SD_, RN0);
3907 genericAdd (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), dstreg);
3910 // 1111 1110 1000 1000 Rn Rn IMM32; addc imm32,Rn
3911 8.0xfe+8.0x88+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::addc
3916 unsigned int imm, reg2, sum;
3920 dstreg = translate_rreg (SD_, RN0);
3922 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
3923 reg2 = State.regs[dstreg];
3924 sum = imm + reg2 + ((PSW & PSW_C) != 0);
3925 State.regs[dstreg] = sum;
3927 z = ((PSW & PSW_Z) != 0) && (sum == 0);
3928 n = (sum & 0x80000000);
3929 c = (sum < imm) || (sum < reg2);
3930 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
3931 && (reg2 & 0x80000000) != (sum & 0x80000000));
3933 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3934 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
3935 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
3938 // 1111 1110 1001 1000 Rn Rn IMM32; sub imm32,Rn
3939 8.0xfe+8.0x98+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::sub
3946 dstreg = translate_rreg (SD_, RN0);
3947 genericSub (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), dstreg);
3950 // 1111 1110 1010 1000 Rn Rn IMM32; subc imm32,Rn
3951 8.0xfe+8.0xa8+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::subc
3956 unsigned int imm, reg2, difference;
3960 dstreg = translate_rreg (SD_, RN0);
3962 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
3963 reg2 = State.regs[dstreg];
3964 difference = reg2 - imm - ((PSW & PSW_C) != 0);
3965 State.regs[dstreg] = difference;
3967 z = ((PSW & PSW_Z) != 0) && (difference == 0);
3968 n = (difference & 0x80000000);
3970 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
3971 && (reg2 & 0x80000000) != (difference & 0x80000000));
3973 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3974 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
3975 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
3978 // 1111 1110 0111 1000 Rn Rn IMM32; cmp imm32,Rn
3979 8.0xfe+8.0xd8+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::cmp
3986 srcreg = translate_rreg (SD_, RN0);
3987 genericCmp (FETCH32(IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
3990 // 1111 1110 1111 1000 XRn XRn IMM32; mov imm32,XRn
3991 8.0xfe+8.0xf8+4.XRM2,4.XRN0=XRM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5b:::mov
3998 State.regs[REG_SP] = FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
4003 // 1111 1110 0000 1001 Rn Rn IMM32; and imm32,Rn
4004 8.0xfe+8.0x09+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::and
4012 dstreg = translate_rreg (SD_, RN0);
4014 State.regs[dstreg] &= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4015 z = (State.regs[dstreg] == 0);
4016 n = (State.regs[dstreg] & 0x80000000) != 0;
4017 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4018 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4021 // 1111 1110 0001 1001 Rn Rn IMM32; or imm32,Rn
4022 8.0xfe+8.0x19+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::or
4030 dstreg = translate_rreg (SD_, RN0);
4032 State.regs[dstreg] |= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4033 z = (State.regs[dstreg] == 0);
4034 n = (State.regs[dstreg] & 0x80000000) != 0;
4035 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4036 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4039 // 1111 1110 0010 1001 Rn Rn IMM32; xor imm32,Rn
4040 8.0xfe+8.0x29+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::xor
4048 dstreg = translate_rreg (SD_, RN0);
4050 State.regs[dstreg] ^= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4051 z = (State.regs[dstreg] == 0);
4052 n = (State.regs[dstreg] & 0x80000000) != 0;
4053 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4054 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4057 // 1111 1110 0100 1001 Rn Rn IMM32; asr imm32,Rn
4058 8.0xfe+8.0x49+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::asr
4067 dstreg = translate_rreg (SD_, RN0);
4069 temp = State.regs[dstreg];
4071 temp >>= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4072 State.regs[dstreg] = temp;
4073 z = (State.regs[dstreg] == 0);
4074 n = (State.regs[dstreg] & 0x80000000) != 0;
4075 PSW &= ~(PSW_Z | PSW_N | PSW_C);
4076 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
4079 // 1111 1110 0101 1001 Rn Rn IMM32; lsr imm32,Rn
4080 8.0xfe+8.0x59+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::lsr
4088 dstreg = translate_rreg (SD_, RN0);
4090 c = State.regs[dstreg] & 1;
4091 State.regs[dstreg] >>= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4092 z = (State.regs[dstreg] == 0);
4093 n = (State.regs[dstreg] & 0x80000000) != 0;
4094 PSW &= ~(PSW_Z | PSW_N | PSW_C);
4095 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
4098 // 1111 1110 0110 1001 Rn Rn IMM32; asl imm32,Rn
4099 8.0xfe+8.0x69+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::asl
4107 dstreg = translate_rreg (SD_, RN0);
4109 State.regs[dstreg] <<= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4110 z = (State.regs[dstreg] == 0);
4111 n = (State.regs[dstreg] & 0x80000000) != 0;
4112 PSW &= ~(PSW_Z | PSW_N);
4113 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4119 // 1111 1110 1110 1001 Rn Rn IMM32; btst imm32,Rn
4120 8.0xfe+8.0xe9+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5a:::btst
4127 srcreg = translate_rreg (SD_, RN0);
4128 genericBtst (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4131 // 1111 1110 0000 1010 Rn Rm IMM32; mov (d32,Rm),Rn
4132 8.0xfe+8.0x0a+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5f:::mov
4139 srcreg = translate_rreg (SD_, RM0);
4140 dstreg = translate_rreg (SD_, RN2);
4141 State.regs[dstreg] = load_word (State.regs[srcreg]
4142 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4145 // 1111 1110 0001 1010 Rm Rn IMM32; mov Rm,(d32,Rn)
4146 8.0xfe+8.0x1a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5g:::mov
4153 srcreg = translate_rreg (SD_, RM2);
4154 dstreg = translate_rreg (SD_, RN0);
4155 store_word (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4156 State.regs[srcreg]);
4159 // 1111 1110 0010 1010 Rn Rm IMM32; movbu (d32,Rm),Rn
4160 8.0xfe+8.0x2a+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::movbu
4167 srcreg = translate_rreg (SD_, RM0);
4168 dstreg = translate_rreg (SD_, RN2);
4169 State.regs[dstreg] = load_byte (State.regs[srcreg]
4170 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4173 // 1111 1110 0011 1010 Rm Rn IMM32; movbu Rm,(d32,Rn)
4174 8.0xfe+8.0x3a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5b:::movbu
4181 srcreg = translate_rreg (SD_, RM2);
4182 dstreg = translate_rreg (SD_, RN0);
4183 store_byte (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4184 State.regs[srcreg]);
4187 // 1111 1110 0100 1010 Rn Rm IMM32; movhu (d32,Rm),Rn
4188 8.0xfe+8.0x4a+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::movhu
4195 srcreg = translate_rreg (SD_, RM0);
4196 dstreg = translate_rreg (SD_, RN2);
4197 State.regs[dstreg] = load_half (State.regs[srcreg]
4198 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4201 // 1111 1110 0101 1010 Rm Rn IMM32; movhu Rm,(d32,Rn)
4202 8.0xfe+8.0x5a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5b:::movhu
4209 srcreg = translate_rreg (SD_, RM2);
4210 dstreg = translate_rreg (SD_, RN0);
4211 store_half (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4212 State.regs[srcreg]);
4215 // 1111 1110 0110 1010 Rn Rm IMM32; mov (d32,Rm+),Rn
4216 8.0xfe+8.0x6a+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5y:::mov
4223 srcreg = translate_rreg (SD_, RM0);
4224 dstreg = translate_rreg (SD_, RN2);
4225 State.regs[dstreg] = load_word (State.regs[srcreg]
4226 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4227 State.regs[srcreg] += 4;
4230 // 1111 1110 0111 1010 Rm Rn IMM32; mov Rm,(d32,Rn+)
4231 8.0xfe+8.0x7a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5z:::mov
4238 srcreg = translate_rreg (SD_, RM2);
4239 dstreg = translate_rreg (SD_, RN0);
4240 store_word (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4241 State.regs[srcreg]);
4242 State.regs[dstreg] += 4;
4246 // 1111 1110 1000 1010 Rn 0000 IMM32; mov (d32,sp),Rn
4247 8.0xfe+8.0x8a+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5c:::mov
4254 dstreg = translate_rreg (SD_, RN2);
4255 State.regs[dstreg] = load_word (State.regs[REG_SP]
4256 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4259 // 1111 1110 1001 1010 Rm 0000 IMM32; mov Rm,(d32,sp)
4260 8.0xfe+8.0x9a+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5d:::mov
4267 srcreg = translate_rreg (SD_, RM2);
4268 store_word (State.regs[REG_SP] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4269 State.regs[srcreg]);
4272 // 1111 1110 1010 1010 Rn 0000 IMM32; movbu (d32,sp),Rn
4273 8.0xfe+8.0xaa+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5c:::movbu
4280 dstreg = translate_rreg (SD_, RN2);
4281 State.regs[dstreg] = load_byte (State.regs[REG_SP]
4282 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4285 // 1111 1110 1011 1010 Rm 0000 IMM32; movbu Rm,(d32,sp)
4286 8.0xfe+8.0xba+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5d:::movbu
4293 srcreg = translate_rreg (SD_, RM2);
4294 store_byte (State.regs[REG_SP] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4295 State.regs[srcreg]);
4298 // 1111 1110 1100 1010 Rn 0000 IMM32; movhu (d32,sp),Rn
4299 8.0xfe+8.0xca+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5c:::movhu
4306 dstreg = translate_rreg (SD_, RN2);
4307 State.regs[dstreg] = load_half (State.regs[REG_SP]
4308 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4311 // 1111 1110 1101 1010 Rm 0000 IMM32; movhu Rm,(d32,sp)
4312 8.0xfe+8.0xda+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5d:::movhu
4319 srcreg = translate_rreg (SD_, RM2);
4320 store_half (State.regs[REG_SP] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4321 State.regs[srcreg]);
4325 // 1111 1110 1110 1010 Rn Rm IMM32; movhu (d32,Rm+),Rn
4326 8.0xfe+8.0xea+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5y:::movhu
4333 srcreg = translate_rreg (SD_, RM0);
4334 dstreg = translate_rreg (SD_, RN2);
4335 State.regs[dstreg] = load_half (State.regs[srcreg]
4336 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4337 State.regs[srcreg] += 2;
4340 // 1111 1110 1111 1010 Rm Rn IMM32; movhu Rm,(d32,Rn+)
4341 8.0xfe+8.0xfa+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5f:::movhu
4348 srcreg = translate_rreg (SD_, RM2);
4349 dstreg = translate_rreg (SD_, RN0);
4350 store_half (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4351 State.regs[srcreg]);
4352 State.regs[dstreg] += 2;
4367 // 1111 1110 0000 1110 Rn 0000 IMM32; mov (abs32),Rn
4368 8.0xfe+8.0x0e+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5h:::mov
4375 dstreg = translate_rreg (SD_, RN2);
4376 State.regs[dstreg] = load_word (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4379 // 1111 1110 0001 1110 Rm 0000 IMM32; mov Rn,(abs32)
4380 8.0xfe+8.0x1e+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5e:::mov
4387 srcreg = translate_rreg (SD_, RM2);
4388 store_word (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4391 // 1111 1110 0020 1110 Rn 0000 IMM32; movbu (abs32),Rn
4392 8.0xfe+8.0x2e+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5i:::movbu
4399 dstreg = translate_rreg (SD_, RN2);
4400 State.regs[dstreg] = load_byte (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4403 // 1111 1110 0011 1110 Rm 0000 IMM32; movbu Rn,(abs32)
4404 8.0xfe+8.0x3e+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5e:::movbu
4411 srcreg = translate_rreg (SD_, RM2);
4412 store_byte (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4415 // 1111 1110 0100 1110 Rn 0000 IMM32; movhu (abs32),Rn
4416 8.0xfe+8.0x4e+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5j:::movhu
4423 dstreg = translate_rreg (SD_, RN2);
4424 State.regs[dstreg] = load_half (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4427 // 1111 1110 0101 1110 Rm 0000 IMM32; movhu Rn,(abs32)
4428 8.0xfe+8.0x5e+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5e:::movhu
4435 srcreg = translate_rreg (SD_, RM2);
4436 store_half (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);