[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