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 :function:::int:translate_xreg:int xreg
41 // 1111 0000 0010 00An; mov USP,An
42 8.0xf0+4.0x2,00,2.AN0:D0m:::mov
47 State.regs[REG_A0 + AN0] = State.regs[REG_USP];
51 // 1111 0000 0010 01An; mov SSP,An
52 8.0xf0+4.0x2,01,2.AN0:D0n:::mov
57 State.regs[REG_A0 + AN0] = State.regs[REG_SSP];
61 // 1111 0000 0010 10An; mov MSP,An
62 8.0xf0+4.0x2,10,2.AN0:D0o:::mov
67 State.regs[REG_A0 + AN0] = State.regs[REG_MSP];
71 // 1111 0000 0010 11An; mov PC,An
72 8.0xf0+4.0x2,11,2.AN0:D0p:::mov
77 State.regs[REG_A0 + AN0] = PC;
81 // 1111 0000 0011 Am00; mov Am,USP
82 8.0xf0+4.0x3,2.AM1,00:D0q:::mov
87 State.regs[REG_USP] = State.regs[REG_A0 + AM1];
90 // 1111 0000 0011 Am01; mov Am,SSP
91 8.0xf0+4.0x3,2.AM1,01:D0r:::mov
96 State.regs[REG_SSP] = State.regs[REG_A0 + AM1];
99 // 1111 0000 0011 Am10; mov Am,MSP
100 8.0xf0+4.0x3,2.AM1,10:D0s:::mov
105 State.regs[REG_MSP] = State.regs[REG_A0 + AM1];
109 // 1111 0000 1110 imm4; syscall
110 8.0xf0+4.0xe,IMM4:D0t:::syscall
114 unsigned int sp, next_pc;
117 sp = State.regs[REG_SP];
118 next_pc = State.regs[REG_PC] + 2;
119 store_word (sp - 4, next_pc);
120 store_word (sp - 8, PSW);
121 State.regs[REG_PC] = 0x40000000 + IMM4 * 8;
126 // 1111 0010 1110 11Dn; mov EPSW,Dn
127 8.0xf2+4.0xe,11,2.DN0:D0u:::mov
132 State.regs[REG_D0 + DN0] = PSW;
136 // 1111 0010 1111 Dm01; mov Dm,EPSW
137 8.0xf2+4.0xf,2.DM1,01:D0v:::mov
142 PSW = State.regs[REG_D0 + DM1];
145 // 1111 0101 00Am Rn; mov Am,Rn
146 8.0xf5+00,2.AM1,4.RN0:D0w:::mov
150 int destreg = translate_rreg (SD_, RN0);
153 State.regs[destreg] = State.regs[REG_A0 + AM1];
156 // 1111 0101 01Dm Rn; mov Dm,Rn
157 8.0xf5+01,2.DM1,4.RN0:D0x:::mov
161 int destreg = translate_rreg (SD_, RN0);
164 State.regs[destreg] = State.regs[REG_D0 + DM1];
167 // 1111 0101 10Rm An; mov Rm,An
168 8.0xf5+10,4.RM1,2.AN0:D0y:::mov
172 int destreg = translate_rreg (SD_, RM1);
175 State.regs[REG_A0 + AN0] = State.regs[destreg];
178 // 1111 0101 11Rm Dn; mov Rm,Dn
179 8.0xf5+11,4.RM1,2.DN0:D0z:::mov
183 int destreg = translate_rreg (SD_, RM1);
186 State.regs[REG_D0 + DN0] = State.regs[destreg];
190 // 1111 1000 1100 1110 regs....; movm (USP),regs
191 8.0xf8+8.0xce+8.REGS:D1a:::movm
195 unsigned long usp = State.regs[REG_USP];
204 State.regs[REG_LAR] = load_word (usp);
206 State.regs[REG_LIR] = load_word (usp);
208 State.regs[REG_MDR] = load_word (usp);
210 State.regs[REG_A0 + 1] = load_word (usp);
212 State.regs[REG_A0] = load_word (usp);
214 State.regs[REG_D0 + 1] = load_word (usp);
216 State.regs[REG_D0] = load_word (usp);
222 State.regs[REG_A0 + 3] = load_word (usp);
228 State.regs[REG_A0 + 2] = load_word (usp);
234 State.regs[REG_D0 + 3] = load_word (usp);
240 State.regs[REG_D0 + 2] = load_word (usp);
244 if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_am33)
248 /* Need to restore MDQR, MCRH, MCRL, and MCVF */
250 State.regs[REG_E0 + 1] = load_word (usp);
252 State.regs[REG_E0 + 0] = load_word (usp);
258 State.regs[REG_E0 + 7] = load_word (usp);
260 State.regs[REG_E0 + 6] = load_word (usp);
262 State.regs[REG_E0 + 5] = load_word (usp);
264 State.regs[REG_E0 + 4] = load_word (usp);
270 State.regs[REG_E0 + 3] = load_word (usp);
272 State.regs[REG_E0 + 2] = load_word (usp);
277 /* And make sure to update the stack pointer. */
278 State.regs[REG_USP] = usp;
281 // 1111 1000 1100 1111 regs....; movm (USP),regs
282 8.0xf8+8.0xcf+8.REGS:D1b:::movm
286 unsigned long usp = State.regs[REG_USP];
289 if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_am33)
294 store_word (usp, State.regs[REG_E0 + 2]);
296 store_word (usp, State.regs[REG_E0 + 3]);
302 store_word (usp, State.regs[REG_E0 + 4]);
304 store_word (usp, State.regs[REG_E0 + 5]);
306 store_word (usp, State.regs[REG_E0 + 6]);
308 store_word (usp, State.regs[REG_E0 + 7]);
314 store_word (usp, State.regs[REG_E0 + 0]);
316 store_word (usp, State.regs[REG_E0 + 1]);
318 /* Need to save MDQR, MCRH, MCRL, and MCVF */
325 store_word (usp, State.regs[REG_D0 + 2]);
331 store_word (usp, State.regs[REG_D0 + 3]);
337 store_word (usp, State.regs[REG_A0 + 2]);
343 store_word (usp, State.regs[REG_A0 + 3]);
349 store_word (usp, State.regs[REG_D0]);
351 store_word (usp, State.regs[REG_D0 + 1]);
353 store_word (usp, State.regs[REG_A0]);
355 store_word (usp, State.regs[REG_A0 + 1]);
357 store_word (usp, State.regs[REG_MDR]);
359 store_word (usp, State.regs[REG_LIR]);
361 store_word (usp, State.regs[REG_LAR]);
365 /* And make sure to update the stack pointer. */
366 State.regs[REG_USP] = usp;
369 // 1111 1100 1111 1100 imm32...; and imm32,EPSW
370 8.0xfc+8.0xfc+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:4a:::and
375 PSW &= FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
378 // 1111 1100 1111 1101 imm32...; or imm32,EPSW
379 8.0xfc+8.0xfd+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D4a:::or
384 PSW |= FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
387 // 1111 1001 0000 1000 Rm Rn; mov Rm,Rn (Rm != Rn)
388 8.0xf9+8.0x08+4.RM2,4.RN0!RM2:D1g:::mov
396 srcreg = translate_rreg (SD_, RM2);
397 dstreg = translate_rreg (SD_, RN0);
398 State.regs[dstreg] = State.regs[srcreg];
401 // 1111 1001 0001 1000 Rn Rn; ext Rn
402 8.0xf9+8.0x18+4.RN0,4.RN2=RN0:D1:::ext
409 srcreg = translate_rreg (SD_, RN0);
410 if (State.regs[srcreg] & 0x80000000)
411 State.regs[REG_MDR] = -1;
413 State.regs[REG_MDR] = 0;
416 // 1111 1001 0010 1000 Rm Rn; extb Rm,Rn
417 8.0xf9+8.0x28+4.RM2,4.RN0!RM2:D1:::extb
424 srcreg = translate_rreg (SD_, RM2);
425 dstreg = translate_rreg (SD_, RN0);
426 State.regs[dstreg] = EXTEND8 (State.regs[srcreg]);
429 // 1111 1001 0011 1000 Rm Rn; extbu Rm,Rn
430 8.0xf9+8.0x38+4.RM2,4.RN0!RM2:D1:::extbu
437 srcreg = translate_rreg (SD_, RM2);
438 dstreg = translate_rreg (SD_, RN0);
439 State.regs[dstreg] = State.regs[srcreg] & 0xff;
442 // 1111 1001 0100 1000 Rm Rn; exth Rm,Rn
443 8.0xf9+8.0x48+4.RM2,4.RN0!RM2:D1:::exth
450 srcreg = translate_rreg (SD_, RM2);
451 dstreg = translate_rreg (SD_, RN0);
452 State.regs[dstreg] = EXTEND16 (State.regs[srcreg]);
455 // 1111 1001 0101 1000 Rm Rn; exthu Rm,Rn
456 8.0xf9+8.0x58+4.RM2,4.RN0!RM2:D1:::exthu
463 srcreg = translate_rreg (SD_, RM2);
464 dstreg = translate_rreg (SD_, RN0);
465 State.regs[dstreg] = State.regs[srcreg] & 0xffff;
468 // 1111 1001 0110 1000 Rn Rn; clr Rn
469 8.0xf9+8.0x68+4.RM2,4.RN0=RM2:D1:::clr
476 dstreg = translate_rreg (SD_, RN0);
477 State.regs[dstreg] = 0;
479 PSW &= ~(PSW_V | PSW_C | PSW_N);
482 // 1111 1001 0111 1000 Rm Rn; add Rm,Rn
483 8.0xf9+8.0x78+4.RM2,4.RN0:D1b:::add
490 srcreg = translate_rreg (SD_, RM2);
491 dstreg = translate_rreg (SD_, RN0);
492 genericAdd (State.regs[srcreg], dstreg);
495 // 1111 1001 1000 1000 Rm Rn; addc Rm,Rn
496 8.0xf9+8.0x88+4.RM2,4.RN0:D1b:::addc
502 unsigned long reg1, reg2, sum;
505 srcreg = translate_rreg (SD_, RM2);
506 dstreg = translate_rreg (SD_, RN0);
508 reg1 = State.regs[srcreg];
509 reg2 = State.regs[dstreg];
510 sum = reg1 + reg2 + ((PSW & PSW_C) != 0);
511 State.regs[dstreg] = sum;
513 z = ((PSW & PSW_Z) != 0) && (sum == 0);
514 n = (sum & 0x80000000);
515 c = (sum < reg1) || (sum < reg2);
516 v = ((reg2 & 0x80000000) == (reg1 & 0x80000000)
517 && (reg2 & 0x80000000) != (sum & 0x80000000));
519 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
520 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
521 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
524 // 1111 1001 1001 1000 Rm Rn; sub Rm,Rn
525 8.0xf9+8.0x98+4.RM2,4.RN0:D1b:::sub
532 srcreg = translate_rreg (SD_, RM2);
533 dstreg = translate_rreg (SD_, RN0);
534 genericSub (State.regs[srcreg], dstreg);
537 // 1111 1001 1010 1000 Rm Rn; subc Rm,Rn
538 8.0xf9+8.0xa8+4.RM2,4.RN0:D1b:::subc
544 unsigned long reg1, reg2, difference;
547 srcreg = translate_rreg (SD_, RM2);
548 dstreg = translate_rreg (SD_, RN0);
550 reg1 = State.regs[srcreg];
551 reg2 = State.regs[dstreg];
552 difference = reg2 - reg1 - ((PSW & PSW_C) != 0);
553 State.regs[dstreg] = difference;
555 z = ((PSW & PSW_Z) != 0) && (difference == 0);
556 n = (difference & 0x80000000);
558 v = ((reg2 & 0x80000000) == (reg1 & 0x80000000)
559 && (reg2 & 0x80000000) != (difference & 0x80000000));
561 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
562 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
563 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
566 // 1111 1001 1011 1000 Rn Rn; inc Rn
567 8.0xf9+8.0xb8+4.RN0,4.RN2=RN0:D1:::inc
574 dstreg = translate_rreg (SD_, RN0);
575 genericAdd (1, dstreg);
578 // 1111 1001 1101 1000 Rn Rn; inc Rn
579 8.0xf9+8.0xc8+4.RN0,4.RN2=RN0:D1:::inc4
586 dstreg = translate_rreg (SD_, RN0);
587 State.regs[dstreg] += 4;
590 // 1111 1001 1101 1000 Rm Rn; cmp Rm,Rn
591 8.0xf9+8.0xd8+4.RM2,4.RN0:D1:::cmp
595 int srcreg1, srcreg2;
598 srcreg1 = translate_rreg (SD_, RN0);
599 srcreg2 = translate_rreg (SD_, RM2);
600 genericCmp (State.regs[srcreg2], State.regs[srcreg1]);
603 // 1111 1001 1110 1000 XRm Rn; mov XRm,Rn
604 8.0xf9+8.0xe8+4.XRM2,4.RN0:D1l:::mov
611 dstreg = translate_rreg (SD_, RN0);
612 srcreg = translate_xreg (SD_, XRM2);
614 State.regs[dstreg] = State.regs[srcreg];
617 // 1111 1001 1111 1000 Rm XRn; mov Rm,XRn
618 8.0xf9+8.0xf8+4.RM2,4.XRN0:D1m:::mov
625 srcreg = translate_rreg (SD_, RM2);
626 dstreg = translate_xreg (SD_, XRN0);
628 State.regs[dstreg] = State.regs[srcreg];
631 // 1111 1001 0000 1001 Rm Rn; and Rm,Rn
632 8.0xf9+8.0x09+4.RM2,4.RN0:D1a:::and
641 srcreg = translate_rreg (SD_, RM2);
642 dstreg = translate_rreg (SD_, RN0);
644 State.regs[dstreg] &= State.regs[srcreg];
645 z = (State.regs[dstreg] == 0);
646 n = (State.regs[dstreg] & 0x80000000) != 0;
647 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
648 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
651 // 1111 1001 0001 1001 Rm Rn; or Rm,Rn
652 8.0xf9+8.0x19+4.RM2,4.RN0:D1a:::or
660 srcreg = translate_rreg (SD_, RM2);
661 dstreg = translate_rreg (SD_, RN0);
663 State.regs[dstreg] |= State.regs[srcreg];
664 z = (State.regs[dstreg] == 0);
665 n = (State.regs[dstreg] & 0x80000000) != 0;
666 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
667 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
670 // 1111 1001 0010 1001 Rm Rn; xor Rm,Rn
671 8.0xf9+8.0x29+4.RM2,4.RN0:D1a:::xor
679 srcreg = translate_rreg (SD_, RM2);
680 dstreg = translate_rreg (SD_, RN0);
682 State.regs[dstreg] ^= State.regs[srcreg];
683 z = (State.regs[dstreg] == 0);
684 n = (State.regs[dstreg] & 0x80000000) != 0;
685 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
686 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
689 // 1111 1001 0011 1001 Rn Rn; not Rn
690 8.0xf9+8.0x39+4.RM2,4.RN0=RM2:D1:::not
698 dstreg = translate_rreg (SD_, RN0);
700 State.regs[dstreg] = ~State.regs[dstreg];
701 z = (State.regs[dstreg] == 0);
702 n = (State.regs[dstreg] & 0x80000000) != 0;
703 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
704 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
707 // 1111 1001 0100 1001 Rm Rn; asr Rm,Rn
708 8.0xf9+8.0x49+4.RM2,4.RN0:D1a:::asr
717 srcreg = translate_rreg (SD_, RM2);
718 dstreg = translate_rreg (SD_, RN0);
720 temp = State.regs[dstreg];
722 temp >>= State.regs[srcreg];
723 State.regs[dstreg] = temp;
724 z = (State.regs[dstreg] == 0);
725 n = (State.regs[dstreg] & 0x80000000) != 0;
726 PSW &= ~(PSW_Z | PSW_N | PSW_C);
727 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
730 // 1111 1001 0101 1001 Rm Rn; lsr Rm,Rn
731 8.0xf9+8.0x59+4.RM2,4.RN0:D1a:::lsr
740 srcreg = translate_rreg (SD_, RM2);
741 dstreg = translate_rreg (SD_, RN0);
743 c = State.regs[dstreg] & 1;
744 State.regs[dstreg] >>= State.regs[srcreg];
745 z = (State.regs[dstreg] == 0);
746 n = (State.regs[dstreg] & 0x80000000) != 0;
747 PSW &= ~(PSW_Z | PSW_N | PSW_C);
748 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
751 // 1111 1001 0110 1001 Rm Rn; asl Rm,Rn
752 8.0xf9+8.0x69+4.RM2,4.RN0:D1a:::asl
760 srcreg = translate_rreg (SD_, RM2);
761 dstreg = translate_rreg (SD_, RN0);
763 State.regs[dstreg] <<= State.regs[srcreg];
764 z = (State.regs[dstreg] == 0);
765 n = (State.regs[dstreg] & 0x80000000) != 0;
766 PSW &= ~(PSW_Z | PSW_N);
767 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
770 // 1111 1001 0111 1001 Rn Rn; asl2 Rn
771 8.0xf9+8.0x79+4.RM2,4.RN0=RM2:D1:::asl2
779 dstreg = translate_rreg (SD_, RN0);
781 State.regs[dstreg] <<= 2;
782 z = (State.regs[dstreg] == 0);
783 n = (State.regs[dstreg] & 0x80000000) != 0;
784 PSW &= ~(PSW_Z | PSW_N);
785 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
788 // 1111 1001 1000 1001 Rn Rn; ror Rn
789 8.0xf9+8.0x89+4.RM2,4.RN0=RM2:D1:::ror
798 dstreg = translate_rreg (SD_, RN0);
800 value = State.regs[dstreg];
804 value |= ((PSW & PSW_C) != 0) ? 0x80000000 : 0;
805 State.regs[dstreg] = value;
807 n = (value & 0x80000000) != 0;
808 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
809 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
812 // 1111 1001 1001 1001 Rn Rn; rol Rn
813 8.0xf9+8.0x99+4.RM2,4.RN0=RM2:D1:::rol
822 dstreg = translate_rreg (SD_, RN0);
824 value = State.regs[dstreg];
825 c = (value & 0x80000000) ? 1 : 0;
828 value |= ((PSW & PSW_C) != 0);
829 State.regs[dstreg] = value;
831 n = (value & 0x80000000) != 0;
832 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
833 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
836 // 1111 1001 1010 1001 Rm Rn; mul Rm,Rn
837 8.0xf9+8.0xa9+4.RM2,4.RN0:D1b:::mul
842 unsigned long long temp;
846 srcreg = translate_rreg (SD_, RM2);
847 dstreg = translate_rreg (SD_, RN0);
849 temp = ((signed64)(signed32)State.regs[dstreg]
850 * (signed64)(signed32)State.regs[srcreg]);
851 State.regs[dstreg] = temp & 0xffffffff;
852 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
853 z = (State.regs[dstreg] == 0);
854 n = (State.regs[dstreg] & 0x80000000) != 0;
855 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
856 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
859 // 1111 1001 1011 1001 Rm Rn; mulu Rm,Rn
860 8.0xf9+8.0xb9+4.RM2,4.RN0:D1b:::mulu
865 unsigned long long temp;
869 srcreg = translate_rreg (SD_, RM2);
870 dstreg = translate_rreg (SD_, RN0);
872 temp = ((unsigned64)State.regs[dstreg]
873 * (unsigned64)State.regs[srcreg]);
874 State.regs[dstreg] = temp & 0xffffffff;
875 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
876 z = (State.regs[dstreg] == 0);
877 n = (State.regs[dstreg] & 0x80000000) != 0;
878 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
879 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
882 // 1111 1001 1100 1001 Rm Rn; div Rm,Rn
883 8.0xf9+8.0xc9+4.RM2,4.RN0:D1b:::div
892 srcreg = translate_rreg (SD_, RM2);
893 dstreg = translate_rreg (SD_, RN0);
895 temp = State.regs[REG_MDR];
897 temp |= State.regs[dstreg];
898 State.regs[REG_MDR] = temp % (signed32)State.regs[srcreg];
899 temp /= (signed32)State.regs[srcreg];
900 State.regs[dstreg] = temp & 0xffffffff;
901 z = (State.regs[dstreg] == 0);
902 n = (State.regs[dstreg] & 0x80000000) != 0;
903 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
904 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
907 // 1111 1001 1101 1001 Rm Rn; divu Rm,Rn
908 8.0xf9+8.0xd9+4.RM2,4.RN0:D1b:::divu
913 unsigned long long temp;
917 srcreg = translate_rreg (SD_, RM2);
918 dstreg = translate_rreg (SD_, RN0);
920 temp = State.regs[REG_MDR];
922 temp |= State.regs[dstreg];
923 State.regs[REG_MDR] = temp % State.regs[srcreg];
924 temp /= State.regs[srcreg];
925 State.regs[dstreg] = temp & 0xffffffff;
926 z = (State.regs[dstreg] == 0);
927 n = (State.regs[dstreg] & 0x80000000) != 0;
928 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
929 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
933 // 1111 1001 0000 1010 Rm Rn; mov (Rm),Rn
934 8.0xf9+8.0x0a+4.RN2,4.RM0:D1h:::mov
941 srcreg = translate_rreg (SD_, RM0);
942 dstreg = translate_rreg (SD_, RN2);
943 State.regs[dstreg] = load_word (State.regs[srcreg]);
946 // 1111 1001 0001 1010 Rm Rn; mov Rm,(Rn)
947 8.0xf9+8.0x1a+4.RM2,4.RN0:D1i:::mov
954 srcreg = translate_rreg (SD_, RM2);
955 dstreg = translate_rreg (SD_, RN0);
956 store_word (State.regs[dstreg], State.regs[srcreg]);
959 // 1111 1001 0010 1010 Rm Rn; movbu (Rm),Rn
960 8.0xf9+8.0x2a+4.RN2,4.RM0:D1g:::movbu
967 srcreg = translate_rreg (SD_, RM0);
968 dstreg = translate_rreg (SD_, RN2);
969 State.regs[dstreg] = load_byte (State.regs[srcreg]);
972 // 1111 1001 0011 1010 Rm Rn; movbu Rm,(Rn)
973 8.0xf9+8.0x3a+4.RM2,4.RN0:D1i:::movbu
980 srcreg = translate_rreg (SD_, RM2);
981 dstreg = translate_rreg (SD_, RN0);
982 store_byte (State.regs[dstreg], State.regs[srcreg]);
985 // 1111 1001 0100 1010 Rm Rn; movhu (Rm),Rn
986 8.0xf9+8.0x4a+4.RN2,4.RM0:D1g:::movhu
993 srcreg = translate_rreg (SD_, RM0);
994 dstreg = translate_rreg (SD_, RN2);
995 State.regs[dstreg] = load_half (State.regs[srcreg]);
998 // 1111 1001 0101 1010 Rm Rn; movhu Rm,(Rn)
999 8.0xf9+8.0x5a+4.RM2,4.RN0:D1i:::movhu
1006 srcreg = translate_rreg (SD_, RM2);
1007 dstreg = translate_rreg (SD_, RN0);
1008 store_half (State.regs[dstreg], State.regs[srcreg]);
1011 // 1111 1001 0110 1010 Rm Rn; mov (Rm+),Rn
1012 8.0xf9+8.0x6a+4.RN2,4.RM0!RN2:D1y:::mov
1019 srcreg = translate_rreg (SD_, RM0);
1020 dstreg = translate_rreg (SD_, RN2);
1021 State.regs[dstreg] = load_word (State.regs[srcreg]);
1022 State.regs[srcreg] += 4;
1025 // 1111 1001 0111 1010 Rm Rn; mov Rm,(Rn+)
1026 8.0xf9+8.0x7a+4.RM2,4.RN0:D1z:::mov
1033 srcreg = translate_rreg (SD_, RM2);
1034 dstreg = translate_rreg (SD_, RN0);
1035 store_word (State.regs[dstreg], State.regs[srcreg]);
1036 State.regs[dstreg] += 4;
1039 // 1111 1001 1000 1010 Rn 0000; mov (sp),Rn
1040 8.0xf9+8.0x8a+4.RN2,4.0000:D1j:::mov
1047 dstreg = translate_rreg (SD_, RN2);
1048 State.regs[dstreg] = load_word (State.regs[REG_SP]);
1051 // 1111 1001 1001 1010 Rm 0000; mov Rm, (sp)
1052 8.0xf9+8.0x9a+4.RM2,4.0000:D1k:::mov
1059 srcreg = translate_rreg (SD_, RM2);
1060 store_word (State.regs[REG_SP], State.regs[srcreg]);
1063 // 1111 1001 1010 1010 Rn 0000; mobvu (sp),Rn
1064 8.0xf9+8.0xaa+4.RN2,4.0000:D1j:::movbu
1071 dstreg = translate_rreg (SD_, RN2);
1072 State.regs[dstreg] = load_byte (State.regs[REG_SP]);
1075 // 1111 1001 1011 1010 Rm 0000; movbu Rm, (sp)
1076 8.0xf9+8.0xba+4.RM2,4.0000:D1k:::movbu
1083 srcreg = translate_rreg (SD_, RM2);
1084 store_byte (State.regs[REG_SP], State.regs[srcreg]);
1087 // 1111 1001 1000 1100 Rn 0000; movhu (sp),Rn
1088 8.0xf9+8.0xca+4.RN2,4.0000:D1j:::movhu
1095 dstreg = translate_rreg (SD_, RN2);
1096 State.regs[dstreg] = load_half (State.regs[REG_SP]);
1099 // 1111 1001 1001 1101 Rm 0000; movhu Rm, (sp)
1100 8.0xf9+8.0xda+4.RM2,4.0000:D1k:::movhu
1107 srcreg = translate_rreg (SD_, RM2);
1108 store_half (State.regs[REG_SP], State.regs[srcreg]);
1111 // 1111 1001 1110 1010 Rm Rn; movhu (Rm+),Rn
1112 8.0xf9+8.0xea+4.RN2,4.RM0!RN2:D1y:::movhu
1119 srcreg = translate_rreg (SD_, RM0);
1120 dstreg = translate_rreg (SD_, RN2);
1121 State.regs[dstreg] = load_half (State.regs[srcreg]);
1122 State.regs[srcreg] += 2;
1125 // 1111 1001 1111 1010 Rm Rn; movhu Rm,(Rn+)
1126 8.0xf9+8.0xfa+4.RM2,4.RN0:D1z:::movhu
1133 srcreg = translate_rreg (SD_, RM2);
1134 dstreg = translate_rreg (SD_, RN0);
1135 store_half (State.regs[dstreg], State.regs[srcreg]);
1136 State.regs[dstreg] += 2;
1140 // 1111 1001 0000 1011 Rm Rn; mac Rm,Rn
1141 8.0xf9+8.0x0b+4.RM2,4.RN0:D1:::mac
1145 int srcreg1, srcreg2;
1146 long long temp, sum;
1150 srcreg1 = translate_rreg (SD_, RM2);
1151 srcreg2 = translate_rreg (SD_, RN0);
1153 temp = ((signed64)(signed32)State.regs[srcreg2]
1154 * (signed64)(signed32)State.regs[srcreg1]);
1155 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1156 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1157 State.regs[REG_MCRL] = sum;
1160 sum = State.regs[REG_MCRH] + temp + c;
1161 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1162 && (temp & 0x80000000) != (sum & 0x80000000));
1163 State.regs[REG_MCRH] = sum;
1165 State.regs[REG_MCVF] = 1;
1168 // 1111 1001 0001 1011 Rm Rn; macu Rm,Rn
1169 8.0xf9+8.0x1b+4.RM2,4.RN0:D1:::macu
1173 int srcreg1, srcreg2;
1174 unsigned long long temp, sum;
1178 srcreg1 = translate_rreg (SD_, RM2);
1179 srcreg2 = translate_rreg (SD_, RN0);
1181 temp = ((unsigned64)State.regs[srcreg2]
1182 * (unsigned64)State.regs[srcreg1]);
1183 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1184 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1185 State.regs[REG_MCRL] = sum;
1188 sum = State.regs[REG_MCRH] + temp + c;
1189 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1190 && (temp & 0x80000000) != (sum & 0x80000000));
1191 State.regs[REG_MCRH] = sum;
1193 State.regs[REG_MCVF] = 1;
1196 // 1111 1001 0010 1011 Rm Rn; macb Rm,Rn
1197 8.0xf9+8.0x2b+4.RM2,4.RN0:D1:::macb
1201 int srcreg1, srcreg2;
1206 srcreg1 = translate_rreg (SD_, RM2);
1207 srcreg2 = translate_rreg (SD_, RN0);
1209 temp = ((signed32)(signed8)(State.regs[srcreg2] & 0xff)
1210 * (signed32)(signed8)(State.regs[srcreg1] & 0xff));
1211 sum = State.regs[REG_MCRL] + temp;
1212 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1213 && (temp & 0x80000000) != (sum & 0x80000000));
1214 State.regs[REG_MCRL] = sum;
1216 State.regs[REG_MCVF] = 1;
1219 // 1111 1001 0011 1011 Rm Rn; macbu Rm,Rn
1220 8.0xf9+8.0x3b+4.RM2,4.RN0:D1:::macbu
1224 int srcreg1, srcreg2;
1225 long long temp, sum;
1229 srcreg1 = translate_rreg (SD_, RM2);
1230 srcreg2 = translate_rreg (SD_, RN0);
1232 temp = ((unsigned32)(State.regs[srcreg2] & 0xff)
1233 * (unsigned32)(State.regs[srcreg1] & 0xff));
1234 sum = State.regs[REG_MCRL] + temp;
1235 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1236 && (temp & 0x80000000) != (sum & 0x80000000));
1237 State.regs[REG_MCRL] = sum;
1239 State.regs[REG_MCVF] = 1;
1242 // 1111 1001 0100 1011 Rm Rn; mach Rm,Rn
1243 8.0xf9+8.0x4b+4.RM2,4.RN0:D1:::mach
1247 int srcreg1, srcreg2;
1248 long long temp, sum;
1252 srcreg1 = translate_rreg (SD_, RM2);
1253 srcreg2 = translate_rreg (SD_, RN0);
1255 temp = ((unsigned64)(signed16)(State.regs[srcreg2] & 0xffff)
1256 * (unsigned64)(signed16)(State.regs[srcreg1] & 0xffff));
1257 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1258 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1259 State.regs[REG_MCRL] = sum;
1262 sum = State.regs[REG_MCRH] + temp + c;
1263 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1264 && (temp & 0x80000000) != (sum & 0x80000000));
1265 State.regs[REG_MCRH] = sum;
1267 State.regs[REG_MCVF] = 1;
1270 // 1111 1001 0101 1011 Rm Rn; machu Rm,Rn
1271 8.0xf9+8.0x5b+4.RM2,4.RN0:D1:::machu
1275 int srcreg1, srcreg2;
1276 long long temp, sum;
1280 srcreg1 = translate_rreg (SD_, RM2);
1281 srcreg2 = translate_rreg (SD_, RN0);
1283 temp = ((unsigned64)(State.regs[srcreg2] & 0xffff)
1284 * (unsigned64)(State.regs[srcreg1] & 0xffff));
1285 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
1286 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
1287 State.regs[REG_MCRL] = sum;
1290 sum = State.regs[REG_MCRH] + temp + c;
1291 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
1292 && (temp & 0x80000000) != (sum & 0x80000000));
1293 State.regs[REG_MCRH] = sum;
1295 State.regs[REG_MCVF] = 1;
1298 // 1111 1001 0110 1011 Rm Rn; dmach Rm,Rn
1299 8.0xf9+8.0x6b+4.RM2,4.RN0:D1:::dmach
1303 int srcreg1, srcreg2;
1304 long temp, temp2, sum;
1308 srcreg1 = translate_rreg (SD_, RM2);
1309 srcreg2 = translate_rreg (SD_, RN0);
1311 temp = ((signed32)(signed16)(State.regs[srcreg2] & 0xffff)
1312 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
1313 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
1314 * (signed32)(signed16)((State.regs[srcreg2] >> 16) & 0xffff));
1315 sum = temp + temp2 + State.regs[REG_MCRL];
1316 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1317 && (temp & 0x80000000) != (sum & 0x80000000));
1318 State.regs[REG_MCRL] = sum;
1320 State.regs[REG_MCVF] = 1;
1323 // 1111 1001 0111 1011 Rm Rn; dmachu Rm,Rn
1324 8.0xf9+8.0x7b+4.RM2,4.RN0:D1:::dmachu
1328 int srcreg1, srcreg2;
1329 unsigned long temp, temp2, sum;
1333 srcreg1 = translate_rreg (SD_, RM2);
1334 srcreg2 = translate_rreg (SD_, RN0);
1336 temp = ((unsigned32)(State.regs[srcreg2] & 0xffff)
1337 * (unsigned32)(State.regs[srcreg1] & 0xffff));
1338 temp2 = ((unsigned32)((State.regs[srcreg1] >> 16) & 0xffff)
1339 * (unsigned32)((State.regs[srcreg2] >> 16) & 0xffff));
1340 sum = temp + temp2 + State.regs[REG_MCRL];
1341 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
1342 && (temp & 0x80000000) != (sum & 0x80000000));
1343 State.regs[REG_MCRL] = sum;
1345 State.regs[REG_MCVF] = 1;
1348 // 1111 1001 1000 1011 Rm Rn; dmulh Rm,Rn
1349 8.0xf9+8.0x8b+4.RM2,4.RN0:D1:::dmulh
1357 srcreg = translate_rreg (SD_, RM2);
1358 dstreg = translate_rreg (SD_, RN0);
1360 temp = ((signed32)(signed16)(State.regs[dstreg] & 0xffff)
1361 * (signed32)(signed16)(State.regs[srcreg] & 0xffff));
1362 State.regs[REG_MDRQ] = temp;
1363 temp = ((signed32)(signed16)((State.regs[dstreg] >> 16) & 0xffff)
1364 * (signed32)(signed16)((State.regs[srcreg] >>16) & 0xffff));
1365 State.regs[dstreg] = temp;
1368 // 1111 1001 1001 1011 Rm Rn; dmulhu Rm,Rn
1369 8.0xf9+8.0x9b+4.RM2,4.RN0:D1:::dumachu
1377 srcreg = translate_rreg (SD_, RM2);
1378 dstreg = translate_rreg (SD_, RN0);
1380 temp = ((unsigned32)(State.regs[dstreg] & 0xffff)
1381 * (unsigned32)(State.regs[srcreg] & 0xffff));
1382 State.regs[REG_MDRQ] = temp;
1383 temp = ((unsigned32)((State.regs[dstreg] >> 16) & 0xffff)
1384 * (unsigned32)((State.regs[srcreg] >>16) & 0xffff));
1385 State.regs[dstreg] = temp;
1388 // 1111 1001 1010 1011 Rm Rn; sat16 Rm,Rn
1389 8.0xf9+8.0xab+4.RM2,4.RN0:D1:::sat16
1397 srcreg = translate_rreg (SD_, RM2);
1398 dstreg = translate_rreg (SD_, RN0);
1400 value = State.regs[srcreg];
1402 if (value >= 0x7fff)
1403 State.regs[dstreg] = 0x7fff;
1404 else if (value <= 0xffff8000)
1405 State.regs[dstreg] = 0xffff8000;
1407 State.regs[dstreg] = value;
1409 n = (State.regs[dstreg] & 0x8000) != 0;
1410 z = (State.regs[dstreg] == 0);
1411 PSW &= ~(PSW_Z | PSW_N);
1412 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1415 // 1111 1001 1011 1011 Rm Rn; mcste Rm,Rn
1416 8.0xf9+8.0xbb+4.RM2,4.RN0:D1:::mcste
1423 srcreg = translate_rreg (SD_, RM2);
1424 dstreg = translate_rreg (SD_, RN0);
1426 PSW &= ~(PSW_V | PSW_C);
1427 PSW |= (State.regs[REG_MCVF] ? PSW_V : 0);
1429 /* 32bit saturation. */
1430 if (State.regs[srcreg] == 0x20)
1434 tmp = State.regs[REG_MCRH];
1436 tmp += State.regs[REG_MCRL];
1438 if (tmp > 0x7fffffff)
1439 State.regs[dstreg] = 0x7fffffff;
1440 else if (tmp < 0xffffffff80000000LL)
1441 State.regs[dstreg] = 0x80000000;
1443 State.regs[dstreg] = tmp;
1445 /* 16bit saturation */
1446 else if (State.regs[srcreg] == 0x10)
1450 tmp = State.regs[REG_MCRH];
1452 tmp += State.regs[REG_MCRL];
1455 State.regs[dstreg] = 0x7fff;
1456 else if (tmp < 0xffffffffffff8000LL)
1457 State.regs[dstreg] = 0x8000;
1459 State.regs[dstreg] = tmp;
1461 /* 8 bit saturation */
1462 else if (State.regs[srcreg] == 0x8)
1466 tmp = State.regs[REG_MCRH];
1468 tmp += State.regs[REG_MCRL];
1471 State.regs[dstreg] = 0x7f;
1472 else if (tmp < 0xffffffffffffff80LL)
1473 State.regs[dstreg] = 0x80;
1475 State.regs[dstreg] = tmp;
1477 /* 9 bit saturation */
1478 else if (State.regs[srcreg] == 0x9)
1482 tmp = State.regs[REG_MCRH];
1484 tmp += State.regs[REG_MCRL];
1487 State.regs[dstreg] = 0x80;
1488 else if (tmp < 0xffffffffffffff81LL)
1489 State.regs[dstreg] = 0x81;
1491 State.regs[dstreg] = tmp;
1493 /* 9 bit saturation */
1494 else if (State.regs[srcreg] == 0x30)
1498 tmp = State.regs[REG_MCRH];
1500 tmp += State.regs[REG_MCRL];
1502 if (tmp > 0x7fffffffffffLL)
1503 tmp = 0x7fffffffffffLL;
1504 else if (tmp < 0xffff800000000000LL)
1505 tmp = 0xffff800000000000LL;
1508 State.regs[dstreg] = tmp;
1512 // 1111 1001 1100 1011 Rm Rn; swap Rm,Rn
1513 8.0xf9+8.0xcb+4.RM2,4.RN0:D1:::swap
1520 srcreg = translate_rreg (SD_, RM2);
1521 dstreg = translate_rreg (SD_, RN0);
1523 State.regs[dstreg] = (((State.regs[srcreg] & 0xff) << 24)
1524 | (((State.regs[srcreg] >> 8) & 0xff) << 16)
1525 | (((State.regs[srcreg] >> 16) & 0xff) << 8)
1526 | ((State.regs[srcreg] >> 24) & 0xff));
1529 // 1111 1101 1101 1011 Rm Rn; swaph Rm,Rn
1530 8.0xf9+8.0xdb+4.RM2,4.RN0:D1:::swaph
1537 srcreg = translate_rreg (SD_, RM2);
1538 dstreg = translate_rreg (SD_, RN0);
1540 State.regs[dstreg] = (((State.regs[srcreg] & 0xff) << 8)
1541 | ((State.regs[srcreg] >> 8) & 0xff)
1542 | (((State.regs[srcreg] >> 16) & 0xff) << 24)
1543 | (((State.regs[srcreg] >> 24) & 0xff) << 16));
1546 // 1111 1001 1110 1011 Rm Rn; swhw Rm,Rn
1547 8.0xf9+8.0xeb+4.RM2,4.RN0:D1:::swhw
1554 srcreg = translate_rreg (SD_, RM2);
1555 dstreg = translate_rreg (SD_, RN0);
1557 State.regs[dstreg] = (((State.regs[srcreg] & 0xffff) << 16)
1558 | ((State.regs[srcreg] >> 16) & 0xffff));
1561 // 1111 1001 1111 1011 Rm Rn; bsch Rm,Rn
1562 8.0xf9+8.0xfb+4.RM2,4.RN0:D1:::bsch
1571 srcreg = translate_rreg (SD_, RM2);
1572 dstreg = translate_rreg (SD_, RN0);
1574 temp = State.regs[srcreg];
1575 start = (State.regs[dstreg] & 0x1f) - 1;
1579 for (i = start; i >= 0; i--)
1581 if (temp & (1 << i))
1584 State.regs[dstreg] = i;
1592 State.regs[dstreg] = 0;
1595 PSW |= (c ? PSW_C : 0);
1599 // 1111 1011 0000 1000 Rn Rn IMM8; mov IMM8,Rn
1600 8.0xfb+8.0x08+4.RM2,4.RN0=RM2+8.IMM8:D2j:::mov
1607 dstreg = translate_rreg (SD_, RN0);
1608 State.regs[dstreg] = EXTEND8 (IMM8);
1611 // 1111 1011 0001 1000 Rn Rn IMM8; movu IMM8,Rn
1612 8.0xfb+8.0x18+4.RM2,4.RN0=RM2+8.IMM8:D2:::movu
1619 dstreg = translate_rreg (SD_, RN0);
1620 State.regs[dstreg] = IMM8 & 0xff;
1623 // 1111 1011 0111 1000 Rn Rn IMM8; add IMM8,Rn
1624 8.0xfb+8.0x78+4.RM2,4.RN0=RM2+8.IMM8:D2d:::add
1631 dstreg = translate_rreg (SD_, RN0);
1632 genericAdd (EXTEND8 (IMM8), dstreg);
1635 // 1111 1011 1000 1000 Rn Rn IMM8; addc IMM8,Rn
1636 8.0xfb+8.0x88+4.RM2,4.RN0=RM2+8.IMM8:D2d:::addc
1642 unsigned long reg1, reg2, sum;
1645 dstreg = translate_rreg (SD_, RN0);
1647 imm = EXTEND8 (IMM8);
1648 reg2 = State.regs[dstreg];
1649 sum = imm + reg2 + ((PSW & PSW_C) != 0);
1650 State.regs[dstreg] = sum;
1652 z = ((PSW & PSW_Z) != 0) && (sum == 0);
1653 n = (sum & 0x80000000);
1654 c = (sum < imm) || (sum < reg2);
1655 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
1656 && (reg2 & 0x80000000) != (sum & 0x80000000));
1658 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1659 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
1660 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
1663 // 1111 1011 1001 1000 Rn Rn IMM8; sub IMM8,Rn
1664 8.0xfb+8.0x98+4.RM2,4.RN0=RM2+8.IMM8:D2d:::sub
1671 dstreg = translate_rreg (SD_, RN0);
1673 genericSub (EXTEND8 (IMM8), dstreg);
1676 // 1111 1011 1010 1000 Rn Rn IMM8; subc IMM8,Rn
1677 8.0xfb+8.0xa8+4.RM2,4.RN0=RM2+8.IMM8:D2d:::subc
1683 unsigned long reg1, reg2, difference;
1686 dstreg = translate_rreg (SD_, RN0);
1688 imm = EXTEND8 (IMM8);
1689 reg2 = State.regs[dstreg];
1690 difference = reg2 - imm - ((PSW & PSW_C) != 0);
1691 State.regs[dstreg] = difference;
1693 z = ((PSW & PSW_Z) != 0) && (difference == 0);
1694 n = (difference & 0x80000000);
1696 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
1697 && (reg2 & 0x80000000) != (difference & 0x80000000));
1699 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1700 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
1701 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
1704 // 1111 1011 1101 1000 Rn Rn IMM8; cmp IMM8,Rn
1705 8.0xfb+8.0xd8+4.RM2,4.RN0=RM2+8.IMM8:D2b:::cmp
1712 srcreg = translate_rreg (SD_, RN0);
1713 genericCmp (EXTEND8 (IMM8), State.regs[srcreg]);
1716 // 1111 1011 1111 1000 XRn XRn IMM8; mov IMM8,XRn
1717 8.0xfb+8.0xf8+4.XRM2,4.XRN0=XRM2+8.IMM8:D2k:::mov
1724 dstreg = translate_xreg (SD_, XRN0);
1726 State.regs[dstreg] = IMM8;
1729 // 1111 1011 0000 1001 Rn Rn IMM8; and IMM8,Rn
1730 8.0xfb+8.0x09+4.RM2,4.RN0=RM2+8.IMM8:D2d:::and
1738 dstreg = translate_rreg (SD_, RN0);
1740 State.regs[dstreg] &= (IMM8 & 0xff);
1741 z = (State.regs[dstreg] == 0);
1742 n = (State.regs[dstreg] & 0x80000000) != 0;
1743 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1744 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1747 // 1111 1011 0001 1001 Rn Rn IMM8; or IMM8,Rn
1748 8.0xfb+8.0x19+4.RM2,4.RN0=RM2+8.IMM8:D2d:::or
1756 dstreg = translate_rreg (SD_, RN0);
1758 State.regs[dstreg] |= (IMM8 & 0xff);
1759 z = (State.regs[dstreg] == 0);
1760 n = (State.regs[dstreg] & 0x80000000) != 0;
1761 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1762 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1765 // 1111 1011 0010 1001 Rn Rn IMM8; xor IMM8,Rn
1766 8.0xfb+8.0x29+4.RM2,4.RN0=RM2+8.IMM8:D2d:::xor
1774 dstreg = translate_rreg (SD_, RN0);
1776 State.regs[dstreg] ^= (IMM8 & 0xff);
1777 z = (State.regs[dstreg] == 0);
1778 n = (State.regs[dstreg] & 0x80000000) != 0;
1779 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1780 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1783 // 1111 1011 0100 1001 Rn Rn IMM8; asr IMM8,Rn
1784 8.0xfb+8.0x49+4.RM2,4.RN0=RM2+8.IMM8:D2a:::asr
1793 dstreg = translate_rreg (SD_, RN0);
1795 temp = State.regs[dstreg];
1797 temp >>= (IMM8 & 0xff);
1798 State.regs[dstreg] = temp;
1799 z = (State.regs[dstreg] == 0);
1800 n = (State.regs[dstreg] & 0x80000000) != 0;
1801 PSW &= ~(PSW_Z | PSW_N | PSW_C);
1802 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
1805 // 1111 1011 0101 1001 Rn Rn IMM8; lsr IMM8,Rn
1806 8.0xfb+8.0x59+4.RM2,4.RN0=RM2+8.IMM8:D2a:::lsr
1814 dstreg = translate_rreg (SD_, RN0);
1816 c = State.regs[dstreg] & 1;
1817 State.regs[dstreg] >>= (IMM8 & 0xff);
1818 z = (State.regs[dstreg] == 0);
1819 n = (State.regs[dstreg] & 0x80000000) != 0;
1820 PSW &= ~(PSW_Z | PSW_N | PSW_C);
1821 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
1824 // 1111 1011 0110 1001 Rn Rn IMM8; asl IMM8,Rn
1825 8.0xfb+8.0x69+4.RM2,4.RN0=RM2+8.IMM8:D2a:::asl
1833 dstreg = translate_rreg (SD_, RN0);
1835 State.regs[dstreg] <<= (IMM8 & 0xff);
1836 z = (State.regs[dstreg] == 0);
1837 n = (State.regs[dstreg] & 0x80000000) != 0;
1838 PSW &= ~(PSW_Z | PSW_N);
1839 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1842 // 1111 1011 1010 1001 Rn Rn IMM8; mul IMM8,Rn
1843 8.0xfb+8.0xa9+4.RM2,4.RN0=RM2+8.IMM8:D2a:::mul
1848 unsigned long long temp;
1852 dstreg = translate_rreg (SD_, RN0);
1854 temp = ((signed64)(signed32)State.regs[dstreg]
1855 * (signed64)(signed32)EXTEND8 (IMM8));
1856 State.regs[dstreg] = temp & 0xffffffff;
1857 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
1858 z = (State.regs[dstreg] == 0);
1859 n = (State.regs[dstreg] & 0x80000000) != 0;
1860 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1861 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1864 // 1111 1011 1011 1001 Rn Rn IMM8; mulu IMM8,Rn
1865 8.0xfb+8.0xb9+4.RM2,4.RN0=RM2+8.IMM8:D2a:::mulu
1870 unsigned long long temp;
1874 dstreg = translate_rreg (SD_, RN0);
1876 temp = ((unsigned64)State.regs[dstreg]
1877 * (unsigned64)(IMM8 & 0xff));
1878 State.regs[dstreg] = temp & 0xffffffff;
1879 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
1880 z = (State.regs[dstreg] == 0);
1881 n = (State.regs[dstreg] & 0x80000000) != 0;
1882 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
1883 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
1886 // 1111 1011 1110 1001 Rn Rn IMM8; btst imm8,Rn
1887 8.0xfb+8.0xe9+4.RN2,4.RM0=RN2+8.IMM8:D2l:::btst
1894 srcreg = translate_rreg (SD_, RM0);
1895 genericBtst(IMM8, State.regs[srcreg]);
1898 // 1111 1011 0000 1010 Rn Rm IMM8; mov (d8,Rm),Rn
1899 8.0xfb+8.0x0a+4.RN2,4.RM0+8.IMM8:D2l:::mov
1906 srcreg = translate_rreg (SD_, RM0);
1907 dstreg = translate_rreg (SD_, RN2);
1908 State.regs[dstreg] = load_word (State.regs[srcreg] + EXTEND8 (IMM8));
1911 // 1111 1011 0001 1010 Rn Rm IMM8; mov Rm,(d8,Rn)
1912 8.0xfb+8.0x1a+4.RM2,4.RN0+8.IMM8:D2m:::mov
1919 srcreg = translate_rreg (SD_, RM2);
1920 dstreg = translate_rreg (SD_, RN0);
1921 store_word (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
1924 // 1111 1011 0010 1010 Rn Rm IMM8; movbu (d8,Rm),Rn
1925 8.0xfb+8.0x2a+4.RN2,4.RM0+8.IMM8:D2l:::movbu
1932 srcreg = translate_rreg (SD_, RM0);
1933 dstreg = translate_rreg (SD_, RN2);
1934 State.regs[dstreg] = load_byte (State.regs[srcreg] + EXTEND8 (IMM8));
1937 // 1111 1011 0011 1010 Rn Rm IMM8; movbu Rm,(d8,Rn)
1938 8.0xfb+8.0x3a+4.RM2,4.RN0+8.IMM8:D2m:::movbu
1945 srcreg = translate_rreg (SD_, RM2);
1946 dstreg = translate_rreg (SD_, RN0);
1947 store_byte (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
1950 // 1111 1011 0100 1010 Rn Rm IMM8; movhu (d8,Rm),Rn
1951 8.0xfb+8.0x4a+4.RN2,4.RM0+8.IMM8:D2l:::movhu
1958 srcreg = translate_rreg (SD_, RM0);
1959 dstreg = translate_rreg (SD_, RN2);
1960 State.regs[dstreg] = load_half (State.regs[srcreg] + EXTEND8 (IMM8));
1963 // 1111 1011 0101 1010 Rn Rm IMM8; movhu Rm,(d8,Rn)
1964 8.0xfb+8.0x5a+4.RM2,4.RN0+8.IMM8:D2m:::movhu
1971 srcreg = translate_rreg (SD_, RM2);
1972 dstreg = translate_rreg (SD_, RN0);
1973 store_half (State.regs[dstreg] + EXTEND8 (IMM8), State.regs[srcreg]);
1976 // 1111 1011 0110 1010 Rn Rm IMM8; mov (d8,Rm+),Rn
1977 8.0xfb+8.0x6a+4.RN2,4.RM0!RN2+8.IMM8:D2y:::mov
1984 srcreg = translate_rreg (SD_, RM0);
1985 dstreg = translate_rreg (SD_, RN2);
1986 State.regs[dstreg] = load_word (State.regs[srcreg]);
1987 State.regs[srcreg] += EXTEND8 (IMM8);
1990 // 1111 1011 0111 1010 Rn Rm IMM8; mov Rm,(d8,Rn+)
1991 8.0xfb+8.0x7a+4.RM2,4.RN0+8.IMM8:D2z:::mov
1998 srcreg = translate_rreg (SD_, RM2);
1999 dstreg = translate_rreg (SD_, RN0);
2000 store_word (State.regs[dstreg], State.regs[srcreg]);
2001 State.regs[dstreg] += EXTEND8 (IMM8);
2005 // 1111 1011 1000 1010 Rn 0000 IMM8; mov (d8,sp),Rn
2006 8.0xfb+8.0x8a+4.RN2,4.0x0+8.IMM8:D2n:::mov
2013 dstreg = translate_rreg (SD_, RN2);
2014 State.regs[dstreg] = load_word (State.regs[REG_SP] + IMM8);
2017 // 1111 1011 1001 1010 Rm 0000 IMM8; mov Rm,(d8,Rn)
2018 8.0xfb+8.0x9a+4.RM2,4.0x0+8.IMM8:D2o:::mov
2025 srcreg = translate_rreg (SD_, RM2);
2026 store_word (State.regs[REG_SP] + EXTEND8 (IMM8), State.regs[srcreg]);
2029 // 1111 1011 1010 1010 Rn Rm IMM8; movbu (d8,sp),Rn
2030 8.0xfb+8.0xaa+4.RN2,4.0x0+8.IMM8:D2n:::movbu
2037 dstreg = translate_rreg (SD_, RN2);
2038 State.regs[dstreg] = load_byte (State.regs[REG_SP] + IMM8);
2041 // 1111 1011 1011 1010 Rn Rm IMM8; movbu Rm,(sp,Rn)
2042 8.0xfb+8.0xba+4.RM2,4.0x0+8.IMM8:D2o:::movbu
2049 srcreg = translate_rreg (SD_, RM2);
2050 store_byte (State.regs[REG_SP] + EXTEND8 (IMM8), State.regs[srcreg]);
2053 // 1111 1011 1100 1010 Rn Rm IMM8; movhu (d8,sp),Rn
2054 8.0xfb+8.0xca+4.RN2,4.0x0+8.IMM8:D2n:::movhu
2061 dstreg = translate_rreg (SD_, RN2);
2062 State.regs[dstreg] = load_half (State.regs[REG_SP] + IMM8);
2065 // 1111 1011 1101 1010 Rn Rm IMM8; movhu Rm,(d8,sp)
2066 8.0xfb+8.0xda+4.RM2,4.0x0+8.IMM8:D2o:::movhu
2073 srcreg = translate_rreg (SD_, RM2);
2074 store_half (State.regs[REG_SP] + IMM8, State.regs[srcreg]);
2077 // 1111 1011 1110 1010 Rn Rm IMM8; movhu (d8,Rm+),Rn
2078 8.0xfb+8.0xea+4.RN2,4.RM0!RN2+8.IMM8:D2y:::movhu
2085 srcreg = translate_rreg (SD_, RM0);
2086 dstreg = translate_rreg (SD_, RN2);
2087 State.regs[dstreg] = load_half (State.regs[srcreg]);
2088 State.regs[srcreg] += EXTEND8 (IMM8);
2091 // 1111 1011 1111 1010 Rn Rm IMM8; movhu Rm,(d8,Rn+)
2092 8.0xfb+8.0xfa+4.RM2,4.RN0+8.IMM8:D2z:::movhu
2099 srcreg = translate_rreg (SD_, RM2);
2100 dstreg = translate_rreg (SD_, RN0);
2101 store_half (State.regs[dstreg], State.regs[srcreg]);
2102 State.regs[dstreg] += EXTEND8 (IMM8);
2106 // 1111 1011 0000 1011 Rn Rn IMM8; mac imm8,Rn
2107 8.0xfb+8.0x0b+4.RN2,4.RN0=RN2+8.IMM8:D2:::mac
2112 long long temp, sum;
2116 srcreg = translate_rreg (SD_, RN2);
2118 temp = ((signed64)(signed32)EXTEND8 (IMM8)
2119 * (signed64)(signed32)State.regs[srcreg]);
2120 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2121 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2122 State.regs[REG_MCRL] = sum;
2125 sum = State.regs[REG_MCRH] + temp + c;
2126 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2127 && (temp & 0x80000000) != (sum & 0x80000000));
2128 State.regs[REG_MCRH] = sum;
2130 State.regs[REG_MCVF] = 1;
2133 // 1111 1011 0001 1011 Rn Rn IMM8; macu imm8,Rn
2134 8.0xfb+8.0x1b+4.RN2,4.RN0=RN2+8.IMM8:D2:::macu
2139 long long temp, sum;
2143 srcreg = translate_rreg (SD_, RN2);
2145 temp = ((unsigned64) (IMM8)
2146 * (unsigned64)State.regs[srcreg]);
2147 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2148 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2149 State.regs[REG_MCRL] = sum;
2152 sum = State.regs[REG_MCRH] + temp + c;
2153 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2154 && (temp & 0x80000000) != (sum & 0x80000000));
2155 State.regs[REG_MCRH] = sum;
2157 State.regs[REG_MCVF] = 1;
2160 // 1111 1011 0010 1011 Rn Rn IMM8; macb imm8,Rn
2161 8.0xfb+8.0x2b+4.RN2,4.RN0=RN2+8.IMM8:D2:::macb
2166 long long temp, sum;
2170 srcreg = translate_rreg (SD_, RN2);
2172 temp = ((signed64)(signed8)EXTEND8 (IMM8)
2173 * (signed64)(signed8)State.regs[srcreg] & 0xff);
2174 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2175 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2176 State.regs[REG_MCRL] = sum;
2179 sum = State.regs[REG_MCRH] + temp + c;
2180 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2181 && (temp & 0x80000000) != (sum & 0x80000000));
2182 State.regs[REG_MCRH] = sum;
2184 State.regs[REG_MCVF] = 1;
2187 // 1111 1011 0011 1011 Rn Rn IMM8; macbu imm8,Rn
2188 8.0xfb+8.0x3b+4.RN2,4.RN0=RN2+8.IMM8:D2:::macbu
2193 long long temp, sum;
2197 srcreg = translate_rreg (SD_, RN2);
2199 temp = ((unsigned64) (IMM8)
2200 * (unsigned64)State.regs[srcreg] & 0xff);
2201 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2202 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2203 State.regs[REG_MCRL] = sum;
2206 sum = State.regs[REG_MCRH] + temp + c;
2207 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2208 && (temp & 0x80000000) != (sum & 0x80000000));
2209 State.regs[REG_MCRH] = sum;
2211 State.regs[REG_MCVF] = 1;
2214 // 1111 1011 0100 1011 Rn Rn IMM8; mach imm8,Rn
2215 8.0xfb+8.0x4b+4.RN2,4.RN0=RN2+8.IMM8:D2:::mach
2220 long long temp, sum;
2224 srcreg = translate_rreg (SD_, RN2);
2226 temp = ((signed64)(signed16)EXTEND8 (IMM8)
2227 * (signed64)(signed16)State.regs[srcreg] & 0xffff);
2228 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2229 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2230 State.regs[REG_MCRL] = sum;
2233 sum = State.regs[REG_MCRH] + temp + c;
2234 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2235 && (temp & 0x80000000) != (sum & 0x80000000));
2236 State.regs[REG_MCRH] = sum;
2238 State.regs[REG_MCVF] = 1;
2241 // 1111 1011 0101 1011 Rn Rn IMM8; machu imm8,Rn
2242 8.0xfb+8.0x5b+4.RN2,4.RN0=RN2+8.IMM8:D2:::machu
2247 long long temp, sum;
2251 srcreg = translate_rreg (SD_, RN2);
2253 temp = ((unsigned64) (IMM8)
2254 * (unsigned64)State.regs[srcreg] & 0xffff);
2255 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
2256 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
2257 State.regs[REG_MCRL] = sum;
2260 sum = State.regs[REG_MCRH] + temp + c;
2261 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
2262 && (temp & 0x80000000) != (sum & 0x80000000));
2263 State.regs[REG_MCRH] = sum;
2265 State.regs[REG_MCVF] = 1;
2268 // 1111 1011 1011 1011 Rn Rn IMM8; mcste imm8,Rn
2269 8.0xfb+8.0xbb+4.RN2,4.RN0=RN2+8.IMM8:D2:::mcste
2276 dstreg = translate_rreg (SD_, RN0);
2278 PSW &= ~(PSW_V | PSW_C);
2279 PSW |= (State.regs[REG_MCVF] ? PSW_V : 0);
2281 /* 32bit saturation. */
2286 tmp = State.regs[REG_MCRH];
2288 tmp += State.regs[REG_MCRL];
2290 if (tmp > 0x7fffffff)
2291 State.regs[dstreg] = 0x7fffffff;
2292 else if (tmp < 0xffffffff80000000LL)
2293 State.regs[dstreg] = 0x80000000;
2295 State.regs[dstreg] = tmp;
2297 /* 16bit saturation */
2298 else if (IMM8 == 0x10)
2302 tmp = State.regs[REG_MCRH];
2304 tmp += State.regs[REG_MCRL];
2307 State.regs[dstreg] = 0x7fff;
2308 else if (tmp < 0xffffffffffff8000LL)
2309 State.regs[dstreg] = 0x8000;
2311 State.regs[dstreg] = tmp;
2313 /* 8 bit saturation */
2314 else if (IMM8 == 0x8)
2318 tmp = State.regs[REG_MCRH];
2320 tmp += State.regs[REG_MCRL];
2323 State.regs[dstreg] = 0x7f;
2324 else if (tmp < 0xffffffffffffff80LL)
2325 State.regs[dstreg] = 0x80;
2327 State.regs[dstreg] = tmp;
2329 /* 9 bit saturation */
2330 else if (IMM8 == 0x9)
2334 tmp = State.regs[REG_MCRH];
2336 tmp += State.regs[REG_MCRL];
2339 State.regs[dstreg] = 0x80;
2340 else if (tmp < 0xffffffffffffff81LL)
2341 State.regs[dstreg] = 0x81;
2343 State.regs[dstreg] = tmp;
2345 /* 9 bit saturation */
2346 else if (IMM8 == 0x30)
2350 tmp = State.regs[REG_MCRH];
2352 tmp += State.regs[REG_MCRL];
2354 if (tmp > 0x7fffffffffffLL)
2355 tmp = 0x7fffffffffffLL;
2356 else if (tmp < 0xffff800000000000LL)
2357 tmp = 0xffff800000000000LL;
2360 State.regs[dstreg] = tmp;
2364 // 1111 1011 0111 1100 Rm Rn Rd; add Rm,Rn,Rd
2365 8.0xfb+8.0x7c+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::add
2370 unsigned long sum, source1, source2;
2371 int srcreg1, srcreg2, dstreg;
2374 srcreg1 = translate_rreg (SD_, RM2);
2375 srcreg2 = translate_rreg (SD_, RN0);
2376 dstreg = translate_rreg (SD_, RD0);
2378 source1 = State.regs[srcreg1];
2379 source2 = State.regs[srcreg2];
2380 sum = source1 + source2;
2381 State.regs[dstreg] = sum;
2384 n = (sum & 0x80000000);
2385 c = (sum < source1) || (sum < source2);
2386 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2387 && (source1 & 0x80000000) != (sum & 0x80000000));
2389 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2390 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2391 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2394 // 1111 1011 1000 1100 Rm Rn Rd; addc Rm,Rn,Rd
2395 8.0xfb+8.0x8c+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::addc
2400 unsigned long sum, source1, source2;
2401 int srcreg1, srcreg2, dstreg;
2404 srcreg1 = translate_rreg (SD_, RM2);
2405 srcreg2 = translate_rreg (SD_, RN0);
2406 dstreg = translate_rreg (SD_, RD0);
2408 source1 = State.regs[srcreg1];
2409 source2 = State.regs[srcreg2];
2410 sum = source1 + source2 + ((PSW & PSW_C) != 0);
2411 State.regs[dstreg] = sum;
2413 z = ((PSW & PSW_Z) != 0) && (sum == 0);
2414 n = (sum & 0x80000000);
2415 c = (sum < source1) || (sum < source2);
2416 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2417 && (source1 & 0x80000000) != (sum & 0x80000000));
2419 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2420 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2421 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2424 // 1111 1011 1001 1100 Rm Rn Rd; sub Rm,Rn,Rd
2425 8.0xfb+8.0x9c+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::sub
2430 unsigned long difference, source1, source2;
2431 int srcreg1, srcreg2, dstreg;
2434 srcreg1 = translate_rreg (SD_, RM2);
2435 srcreg2 = translate_rreg (SD_, RN0);
2436 dstreg = translate_rreg (SD_, RD0);
2438 source1 = State.regs[srcreg1];
2439 source2 = State.regs[srcreg2];
2440 difference = source2 - source1;
2441 State.regs[dstreg] = difference;
2443 z = (difference == 0);
2444 n = (difference & 0x80000000);
2445 c = (source1 > source1);
2446 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2447 && (source1 & 0x80000000) != (difference & 0x80000000));
2449 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2450 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2451 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2454 // 1111 1011 1010 1100 Rm Rn Rd; subc Rm,Rn,Rd
2455 8.0xfb+8.0xac+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::subc
2460 unsigned long difference, source1, source2;
2461 int srcreg1, srcreg2, dstreg;
2464 srcreg1 = translate_rreg (SD_, RM2);
2465 srcreg2 = translate_rreg (SD_, RN0);
2466 dstreg = translate_rreg (SD_, RD0);
2468 source1 = State.regs[srcreg1];
2469 source2 = State.regs[srcreg2];
2470 difference = source2 - source1 - ((PSW & PSW_C) != 0);
2471 State.regs[dstreg] = difference;
2473 z = ((PSW & PSW_Z) != 0) && (difference == 0);
2474 n = (difference & 0x80000000);
2475 c = (source1 > source2);
2476 v = ((source1 & 0x80000000) == (source2 & 0x80000000)
2477 && (source1 & 0x80000000) != (difference & 0x80000000));
2479 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2480 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
2481 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
2484 // 1111 1011 0000 1101 Rm Rn Rd; and Rm,Rn,Rd
2485 8.0xfb+8.0x0d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::and
2490 int srcreg1, srcreg2, dstreg;
2493 srcreg1 = translate_rreg (SD_, RM2);
2494 srcreg2 = translate_rreg (SD_, RN0);
2495 dstreg = translate_rreg (SD_, RD0);
2497 State.regs[dstreg] = State.regs[srcreg1] & State.regs[srcreg2];
2499 z = (State.regs[dstreg] == 0);
2500 n = (State.regs[dstreg] & 0x80000000);
2502 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2503 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2506 // 1111 1011 0001 1101 Rm Rn Rd; or Rm,Rn,Rd
2507 8.0xfb+8.0x1d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::or
2512 int srcreg1, srcreg2, dstreg;
2515 srcreg1 = translate_rreg (SD_, RM2);
2516 srcreg2 = translate_rreg (SD_, RN0);
2517 dstreg = translate_rreg (SD_, RD0);
2519 State.regs[dstreg] = State.regs[srcreg1] | State.regs[srcreg2];
2521 z = (State.regs[dstreg] == 0);
2522 n = (State.regs[dstreg] & 0x80000000);
2524 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2525 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2528 // 1111 1011 0010 1101 Rm Rn Rd; xor Rm,Rn,Rd
2529 8.0xfb+8.0x2d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::xor
2534 int srcreg1, srcreg2, dstreg;
2537 srcreg1 = translate_rreg (SD_, RM2);
2538 srcreg2 = translate_rreg (SD_, RN0);
2539 dstreg = translate_rreg (SD_, RD0);
2541 State.regs[dstreg] = State.regs[srcreg1] ^ State.regs[srcreg2];
2543 z = (State.regs[dstreg] == 0);
2544 n = (State.regs[dstreg] & 0x80000000);
2546 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
2547 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2550 // 1111 1011 0100 1101 Rm Rn Rd; asr Rm,Rn,Rd
2551 8.0xfb+8.0x4d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::asr
2557 int srcreg1, srcreg2, dstreg;
2560 srcreg1 = translate_rreg (SD_, RM2);
2561 srcreg2 = translate_rreg (SD_, RN0);
2562 dstreg = translate_rreg (SD_, RD0);
2564 temp = State.regs[srcreg2];
2566 temp >>= State.regs[srcreg1];
2567 State.regs[dstreg] = temp;
2569 z = (State.regs[dstreg] == 0);
2570 n = (State.regs[dstreg] & 0x80000000);
2572 PSW &= ~(PSW_Z | PSW_N | PSW_C);
2573 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2576 // 1111 1011 0101 1101 Rm Rn Rd; lsr Rm,Rn,Rd
2577 8.0xfb+8.0x5d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::lsr
2582 int srcreg1, srcreg2, dstreg;
2585 srcreg1 = translate_rreg (SD_, RM2);
2586 srcreg2 = translate_rreg (SD_, RN0);
2587 dstreg = translate_rreg (SD_, RD0);
2589 c = State.regs[srcreg2] & 1;
2590 State.regs[dstreg] = State.regs[srcreg2] >> State.regs[srcreg1];
2592 z = (State.regs[dstreg] == 0);
2593 n = (State.regs[dstreg] & 0x80000000);
2595 PSW &= ~(PSW_Z | PSW_N | PSW_C);
2596 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2599 // 1111 1011 0110 1101 Rm Rn Rd; asl Rm,Rn,Rd
2600 8.0xfb+8.0x6d+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::asl
2605 int srcreg1, srcreg2, dstreg;
2608 srcreg1 = translate_rreg (SD_, RM2);
2609 srcreg2 = translate_rreg (SD_, RN0);
2610 dstreg = translate_rreg (SD_, RD0);
2612 State.regs[dstreg] = State.regs[srcreg2] << State.regs[srcreg1];
2614 z = (State.regs[dstreg] == 0);
2615 n = (State.regs[dstreg] & 0x80000000);
2617 PSW &= ~(PSW_Z | PSW_N | PSW_C);
2618 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2621 // 1111 1011 1010 1101 Rm Rn Rd1 Rd2; mul Rm,Rn,Rd1,Rd2
2622 8.0xfb+8.0xad+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::mul
2626 int srcreg1, srcreg2, dstreg1, dstreg2;
2627 signed long long temp;
2631 srcreg1 = translate_rreg (SD_, RM2);
2632 srcreg2 = translate_rreg (SD_, RN0);
2633 dstreg1 = translate_rreg (SD_, RD0);
2634 dstreg2 = translate_rreg (SD_, RD2);
2636 temp = ((signed64)(signed32)State.regs[srcreg1]
2637 * (signed64)(signed32)State.regs[srcreg2]);
2638 State.regs[dstreg2] = temp & 0xffffffff;
2639 State.regs[dstreg1] = (temp & 0xffffffff00000000LL) >> 32;
2641 z = (State.regs[dstreg1] == 0) && (State.regs[dstreg2] == 0);
2642 n = (State.regs[dstreg1] & 0x80000000);
2644 PSW &= ~(PSW_Z | PSW_N);
2645 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2648 // 1111 1011 1011 1101 Rm Rn Rd1 Rd2; mulu Rm,Rn,Rd1,Rd2
2649 8.0xfb+8.0xbd+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::mulu
2653 int srcreg1, srcreg2, dstreg1, dstreg2;
2654 signed long long temp;
2658 srcreg1 = translate_rreg (SD_, RM2);
2659 srcreg2 = translate_rreg (SD_, RN0);
2660 dstreg1 = translate_rreg (SD_, RD0);
2661 dstreg2 = translate_rreg (SD_, RD2);
2663 temp = ((unsigned64)State.regs[srcreg1]
2664 * (unsigned64)State.regs[srcreg2]);
2665 State.regs[dstreg2] = temp & 0xffffffff;
2666 State.regs[dstreg1] = (temp & 0xffffffff00000000LL) >> 32;
2668 z = (State.regs[dstreg1] == 0) && (State.regs[dstreg2] == 0);
2669 n = (State.regs[dstreg1] & 0x80000000);
2671 PSW &= ~(PSW_Z | PSW_N);
2672 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0));
2675 // 1111 1011 0000 1110 Rn 0000 abs8 ; mov (abs8),Rn
2676 8.0xfb+8.0x0e+4.RN2,4.0x0+8.IMM8:D2p:::mov
2683 dstreg = translate_rreg (SD_, RN2);
2684 State.regs[dstreg] = load_word (IMM8);
2687 // 1111 1011 0001 1110 Rm 0000 abs8 ; mov Rn,(abs8)
2688 8.0xfb+8.0x1e+4.RM2,4.0x0+8.IMM8:D2q:::mov
2695 srcreg = translate_rreg (SD_, RM2);
2696 store_word (IMM8, State.regs[srcreg]);
2699 // 1111 1011 0010 1110 Rn 0000 abs8 ; movbu (abs8),Rn
2700 8.0xfb+8.0x2e+4.RN2,4.0x0+8.IMM8:D2p:::movbu
2707 dstreg = translate_rreg (SD_, RN2);
2708 State.regs[dstreg] = load_byte (IMM8);
2711 // 1111 1011 0011 1110 Rm 0000 abs8 ; movbu Rn,(abs8)
2712 8.0xfb+8.0x3e+4.RM2,4.0x0+8.IMM8:D2q:::movbu
2719 srcreg = translate_rreg (SD_, RM2);
2720 store_byte (IMM8, State.regs[srcreg]);
2723 // 1111 1011 0100 1110 Rn 0000 abs8 ; movhu (abs8),Rn
2724 8.0xfb+8.0x4e+4.RN2,4.0x0+8.IMM8:D2p:::movhu
2731 dstreg = translate_rreg (SD_, RN2);
2732 State.regs[dstreg] = load_half (IMM8);
2735 // 1111 1011 0101 1110 Rm 0000 abs8 ; movhu Rn,(abs8)
2736 8.0xfb+8.0x5e+4.RM2,4.0x0+8.IMM8:D2q:::movhu
2743 srcreg = translate_rreg (SD_, RM2);
2744 store_half (IMM8, State.regs[srcreg]);
2747 // 1111 1011 1000 1110 Ri Rm Rn; mov (Ri,Rm),Rn
2748 8.0xfb+8.0x8e+4.RI0,4.RM0+4.RN0,4.0x0:D2r:::mov
2752 int srcreg1, srcreg2, dstreg;
2755 srcreg1 = translate_rreg (SD_, RM0);
2756 srcreg1 = translate_rreg (SD_, RI0);
2757 dstreg = translate_rreg (SD_, RN0);
2758 State.regs[dstreg] = load_word (State.regs[srcreg1] + State.regs[srcreg2]);
2761 // 1111 1011 1001 1110 Ri Rm Rn; mov Rn,(Ri,Rm)
2762 8.0xfb+8.0x9e+4.RI0,4.RN0+4.RM0,4.0x0:D2s:::mov
2766 int srcreg, dstreg1, dstreg2;
2769 srcreg = translate_rreg (SD_, RM0);
2770 dstreg1 = translate_rreg (SD_, RI0);
2771 dstreg2 = translate_rreg (SD_, RN0);
2772 store_word (State.regs[dstreg1] + State.regs[dstreg2], State.regs[srcreg]);
2775 // 1111 1011 1010 1110 Ri Rm Rn; movbu (Ri,Rm),Rn
2776 8.0xfb+8.0xae+4.RI0,4.RM0+4.RN0,4.0x0:D2r:::movbu
2780 int srcreg1, srcreg2, dstreg;
2783 srcreg1 = translate_rreg (SD_, RM0);
2784 srcreg1 = translate_rreg (SD_, RI0);
2785 dstreg = translate_rreg (SD_, RN0);
2786 State.regs[dstreg] = load_byte (State.regs[srcreg1] + State.regs[srcreg2]);
2789 // 1111 1011 1011 1110 Ri Rm Rn; movbu Rn,(Ri,Rm)
2790 8.0xfb+8.0xbe+4.RI0,4.RN0+4.RM0,4.0x0:D2s:::movbu
2794 int srcreg, dstreg1, dstreg2;
2797 srcreg = translate_rreg (SD_, RM0);
2798 dstreg1 = translate_rreg (SD_, RI0);
2799 dstreg2 = translate_rreg (SD_, RN0);
2800 store_byte (State.regs[dstreg1] + State.regs[dstreg2], State.regs[srcreg]);
2803 // 1111 1011 1100 1110 Ri Rm Rn; movhu (Ri,Rm),Rn
2804 8.0xfb+8.0xce+4.RI0,4.RM0+4.RN0,4.0x0:D2r:::movhu
2808 int srcreg1, srcreg2, dstreg;
2811 srcreg1 = translate_rreg (SD_, RM0);
2812 srcreg1 = translate_rreg (SD_, RI0);
2813 dstreg = translate_rreg (SD_, RN0);
2814 State.regs[dstreg] = load_half (State.regs[srcreg1] + State.regs[srcreg2]);
2817 // 1111 1011 1101 1110 Ri Rm Rn; movhu Rn,(Ri,Rm)
2818 8.0xfb+8.0xde+4.RI0,4.RN0+4.RM0,4.0x0:D2s:::movhu
2822 int srcreg, dstreg1, dstreg2;
2825 srcreg = translate_rreg (SD_, RM0);
2826 dstreg1 = translate_rreg (SD_, RI0);
2827 dstreg2 = translate_rreg (SD_, RN0);
2828 store_half (State.regs[dstreg1] + State.regs[dstreg2], State.regs[srcreg]);
2831 // 1111 1011 0000 1111 Rm Rn Rd1 Rd2; mac Rm,Rn,Rd1,Rd2
2832 8.0xfb+8.0x0f+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::mac
2836 int srcreg1, srcreg2, dstreg1, dstreg2;
2837 signed long long temp;
2842 srcreg1 = translate_rreg (SD_, RM2);
2843 srcreg2 = translate_rreg (SD_, RN0);
2844 dstreg1 = translate_rreg (SD_, RD0);
2845 dstreg2 = translate_rreg (SD_, RD2);
2847 temp = ((signed64)(signed32)State.regs[srcreg1]
2848 * (signed64)(signed32)State.regs[srcreg2]);
2850 sum = State.regs[dstreg2] + (temp & 0xffffffff);
2851 c = (sum < State.regs[dstreg2]) || (sum < (temp & 0xffffffff));
2852 State.regs[dstreg2] = sum;
2855 sum = State.regs[dstreg1] + temp + c;
2856 v = ((State.regs[dstreg1] & 0x80000000) == (temp & 0x80000000)
2857 && (temp & 0x80000000) != (sum & 0x80000000));
2858 State.regs[dstreg1] = sum;
2861 State.regs[REG_MCVF] = 1;
2863 PSW |= (( v ? PSW_V : 0));
2867 // 1111 1011 0001 1111 Rm Rn Rd1 Rd2; macu Rm,Rn,Rd1,Rd2
2868 8.0xfb+8.0x1f+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::macu
2872 int srcreg1, srcreg2, dstreg1, dstreg2;
2873 signed long long temp;
2878 srcreg1 = translate_rreg (SD_, RM2);
2879 srcreg2 = translate_rreg (SD_, RN0);
2880 dstreg1 = translate_rreg (SD_, RD0);
2881 dstreg2 = translate_rreg (SD_, RD2);
2883 temp = ((unsigned64)State.regs[srcreg1]
2884 * (unsigned64)State.regs[srcreg2]);
2886 sum = State.regs[dstreg2] + (temp & 0xffffffff);
2887 c = (sum < State.regs[dstreg2]) || (sum < (temp & 0xffffffff));
2888 State.regs[dstreg2] = sum;
2891 sum = State.regs[dstreg1] + temp + c;
2892 v = ((State.regs[dstreg1] & 0x80000000) == (temp & 0x80000000)
2893 && (temp & 0x80000000) != (sum & 0x80000000));
2894 State.regs[dstreg1] = sum;
2897 State.regs[REG_MCVF] = 1;
2899 PSW |= (( v ? PSW_V : 0));
2903 // 1111 1011 0010 1111 Rm Rn Rd1; macb Rm,Rn,Rd1
2904 8.0xfb+8.0x2f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::macb
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] & 0xff)
2918 * (signed32)(State.regs[srcreg1] & 0xff));
2919 sum = State.regs[dstreg] + temp;
2920 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2921 && (temp & 0x80000000) != (sum & 0x80000000));
2922 State.regs[dstreg] = sum;
2925 State.regs[REG_MCVF] = 1;
2927 PSW |= ((v ? PSW_V : 0));
2931 // 1111 1011 0011 1111 Rm Rn Rd1; macbu Rm,Rn,Rd1
2932 8.0xfb+8.0x3f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::macbu
2936 int srcreg1, srcreg2, dstreg;
2941 srcreg1 = translate_rreg (SD_, RM2);
2942 srcreg2 = translate_rreg (SD_, RN0);
2943 dstreg = translate_rreg (SD_, RD0);
2945 temp = ((unsigned32)(State.regs[srcreg2] & 0xff)
2946 * (unsigned32)(State.regs[srcreg1] & 0xff));
2947 sum = State.regs[dstreg] + temp;
2948 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
2949 && (temp & 0x80000000) != (sum & 0x80000000));
2950 State.regs[dstreg] = sum;
2953 State.regs[REG_MCVF] = 1;
2955 PSW |= ((v ? PSW_V : 0));
2959 // 1111 1011 0100 1111 Rm Rn Rd1; mach Rm,Rn,Rd1,Rd2
2960 8.0xfb+8.0x4f+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::mach
2964 int srcreg1, srcreg2, dstreg1, dstreg2;
2965 long long temp, sum;
2969 srcreg1 = translate_rreg (SD_, RM2);
2970 srcreg2 = translate_rreg (SD_, RN0);
2971 dstreg1 = translate_rreg (SD_, RD0);
2972 dstreg2 = translate_rreg (SD_, RD0);
2974 temp = ((signed32)(State.regs[srcreg2] & 0xffff)
2975 * (signed32)(State.regs[srcreg1] & 0xffff));
2976 State.regs[dstreg2] += (temp & 0xffffffff);
2977 sum = State.regs[dstreg1] + ((temp >> 32) & 0xffffffff);
2978 v = ((State.regs[dstreg1] & 0x80000000) == (temp & 0x80000000)
2979 && (temp & 0x80000000) != (sum & 0x80000000));
2980 State.regs[dstreg1] = sum;
2983 State.regs[REG_MCVF] = 1;
2985 PSW |= ((v ? PSW_V : 0));
2989 // 1111 1011 0101 1111 Rm Rn Rd1; machu Rm,Rn,Rd1,Rd2
2990 8.0xfb+8.0x5f+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::machu
2994 int srcreg1, srcreg2, dstreg1, dstreg2;
2995 long long temp, sum;
2999 srcreg1 = translate_rreg (SD_, RM2);
3000 srcreg2 = translate_rreg (SD_, RN0);
3001 dstreg1 = translate_rreg (SD_, RD0);
3002 dstreg2 = translate_rreg (SD_, RD0);
3004 temp = ((unsigned32)(State.regs[srcreg2] & 0xffff)
3005 * (unsigned32)(State.regs[srcreg1] & 0xffff));
3006 State.regs[dstreg2] += (temp & 0xffffffff);
3007 sum = State.regs[dstreg1] + ((temp >> 32) & 0xffffffff);
3008 v = ((State.regs[dstreg1] & 0x80000000) == (temp & 0x80000000)
3009 && (temp & 0x80000000) != (sum & 0x80000000));
3010 State.regs[dstreg1] = sum;
3013 State.regs[REG_MCVF] = 1;
3015 PSW |= ((v ? PSW_V : 0));
3019 // 1111 1011 0110 1111 Rm Rn Rd1; dmach Rm,Rn,Rd1
3020 8.0xfb+8.0x6f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::dmach
3024 int srcreg1, srcreg2, dstreg;
3025 long temp, temp2, sum;
3029 srcreg1 = translate_rreg (SD_, RM2);
3030 srcreg2 = translate_rreg (SD_, RN0);
3031 dstreg = translate_rreg (SD_, RD0);
3033 temp = ((signed32)(State.regs[srcreg2] & 0xffff)
3034 * (signed32)(State.regs[srcreg1] & 0xffff));
3035 temp2 = ((signed32)((State.regs[srcreg1] >> 16) & 0xffff)
3036 * (signed32)((State.regs[srcreg2] >> 16) & 0xffff));
3037 sum = temp + temp2 + State.regs[dstreg];
3038 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
3039 && (temp & 0x80000000) != (sum & 0x80000000));
3040 State.regs[dstreg] = sum;
3043 State.regs[REG_MCVF] = 1;
3045 PSW |= ((v ? PSW_V : 0));
3049 // 1111 1011 0111 1111 Rm Rn Rd1; dmachu Rm,Rn,Rd1
3050 8.0xfb+8.0x7f+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::dmachu
3054 int srcreg1, srcreg2, dstreg;
3055 long temp, temp2, sum;
3059 srcreg1 = translate_rreg (SD_, RM2);
3060 srcreg2 = translate_rreg (SD_, RN0);
3061 dstreg = translate_rreg (SD_, RD0);
3063 temp = ((unsigned32)(State.regs[srcreg2] & 0xffff)
3064 * (unsigned32)(State.regs[srcreg1] & 0xffff));
3065 temp2 = ((unsigned32)((State.regs[srcreg1] >> 16) & 0xffff)
3066 * (unsigned32)((State.regs[srcreg2] >> 16) & 0xffff));
3067 sum = temp + temp2 + State.regs[dstreg];
3068 v = ((State.regs[dstreg] & 0x80000000) == (temp & 0x80000000)
3069 && (temp & 0x80000000) != (sum & 0x80000000));
3070 State.regs[dstreg] = sum;
3073 State.regs[REG_MCVF] = 1;
3075 PSW |= ((v ? PSW_V : 0));
3079 // 1111 1011 1000 1111 Rm Rn Rd1 Rd2; dmulh Rm,Rn,Rd1,Rd2
3080 8.0xfb+8.0x8f+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::dmulh
3084 int srcreg1, srcreg2, dstreg1, dstreg2;
3085 signed long long temp;
3088 srcreg1 = translate_rreg (SD_, RM2);
3089 srcreg2 = translate_rreg (SD_, RN0);
3090 dstreg1 = translate_rreg (SD_, RD0);
3091 dstreg2 = translate_rreg (SD_, RD2);
3093 temp = ((signed32)(State.regs[srcreg1] & 0xffff)
3094 * (signed32)(State.regs[srcreg1] & 0xffff));
3095 State.regs[dstreg2] = temp;
3096 temp = ((signed32)((State.regs[srcreg1] >> 16) & 0xffff)
3097 * (signed32)((State.regs[srcreg1] >>16) & 0xffff));
3098 State.regs[dstreg1] = temp;
3101 // 1111 1011 1001 1111 Rm Rn Rd1 Rd2; dmulhu Rm,Rn,Rd1,Rd2
3102 8.0xfb+8.0x9f+4.RM2,4.RN0+4.RD0,4.RD2!RD0:D2c:::dmulhu
3106 int srcreg1, srcreg2, dstreg1, dstreg2;
3107 signed long long temp;
3110 srcreg1 = translate_rreg (SD_, RM2);
3111 srcreg2 = translate_rreg (SD_, RN0);
3112 dstreg1 = translate_rreg (SD_, RD0);
3113 dstreg2 = translate_rreg (SD_, RD2);
3115 temp = ((unsigned32)(State.regs[srcreg1] & 0xffff)
3116 * (unsigned32)(State.regs[srcreg1] & 0xffff));
3117 State.regs[dstreg2] = temp;
3118 temp = ((unsigned32)((State.regs[srcreg1] >> 16) & 0xffff)
3119 * (unsigned32)((State.regs[srcreg1] >>16) & 0xffff));
3120 State.regs[dstreg1] = temp;
3123 // 1111 1011 1010 1111 Rm Rn; sat24 Rm,Rn
3124 8.0xfb+8.0xaf+4.RM2,4.RN0+8.0x0:D2:::sat24
3132 srcreg = translate_rreg (SD_, RM2);
3133 dstreg = translate_rreg (SD_, RN0);
3135 value = State.regs[srcreg];
3137 if (value >= 0x7fffff)
3138 State.regs[dstreg] = 0x7fffff;
3139 else if (value <= 0xff800000)
3140 State.regs[dstreg] = 0xff800000;
3142 State.regs[dstreg] = value;
3144 n = (State.regs[dstreg] & 0x800000) != 0;
3145 z = (State.regs[dstreg] == 0);
3146 PSW &= ~(PSW_Z | PSW_N);
3147 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3150 // 1111 1011 1111 1111 Rm Rn Rd1; bsch Rm,Rn,Rd1
3151 8.0xfb+8.0xff+4.RM2,4.RN0+4.RD0,4.0x0:D2c:::bsch
3156 int srcreg1, srcreg2, dstreg;
3160 srcreg1 = translate_rreg (SD_, RM2);
3161 srcreg2 = translate_rreg (SD_, RN0);
3162 dstreg = translate_rreg (SD_, RD0);
3164 temp = State.regs[srcreg1];
3165 start = (State.regs[srcreg2] & 0x1f) - 1;
3169 for (i = start; i >= 0; i--)
3171 if (temp & (1 << i))
3174 State.regs[dstreg] = i;
3182 State.regs[dstreg] = 0;
3185 PSW |= (c ? PSW_C : 0);
3188 // 1111 1101 0000 1000 Rn Rn IMM32; mov imm24,Rn
3189 8.0xfd+8.0x08+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4t:::mov
3196 dstreg = translate_rreg (SD_, RN0);
3197 State.regs[dstreg] = EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3200 // 1111 1101 0001 1000 Rn Rn IMM32; movu imm24,Rn
3201 8.0xfd+8.0x18+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4k:::movu
3208 dstreg = translate_rreg (SD_, RN0);
3209 State.regs[dstreg] = FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff;
3212 // 1111 1101 0111 1000 Rn Rn IMM32; add imm24,Rn
3213 8.0xfd+8.0x78+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4c:::add
3220 dstreg = translate_rreg (SD_, RN0);
3221 genericAdd (EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)), dstreg);
3224 // 1111 1101 1000 1000 Rn Rn IMM32; addc imm24,Rn
3225 8.0xfd+8.0x88+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::addc
3229 int dstreg, z, n, c, v;
3230 unsigned long sum, imm, reg2;
3233 dstreg = translate_rreg (SD_, RN0);
3235 imm = EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3236 reg2 = State.regs[dstreg];
3237 sum = imm + reg2 + ((PSW & PSW_C) != 0);
3238 State.regs[dstreg] = sum;
3240 z = ((PSW & PSW_Z) != 0) && (sum == 0);
3241 n = (sum & 0x80000000);
3242 c = (sum < imm) || (sum < reg2);
3243 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
3244 && (reg2 & 0x80000000) != (sum & 0x80000000));
3246 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3247 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
3248 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
3251 // 1111 1101 1001 1000 Rn Rn IMM32; sub imm24,Rn
3252 8.0xfd+8.0x98+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::sub
3259 dstreg = translate_rreg (SD_, RN0);
3260 genericSub (EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)), dstreg);
3263 // 1111 1101 1010 1000 Rn Rn IMM32; subc imm24,Rn
3264 8.0xfd+8.0xa8+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::subc
3268 int dstreg, z, n, c, v;
3269 unsigned long difference, imm, reg2;
3272 dstreg = translate_rreg (SD_, RN0);
3274 imm = EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3275 reg2 = State.regs[dstreg];
3276 difference = reg2 - imm - ((PSW & PSW_C) != 0);
3277 State.regs[dstreg] = difference;
3279 z = ((PSW & PSW_Z) != 0) && (difference == 0);
3280 n = (difference & 0x80000000);
3282 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
3283 && (reg2 & 0x80000000) != (difference & 0x80000000));
3285 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3286 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
3287 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
3290 // 1111 1101 1101 1000 Rn Rn IMM32; cmp imm24,Rn
3291 8.0xfd+8.0xd8+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::cmp
3298 srcreg = translate_rreg (SD_, RN0);
3299 genericCmp (EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)), State.regs[srcreg]);
3302 // 1111 1101 1111 1000 XRn XRn IMM32; mov imm24,XRn
3303 8.0xfd+8.0xf8+4.XRM2,4.XRN0=XRM2+8.IMM24A+8.IMM24B+8.IMM24C:D4o:::mov
3310 dstreg = translate_xreg (SD_, XRN0);
3312 State.regs[dstreg] = FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff;
3315 // 1111 1101 0000 1001 Rn Rn IMM24; and imm24,Rn
3316 8.0xfd+8.0x09+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::and
3324 dstreg = translate_rreg (SD_, RN0);
3326 State.regs[dstreg] &= (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff);
3327 z = (State.regs[dstreg] == 0);
3328 n = (State.regs[dstreg] & 0x80000000) != 0;
3329 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3330 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3333 // 1111 1101 0001 1001 Rn Rn IMM24; or imm24,Rn
3334 8.0xfd+8.0x19+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::or
3342 dstreg = translate_rreg (SD_, RN0);
3344 State.regs[dstreg] |= (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff);
3345 z = (State.regs[dstreg] == 0);
3346 n = (State.regs[dstreg] & 0x80000000) != 0;
3347 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3348 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3351 // 1111 1101 0010 1001 Rn Rn IMM24; xor imm24,Rn
3352 8.0xfd+8.0x29+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::xor
3360 dstreg = translate_rreg (SD_, RN0);
3362 State.regs[dstreg] ^= (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffffff);
3363 z = (State.regs[dstreg] == 0);
3364 n = (State.regs[dstreg] & 0x80000000) != 0;
3365 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3366 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3369 // 1111 1101 0100 1001 Rn Rn IMM24; asr imm24,Rn
3370 8.0xfd+8.0x49+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::asr
3379 dstreg = translate_rreg (SD_, RN0);
3381 temp = State.regs[dstreg];
3383 temp >>= (FETCH24 (IMM24A, IMM24B, IMM24C));
3384 State.regs[dstreg] = temp;
3385 z = (State.regs[dstreg] == 0);
3386 n = (State.regs[dstreg] & 0x80000000) != 0;
3387 PSW &= ~(PSW_Z | PSW_N | PSW_C);
3388 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
3392 // 1111 1101 0101 1001 Rn Rn IMM24; lsr imm24,Rn
3393 8.0xfd+8.0x59+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::lsr
3401 dstreg = translate_rreg (SD_, RN0);
3403 c = State.regs[dstreg] & 1;
3404 State.regs[dstreg] >>= (FETCH24 (IMM24A, IMM24B, IMM24C));
3405 z = (State.regs[dstreg] == 0);
3406 n = (State.regs[dstreg] & 0x80000000) != 0;
3407 PSW &= ~(PSW_Z | PSW_N | PSW_C);
3408 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
3411 // 1111 1101 0110 1001 Rn Rn IMM24; asl imm24,Rn
3412 8.0xfd+8.0x69+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::asl
3420 dstreg = translate_rreg (SD_, RN0);
3422 State.regs[dstreg] <<= (FETCH24 (IMM24A, IMM24B, IMM24C));
3423 z = (State.regs[dstreg] == 0);
3424 n = (State.regs[dstreg] & 0x80000000) != 0;
3425 PSW &= ~(PSW_Z | PSW_N);
3426 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3429 // 1111 1101 1010 1001 Rn Rn IMM24; mul imm24,Rn
3430 8.0xfd+8.0xa9+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::mul
3435 unsigned long long temp;
3439 dstreg = translate_rreg (SD_, RN0);
3441 temp = ((signed64)(signed32)State.regs[dstreg]
3442 * (signed64)(signed32)EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)));
3443 State.regs[dstreg] = temp & 0xffffffff;
3444 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
3445 z = (State.regs[dstreg] == 0);
3446 n = (State.regs[dstreg] & 0x80000000) != 0;
3447 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3448 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3451 // 1111 1101 1011 1001 Rn Rn IMM24; mulu imm24,Rn
3452 8.0xfd+8.0xb9+4.RM2,4.RN0=RM2+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::mulu
3457 unsigned long long temp;
3461 dstreg = translate_rreg (SD_, RN0);
3463 temp = ((unsigned64)State.regs[dstreg]
3464 * (unsigned64)EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)));
3465 State.regs[dstreg] = temp & 0xffffffff;
3466 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
3467 z = (State.regs[dstreg] == 0);
3468 n = (State.regs[dstreg] & 0x80000000) != 0;
3469 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
3470 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
3473 // 1111 1101 1110 1001 Rn Rn IMM24; btst imm24,,Rn
3474 8.0xfd+8.0xe9+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::btst
3481 srcreg = translate_rreg (SD_, RN0);
3482 genericBtst (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3485 // 1111 1101 0000 1010 Rn Rm IMM24; mov (d24,Rm),Rn
3486 8.0xfd+8.0x0a+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::mov
3493 srcreg = translate_rreg (SD_, RM0);
3494 dstreg = translate_rreg (SD_, RN2);
3495 State.regs[dstreg] = load_word (State.regs[srcreg]
3496 + EXTEND24 (FETCH24 (IMM24A,
3500 // 1111 1101 0001 1010 Rm Rn IMM24; mov Rm,(d24,Rn)
3501 8.0xfd+8.0x1a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4q:::mov
3508 srcreg = translate_rreg (SD_, RM2);
3509 dstreg = translate_rreg (SD_, RN0);
3510 store_word (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3511 State.regs[srcreg]);
3514 // 1111 1101 0010 1010 Rn Rm IMM24; movbu (d24,Rm),Rn
3515 8.0xfd+8.0x2a+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::movbu
3522 srcreg = translate_rreg (SD_, RM0);
3523 dstreg = translate_rreg (SD_, RN2);
3524 State.regs[dstreg] = load_byte (State.regs[srcreg]
3525 + EXTEND24 (FETCH24 (IMM24A,
3529 // 1111 1101 0011 1010 Rm Rn IMM24; movbu Rm,(d24,Rn)
3530 8.0xfd+8.0x3a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4q:::movbu
3537 srcreg = translate_rreg (SD_, RM2);
3538 dstreg = translate_rreg (SD_, RN0);
3539 store_byte (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3540 State.regs[srcreg]);
3543 // 1111 1101 0100 1010 Rn Rm IMM24; movhu (d24,Rm),Rn
3544 8.0xfd+8.0x4a+4.RN2,4.RM0+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::movhu
3551 srcreg = translate_rreg (SD_, RM0);
3552 dstreg = translate_rreg (SD_, RN2);
3553 State.regs[dstreg] = load_half (State.regs[srcreg]
3554 + EXTEND24 (FETCH24 (IMM24A,
3558 // 1111 1101 0101 1010 Rm Rn IMM24; movhu Rm,(d24,Rn)
3559 8.0xfd+8.0x5a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4q:::movhu
3566 srcreg = translate_rreg (SD_, RM2);
3567 dstreg = translate_rreg (SD_, RN0);
3568 store_half (State.regs[dstreg] + EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C)),
3569 State.regs[srcreg]);
3572 // 1111 1101 0110 1010 Rn Rm IMM24; mov (d24,Rm+),Rn
3573 8.0xfd+8.0x6a+4.RN2,4.RM0!RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4y:::mov
3580 srcreg = translate_rreg (SD_, RM0);
3581 dstreg = translate_rreg (SD_, RN2);
3582 State.regs[dstreg] = load_word (State.regs[srcreg]);
3583 State.regs[srcreg] += EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3586 // 1111 1101 0111 1010 Rm Rn IMM24; mov Rm,(d24,Rn+)
3587 8.0xfd+8.0x7a+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::mov
3594 srcreg = translate_rreg (SD_, RM2);
3595 dstreg = translate_rreg (SD_, RN0);
3596 store_word (State.regs[dstreg], State.regs[srcreg]);
3597 State.regs[dstreg] += EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3601 // 1111 1101 1000 1010 Rn 0000 IMM24; mov (d24,sp),Rn
3602 8.0xfd+8.0x8a+4.RN2,4.0x0+IMM24A+8.IMM24B+8.IMM24C:D4r:::mov
3609 dstreg = translate_rreg (SD_, RN2);
3610 State.regs[dstreg] = load_word (State.regs[REG_SP]
3611 + FETCH24 (IMM24A, IMM24B, IMM24C));
3614 // 1111 1101 1001 1010 Rm 0000 IMM24; mov Rm,(d24,sp)
3615 8.0xfd+8.0x9a+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4s:::mov
3622 srcreg = translate_rreg (SD_, RM2);
3623 store_word (State.regs[REG_SP] + FETCH24 (IMM24A, IMM24B, IMM24C),
3624 State.regs[srcreg]);
3627 // 1111 1101 1010 1010 Rn 0000 IMM24; movbu (d24,Rm),Rn
3628 8.0xfd+8.0xaa+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4r:::movbu
3635 dstreg = translate_rreg (SD_, RN2);
3636 State.regs[dstreg] = load_byte (State.regs[REG_SP]
3637 + EXTEND24 (FETCH24 (IMM24A,
3641 // 1111 1101 1011 1010 Rm 0000 IMM24; movbu Rm,(d24,sp)
3642 8.0xfd+8.0xba+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4s:::movbu
3649 srcreg = translate_rreg (SD_, RM2);
3650 store_byte (State.regs[REG_SP] + FETCH24 (IMM24A, IMM24B, IMM24C),
3651 State.regs[srcreg]);
3654 // 1111 1101 1100 1010 Rn 0000 IMM24; movhu (d24,sp),Rn
3655 8.0xfd+8.0xca+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4r:::movhu
3662 dstreg = translate_rreg (SD_, RN2);
3663 State.regs[dstreg] = load_half (State.regs[REG_SP]
3664 + FETCH24 (IMM24A, IMM24B, IMM24C));
3667 // 1111 1101 1101 1010 Rm Rn IMM24; movhu Rm,(d24,sp)
3668 8.0xfd+8.0xda+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4s:::movhu
3675 srcreg = translate_rreg (SD_, RM2);
3676 store_half (State.regs[REG_SP] + FETCH24 (IMM24A, IMM24B, IMM24C),
3677 State.regs[srcreg]);
3680 // 1111 1101 1110 1010 Rn Rm IMM24; movhu (d24,Rm+),Rn
3681 8.0xfd+8.0xea+4.RN2,4.RM0!RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4y:::movhu
3688 srcreg = translate_rreg (SD_, RM0);
3689 dstreg = translate_rreg (SD_, RN2);
3690 State.regs[dstreg] = load_half (State.regs[srcreg]);
3691 State.regs[dstreg] += EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3694 // 1111 1101 1111 1010 Rm Rn IMM24; movhu Rm,(d24,Rn+)
3695 8.0xfd+8.0xfa+4.RM2,4.RN0+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::movhu
3702 srcreg = translate_rreg (SD_, RM2);
3703 dstreg = translate_rreg (SD_, RN0);
3704 store_half (State.regs[dstreg], State.regs[srcreg]);
3705 State.regs[srcreg] += EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C));
3708 // 1111 1101 0000 1011 Rn IMM24; mac imm24,Rn
3709 8.0xfd+8.0x0b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::mac
3714 long long temp, sum;
3718 srcreg = translate_rreg (SD_, RN2);
3720 temp = ((signed64)EXTEND24 (FETCH24 (IMM24A, IMM24B, IMM24C))
3721 * (signed64)State.regs[srcreg]);
3722 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3723 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3724 State.regs[REG_MCRL] = sum;
3727 sum = State.regs[REG_MCRH] + temp + c;
3728 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3729 && (temp & 0x80000000) != (sum & 0x80000000));
3730 State.regs[REG_MCRH] = sum;
3732 State.regs[REG_MCVF] = 1;
3735 // 1111 1101 0001 1011 Rn IMM24; macu imm24,Rn
3736 8.0xfd+8.0x1b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::macu
3741 long long temp, sum;
3745 srcreg = translate_rreg (SD_, RN2);
3747 temp = ((unsigned64) (FETCH24 (IMM24A, IMM24B, IMM24C))
3748 * (unsigned64)State.regs[srcreg]);
3749 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3750 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3751 State.regs[REG_MCRL] = sum;
3754 sum = State.regs[REG_MCRH] + temp + c;
3755 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3756 && (temp & 0x80000000) != (sum & 0x80000000));
3757 State.regs[REG_MCRH] = sum;
3759 State.regs[REG_MCVF] = 1;
3762 // 1111 1101 0010 1011 Rn IMM24; macb imm24,Rn
3763 8.0xfd+8.0x2b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::macb
3768 long long temp, sum;
3772 srcreg = translate_rreg (SD_, RN2);
3774 temp = ((signed64)EXTEND8 (FETCH24 (IMM24A, IMM24B, IMM24C))
3775 * (signed64)State.regs[srcreg] & 0xff);
3776 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3777 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3778 State.regs[REG_MCRL] = sum;
3781 sum = State.regs[REG_MCRH] + temp + c;
3782 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3783 && (temp & 0x80000000) != (sum & 0x80000000));
3784 State.regs[REG_MCRH] = sum;
3786 State.regs[REG_MCVF] = 1;
3789 // 1111 1101 0011 1011 Rn IMM24; macbu imm24,Rn
3790 8.0xfd+8.0x3b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::macbu
3795 long long temp, sum;
3799 srcreg = translate_rreg (SD_, RN2);
3801 temp = ((unsigned64) (FETCH24 (IMM24A, IMM24B, IMM24C))
3802 * (unsigned64)State.regs[srcreg] & 0xff);
3803 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3804 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3805 State.regs[REG_MCRL] = sum;
3808 sum = State.regs[REG_MCRH] + temp + c;
3809 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3810 && (temp & 0x80000000) != (sum & 0x80000000));
3811 State.regs[REG_MCRH] = sum;
3813 State.regs[REG_MCVF] = 1;
3816 // 1111 1101 0100 1011 Rn IMM24; mach imm24,Rn
3817 8.0xfd+8.0x4b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::mach
3822 long long temp, sum;
3826 srcreg = translate_rreg (SD_, RN2);
3828 temp = ((signed64)EXTEND16 (FETCH24 (IMM24A, IMM24B, IMM24C))
3829 * (signed64)State.regs[srcreg] & 0xffff);
3830 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3831 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3832 State.regs[REG_MCRL] = sum;
3835 sum = State.regs[REG_MCRH] + temp + c;
3836 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3837 && (temp & 0x80000000) != (sum & 0x80000000));
3838 State.regs[REG_MCRH] = sum;
3840 State.regs[REG_MCVF] = 1;
3843 // 1111 1101 0101 1011 Rn IMM24; machu imm24,Rn
3844 8.0xfd+8.0x5b+4.RN2,4.RN0=RN2+8.IMM24A+8.IMM24B+8.IMM24C:D4z:::machu
3849 long long temp, sum;
3853 srcreg = translate_rreg (SD_, RN2);
3855 temp = ((unsigned64) (FETCH24 (IMM24A, IMM24B, IMM24C) & 0xffff)
3856 * (unsigned64)State.regs[srcreg] & 0xffff);
3857 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
3858 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
3859 State.regs[REG_MCRL] = sum;
3862 sum = State.regs[REG_MCRH] + temp + c;
3863 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
3864 && (temp & 0x80000000) != (sum & 0x80000000));
3865 State.regs[REG_MCRH] = sum;
3867 State.regs[REG_MCVF] = 1;
3870 // 1111 1101 0000 1110 Rn 0000 ABS24; mov (abs24),Rn
3871 8.0xfd+8.0x0e+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4u:::mov
3878 dstreg = translate_rreg (SD_, RN2);
3879 State.regs[dstreg] = load_word (FETCH24 (IMM24A, IMM24B, IMM24C));
3882 // 1111 1101 0001 1110 Rm 0000 ABS24; mov Rm,(abs24)
3883 8.0xfd+8.0x1e+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4v:::mov
3890 srcreg = translate_rreg (SD_, RM2);
3891 store_word (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3895 // 1111 1101 0010 1110 Rn 0000 ABS24; movbu (abs24),Rn
3896 8.0xfd+8.0x2e+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4t:::movbu
3903 dstreg = translate_rreg (SD_, RN2);
3904 State.regs[dstreg] = load_byte (FETCH24 (IMM24A, IMM24B, IMM24C));
3907 // 1111 1101 0011 1110 Rm 0000 ABS24; movbu Rm,(abs24)
3908 8.0xfd+8.0x3e+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4u:::movbu
3915 srcreg = translate_rreg (SD_, RM2);
3916 store_byte (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3920 // 1111 1101 0100 1110 Rn 0000 ABS24; movhu (abs24),Rn
3921 8.0xfd+8.0x4e+4.RN2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4t:::movhu
3928 dstreg = translate_rreg (SD_, RN2);
3929 State.regs[dstreg] = load_half (FETCH24 (IMM24A, IMM24B, IMM24C));
3932 // 1111 1101 0101 1110 Rm 0000 ABS24; movhu Rm,(abs24)
3933 8.0xfd+8.0x5e+4.RM2,4.0x0+8.IMM24A+8.IMM24B+8.IMM24C:D4u:::movhu
3940 srcreg = translate_rreg (SD_, RM2);
3941 store_half (FETCH24 (IMM24A, IMM24B, IMM24C), State.regs[srcreg]);
3945 // 1111 1110 0000 1000 Rn Rn IMM32; mov imm32,Rn
3946 8.0xfe+8.0x08+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::mov
3953 dstreg = translate_rreg (SD_, RN0);
3954 State.regs[dstreg] = FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
3957 // 1111 1110 0001 1000 Rn Rn IMM32; movu imm32,Rn
3958 8.0xfe+8.0x18+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::movu
3965 dstreg = translate_rreg (SD_, RN0);
3966 State.regs[dstreg] = FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
3969 // 1111 1110 0111 1000 Rn Rn IMM32; add imm32,Rn
3970 8.0xfe+8.0x78+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::add
3977 dstreg = translate_rreg (SD_, RN0);
3978 genericAdd (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), dstreg);
3981 // 1111 1110 1000 1000 Rn Rn IMM32; addc imm32,Rn
3982 8.0xfe+8.0x88+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::addc
3987 unsigned int imm, reg2, sum;
3991 dstreg = translate_rreg (SD_, RN0);
3993 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
3994 reg2 = State.regs[dstreg];
3995 sum = imm + reg2 + ((PSW & PSW_C) != 0);
3996 State.regs[dstreg] = sum;
3998 z = ((PSW & PSW_Z) != 0) && (sum == 0);
3999 n = (sum & 0x80000000);
4000 c = (sum < imm) || (sum < reg2);
4001 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
4002 && (reg2 & 0x80000000) != (sum & 0x80000000));
4004 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4005 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
4006 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
4009 // 1111 1110 1001 1000 Rn Rn IMM32; sub imm32,Rn
4010 8.0xfe+8.0x98+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::sub
4017 dstreg = translate_rreg (SD_, RN0);
4018 genericSub (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), dstreg);
4021 // 1111 1110 1010 1000 Rn Rn IMM32; subc imm32,Rn
4022 8.0xfe+8.0xa8+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::subc
4027 unsigned int imm, reg2, difference;
4031 dstreg = translate_rreg (SD_, RN0);
4033 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4034 reg2 = State.regs[dstreg];
4035 difference = reg2 - imm - ((PSW & PSW_C) != 0);
4036 State.regs[dstreg] = difference;
4038 z = ((PSW & PSW_Z) != 0) && (difference == 0);
4039 n = (difference & 0x80000000);
4041 v = ((reg2 & 0x80000000) == (imm & 0x80000000)
4042 && (reg2 & 0x80000000) != (difference & 0x80000000));
4044 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4045 PSW |= ((z ? PSW_Z : 0) | ( n ? PSW_N : 0)
4046 | (c ? PSW_C : 0) | (v ? PSW_V : 0));
4049 // 1111 1110 0111 1000 Rn Rn IMM32; cmp imm32,Rn
4050 8.0xfe+8.0xd8+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::cmp
4057 srcreg = translate_rreg (SD_, RN0);
4058 genericCmp (FETCH32(IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4061 // 1111 1110 1111 1000 XRn XRn IMM32; mov imm32,XRn
4062 8.0xfe+8.0xf8+4.XRM2,4.XRN0=XRM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5b:::mov
4069 dstreg = translate_xreg (SD_, XRN0);
4071 State.regs[dstreg] = FETCH32(IMM32A, IMM32B, IMM32C, IMM32D);
4074 // 1111 1110 0000 1001 Rn Rn IMM32; and imm32,Rn
4075 8.0xfe+8.0x09+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::and
4083 dstreg = translate_rreg (SD_, RN0);
4085 State.regs[dstreg] &= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4086 z = (State.regs[dstreg] == 0);
4087 n = (State.regs[dstreg] & 0x80000000) != 0;
4088 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4089 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4092 // 1111 1110 0001 1001 Rn Rn IMM32; or imm32,Rn
4093 8.0xfe+8.0x19+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::or
4101 dstreg = translate_rreg (SD_, RN0);
4103 State.regs[dstreg] |= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4104 z = (State.regs[dstreg] == 0);
4105 n = (State.regs[dstreg] & 0x80000000) != 0;
4106 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4107 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4110 // 1111 1110 0010 1001 Rn Rn IMM32; xor imm32,Rn
4111 8.0xfe+8.0x29+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::xor
4119 dstreg = translate_rreg (SD_, RN0);
4121 State.regs[dstreg] ^= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4122 z = (State.regs[dstreg] == 0);
4123 n = (State.regs[dstreg] & 0x80000000) != 0;
4124 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4125 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4128 // 1111 1110 0100 1001 Rn Rn IMM32; asr imm32,Rn
4129 8.0xfe+8.0x49+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::asr
4138 dstreg = translate_rreg (SD_, RN0);
4140 temp = State.regs[dstreg];
4142 temp >>= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4143 State.regs[dstreg] = temp;
4144 z = (State.regs[dstreg] == 0);
4145 n = (State.regs[dstreg] & 0x80000000) != 0;
4146 PSW &= ~(PSW_Z | PSW_N | PSW_C);
4147 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
4150 // 1111 1110 0101 1001 Rn Rn IMM32; lsr imm32,Rn
4151 8.0xfe+8.0x59+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::lsr
4159 dstreg = translate_rreg (SD_, RN0);
4161 c = State.regs[dstreg] & 1;
4162 State.regs[dstreg] >>= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4163 z = (State.regs[dstreg] == 0);
4164 n = (State.regs[dstreg] & 0x80000000) != 0;
4165 PSW &= ~(PSW_Z | PSW_N | PSW_C);
4166 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0) | (c ? PSW_C : 0));
4169 // 1111 1110 0110 1001 Rn Rn IMM32; asl imm32,Rn
4170 8.0xfe+8.0x69+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::asl
4178 dstreg = translate_rreg (SD_, RN0);
4180 State.regs[dstreg] <<= (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4181 z = (State.regs[dstreg] == 0);
4182 n = (State.regs[dstreg] & 0x80000000) != 0;
4183 PSW &= ~(PSW_Z | PSW_N);
4184 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4187 // 1111 1110 1010 1001 Rn Rn IMM32; mul imm32,Rn
4188 8.0xfe+8.0xa9+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::mul
4193 unsigned long long temp;
4197 dstreg = translate_rreg (SD_, RN0);
4199 temp = ((signed64)(signed32)State.regs[dstreg]
4200 * (signed64)(signed32)(FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D)));
4201 State.regs[dstreg] = temp & 0xffffffff;
4202 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
4203 z = (State.regs[dstreg] == 0);
4204 n = (State.regs[dstreg] & 0x80000000) != 0;
4205 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4206 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4209 // 1111 1110 1011 1001 Rn Rn IMM32; mulu imm32,Rn
4210 8.0xfe+8.0xb9+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::mulu
4215 unsigned long long temp;
4219 dstreg = translate_rreg (SD_, RN0);
4221 temp = ((unsigned64)State.regs[dstreg]
4222 * (unsigned64) (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D)));
4223 State.regs[dstreg] = temp & 0xffffffff;
4224 State.regs[REG_MDR] = (temp & 0xffffffff00000000LL) >> 32;
4225 z = (State.regs[dstreg] == 0);
4226 n = (State.regs[dstreg] & 0x80000000) != 0;
4227 PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
4228 PSW |= ((z ? PSW_Z : 0) | (n ? PSW_N : 0));
4231 // 1111 1110 1110 1001 Rn Rn IMM32; btst imm32,Rn
4232 8.0xfe+8.0xe9+4.RM2,4.RN0=RM2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5a:::btst
4239 srcreg = translate_rreg (SD_, RN0);
4240 genericBtst (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4243 // 1111 1110 0000 1010 Rn Rm IMM32; mov (d32,Rm),Rn
4244 8.0xfe+8.0x0a+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5f:::mov
4251 srcreg = translate_rreg (SD_, RM0);
4252 dstreg = translate_rreg (SD_, RN2);
4253 State.regs[dstreg] = load_word (State.regs[srcreg]
4254 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4257 // 1111 1110 0001 1010 Rm Rn IMM32; mov Rm,(d32,Rn)
4258 8.0xfe+8.0x1a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5g:::mov
4265 srcreg = translate_rreg (SD_, RM2);
4266 dstreg = translate_rreg (SD_, RN0);
4267 store_word (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4268 State.regs[srcreg]);
4271 // 1111 1110 0010 1010 Rn Rm IMM32; movbu (d32,Rm),Rn
4272 8.0xfe+8.0x2a+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::movbu
4279 srcreg = translate_rreg (SD_, RM0);
4280 dstreg = translate_rreg (SD_, RN2);
4281 State.regs[dstreg] = load_byte (State.regs[srcreg]
4282 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4285 // 1111 1110 0011 1010 Rm Rn IMM32; movbu Rm,(d32,Rn)
4286 8.0xfe+8.0x3a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5b:::movbu
4293 srcreg = translate_rreg (SD_, RM2);
4294 dstreg = translate_rreg (SD_, RN0);
4295 store_byte (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4296 State.regs[srcreg]);
4299 // 1111 1110 0100 1010 Rn Rm IMM32; movhu (d32,Rm),Rn
4300 8.0xfe+8.0x4a+4.RN2,4.RM0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::movhu
4307 srcreg = translate_rreg (SD_, RM0);
4308 dstreg = translate_rreg (SD_, RN2);
4309 State.regs[dstreg] = load_half (State.regs[srcreg]
4310 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4313 // 1111 1110 0101 1010 Rm Rn IMM32; movhu Rm,(d32,Rn)
4314 8.0xfe+8.0x5a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5b:::movhu
4321 srcreg = translate_rreg (SD_, RM2);
4322 dstreg = translate_rreg (SD_, RN0);
4323 store_half (State.regs[dstreg] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4324 State.regs[srcreg]);
4327 // 1111 1110 0110 1010 Rn Rm IMM32; mov (d32,Rm+),Rn
4328 8.0xfe+8.0x6a+4.RN2,4.RM0!RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5y:::mov
4335 srcreg = translate_rreg (SD_, RM0);
4336 dstreg = translate_rreg (SD_, RN2);
4337 State.regs[dstreg] = load_word (State.regs[srcreg]);
4338 State.regs[srcreg] += FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4341 // 1111 1110 0111 1010 Rm Rn IMM32; mov Rm,(d32,Rn+)
4342 8.0xfe+8.0x7a+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5z:::mov
4349 srcreg = translate_rreg (SD_, RM2);
4350 dstreg = translate_rreg (SD_, RN0);
4351 store_word (State.regs[dstreg], State.regs[srcreg]);
4352 State.regs[dstreg] += FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4356 // 1111 1110 1000 1010 Rn 0000 IMM32; mov (d32,sp),Rn
4357 8.0xfe+8.0x8a+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5c:::mov
4364 dstreg = translate_rreg (SD_, RN2);
4365 State.regs[dstreg] = load_word (State.regs[REG_SP]
4366 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4369 // 1111 1110 1001 1010 Rm 0000 IMM32; mov Rm,(d32,sp)
4370 8.0xfe+8.0x9a+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5d:::mov
4377 srcreg = translate_rreg (SD_, RM2);
4378 store_word (State.regs[REG_SP] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4379 State.regs[srcreg]);
4382 // 1111 1110 1010 1010 Rn 0000 IMM32; movbu (d32,sp),Rn
4383 8.0xfe+8.0xaa+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5c:::movbu
4390 dstreg = translate_rreg (SD_, RN2);
4391 State.regs[dstreg] = load_byte (State.regs[REG_SP]
4392 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4395 // 1111 1110 1011 1010 Rm 0000 IMM32; movbu Rm,(d32,sp)
4396 8.0xfe+8.0xba+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5d:::movbu
4403 srcreg = translate_rreg (SD_, RM2);
4404 store_byte (State.regs[REG_SP] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4405 State.regs[srcreg]);
4408 // 1111 1110 1100 1010 Rn 0000 IMM32; movhu (d32,sp),Rn
4409 8.0xfe+8.0xca+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5c:::movhu
4416 dstreg = translate_rreg (SD_, RN2);
4417 State.regs[dstreg] = load_half (State.regs[REG_SP]
4418 + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4421 // 1111 1110 1101 1010 Rm 0000 IMM32; movhu Rm,(d32,sp)
4422 8.0xfe+8.0xda+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5d:::movhu
4429 srcreg = translate_rreg (SD_, RM2);
4430 store_half (State.regs[REG_SP] + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D),
4431 State.regs[srcreg]);
4435 // 1111 1110 1110 1010 Rn Rm IMM32; movhu (d32,Rm+),Rn
4436 8.0xfe+8.0xea+4.RN2,4.RM0!RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5y:::movhu
4443 srcreg = translate_rreg (SD_, RM0);
4444 dstreg = translate_rreg (SD_, RN2);
4445 State.regs[dstreg] = load_half (State.regs[srcreg]);
4446 State.regs[srcreg] += FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4449 // 1111 1110 1111 1010 Rm Rn IMM32; movhu Rm,(d32,Rn+)
4450 8.0xfe+8.0xfa+4.RM2,4.RN0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5f:::movhu
4457 srcreg = translate_rreg (SD_, RM2);
4458 dstreg = translate_rreg (SD_, RN0);
4459 store_half (State.regs[dstreg], State.regs[srcreg]);
4460 State.regs[dstreg] += FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4464 // 1111 1110 0000 1011 Rn Rn IMM32; mac imm32,Rn
4465 8.0xfe+8.0x0b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::mac
4470 long long temp, sum;
4474 srcreg = translate_rreg (SD_, RN0);
4475 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4477 temp = ((signed64)(signed32)State.regs[srcreg]
4478 * (signed64)(signed32)imm);
4479 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
4480 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
4481 State.regs[REG_MCRL] = sum;
4484 sum = State.regs[REG_MCRH] + temp + c;
4485 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
4486 && (temp & 0x80000000) != (sum & 0x80000000));
4487 State.regs[REG_MCRH] = sum;
4489 State.regs[REG_MCVF] = 1;
4492 // 1111 1110 0001 1011 Rn Rn IMM32; macu imm32,Rn
4493 8.0xfe+8.0x1b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::macu
4498 long long temp, sum;
4502 srcreg = translate_rreg (SD_, RN0);
4503 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4505 temp = ((unsigned64)State.regs[srcreg]
4507 sum = State.regs[REG_MCRL] + (temp & 0xffffffff);
4508 c = (sum < State.regs[REG_MCRL]) || (sum < (temp & 0xffffffff));
4509 State.regs[REG_MCRL] = sum;
4512 sum = State.regs[REG_MCRH] + temp + c;
4513 v = ((State.regs[REG_MCRH] & 0x80000000) == (temp & 0x80000000)
4514 && (temp & 0x80000000) != (sum & 0x80000000));
4515 State.regs[REG_MCRH] = sum;
4517 State.regs[REG_MCVF] = 1;
4520 // 1111 1110 0010 1011 Rn Rn IMM32; macb imm32,Rn
4521 8.0xfe+8.0x2b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::macb
4530 srcreg = translate_rreg (SD_, RN0);
4531 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4533 temp = ((signed32)(signed8)(State.regs[srcreg] & 0xff)
4534 * (signed32)(signed8)(imm & 0xff));
4535 sum = State.regs[REG_MCRL] + temp;
4536 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
4537 && (temp & 0x80000000) != (sum & 0x80000000));
4538 State.regs[REG_MCRL] = sum;
4540 State.regs[REG_MCVF] = 1;
4543 // 1111 1110 0011 1011 Rn Rn IMM32; macbu imm32,Rn
4544 8.0xfe+8.0x3b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::macbu
4553 srcreg = translate_rreg (SD_, RN0);
4554 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4556 temp = ((unsigned32)(State.regs[srcreg] & 0xff)
4557 * (unsigned32)(imm & 0xff));
4558 sum = State.regs[REG_MCRL] + temp;
4559 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
4560 && (temp & 0x80000000) != (sum & 0x80000000));
4561 State.regs[REG_MCRL] = sum;
4563 State.regs[REG_MCVF] = 1;
4566 // 1111 1110 0100 1011 Rn Rn IMM32; mach imm32,Rn
4567 8.0xfe+8.0x4b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::mach
4576 srcreg = translate_rreg (SD_, RN0);
4577 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4579 temp = ((signed32)(signed16)(State.regs[srcreg] & 0xffff)
4580 * (signed32)(signed16)(imm & 0xffff));
4581 sum = State.regs[REG_MCRL] + temp;
4582 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
4583 && (temp & 0x80000000) != (sum & 0x80000000));
4584 State.regs[REG_MCRL] = sum;
4586 State.regs[REG_MCVF] = 1;
4589 // 1111 1110 0101 1011 Rn Rn IMM32; machu imm32,Rn
4590 8.0xfe+8.0x5b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::machu
4599 srcreg = translate_rreg (SD_, RN0);
4600 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4602 temp = ((unsigned32)(State.regs[srcreg] & 0xffff)
4603 * (unsigned32)(imm & 0xffff));
4604 sum = State.regs[REG_MCRL] + temp;
4605 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
4606 && (temp & 0x80000000) != (sum & 0x80000000));
4607 State.regs[REG_MCRL] = sum;
4609 State.regs[REG_MCVF] = 1;
4612 // 1111 1110 0110 1011 Rn Rn IMM32; dmach imm32,Rn
4613 8.0xfe+8.0x6b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::dmach
4618 long temp, temp2, sum;
4622 srcreg = translate_rreg (SD_, RN0);
4623 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4625 temp = ((signed32)(signed16)(State.regs[srcreg] & 0xffff)
4626 * (signed32)(signed16)(imm & 0xffff));
4627 temp2 = ((signed32)(signed16)((State.regs[srcreg] >> 16) & 0xffff)
4628 * (signed32)(signed16)((imm >> 16) & 0xffff));
4629 sum = temp + temp2 + State.regs[REG_MCRL];
4630 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
4631 && (temp & 0x80000000) != (sum & 0x80000000));
4632 State.regs[REG_MCRL] = sum;
4634 State.regs[REG_MCVF] = 1;
4637 // 1111 1110 0111 1011 Rn Rn IMM32; dmachu imm32,Rn
4638 8.0xfe+8.0x7b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::dmachu
4643 long temp, temp2, sum;
4647 srcreg = translate_rreg (SD_, RN0);
4648 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4650 temp = ((unsigned32)(State.regs[srcreg] & 0xffff)
4651 * (unsigned32)(imm & 0xffff));
4652 temp2 = ((unsigned32)((State.regs[srcreg] >> 16) & 0xffff)
4653 * (unsigned32)((imm >> 16) & 0xffff));
4654 sum = temp + temp2 + State.regs[REG_MCRL];
4655 v = ((State.regs[REG_MCRL] & 0x80000000) == (temp & 0x80000000)
4656 && (temp & 0x80000000) != (sum & 0x80000000));
4657 State.regs[REG_MCRL] = sum;
4659 State.regs[REG_MCVF] = 1;
4662 // 1111 1110 1000 1011 Rn Rn IMM32; dmulh imm32,Rn
4663 8.0xfe+8.0x8b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::dmulh
4671 dstreg = translate_rreg (SD_, RN0);
4672 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4674 temp = ((signed32)(signed16)(State.regs[dstreg] & 0xffff)
4675 * (signed32)(signed16)(imm & 0xffff));
4676 State.regs[REG_MDRQ] = temp;
4677 temp = ((signed32)(signed16)((State.regs[dstreg] >> 16) & 0xffff)
4678 * (signed32)(signed16)((imm>>16) & 0xffff));
4679 State.regs[dstreg] = temp;
4682 // 1111 1110 1001 1011 Rn Rn IMM32; dmulhu imm32,Rn
4683 8.0xfe+8.0x9b+4.RN2,4.RN0=RN2+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::dmulhu
4691 dstreg = translate_rreg (SD_, RN0);
4692 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
4694 temp = ((unsigned32)(State.regs[dstreg] & 0xffff)
4695 * (unsigned32)(imm & 0xffff));
4696 State.regs[REG_MDRQ] = temp;
4697 temp = ((unsigned32)((State.regs[dstreg] >> 16) & 0xffff)
4698 * (unsigned32)((imm >>16) & 0xffff));
4699 State.regs[dstreg] = temp;
4702 // 1111 1110 0000 1110 Rn 0000 IMM32; mov (abs32),Rn
4703 8.0xfe+8.0x0e+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5h:::mov
4710 dstreg = translate_rreg (SD_, RN2);
4711 State.regs[dstreg] = load_word (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4714 // 1111 1110 0001 1110 Rm 0000 IMM32; mov Rn,(abs32)
4715 8.0xfe+8.0x1e+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5e:::mov
4722 srcreg = translate_rreg (SD_, RM2);
4723 store_word (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4726 // 1111 1110 0020 1110 Rn 0000 IMM32; movbu (abs32),Rn
4727 8.0xfe+8.0x2e+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5i:::movbu
4734 dstreg = translate_rreg (SD_, RN2);
4735 State.regs[dstreg] = load_byte (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4738 // 1111 1110 0011 1110 Rm 0000 IMM32; movbu Rn,(abs32)
4739 8.0xfe+8.0x3e+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5e:::movbu
4746 srcreg = translate_rreg (SD_, RM2);
4747 store_byte (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4750 // 1111 1110 0100 1110 Rn 0000 IMM32; movhu (abs32),Rn
4751 8.0xfe+8.0x4e+4.RN2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5j:::movhu
4758 dstreg = translate_rreg (SD_, RN2);
4759 State.regs[dstreg] = load_half (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
4762 // 1111 1110 0101 1110 Rm 0000 IMM32; movhu Rn,(abs32)
4763 8.0xfe+8.0x5e+4.RM2,4.0x0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5e:::movhu
4770 srcreg = translate_rreg (SD_, RM2);
4771 store_half (FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D), State.regs[srcreg]);
4774 // 1111 0111 0000 0000 Rm1 Rn1 Rm2 Rn2; add_add Rm1, Rn1, Rm2, Rn2
4775 8.0xf7+8.0x00+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::add_add
4779 int srcreg1, srcreg2, dstreg1, dstreg2;
4783 srcreg1 = translate_rreg (SD_, RM1);
4784 srcreg2 = translate_rreg (SD_, RM2);
4785 dstreg1 = translate_rreg (SD_, RN1);
4786 dstreg2 = translate_rreg (SD_, RN2);
4788 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4789 State.regs[dstreg2] += State.regs[srcreg2];
4790 State.regs[dstreg1] = result1;
4793 // 1111 0111 0001 0000 Rm1 Rn1 imm4 Rn2; add_add Rm1, Rn1, imm4, Rn2
4794 8.0xf7+8.0x10+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::add_add
4798 int srcreg1, dstreg1, dstreg2;
4802 srcreg1 = translate_rreg (SD_, RM1);
4803 dstreg1 = translate_rreg (SD_, RN1);
4804 dstreg2 = translate_rreg (SD_, RN2);
4806 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4807 State.regs[dstreg2] += EXTEND4 (IMM4);
4808 State.regs[dstreg1] = result1;
4811 // 1111 0111 0010 0000 Rm1 Rn1 Rm2 Rn2; add_sub Rm1, Rn1, Rm2, Rn2
4812 8.0xf7+8.0x20+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::add_sub
4816 int srcreg1, srcreg2, dstreg1, dstreg2;
4820 srcreg1 = translate_rreg (SD_, RM1);
4821 srcreg2 = translate_rreg (SD_, RM2);
4822 dstreg1 = translate_rreg (SD_, RN1);
4823 dstreg2 = translate_rreg (SD_, RN2);
4825 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4826 State.regs[dstreg2] -= State.regs[srcreg2];
4827 State.regs[dstreg1] = result1;
4830 // 1111 0111 0011 0000 Rm1 Rn1 imm4 Rn2; add_sub Rm1, Rn1, imm4, Rn2
4831 8.0xf7+8.0x30+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::add_sub
4835 int srcreg1, dstreg1, dstreg2;
4839 srcreg1 = translate_rreg (SD_, RM1);
4840 dstreg1 = translate_rreg (SD_, RN1);
4841 dstreg2 = translate_rreg (SD_, RN2);
4843 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4844 State.regs[dstreg2] -= EXTEND4 (IMM4);
4845 State.regs[dstreg1] = result1;
4848 // 1111 0111 0100 0000 Rm1 Rn1 Rm2 Rn2; add_cmp Rm1, Rn1, Rm2, Rn2
4849 8.0xf7+8.0x40+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::add_cmp
4853 int srcreg1, srcreg2, dstreg1, dstreg2;
4856 srcreg1 = translate_rreg (SD_, RM1);
4857 srcreg2 = translate_rreg (SD_, RM2);
4858 dstreg1 = translate_rreg (SD_, RN1);
4859 dstreg2 = translate_rreg (SD_, RN2);
4861 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
4862 State.regs[dstreg1] += State.regs[srcreg1];
4865 // 1111 0111 0101 0000 Rm1 Rn1 imm4 Rn2; add_cmp Rm1, Rn1, imm4, Rn2
4866 8.0xf7+8.0x50+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::add_cmp
4870 int srcreg1, dstreg1, dstreg2;
4873 srcreg1 = translate_rreg (SD_, RM1);
4874 dstreg1 = translate_rreg (SD_, RN1);
4875 dstreg2 = translate_rreg (SD_, RN2);
4877 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
4878 State.regs[dstreg1] += State.regs[srcreg1];
4881 // 1111 0111 0110 0000 Rm1 Rn1 Rm2 Rn2; add_mov Rm1, Rn1, Rm2, Rn2
4882 8.0xf7+8.0x60+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::add_mov
4886 int srcreg1, srcreg2, dstreg1, dstreg2;
4890 srcreg1 = translate_rreg (SD_, RM1);
4891 srcreg2 = translate_rreg (SD_, RM2);
4892 dstreg1 = translate_rreg (SD_, RN1);
4893 dstreg2 = translate_rreg (SD_, RN2);
4895 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4896 State.regs[dstreg2] = State.regs[srcreg2];
4897 State.regs[dstreg1] = result1;
4900 // 1111 0111 0111 0000 Rm1 Rn1 imm4 Rn2; add_mov Rm1, Rn1, imm4, Rn2
4901 8.0xf7+8.0x70+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::add_mov
4905 int srcreg1, dstreg1, dstreg2;
4909 srcreg1 = translate_rreg (SD_, RM1);
4910 dstreg1 = translate_rreg (SD_, RN1);
4911 dstreg2 = translate_rreg (SD_, RN2);
4913 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4914 State.regs[dstreg2] = EXTEND4 (IMM4);
4915 State.regs[dstreg1] = result1;
4918 // 1111 0111 1000 0000 Rm1 Rn1 Rm2 Rn2; add_asr Rm1, Rn1, Rm2, Rn2
4919 8.0xf7+8.0x80+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::add_asr
4923 int srcreg1, srcreg2, dstreg1, dstreg2;
4928 srcreg1 = translate_rreg (SD_, RM1);
4929 srcreg2 = translate_rreg (SD_, RM2);
4930 dstreg1 = translate_rreg (SD_, RN1);
4931 dstreg2 = translate_rreg (SD_, RN2);
4933 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4934 temp = State.regs[dstreg2];
4935 temp >>= State.regs[srcreg2];
4936 State.regs[dstreg2] = temp;
4937 State.regs[dstreg1] = result1;
4940 // 1111 0111 1001 0000 Rm1 Rn1 imm4 Rn2; add_asr Rm1, Rn1, imm4, Rn2
4941 8.0xf7+8.0x90+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::add_asr
4945 int srcreg1, dstreg1, dstreg2;
4950 srcreg1 = translate_rreg (SD_, RM1);
4951 dstreg1 = translate_rreg (SD_, RN1);
4952 dstreg2 = translate_rreg (SD_, RN2);
4954 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4955 temp = State.regs[dstreg2];
4957 State.regs[dstreg2] = temp;
4958 State.regs[dstreg1] = result1;
4961 // 1111 0111 1010 0000 Rm1 Rn1 Rm2 Rn2; add_lsr Rm1, Rn1, Rm2, Rn2
4962 8.0xf7+8.0xa0+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::add_lsr
4966 int srcreg1, srcreg2, dstreg1, dstreg2;
4970 srcreg1 = translate_rreg (SD_, RM1);
4971 srcreg2 = translate_rreg (SD_, RM2);
4972 dstreg1 = translate_rreg (SD_, RN1);
4973 dstreg2 = translate_rreg (SD_, RN2);
4975 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4976 State.regs[dstreg2] >>= State.regs[srcreg2];
4977 State.regs[dstreg1] = result1;
4980 // 1111 0111 1011 0000 Rm1 Rn1 imm4 Rn2; add_lsr Rm1, Rn1, imm4, Rn2
4981 8.0xf7+8.0xb0+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::add_lsr
4985 int srcreg1, dstreg1, dstreg2;
4990 srcreg1 = translate_rreg (SD_, RM1);
4991 dstreg1 = translate_rreg (SD_, RN1);
4992 dstreg2 = translate_rreg (SD_, RN2);
4994 result1 = State.regs[dstreg1] + State.regs[srcreg1];
4995 State.regs[dstreg2] >>= IMM4;
4996 State.regs[dstreg1] = result1;
5000 // 1111 0111 1100 0000 Rm1 Rn1 Rm2 Rn2; add_asl Rm1, Rn1, Rm2, Rn2
5001 8.0xf7+8.0xc0+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::add_asl
5005 int srcreg1, srcreg2, dstreg1, dstreg2;
5009 srcreg1 = translate_rreg (SD_, RM1);
5010 srcreg2 = translate_rreg (SD_, RM2);
5011 dstreg1 = translate_rreg (SD_, RN1);
5012 dstreg2 = translate_rreg (SD_, RN2);
5014 result1 = State.regs[dstreg1] + State.regs[srcreg1];
5015 State.regs[dstreg2] <<= State.regs[srcreg2];
5016 State.regs[dstreg1] = result1;
5019 // 1111 0111 1101 0000 Rm1 Rn1 imm4 Rn2; add_asl Rm1, Rn1, imm4, Rn2
5020 8.0xf7+8.0xd0+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::add_asl
5024 int srcreg1, dstreg1, dstreg2;
5029 srcreg1 = translate_rreg (SD_, RM1);
5030 dstreg1 = translate_rreg (SD_, RN1);
5031 dstreg2 = translate_rreg (SD_, RN2);
5033 result1 = State.regs[dstreg1] + State.regs[srcreg1];
5034 State.regs[dstreg2] <<= IMM4;
5035 State.regs[dstreg1] = result1;
5038 // 1111 0111 0000 0001 Rm1 Rn1 Rm2 Rn2; cmp_add Rm1, Rn1, Rm2, Rn2
5039 8.0xf7+8.0x01+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::cmp_add
5043 int srcreg1, srcreg2, dstreg1, dstreg2;
5046 srcreg1 = translate_rreg (SD_, RM1);
5047 srcreg2 = translate_rreg (SD_, RM2);
5048 dstreg1 = translate_rreg (SD_, RN1);
5049 dstreg2 = translate_rreg (SD_, RN2);
5051 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5052 State.regs[dstreg2] += State.regs[srcreg2];
5055 // 1111 0111 0001 0001 Rm1 Rn1 imm4 Rn2; cmp_add Rm1, Rn1, imm4, Rn2
5056 8.0xf7+8.0x11+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::cmp_add
5060 int srcreg1, dstreg1, dstreg2;
5063 srcreg1 = translate_rreg (SD_, RM1);
5064 dstreg1 = translate_rreg (SD_, RN1);
5065 dstreg2 = translate_rreg (SD_, RN2);
5067 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5068 State.regs[dstreg2] += EXTEND4 (IMM4);
5071 // 1111 0111 0010 0001 Rm1 Rn1 Rm2 Rn2; cmp_sub Rm1, Rn1, Rm2, Rn2
5072 8.0xf7+8.0x21+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::cmp_sub
5076 int srcreg1, srcreg2, dstreg1, dstreg2;
5079 srcreg1 = translate_rreg (SD_, RM1);
5080 srcreg2 = translate_rreg (SD_, RM2);
5081 dstreg1 = translate_rreg (SD_, RN1);
5082 dstreg2 = translate_rreg (SD_, RN2);
5084 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5085 State.regs[dstreg2] -= State.regs[srcreg2];
5088 // 1111 0111 0011 0001 Rm1 Rn1 imm4 Rn2; cmp_sub Rm1, Rn1, imm4, Rn2
5089 8.0xf7+8.0x31+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::cmp_sub
5093 int srcreg1, dstreg1, dstreg2;
5096 srcreg1 = translate_rreg (SD_, RM1);
5097 dstreg1 = translate_rreg (SD_, RN1);
5098 dstreg2 = translate_rreg (SD_, RN2);
5100 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5101 State.regs[dstreg2] -= EXTEND4 (IMM4);
5104 // 1111 0111 0110 0001 Rm1 Rn1 Rm2 Rn2; cmp_mov Rm1, Rn1, Rm2, Rn2
5105 8.0xf7+8.0x61+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::cmp_mov
5109 int srcreg1, srcreg2, dstreg1, dstreg2;
5112 srcreg1 = translate_rreg (SD_, RM1);
5113 srcreg2 = translate_rreg (SD_, RM2);
5114 dstreg1 = translate_rreg (SD_, RN1);
5115 dstreg2 = translate_rreg (SD_, RN2);
5117 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5118 State.regs[dstreg2] = State.regs[srcreg2];
5121 // 1111 0111 0111 0001 Rm1 Rn1 imm4 Rn2; cmp_mov Rm1, Rn1, imm4, Rn2
5122 8.0xf7+8.0x71+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::cmp_mov
5126 int srcreg1, dstreg1, dstreg2;
5129 srcreg1 = translate_rreg (SD_, RM1);
5130 dstreg1 = translate_rreg (SD_, RN1);
5131 dstreg2 = translate_rreg (SD_, RN2);
5133 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5134 State.regs[dstreg2] = EXTEND4 (IMM4);
5137 // 1111 0111 1000 0001 Rm1 Rn1 Rm2 Rn2; cmp_asr Rm1, Rn1, Rm2, Rn2
5138 8.0xf7+8.0x81+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::cmp_asr
5142 int srcreg1, srcreg2, dstreg1, dstreg2;
5146 srcreg1 = translate_rreg (SD_, RM1);
5147 srcreg2 = translate_rreg (SD_, RM2);
5148 dstreg1 = translate_rreg (SD_, RN1);
5149 dstreg2 = translate_rreg (SD_, RN2);
5151 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5152 temp = State.regs[dstreg2];
5153 temp >>= State.regs[srcreg2];
5154 State.regs[dstreg2] = temp;
5157 // 1111 0111 1001 0001 Rm1 Rn1 imm4 Rn2; cmp_asr Rm1, Rn1, imm4, Rn2
5158 8.0xf7+8.0x91+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::cmp_asr
5162 int srcreg1, dstreg1, dstreg2;
5166 srcreg1 = translate_rreg (SD_, RM1);
5167 dstreg1 = translate_rreg (SD_, RN1);
5168 dstreg2 = translate_rreg (SD_, RN2);
5170 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5171 temp = State.regs[dstreg2];
5173 State.regs[dstreg2] = temp;
5176 // 1111 0111 1010 0001 Rm1 Rn1 Rm2 Rn2; cmp_lsr Rm1, Rn1, Rm2, Rn2
5177 8.0xf7+8.0xa1+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::cmp_lsr
5181 int srcreg1, srcreg2, dstreg1, dstreg2;
5184 srcreg1 = translate_rreg (SD_, RM1);
5185 srcreg2 = translate_rreg (SD_, RM2);
5186 dstreg1 = translate_rreg (SD_, RN1);
5187 dstreg2 = translate_rreg (SD_, RN2);
5189 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5190 State.regs[dstreg2] >>= State.regs[srcreg2];
5193 // 1111 0111 1011 0001 Rm1 Rn1 imm4 Rn2; cmp_lsr Rm1, Rn1, imm4, Rn2
5194 8.0xf7+8.0xb1+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::cmp_lsr
5198 int srcreg1, dstreg1, dstreg2;
5202 srcreg1 = translate_rreg (SD_, RM1);
5203 dstreg1 = translate_rreg (SD_, RN1);
5204 dstreg2 = translate_rreg (SD_, RN2);
5206 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5207 State.regs[dstreg2] >>= IMM4;
5211 // 1111 0111 1100 0001 Rm1 Rn1 Rm2 Rn2; cmp_asl Rm1, Rn1, Rm2, Rn2
5212 8.0xf7+8.0xc1+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::cmp_asl
5216 int srcreg1, srcreg2, dstreg1, dstreg2;
5219 srcreg1 = translate_rreg (SD_, RM1);
5220 srcreg2 = translate_rreg (SD_, RM2);
5221 dstreg1 = translate_rreg (SD_, RN1);
5222 dstreg2 = translate_rreg (SD_, RN2);
5224 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5225 State.regs[dstreg2] <<= State.regs[srcreg2];
5228 // 1111 0111 1101 0001 Rm1 Rn1 imm4 Rn2; cmp_asl Rm1, Rn1, imm4, Rn2
5229 8.0xf7+8.0xd1+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::cmp_asl
5233 int srcreg1, dstreg1, dstreg2;
5237 srcreg1 = translate_rreg (SD_, RM1);
5238 dstreg1 = translate_rreg (SD_, RN1);
5239 dstreg2 = translate_rreg (SD_, RN2);
5241 genericCmp (State.regs[srcreg1], State.regs[dstreg1]);
5242 State.regs[dstreg2] <<= IMM4;
5245 // 1111 0111 0000 0010 Rm1 Rn1 Rm2 Rn2; sub_add Rm1, Rn1, Rm2, Rn2
5246 8.0xf7+8.0x02+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sub_add
5250 int srcreg1, srcreg2, dstreg1, dstreg2;
5254 srcreg1 = translate_rreg (SD_, RM1);
5255 srcreg2 = translate_rreg (SD_, RM2);
5256 dstreg1 = translate_rreg (SD_, RN1);
5257 dstreg2 = translate_rreg (SD_, RN2);
5259 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5260 State.regs[dstreg2] += State.regs[srcreg2];
5261 State.regs[dstreg1] = result1;
5264 // 1111 0111 0001 0010 Rm1 Rn1 imm4 Rn2; sub_add Rm1, Rn1, imm4, Rn2
5265 8.0xf7+8.0x12+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sub_add
5269 int srcreg1, dstreg1, dstreg2;
5273 srcreg1 = translate_rreg (SD_, RM1);
5274 dstreg1 = translate_rreg (SD_, RN1);
5275 dstreg2 = translate_rreg (SD_, RN2);
5277 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5278 State.regs[dstreg2] += EXTEND4 (IMM4);
5279 State.regs[dstreg1] = result1;
5282 // 1111 0111 0010 0010 Rm1 Rn1 Rm2 Rn2; sub_sub Rm1, Rn1, Rm2, Rn2
5283 8.0xf7+8.0x22+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sub_sub
5287 int srcreg1, srcreg2, dstreg1, dstreg2;
5291 srcreg1 = translate_rreg (SD_, RM1);
5292 srcreg2 = translate_rreg (SD_, RM2);
5293 dstreg1 = translate_rreg (SD_, RN1);
5294 dstreg2 = translate_rreg (SD_, RN2);
5296 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5297 State.regs[dstreg2] -= State.regs[srcreg2];
5298 State.regs[dstreg1] = result1;
5301 // 1111 0111 0011 0010 Rm1 Rn1 imm4 Rn2; sub_sub Rm1, Rn1, imm4, Rn2
5302 8.0xf7+8.0x32+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sub_sub
5306 int srcreg1, dstreg1, dstreg2;
5310 srcreg1 = translate_rreg (SD_, RM1);
5311 dstreg1 = translate_rreg (SD_, RN1);
5312 dstreg2 = translate_rreg (SD_, RN2);
5314 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5315 State.regs[dstreg2] -= EXTEND4 (IMM4);
5316 State.regs[dstreg1] = result1;
5319 // 1111 0111 0100 0010 Rm1 Rn1 Rm2 Rn2; sub_cmp Rm1, Rn1, Rm2, Rn2
5320 8.0xf7+8.0x42+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sub_cmp
5324 int srcreg1, srcreg2, dstreg1, dstreg2;
5327 srcreg1 = translate_rreg (SD_, RM1);
5328 srcreg2 = translate_rreg (SD_, RM2);
5329 dstreg1 = translate_rreg (SD_, RN1);
5330 dstreg2 = translate_rreg (SD_, RN2);
5332 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
5333 State.regs[dstreg1] -= State.regs[srcreg1];
5336 // 1111 0111 0101 0010 Rm1 Rn1 imm4 Rn2; sub_cmp Rm1, Rn1, imm4, Rn2
5337 8.0xf7+8.0x52+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sub_cmp
5341 int srcreg1, dstreg1, dstreg2;
5345 srcreg1 = translate_rreg (SD_, RM1);
5346 dstreg1 = translate_rreg (SD_, RN1);
5347 dstreg2 = translate_rreg (SD_, RN2);
5349 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
5350 State.regs[dstreg1] -= State.regs[srcreg1];
5353 // 1111 0111 0110 0010 Rm1 Rn1 Rm2 Rn2; sub_mov Rm1, Rn1, Rm2, Rn2
5354 8.0xf7+8.0x62+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sub_mov
5358 int srcreg1, srcreg2, dstreg1, dstreg2;
5362 srcreg1 = translate_rreg (SD_, RM1);
5363 srcreg2 = translate_rreg (SD_, RM2);
5364 dstreg1 = translate_rreg (SD_, RN1);
5365 dstreg2 = translate_rreg (SD_, RN2);
5367 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5368 State.regs[dstreg2] = State.regs[srcreg2];
5369 State.regs[dstreg1] = result1;
5372 // 1111 0111 0111 0010 Rm1 Rn1 imm4 Rn2; sub_mov Rm1, Rn1, imm4, Rn2
5373 8.0xf7+8.0x72+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sub_mov
5377 int srcreg1, dstreg1, dstreg2;
5381 srcreg1 = translate_rreg (SD_, RM1);
5382 dstreg1 = translate_rreg (SD_, RN1);
5383 dstreg2 = translate_rreg (SD_, RN2);
5385 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5386 State.regs[dstreg2] = EXTEND4 (IMM4);
5387 State.regs[dstreg1] = result1;
5390 // 1111 0111 1000 0010 Rm1 Rn1 Rm2 Rn2; sub_asr Rm1, Rn1, Rm2, Rn2
5391 8.0xf7+8.0x82+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sub_asr
5395 int srcreg1, srcreg2, dstreg1, dstreg2;
5400 srcreg1 = translate_rreg (SD_, RM1);
5401 srcreg2 = translate_rreg (SD_, RM2);
5402 dstreg1 = translate_rreg (SD_, RN1);
5403 dstreg2 = translate_rreg (SD_, RN2);
5405 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5406 temp = State.regs[dstreg2];
5407 temp >>= State.regs[srcreg2];
5408 State.regs[dstreg2] = temp;
5409 State.regs[dstreg1] = result1;
5412 // 1111 0111 1001 0010 Rm1 Rn1 imm4 Rn2; sub_asr Rm1, Rn1, imm4, Rn2
5413 8.0xf7+8.0x92+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sub_asr
5417 int srcreg1, dstreg1, dstreg2;
5422 srcreg1 = translate_rreg (SD_, RM1);
5423 dstreg1 = translate_rreg (SD_, RN1);
5424 dstreg2 = translate_rreg (SD_, RN2);
5426 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5427 temp = State.regs[dstreg2];
5429 State.regs[dstreg2] = temp;
5430 State.regs[dstreg1] = result1;
5433 // 1111 0111 1010 0010 Rm1 Rn1 Rm2 Rn2; sub_lsr Rm1, Rn1, Rm2, Rn2
5434 8.0xf7+8.0xa2+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sub_lsr
5438 int srcreg1, srcreg2, dstreg1, dstreg2;
5442 srcreg1 = translate_rreg (SD_, RM1);
5443 srcreg2 = translate_rreg (SD_, RM2);
5444 dstreg1 = translate_rreg (SD_, RN1);
5445 dstreg2 = translate_rreg (SD_, RN2);
5447 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5448 State.regs[dstreg2] >>= State.regs[srcreg2];
5449 State.regs[dstreg1] = result1;
5452 // 1111 0111 1011 0010 Rm1 Rn1 imm4 Rn2; sub_lsr Rm1, Rn1, imm4, Rn2
5453 8.0xf7+8.0xb2+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sub_lsr
5457 int srcreg1, dstreg1, dstreg2;
5462 srcreg1 = translate_rreg (SD_, RM1);
5463 dstreg1 = translate_rreg (SD_, RN1);
5464 dstreg2 = translate_rreg (SD_, RN2);
5466 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5467 State.regs[dstreg2] >>= IMM4;
5468 State.regs[dstreg1] = result1;
5472 // 1111 0111 1100 0010 Rm1 Rn1 Rm2 Rn2; sub_asl Rm1, Rn1, Rm2, Rn2
5473 8.0xf7+8.0xc2+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sub_asl
5477 int srcreg1, srcreg2, dstreg1, dstreg2;
5481 srcreg1 = translate_rreg (SD_, RM1);
5482 srcreg2 = translate_rreg (SD_, RM2);
5483 dstreg1 = translate_rreg (SD_, RN1);
5484 dstreg2 = translate_rreg (SD_, RN2);
5486 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5487 State.regs[dstreg2] <<= State.regs[srcreg2];
5488 State.regs[dstreg1] = result1;
5491 // 1111 0111 1101 0010 Rm1 Rn1 imm4 Rn2; sub_asl Rm1, Rn1, imm4, Rn2
5492 8.0xf7+8.0xd2+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sub_asl
5496 int srcreg1, dstreg1, dstreg2;
5501 srcreg1 = translate_rreg (SD_, RM1);
5502 dstreg1 = translate_rreg (SD_, RN1);
5503 dstreg2 = translate_rreg (SD_, RN2);
5505 result1 = State.regs[dstreg1] - State.regs[srcreg1];
5506 State.regs[dstreg2] <<= IMM4;
5507 State.regs[dstreg1] = result1;
5510 // 1111 0111 0000 0011 Rm1 Rn1 Rm2 Rn2; mov_add Rm1, Rn1, Rm2, Rn2
5511 8.0xf7+8.0x03+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::mov_add
5515 int srcreg1, srcreg2, dstreg1, dstreg2;
5519 srcreg1 = translate_rreg (SD_, RM1);
5520 srcreg2 = translate_rreg (SD_, RM2);
5521 dstreg1 = translate_rreg (SD_, RN1);
5522 dstreg2 = translate_rreg (SD_, RN2);
5524 result1 = State.regs[srcreg1];
5525 State.regs[dstreg2] += State.regs[srcreg2];
5526 State.regs[dstreg1] = result1;
5529 // 1111 0111 0001 0011 Rm1 Rn1 imm4 Rn2; mov_add Rm1, Rn1, imm4, Rn2
5530 8.0xf7+8.0x13+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::mov_add
5534 int srcreg1, dstreg1, dstreg2;
5538 srcreg1 = translate_rreg (SD_, RM1);
5539 dstreg1 = translate_rreg (SD_, RN1);
5540 dstreg2 = translate_rreg (SD_, RN2);
5542 result1 = State.regs[srcreg1];
5543 State.regs[dstreg2] += EXTEND4 (IMM4);
5544 State.regs[dstreg1] = result1;
5547 // 1111 0111 0010 0011 Rm1 Rn1 Rm2 Rn2; mov_sub Rm1, Rn1, Rm2, Rn2
5548 8.0xf7+8.0x23+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::mov_sub
5552 int srcreg1, srcreg2, dstreg1, dstreg2;
5556 srcreg1 = translate_rreg (SD_, RM1);
5557 srcreg2 = translate_rreg (SD_, RM2);
5558 dstreg1 = translate_rreg (SD_, RN1);
5559 dstreg2 = translate_rreg (SD_, RN2);
5561 result1 = State.regs[srcreg1];
5562 State.regs[dstreg2] -= State.regs[srcreg2];
5563 State.regs[dstreg1] = result1;
5566 // 1111 0111 0011 0011 Rm1 Rn1 imm4 Rn2; mov_sub Rm1, Rn1, imm4, Rn2
5567 8.0xf7+8.0x33+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::mov_sub
5571 int srcreg1, dstreg1, dstreg2;
5575 srcreg1 = translate_rreg (SD_, RM1);
5576 dstreg1 = translate_rreg (SD_, RN1);
5577 dstreg2 = translate_rreg (SD_, RN2);
5579 result1 = State.regs[srcreg1];
5580 State.regs[dstreg2] -= EXTEND4 (IMM4);
5581 State.regs[dstreg1] = result1;
5584 // 1111 0111 0100 0011 Rm1 Rn1 Rm2 Rn2; mov_cmp Rm1, Rn1, Rm2, Rn2
5585 8.0xf7+8.0x43+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::mov_cmp
5589 int srcreg1, srcreg2, dstreg1, dstreg2;
5592 srcreg1 = translate_rreg (SD_, RM1);
5593 srcreg2 = translate_rreg (SD_, RM2);
5594 dstreg1 = translate_rreg (SD_, RN1);
5595 dstreg2 = translate_rreg (SD_, RN2);
5597 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
5598 State.regs[dstreg1] = State.regs[srcreg1];
5601 // 1111 0111 0101 0011 Rm1 Rn1 imm4 Rn2; mov_cmp Rm1, Rn1, imm4, Rn2
5602 8.0xf7+8.0x53+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::mov_cmp
5606 int srcreg1, dstreg1, dstreg2;
5609 srcreg1 = translate_rreg (SD_, RM1);
5610 dstreg1 = translate_rreg (SD_, RN1);
5611 dstreg2 = translate_rreg (SD_, RN2);
5613 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
5614 State.regs[dstreg1] = State.regs[srcreg1];
5617 // 1111 0111 0110 0011 Rm1 Rn1 Rm2 Rn2; mov_mov Rm1, Rn1, Rm2, Rn2
5618 8.0xf7+8.0x63+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::mov_mov
5622 int srcreg1, srcreg2, dstreg1, dstreg2;
5626 srcreg1 = translate_rreg (SD_, RM1);
5627 srcreg2 = translate_rreg (SD_, RM2);
5628 dstreg1 = translate_rreg (SD_, RN1);
5629 dstreg2 = translate_rreg (SD_, RN2);
5631 result1 = State.regs[srcreg1];
5632 State.regs[dstreg2] = State.regs[srcreg2];
5633 State.regs[dstreg1] = result1;
5636 // 1111 0111 0111 0011 Rm1 Rn1 imm4 Rn2; mov_mov Rm1, Rn1, imm4, Rn2
5637 8.0xf7+8.0x73+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::mov_mov
5641 int srcreg1, dstreg1, dstreg2;
5645 srcreg1 = translate_rreg (SD_, RM1);
5646 dstreg1 = translate_rreg (SD_, RN1);
5647 dstreg2 = translate_rreg (SD_, RN2);
5649 result1 = State.regs[srcreg1];
5650 State.regs[dstreg2] = EXTEND4 (IMM4);
5651 State.regs[dstreg1] = result1;
5654 // 1111 0111 1000 0011 Rm1 Rn1 Rm2 Rn2; mov_asr Rm1, Rn1, Rm2, Rn2
5655 8.0xf7+8.0x83+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::mov_asr
5659 int srcreg1, srcreg2, dstreg1, dstreg2;
5664 srcreg1 = translate_rreg (SD_, RM1);
5665 srcreg2 = translate_rreg (SD_, RM2);
5666 dstreg1 = translate_rreg (SD_, RN1);
5667 dstreg2 = translate_rreg (SD_, RN2);
5669 result1 = State.regs[srcreg1];
5670 temp = State.regs[dstreg2];
5671 temp >>= State.regs[srcreg2];
5672 State.regs[dstreg2] = temp;
5673 State.regs[dstreg1] = result1;
5676 // 1111 0111 1001 0011 Rm1 Rn1 imm4 Rn2; mov_asr Rm1, Rn1, imm4, Rn2
5677 8.0xf7+8.0x93+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::mov_asr
5681 int srcreg1, dstreg1, dstreg2;
5686 srcreg1 = translate_rreg (SD_, RM1);
5687 dstreg1 = translate_rreg (SD_, RN1);
5688 dstreg2 = translate_rreg (SD_, RN2);
5690 result1 = State.regs[srcreg1];
5691 temp = State.regs[dstreg2];
5693 State.regs[dstreg2] = temp;
5694 State.regs[dstreg1] = result1;
5697 // 1111 0111 1010 0011 Rm1 Rn1 Rm2 Rn2; mov_lsr Rm1, Rn1, Rm2, Rn2
5698 8.0xf7+8.0xa3+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::mov_lsr
5702 int srcreg1, srcreg2, dstreg1, dstreg2;
5706 srcreg1 = translate_rreg (SD_, RM1);
5707 srcreg2 = translate_rreg (SD_, RM2);
5708 dstreg1 = translate_rreg (SD_, RN1);
5709 dstreg2 = translate_rreg (SD_, RN2);
5711 result1 = State.regs[srcreg1];
5712 State.regs[dstreg2] >>= State.regs[srcreg2];
5713 State.regs[dstreg1] = result1;
5716 // 1111 0111 1011 0011 Rm1 Rn1 imm4 Rn2; mov_lsr Rm1, Rn1, imm4, Rn2
5717 8.0xf7+8.0xb3+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::mov_lsr
5721 int srcreg1, dstreg1, dstreg2;
5726 srcreg1 = translate_rreg (SD_, RM1);
5727 dstreg1 = translate_rreg (SD_, RN1);
5728 dstreg2 = translate_rreg (SD_, RN2);
5730 result1 = State.regs[srcreg1];
5731 State.regs[dstreg2] >>= IMM4;
5732 State.regs[dstreg1] = result1;
5736 // 1111 0111 1100 0011 Rm1 Rn1 Rm2 Rn2; mov_asl Rm1, Rn1, Rm2, Rn2
5737 8.0xf7+8.0xc3+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::mov_asl
5741 int srcreg1, srcreg2, dstreg1, dstreg2;
5745 srcreg1 = translate_rreg (SD_, RM1);
5746 srcreg2 = translate_rreg (SD_, RM2);
5747 dstreg1 = translate_rreg (SD_, RN1);
5748 dstreg2 = translate_rreg (SD_, RN2);
5750 result1 = State.regs[srcreg1];
5751 State.regs[dstreg2] <<= State.regs[srcreg2];
5752 State.regs[dstreg1] = result1;
5755 // 1111 0111 1101 0011 Rm1 Rn1 imm4 Rn2; mov_asl Rm1, Rn1, imm4, Rn2
5756 8.0xf7+8.0xd3+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::mov_asl
5760 int srcreg1, dstreg1, dstreg2;
5765 srcreg1 = translate_rreg (SD_, RM1);
5766 dstreg1 = translate_rreg (SD_, RN1);
5767 dstreg2 = translate_rreg (SD_, RN2);
5769 result1 = State.regs[srcreg1];
5770 State.regs[dstreg2] <<= IMM4;
5771 State.regs[dstreg1] = result1;
5774 // 1111 0111 0000 0100 imm4 Rn1 Rm2 Rn2; add_add imm4, Rn1, Rm2, Rn2
5775 8.0xf7+8.0x04+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::add_add
5779 int srcreg2, dstreg1, dstreg2;
5783 srcreg2 = translate_rreg (SD_, RM2);
5784 dstreg1 = translate_rreg (SD_, RN1);
5785 dstreg2 = translate_rreg (SD_, RN2);
5787 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5788 State.regs[dstreg2] += State.regs[srcreg2];
5789 State.regs[dstreg1] = result1;
5792 // 1111 0111 0001 0100 imm4 Rn1 imm4 Rn2; add_add imm4, Rn1, imm4, Rn2
5793 8.0xf7+8.0x14+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::add_add
5797 int dstreg1, dstreg2;
5801 dstreg1 = translate_rreg (SD_, RN1);
5802 dstreg2 = translate_rreg (SD_, RN2);
5804 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5805 State.regs[dstreg2] += EXTEND4 (IMM4);
5806 State.regs[dstreg1] = result1;
5809 // 1111 0111 0010 0100 imm4 Rn1 Rm2 Rn2; add_sub imm4, Rn1, Rm2, Rn2
5810 8.0xf7+8.0x24+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::add_sub
5814 int srcreg2, dstreg1, dstreg2;
5818 srcreg2 = translate_rreg (SD_, RM2);
5819 dstreg1 = translate_rreg (SD_, RN1);
5820 dstreg2 = translate_rreg (SD_, RN2);
5822 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5823 State.regs[dstreg2] -= State.regs[srcreg2];
5824 State.regs[dstreg1] = result1;
5827 // 1111 0111 0011 0100 imm4 Rn1 imm4 Rn2; add_sub imm4, Rn1, imm4, Rn2
5828 8.0xf7+8.0x34+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::add_sub
5832 int dstreg1, dstreg2;
5836 dstreg1 = translate_rreg (SD_, RN1);
5837 dstreg2 = translate_rreg (SD_, RN2);
5839 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5840 State.regs[dstreg2] -= EXTEND4 (IMM4);
5841 State.regs[dstreg1] = result1;
5844 // 1111 0111 0100 0100 imm4 Rn1 Rm2 Rn2; add_cmp imm4, Rn1, Rm2, Rn2
5845 8.0xf7+8.0x44+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::add_cmp
5849 int srcreg2, dstreg1, dstreg2;
5852 srcreg2 = translate_rreg (SD_, RM2);
5853 dstreg1 = translate_rreg (SD_, RN1);
5854 dstreg2 = translate_rreg (SD_, RN2);
5856 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
5857 State.regs[dstreg1] += EXTEND4 (IMM4A);
5860 // 1111 0111 0101 0100 imm4 Rn1 imm4 Rn2; add_cmp imm4, Rn1, imm4, Rn2
5861 8.0xf7+8.0x54+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::add_cmp
5865 int dstreg1, dstreg2;
5868 dstreg1 = translate_rreg (SD_, RN1);
5869 dstreg2 = translate_rreg (SD_, RN2);
5871 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
5872 State.regs[dstreg1] += EXTEND4 (IMM4A);
5875 // 1111 0111 0110 0100 imm4 Rn1 Rm2 Rn2; add_mov imm4, Rn1, Rm2, Rn2
5876 8.0xf7+8.0x64+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::add_mov
5880 int srcreg2, dstreg1, dstreg2;
5884 srcreg2 = translate_rreg (SD_, RM2);
5885 dstreg1 = translate_rreg (SD_, RN1);
5886 dstreg2 = translate_rreg (SD_, RN2);
5888 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5889 State.regs[dstreg2] = State.regs[srcreg2];
5890 State.regs[dstreg1] = result1;
5893 // 1111 0111 0111 0100 imm4 Rn1 imm4 Rn2; add_mov imm4, Rn1, imm4, Rn2
5894 8.0xf7+8.0x74+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::add_mov
5898 int dstreg1, dstreg2;
5902 dstreg1 = translate_rreg (SD_, RN1);
5903 dstreg2 = translate_rreg (SD_, RN2);
5905 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5906 State.regs[dstreg2] = EXTEND4 (IMM4);
5907 State.regs[dstreg1] = result1;
5910 // 1111 0111 1000 0100 imm4 Rn1 Rm2 Rn2; add_asr imm4, Rn1, Rm2, Rn2
5911 8.0xf7+8.0x84+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::add_asr
5915 int srcreg2, dstreg1, dstreg2;
5920 srcreg2 = translate_rreg (SD_, RM2);
5921 dstreg1 = translate_rreg (SD_, RN1);
5922 dstreg2 = translate_rreg (SD_, RN2);
5924 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5925 temp = State.regs[dstreg2];
5926 temp >>= State.regs[srcreg2];
5927 State.regs[dstreg2] = temp;
5928 State.regs[dstreg1] = result1;
5931 // 1111 0111 1001 0100 imm4 Rn1 imm4 Rn2; add_asr imm4, Rn1, imm4, Rn2
5932 8.0xf7+8.0x94+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::add_asr
5936 int dstreg1, dstreg2;
5941 dstreg1 = translate_rreg (SD_, RN1);
5942 dstreg2 = translate_rreg (SD_, RN2);
5944 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5945 temp = State.regs[dstreg2];
5947 State.regs[dstreg2] = temp;
5948 State.regs[dstreg1] = result1;
5951 // 1111 0111 1010 0100 imm4 Rn1 Rm2 Rn2; add_lsr imm4, Rn1, Rm2, Rn2
5952 8.0xf7+8.0xa4+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::add_lsr
5956 int srcreg2, dstreg1, dstreg2;
5960 srcreg2 = translate_rreg (SD_, RM2);
5961 dstreg1 = translate_rreg (SD_, RN1);
5962 dstreg2 = translate_rreg (SD_, RN2);
5964 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5965 State.regs[dstreg2] >>= State.regs[srcreg2];
5966 State.regs[dstreg1] = result1;
5969 // 1111 0111 1011 0100 imm4 Rn1 imm4 Rn2; add_lsr imm4, Rn1, imm4, Rn2
5970 8.0xf7+8.0xb4+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::add_lsr
5974 int dstreg1, dstreg2;
5979 dstreg1 = translate_rreg (SD_, RN1);
5980 dstreg2 = translate_rreg (SD_, RN2);
5982 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
5983 State.regs[dstreg2] >>= IMM4;
5984 State.regs[dstreg1] = result1;
5988 // 1111 0111 1100 0100 imm4 Rn1 Rm2 Rn2; add_asl imm4, Rn1, Rm2, Rn2
5989 8.0xf7+8.0xc4+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::add_asl
5993 int srcreg2, dstreg1, dstreg2;
5997 srcreg2 = translate_rreg (SD_, RM2);
5998 dstreg1 = translate_rreg (SD_, RN1);
5999 dstreg2 = translate_rreg (SD_, RN2);
6001 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
6002 State.regs[dstreg2] <<= State.regs[srcreg2];
6003 State.regs[dstreg1] = result1;
6006 // 1111 0111 1101 0100 imm4 Rn1 imm4 Rn2; add_asl imm4, Rn1, imm4, Rn2
6007 8.0xf7+8.0xd4+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::add_asl
6011 int dstreg1, dstreg2;
6016 dstreg1 = translate_rreg (SD_, RN1);
6017 dstreg2 = translate_rreg (SD_, RN2);
6019 result1 = State.regs[dstreg1] + EXTEND4 (IMM4A);
6020 State.regs[dstreg2] <<= IMM4;
6021 State.regs[dstreg1] = result1;
6024 // 1111 0111 0000 0101 imm4 Rn1 Rm2 Rn2; cmp_add imm4, Rn1, Rm2, Rn2
6025 8.0xf7+8.0x05+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::cmp_add
6029 int srcreg2, dstreg1, dstreg2;
6032 srcreg2 = translate_rreg (SD_, RM2);
6033 dstreg1 = translate_rreg (SD_, RN1);
6034 dstreg2 = translate_rreg (SD_, RN2);
6036 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6037 State.regs[dstreg2] += State.regs[srcreg2];
6040 // 1111 0111 0001 0101 imm4 Rn1 imm4 Rn2; cmp_add imm4, Rn1, imm4, Rn2
6041 8.0xf7+8.0x15+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::cmp_add
6045 int dstreg1, dstreg2;
6048 dstreg1 = translate_rreg (SD_, RN1);
6049 dstreg2 = translate_rreg (SD_, RN2);
6051 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6052 State.regs[dstreg2] += EXTEND4 (IMM4);
6055 // 1111 0111 0010 0101 imm4 Rn1 Rm2 Rn2; cmp_sub imm4, Rn1, Rm2, Rn2
6056 8.0xf7+8.0x25+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::cmp_sub
6060 int srcreg2, dstreg1, dstreg2;
6063 srcreg2 = translate_rreg (SD_, RM2);
6064 dstreg1 = translate_rreg (SD_, RN1);
6065 dstreg2 = translate_rreg (SD_, RN2);
6067 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6068 State.regs[dstreg2] -= State.regs[srcreg2];
6071 // 1111 0111 0011 0101 imm4 Rn1 imm4 Rn2; cmp_sub imm4, Rn1, imm4, Rn2
6072 8.0xf7+8.0x35+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::cmp_sub
6076 int dstreg1, dstreg2;
6079 dstreg1 = translate_rreg (SD_, RN1);
6080 dstreg2 = translate_rreg (SD_, RN2);
6082 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6083 State.regs[dstreg2] -= EXTEND4 (IMM4);
6086 // 1111 0111 0110 0101 imm4 Rn1 Rm2 Rn2; cmp_mov imm4, Rn1, Rm2, Rn2
6087 8.0xf7+8.0x65+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::cmp_mov
6091 int srcreg2, dstreg1, dstreg2;
6094 srcreg2 = translate_rreg (SD_, RM2);
6095 dstreg1 = translate_rreg (SD_, RN1);
6096 dstreg2 = translate_rreg (SD_, RN2);
6098 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6099 State.regs[dstreg2] = State.regs[srcreg2];
6102 // 1111 0111 0111 0101 imm4 Rn1 imm4 Rn2; cmp_mov imm4, Rn1, imm4, Rn2
6103 8.0xf7+8.0x75+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::cmp_mov
6107 int dstreg1, dstreg2;
6110 dstreg1 = translate_rreg (SD_, RN1);
6111 dstreg2 = translate_rreg (SD_, RN2);
6113 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6114 State.regs[dstreg2] = EXTEND4 (IMM4);
6117 // 1111 0111 1000 0101 imm4 Rn1 Rm2 Rn2; cmp_asr imm4, Rn1, Rm2, Rn2
6118 8.0xf7+8.0x85+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::cmp_asr
6122 int srcreg2, dstreg1, dstreg2;
6126 srcreg2 = translate_rreg (SD_, RM2);
6127 dstreg1 = translate_rreg (SD_, RN1);
6128 dstreg2 = translate_rreg (SD_, RN2);
6130 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6131 temp = State.regs[dstreg2];
6132 temp >>= State.regs[srcreg2];
6133 State.regs[dstreg2] = temp;
6136 // 1111 0111 1001 0101 imm4 Rn1 imm4 Rn2; cmp_asr imm4, Rn1, imm4, Rn2
6137 8.0xf7+8.0x95+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::cmp_asr
6141 int dstreg1, dstreg2;
6145 dstreg1 = translate_rreg (SD_, RN1);
6146 dstreg2 = translate_rreg (SD_, RN2);
6148 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6149 temp = State.regs[dstreg2];
6151 State.regs[dstreg2] = temp;
6154 // 1111 0111 1010 0101 imm4 Rn1 Rm2 Rn2; cmp_lsr imm4, Rn1, Rm2, Rn2
6155 8.0xf7+8.0xa5+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::cmp_lsr
6159 int srcreg2, dstreg1, dstreg2;
6162 srcreg2 = translate_rreg (SD_, RM2);
6163 dstreg1 = translate_rreg (SD_, RN1);
6164 dstreg2 = translate_rreg (SD_, RN2);
6166 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6167 State.regs[dstreg2] >>= State.regs[srcreg2];
6170 // 1111 0111 1011 0101 imm4 Rn1 imm4 Rn2; cmp_lsr imm4, Rn1, imm4, Rn2
6171 8.0xf7+8.0xb5+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::cmp_lsr
6175 int dstreg1, dstreg2;
6179 dstreg1 = translate_rreg (SD_, RN1);
6180 dstreg2 = translate_rreg (SD_, RN2);
6182 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6183 State.regs[dstreg2] >>= IMM4;
6187 // 1111 0111 1100 0101 imm4 Rn1 Rm2 Rn2; cmp_asl imm4, Rn1, Rm2, Rn2
6188 8.0xf7+8.0xc5+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::cmp_asl
6192 int srcreg2, dstreg1, dstreg2;
6195 srcreg2 = translate_rreg (SD_, RM2);
6196 dstreg1 = translate_rreg (SD_, RN1);
6197 dstreg2 = translate_rreg (SD_, RN2);
6199 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6200 State.regs[dstreg2] <<= State.regs[srcreg2];
6203 // 1111 0111 1101 0101 imm4 Rn1 imm4 Rn2; cmp_asl imm4, Rn1, imm4, Rn2
6204 8.0xf7+8.0xd5+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::cmp_asl
6208 int dstreg1, dstreg2;
6212 dstreg1 = translate_rreg (SD_, RN1);
6213 dstreg2 = translate_rreg (SD_, RN2);
6215 genericCmp (EXTEND4 (IMM4A), State.regs[dstreg1]);
6216 State.regs[dstreg2] <<= IMM4;
6219 // 1111 0111 0000 0110 imm4 Rn1 Rm2 Rn2; sub_add imm4, Rn1, Rm2, Rn2
6220 8.0xf7+8.0x06+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::sub_add
6224 int srcreg2, dstreg1, dstreg2;
6228 srcreg2 = translate_rreg (SD_, RM2);
6229 dstreg1 = translate_rreg (SD_, RN1);
6230 dstreg2 = translate_rreg (SD_, RN2);
6232 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6233 State.regs[dstreg2] += State.regs[srcreg2];
6234 State.regs[dstreg1] = result1;
6237 // 1111 0111 0001 0110 imm4 Rn1 imm4 Rn2; sub_add imm4, Rn1, imm4, Rn2
6238 8.0xf7+8.0x16+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::sub_add
6242 int dstreg1, dstreg2;
6246 dstreg1 = translate_rreg (SD_, RN1);
6247 dstreg2 = translate_rreg (SD_, RN2);
6249 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6250 State.regs[dstreg2] += EXTEND4 (IMM4);
6251 State.regs[dstreg1] = result1;
6254 // 1111 0111 0010 0110 imm4 Rn1 Rm2 Rn2; sub_sub imm4, Rn1, Rm2, Rn2
6255 8.0xf7+8.0x26+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::sub_sub
6259 int srcreg2, dstreg1, dstreg2;
6263 srcreg2 = translate_rreg (SD_, RM2);
6264 dstreg1 = translate_rreg (SD_, RN1);
6265 dstreg2 = translate_rreg (SD_, RN2);
6267 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6268 State.regs[dstreg2] -= State.regs[srcreg2];
6269 State.regs[dstreg1] = result1;
6272 // 1111 0111 0011 0110 imm4 Rn1 imm4 Rn2; sub_sub imm4, Rn1, imm4, Rn2
6273 8.0xf7+8.0x36+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::sub_sub
6277 int dstreg1, dstreg2;
6281 dstreg1 = translate_rreg (SD_, RN1);
6282 dstreg2 = translate_rreg (SD_, RN2);
6284 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6285 State.regs[dstreg2] -= EXTEND4 (IMM4);
6286 State.regs[dstreg1] = result1;
6289 // 1111 0111 0100 0110 imm4 Rn1 Rm2 Rn2; sub_cmp imm4, Rn1, Rm2, Rn2
6290 8.0xf7+8.0x46+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::sub_cmp
6294 int srcreg2, dstreg1, dstreg2;
6298 srcreg2 = translate_rreg (SD_, RM2);
6299 dstreg1 = translate_rreg (SD_, RN1);
6300 dstreg2 = translate_rreg (SD_, RN2);
6302 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
6303 State.regs[dstreg1] -= EXTEND4 (IMM4A);
6306 // 1111 0111 0101 0110 imm4 Rn1 imm4 Rn2; sub_cmp imm4, Rn1, imm4, Rn2
6307 8.0xf7+8.0x56+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::sub_cmp
6311 int dstreg1, dstreg2;
6315 dstreg1 = translate_rreg (SD_, RN1);
6316 dstreg2 = translate_rreg (SD_, RN2);
6318 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
6319 State.regs[dstreg1] -= EXTEND4 (IMM4A);
6322 // 1111 0111 0110 0110 imm4 Rn1 Rm2 Rn2; sub_mov imm4, Rn1, Rm2, Rn2
6323 8.0xf7+8.0x66+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::sub_mov
6327 int srcreg2, dstreg1, dstreg2;
6331 srcreg2 = translate_rreg (SD_, RM2);
6332 dstreg1 = translate_rreg (SD_, RN1);
6333 dstreg2 = translate_rreg (SD_, RN2);
6335 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6336 State.regs[dstreg2] = State.regs[srcreg2];
6337 State.regs[dstreg1] = result1;
6340 // 1111 0111 0111 0110 imm4 Rn1 imm4 Rn2; sub_mov imm4, Rn1, imm4, Rn2
6341 8.0xf7+8.0x76+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::sub_mov
6345 int dstreg1, dstreg2;
6349 dstreg1 = translate_rreg (SD_, RN1);
6350 dstreg2 = translate_rreg (SD_, RN2);
6352 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6353 State.regs[dstreg2] = EXTEND4 (IMM4);
6354 State.regs[dstreg1] = result1;
6357 // 1111 0111 1000 0110 imm4 Rn1 Rm2 Rn2; sub_asr imm4, Rn1, Rm2, Rn2
6358 8.0xf7+8.0x86+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::sub_asr
6362 int srcreg2, dstreg1, dstreg2;
6367 srcreg2 = translate_rreg (SD_, RM2);
6368 dstreg1 = translate_rreg (SD_, RN1);
6369 dstreg2 = translate_rreg (SD_, RN2);
6371 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6372 temp = State.regs[dstreg2];
6373 temp >>= State.regs[srcreg2];
6374 State.regs[dstreg2] = temp;
6375 State.regs[dstreg1] = result1;
6378 // 1111 0111 1001 0110 imm4 Rn1 imm4 Rn2; sub_asr imm4, Rn1, imm4, Rn2
6379 8.0xf7+8.0x96+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::sub_asr
6383 int dstreg1, dstreg2;
6388 dstreg1 = translate_rreg (SD_, RN1);
6389 dstreg2 = translate_rreg (SD_, RN2);
6391 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6392 temp = State.regs[dstreg2];
6394 State.regs[dstreg2] = temp;
6395 State.regs[dstreg1] = result1;
6398 // 1111 0111 1010 0110 imm4 Rn1 Rm2 Rn2; sub_lsr imm4, Rn1, Rm2, Rn2
6399 8.0xf7+8.0xa6+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::sub_lsr
6403 int srcreg2, dstreg1, dstreg2;
6407 srcreg2 = translate_rreg (SD_, RM2);
6408 dstreg1 = translate_rreg (SD_, RN1);
6409 dstreg2 = translate_rreg (SD_, RN2);
6411 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6412 State.regs[dstreg2] >>= State.regs[srcreg2];
6413 State.regs[dstreg1] = result1;
6416 // 1111 0111 1011 0110 imm4 Rn1 imm4 Rn2; sub_lsr imm4, Rn1, imm4, Rn2
6417 8.0xf7+8.0xb6+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::sub_lsr
6421 int dstreg1, dstreg2;
6426 dstreg1 = translate_rreg (SD_, RN1);
6427 dstreg2 = translate_rreg (SD_, RN2);
6429 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6430 State.regs[dstreg2] >>= IMM4;
6431 State.regs[dstreg1] = result1;
6435 // 1111 0111 1100 0110 imm4 Rn1 Rm2 Rn2; sub_asl imm4, Rn1, Rm2, Rn2
6436 8.0xf7+8.0xc6+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::sub_asl
6440 int srcreg2, dstreg1, dstreg2;
6444 srcreg2 = translate_rreg (SD_, RM2);
6445 dstreg1 = translate_rreg (SD_, RN1);
6446 dstreg2 = translate_rreg (SD_, RN2);
6448 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6449 State.regs[dstreg2] <<= State.regs[srcreg2];
6450 State.regs[dstreg1] = result1;
6453 // 1111 0111 1101 0110 imm4 Rn1 imm4 Rn2; sub_asl imm4, Rn1, imm4, Rn2
6454 8.0xf7+8.0xd6+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::sub_asl
6458 int dstreg1, dstreg2;
6463 dstreg1 = translate_rreg (SD_, RN1);
6464 dstreg2 = translate_rreg (SD_, RN2);
6466 result1 = State.regs[dstreg1] - EXTEND4 (IMM4A);
6467 State.regs[dstreg2] <<= IMM4;
6468 State.regs[dstreg1] = result1;
6471 // 1111 0111 0000 0111 imm4 Rn1 Rm2 Rn2; mov_add imm4, Rn1, Rm2, Rn2
6472 8.0xf7+8.0x07+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::mov_add
6476 int srcreg2, dstreg1, dstreg2;
6480 srcreg2 = translate_rreg (SD_, RM2);
6481 dstreg1 = translate_rreg (SD_, RN1);
6482 dstreg2 = translate_rreg (SD_, RN2);
6484 result1 = EXTEND4 (IMM4A);
6485 State.regs[dstreg2] += State.regs[srcreg2];
6486 State.regs[dstreg1] = result1;
6489 // 1111 0111 0001 0111 imm4 Rn1 imm4 Rn2; mov_add imm4, Rn1, imm4, Rn2
6490 8.0xf7+8.0x17+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::mov_add
6494 int dstreg1, dstreg2;
6498 dstreg1 = translate_rreg (SD_, RN1);
6499 dstreg2 = translate_rreg (SD_, RN2);
6501 result1 = EXTEND4 (IMM4A);
6502 State.regs[dstreg2] += EXTEND4 (IMM4);
6503 State.regs[dstreg1] = result1;
6506 // 1111 0111 0010 0111 imm4 Rn1 Rm2 Rn2; mov_sub imm4, Rn1, Rm2, Rn2
6507 8.0xf7+8.0x27+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::mov_sub
6511 int srcreg2, dstreg1, dstreg2;
6515 srcreg2 = translate_rreg (SD_, RM2);
6516 dstreg1 = translate_rreg (SD_, RN1);
6517 dstreg2 = translate_rreg (SD_, RN2);
6519 result1 = EXTEND4 (IMM4A);
6520 State.regs[dstreg2] -= State.regs[srcreg2];
6521 State.regs[dstreg1] = result1;
6524 // 1111 0111 0011 0111 imm4 Rn1 imm4 Rn2; mov_sub imm4, Rn1, imm4, Rn2
6525 8.0xf7+8.0x37+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::mov_sub
6529 int dstreg1, dstreg2;
6533 dstreg1 = translate_rreg (SD_, RN1);
6534 dstreg2 = translate_rreg (SD_, RN2);
6536 result1 = EXTEND4 (IMM4A);
6537 State.regs[dstreg2] -= EXTEND4 (IMM4);
6538 State.regs[dstreg1] = result1;
6541 // 1111 0111 0100 0111 imm4 Rn1 Rm2 Rn2; mov_cmp imm4, Rn1, Rm2, Rn2
6542 8.0xf7+8.0x47+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::mov_cmp
6546 int srcreg2, dstreg1, dstreg2;
6549 srcreg2 = translate_rreg (SD_, RM2);
6550 dstreg1 = translate_rreg (SD_, RN1);
6551 dstreg2 = translate_rreg (SD_, RN2);
6553 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
6554 State.regs[dstreg1] = EXTEND4 (IMM4A);
6557 // 1111 0111 0101 0111 imm4 Rn1 imm4 Rn2; mov_cmp imm4, Rn1, imm4, Rn2
6558 8.0xf7+8.0x57+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::mov_cmp
6562 int dstreg1, dstreg2;
6565 dstreg1 = translate_rreg (SD_, RN1);
6566 dstreg2 = translate_rreg (SD_, RN2);
6568 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
6569 State.regs[dstreg1] = EXTEND4 (IMM4A);
6572 // 1111 0111 0110 0111 imm4 Rn1 Rm2 Rn2; mov_mov imm4, Rn1, Rm2, Rn2
6573 8.0xf7+8.0x67+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::mov_mov
6577 int srcreg2, dstreg1, dstreg2;
6581 srcreg2 = translate_rreg (SD_, RM2);
6582 dstreg1 = translate_rreg (SD_, RN1);
6583 dstreg2 = translate_rreg (SD_, RN2);
6585 result1 = EXTEND4 (IMM4A);
6586 State.regs[dstreg2] = State.regs[srcreg2];
6587 State.regs[dstreg1] = result1;
6590 // 1111 0111 0111 0111 imm4 Rn1 imm4 Rn2; mov_mov imm4, Rn1, imm4, Rn2
6591 8.0xf7+8.0x77+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::mov_mov
6595 int dstreg1, dstreg2;
6599 dstreg1 = translate_rreg (SD_, RN1);
6600 dstreg2 = translate_rreg (SD_, RN2);
6602 result1 = EXTEND4 (IMM4A);
6603 State.regs[dstreg2] = EXTEND4 (IMM4);
6604 State.regs[dstreg1] = result1;
6607 // 1111 0111 1000 0111 imm4 Rn1 Rm2 Rn2; mov_asr imm4, Rn1, Rm2, Rn2
6608 8.0xf7+8.0x87+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::mov_asr
6612 int srcreg2, dstreg1, dstreg2;
6617 srcreg2 = translate_rreg (SD_, RM2);
6618 dstreg1 = translate_rreg (SD_, RN1);
6619 dstreg2 = translate_rreg (SD_, RN2);
6621 result1 = EXTEND4 (IMM4A);
6622 temp = State.regs[dstreg2];
6623 temp >>= State.regs[srcreg2];
6624 State.regs[dstreg2] = temp;
6625 State.regs[dstreg1] = result1;
6628 // 1111 0111 1001 0111 imm4 Rn1 imm4 Rn2; mov_asr imm4, Rn1, imm4, Rn2
6629 8.0xf7+8.0x97+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::mov_asr
6633 int dstreg1, dstreg2;
6638 dstreg1 = translate_rreg (SD_, RN1);
6639 dstreg2 = translate_rreg (SD_, RN2);
6641 result1 = EXTEND4 (IMM4A);
6642 temp = State.regs[dstreg2];
6644 State.regs[dstreg2] = temp;
6645 State.regs[dstreg1] = result1;
6648 // 1111 0111 1010 0111 imm4 Rn1 Rm2 Rn2; mov_lsr imm4, Rn1, Rm2, Rn2
6649 8.0xf7+8.0xa7+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::mov_lsr
6653 int srcreg2, dstreg1, dstreg2;
6657 srcreg2 = translate_rreg (SD_, RM2);
6658 dstreg1 = translate_rreg (SD_, RN1);
6659 dstreg2 = translate_rreg (SD_, RN2);
6661 result1 = EXTEND4 (IMM4A);
6662 State.regs[dstreg2] >>= State.regs[srcreg2];
6663 State.regs[dstreg1] = result1;
6666 // 1111 0111 1011 0111 imm4 Rn1 imm4 Rn2; mov_lsr imm4, Rn1, imm4, Rn2
6667 8.0xf7+8.0xb7+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::mov_lsr
6671 int dstreg1, dstreg2;
6676 dstreg1 = translate_rreg (SD_, RN1);
6677 dstreg2 = translate_rreg (SD_, RN2);
6679 result1 = EXTEND4 (IMM4A);
6680 State.regs[dstreg2] >>= IMM4;
6681 State.regs[dstreg1] = result1;
6685 // 1111 0111 1100 0111 imm4 Rn1 Rm2 Rn2; mov_asl imm4, Rn1, Rm2, Rn2
6686 8.0xf7+8.0xc7+4.IMM4A,4.RN1+4.RM2,4.RN2!RN1:D2c:::mov_asl
6690 int srcreg2, dstreg1, dstreg2;
6694 srcreg2 = translate_rreg (SD_, RM2);
6695 dstreg1 = translate_rreg (SD_, RN1);
6696 dstreg2 = translate_rreg (SD_, RN2);
6698 result1 = EXTEND4 (IMM4A);
6699 State.regs[dstreg2] <<= State.regs[srcreg2];
6700 State.regs[dstreg1] = result1;
6703 // 1111 0111 1101 0111 imm4 Rn1 imm4 Rn2; mov_asl imm4, Rn1, imm4, Rn2
6704 8.0xf7+8.0xd7+4.IMM4A,4.RN1+4.IMM4,4.RN2!RN1:D2d:::mov_asl
6708 int dstreg1, dstreg2;
6713 dstreg1 = translate_rreg (SD_, RN1);
6714 dstreg2 = translate_rreg (SD_, RN2);
6716 result1 = EXTEND4 (IMM4A);
6717 State.regs[dstreg2] <<= IMM4;
6718 State.regs[dstreg1] = result1;
6721 // 1111 0111 0000 1000 Rm1 Rn1 Rm2 Rn2; and_add Rm1, Rn1, Rm2, Rn2
6722 8.0xf7+8.0x08+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::and_add
6726 int srcreg1, srcreg2, dstreg1, dstreg2;
6730 srcreg1 = translate_rreg (SD_, RM1);
6731 srcreg2 = translate_rreg (SD_, RM2);
6732 dstreg1 = translate_rreg (SD_, RN1);
6733 dstreg2 = translate_rreg (SD_, RN2);
6735 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6736 State.regs[dstreg2] += State.regs[srcreg2];
6737 State.regs[dstreg1] = result1;
6740 // 1111 0111 0001 1000 Rm1 Rn1 imm4 Rn2; and_add Rm1, Rn1, imm4, Rn2
6741 8.0xf7+8.0x18+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::and_add
6745 int srcreg1, dstreg1, dstreg2;
6749 srcreg1 = translate_rreg (SD_, RM1);
6750 dstreg1 = translate_rreg (SD_, RN1);
6751 dstreg2 = translate_rreg (SD_, RN2);
6753 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6754 State.regs[dstreg2] += EXTEND4 (IMM4);
6755 State.regs[dstreg1] = result1;
6758 // 1111 0111 0010 1000 Rm1 Rn1 Rm2 Rn2; and_sub Rm1, Rn1, Rm2, Rn2
6759 8.0xf7+8.0x28+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::and_sub
6763 int srcreg1, srcreg2, dstreg1, dstreg2;
6767 srcreg1 = translate_rreg (SD_, RM1);
6768 srcreg2 = translate_rreg (SD_, RM2);
6769 dstreg1 = translate_rreg (SD_, RN1);
6770 dstreg2 = translate_rreg (SD_, RN2);
6772 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6773 State.regs[dstreg2] -= State.regs[srcreg2];
6774 State.regs[dstreg1] = result1;
6777 // 1111 0111 0011 1000 Rm1 Rn1 imm4 Rn2; and_sub Rm1, Rn1, imm4, Rn2
6778 8.0xf7+8.0x38+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::and_sub
6782 int srcreg1, dstreg1, dstreg2;
6786 srcreg1 = translate_rreg (SD_, RM1);
6787 dstreg1 = translate_rreg (SD_, RN1);
6788 dstreg2 = translate_rreg (SD_, RN2);
6790 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6791 State.regs[dstreg2] -= EXTEND4 (IMM4);
6792 State.regs[dstreg1] = result1;
6795 // 1111 0111 0100 1000 Rm1 Rn1 Rm2 Rn2; and_cmp Rm1, Rn1, Rm2, Rn2
6796 8.0xf7+8.0x48+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::and_cmp
6800 int srcreg1, srcreg2, dstreg1, dstreg2;
6803 srcreg1 = translate_rreg (SD_, RM1);
6804 srcreg2 = translate_rreg (SD_, RM2);
6805 dstreg1 = translate_rreg (SD_, RN1);
6806 dstreg2 = translate_rreg (SD_, RN2);
6808 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
6809 State.regs[dstreg1] &= State.regs[srcreg1];
6812 // 1111 0111 0101 1000 Rm1 Rn1 imm4 Rn2; and_cmp Rm1, Rn1, imm4, Rn2
6813 8.0xf7+8.0x58+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::and_cmp
6817 int srcreg1, dstreg1, dstreg2;
6820 srcreg1 = translate_rreg (SD_, RM1);
6821 dstreg1 = translate_rreg (SD_, RN1);
6822 dstreg2 = translate_rreg (SD_, RN2);
6824 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
6825 State.regs[dstreg1] &= State.regs[srcreg1];
6828 // 1111 0111 0110 1000 Rm1 Rn1 Rm2 Rn2; and_mov Rm1, Rn1, Rm2, Rn2
6829 8.0xf7+8.0x68+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::and_mov
6833 int srcreg1, srcreg2, dstreg1, dstreg2;
6837 srcreg1 = translate_rreg (SD_, RM1);
6838 srcreg2 = translate_rreg (SD_, RM2);
6839 dstreg1 = translate_rreg (SD_, RN1);
6840 dstreg2 = translate_rreg (SD_, RN2);
6842 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6843 State.regs[dstreg2] = State.regs[srcreg2];
6844 State.regs[dstreg1] = result1;
6847 // 1111 0111 0111 1000 Rm1 Rn1 imm4 Rn2; and_mov Rm1, Rn1, imm4, Rn2
6848 8.0xf7+8.0x78+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::and_mov
6852 int srcreg1, dstreg1, dstreg2;
6856 srcreg1 = translate_rreg (SD_, RM1);
6857 dstreg1 = translate_rreg (SD_, RN1);
6858 dstreg2 = translate_rreg (SD_, RN2);
6860 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6861 State.regs[dstreg2] = EXTEND4 (IMM4);
6862 State.regs[dstreg1] = result1;
6865 // 1111 0111 1000 1000 Rm1 Rn1 Rm2 Rn2; and_asr Rm1, Rn1, Rm2, Rn2
6866 8.0xf7+8.0x88+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::and_asr
6870 int srcreg1, srcreg2, dstreg1, dstreg2;
6875 srcreg1 = translate_rreg (SD_, RM1);
6876 srcreg2 = translate_rreg (SD_, RM2);
6877 dstreg1 = translate_rreg (SD_, RN1);
6878 dstreg2 = translate_rreg (SD_, RN2);
6880 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6881 temp = State.regs[dstreg2];
6882 temp >>= State.regs[srcreg2];
6883 State.regs[dstreg2] = temp;
6884 State.regs[dstreg1] = result1;
6887 // 1111 0111 1001 1000 Rm1 Rn1 imm4 Rn2; and_asr Rm1, Rn1, imm4, Rn2
6888 8.0xf7+8.0x98+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::and_asr
6892 int srcreg1, dstreg1, dstreg2;
6897 srcreg1 = translate_rreg (SD_, RM1);
6898 dstreg1 = translate_rreg (SD_, RN1);
6899 dstreg2 = translate_rreg (SD_, RN2);
6901 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6902 temp = State.regs[dstreg2];
6904 State.regs[dstreg2] = temp;
6905 State.regs[dstreg1] = result1;
6908 // 1111 0111 1010 1000 Rm1 Rn1 Rm2 Rn2; and_lsr Rm1, Rn1, Rm2, Rn2
6909 8.0xf7+8.0xa8+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::and_lsr
6913 int srcreg1, srcreg2, dstreg1, dstreg2;
6917 srcreg1 = translate_rreg (SD_, RM1);
6918 srcreg2 = translate_rreg (SD_, RM2);
6919 dstreg1 = translate_rreg (SD_, RN1);
6920 dstreg2 = translate_rreg (SD_, RN2);
6922 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6923 State.regs[dstreg2] >>= State.regs[srcreg2];
6924 State.regs[dstreg1] = result1;
6927 // 1111 0111 1011 1000 Rm1 Rn1 imm4 Rn2; and_lsr Rm1, Rn1, imm4, Rn2
6928 8.0xf7+8.0xb8+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::and_lsr
6932 int srcreg1, dstreg1, dstreg2;
6937 srcreg1 = translate_rreg (SD_, RM1);
6938 dstreg1 = translate_rreg (SD_, RN1);
6939 dstreg2 = translate_rreg (SD_, RN2);
6941 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6942 State.regs[dstreg2] >>= IMM4;
6943 State.regs[dstreg1] = result1;
6947 // 1111 0111 1100 1000 Rm1 Rn1 Rm2 Rn2; and_asl Rm1, Rn1, Rm2, Rn2
6948 8.0xf7+8.0xc8+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::and_asl
6952 int srcreg1, srcreg2, dstreg1, dstreg2;
6956 srcreg1 = translate_rreg (SD_, RM1);
6957 srcreg2 = translate_rreg (SD_, RM2);
6958 dstreg1 = translate_rreg (SD_, RN1);
6959 dstreg2 = translate_rreg (SD_, RN2);
6961 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6962 State.regs[dstreg2] <<= State.regs[srcreg2];
6963 State.regs[dstreg1] = result1;
6966 // 1111 0111 1101 1000 Rm1 Rn1 imm4 Rn2; and_asl Rm1, Rn1, imm4, Rn2
6967 8.0xf7+8.0xd8+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::and_asl
6971 int srcreg1, dstreg1, dstreg2;
6976 srcreg1 = translate_rreg (SD_, RM1);
6977 dstreg1 = translate_rreg (SD_, RN1);
6978 dstreg2 = translate_rreg (SD_, RN2);
6980 result1 = State.regs[dstreg1] & State.regs[srcreg1];
6981 State.regs[dstreg2] <<= IMM4;
6982 State.regs[dstreg1] = result1;
6985 // 1111 0111 0000 1001 Rm1 Rn1 Rm2 Rn2; dmach_add Rm1, Rn1, Rm2, Rn2
6986 8.0xf7+8.0x09+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::dmach_add
6990 int srcreg1, srcreg2, dstreg1, dstreg2;
6991 long temp, temp2, sum;
6994 srcreg1 = translate_rreg (SD_, RM1);
6995 srcreg2 = translate_rreg (SD_, RM2);
6996 dstreg1 = translate_rreg (SD_, RN1);
6997 dstreg2 = translate_rreg (SD_, RN2);
6999 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7000 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7001 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7002 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7003 sum = temp + temp2 + State.regs[REG_MCRL];
7005 State.regs[dstreg2] += State.regs[srcreg2];
7006 State.regs[dstreg1] = sum;
7009 // 1111 0111 0001 1001 Rm1 Rn1 imm4 Rn2; dmach_add Rm1, Rn1, imm4, Rn2
7010 8.0xf7+8.0x19+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::dmach_add
7014 int srcreg1, dstreg1, dstreg2;
7015 long temp, temp2, sum;
7018 srcreg1 = translate_rreg (SD_, RM1);
7019 dstreg1 = translate_rreg (SD_, RN1);
7020 dstreg2 = translate_rreg (SD_, RN2);
7022 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7023 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7024 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7025 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7026 sum = temp + temp2 + State.regs[REG_MCRL];
7028 State.regs[dstreg2] += EXTEND4 (IMM4);
7029 State.regs[dstreg1] = sum;
7032 // 1111 0111 0010 1001 Rm1 Rn1 Rm2 Rn2; dmach_sub Rm1, Rn1, Rm2, Rn2
7033 8.0xf7+8.0x29+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::dmach_sub
7037 int srcreg1, srcreg2, dstreg1, dstreg2;
7038 long temp, temp2, sum;
7041 srcreg1 = translate_rreg (SD_, RM1);
7042 srcreg2 = translate_rreg (SD_, RM2);
7043 dstreg1 = translate_rreg (SD_, RN1);
7044 dstreg2 = translate_rreg (SD_, RN2);
7046 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7047 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7048 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7049 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7050 sum = temp + temp2 + State.regs[REG_MCRL];
7052 State.regs[dstreg2] -= State.regs[srcreg2];
7053 State.regs[dstreg1] = sum;
7056 // 1111 0111 0011 1001 Rm1 Rn1 imm4 Rn2; dmach_sub Rm1, Rn1, imm4, Rn2
7057 8.0xf7+8.0x39+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::dmach_sub
7061 int srcreg1, dstreg1, dstreg2;
7062 long temp, temp2, sum;
7065 srcreg1 = translate_rreg (SD_, RM1);
7066 dstreg1 = translate_rreg (SD_, RN1);
7067 dstreg2 = translate_rreg (SD_, RN2);
7069 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7070 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7071 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7072 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7073 sum = temp + temp2 + State.regs[REG_MCRL];
7075 State.regs[dstreg2] -= EXTEND4 (IMM4);
7076 State.regs[dstreg1] = sum;
7079 // 1111 0111 0100 1001 Rm1 Rn1 Rm2 Rn2; dmach_cmp Rm1, Rn1, Rm2, Rn2
7080 8.0xf7+8.0x49+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::dmach_cmp
7084 int srcreg1, srcreg2, dstreg1, dstreg2;
7085 long temp, temp2, sum;
7088 srcreg1 = translate_rreg (SD_, RM1);
7089 srcreg2 = translate_rreg (SD_, RM2);
7090 dstreg1 = translate_rreg (SD_, RN1);
7091 dstreg2 = translate_rreg (SD_, RN2);
7093 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7094 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7095 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7096 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7097 sum = temp + temp2 + State.regs[REG_MCRL];
7099 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
7100 State.regs[dstreg1] = sum;
7103 // 1111 0111 0101 1001 Rm1 Rn1 imm4 Rn2; dmach_cmp Rm1, Rn1, imm4, Rn2
7104 8.0xf7+8.0x59+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::dmach_cmp
7108 int srcreg1, dstreg1, dstreg2;
7109 long temp, temp2, sum;
7112 srcreg1 = translate_rreg (SD_, RM1);
7113 dstreg1 = translate_rreg (SD_, RN1);
7114 dstreg2 = translate_rreg (SD_, RN2);
7116 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7117 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7118 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7119 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7120 sum = temp + temp2 + State.regs[REG_MCRL];
7122 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
7123 State.regs[dstreg1] = sum;
7126 // 1111 0111 0110 1001 Rm1 Rn1 Rm2 Rn2; dmach_mov Rm1, Rn1, Rm2, Rn2
7127 8.0xf7+8.0x69+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::dmach_mov
7131 int srcreg1, srcreg2, dstreg1, dstreg2;
7132 long temp, temp2, sum;
7135 srcreg1 = translate_rreg (SD_, RM1);
7136 srcreg2 = translate_rreg (SD_, RM2);
7137 dstreg1 = translate_rreg (SD_, RN1);
7138 dstreg2 = translate_rreg (SD_, RN2);
7140 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7141 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7142 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7143 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7144 sum = temp + temp2 + State.regs[REG_MCRL];
7146 State.regs[dstreg2] = State.regs[srcreg2];
7147 State.regs[dstreg1] = sum;
7150 // 1111 0111 0111 1001 Rm1 Rn1 imm4 Rn2; dmach_mov Rm1, Rn1, imm4, Rn2
7151 8.0xf7+8.0x79+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::dmach_mov
7155 int srcreg1, dstreg1, dstreg2;
7156 long temp, temp2, sum;
7159 srcreg1 = translate_rreg (SD_, RM1);
7160 dstreg1 = translate_rreg (SD_, RN1);
7161 dstreg2 = translate_rreg (SD_, RN2);
7163 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7164 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7165 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7166 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7167 sum = temp + temp2 + State.regs[REG_MCRL];
7169 State.regs[dstreg2] = EXTEND4 (IMM4);
7170 State.regs[dstreg1] = sum;
7173 // 1111 0111 1000 1001 Rm1 Rn1 Rm2 Rn2; dmach_asr Rm1, Rn1, Rm2, Rn2
7174 8.0xf7+8.0x89+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::dmach_asr
7178 int srcreg1, srcreg2, dstreg1, dstreg2;
7179 long temp, temp2, sum;
7182 srcreg1 = translate_rreg (SD_, RM1);
7183 srcreg2 = translate_rreg (SD_, RM2);
7184 dstreg1 = translate_rreg (SD_, RN1);
7185 dstreg2 = translate_rreg (SD_, RN2);
7187 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7188 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7189 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7190 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7191 sum = temp + temp2 + State.regs[REG_MCRL];
7193 temp = State.regs[dstreg2];
7194 temp >>= State.regs[srcreg2];
7195 State.regs[dstreg2] = temp;
7196 State.regs[dstreg1] = sum;
7199 // 1111 0111 1001 1001 Rm1 Rn1 imm4 Rn2; dmach_asr Rm1, Rn1, imm4, Rn2
7200 8.0xf7+8.0x99+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::dmach_asr
7204 int srcreg1, dstreg1, dstreg2;
7205 long temp, temp2, sum;
7208 srcreg1 = translate_rreg (SD_, RM1);
7209 dstreg1 = translate_rreg (SD_, RN1);
7210 dstreg2 = translate_rreg (SD_, RN2);
7212 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7213 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7214 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7215 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7216 sum = temp + temp2 + State.regs[REG_MCRL];
7218 temp = State.regs[dstreg2];
7220 State.regs[dstreg2] = temp;
7221 State.regs[dstreg1] = sum;
7224 // 1111 0111 1010 1001 Rm1 Rn1 Rm2 Rn2; dmach_lsr Rm1, Rn1, Rm2, Rn2
7225 8.0xf7+8.0xa9+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::dmach_lsr
7229 int srcreg1, srcreg2, dstreg1, dstreg2;
7230 long temp, temp2, sum;
7233 srcreg1 = translate_rreg (SD_, RM1);
7234 srcreg2 = translate_rreg (SD_, RM2);
7235 dstreg1 = translate_rreg (SD_, RN1);
7236 dstreg2 = translate_rreg (SD_, RN2);
7238 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7239 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7240 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7241 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7242 sum = temp + temp2 + State.regs[REG_MCRL];
7244 State.regs[dstreg2] >>= State.regs[srcreg2];
7245 State.regs[dstreg1] = sum;
7248 // 1111 0111 1011 1001 Rm1 Rn1 imm4 Rn2; dmach_lsr Rm1, Rn1, imm4, Rn2
7249 8.0xf7+8.0xb9+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::dmach_lsr
7253 int srcreg1, dstreg1, dstreg2;
7254 long temp, temp2, sum;
7257 srcreg1 = translate_rreg (SD_, RM1);
7258 dstreg1 = translate_rreg (SD_, RN1);
7259 dstreg2 = translate_rreg (SD_, RN2);
7261 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7262 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7263 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7264 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7265 sum = temp + temp2 + State.regs[REG_MCRL];
7267 State.regs[dstreg2] >>= IMM4;
7268 State.regs[dstreg1] = sum;
7272 // 1111 0111 1100 1001 Rm1 Rn1 Rm2 Rn2; dmach_asl Rm1, Rn1, Rm2, Rn2
7273 8.0xf7+8.0xc9+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::dmach_asl
7277 int srcreg1, srcreg2, dstreg1, dstreg2;
7278 long temp, temp2, sum;
7281 srcreg1 = translate_rreg (SD_, RM1);
7282 srcreg2 = translate_rreg (SD_, RM2);
7283 dstreg1 = translate_rreg (SD_, RN1);
7284 dstreg2 = translate_rreg (SD_, RN2);
7286 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7287 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7288 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7289 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7290 sum = temp + temp2 + State.regs[REG_MCRL];
7292 State.regs[dstreg2] <<= State.regs[srcreg2];
7293 State.regs[dstreg1] = sum;
7296 // 1111 0111 1101 1001 Rm1 Rn1 imm4 Rn2; dmach_asl Rm1, Rn1, imm4, Rn2
7297 8.0xf7+8.0xd9+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::dmach_asl
7301 int srcreg1, dstreg1, dstreg2;
7302 long temp, temp2, sum;
7305 srcreg1 = translate_rreg (SD_, RM1);
7306 dstreg1 = translate_rreg (SD_, RN1);
7307 dstreg2 = translate_rreg (SD_, RN2);
7309 temp = ((signed32)(signed16)(State.regs[dstreg1] & 0xffff)
7310 * (signed32)(signed16)(State.regs[srcreg1] & 0xffff));
7311 temp2 = ((signed32)(signed16)((State.regs[srcreg1] >> 16) & 0xffff)
7312 * (signed32)(signed16)((State.regs[dstreg1] >> 16) & 0xffff));
7313 sum = temp + temp2 + State.regs[REG_MCRL];
7315 State.regs[dstreg2] <<= IMM4;
7316 State.regs[dstreg1] = sum;
7319 // 1111 0111 0000 1010 Rm1 Rn1 Rm2 Rn2; xor_add Rm1, Rn1, Rm2, Rn2
7320 8.0xf7+8.0x0a+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::xor_add
7324 int srcreg1, srcreg2, dstreg1, dstreg2;
7328 srcreg1 = translate_rreg (SD_, RM1);
7329 srcreg2 = translate_rreg (SD_, RM2);
7330 dstreg1 = translate_rreg (SD_, RN1);
7331 dstreg2 = translate_rreg (SD_, RN2);
7333 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7334 State.regs[dstreg2] += State.regs[srcreg2];
7335 State.regs[dstreg1] = result1;
7338 // 1111 0111 0001 1010 Rm1 Rn1 imm4 Rn2; xor_add Rm1, Rn1, imm4, Rn2
7339 8.0xf7+8.0x1a+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::xor_add
7343 int srcreg1, dstreg1, dstreg2;
7347 srcreg1 = translate_rreg (SD_, RM1);
7348 dstreg1 = translate_rreg (SD_, RN1);
7349 dstreg2 = translate_rreg (SD_, RN2);
7351 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7352 State.regs[dstreg2] += EXTEND4 (IMM4);
7353 State.regs[dstreg1] = result1;
7356 // 1111 0111 0010 1010 Rm1 Rn1 Rm2 Rn2; xor_sub Rm1, Rn1, Rm2, Rn2
7357 8.0xf7+8.0x2a+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::xor_sub
7361 int srcreg1, srcreg2, dstreg1, dstreg2;
7365 srcreg1 = translate_rreg (SD_, RM1);
7366 srcreg2 = translate_rreg (SD_, RM2);
7367 dstreg1 = translate_rreg (SD_, RN1);
7368 dstreg2 = translate_rreg (SD_, RN2);
7370 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7371 State.regs[dstreg2] -= State.regs[srcreg2];
7372 State.regs[dstreg1] = result1;
7375 // 1111 0111 0011 1010 Rm1 Rn1 imm4 Rn2; xor_sub Rm1, Rn1, imm4, Rn2
7376 8.0xf7+8.0x3a+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::xor_sub
7380 int srcreg1, dstreg1, dstreg2;
7384 srcreg1 = translate_rreg (SD_, RM1);
7385 dstreg1 = translate_rreg (SD_, RN1);
7386 dstreg2 = translate_rreg (SD_, RN2);
7388 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7389 State.regs[dstreg2] -= EXTEND4 (IMM4);
7390 State.regs[dstreg1] = result1;
7393 // 1111 0111 0100 1010 Rm1 Rn1 Rm2 Rn2; xor_cmp Rm1, Rn1, Rm2, Rn2
7394 8.0xf7+8.0x4a+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::xor_cmp
7398 int srcreg1, srcreg2, dstreg1, dstreg2;
7401 srcreg1 = translate_rreg (SD_, RM1);
7402 srcreg2 = translate_rreg (SD_, RM2);
7403 dstreg1 = translate_rreg (SD_, RN1);
7404 dstreg2 = translate_rreg (SD_, RN2);
7406 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
7407 State.regs[dstreg1] ^= State.regs[srcreg1];
7410 // 1111 0111 0101 1010 Rm1 Rn1 imm4 Rn2; xor_cmp Rm1, Rn1, imm4, Rn2
7411 8.0xf7+8.0x5a+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::xor_cmp
7415 int srcreg1, dstreg1, dstreg2;
7418 srcreg1 = translate_rreg (SD_, RM1);
7419 dstreg1 = translate_rreg (SD_, RN1);
7420 dstreg2 = translate_rreg (SD_, RN2);
7422 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
7423 State.regs[dstreg1] ^= State.regs[srcreg1];
7426 // 1111 0111 0110 1010 Rm1 Rn1 Rm2 Rn2; xor_mov Rm1, Rn1, Rm2, Rn2
7427 8.0xf7+8.0x6a+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::xor_mov
7431 int srcreg1, srcreg2, dstreg1, dstreg2;
7435 srcreg1 = translate_rreg (SD_, RM1);
7436 srcreg2 = translate_rreg (SD_, RM2);
7437 dstreg1 = translate_rreg (SD_, RN1);
7438 dstreg2 = translate_rreg (SD_, RN2);
7440 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7441 State.regs[dstreg2] = State.regs[srcreg2];
7442 State.regs[dstreg1] = result1;
7445 // 1111 0111 0111 1010 Rm1 Rn1 imm4 Rn2; xor_mov Rm1, Rn1, imm4, Rn2
7446 8.0xf7+8.0x7a+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::xor_mov
7450 int srcreg1, dstreg1, dstreg2;
7454 srcreg1 = translate_rreg (SD_, RM1);
7455 dstreg1 = translate_rreg (SD_, RN1);
7456 dstreg2 = translate_rreg (SD_, RN2);
7458 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7459 State.regs[dstreg2] = EXTEND4 (IMM4);
7460 State.regs[dstreg1] = result1;
7463 // 1111 0111 1000 1010 Rm1 Rn1 Rm2 Rn2; xor_asr Rm1, Rn1, Rm2, Rn2
7464 8.0xf7+8.0x8a+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::xor_asr
7468 int srcreg1, srcreg2, dstreg1, dstreg2;
7473 srcreg1 = translate_rreg (SD_, RM1);
7474 srcreg2 = translate_rreg (SD_, RM2);
7475 dstreg1 = translate_rreg (SD_, RN1);
7476 dstreg2 = translate_rreg (SD_, RN2);
7478 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7479 temp = State.regs[dstreg2];
7480 temp >>= State.regs[srcreg2];
7481 State.regs[dstreg2] = temp;
7482 State.regs[dstreg1] = result1;
7485 // 1111 0111 1001 1010 Rm1 Rn1 imm4 Rn2; xor_asr Rm1, Rn1, imm4, Rn2
7486 8.0xf7+8.0x9a+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::xor_asr
7490 int srcreg1, dstreg1, dstreg2;
7495 srcreg1 = translate_rreg (SD_, RM1);
7496 dstreg1 = translate_rreg (SD_, RN1);
7497 dstreg2 = translate_rreg (SD_, RN2);
7499 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7500 temp = State.regs[dstreg2];
7502 State.regs[dstreg2] = temp;
7503 State.regs[dstreg1] = result1;
7506 // 1111 0111 1010 1010 Rm1 Rn1 Rm2 Rn2; xor_lsr Rm1, Rn1, Rm2, Rn2
7507 8.0xf7+8.0xaa+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::xor_lsr
7511 int srcreg1, srcreg2, dstreg1, dstreg2;
7515 srcreg1 = translate_rreg (SD_, RM1);
7516 srcreg2 = translate_rreg (SD_, RM2);
7517 dstreg1 = translate_rreg (SD_, RN1);
7518 dstreg2 = translate_rreg (SD_, RN2);
7520 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7521 State.regs[dstreg2] >>= State.regs[srcreg2];
7522 State.regs[dstreg1] = result1;
7525 // 1111 0111 1011 1010 Rm1 Rn1 imm4 Rn2; xor_lsr Rm1, Rn1, imm4, Rn2
7526 8.0xf7+8.0xba+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::xor_lsr
7530 int srcreg1, dstreg1, dstreg2;
7535 srcreg1 = translate_rreg (SD_, RM1);
7536 dstreg1 = translate_rreg (SD_, RN1);
7537 dstreg2 = translate_rreg (SD_, RN2);
7539 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7540 State.regs[dstreg2] >>= IMM4;
7541 State.regs[dstreg1] = result1;
7545 // 1111 0111 1100 1010 Rm1 Rn1 Rm2 Rn2; xor_asl Rm1, Rn1, Rm2, Rn2
7546 8.0xf7+8.0xca+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::xor_asl
7550 int srcreg1, srcreg2, dstreg1, dstreg2;
7554 srcreg1 = translate_rreg (SD_, RM1);
7555 srcreg2 = translate_rreg (SD_, RM2);
7556 dstreg1 = translate_rreg (SD_, RN1);
7557 dstreg2 = translate_rreg (SD_, RN2);
7559 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7560 State.regs[dstreg2] <<= State.regs[srcreg2];
7561 State.regs[dstreg1] = result1;
7564 // 1111 0111 1101 1010 Rm1 Rn1 imm4 Rn2; xor_asl Rm1, Rn1, imm4, Rn2
7565 8.0xf7+8.0xda+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::xor_asl
7569 int srcreg1, dstreg1, dstreg2;
7574 srcreg1 = translate_rreg (SD_, RM1);
7575 dstreg1 = translate_rreg (SD_, RN1);
7576 dstreg2 = translate_rreg (SD_, RN2);
7578 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7579 State.regs[dstreg2] <<= IMM4;
7580 State.regs[dstreg1] = result1;
7583 // 1111 0111 0000 1011 Rm1 Rn1 Rm2 Rn2; swhw_add Rm1, Rn1, Rm2, Rn2
7584 8.0xf7+8.0x0b+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::swhw_add
7588 int srcreg1, srcreg2, dstreg1, dstreg2;
7592 srcreg1 = translate_rreg (SD_, RM1);
7593 srcreg2 = translate_rreg (SD_, RM2);
7594 dstreg1 = translate_rreg (SD_, RN1);
7595 dstreg2 = translate_rreg (SD_, RN2);
7597 result1 = State.regs[dstreg1] ^ State.regs[srcreg1];
7598 State.regs[dstreg2] += State.regs[srcreg2];
7599 State.regs[dstreg1] = result1;
7602 // 1111 0111 0001 1011 Rm1 Rn1 imm4 Rn2; swhw_add Rm1, Rn1, imm4, Rn2
7603 8.0xf7+8.0x1b+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::swhw_add
7607 int srcreg1, dstreg1, dstreg2;
7611 srcreg1 = translate_rreg (SD_, RM1);
7612 dstreg1 = translate_rreg (SD_, RN1);
7613 dstreg2 = translate_rreg (SD_, RN2);
7615 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7616 | ((State.regs[srcreg1] >> 16) & 0xffff));
7617 State.regs[dstreg2] += EXTEND4 (IMM4);
7618 State.regs[dstreg1] = result1;
7621 // 1111 0111 0010 1011 Rm1 Rn1 Rm2 Rn2; swhw_sub Rm1, Rn1, Rm2, Rn2
7622 8.0xf7+8.0x2b+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::swhw_sub
7626 int srcreg1, srcreg2, dstreg1, dstreg2;
7630 srcreg1 = translate_rreg (SD_, RM1);
7631 srcreg2 = translate_rreg (SD_, RM2);
7632 dstreg1 = translate_rreg (SD_, RN1);
7633 dstreg2 = translate_rreg (SD_, RN2);
7635 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7636 | ((State.regs[srcreg1] >> 16) & 0xffff));
7637 State.regs[dstreg2] -= State.regs[srcreg2];
7638 State.regs[dstreg1] = result1;
7641 // 1111 0111 0011 1011 Rm1 Rn1 imm4 Rn2; swhw_sub Rm1, Rn1, imm4, Rn2
7642 8.0xf7+8.0x3b+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::swhw_sub
7646 int srcreg1, dstreg1, dstreg2;
7650 srcreg1 = translate_rreg (SD_, RM1);
7651 dstreg1 = translate_rreg (SD_, RN1);
7652 dstreg2 = translate_rreg (SD_, RN2);
7654 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7655 | ((State.regs[srcreg1] >> 16) & 0xffff));
7656 State.regs[dstreg2] -= EXTEND4 (IMM4);
7657 State.regs[dstreg1] = result1;
7660 // 1111 0111 0100 1011 Rm1 Rn1 Rm2 Rn2; swhw_cmp Rm1, Rn1, Rm2, Rn2
7661 8.0xf7+8.0x4b+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::swhw_cmp
7665 int srcreg1, srcreg2, dstreg1, dstreg2;
7668 srcreg1 = translate_rreg (SD_, RM1);
7669 srcreg2 = translate_rreg (SD_, RM2);
7670 dstreg1 = translate_rreg (SD_, RN1);
7671 dstreg2 = translate_rreg (SD_, RN2);
7673 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
7674 State.regs[dstreg1] = (((State.regs[srcreg1] & 0xffff) << 16)
7675 | ((State.regs[srcreg1] >> 16) & 0xffff));
7678 // 1111 0111 0101 1011 Rm1 Rn1 imm4 Rn2; swhw_cmp Rm1, Rn1, imm4, Rn2
7679 8.0xf7+8.0x5b+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::swhw_cmp
7683 int srcreg1, dstreg1, dstreg2;
7686 srcreg1 = translate_rreg (SD_, RM1);
7687 dstreg1 = translate_rreg (SD_, RN1);
7688 dstreg2 = translate_rreg (SD_, RN2);
7690 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
7691 State.regs[dstreg1] = (((State.regs[srcreg1] & 0xffff) << 16)
7692 | ((State.regs[srcreg1] >> 16) & 0xffff));
7695 // 1111 0111 0110 1011 Rm1 Rn1 Rm2 Rn2; swhw_mov Rm1, Rn1, Rm2, Rn2
7696 8.0xf7+8.0x6b+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::swhw_mov
7700 int srcreg1, srcreg2, dstreg1, dstreg2;
7704 srcreg1 = translate_rreg (SD_, RM1);
7705 srcreg2 = translate_rreg (SD_, RM2);
7706 dstreg1 = translate_rreg (SD_, RN1);
7707 dstreg2 = translate_rreg (SD_, RN2);
7709 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7710 | ((State.regs[srcreg1] >> 16) & 0xffff));
7711 State.regs[dstreg2] = State.regs[srcreg2];
7712 State.regs[dstreg1] = result1;
7715 // 1111 0111 0111 1011 Rm1 Rn1 imm4 Rn2; swhw_mov Rm1, Rn1, imm4, Rn2
7716 8.0xf7+8.0x7b+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::swhw_mov
7720 int srcreg1, dstreg1, dstreg2;
7724 srcreg1 = translate_rreg (SD_, RM1);
7725 dstreg1 = translate_rreg (SD_, RN1);
7726 dstreg2 = translate_rreg (SD_, RN2);
7728 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7729 | ((State.regs[srcreg1] >> 16) & 0xffff));
7730 State.regs[dstreg2] = EXTEND4 (IMM4);
7731 State.regs[dstreg1] = result1;
7734 // 1111 0111 1000 1011 Rm1 Rn1 Rm2 Rn2; swhw_asr Rm1, Rn1, Rm2, Rn2
7735 8.0xf7+8.0x8b+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::swhw_asr
7739 int srcreg1, srcreg2, dstreg1, dstreg2;
7744 srcreg1 = translate_rreg (SD_, RM1);
7745 srcreg2 = translate_rreg (SD_, RM2);
7746 dstreg1 = translate_rreg (SD_, RN1);
7747 dstreg2 = translate_rreg (SD_, RN2);
7749 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7750 | ((State.regs[srcreg1] >> 16) & 0xffff));
7751 temp = State.regs[dstreg2];
7752 temp >>= State.regs[srcreg2];
7753 State.regs[dstreg2] = temp;
7754 State.regs[dstreg1] = result1;
7757 // 1111 0111 1001 1011 Rm1 Rn1 imm4 Rn2; swhw_asr Rm1, Rn1, imm4, Rn2
7758 8.0xf7+8.0x9b+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::swhw_asr
7762 int srcreg1, dstreg1, dstreg2;
7767 srcreg1 = translate_rreg (SD_, RM1);
7768 dstreg1 = translate_rreg (SD_, RN1);
7769 dstreg2 = translate_rreg (SD_, RN2);
7771 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7772 | ((State.regs[srcreg1] >> 16) & 0xffff));
7773 temp = State.regs[dstreg2];
7775 State.regs[dstreg2] = temp;
7776 State.regs[dstreg1] = result1;
7779 // 1111 0111 1010 1011 Rm1 Rn1 Rm2 Rn2; swhw_lsr Rm1, Rn1, Rm2, Rn2
7780 8.0xf7+8.0xab+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::swhw_lsr
7784 int srcreg1, srcreg2, dstreg1, dstreg2;
7788 srcreg1 = translate_rreg (SD_, RM1);
7789 srcreg2 = translate_rreg (SD_, RM2);
7790 dstreg1 = translate_rreg (SD_, RN1);
7791 dstreg2 = translate_rreg (SD_, RN2);
7793 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7794 | ((State.regs[srcreg1] >> 16) & 0xffff));
7795 State.regs[dstreg2] >>= State.regs[srcreg2];
7796 State.regs[dstreg1] = result1;
7799 // 1111 0111 1011 1011 Rm1 Rn1 imm4 Rn2; swhw_lsr Rm1, Rn1, imm4, Rn2
7800 8.0xf7+8.0xbb+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::swhw_lsr
7804 int srcreg1, dstreg1, dstreg2;
7809 srcreg1 = translate_rreg (SD_, RM1);
7810 dstreg1 = translate_rreg (SD_, RN1);
7811 dstreg2 = translate_rreg (SD_, RN2);
7813 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7814 | ((State.regs[srcreg1] >> 16) & 0xffff));
7815 State.regs[dstreg2] >>= IMM4;
7816 State.regs[dstreg1] = result1;
7820 // 1111 0111 1100 1011 Rm1 Rn1 Rm2 Rn2; swhw_asl Rm1, Rn1, Rm2, Rn2
7821 8.0xf7+8.0xcb+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::swhw_asl
7825 int srcreg1, srcreg2, dstreg1, dstreg2;
7829 srcreg1 = translate_rreg (SD_, RM1);
7830 srcreg2 = translate_rreg (SD_, RM2);
7831 dstreg1 = translate_rreg (SD_, RN1);
7832 dstreg2 = translate_rreg (SD_, RN2);
7834 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7835 | ((State.regs[srcreg1] >> 16) & 0xffff));
7836 State.regs[dstreg2] <<= State.regs[srcreg2];
7837 State.regs[dstreg1] = result1;
7840 // 1111 0111 1101 1011 Rm1 Rn1 imm4 Rn2; swhw_asl Rm1, Rn1, imm4, Rn2
7841 8.0xf7+8.0xdb+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::swhw_asl
7845 int srcreg1, dstreg1, dstreg2;
7850 srcreg1 = translate_rreg (SD_, RM1);
7851 dstreg1 = translate_rreg (SD_, RN1);
7852 dstreg2 = translate_rreg (SD_, RN2);
7854 result1 = (((State.regs[srcreg1] & 0xffff) << 16)
7855 | ((State.regs[srcreg1] >> 16) & 0xffff));
7856 State.regs[dstreg2] <<= IMM4;
7857 State.regs[dstreg1] = result1;
7860 // 1111 0111 0000 1100 Rm1 Rn1 Rm2 Rn2; or_add Rm1, Rn1, Rm2, Rn2
7861 8.0xf7+8.0x0c+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::or_add
7865 int srcreg1, srcreg2, dstreg1, dstreg2;
7869 srcreg1 = translate_rreg (SD_, RM1);
7870 srcreg2 = translate_rreg (SD_, RM2);
7871 dstreg1 = translate_rreg (SD_, RN1);
7872 dstreg2 = translate_rreg (SD_, RN2);
7874 result1 = State.regs[dstreg1] | State.regs[srcreg1];
7875 State.regs[dstreg2] += State.regs[srcreg2];
7876 State.regs[dstreg1] = result1;
7879 // 1111 0111 0001 1100 Rm1 Rn1 imm4 Rn2; or_add Rm1, Rn1, imm4, Rn2
7880 8.0xf7+8.0x1c+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::or_add
7884 int srcreg1, dstreg1, dstreg2;
7888 srcreg1 = translate_rreg (SD_, RM1);
7889 dstreg1 = translate_rreg (SD_, RN1);
7890 dstreg2 = translate_rreg (SD_, RN2);
7892 result1 = State.regs[dstreg1] | State.regs[srcreg1];
7893 State.regs[dstreg2] += EXTEND4 (IMM4);
7894 State.regs[dstreg1] = result1;
7897 // 1111 0111 0010 1100 Rm1 Rn1 Rm2 Rn2; or_sub Rm1, Rn1, Rm2, Rn2
7898 8.0xf7+8.0x2c+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::or_sub
7902 int srcreg1, srcreg2, dstreg1, dstreg2;
7906 srcreg1 = translate_rreg (SD_, RM1);
7907 srcreg2 = translate_rreg (SD_, RM2);
7908 dstreg1 = translate_rreg (SD_, RN1);
7909 dstreg2 = translate_rreg (SD_, RN2);
7911 result1 = State.regs[dstreg1] | State.regs[srcreg1];
7912 State.regs[dstreg2] -= State.regs[srcreg2];
7913 State.regs[dstreg1] = result1;
7916 // 1111 0111 0011 1100 Rm1 Rn1 imm4 Rn2; or_sub Rm1, Rn1, imm4, Rn2
7917 8.0xf7+8.0x3c+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::or_sub
7921 int srcreg1, dstreg1, dstreg2;
7925 srcreg1 = translate_rreg (SD_, RM1);
7926 dstreg1 = translate_rreg (SD_, RN1);
7927 dstreg2 = translate_rreg (SD_, RN2);
7929 result1 = State.regs[dstreg1] | State.regs[srcreg1];
7930 State.regs[dstreg2] -= EXTEND4 (IMM4);
7931 State.regs[dstreg1] = result1;
7934 // 1111 0111 0100 1100 Rm1 Rn1 Rm2 Rn2; or_cmp Rm1, Rn1, Rm2, Rn2
7935 8.0xf7+8.0x4c+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::or_cmp
7939 int srcreg1, srcreg2, dstreg1, dstreg2;
7942 srcreg1 = translate_rreg (SD_, RM1);
7943 srcreg2 = translate_rreg (SD_, RM2);
7944 dstreg1 = translate_rreg (SD_, RN1);
7945 dstreg2 = translate_rreg (SD_, RN2);
7947 genericCmp (State.regs[srcreg2], State.regs[dstreg2]);
7948 State.regs[dstreg1] |= State.regs[srcreg1];
7951 // 1111 0111 0101 1100 Rm1 Rn1 imm4 Rn2; or_cmp Rm1, Rn1, imm4, Rn2
7952 8.0xf7+8.0x5c+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::or_cmp
7956 int srcreg1, dstreg1, dstreg2;
7959 srcreg1 = translate_rreg (SD_, RM1);
7960 dstreg1 = translate_rreg (SD_, RN1);
7961 dstreg2 = translate_rreg (SD_, RN2);
7963 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
7964 State.regs[dstreg1] |= State.regs[srcreg1];
7967 // 1111 0111 0110 1100 Rm1 Rn1 Rm2 Rn2; or_mov Rm1, Rn1, Rm2, Rn2
7968 8.0xf7+8.0x6c+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::or_mov
7972 int srcreg1, srcreg2, dstreg1, dstreg2;
7976 srcreg1 = translate_rreg (SD_, RM1);
7977 srcreg2 = translate_rreg (SD_, RM2);
7978 dstreg1 = translate_rreg (SD_, RN1);
7979 dstreg2 = translate_rreg (SD_, RN2);
7981 result1 = State.regs[dstreg1] | State.regs[srcreg1];
7982 State.regs[dstreg2] = State.regs[srcreg2];
7983 State.regs[dstreg1] = result1;
7986 // 1111 0111 0111 1100 Rm1 Rn1 imm4 Rn2; or_mov Rm1, Rn1, imm4, Rn2
7987 8.0xf7+8.0x7c+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::or_mov
7991 int srcreg1, dstreg1, dstreg2;
7995 srcreg1 = translate_rreg (SD_, RM1);
7996 dstreg1 = translate_rreg (SD_, RN1);
7997 dstreg2 = translate_rreg (SD_, RN2);
7999 result1 = State.regs[dstreg1] | State.regs[srcreg1];
8000 State.regs[dstreg2] = EXTEND4 (IMM4);
8001 State.regs[dstreg1] = result1;
8004 // 1111 0111 1000 1100 Rm1 Rn1 Rm2 Rn2; or_asr Rm1, Rn1, Rm2, Rn2
8005 8.0xf7+8.0x8c+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::or_asr
8009 int srcreg1, srcreg2, dstreg1, dstreg2;
8014 srcreg1 = translate_rreg (SD_, RM1);
8015 srcreg2 = translate_rreg (SD_, RM2);
8016 dstreg1 = translate_rreg (SD_, RN1);
8017 dstreg2 = translate_rreg (SD_, RN2);
8019 result1 = State.regs[dstreg1] | State.regs[srcreg1];
8020 temp = State.regs[dstreg2];
8021 temp >>= State.regs[srcreg2];
8022 State.regs[dstreg2] = temp;
8023 State.regs[dstreg1] = result1;
8026 // 1111 0111 1001 1100 Rm1 Rn1 imm4 Rn2; or_asr Rm1, Rn1, imm4, Rn2
8027 8.0xf7+8.0x9c+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::or_asr
8031 int srcreg1, dstreg1, dstreg2;
8036 srcreg1 = translate_rreg (SD_, RM1);
8037 dstreg1 = translate_rreg (SD_, RN1);
8038 dstreg2 = translate_rreg (SD_, RN2);
8040 result1 = State.regs[dstreg1] | State.regs[srcreg1];
8041 temp = State.regs[dstreg2];
8043 State.regs[dstreg2] = temp;
8044 State.regs[dstreg1] = result1;
8047 // 1111 0111 1010 1100 Rm1 Rn1 Rm2 Rn2; or_lsr Rm1, Rn1, Rm2, Rn2
8048 8.0xf7+8.0xac+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::or_lsr
8052 int srcreg1, srcreg2, dstreg1, dstreg2;
8056 srcreg1 = translate_rreg (SD_, RM1);
8057 srcreg2 = translate_rreg (SD_, RM2);
8058 dstreg1 = translate_rreg (SD_, RN1);
8059 dstreg2 = translate_rreg (SD_, RN2);
8061 result1 = State.regs[dstreg1] | State.regs[srcreg1];
8062 State.regs[dstreg2] >>= State.regs[srcreg2];
8063 State.regs[dstreg1] = result1;
8066 // 1111 0111 1011 1100 Rm1 Rn1 imm4 Rn2; or_lsr Rm1, Rn1, imm4, Rn2
8067 8.0xf7+8.0xbc+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::or_lsr
8071 int srcreg1, dstreg1, dstreg2;
8076 srcreg1 = translate_rreg (SD_, RM1);
8077 dstreg1 = translate_rreg (SD_, RN1);
8078 dstreg2 = translate_rreg (SD_, RN2);
8080 result1 = State.regs[dstreg1] | State.regs[srcreg1];
8081 State.regs[dstreg2] >>= IMM4;
8082 State.regs[dstreg1] = result1;
8086 // 1111 0111 1100 1100 Rm1 Rn1 Rm2 Rn2; or_asl Rm1, Rn1, Rm2, Rn2
8087 8.0xf7+8.0xcc+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::or_asl
8091 int srcreg1, srcreg2, dstreg1, dstreg2;
8095 srcreg1 = translate_rreg (SD_, RM1);
8096 srcreg2 = translate_rreg (SD_, RM2);
8097 dstreg1 = translate_rreg (SD_, RN1);
8098 dstreg2 = translate_rreg (SD_, RN2);
8100 result1 = State.regs[dstreg1] | State.regs[srcreg1];
8101 State.regs[dstreg2] <<= State.regs[srcreg2];
8102 State.regs[dstreg1] = result1;
8105 // 1111 0111 1101 1100 Rm1 Rn1 imm4 Rn2; or_asl Rm1, Rn1, imm4, Rn2
8106 8.0xf7+8.0xdc+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::or_asl
8110 int srcreg1, dstreg1, dstreg2;
8115 srcreg1 = translate_rreg (SD_, RM1);
8116 dstreg1 = translate_rreg (SD_, RN1);
8117 dstreg2 = translate_rreg (SD_, RN2);
8119 result1 = State.regs[dstreg1] | State.regs[srcreg1];
8120 State.regs[dstreg2] <<= IMM4;
8121 State.regs[dstreg1] = result1;
8124 // 1111 0111 0000 1101 Rm1 Rn1 Rm2 Rn2; sat16_add Rm1, Rn1, Rm2, Rn2
8125 8.0xf7+8.0x0d+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sat16_add
8129 int srcreg1, srcreg2, dstreg1, dstreg2;
8133 srcreg1 = translate_rreg (SD_, RM1);
8134 srcreg2 = translate_rreg (SD_, RM2);
8135 dstreg1 = translate_rreg (SD_, RN1);
8136 dstreg2 = translate_rreg (SD_, RN2);
8138 if (State.regs[srcreg1] >= 0x7fff)
8140 else if (State.regs[srcreg1] <= 0xffff8000)
8141 result1 = 0xffff8000;
8143 result1 = State.regs[srcreg1];
8145 State.regs[dstreg2] += State.regs[srcreg2];
8146 State.regs[dstreg1] = result1;
8149 // 1111 0111 0001 1101 Rm1 Rn1 imm4 Rn2; sat16_add Rm1, Rn1, imm4, Rn2
8150 8.0xf7+8.0x1d+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sat16_add
8154 int srcreg1, dstreg1, dstreg2;
8158 srcreg1 = translate_rreg (SD_, RM1);
8159 dstreg1 = translate_rreg (SD_, RN1);
8160 dstreg2 = translate_rreg (SD_, RN2);
8162 if (State.regs[srcreg1] >= 0x7fff)
8164 else if (State.regs[srcreg1] <= 0xffff8000)
8165 result1 = 0xffff8000;
8167 result1 = State.regs[srcreg1];
8169 State.regs[dstreg2] += EXTEND4 (IMM4);
8170 State.regs[dstreg1] = result1;
8173 // 1111 0111 0010 1101 Rm1 Rn1 Rm2 Rn2; sat16_sub Rm1, Rn1, Rm2, Rn2
8174 8.0xf7+8.0x2d+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sat16_sub
8178 int srcreg1, srcreg2, dstreg1, dstreg2;
8182 srcreg1 = translate_rreg (SD_, RM1);
8183 srcreg2 = translate_rreg (SD_, RM2);
8184 dstreg1 = translate_rreg (SD_, RN1);
8185 dstreg2 = translate_rreg (SD_, RN2);
8187 if (State.regs[srcreg1] >= 0x7fff)
8189 else if (State.regs[srcreg1] <= 0xffff8000)
8190 result1 = 0xffff8000;
8192 result1 = State.regs[srcreg1];
8194 State.regs[dstreg2] -= State.regs[srcreg2];
8195 State.regs[dstreg1] = result1;
8198 // 1111 0111 0011 1101 Rm1 Rn1 imm4 Rn2; sat16_sub Rm1, Rn1, imm4, Rn2
8199 8.0xf7+8.0x3d+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sat16_sub
8203 int srcreg1, dstreg1, dstreg2;
8207 srcreg1 = translate_rreg (SD_, RM1);
8208 dstreg1 = translate_rreg (SD_, RN1);
8209 dstreg2 = translate_rreg (SD_, RN2);
8211 if (State.regs[srcreg1] >= 0x7fff)
8213 else if (State.regs[srcreg1] <= 0xffff8000)
8214 result1 = 0xffff8000;
8216 result1 = State.regs[srcreg1];
8218 State.regs[dstreg2] -= EXTEND4 (IMM4);
8219 State.regs[dstreg1] = result1;
8222 // 1111 0111 0100 1101 Rm1 Rn1 Rm2 Rn2; sat16_cmp Rm1, Rn1, Rm2, Rn2
8223 8.0xf7+8.0x4d+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sat16_cmp
8227 int srcreg1, srcreg2, dstreg1, dstreg2;
8231 srcreg1 = translate_rreg (SD_, RM1);
8232 srcreg2 = translate_rreg (SD_, RM2);
8233 dstreg1 = translate_rreg (SD_, RN1);
8234 dstreg2 = translate_rreg (SD_, RN2);
8236 State.regs[dstreg1] = result1;
8237 if (State.regs[srcreg1] >= 0x7fff)
8238 State.regs[dstreg1] = 0x7fff;
8239 else if (State.regs[srcreg1] <= 0xffff8000)
8240 State.regs[dstreg1] = 0xffff8000;
8242 State.regs[dstreg1] = State.regs[srcreg1];
8245 // 1111 0111 0101 1101 Rm1 Rn1 imm4 Rn2; sat16_cmp Rm1, Rn1, imm4, Rn2
8246 8.0xf7+8.0x5d+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sat16_cmp
8250 int srcreg1, dstreg1, dstreg2;
8253 srcreg1 = translate_rreg (SD_, RM1);
8254 dstreg1 = translate_rreg (SD_, RN1);
8255 dstreg2 = translate_rreg (SD_, RN2);
8257 genericCmp (EXTEND4 (IMM4), State.regs[dstreg2]);
8258 if (State.regs[srcreg1] >= 0x7fff)
8259 State.regs[dstreg1] = 0x7fff;
8260 else if (State.regs[srcreg1] <= 0xffff8000)
8261 State.regs[dstreg1] = 0xffff8000;
8263 State.regs[dstreg1] = State.regs[srcreg1];
8266 // 1111 0111 0110 1101 Rm1 Rn1 Rm2 Rn2; sat16_mov Rm1, Rn1, Rm2, Rn2
8267 8.0xf7+8.0x6d+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sat16_mov
8271 int srcreg1, srcreg2, dstreg1, dstreg2;
8275 srcreg1 = translate_rreg (SD_, RM1);
8276 srcreg2 = translate_rreg (SD_, RM2);
8277 dstreg1 = translate_rreg (SD_, RN1);
8278 dstreg2 = translate_rreg (SD_, RN2);
8280 if (State.regs[srcreg1] >= 0x7fff)
8282 else if (State.regs[srcreg1] <= 0xffff8000)
8283 result1 = 0xffff8000;
8285 result1 = State.regs[srcreg1];
8287 State.regs[dstreg2] = State.regs[srcreg2];
8288 State.regs[dstreg1] = result1;
8291 // 1111 0111 0111 1101 Rm1 Rn1 imm4 Rn2; sat16_mov Rm1, Rn1, imm4, Rn2
8292 8.0xf7+8.0x7d+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sat16_mov
8296 int srcreg1, dstreg1, dstreg2;
8300 srcreg1 = translate_rreg (SD_, RM1);
8301 dstreg1 = translate_rreg (SD_, RN1);
8302 dstreg2 = translate_rreg (SD_, RN2);
8304 if (State.regs[srcreg1] >= 0x7fff)
8306 else if (State.regs[srcreg1] <= 0xffff8000)
8307 result1 = 0xffff8000;
8309 result1 = State.regs[srcreg1];
8311 State.regs[dstreg2] = EXTEND4 (IMM4);
8312 State.regs[dstreg1] = result1;
8315 // 1111 0111 1000 1101 Rm1 Rn1 Rm2 Rn2; sat16_asr Rm1, Rn1, Rm2, Rn2
8316 8.0xf7+8.0x8d+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sat16_asr
8320 int srcreg1, srcreg2, dstreg1, dstreg2;
8325 srcreg1 = translate_rreg (SD_, RM1);
8326 srcreg2 = translate_rreg (SD_, RM2);
8327 dstreg1 = translate_rreg (SD_, RN1);
8328 dstreg2 = translate_rreg (SD_, RN2);
8330 if (State.regs[srcreg1] >= 0x7fff)
8332 else if (State.regs[srcreg1] <= 0xffff8000)
8333 result1 = 0xffff8000;
8335 result1 = State.regs[srcreg1];
8337 temp = State.regs[dstreg2];
8338 temp >>= State.regs[srcreg2];
8339 State.regs[dstreg2] = temp;
8340 State.regs[dstreg1] = result1;
8343 // 1111 0111 1001 1101 Rm1 Rn1 imm4 Rn2; sat16_asr Rm1, Rn1, imm4, Rn2
8344 8.0xf7+8.0x9d+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sat16_asr
8348 int srcreg1, dstreg1, dstreg2;
8353 srcreg1 = translate_rreg (SD_, RM1);
8354 dstreg1 = translate_rreg (SD_, RN1);
8355 dstreg2 = translate_rreg (SD_, RN2);
8357 if (State.regs[srcreg1] >= 0x7fff)
8359 else if (State.regs[srcreg1] <= 0xffff8000)
8360 result1 = 0xffff8000;
8362 result1 = State.regs[srcreg1];
8364 temp = State.regs[dstreg2];
8366 State.regs[dstreg2] = temp;
8367 State.regs[dstreg1] = result1;
8370 // 1111 0111 1010 1101 Rm1 Rn1 Rm2 Rn2; sat16_lsr Rm1, Rn1, Rm2, Rn2
8371 8.0xf7+8.0xad+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sat16_lsr
8375 int srcreg1, srcreg2, dstreg1, dstreg2;
8379 srcreg1 = translate_rreg (SD_, RM1);
8380 srcreg2 = translate_rreg (SD_, RM2);
8381 dstreg1 = translate_rreg (SD_, RN1);
8382 dstreg2 = translate_rreg (SD_, RN2);
8384 if (State.regs[srcreg1] >= 0x7fff)
8386 else if (State.regs[srcreg1] <= 0xffff8000)
8387 result1 = 0xffff8000;
8389 result1 = State.regs[srcreg1];
8391 State.regs[dstreg2] >>= State.regs[srcreg2];
8392 State.regs[dstreg1] = result1;
8395 // 1111 0111 1011 1101 Rm1 Rn1 imm4 Rn2; sat16_lsr Rm1, Rn1, imm4, Rn2
8396 8.0xf7+8.0xbd+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sat16_lsr
8400 int srcreg1, dstreg1, dstreg2;
8405 srcreg1 = translate_rreg (SD_, RM1);
8406 dstreg1 = translate_rreg (SD_, RN1);
8407 dstreg2 = translate_rreg (SD_, RN2);
8409 if (State.regs[srcreg1] >= 0x7fff)
8411 else if (State.regs[srcreg1] <= 0xffff8000)
8412 result1 = 0xffff8000;
8414 result1 = State.regs[srcreg1];
8416 State.regs[dstreg2] >>= IMM4;
8417 State.regs[dstreg1] = result1;
8421 // 1111 0111 1100 1101 Rm1 Rn1 Rm2 Rn2; sat16_asl Rm1, Rn1, Rm2, Rn2
8422 8.0xf7+8.0xcd+4.RM1,4.RN1+4.RM2,4.RN2!RN1:D2:::sat16_asl
8426 int srcreg1, srcreg2, dstreg1, dstreg2;
8430 srcreg1 = translate_rreg (SD_, RM1);
8431 srcreg2 = translate_rreg (SD_, RM2);
8432 dstreg1 = translate_rreg (SD_, RN1);
8433 dstreg2 = translate_rreg (SD_, RN2);
8435 if (State.regs[srcreg1] >= 0x7fff)
8437 else if (State.regs[srcreg1] <= 0xffff8000)
8438 result1 = 0xffff8000;
8440 result1 = State.regs[srcreg1];
8442 State.regs[dstreg2] <<= State.regs[srcreg2];
8443 State.regs[dstreg1] = result1;
8446 // 1111 0111 1101 1101 Rm1 Rn1 imm4 Rn2; sat16_asl Rm1, Rn1, imm4, Rn2
8447 8.0xf7+8.0xdd+4.RM1,4.RN1+4.IMM4,4.RN2!RN1:D2b:::sat16_asl
8451 int srcreg1, dstreg1, dstreg2;
8456 srcreg1 = translate_rreg (SD_, RM1);
8457 dstreg1 = translate_rreg (SD_, RN1);
8458 dstreg2 = translate_rreg (SD_, RN2);
8460 if (State.regs[srcreg1] >= 0x7fff)
8462 else if (State.regs[srcreg1] <= 0xffff8000)
8463 result1 = 0xffff8000;
8465 result1 = State.regs[srcreg1];
8467 State.regs[dstreg2] <<= IMM4;
8468 State.regs[dstreg1] = result1;
8471 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0000; mov_llt (Rm+,imm4),Rn
8472 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x0:D2:::mov_llt
8480 srcreg = translate_rreg (SD_, RM);
8481 dstreg = translate_rreg (SD_, RN);
8483 State.regs[dstreg] = load_word (State.regs[srcreg]);
8484 State.regs[srcreg] += EXTEND4 (IMM4);
8486 if (((PSW & PSW_N) != 0) ^ ((PSW & PSW_V) != 0))
8488 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8491 State.regs[dstreg] = result1;
8494 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0001; mov_lgt (Rm+,imm4),Rn
8495 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x1:D2:::mov_lgt
8502 srcreg = translate_rreg (SD_, RM);
8503 dstreg = translate_rreg (SD_, RN);
8505 State.regs[dstreg] = load_word (State.regs[srcreg]);
8506 State.regs[srcreg] += EXTEND4 (IMM4);
8509 || (((PSW & PSW_N) != 0) ^ ((PSW & PSW_V) != 0))))
8511 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8516 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0010; mov_lge (Rm+,imm4),Rn
8517 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x2:D2:::mov_lge
8524 srcreg = translate_rreg (SD_, RM);
8525 dstreg = translate_rreg (SD_, RN);
8527 State.regs[dstreg] = load_word (State.regs[srcreg]);
8528 State.regs[srcreg] += EXTEND4 (IMM4);
8530 if (!(((PSW & PSW_N) != 0) ^ ((PSW & PSW_V) != 0)))
8532 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8537 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0011; mov_lle (Rm+,imm4),Rn
8538 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x3:D2:::mov_lle
8545 srcreg = translate_rreg (SD_, RM);
8546 dstreg = translate_rreg (SD_, RN);
8548 State.regs[dstreg] = load_word (State.regs[srcreg]);
8549 State.regs[srcreg] += EXTEND4 (IMM4);
8552 || (((PSW & PSW_N) != 0) ^ ((PSW & PSW_V) != 0)))
8554 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8559 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0100; mov_lcs (Rm+,imm4),Rn
8560 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x4:D2:::mov_lcs
8567 srcreg = translate_rreg (SD_, RM);
8568 dstreg = translate_rreg (SD_, RN);
8570 State.regs[dstreg] = load_word (State.regs[srcreg]);
8571 State.regs[srcreg] += EXTEND4 (IMM4);
8575 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8580 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0101; mov_lhi (Rm+,imm4),Rn
8581 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x5:D2:::mov_lhi
8588 srcreg = translate_rreg (SD_, RM);
8589 dstreg = translate_rreg (SD_, RN);
8591 State.regs[dstreg] = load_word (State.regs[srcreg]);
8592 State.regs[srcreg] += EXTEND4 (IMM4);
8594 if (!(((PSW & PSW_C) != 0) || (PSW & PSW_Z) != 0))
8596 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8601 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0110; mov_lcc (Rm+,imm4),Rn
8602 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x6:D2:::mov_lcc
8609 srcreg = translate_rreg (SD_, RM);
8610 dstreg = translate_rreg (SD_, RN);
8612 State.regs[dstreg] = load_word (State.regs[srcreg]);
8613 State.regs[srcreg] += EXTEND4 (IMM4);
8617 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8622 // 1111 0111 1110 0000 Rm1 Rn1 imm4 0111; mov_lls (Rm+,imm4),Rn
8623 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x7:D2:::mov_lls
8630 srcreg = translate_rreg (SD_, RM);
8631 dstreg = translate_rreg (SD_, RN);
8633 State.regs[dstreg] = load_word (State.regs[srcreg]);
8634 State.regs[srcreg] += EXTEND4 (IMM4);
8636 if (((PSW & PSW_C) != 0) || (PSW & PSW_Z) != 0)
8638 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8643 // 1111 0111 1110 0000 Rm1 Rn1 imm4 1000; mov_leq (Rm+,imm4),Rn
8644 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x8:D2:::mov_leq
8651 srcreg = translate_rreg (SD_, RM);
8652 dstreg = translate_rreg (SD_, RN);
8654 State.regs[dstreg] = load_word (State.regs[srcreg]);
8655 State.regs[srcreg] += EXTEND4 (IMM4);
8659 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8664 // 1111 0111 1110 0000 Rm1 Rn1 imm4 1001; mov_lne (Rm+,imm4),Rn
8665 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0x9:D2:::mov_lne
8672 srcreg = translate_rreg (SD_, RM);
8673 dstreg = translate_rreg (SD_, RN);
8675 State.regs[dstreg] = load_word (State.regs[srcreg]);
8676 State.regs[srcreg] += EXTEND4 (IMM4);
8680 State.regs[REG_PC] = State.regs[REG_LAR] - 4;
8685 // 1111 0111 1110 0000 Rm1 Rn1 imm4 1010; mov_lra (Rm+,imm4),Rn
8686 8.0xf7+8.0xe0+4.RN,4.RM!RN+4.IMM4,4.0xa:D2:::mov_lra
8693 srcreg = translate_rreg (SD_, RM);
8694 dstreg = translate_rreg (SD_, RN);
8696 State.regs[dstreg] = load_word (State.regs[srcreg]);
8697 State.regs[srcreg] += EXTEND4 (IMM4);
8699 State.regs[REG_PC] = State.regs[REG_LAR] - 4;