Lines Matching refs:amount
1969 uint32_t amount = operand.GetShiftAmount();
1971 // ADC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
1972 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
1974 uint32_t amount_ = amount % 32;
1982 // ADC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
1983 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
1984 uint32_t amount_ = amount % 32;
2057 uint32_t amount = operand.GetShiftAmount();
2059 // ADCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
2060 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
2062 uint32_t amount_ = amount % 32;
2070 // ADCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2071 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
2072 uint32_t amount_ = amount % 32;
2256 uint32_t amount = operand.GetShiftAmount();
2258 // ADD{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T3
2259 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
2261 uint32_t amount_ = amount % 32;
2268 // ADD{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T3
2269 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
2271 uint32_t amount_ = amount % 32;
2279 // ADD{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2280 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
2281 uint32_t amount_ = amount % 32;
2287 // ADD{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
2288 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
2289 uint32_t amount_ = amount % 32;
2425 uint32_t amount = operand.GetShiftAmount();
2427 // ADDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T3
2428 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
2430 uint32_t amount_ = amount % 32;
2437 // ADDS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T3
2438 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
2440 uint32_t amount_ = amount % 32;
2448 // ADDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2449 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
2450 uint32_t amount_ = amount % 32;
2456 // ADDS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
2457 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
2458 uint32_t amount_ = amount % 32;
2743 uint32_t amount = operand.GetShiftAmount();
2745 // AND{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
2746 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
2748 uint32_t amount_ = amount % 32;
2756 // AND{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2757 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
2758 uint32_t amount_ = amount % 32;
2831 uint32_t amount = operand.GetShiftAmount();
2833 // ANDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
2834 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rd.Is(pc) &&
2836 uint32_t amount_ = amount % 32;
2844 // ANDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2845 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
2846 uint32_t amount_ = amount % 32;
3296 uint32_t amount = operand.GetShiftAmount();
3298 // BIC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
3299 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3301 uint32_t amount_ = amount % 32;
3309 // BIC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
3310 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3311 uint32_t amount_ = amount % 32;
3384 uint32_t amount = operand.GetShiftAmount();
3386 // BICS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
3387 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3389 uint32_t amount_ = amount % 32;
3397 // BICS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
3398 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3399 uint32_t amount_ = amount % 32;
3866 uint32_t amount = operand.GetShiftAmount();
3868 // CMN{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; T2
3869 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3871 uint32_t amount_ = amount % 32;
3879 // CMN{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
3880 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3881 uint32_t amount_ = amount % 32;
3964 uint32_t amount = operand.GetShiftAmount();
3966 // CMP{<c>}{<q>} <Rn>, <Rm>, <shift> #<amount> ; T3
3967 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3969 uint32_t amount_ = amount % 32;
3977 // CMP{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
3978 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3979 uint32_t amount_ = amount % 32;
4231 uint32_t amount = operand.GetShiftAmount();
4233 // EOR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
4234 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
4236 uint32_t amount_ = amount % 32;
4244 // EOR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
4245 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
4246 uint32_t amount_ = amount % 32;
4319 uint32_t amount = operand.GetShiftAmount();
4321 // EORS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
4322 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rd.Is(pc) &&
4324 uint32_t amount_ = amount % 32;
4332 // EORS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
4333 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
4334 uint32_t amount_ = amount % 32;
5137 uint32_t amount = operand.GetShiftAmount();
5140 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
5145 rm.GetCode() | (amount << 4));
5155 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
5166 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
5177 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
5440 uint32_t amount = operand.GetShiftAmount();
5443 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
5447 rm.GetCode() | (amount << 4));
5457 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
5469 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
5480 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
6102 uint32_t amount = operand.GetShiftAmount();
6105 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
6109 rm.GetCode() | (amount << 4));
6357 uint32_t amount = operand.GetShiftAmount();
6360 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
6364 rm.GetCode() | (amount << 4));
6612 uint32_t amount = operand.GetShiftAmount();
6615 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
6619 rm.GetCode() | (amount << 4));
7076 uint32_t amount = operand.GetShiftAmount();
7078 // MOV<c>{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7080 shift.IsValidAmount(amount) && rm.IsLow() &&
7082 ((!shift.Is(LSL) || (amount != 0)) || AllowUnpredictable())) {
7083 uint32_t amount_ = amount % 32;
7089 // MOV{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T3
7090 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7092 uint32_t amount_ = amount % 32;
7100 // MOV{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7101 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7102 uint32_t amount_ = amount % 32;
7220 uint32_t amount = operand.GetShiftAmount();
7222 // MOVS{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7224 shift.IsValidAmount(amount) && rm.IsLow() &&
7226 uint32_t amount_ = amount % 32;
7232 // MOVS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T3
7233 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7235 uint32_t amount_ = amount % 32;
7243 // MOVS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7244 if (shift.IsValidAmount(amount) && cond.IsNotNever() &&
7246 uint32_t amount_ = amount % 32;
7553 uint32_t amount = operand.GetShiftAmount();
7555 // MVN{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7556 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7558 uint32_t amount_ = amount % 32;
7566 // MVN{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7567 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7568 uint32_t amount_ = amount % 32;
7637 uint32_t amount = operand.GetShiftAmount();
7639 // MVNS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7640 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7642 uint32_t amount_ = amount % 32;
7650 // MVNS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7651 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7652 uint32_t amount_ = amount % 32;
7729 uint32_t amount = operand.GetShiftAmount();
7731 // ORN{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
7732 if (shift.IsValidAmount(amount) && !rn.Is(pc) &&
7734 uint32_t amount_ = amount % 32;
7771 uint32_t amount = operand.GetShiftAmount();
7773 // ORNS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
7774 if (shift.IsValidAmount(amount) && !rn.Is(pc) &&
7776 uint32_t amount_ = amount % 32;
7834 uint32_t amount = operand.GetShiftAmount();
7836 // ORR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
7837 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(pc) &&
7839 uint32_t amount_ = amount % 32;
7847 // ORR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
7848 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7849 uint32_t amount_ = amount % 32;
7922 uint32_t amount = operand.GetShiftAmount();
7924 // ORRS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
7925 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(pc) &&
7927 uint32_t amount_ = amount % 32;
7935 // ORRS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
7936 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7937 uint32_t amount_ = amount % 32;
7973 uint32_t amount = operand.GetShiftAmount();
7976 if (shift.IsLSL() && shift.IsValidAmount(amount) &&
7979 rm.GetCode() | ((amount & 0x3) << 6) |
7980 ((amount & 0x1c) << 10));
7986 if (shift.IsLSL() && shift.IsValidAmount(amount) && cond.IsNotNever() &&
7990 (amount << 7));
8007 uint32_t amount = operand.GetShiftAmount();
8010 if ((shift.IsASR() || (amount == 0)) && shift.IsValidAmount(amount) &&
8012 uint32_t amount_ = amount % 32;
8021 if ((shift.IsASR() || (amount == 0)) && shift.IsValidAmount(amount) &&
8024 uint32_t amount_ = amount % 32;
8181 uint32_t amount = operand.GetShiftAmount();
8183 // PLD{<c>}{<q>} [<Rn>, {+}<Rm>{, LSL #<amount>}] ; T1
8188 (amount << 4));
8194 if (!shift.IsRRX() && shift.IsValidAmount(amount) && operand.IsOffset() &&
8198 uint32_t amount_ = amount % 32;
8258 uint32_t amount = operand.GetShiftAmount();
8260 // PLDW{<c>}{<q>} [<Rn>, {+}<Rm>{, LSL #<amount>}] ; T1
8265 (amount << 4));
8271 if (!shift.IsRRX() && shift.IsValidAmount(amount) && operand.IsOffset() &&
8275 uint32_t amount_ = amount % 32;
8361 uint32_t amount = operand.GetShiftAmount();
8363 // PLI{<c>}{<q>} [<Rn>, {+}<Rm>{, LSL #<amount>}] ; T1
8368 (amount << 4));
8384 if (!shift.IsRRX() && shift.IsValidAmount(amount) && operand.IsOffset() &&
8388 uint32_t amount_ = amount % 32;
9163 uint32_t amount = operand.GetShiftAmount();
9165 // RSB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
9166 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9168 uint32_t amount_ = amount % 32;
9176 // RSB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9177 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9178 uint32_t amount_ = amount % 32;
9247 uint32_t amount = operand.GetShiftAmount();
9249 // RSBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
9250 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9252 uint32_t amount_ = amount % 32;
9260 // RSBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9261 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9262 uint32_t amount_ = amount % 32;
9311 uint32_t amount = operand.GetShiftAmount();
9313 // RSC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9314 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9315 uint32_t amount_ = amount % 32;
9364 uint32_t amount = operand.GetShiftAmount();
9366 // RSCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9367 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9368 uint32_t amount_ = amount % 32;
9510 uint32_t amount = operand.GetShiftAmount();
9512 // SBC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
9513 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9515 uint32_t amount_ = amount % 32;
9523 // SBC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9524 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9525 uint32_t amount_ = amount % 32;
9598 uint32_t amount = operand.GetShiftAmount();
9600 // SBCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
9601 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9603 uint32_t amount_ = amount % 32;
9611 // SBCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9612 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9613 uint32_t amount_ = amount % 32;
10802 uint32_t amount = operand.GetShiftAmount();
10804 // SSAT{<c>}{<q>} <Rd>, #<imm>, <Rn>, ASR #<amount> ; T1
10805 if ((imm >= 1) && (imm <= 32) && shift.IsASR() && (amount >= 1) &&
10806 (amount <= 31) &&
10810 (rn.GetCode() << 16) | ((amount & 0x3) << 6) |
10811 ((amount & 0x1c) << 10));
10815 // SSAT{<c>}{<q>} <Rd>, #<imm>, <Rn> {, LSL #<amount> } ; T1
10816 if ((imm >= 1) && (imm <= 32) && shift.IsLSL() && (amount <= 31) &&
10820 (rn.GetCode() << 16) | ((amount & 0x3) << 6) |
10821 ((amount & 0x1c) << 10));
10826 // SSAT{<c>}{<q>} <Rd>, #<imm>, <Rn>, ASR #<amount> ; A1
10827 if ((imm >= 1) && (imm <= 32) && shift.IsASR() && (amount >= 1) &&
10828 (amount <= 32) && cond.IsNotNever() &&
10831 uint32_t amount_ = amount % 32;
10837 // SSAT{<c>}{<q>} <Rd>, #<imm>, <Rn> {, LSL #<amount> } ; A1
10838 if ((imm >= 1) && (imm <= 32) && shift.IsLSL() && (amount <= 31) &&
10844 (amount << 7));
11495 uint32_t amount = operand.GetShiftAmount();
11498 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
11502 rm.GetCode() | (amount << 4));
11512 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
11523 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
11534 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
11656 uint32_t amount = operand.GetShiftAmount();
11659 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
11663 rm.GetCode() | (amount << 4));
11673 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
11685 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
11696 uint32_t imm_and_type_ = (((amount % 32) << 2) | shift_);
12100 uint32_t amount = operand.GetShiftAmount();
12103 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
12107 rm.GetCode() | (amount << 4));
12238 uint32_t amount = operand.GetShiftAmount();
12240 // SUB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
12241 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
12243 uint32_t amount_ = amount % 32;
12250 // SUB{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T1
12251 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
12253 uint32_t amount_ = amount % 32;
12261 // SUB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
12262 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
12263 uint32_t amount_ = amount % 32;
12269 // SUB{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
12270 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
12271 uint32_t amount_ = amount % 32;
12399 uint32_t amount = operand.GetShiftAmount();
12401 // SUBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
12402 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
12404 uint32_t amount_ = amount % 32;
12411 // SUBS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T1
12412 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
12414 uint32_t amount_ = amount % 32;
12422 // SUBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
12423 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
12424 uint32_t amount_ = amount % 32;
12430 // SUBS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
12431 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
12432 uint32_t amount_ = amount % 32;
12534 uint32_t amount = operand.GetShiftAmount();
12536 // SXTAB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; T1
12537 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12538 ((amount % 8) == 0) && !rn.Is(pc) &&
12540 uint32_t amount_ = amount / 8;
12547 // SXTAB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; A1
12548 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12549 ((amount % 8) == 0) && cond.IsNotNever() && !rn.Is(pc) &&
12551 uint32_t amount_ = amount / 8;
12571 uint32_t amount = operand.GetShiftAmount();
12573 // SXTAB16{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; T1
12574 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12575 ((amount % 8) == 0) && !rn.Is(pc) &&
12577 uint32_t amount_ = amount / 8;
12584 // SXTAB16{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; A1
12585 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12586 ((amount % 8) == 0) && cond.IsNotNever() && !rn.Is(pc) &&
12588 uint32_t amount_ = amount / 8;
12608 uint32_t amount = operand.GetShiftAmount();
12610 // SXTAH{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; T1
12611 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12612 ((amount % 8) == 0) && !rn.Is(pc) &&
12614 uint32_t amount_ = amount / 8;
12621 // SXTAH{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; A1
12622 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12623 ((amount % 8) == 0) && cond.IsNotNever() && !rn.Is(pc) &&
12625 uint32_t amount_ = amount / 8;
12655 uint32_t amount = operand.GetShiftAmount();
12657 // SXTB{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; T2
12658 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
12659 (amount <= 24) && ((amount % 8) == 0) &&
12661 uint32_t amount_ = amount / 8;
12668 // SXTB{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; A1
12669 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12670 ((amount % 8) == 0) && cond.IsNotNever() &&
12672 uint32_t amount_ = amount / 8;
12688 uint32_t amount = operand.GetShiftAmount();
12690 // SXTB16{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; T1
12691 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12692 ((amount % 8) == 0) &&
12694 uint32_t amount_ = amount / 8;
12701 // SXTB16{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; A1
12702 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12703 ((amount % 8) == 0) && cond.IsNotNever() &&
12705 uint32_t amount_ = amount / 8;
12734 uint32_t amount = operand.GetShiftAmount();
12736 // SXTH{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; T2
12737 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
12738 (amount <= 24) && ((amount % 8) == 0) &&
12740 uint32_t amount_ = amount / 8;
12747 // SXTH{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; A1
12748 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12749 ((amount % 8) == 0) && cond.IsNotNever() &&
12751 uint32_t amount_ = amount / 8;
12820 uint32_t amount = operand.GetShiftAmount();
12822 // TEQ{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; T1
12823 if (shift.IsValidAmount(amount) &&
12825 uint32_t amount_ = amount % 32;
12833 // TEQ{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
12834 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
12835 uint32_t amount_ = amount % 32;
12904 uint32_t amount = operand.GetShiftAmount();
12906 // TST{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; T2
12907 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
12909 uint32_t amount_ = amount % 32;
12917 // TST{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
12918 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
12919 uint32_t amount_ = amount % 32;
13548 uint32_t amount = operand.GetShiftAmount();
13550 // USAT{<c>}{<q>} <Rd>, #<imm>, <Rn>, ASR #<amount> ; T1
13551 if ((imm <= 31) && shift.IsASR() && (amount >= 1) && (amount <= 31) &&
13554 (rn.GetCode() << 16) | ((amount & 0x3) << 6) |
13555 ((amount & 0x1c) << 10));
13559 // USAT{<c>}{<q>} <Rd>, #<imm>, <Rn> {, LSL #<amount> } ; T1
13560 if ((imm <= 31) && shift.IsLSL() && (amount <= 31) &&
13563 (rn.GetCode() << 16) | ((amount & 0x3) << 6) |
13564 ((amount & 0x1c) << 10));
13569 // USAT{<c>}{<q>} <Rd>, #<imm>, <Rn>, ASR #<amount> ; A1
13570 if ((imm <= 31) && shift.IsASR() && (amount >= 1) && (amount <= 32) &&
13573 uint32_t amount_ = amount % 32;
13579 // USAT{<c>}{<q>} <Rd>, #<imm>, <Rn> {, LSL #<amount> } ; A1
13580 if ((imm <= 31) && shift.IsLSL() && (amount <= 31) && cond.IsNotNever() &&
13584 (amount << 7));
13693 uint32_t amount = operand.GetShiftAmount();
13695 // UXTAB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; T1
13696 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13697 ((amount % 8) == 0) && !rn.Is(pc) &&
13699 uint32_t amount_ = amount / 8;
13706 // UXTAB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; A1
13707 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13708 ((amount % 8) == 0) && cond.IsNotNever() && !rn.Is(pc) &&
13710 uint32_t amount_ = amount / 8;
13730 uint32_t amount = operand.GetShiftAmount();
13732 // UXTAB16{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; T1
13733 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13734 ((amount % 8) == 0) && !rn.Is(pc) &&
13736 uint32_t amount_ = amount / 8;
13743 // UXTAB16{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; A1
13744 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13745 ((amount % 8) == 0) && cond.IsNotNever() && !rn.Is(pc) &&
13747 uint32_t amount_ = amount / 8;
13767 uint32_t amount = operand.GetShiftAmount();
13769 // UXTAH{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; T1
13770 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13771 ((amount % 8) == 0) && !rn.Is(pc) &&
13773 uint32_t amount_ = amount / 8;
13780 // UXTAH{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, ROR #<amount> } ; A1
13781 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13782 ((amount % 8) == 0) && cond.IsNotNever() && !rn.Is(pc) &&
13784 uint32_t amount_ = amount / 8;
13814 uint32_t amount = operand.GetShiftAmount();
13816 // UXTB{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; T2
13817 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
13818 (amount <= 24) && ((amount % 8) == 0) &&
13820 uint32_t amount_ = amount / 8;
13827 // UXTB{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; A1
13828 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13829 ((amount % 8) == 0) && cond.IsNotNever() &&
13831 uint32_t amount_ = amount / 8;
13847 uint32_t amount = operand.GetShiftAmount();
13849 // UXTB16{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; T1
13850 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13851 ((amount % 8) == 0) &&
13853 uint32_t amount_ = amount / 8;
13860 // UXTB16{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; A1
13861 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13862 ((amount % 8) == 0) && cond.IsNotNever() &&
13864 uint32_t amount_ = amount / 8;
13893 uint32_t amount = operand.GetShiftAmount();
13895 // UXTH{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; T2
13896 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
13897 (amount <= 24) && ((amount % 8) == 0) &&
13899 uint32_t amount_ = amount / 8;
13906 // UXTH{<c>}{<q>} {<Rd>}, <Rm> {, ROR #<amount> } ; A1
13907 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13908 ((amount % 8) == 0) && cond.IsNotNever() &&
13910 uint32_t amount_ = amount / 8;