[ARM] Optimise ASRL/LSRL to smaller shifts using demand bits.

[dmgreen]

Summary

The ASRL/LSRL long shifts are generated from 64bit shifts. Once we have them, it might turn out that enough of the 64bit result was not required that we can use a smaller shift to perform the same result. As the smaller shift can in general be folded in more way, such as into add instructions in one of the test cases here, we can use the demand bit analysis to prefer the smaller shifts where we can.

[samparker]

Are there tests for shifts greater than 31? And don't we do some weird stuff with negative shifts, or is that just with custom nodes?

llvm/lib/Target/ARM/ARMISelLowering.h

358

Doesn't this need override?

[dmgreen]

Whoops. That was the wrong number on that commit.

[dmgreen]

Rebase to on top of D75553 (I had not really considered them together when I wrote that, only from the times we would generate the nodes from shifts. From intrinsics more cases can come up). It makes sense to do that one first as this has become more complex.

I have tried to add a few of the obvious cases that I thought might come up, when parts of the shift are not used. The intrinsics are really designed for variable shifts but they can become constant during optimisation (and the first example I saw of someone using them was asrl(X, 23), as opposed to using a standard shift).

This doesn't feel like the prettiest code I've ever written. Suggestions welcome.

[samparker]

llvm/lib/Target/ARM/ARMISelLowering.cpp

14124

For readability, maybe introduce a lambda to help create the shift and do the replacement? Some aptly named variables for shift ranges and whether we're doing a logical/left/right shift could also help.

[dmgreen]

I decided that this was really doing two separate things, and should split it back in two. This it the first (not so ugly) part for the time being. I will try to get to the second part later.

[samparker]

Simplified the simplify! LGTM

[dmgreen]

Thanks

llvm/lib/Target/ARM/ARMISelLowering.h

public:
     void AdjustInstrPostInstrSelection(MachineInstr &MI,
                                        SDNode *Node) const override;
 
     SDValue PerformCMOVCombine(SDNode *N, SelectionDAG &DAG) const;
     SDValue PerformBRCONDCombine(SDNode *N, SelectionDAG &DAG) const;
     SDValue PerformCMOVToBFICombine(SDNode *N, SelectionDAG &DAG) const;
     SDValue PerformDAGCombine(SDNode *N, DAGCombinerInfo &DCI) const override;
 
