[llvm] [RISCV][CodeGen] Add initial CodeGen support of vunzip{e,o} (PR #196024)
Boyao Wang via llvm-commits
llvm-commits at lists.llvm.org
Wed May 6 01:30:38 PDT 2026
https://github.com/BoyaoWang430 created https://github.com/llvm/llvm-project/pull/196024
Add initial support for vunzip{e,o} instructions, which are included in zvzip extension.
>From 81a7001033677566d0040436ffd9c03ea93ae861 Mon Sep 17 00:00:00 2001
From: wangboyao <wangboyao at bytedance.com>
Date: Wed, 6 May 2026 16:20:52 +0800
Subject: [PATCH] [RISCV][CodeGen] Add initial CodeGen support of vunzip{e,o}
Add initial support for vunzip{e,o} instructions, which are included in zvzip extension.
---
llvm/lib/Target/RISCV/RISCVISelLowering.cpp | 155 +++++++---
llvm/lib/Target/RISCV/RISCVInstrInfoZvzip.td | 33 +++
.../fixed-vectors-shuffle-deinterleave2.ll | 143 +++------
.../RISCV/rvv/vector-deinterleave-fixed.ll | 102 ++-----
.../CodeGen/RISCV/rvv/vector-deinterleave.ll | 276 ++++++------------
5 files changed, 311 insertions(+), 398 deletions(-)
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index d126616312748..032f7ef1b1214 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -5684,6 +5684,44 @@ static SDValue lowerZvzipVZIP(SDValue Op0, SDValue Op1, const SDLoc &DL,
return Res;
}
+static SDValue lowerZvzipVUNZIP(unsigned Opc, SDValue Op, const SDLoc &DL,
+ SelectionDAG &DAG,
+ const RISCVSubtarget &Subtarget) {
+ assert(RISCVISD::VUNZIPE_VL == Opc || RISCVISD::VUNZIPO_VL == Opc);
+ MVT VT = Op.getSimpleValueType();
+ if (VT.getVectorMinNumElements() < 2)
+ return SDValue();
+
+ MVT IntVT = VT.changeVectorElementTypeToInteger();
+ Op = DAG.getBitcast(IntVT, Op);
+ MVT ContainerVT = IntVT;
+ if (VT.isFixedLengthVector()) {
+ ContainerVT = getContainerForFixedLengthVector(DAG, IntVT, Subtarget);
+ // For E64 with LMUL <= 1, we can't represent a smaller fractional LMUL for
+ // the result (LMUL <= 1/2 is not valid for E64). We must widen the input
+ // container to at least LMUL=2 so the result can be LMUL=1.
+ if (ContainerVT.getVectorElementType() == MVT::i64 &&
+ RISCVTargetLowering::getLMUL(ContainerVT) == RISCVVType::LMUL_1) {
+ ContainerVT = MVT::getScalableVectorVT(MVT::i64, 2);
+ }
+ Op = convertToScalableVector(ContainerVT, Op, DAG, Subtarget);
+ }
+
+ MVT ResVT = ContainerVT.getHalfNumVectorElementsVT();
+ MVT HalfVT = VT.getHalfNumVectorElementsVT();
+ MVT HalfIntVT = IntVT.getHalfNumVectorElementsVT();
+ auto [Mask, VL] = getDefaultVLOps(ResVT, ResVT, DL, DAG, Subtarget);
+ if (VT.isFixedLengthVector())
+ VL = DAG.getConstant(VT.getVectorNumElements() / 2, DL,
+ Subtarget.getXLenVT());
+ SDValue Passthru = DAG.getUNDEF(ResVT);
+ SDValue Res = DAG.getNode(Opc, DL, ResVT, Op, Passthru, Mask, VL);
+ if (HalfIntVT.isFixedLengthVector())
+ Res = convertFromScalableVector(HalfIntVT, Res, DAG, Subtarget);
+ Res = DAG.getBitcast(HalfVT, Res);
+ return Res;
+}
+
// Given a vector a, b, c, d return a vector Factor times longer
// with Factor-1 undef's between elements. Ex:
// a, undef, b, undef, c, undef, d, undef (Factor=2, Index=0)
@@ -6373,50 +6411,82 @@ SDValue RISCVTargetLowering::lowerVECTOR_SHUFFLE(SDValue Op,
}
}
- // If this is a deinterleave(2), try using vunzip{a,b}. This mostly catches
- // e64 which can't match above.
+ // If this is a deinterleave(2), try using vunzip{a,b} or vunzip{e,o}. This
+ // mostly catches e64 which can't match above.
unsigned Index = 0;
- if (Subtarget.hasVendorXRivosVizip() &&
+ if ((Subtarget.hasVendorXRivosVizip() || Subtarget.hasStdExtZvzip()) &&
ShuffleVectorInst::isDeInterleaveMaskOfFactor(Mask, 2, Index) &&
1 < count_if(Mask, [](int Idx) { return Idx != -1; })) {
- unsigned Opc =
- Index == 0 ? RISCVISD::RI_VUNZIP2A_VL : RISCVISD::RI_VUNZIP2B_VL;
- if (V2.isUndef())
- return lowerVZIP(Opc, V1, V2, DL, DAG, Subtarget);
- if (auto VLEN = Subtarget.getRealVLen();
- VLEN && VT.getSizeInBits().getKnownMinValue() % *VLEN == 0)
- return lowerVZIP(Opc, V1, V2, DL, DAG, Subtarget);
- if (SDValue Src = foldConcatVector(V1, V2)) {
- EVT NewVT = VT.getDoubleNumVectorElementsVT();
- Src = DAG.getExtractSubvector(DL, NewVT, Src, 0);
- SDValue Res =
- lowerVZIP(Opc, Src, DAG.getUNDEF(NewVT), DL, DAG, Subtarget);
- return DAG.getExtractSubvector(DL, VT, Res, 0);
- }
- // Deinterleave each source and concatenate them, or concat first, then
- // deinterleave.
- if (1 < count_if(Mask,
+ bool UsesBothSources =
+ 1 < count_if(Mask,
[&Mask](int Idx) { return Idx < (int)Mask.size(); }) &&
1 < count_if(Mask,
- [&Mask](int Idx) { return Idx >= (int)Mask.size(); })) {
+ [&Mask](int Idx) { return Idx >= (int)Mask.size(); });
+
+ if (Subtarget.hasStdExtZvzip() &&
+ isLegalVTForZvzipOperand(VT, Subtarget, *this)) {
+ unsigned Opc = Index == 0 ? RISCVISD::VUNZIPE_VL : RISCVISD::VUNZIPO_VL;
+ MVT NewVT = VT.getDoubleNumVectorElementsVT();
+ if (isTypeLegal(NewVT)) {
+ SDValue Op;
+ if (V2.isUndef()) {
+ Op = DAG.getNode(ISD::CONCAT_VECTORS, DL, NewVT, V1, V2);
+ } else if (auto VLEN = Subtarget.getRealVLen();
+ VLEN && VT.getSizeInBits().getKnownMinValue() % *VLEN == 0) {
+ Op = DAG.getNode(ISD::CONCAT_VECTORS, DL, NewVT, V1, V2);
+ } else if (SDValue Src = foldConcatVector(V1, V2)) {
+ Op = DAG.getExtractSubvector(DL, NewVT, Src, 0);
+ }
+ if (Op)
+ if (SDValue Res = lowerZvzipVUNZIP(Opc, Op, DL, DAG, Subtarget))
+ return Res;
+ }
+
+ if (UsesBothSources) {
+ SDValue Lo = lowerZvzipVUNZIP(Opc, V1, DL, DAG, Subtarget);
+ SDValue Hi = lowerZvzipVUNZIP(Opc, V2, DL, DAG, Subtarget);
+ if (Lo && Hi)
+ return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
+ }
+ }
- const unsigned EltSize = VT.getScalarSizeInBits();
- const unsigned MinVLMAX = Subtarget.getRealMinVLen() / EltSize;
- if (NumElts < MinVLMAX) {
- MVT ConcatVT = VT.getDoubleNumVectorElementsVT();
- SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, DL, ConcatVT, V1, V2);
+ if (Subtarget.hasVendorXRivosVizip()) {
+ unsigned Opc =
+ Index == 0 ? RISCVISD::RI_VUNZIP2A_VL : RISCVISD::RI_VUNZIP2B_VL;
+ if (V2.isUndef())
+ return lowerVZIP(Opc, V1, V2, DL, DAG, Subtarget);
+ if (auto VLEN = Subtarget.getRealVLen();
+ VLEN && VT.getSizeInBits().getKnownMinValue() % *VLEN == 0)
+ return lowerVZIP(Opc, V1, V2, DL, DAG, Subtarget);
+ if (SDValue Src = foldConcatVector(V1, V2)) {
+ EVT NewVT = VT.getDoubleNumVectorElementsVT();
+ Src = DAG.getExtractSubvector(DL, NewVT, Src, 0);
SDValue Res =
- lowerVZIP(Opc, Concat, DAG.getUNDEF(ConcatVT), DL, DAG, Subtarget);
+ lowerVZIP(Opc, Src, DAG.getUNDEF(NewVT), DL, DAG, Subtarget);
return DAG.getExtractSubvector(DL, VT, Res, 0);
}
+ // Deinterleave each source and concatenate them, or concat first, then
+ // deinterleave.
+ if (UsesBothSources) {
+ const unsigned EltSize = VT.getScalarSizeInBits();
+ const unsigned MinVLMAX = Subtarget.getRealMinVLen() / EltSize;
+ if (NumElts < MinVLMAX) {
+ MVT ConcatVT = VT.getDoubleNumVectorElementsVT();
+ SDValue Concat =
+ DAG.getNode(ISD::CONCAT_VECTORS, DL, ConcatVT, V1, V2);
+ SDValue Res = lowerVZIP(Opc, Concat, DAG.getUNDEF(ConcatVT), DL, DAG,
+ Subtarget);
+ return DAG.getExtractSubvector(DL, VT, Res, 0);
+ }
- SDValue Lo = lowerVZIP(Opc, V1, DAG.getUNDEF(VT), DL, DAG, Subtarget);
- SDValue Hi = lowerVZIP(Opc, V2, DAG.getUNDEF(VT), DL, DAG, Subtarget);
+ SDValue Lo = lowerVZIP(Opc, V1, DAG.getUNDEF(VT), DL, DAG, Subtarget);
+ SDValue Hi = lowerVZIP(Opc, V2, DAG.getUNDEF(VT), DL, DAG, Subtarget);
- MVT SubVT = VT.getHalfNumVectorElementsVT();
- return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT,
- DAG.getExtractSubvector(DL, SubVT, Lo, 0),
- DAG.getExtractSubvector(DL, SubVT, Hi, 0));
+ MVT SubVT = VT.getHalfNumVectorElementsVT();
+ return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT,
+ DAG.getExtractSubvector(DL, SubVT, Lo, 0),
+ DAG.getExtractSubvector(DL, SubVT, Hi, 0));
+ }
}
}
@@ -12746,6 +12816,25 @@ SDValue RISCVTargetLowering::lowerVECTOR_DEINTERLEAVE(SDValue Op,
return DAG.getMergeValues(Res, DL);
}
+ if (Subtarget.hasStdExtZvzip() && Factor == 2) {
+ MVT VT = Op->getSimpleValueType(0);
+ MVT NewVT = VT.getDoubleNumVectorElementsVT();
+ if (isTypeLegal(NewVT) && isLegalVTForZvzipOperand(VT, Subtarget, *this)) {
+ SDValue V1 = Op->getOperand(0);
+ SDValue V2 = Op->getOperand(1);
+ // Freeze the sources so we can increase their use count.
+ V1 = DAG.getFreeze(V1);
+ V2 = DAG.getFreeze(V2);
+ SDValue V = DAG.getNode(ISD::CONCAT_VECTORS, DL, NewVT, V1, V2);
+ SDValue Even =
+ lowerZvzipVUNZIP(RISCVISD::VUNZIPE_VL, V, DL, DAG, Subtarget);
+ SDValue Odd =
+ lowerZvzipVUNZIP(RISCVISD::VUNZIPO_VL, V, DL, DAG, Subtarget);
+ if (Even && Odd)
+ return DAG.getMergeValues({Even, Odd}, DL);
+ }
+ }
+
if (Subtarget.hasVendorXRivosVizip() && Factor == 2) {
MVT VT = Op->getSimpleValueType(0);
SDValue V1 = Op->getOperand(0);
diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfoZvzip.td b/llvm/lib/Target/RISCV/RISCVInstrInfoZvzip.td
index 5f650f3cd06ea..70958ee6f0950 100644
--- a/llvm/lib/Target/RISCV/RISCVInstrInfoZvzip.td
+++ b/llvm/lib/Target/RISCV/RISCVInstrInfoZvzip.td
@@ -148,6 +148,14 @@ def SDT_RISCVZip_VL : SDTypeProfile<1, 5, [SDTCisVec<0>, SDTCisVec<1>,
SDTCisSameNumEltsAs<1, 4>,
SDTCisVT<5, XLenVT>]>;
+// (vd (op vs2, passthru, mask, vl))
+def SDT_RISCVUnzip_VL : SDTypeProfile<1, 4, [SDTCisVec<0>, SDTCisVec<1>,
+ SDTCisSubVecOfVec<0, 1>,
+ SDTCisSameAs<0, 2>,
+ SDTCVecEltisVT<3, i1>,
+ SDTCisSameNumEltsAs<0, 3>,
+ SDTCisVT<4, XLenVT>]>;
+
def SDT_RISCVVecBinOp_VL : SDTypeProfile<1, 5, [SDTCisSameAs<0, 1>,
SDTCisSameAs<0, 2>,
SDTCisVec<0>,
@@ -160,6 +168,8 @@ let HasPassthruOp = true, HasMaskOp = true in {
def vpaire_vl : RVSDNode<"VPAIRE_VL", SDT_RISCVVecBinOp_VL>;
def vpairo_vl : RVSDNode<"VPAIRO_VL", SDT_RISCVVecBinOp_VL>;
def vzip_vl : RVSDNode<"VZIP_VL", SDT_RISCVZip_VL>;
+def vunzipe_vl : RVSDNode<"VUNZIPE_VL", SDT_RISCVUnzip_VL>;
+def vunzipo_vl : RVSDNode<"VUNZIPO_VL", SDT_RISCVUnzip_VL>;
} // HasPassthruOp = true, HasMaskOp = true
multiclass VPatVZIP<SDPatternOperator vop, string instruction_name> {
@@ -176,7 +186,30 @@ multiclass VPatVZIP<SDPatternOperator vop, string instruction_name> {
}
}
+multiclass VPatVUNZIP<SDPatternOperator op, string instruction_name> {
+ foreach VtiToWti = AllZvzipVectors in {
+ defvar vti = VtiToWti.Vti;
+ defvar wti = VtiToWti.Wti;
+ let Predicates = !listconcat([HasStdExtZvzip],
+ GetVTypeMinimalPredicates<vti>.Predicates) in {
+ def : Pat<(vti.Vector (op (wti.Vector wti.RegClass:$rs2),
+ (vti.Vector vti.RegClass:$passthru),
+ (vti.Mask VMV0:$vm),
+ VLOpFrag)),
+ (!cast<Instruction>(instruction_name#"_V_"#vti.LMul.MX#"_MASK")
+ vti.RegClass:$passthru,
+ wti.RegClass:$rs2,
+ (vti.Mask VMV0:$vm),
+ GPR:$vl,
+ vti.Log2SEW,
+ TAIL_AGNOSTIC)>;
+ }
+ }
+}
+
defm : VPatVZIP<vzip_vl, "PseudoVZIP">;
+defm : VPatVUNZIP<vunzipe_vl, "PseudoVUNZIPE">;
+defm : VPatVUNZIP<vunzipo_vl, "PseudoVUNZIPO">;
defm : VPatBinaryVL_VV<vpaire_vl, "PseudoVPAIRE", AllVectors,
ExtraPreds = [HasStdExtZvzip],
requireMinimal = true>;
diff --git a/llvm/test/CodeGen/RISCV/rvv/fixed-vectors-shuffle-deinterleave2.ll b/llvm/test/CodeGen/RISCV/rvv/fixed-vectors-shuffle-deinterleave2.ll
index 6ebb2f51b4f2a..5005876de9369 100644
--- a/llvm/test/CodeGen/RISCV/rvv/fixed-vectors-shuffle-deinterleave2.ll
+++ b/llvm/test/CodeGen/RISCV/rvv/fixed-vectors-shuffle-deinterleave2.ll
@@ -519,9 +519,8 @@ define void @vnsrl_0_i64(ptr %in, ptr %out) {
; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
; ZVZIP-NEXT: vle64.v v8, (a0)
; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v9, v8, 2
-; ZVZIP-NEXT: vslideup.vi v8, v9, 1
-; ZVZIP-NEXT: vse64.v v8, (a1)
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vse64.v v10, (a1)
; ZVZIP-NEXT: ret
entry:
%0 = load <4 x i64>, ptr %in, align 8
@@ -564,8 +563,7 @@ define void @vnsrl_64_i64(ptr %in, ptr %out) {
; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
; ZVZIP-NEXT: vle64.v v8, (a0)
; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v9, v8, 2
-; ZVZIP-NEXT: vpairo.vv v10, v8, v9
+; ZVZIP-NEXT: vunzipo.v v10, v8
; ZVZIP-NEXT: vse64.v v10, (a1)
; ZVZIP-NEXT: ret
entry:
@@ -608,9 +606,8 @@ define void @vnsrl_0_double(ptr %in, ptr %out) {
; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
; ZVZIP-NEXT: vle64.v v8, (a0)
; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v9, v8, 2
-; ZVZIP-NEXT: vslideup.vi v8, v9, 1
-; ZVZIP-NEXT: vse64.v v8, (a1)
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vse64.v v10, (a1)
; ZVZIP-NEXT: ret
entry:
%0 = load <4 x double>, ptr %in, align 8
@@ -653,8 +650,7 @@ define void @vnsrl_64_double(ptr %in, ptr %out) {
; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
; ZVZIP-NEXT: vle64.v v8, (a0)
; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v9, v8, 2
-; ZVZIP-NEXT: vpairo.vv v10, v8, v9
+; ZVZIP-NEXT: vunzipo.v v10, v8
; ZVZIP-NEXT: vse64.v v10, (a1)
; ZVZIP-NEXT: ret
entry:
@@ -1904,14 +1900,13 @@ define <4 x i64> @unzip2a_dual_v4i64(<4 x i64> %a, <4 x i64> %b) {
;
; ZVZIP-LABEL: unzip2a_dual_v4i64:
; ZVZIP: # %bb.0: # %entry
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, mu
-; ZVZIP-NEXT: vmv.v.i v0, 8
-; ZVZIP-NEXT: vslideup.vi v10, v9, 2
-; ZVZIP-NEXT: vslideup.vi v10, v9, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 2
-; ZVZIP-NEXT: vslidedown.vi v8, v8, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 12
-; ZVZIP-NEXT: vmerge.vvm v8, v8, v10, v0
+; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
+; ZVZIP-NEXT: vmv1r.v v10, v9
+; ZVZIP-NEXT: vunzipe.v v12, v10
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
+; ZVZIP-NEXT: vslideup.vi v10, v12, 2
+; ZVZIP-NEXT: vmv.v.v v8, v10
; ZVZIP-NEXT: ret
entry:
%c = shufflevector <4 x i64> %a, <4 x i64> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
@@ -2052,21 +2047,12 @@ define <16 x i64> @unzip2a_dual_v16i64(<16 x i64> %a, <16 x i64> %b) {
;
; ZVZIP-LABEL: unzip2a_dual_v16i64:
; ZVZIP: # %bb.0: # %entry
-; ZVZIP-NEXT: vsetivli zero, 16, e16, m1, ta, ma
-; ZVZIP-NEXT: vid.v v16
-; ZVZIP-NEXT: lui a0, 5
-; ZVZIP-NEXT: addi a0, a0, 1365
-; ZVZIP-NEXT: vmv.s.x v20, a0
-; ZVZIP-NEXT: li a0, -256
-; ZVZIP-NEXT: vadd.vv v21, v16, v16
-; ZVZIP-NEXT: vsetvli zero, zero, e64, m4, ta, ma
-; ZVZIP-NEXT: vcompress.vm v16, v8, v20
-; ZVZIP-NEXT: vmv.s.x v0, a0
-; ZVZIP-NEXT: vsetvli zero, zero, e16, m1, ta, ma
-; ZVZIP-NEXT: vadd.vi v8, v21, -16
-; ZVZIP-NEXT: vsetvli zero, zero, e64, m4, ta, mu
-; ZVZIP-NEXT: vrgatherei16.vv v16, v12, v8, v0.t
-; ZVZIP-NEXT: vmv.v.v v8, v16
+; ZVZIP-NEXT: vsetivli zero, 8, e64, m2, ta, ma
+; ZVZIP-NEXT: vunzipe.v v16, v12
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vsetivli zero, 16, e64, m4, ta, ma
+; ZVZIP-NEXT: vslideup.vi v12, v16, 8
+; ZVZIP-NEXT: vmv.v.v v8, v12
; ZVZIP-NEXT: ret
entry:
%c = shufflevector <16 x i64> %a, <16 x i64> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
@@ -2119,14 +2105,9 @@ define <4 x i64> @unzip2a_dual_v4i64_exact(<4 x i64> %a, <4 x i64> %b) vscale_ra
;
; ZVZIP-LABEL: unzip2a_dual_v4i64_exact:
; ZVZIP: # %bb.0: # %entry
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, mu
-; ZVZIP-NEXT: vmv.v.i v0, 8
-; ZVZIP-NEXT: vslideup.vi v10, v9, 2
-; ZVZIP-NEXT: vslideup.vi v10, v9, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 2
-; ZVZIP-NEXT: vslidedown.vi v8, v8, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 12
-; ZVZIP-NEXT: vmerge.vvm v8, v8, v10, v0
+; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vmv.v.v v8, v10
; ZVZIP-NEXT: ret
entry:
%c = shufflevector <4 x i64> %a, <4 x i64> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
@@ -2180,14 +2161,13 @@ define <4 x i64> @unzip2a_dual_v4i64_exact_nf2(<4 x i64> %a, <4 x i64> %b) vscal
;
; ZVZIP-LABEL: unzip2a_dual_v4i64_exact_nf2:
; ZVZIP: # %bb.0: # %entry
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, mu
-; ZVZIP-NEXT: vmv.v.i v0, 8
-; ZVZIP-NEXT: vslideup.vi v10, v9, 2
-; ZVZIP-NEXT: vslideup.vi v10, v9, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 2
-; ZVZIP-NEXT: vslidedown.vi v8, v8, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 12
-; ZVZIP-NEXT: vmerge.vvm v8, v8, v10, v0
+; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
+; ZVZIP-NEXT: vmv1r.v v10, v9
+; ZVZIP-NEXT: vunzipe.v v12, v10
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, tu, ma
+; ZVZIP-NEXT: vslideup.vi v10, v12, 2
+; ZVZIP-NEXT: vmv1r.v v8, v10
; ZVZIP-NEXT: ret
entry:
%c = shufflevector <4 x i64> %a, <4 x i64> %b, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
@@ -2319,42 +2299,9 @@ define <16 x i64> @unzip2a_dual_v16i64_exact(<16 x i64> %a, <16 x i64> %b) vscal
;
; ZVZIP-LABEL: unzip2a_dual_v16i64_exact:
; ZVZIP: # %bb.0: # %entry
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, mu
-; ZVZIP-NEXT: vslideup.vi v19, v15, 2
-; ZVZIP-NEXT: vmv.v.i v16, 8
-; ZVZIP-NEXT: vmv.v.i v17, 2
-; ZVZIP-NEXT: vmv.v.i v18, 12
-; ZVZIP-NEXT: vmv.v.v v0, v16
-; ZVZIP-NEXT: vslideup.vi v19, v15, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v17
-; ZVZIP-NEXT: vslidedown.vi v14, v14, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v18
-; ZVZIP-NEXT: vmerge.vvm v15, v14, v19, v0
-; ZVZIP-NEXT: vslideup.vi v14, v13, 2
-; ZVZIP-NEXT: vmv.v.v v0, v16
-; ZVZIP-NEXT: vslideup.vi v14, v13, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v17
-; ZVZIP-NEXT: vslidedown.vi v12, v12, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v18
-; ZVZIP-NEXT: vmerge.vvm v14, v12, v14, v0
-; ZVZIP-NEXT: vslideup.vi v12, v11, 2
-; ZVZIP-NEXT: li a0, -256
-; ZVZIP-NEXT: vmv.v.v v0, v16
-; ZVZIP-NEXT: vslideup.vi v12, v11, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v17
-; ZVZIP-NEXT: vslidedown.vi v10, v10, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v18
-; ZVZIP-NEXT: vmerge.vvm v13, v10, v12, v0
-; ZVZIP-NEXT: vslideup.vi v10, v9, 2
-; ZVZIP-NEXT: vmv.v.v v0, v16
-; ZVZIP-NEXT: vslideup.vi v10, v9, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v17
-; ZVZIP-NEXT: vslidedown.vi v8, v8, 1, v0.t
-; ZVZIP-NEXT: vmv.v.v v0, v18
-; ZVZIP-NEXT: vmerge.vvm v12, v8, v10, v0
-; ZVZIP-NEXT: vmv.s.x v0, a0
; ZVZIP-NEXT: vsetivli zero, 16, e64, m4, ta, ma
-; ZVZIP-NEXT: vmerge.vvm v8, v12, v12, v0
+; ZVZIP-NEXT: vunzipe.v v16, v8
+; ZVZIP-NEXT: vmv.v.v v8, v16
; ZVZIP-NEXT: ret
entry:
%c = shufflevector <16 x i64> %a, <16 x i64> %b, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
@@ -2410,15 +2357,13 @@ define <4 x i64> @unzip2b_dual_v4i64(<4 x i64> %a, <4 x i64> %b) {
;
; ZVZIP-LABEL: unzip2b_dual_v4i64:
; ZVZIP: # %bb.0: # %entry
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, mu
-; ZVZIP-NEXT: vmv.v.i v0, 2
-; ZVZIP-NEXT: vslidedown.vi v10, v8, 1
-; ZVZIP-NEXT: vslidedown.vi v10, v8, 2, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 4
-; ZVZIP-NEXT: vmv1r.v v8, v9
-; ZVZIP-NEXT: vslideup.vi v8, v9, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 12
-; ZVZIP-NEXT: vmerge.vvm v8, v10, v8, v0
+; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
+; ZVZIP-NEXT: vmv1r.v v10, v9
+; ZVZIP-NEXT: vunzipo.v v12, v10
+; ZVZIP-NEXT: vunzipo.v v10, v8
+; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
+; ZVZIP-NEXT: vslideup.vi v10, v12, 2
+; ZVZIP-NEXT: vmv.v.v v8, v10
; ZVZIP-NEXT: ret
entry:
%c = shufflevector <4 x i64> %a, <4 x i64> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
@@ -2472,15 +2417,9 @@ define <4 x i64> @unzip2b_dual_v4i64_exact(<4 x i64> %a, <4 x i64> %b) vscale_ra
;
; ZVZIP-LABEL: unzip2b_dual_v4i64_exact:
; ZVZIP: # %bb.0: # %entry
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, mu
-; ZVZIP-NEXT: vmv.v.i v0, 2
-; ZVZIP-NEXT: vslidedown.vi v10, v8, 1
-; ZVZIP-NEXT: vslidedown.vi v10, v8, 2, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 4
-; ZVZIP-NEXT: vmv1r.v v8, v9
-; ZVZIP-NEXT: vslideup.vi v8, v9, 1, v0.t
-; ZVZIP-NEXT: vmv.v.i v0, 12
-; ZVZIP-NEXT: vmerge.vvm v8, v10, v8, v0
+; ZVZIP-NEXT: vsetivli zero, 4, e64, m1, ta, ma
+; ZVZIP-NEXT: vunzipo.v v10, v8
+; ZVZIP-NEXT: vmv.v.v v8, v10
; ZVZIP-NEXT: ret
entry:
%c = shufflevector <4 x i64> %a, <4 x i64> %b, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
diff --git a/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave-fixed.ll b/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave-fixed.ll
index 6a854309f6265..77d06e53e172a 100644
--- a/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave-fixed.ll
+++ b/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave-fixed.ll
@@ -95,11 +95,11 @@ define {<2 x i64>, <2 x i64>} @vector_deinterleave_v2i64_v4i64(<4 x i64> %vec) {
;
; ZVZIP-LABEL: vector_deinterleave_v2i64_v4i64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: vsetivli zero, 2, e64, m2, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v10, v8, 2
; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
-; ZVZIP-NEXT: vpairo.vv v9, v8, v10
-; ZVZIP-NEXT: vslideup.vi v8, v10, 1
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vunzipo.v v11, v8
+; ZVZIP-NEXT: vmv.v.v v8, v10
+; ZVZIP-NEXT: vmv.v.v v9, v11
; ZVZIP-NEXT: ret
%retval = call {<2 x i64>, <2 x i64>} @llvm.vector.deinterleave2.v4i64(<4 x i64> %vec)
ret {<2 x i64>, <2 x i64>} %retval
@@ -147,32 +147,11 @@ define {<4 x i64>, <4 x i64>} @vector_deinterleave_v4i64_v8i64(<8 x i64> %vec) {
;
; ZVZIP-LABEL: vector_deinterleave_v4i64_v8i64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: vsetivli zero, 1, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.i v0, 8
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m4, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v16, v8, 4
-; ZVZIP-NEXT: vsetivli zero, 1, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.i v10, 2
-; ZVZIP-NEXT: vmv2r.v v12, v8
-; ZVZIP-NEXT: vmv.v.i v11, 12
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m2, ta, mu
-; ZVZIP-NEXT: vslideup.vi v14, v16, 2
-; ZVZIP-NEXT: vslideup.vi v14, v16, 1, v0.t
-; ZVZIP-NEXT: vmv1r.v v0, v10
-; ZVZIP-NEXT: vslidedown.vi v12, v8, 1, v0.t
-; ZVZIP-NEXT: vmv1r.v v0, v11
-; ZVZIP-NEXT: vmerge.vvm v12, v12, v14, v0
-; ZVZIP-NEXT: vslidedown.vi v14, v8, 1
-; ZVZIP-NEXT: vmv1r.v v0, v10
-; ZVZIP-NEXT: vslidedown.vi v14, v8, 2, v0.t
-; ZVZIP-NEXT: vsetivli zero, 1, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.i v0, 4
-; ZVZIP-NEXT: vmv2r.v v8, v16
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m2, ta, mu
-; ZVZIP-NEXT: vslideup.vi v8, v16, 1, v0.t
-; ZVZIP-NEXT: vmv1r.v v0, v11
-; ZVZIP-NEXT: vmerge.vvm v10, v14, v8, v0
-; ZVZIP-NEXT: vmv2r.v v8, v12
+; ZVZIP-NEXT: vsetivli zero, 4, e64, m2, ta, ma
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
+; ZVZIP-NEXT: vmv.v.v v8, v12
+; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
%retval = call {<4 x i64>, <4 x i64>} @llvm.vector.deinterleave2.v8i64(<8 x i64> %vec)
ret {<4 x i64>, <4 x i64>} %retval
@@ -215,27 +194,11 @@ define {<8 x i64>, <8 x i64>} @vector_deinterleave_v8i64_v16i64(<16 x i64> %vec)
;
; ZVZIP-LABEL: vector_deinterleave_v8i64_v16i64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: vsetivli zero, 8, e16, m1, ta, ma
-; ZVZIP-NEXT: vid.v v16
-; ZVZIP-NEXT: vsetivli zero, 8, e64, m8, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v24, v8, 8
-; ZVZIP-NEXT: li a0, 85
-; ZVZIP-NEXT: vsetivli zero, 8, e16, m1, ta, ma
-; ZVZIP-NEXT: vmv.v.i v0, -16
-; ZVZIP-NEXT: vmv.s.x v12, a0
-; ZVZIP-NEXT: li a0, 170
-; ZVZIP-NEXT: vadd.vv v13, v16, v16
-; ZVZIP-NEXT: vmv.s.x v20, a0
-; ZVZIP-NEXT: vadd.vi v21, v13, -8
-; ZVZIP-NEXT: vsetvli zero, zero, e64, m4, ta, ma
-; ZVZIP-NEXT: vcompress.vm v16, v8, v12
-; ZVZIP-NEXT: vsetvli zero, zero, e16, m1, ta, ma
-; ZVZIP-NEXT: vadd.vi v22, v13, -7
-; ZVZIP-NEXT: vsetvli zero, zero, e64, m4, ta, mu
-; ZVZIP-NEXT: vcompress.vm v12, v8, v20
-; ZVZIP-NEXT: vrgatherei16.vv v16, v24, v21, v0.t
-; ZVZIP-NEXT: vrgatherei16.vv v12, v24, v22, v0.t
+; ZVZIP-NEXT: vsetivli zero, 8, e64, m4, ta, ma
+; ZVZIP-NEXT: vunzipe.v v16, v8
+; ZVZIP-NEXT: vunzipo.v v20, v8
; ZVZIP-NEXT: vmv.v.v v8, v16
+; ZVZIP-NEXT: vmv.v.v v12, v20
; ZVZIP-NEXT: ret
%retval = call {<8 x i64>, <8 x i64>} @llvm.vector.deinterleave2.v16i64(<16 x i64> %vec)
ret {<8 x i64>, <8 x i64>} %retval
@@ -580,11 +543,11 @@ define {<2 x double>, <2 x double>} @vector_deinterleave_v2f64_v4f64(<4 x double
;
; ZVZIP-LABEL: vector_deinterleave_v2f64_v4f64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: vsetivli zero, 2, e64, m2, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v10, v8, 2
; ZVZIP-NEXT: vsetivli zero, 2, e64, m1, ta, ma
-; ZVZIP-NEXT: vpairo.vv v9, v8, v10
-; ZVZIP-NEXT: vslideup.vi v8, v10, 1
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vunzipo.v v11, v8
+; ZVZIP-NEXT: vmv.v.v v8, v10
+; ZVZIP-NEXT: vmv.v.v v9, v11
; ZVZIP-NEXT: ret
%retval = call {<2 x double>, <2 x double>} @llvm.vector.deinterleave2.v4f64(<4 x double> %vec)
ret {<2 x double>, <2 x double>} %retval
@@ -632,32 +595,11 @@ define {<4 x double>, <4 x double>} @vector_deinterleave_v4f64_v8f64(<8 x double
;
; ZVZIP-LABEL: vector_deinterleave_v4f64_v8f64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: vsetivli zero, 1, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.i v0, 8
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m4, ta, ma
-; ZVZIP-NEXT: vslidedown.vi v16, v8, 4
-; ZVZIP-NEXT: vsetivli zero, 1, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.i v10, 2
-; ZVZIP-NEXT: vmv2r.v v12, v8
-; ZVZIP-NEXT: vmv.v.i v11, 12
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m2, ta, mu
-; ZVZIP-NEXT: vslideup.vi v14, v16, 2
-; ZVZIP-NEXT: vslideup.vi v14, v16, 1, v0.t
-; ZVZIP-NEXT: vmv1r.v v0, v10
-; ZVZIP-NEXT: vslidedown.vi v12, v8, 1, v0.t
-; ZVZIP-NEXT: vmv1r.v v0, v11
-; ZVZIP-NEXT: vmerge.vvm v12, v12, v14, v0
-; ZVZIP-NEXT: vslidedown.vi v14, v8, 1
-; ZVZIP-NEXT: vmv1r.v v0, v10
-; ZVZIP-NEXT: vslidedown.vi v14, v8, 2, v0.t
-; ZVZIP-NEXT: vsetivli zero, 1, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.i v0, 4
-; ZVZIP-NEXT: vmv2r.v v8, v16
-; ZVZIP-NEXT: vsetivli zero, 4, e64, m2, ta, mu
-; ZVZIP-NEXT: vslideup.vi v8, v16, 1, v0.t
-; ZVZIP-NEXT: vmv1r.v v0, v11
-; ZVZIP-NEXT: vmerge.vvm v10, v14, v8, v0
-; ZVZIP-NEXT: vmv2r.v v8, v12
+; ZVZIP-NEXT: vsetivli zero, 4, e64, m2, ta, ma
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
+; ZVZIP-NEXT: vmv.v.v v8, v12
+; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
%retval = call {<4 x double>, <4 x double>} @llvm.vector.deinterleave2.v8f64(<8 x double> %vec)
ret {<4 x double>, <4 x double>} %retval
diff --git a/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave.ll b/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave.ll
index f220b37fc81e2..0e691600fd238 100644
--- a/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave.ll
+++ b/llvm/test/CodeGen/RISCV/rvv/vector-deinterleave.ll
@@ -52,8 +52,8 @@ define {<vscale x 16 x i1>, <vscale x 16 x i1>} @vector_deinterleave_nxv16i1_nxv
; ZVZIP-NEXT: vslidedown.vx v0, v0, a0
; ZVZIP-NEXT: vsetvli a0, zero, e8, m2, ta, ma
; ZVZIP-NEXT: vmerge.vim v10, v10, 1, v0
-; ZVZIP-NEXT: vnsrl.wi v12, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v14, v8, 8
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
; ZVZIP-NEXT: vmsne.vi v0, v12, 0
; ZVZIP-NEXT: vmsne.vi v8, v14, 0
; ZVZIP-NEXT: ret
@@ -83,8 +83,8 @@ define {<vscale x 16 x i8>, <vscale x 16 x i8>} @vector_deinterleave_nxv16i8_nxv
; ZVZIP-LABEL: vector_deinterleave_nxv16i8_nxv32i8:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e8, m2, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v12, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v14, v8, 8
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
; ZVZIP-NEXT: vmv.v.v v8, v12
; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
@@ -114,8 +114,8 @@ define {<vscale x 8 x i16>, <vscale x 8 x i16>} @vector_deinterleave_nxv8i16_nxv
; ZVZIP-LABEL: vector_deinterleave_nxv8i16_nxv16i16:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m2, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v12, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v14, v8, 16
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
; ZVZIP-NEXT: vmv.v.v v8, v12
; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
@@ -145,12 +145,11 @@ define {<vscale x 4 x i32>, <vscale x 4 x i32>} @vector_deinterleave_nxv4i32_nxv
;
; ZVZIP-LABEL: vector_deinterleave_nxv4i32_nxvv8i32:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: li a0, 32
-; ZVZIP-NEXT: vsetvli a1, zero, e32, m2, ta, ma
-; ZVZIP-NEXT: vnsrl.wx v12, v8, a0
-; ZVZIP-NEXT: vnsrl.wi v14, v8, 0
-; ZVZIP-NEXT: vmv.v.v v8, v14
-; ZVZIP-NEXT: vmv.v.v v10, v12
+; ZVZIP-NEXT: vsetvli a0, zero, e32, m2, ta, ma
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
+; ZVZIP-NEXT: vmv.v.v v8, v12
+; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
%retval = call {<vscale x 4 x i32>, <vscale x 4 x i32>} @llvm.vector.deinterleave2.nxv8i32(<vscale x 8 x i32> %vec)
ret {<vscale x 4 x i32>, <vscale x 4 x i32>} %retval
@@ -182,16 +181,11 @@ define {<vscale x 2 x i64>, <vscale x 2 x i64>} @vector_deinterleave_nxv2i64_nxv
;
; ZVZIP-LABEL: vector_deinterleave_nxv2i64_nxv4i64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: li a0, 85
-; ZVZIP-NEXT: vsetvli a1, zero, e8, m1, ta, ma
-; ZVZIP-NEXT: vmv.v.x v16, a0
-; ZVZIP-NEXT: li a0, 170
-; ZVZIP-NEXT: vmv.v.x v20, a0
-; ZVZIP-NEXT: vsetvli a0, zero, e64, m4, ta, ma
-; ZVZIP-NEXT: vcompress.vm v12, v8, v16
-; ZVZIP-NEXT: vcompress.vm v16, v8, v20
-; ZVZIP-NEXT: vmv2r.v v8, v12
-; ZVZIP-NEXT: vmv2r.v v10, v16
+; ZVZIP-NEXT: vsetvli a0, zero, e64, m2, ta, ma
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
+; ZVZIP-NEXT: vmv.v.v v8, v12
+; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
%retval = call {<vscale x 2 x i64>, <vscale x 2 x i64>} @llvm.vector.deinterleave2.nxv4i64(<vscale x 4 x i64> %vec)
ret {<vscale x 2 x i64>, <vscale x 2 x i64>} %retval
@@ -223,16 +217,11 @@ define {<vscale x 4 x i64>, <vscale x 4 x i64>} @vector_deinterleave_nxv4i64_nxv
;
; ZVZIP-LABEL: vector_deinterleave_nxv4i64_nxv8i64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: li a0, 85
-; ZVZIP-NEXT: vsetvli a1, zero, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.x v24, a0
-; ZVZIP-NEXT: li a0, 170
-; ZVZIP-NEXT: vmv.v.x v7, a0
-; ZVZIP-NEXT: vsetvli a0, zero, e64, m8, ta, ma
-; ZVZIP-NEXT: vcompress.vm v16, v8, v24
-; ZVZIP-NEXT: vcompress.vm v24, v8, v7
-; ZVZIP-NEXT: vmv4r.v v8, v16
-; ZVZIP-NEXT: vmv4r.v v12, v24
+; ZVZIP-NEXT: vsetvli a0, zero, e64, m4, ta, ma
+; ZVZIP-NEXT: vunzipe.v v16, v8
+; ZVZIP-NEXT: vunzipo.v v20, v8
+; ZVZIP-NEXT: vmv.v.v v8, v16
+; ZVZIP-NEXT: vmv.v.v v12, v20
; ZVZIP-NEXT: ret
%retval = call {<vscale x 4 x i64>, <vscale x 4 x i64>} @llvm.vector.deinterleave2.nxv8i64(<vscale x 8 x i64> %vec)
ret {<vscale x 4 x i64>, <vscale x 4 x i64>} %retval
@@ -286,10 +275,10 @@ define {<vscale x 64 x i1>, <vscale x 64 x i1>} @vector_deinterleave_nxv64i1_nxv
; ZVZIP-NEXT: vmv1r.v v0, v8
; ZVZIP-NEXT: vmerge.vim v24, v24, 1, v0
; ZVZIP-NEXT: vsetvli a0, zero, e8, m4, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v8, v16, 0
-; ZVZIP-NEXT: vnsrl.wi v0, v16, 8
-; ZVZIP-NEXT: vnsrl.wi v12, v24, 0
-; ZVZIP-NEXT: vnsrl.wi v4, v24, 8
+; ZVZIP-NEXT: vunzipe.v v8, v16
+; ZVZIP-NEXT: vunzipo.v v0, v16
+; ZVZIP-NEXT: vunzipe.v v12, v24
+; ZVZIP-NEXT: vunzipo.v v4, v24
; ZVZIP-NEXT: vsetvli a0, zero, e8, m8, ta, ma
; ZVZIP-NEXT: vmsne.vi v16, v8, 0
; ZVZIP-NEXT: vmsne.vi v8, v0, 0
@@ -326,10 +315,10 @@ define {<vscale x 64 x i8>, <vscale x 64 x i8>} @vector_deinterleave_nxv64i8_nxv
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e8, m4, ta, ma
; ZVZIP-NEXT: vmv8r.v v24, v8
-; ZVZIP-NEXT: vnsrl.wi v8, v24, 0
-; ZVZIP-NEXT: vnsrl.wi v0, v24, 8
-; ZVZIP-NEXT: vnsrl.wi v12, v16, 0
-; ZVZIP-NEXT: vnsrl.wi v4, v16, 8
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
; ZVZIP-NEXT: vmv8r.v v16, v0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 64 x i8>, <vscale x 64 x i8>} @llvm.vector.deinterleave2.nxv128i8(<vscale x 128 x i8> %vec)
@@ -363,10 +352,10 @@ define {<vscale x 32 x i16>, <vscale x 32 x i16>} @vector_deinterleave_nxv32i16_
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m4, ta, ma
; ZVZIP-NEXT: vmv8r.v v24, v8
-; ZVZIP-NEXT: vnsrl.wi v8, v24, 0
-; ZVZIP-NEXT: vnsrl.wi v0, v24, 16
-; ZVZIP-NEXT: vnsrl.wi v12, v16, 0
-; ZVZIP-NEXT: vnsrl.wi v4, v16, 16
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
; ZVZIP-NEXT: vmv8r.v v16, v0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 32 x i16>, <vscale x 32 x i16>} @llvm.vector.deinterleave2.nxv64i16(<vscale x 64 x i16> %vec)
@@ -400,13 +389,12 @@ define {<vscale x 16 x i32>, <vscale x 16 x i32>} @vector_deinterleave_nxv16i32_
; ZVZIP-LABEL: vector_deinterleave_nxv16i32_nxvv32i32:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e32, m4, ta, ma
-; ZVZIP-NEXT: vmv8r.v v24, v16
-; ZVZIP-NEXT: li a0, 32
-; ZVZIP-NEXT: vnsrl.wx v20, v24, a0
-; ZVZIP-NEXT: vnsrl.wx v16, v8, a0
-; ZVZIP-NEXT: vnsrl.wi v0, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v4, v24, 0
-; ZVZIP-NEXT: vmv8r.v v8, v0
+; ZVZIP-NEXT: vmv8r.v v24, v8
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
+; ZVZIP-NEXT: vmv8r.v v16, v0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 16 x i32>, <vscale x 16 x i32>} @llvm.vector.deinterleave2.nxv32i32(<vscale x 32 x i32> %vec)
ret {<vscale x 16 x i32>, <vscale x 16 x i32>} %retval
@@ -472,48 +460,13 @@ define {<vscale x 8 x i64>, <vscale x 8 x i64>} @vector_deinterleave_nxv8i64_nxv
;
; ZVZIP-LABEL: vector_deinterleave_nxv8i64_nxv16i64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: addi sp, sp, -16
-; ZVZIP-NEXT: .cfi_def_cfa_offset 16
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 4
-; ZVZIP-NEXT: sub sp, sp, a0
-; ZVZIP-NEXT: .cfi_escape 0x0f, 0x0d, 0x72, 0x00, 0x11, 0x10, 0x22, 0x11, 0x10, 0x92, 0xa2, 0x38, 0x00, 0x1e, 0x22 # sp + 16 + 16 * vlenb
-; ZVZIP-NEXT: li a0, 85
-; ZVZIP-NEXT: vsetvli a1, zero, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.x v7, a0
-; ZVZIP-NEXT: li a0, 170
-; ZVZIP-NEXT: vmv.v.x v6, a0
-; ZVZIP-NEXT: vsetvli a0, zero, e64, m8, ta, ma
-; ZVZIP-NEXT: vcompress.vm v24, v8, v7
-; ZVZIP-NEXT: vmv1r.v v28, v7
-; ZVZIP-NEXT: vmv1r.v v29, v6
-; ZVZIP-NEXT: vcompress.vm v0, v8, v29
-; ZVZIP-NEXT: vcompress.vm v8, v16, v28
-; ZVZIP-NEXT: addi a0, sp, 16
-; ZVZIP-NEXT: vs8r.v v8, (a0) # vscale x 64-byte Folded Spill
-; ZVZIP-NEXT: vcompress.vm v8, v16, v29
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 3
-; ZVZIP-NEXT: add a0, sp, a0
-; ZVZIP-NEXT: addi a0, a0, 16
-; ZVZIP-NEXT: vs8r.v v8, (a0) # vscale x 64-byte Folded Spill
-; ZVZIP-NEXT: addi a0, sp, 16
-; ZVZIP-NEXT: vl8r.v v8, (a0) # vscale x 64-byte Folded Reload
-; ZVZIP-NEXT: vmv4r.v v28, v8
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 3
-; ZVZIP-NEXT: add a0, sp, a0
-; ZVZIP-NEXT: addi a0, a0, 16
-; ZVZIP-NEXT: vl8r.v v8, (a0) # vscale x 64-byte Folded Reload
-; ZVZIP-NEXT: vmv4r.v v4, v8
-; ZVZIP-NEXT: vmv8r.v v8, v24
+; ZVZIP-NEXT: vsetvli a0, zero, e64, m4, ta, ma
+; ZVZIP-NEXT: vmv8r.v v24, v8
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
; ZVZIP-NEXT: vmv8r.v v16, v0
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 4
-; ZVZIP-NEXT: add sp, sp, a0
-; ZVZIP-NEXT: .cfi_def_cfa sp, 16
-; ZVZIP-NEXT: addi sp, sp, 16
-; ZVZIP-NEXT: .cfi_def_cfa_offset 0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 8 x i64>, <vscale x 8 x i64>} @llvm.vector.deinterleave2.nxv16i64(<vscale x 16 x i64> %vec)
ret {<vscale x 8 x i64>, <vscale x 8 x i64>} %retval
@@ -1768,8 +1721,8 @@ define {<vscale x 2 x bfloat>, <vscale x 2 x bfloat>} @vector_deinterleave_nxv2b
; ZVZIP-LABEL: vector_deinterleave_nxv2bf16_nxv4bf16:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, mf2, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v10, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v9, v8, 16
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vunzipo.v v9, v8
; ZVZIP-NEXT: vmv1r.v v8, v10
; ZVZIP-NEXT: ret
%retval = call {<vscale x 2 x bfloat>, <vscale x 2 x bfloat>} @llvm.vector.deinterleave2.nxv4bf16(<vscale x 4 x bfloat> %vec)
@@ -1796,8 +1749,8 @@ define {<vscale x 2 x half>, <vscale x 2 x half>} @vector_deinterleave_nxv2f16_n
; ZVZIP-LABEL: vector_deinterleave_nxv2f16_nxv4f16:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, mf2, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v10, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v9, v8, 16
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vunzipo.v v9, v8
; ZVZIP-NEXT: vmv1r.v v8, v10
; ZVZIP-NEXT: ret
%retval = call {<vscale x 2 x half>, <vscale x 2 x half>} @llvm.vector.deinterleave2.nxv4f16(<vscale x 4 x half> %vec)
@@ -1826,8 +1779,8 @@ define {<vscale x 4 x bfloat>, <vscale x 4 x bfloat>} @vector_deinterleave_nxv4b
; ZVZIP-LABEL: vector_deinterleave_nxv4bf16_nxv8bf16:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m1, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v10, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v11, v8, 16
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vunzipo.v v11, v8
; ZVZIP-NEXT: vmv.v.v v8, v10
; ZVZIP-NEXT: vmv.v.v v9, v11
; ZVZIP-NEXT: ret
@@ -1857,8 +1810,8 @@ define {<vscale x 4 x half>, <vscale x 4 x half>} @vector_deinterleave_nxv4f16_n
; ZVZIP-LABEL: vector_deinterleave_nxv4f16_nxv8f16:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m1, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v10, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v11, v8, 16
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vunzipo.v v11, v8
; ZVZIP-NEXT: vmv.v.v v8, v10
; ZVZIP-NEXT: vmv.v.v v9, v11
; ZVZIP-NEXT: ret
@@ -1888,12 +1841,11 @@ define {<vscale x 2 x float>, <vscale x 2 x float>} @vector_deinterleave_nxv2f32
;
; ZVZIP-LABEL: vector_deinterleave_nxv2f32_nxv4f32:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: li a0, 32
-; ZVZIP-NEXT: vsetvli a1, zero, e32, m1, ta, ma
-; ZVZIP-NEXT: vnsrl.wx v10, v8, a0
-; ZVZIP-NEXT: vnsrl.wi v11, v8, 0
-; ZVZIP-NEXT: vmv.v.v v8, v11
-; ZVZIP-NEXT: vmv.v.v v9, v10
+; ZVZIP-NEXT: vsetvli a0, zero, e32, m1, ta, ma
+; ZVZIP-NEXT: vunzipe.v v10, v8
+; ZVZIP-NEXT: vunzipo.v v11, v8
+; ZVZIP-NEXT: vmv.v.v v8, v10
+; ZVZIP-NEXT: vmv.v.v v9, v11
; ZVZIP-NEXT: ret
%retval = call {<vscale x 2 x float>, <vscale x 2 x float>} @llvm.vector.deinterleave2.nxv4f32(<vscale x 4 x float> %vec)
ret {<vscale x 2 x float>, <vscale x 2 x float>} %retval
@@ -1921,8 +1873,8 @@ define {<vscale x 8 x bfloat>, <vscale x 8 x bfloat>} @vector_deinterleave_nxv8b
; ZVZIP-LABEL: vector_deinterleave_nxv8bf16_nxv16bf16:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m2, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v12, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v14, v8, 16
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
; ZVZIP-NEXT: vmv.v.v v8, v12
; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
@@ -1952,8 +1904,8 @@ define {<vscale x 8 x half>, <vscale x 8 x half>} @vector_deinterleave_nxv8f16_n
; ZVZIP-LABEL: vector_deinterleave_nxv8f16_nxv16f16:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m2, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v12, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v14, v8, 16
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
; ZVZIP-NEXT: vmv.v.v v8, v12
; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
@@ -1983,12 +1935,11 @@ define {<vscale x 4 x float>, <vscale x 4 x float>} @vector_deinterleave_nxv4f32
;
; ZVZIP-LABEL: vector_deinterleave_nxv4f32_nxv8f32:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: li a0, 32
-; ZVZIP-NEXT: vsetvli a1, zero, e32, m2, ta, ma
-; ZVZIP-NEXT: vnsrl.wx v12, v8, a0
-; ZVZIP-NEXT: vnsrl.wi v14, v8, 0
-; ZVZIP-NEXT: vmv.v.v v8, v14
-; ZVZIP-NEXT: vmv.v.v v10, v12
+; ZVZIP-NEXT: vsetvli a0, zero, e32, m2, ta, ma
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
+; ZVZIP-NEXT: vmv.v.v v8, v12
+; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
%retval = call {<vscale x 4 x float>, <vscale x 4 x float>} @llvm.vector.deinterleave2.nxv8f32(<vscale x 8 x float> %vec)
ret {<vscale x 4 x float>, <vscale x 4 x float>} %retval
@@ -2020,16 +1971,11 @@ define {<vscale x 2 x double>, <vscale x 2 x double>} @vector_deinterleave_nxv2f
;
; ZVZIP-LABEL: vector_deinterleave_nxv2f64_nxv4f64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: li a0, 85
-; ZVZIP-NEXT: vsetvli a1, zero, e8, m1, ta, ma
-; ZVZIP-NEXT: vmv.v.x v16, a0
-; ZVZIP-NEXT: li a0, 170
-; ZVZIP-NEXT: vmv.v.x v20, a0
-; ZVZIP-NEXT: vsetvli a0, zero, e64, m4, ta, ma
-; ZVZIP-NEXT: vcompress.vm v12, v8, v16
-; ZVZIP-NEXT: vcompress.vm v16, v8, v20
-; ZVZIP-NEXT: vmv2r.v v8, v12
-; ZVZIP-NEXT: vmv2r.v v10, v16
+; ZVZIP-NEXT: vsetvli a0, zero, e64, m2, ta, ma
+; ZVZIP-NEXT: vunzipe.v v12, v8
+; ZVZIP-NEXT: vunzipo.v v14, v8
+; ZVZIP-NEXT: vmv.v.v v8, v12
+; ZVZIP-NEXT: vmv.v.v v10, v14
; ZVZIP-NEXT: ret
%retval = call {<vscale x 2 x double>, <vscale x 2 x double>} @llvm.vector.deinterleave2.nxv4f64(<vscale x 4 x double> %vec)
ret {<vscale x 2 x double>, <vscale x 2 x double>} %retval
@@ -2063,10 +2009,10 @@ define {<vscale x 32 x bfloat>, <vscale x 32 x bfloat>} @vector_deinterleave_nxv
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m4, ta, ma
; ZVZIP-NEXT: vmv8r.v v24, v8
-; ZVZIP-NEXT: vnsrl.wi v8, v24, 0
-; ZVZIP-NEXT: vnsrl.wi v0, v24, 16
-; ZVZIP-NEXT: vnsrl.wi v12, v16, 0
-; ZVZIP-NEXT: vnsrl.wi v4, v16, 16
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
; ZVZIP-NEXT: vmv8r.v v16, v0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 32 x bfloat>, <vscale x 32 x bfloat>} @llvm.vector.deinterleave2.nxv64bf16(<vscale x 64 x bfloat> %vec)
@@ -2100,10 +2046,10 @@ define {<vscale x 32 x half>, <vscale x 32 x half>} @vector_deinterleave_nxv32f1
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e16, m4, ta, ma
; ZVZIP-NEXT: vmv8r.v v24, v8
-; ZVZIP-NEXT: vnsrl.wi v8, v24, 0
-; ZVZIP-NEXT: vnsrl.wi v0, v24, 16
-; ZVZIP-NEXT: vnsrl.wi v12, v16, 0
-; ZVZIP-NEXT: vnsrl.wi v4, v16, 16
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
; ZVZIP-NEXT: vmv8r.v v16, v0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 32 x half>, <vscale x 32 x half>} @llvm.vector.deinterleave2.nxv64f16(<vscale x 64 x half> %vec)
@@ -2137,13 +2083,12 @@ define {<vscale x 16 x float>, <vscale x 16 x float>} @vector_deinterleave_nxv16
; ZVZIP-LABEL: vector_deinterleave_nxv16f32_nxv32f32:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e32, m4, ta, ma
-; ZVZIP-NEXT: vmv8r.v v24, v16
-; ZVZIP-NEXT: li a0, 32
-; ZVZIP-NEXT: vnsrl.wx v20, v24, a0
-; ZVZIP-NEXT: vnsrl.wx v16, v8, a0
-; ZVZIP-NEXT: vnsrl.wi v0, v8, 0
-; ZVZIP-NEXT: vnsrl.wi v4, v24, 0
-; ZVZIP-NEXT: vmv8r.v v8, v0
+; ZVZIP-NEXT: vmv8r.v v24, v8
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
+; ZVZIP-NEXT: vmv8r.v v16, v0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 16 x float>, <vscale x 16 x float>} @llvm.vector.deinterleave2.nxv32f32(<vscale x 32 x float> %vec)
ret {<vscale x 16 x float>, <vscale x 16 x float>} %retval
@@ -2209,48 +2154,13 @@ define {<vscale x 8 x double>, <vscale x 8 x double>} @vector_deinterleave_nxv8f
;
; ZVZIP-LABEL: vector_deinterleave_nxv8f64_nxv16f64:
; ZVZIP: # %bb.0:
-; ZVZIP-NEXT: addi sp, sp, -16
-; ZVZIP-NEXT: .cfi_def_cfa_offset 16
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 4
-; ZVZIP-NEXT: sub sp, sp, a0
-; ZVZIP-NEXT: .cfi_escape 0x0f, 0x0d, 0x72, 0x00, 0x11, 0x10, 0x22, 0x11, 0x10, 0x92, 0xa2, 0x38, 0x00, 0x1e, 0x22 # sp + 16 + 16 * vlenb
-; ZVZIP-NEXT: li a0, 85
-; ZVZIP-NEXT: vsetvli a1, zero, e8, mf8, ta, ma
-; ZVZIP-NEXT: vmv.v.x v7, a0
-; ZVZIP-NEXT: li a0, 170
-; ZVZIP-NEXT: vmv.v.x v6, a0
-; ZVZIP-NEXT: vsetvli a0, zero, e64, m8, ta, ma
-; ZVZIP-NEXT: vcompress.vm v24, v8, v7
-; ZVZIP-NEXT: vmv1r.v v28, v7
-; ZVZIP-NEXT: vmv1r.v v29, v6
-; ZVZIP-NEXT: vcompress.vm v0, v8, v29
-; ZVZIP-NEXT: vcompress.vm v8, v16, v28
-; ZVZIP-NEXT: addi a0, sp, 16
-; ZVZIP-NEXT: vs8r.v v8, (a0) # vscale x 64-byte Folded Spill
-; ZVZIP-NEXT: vcompress.vm v8, v16, v29
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 3
-; ZVZIP-NEXT: add a0, sp, a0
-; ZVZIP-NEXT: addi a0, a0, 16
-; ZVZIP-NEXT: vs8r.v v8, (a0) # vscale x 64-byte Folded Spill
-; ZVZIP-NEXT: addi a0, sp, 16
-; ZVZIP-NEXT: vl8r.v v8, (a0) # vscale x 64-byte Folded Reload
-; ZVZIP-NEXT: vmv4r.v v28, v8
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 3
-; ZVZIP-NEXT: add a0, sp, a0
-; ZVZIP-NEXT: addi a0, a0, 16
-; ZVZIP-NEXT: vl8r.v v8, (a0) # vscale x 64-byte Folded Reload
-; ZVZIP-NEXT: vmv4r.v v4, v8
-; ZVZIP-NEXT: vmv8r.v v8, v24
+; ZVZIP-NEXT: vsetvli a0, zero, e64, m4, ta, ma
+; ZVZIP-NEXT: vmv8r.v v24, v8
+; ZVZIP-NEXT: vunzipe.v v8, v24
+; ZVZIP-NEXT: vunzipo.v v0, v24
+; ZVZIP-NEXT: vunzipe.v v12, v16
+; ZVZIP-NEXT: vunzipo.v v4, v16
; ZVZIP-NEXT: vmv8r.v v16, v0
-; ZVZIP-NEXT: csrr a0, vlenb
-; ZVZIP-NEXT: slli a0, a0, 4
-; ZVZIP-NEXT: add sp, sp, a0
-; ZVZIP-NEXT: .cfi_def_cfa sp, 16
-; ZVZIP-NEXT: addi sp, sp, 16
-; ZVZIP-NEXT: .cfi_def_cfa_offset 0
; ZVZIP-NEXT: ret
%retval = call {<vscale x 8 x double>, <vscale x 8 x double>} @llvm.vector.deinterleave2.nxv16f64(<vscale x 16 x double> %vec)
ret {<vscale x 8 x double>, <vscale x 8 x double>} %retval
@@ -4040,7 +3950,7 @@ define <vscale x 16 x i8> @vector_deinterleave_nxv16i8_nxv32i8_oneactive(<vscale
; ZVZIP-LABEL: vector_deinterleave_nxv16i8_nxv32i8_oneactive:
; ZVZIP: # %bb.0:
; ZVZIP-NEXT: vsetvli a0, zero, e8, m2, ta, ma
-; ZVZIP-NEXT: vnsrl.wi v12, v8, 0
+; ZVZIP-NEXT: vunzipe.v v12, v8
; ZVZIP-NEXT: vmv.v.v v8, v12
; ZVZIP-NEXT: ret
%retval = call {<vscale x 16 x i8>, <vscale x 16 x i8>} @llvm.vector.deinterleave2.nxv32i8(<vscale x 32 x i8> %vec)
More information about the llvm-commits
mailing list