[llvm] [LV][NFC] Rename ScalarEpilogueLowering to remove 'Scalar' term. (PR #191871)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Apr 13 11:51:52 PDT 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-vectorizers
Author: Hassnaa Hamdi (hassnaaHamdi)
<details>
<summary>Changes</summary>
Rename ScalarEpilogueLowering enum to EpilogueLowering and update related code.
The term 'scalar' here is misleading given that the epilogue could get vectorized.
---
Patch is 28.58 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/191871.diff
10 Files Affected:
- (modified) llvm/include/llvm/Analysis/TargetTransformInfo.h (+2-2)
- (modified) llvm/include/llvm/Analysis/TargetTransformInfoImpl.h (+1-1)
- (modified) llvm/include/llvm/CodeGen/BasicTTIImpl.h (+2-2)
- (modified) llvm/lib/Analysis/TargetTransformInfo.cpp (+2-2)
- (modified) llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp (+3-3)
- (modified) llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h (+1-1)
- (modified) llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp (+10-9)
- (modified) llvm/lib/Target/ARM/ARMTargetTransformInfo.h (+1-1)
- (modified) llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h (+1-1)
- (modified) llvm/lib/Transforms/Vectorize/LoopVectorize.cpp (+84-85)
``````````diff
diff --git a/llvm/include/llvm/Analysis/TargetTransformInfo.h b/llvm/include/llvm/Analysis/TargetTransformInfo.h
index 3c4f00c0d87b5..5b427bbf1042f 100644
--- a/llvm/include/llvm/Analysis/TargetTransformInfo.h
+++ b/llvm/include/llvm/Analysis/TargetTransformInfo.h
@@ -754,9 +754,9 @@ class TargetTransformInfo {
// vectorization should be considered.
LLVM_ABI unsigned getEpilogueVectorizationMinVF() const;
- /// Query the target whether it would be prefered to create a predicated
+ /// Query the target whether it would be prefered to create a tail-folded
/// vector loop, which can avoid the need to emit a scalar epilogue loop.
- LLVM_ABI bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const;
+ LLVM_ABI bool preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const;
/// Query the target what the preferred style of tail folding is.
LLVM_ABI TailFoldingStyle getPreferredTailFoldingStyle() const;
diff --git a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
index 7eb363c7b4404..3221f6b63e4f4 100644
--- a/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
+++ b/llvm/include/llvm/Analysis/TargetTransformInfoImpl.h
@@ -274,7 +274,7 @@ class TargetTransformInfoImplBase {
virtual unsigned getEpilogueVectorizationMinVF() const { return 16; }
- virtual bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const {
+ virtual bool preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const {
return false;
}
diff --git a/llvm/include/llvm/CodeGen/BasicTTIImpl.h b/llvm/include/llvm/CodeGen/BasicTTIImpl.h
index 7dbd8bc658161..6dd3e264c4870 100644
--- a/llvm/include/llvm/CodeGen/BasicTTIImpl.h
+++ b/llvm/include/llvm/CodeGen/BasicTTIImpl.h
@@ -801,8 +801,8 @@ class BasicTTIImplBase : public TargetTransformInfoImplCRTPBase<T> {
return BaseT::getEpilogueVectorizationMinVF();
}
- bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const override {
- return BaseT::preferPredicateOverEpilogue(TFI);
+ bool preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const override {
+ return BaseT::preferTailFoldingOverEpilogue(TFI);
}
TailFoldingStyle getPreferredTailFoldingStyle() const override {
diff --git a/llvm/lib/Analysis/TargetTransformInfo.cpp b/llvm/lib/Analysis/TargetTransformInfo.cpp
index 5111593d76a6d..28a418897a1d1 100644
--- a/llvm/lib/Analysis/TargetTransformInfo.cpp
+++ b/llvm/lib/Analysis/TargetTransformInfo.cpp
@@ -379,9 +379,9 @@ unsigned TargetTransformInfo::getEpilogueVectorizationMinVF() const {
return TTIImpl->getEpilogueVectorizationMinVF();
}
-bool TargetTransformInfo::preferPredicateOverEpilogue(
+bool TargetTransformInfo::preferTailFoldingOverEpilogue(
TailFoldingInfo *TFI) const {
- return TTIImpl->preferPredicateOverEpilogue(TFI);
+ return TTIImpl->preferTailFoldingOverEpilogue(TFI);
}
TailFoldingStyle TargetTransformInfo::getPreferredTailFoldingStyle() const {
diff --git a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
index 734339e5c7a05..2d306b3eccbe6 100644
--- a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
+++ b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.cpp
@@ -6469,7 +6469,7 @@ unsigned AArch64TTIImpl::getEpilogueVectorizationMinVF() const {
return ST->getEpilogueVectorizationMinVF();
}
-bool AArch64TTIImpl::preferPredicateOverEpilogue(TailFoldingInfo *TFI) const {
+bool AArch64TTIImpl::preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const {
if (!ST->hasSVE())
return false;
@@ -6486,8 +6486,8 @@ bool AArch64TTIImpl::preferPredicateOverEpilogue(TailFoldingInfo *TFI) const {
Required |= TailFoldingOpts::Recurrences;
// We call this to discover whether any load/store pointers in the loop have
- // negative strides. This will require extra work to reverse the loop
- // predicate, which may be expensive.
+ // negative strides. This will require extra work to reverse the tail-folded
+ // loop, which may be expensive.
if (containsDecreasingPointers(TFI->LVL->getLoop(),
TFI->LVL->getPredicatedScalarEvolution(),
*TFI->LVL->getDominatorTree()))
diff --git a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h
index cde391bdcaea8..db9d361b2d92a 100644
--- a/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h
+++ b/llvm/lib/Target/AArch64/AArch64TargetTransformInfo.h
@@ -473,7 +473,7 @@ class AArch64TTIImpl final : public BasicTTIImplBase<AArch64TTIImpl> {
unsigned getEpilogueVectorizationMinVF() const override;
- bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const override;
+ bool preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const override;
bool supportsScalableVectors() const override {
return ST->isSVEorStreamingSVEAvailable();
diff --git a/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp b/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp
index 03392fc2d84bc..c1df7fbb9d702 100644
--- a/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp
+++ b/llvm/lib/Target/ARM/ARMTargetTransformInfo.cpp
@@ -2616,14 +2616,14 @@ static bool canTailPredicateLoop(Loop *L, LoopInfo *LI, ScalarEvolution &SE,
return true;
}
-bool ARMTTIImpl::preferPredicateOverEpilogue(TailFoldingInfo *TFI) const {
+bool ARMTTIImpl::preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const {
if (!EnableTailPredication) {
- LLVM_DEBUG(dbgs() << "Tail-predication not enabled.\n");
+ LLVM_DEBUG(dbgs() << "Tail-folding not enabled.\n");
return false;
}
- // Creating a predicated vector loop is the first step for generating a
- // tail-predicated hardware loop, for which we need the MVE masked
+ // Creating a tail-folded vector loop is the first step for generating a
+ // tail-folded hardware loop, for which we need the MVE masked
// load/stores instructions:
if (!ST->hasMVEIntegerOps())
return false;
@@ -2633,17 +2633,18 @@ bool ARMTTIImpl::preferPredicateOverEpilogue(TailFoldingInfo *TFI) const {
// For now, restrict this to single block loops.
if (L->getNumBlocks() > 1) {
- LLVM_DEBUG(dbgs() << "preferPredicateOverEpilogue: not a single block "
+ LLVM_DEBUG(dbgs() << "preferTailFoldingOverEpilogue: not a single block "
"loop.\n");
return false;
}
- assert(L->isInnermost() && "preferPredicateOverEpilogue: inner-loop expected");
+ assert(L->isInnermost() &&
+ "preferTailFoldingOverEpilogue: inner-loop expected");
LoopInfo *LI = LVL->getLoopInfo();
HardwareLoopInfo HWLoopInfo(L);
if (!HWLoopInfo.canAnalyze(*LI)) {
- LLVM_DEBUG(dbgs() << "preferPredicateOverEpilogue: hardware-loop is not "
+ LLVM_DEBUG(dbgs() << "preferTailFoldingOverEpilogue: hardware-loop is not "
"analyzable.\n");
return false;
}
@@ -2654,14 +2655,14 @@ bool ARMTTIImpl::preferPredicateOverEpilogue(TailFoldingInfo *TFI) const {
// This checks if we have the low-overhead branch architecture
// extension, and if we will create a hardware-loop:
if (!isHardwareLoopProfitable(L, *SE, *AC, TFI->TLI, HWLoopInfo)) {
- LLVM_DEBUG(dbgs() << "preferPredicateOverEpilogue: hardware-loop is not "
+ LLVM_DEBUG(dbgs() << "preferTailFoldingOverEpilogue: hardware-loop is not "
"profitable.\n");
return false;
}
DominatorTree *DT = LVL->getDominatorTree();
if (!HWLoopInfo.isHardwareLoopCandidate(*SE, *LI, *DT)) {
- LLVM_DEBUG(dbgs() << "preferPredicateOverEpilogue: hardware-loop is not "
+ LLVM_DEBUG(dbgs() << "preferTailFoldingOverEpilogue: hardware-loop is not "
"a candidate.\n");
return false;
}
diff --git a/llvm/lib/Target/ARM/ARMTargetTransformInfo.h b/llvm/lib/Target/ARM/ARMTargetTransformInfo.h
index 0d6d5d202bddf..e824839e39159 100644
--- a/llvm/lib/Target/ARM/ARMTargetTransformInfo.h
+++ b/llvm/lib/Target/ARM/ARMTargetTransformInfo.h
@@ -436,7 +436,7 @@ class ARMTTIImpl final : public BasicTTIImplBase<ARMTTIImpl> {
bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE,
AssumptionCache &AC, TargetLibraryInfo *LibInfo,
HardwareLoopInfo &HWLoopInfo) const override;
- bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const override;
+ bool preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const override;
void getUnrollingPreferences(Loop *L, ScalarEvolution &SE,
TTI::UnrollingPreferences &UP,
OptimizationRemarkEmitter *ORE) const override;
diff --git a/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h b/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h
index 18e3ea0554881..9134bd20fccff 100644
--- a/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h
+++ b/llvm/lib/Target/RISCV/RISCVTargetTransformInfo.h
@@ -121,7 +121,7 @@ class RISCVTTIImpl final : public BasicTTIImplBase<RISCVTTIImpl> {
bool enableScalableVectorization() const override {
return ST->hasVInstructions();
}
- bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const override {
+ bool preferTailFoldingOverEpilogue(TailFoldingInfo *TFI) const override {
return ST->hasVInstructions();
}
TailFoldingStyle getPreferredTailFoldingStyle() const override {
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index a7bbd94a0c776..cca84b5232df7 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -838,27 +838,27 @@ static void reportVectorization(OptimizationRemarkEmitter *ORE, Loop *TheLoop,
namespace llvm {
-// Loop vectorization cost-model hints how the scalar epilogue loop should be
+// Loop vectorization cost-model hints how the epilogue/tail loop should be
// lowered.
-enum ScalarEpilogueLowering {
+enum EpilogueLowering {
- // The default: allowing scalar epilogues.
- CM_ScalarEpilogueAllowed,
+ // The default: allowing epilogues.
+ CM_EpilogueAllowed,
// Vectorization with OptForSize: don't allow epilogues.
- CM_ScalarEpilogueNotAllowedOptSize,
+ CM_EpilogueNotAllowedOptSize,
// A special case of vectorisation with OptForSize: loops with a very small
// trip count are considered for vectorization under OptForSize, thereby
// making sure the cost of their loop body is dominant, free of runtime
// guards and scalar iteration overheads.
- CM_ScalarEpilogueNotAllowedLowTripLoop,
+ CM_EpilogueNotAllowedLowTripLoop,
- // Loop hint predicate indicating an epilogue is undesired.
- CM_ScalarEpilogueNotNeededUsePredicate,
+ // Loop hint indicating an epilogue is undesired, apply tail folding.
+ CM_EpilogueNotNeededFoldTail,
- // Directive indicating we must either tail fold or not vectorize
- CM_ScalarEpilogueNotAllowedUsePredicate
+ // Directive indicating we must either fold the epilogue/tail or not vectorize
+ CM_EpilogueNotAllowedFoldTail
};
/// LoopVectorizationCostModel - estimates the expected speedups due to
@@ -872,7 +872,7 @@ class LoopVectorizationCostModel {
friend class LoopVectorizationPlanner;
public:
- LoopVectorizationCostModel(ScalarEpilogueLowering SEL, Loop *L,
+ LoopVectorizationCostModel(EpilogueLowering SEL, Loop *L,
PredicatedScalarEvolution &PSE, LoopInfo *LI,
LoopVectorizationLegality *Legal,
const TargetTransformInfo &TTI,
@@ -882,7 +882,7 @@ class LoopVectorizationCostModel {
std::function<BlockFrequencyInfo &()> GetBFI,
const Function *F, const LoopVectorizeHints *Hints,
InterleavedAccessInfo &IAI, bool OptForSize)
- : ScalarEpilogueStatus(SEL), TheLoop(L), PSE(PSE), LI(LI), Legal(Legal),
+ : EpilogueLoweringStatus(SEL), TheLoop(L), PSE(PSE), LI(LI), Legal(Legal),
TTI(TTI), TLI(TLI), DB(DB), AC(AC), ORE(ORE), GetBFI(GetBFI),
TheFunction(F), Hints(Hints), InterleaveInfo(IAI),
OptForSize(OptForSize) {
@@ -1289,7 +1289,7 @@ class LoopVectorizationCostModel {
/// Returns true if we're required to use a scalar epilogue for at least
/// the final iteration of the original loop.
bool requiresScalarEpilogue(bool IsVectorizing) const {
- if (!isScalarEpilogueAllowed()) {
+ if (!isEpilogueAllowed()) {
LLVM_DEBUG(dbgs() << "LV: Loop does not require scalar epilogue\n");
return false;
}
@@ -1310,16 +1310,16 @@ class LoopVectorizationCostModel {
return false;
}
- /// Returns true if a scalar epilogue is allowed (e.g.., not prevented by
+ /// Returns true if an epilogue is allowed (e.g.., not prevented by
/// optsize or a loop hint annotation).
- bool isScalarEpilogueAllowed() const {
- return ScalarEpilogueStatus == CM_ScalarEpilogueAllowed;
+ bool isEpilogueAllowed() const {
+ return EpilogueLoweringStatus == CM_EpilogueAllowed;
}
- /// Returns true if tail-folding is preferred over a scalar epilogue.
- bool preferPredicatedLoop() const {
- return ScalarEpilogueStatus == CM_ScalarEpilogueNotNeededUsePredicate ||
- ScalarEpilogueStatus == CM_ScalarEpilogueNotAllowedUsePredicate;
+ /// Returns true if tail-folding is preferred over an epilogue.
+ bool preferTailFoldedLoop() const {
+ return EpilogueLoweringStatus == CM_EpilogueNotNeededFoldTail ||
+ EpilogueLoweringStatus == CM_EpilogueNotAllowedFoldTail;
}
/// Returns the TailFoldingStyle that is best for the current loop.
@@ -1351,10 +1351,10 @@ class LoopVectorizationCostModel {
TTI.hasActiveVectorLength() && !EnableVPlanNativePath;
if (EVLIsLegal)
return;
- // If for some reason EVL mode is unsupported, fallback to a scalar epilogue
+ // If for some reason EVL mode is unsupported, fallback to an epilogue
// if it's allowed, or DataWithoutLaneMask otherwise.
- if (ScalarEpilogueStatus == CM_ScalarEpilogueAllowed ||
- ScalarEpilogueStatus == CM_ScalarEpilogueNotNeededUsePredicate)
+ if (EpilogueLoweringStatus == CM_EpilogueAllowed ||
+ EpilogueLoweringStatus == CM_EpilogueNotNeededFoldTail)
ChosenTailFoldingStyle = TailFoldingStyle::None;
else
ChosenTailFoldingStyle = TailFoldingStyle::DataWithoutLaneMask;
@@ -1588,7 +1588,7 @@ class LoopVectorizationCostModel {
/// or as a peel-loop to handle gaps in interleave-groups.
/// Under optsize and when the trip count is very small we don't allow any
/// iterations to execute in the scalar loop.
- ScalarEpilogueLowering ScalarEpilogueStatus = CM_ScalarEpilogueAllowed;
+ EpilogueLowering EpilogueLoweringStatus = CM_EpilogueAllowed;
/// Control finally chosen tail folding style.
TailFoldingStyle ChosenTailFoldingStyle = TailFoldingStyle::None;
@@ -2764,7 +2764,7 @@ bool LoopVectorizationCostModel::isPredicatedInst(Instruction *I) const {
if (Legal->blockNeedsPredication(I->getParent()))
return true;
- // If we're not folding the tail by masking, predication is unnecessary.
+ // If we're not folding the tail by masking, tail-folding is unnecessary.
if (!foldTailByMasking())
return false;
@@ -2930,7 +2930,7 @@ bool LoopVectorizationCostModel::interleavedAccessCanBeWidened(
blockNeedsPredicationForAnyReason(I->getParent()) && isMaskRequired(I);
bool LoadAccessWithGapsRequiresEpilogMasking =
isa<LoadInst>(I) && Group->requiresScalarEpilogue() &&
- !isScalarEpilogueAllowed();
+ !isEpilogueAllowed();
bool StoreAccessWithGapsRequiresMasking =
isa<StoreInst>(I) && !Group->isFull();
if (!PredicatedAccessRequiresMasking &&
@@ -3467,7 +3467,7 @@ LoopVectorizationCostModel::computeMaxVF(ElementCount UserVF, unsigned UserIC) {
ScalarEvolution *SE = PSE.getSE();
ElementCount TC = getSmallConstantTripCount(SE, TheLoop);
unsigned MaxTC = PSE.getSmallConstantMaxTripCount();
- if (!MaxTC && ScalarEpilogueStatus == CM_ScalarEpilogueAllowed)
+ if (!MaxTC && EpilogueLoweringStatus == CM_EpilogueAllowed)
MaxTC = getMaxTCFromNonZeroRange(PSE, TheLoop);
LLVM_DEBUG(dbgs() << "LV: Found trip count: " << TC << '\n');
if (TC != ElementCount::getFixed(MaxTC))
@@ -3495,25 +3495,23 @@ LoopVectorizationCostModel::computeMaxVF(ElementCount UserVF, unsigned UserIC) {
return FixedScalableVFPair::getNone();
}
- switch (ScalarEpilogueStatus) {
- case CM_ScalarEpilogueAllowed:
+ switch (EpilogueLoweringStatus) {
+ case CM_EpilogueAllowed:
return computeFeasibleMaxVF(MaxTC, UserVF, UserIC, false);
- case CM_ScalarEpilogueNotAllowedUsePredicate:
+ case CM_EpilogueNotAllowedFoldTail:
[[fallthrough]];
- case CM_ScalarEpilogueNotNeededUsePredicate:
- LLVM_DEBUG(
- dbgs() << "LV: vector predicate hint/switch found.\n"
- << "LV: Not allowing scalar epilogue, creating predicated "
- << "vector loop.\n");
+ case CM_EpilogueNotNeededFoldTail:
+ LLVM_DEBUG(dbgs() << "LV: tail-folding hint/switch found.\n"
+ << "LV: Not allowing epilogue, creating tail-folded "
+ << "vector loop.\n");
break;
- case CM_ScalarEpilogueNotAllowedLowTripLoop:
+ case CM_EpilogueNotAllowedLowTripLoop:
// fallthrough as a special case of OptForSize
- case CM_ScalarEpilogueNotAllowedOptSize:
- if (ScalarEpilogueStatus == CM_ScalarEpilogueNotAllowedOptSize)
- LLVM_DEBUG(
- dbgs() << "LV: Not allowing scalar epilogue due to -Os/-Oz.\n");
+ case CM_EpilogueNotAllowedOptSize:
+ if (EpilogueLoweringStatus == CM_EpilogueNotAllowedOptSize)
+ LLVM_DEBUG(dbgs() << "LV: Not allowing epilogue due to -Os/-Oz.\n");
else
- LLVM_DEBUG(dbgs() << "LV: Not allowing scalar epilogue due to low trip "
+ LLVM_DEBUG(dbgs() << "LV: Not allowing epilogue due to low trip "
<< "count.\n");
// Bail if runtime checks are required, which are not good when optimising
@@ -3594,7 +3592,7 @@ LoopVectorizationCostModel::computeMaxVF(ElementCount UserVF, unsigned UserIC) {
// If we have a low-trip-count, and the fixed-width VF is known to divide
// the trip count but the scalable factor does not, use the fixed-width
// factor in preference to allow the generation of a non-predicated loop.
- if (ScalarEpilogueStatus == CM_ScalarEpilogueNotAllowedLowTripLoop &&
+ if (EpilogueLoweringStatus == CM_EpilogueNotAllowedLowTripLoop &&
NoScalarEpilogueNeeded(MaxFactors.FixedVF.getFixedValue())) {
LLVM_DEBUG(dbgs() << "LV: Picking a fixed-width so that no tail will "
"remain for any chosen VF.\n");
@@ -3634,15 +3632,15 @@ LoopVectorizationCostModel::computeMaxVF(ElementCount UserVF, unsigned UserIC) {
}
// If there was a tail-folding hint/switch, but we can't fold the tail by
- // masking, fallback to a vectorization with a scalar epilogue.
- if (ScalarEpilogueStatus == CM_ScalarEpilogueNotNeededUsePredicate) {
- LLVM_DEBUG(dbgs() << "LV: Cannot fold tail by masking: vectorize with a "
- "scalar epilogue instead.\n");
- ScalarEpilogueStatus = CM_ScalarEpilogueAllowed;
+ // masking, fallback to a vectorization with an epilogue.
+ if (EpilogueLoweringStatus == CM_EpilogueNotNeededFoldTail) {
+ LLVM_DEBUG(dbgs() << "LV: Cannot fold tail by masking: vectorize with an "
+ "epilogue instead.\n");
+ EpilogueLoweringStatus = CM_EpilogueAllowed;
return MaxFactors;
}
- if (ScalarEpilogueStatus == CM_ScalarEpilogueNotAllowedUsePredicate) {
+ if (EpilogueLoweringStatus == CM_EpilogueNotAllowedFoldTail) {
LLVM_DEBUG(dbgs() << "LV: Can't fold tail by masking: don't vectorize\n");
return FixedScalableVFPair::getNone();
}
@@ -4360,7 +4358,7 @@ std::unique_ptr<VPlan> LoopVectorizationPlanner::selectBestEpiloguePlan(
return nullptr;
}
- if (!CM.isScalarEpilogueAllowed()) {
+ if (!CM.isEpilogueAllowed()) {
LLVM_DEBUG(dbgs() << "LEV: Unable to vectorize epilogue because no "
"epilogue is allowed.\n");
return nullptr;
@@ -4621,10 +4619,10 @@ LoopVectorizationPlanner::selectInterleaveCount(VPlan &Plan, ElementCount VF,
// Only interleave...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/191871
More information about the llvm-commits
mailing list