[llvm] [NFC][LV] Introduce enums for uncountable exit detail and style (PR #184808)
Graham Hunter via llvm-commits
llvm-commits at lists.llvm.org
Thu Mar 19 04:02:19 PDT 2026
https://github.com/huntergr-arm updated https://github.com/llvm/llvm-project/pull/184808
>From c4d5600f7965415e167f89c91ca0a3bfe957c2c0 Mon Sep 17 00:00:00 2001
From: Graham Hunter <graham.hunter at arm.com>
Date: Tue, 1 Jul 2025 13:08:48 +0000
Subject: [PATCH 1/3] [NFC][LV] Introduce enums for uncountable exit detail and
style
Recursively splitting out some work from #183318; this covers
the enums for early exit loop type (none, readonly, readwrite)
and the style used (just readonly with multiple exit blocks for
now) and refactoring for basic use of those enums.
---
.../Vectorize/LoopVectorizationLegality.h | 29 ++++++++++++++-----
.../Vectorize/LoopVectorizationLegality.cpp | 11 ++++---
.../Transforms/Vectorize/LoopVectorize.cpp | 15 ++++++++--
llvm/lib/Transforms/Vectorize/VPlan.h | 16 ++++++++++
.../Vectorize/VPlanConstruction.cpp | 27 +++++++++++++----
.../lib/Transforms/Vectorize/VPlanRecipes.cpp | 2 ++
.../Transforms/Vectorize/VPlanTransforms.cpp | 6 +++-
.../Transforms/Vectorize/VPlanTransforms.h | 5 ++--
.../Transforms/Vectorize/VPlanTestBase.h | 6 ++--
.../Vectorize/VPlanUncountableExitTest.cpp | 7 +++--
10 files changed, 95 insertions(+), 29 deletions(-)
diff --git a/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h b/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h
index f82fc588639dd..ba84b38442ce0 100644
--- a/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h
+++ b/llvm/include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h
@@ -245,6 +245,13 @@ struct HistogramInfo {
: Load(Load), Update(Update), Store(Store) {}
};
+/// Indicates the characteristics of a loop with an uncountable exit.
+/// * None -- No uncountable exit present.
+/// * ReadOnly -- At least one uncountable exit in a readonly loop.
+/// * ReadWrite -- At least one uncountable exit in a loop with side effects
+/// that may require masking.
+enum class UncountableExitTrait { None, ReadOnly, ReadWrite };
+
/// LoopVectorizationLegality checks if it is legal to vectorize a loop, and
/// to what vectorization factor.
/// This class does not look at the profitability of vectorization, only the
@@ -407,16 +414,25 @@ class LoopVectorizationLegality {
return LAI->getDepChecker().getMaxSafeVectorWidthInBits();
}
+ /// Returns information about whether this loop contains at least one
+ /// uncountable early exit, and if so, if it also contains instructions (such
+ /// as stores) that cause side-effects.
+ UncountableExitTrait getUncountableExitTrait() const {
+ return UncountableExitType;
+ }
+
/// Returns true if the loop has uncountable early exits, i.e. uncountable
/// exits that aren't the latch block.
- bool hasUncountableEarlyExit() const { return HasUncountableEarlyExit; }
+ bool hasUncountableEarlyExit() const {
+ return getUncountableExitTrait() != UncountableExitTrait::None;
+ }
/// Returns true if this is an early exit loop with state-changing or
/// potentially-faulting operations and the condition for the uncountable
/// exit must be determined before any of the state changes or potentially
/// faulting operations take place.
bool hasUncountableExitWithSideEffects() const {
- return UncountableExitWithSideEffects;
+ return getUncountableExitTrait() == UncountableExitTrait::ReadWrite;
}
/// Return true if there is store-load forwarding dependencies.
@@ -738,12 +754,9 @@ class LoopVectorizationLegality {
/// the exact backedge taken count is not computable.
SmallVector<BasicBlock *, 4> CountableExitingBlocks;
- /// True if the loop has uncountable early exits.
- bool HasUncountableEarlyExit = false;
-
- /// If true, the loop has at least one uncountable exit and operations within
- /// the loop may have observable side effects.
- bool UncountableExitWithSideEffects = false;
+ /// Records whether we have an uncountable early exit in a loop that's
+ /// either read-only or read-write.
+ UncountableExitTrait UncountableExitType = UncountableExitTrait::None;
};
} // namespace llvm
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp
index be0288b699d59..910d2c318dbb1 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp
@@ -1846,8 +1846,8 @@ bool LoopVectorizationLegality::isVectorizableEarlyExitLoop() {
LLVM_DEBUG(dbgs() << "LV: Found an early exit loop with symbolic max "
"backedge taken count: "
<< *SymbolicMaxBTC << '\n');
- HasUncountableEarlyExit = true;
- UncountableExitWithSideEffects = HasSideEffects;
+ UncountableExitType = HasSideEffects ? UncountableExitTrait::ReadWrite
+ : UncountableExitTrait::ReadOnly;
return true;
}
@@ -2012,8 +2012,7 @@ bool LoopVectorizationLegality::canVectorize(bool UseVPlanNativePath) {
return false;
} else {
if (!isVectorizableEarlyExitLoop()) {
- assert(!hasUncountableEarlyExit() &&
- !hasUncountableExitWithSideEffects() &&
+ assert(UncountableExitType == UncountableExitTrait::None &&
"Must be false without vectorizable early-exit loop");
if (DoExtraAnalysis)
Result = false;
@@ -2032,8 +2031,8 @@ bool LoopVectorizationLegality::canVectorize(bool UseVPlanNativePath) {
return false;
}
- // Bail out for state-changing loops with uncountable exits for now.
- if (UncountableExitWithSideEffects) {
+ // Bail out for ReadWrite loops with uncountable exits for now.
+ if (UncountableExitType == UncountableExitTrait::ReadWrite) {
reportVectorizationFailure(
"Writes to memory unsupported in early exit loops",
"Cannot vectorize early exit loop with writes to memory",
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index ac9b790c739bf..a6952a153d76a 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -8046,7 +8046,18 @@ void LoopVectorizationPlanner::buildVPlansWithVPRecipes(ElementCount MinVF,
getDebugLocFromInstOrOperands(Legal->getPrimaryInduction()), PSE, &LVer);
VPlanTransforms::simplifyRecipes(*VPlan0);
- VPlanTransforms::handleEarlyExits(*VPlan0, Legal->hasUncountableEarlyExit());
+ // If we're vectorizing a loop with an uncountable exit, make sure that the
+ // recipes are safe to handle.
+ // TODO: Remove this once we can properly check the VPlan itself for both
+ // the presence of an uncountable exit and the presence of stores in
+ // the loop inside handleEarlyExits itself.
+ UncountableExitStyle EEStyle = UncountableExitStyle::NoUncountableExit;
+ if (Legal->hasUncountableEarlyExit())
+ EEStyle = Legal->hasUncountableExitWithSideEffects()
+ ? UncountableExitStyle::MaskedHandleExitInScalarLoop
+ : UncountableExitStyle::ReadOnlyMultipleBranches;
+
+ VPlanTransforms::handleEarlyExits(*VPlan0, EEStyle);
VPlanTransforms::addMiddleCheck(*VPlan0, CM.foldTailByMasking());
RUN_VPLAN_PASS_NO_VERIFY(VPlanTransforms::createLoopRegions, *VPlan0);
@@ -8347,7 +8358,7 @@ VPlanPtr LoopVectorizationPlanner::tryToBuildVPlan(VFRange &Range) {
getDebugLocFromInstOrOperands(Legal->getPrimaryInduction()), PSE);
VPlanTransforms::handleEarlyExits(*Plan,
- /*HasUncountableExit*/ false);
+ UncountableExitStyle::NoUncountableExit);
VPlanTransforms::addMiddleCheck(*Plan, /*TailFolded*/ false);
VPlanTransforms::createLoopRegions(*Plan);
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index 80df058dfcf66..1400935ac3dae 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -77,6 +77,22 @@ typedef unsigned ID;
using VPlanPtr = std::unique_ptr<VPlan>;
+/// \enum UncountableExitStyle
+/// Different methods of handling early exits.
+///
+enum class UncountableExitStyle {
+ NoUncountableExit = 0,
+ /// No side effects to worry about, so we can process any uncountable exits
+ /// in the loop and branch either to the middle block if the trip count was
+ /// reached, or an early exitblock to determine which exit was taken.
+ ReadOnlyMultipleBranches,
+ /// All memory operations other than the load(s) required to determine whether
+ /// an uncountable exit occurre will be masked based on that condition. If an
+ /// uncountable exit is taken, then all lanes before the exiting lane will
+ /// complete, leaving just the final lane to execute in the scalar tail.
+ MaskedHandleExitInScalarLoop,
+};
+
/// VPBlockBase is the building block of the Hierarchical Control-Flow Graph.
/// A VPBlockBase can be either a VPBasicBlock or a VPRegionBlock.
class LLVM_ABI_FOR_TEST VPBlockBase {
diff --git a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
index d755851eca44a..ba1d7810c8c01 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
@@ -933,15 +933,30 @@ void VPlanTransforms::createInLoopReductionRecipes(
}
void VPlanTransforms::handleEarlyExits(VPlan &Plan,
- bool HasUncountableEarlyExit) {
+ UncountableExitStyle Style) {
auto *MiddleVPBB = cast<VPBasicBlock>(
Plan.getScalarHeader()->getSinglePredecessor()->getPredecessors()[0]);
auto *LatchVPBB = cast<VPBasicBlock>(MiddleVPBB->getSinglePredecessor());
- VPBlockBase *HeaderVPB = cast<VPBasicBlock>(LatchVPBB->getSuccessors()[1]);
-
- if (HasUncountableEarlyExit) {
- handleUncountableEarlyExits(Plan, cast<VPBasicBlock>(HeaderVPB), LatchVPBB,
- MiddleVPBB);
+ VPBasicBlock *HeaderVPBB = cast<VPBasicBlock>(LatchVPBB->getSuccessors()[1]);
+
+ // TODO: We would like to detect uncountable exits and stores within loops
+ // with such exits from the VPlan alone. Exit detection can be moved
+ // here from handleUncountableEarlyExits, but we need to improve
+ // detection of recipes which may write to memory.
+ if (Style != UncountableExitStyle::NoUncountableExit) {
+ // TODO: Check target preference for style.
+ // TODO: Currently VPRecipeBase::mayWriteToMemory is incomplete and won't
+ // handle many recipe types correctly. Once we can handle them then
+ // we need to check the actual blocks that will form the vector loop.
+ // Right now we're only checking the header for the scalar loop, since
+ // any other blocks in the scalar loop won't be represented in the
+ // plan.
+ for (VPRecipeBase &R : Plan.getScalarHeader()->getRecipeList())
+ if (R.mayWriteToMemory())
+ assert(Style == UncountableExitStyle::MaskedHandleExitInScalarLoop &&
+ "Found unexpected write in uncountable exit loop.");
+
+ handleUncountableEarlyExits(Plan, HeaderVPBB, LatchVPBB, MiddleVPBB, Style);
return;
}
diff --git a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
index 401f6725677e3..939e396d1d4d0 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp
@@ -51,6 +51,8 @@ bool VPRecipeBase::mayWriteToMemory() const {
switch (getVPRecipeID()) {
case VPExpressionSC:
return cast<VPExpressionRecipe>(this)->mayReadOrWriteMemory();
+ case VPIRInstructionSC:
+ return cast<VPIRInstruction>(this)->getInstruction().mayWriteToMemory();
case VPInstructionSC: {
auto *VPI = cast<VPInstruction>(this);
// Loads read from memory but don't write to memory.
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
index d389db07885c8..7728bde072192 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -4142,7 +4142,8 @@ void VPlanTransforms::convertToConcreteRecipes(VPlan &Plan) {
void VPlanTransforms::handleUncountableEarlyExits(VPlan &Plan,
VPBasicBlock *HeaderVPBB,
VPBasicBlock *LatchVPBB,
- VPBasicBlock *MiddleVPBB) {
+ VPBasicBlock *MiddleVPBB,
+ UncountableExitStyle Style) {
struct EarlyExitInfo {
VPBasicBlock *EarlyExitingVPBB;
VPIRBasicBlock *EarlyExitVPBB;
@@ -4220,6 +4221,9 @@ void VPlanTransforms::handleUncountableEarlyExits(VPlan &Plan,
VPValue *IsAnyExitTaken =
Builder.createNaryOp(VPInstruction::AnyOf, {Combined});
+ assert(Style == UncountableExitStyle::ReadOnlyMultipleBranches &&
+ "Early exit store masking not implemented");
+
// Create the vector.early.exit blocks.
SmallVector<VPBasicBlock *> VectorEarlyExitVPBBs(Exits.size());
for (unsigned Idx = 0; Idx != Exits.size(); ++Idx) {
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.h b/llvm/lib/Transforms/Vectorize/VPlanTransforms.h
index d10ef23dd05b2..b04460e2323c4 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.h
@@ -151,7 +151,7 @@ struct VPlanTransforms {
/// Update \p Plan to account for all early exits.
LLVM_ABI_FOR_TEST static void handleEarlyExits(VPlan &Plan,
- bool HasUncountableExit);
+ UncountableExitStyle Style);
/// If a check is needed to guard executing the scalar epilogue loop, it will
/// be added to the middle block.
@@ -319,7 +319,8 @@ struct VPlanTransforms {
/// that determines which exit to take based on lane-by-lane semantics.
static void handleUncountableEarlyExits(VPlan &Plan, VPBasicBlock *HeaderVPBB,
VPBasicBlock *LatchVPBB,
- VPBasicBlock *MiddleVPBB);
+ VPBasicBlock *MiddleVPBB,
+ UncountableExitStyle Style);
/// Replaces the exit condition from
/// (branch-on-cond eq CanonicalIVInc, VectorTripCount)
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanTestBase.h b/llvm/unittests/Transforms/Vectorize/VPlanTestBase.h
index 472c04b17863b..805f2ab61d23e 100644
--- a/llvm/unittests/Transforms/Vectorize/VPlanTestBase.h
+++ b/llvm/unittests/Transforms/Vectorize/VPlanTestBase.h
@@ -65,7 +65,9 @@ class VPlanTestIRBase : public testing::Test {
}
/// Build the VPlan for the loop starting from \p LoopHeader.
- VPlanPtr buildVPlan(BasicBlock *LoopHeader, bool HasUncountableExit = false) {
+ VPlanPtr buildVPlan(
+ BasicBlock *LoopHeader,
+ UncountableExitStyle Style = UncountableExitStyle::NoUncountableExit) {
Function &F = *LoopHeader->getParent();
assert(!verifyFunction(F) && "input function must be valid");
doAnalysis(F);
@@ -75,7 +77,7 @@ class VPlanTestIRBase : public testing::Test {
auto Plan = VPlanTransforms::buildVPlan0(L, *LI, IntegerType::get(*Ctx, 64),
{}, PSE);
- VPlanTransforms::handleEarlyExits(*Plan, HasUncountableExit);
+ VPlanTransforms::handleEarlyExits(*Plan, Style);
VPlanTransforms::addMiddleCheck(*Plan, false);
VPlanTransforms::createLoopRegions(*Plan);
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp
index c701382c54e6b..3a0ee31234994 100644
--- a/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp
@@ -28,7 +28,9 @@ TEST_F(VPUncountableExitTest, FindUncountableExitRecipes) {
" %st.addr = getelementptr inbounds i16, ptr %array, i64 %iv\n"
" %data = load i16, ptr %st.addr, align 2\n"
" %inc = add nsw i16 %data, 1\n"
- " store i16 %inc, ptr %st.addr, align 2\n"
+ // TODO: Uncomment store once more support is added for uncountable exits
+ // in loops with stores.
+ // " store i16 %inc, ptr %st.addr, align 2\n"
" %uncountable.addr = getelementptr inbounds nuw i16, ptr %pred, i64 "
"%iv\n"
" %uncountable.val = load i16, ptr %uncountable.addr, align 2\n"
@@ -46,7 +48,8 @@ TEST_F(VPUncountableExitTest, FindUncountableExitRecipes) {
Function *F = M.getFunction("f");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
- auto Plan = buildVPlan(LoopHeader, /*HasUncountableExit=*/true);
+ auto Plan =
+ buildVPlan(LoopHeader, UncountableExitStyle::ReadOnlyMultipleBranches);
VPlanTransforms::tryToConvertVPInstructionsToVPRecipes(*Plan, *TLI);
VPlanTransforms::optimize(*Plan);
>From 81d1132a23b9b71c6d86b34f3c2e38a94df1d342 Mon Sep 17 00:00:00 2001
From: Graham Hunter <graham.hunter at arm.com>
Date: Thu, 19 Mar 2026 10:19:17 +0000
Subject: [PATCH 2/3] Shorten ReadOnly style name
---
llvm/lib/Transforms/Vectorize/LoopVectorize.cpp | 2 +-
llvm/lib/Transforms/Vectorize/VPlan.h | 2 +-
llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp | 2 +-
.../Transforms/Vectorize/VPlanUncountableExitTest.cpp | 3 +--
4 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index a6952a153d76a..335e5720bc469 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -8055,7 +8055,7 @@ void LoopVectorizationPlanner::buildVPlansWithVPRecipes(ElementCount MinVF,
if (Legal->hasUncountableEarlyExit())
EEStyle = Legal->hasUncountableExitWithSideEffects()
? UncountableExitStyle::MaskedHandleExitInScalarLoop
- : UncountableExitStyle::ReadOnlyMultipleBranches;
+ : UncountableExitStyle::ReadOnly;
VPlanTransforms::handleEarlyExits(*VPlan0, EEStyle);
VPlanTransforms::addMiddleCheck(*VPlan0, CM.foldTailByMasking());
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.h b/llvm/lib/Transforms/Vectorize/VPlan.h
index 1400935ac3dae..9ed9d07151d7f 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.h
+++ b/llvm/lib/Transforms/Vectorize/VPlan.h
@@ -85,7 +85,7 @@ enum class UncountableExitStyle {
/// No side effects to worry about, so we can process any uncountable exits
/// in the loop and branch either to the middle block if the trip count was
/// reached, or an early exitblock to determine which exit was taken.
- ReadOnlyMultipleBranches,
+ ReadOnly,
/// All memory operations other than the load(s) required to determine whether
/// an uncountable exit occurre will be masked based on that condition. If an
/// uncountable exit is taken, then all lanes before the exiting lane will
diff --git a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
index 7728bde072192..b7c9b276f0489 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanTransforms.cpp
@@ -4221,7 +4221,7 @@ void VPlanTransforms::handleUncountableEarlyExits(VPlan &Plan,
VPValue *IsAnyExitTaken =
Builder.createNaryOp(VPInstruction::AnyOf, {Combined});
- assert(Style == UncountableExitStyle::ReadOnlyMultipleBranches &&
+ assert(Style == UncountableExitStyle::ReadOnly &&
"Early exit store masking not implemented");
// Create the vector.early.exit blocks.
diff --git a/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp b/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp
index 3a0ee31234994..1e0990db89aa4 100644
--- a/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp
+++ b/llvm/unittests/Transforms/Vectorize/VPlanUncountableExitTest.cpp
@@ -48,8 +48,7 @@ TEST_F(VPUncountableExitTest, FindUncountableExitRecipes) {
Function *F = M.getFunction("f");
BasicBlock *LoopHeader = F->getEntryBlock().getSingleSuccessor();
- auto Plan =
- buildVPlan(LoopHeader, UncountableExitStyle::ReadOnlyMultipleBranches);
+ auto Plan = buildVPlan(LoopHeader, UncountableExitStyle::ReadOnly);
VPlanTransforms::tryToConvertVPInstructionsToVPRecipes(*Plan, *TLI);
VPlanTransforms::optimize(*Plan);
>From 6b60f219054c979bd9e20c1de41efd88e0a82c28 Mon Sep 17 00:00:00 2001
From: Graham Hunter <graham.hunter at arm.com>
Date: Thu, 19 Mar 2026 10:50:31 +0000
Subject: [PATCH 3/3] Remove redundant checks that do not cover the full loop
---
llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp | 11 -----------
1 file changed, 11 deletions(-)
diff --git a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
index ba1d7810c8c01..db5ba5ed42253 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlanConstruction.cpp
@@ -945,17 +945,6 @@ void VPlanTransforms::handleEarlyExits(VPlan &Plan,
// detection of recipes which may write to memory.
if (Style != UncountableExitStyle::NoUncountableExit) {
// TODO: Check target preference for style.
- // TODO: Currently VPRecipeBase::mayWriteToMemory is incomplete and won't
- // handle many recipe types correctly. Once we can handle them then
- // we need to check the actual blocks that will form the vector loop.
- // Right now we're only checking the header for the scalar loop, since
- // any other blocks in the scalar loop won't be represented in the
- // plan.
- for (VPRecipeBase &R : Plan.getScalarHeader()->getRecipeList())
- if (R.mayWriteToMemory())
- assert(Style == UncountableExitStyle::MaskedHandleExitInScalarLoop &&
- "Found unexpected write in uncountable exit loop.");
-
handleUncountableEarlyExits(Plan, HeaderVPBB, LatchVPBB, MiddleVPBB, Style);
return;
}
More information about the llvm-commits
mailing list