[llvm] [AArch64][ISel] Prefer SVE over NEON for fixed-width ASL LSR (PR #199003)

Harry Ramsey via llvm-commits llvm-commits at lists.llvm.org
Mon Jun 22 04:25:12 PDT 2026


https://github.com/Harry-Ramsey updated https://github.com/llvm/llvm-project/pull/199003

>From 6326d55156d09a2f20cf269873cd54450e3fe6db Mon Sep 17 00:00:00 2001
From: Harry Ramsey <harry.ramsey at arm.com>
Date: Tue, 16 Jun 2026 16:03:12 +0000
Subject: [PATCH] [AArch64][ISel] Prefer SVE over NEON for fixed-width ASL LSR

Prefer SVE ASR/LSR for fixed-length vector SRA/SRL when SVE is available
whilst retaining existing NEON lowering for immediate right shifts and
negative shift-count splats.
---
 .../Target/AArch64/AArch64MIPeepholeOpt.cpp   | 142 ++++++++++++++++++
 .../AArch64/sve-fixed-length-int-shifts.ll    | 112 ++++++++------
 2 files changed, 212 insertions(+), 42 deletions(-)

diff --git a/llvm/lib/Target/AArch64/AArch64MIPeepholeOpt.cpp b/llvm/lib/Target/AArch64/AArch64MIPeepholeOpt.cpp
index 900f22abcf8b0..e9dda1e77c92a 100644
--- a/llvm/lib/Target/AArch64/AArch64MIPeepholeOpt.cpp
+++ b/llvm/lib/Target/AArch64/AArch64MIPeepholeOpt.cpp
@@ -67,11 +67,22 @@
 // 9. Replace UBFMXri with UBFMWri if the instruction is equivalent to a 32 bit
 //    LSR or LSL alias of UBFM.
 //
+// 10. Prefer SVE predicated shifts when SVE is available for fixed-length
+//     vector right shifts selected as a NEON left shift by negated amount.
+//
+//   %shift = NEGv* %amt
+//   %dst = SSHLv* %src, %shift
+//   ==>
+//   %pg = PTRUE_*, vl*
+//   %dst = ASR_ZPmZ_* %pg, %src, %amt
+//
 //===----------------------------------------------------------------------===//
 
 #include "AArch64ExpandImm.h"
 #include "AArch64InstrInfo.h"
+#include "AArch64Subtarget.h"
 #include "MCTargetDesc/AArch64AddressingModes.h"
+#include "Utils/AArch64BaseInfo.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 
@@ -81,10 +92,20 @@ using namespace llvm;
 
 namespace {
 
+struct SVEInstReplInfo {
+  unsigned NeonShiftOpc;
+  unsigned NeonNegOpc;
+  unsigned SVEShiftOpc;
+  unsigned PTrueOpc;
+  unsigned PTruePattern;
+  unsigned SubRegIdx;
+};
+
 class AArch64MIPeepholeOptImpl {
 public:
   const AArch64InstrInfo *TII;
   const AArch64RegisterInfo *TRI;
+  const AArch64Subtarget *ST;
   MachineLoopInfo *MLI;
   MachineRegisterInfo *MRI;
 
@@ -143,6 +164,7 @@ class AArch64MIPeepholeOptImpl {
   bool visitFMOVDr(MachineInstr &MI);
   bool visitUBFMXri(MachineInstr &MI);
   bool visitCopy(MachineInstr &MI);
+  bool visitNeonNegatedShift(MachineInstr &MI);
 };
 
 struct AArch64MIPeepholeOptLegacy : public MachineFunctionPass {
@@ -170,6 +192,38 @@ char AArch64MIPeepholeOptLegacy::ID = 0;
 INITIALIZE_PASS(AArch64MIPeepholeOptLegacy, "aarch64-mi-peephole-opt",
                 "AArch64 MI Peephole Optimization", false, false)
 
+static constexpr SVEInstReplInfo SVEVectorShiftReplInfo[] = {
+    {AArch64::SSHLv8i8, AArch64::NEGv8i8, AArch64::ASR_ZPmZ_B, AArch64::PTRUE_B,
+     AArch64SVEPredPattern::vl8, AArch64::dsub},
+    {AArch64::SSHLv16i8, AArch64::NEGv16i8, AArch64::ASR_ZPmZ_B,
+     AArch64::PTRUE_B, AArch64SVEPredPattern::vl16, AArch64::qsub0},
+    {AArch64::SSHLv4i16, AArch64::NEGv4i16, AArch64::ASR_ZPmZ_H,
+     AArch64::PTRUE_H, AArch64SVEPredPattern::vl4, AArch64::dsub},
+    {AArch64::SSHLv8i16, AArch64::NEGv8i16, AArch64::ASR_ZPmZ_H,
+     AArch64::PTRUE_H, AArch64SVEPredPattern::vl8, AArch64::qsub0},
+    {AArch64::SSHLv2i32, AArch64::NEGv2i32, AArch64::ASR_ZPmZ_S,
+     AArch64::PTRUE_S, AArch64SVEPredPattern::vl2, AArch64::dsub},
+    {AArch64::SSHLv4i32, AArch64::NEGv4i32, AArch64::ASR_ZPmZ_S,
+     AArch64::PTRUE_S, AArch64SVEPredPattern::vl4, AArch64::qsub0},
+    {AArch64::SSHLv2i64, AArch64::NEGv2i64, AArch64::ASR_ZPmZ_D,
+     AArch64::PTRUE_D, AArch64SVEPredPattern::vl2, AArch64::qsub0},
+
+    {AArch64::USHLv8i8, AArch64::NEGv8i8, AArch64::LSR_ZPmZ_B, AArch64::PTRUE_B,
+     AArch64SVEPredPattern::vl8, AArch64::dsub},
+    {AArch64::USHLv16i8, AArch64::NEGv16i8, AArch64::LSR_ZPmZ_B,
+     AArch64::PTRUE_B, AArch64SVEPredPattern::vl16, AArch64::qsub0},
+    {AArch64::USHLv4i16, AArch64::NEGv4i16, AArch64::LSR_ZPmZ_H,
+     AArch64::PTRUE_H, AArch64SVEPredPattern::vl4, AArch64::dsub},
+    {AArch64::USHLv8i16, AArch64::NEGv8i16, AArch64::LSR_ZPmZ_H,
+     AArch64::PTRUE_H, AArch64SVEPredPattern::vl8, AArch64::qsub0},
+    {AArch64::USHLv2i32, AArch64::NEGv2i32, AArch64::LSR_ZPmZ_S,
+     AArch64::PTRUE_S, AArch64SVEPredPattern::vl2, AArch64::dsub},
+    {AArch64::USHLv4i32, AArch64::NEGv4i32, AArch64::LSR_ZPmZ_S,
+     AArch64::PTRUE_S, AArch64SVEPredPattern::vl4, AArch64::qsub0},
+    {AArch64::USHLv2i64, AArch64::NEGv2i64, AArch64::LSR_ZPmZ_D,
+     AArch64::PTRUE_D, AArch64SVEPredPattern::vl2, AArch64::qsub0},
+};
+
 template <typename T>
 static bool splitBitmaskImm(T Imm, unsigned RegSize, T &Imm1Enc, T &Imm2Enc) {
   T UImm = static_cast<T>(Imm);
@@ -936,11 +990,94 @@ bool AArch64MIPeepholeOptImpl::visitCopy(MachineInstr &MI) {
   return true;
 }
 
+bool AArch64MIPeepholeOptImpl::visitNeonNegatedShift(MachineInstr &MI) {
+  if (!ST->isSVEorStreamingSVEAvailable())
+    return false;
+
+  const SVEInstReplInfo *Rule = nullptr;
+  for (const SVEInstReplInfo &Candidate : SVEVectorShiftReplInfo) {
+    if (MI.getOpcode() == Candidate.NeonShiftOpc) {
+      Rule = &Candidate;
+      break;
+    }
+  }
+  if (!Rule)
+    return false;
+
+  Register ShiftReg = MI.getOperand(2).getReg();
+  MachineInstr *DefMI = MRI->getUniqueVRegDef(ShiftReg);
+  if (!DefMI || DefMI->getOpcode() != Rule->NeonNegOpc)
+    return false;
+
+  if (!MRI->hasOneUse(ShiftReg))
+    return false;
+
+  MachineBasicBlock &MBB = *MI.getParent();
+  DebugLoc DL = MI.getDebugLoc();
+  Register SrcReg = MI.getOperand(1).getReg();
+  Register OldDestReg = MI.getOperand(0).getReg();
+  Register TrueShiftAmt = DefMI->getOperand(1).getReg();
+  bool Is64BitVector = Rule->SubRegIdx == AArch64::dsub;
+
+  Register PredReg = MRI->createVirtualRegister(&AArch64::PPRRegClass);
+  BuildMI(MBB, MI, DL, TII->get(Rule->PTrueOpc), PredReg)
+      .addImm(Rule->PTruePattern);
+
+  auto PromoteToZPR = [&](Register Reg) {
+    if (Is64BitVector) {
+      Register UndefQ = MRI->createVirtualRegister(&AArch64::FPR128RegClass);
+      BuildMI(MBB, MI, DL, TII->get(TargetOpcode::IMPLICIT_DEF), UndefQ);
+
+      Register QReg = MRI->createVirtualRegister(&AArch64::FPR128RegClass);
+      BuildMI(MBB, MI, DL, TII->get(TargetOpcode::INSERT_SUBREG), QReg)
+          .addReg(UndefQ)
+          .addReg(Reg)
+          .addImm(AArch64::dsub);
+      Reg = QReg;
+    }
+
+    Register UndefZ = MRI->createVirtualRegister(&AArch64::ZPRRegClass);
+    BuildMI(MBB, MI, DL, TII->get(TargetOpcode::IMPLICIT_DEF), UndefZ);
+
+    Register ZReg = MRI->createVirtualRegister(&AArch64::ZPRRegClass);
+    BuildMI(MBB, MI, DL, TII->get(TargetOpcode::INSERT_SUBREG), ZReg)
+        .addReg(UndefZ)
+        .addReg(Reg)
+        .addImm(AArch64::zsub);
+    return ZReg;
+  };
+
+  Register ZSrc = PromoteToZPR(SrcReg);
+  Register ZAmt = PromoteToZPR(TrueShiftAmt);
+
+  Register ZDst = MRI->createVirtualRegister(&AArch64::ZPRRegClass);
+  BuildMI(MBB, MI, DL, TII->get(Rule->SVEShiftOpc), ZDst)
+      .addReg(PredReg)
+      .addReg(ZSrc)
+      .addReg(ZAmt);
+
+  if (Is64BitVector) {
+    Register QReg = MRI->createVirtualRegister(&AArch64::FPR128RegClass);
+    BuildMI(MBB, MI, DL, TII->get(TargetOpcode::COPY), QReg)
+        .addReg(ZDst, RegState::NoFlags, AArch64::zsub);
+    BuildMI(MBB, MI, DL, TII->get(TargetOpcode::COPY), OldDestReg)
+        .addReg(QReg, RegState::NoFlags, AArch64::dsub);
+  } else {
+    BuildMI(MBB, MI, DL, TII->get(TargetOpcode::COPY), OldDestReg)
+        .addReg(ZDst, RegState::NoFlags, AArch64::zsub);
+  }
+
+  MI.eraseFromParent();
+  DefMI->eraseFromParent();
+  return true;
+}
+
 bool AArch64MIPeepholeOptImpl::run(MachineFunction &MF) {
   TII = static_cast<const AArch64InstrInfo *>(MF.getSubtarget().getInstrInfo());
   TRI = static_cast<const AArch64RegisterInfo *>(
       MF.getSubtarget().getRegisterInfo());
   MRI = &MF.getRegInfo();
+  ST = &MF.getSubtarget<AArch64Subtarget>();
 
   assert(MRI->isSSA() && "Expected to be run on SSA form!");
 
@@ -948,6 +1085,11 @@ bool AArch64MIPeepholeOptImpl::run(MachineFunction &MF) {
 
   for (MachineBasicBlock &MBB : MF) {
     for (MachineInstr &MI : make_early_inc_range(MBB)) {
+      if (visitNeonNegatedShift(MI)) {
+        Changed = true;
+        continue;
+      }
+
       switch (MI.getOpcode()) {
       default:
         break;
diff --git a/llvm/test/CodeGen/AArch64/sve-fixed-length-int-shifts.ll b/llvm/test/CodeGen/AArch64/sve-fixed-length-int-shifts.ll
index a8afa90df96e4..dcfae2c71be0e 100644
--- a/llvm/test/CodeGen/AArch64/sve-fixed-length-int-shifts.ll
+++ b/llvm/test/CodeGen/AArch64/sve-fixed-length-int-shifts.ll
@@ -9,23 +9,27 @@ target triple = "aarch64-unknown-linux-gnu"
 ; ASHR
 ;
 
-; Don't use SVE for 64-bit vectors.
 define <8 x i8> @ashr_v8i8(<8 x i8> %op1, <8 x i8> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: ashr_v8i8:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.8b, v1.8b
-; CHECK-NEXT:    sshl v0.8b, v0.8b, v1.8b
+; CHECK-NEXT:    ptrue p0.b, vl8
+; CHECK-NEXT:    // kill: def $d0 killed $d0 def $z0
+; CHECK-NEXT:    // kill: def $d1 killed $d1 def $z1
+; CHECK-NEXT:    asr z0.b, p0/m, z0.b, z1.b
+; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $z0
 ; CHECK-NEXT:    ret
   %res = ashr <8 x i8> %op1, %op2
   ret <8 x i8> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <16 x i8> @ashr_v16i8(<16 x i8> %op1, <16 x i8> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: ashr_v16i8:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.16b, v1.16b
-; CHECK-NEXT:    sshl v0.16b, v0.16b, v1.16b
+; CHECK-NEXT:    ptrue p0.b, vl16
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    asr z0.b, p0/m, z0.b, z1.b
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = ashr <16 x i8> %op1, %op2
   ret <16 x i8> %res
@@ -109,23 +113,27 @@ define void @ashr_v256i8(ptr %a, ptr %b) vscale_range(16,0) #0 {
   ret void
 }
 
-; Don't use SVE for 64-bit vectors.
 define <4 x i16> @ashr_v4i16(<4 x i16> %op1, <4 x i16> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: ashr_v4i16:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.4h, v1.4h
-; CHECK-NEXT:    sshl v0.4h, v0.4h, v1.4h
+; CHECK-NEXT:    ptrue p0.h, vl4
+; CHECK-NEXT:    // kill: def $d0 killed $d0 def $z0
+; CHECK-NEXT:    // kill: def $d1 killed $d1 def $z1
+; CHECK-NEXT:    asr z0.h, p0/m, z0.h, z1.h
+; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $z0
 ; CHECK-NEXT:    ret
   %res = ashr <4 x i16> %op1, %op2
   ret <4 x i16> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <8 x i16> @ashr_v8i16(<8 x i16> %op1, <8 x i16> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: ashr_v8i16:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.8h, v1.8h
-; CHECK-NEXT:    sshl v0.8h, v0.8h, v1.8h
+; CHECK-NEXT:    ptrue p0.h, vl8
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    asr z0.h, p0/m, z0.h, z1.h
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = ashr <8 x i16> %op1, %op2
   ret <8 x i16> %res
@@ -209,23 +217,27 @@ define void @ashr_v128i16(ptr %a, ptr %b) vscale_range(16,0) #0 {
   ret void
 }
 
-; Don't use SVE for 64-bit vectors.
 define <2 x i32> @ashr_v2i32(<2 x i32> %op1, <2 x i32> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: ashr_v2i32:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.2s, v1.2s
-; CHECK-NEXT:    sshl v0.2s, v0.2s, v1.2s
+; CHECK-NEXT:    ptrue p0.s, vl2
+; CHECK-NEXT:    // kill: def $d0 killed $d0 def $z0
+; CHECK-NEXT:    // kill: def $d1 killed $d1 def $z1
+; CHECK-NEXT:    asr z0.s, p0/m, z0.s, z1.s
+; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $z0
 ; CHECK-NEXT:    ret
   %res = ashr <2 x i32> %op1, %op2
   ret <2 x i32> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <4 x i32> @ashr_v4i32(<4 x i32> %op1, <4 x i32> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: ashr_v4i32:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.4s, v1.4s
-; CHECK-NEXT:    sshl v0.4s, v0.4s, v1.4s
+; CHECK-NEXT:    ptrue p0.s, vl4
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    asr z0.s, p0/m, z0.s, z1.s
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = ashr <4 x i32> %op1, %op2
   ret <4 x i32> %res
@@ -320,12 +332,14 @@ define <1 x i64> @ashr_v1i64(<1 x i64> %op1, <1 x i64> %op2) vscale_range(2,0) #
   ret <1 x i64> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <2 x i64> @ashr_v2i64(<2 x i64> %op1, <2 x i64> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: ashr_v2i64:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.2d, v1.2d
-; CHECK-NEXT:    sshl v0.2d, v0.2d, v1.2d
+; CHECK-NEXT:    ptrue p0.d, vl2
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    asr z0.d, p0/m, z0.d, z1.d
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = ashr <2 x i64> %op1, %op2
   ret <2 x i64> %res
@@ -413,23 +427,27 @@ define void @ashr_v32i64(ptr %a, ptr %b) vscale_range(16,0) #0 {
 ; LSHR
 ;
 
-; Don't use SVE for 64-bit vectors.
 define <8 x i8> @lshr_v8i8(<8 x i8> %op1, <8 x i8> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: lshr_v8i8:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.8b, v1.8b
-; CHECK-NEXT:    ushl v0.8b, v0.8b, v1.8b
+; CHECK-NEXT:    ptrue p0.b, vl8
+; CHECK-NEXT:    // kill: def $d0 killed $d0 def $z0
+; CHECK-NEXT:    // kill: def $d1 killed $d1 def $z1
+; CHECK-NEXT:    lsr z0.b, p0/m, z0.b, z1.b
+; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $z0
 ; CHECK-NEXT:    ret
   %res = lshr <8 x i8> %op1, %op2
   ret <8 x i8> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <16 x i8> @lshr_v16i8(<16 x i8> %op1, <16 x i8> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: lshr_v16i8:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.16b, v1.16b
-; CHECK-NEXT:    ushl v0.16b, v0.16b, v1.16b
+; CHECK-NEXT:    ptrue p0.b, vl16
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    lsr z0.b, p0/m, z0.b, z1.b
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = lshr <16 x i8> %op1, %op2
   ret <16 x i8> %res
@@ -513,23 +531,27 @@ define void @lshr_v256i8(ptr %a, ptr %b) vscale_range(16,0) #0 {
   ret void
 }
 
-; Don't use SVE for 64-bit vectors.
 define <4 x i16> @lshr_v4i16(<4 x i16> %op1, <4 x i16> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: lshr_v4i16:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.4h, v1.4h
-; CHECK-NEXT:    ushl v0.4h, v0.4h, v1.4h
+; CHECK-NEXT:    ptrue p0.h, vl4
+; CHECK-NEXT:    // kill: def $d0 killed $d0 def $z0
+; CHECK-NEXT:    // kill: def $d1 killed $d1 def $z1
+; CHECK-NEXT:    lsr z0.h, p0/m, z0.h, z1.h
+; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $z0
 ; CHECK-NEXT:    ret
   %res = lshr <4 x i16> %op1, %op2
   ret <4 x i16> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <8 x i16> @lshr_v8i16(<8 x i16> %op1, <8 x i16> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: lshr_v8i16:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.8h, v1.8h
-; CHECK-NEXT:    ushl v0.8h, v0.8h, v1.8h
+; CHECK-NEXT:    ptrue p0.h, vl8
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    lsr z0.h, p0/m, z0.h, z1.h
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = lshr <8 x i16> %op1, %op2
   ret <8 x i16> %res
@@ -613,23 +635,27 @@ define void @lshr_v128i16(ptr %a, ptr %b) vscale_range(16,0) #0 {
   ret void
 }
 
-; Don't use SVE for 64-bit vectors.
 define <2 x i32> @lshr_v2i32(<2 x i32> %op1, <2 x i32> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: lshr_v2i32:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.2s, v1.2s
-; CHECK-NEXT:    ushl v0.2s, v0.2s, v1.2s
+; CHECK-NEXT:    ptrue p0.s, vl2
+; CHECK-NEXT:    // kill: def $d0 killed $d0 def $z0
+; CHECK-NEXT:    // kill: def $d1 killed $d1 def $z1
+; CHECK-NEXT:    lsr z0.s, p0/m, z0.s, z1.s
+; CHECK-NEXT:    // kill: def $d0 killed $d0 killed $z0
 ; CHECK-NEXT:    ret
   %res = lshr <2 x i32> %op1, %op2
   ret <2 x i32> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <4 x i32> @lshr_v4i32(<4 x i32> %op1, <4 x i32> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: lshr_v4i32:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.4s, v1.4s
-; CHECK-NEXT:    ushl v0.4s, v0.4s, v1.4s
+; CHECK-NEXT:    ptrue p0.s, vl4
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    lsr z0.s, p0/m, z0.s, z1.s
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = lshr <4 x i32> %op1, %op2
   ret <4 x i32> %res
@@ -724,12 +750,14 @@ define <1 x i64> @lshr_v1i64(<1 x i64> %op1, <1 x i64> %op2) vscale_range(2,0) #
   ret <1 x i64> %res
 }
 
-; Don't use SVE for 128-bit vectors.
 define <2 x i64> @lshr_v2i64(<2 x i64> %op1, <2 x i64> %op2) vscale_range(2,0) #0 {
 ; CHECK-LABEL: lshr_v2i64:
 ; CHECK:       // %bb.0:
-; CHECK-NEXT:    neg v1.2d, v1.2d
-; CHECK-NEXT:    ushl v0.2d, v0.2d, v1.2d
+; CHECK-NEXT:    ptrue p0.d, vl2
+; CHECK-NEXT:    // kill: def $q0 killed $q0 def $z0
+; CHECK-NEXT:    // kill: def $q1 killed $q1 def $z1
+; CHECK-NEXT:    lsr z0.d, p0/m, z0.d, z1.d
+; CHECK-NEXT:    // kill: def $q0 killed $q0 killed $z0
 ; CHECK-NEXT:    ret
   %res = lshr <2 x i64> %op1, %op2
   ret <2 x i64> %res



More information about the llvm-commits mailing list