+    bool SimplifyDemandedBitsForTargetNode(SDValue Op,
+                                           const APInt &OriginalDemandedBits,
+                                           const APInt &OriginalDemandedElts,
+                                           KnownBits &Known,
+                                           TargetLoweringOpt &TLO,
+                                           unsigned Depth) const override;
+
     bool isDesirableToTransformToIntegerOp(unsigned Opc, EVT VT) const override;
 
     /// allowsMisalignedMemoryAccesses - Returns true if the target allows
     /// unaligned memory accesses of the specified type. Returns whether it
     /// is "fast" by reference in the second argument.
     bool allowsMisalignedMemoryAccesses(EVT VT, unsigned AddrSpace,
                                         unsigned Align,
                                         MachineMemOperand::Flags Flags,

llvm/lib/Target/ARM/ARMISelLowering.cpp

static SDValue PerformVECREDUCE_ADDCombine(SDNode *N, SelectionDAG &DAG,
   return SDValue();
 }
 
 static SDValue PerformLongShiftCombine(SDNode *N, SelectionDAG &DAG) {
   SDLoc DL(N);
   SDValue Op0 = N->getOperand(0);
   SDValue Op1 = N->getOperand(1);
 
-  // Turn X << -C -> X >> C and viceversa. The negative shifts can come up from
-  // uses of the intrinsics.
   if (auto C = dyn_cast<ConstantSDNode>(N->getOperand(2))) {
     int ShiftAmt = C->getSExtValue();
+
+    // Shift by 0 is just the inputs
     if (ShiftAmt == 0) {
       SDValue Merge = DAG.getMergeValues({Op0, Op1}, DL);
       DAG.ReplaceAllUsesWith(N, Merge.getNode());
       return SDValue();
     }
 
+    // Turn X << -C -> X >> C and viceversa. The negative shifts can come up
+    // from uses of the intrinsics.
     if (ShiftAmt >= -32 && ShiftAmt < 0) {
       unsigned NewOpcode =
           N->getOpcode() == ARMISD::LSLL ? ARMISD::LSRL : ARMISD::LSLL;
       SDValue NewShift = DAG.getNode(NewOpcode, DL, N->getVTList(), Op0, Op1,
                                      DAG.getConstant(-ShiftAmt, DL, MVT::i32));
       DAG.ReplaceAllUsesWith(N, NewShift.getNode());
       return NewShift;
     }
+
+    // If we do not use part of the result, turn the other half into a smaller
+    // shift or a mov, depending on the constant.
+    if (!N->hasAnyUseOfValue(0)) {
+      if (N->getOpcode() == ARMISD::LSRL || N->getOpcode() == ARMISD::ASRL) {
+        if (ShiftAmt >= 0 && ShiftAmt < 32) {
+          unsigned NewOpcode =
+              N->getOpcode() == ARMISD::ASRL ? ISD::SRA : ISD::SRL;
+          SDValue NewShift = DAG.getNode(NewOpcode, DL, MVT::i32, Op1,
+                                        DAG.getConstant(ShiftAmt, DL, MVT::i32));
+          DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), NewShift);
+          return SDValue();
+        } else if (ShiftAmt > 32 && ShiftAmt < 64) {
+          if (N->getOpcode() == ARMISD::ASRL) {
+            SDValue NewShift = DAG.getNode(ISD::SRA, DL, MVT::i32, Op1,
+                                          DAG.getConstant(31, DL, MVT::i32));
+            DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), NewShift);
+            return SDValue();
+          } else {
+            DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1),
+                                          DAG.getConstant(0, DL, MVT::i32));
+            return SDValue();
+          }
+        }
+      }
+      else {
+        if (ShiftAmt == 32) {
+          DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), Op0);
+          return SDValue();
+        } else if (ShiftAmt > 32 && ShiftAmt < 64) {
+          SDValue NewShift = DAG.getNode(ISD::SHL, DL, MVT::i32, Op0,
+                                        DAG.getConstant(ShiftAmt - 32, DL, MVT::i32));
+          DAG.ReplaceAllUsesOfValueWith(SDValue(N, 1), NewShift);
+          return SDValue();
+        }
+      }
+    }
+    if (!N->hasAnyUseOfValue(1)) {
+      if (N->getOpcode() == ARMISD::LSLL) {
+        if (ShiftAmt >= 0 && ShiftAmt < 32) {
+          SDValue NewShift = DAG.getNode(ISD::SHL, DL, MVT::i32, Op0,
+                                        DAG.getConstant(ShiftAmt, DL, MVT::i32));
+          DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), NewShift);
+          return SDValue();
+        }
+        else if (ShiftAmt >= 32 && ShiftAmt < 64) {
+          DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0),
+                                        DAG.getConstant(0, DL, MVT::i32));
+          return SDValue();
+        }
+      } else {
+        if (ShiftAmt == 32) {
+          DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), Op1);
+          return SDValue();
+        } else if (ShiftAmt > 32 && ShiftAmt < 64) {
+          unsigned NewOpcode =
+              N->getOpcode() == ARMISD::ASRL ? ISD::SRA : ISD::SRL;
+          SDValue NewShift = DAG.getNode(NewOpcode, DL, MVT::i32, Op1,
+                                        DAG.getConstant(ShiftAmt - 32, DL, MVT::i32));
+          DAG.ReplaceAllUsesOfValueWith(SDValue(N, 0), NewShift);
+          return SDValue();
+        }
+      }
+    }
   }
 
   return SDValue();
 }
 
 /// PerformIntrinsicCombine - ARM-specific DAG combining for intrinsics.
 static SDValue PerformIntrinsicCombine(SDNode *N, SelectionDAG &DAG) {
   unsigned IntNo = cast<ConstantSDNode>(N->getOperand(0))->getZExtValue();
ARMTargetLowering::targetShrinkDemandedConstant(SDValue Op,
   // We could try to recognize lsls+lsrs or lsrs+lsls pairs here.
   // We could try to prefer Thumb1 immediates which can be lowered to a
   // two-instruction sequence.
   // We could try to recognize more legal ARM/Thumb2 immediates here.
 
   return false;
 }
 
+bool ARMTargetLowering::SimplifyDemandedBitsForTargetNode(
+    SDValue Op, const APInt &OriginalDemandedBits,
+    const APInt &OriginalDemandedElts, KnownBits &Known, TargetLoweringOpt &TLO,
+    unsigned Depth) const {
+  unsigned Opc = Op.getOpcode();
+
+  switch (Opc) {
+  case ARMISD::ASRL:
+  case ARMISD::LSRL: {
+    // If this is result 0 and the other result is unused, see if the demand
+    // bits allow us to shrink this long shift into a standard small shift in
+    // the opposite direction.
+    if (Op.getResNo() == 0 && !Op->hasAnyUseOfValue(1) &&
+        isa<ConstantSDNode>(Op->getOperand(2))) {
+      unsigned ShAmt = Op->getConstantOperandVal(2);
+      if (ShAmt < 32 && OriginalDemandedBits.isSubsetOf(
+                             APInt::getAllOnesValue(32) << (32 - ShAmt)))
+        return TLO.CombineTo(
+            Op, TLO.DAG.getNode(
+                    ISD::SHL, SDLoc(Op), MVT::i32, Op.getOperand(1),
+                    TLO.DAG.getConstant(32 - ShAmt, SDLoc(Op), MVT::i32)));
+    }
+    break;
+  }
+  }
+
+  return TargetLowering::SimplifyDemandedBitsForTargetNode(
+      Op, OriginalDemandedBits, OriginalDemandedElts, Known, TLO, Depth);
+}
 
 //===----------------------------------------------------------------------===//
 //                           ARM Inline Assembly Support
 //===----------------------------------------------------------------------===//
 
 bool ARMTargetLowering::ExpandInlineAsm(CallInst *CI) const {
   // Looking for "rev" which is V6+.
   if (!Subtarget->hasV6Ops())

llvm/test/CodeGen/Thumb2/fir.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc --verify-machineinstrs -mtriple=thumbv8.1m.main-none-eabi -mattr=+mve %s -o - | FileCheck %s -check-prefix=CHECK --check-prefix=CHECK-MVE
 ; RUN: llc --verify-machineinstrs -mtriple=thumbv8.1m.main-none-eabi -mattr=+dsp %s -o - | FileCheck %s -check-prefix=CHECK --check-prefix=CHECK-NOMVE
 
 define void @test1(i32* %p0, i32 *%p1, i32 *%p2, i32 *%pDst) {
-; CHECK-MVE-LABEL: test1:
-; CHECK-MVE:       @ %bb.0: @ %entry
-; CHECK-MVE-NEXT:    ldr r1, [r1]
-; CHECK-MVE-NEXT:    ldr r2, [r2]
-; CHECK-MVE-NEXT:    ldr r0, [r0]
-; CHECK-MVE-NEXT:    smull r2, r1, r2, r1
-; CHECK-MVE-NEXT:    lsrl r2, r1, #31
-; CHECK-MVE-NEXT:    bic r1, r2, #1
-; CHECK-MVE-NEXT:    add r0, r1
-; CHECK-MVE-NEXT:    str r0, [r3]
-; CHECK-MVE-NEXT:    bx lr
-;
-; CHECK-NOMVE-LABEL: test1:
-; CHECK-NOMVE:       @ %bb.0: @ %entry
-; CHECK-NOMVE-NEXT:    ldr r1, [r1]
-; CHECK-NOMVE-NEXT:    ldr r2, [r2]
-; CHECK-NOMVE-NEXT:    ldr r0, [r0]
-; CHECK-NOMVE-NEXT:    smmul r1, r2, r1
-; CHECK-NOMVE-NEXT:    add.w r0, r0, r1, lsl #1
-; CHECK-NOMVE-NEXT:    str r0, [r3]
-; CHECK-NOMVE-NEXT:    bx lr
+; CHECK-LABEL: test1:
+; CHECK:       @ %bb.0: @ %entry
+; CHECK-NEXT:    ldr r1, [r1]
+; CHECK-NEXT:    ldr r2, [r2]
+; CHECK-NEXT:    ldr r0, [r0]
+; CHECK-NEXT:    smmul r1, r2, r1
+; CHECK-NEXT:    add.w r0, r0, r1, lsl #1
+; CHECK-NEXT:    str r0, [r3]
+; CHECK-NEXT:    bx lr
 entry:
   %l3 = load i32, i32* %p0, align 4
   %l4 = load i32, i32* %p1, align 4
   %conv5.us = sext i32 %l4 to i64
   %l5 = load i32, i32* %p2, align 4
   %conv6.us = sext i32 %l5 to i64
   %mul.us = mul nsw i64 %conv6.us, %conv5.us
   %l6 = lshr i64 %mul.us, 31

llvm/test/CodeGen/Thumb2/mve-intrinsics/longshift-demand.ll

entry:
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_bottom3(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottom3:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #3
+; CHECK-NEXT:    lsls r0, r0, #3
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 3)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @ashr_demand_bottomm3(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottomm3:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #3
+; CHECK-NEXT:    lsls r0, r0, #3
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 -3)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_bottom31(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottom31:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #31
+; CHECK-NEXT:    lsls r0, r0, #31
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 31)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @ashr_demand_bottomm31(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottomm31:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #31
+; CHECK-NEXT:    lsls r0, r0, #31
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 -31)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 
 define i32 @ashr_demand_bottom32(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottom32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    asrl r0, r1, #32
+; CHECK-NEXT:    mov r0, r1
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_bottom32(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottom32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #32
+; CHECK-NEXT:    movs r0, #0
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @ashr_demand_bottomm32(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottomm32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #32
+; CHECK-NEXT:    movs r0, #0
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 -32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_bottomm32(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottomm32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsrl r0, r1, #32
+; CHECK-NEXT:    mov r0, r1
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 -32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 
 define i32 @ashr_demand_bottom44(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottom44:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    movs r2, #44
-; CHECK-NEXT:    asrl r0, r1, r2
+; CHECK-NEXT:    asrs r0, r1, #12
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 44)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_bottom44(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottom44:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    movs r2, #44
-; CHECK-NEXT:    lsll r0, r1, r2
+; CHECK-NEXT:    movs r0, #0
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 44)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64

 
 
 
 
 
 define i32 @ashr_demand_top3(i64 %X) {
 ; CHECK-LABEL: ashr_demand_top3:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    asrl r0, r1, #3
-; CHECK-NEXT:    mov r0, r1
+; CHECK-NEXT:    asrs r0, r1, #3
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 3)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %sm = lshr i64 %shr, 32
   %t = trunc i64 %sm to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_topm3(i64 %X) {
 ; CHECK-LABEL: lsll_demand_topm3:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsrl r0, r1, #3
-; CHECK-NEXT:    mov r0, r1
+; CHECK-NEXT:    lsrs r0, r1, #3
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 -3)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %sm = lshr i64 %shr, 32
   %t = trunc i64 %sm to i32
   ret i32 %t
 }
 
 
 define i32 @ashr_demand_top31(i64 %X) {
 ; CHECK-LABEL: ashr_demand_top31:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    asrl r0, r1, #31
-; CHECK-NEXT:    mov r0, r1
+; CHECK-NEXT:    asrs r0, r1, #31
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 31)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %sm = lshr i64 %shr, 32
   %t = trunc i64 %sm to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_topm31(i64 %X) {
 ; CHECK-LABEL: lsll_demand_topm31:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsrl r0, r1, #31
-; CHECK-NEXT:    mov r0, r1
+; CHECK-NEXT:    lsrs r0, r1, #31
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 -31)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %sm = lshr i64 %shr, 32
   %t = trunc i64 %sm to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_top32(i64 %X) {
 ; CHECK-LABEL: lsll_demand_top32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #32
-; CHECK-NEXT:    mov r0, r1
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %sm = lshr i64 %shr, 32
   %t = trunc i64 %sm to i32
   ret i32 %t
 }
 
 define i32 @ashr_demand_topm32(i64 %X) {
 ; CHECK-LABEL: ashr_demand_topm32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #32
-; CHECK-NEXT:    mov r0, r1
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 -32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %t = trunc i64 %sm to i32
   ret i32 %t
 }
 
 
 define i32 @ashr_demand_top44(i64 %X) {
 ; CHECK-LABEL: ashr_demand_top44:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    movs r2, #44
-; CHECK-NEXT:    asrl r0, r1, r2
-; CHECK-NEXT:    mov r0, r1
+; CHECK-NEXT:    asrs r0, r1, #31
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 44)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %sm = lshr i64 %shr, 32
   %t = trunc i64 %sm to i32
   ret i32 %t
 }
 
 define i32 @lsll_demand_top44(i64 %X) {
 ; CHECK-LABEL: lsll_demand_top44:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    movs r2, #44
-; CHECK-NEXT:    lsll r0, r1, r2
-; CHECK-NEXT:    mov r0, r1
+; CHECK-NEXT:    lsls r0, r0, #12
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 44)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @lsll_demand_bottommask3(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottommask3:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #3
-; CHECK-NEXT:    bic r0, r0, #1
+; CHECK-NEXT:    lsls r0, r0, #3
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 3)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @ashr_demand_bottommaskm3(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottommaskm3:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #3
-; CHECK-NEXT:    bic r0, r0, #1
+; CHECK-NEXT:    lsls r0, r0, #3
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 -3)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
entry:
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 
 define i32 @ashr_demand_bottommask32(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottommask32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    asrl r0, r1, #32
-; CHECK-NEXT:    bic r0, r0, #1
+; CHECK-NEXT:    bic r0, r1, #1
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @lsll_demand_bottommask32(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottommask32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #32
-; CHECK-NEXT:    bic r0, r0, #1
+; CHECK-NEXT:    movs r0, #0
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @ashr_demand_bottommaskm32(i64 %X) {
 ; CHECK-LABEL: ashr_demand_bottommaskm32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsll r0, r1, #32
-; CHECK-NEXT:    bic r0, r0, #1
+; CHECK-NEXT:    movs r0, #0
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.asrl(i32 %2, i32 %1, i32 -32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @lsll_demand_bottommaskm32(i64 %X) {
 ; CHECK-LABEL: lsll_demand_bottommaskm32:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    lsrl r0, r1, #32
-; CHECK-NEXT:    bic r0, r0, #1
+; CHECK-NEXT:    bic r0, r1, #1
 ; CHECK-NEXT:    bx lr
 entry:
   %0 = lshr i64 %X, 32
   %1 = trunc i64 %0 to i32
   %2 = trunc i64 %X to i32
   %3 = call { i32, i32 } @llvm.arm.mve.lsll(i32 %2, i32 %1, i32 -32)
   %4 = extractvalue { i32, i32 } %3, 1
   %5 = zext i32 %4 to i64
   %6 = shl nuw i64 %5, 32
   %7 = extractvalue { i32, i32 } %3, 0
   %8 = zext i32 %7 to i64
   %shr = or i64 %6, %8
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }

llvm/test/CodeGen/Thumb2/shift_parts.ll

 entry:
   %shr = shl i64 %x, 44
   %t = trunc i64 %shr to i32
   ret i32 %t
 }
 
 
 define i32 @ashr_demand_bottommask(i64 %x) {
-; CHECK-MVE-LABEL: ashr_demand_bottommask:
-; CHECK-MVE:       @ %bb.0: @ %entry
-; CHECK-MVE-NEXT:    lsrl r0, r1, #31
-; CHECK-MVE-NEXT:    bic r0, r0, #1
-; CHECK-MVE-NEXT:    bx lr
-;
-; CHECK-NON-MVE-LABEL: ashr_demand_bottommask:
-; CHECK-NON-MVE:       @ %bb.0: @ %entry
-; CHECK-NON-MVE-NEXT:    lsls r0, r1, #1
-; CHECK-NON-MVE-NEXT:    bx lr
+; CHECK-LABEL: ashr_demand_bottommask:
+; CHECK:       @ %bb.0: @ %entry
+; CHECK-NEXT:    lsls r0, r1, #1
+; CHECK-NEXT:    bx lr
 entry:
   %shr = ashr i64 %x, 31
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @lshr_demand_bottommask(i64 %x) {
-; CHECK-MVE-LABEL: lshr_demand_bottommask:
-; CHECK-MVE:       @ %bb.0: @ %entry
-; CHECK-MVE-NEXT:    lsrl r0, r1, #31
-; CHECK-MVE-NEXT:    bic r0, r0, #1
-; CHECK-MVE-NEXT:    bx lr
-;
-; CHECK-NON-MVE-LABEL: lshr_demand_bottommask:
-; CHECK-NON-MVE:       @ %bb.0: @ %entry
-; CHECK-NON-MVE-NEXT:    lsls r0, r1, #1
-; CHECK-NON-MVE-NEXT:    bx lr
+; CHECK-LABEL: lshr_demand_bottommask:
+; CHECK:       @ %bb.0: @ %entry
+; CHECK-NEXT:    lsls r0, r1, #1
+; CHECK-NEXT:    bx lr
 entry:
   %shr = lshr i64 %x, 31
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @lsl_demand_bottommask(i64 %x) {
 ; CHECK-LABEL: lsl_demand_bottommask:
 ; CHECK:       @ %bb.0: @ %entry
 ; CHECK-NEXT:    lsls r0, r0, #31
 ; CHECK-NEXT:    bx lr
 entry:
   %shr = shl i64 %x, 31
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -2
   ret i32 %a
 }
 
 define i32 @ashr_demand_bottommask2(i64 %x) {
-; CHECK-MVE-LABEL: ashr_demand_bottommask2:
-; CHECK-MVE:       @ %bb.0: @ %entry
-; CHECK-MVE-NEXT:    lsrl r0, r1, #31
-; CHECK-MVE-NEXT:    bic r0, r0, #3
-; CHECK-MVE-NEXT:    bx lr
-;
-; CHECK-NON-MVE-LABEL: ashr_demand_bottommask2:
-; CHECK-NON-MVE:       @ %bb.0: @ %entry
-; CHECK-NON-MVE-NEXT:    mvn r0, #2
-; CHECK-NON-MVE-NEXT:    and.w r0, r0, r1, lsl #1
-; CHECK-NON-MVE-NEXT:    bx lr
+; CHECK-LABEL: ashr_demand_bottommask2:
+; CHECK:       @ %bb.0: @ %entry
+; CHECK-NEXT:    mvn r0, #2
+; CHECK-NEXT:    and.w r0, r0, r1, lsl #1
+; CHECK-NEXT:    bx lr
 entry:
   %shr = ashr i64 %x, 31
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -4
   ret i32 %a
 }
 
 define i32 @lshr_demand_bottommask2(i64 %x) {
-; CHECK-MVE-LABEL: lshr_demand_bottommask2:
-; CHECK-MVE:       @ %bb.0: @ %entry
-; CHECK-MVE-NEXT:    lsrl r0, r1, #31
-; CHECK-MVE-NEXT:    bic r0, r0, #3
-; CHECK-MVE-NEXT:    bx lr
-;
-; CHECK-NON-MVE-LABEL: lshr_demand_bottommask2:
-; CHECK-NON-MVE:       @ %bb.0: @ %entry
-; CHECK-NON-MVE-NEXT:    mvn r0, #2
-; CHECK-NON-MVE-NEXT:    and.w r0, r0, r1, lsl #1
-; CHECK-NON-MVE-NEXT:    bx lr
+; CHECK-LABEL: lshr_demand_bottommask2:
+; CHECK:       @ %bb.0: @ %entry
+; CHECK-NEXT:    mvn r0, #2
+; CHECK-NEXT:    and.w r0, r0, r1, lsl #1
+; CHECK-NEXT:    bx lr
 entry:
   %shr = lshr i64 %x, 31
   %t = trunc i64 %shr to i32
   %a = and i32 %t, -4
   ret i32 %a
 }
 
 define i32 @lsl_demand_bottommask2(i64 %x) {