[llvm] 01a9888 - [SLP][NFC]Add isGather() function and use it instead direct comparison, NFC.
Alexey Bataev via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 11 12:11:53 PDT 2024
Author: Alexey Bataev
Date: 2024-07-11T11:56:32-07:00
New Revision: 01a9888694a9c4724fefd6b734f05254f881027b
URL: https://github.com/llvm/llvm-project/commit/01a9888694a9c4724fefd6b734f05254f881027b
DIFF: https://github.com/llvm/llvm-project/commit/01a9888694a9c4724fefd6b734f05254f881027b.diff
LOG: [SLP][NFC]Add isGather() function and use it instead direct comparison, NFC.
Added:
Modified:
llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
index 19353ffd0081a..a56294efc6369 100644
--- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
+++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp
@@ -2884,8 +2884,7 @@ class BoUpSLP {
}
bool isOperandGatherNode(const EdgeInfo &UserEI) const {
- return State == TreeEntry::NeedToGather &&
- UserTreeIndices.front().EdgeIdx == UserEI.EdgeIdx &&
+ return isGather() && UserTreeIndices.front().EdgeIdx == UserEI.EdgeIdx &&
UserTreeIndices.front().UserTE == UserEI.UserTE;
}
@@ -2920,6 +2919,9 @@ class BoUpSLP {
return Scalars.size();
};
+ /// Checks if the current node is a gather node.
+ bool isGather() const {return State == NeedToGather; }
+
/// A vector of scalars.
ValueList Scalars;
@@ -3222,7 +3224,7 @@ class BoUpSLP {
Last->setOperations(S);
Last->ReorderIndices.append(ReorderIndices.begin(), ReorderIndices.end());
}
- if (Last->State != TreeEntry::NeedToGather) {
+ if (!Last->isGather()) {
for (Value *V : VL) {
const TreeEntry *TE = getTreeEntry(V);
assert((!TE || TE == Last || doesNotNeedToBeScheduled(V)) &&
@@ -4088,7 +4090,7 @@ template <> struct DOTGraphTraits<BoUpSLP *> : public DefaultDOTGraphTraits {
static std::string getNodeAttributes(const TreeEntry *Entry,
const BoUpSLP *) {
- if (Entry->State == TreeEntry::NeedToGather)
+ if (Entry->isGather())
return "color=red";
if (Entry->State == TreeEntry::ScatterVectorize ||
Entry->State == TreeEntry::StridedVectorize)
@@ -4200,7 +4202,7 @@ static void reorderOrder(SmallVectorImpl<unsigned> &Order, ArrayRef<int> Mask,
std::optional<BoUpSLP::OrdersType>
BoUpSLP::findReusedOrderedScalars(const BoUpSLP::TreeEntry &TE) {
- assert(TE.State == TreeEntry::NeedToGather && "Expected gather node only.");
+ assert(TE.isGather() && "Expected gather node only.");
// Try to find subvector extract/insert patterns and reorder only such
// patterns.
SmallVector<Value *> GatheredScalars(TE.Scalars.begin(), TE.Scalars.end());
@@ -4834,7 +4836,7 @@ static bool clusterSortPtrAccesses(ArrayRef<Value *> VL, Type *ElemTy,
std::optional<BoUpSLP::OrdersType>
BoUpSLP::findPartiallyOrderedLoads(const BoUpSLP::TreeEntry &TE) {
- assert(TE.State == TreeEntry::NeedToGather && "Expected gather node only.");
+ assert(TE.isGather() && "Expected gather node only.");
Type *ScalarTy = TE.Scalars[0]->getType();
SmallVector<Value *> Ptrs;
@@ -4923,7 +4925,7 @@ BoUpSLP::getReorderingData(const TreeEntry &TE, bool TopToBottom) {
// 0, 1, 2, 3, 3, 3, 1, 0 - not clustered, because
// element 3 is used twice in the second submask.
unsigned Sz = TE.Scalars.size();
- if (TE.State == TreeEntry::NeedToGather) {
+ if (TE.isGather()) {
if (std::optional<OrdersType> CurrentOrder =
findReusedOrderedScalars(TE)) {
SmallVector<int> Mask;
@@ -5014,9 +5016,9 @@ BoUpSLP::getReorderingData(const TreeEntry &TE, bool TopToBottom) {
transform(CurrentOrder, It, [K](unsigned Pos) { return Pos + K; });
std::advance(It, Sz);
}
- if (TE.State == TreeEntry::NeedToGather &&
- all_of(enumerate(ResOrder),
- [](const auto &Data) { return Data.index() == Data.value(); }))
+ if (TE.isGather() && all_of(enumerate(ResOrder), [](const auto &Data) {
+ return Data.index() == Data.value();
+ }))
return std::nullopt; // No need to reorder.
return std::move(ResOrder);
}
@@ -5082,8 +5084,7 @@ BoUpSLP::getReorderingData(const TreeEntry &TE, bool TopToBottom) {
return std::nullopt; // No need to reorder.
return std::move(ResOrder);
}
- if (TE.State == TreeEntry::NeedToGather && !TE.isAltShuffle() &&
- allSameType(TE.Scalars)) {
+ if (TE.isGather() && !TE.isAltShuffle() && allSameType(TE.Scalars)) {
// TODO: add analysis of other gather nodes with extractelement
// instructions and other values/instructions, not only undefs.
if ((TE.getOpcode() == Instruction::ExtractElement ||
@@ -5170,7 +5171,7 @@ void BoUpSLP::reorderNodeWithReuses(TreeEntry &TE, ArrayRef<int> Mask) const {
reorderReuses(TE.ReuseShuffleIndices, Mask);
const unsigned Sz = TE.Scalars.size();
// For vectorized and non-clustered reused no need to do anything else.
- if (TE.State != TreeEntry::NeedToGather ||
+ if (!TE.isGather() ||
!ShuffleVectorInst::isOneUseSingleSourceMask(TE.ReuseShuffleIndices,
Sz) ||
!isRepeatedNonIdentityClusteredMask(TE.ReuseShuffleIndices, Sz))
@@ -5319,8 +5320,7 @@ void BoUpSLP::reorderTopToBottom() {
// Count number of orders uses.
const auto &Order = [OpTE, &GathersToOrders, &AltShufflesToOrders,
&PhisToOrders]() -> const OrdersType & {
- if (OpTE->State == TreeEntry::NeedToGather ||
- !OpTE->ReuseShuffleIndices.empty()) {
+ if (OpTE->isGather() || !OpTE->ReuseShuffleIndices.empty()) {
auto It = GathersToOrders.find(OpTE);
if (It != GathersToOrders.end())
return It->second;
@@ -5566,8 +5566,7 @@ void BoUpSLP::reorderBottomToTop(bool IgnoreReorder) {
for (TreeEntry *TE : OrderedEntries) {
if (!(TE->State == TreeEntry::Vectorize ||
TE->State == TreeEntry::StridedVectorize ||
- (TE->State == TreeEntry::NeedToGather &&
- GathersToOrders.contains(TE))) ||
+ (TE->isGather() && GathersToOrders.contains(TE))) ||
TE->UserTreeIndices.empty() || !TE->ReuseShuffleIndices.empty() ||
!all_of(drop_begin(TE->UserTreeIndices),
[TE](const EdgeInfo &EI) {
@@ -5622,8 +5621,7 @@ void BoUpSLP::reorderBottomToTop(bool IgnoreReorder) {
if (!OpTE->ReuseShuffleIndices.empty() && !GathersToOrders.count(OpTE))
continue;
const auto Order = [&]() -> const OrdersType {
- if (OpTE->State == TreeEntry::NeedToGather ||
- !OpTE->ReuseShuffleIndices.empty())
+ if (OpTE->isGather() || !OpTE->ReuseShuffleIndices.empty())
return getReorderingData(*OpTE, /*TopToBottom=*/false)
.value_or(OrdersType(1));
return OpTE->ReorderIndices;
@@ -5661,7 +5659,7 @@ void BoUpSLP::reorderBottomToTop(bool IgnoreReorder) {
(TE->State == TreeEntry::Vectorize && TE->isAltShuffle()) ||
(IgnoreReorder && TE->Idx == 0))
return true;
- if (TE->State == TreeEntry::NeedToGather) {
+ if (TE->isGather()) {
if (GathersToOrders.contains(TE))
return !getReorderingData(*TE, /*TopToBottom=*/false)
.value_or(OrdersType(1))
@@ -5822,7 +5820,7 @@ void BoUpSLP::buildExternalUses(
TreeEntry *Entry = TEPtr.get();
// No need to handle users of gathered values.
- if (Entry->State == TreeEntry::NeedToGather)
+ if (Entry->isGather())
continue;
// For each lane:
@@ -5866,7 +5864,7 @@ void BoUpSLP::buildExternalUses(
Scalar, cast<Instruction>(UseEntry->Scalars.front()), TLI)) {
LLVM_DEBUG(dbgs() << "SLP: \tInternal user will be removed:" << *U
<< ".\n");
- assert(UseEntry->State != TreeEntry::NeedToGather && "Bad state");
+ assert(!UseEntry->isGather() && "Bad state");
continue;
}
U = nullptr;
@@ -8672,7 +8670,7 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {
InstructionCost ExtraCost = 0;
auto GetNodeMinBWAffectedCost = [&](const TreeEntry &E,
unsigned VF) -> InstructionCost {
- if (E.State == TreeEntry::NeedToGather && allConstant(E.Scalars))
+ if (E.isGather() && allConstant(E.Scalars))
return TTI::TCC_Free;
Type *EScalarTy = E.Scalars.front()->getType();
bool IsSigned = true;
@@ -8895,7 +8893,7 @@ class BoUpSLP::ShuffleCostEstimator : public BaseShuffleAnalysis {
[&](const std::unique_ptr<TreeEntry> &TE) {
return ((!TE->isAltShuffle() &&
TE->getOpcode() == Instruction::ExtractElement) ||
- TE->State == TreeEntry::NeedToGather) &&
+ TE->isGather()) &&
all_of(enumerate(TE->Scalars), [&](auto &&Data) {
return VL.size() > Data.index() &&
(Mask[Data.index()] == PoisonMaskElem ||
@@ -9178,7 +9176,7 @@ const BoUpSLP::TreeEntry *BoUpSLP::getOperandEntry(const TreeEntry *E,
}
const auto *It =
find_if(VectorizableTree, [&](const std::unique_ptr<TreeEntry> &TE) {
- return TE->State == TreeEntry::NeedToGather &&
+ return TE->isGather() &&
find_if(TE->UserTreeIndices, [&](const EdgeInfo &EI) {
return EI.EdgeIdx == Idx && EI.UserTE == E;
}) != TE->UserTreeIndices.end();
@@ -9233,7 +9231,7 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
ArrayRef<Value *> VL = E->Scalars;
Type *ScalarTy = VL[0]->getType();
- if (E->State != TreeEntry::NeedToGather) {
+ if (!E->isGather()) {
if (auto *SI = dyn_cast<StoreInst>(VL[0]))
ScalarTy = SI->getValueOperand()->getType();
else if (auto *CI = dyn_cast<CmpInst>(VL[0]))
@@ -9256,7 +9254,7 @@ BoUpSLP::getEntryCost(const TreeEntry *E, ArrayRef<Value *> VectorizedVals,
auto *FinalVecTy = getWidenedType(ScalarTy, EntryVF);
bool NeedToShuffleReuses = !E->ReuseShuffleIndices.empty();
- if (E->State == TreeEntry::NeedToGather) {
+ if (E->isGather()) {
if (allConstant(VL))
return 0;
if (isa<InsertElementInst>(VL[0]))
@@ -9951,7 +9949,7 @@ bool BoUpSLP::isFullyVectorizableTinyTree(bool ForReduction) const {
auto &&AreVectorizableGathers = [this](const TreeEntry *TE, unsigned Limit) {
SmallVector<int> Mask;
- return TE->State == TreeEntry::NeedToGather &&
+ return TE->isGather() &&
!any_of(TE->Scalars,
[this](Value *V) { return EphValues.contains(V); }) &&
(allConstant(TE->Scalars) || isSplat(TE->Scalars) ||
@@ -9959,8 +9957,8 @@ bool BoUpSLP::isFullyVectorizableTinyTree(bool ForReduction) const {
((TE->getOpcode() == Instruction::ExtractElement ||
all_of(TE->Scalars, IsaPred<ExtractElementInst, UndefValue>)) &&
isFixedVectorShuffle(TE->Scalars, Mask)) ||
- (TE->State == TreeEntry::NeedToGather &&
- TE->getOpcode() == Instruction::Load && !TE->isAltShuffle()));
+ (TE->isGather() && TE->getOpcode() == Instruction::Load &&
+ !TE->isAltShuffle()));
};
// We only handle trees of heights 1 and 2.
@@ -9986,8 +9984,8 @@ bool BoUpSLP::isFullyVectorizableTinyTree(bool ForReduction) const {
return true;
// Gathering cost would be too much for tiny trees.
- if (VectorizableTree[0]->State == TreeEntry::NeedToGather ||
- (VectorizableTree[1]->State == TreeEntry::NeedToGather &&
+ if (VectorizableTree[0]->isGather() ||
+ (VectorizableTree[1]->isGather() &&
VectorizableTree[0]->State != TreeEntry::ScatterVectorize &&
VectorizableTree[0]->State != TreeEntry::StridedVectorize))
return false;
@@ -10062,7 +10060,7 @@ bool BoUpSLP::isTreeTinyAndNotFullyVectorizable(bool ForReduction) const {
// No need to vectorize inserts of gathered values.
if (VectorizableTree.size() == 2 &&
isa<InsertElementInst>(VectorizableTree[0]->Scalars[0]) &&
- VectorizableTree[1]->State == TreeEntry::NeedToGather &&
+ VectorizableTree[1]->isGather() &&
(VectorizableTree[1]->getVectorFactor() <= 2 ||
!(isSplat(VectorizableTree[1]->Scalars) ||
allConstant(VectorizableTree[1]->Scalars))))
@@ -10076,7 +10074,7 @@ bool BoUpSLP::isTreeTinyAndNotFullyVectorizable(bool ForReduction) const {
if (!ForReduction && !SLPCostThreshold.getNumOccurrences() &&
!VectorizableTree.empty() &&
all_of(VectorizableTree, [&](const std::unique_ptr<TreeEntry> &TE) {
- return (TE->State == TreeEntry::NeedToGather &&
+ return (TE->isGather() &&
TE->getOpcode() != Instruction::ExtractElement &&
count_if(TE->Scalars, IsaPred<ExtractElementInst>) <= Limit) ||
TE->getOpcode() == Instruction::PHI;
@@ -10103,8 +10101,7 @@ bool BoUpSLP::isTreeTinyAndNotFullyVectorizable(bool ForReduction) const {
VectorizableTree.front()->getOpcode() != Instruction::GetElementPtr &&
allSameBlock(VectorizableTree.front()->Scalars));
if (any_of(VectorizableTree, [&](const std::unique_ptr<TreeEntry> &TE) {
- return TE->State == TreeEntry::NeedToGather &&
- all_of(TE->Scalars, [&](Value *V) {
+ return TE->isGather() && all_of(TE->Scalars, [&](Value *V) {
return isa<ExtractElementInst, UndefValue>(V) ||
(IsAllowedSingleBVNode &&
!V->hasNUsesOrMore(UsesLimit) &&
@@ -10403,7 +10400,7 @@ InstructionCost BoUpSLP::getTreeCost(ArrayRef<Value *> VectorizedVals) {
SmallPtrSet<Value *, 4> CheckedExtracts;
for (unsigned I = 0, E = VectorizableTree.size(); I < E; ++I) {
TreeEntry &TE = *VectorizableTree[I];
- if (TE.State == TreeEntry::NeedToGather) {
+ if (TE.isGather()) {
if (const TreeEntry *E = getTreeEntry(TE.getMainOp());
E && E->getVectorFactor() == TE.getVectorFactor() &&
E->isSame(TE.Scalars)) {
@@ -11462,8 +11459,7 @@ Instruction &BoUpSLP::getLastInstructionInBundle(const TreeEntry *E) {
// Set the insert point to the beginning of the basic block if the entry
// should not be scheduled.
if (doesNotNeedToSchedule(E->Scalars) ||
- (E->State != TreeEntry::NeedToGather &&
- all_of(E->Scalars, isVectorLikeInstWithConstOps))) {
+ (!E->isGather() && all_of(E->Scalars, isVectorLikeInstWithConstOps))) {
if ((E->getOpcode() == Instruction::GetElementPtr &&
any_of(E->Scalars,
[](Value *V) {
@@ -11474,8 +11470,7 @@ Instruction &BoUpSLP::getLastInstructionInBundle(const TreeEntry *E) {
return !isVectorLikeInstWithConstOps(V) &&
isUsedOutsideBlock(V);
}) ||
- (E->State == TreeEntry::NeedToGather && E->Idx == 0 &&
- all_of(E->Scalars, [](Value *V) {
+ (E->isGather() && E->Idx == 0 && all_of(E->Scalars, [](Value *V) {
return isa<ExtractElementInst, UndefValue>(V) ||
areAllOperandsNonInsts(V);
})))
@@ -11533,8 +11528,7 @@ void BoUpSLP::setInsertPointAfterBundle(const TreeEntry *E) {
bool IsPHI = isa<PHINode>(LastInst);
if (IsPHI)
LastInstIt = LastInst->getParent()->getFirstNonPHIIt();
- if (IsPHI || (E->State != TreeEntry::NeedToGather &&
- doesNotNeedToSchedule(E->Scalars))) {
+ if (IsPHI || (!E->isGather() && doesNotNeedToSchedule(E->Scalars))) {
Builder.SetInsertPoint(LastInst->getParent(), LastInstIt);
} else {
// Set the insertion point after the last instruction in the bundle. Set the
@@ -12239,7 +12233,7 @@ Value *BoUpSLP::vectorizeOperand(TreeEntry *E, unsigned NodeIdx,
}) == VE->UserTreeIndices.end()) {
auto *It = find_if(
VectorizableTree, [&](const std::unique_ptr<TreeEntry> &TE) {
- return TE->State == TreeEntry::NeedToGather &&
+ return TE->isGather() &&
TE->UserTreeIndices.front().UserTE == E &&
TE->UserTreeIndices.front().EdgeIdx == NodeIdx;
});
@@ -12267,7 +12261,7 @@ Value *BoUpSLP::vectorizeOperand(TreeEntry *E, unsigned NodeIdx,
template <typename BVTy, typename ResTy, typename... Args>
ResTy BoUpSLP::processBuildVector(const TreeEntry *E, Type *ScalarTy,
Args &...Params) {
- assert(E->State == TreeEntry::NeedToGather && "Expected gather node.");
+ assert(E->isGather() && "Expected gather node.");
unsigned VF = E->getVectorFactor();
bool NeedFreeze = false;
@@ -12727,7 +12721,7 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
if (It != MinBWs.end())
ScalarTy = IntegerType::get(F->getContext(), It->second.first);
auto *VecTy = getWidenedType(ScalarTy, E->Scalars.size());
- if (E->State == TreeEntry::NeedToGather) {
+ if (E->isGather()) {
// Set insert point for non-reduction initial nodes.
if (E->getMainOp() && E->Idx == 0 && !UserIgnoreList)
setInsertPointAfterBundle(E);
@@ -12828,8 +12822,7 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
Builder.SetCurrentDebugLocation(PH->getDebugLoc());
Value *Vec = vectorizeOperand(E, I, /*PostponedPHIs=*/true);
if (VecTy != Vec->getType()) {
- assert((It != MinBWs.end() ||
- getOperandEntry(E, I)->State == TreeEntry::NeedToGather ||
+ assert((It != MinBWs.end() || getOperandEntry(E, I)->isGather() ||
MinBWs.contains(getOperandEntry(E, I))) &&
"Expected item in MinBWs.");
Vec = Builder.CreateIntCast(Vec, VecTy, GetOperandSignedness(I));
@@ -13093,8 +13086,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
return E->VectorizedValue;
}
if (L->getType() != R->getType()) {
- assert((getOperandEntry(E, 0)->State == TreeEntry::NeedToGather ||
- getOperandEntry(E, 1)->State == TreeEntry::NeedToGather ||
+ assert((getOperandEntry(E, 0)->isGather() ||
+ getOperandEntry(E, 1)->isGather() ||
MinBWs.contains(getOperandEntry(E, 0)) ||
MinBWs.contains(getOperandEntry(E, 1))) &&
"Expected item in MinBWs.");
@@ -13141,9 +13134,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
return E->VectorizedValue;
}
if (True->getType() != VecTy || False->getType() != VecTy) {
- assert((It != MinBWs.end() ||
- getOperandEntry(E, 1)->State == TreeEntry::NeedToGather ||
- getOperandEntry(E, 2)->State == TreeEntry::NeedToGather ||
+ assert((It != MinBWs.end() || getOperandEntry(E, 1)->isGather() ||
+ getOperandEntry(E, 2)->isGather() ||
MinBWs.contains(getOperandEntry(E, 1)) ||
MinBWs.contains(getOperandEntry(E, 2))) &&
"Expected item in MinBWs.");
@@ -13228,9 +13220,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
}
}
if (LHS->getType() != VecTy || RHS->getType() != VecTy) {
- assert((It != MinBWs.end() ||
- getOperandEntry(E, 0)->State == TreeEntry::NeedToGather ||
- getOperandEntry(E, 1)->State == TreeEntry::NeedToGather ||
+ assert((It != MinBWs.end() || getOperandEntry(E, 0)->isGather() ||
+ getOperandEntry(E, 1)->isGather() ||
MinBWs.contains(getOperandEntry(E, 0)) ||
MinBWs.contains(getOperandEntry(E, 1))) &&
"Expected item in MinBWs.");
@@ -13522,9 +13513,8 @@ Value *BoUpSLP::vectorizeTree(TreeEntry *E, bool PostponedPHIs) {
((Instruction::isBinaryOp(E->getOpcode()) &&
(LHS->getType() != VecTy || RHS->getType() != VecTy)) ||
(isa<CmpInst>(VL0) && LHS->getType() != RHS->getType()))) {
- assert((It != MinBWs.end() ||
- getOperandEntry(E, 0)->State == TreeEntry::NeedToGather ||
- getOperandEntry(E, 1)->State == TreeEntry::NeedToGather ||
+ assert((It != MinBWs.end() || getOperandEntry(E, 0)->isGather() ||
+ getOperandEntry(E, 1)->isGather() ||
MinBWs.contains(getOperandEntry(E, 0)) ||
MinBWs.contains(getOperandEntry(E, 1))) &&
"Expected item in MinBWs.");
@@ -13809,8 +13799,7 @@ Value *BoUpSLP::vectorizeTree(
continue;
TreeEntry *E = getTreeEntry(Scalar);
assert(E && "Invalid scalar");
- assert(E->State != TreeEntry::NeedToGather &&
- "Extracting from a gather list");
+ assert(!E->isGather() && "Extracting from a gather list");
// Non-instruction pointers are not deleted, just skip them.
if (E->getOpcode() == Instruction::GetElementPtr &&
!isa<GetElementPtrInst>(Scalar))
@@ -14168,7 +14157,7 @@ Value *BoUpSLP::vectorizeTree(
TreeEntry *Entry = TEPtr.get();
// No need to handle users of gathered values.
- if (Entry->State == TreeEntry::NeedToGather)
+ if (Entry->isGather())
continue;
assert(Entry->VectorizedValue && "Can't find vectorizable value");
@@ -15122,7 +15111,7 @@ bool BoUpSLP::collectValuesToDemote(
bool Res = all_of(
E.Scalars, std::bind(IsPotentiallyTruncated, _1, std::ref(BitWidth)));
// Demote gathers.
- if (Res && E.State == TreeEntry::NeedToGather) {
+ if (Res && E.isGather()) {
// Check possible extractelement instructions bases and final vector
// length.
SmallPtrSet<Value *, 4> UniqueBases;
@@ -15142,7 +15131,7 @@ bool BoUpSLP::collectValuesToDemote(
}
return Res;
};
- if (E.State == TreeEntry::NeedToGather || !Visited.insert(&E).second ||
+ if (E.isGather() || !Visited.insert(&E).second ||
any_of(E.Scalars, [&](Value *V) {
return all_of(V->users(), [&](User *U) {
return isa<InsertElementInst>(U) && !getTreeEntry(U);
@@ -15431,12 +15420,11 @@ void BoUpSLP::computeMinimumValueSizes() {
return;
unsigned NodeIdx = 0;
- if (IsStoreOrInsertElt &&
- VectorizableTree.front()->State != TreeEntry::NeedToGather)
+ if (IsStoreOrInsertElt && !VectorizableTree.front()->isGather())
NodeIdx = 1;
// Ensure the roots of the vectorizable tree don't form a cycle.
- if (VectorizableTree[NodeIdx]->State == TreeEntry::NeedToGather ||
+ if (VectorizableTree[NodeIdx]->isGather() ||
(NodeIdx == 0 && !VectorizableTree[NodeIdx]->UserTreeIndices.empty()) ||
(NodeIdx != 0 && any_of(VectorizableTree[NodeIdx]->UserTreeIndices,
[NodeIdx](const EdgeInfo &EI) {
More information about the llvm-commits
mailing list