Lines Matching defs:shift
1968 Shift shift = operand.GetShift();
1971 // ADC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
1972 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
1982 // ADC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
1983 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
1994 Shift shift = operand.GetShift();
1997 // ADC{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
2003 (shift.GetType() << 5) | (rs.GetCode() << 8));
2056 Shift shift = operand.GetShift();
2059 // ADCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
2060 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
2070 // ADCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2071 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
2082 Shift shift = operand.GetShift();
2085 // ADCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
2091 (shift.GetType() << 5) | (rs.GetCode() << 8));
2255 Shift shift = operand.GetShift();
2258 // ADD{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T3
2259 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
2268 // ADD{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T3
2269 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
2279 // ADD{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2280 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
2287 // ADD{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
2288 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
2299 Shift shift = operand.GetShift();
2302 // ADD{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
2308 (shift.GetType() << 5) | (rs.GetCode() << 8));
2424 Shift shift = operand.GetShift();
2427 // ADDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T3
2428 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
2437 // ADDS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T3
2438 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
2448 // ADDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2449 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
2456 // ADDS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
2457 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
2468 Shift shift = operand.GetShift();
2471 // ADDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
2477 (shift.GetType() << 5) | (rs.GetCode() << 8));
2742 Shift shift = operand.GetShift();
2745 // AND{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
2746 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
2756 // AND{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2757 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
2768 Shift shift = operand.GetShift();
2771 // AND{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
2777 (shift.GetType() << 5) | (rs.GetCode() << 8));
2830 Shift shift = operand.GetShift();
2833 // ANDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
2834 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rd.Is(pc) &&
2844 // ANDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
2845 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
2856 Shift shift = operand.GetShift();
2859 // ANDS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
2865 (shift.GetType() << 5) | (rs.GetCode() << 8));
3295 Shift shift = operand.GetShift();
3298 // BIC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
3299 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3309 // BIC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
3310 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3321 Shift shift = operand.GetShift();
3324 // BIC{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
3330 (shift.GetType() << 5) | (rs.GetCode() << 8));
3383 Shift shift = operand.GetShift();
3386 // BICS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
3387 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3397 // BICS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
3398 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3409 Shift shift = operand.GetShift();
3412 // BICS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
3418 (shift.GetType() << 5) | (rs.GetCode() << 8));
3865 Shift shift = operand.GetShift();
3868 // CMN{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; T2
3869 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3879 // CMN{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
3880 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3891 Shift shift = operand.GetShift();
3894 // CMN{<c>}{<q>} <Rn>, <Rm>, <shift> <Rs> ; A1
3898 (rn.GetCode() << 16) | rm.GetCode() | (shift.GetType() << 5) |
3963 Shift shift = operand.GetShift();
3966 // CMP{<c>}{<q>} <Rn>, <Rm>, <shift> #<amount> ; T3
3967 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
3977 // CMP{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
3978 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
3989 Shift shift = operand.GetShift();
3992 // CMP{<c>}{<q>} <Rn>, <Rm>, <shift> <Rs> ; A1
3996 (rn.GetCode() << 16) | rm.GetCode() | (shift.GetType() << 5) |
4230 Shift shift = operand.GetShift();
4233 // EOR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
4234 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
4244 // EOR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
4245 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
4256 Shift shift = operand.GetShift();
4259 // EOR{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
4265 (shift.GetType() << 5) | (rs.GetCode() << 8));
4318 Shift shift = operand.GetShift();
4321 // EORS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
4322 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rd.Is(pc) &&
4332 // EORS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
4333 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
4344 Shift shift = operand.GetShift();
4347 // EORS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
4353 (shift.GetType() << 5) | (rs.GetCode() << 8));
5136 Shift shift = operand.GetShift();
5140 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
5150 // LDR{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}] ; A1
5154 uint32_t shift_ = TypeEncodingValue(shift);
5161 // LDR{<c>}{<q>} <Rt>, [<Rn>], {+/-}<Rm>{, <shift>} ; A1
5165 uint32_t shift_ = TypeEncodingValue(shift);
5172 // LDR{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}]! ; A1
5176 uint32_t shift_ = TypeEncodingValue(shift);
5439 Shift shift = operand.GetShift();
5443 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
5452 // LDRB{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}] ; A1
5456 uint32_t shift_ = TypeEncodingValue(shift);
5463 // LDRB{<c>}{<q>} <Rt>, [<Rn>], {+/-}<Rm>{, <shift>} ; A1
5468 uint32_t shift_ = TypeEncodingValue(shift);
5475 // LDRB{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}]! ; A1
5479 uint32_t shift_ = TypeEncodingValue(shift);
6101 Shift shift = operand.GetShift();
6105 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
6356 Shift shift = operand.GetShift();
6360 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
6611 Shift shift = operand.GetShift();
6615 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
7075 Shift shift = operand.GetShift();
7078 // MOV<c>{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7080 shift.IsValidAmount(amount) && rm.IsLow() &&
7081 (shift.Is(LSL) || shift.Is(LSR) || shift.Is(ASR)) &&
7082 ((!shift.Is(LSL) || (amount != 0)) || AllowUnpredictable())) {
7089 // MOV{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T3
7090 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7100 // MOV{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7101 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7112 Shift shift = operand.GetShift();
7117 shift.IsASR() && rs.IsLow()) {
7124 shift.IsLSL() && rs.IsLow()) {
7131 shift.IsLSR() && rs.IsLow()) {
7138 shift.IsROR() && rs.IsLow()) {
7143 // MOV{<c>}{<q>} <Rd>, <Rm>, <shift> <Rs> ; T2
7147 (shift.GetType() << 21) | rs.GetCode());
7152 // MOV{<c>}{<q>} <Rd>, <Rm>, <shift> <Rs> ; A1
7156 (rd.GetCode() << 12) | rm.GetCode() | (shift.GetType() << 5) |
7219 Shift shift = operand.GetShift();
7222 // MOVS{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7224 shift.IsValidAmount(amount) && rm.IsLow() &&
7225 (shift.Is(LSL) || shift.Is(LSR) || shift.Is(ASR))) {
7232 // MOVS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T3
7233 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7243 // MOVS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7244 if (shift.IsValidAmount(amount) && cond.IsNotNever() &&
7256 Shift shift = operand.GetShift();
7261 shift.IsASR() && rs.IsLow()) {
7268 shift.IsLSL() && rs.IsLow()) {
7275 shift.IsLSR() && rs.IsLow()) {
7282 shift.IsROR() && rs.IsLow()) {
7287 // MOVS{<c>}{<q>} <Rd>, <Rm>, <shift> <Rs> ; T2
7291 (shift.GetType() << 21) | rs.GetCode());
7296 // MOVS{<c>}{<q>} <Rd>, <Rm>, <shift> <Rs> ; A1
7300 (rd.GetCode() << 12) | rm.GetCode() | (shift.GetType() << 5) |
7552 Shift shift = operand.GetShift();
7555 // MVN{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7556 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7566 // MVN{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7567 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7578 Shift shift = operand.GetShift();
7581 // MVN{<c>}{<q>} <Rd>, <Rm>, <shift> <Rs> ; A1
7585 (rd.GetCode() << 12) | rm.GetCode() | (shift.GetType() << 5) |
7636 Shift shift = operand.GetShift();
7639 // MVNS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; T2
7640 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
7650 // MVNS{<c>}{<q>} <Rd>, <Rm> {, <shift> #<amount> } ; A1
7651 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7662 Shift shift = operand.GetShift();
7665 // MVNS{<c>}{<q>} <Rd>, <Rm>, <shift> <Rs> ; A1
7669 (rd.GetCode() << 12) | rm.GetCode() | (shift.GetType() << 5) |
7728 Shift shift = operand.GetShift();
7731 // ORN{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
7732 if (shift.IsValidAmount(amount) && !rn.Is(pc) &&
7770 Shift shift = operand.GetShift();
7773 // ORNS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
7774 if (shift.IsValidAmount(amount) && !rn.Is(pc) &&
7833 Shift shift = operand.GetShift();
7836 // ORR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
7837 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(pc) &&
7847 // ORR{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
7848 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7859 Shift shift = operand.GetShift();
7862 // ORR{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
7868 (shift.GetType() << 5) | (rs.GetCode() << 8));
7921 Shift shift = operand.GetShift();
7924 // ORRS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
7925 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(pc) &&
7935 // ORRS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
7936 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
7947 Shift shift = operand.GetShift();
7950 // ORRS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
7956 (shift.GetType() << 5) | (rs.GetCode() << 8));
7972 Shift shift = operand.GetShift();
7976 if (shift.IsLSL() && shift.IsValidAmount(amount) &&
7986 if (shift.IsLSL() && shift.IsValidAmount(amount) && cond.IsNotNever() &&
8006 Shift shift = operand.GetShift();
8010 if ((shift.IsASR() || (amount == 0)) && shift.IsValidAmount(amount) &&
8021 if ((shift.IsASR() || (amount == 0)) && shift.IsValidAmount(amount) &&
8180 Shift shift = operand.GetShift();
8184 if (sign.IsPlus() && shift.IsLSL() && operand.IsOffset() &&
8193 // PLD{<c>}{<q>} [<Rn>, {+/-}<Rm>{, <shift> #<amount_1>}] ; A1
8194 if (!shift.IsRRX() && shift.IsValidAmount(amount) && operand.IsOffset() &&
8200 (sign_ << 23) | (shift.GetType() << 5) | (amount_ << 7));
8205 if (shift.IsRRX() && operand.IsOffset() &&
8257 Shift shift = operand.GetShift();
8261 if (sign.IsPlus() && shift.IsLSL() && operand.IsOffset() &&
8270 // PLDW{<c>}{<q>} [<Rn>, {+/-}<Rm>{, <shift> #<amount_1>}] ; A1
8271 if (!shift.IsRRX() && shift.IsValidAmount(amount) && operand.IsOffset() &&
8277 (sign_ << 23) | (shift.GetType() << 5) | (amount_ << 7));
8282 if (shift.IsRRX() && operand.IsOffset() &&
8360 Shift shift = operand.GetShift();
8364 if (sign.IsPlus() && shift.IsLSL() && operand.IsOffset() &&
8374 if (shift.IsRRX() && operand.IsOffset() &&
8383 // PLI{<c>}{<q>} [<Rn>, {+/-}<Rm>{, <shift> #<amount_1>}] ; A1
8384 if (!shift.IsRRX() && shift.IsValidAmount(amount) && operand.IsOffset() &&
8390 (sign_ << 23) | (shift.GetType() << 5) | (amount_ << 7));
9162 Shift shift = operand.GetShift();
9165 // RSB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
9166 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9176 // RSB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9177 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9188 Shift shift = operand.GetShift();
9191 // RSB{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
9197 (shift.GetType() << 5) | (rs.GetCode() << 8));
9246 Shift shift = operand.GetShift();
9249 // RSBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T1
9250 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9260 // RSBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9261 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9272 Shift shift = operand.GetShift();
9275 // RSBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
9281 (shift.GetType() << 5) | (rs.GetCode() << 8));
9310 Shift shift = operand.GetShift();
9313 // RSC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9314 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9325 Shift shift = operand.GetShift();
9328 // RSC{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
9334 (shift.GetType() << 5) | (rs.GetCode() << 8));
9363 Shift shift = operand.GetShift();
9366 // RSCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9367 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9378 Shift shift = operand.GetShift();
9381 // RSCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
9387 (shift.GetType() << 5) | (rs.GetCode() << 8));
9509 Shift shift = operand.GetShift();
9512 // SBC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
9513 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9523 // SBC{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9524 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9535 Shift shift = operand.GetShift();
9538 // SBC{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
9544 (shift.GetType() << 5) | (rs.GetCode() << 8));
9597 Shift shift = operand.GetShift();
9600 // SBCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
9601 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
9611 // SBCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
9612 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
9623 Shift shift = operand.GetShift();
9626 // SBCS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
9632 (shift.GetType() << 5) | (rs.GetCode() << 8));
10801 Shift shift = operand.GetShift();
10805 if ((imm >= 1) && (imm <= 32) && shift.IsASR() && (amount >= 1) &&
10816 if ((imm >= 1) && (imm <= 32) && shift.IsLSL() && (amount <= 31) &&
10827 if ((imm >= 1) && (imm <= 32) && shift.IsASR() && (amount >= 1) &&
10838 if ((imm >= 1) && (imm <= 32) && shift.IsLSL() && (amount <= 31) &&
11494 Shift shift = operand.GetShift();
11498 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
11507 // STR{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}] ; A1
11511 uint32_t shift_ = TypeEncodingValue(shift);
11518 // STR{<c>}{<q>} <Rt>, [<Rn>], {+/-}<Rm>{, <shift>} ; A1
11522 uint32_t shift_ = TypeEncodingValue(shift);
11529 // STR{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}]! ; A1
11533 uint32_t shift_ = TypeEncodingValue(shift);
11655 Shift shift = operand.GetShift();
11659 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
11668 // STRB{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}] ; A1
11672 uint32_t shift_ = TypeEncodingValue(shift);
11679 // STRB{<c>}{<q>} <Rt>, [<Rn>], {+/-}<Rm>{, <shift>} ; A1
11684 uint32_t shift_ = TypeEncodingValue(shift);
11691 // STRB{<c>}{<q>} <Rt>, [<Rn>, {+/-}<Rm>{, <shift>}]! ; A1
11695 uint32_t shift_ = TypeEncodingValue(shift);
12099 Shift shift = operand.GetShift();
12103 if (!size.IsNarrow() && sign.IsPlus() && shift.IsLSL() && (amount <= 3) &&
12237 Shift shift = operand.GetShift();
12240 // SUB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
12241 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
12250 // SUB{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T1
12251 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
12261 // SUB{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
12262 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
12269 // SUB{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
12270 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
12281 Shift shift = operand.GetShift();
12284 // SUB{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
12290 (shift.GetType() << 5) | (rs.GetCode() << 8));
12398 Shift shift = operand.GetShift();
12401 // SUBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; T2
12402 if (!size.IsNarrow() && shift.IsValidAmount(amount) && !rn.Is(sp) &&
12411 // SUBS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; T1
12412 if (!size.IsNarrow() && rn.Is(sp) && shift.IsValidAmount(amount) &&
12422 // SUBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm> {, <shift> #<amount> } ; A1
12423 if (shift.IsValidAmount(amount) && cond.IsNotNever() && !rn.Is(sp)) {
12430 // SUBS{<c>}{<q>} {<Rd>}, SP, <Rm> {, <shift> #<amount> } ; A1
12431 if (rn.Is(sp) && shift.IsValidAmount(amount) && cond.IsNotNever()) {
12442 Shift shift = operand.GetShift();
12445 // SUBS{<c>}{<q>} {<Rd>}, <Rn>, <Rm>, <shift> <Rs> ; A1
12451 (shift.GetType() << 5) | (rs.GetCode() << 8));
12533 Shift shift = operand.GetShift();
12537 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12548 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12570 Shift shift = operand.GetShift();
12574 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12585 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12607 Shift shift = operand.GetShift();
12611 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12622 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12654 Shift shift = operand.GetShift();
12658 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
12669 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12687 Shift shift = operand.GetShift();
12691 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12702 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12733 Shift shift = operand.GetShift();
12737 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
12748 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
12819 Shift shift = operand.GetShift();
12822 // TEQ{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; T1
12823 if (shift.IsValidAmount(amount) &&
12833 // TEQ{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
12834 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
12845 Shift shift = operand.GetShift();
12848 // TEQ{<c>}{<q>} <Rn>, <Rm>, <shift> <Rs> ; A1
12852 (rn.GetCode() << 16) | rm.GetCode() | (shift.GetType() << 5) |
12903 Shift shift = operand.GetShift();
12906 // TST{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; T2
12907 if (!size.IsNarrow() && shift.IsValidAmount(amount) &&
12917 // TST{<c>}{<q>} <Rn>, <Rm> {, <shift> #<amount> } ; A1
12918 if (shift.IsValidAmount(amount) && cond.IsNotNever()) {
12929 Shift shift = operand.GetShift();
12932 // TST{<c>}{<q>} <Rn>, <Rm>, <shift> <Rs> ; A1
12936 (rn.GetCode() << 16) | rm.GetCode() | (shift.GetType() << 5) |
13547 Shift shift = operand.GetShift();
13551 if ((imm <= 31) && shift.IsASR() && (amount >= 1) && (amount <= 31) &&
13560 if ((imm <= 31) && shift.IsLSL() && (amount <= 31) &&
13570 if ((imm <= 31) && shift.IsASR() && (amount >= 1) && (amount <= 32) &&
13580 if ((imm <= 31) && shift.IsLSL() && (amount <= 31) && cond.IsNotNever() &&
13692 Shift shift = operand.GetShift();
13696 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13707 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13729 Shift shift = operand.GetShift();
13733 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13744 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13766 Shift shift = operand.GetShift();
13770 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13781 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13813 Shift shift = operand.GetShift();
13817 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
13828 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13846 Shift shift = operand.GetShift();
13850 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13861 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
13892 Shift shift = operand.GetShift();
13896 if (!size.IsNarrow() && (shift.IsROR() || (amount == 0)) &&
13907 if ((shift.IsROR() || (amount == 0)) && (amount <= 24) &&
21310 uint32_t shift = 4;
21312 shift = 3;
21314 uint32_t mvm = dm.GetCode() | index << shift;
21329 uint32_t shift = 4;
21331 shift = 3;
21333 uint32_t mvm = dm.GetCode() | index << shift;
21360 uint32_t shift = 4;
21362 shift = 3;
21364 uint32_t mvm = dm.GetCode() | index << shift;
21379 uint32_t shift = 4;
21381 shift = 3;
21383 uint32_t mvm = dm.GetCode() | index << shift;
21541 uint32_t shift = 4;
21543 shift = 3;
21545 uint32_t mvm = dm.GetCode() | index << shift;
21561 uint32_t shift = 4;
21563 shift = 3;
21565 uint32_t mvm = dm.GetCode() | index << shift;
22707 uint32_t shift = 4;
22709 shift = 3;
22711 uint32_t mvm = dm.GetCode() | index << shift;
22726 uint32_t shift = 4;
22728 shift = 3;
22730 uint32_t mvm = dm.GetCode() | index << shift;
22785 uint32_t shift = 4;
22787 shift = 3;
22789 uint32_t mvm = dm.GetCode() | index << shift;
22804 uint32_t shift = 4;
22806 shift = 3;
22808 uint32_t mvm = dm.GetCode() | index << shift;