[llvm] [SLP]Add extractelement as a main opcode for copyables (PR #216503)
via llvm-commits
llvm-commits at lists.llvm.org
Sat Aug 15 12:06:56 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-risc-v
Author: Alexey Bataev (alexey-bataev)
<details>
<summary>Changes</summary>
Model a bundle of extractelements from a common vector plus a foreign scalar
as a copyable node: matching lanes reuse the source vector and copyable lanes
are inserted into it. Limited to the identity extract order without a reuse
shuffle, other cases fall back to gather.
Fixes #<!-- -->192849
---
Patch is 42.98 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/216503.diff
12 Files Affected:
- (modified) llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp (+94-21)
- (modified) llvm/test/Transforms/SLPVectorizer/AArch64/externally-used-copyables.ll (+1-1)
- (modified) llvm/test/Transforms/SLPVectorizer/RISCV/load-store.ll (+6-8)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/copyable-extractelement-in-stores.ll (+2-16)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/extractelement-single-use-many-nodes.ll (+1-1)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/reduction-logical.ll (+1-3)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/reduction-with-removed-extracts.ll (+4-2)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/same-values-sub-node-with-poisons.ll (+22-15)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/select-copyable-cmp-poison.ll (+9-9)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/split-node-reused-and-reordered-operand.ll (+11-9)
- (modified) llvm/test/Transforms/SLPVectorizer/X86/split-node-reused-in-later-vector.ll (+6-8)
- (modified) llvm/test/Transforms/SLPVectorizer/reduction-gather-non-scheduled-extracts.ll (+5-7)
``````````diff
diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
index 1b418ae5185ee..06ea9f8ec9693 100644
--- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
+++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
@@ -539,10 +539,13 @@ isFixedVectorShuffle(ArrayRef<Value *> VL, SmallVectorImpl<int> &Mask,
ShuffleMode CommonShuffleMode = Unknown;
Mask.assign(VL.size(), PoisonMaskElem);
for (unsigned I = 0, E = VL.size(); I < E; ++I) {
- // Undef can be represented as an undef element in a vector.
+ // Undef, or a copyable lane modeled on an extract main op, can be
+ // represented as an undef element in a vector.
if (isa<UndefValue>(VL[I]))
continue;
- auto *EI = cast<ExtractElementInst>(VL[I]);
+ auto *EI = dyn_cast<ExtractElementInst>(VL[I]);
+ if (!EI)
+ continue;
if (isa<ScalableVectorType>(EI->getVectorOperandType()))
return std::nullopt;
auto *Vec = EI->getVectorOperand();
@@ -7448,7 +7451,7 @@ BoUpSLP::getReorderingData(const TreeEntry &TE, bool TopToBottom,
SmallVector<int> ReusedMask(TE.ReuseShuffleIndices.begin(),
TE.ReuseShuffleIndices.end());
if (TE.hasState() && TE.getOpcode() == Instruction::ExtractElement &&
- all_of(TE.Scalars, [Sz](Value *V) {
+ !TE.hasCopyableElements() && all_of(TE.Scalars, [Sz](Value *V) {
if (isa<PoisonValue>(V))
return true;
std::optional<unsigned> Idx = getExtractIndex(cast<Instruction>(V));
@@ -7647,7 +7650,10 @@ BoUpSLP::getReorderingData(const TreeEntry &TE, bool TopToBottom,
allSameType(TE.Scalars)) {
// TODO: add analysis of other gather nodes with extractelement
// instructions and other values/instructions, not only undefs.
- if (((TE.hasState() && TE.getOpcode() == Instruction::ExtractElement) ||
+ // Nodes with copyable lanes may mix in non-extract lanes, for which the
+ // extract-index order is not applicable.
+ if (((TE.hasState() && TE.getOpcode() == Instruction::ExtractElement &&
+ !TE.hasCopyableElements()) ||
(all_of(TE.Scalars, IsaPred<UndefValue, ExtractElementInst>) &&
any_of(TE.Scalars, IsaPred<ExtractElementInst>))) &&
all_of(TE.Scalars, [](Value *V) {
@@ -10157,6 +10163,8 @@ BoUpSLP::TreeEntry::EntryState BoUpSLP::getScalarsVectorizationState(
}
case Instruction::ExtractElement:
if (any_of(VL, [&](Value *V) {
+ if (S.isCopyableElement(V) || isa<PoisonValue>(V))
+ return false;
auto *EI = dyn_cast<ExtractElementInst>(V);
if (!EI)
return true;
@@ -10170,6 +10178,13 @@ BoUpSLP::TreeEntry::EntryState BoUpSLP::getScalarsVectorizationState(
[[fallthrough]];
case Instruction::ExtractValue: {
bool Reuse = canReuseExtract(VL, CurrentOrder);
+ // Copyable lanes are inserted into the reused source vector at their own
+ // index, which is correct only for the identity extract order (empty
+ // CurrentOrder) and without a reuse shuffle; other cases fall back to
+ // gather.
+ if (S.areInstructionsWithCopyableElements() &&
+ (!Reuse || !ReuseShuffleIndices.empty()))
+ return TreeEntry::NeedToGather;
if (Reuse || !CurrentOrder.empty())
return TreeEntry::Vectorize;
SmallVector<unsigned> Indices;
@@ -11150,10 +11165,14 @@ class InstructionsCompatibilityAnalysis {
/// Checks if \p I can be the main op for copyable analysis: a supported
/// binary operator, fmuladd, or an integer min/max intrinsic, the only
/// call with a well-defined idempotent value (FP min/max lacks one because of
- /// NaNs).
+ /// NaNs). An extractelement with constant index from a fixed vector is also
+ /// supported: the matching lanes reuse the source vector and the copyable
+ /// lanes are inserted into it.
static bool isSupportedMainOp(Instruction *I) {
return isSupportedOpcode(I->getOpcode()) || isa<MinMaxIntrinsic>(I) ||
- RecurrenceDescriptor::isFMulAddIntrinsic(I);
+ RecurrenceDescriptor::isFMulAddIntrinsic(I) ||
+ (isa<ExtractElementInst>(I) && isVectorLikeInstWithConstOps(I) &&
+ isa<FixedVectorType>(I->getOperand(0)->getType()));
}
/// Identifies the best candidate value, which represents main opcode
@@ -11768,6 +11787,18 @@ class InstructionsCompatibilityAnalysis {
return OrigS;
if (!WithProfitabilityCheck)
return S;
+ // ExtractElement copyable nodes reuse the source vector and insert the
+ // copyable lanes; the binary-operator operand heuristics below do not
+ // apply, so defer profitability to the full tree cost.
+ if (isa<ExtractElementInst>(MainOp)) {
+ // A load as a copyable lane would be pulled out of the consecutive-load
+ // vectorization; keep the original state so the node can be split.
+ if (any_of(VL, [&](Value *V) {
+ return S.isCopyableElement(V) && isa<LoadInst>(V);
+ }))
+ return OrigS;
+ return S;
+ }
// Check if it is profitable to vectorize the instruction.
unsigned CopyableNum =
count_if(VL, [&](Value *V) { return S.isCopyableElement(V); });
@@ -11954,6 +11985,14 @@ class InstructionsCompatibilityAnalysis {
if (S.areInstructionsWithCopyableElements()) {
MainOp = S.getMainOp();
MainOpcode = S.getOpcode();
+ // ExtractElement copyable nodes carry a single operand (the shared
+ // source vector); copyable lanes are inserted during codegen and do
+ // not contribute an operand column.
+ if (MainOpcode == Instruction::ExtractElement) {
+ Operands.assign(1,
+ BoUpSLP::ValueList(VL.size(), MainOp->getOperand(0)));
+ return Operands;
+ }
// Excludes the trailing callee operand (2 for min/max, 3 for fmuladd).
// getNumberOfPotentiallyCommutativeOps collapses fmuladd to 2 and must
// not be used here. Only the 2-operand case is commutative-normalized.
@@ -13504,9 +13543,6 @@ bool BoUpSLP::canReuseExtract(ArrayRef<Value *> VL,
const auto *It = find_if(VL, IsaPred<ExtractElementInst, ExtractValueInst>);
assert(It != VL.end() && "Expected at least one extract instruction.");
auto *E0 = cast<Instruction>(*It);
- assert(
- all_of(VL, IsaPred<UndefValue, ExtractElementInst, ExtractValueInst>) &&
- "Invalid opcode");
// Check if all of the extracts come from the same vector and from the
// correct offset.
Value *Vec = E0->getOperand(0);
@@ -13533,9 +13569,11 @@ bool BoUpSLP::canReuseExtract(ArrayRef<Value *> VL,
SmallVector<int> Indices(E, PoisonMaskElem);
unsigned MinIdx = NElts, MaxIdx = 0;
for (auto [I, V] : enumerate(VL)) {
- auto *Inst = dyn_cast<Instruction>(V);
- if (!Inst)
+ // Non-extract lanes (copyable elements modeled on an extract main op, or
+ // undefs) are treated as holes.
+ if (!isa<ExtractElementInst, ExtractValueInst>(V))
continue;
+ auto *Inst = cast<Instruction>(V);
if (Inst->getOperand(0) != Vec)
return false;
if (auto *EE = dyn_cast<ExtractElementInst>(Inst))
@@ -17015,11 +17053,21 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
if (ShuffleOrOp == Instruction::ExtractValue && !E->StructEVIndices.empty())
return CommonCost;
APInt DemandedElts;
+ APInt CopyableInsertElts;
VectorType *SrcVecTy = nullptr;
auto GetScalarCost = [&](unsigned Idx) {
if (isa<PoisonValue>(UniqueValues[Idx]))
return InstructionCost(TTI::TCC_Free);
+ // Copyable lanes are not extracts; they are inserted into the reused
+ // source vector, so charge the insert to the vector side only.
+ if (E->isCopyableElement(UniqueValues[Idx])) {
+ if (CopyableInsertElts.isZero())
+ CopyableInsertElts = APInt::getZero(E->getVectorFactor());
+ CopyableInsertElts.setBit(Idx);
+ return InstructionCost(TTI::TCC_Free);
+ }
+
auto *I = cast<Instruction>(UniqueValues[Idx]);
if (!SrcVecTy) {
if (ShuffleOrOp == Instruction::ExtractElement) {
@@ -17058,11 +17106,19 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
return InstructionCost(TTI::TCC_Free);
};
auto GetVectorCost = [&, &TTI = *TTI](InstructionCost CommonCost) {
- return CommonCost - (DemandedElts.isZero()
- ? TTI::TCC_Free
- : TTI.getScalarizationOverhead(
- SrcVecTy, DemandedElts, /*Insert=*/false,
- /*Extract=*/true, CostKind));
+ return CommonCost +
+ (CopyableInsertElts.isZero()
+ ? TTI::TCC_Free
+ : TTI.getScalarizationOverhead(
+ cast<VectorType>(
+ getWidenedType(OrigScalarTy, E->getVectorFactor())),
+ CopyableInsertElts, /*Insert=*/true,
+ /*Extract=*/false, CostKind)) -
+ (DemandedElts.isZero()
+ ? TTI::TCC_Free
+ : TTI.getScalarizationOverhead(SrcVecTy, DemandedElts,
+ /*Insert=*/false,
+ /*Extract=*/true, CostKind));
};
return GetCostDiff(GetScalarCost, GetVectorCost);
}
@@ -18082,8 +18138,11 @@ bool BoUpSLP::isFullyVectorizableTinyTree(bool ForReduction) const {
[this](Value *V) { return EphValues.contains(V); }) &&
(allConstant(TE->Scalars) || isSplat(TE->Scalars) ||
TE->Scalars.size() < Limit ||
+ // Nodes with copyable lanes may mix in non-extract lanes, which
+ // are not representable as a shuffle of the source vector.
(((TE->hasState() &&
- TE->getOpcode() == Instruction::ExtractElement) ||
+ TE->getOpcode() == Instruction::ExtractElement &&
+ !TE->hasCopyableElements()) ||
all_of(TE->Scalars, IsaPred<ExtractElementInst, UndefValue>)) &&
isFixedVectorShuffle(TE->Scalars, Mask, AC)) ||
(TE->hasState() && TE->getOpcode() == Instruction::Load &&
@@ -18470,11 +18529,14 @@ bool BoUpSLP::isTreeTinyAndNotFullyVectorizable(bool ForReduction) const {
// Check if any of the gather node forms an insertelement buildvector
// somewhere. TreeSize >= 1 is guaranteed, so the multi-node case reduces to
// a simple TreeSize > 1 short-circuit.
+ // A gather with copyable lanes is not a real instruction node; do not let
+ // its state qualify it as a buildvector-forming node.
const bool IsAllowedSingleBVNode =
- TreeSize > 1 || (FrontHasState && !Front.isAltShuffle() &&
- FrontOpcode != Instruction::PHI &&
- FrontOpcode != Instruction::GetElementPtr &&
- allSameBlock(Front.Scalars));
+ TreeSize > 1 ||
+ (FrontHasState && !Front.isAltShuffle() && !Front.hasCopyableElements() &&
+ FrontOpcode != Instruction::PHI &&
+ FrontOpcode != Instruction::GetElementPtr &&
+ allSameBlock(Front.Scalars));
if (any_of(VectorizableTree, [&](const std::unique_ptr<TreeEntry> &TE) {
return TE->isGather() && all_of(TE->Scalars, [&](Value *V) {
return isa<ExtractElementInst, Constant>(V) ||
@@ -23473,6 +23535,17 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E) {
Value *V = E->getSingleOperand(0);
setInsertPointAfterBundle(E);
V = FinalShuffle(V, E);
+ // Insert the copyable lanes (non-extract scalars modeled on the extract
+ // main op) into the reused source vector. The identity extract order and
+ // absence of a reuse shuffle are guaranteed when the node is created, so
+ // a lane maps to its own index.
+ if (E->hasCopyableElements()) {
+ assert(E->ReorderIndices.empty() && E->ReuseShuffleIndices.empty() &&
+ "Copyable extract lanes require identity order and no reuse.");
+ for (auto [Idx, Scalar] : enumerate(E->Scalars))
+ if (E->isCopyableElement(Scalar))
+ V = Builder.CreateInsertElement(V, Scalar, Builder.getInt32(Idx));
+ }
E->VectorizedValue = V;
return V;
}
diff --git a/llvm/test/Transforms/SLPVectorizer/AArch64/externally-used-copyables.ll b/llvm/test/Transforms/SLPVectorizer/AArch64/externally-used-copyables.ll
index f602ff125bd8c..c98a4d1f2c182 100644
--- a/llvm/test/Transforms/SLPVectorizer/AArch64/externally-used-copyables.ll
+++ b/llvm/test/Transforms/SLPVectorizer/AArch64/externally-used-copyables.ll
@@ -66,7 +66,6 @@ define void @test(i64 %0, i64 %1, i64 %2, i64 %3, i64 %.sroa.3341.0.copyload, i6
; CHECK-NEXT: [[DIFF_CHECK3817:%.*]] = icmp ult i64 [[TMP1]], [[TMP2]]
; CHECK-NEXT: [[TMP76:%.*]] = add i64 [[TMP53]], 1
; CHECK-NEXT: [[DIFF_CHECK3820:%.*]] = icmp ult i64 [[TMP76]], [[TMP0]]
-; CHECK-NEXT: [[TMP98:%.*]] = shl <2 x i64> [[TMP12]], splat (i64 1)
; CHECK-NEXT: [[TMP77:%.*]] = insertelement <4 x i64> [[TMP63]], i64 [[INDVAR37888]], i64 0
; CHECK-NEXT: [[TMP78:%.*]] = shufflevector <4 x i64> [[TMP77]], <4 x i64> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 1>
; CHECK-NEXT: [[TMP80:%.*]] = shufflevector <4 x i64> [[TMP77]], <4 x i64> <i64 1, i64 poison, i64 poison, i64 poison>, <4 x i32> <i32 4, i32 1, i32 poison, i32 poison>
@@ -80,6 +79,7 @@ define void @test(i64 %0, i64 %1, i64 %2, i64 %3, i64 %.sroa.3341.0.copyload, i6
; CHECK-NEXT: [[TMP100:%.*]] = shufflevector <8 x i64> [[TMP52]], <8 x i64> poison, <32 x i32> <i32 poison, i32 poison, i32 poison, i32 poison, i32 4, i32 5, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
; CHECK-NEXT: [[TMP73:%.*]] = shufflevector <8 x i64> [[TMP52]], <8 x i64> poison, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
; CHECK-NEXT: [[TMP87:%.*]] = shufflevector <32 x i64> [[TMP90]], <32 x i64> [[TMP73]], <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 36, i32 37, i32 poison, i32 poison, i32 10, i32 11, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
+; CHECK-NEXT: [[TMP98:%.*]] = shl <2 x i64> [[TMP12]], splat (i64 1)
; CHECK-NEXT: [[TMP125:%.*]] = shufflevector <2 x i64> [[TMP98]], <2 x i64> poison, <32 x i32> <i32 0, i32 1, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
; CHECK-NEXT: [[TMP88:%.*]] = shufflevector <32 x i64> [[TMP87]], <32 x i64> [[TMP125]], <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 32, i32 33, i32 10, i32 11, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>
; CHECK-NEXT: [[TMP59:%.*]] = insertelement <32 x i64> [[TMP88]], i64 [[TMP54]], i64 12
diff --git a/llvm/test/Transforms/SLPVectorizer/RISCV/load-store.ll b/llvm/test/Transforms/SLPVectorizer/RISCV/load-store.ll
index dc022108dfc1e..0a40632c3e4f9 100644
--- a/llvm/test/Transforms/SLPVectorizer/RISCV/load-store.ll
+++ b/llvm/test/Transforms/SLPVectorizer/RISCV/load-store.ll
@@ -274,10 +274,9 @@ define void @shared-chain-ordering(ptr %dest, ptr %p, i64 %offset) {
; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i16>, ptr [[P]], align 4
; CHECK-NEXT: [[E1:%.*]] = load i16, ptr [[INC]], align 2
; CHECK-NEXT: store <4 x i16> [[TMP0]], ptr [[INCS0]], align 4
-; CHECK-NEXT: [[TMP1:%.*]] = extractelement <4 x i16> [[TMP0]], i64 0
-; CHECK-NEXT: store i16 [[TMP1]], ptr [[DEST]], align 4
-; CHECK-NEXT: [[INCS:%.*]] = getelementptr inbounds i16, ptr [[DEST]], i64 1
-; CHECK-NEXT: store i16 [[E1]], ptr [[INCS]], align 2
+; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <4 x i16> [[TMP0]], <4 x i16> poison, <2 x i32> <i32 0, i32 poison>
+; CHECK-NEXT: [[TMP2:%.*]] = insertelement <2 x i16> [[TMP1]], i16 [[E1]], i64 1
+; CHECK-NEXT: store <2 x i16> [[TMP2]], ptr [[DEST]], align 4
; CHECK-NEXT: ret void
;
; DEFAULT-LABEL: @shared-chain-ordering(
@@ -287,10 +286,9 @@ define void @shared-chain-ordering(ptr %dest, ptr %p, i64 %offset) {
; DEFAULT-NEXT: [[TMP0:%.*]] = load <4 x i16>, ptr [[P]], align 4
; DEFAULT-NEXT: [[E1:%.*]] = load i16, ptr [[INC]], align 2
; DEFAULT-NEXT: store <4 x i16> [[TMP0]], ptr [[INCS0]], align 4
-; DEFAULT-NEXT: [[TMP1:%.*]] = extractelement <4 x i16> [[TMP0]], i64 0
-; DEFAULT-NEXT: store i16 [[TMP1]], ptr [[DEST]], align 4
-; DEFAULT-NEXT: [[INCS:%.*]] = getelementptr inbounds i16, ptr [[DEST]], i64 1
-; DEFAULT-NEXT: store i16 [[E1]], ptr [[INCS]], align 2
+; DEFAULT-NEXT: [[TMP1:%.*]] = shufflevector <4 x i16> [[TMP0]], <4 x i16> poison, <2 x i32> <i32 0, i32 poison>
+; DEFAULT-NEXT: [[TMP2:%.*]] = insertelement <2 x i16> [[TMP1]], i16 [[E1]], i64 1
+; DEFAULT-NEXT: store <2 x i16> [[TMP2]], ptr [[DEST]], align 4
; DEFAULT-NEXT: ret void
;
entry:
diff --git a/llvm/test/Transforms/SLPVectorizer/X86/copyable-extractelement-in-stores.ll b/llvm/test/Transforms/SLPVectorizer/X86/copyable-extractelement-in-stores.ll
index a377ca2e44f48..09a006e1cf689 100644
--- a/llvm/test/Transforms/SLPVectorizer/X86/copyable-extractelement-in-stores.ll
+++ b/llvm/test/Transforms/SLPVectorizer/X86/copyable-extractelement-in-stores.ll
@@ -12,22 +12,8 @@ define void @test(i8 %s, ptr %out) {
; CHECK-NEXT: [[I0:%.*]] = insertelement <16 x i8> poison, i8 [[S]], i64 0
; CHECK-NEXT: [[SPLAT:%.*]] = shufflevector <16 x i8> [[I0]], <16 x i8> poison, <16 x i32> zeroinitializer
; CHECK-NEXT: [[V:%.*]] = add <16 x i8> [[SPLAT]], <i8 poison, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>
-; CHECK-NEXT: store i8 [[S]], ptr [[OUT]], align 1
-; CHECK-NEXT: [[P1:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i64 1
-; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <16 x i8> [[V]], <16 x i8> poison, <8 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8>
-; CHECK-NEXT: store <8 x i8> [[TMP1]], ptr [[P1]], align 1
-; CHECK-NEXT: [[P9:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i64 9
-; CHECK-NEXT: [[TMP2:%.*]] = shufflevector <16 x i8> [[V]], <16 x i8> poison, <4 x i32> <i32 9, i32 10, i32 11, i32 12>
-; CHECK-NEXT: store <4 x i8> [[TMP2]], ptr [[P9]], align 1
-; CHECK-NEXT: [[E13:%.*]] = extractelement <16 x i8> [[V]], i64 13
-; CHECK-NEXT: [[P13:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i64 13
-; CHECK-NEXT: store i8 [[E13]], ptr [[P13]], align 1
-; CHECK-NEXT: [[E14:%.*]] = extractelement <16 x i8> [[V]], i64 14
-; CHECK-NEXT: [[P14:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i64 14
-; CHECK-NEXT: store i8 [[E14]], ptr [[P14]], align 1
-; CHECK-NEXT: [[E15:%.*]] = extractelement <16 x i8> [[V]], i64 15
-; CHECK-NEXT: [[P15:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i64 15
-; CHECK-NEXT: store i8 [[E15]], ptr [[P15]], align 1
+; CHECK-NEXT: [[TMP1:%.*]] = shufflevector <16 x i8> [[V]], <16 x i8> [[I0]], <16 x i32> <i32 16, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
+; CHECK-NEXT: store <16 x i8> [[TMP1]], ptr [[OUT]], align 1
; CHECK-NEXT: ret void
;
%i0 = inser...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/216503
More information about the llvm-commits
mailing list