[llvm] daf3236 - [VPlan] Move scalarizeInstruction out of ILV (NFC).
Florian Hahn via llvm-commits
llvm-commits at lists.llvm.org
Sat May 3 12:52:27 PDT 2025
Author: Florian Hahn
Date: 2025-05-03T20:52:03+01:00
New Revision: daf32369dd1230628e4ca6fc919859bc33dc0032
URL: https://github.com/llvm/llvm-project/commit/daf32369dd1230628e4ca6fc919859bc33dc0032
DIFF: https://github.com/llvm/llvm-project/commit/daf32369dd1230628e4ca6fc919859bc33dc0032.diff
LOG: [VPlan] Move scalarizeInstruction out of ILV (NFC).
15bb1db4a9830 removed the last dependency on ILV, move the code out of
ILV in preparation of consolidating in VPlanRecipes.cpp.
Added:
Modified:
llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
llvm/lib/Transforms/Vectorize/VPlan.cpp
llvm/lib/Transforms/Vectorize/VPlanHelpers.h
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 4a809badb0ee7..2632dac9900ef 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -508,15 +508,6 @@ class InnerLoopVectorizer {
// Return true if any runtime check is added.
bool areSafetyChecksAdded() { return AddedSafetyChecks; }
- /// A helper function to scalarize a single Instruction in the innermost loop.
- /// Generates a sequence of scalar instances for each lane between \p MinLane
- /// and \p MaxLane, times each part between \p MinPart and \p MaxPart,
- /// inclusive. Uses the VPValue operands from \p RepRecipe instead of \p
- /// Instr's operands.
- void scalarizeInstruction(const Instruction *Instr,
- VPReplicateRecipe *RepRecipe, const VPLane &Lane,
- VPTransformState &State);
-
/// Fix the non-induction PHIs in \p Plan.
void fixNonInductionPHIs(VPTransformState &State);
@@ -2321,10 +2312,12 @@ static bool useMaskedInterleavedAccesses(const TargetTransformInfo &TTI) {
return TTI.enableMaskedInterleavedAccessVectorization();
}
-void InnerLoopVectorizer::scalarizeInstruction(const Instruction *Instr,
- VPReplicateRecipe *RepRecipe,
- const VPLane &Lane,
- VPTransformState &State) {
+/// A helper function to scalarize a single Instruction in the innermost loop.
+/// Generates a sequence of scalar instances for lane \p Lane. Uses the VPValue
+/// operands from \p RepRecipe instead of \p Instr's operands.
+static void scalarizeInstruction(const Instruction *Instr,
+ VPReplicateRecipe *RepRecipe,
+ const VPLane &Lane, VPTransformState &State) {
assert((!Instr->getType()->isAggregateType() ||
canVectorizeTy(Instr->getType())) &&
"Expected vectorizable or non-aggregate type.");
@@ -2366,7 +2359,7 @@ void InnerLoopVectorizer::scalarizeInstruction(const Instruction *Instr,
// If we just cloned a new assumption, add it the assumption cache.
if (auto *II = dyn_cast<AssumeInst>(Cloned))
- AC->registerAssumption(II);
+ State.AC->registerAssumption(II);
assert(
(RepRecipe->getParent()->getParent() ||
@@ -7863,7 +7856,7 @@ DenseMap<const SCEV *, Value *> LoopVectorizationPlanner::executePlan(
*Legal->getWidestInductionType());
// Perform the actual loop transformation.
- VPTransformState State(&TTI, BestVF, LI, DT, ILV.Builder, &ILV, &BestVPlan,
+ VPTransformState State(&TTI, BestVF, LI, DT, ILV.AC, ILV.Builder, &BestVPlan,
OrigLoop->getParentLoop(),
Legal->getWidestInductionType());
@@ -10094,7 +10087,7 @@ void VPReplicateRecipe::execute(VPTransformState &State) {
assert((State.VF.isScalar() || !isUniform()) &&
"uniform recipe shouldn't be predicated");
assert(!State.VF.isScalable() && "Can't scalarize a scalable vector");
- State.ILV->scalarizeInstruction(UI, this, *State.Lane, State);
+ scalarizeInstruction(UI, this, *State.Lane, State);
// Insert scalar instance packing it into a vector.
if (State.VF.isVector() && shouldPack()) {
// If we're constructing lane 0, initialize to start from poison.
@@ -10111,7 +10104,7 @@ void VPReplicateRecipe::execute(VPTransformState &State) {
if (IsUniform) {
// Uniform within VL means we need to generate lane 0.
- State.ILV->scalarizeInstruction(UI, this, VPLane(0), State);
+ scalarizeInstruction(UI, this, VPLane(0), State);
return;
}
@@ -10120,7 +10113,7 @@ void VPReplicateRecipe::execute(VPTransformState &State) {
if (isa<StoreInst>(UI) &&
vputils::isUniformAfterVectorization(getOperand(1))) {
auto Lane = VPLane::getLastLaneForVF(State.VF);
- State.ILV->scalarizeInstruction(UI, this, VPLane(Lane), State);
+ scalarizeInstruction(UI, this, VPLane(Lane), State);
return;
}
@@ -10128,7 +10121,7 @@ void VPReplicateRecipe::execute(VPTransformState &State) {
assert(!State.VF.isScalable() && "Can't scalarize a scalable vector");
const unsigned EndLane = State.VF.getKnownMinValue();
for (unsigned Lane = 0; Lane < EndLane; ++Lane)
- State.ILV->scalarizeInstruction(UI, this, VPLane(Lane), State);
+ scalarizeInstruction(UI, this, VPLane(Lane), State);
}
// Determine how to lower the scalar epilogue, which depends on 1) optimising
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp
index 701e4bfe0623e..a4aab8a2dee79 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp
@@ -216,10 +216,10 @@ VPBasicBlock::iterator VPBasicBlock::getFirstNonPhi() {
VPTransformState::VPTransformState(const TargetTransformInfo *TTI,
ElementCount VF, LoopInfo *LI,
- DominatorTree *DT, IRBuilderBase &Builder,
- InnerLoopVectorizer *ILV, VPlan *Plan,
+ DominatorTree *DT, AssumptionCache *AC,
+ IRBuilderBase &Builder, VPlan *Plan,
Loop *CurrentParentLoop, Type *CanonicalIVTy)
- : TTI(TTI), VF(VF), CFG(DT), LI(LI), Builder(Builder), ILV(ILV), Plan(Plan),
+ : TTI(TTI), VF(VF), CFG(DT), LI(LI), AC(AC), Builder(Builder), Plan(Plan),
CurrentParentLoop(CurrentParentLoop), LVer(nullptr),
TypeAnalysis(CanonicalIVTy), VPDT(*Plan) {}
diff --git a/llvm/lib/Transforms/Vectorize/VPlanHelpers.h b/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
index e860595b473a0..cf8adc15e74bd 100644
--- a/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
+++ b/llvm/lib/Transforms/Vectorize/VPlanHelpers.h
@@ -27,6 +27,7 @@
namespace llvm {
+class AssumptionCache;
class BasicBlock;
class DominatorTree;
class InnerLoopVectorizer;
@@ -203,9 +204,9 @@ class VPLane {
/// needed for generating the output IR.
struct VPTransformState {
VPTransformState(const TargetTransformInfo *TTI, ElementCount VF,
- LoopInfo *LI, DominatorTree *DT, IRBuilderBase &Builder,
- InnerLoopVectorizer *ILV, VPlan *Plan,
- Loop *CurrentParentLoop, Type *CanonicalIVTy);
+ LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC,
+ IRBuilderBase &Builder, VPlan *Plan, Loop *CurrentParentLoop,
+ Type *CanonicalIVTy);
/// Target Transform Info.
const TargetTransformInfo *TTI;
@@ -329,12 +330,13 @@ struct VPTransformState {
/// Hold a pointer to LoopInfo to register new basic blocks in the loop.
LoopInfo *LI;
+ /// Hold a pointer to AssumptionCache to register new assumptions after
+ /// replicating assume calls.
+ AssumptionCache *AC;
+
/// Hold a reference to the IRBuilder used to generate output IR code.
IRBuilderBase &Builder;
- /// Hold a pointer to InnerLoopVectorizer to reuse its IR generation methods.
- InnerLoopVectorizer *ILV;
-
/// Pointer to the VPlan code is generated for.
VPlan *Plan;
More information about the llvm-commits
mailing list